def handle_perform_verify_email(self, request_data):
response = {}
redis_key = "emailveri_{}".format(request_data['userid'])
success = False
user = None
required_params = ["userid", "verifykey"]
for param in required_params:
if param not in request_data:
raise OS_MissingParam(param)
try:
user = User.get((User.id == request_data['userid']))
if self.redis_ctx.exists(redis_key):
real_verification_key = self.redis_ctx.get(redis_key)
if request_data['verifykey'] == real_verification_key:
success = True
user.email_verified = True
user.save()
self.redis_ctx.delete(redis_key)
except User.DoesNotExist:
raise OS_Auth_NoSuchUser()
response['success'] = success
return response
def handle_create_profile(self, data):
profile_data = data["profile"]
user_data = None
if "user" in data:
user_data = data["user"]
if "namespaceid" in profile_data:
namespaceid = profile_data["namespaceid"]
else:
namespaceid = 0
if "uniquenick" in profile_data:
if not self.is_name_valid(profile_data["uniquenick"]):
raise OS_Profile_UniquenickInvalid()
nick_available = self.check_uniquenick_available(
profile_data["uniquenick"], namespaceid)
if nick_available["exists"]:
raise OS_Profile_UniquenickInUse(nick_available["profile"])
user = User.get((User.id == user_data["id"]))
if "nick" in profile_data:
if not self.is_name_valid(profile_data["nick"]):
raise OS_Profile_NickInvalid()
profile_data["user"] = user
profile_pk = Profile.insert(**profile_data).execute()
profile = Profile.get((Profile.id == profile_pk))
profile = model_to_dict(profile)
del profile["user"]
user = model_to_dict(user)
return {"user": user, "profile": profile, "success": True}
def handle_get_user(self, data):
user = None
if "user" not in data:
raise OS_MissingParam("user")
user_data = data["user"]
response = {"success": False}
try:
if "userid" in user_data:
user = User.get((User.id == user_data["userid"]))
elif "email" in user_data:
user = User.get((User.email == user_data["email"]) &
(User.partnercode == user_data["partnercode"]))
if user:
user = model_to_dict(user)
del user['password']
response["user"] = user
response["success"] = True
except User.DoesNotExist:
return None
return response
def handle_update_user(self, data):
response = {"success": False}
if "user" not in data:
data = {'user': data}
user_model = User.get((User.id == data['user']['id']))
if "email" in data["user"]:
if data["user"]["email"] != user_model.email:
user_model.email_verified = False
if "email_verified" in data["user"]:
del data["user"]["email_verified"]
for key in data['user']:
if key != "id":
setattr(user_model, key, data['user'][key])
user_model.save()
response["success"] = True
return response
def handle_resend_verify_email(self, request_data):
response = {}
success = False
user_id = False
if "id" in request_data:
user_id = request_data["id"]
elif "userid" in request_data:
user_id = request_data["userid"]
else:
raise OS_MissingParam("userid")
if user_id != False:
redis_key = "emailveri_{}".format(user_id)
if not self.redis_ctx.exists(redis_key):
try:
user = User.get((User.id == user_id))
self.send_verification_email(model_to_dict(user))
success = True
except User.DoesNotExist:
raise OS_Auth_NoSuchUser()
response['success'] = success
return response
def auth_or_create_profile(self, request_body, account_data):
#{u'profilenick': u'sctest01', u'save_session': True, u'set_context': u'profile', u'hash_type': u'auth_or_create_profile', u'namespaceid': 1,
#u'uniquenick': u'', u'partnercode': 0, u'password': u'gspy', u'email': u'*****@*****.**'}
user_where = (User.deleted == False)
user_data = request_body["user"]
if "email" in user_data:
#if User.is_email_valid(user_data["email"]):
# raise OS_InvalidParam("email")
user_where = (user_where) & (User.email == user_data["email"])
if "partnercode" in user_data:
user_data['partnercode'] = user_data["partnercode"]
partnercode = user_data["partnercode"]
else:
partnercode = 0
auth_create_auth_token = False
if "use_auth_token" in request_body:
auth_create_auth_token = request_body["use_auth_token"]
user_where = ((user_where) & (User.partnercode == partnercode))
try:
user = User.get(user_where)
user = model_to_dict(user)
if ("password" not in user_data or user['password'] !=
user_data["password"]) and not auth_create_auth_token:
raise OS_Auth_InvalidCredentials()
except User.DoesNotExist:
register_svc = RegistrationService()
user = register_svc.try_register_user(user_data)
user = user["user"]
profile_data = request_body["profile"] #create data
profile_where = (Profile.deleted == False)
force_unique = False
if "uniquenick" in profile_data:
if "namespaceid" in profile_data:
if profile_data["namespaceid"] > 0:
force_unique = True
else:
force_unique = True
profile_where = (profile_where) & (Profile.uniquenick
== profile_data["uniquenick"])
if "nick" in profile_data:
profile_where = (profile_where) & (Profile.nick
== profile_data['nick'])
if "namespaceid" in profile_data:
namespaceid = profile_data["namespaceid"]
else:
namespaceid = 0
profile_where = (profile_where) & (Profile.namespaceid == namespaceid)
ret = {}
try:
if not force_unique:
profile_where = (profile_where) & (Profile.userid
== user["id"])
profile = Profile.get(profile_where)
profile = model_to_dict(profile)
del profile['user']['password']
ret["new_profile"] = False
ret["success"] = True
if user["id"] != profile["user"]["id"]:
raise OS_InvalidParam("uniquenick")
except Profile.DoesNotExist:
user_profile_srv = UserProfileMgrService()
#this should raise an exception instead of return an error object...
profile = user_profile_srv.handle_create_profile({
'profile': profile_data,
'user': user
})
if "error" in profile:
ret["error"] = profile["error"]
return ret
ret["new_profile"] = True
ret["success"] = True
profile = profile["profile"]
ret["profile"] = profile
ret["user"] = user
if auth_create_auth_token:
auth_token_data = self.handle_make_auth_ticket(
{"profileid": profile["id"]})
ret["auth_token"] = auth_token_data
return ret
