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 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 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 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_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 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 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 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"])
def test_multiple_goals_of_same_achievement(self):
user = create_user()
achievement = create_achievement(
achievement_name="participate_achievement", achievement_maxlevel=3)
create_achievement_rewards(achievement=achievement)
achievement_date = Achievement.get_datetime_for_evaluation_type(
achievement.evaluation_timezone, achievement.evaluation)
create_goals(
achievement=achievement,
goal_condition=
"""{"term": {"key": ["5","7"], "type": "literal", "key_operator": "IN", "variable": "participate_seminar"}}""",
goal_group_by_key=False,
goal_operator="geq",
goal_goal="2*level",
goal_name="goal_participate_seminar")
create_goals(
achievement=achievement,
goal_condition=
"""{"term": {"type": "literal", "variable": "participate_talk"}}""",
goal_group_by_key=False,
goal_operator="geq",
goal_goal="1*level",
goal_name="goal_participate_talk")
clear_all_caches()
create_achievement_user(user=user,
achievement=achievement,
achievement_date=achievement_date,
level=1)
variable1 = create_variable("participate_seminar", variable_group=None)
variable2 = create_variable("participate_talk", variable_group=None)
Value.increase_value(variable1.name,
user,
"2",
"5",
at_datetime=achievement_date)
Value.increase_value(variable1.name,
user,
"3",
"7",
at_datetime=achievement_date)
Value.increase_value(variable2.name,
user,
"3",
key=None,
at_datetime=achievement_date)
result = Achievement.evaluate(user, achievement.id, achievement_date)
print("multiple_goals_of_same_achievement:", result)
Value.increase_value(variable1.name,
user,
"2",
"7",
at_datetime=achievement_date)
result1 = Achievement.evaluate(user, achievement.id, achievement_date)
print(result1)
Value.increase_value(variable2.name,
user,
"2",
key=None,
at_datetime=achievement_date)
result2 = Achievement.evaluate(user, achievement.id, achievement_date)
print(result2)
self.assertEqual(len(result["levels"]["3"]["rewards"]), 1)
self.assertEqual(result["levels"]["1"]["goals"]["1"]["goal_goal"], 2)
self.assertEqual(result["levels"]["3"]["goals"]["2"]["goal_goal"], 3)
self.assertEqual(result1["levels"]["2"]["goals"]["1"]["goal_goal"], 4)
self.assertEqual(result1["levels"]["3"]["goals"]["2"]["goal_goal"], 3)
self.assertEqual(result2["levels"]["2"]["goals"]["1"]["goal_goal"], 4)
self.assertEqual(result2["levels"]["3"]["goals"]["2"]["goal_goal"], 3)
def test_evaluate_achievement_for_monthly_evaluation_case2(self):
achievement = create_achievement(
achievement_name="invite_users_achievement",
achievement_relevance="friends",
achievement_maxlevel=3,
achievement_evaluation="monthly")
user = create_user()
achievement_date = Achievement.get_datetime_for_evaluation_type(
achievement.evaluation_timezone, achievement["evaluation"])
print(achievement_date)
next_month = achievement_date + datetime.timedelta(31)
print(next_month)
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 this month but in the next month
print("Monthly 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="monthly",
dt=next_month + datetime.timedelta(days=10))
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.assertGreaterEqual(
next_month,
next_date) # next_month can be the 1st, 2nd, 3rd of 4th (February)
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"])
