def auth():
try:
data = request.json
if data is None or 'email' not in data:
return response_error(MESSAGE.INVALID_DATA, CODE.INVALID_DATA)
email = data['email']
password = data['password']
if is_valid_email(email) == False:
return response_error(MESSAGE.USER_INVALID_EMAIL,
CODE.USER_INVALID_EMAIL)
if is_valid_password(password) == False:
return response_error(MESSAGE.USER_INVALID_PASSWORD,
CODE.USER_INVALID_PASSWORD)
password = hashlib.md5(password).hexdigest()
u = User.find_user_by_email_and_password(email, password)
if u is not None:
response = u.to_json()
response['access_token'] = create_access_token(identity=email,
fresh=True)
return response_ok(response)
return response_error(MESSAGE.USER_INVALID, CODE.USER_INVALID)
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def auth():
try:
data = request.json
if data is None or 'email' not in data:
return response_error(MESSAGE.INVALID_DATA, CODE.INVALID_DATA)
email = data['email']
password = data['password']
confirm = hashlib.md5('{}{}'.format(email.strip(),
g.PASSPHASE)).hexdigest()
if email == g.EMAIL and password == confirm:
response = {}
if is_valid_email(email):
response['access_token'] = create_access_token(identity=email,
fresh=True)
else:
return response_error(MESSAGE.USER_INVALID_EMAIL,
CODE.USER_INVALID_EMAIL)
return response_ok(response)
else:
return response_error(MESSAGE.USER_INVALID, CODE.USER_INVALID)
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def reward_user_redeem_code(user_id, code):
u = User.find_user_with_id(user_id)
if u is not None and is_valid_email(u.email):
r = Referral.find_referral_by_uid(u.id)
if r is not None:
send_reward_redeem.delay(
u.email, code,
'{}prediction?refer={}'.format(g.BASE_URL, r.code))
def user_subscribe():
"""
" 3 use cases:
" Popup subscribe email will appear after user plays on match_id.
" Popup subscribe email will appear at the first time.
" Popup subscribe email will apear when user click on referral link.
"""
try:
data = request.json
if data is None:
return response_error(MESSAGE.INVALID_DATA, CODE.INVALID_DATA)
if 'email' not in data or is_valid_email(data["email"]) is False:
return response_error(MESSAGE.USER_INVALID_EMAIL,
CODE.USER_INVALID_EMAIL)
if user_bl.is_email_subscribed(data['email']):
return response_error(MESSAGE.EMAIL_ALREADY_SUBSCRIBED,
CODE.EMAIL_ALREADY_SUBSCRIBED)
match = Match.find_match_by_id(data.get('match_id', -1))
email = data["email"]
uid = int(request.headers["Uid"])
referral_code = data.get('referral_code', None)
user = User.find_user_with_id(uid)
user.email = email
user.is_user_disable_popup = 0
user.is_subscribe = 1
if referral_code is not None:
r = Referral.find_referral_by_code(referral_code)
if r is not None and r.user_id != uid:
user.invited_by_user = r.user_id
db.session.flush()
# issue referral code for user if any
referral_bl.issue_referral_code_for_user(user)
db.session.commit()
# send email
result, code_1, code_2 = user_bl.claim_redeem_code_for_user(user)
if result:
subscribe_email_to_claim_redeem_code.delay(
email, code_1, code_2, request.headers["Fcm-Token"],
request.headers["Payload"], uid)
elif match is not None:
subscribe_email.delay(email, match.id,
request.headers["Fcm-Token"],
request.headers["Payload"], uid)
return response_ok(user.to_json())
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def issue_new_redeem_code_for_user(user_id, is_need_send_mail=True):
u = User.find_user_with_id(user_id)
if u is not None and is_valid_email(u.email):
redeem = db.session.query(Redeem).filter(
Redeem.reserved_id == 0, Redeem.used_user == 0).limit(1).first()
referral_code = referral_bl.issue_referral_code_for_user(u)
if redeem is not None:
redeem.reserved_id = user_id
db.session.flush()
if is_need_send_mail:
send_renew_redeem_code.delay(
u.email, redeem.code,
'{}prediction?refer={}'.format(g.BASE_URL, referral_code))
def user_accept_notification():
"""
" user input their email in notification section on create market page.
"""
try:
data = request.json
if data is None:
return response_error(MESSAGE.INVALID_DATA, CODE.INVALID_DATA)
if 'email' not in data or is_valid_email(data["email"]) is False:
return response_error(MESSAGE.USER_INVALID_EMAIL,
CODE.USER_INVALID_EMAIL)
is_need_send_verification_code = data.get(
'need_send_verification_code', 0)
email = data["email"]
is_subscribed = user_bl.is_email_subscribed(email)
if is_need_send_verification_code == 1:
if is_subscribed == False:
return response_error(
MESSAGE.USER_CANNOT_RECEIVE_VERIFICATION_CODE,
CODE.USER_CANNOT_RECEIVE_VERIFICATION_CODE)
elif is_subscribed:
return response_error(MESSAGE.EMAIL_ALREADY_SUBSCRIBED,
CODE.EMAIL_ALREADY_SUBSCRIBED)
uid = int(request.headers["Uid"])
user = User.find_user_with_id(uid)
user.email = email
user.is_subscribe = 1
user.is_user_disable_popup = 0
db.session.flush()
# send email
subscribe_notification_email.delay(email, request.headers["Fcm-Token"],
request.headers["Payload"], uid)
db.session.commit()
return response_ok()
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def sign_up():
try:
saved_path = None
image_name = None
email = request.form.get('email', '')
password = request.form.get('password', '')
name = request.form.get('name', '')
title = request.form.get('title', '')
if is_valid_email(email) == False:
return response_error(MESSAGE.USER_INVALID_EMAIL,
CODE.USER_INVALID_EMAIL)
if is_valid_password(password) == False:
return response_error(MESSAGE.USER_INVALID_PASSWORD,
CODE.USER_INVALID_PASSWORD)
t = db.session.query(ReviewType).filter(
ReviewType.name == CONST.Type['People']).first()
if t is None:
return response_error(MESSAGE.TYPE_NOT_IN_DATABASE,
CODE.TYPE_NOT_IN_DATABASE)
u = User.find_user_by_email(email)
if u is None:
request_size = request.headers.get('Content-length')
if request.files and len(
request.files) > 0 and request.files['avatar'] is not None:
if int(
request_size
) <= CONST.UPLOAD_MAX_FILE_SIZE and storage_bl.validate_extension(
request.files['avatar'].filename,
CONST.UPLOAD_ALLOWED_EXTENSIONS):
time = datetime.now().timetuple()
seconds = local_to_utc(time)
image_name = '{}_{}'.format(
seconds, request.files['avatar'].filename)
saved_path = storage_bl.handle_upload_file(
request.files['avatar'], file_name=image_name)
else:
return response_error(MESSAGE.FILE_TOO_LARGE,
CODE.FILE_TOO_LARGE)
gc_services.upload_to_storage(g.GC_STORAGE_BUCKET, saved_path,
g.GC_STORAGE_FOLDER, image_name)
u = User(name=name,
email=email,
password=hashlib.md5(password).hexdigest(),
type_id=t.id,
title=title,
avatar='{}{}'.format(CONST.BASE_IMAGE_URL, image_name)
if image_name is not None else None)
db.session.add(u)
db.session.flush()
else:
return response_error(MESSAGE.USER_EMAIL_EXIST_ALREADY,
CODE.USER_EMAIL_EXIST_ALREADY)
response = u.to_json()
response['access_token'] = create_access_token(identity=email,
fresh=True)
db.session.commit()
storage_bl.delete_file(saved_path)
return response_ok(response)
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
def update_user(user_id):
try:
u = User.find_user_by_id(user_id)
if u is None:
return response_error(MESSAGE.USER_INVALID, CODE.USER_INVALID)
email = request.form.get('email', '')
password = request.form.get('password', '')
name = request.form.get('name', '')
title = request.form.get('title', '')
role_id = request.form.get('role_id')
t = db.session.query(ReviewType).filter(
ReviewType.name == CONST.Type['People']).first()
if t is None:
return response_error(MESSAGE.TYPE_NOT_IN_DATABASE,
CODE.TYPE_NOT_IN_DATABASE)
if len(email) > 0:
if is_valid_email(email) == False or \
User.find_user_by_email(email) is not None:
return response_error(MESSAGE.USER_INVALID_EMAIL,
CODE.USER_INVALID_EMAIL)
u.email = email
if len(password) > 0:
if is_valid_password(password) == False:
return response_error(MESSAGE.USER_INVALID_PASSWORD,
CODE.USER_INVALID_PASSWORD)
u.password = hashlib.md5(password).hexdigest()
if len(name) > 0:
u.name = name
if len(title) > 0:
u.title = title
if role_id is not None and \
Role.find_role_by_id(role_id) is not None:
u.role_id = role_id
request_size = request.headers.get('Content-length')
if request.files and len(
request.files) > 0 and request.files['avatar'] is not None:
if int(
request_size
) <= CONST.UPLOAD_MAX_FILE_SIZE and storage_bl.validate_extension(
request.files['avatar'].filename,
CONST.UPLOAD_ALLOWED_EXTENSIONS):
time = datetime.now().timetuple()
seconds = local_to_utc(time)
image_name = '{}_{}'.format(seconds,
request.files['avatar'].filename)
saved_path = storage_bl.handle_upload_file(
request.files['avatar'], file_name=image_name)
else:
return response_error(MESSAGE.FILE_TOO_LARGE,
CODE.FILE_TOO_LARGE)
gc_services.upload_to_storage(g.GC_STORAGE_BUCKET, saved_path,
g.GC_STORAGE_FOLDER, image_name)
u.avatar = '{}{}'.format(CONST.BASE_IMAGE_URL, image_name)
db.session.commit()
return response_ok(u.to_json())
except Exception, ex:
db.session.rollback()
return response_error(ex.message)
