def delete_subject(request):
"""delete a subject completely"""
subject_id = int(request.matchdict["subject_id"])
if asbool(get_settings().get("enable_user_authentication", False)):
# ensure that the subject exists and we have the permission to update it
may_delete = request.has_perm(
perm_global_delete_subject) or request.has_perm(
perm_own_delete_subject) and request.subject.id == subject_id
if not may_delete:
raise APIError(403, "forbidden",
"You may not delete this subject.")
Subject.delete_subject(subject_id)
return {"status": "OK"}
def get_progress(request):
"""get all relevant data concerning the subject's progress"""
try:
subject_id = int(request.matchdict["subject_id"])
except:
raise APIError(400, "illegal_subject_id", "no valid subject_id given")
subject = Subject.get_subject(subject_id)
if not subject:
raise APIError(404, "subject_not_found", "subject not found")
try:
achievement_id = int(request.GET["achievement_id"])
except:
achievement_id = None
try:
achievement_history = int(request.GET["achievement_history"])
except:
achievement_history = 2
output = _get_progress(achievements_for_subject=subject,
requesting_subject=request.subject,
achievement_id=achievement_id,
achievement_history=achievement_history)
output = copy.deepcopy(output)
for i in range(len(output["achievements"])):
if "new_levels" in output["achievements"][i]:
del output["achievements"][i]["new_levels"]
return output
def test_ancestors_descendants(self):
create_subjecttypes()
create_subjects()
klaus = DBSession.query(Subject).filter_by(name="Klaus").first()
clara = DBSession.query(Subject).filter_by(name="Clara").first()
liam = DBSession.query(Subject).filter_by(name="Liam").first()
bielefeld = DBSession.query(Subject).filter_by(
name="Bielefeld").first()
paderborn = DBSession.query(Subject).filter_by(
name="Paderborn").first()
germany = DBSession.query(Subject).filter_by(name="Germany").first()
france = DBSession.query(Subject).filter_by(name="France").first()
dev_team_bielefeld = DBSession.query(Subject).filter_by(
name="Developer Team Bielefeld").first()
junior_developer = DBSession.query(Subject).filter_by(
name="Junior Developer").first()
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()
klaus_ancestors = Subject.get_ancestor_subjects(
subject_id=klaus.id,
of_type_id=None,
from_date=default_dt(),
to_date=default_dt(),
whole_time_required=False)
self.assertIn(bielefeld.id, klaus_ancestors.keys())
self.assertIn(germany.id, klaus_ancestors.keys())
self.assertIn(dev_team_bielefeld.id, klaus_ancestors.keys())
self.assertIn(junior_developer.id, klaus_ancestors.keys())
self.assertNotIn(france.id, klaus_ancestors.keys())
germany_descendants = Subject.get_descendent_subjects(
subject_id=germany.id,
of_type_id=team_type.id,
from_date=default_dt(),
to_date=default_dt(),
whole_time_required=False)
self.assertIn(dev_team_bielefeld.id, germany_descendants.keys())
self.assertNotIn(klaus.id, germany_descendants.keys())
def change_password(request):
try:
doc = request.json_body
except:
raise APIError(400, "invalid_json", "no valid json body")
email = doc.get("email")
old_password = doc.get("old_password")
new_password = doc.get("new_password")
if not email or not old_password or not new_password:
raise APIError(
400,
"change_password.email_and_old_password_and_new_password_required",
"You need to send your email, the old password and a new password."
)
user = DBSession.query(AuthUser).filter_by(email=email).first()
if not user or not user.verify_password(old_password):
raise APIError(
401, "change_password.email_or_old_password_invalid",
"Either the email address or the old password is wrong.")
if not user.active:
raise APIError(400, "user_is_not_activated",
"Your user is not activated.")
if new_password == old_password:
raise APIError(400, "change_password.may_not_be_the_same",
"The new password may not be the same as the old one.")
if not AuthUser.check_password_strength(new_password):
raise APIError(
400, "change_password.invalid_new_password",
"The new password is too weak. Minimum length is 8 characters.")
user.password = new_password
user.force_password_change = False
DBSession.add(user)
token = AuthToken.generate_token()
tokenObj = AuthToken(auth_user_id=user.id, token=token)
DBSession.add(tokenObj)
DBSession.flush()
return {
"token": token,
"subject": Subject.full_output(user.subject_id),
}
def create_user(DBSession, user, password):
from gengine.app.model import (AuthUser, Subject, AuthRole,
AuthRolePermission, SubjectType,
t_auth_roles_permissions)
with transaction.manager:
subjecttype_user = DBSession.query(SubjectType).filter_by(
name="User").first()
if not subjecttype_user:
subjecttype_user = SubjectType(name="User")
DBSession.add(subjecttype_user)
existing = DBSession.query(AuthUser).filter_by(email=user).first()
DBSession.flush()
if not existing:
user1 = Subject(lat=10,
lng=50,
timezone="Europe/Berlin",
subjecttype_id=subjecttype_user.id)
DBSession.add(user1)
DBSession.flush()
auth_user = AuthUser(subject=user1,
email=user,
password=password,
active=True)
DBSession.add(auth_user)
auth_role = get_or_create_role(DBSession=DBSession,
name="Global Admin")
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)
DBSession.flush()
def create_subject(
name,
type,
lat=None,
lng=None,
timezone=None,
language=None,
additional_public_data={},
):
type_obj = DBSession.query(SubjectType).filter_by(name=type).first()
language_obj = get_or_create_language(name=language) if language else None
subject = Subject()
subject.name = name
subject.lat = lat
subject.lng = lng
subject.timezone = timezone
subject.language = language_obj
subject.additional_public_data = additional_public_data
subject.type = type_obj
DBSession.add(subject)
return subject
def forward(cls, subjecttype_id, context_subject_id, from_date, to_date, whole_time_required=False):
# We are comparing all subjects of type subject_type which have been part of context_subject_id between from_date and to_date
# By default, they don't have to be member all the time (whole_time_required).
#print("Looking for descendents of %s of type %s" % (context_subject_id, subjecttype_id))
#print("From Date: %s, To Date: %s, whole_time_required: %s" % (from_date, to_date, whole_time_required))
ancestor_subjects = Subject.get_descendent_subjects(
subject_id=context_subject_id,
of_type_id=subjecttype_id,
from_date=from_date if from_date else dt_now(),
to_date=to_date if to_date else dt_now(),
whole_time_required=whole_time_required
)
subjects = [x for x in ancestor_subjects.keys()]
return subjects
def auth_login(request):
try:
doc = request.json_body
except:
raise APIError(400, "invalid_json", "no valid json body")
user = request.user
email = doc.get("email")
password = doc.get("password")
if user:
#already logged in
token = user.get_or_create_token().token
else:
if not email or not password:
raise APIError(400, "login.email_and_password_required",
"You need to send your email and password.")
user = DBSession.query(AuthUser).filter_by(email=email).first()
if not user or not user.verify_password(password):
raise APIError(
401, "login.email_or_password_invalid",
"Either the email address or the password is wrong.")
if not user.active:
raise APIError(400, "user_is_not_activated",
"Your user is not activated.")
if user.force_password_change:
raise APIError(400, "user_has_to_change_password",
"You have to change your password.")
token = AuthToken.generate_token()
tokenObj = AuthToken(auth_user_id=user.id, token=token)
DBSession.add(tokenObj)
return {
"token": token,
"subject": Subject.full_output(user.subject_id),
}
def test_cycling_leaderboard(self):
create_subjecttypes()
create_subjects()
create_variables()
create_achievements()
klaus = DBSession.query(Subject).filter_by(name="Klaus").first()
clara = DBSession.query(Subject).filter_by(name="Clara").first()
liam = DBSession.query(Subject).filter_by(name="Liam").first()
bielefeld = DBSession.query(Subject).filter_by(
name="Bielefeld").first()
paderborn = DBSession.query(Subject).filter_by(
name="Paderborn").first()
germany = DBSession.query(Subject).filter_by(name="Germany").first()
france = DBSession.query(Subject).filter_by(name="France").first()
cyclist_of_the_month_achievement = DBSession.query(
Achievement).filter_by(name="cyclist_of_the_month").first()
def cycle(user, km, dt):
Value.increase_value(variable_name="cycling",
subject_id=user.id,
value=km,
key=None,
at_datetime=dt)
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)
cycle(klaus, 5, default_dt())
cycle(clara, 3, default_dt())
cycle(liam, 10, default_dt())
lb_bielefeld = ev(klaus, default_dt(), bielefeld)
lb_germany = ev(klaus, default_dt(), germany)
self.assertEqual(lb_bielefeld["leaderboard_position"], 0)
self.assertEqual(lb_germany["leaderboard_position"], 1)
lb_bielefeld = ev(clara, default_dt(), bielefeld)
lb_germany = ev(clara, default_dt(), germany)
lb_france = ev(clara, default_dt(), france)
self.assertEqual(lb_bielefeld["leaderboard_position"], 1)
self.assertEqual(lb_germany["leaderboard_position"], 2)
self.assertEqual(lb_france["leaderboard_position"], None)
# clara also cycled last month
Subject.join_subject(subject_id=clara.id,
part_of_id=germany.id,
join_date=last_month(default_dt()))
cycle(clara, 10, last_month(default_dt()))
# should not effect this month
lb_germany = ev(clara, default_dt(), germany)
self.assertEqual(lb_germany["leaderboard_position"], 2)
# but should effect last month
lb_germany = ev(clara, last_month(default_dt()), germany)
self.assertEqual(lb_germany["leaderboard_position"], 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 create_subjects():
germany = create_subject(name="Germany", type="Country")
DBSession.add(germany)
france = create_subject(name="France", type="Country")
DBSession.add(france)
bielefeld = create_subject(name="Bielefeld", type="City")
DBSession.add(bielefeld)
DBSession.flush()
Subject.join_subject(subject_id=bielefeld.id,
part_of_id=germany.id,
join_date=default_dt())
paderborn = create_subject(name="Paderborn", type="City")
DBSession.add(paderborn)
DBSession.flush()
Subject.join_subject(subject_id=paderborn.id,
part_of_id=germany.id,
join_date=default_dt())
lyon = create_subject(name="Lyon", type="City")
DBSession.add(lyon)
DBSession.flush()
Subject.join_subject(subject_id=lyon.id,
part_of_id=france.id,
join_date=default_dt())
junior_developer = create_subject(name="Junior Developer", type="Position")
DBSession.add(junior_developer)
senior_developer = create_subject(name="Senior Developer", type="Position")
DBSession.add(senior_developer)
project_manager = create_subject(name="Project Manager", type="Position")
DBSession.add(project_manager)
dev_team_bielefeld = create_subject(name="Developer Team Bielefeld",
type="Team")
DBSession.add(dev_team_bielefeld)
DBSession.flush()
Subject.join_subject(subject_id=dev_team_bielefeld.id,
part_of_id=bielefeld.id,
join_date=default_dt())
dev_team_paderborn = create_subject(name="Developer Team Paderborn",
type="Team")
DBSession.add(dev_team_paderborn)
DBSession.flush()
Subject.join_subject(subject_id=dev_team_paderborn.id,
part_of_id=paderborn.id,
join_date=default_dt())
dev_team_lyon = create_subject(name="Developer Team Lyon", type="Team")
DBSession.add(dev_team_lyon)
DBSession.flush()
Subject.join_subject(subject_id=dev_team_lyon.id,
part_of_id=lyon.id,
join_date=default_dt())
klaus = create_subject(name="Klaus", type="User")
DBSession.add(klaus)
DBSession.flush()
Subject.join_subject(subject_id=klaus.id,
part_of_id=bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=klaus.id,
part_of_id=junior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=klaus.id,
part_of_id=dev_team_bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=klaus.id,
part_of_id=germany.id,
join_date=default_dt())
clara = create_subject(name="Clara", type="User")
DBSession.add(clara)
DBSession.flush()
Subject.join_subject(subject_id=clara.id,
part_of_id=bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=clara.id,
part_of_id=junior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=clara.id,
part_of_id=dev_team_bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=clara.id,
part_of_id=germany.id,
join_date=default_dt())
manfred = create_subject(name="Manfred", type="User")
DBSession.add(manfred)
DBSession.flush()
Subject.join_subject(subject_id=manfred.id,
part_of_id=bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=manfred.id,
part_of_id=junior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=manfred.id,
part_of_id=dev_team_bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=manfred.id,
part_of_id=germany.id,
join_date=default_dt())
otto = create_subject(name="Otto", type="User")
DBSession.add(otto)
DBSession.flush()
Subject.join_subject(subject_id=otto.id,
part_of_id=bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=otto.id,
part_of_id=junior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=otto.id,
part_of_id=dev_team_bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=otto.id,
part_of_id=germany.id,
join_date=default_dt())
max = create_subject(name="Max", type="User")
DBSession.add(max)
DBSession.flush()
Subject.join_subject(subject_id=max.id,
part_of_id=bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=max.id,
part_of_id=senior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=max.id,
part_of_id=dev_team_bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=max.id,
part_of_id=germany.id,
join_date=default_dt())
ronny = create_subject(name="Ronny", type="User")
DBSession.add(ronny)
DBSession.flush()
Subject.join_subject(subject_id=ronny.id,
part_of_id=bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=ronny.id,
part_of_id=senior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=ronny.id,
part_of_id=dev_team_bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=ronny.id,
part_of_id=germany.id,
join_date=default_dt())
sonja = create_subject(name="Sonja", type="User")
DBSession.add(sonja)
DBSession.flush()
Subject.join_subject(subject_id=sonja.id,
part_of_id=bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=sonja.id,
part_of_id=project_manager.id,
join_date=default_dt())
Subject.join_subject(subject_id=sonja.id,
part_of_id=dev_team_bielefeld.id,
join_date=default_dt())
Subject.join_subject(subject_id=sonja.id,
part_of_id=germany.id,
join_date=default_dt())
#Paderborn
liam = create_subject(name="Liam", type="User")
DBSession.add(liam)
DBSession.flush()
Subject.join_subject(subject_id=liam.id,
part_of_id=paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=liam.id,
part_of_id=junior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=liam.id,
part_of_id=dev_team_paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=liam.id,
part_of_id=germany.id,
join_date=default_dt())
tim = create_subject(name="Tim", type="User")
DBSession.add(tim)
DBSession.flush()
Subject.join_subject(subject_id=tim.id,
part_of_id=paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=tim.id,
part_of_id=junior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=tim.id,
part_of_id=dev_team_paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=tim.id,
part_of_id=germany.id,
join_date=default_dt())
robin = create_subject(name="Robin", type="User")
DBSession.add(robin)
DBSession.flush()
Subject.join_subject(subject_id=robin.id,
part_of_id=paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=robin.id,
part_of_id=junior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=robin.id,
part_of_id=dev_team_paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=robin.id,
part_of_id=germany.id,
join_date=default_dt())
alina = create_subject(name="Alina", type="User")
DBSession.add(alina)
DBSession.flush()
Subject.join_subject(subject_id=alina.id,
part_of_id=paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=alina.id,
part_of_id=junior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=alina.id,
part_of_id=dev_team_paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=alina.id,
part_of_id=germany.id,
join_date=default_dt())
charlotte = create_subject(name="Charlotte", type="User")
DBSession.add(charlotte)
DBSession.flush()
Subject.join_subject(subject_id=charlotte.id,
part_of_id=paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=charlotte.id,
part_of_id=senior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=charlotte.id,
part_of_id=dev_team_paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=charlotte.id,
part_of_id=germany.id,
join_date=default_dt())
ida = create_subject(name="Ida", type="User")
DBSession.add(ida)
DBSession.flush()
Subject.join_subject(subject_id=ida.id,
part_of_id=paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=ida.id,
part_of_id=senior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=ida.id,
part_of_id=dev_team_paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=ida.id,
part_of_id=germany.id,
join_date=default_dt())
carolin = create_subject(name="Carolin", type="User")
DBSession.add(carolin)
DBSession.flush()
Subject.join_subject(subject_id=carolin.id,
part_of_id=paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=carolin.id,
part_of_id=project_manager.id,
join_date=default_dt())
Subject.join_subject(subject_id=carolin.id,
part_of_id=dev_team_paderborn.id,
join_date=default_dt())
Subject.join_subject(subject_id=carolin.id,
part_of_id=germany.id,
join_date=default_dt())
#Lyon
lola = create_subject(name="Lola", type="User")
DBSession.add(lola)
DBSession.flush()
Subject.join_subject(subject_id=lola.id,
part_of_id=lyon.id,
join_date=default_dt())
Subject.join_subject(subject_id=lola.id,
part_of_id=junior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=lola.id,
part_of_id=dev_team_lyon.id,
join_date=default_dt())
Subject.join_subject(subject_id=lola.id,
part_of_id=france.id,
join_date=default_dt())
lina = create_subject(name="Lina", type="User")
DBSession.add(lina)
DBSession.flush()
Subject.join_subject(subject_id=lina.id,
part_of_id=lyon.id,
join_date=default_dt())
Subject.join_subject(subject_id=lina.id,
part_of_id=senior_developer.id,
join_date=default_dt())
Subject.join_subject(subject_id=lina.id,
part_of_id=dev_team_lyon.id,
join_date=default_dt())
Subject.join_subject(subject_id=lina.id,
part_of_id=france.id,
join_date=default_dt())
ethan = create_subject(name="Ethan", type="User")
DBSession.add(ethan)
DBSession.flush()
Subject.join_subject(subject_id=ethan.id,
part_of_id=lyon.id,
join_date=default_dt())
Subject.join_subject(subject_id=ethan.id,
part_of_id=project_manager.id,
join_date=default_dt())
Subject.join_subject(subject_id=ethan.id,
part_of_id=dev_team_lyon.id,
join_date=default_dt())
Subject.join_subject(subject_id=ethan.id,
part_of_id=france.id,
join_date=default_dt())
def add_or_update_subject(request):
"""add a subject and set its metadata"""
subject_id = int(request.matchdict["subject_id"])
if asbool(get_settings().get("enable_user_authentication", False)):
#ensure that the subject exists and we have the permission to update it
may_update = request.has_perm(
perm_global_manage_subjects
) or request.has_perm(
perm_own_update_subject_infos) and request.subject.id == subject_id
if not may_update:
raise APIError(403, "forbidden", "You may not edit this subject.")
#if not exists_by_expr(t_subjects,t_subjects.c.id==subject_id):
# raise APIError(403, "forbidden", "The subject does not exist. As the user authentication is enabled, you need to create the AuthUser first.")
lat = None
if len(request.POST.get("lat", "")) > 0:
lat = float(request.POST["lat"])
lon = None
if len(request.POST.get("lon", "")) > 0:
lon = float(request.POST["lon"])
friends = []
if len(request.POST.get("friends", "")) > 0:
friends = [int(x) for x in request.POST["friends"].split(",")]
groups = []
if len(request.POST.get("groups", "")) > 0:
groups = [int(x) for x in request.POST["groups"].split(",")]
timezone = "UTC"
if len(request.POST.get("timezone", "")) > 0:
timezone = request.POST["timezone"]
if not valid_timezone(timezone):
timezone = 'UTC'
language = None
if len(request.POST.get("language", "")) > 0:
language = request.POST["language"]
additional_public_data = {}
if len(request.POST.get("additional_public_data", "")) > 0:
try:
additional_public_data = json.loads(
request.POST["additional_public_data"])
except:
additional_public_data = {}
Subject.set_infos(subject_id=subject_id,
lat=lat,
lng=lon,
timezone=timezone,
language_id=language,
additional_public_data=additional_public_data)
Subject.set_relations(subject_id=subject_id, relation_ids=friends)
Subject.set_parent_subjects(subject_id=subject_id,
parent_subject_ids=groups)
return {"status": "OK", "subject": Subject.full_output(subject_id)}
def increase_multi_values(request):
try:
doc = request.json_body
except:
raise APIError(400, "invalid_json", "no valid json body")
try:
achievement_history = int(request.GET["achievement_history"])
except:
achievement_history = 2
ret = {}
for subject_id, values in doc.items():
subject = Subject.get_subject(subject_id)
if not subject:
raise APIError(404, "subject_not_found",
"subject %s not found" % (subject_id, ))
for variable_name, values_and_keys in values.items():
for value_and_key in values_and_keys:
variable = Variable.get_variable_by_name(variable_name)
if asbool(get_settings().get("enable_user_authentication",
False)):
if not Variable.may_increase(variable, request,
subject_id):
raise APIError(
403, "forbidden",
"You may not increase the variable %s for subject %s."
% (variable_name, subject_id))
if not variable:
raise APIError(404, "variable_not_found",
"variable %s not found" % (variable_name, ))
if not 'value' in value_and_key:
raise APIError(400, "variable_not_found",
"illegal value for %s" % (variable_name, ))
value = value_and_key['value']
key = value_and_key.get('key', '')
Value.increase_value(variable_name, subject, value, key)
output = _get_progress(achievements_for_subject=subject,
requesting_subject=request.subject,
achievement_history=achievement_history)
output = copy.deepcopy(output)
to_delete = list()
for i in range(len(output["achievements"])):
if len(output["achievements"][i]["new_levels"]) > 0:
if "levels" in output["achievements"][i]:
del output["achievements"][i]["levels"]
if "priority" in output["achievements"][i]:
del output["achievements"][i]["priority"]
if "goals" in output["achievements"][i]:
del output["achievements"][i]["goals"]
else:
to_delete.append(i)
for i in sorted(to_delete, reverse=True):
del output["achievements"][i]
if len(output["achievements"]) > 0:
ret[subject_id] = output
return ret
def increase_value(request):
"""increase a value for the subject"""
subject_id = int(request.matchdict["subject_id"])
try:
value = float(request.POST["value"])
except:
try:
doc = request.json_body
value = doc["value"]
except:
raise APIError(400, "invalid_value", "Invalid value provided")
key = request.matchdict["key"] if (
"key" in request.matchdict
and request.matchdict["key"] is not None) else ""
variable_name = request.matchdict["variable_name"]
subject = Subject.get_subject(subject_id)
if not subject:
raise APIError(404, "subject_not_found", "subject not found")
variable = Variable.get_variable_by_name(variable_name)
if not variable:
raise APIError(404, "variable_not_found", "variable not found")
if asbool(get_settings().get("enable_user_authentication", False)):
if not AuthUser.may_increase(variable, request, subject_id):
raise APIError(
403, "forbidden",
"You may not increase the variable for this subject.")
Value.increase_value(variable_name,
subject["id"],
value,
key,
at_datetime=dt_now())
try:
achievement_history = int(request.GET["achievement_history"])
except:
achievement_history = 2
output = _get_progress(achievements_for_subject=subject,
requesting_subject=request.subject,
achievement_history=achievement_history)
output = copy.deepcopy(output)
to_delete = list()
for i in range(len(output["achievements"])):
if len(output["achievements"][i]["new_levels"]) > 0:
if "levels" in output["achievements"][i]:
del output["achievements"][i]["levels"]
if "priority" in output["achievements"][i]:
del output["achievements"][i]["priority"]
if "goals" in output["achievements"][i]:
del output["achievements"][i]["goals"]
else:
to_delete.append(i)
for i in sorted(to_delete, reverse=True):
del output["achievements"][i]
return output
