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