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"])
