def create_goal_evaluation_cache( goal_id, gec_achievement_date, gec_user_id, gec_achieved=undefined, gec_value=undefined, ): goal_evaluation_cache = GoalEvaluationCache() if gec_achieved is undefined: goal_evaluation_cache.gec_achieved = True else: goal_evaluation_cache.gec_achieved = gec_achieved if gec_value is undefined: goal_evaluation_cache.gec_value = 20.0 else: goal_evaluation_cache.gec_value = gec_value goal_evaluation_cache.goal_id = goal_id goal_evaluation_cache.achievement_date = gec_achievement_date goal_evaluation_cache.user_id = gec_user_id goal_evaluation_cache.achieved = gec_achieved goal_evaluation_cache.value = gec_value DBSession.add(goal_evaluation_cache) DBSession.flush() return goal_evaluation_cache
def add_Reward(request): reward = Reward() reward.name = request.POST["name"] DBSession.add(reward) DBSession.flush() return {"Achivement_Reward": "ok"}
def create_variable(name, increase_permission="admin"): variable = Variable() variable.name = name variable.increase_permission = increase_permission DBSession.add(variable) DBSession.flush() return variable
def test_evaluate_achievement_for_participate(self): achievement = create_achievement( achievement_name="participate_achievement", achievement_relevance="own", achievement_maxlevel=4) user = create_user() achievement_date = Achievement.get_datetime_for_evaluation_type( achievement.evaluation_timezone, achievement.evaluation) current_level = 1 achievement_user = AchievementSubject() achievement_user.user_id = user.id achievement_user.achievement_id = achievement.id achievement_user.achievement_date = achievement_date achievement_user.level = current_level DBSession.add(achievement_user) DBSession.flush() variable = create_variable("participate", variable_group="day") Value.increase_value(variable_name=variable.name, user=user, value=1, key="5") create_goals( achievement, goal_condition= """{"term": {"key": ["5","7"], "type": "literal", "key_operator": "IN", "variable": "participate"}}""", goal_group_by_key=True, goal_operator="geq", goal_goal="1*level") clear_all_caches() level = Achievement.evaluate(user, achievement.id, achievement_date).get("level") Value.increase_value(variable_name="participate", user=user, value=1, key="7", at_datetime=achievement_date) level2 = Achievement.evaluate(user, achievement.id, achievement_date).get("level") Value.increase_value(variable_name="participate", user=user, value=5, key="5", at_datetime=achievement_date) level1 = Achievement.evaluate(user, achievement.id, achievement_date).get("level") self.assertEqual(level, 1) self.assertEqual(level2, 1) self.assertEqual(level1, 4)
def get_or_create_language(name): lang = DBSession.query(Language).filter_by(name=name).first() if not lang: lang = Language() lang.name = name DBSession.add(lang) DBSession.flush() return lang
def add_Achivement_Properties(request): achievementProperty = AchievementProperty() achievementProperty.name = request.POST["name"] DBSession.add(achievementProperty) DBSession.flush() return {"Achivement_Properties": "ok"}
def get_or_create_role(DBSession, name): from gengine.app.model import AuthRole auth_role = DBSession.query(AuthRole).filter_by(name=name).first() if not auth_role: auth_role = AuthRole(name=name) DBSession.add(auth_role) return auth_role
def add_Variable(request): variable = Variable() variable.name = request.POST["variable_name"] variable.group = request.POST["variable_group"] DBSession.add(variable) DBSession.flush() return {"variable": "ok"}
def create_achievement_user(user, achievement, achievement_date, level): achievement_user = AchievementSubject() achievement_user.user_id = user.id achievement_user.achievement_id = achievement.id achievement_user.achievement_date = achievement_date achievement_user.level = level DBSession.add(achievement_user) DBSession.flush() return achievement_user
def test_verify_password(self): auth_user = AuthUser() auth_user.password = "******" auth_user.active = True auth_user.email = "*****@*****.**" DBSession.add(auth_user) iscorrect = auth_user.verify_password("test12345") self.assertEqual(iscorrect, True)
def create_variable( variable_name=undefined, variable_group=undefined, ): variable = Variable() variable.name = variable_name variable.group = variable_group DBSession.add(variable) DBSession.flush() return variable
def test_create_token(self): user = create_user() auth_user = AuthUser() auth_user.user_id = user.id auth_user.password = "******" auth_user.active = True auth_user.email = "*****@*****.**" DBSession.add(auth_user) if auth_user.verify_password("test12345"): token = auth_user.get_or_create_token() self.assertNotEqual(token, None)
def test_get_achievement_properties(self): achievement = create_achievement(achievement_maxlevel=3) achievementproperty = AchievementProperty() achievementproperty.name = "xp" DBSession.add(achievementproperty) DBSession.flush() achievements_achievementproperty = AchievementAchievementProperty() achievements_achievementproperty.achievement_id = achievement.id achievements_achievementproperty.property_id = achievementproperty.id achievements_achievementproperty.value = "5" achievements_achievementproperty.from_level = 2 DBSession.add(achievements_achievementproperty) DBSession.flush() clear_all_caches() result1 = Achievement.get_achievement_properties(achievement.id, 4) print(result1) result2 = Achievement.get_achievement_properties(achievement.id, 1) print(result2) self.assertNotEqual(result1, []) self.assertEqual(result2, [])
def add_Achivement(request): achievementCategory = AchievementCategory() achievementCategory.name = request.POST["category"] DBSession.add(achievementCategory) DBSession.flush() achievement = Achievement() achievement.name = request.POST["achievement_name"] achievement.valid_start = request.POST["achievement_valid_start"] achievement.valid_end = request.POST["achievement_valid_end"] achievement.maxlevel = request.POST["achievement_maxlevel"] achievement.relevance = "global" achievement.evaluation_timezone = "UTC" achievement.achievementcategory_id = achievementCategory.id """ achievement.lat = 0 achievement.lng = 0 achievement.max_distance = 0 achievement.evaluation = "immediately" #to add with edit after creating groups and friends users achievement.relevance = "friends" achievement.view_permission = request.POST["achievement_view_permission"] """ DBSession.add(achievement) DBSession.flush() params = {"id": achievement.id} #params = {"id": "7"} return HTTPFound(request.route_url('upload', _query=params))
def create_device(subject_id=undefined, device_id=undefined, device_os=undefined, push_id=undefined, app_version=undefined, gen_data=default_device_data): if push_id is undefined: push_id = gen_data["push_id"] if device_os is undefined: device_os = gen_data["device_os"] if app_version is undefined: app_version = gen_data["app_version"] if device_id is undefined: device_id = gen_data["device_id"] SubjectDevice.add_or_update_device(device_id=device_id, subject_id=subject_id, device_os=device_os, push_id=push_id, app_version=app_version) device = DBSession.execute(t_subject_device.select().where( and_(t_subject_device.c.device_id == device_id, t_subject_device.c.subject_id == subject_id))).fetchone() return device
def forward(cls, subjecttype_id, from_date, to_date, whole_time_required): q = select([t_subjects.c.id, ]).where(t_subjects.c.subjecttype_id == subjecttype_id) if whole_time_required: q = q.where(and_( t_subjects.c.created_at <= from_date #or_( # t_subjects.c.deleted_at == None, # t_subjects.c.deleted_at >= to_date #) )) else: q = q.where(or_( and_( t_subjects.c.created_at <= from_date, #or_( # t_subjects.c.deleted_at >= from_date, # t_subjects.c.deleted_at == None, #) ), and_( t_subjects.c.created_at >= from_date, t_subjects.c.created_at <= to_date, ) )) return [x.id for x in DBSession.execute(q).fetchall()]
def subject_remove_from_parent(request, *args, **kw): context = request.context parent_row = context.subject_row if not request.has_perm(perm_global_manage_subjects): raise APIError(403, "forbidden") q = t_subjects_subjects.select().where(and_( t_subjects_subjects.c.subject_id == request.validated_params.body["subject_id"], t_subjects_subjects.c.part_of_id == parent_row["id"], )) r = DBSession.execute(q).fetchone() if r: q = t_subjects_subjects.delete().where(and_( t_subjects_subjects.c.subject_id == request.validated_params.body["subject_id"], t_subjects_subjects.c.part_of_id == parent_row["id"], )) update_connection().execute(q) return r_status.output({ "status": "ok" })
def delete_user(user_id=undefined, ): User.delete_user(user_id) users = DBSession.execute(select([ t_users.c.id, ])).fetchall() return users
def create_value( user_id=undefined, variable_id=undefined, var_value=undefined, key="", ): value = Value() value.user_id = user_id value.variable_id = variable_id value.value = var_value value.key = key DBSession.add(value) DBSession.flush() return value
def create_user( user_id = undefined, lat = undefined, lng = undefined, country = undefined, region = undefined, city = undefined, timezone = undefined, language = undefined, friends = [], groups = [], additional_public_data = undefined, gen_data = default_gen_data ): if additional_public_data is undefined: additional_public_data = { 'first_name' : 'Stefan', 'last_name' : 'Rogers' } if user_id is undefined: user_id = (DBSession.execute("SELECT max(id) as c FROM users").scalar() or 0) + 1 if lat is undefined: lat = randrange_float(gen_data["area"]["min_lat"],gen_data["area"]["max_lat"]) if lng is undefined: lng = randrange_float(gen_data["area"]["min_lng"], gen_data["area"]["max_lng"]) if country is undefined: country = gen_data["country"] if timezone is undefined: timezone = gen_data["timezone"] if region is undefined: region = gen_data["region"] if city is undefined: city = gen_data["city"] if language is undefined: language = gen_data["language"] User.set_infos( user_id = user_id, lat = lat, lng = lng, timezone = timezone, country = country, region = region, city = city, language = language, groups = groups, friends = friends, additional_public_data = additional_public_data ) return User.get_user(user_id)
def test_get_reward_and_properties_for_achievement(self): user = create_user() achievement = create_achievement( achievement_name="invite_users_achievement", achievement_relevance="friends", achievement_maxlevel=3) achievementproperty = AchievementProperty() achievementproperty.name = "xp" DBSession.add(achievementproperty) DBSession.flush() achievements_achievementproperty = AchievementAchievementProperty() achievements_achievementproperty.achievement_id = achievement.id achievements_achievementproperty.property_id = achievementproperty.id achievements_achievementproperty.value = "5" achievements_achievementproperty.from_level = None DBSession.add(achievements_achievementproperty) DBSession.flush() create_achievement_rewards(achievement=achievement) achievement_date = Achievement.get_datetime_for_evaluation_type( achievement.evaluation_timezone, achievement.evaluation) create_achievement_user(user=user, achievement=achievement, achievement_date=achievement_date, level=1) create_variable("invite_users", "none") Value.increase_value(variable_name="invite_users", user=user, value=4, key="5", at_datetime=achievement_date) create_goals( achievement=achievement, goal_condition= """{"term": {"type": "literal", "variable": "invite_users"}}""", goal_group_by_key=True, goal_operator="geq", goal_goal="1*level") clear_all_caches() result = Achievement.evaluate(user, achievement.id, achievement_date) print("reward_achievement_result:", result) self.assertEqual(len(result["new_levels"]["2"]["rewards"]), 0) self.assertEqual(len(result["new_levels"]["3"]["rewards"]), 1) self.assertEqual(len(result["new_levels"]["2"]["properties"]), 1) self.assertEqual(len(result["new_levels"]["3"]["properties"]), 1)
def auth_login(request): try: doc = request.json_body except: raise APIError(400, "invalid_json", "no valid json body") user = request.user email = doc.get("email") password = doc.get("password") if user: #already logged in token = user.get_or_create_token().token else: if not email or not password: raise APIError(400, "login.email_and_password_required", "You need to send your email and password.") user = DBSession.query(AuthUser).filter_by(email=email).first() if not user or not user.verify_password(password): raise APIError( 401, "login.email_or_password_invalid", "Either the email address or the password is wrong.") if not user.active: raise APIError(400, "user_is_not_activated", "Your user is not activated.") if user.force_password_change: raise APIError(400, "user_has_to_change_password", "You have to change your password.") token = AuthToken.generate_token() tokenObj = AuthToken(auth_user_id=user.id, token=token) DBSession.add(tokenObj) return { "token": token, "subject": Subject.full_output(user.subject_id), }
def create_achievement(request, *args, **kw): context = request.context if not request.has_perm(perm_global_manage_achievements): raise APIError(403, "forbidden") try: name = request.validated_params.body.get("name", None) player_subjecttype_id = request.validated_params.body.get("player_subjecttype_id") context_subjecttype_id = request.validated_params.body.get("context_subjecttype_id") domain_subject_ids = request.validated_params.body.get("domain_subject_ids") condition = request.validated_params.body.get("condition") evaluation = request.validated_params.body.get("evaluation") evaluation_timezone = request.validated_params.body.get("evaluation_timezone") evaluation_shift = request.validated_params.body.get("evaluation_shift") valid_start = request.validated_params.body.get("valid_start") valid_end = request.validated_params.body.get("valid_end") comparison_type = request.validated_params.body.get("comparison_type") ach = Achievement( name = name, player_subjecttype_id = player_subjecttype_id, context_subjecttype_id = context_subjecttype_id, domain_subject_ids = domain_subject_ids, condition = json.dumps(condition), comparison_type = comparison_type, evaluation = evaluation, evaluation_timezone = evaluation_timezone, evaluation_shift = evaluation_shift, valid_start = valid_start, valid_end = valid_end, ) DBSession.add(ach) DBSession.flush() return r_status.output({ "status": "ok" }) except: raise APIError(500, message="Error creating achievement")
def create_achievement_rewards(achievement): reward = Reward() reward.name = "badge" DBSession.add(reward) DBSession.flush() achievement_reward = AchievementReward() achievement_reward.achievement_id = achievement.id achievement_reward.reward_id = reward.id achievement_reward.value = "https://www.gamification-software.com/img/trophy_{level1}.png" achievement_reward.from_level = achievement.maxlevel DBSession.add(achievement_reward) DBSession.flush() return achievement_reward
def create_variables(): invite_users = Variable(name="invite_users", increase_permission="own") DBSession.add(invite_users) cycling = Variable(name="cycling", increase_permission="own") DBSession.add(cycling) DBSession.flush()
def create_subject( name, type, lat=None, lng=None, timezone=None, language=None, additional_public_data={}, ): type_obj = DBSession.query(SubjectType).filter_by(name=type).first() language_obj = get_or_create_language(name=language) if language else None subject = Subject() subject.name = name subject.lat = lat subject.lng = lng subject.timezone = timezone subject.language = language_obj subject.additional_public_data = additional_public_data subject.type = type_obj DBSession.add(subject) return subject
def change_password(request): try: doc = request.json_body except: raise APIError(400, "invalid_json", "no valid json body") email = doc.get("email") old_password = doc.get("old_password") new_password = doc.get("new_password") if not email or not old_password or not new_password: raise APIError( 400, "change_password.email_and_old_password_and_new_password_required", "You need to send your email, the old password and a new password." ) user = DBSession.query(AuthUser).filter_by(email=email).first() if not user or not user.verify_password(old_password): raise APIError( 401, "change_password.email_or_old_password_invalid", "Either the email address or the old password is wrong.") if not user.active: raise APIError(400, "user_is_not_activated", "Your user is not activated.") if new_password == old_password: raise APIError(400, "change_password.may_not_be_the_same", "The new password may not be the same as the old one.") if not AuthUser.check_password_strength(new_password): raise APIError( 400, "change_password.invalid_new_password", "The new password is too weak. Minimum length is 8 characters.") user.password = new_password user.force_password_change = False DBSession.add(user) token = AuthToken.generate_token() tokenObj = AuthToken(auth_user_id=user.id, token=token) DBSession.add(tokenObj) DBSession.flush() return { "token": token, "subject": Subject.full_output(user.subject_id), }
def __getitem__(self, subject_id): try: from gengine.metadata import DBSession row = DBSession.execute(t_subjects.select().where( t_subjects.c.id == int(subject_id))).fetchone() if row: return SubjectResource(request=self.request, t_name=subject_id, t_parent=self, subject_id=subject_id, subject_row=row) except ValueError: pass except: log.exception("Error creating SubjectResource") raise KeyError()
def main(argv=sys.argv): if len(argv) < 2: usage(argv) config_uri = argv[1] options = parse_vars(argv[2:]) setup_logging(config_uri) settings = get_appsettings(config_uri, options=options) from gengine.base.settings import set_settings set_settings(settings) durl = os.environ.get("DATABASE_URL") # heroku if durl: settings['sqlalchemy.url'] = durl murl = os.environ.get("MEMCACHED_URL") if murl: settings['urlcache_url'] = murl engine = engine_from_config(settings, 'sqlalchemy.') config = Configurator(settings=settings) pyramid_dogpile_cache.includeme(config) from gengine.metadata import ( init_session, init_declarative_base, init_db ) init_session() init_declarative_base() init_db(engine) init_caches() from gengine.metadata import ( DBSession ) sess = DBSession() init_session(override_session=sess, replace=True) import gengine.app.model as m with transaction.manager: mark_changed(sess, transaction.manager, True) messages = sess.execute(m.t_user_messages.select().where(m.t_user_messages.c.has_been_pushed == False)) for msg in messages: m.UserMessage.deliver(msg) sess.flush() sess.commit()
def variables_search_list(request, *args, **kw): context = request.context q = t_variables.select().order_by(t_variables.c.name.asc()) types = DBSession.execute(q).fetchall() if not request.has_perm(perm_global_list_variables): raise APIError(403, "forbidden") ret = { "variables": [{ "id": st["id"], "name": st["name"], "increase_permission": st["increase_permission"], } for st in types] } return r_variablelist.output(ret)