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 get_achievement_level(request): """get all information about an achievement for a specific level""" try: achievement_id = int(request.matchdict.get("achievement_id", None)) level = int(request.matchdict.get("level", None)) except: raise APIError(400, "invalid_input", "invalid input") achievement = Achievement.get_achievement(achievement_id) if not achievement: raise APIError(404, "achievement_not_found", "achievement not found") level_output = Achievement.basic_output(achievement, True, level).get("levels").get( str(level), { "properties": {}, "rewards": {} }) if "goals" in level_output: del level_output["goals"] if "level" in level_output: del level_output["level"] return level_output
def test_get_level(self): user = create_user(timezone="Australia/Sydney", country="Australia", region="xyz", city="Sydney") achievement = create_achievement( achievement_name="invite_users_achievement", achievement_evaluation="weekly") achievement_date = Achievement.get_datetime_for_evaluation_type( evaluation_timezone=achievement.evaluation_timezone, evaluation_type="weekly") create_achievement_user(user, achievement, achievement_date, level=2) achievement.get_level(user.id, achievement["id"], achievement_date) level = achievement.get_level_int(user.id, achievement.id, achievement_date) achievement_date1 = Achievement.get_datetime_for_evaluation_type( evaluation_timezone=achievement.evaluation_timezone, evaluation_type="weekly", dt=achievement_date + datetime.timedelta(7)) achievement.get_level(user.id, achievement["id"], achievement_date1) level1 = achievement.get_level_int(user.id, achievement.id, achievement_date1) # Test for get_level as integer print("level1:", level1) self.assertEqual(level, 2) self.assertEqual(level1, 0)
def create_achievements(): user_type = DBSession.query(SubjectType).filter_by(name="User").first() team_type = DBSession.query(SubjectType).filter_by(name="Team").first() country_type = DBSession.query(SubjectType).filter_by( name="Country").first() invite_users = Achievement( name="invite_users", maxlevel=100, hidden=False, evaluation="immediately", comparison_type="none", player_subjecttype_id=user_type["id"], view_permission="own", condition= """{"term": {"type": "literal", "variable": "invite_users"}}""", goal="3*level", operator="geq") DBSession.add(invite_users) DBSession.flush() cyclist_of_the_month = Achievement( name="cyclist_of_the_month", hidden=False, evaluation="monthly", comparison_type="context_subject", player_subjecttype_id=user_type["id"], view_permission="everyone", condition="""{"term": {"type": "literal", "variable": "cycling"}}""", context_subjecttype_id=country_type.id, operator="geq") cyclist_of_the_month.compared_subjecttypes.append(user_type, team_type) DBSession.add(cyclist_of_the_month) DBSession.flush()
def test_evaluate_achievement_for_yearly_evaluation_case2(self): achievement = create_achievement( achievement_name="invite_users_achievement", achievement_relevance="friends", achievement_maxlevel=3, achievement_evaluation="yearly") user = create_user() achievement_date = Achievement.get_datetime_for_evaluation_type( achievement.evaluation_timezone, achievement["evaluation"]) print(achievement_date) next_year = achievement_date + datetime.timedelta(534) print(next_year) create_achievement_user(user, achievement, achievement_date, level=1) create_variable("invite_users", variable_group="day") create_goals(achievement, goal_goal="3*level", goal_operator="geq", goal_group_by_key=False) clear_all_caches() # Not achieved in first year but in the second year print("Yearly evaluation Case 2") Value.increase_value(variable_name="invite_users", user=user, value=5, key=None, at_datetime=achievement_date) achievement_result = Achievement.evaluate(user, achievement.id, achievement_date) print("achievement result: ", achievement_result) next_date = Achievement.get_datetime_for_evaluation_type( achievement.evaluation_timezone, evaluation_type="yearly", dt=next_year + datetime.timedelta(10)) Value.increase_value(variable_name="invite_users", user=user, value=15, key=None, at_datetime=next_date) achievement_result1 = Achievement.evaluate(user, achievement.id, next_date) print("achievement result1: ", achievement_result1) self.assertEqual(achievement_result["achievement_date"], achievement_date) self.assertEqual(achievement_result1["achievement_date"], next_date) self.assertNotEqual(next_year, next_date) self.assertIn('1', achievement_result["levels_achieved"]) self.assertIn('1', achievement_result1["new_levels"]) self.assertIn('2', achievement_result1["new_levels"]) self.assertIn('3', achievement_result1["new_levels"])
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 progress_user(request): dir_name = os.path.dirname( os.path.abspath(__file__)) + "\\csv_uploads\\file.csv" params = request.GET with open(dir_name) as f: keys = f.readline().rstrip().split(";") achievements = Achievement.get_all_achievements() if request.method == 'POST': achievement_id = request.POST['achievement_id'] user_id = request.POST['user_id'] sort_by = request.POST['sort_by'] user_id_value = request.POST['user_id_value'] res_id_user = User.get_by_id(user_id, user_id_value) leaderboard = Achievement.get_leaderbord_by_user( achievement_id, res_id_user, sort_by) user = leaderboard['leaderboard'][leaderboard['user_position']] user_object = User.get_user(res_id_user) prog = Achievement.evaluate(user_object, achievement_id, achievement_date=None, execute_triggers=True) rewards = [] badges = [] current_level = prog['level'] all_rewards = AchievementReward.get_rewards(achievement_id, 6) all_badges = AchievementReward.get_rewards(achievement_id, 1) for i in range(0, len(all_rewards)): if all_rewards[i]['from_level'] <= current_level: rewards.append(all_rewards[i]['value']) for i in range(0, len(all_badges)): if all_badges[i]['from_level'] <= current_level: badges.append(all_badges[i]['value']) """ levels = prog['levels'] for key,value in levels.items(): if value['level'] <= current_level: for key,value in value['rewards'].items(): if value['name'] == 'badge': badges.append(value['value']) if value['name'] == 'reward': rewards.append(value['value']) """ header_user = [] for key, value in user['user']['additional_public_data'].items(): header_user.append(key) return { 'header_user': header_user, 'user': user, 'achievements': achievements, 'params': params, 'keys': keys, 'badges': badges, 'rewards': rewards, 'current_level': current_level } else: return {'achievements': achievements, 'params': params, 'keys': keys}
def test_evaluate_achievement_for_invite_users(self): achievement = create_achievement( achievement_name="invite_users_achievement", achievement_relevance="friends", achievement_maxlevel=10) user = create_user() 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) update_connection().execute(t_values.delete()) create_variable("invite_users", variable_group="day") Value.increase_value(variable_name="invite_users", user=user, value=1, key=None, at_datetime=achievement_date) create_goals(achievement, goal_goal="1*level", goal_operator="geq", goal_group_by_key=False) clear_all_caches() level = Achievement.evaluate(user, achievement.id, achievement_date).get("level") print("level: ", level) Value.increase_value(variable_name="invite_users", user=user, value=8, key=None, at_datetime=achievement_date) level1 = Achievement.evaluate(user, achievement.id, achievement_date).get("level") print("level1 ", level1) Value.increase_value(variable_name="invite_users", user=user, value=5, key=None, at_datetime=achievement_date) level2 = Achievement.evaluate(user, achievement.id, achievement_date).get("level") print("level2: ", level2) self.assertEqual(level, 1) self.assertEqual(level1, 9) self.assertEqual(level2, 10)
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 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 test_evaluate_achievement_for_weekly_evaluation_case3(self): achievement = create_achievement( achievement_name="invite_users_achievement", achievement_relevance="friends", achievement_maxlevel=3, achievement_evaluation="weekly") user = create_user() achievement_date = Achievement.get_datetime_for_evaluation_type( achievement.evaluation_timezone, achievement["evaluation"]) create_achievement_user(user, achievement, achievement_date, level=1) create_variable("invite_users", variable_group="day") create_goals(achievement, goal_goal="3*level", goal_operator="geq", goal_group_by_key=False) clear_all_caches() # User has not achieved in first week and achieved after few days in a same week print("Weekly evaluation Case 3") Value.increase_value(variable_name="invite_users", user=user, value=5, key=None, at_datetime=achievement_date) achievement_result = Achievement.evaluate(user, achievement.id, achievement_date) print(achievement_result) next_date = Achievement.get_datetime_for_evaluation_type( achievement.evaluation_timezone, evaluation_type="weekly", dt=achievement_date + datetime.timedelta(3)) Value.increase_value(variable_name="invite_users", user=user, value=10, key=None, at_datetime=next_date) achievement_result1 = Achievement.evaluate(user, achievement.id, next_date) print("achievement result1: ", achievement_result1) self.assertEqual(achievement_result["achievement_date"], achievement_date) self.assertEqual(achievement_result1["achievement_date"], next_date) self.assertEqual(achievement_date, next_date) self.assertIn('1', achievement_result["levels_achieved"]) self.assertIn('2', achievement_result1["new_levels"]) self.assertIn('3', achievement_result1["new_levels"])
def increase_data(request): dir_name = os.path.dirname( os.path.abspath(__file__)) + "\\csv_uploads\\file.csv" params = request.GET if request.method == 'POST': if 'upload' in request.POST: dir_name = os.path.dirname( os.path.abspath(__file__)) + "\\csv_uploads\\values_data.csv" content = request.POST['file'].file content = content.read() content = content.decode('utf-8', 'ignore') my_dict = p.get_book(file_type="csv", file_content=content, delimiter=';') my_dict.save_as(dir_name, delimiter=';') with open(dir_name) as f: keys_data = f.readline().rstrip().split(";") params.update({'id': request.POST['achievement_id']}) return render_to_response( 'gengine.app:templates/index/increase_data.jinja2', { 'keys_data': keys_data, 'params': params }, request=request) elif 'value' in request.POST: user_id = request.POST["user_id"] variable = request.POST["variable"] value = request.POST["value"] user_id_value = request.POST["user_id_value"] achievement_id = request.POST['achievement_id'] res_id_user = User.get_by_id(user_id, user_id_value) Value.increaseByValue(variable, res_id_user, value) Achievement.update_user_value(achievement_id, res_id_user) return HTTPFound(request.route_url('increase_data', _query=params)) else: user_id = request.POST["user_id"] variable = request.POST["variable"] achievement_id = params["id"] Value.increase(achievement_id, variable, user_id, dir_name) return HTTPFound(request.route_url('leaderboard', _query=params)) else: with open(dir_name) as f: keys = f.readline().rstrip().split(";") achievements = Achievement.get_all_achievements() return {'achievements': achievements, 'params': params, 'keys': keys}
def tables(request): params = request.GET if request.method == 'POST': params.update({'id': request.POST['achievement_id']}) return HTTPFound(request.route_url('leaderboard', _query=params)) else: achievements = Achievement.get_all_achievements() return {'achievements': achievements, 'params': params}
def test_get_rewards(self): achievement = create_achievement(achievement_maxlevel=3) create_achievement_rewards(achievement) clear_all_caches() rewardlist1 = Achievement.get_rewards(achievement.id, 1) print("rewardlist1", rewardlist1) rewardlist2 = Achievement.get_rewards(achievement.id, 5) print("rewardlist2", rewardlist2) rewardlist3 = Achievement.get_rewards(achievement.id, 3) print("rewardlist3", rewardlist3) self.assertEqual(rewardlist1, []) self.assertEqual(rewardlist2, []) self.assertNotEqual(rewardlist3, [])
def get_leaderboard_achievement(request): try: achievement_id = int(request.matchdict["achievement_id"]) except: raise APIError(400, "illegal_achievement_id", "no valid achievement_id given") return Achievement.get_leaderbord_by_achievement(achievement_id)
def badges(request): params = request.GET achievements = Achievement.get_all_achievements() if request.method == 'POST': if 'achievement_id' in request.POST: achievement_id = request.POST['achievement_id'] achievement = Achievement.get_achievement(achievement_id) rewards = AchievementReward.get_rewards(achievement_id, 6) badges = AchievementReward.get_rewards(achievement_id, 1) nb_levels = (int)(achievement["maxlevel"] / 5) if not badges: AchievementReward.create_achievement_rewards_badges( achievement_id, "badge1.PNG", 1) AchievementReward.create_achievement_rewards_badges( achievement_id, "badge2.PNG", nb_levels) AchievementReward.create_achievement_rewards_badges( achievement_id, "badge3.PNG", nb_levels * 2) AchievementReward.create_achievement_rewards_badges( achievement_id, "badge4.PNG", nb_levels * 3) AchievementReward.create_achievement_rewards_badges( achievement_id, "badge5.PNG", nb_levels * 4) AchievementReward.create_achievement_rewards_badges( achievement_id, "badge6.PNG", nb_levels * 5) achievement_id = request.POST['achievement_id'] return { 'selected_achievement': achievement_id, 'achievements': achievements, 'params': params, 'levels': nb_levels, 'rewards': rewards } else: reward_name = request.POST['reward_name'] reward_level = request.POST['reward_level'] selected_achievement = request.POST['selected_achievement'] AchievementReward.create_achievement_rewards( selected_achievement, reward_name, reward_level) return {'achievements': achievements, 'params': params} else: return {'achievements': achievements, 'params': params}
def ea(achievement, achievement_date, context_subject_id, execute_triggers): try: return Achievement.evaluate(achievements_for_subject, achievement["id"], achievement_date, execute_triggers=execute_triggers, context_subject_id=context_subject_id) except FormularEvaluationException as e: return { "error": "Cannot evaluate formular: " + e.message, "id": achievement["id"] }
def ev(user, dt, context_subject): return Achievement.evaluate( compared_subject=user, achievement_id=cyclist_of_the_month_achievement.id, achievement_date=AchievementDate.compute( evaluation_timezone=cyclist_of_the_month_achievement. evaluation_timezone, evaluation_type=cyclist_of_the_month_achievement. evaluation, evaluation_shift=cyclist_of_the_month_achievement. evaluation_shift, context_datetime=dt), execute_triggers=False, context_subject_id=context_subject.id)
def ea(achievement, achievement_date, execute_triggers): try: return Achievement.evaluate(achievements_for_user, achievement["id"], achievement_date, execute_triggers=execute_triggers) except FormularEvaluationException as e: return { "error": "Cannot evaluate formular: " + e.message, "id": achievement["id"] } except Exception as e: tb = traceback.format_exc() return {"error": tb, "id": achievement["id"]}
def users_cities(request): achievement_id = int(request.matchdict["achievement_id"]) cities = User.sort("City") res_cities = [] res_cities = np.asarray(cities) result = [] for i in range(len(res_cities)): relevance = {'type': 'City', 'value': res_cities[i][0]} result.append({ 'City': res_cities[i][0], 'Leaderboard': Achievement.get_leaderbord_by_relevance(achievement_id, relevance) }) return result
def test_get_achievements_by_location_and_date(self): user = create_user() achievement1 = create_achievement( achievement_name="invite_users_achievement") achievement2 = create_achievement( achievement_name="participate_achievement") create_goals(achievement1) create_goals(achievement2) achievement_today = Achievement.get_achievements_by_user_for_today( user) print("achievement_today") print(achievement_today) self.assertEqual(achievement_today[0]["name"], "invite_users_achievement") self.assertEqual(len(achievement_today), 2)
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 get_leaderboard_user(request): try: achievement_id = int(request.matchdict["achievement_id"]) except: raise APIError(400, "illegal_achievement_id", "no valid achievement_id given") try: user_id = int(request.matchdict["user_id"]) except: raise APIError(400, "illegal_user_id", "no valid user_id given") relevance = 'global' if len(request.matchdict["relevance"]) > 0: relevance = request.matchdict["relevance"] #relevance = request.matchdict["relevance"] #print('relevance',relevance) return Achievement.get_leaderbord_by_user(achievement_id, user_id, relevance)
def test_simple_invite_users(self): create_subjecttypes() create_subjects() create_variables() create_achievements() klaus = DBSession.query(Subject).filter_by(name="Klaus").first() invite_users_achievement = DBSession.query(Achievement).filter_by( name="invite_users").first() # First step: increase by 1, level 1 will not be achieved Value.increase_value(variable_name="invite_users", subject_id=klaus.id, value=1, key=None, at_datetime=default_dt()) evaluation = Achievement.evaluate( compared_subject=klaus, achievement_id=invite_users_achievement.id, achievement_date=AchievementDate.compute( evaluation_timezone=invite_users_achievement. evaluation_timezone, evaluation_type=invite_users_achievement.evaluation, evaluation_shift=invite_users_achievement.evaluation_shift, context_datetime=default_dt()), context_subject_id=None, execute_triggers=False) self.assertEqual(evaluation["level"], 0) self.assertEqual(evaluation["progress"], 1.0) # Now increase by 3, level 1 will achieved, progress 4.0 Value.increase_value(variable_name="invite_users", subject_id=klaus.id, value=3, key=None, at_datetime=default_dt()) evaluation = Achievement.evaluate( compared_subject=klaus, achievement_id=invite_users_achievement.id, achievement_date=AchievementDate.compute( evaluation_timezone=invite_users_achievement. evaluation_timezone, evaluation_type=invite_users_achievement.evaluation, evaluation_shift=invite_users_achievement.evaluation_shift, context_datetime=default_dt()), context_subject_id=None, execute_triggers=False) self.assertEqual(evaluation["level"], 1) self.assertEqual(evaluation["progress"], 4.0) # Now lets test the maximum level (100) Value.increase_value(variable_name="invite_users", subject_id=klaus.id, value=300, key=None, at_datetime=default_dt()) evaluation = Achievement.evaluate( compared_subject=klaus, achievement_id=invite_users_achievement.id, achievement_date=AchievementDate.compute( evaluation_timezone=invite_users_achievement. evaluation_timezone, evaluation_type=invite_users_achievement.evaluation, evaluation_shift=invite_users_achievement.evaluation_shift, context_datetime=default_dt()), context_subject_id=None, execute_triggers=False) self.assertEqual(evaluation["level"], 100) self.assertEqual(evaluation["progress"], 304.0)
def populate_demo(DBSession): from gengine.app.model import ( Achievement, AchievementCategory, Variable, Subject, Language, TranslationVariable, Translation, Reward, AchievementProperty, AchievementAchievementProperty, AchievementReward, AuthUser, AuthRole, AuthRolePermission, SubjectType, t_auth_roles_permissions ) def add_translation_variable(name): t = TranslationVariable(name=name) DBSession.add(t) return t def add_translation(variable, lang, text): tr = Translation(translationvariable=variable, text=text, language=lang) DBSession.add(tr) return tr with transaction.manager: subjecttype_country = SubjectType(name="Country") DBSession.add(subjecttype_country) subjecttype_region = SubjectType(name="Region") subjecttype_region.part_of_types.append(subjecttype_country) DBSession.add(subjecttype_region) subjecttype_city = SubjectType(name="City") subjecttype_city.part_of_types.append(subjecttype_region) DBSession.add(subjecttype_city) subjecttype_position = SubjectType(name="Position") DBSession.add(subjecttype_position) subjecttype_team = SubjectType(name="Team") DBSession.add(subjecttype_team) subjecttype_user = DBSession.query(SubjectType).filter_by(name="User").first() if not subjecttype_user: subjecttype_user = SubjectType(name="User") DBSession.add(subjecttype_user) subjecttype_user.part_of_types.append(subjecttype_city) subjecttype_user.part_of_types.append(subjecttype_team) subjecttype_user.part_of_types.append(subjecttype_position) DBSession.add(subjecttype_user) subject_germany = Subject(type=subjecttype_country, name="Germany") DBSession.add(subject_germany) subject_france = Subject(type=subjecttype_country, name="France") DBSession.add(subject_france) subject_india = Subject(type=subjecttype_country, name="India") DBSession.add(subject_india) subject_germany_north = Subject(type=subjecttype_region, name="Germany-North") DBSession.add(subject_germany_north) subject_germany_west = Subject(type=subjecttype_region, name="Germany-West") DBSession.add(subject_germany_west) subject_germany_east = Subject(type=subjecttype_region, name="Germany-East") DBSession.add(subject_germany_east) subject_germany_south = Subject(type=subjecttype_region, name="Germany-South") DBSession.add(subject_germany_south) subject_paderborn = Subject(type=subjecttype_city, name="Paderborn") DBSession.add(subject_paderborn) subject_bielefeld = Subject(type=subjecttype_city, name="Bielefeld") DBSession.add(subject_bielefeld) subject_detmold = Subject(type=subjecttype_city, name="Detmold") DBSession.add(subject_detmold) subject_berlin = Subject(type=subjecttype_city, name="Berlin") DBSession.add(subject_berlin) subject_sales = Subject(type=subjecttype_team, name="Sales") DBSession.add(subject_sales) subject_tech = Subject(type=subjecttype_team, name="Tech") DBSession.add(subject_tech) subject_junior_developer = Subject(type=subjecttype_position, name="Junior Developer") DBSession.add(subject_junior_developer) subject_senior_developer = Subject(type=subjecttype_position, name="Senior Developer") DBSession.add(subject_senior_developer) subject_manager = Subject(type=subjecttype_position, name="Manager") DBSession.add(subject_manager) subject_promoter = Subject(type=subjecttype_position, name="Promoter") DBSession.add(subject_promoter) DBSession.flush() lang_de = Language(name="de") lang_en = Language(name="en") DBSession.add(lang_de) DBSession.add(lang_en) var_invited_users = Variable(name="invite_users") DBSession.add(var_invited_users) var_invited_users = Variable(name="participate", group="none") DBSession.add(var_invited_users) achievementcategory_community = AchievementCategory(name="community") DBSession.add(achievementcategory_community) achievement_invite = Achievement(name='invite_users', evaluation="immediately", maxtimes=20, achievementcategory=achievementcategory_community, condition='{"term": {"type": "literal", "variable": "invite_users"}}', goal="5*level", operator="geq", player_subjecttype=subjecttype_user ) DBSession.add(achievement_invite) achievementcategory_sports = AchievementCategory(name="sports") DBSession.add(achievementcategory_sports) achievement_fittest = Achievement(name='fittest', relevance="friends", maxlevel=100, achievementcategory=achievementcategory_sports, condition='{"term": {"key": ["5","7","9"], "type": "literal", "key_operator": "IN", "variable": "participate"}}', evaluation="weekly", goal="5*level", player_subjecttype=subjecttype_user ) DBSession.add(achievement_fittest) property_name = AchievementProperty(name='name') DBSession.add(property_name) property_xp = AchievementProperty(name='xp') DBSession.add(property_xp) property_icon = AchievementProperty(name='icon') DBSession.add(property_icon) reward_badge = Reward(name='badge', rewarded_subjecttype=subjecttype_user) DBSession.add(reward_badge) reward_image = Reward(name='backgroud_image', rewarded_subjecttype=subjecttype_user) DBSession.add(reward_image) transvar_invite_name = add_translation_variable(name="invite_users_achievement_name") add_translation(transvar_invite_name, lang_en, 'Invite ${5*level} Users') add_translation(transvar_invite_name, lang_de, 'Lade ${5*level} Freunde ein') DBSession.add(AchievementAchievementProperty(achievement=achievement_invite, property=property_name, value_translation=transvar_invite_name)) DBSession.add(AchievementAchievementProperty(achievement=achievement_invite, property=property_xp, value='${100 * level}')) DBSession.add(AchievementAchievementProperty(achievement=achievement_invite, property=property_icon, value="https://www.gamification-software.com/img/running.png")) DBSession.add(AchievementReward(achievement=achievement_invite, reward=reward_badge, value="https://www.gamification-software.com/img/trophy.png", from_level=5)) DBSession.add(AchievementReward(achievement=achievement_invite, reward=reward_image, value="https://www.gamification-software.com/img/video-controller-336657_1920.jpg", from_level=5)) transvar_fittest_name = add_translation_variable(name="fittest_achievement_name") add_translation(transvar_fittest_name, lang_en, 'Do the most sport activities among your friends') add_translation(transvar_fittest_name, lang_de, 'Mache unter deinen Freunden am meisten Sportaktivitäten') DBSession.add(AchievementAchievementProperty(achievement=achievement_fittest, property=property_name, value_translation=transvar_fittest_name)) DBSession.add(AchievementAchievementProperty(achievement=achievement_fittest, property=property_xp, value='${50 + (200 * level)}')) DBSession.add(AchievementAchievementProperty(achievement=achievement_fittest, property=property_icon, value="https://www.gamification-software.com/img/colorwheel.png")) DBSession.add(AchievementReward(achievement=achievement_fittest, reward=reward_badge, value="https://www.gamification-software.com/img/easel.png", from_level=1)) DBSession.add(AchievementReward(achievement=achievement_fittest, reward=reward_image, value="https://www.gamification-software.com/img/game-characters-622654.jpg", from_level=1)) DBSession.flush() user1 = Subject(lat=10, lng=50, timezone="Europe/Berlin", name="Fritz", type=subjecttype_user) user2 = Subject(lat=10, lng=50, timezone="US/Eastern", name="Ludwig", type=subjecttype_user) user3 = Subject(lat=10, lng=50, name="Helene", type=subjecttype_user) user1.friends.append(user2) user1.friends.append(user3) user2.friends.append(user1) user2.friends.append(user3) user3.friends.append(user1) user3.friends.append(user2) user1.part_of_subjects.append(subject_bielefeld) user1.part_of_subjects.append(subject_sales) user1.part_of_subjects.append(subject_manager) user2.part_of_subjects.append(subject_bielefeld) user2.part_of_subjects.append(subject_sales) user2.part_of_subjects.append(subject_promoter) user3.part_of_subjects.append(subject_paderborn) user3.part_of_subjects.append(subject_sales) user3.part_of_subjects.append(subject_promoter) DBSession.add(user2) DBSession.add(user3) DBSession.flush() try: auth_user = DBSession.query(AuthUser).filter_by(email="*****@*****.**").first() if not auth_user: auth_user = AuthUser(subject=user1, email="*****@*****.**", password="******", active=True) DBSession.add(auth_user) auth_role = DBSession.query(AuthRole).filter_by(name="Global Admin").first() if not auth_role: auth_role = AuthRole(name="Global Admin") DBSession.add(auth_role) DBSession.flush() for perm in yield_all_perms(): if not exists_by_expr(t_auth_roles_permissions, and_( t_auth_roles_permissions.c.auth_role_id == auth_role.id, t_auth_roles_permissions.c.name == perm[0] )): DBSession.add(AuthRolePermission(role=auth_role, name=perm[0])) auth_user.roles.append(auth_role) DBSession.add(auth_user) except ImportError as e: print("[auth] feature not installed - not importing auth demo data")
def test_evaluate_goal(self): user = create_user() create_variable(variable_name="invite_users", variable_group="day") Value.increase_value(variable_name="invite_users", user=user, value=6, key=None) Value.increase_value(variable_name="invite_users", user=user, value=7, key=None) create_variable(variable_name="participate", variable_group="day") Value.increase_value(variable_name="participate", user=user, value=6, key="5") Value.increase_value(variable_name="participate", user=user, value=3, key="7") Value.increase_value(variable_name="participate", user=user, value=5, key="7") # Goal Participate with group_by = False achievement = create_achievement( achievement_name="participate_achievement") goal = create_goals(achievement, goal_group_by_key=False, goal_goal="3*level") achievement_date = Achievement.get_datetime_for_evaluation_type( User.get_user(user.id)["timezone"], achievement["evaluation"]) evaluation_result = Goal.evaluate(goal, achievement, achievement_date, user, level=4, goal_eval_cache_before=False, execute_triggers=True) print(evaluation_result) # True cases self.assertGreaterEqual(evaluation_result["value"], 12) self.assertEqual(evaluation_result["achieved"], True) # Goal Participate with group_by = True goal2 = create_goals(achievement, goal_group_by_key=True, goal_goal="3*level") evaluation_result2 = Goal.evaluate(goal2, achievement, achievement_date, user, level=4, goal_eval_cache_before=False, execute_triggers=True) print(evaluation_result2) self.assertLessEqual(evaluation_result2["value"], 12) self.assertEqual(evaluation_result2["achieved"], False) # Goal invite_users achievement1 = create_achievement( achievement_name="invite_users_achievement") goal1 = create_goals(achievement1, goal_goal="4*level") achievement_date1 = Achievement.get_datetime_for_evaluation_type( User.get_user(user.id)["timezone"], achievement1["evaluation"]) evaluation_result1 = Goal.evaluate(goal1, achievement1, achievement_date1, user, level=2, goal_eval_cache_before=False, execute_triggers=True) print(evaluation_result1) self.assertGreaterEqual(evaluation_result1["value"], 8) self.assertEqual(evaluation_result1["achieved"], True)
def test_compute_progress(self): user = create_user() create_variable(variable_name="invite_users", variable_group="day") Value.increase_value(variable_name="invite_users", user=user, value=6, key=None) Value.increase_value(variable_name="invite_users", user=user, value=7, key=None) create_variable(variable_name="participate", variable_group="day") Value.increase_value(variable_name="participate", user=user, value=2, key="5") Value.increase_value(variable_name="participate", user=user, value=3, key="7") Value.increase_value(variable_name="participate", user=user, value=5, key="7") achievement = create_achievement( achievement_name="invite_users_achievement") goal = create_goals(achievement) # goal is for invite_users, its group_by_key is false, progress is sum of all the values achievement_date = Achievement.get_datetime_for_evaluation_type( User.get_user(user.id)["timezone"], achievement["evaluation"]) users_progress_goal = Goal.compute_progress( goal=goal, achievement=achievement, user=user, evaluation_date=achievement_date) goal_evaluation = { e["user_id"]: e["value"] for e in users_progress_goal } print(goal_evaluation) self.assertLessEqual(goal_evaluation.get(user.id), 13) # For goal1, since its group_by_key is True, it'll add the values of the same key achievement1 = create_achievement( achievement_name="participate_achievement") goal1 = create_goals(achievement1) achievement_date1 = Achievement.get_datetime_for_evaluation_type( User.get_user(user.id)["timezone"], achievement1["evaluation"]) users_progress_goal1 = Goal.compute_progress( goal=goal1, achievement=achievement1, user=user, evaluation_date=achievement_date1) goal_evaluation1 = { e["user_id"]: e["value"] for e in users_progress_goal1 } print(goal_evaluation1) self.assertLess(goal_evaluation1.get(user.id), 10) # Check with group_by_key for goals participate = False goal2 = create_goals(achievement1, goal_group_by_key=False) users_progress_goal1 = Goal.compute_progress( goal=goal2, achievement=achievement1, user=user, evaluation_date=achievement_date1) goal_evaluation2 = { e["user_id"]: e["value"] for e in users_progress_goal1 } print(goal_evaluation2) self.assertLessEqual(goal_evaluation2.get(user.id), 10)
def test_get_leaderboard(self): achievement = create_achievement( achievement_name="invite_users_achievement") goals = create_goals(achievement) # Create multiple users for a goal user1 = create_user() user2 = create_user(lat=85.59, lng=65.75, country="USA", region="Lethal crosside", city="New York", timezone="US/Eastern", language="en", additional_public_data={ "first_name": "Michael", "last_name": "Clarke" }) # Create Third user user3 = create_user(lat=12.1, lng=12.2, country="RO", region="Transylvania", city="Cluj-Napoca", timezone="Europe/Bucharest", language="en", additional_public_data={ "first_name": "Rudolf", "last_name": "Red Nose" }, friends=[1, 2]) # Create Fourth user user4 = create_user(lat=25.56, lng=15.89, country="AU", region="Sydney", city="New South Wales", timezone="Australia/Sydney", language="en", additional_public_data={ "first_name": "Steve", "last_name": "Waugh" }, friends=[3]) achievement_date_for_user1 = Achievement.get_datetime_for_evaluation_type( User.get_user(user1.id)["timezone"], achievement["evaluation"]) achievement_date_for_user2 = Achievement.get_datetime_for_evaluation_type( User.get_user(user2.id)["timezone"], achievement["evaluation"]) achievement_date_for_user3 = Achievement.get_datetime_for_evaluation_type( User.get_user(user3.id)["timezone"], achievement["evaluation"]) achievement_date_for_user4 = Achievement.get_datetime_for_evaluation_type( User.get_user(user4.id)["timezone"], achievement["evaluation"]) print(achievement_date_for_user4) create_goal_evaluation_cache( goal_id=goals.id, gec_achievement_date=achievement_date_for_user1, gec_user_id=user1.id, gec_value=22.00, gec_achieved=True) create_goal_evaluation_cache( goal_id=goals.id, gec_achievement_date=achievement_date_for_user2, gec_user_id=user2.id, gec_value=8.00, gec_achieved=True) create_goal_evaluation_cache( goal_id=goals.id, gec_achievement_date=achievement_date_for_user3, gec_user_id=user3.id, gec_value=15.00, gec_achieved=True) # Test for finding leaderboard in case where goal has been evaluated for all given users # First get list of friends (user_ids) of given user user_ids = Achievement.get_relevant_users_by_achievement_and_user( achievement, user3.id) # Get leaderboard positions = Goal.get_leaderboard(goals, achievement_date_for_user3, user_ids) print(positions) self.assertEqual(positions[0]["value"], 22.00) self.assertEqual(positions[1]["value"], 15.00) self.assertEqual(positions[2]["value"], 8.00) # Test for Goal is not evaluated for few user_ids create_variable(variable_name="invite_users", variable_group="day") Value.increase_value(variable_name="invite_users", user=user4, value=6, key=None) Value.increase_value(variable_name="invite_users", user=user4, value=9, key=None) user_ids = Achievement.get_relevant_users_by_achievement_and_user( achievement, user4.id) positions = Goal.get_leaderboard(goals, achievement_date_for_user4, user_ids) print(positions) self.assertEqual(positions[0]["value"], 15.00)
def _get_progress(achievements_for_subject, requesting_subject, achievement_id=None, achievement_history=None): achievements = Achievement.get_achievements_by_subject_for_today( achievements_for_subject) if achievement_id: achievements = [ x for x in achievements if int(x["id"]) == int(achievement_id) ] def ea(achievement, achievement_date, context_subject_id, execute_triggers): try: return Achievement.evaluate(achievements_for_subject, achievement["id"], achievement_date, execute_triggers=execute_triggers, context_subject_id=context_subject_id) except FormularEvaluationException as e: return { "error": "Cannot evaluate formular: " + e.message, "id": achievement["id"] } #except Exception as e: # tb = traceback.format_exc() # return { "error": tb, "id" : achievement["id"] } check = lambda x: x != None and not "error" in x and (x["hidden"] == False or x["level"] > 0) def may_view(achievement, requesting_subject): if not asbool(get_settings().get("enable_user_authentication", False)): return True if achievement["view_permission"] == "everyone": return True if achievement["view_permission"] == "own" and achievements_for_subject[ "id"] == requesting_subject["id"]: return True return False evaluatelist = [] now = datetime.datetime.now( pytz.timezone(achievements_for_subject["timezone"])) for achievement in achievements: if may_view(achievement, requesting_subject): achievement_dates = set() d = max(achievement["created_at"], achievements_for_subject["created_at"]).replace( tzinfo=pytz.utc) dr = AchievementDate.compute( evaluation_timezone=achievement["evaluation_timezone"], evaluation_type=achievement["evaluation"], context_datetime=d, evaluation_shift=achievement["evaluation_shift"], ) achievement_dates.add(dr) if dr != None: while d <= now: if achievement["evaluation"] == "yearly": d += relativedelta.relativedelta(years=1) elif achievement["evaluation"] == "monthly": d += relativedelta.relativedelta(months=1) elif achievement["evaluation"] == "weekly": d += relativedelta.relativedelta(weeks=1) elif achievement["evaluation"] == "daily": d += relativedelta.relativedelta(days=1) else: break # should not happen dr = AchievementDate.compute( evaluation_timezone=achievement["evaluation_timezone"], evaluation_type=achievement["evaluation"], context_datetime=d, evaluation_shift=achievement["evaluation_shift"], ) if dr.from_date <= now: achievement_dates.add(dr) i = 0 for achievement_date in reversed(sorted(achievement_dates)): # We execute the goal triggers only for the newest and previous period, not for any periods longer ago # (To not send messages for very old things....) relevant_context_ids = Achievement.get_relevant_contexts( subject_id=achievements_for_subject["id"], achievement=achievement, from_date=achievement_date.from_date if achievement_date else None, to_date=achievement_date.to_date if achievement_date else None, whole_time_required=False) for context_subject_id in relevant_context_ids: evaluatelist.append( ea(achievement, achievement_date, context_subject_id, execute_triggers=(i == 0 or i == 1 or achievement_date == None))) i += 1 if achievement_history is not None and i >= achievement_history: # achievement_history restricts the number of lookback items break ret = { "achievements": [x for x in evaluatelist if check(x)], "achievement_errors": [x for x in evaluatelist if x != None and "error" in x] } return ret
def test_friends_leaderboard(self): user1 = create_user() # Create Second user user2 = create_user( lat=85.59, lng=65.75, #country="DE", #region="Roland", #city="New York", timezone="US/Eastern", language="en", additional_public_data={ "first_name": "Michael", "last_name": "Clarke" }) # Create Third user user3 = create_user( lat=12.1, lng=12.2, #country="RO", #region="Transylvania", #city="Cluj-Napoca", timezone="Europe/Bucharest", language="en", additional_public_data={ "first_name": "Rudolf", "last_name": "Red Nose" }, friends=[1, 2]) # Create Fourth user user4 = create_user( lat=25.56, lng=15.89, #country="AU", #region="Sydney", #city="New South Wales", timezone="Australia/Sydney", language="en", additional_public_data={ "first_name": "Steve", "last_name": "Waugh" }, friends=[3]) achievement = create_achievement( achievement_name="invite_users_achievement", achievement_relevance="friends", achievement_maxlevel=3, achievement_evaluation="weekly") print(achievement.evaluation_timezone) achievement_date1 = Achievement.get_datetime_for_evaluation_type( achievement.evaluation_timezone, achievement.evaluation) print("Achievement date for first user:"******"invite_users", variable_group="day") create_goals(achievement, goal_goal=None, goal_operator="geq", goal_group_by_key=False) Value.increase_value(variable_name="invite_users", user=user1, value=12, key=None, at_datetime=achievement_date1) Value.increase_value(variable_name="invite_users", user=user2, value=2, key=None, at_datetime=achievement_date1) Value.increase_value(variable_name="invite_users", user=user3, value=11, key=None, at_datetime=achievement_date1) Value.increase_value(variable_name="invite_users", user=user4, value=6, key=None, at_datetime=achievement_date1) clear_all_caches() print("test for multiple users") # Evaluate achievement for friends of user 3 achievement1 = Achievement.evaluate(user3, achievement.id, achievement_date1) print(achievement1["goals"][1]["leaderboard"]) # user 3 has to friends: user 1 and user 2 self.assertEqual( user1["id"], achievement1["goals"][1]["leaderboard"][0]["user"]["id"]) self.assertEqual( user3["id"], achievement1["goals"][1]["leaderboard"][1]["user"]["id"]) self.assertEqual( user2["id"], achievement1["goals"][1]["leaderboard"][2]["user"]["id"]) self.assertEqual(12.0, achievement1["goals"][1]["leaderboard"][0]["value"]) self.assertEqual(11.0, achievement1["goals"][1]["leaderboard"][1]["value"]) self.assertEqual(2.0, achievement1["goals"][1]["leaderboard"][2]["value"])