76 | {% else %}
77 | [var=value]\n'
23 | '(example: "%s production.ini")' % (cmd, cmd))
24 | sys.exit(1)
25 |
26 |
27 | def main(argv=sys.argv):
28 | if len(argv) < 2:
29 | usage(argv)
30 | config_uri = argv[1]
31 | options = parse_vars(argv[2:])
32 | setup_logging(config_uri)
33 | settings = get_appsettings(config_uri, options=options)
34 |
35 | import gengine
36 | gengine.main({}, **settings)
37 |
38 | from gengine.metadata import (
39 | DBSession
40 | )
41 | sess = DBSession()
42 |
43 | import gengine.app.model as m
44 |
45 | from gengine.app.registries import get_task_registry
46 | enginetasks = get_task_registry().registrations
47 |
48 | to_run = []
49 |
50 | with transaction.manager:
51 | mark_changed(sess, transaction.manager, True)
52 |
53 | tasks = sess.execute(
54 | select([
55 | m.t_tasks.c.entry_name,
56 | m.t_tasks.c.task_name,
57 | m.t_tasks.c.config,
58 | m.t_taskexecutions.c.id.label("execution_id"),
59 | ], from_obj=m.t_taskexecutions.join(m.t_tasks)).\
60 | where(and_(
61 | m.t_taskexecutions.c.planned_at < dt_now(),
62 | m.t_taskexecutions.c.canceled_at==None,
63 | m.t_taskexecutions.c.locked_at==None,
64 | m.t_taskexecutions.c.finished_at==None,
65 | ))
66 | ).fetchall()
67 |
68 | for task in tasks:
69 | if task["task_name"] in enginetasks.keys():
70 | to_run.append(task)
71 |
72 | sess.execute(
73 | m.t_taskexecutions.update().values({
74 | 'locked_at' : dt_now()
75 | }).where(
76 | m.t_taskexecutions.c.id == task["execution_id"]
77 | )
78 | )
79 |
80 | sess.flush()
81 | sess.commit()
82 |
83 | for task in to_run:
84 | with transaction.manager:
85 | mark_changed(sess, transaction.manager, True)
86 |
87 | log.info("Running task %(task_name)s (ExecutionID: %(execution_id)s)" % {
88 | 'task_name': task["task_name"],
89 | 'execution_id': task["execution_id"]
90 | })
91 |
92 | result = get_task_registry().execute(
93 | name=task["task_name"],
94 | config=task["config"] # execute contains fallback to default_config
95 | )
96 | logged = result.get("log", None)
97 | success = result.get("success", True)
98 |
99 | sess.execute(
100 | m.t_taskexecutions.update().values({
101 | 'finished_at': dt_now(),
102 | 'log': logged,
103 | 'success': success
104 | }).where(
105 | m.t_taskexecutions.c.id == task["execution_id"]
106 | )
107 | )
108 |
109 | sess.flush()
110 | sess.commit()
111 |
--------------------------------------------------------------------------------
/development.ini:
--------------------------------------------------------------------------------
1 | ###
2 | # app configuration
3 | # http://docs.pylonsproject.org/projects/pyramid/en/1.5-branch/narr/environment.html
4 | ###
5 |
6 | [app:main]
7 | use = egg:gamification-engine
8 |
9 | pyramid.reload_templates = true
10 | pyramid.debug_authorization = false
11 | pyramid.debug_notfound = false
12 | pyramid.debug_routematch = true
13 | pyramid.default_locale_name = en
14 | pyramid.includes =
15 | pyramid_debugtoolbar
16 | pyramid_tm
17 |
18 | sqlalchemy.url = postgres://postgres:password@postgres/gengine
19 |
20 | #reverse proxy settings
21 | force_https = false
22 | urlprefix =
23 | urlcacheid = gengine
24 | load_from_webpack_dev_server = false
25 |
26 | swagger.use_http_scheme = true
27 | swagger.host = localhost:6543
28 |
29 | #flaskadmin settings
30 | flaskadmin_secret = 87ghsjkdjfhg85grsfgsdfghwez89hsuif # replace with random string!
31 |
32 | # By default, the toolbar only appears for clients from IP addresses
33 | # '127.0.0.1' and '::1'.
34 | # debugtoolbar.hosts = 127.0.0.1 ::1
35 |
36 | # dogpile cache
37 | dogpile_cache.backend = dogpile.cache.null
38 |
39 | dogpile_cache.general.backend = dogpile.cache.dbm
40 | dogpile_cache.general.arguments.filename = general.dbm
41 |
42 | dogpile_cache.achievement_eval.backend = dogpile.cache.dbm
43 | dogpile_cache.achievement_eval.arguments.filename = achievement_eval.dbm
44 |
45 | dogpile_cache.achievements_by_user_for_today.backend = dogpile.cache.dbm
46 | dogpile_cache.achievements_by_user_for_today.arguments.filename = achievements_by_user_for_today.dbm
47 |
48 | dogpile_cache.translations.backend = dogpile.cache.dbm
49 | dogpile_cache.translations.arguments.filename = translations.dbm
50 |
51 | dogpile_cache.achievements_users_levels.backend = dogpile.cache.dbm
52 | dogpile_cache.achievements_users_levels.arguments.filename = achievements_users_levels.dbm
53 |
54 | dogpile_cache.goal_evaluation.backend = dogpile.cache.dbm
55 | dogpile_cache.goal_evaluation.arguments.filename = goal_evaluation.dbm
56 |
57 | dogpile_cache.goal_statements.backend = dogpile.cache.memory
58 |
59 | # memcache
60 | urlcache_url = memcached:11211
61 | urlcache_active = true
62 |
63 | # callback url, will be used for time-related leaderboard evaluations (daily,monthly,yearly) (TBD)
64 | notify_progress =
65 |
66 | enable_user_authentication = true
67 | fallback_language = en
68 | gcm.api_key=
69 | gcm.package=
70 | apns.dev.key=
71 | apns.dev.certificate=
72 | apns.prod.key=
73 | apns.prod.certificate=
74 | push_title=Gamification Engine
75 |
76 |
77 | ###
78 | # wsgi server configuration
79 | ###
80 |
81 | [server:main]
82 | use = egg:waitress#main
83 | host = 0.0.0.0
84 | port = 6543
85 |
86 | ###
87 | # logging configuration
88 | # http://docs.pylonsproject.org/projects/pyramid/en/1.5-branch/narr/logging.html
89 | ###
90 |
91 | [loggers]
92 | keys = root, gengine, sqlalchemy, sentry
93 |
94 | [handlers]
95 | keys = console, sentry
96 |
97 | [formatters]
98 | keys = generic
99 |
100 | [logger_root]
101 | level = DEBUG
102 | handlers = console,sentry
103 |
104 | [logger_gengine]
105 | level = DEBUG
106 | handlers =
107 | qualname = gengine
108 |
109 | [logger_sqlalchemy]
110 | level = DEBUG
111 | handlers =
112 | qualname = sqlalchemy.engine
113 | # "level = INFO" logs SQL queries.
114 | # "level = DEBUG" logs SQL queries and results.
115 | # "level = WARN" logs neither. (Recommended for production systems.)
116 |
117 | [logger_sentry]
118 | level = WARN
119 | handlers = console
120 | qualname = sentry.errors
121 | propagate = 0
122 |
123 | [handler_console]
124 | class = StreamHandler
125 | args = (sys.stderr,)
126 | level = NOTSET
127 | formatter = generic
128 |
129 | [handler_sentry]
130 | class = raven.handlers.logging.SentryHandler
131 | args = ()
132 | level = WARNING
133 | formatter = generic
134 |
135 | [formatter_generic]
136 | format = %(asctime)s %(levelname)-5.5s [%(name)s][%(threadName)s] %(message)s
137 |
--------------------------------------------------------------------------------
/gengine/base/model.py:
--------------------------------------------------------------------------------
1 | import pytz
2 | from pytz.exceptions import UnknownTimeZoneError
3 | from sqlalchemy.inspection import inspect
4 | from sqlalchemy.orm.exc import DetachedInstanceError
5 | from sqlalchemy.orm.query import Query
6 | from sqlalchemy.sql.expression import select
7 | from sqlalchemy.sql.functions import func
8 | from sqlalchemy.util.compat import with_metaclass
9 | from zope.sqlalchemy.datamanager import mark_changed
10 |
11 | import gengine.metadata as meta
12 |
13 | class ABaseMeta(type):
14 | def __init__(cls, name, bases, nmspc):
15 | super(ABaseMeta, cls).__init__(name, bases, nmspc)
16 |
17 | # monkey patch __unicode__
18 | # this is required to give show the SQL error to the user in flask admin if constraints are violated
19 | if hasattr(cls,"__unicode__"):
20 | old_unicode = cls.__unicode__
21 | def patched(self):
22 | try:
23 | return old_unicode(self)
24 | except DetachedInstanceError:
25 | return "(DetachedInstance)"
26 | cls.__unicode__ = patched
27 |
28 | def __getattr__(cls, item):
29 | if item == "__table__":
30 | return inspect(cls).local_table
31 | raise AttributeError(item)
32 |
33 |
34 | class ABase(with_metaclass(ABaseMeta, object)):
35 | """abstract base class which introduces a nice constructor for the model classes."""
36 |
37 | def __init__(self, *args, **kw):
38 | """ create a model object.
39 |
40 | pass attributes by using named parameters, e.g. name="foo", value=123
41 | """
42 |
43 | for k, v in kw.items():
44 | setattr(self, k, v)
45 |
46 | def __str__(self):
47 | if hasattr(self, "__unicode__"):
48 | return self.__unicode__()
49 |
50 | def __getitem__(self, key):
51 | return getattr(self,key)
52 |
53 | def __setitem__(self, key, item):
54 | return setattr(self,key,item)
55 |
56 |
57 | def calc_distance(latlong1, latlong2):
58 | """generates a sqlalchemy expression for distance query in km
59 |
60 | :param latlong1: the location from which we look for rows, as tuple (lat,lng)
61 |
62 | :param latlong2: the columns containing the latitude and longitude, as tuple (lat,lng)
63 | """
64 |
65 | # explain: http://geokoder.com/distances
66 |
67 | # return func.sqrt(func.pow(69.1 * (latlong1[0] - latlong2[0]),2)
68 | # + func.pow(53.0 * (latlong1[1] - latlong2[1]),2))
69 |
70 | return func.sqrt(func.pow(111.2 * (latlong1[0] - latlong2[0]), 2)
71 | + func.pow(111.2 * (latlong1[1] - latlong2[1]) * func.cos(latlong2[0]), 2))
72 |
73 |
74 | def coords(row):
75 | return (row["lat"], row["lng"])
76 |
77 |
78 | def combine_updated_at(list_of_dates):
79 | return max(list_of_dates)
80 |
81 |
82 | def get_insert_id_by_result(r):
83 | return r.last_inserted_ids()[0]
84 |
85 |
86 | def get_insert_ids_by_result(r):
87 | return r.last_inserted_ids()
88 |
89 |
90 | def exists_by_expr(t, expr):
91 | # TODO: use exists instead of count
92 | q = select([func.count("*").label("c")], from_obj=t).where(expr)
93 | r = meta.DBSession.execute(q).fetchone()
94 | if r.c > 0:
95 | return True
96 | else:
97 | return False
98 |
99 |
100 | def datetime_trunc(field, timezone):
101 | return "date_trunc('%(field)s', CAST(to_char(NOW() AT TIME ZONE %(timezone)s, 'YYYY-MM-DD HH24:MI:SS') AS TIMESTAMP)) AT TIME ZONE %(timezone)s" % {
102 | "field": field,
103 | "timezone": timezone
104 | }
105 |
106 |
107 | def valid_timezone(timezone):
108 | try:
109 | pytz.timezone(timezone)
110 | except UnknownTimeZoneError:
111 | return False
112 | return True
113 |
114 |
115 | def update_connection():
116 | session = meta.DBSession() if callable(meta.DBSession) else meta.DBSession
117 | mark_changed(session)
118 | return session
119 |
120 |
--------------------------------------------------------------------------------
/gengine/app/api/schemas.py:
--------------------------------------------------------------------------------
1 | import pyramid_swagger_spec.swagger as sw
2 | from pyramid_swagger_spec.schema import JSchema
3 |
4 | r_status = JSchema(schema={
5 | "status": sw.property(sw.Types.string, nullable=False)
6 | })
7 |
8 | r_subject = JSchema(schema={
9 | 'id': sw.property(sw.Types.string, nullable=False),
10 | 'name': sw.property(sw.Types.string, nullable=True),
11 | 'created_at': sw.property(sw.Types.string, nullable=False),
12 | 'subjecttype_id': sw.property(sw.Types.string, nullable=False),
13 | 'path': sw.property(sw.Types.string, nullable=True),
14 | 'inherited_by_subjecttype_id': sw.property(sw.Types.number, nullable=True),
15 | 'inherited_by_name': sw.property(sw.Types.number, nullable=False),
16 | 'in_parent': sw.property(sw.Types.boolean, nullable=False),
17 | 'directly_in_parent': sw.property(sw.Types.boolean, nullable=False),
18 | 'inherited_by': sw.property(sw.Types.number, nullable=True),
19 | })
20 |
21 | r_subject_short = JSchema(schema={
22 | 'id': sw.property(sw.Types.string, nullable=False),
23 | 'name': sw.property(sw.Types.string, nullable=True),
24 | })
25 |
26 | r_subjectlist = JSchema(schema={
27 | 'subjects': sw.array_property(
28 | items=sw.object_property(
29 | properties=r_subject.get_json_schema()
30 | )
31 | )
32 | })
33 |
34 | b_subjectlist = JSchema(schema={
35 | "limit": sw.property(sw.Types.number, nullable=True),
36 | "offset": sw.property(sw.Types.number, nullable=True),
37 | "include_search": sw.property(sw.Types.string, nullable=True),
38 | "exclude_leaves": sw.property(sw.Types.boolean, nullable=True),
39 | "parent_subjecttype_id": sw.property(sw.Types.number, nullable=True),
40 | "parent_subject_id": sw.property(sw.Types.number, nullable=True),
41 | })
42 |
43 | b_subject_id = JSchema(schema={
44 | "subject_id": sw.property(sw.Types.number, nullable=True)
45 | })
46 |
47 |
48 | r_subjecttype = JSchema(schema={
49 | 'id': sw.property(sw.Types.string, nullable=False),
50 | 'name': sw.property(sw.Types.string, nullable=False),
51 | })
52 |
53 | r_subjecttypelist = JSchema(schema={
54 | 'subjecttypes': sw.array_property(
55 | items=sw.object_property(
56 | properties=r_subjecttype.get_json_schema()
57 | )
58 | )
59 | })
60 |
61 | r_variable = JSchema(schema={
62 | 'id': sw.property(sw.Types.string, nullable=False),
63 | 'name': sw.property(sw.Types.string, nullable=False),
64 | 'increase_permission': sw.property(sw.Types.string, nullable=False),
65 | })
66 |
67 | r_variablelist = JSchema(schema={
68 | 'variables': sw.array_property(
69 | items=sw.object_property(
70 | properties=r_variable.get_json_schema()
71 | )
72 | )
73 | })
74 |
75 |
76 | r_timezone = JSchema(schema={
77 | 'name': sw.property(sw.Types.string, nullable=False),
78 | })
79 |
80 | r_timezonelist = JSchema(schema={
81 | 'timezones': sw.array_property(
82 | items=sw.object_property(
83 | properties=r_timezone.get_json_schema()
84 | )
85 | )
86 | })
87 |
88 | # This currently only accepts the parameters which are needed for the leaderboard_creation form
89 | # To be extended if needed
90 | b_createachievement = JSchema(schema={
91 | 'name': sw.property(sw.Types.string, nullable=False),
92 | 'player_subjecttype_id': sw.property(sw.Types.number, nullable=False),
93 | 'context_subjecttype_id': sw.property(sw.Types.number, nullable=True),
94 | 'domain_subject_ids': sw.array_property(
95 | items=sw.property(sw.Types.number, nullable=False),
96 | nullable=True
97 | ),
98 | 'condition': sw.property(sw.Types.object, nullable=False),
99 | 'evaluation': sw.property(sw.Types.string, nullable=False),
100 | 'comparison_type': sw.property(sw.Types.string, nullable=False),
101 | 'evaluation_timezone': sw.property(sw.Types.string, nullable=False),
102 | 'evaluation_shift': sw.property(sw.Types.number, nullable=False),
103 | 'valid_start': sw.property(sw.Types.string, nullable=True),
104 | 'valid_end': sw.property(sw.Types.string, nullable=True),
105 | })
106 |
107 |
--------------------------------------------------------------------------------
/gengine/app/tests_old/test_auth.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from gengine.app.tests.base import BaseDBTest
3 | from gengine.app.tests.helpers import create_user, update_user, delete_user, get_or_create_language
4 | from gengine.metadata import DBSession
5 | from gengine.app.model import AuthUser
6 |
7 |
8 | class TestUserCreation(BaseDBTest):
9 |
10 | def test_user_creation(self):
11 |
12 | lang = get_or_create_language("en")
13 | user = create_user(
14 | lat = 12.1,
15 | lng = 12.2,
16 | #country = "RO",
17 | #region = "Transylvania",
18 | #city = "Cluj-Napoca",
19 | timezone = "Europe/Bukarest",
20 | language = "en",
21 | additional_public_data = {
22 | "first_name" : "Rudolf",
23 | "last_name" : "Red Nose"
24 | }
25 | )
26 |
27 | self.assertTrue(user.lat == 12.1)
28 | self.assertTrue(user.lng == 12.2)
29 | #self.assertTrue(user.country == "RO")
30 | #self.assertTrue(user.region == "Transylvania")
31 | #self.assertTrue(user.city == "Cluj-Napoca")
32 | self.assertTrue(user.timezone == "Europe/Bukarest")
33 | self.assertTrue(user.language_id == lang.id)
34 | self.assertTrue(user.additional_public_data["first_name"] == "Rudolf")
35 | self.assertTrue(user.additional_public_data["last_name"] == "Red Nose")
36 |
37 | def test_user_updation(self):
38 |
39 | lang = get_or_create_language("en")
40 | user = create_user()
41 | user = update_user(
42 | user_id = user.id,
43 | lat = 14.2,
44 | lng = 16.3,
45 | #country = "EN",
46 | #region = "Transylvania",
47 | #city = "Cluj-Napoca",
48 | timezone = "Europe/Bukarest",
49 | language = "en",
50 | additional_public_data = {
51 | "first_name" : "Rudolf",
52 | "last_name" : "Red Nose"
53 | }
54 | )
55 |
56 | # Correct cases
57 | self.assertTrue(user.lat == 14.2)
58 | self.assertTrue(user.lng == 16.3)
59 | #self.assertTrue(user.country == "EN")
60 | #self.assertTrue(user.region == "Transylvania")
61 | #self.assertTrue(user.city == "Cluj-Napoca")
62 | self.assertTrue(user.timezone == "Europe/Bukarest")
63 | self.assertTrue(user.language_id == lang.id)
64 |
65 | def test_user_deletion(self):
66 |
67 | user1 = create_user()
68 |
69 | # Create Second user
70 | user2 = create_user(
71 | lat=85.59,
72 | lng=65.75,
73 | #country="DE",
74 | #region="Niedersachsen",
75 | #city="Osnabrück",
76 | timezone="Europe/Berlin",
77 | language="de",
78 | additional_public_data={
79 | "first_name": "Michael",
80 | "last_name": "Clarke"
81 | },
82 | friends=[1]
83 | )
84 |
85 | remaining_users = delete_user(
86 | user_id = user1.id
87 | )
88 |
89 | # Correct cases
90 | self.assertNotIn(user1.id, remaining_users)
91 | self.assertEqual(user2.id, remaining_users[0].id)
92 |
93 | def test_verify_password(self):
94 | auth_user = AuthUser()
95 | auth_user.password = "test12345"
96 | auth_user.active = True
97 | auth_user.email = "test@actidoo.com"
98 | DBSession.add(auth_user)
99 |
100 | iscorrect = auth_user.verify_password("test12345")
101 |
102 | self.assertEqual(iscorrect, True)
103 |
104 | def test_create_token(self):
105 | user = create_user()
106 | auth_user = AuthUser()
107 | auth_user.user_id = user.id
108 | auth_user.password = "test12345"
109 | auth_user.active = True
110 | auth_user.email = "test@actidoo.com"
111 | DBSession.add(auth_user)
112 |
113 | if auth_user.verify_password("test12345"):
114 | token = auth_user.get_or_create_token()
115 |
116 | self.assertNotEqual(token, None)
117 |
118 |
119 |
120 |
121 |
122 |
--------------------------------------------------------------------------------
/gengine/app/tests_old/test_groups.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from gengine.app.tests.base import BaseDBTest
3 | from gengine.app.tests.helpers import create_user, update_user, delete_user, get_or_create_language
4 | from gengine.metadata import DBSession
5 | from gengine.app.model import AuthUser
6 |
7 |
8 | class TestUserCreation(BaseDBTest):
9 |
10 | def test_user_creation(self):
11 |
12 | lang = get_or_create_language("en")
13 | user = create_user(
14 | lat = 12.1,
15 | lng = 12.2,
16 | #country = "RO",
17 | #region = "Transylvania",
18 | #city = "Cluj-Napoca",
19 | timezone = "Europe/Bukarest",
20 | language = "en",
21 | additional_public_data = {
22 | "first_name" : "Rudolf",
23 | "last_name" : "Red Nose"
24 | }
25 | )
26 |
27 | self.assertTrue(user.lat == 12.1)
28 | self.assertTrue(user.lng == 12.2)
29 | #self.assertTrue(user.country == "RO")
30 | #self.assertTrue(user.region == "Transylvania")
31 | #self.assertTrue(user.city == "Cluj-Napoca")
32 | self.assertTrue(user.timezone == "Europe/Bukarest")
33 | self.assertTrue(user.language_id == lang.id)
34 | self.assertTrue(user.additional_public_data["first_name"] == "Rudolf")
35 | self.assertTrue(user.additional_public_data["last_name"] == "Red Nose")
36 |
37 | def test_user_updation(self):
38 |
39 | lang = get_or_create_language("en")
40 | user = create_user()
41 | user = update_user(
42 | user_id = user.id,
43 | lat = 14.2,
44 | lng = 16.3,
45 | #country = "EN",
46 | #region = "Transylvania",
47 | #city = "Cluj-Napoca",
48 | timezone = "Europe/Bukarest",
49 | language = "en",
50 | additional_public_data = {
51 | "first_name" : "Rudolf",
52 | "last_name" : "Red Nose"
53 | }
54 | )
55 |
56 | # Correct cases
57 | self.assertTrue(user.lat == 14.2)
58 | self.assertTrue(user.lng == 16.3)
59 | #self.assertTrue(user.country == "EN")
60 | #self.assertTrue(user.region == "Transylvania")
61 | #self.assertTrue(user.city == "Cluj-Napoca")
62 | self.assertTrue(user.timezone == "Europe/Bukarest")
63 | self.assertTrue(user.language_id == lang.id)
64 |
65 | def test_user_deletion(self):
66 |
67 | user1 = create_user()
68 |
69 | # Create Second user
70 | user2 = create_user(
71 | lat=85.59,
72 | lng=65.75,
73 | #country="DE",
74 | #region="Niedersachsen",
75 | #city="Osnabrück",
76 | timezone="Europe/Berlin",
77 | language="de",
78 | additional_public_data={
79 | "first_name": "Michael",
80 | "last_name": "Clarke"
81 | },
82 | friends=[1]
83 | )
84 |
85 | remaining_users = delete_user(
86 | user_id = user1.id
87 | )
88 |
89 | # Correct cases
90 | self.assertNotIn(user1.id, remaining_users)
91 | self.assertEqual(user2.id, remaining_users[0].id)
92 |
93 | def test_verify_password(self):
94 | auth_user = AuthUser()
95 | auth_user.password = "test12345"
96 | auth_user.active = True
97 | auth_user.email = "test@actidoo.com"
98 | DBSession.add(auth_user)
99 |
100 | iscorrect = auth_user.verify_password("test12345")
101 |
102 | self.assertEqual(iscorrect, True)
103 |
104 | def test_create_token(self):
105 | user = create_user()
106 | auth_user = AuthUser()
107 | auth_user.user_id = user.id
108 | auth_user.password = "test12345"
109 | auth_user.active = True
110 | auth_user.email = "test@actidoo.com"
111 | DBSession.add(auth_user)
112 |
113 | if auth_user.verify_password("test12345"):
114 | token = auth_user.get_or_create_token()
115 |
116 | self.assertNotEqual(token, None)
117 |
118 |
119 |
120 |
121 |
122 |
--------------------------------------------------------------------------------
/gengine/app/tests_old/test_eval_types_and_rewards.py:
--------------------------------------------------------------------------------
1 | import datetime
2 |
3 | from gengine.app.cache import clear_all_caches
4 | from gengine.app.tests.base import BaseDBTest
5 | from gengine.app.tests.helpers import create_user, create_achievement, create_variable, create_goals, create_achievement_user
6 | from gengine.app.model import Achievement, Value
7 |
8 |
9 | class TestEvaluationForMultipleUsersAndTimzone(BaseDBTest):
10 |
11 | def test_friends_leaderboard(self):
12 |
13 | user1 = create_user()
14 |
15 | # Create Second user
16 | user2 = create_user(
17 | lat=85.59,
18 | lng=65.75,
19 | #country="DE",
20 | #region="Roland",
21 | #city="New York",
22 | timezone="US/Eastern",
23 | language="en",
24 | additional_public_data={
25 | "first_name": "Michael",
26 | "last_name": "Clarke"
27 | }
28 | )
29 |
30 | # Create Third user
31 | user3 = create_user(
32 | lat=12.1,
33 | lng=12.2,
34 | #country="RO",
35 | #region="Transylvania",
36 | #city="Cluj-Napoca",
37 | timezone="Europe/Bucharest",
38 | language="en",
39 | additional_public_data={
40 | "first_name": "Rudolf",
41 | "last_name": "Red Nose"
42 | },
43 | friends=[1, 2]
44 | )
45 |
46 | # Create Fourth user
47 | user4 = create_user(
48 | lat=25.56,
49 | lng=15.89,
50 | #country="AU",
51 | #region="Sydney",
52 | #city="New South Wales",
53 | timezone="Australia/Sydney",
54 | language="en",
55 | additional_public_data={
56 | "first_name": "Steve",
57 | "last_name": "Waugh"
58 | },
59 | friends=[3]
60 | )
61 |
62 | achievement = create_achievement(achievement_name="invite_users_achievement",
63 | achievement_relevance="friends",
64 | achievement_maxlevel=3,
65 | achievement_evaluation="weekly")
66 |
67 | print(achievement.evaluation_timezone)
68 | achievement_date1 = Achievement.get_datetime_for_evaluation_type(achievement.evaluation_timezone, achievement.evaluation)
69 | print("Achievement date for first user:")
70 | print(achievement_date1)
71 |
72 | create_variable("invite_users", variable_group="day")
73 |
74 | create_goals(achievement,
75 | goal_goal=None,
76 | goal_operator="geq",
77 | goal_group_by_key=False
78 | )
79 |
80 | Value.increase_value(variable_name="invite_users", user=user1, value=12, key=None, at_datetime=achievement_date1)
81 | Value.increase_value(variable_name="invite_users", user=user2, value=2, key=None, at_datetime=achievement_date1)
82 | Value.increase_value(variable_name="invite_users", user=user3, value=11, key=None, at_datetime=achievement_date1)
83 | Value.increase_value(variable_name="invite_users", user=user4, value=6, key=None, at_datetime=achievement_date1)
84 |
85 | clear_all_caches()
86 |
87 | print("test for multiple users")
88 |
89 | # Evaluate achievement for friends of user 3
90 | achievement1 = Achievement.evaluate(user3, achievement.id, achievement_date1)
91 | print(achievement1["goals"][1]["leaderboard"])
92 |
93 | # user 3 has to friends: user 1 and user 2
94 | self.assertEqual(user1["id"], achievement1["goals"][1]["leaderboard"][0]["user"]["id"])
95 | self.assertEqual(user3["id"], achievement1["goals"][1]["leaderboard"][1]["user"]["id"])
96 | self.assertEqual(user2["id"], achievement1["goals"][1]["leaderboard"][2]["user"]["id"])
97 |
98 | self.assertEqual(12.0, achievement1["goals"][1]["leaderboard"][0]["value"])
99 | self.assertEqual(11.0, achievement1["goals"][1]["leaderboard"][1]["value"])
100 | self.assertEqual(2.0, achievement1["goals"][1]["leaderboard"][2]["value"])
101 |
102 |
--------------------------------------------------------------------------------
/docs/rest/index.rst:
--------------------------------------------------------------------------------
1 | :title: rest
2 | :description: introduction to the REST api
3 |
4 | REST API
5 | --------
6 |
7 | Add or update user data
8 | =======================
9 |
10 | - POST to "/add_or_update_subject/{subjectId}"
11 | - URL parameters:
12 | - subjectId (the Id of a subject in your system)
13 | - POST parameters:
14 | - lat (float latitude)
15 | - lon (float longitude)
16 | - country (String country)
17 | - city (String city)
18 | - region (String city)
19 | - friends (comma separated list of user Ids)
20 | - groups (comma separated list of group Ids)
21 | - language (name)
22 | - additional_public_data (JSON)
23 |
24 | - add or updates a subject with Id {subjectId} and Post parameters into the engines database
25 | - if friends Ids are not registered a empty record with only the user Id will be created
26 |
27 |
28 | Delete a subject
29 | =============
30 |
31 | - DELETE to "/delete_user/{userId}"
32 |
33 |
34 | Increase Value
35 | ==============
36 |
37 | - POST to "/increase_value/{variable_name}/{userId}/{key}"
38 | - URL parameters:
39 | - variable_name (the name of the variable to increase or decrease)
40 | - userId (the Id of the user)
41 | - key (an optional key, describing the context of the event, can be used in rules)
42 | - POST parameters:
43 | - value (the increase/decrease value in Double)
44 |
45 | - if the userId is not registered an error will be thrown
46 | - directly evaluates all goals associated with this variable_name
47 | - directly returns new reached achievements
48 |
49 | Increase multiple Values at once
50 | ==============
51 |
52 | - POST to "/increase_multi_values"
53 | - JSON request body:
54 | .. code:: json
55 | {
56 | "{userId}" : {
57 | "{variable}" : [
58 | {
59 | "key" : "{key}",
60 | "value" : "{value}"
61 | }
62 | ]
63 | }
64 | }
65 |
66 | - directly evaluates all goals associated with the given variables
67 | - directly returns new reached achievements
68 |
69 | Get Progress
70 | ============
71 |
72 | - get complete achievement progress for a single user
73 |
74 | - GET to "/progress/{userId}"
75 |
76 | - returns the complete achievement progress of a single user
77 |
78 | Get a single achievement Level
79 | ==============================
80 |
81 | - GET to "/achievement/{achievement_id}/level/{level}"
82 |
83 | - retrieves information about the rewards/properties of an achievement level
84 |
85 | Authentication
86 | ==============================
87 | - POST to "/auth/login"
88 | - Parameters in JSON-Body: email, password
89 | - Returns a json body with a token:
90 | .. code:: json
91 | {
92 | "token" : "foobar...."
93 | }
94 |
95 | Register Device (for Push-Messages)
96 | ==============================
97 | - POST to "/register_device/{user_id}"
98 | - Parameters in JSON-Body: device_id, push_id, device_os, app_version
99 | - Returns a json body with an ok status, or an error:
100 | .. code:: json
101 | {
102 | "status" : "ok"
103 | }
104 |
105 | Get Messages
106 | ==============================
107 | - GET to "/messages/{user_id}"
108 | - Possible GET Parameters: offset
109 | - Limit is always 100
110 | - Returns a json body with the messages:
111 | .. code:: json
112 | {
113 | "messages" : [{
114 | "id" : "....",
115 | "text" : "....",
116 | "is_read" : false,
117 | "created_at" : "...."
118 | }]
119 | }
120 |
121 | Set Messages Read
122 | ==============================
123 | - POST to "/read_messages/{user_id}"
124 | - Parameters in JSON-Body: message_id
125 | - Sets all messages as read which are at least as old, as the given message
126 | - Returns a json body with an ok status, or an error:
127 | .. code:: json
128 | {
129 | "status" : "ok"
130 | }
131 |
132 |
--------------------------------------------------------------------------------
/gengine/app/alembic/versions/a90076b18837_tasks_and_shift.py:
--------------------------------------------------------------------------------
1 | """tasks and shift
2 |
3 | Revision ID: a90076b18837
4 | Revises: 8e65de1ed535
5 | Create Date: 2017-05-19 11:18:09.260416
6 |
7 | """
8 |
9 | # revision identifiers, used by Alembic.
10 | revision = 'a90076b18837'
11 | down_revision = '8e65de1ed535'
12 | branch_labels = None
13 | depends_on = None
14 |
15 | from alembic import op
16 | import sqlalchemy as sa
17 | from sqlalchemy.dialects import postgresql
18 |
19 | def upgrade():
20 | ### commands auto generated by Alembic - please adjust! ###
21 | op.create_table('tasks',
22 | sa.Column('id', sa.Integer(), nullable=False),
23 | sa.Column('entry_name', sa.String(length=100), nullable=True),
24 | sa.Column('task_name', sa.String(length=100), nullable=False),
25 | sa.Column('config', sa.JSON(), nullable=True),
26 | sa.Column('cron', sa.String(length=100), nullable=True),
27 | sa.Column('is_removed', sa.Boolean(), nullable=False),
28 | sa.Column('is_auto_created', sa.Boolean(), nullable=False),
29 | sa.Column('is_manually_modified', sa.Boolean(), nullable=False),
30 | sa.PrimaryKeyConstraint('id', name=op.f('pk_tasks'))
31 | )
32 | op.create_index(op.f('ix_tasks_entry_name'), 'tasks', ['entry_name'], unique=False)
33 | op.create_index(op.f('ix_tasks_is_auto_created'), 'tasks', ['is_auto_created'], unique=False)
34 | op.create_index(op.f('ix_tasks_is_removed'), 'tasks', ['is_removed'], unique=False)
35 | op.create_index(op.f('ix_tasks_is_manually_modified'), 'tasks', ['is_manually_modified'], unique=False)
36 | op.create_index(op.f('ix_tasks_task_name'), 'tasks', ['task_name'], unique=False)
37 | op.create_table('taskexecutions',
38 | sa.Column('id', sa.Integer(), nullable=False),
39 | sa.Column('task_id', sa.Integer(), nullable=False),
40 | sa.Column('planned_at', postgresql.TIMESTAMP(timezone=True), nullable=False),
41 | sa.Column('locked_at', postgresql.TIMESTAMP(timezone=True), nullable=True),
42 | sa.Column('finished_at', postgresql.TIMESTAMP(timezone=True), nullable=True),
43 | sa.Column('canceled_at', postgresql.TIMESTAMP(timezone=True), nullable=True),
44 | sa.Column('log', sa.String(), nullable=True),
45 | sa.Column('success', sa.Boolean(), nullable=True),
46 | sa.ForeignKeyConstraint(['task_id'], ['tasks.id'], name=op.f('fk_taskexecutions_task_id_tasks'), ondelete='CASCADE'),
47 | sa.PrimaryKeyConstraint('id', name=op.f('pk_taskexecutions'))
48 | )
49 | op.create_index(op.f('ix_taskexecutions_canceled_at'), 'taskexecutions', ['canceled_at'], unique=False)
50 | op.create_index(op.f('ix_taskexecutions_finished_at'), 'taskexecutions', ['finished_at'], unique=False)
51 | op.create_index(op.f('ix_taskexecutions_locked_at'), 'taskexecutions', ['locked_at'], unique=False)
52 | op.create_index(op.f('ix_taskexecutions_planned_at'), 'taskexecutions', ['planned_at'], unique=False)
53 | op.create_index(op.f('ix_taskexecutions_success'), 'taskexecutions', ['success'], unique=False)
54 | op.create_index(op.f('ix_taskexecutions_task_id'), 'taskexecutions', ['task_id'], unique=False)
55 | op.add_column('achievements', sa.Column('evaluation_shift', sa.Integer(), nullable=True))
56 | ### end Alembic commands ###
57 |
58 |
59 | def downgrade():
60 | ### commands auto generated by Alembic - please adjust! ###
61 | op.drop_column('achievements', 'evaluation_shift')
62 | op.drop_index(op.f('ix_taskexecutions_task_id'), table_name='taskexecutions')
63 | op.drop_index(op.f('ix_taskexecutions_success'), table_name='taskexecutions')
64 | op.drop_index(op.f('ix_taskexecutions_planned_at'), table_name='taskexecutions')
65 | op.drop_index(op.f('ix_taskexecutions_locked_at'), table_name='taskexecutions')
66 | op.drop_index(op.f('ix_taskexecutions_finished_at'), table_name='taskexecutions')
67 | op.drop_index(op.f('ix_taskexecutions_canceled_at'), table_name='taskexecutions')
68 | op.drop_table('taskexecutions')
69 | op.drop_index(op.f('ix_tasks_task_name'), table_name='tasks')
70 | op.drop_index(op.f('ix_tasks_is_manually_modified'), table_name='tasks')
71 | op.drop_index(op.f('ix_tasks_is_removed'), table_name='tasks')
72 | op.drop_index(op.f('ix_tasks_is_auto_created'), table_name='tasks')
73 | op.drop_index(op.f('ix_tasks_entry_name'), table_name='tasks')
74 | op.drop_table('tasks')
75 | ### end Alembic commands ###
76 |
--------------------------------------------------------------------------------
/gengine/maintenance/scripts/scheduler_beat.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import sys
3 | import logging
4 | import datetime
5 | import os
6 | import pyramid_dogpile_cache
7 | import transaction
8 |
9 | from gengine.base.util import dt_ago, dt_now
10 | from sqlalchemy.sql.expression import and_
11 | from zope.sqlalchemy.datamanager import mark_changed
12 |
13 | from gengine.app.cache import init_caches
14 | from pyramid.config import Configurator
15 | from pyramid.paster import (
16 | get_appsettings,
17 | setup_logging,
18 | )
19 | from pyramid.scripts.common import parse_vars
20 | from sqlalchemy import engine_from_config
21 |
22 | log = logging.getLogger(__name__)
23 | log.addHandler(logging.StreamHandler())
24 |
25 |
26 | def usage(argv):
27 | cmd = os.path.basename(argv[0])
28 | print('usage: %s [var=value]\n'
29 | '(example: "%s production.ini")' % (cmd, cmd))
30 | sys.exit(1)
31 |
32 |
33 | def main(argv=sys.argv):
34 | if len(argv) < 2:
35 | usage(argv)
36 | config_uri = argv[1]
37 | options = parse_vars(argv[2:])
38 | setup_logging(config_uri)
39 | settings = get_appsettings(config_uri, options=options)
40 |
41 | import gengine
42 | gengine.main({}, **settings)
43 |
44 | from gengine.metadata import (
45 | DBSession
46 | )
47 | sess = DBSession()
48 |
49 | import gengine.app.model as m
50 | import crontab
51 |
52 | from gengine.app.registries import get_task_registry
53 | enginetasks = get_task_registry().registrations
54 |
55 | with transaction.manager:
56 | mark_changed(sess, transaction.manager, True)
57 |
58 | tasks = sess.execute(m.t_tasks.select()).fetchall()
59 |
60 | for task in tasks:
61 | cron = task["cron"]
62 | if not cron:
63 | cron = enginetasks.get(task["task_name"]).get("default_cron", None)
64 |
65 | if cron:
66 |
67 | now = dt_now().replace(second=0)
68 |
69 | item = crontab.CronItem(line=cron)
70 | s = item.schedule(date_from=now)
71 | prev = s.get_next().replace(second=0)
72 | next = s.get_next().replace(second=0)
73 |
74 | execs = sess.execute(m.t_taskexecutions.select().where(and_(
75 | m.t_taskexecutions.c.task_id == task["id"],
76 | m.t_taskexecutions.c.canceled_at == None,
77 | m.t_taskexecutions.c.finished_at == None,
78 | )).order_by(m.t_taskexecutions.c.planned_at.desc())).fetchall()
79 |
80 | found = False
81 |
82 | for exec in execs:
83 |
84 | if exec["planned_at"] >= next:
85 | # The next execution is already planned
86 | found = True
87 |
88 | if exec["planned_at"] <= prev and prev < dt_ago(minutes=10) and not exec["locked_at"]:
89 | # The execution is more than 10 minutes in the past and not yet locked (worker not running / overloaded)
90 | if next - datetime.timedelta(minutes=10) < dt_now():
91 | # The next execution is planned in less than 10 minutes, cancel the other one
92 | sess.execute(
93 | m.t_taskexecutions.update().values({
94 | 'canceled_at': dt_now()
95 | }).where({
96 | 'id': exec["id"]
97 | })
98 | )
99 |
100 | if exec["locked_at"] and exec["locked_at"] < dt_ago(hours=24):
101 | # this task is running for more than 24 hours. probably crashed.... set it to canceled
102 | sess.execute(
103 | m.t_taskexecutions.update().values({
104 | 'canceled_at': dt_now()
105 | }).where({
106 | 'id': exec["id"]
107 | })
108 | )
109 |
110 | if not found:
111 | # Plan next execution
112 | sess.execute(
113 | m.t_taskexecutions.insert().values({
114 | 'task_id': task["id"],
115 | 'planned_at': next
116 | })
117 | )
118 |
119 | sess.flush()
120 | sess.commit()
121 |
--------------------------------------------------------------------------------
/gengine/app/static/api.js:
--------------------------------------------------------------------------------
1 | var setupAPIForm = function($, defaultcall, fields, api_funcs) {
2 |
3 | var container_fields = {};
4 |
5 | for(var i=0; i0) {
127 | ajax_options["data"] = JSON.stringify(jsondata)
128 | }
129 |
130 | var request = $.ajax(ajax_options);
131 |
132 | request.done(function( msg ) {
133 | api_result.html("
78 | {% endif %}
79 | x
80 | {{ m }}
81 |
82 | {% endfor %}
83 | {% endif %}
84 | {% endwith %}
85 | {% endmacro %}
86 |
--------------------------------------------------------------------------------
/docker-files/production.ini:
--------------------------------------------------------------------------------
1 | ###
2 | # app configuration
3 | # http://docs.pylonsproject.org/projects/pyramid/en/1.5-branch/narr/environment.html
4 | ###
5 |
6 | [app:main]
7 | use = egg:gamification-engine
8 |
9 | pyramid.reload_templates = false
10 | pyramid.debug_authorization = false
11 | pyramid.debug_notfound = false
12 | pyramid.debug_routematch = false
13 | pyramid.default_locale_name = en
14 | pyramid.includes =
15 | pyramid_tm
16 |
17 | sqlalchemy.url = postgres://postgres:password@postgres/gengine
18 |
19 | #reverse proxy settings
20 | force_https = false
21 | urlprefix =
22 | urlcacheid = gengine
23 |
24 | #swagger
25 | swagger.use_http_scheme = true
26 | #leave empty because swagger url is somehow used in some react code (leaving empty makes it use relative path)
27 | swagger.host =
28 |
29 | #flaskadmin settings
30 | flaskadmin_secret = 87ghsjkdjfhg85grsfgsdfghwez89hsuif # replace with random string!
31 |
32 | # dogpile cache
33 | dogpile_cache.backend = dogpile.cache.null
34 |
35 | dogpile_cache.general.backend = dogpile.cache.dbm
36 | dogpile_cache.general.arguments.filename = general.dbm
37 |
38 | dogpile_cache.achievement_eval.backend = dogpile.cache.dbm
39 | dogpile_cache.achievement_eval.arguments.filename = achievement_eval.dbm
40 |
41 | dogpile_cache.achievements_by_user_for_today.backend = dogpile.cache.dbm
42 | dogpile_cache.achievements_by_user_for_today.arguments.filename = achievements_by_user_for_today.dbm
43 |
44 | dogpile_cache.translations.backend = dogpile.cache.dbm
45 | dogpile_cache.translations.arguments.filename = translations.dbm
46 |
47 | dogpile_cache.achievements_users_levels.backend = dogpile.cache.dbm
48 | dogpile_cache.achievements_users_levels.arguments.filename = achievements_users_levels.dbm
49 |
50 | dogpile_cache.goal_evaluation.backend = dogpile.cache.dbm
51 | dogpile_cache.goal_evaluation.arguments.filename = goal_evaluation.dbm
52 |
53 | dogpile_cache.goal_statements.backend = dogpile.cache.memory
54 |
55 | # memcache
56 | urlcache_url = memcached:11211
57 | urlcache_active = true
58 |
59 | # callback url, will be used for time-related leaderboard evaluations (daily,monthly,yearly) (TBD)
60 | notify_progress =
61 |
62 | enable_user_authentication = true
63 | fallback_language = en
64 | gcm.api_key=
65 | gcm.package=
66 | apns.dev.key=
67 | apns.dev.certificate=
68 | apns.prod.key=
69 | apns.prod.certificate=
70 | push_title=Gamification Engine
71 |
72 | ###
73 | # wsgi server configuration
74 | ###
75 |
76 | #[server:main]
77 | #use = egg:waitress#main
78 | #host = 0.0.0.0
79 | #port = 6543
80 |
81 |
82 | ###
83 | # logging configuration
84 | # http://docs.pylonsproject.org/projects/pyramid/en/1.5-branch/narr/logging.html
85 | ###
86 |
87 | [loggers]
88 | keys = root, gengine, sqlalchemy
89 |
90 | [handlers]
91 | keys = console
92 |
93 | [formatters]
94 | keys = generic
95 |
96 | [logger_root]
97 | level = WARN
98 | handlers = console
99 |
100 | [logger_gengine]
101 | level = WARN
102 | handlers =
103 | qualname = gengine
104 |
105 | [logger_sqlalchemy]
106 | level = WARN
107 | handlers =
108 | qualname = sqlalchemy.engine
109 | # "level = INFO" logs SQL queries.
110 | # "level = DEBUG" logs SQL queries and results.
111 | # "level = WARN" logs neither. (Recommended for production systems.)
112 |
113 | [handler_console]
114 | class = StreamHandler
115 | args = (sys.stderr,)
116 | level = NOTSET
117 | formatter = generic
118 |
119 | [formatter_generic]
120 | format = %(asctime)s %(levelname)-5.5s [%(name)s][%(threadName)s] %(message)s
121 |
--------------------------------------------------------------------------------
/gengine/maintenance/scripts/scheduler_worker.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import sys
3 | import logging
4 |
5 | from gengine.base.util import dt_now
6 | from sqlalchemy.sql.expression import and_, select
7 | from zope.sqlalchemy.datamanager import mark_changed
8 |
9 | import os
10 | import transaction
11 | from pyramid.paster import (
12 | get_appsettings,
13 | setup_logging,
14 | )
15 | from pyramid.scripts.common import parse_vars
16 |
17 | log = logging.getLogger(__name__)
18 | log.addHandler(logging.StreamHandler())
19 |
20 | def usage(argv):
21 | cmd = os.path.basename(argv[0])
22 | print('usage: %s "+syntaxHighlight(msg)+""); 134 | }); 135 | 136 | request.fail(function( jqXHR, textStatus ) { 137 | try { 138 | var json = JSON.parse(jqXHR.responseText); 139 | api_result.html("
Error "+jqXHR.status+":\n"+syntaxHighlight(json)+""); 140 | } catch(e) { 141 | api_result.html("
Error: "+jqXHR.status+""); 142 | } 143 | }); 144 | 145 | return false; 146 | }); 147 | 148 | //activate default api call 149 | call_select.val(defaultcall); 150 | activationfuncs[defaultcall](); 151 | }; -------------------------------------------------------------------------------- /gengine/app/leaderboard.py: -------------------------------------------------------------------------------- 1 | from gengine.base.util import dt_now 2 | from sqlalchemy.sql.expression import select, and_, or_ 3 | 4 | from gengine.app.model import t_subjects, t_subjectrelations, t_subjects_subjects, Subject 5 | from gengine.metadata import DBSession 6 | 7 | import logging 8 | # TODO: ADD date filter (compare created_at) 9 | # TODO: filter deleted 10 | 11 | 12 | class GlobalLeaderBoardSubjectSet: 13 | 14 | @classmethod 15 | def forward(cls, subjecttype_id, from_date, to_date, whole_time_required): 16 | q = select([t_subjects.c.id, ]).where(t_subjects.c.subjecttype_id == subjecttype_id) 17 | if from_date != None and to_date != None: 18 | if whole_time_required: 19 | q = q.where(and_( 20 | t_subjects.c.created_at <= from_date 21 | #or_( 22 | # t_subjects.c.deleted_at == None, 23 | # t_subjects.c.deleted_at >= to_date 24 | #) 25 | )) 26 | else: 27 | q = q.where(or_( 28 | and_( 29 | t_subjects.c.created_at <= from_date, 30 | #or_( 31 | # t_subjects.c.deleted_at >= from_date, 32 | # t_subjects.c.deleted_at == None, 33 | #) 34 | ), 35 | and_( 36 | t_subjects.c.created_at >= from_date, 37 | t_subjects.c.created_at <= to_date, 38 | ) 39 | )) 40 | return [x.id for x in DBSession.execute(q).fetchall()] 41 | 42 | #@classmethod 43 | #def reverse(cls): 44 | # return cls.forward() 45 | 46 | 47 | class RelationsLeaderBoardSubjectSet: 48 | 49 | @classmethod 50 | def forward(cls, subject_id, from_date, to_date, whole_time_required): 51 | subjects = [subject_id, ] 52 | 53 | q = select([t_subjectrelations.c.to_id, ], t_subjectrelations.c.from_id == subject_id) 54 | 55 | if from_date and to_date: 56 | if whole_time_required: 57 | q = q.where(and_( 58 | t_subjectrelations.c.created_at <= from_date, 59 | or_( 60 | t_subjectrelations.c.deleted_at == None, 61 | t_subjectrelations.c.deleted_at >= to_date 62 | ) 63 | )) 64 | else: 65 | q = q.where(or_( 66 | and_( 67 | t_subjectrelations.c.created_at <= from_date, 68 | or_( 69 | t_subjectrelations.c.deleted_at >= from_date, 70 | t_subjectrelations.c.deleted_at == None, 71 | ) 72 | ), 73 | and_( 74 | t_subjectrelations.c.created_at >= from_date, 75 | t_subjectrelations.c.created_at <= to_date, 76 | ) 77 | )) 78 | else: 79 | q = q.where( 80 | t_subjectrelations.c.deleted_at == None, 81 | ) 82 | 83 | subjects += [x["to_id"] for x in DBSession.execute(q).fetchall()] 84 | 85 | return subjects 86 | 87 | #@classmethod 88 | #def reverse(cls, subject_id): 89 | # subjects = [subject_id, ] 90 | # subjects += [x["from_id"] for x in DBSession.execute(select([t_subjects_subjects.c.from_id, ], t_subjects_subjects.c.to_id == subject_id)).fetchall()] 91 | # return subjects 92 | 93 | 94 | class ContextSubjectLeaderBoardSubjectSet: 95 | 96 | @classmethod 97 | def forward(cls, subjecttype_id, context_subject_id, from_date, to_date, whole_time_required=False): 98 | # We are comparing all subjects of type subject_type which have been part of context_subject_id between from_date and to_date 99 | # By default, they don't have to be member all the time (whole_time_required). 100 | 101 | #print("Looking for descendents of %s of type %s" % (context_subject_id, subjecttype_id)) 102 | #print("From Date: %s, To Date: %s, whole_time_required: %s" % (from_date, to_date, whole_time_required)) 103 | 104 | ancestor_subjects = Subject.get_descendent_subjects( 105 | subject_id=context_subject_id, 106 | of_type_id=subjecttype_id, 107 | from_date=from_date if from_date else dt_now(), 108 | to_date=to_date if to_date else dt_now(), 109 | whole_time_required=whole_time_required 110 | ) 111 | 112 | subjects = [x for x in ancestor_subjects.keys()] 113 | 114 | return subjects 115 | 116 | #@classmethod 117 | #def reverse(cls, subject_type_id, context_subject_id, from_date, to_date): 118 | # return cls.forward(subject_type=subject_type_id, context_subject_id=context_subject_id, from_date=from_date, to_date=to_date) 119 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # gamification-engine 2 | [](https://travis-ci.org/ActiDoo/gamification-engine) 3 | [](https://coveralls.io/github/ActiDoo/gamification-engine?branch=master) 4 | [](https://requires.io/github/ActiDoo/gamification-engine/requirements/?branch=master) 5 | [](https://gamification-engine.herokuapp.com) 6 | [](https://readthedocs.org/projects/gamification-engine/?badge=master) 7 | [](https://github.com/ActiDoo/gamification-engine/releases/latest) 8 | [](https://pypi.python.org/pypi/gamification-engine/) 9 | []() 10 | [](https://github.com/ActiDoo/gamification-engine/blob/master/LICENSE) 11 | 12 | 13 | The Gamification-Engine (gengine) is an open source software (MIT) for integrating any kinds of gamification features into your product. 14 | 15 | The engine is **not meant to be a platform** including any kinds of predefined graphics, layouts or statistics. 16 | It is framework for developing your own solution, implemented as a **service** to which your application server can talk over a REST api. 17 | 18 | ( https://www.actidoo.com ) 19 | 20 | Latest recommended version: https://github.com/ActiDoo/gamification-engine/releases/latest 21 | 22 | ## Features 23 | 24 | - multi level achievements 25 | - multi goal achievements 26 | - progress and single goals 27 | - leader boards / ladder 28 | - achievements can be reached directly or by evaluating leaderboards daily, weekly, monthly or yearly 29 | - time zone independent (correct daily, weekly.. evaluations among time zones) 30 | - social-awareness (e.g. reach the highest score among your friends) 31 | - geo-awareness (e.g. reach the highest score among all users in your city) 32 | - rules can be defined in python using given variables (e.g. the current level) 33 | - custom definable achievement properties and rewards 34 | - custom definable languages and translations 35 | - dependencies between achievements (prerequisites & postconditions) 36 | - goals can execute triggers (currently creation of messages and mobile pushes for iOS/Android) 37 | - high performance / scalable 38 | - administration ui 39 | 40 | ## REST Interface 41 | 42 | Simple REST-interface to communicate with arbitrary systems 43 | 44 | see http://gamification-engine.readthedocs.org/en/latest/rest/index.html 45 | 46 | ## Demo Installation 47 | 48 | A demo installation is available at https://gamification-engine.herokuapp.com/ 49 | 50 | ## Usage 51 | 52 | 1. A ready-to-use buildpack for Heroku and dokku is available at https://github.com/ActiDoo/gamification-engine-dokku Follow the instructions there. 53 | 2. The current stable version is available as python package at https://pypi.python.org/pypi/gamification-engine 54 | 3. Checkout the source code and configure the PostgreSQL database in `development.ini`. Then run `python setup.py develop` to configure the application, `initialize_gengine_db development.ini reset_db=True populate_demo=True` to configure the database and `pserve development.ini` to start it. The front end is available at http://localhost:6543/admin/ 55 | 56 | ## Docker support (2019-12) 57 | 58 | For development run: 59 | `docker-compose up` 60 | Go to `localhost:9000` to access admin interface or `localhost:6060` to access adminer. 61 | Code will be mounted into the container and server will be started with `--reload`. 62 | 63 | For production deployment adapt passwords and settings in `production.ini` and `docker-compose.production.yml` and run: 64 | ``` 65 | docker-compose -f docker-compose.production.yml up -d 66 | ``` 67 | A production ready server will run on `localhost:9000`, login using credentials set in `docker-compose.production.yml` 68 | 69 | ## Roadmap 70 | 71 | Do you want to contribute? We badly need tests! 72 | Also a nicer admin UI would be great or maybe some cool features :-) 73 | 74 | For a full list see: 75 | 76 | http://gamification-engine.readthedocs.org/en/latest/roadmap.html 77 | 78 | ## Licenses of dependencies 79 | 80 | Pyramid: BSD-derived (http://www.repoze.org/LICENSE.txt) 81 | 82 | pyramid_chameleon: BSD-derived (http://www.repoze.org/LICENSE.txt) 83 | 84 | pyramid_debugtoolbar: BSD 85 | 86 | SQLAlchemy: MIT 87 | 88 | zope.sqlalchemy: Zope Public License (ZPL) Version 2.1 89 | 90 | waitress: Zope Public License (ZPL) Version 2.1 91 | 92 | pytz: MIT 93 | 94 | dogpile.cache: BSD 95 | 96 | pyramid_dogpile_cache: MIT 97 | 98 | flask: BSD 99 | 100 | flask-admin: BSD 101 | 102 | psycopg2: LGPL / ZPL 103 | 104 | pymemcache: Apache License 2.0 105 | 106 | mock: BSD 107 | 108 | alembic: MIT 109 | -------------------------------------------------------------------------------- /gengine/app/alembic/versions/46e4971dc46f_extended_groups.py: -------------------------------------------------------------------------------- 1 | """extended_groups 2 | 3 | Revision ID: 46e4971dc46f 4 | Revises: a90076b18837 5 | Create Date: 2017-05-19 17:08:34.780367 6 | 7 | """ 8 | 9 | # revision identifiers, used by Alembic. 10 | revision = '46e4971dc46f' 11 | down_revision = 'a90076b18837' 12 | branch_labels = None 13 | depends_on = None 14 | 15 | from alembic import op 16 | import sqlalchemy as sa 17 | 18 | 19 | def upgrade(): 20 | ### commands auto generated by Alembic - please adjust! ### 21 | op.create_table('grouptypes', 22 | sa.Column('id', sa.BigInteger(), nullable=False), 23 | sa.Column('name', sa.String(length=100), nullable=False), 24 | sa.PrimaryKeyConstraint('id', name=op.f('pk_grouptypes')), 25 | sa.UniqueConstraint('name', name=op.f('uq_grouptypes_name')) 26 | ) 27 | op.create_table('grouptypes_grouptypes', 28 | sa.Column('id', sa.BigInteger(), nullable=False), 29 | sa.Column('grouptype_id', sa.BigInteger(), nullable=False), 30 | sa.Column('part_of_id', sa.BigInteger(), nullable=False), 31 | sa.ForeignKeyConstraint(['grouptype_id'], ['grouptypes.id'], name=op.f('fk_grouptypes_grouptypes_grouptype_id_grouptypes'), ondelete='CASCADE'), 32 | sa.ForeignKeyConstraint(['part_of_id'], ['grouptypes.id'], name=op.f('fk_grouptypes_grouptypes_part_of_id_grouptypes'), ondelete='CASCADE'), 33 | sa.PrimaryKeyConstraint('id', name=op.f('pk_grouptypes_grouptypes')), 34 | sa.UniqueConstraint('grouptype_id', 'part_of_id', name=op.f('uq_grouptypes_grouptypes_grouptype_id')) 35 | ) 36 | op.create_index(op.f('ix_grouptypes_grouptypes_grouptype_id'), 'grouptypes_grouptypes', ['grouptype_id'], unique=False) 37 | op.create_index(op.f('ix_grouptypes_grouptypes_part_of_id'), 'grouptypes_grouptypes', ['part_of_id'], unique=False) 38 | op.create_table('groups_groups', 39 | sa.Column('id', sa.BigInteger(), nullable=False), 40 | sa.Column('group_id', sa.BigInteger(), nullable=False), 41 | sa.Column('part_of_id', sa.BigInteger(), nullable=False), 42 | sa.ForeignKeyConstraint(['group_id'], ['groups.id'], name=op.f('fk_groups_groups_group_id_groups'), ondelete='CASCADE'), 43 | sa.ForeignKeyConstraint(['part_of_id'], ['groups.id'], name=op.f('fk_groups_groups_part_of_id_groups'), ondelete='CASCADE'), 44 | sa.PrimaryKeyConstraint('id', name=op.f('pk_groups_groups')), 45 | sa.UniqueConstraint('group_id', 'part_of_id', name=op.f('uq_groups_groups_group_id')) 46 | ) 47 | op.create_index(op.f('ix_groups_groups_group_id'), 'groups_groups', ['group_id'], unique=False) 48 | op.create_index(op.f('ix_groups_groups_part_of_id'), 'groups_groups', ['part_of_id'], unique=False) 49 | op.add_column('groups', sa.Column('grouptype_id', sa.BigInteger(), nullable=False)) 50 | op.create_index(op.f('ix_groups_grouptype_id'), 'groups', ['grouptype_id'], unique=False) 51 | op.create_foreign_key(op.f('fk_groups_grouptype_id_grouptypes'), 'groups', 'grouptypes', ['grouptype_id'], ['id'], ondelete='CASCADE') 52 | ### end Alembic commands ### 53 | 54 | op.execute(""" 55 | CREATE OR REPLACE FUNCTION check_grouptypes_grouptypes_cycle() RETURNS trigger AS $$ 56 | DECLARE 57 | cycles INTEGER; 58 | BEGIN 59 | LOCK TABLE grouptypes_grouptypes IN ACCESS EXCLUSIVE MODE; 60 | WITH RECURSIVE search_graph(part_of_id, group_id, id, depth, path, cycle) AS ( 61 | SELECT NEW.part_of_id, NEW.group_id, NEW.id, 1, 62 | ARRAY[NEW.id], false 63 | UNION ALL 64 | SELECT g.part_of_id, g.group_id, g.id, sg.depth + 1, 65 | path || g.id, 66 | g.id = ANY(path) 67 | FROM grouptypes_grouptypes g, search_graph sg 68 | WHERE g.part_of_id = sg.group_id AND NOT cycle 69 | ) 70 | SELECT INTO cycles COUNT(*) FROM search_graph WHERE cycle=true; 71 | RAISE NOTICE 'cycles: %', cycles; 72 | IF cycles > 0 THEN 73 | RAISE EXCEPTION 'cycle'; 74 | END IF; 75 | RETURN NEW; 76 | END 77 | $$ LANGUAGE plpgsql; 78 | 79 | CREATE TRIGGER check_grouptypes_grouptypes_cycle AFTER INSERT OR UPDATE ON grouptypes_grouptypes 80 | FOR EACH ROW EXECUTE PROCEDURE check_grouptypes_grouptypes_cycle(); 81 | """) 82 | 83 | op.execute(""" 84 | CREATE OR REPLACE FUNCTION check_groups_groups_cycle() RETURNS trigger AS $$ 85 | DECLARE 86 | cycles INTEGER; 87 | BEGIN 88 | LOCK TABLE groups_groups IN ACCESS EXCLUSIVE MODE; 89 | WITH RECURSIVE search_graph(part_of_id, group_id, id, depth, path, cycle) AS ( 90 | SELECT NEW.part_of_id, NEW.group_id, NEW.id, 1, 91 | ARRAY[NEW.id], false 92 | UNION ALL 93 | SELECT g.part_of_id, g.group_id, g.id, sg.depth + 1, 94 | path || g.id, 95 | g.id = ANY(path) 96 | FROM groups_groups g, search_graph sg 97 | WHERE g.part_of_id = sg.group_id AND NOT cycle 98 | ) 99 | SELECT INTO cycles COUNT(*) FROM search_graph WHERE cycle=true; 100 | RAISE NOTICE 'cycles: %', cycles; 101 | IF cycles > 0 THEN 102 | RAISE EXCEPTION 'cycle'; 103 | END IF; 104 | RETURN NEW; 105 | END 106 | $$ LANGUAGE plpgsql; 107 | 108 | CREATE TRIGGER check_groups_groups_cycle AFTER INSERT OR UPDATE ON groups_groups 109 | FOR EACH ROW EXECUTE PROCEDURE check_groups_groups_cycle(); 110 | """) 111 | 112 | 113 | def downgrade(): 114 | ### commands auto generated by Alembic - please adjust! ### 115 | raise NotImplementedError() 116 | ### end Alembic commands ### 117 | -------------------------------------------------------------------------------- /gengine/__init__.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | from pyramid.events import NewRequest 3 | 4 | from gengine.app.permissions import yield_all_perms 5 | from gengine.base.context import reset_context 6 | from gengine.base.errors import APIError 7 | from gengine.base.settings import set_settings 8 | from gengine.base.util import dt_now 9 | 10 | __version__ = '0.4.0' 11 | 12 | import datetime 13 | 14 | import os 15 | from pyramid.config import Configurator 16 | from pyramid.renderers import JSON 17 | from pyramid.settings import asbool 18 | from sqlalchemy import engine_from_config, create_engine 19 | 20 | from gengine.wsgiutil import HTTPSProxied, init_reverse_proxy 21 | 22 | def main(global_config, **settings): 23 | """ This function returns a Pyramid WSGI application. 24 | """ 25 | 26 | durl = os.environ.get("DATABASE_URL") #heroku 27 | if durl: 28 | settings['sqlalchemy.url']=durl 29 | 30 | murl = os.environ.get("MEMCACHED_URL") #heroku 31 | if murl: 32 | settings['urlcache_url']=murl 33 | 34 | set_settings(settings) 35 | 36 | if os.environ.get("DATABASE_URL",None): 37 | engine = create_engine(os.environ["DATABASE_URL"], connect_args={"options": "-c timezone=utc"}) 38 | else: 39 | engine = engine_from_config(settings, 'sqlalchemy.', connect_args={"options": "-c timezone=utc"}, ) 40 | 41 | from gengine.app.cache import init_caches 42 | init_caches() 43 | 44 | from gengine.metadata import init_session, init_declarative_base, init_db 45 | 46 | init_session() 47 | init_declarative_base() 48 | init_db(engine) 49 | 50 | from gengine.base.monkeypatch_flaskadmin import do_monkeypatch 51 | do_monkeypatch() 52 | 53 | def reset_context_on_new_request(event): 54 | reset_context() 55 | 56 | from gengine.app.api.resources import root_factory 57 | config = Configurator(settings=settings, root_factory=root_factory) 58 | config.add_subscriber(reset_context_on_new_request,NewRequest) 59 | config.include('pyramid_dogpile_cache') 60 | config.include('pyramid_swagger_spec') 61 | 62 | config.include("pyramid_tm") 63 | config.include('pyramid_chameleon') 64 | config.include('gengine.app.tasks') 65 | config.include('gengine.app.jsscripts') 66 | 67 | urlprefix = settings.get("urlprefix","") 68 | urlcacheid = settings.get("urlcacheid","gengine") 69 | force_https = asbool(settings.get("force_https",False)) 70 | init_reverse_proxy(force_https, urlprefix) 71 | 72 | urlcache_url = settings.get("urlcache_url","127.0.0.1:11211") 73 | urlcache_active = asbool(os.environ.get("URLCACHE_ACTIVE", settings.get("urlcache_active",True))) 74 | 75 | #auth 76 | def get_user(request): 77 | if not asbool(settings.get("enable_user_authentication",False)): 78 | return None 79 | token = request.headers.get('X-Auth-Token') 80 | if (not token) and request.cookies.get("X-Auth-Token"): 81 | token = request.cookies.get("X-Auth-Token") 82 | if token is not None: 83 | from gengine.app.model import DBSession, AuthUser, AuthToken 84 | tokenObj = DBSession.query(AuthToken).filter(AuthToken.token.like(token)).first() 85 | user = None 86 | if tokenObj and tokenObj.valid_until < dt_now(): 87 | tokenObj.extend() 88 | if tokenObj: 89 | user = tokenObj.user 90 | if not user: 91 | raise APIError(401, "invalid_token", "Invalid token provided.") 92 | if not user.active: 93 | raise APIError(404, "user_is_not_activated", "Your user is not activated.") 94 | return user 95 | return None 96 | 97 | def get_permissions(request): 98 | if not asbool(settings.get("enable_user_authentication", False)): 99 | return [x[0] for x in yield_all_perms()] 100 | 101 | if not request.user: 102 | return [] 103 | 104 | from gengine.app.model import DBSession, t_auth_tokens, t_auth_users, t_auth_roles, t_auth_roles_permissions, t_auth_users_roles 105 | from sqlalchemy.sql import select 106 | j = t_auth_users_roles.join(t_auth_roles).join(t_auth_roles_permissions) 107 | q = select([t_auth_roles_permissions.c.name],from_obj=j).where(t_auth_users_roles.c.auth_user_id==request.user.id) 108 | rows = DBSession.execute(q).fetchall() 109 | return [r["name"] for r in rows] 110 | 111 | def get_subject(request): 112 | return request.user.subject if request.user else None 113 | 114 | def has_perm(request, name): 115 | return name in request.permissions 116 | 117 | config.add_request_method(get_user, 'user', reify=True) 118 | config.add_request_method(get_subject, 'subject', reify=True) 119 | config.add_request_method(get_permissions, 'permissions', reify=True) 120 | config.add_request_method(has_perm, 'has_perm') 121 | 122 | #routes 123 | from gengine.app.route import config_routes as config_app_routes 124 | 125 | config.include(config_app_routes, route_prefix=urlprefix) 126 | 127 | #date serialization 128 | json_renderer = JSON() 129 | def datetime_adapter(obj, request): 130 | return obj.isoformat() 131 | json_renderer.add_adapter(datetime.datetime, datetime_adapter) 132 | config.add_renderer('json', json_renderer) 133 | 134 | config.scan(ignore=["gengine.app.tests"]) 135 | 136 | config.add_route('admin_app', '/admin/*subpath') 137 | from gengine.app.admin import init_admin as init_tenantadmin 138 | init_tenantadmin(urlprefix=urlprefix, 139 | secret=settings.get("flaskadmin_secret", "fKY7kJ2xSrbPC5yieEjV")) 140 | 141 | return HTTPSProxied(config.make_wsgi_app()) 142 | -------------------------------------------------------------------------------- /wait-for-it.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | # Use this script to test if a given TCP host/port are available 3 | 4 | WAITFORIT_cmdname=${0##*/} 5 | 6 | echoerr() { if [[ $WAITFORIT_QUIET -ne 1 ]]; then echo "$@" 1>&2; fi } 7 | 8 | usage() 9 | { 10 | cat << USAGE >&2 11 | Usage: 12 | $WAITFORIT_cmdname host:port [-s] [-t timeout] [-- command args] 13 | -h HOST | --host=HOST Host or IP under test 14 | -p PORT | --port=PORT TCP port under test 15 | Alternatively, you specify the host and port as host:port 16 | -s | --strict Only execute subcommand if the test succeeds 17 | -q | --quiet Don't output any status messages 18 | -t TIMEOUT | --timeout=TIMEOUT 19 | Timeout in seconds, zero for no timeout 20 | -- COMMAND ARGS Execute command with args after the test finishes 21 | USAGE 22 | exit 1 23 | } 24 | 25 | wait_for() 26 | { 27 | if [[ $WAITFORIT_TIMEOUT -gt 0 ]]; then 28 | echoerr "$WAITFORIT_cmdname: waiting $WAITFORIT_TIMEOUT seconds for $WAITFORIT_HOST:$WAITFORIT_PORT" 29 | else 30 | echoerr "$WAITFORIT_cmdname: waiting for $WAITFORIT_HOST:$WAITFORIT_PORT without a timeout" 31 | fi 32 | WAITFORIT_start_ts=$(date +%s) 33 | while : 34 | do 35 | if [[ $WAITFORIT_ISBUSY -eq 1 ]]; then 36 | nc -z $WAITFORIT_HOST $WAITFORIT_PORT 37 | WAITFORIT_result=$? 38 | else 39 | (echo > /dev/tcp/$WAITFORIT_HOST/$WAITFORIT_PORT) >/dev/null 2>&1 40 | WAITFORIT_result=$? 41 | fi 42 | if [[ $WAITFORIT_result -eq 0 ]]; then 43 | WAITFORIT_end_ts=$(date +%s) 44 | echoerr "$WAITFORIT_cmdname: $WAITFORIT_HOST:$WAITFORIT_PORT is available after $((WAITFORIT_end_ts - WAITFORIT_start_ts)) seconds" 45 | break 46 | fi 47 | sleep 1 48 | done 49 | return $WAITFORIT_result 50 | } 51 | 52 | wait_for_wrapper() 53 | { 54 | # In order to support SIGINT during timeout: http://unix.stackexchange.com/a/57692 55 | if [[ $WAITFORIT_QUIET -eq 1 ]]; then 56 | timeout $WAITFORIT_BUSYTIMEFLAG $WAITFORIT_TIMEOUT $0 --quiet --child --host=$WAITFORIT_HOST --port=$WAITFORIT_PORT --timeout=$WAITFORIT_TIMEOUT & 57 | else 58 | timeout $WAITFORIT_BUSYTIMEFLAG $WAITFORIT_TIMEOUT $0 --child --host=$WAITFORIT_HOST --port=$WAITFORIT_PORT --timeout=$WAITFORIT_TIMEOUT & 59 | fi 60 | WAITFORIT_PID=$! 61 | trap "kill -INT -$WAITFORIT_PID" INT 62 | wait $WAITFORIT_PID 63 | WAITFORIT_RESULT=$? 64 | if [[ $WAITFORIT_RESULT -ne 0 ]]; then 65 | echoerr "$WAITFORIT_cmdname: timeout occurred after waiting $WAITFORIT_TIMEOUT seconds for $WAITFORIT_HOST:$WAITFORIT_PORT" 66 | fi 67 | return $WAITFORIT_RESULT 68 | } 69 | 70 | # process arguments 71 | while [[ $# -gt 0 ]] 72 | do 73 | case "$1" in 74 | *:* ) 75 | WAITFORIT_hostport=(${1//:/ }) 76 | WAITFORIT_HOST=${WAITFORIT_hostport[0]} 77 | WAITFORIT_PORT=${WAITFORIT_hostport[1]} 78 | shift 1 79 | ;; 80 | --child) 81 | WAITFORIT_CHILD=1 82 | shift 1 83 | ;; 84 | -q | --quiet) 85 | WAITFORIT_QUIET=1 86 | shift 1 87 | ;; 88 | -s | --strict) 89 | WAITFORIT_STRICT=1 90 | shift 1 91 | ;; 92 | -h) 93 | WAITFORIT_HOST="$2" 94 | if [[ $WAITFORIT_HOST == "" ]]; then break; fi 95 | shift 2 96 | ;; 97 | --host=*) 98 | WAITFORIT_HOST="${1#*=}" 99 | shift 1 100 | ;; 101 | -p) 102 | WAITFORIT_PORT="$2" 103 | if [[ $WAITFORIT_PORT == "" ]]; then break; fi 104 | shift 2 105 | ;; 106 | --port=*) 107 | WAITFORIT_PORT="${1#*=}" 108 | shift 1 109 | ;; 110 | -t) 111 | WAITFORIT_TIMEOUT="$2" 112 | if [[ $WAITFORIT_TIMEOUT == "" ]]; then break; fi 113 | shift 2 114 | ;; 115 | --timeout=*) 116 | WAITFORIT_TIMEOUT="${1#*=}" 117 | shift 1 118 | ;; 119 | --) 120 | shift 121 | WAITFORIT_CLI=("$@") 122 | break 123 | ;; 124 | --help) 125 | usage 126 | ;; 127 | *) 128 | echoerr "Unknown argument: $1" 129 | usage 130 | ;; 131 | esac 132 | done 133 | 134 | if [[ "$WAITFORIT_HOST" == "" || "$WAITFORIT_PORT" == "" ]]; then 135 | echoerr "Error: you need to provide a host and port to test." 136 | usage 137 | fi 138 | 139 | WAITFORIT_TIMEOUT=${WAITFORIT_TIMEOUT:-15} 140 | WAITFORIT_STRICT=${WAITFORIT_STRICT:-0} 141 | WAITFORIT_CHILD=${WAITFORIT_CHILD:-0} 142 | WAITFORIT_QUIET=${WAITFORIT_QUIET:-0} 143 | 144 | # check to see if timeout is from busybox? 145 | WAITFORIT_TIMEOUT_PATH=$(type -p timeout) 146 | WAITFORIT_TIMEOUT_PATH=$(realpath $WAITFORIT_TIMEOUT_PATH 2>/dev/null || readlink -f $WAITFORIT_TIMEOUT_PATH) 147 | if [[ $WAITFORIT_TIMEOUT_PATH =~ "busybox" ]]; then 148 | WAITFORIT_ISBUSY=1 149 | WAITFORIT_BUSYTIMEFLAG="" 150 | 151 | else 152 | WAITFORIT_ISBUSY=0 153 | WAITFORIT_BUSYTIMEFLAG="-t" 154 | fi 155 | 156 | if [[ $WAITFORIT_CHILD -gt 0 ]]; then 157 | wait_for 158 | WAITFORIT_RESULT=$? 159 | exit $WAITFORIT_RESULT 160 | else 161 | if [[ $WAITFORIT_TIMEOUT -gt 0 ]]; then 162 | wait_for_wrapper 163 | WAITFORIT_RESULT=$? 164 | else 165 | wait_for 166 | WAITFORIT_RESULT=$? 167 | fi 168 | fi 169 | 170 | if [[ $WAITFORIT_CLI != "" ]]; then 171 | if [[ $WAITFORIT_RESULT -ne 0 && $WAITFORIT_STRICT -eq 1 ]]; then 172 | echoerr "$WAITFORIT_cmdname: strict mode, refusing to execute subprocess" 173 | exit $WAITFORIT_RESULT 174 | fi 175 | exec "${WAITFORIT_CLI[@]}" 176 | else 177 | exit $WAITFORIT_RESULT 178 | fi 179 | --------------------------------------------------------------------------------