def query_user_create(user_name: str, user_email: str, user_password: str,
user_ip="0.0.0.0"):
"""
:param user_name: user's unique nickname
:param user_email: user's unique email
:param user_password: user's password
:param user_ip: user's ip address (default 0.0.0.0)
:return: user object if succeeded
"""
if type(user_name) != str or type(user_email) != str or type(
user_password) != str:
raise MongoError(ErrorCode.MONGODB_STR_EXPECTED)
if len(query_user_get_by_name(user_name)) > 0:
raise MongoError(ErrorCode.MONGODB_USER_NAME_TAKEN)
elif len(query_user_get_by_email(user_email)) > 0:
raise MongoError(ErrorCode.MONGODB_USER_EMAIL_TAKEN)
login = [
UserLogin(user_login_ip=user_ip, user_login_time=get_time_now_utc())]
# EmbeddedDocument must be included when creating
# user_detail, user_reg_date
user = User(user_name=user_name, user_email=user_email,
user_password=user_password,
user_detail=UserDetail(), user_status="private",
user_thumbnail="",
user_reg_date=get_time_now_utc(), user_login=login,
user_following=[], user_follower=[])
return user.save()
def query_user_add_follow(follower_id: str, following_id: str):
"""
:param follower_id: follower user id
:param following_id: uploader user_id
:return: 1 if succeeded
"""
if type(follower_id) != str or type(following_id) != str:
raise MongoError(ErrorCode.MONGODB_STR_EXPECTED)
follower = query_user_get_by_id(follower_id)
following = query_user_get_by_id(following_id)
if len(follower) == 0:
raise MongoError(ErrorCode.MONGODB_FOLLOWER_NOT_FOUND)
if len(following) == 0:
raise MongoError(ErrorCode.MONGODB_FOLLOWED_NOT_FOUND)
if following_id in follower[0].user_following and follower_id in \
following[0].user_follower:
raise MongoError(ErrorCode.MONGODB_FOLLOW_REL_EXISTS)
User.objects(id=follower_id).update(
add_to_set__user_following=following_id)
User.objects(id=following_id).update(
add_to_set__user_follower=follower_id)
return 1
def query_user_add_login(user_id: str, ip="0.0.0.0", time=get_time_now_utc()):
"""
:param user_id: user's unique id
:param ip: user's login ip address
:param time: user's login time (utc, optional), default: current system
time (utc)
:return: 1 if succeeded
"""
if type(user_id) != str or type(ip) != str or type(
time) != datetime.datetime:
raise MongoError(ErrorCode.MONGODB_STR_EXPECTED)
users = query_user_get_by_id(user_id)
if len(users) == 0:
raise MongoError(ErrorCode.MONGODB_USER_NOT_FOUND)
# only keep 10 login info
login_history = users[0].user_login
oldest = login_history[0]
latest = login_history[-1]
# TODO: update latest 10 login info method, some bugs for current version
if len(login_history) >= 10:
# Delete oldest history
clean = UserLogin(
user_login_ip=oldest.user_login_ip,
user_login_time=oldest.user_login_time)
print(User.objects(id=user_id).update_one(
pull__user_login__user_login_time=clean.user_login_time))
if time == latest:
User.objects(id=user_id).update(
pull__user_login__user_login_time=latest)
new_login = {'user_login_ip': ip, 'user_login_time': time}
User.objects(id=user_id).update(
add_to_set__user_login=[new_login])
return 1
def query_user_update_thumbnail(user_id: str, user_thumbnail: str):
"""
:param user_id: user's id
:param user_thumbnail: thumbnail URI
:return: array of user Model
"""
if type(user_id) != str or type(user_thumbnail) != str:
raise MongoError(ErrorCode.MONGODB_STR_EXPECTED)
users = query_user_get_by_id(user_id)
if len(users) == 0:
raise MongoError(ErrorCode.MONGODB_USER_NOT_FOUND)
User.objects(id=user_id).update(
user_thumbnail=user_thumbnail)
def parse_data(fromUserId):
# userId
from_user = User.get_or_none(User.userId == fromUserId)
# to_userId
json_data = flask.request.json
toUserId = json_data.get('userId')
to_user = User.get_or_none(User.userId == toUserId)
msg = "Success"
code = 200
if not to_user:
msg = 'UserId \'%s\' does not exists' % toUserId
code = 400
return (from_user, to_user), msg, code
def signup():
data = flask.request.json
if not data['name']:
return flask.jsonify({"msg": "Missing name"}), 400
if not data['email']:
return flask.jsonify({"msg": "Missing email"}), 400
if not data['password']:
return flask.jsonify({"msg": "Missing password"}), 400
user = User(name=data['name'], email=data['email'], pw=data['password'])
if user.save() and len(user.errors) == 0:
access_token = create_access_token(identity=user.email)
user_dict = user.as_dict()
user_dict['access_token'] = access_token
return flask.jsonify(user_dict), 200
else:
return flask.jsonify({'msg': user.errors[0]}), 400
def test_user_model_load(self):
temp_user = self.data['temp_user'][2]
user = User(**temp_user)
self.assertEqual(user.user_name, temp_user['user_name'])
self.assertEqual(user.user_detail.user_first_name,
temp_user['user_detail']['user_first_name'])
self.assertEqual(user.user_login[0].user_login_time,
temp_user['user_login'][0]['user_login_time'])
self.assertEqual(user.user_follower, temp_user['user_follower'])
def query_user_get_by_id(user_id: str):
"""
:param user_id: user id
:return: an array of such User (len == 0 or 1), len == 0 if no such
user_id, len == 1 if found
"""
if type(user_id) != str:
raise MongoError(ErrorCode.MONGODB_STR_EXPECTED)
return User.objects(id=user_id)
def query_user_get_by_name(user_name: str):
"""
:param user_name: user name
:return: an array of such User, len == 0 if no such user_name, len == 1
if found
"""
if type(user_name) != str:
raise MongoError(ErrorCode.MONGODB_STR_EXPECTED)
return User.objects(user_name=user_name)
def util_tests_clean_database():
data = util_tests_load_data()
for user in data['temp_user']:
User.objects(user_name=user['user_name']).delete()
for video in data['temp_video']:
Video.objects(video_title=video['video_title']).delete()
Video.objects(user_id=video['user_id']).delete()
for video in data['const_video']:
VideoOp.objects(video_id=video['_id']['$oid']).delete()
Video.objects(user_id=data['const_user'][1]['_id']['$oid']).delete()
Video.objects(video_title="new title").delete()
Video.objects(video_title="").delete()
VideoOp.objects(user_id=data['const_user'][1]['_id']['$oid']).delete()
vop = data['const_video_op'][0]
VideoOp(**vop).save()
def edit_image(userId):
if "image" not in flask.request.files:
return flask.jsonify({'msg': 'No \'image\' key in request.files'}), 400
file = flask.request.files['image']
print(file)
if file.filename == '':
return flask.jsonify(
{'msg': 'No file is found in \'image\' in request.files'}), 400
if file and storage.allowed_file(file.filename):
print("here")
file.filename = "user{}-profile-{}{}".format(
userId, datetime.strftime(datetime.now(), "%y%m%d%H%M%S"),
os.path.splitext(file.filename)[1])
upload_error = storage.upload_file_to_s3(file)
if not upload_error:
User.update(imgName=file.filename).where(
User.userId == userId).execute()
return flask.jsonify({'msg': 'Success'}), 200
def query_user_delete_by_name(user_name: str, silent=False):
"""
:param user_name: user's name
:param silent: delete user regardless of existence
:return: 1 if succeeded
"""
if type(user_name) != str:
raise MongoError(ErrorCode.MONGODB_STR_EXPECTED)
users = query_user_get_by_name(user_name)
if len(users) == 0 and silent is False:
raise MongoError(ErrorCode.MONGODB_USER_NOT_FOUND)
return User.objects(user_name=user_name).delete()
def query_user_delete_follow(follower_id: str, following_id: str):
"""
:param follower_id: follower user id
:param following_id: uploader user_id
:return: 1 if succeeded
"""
if type(follower_id) != str or type(following_id) != str:
raise MongoError(ErrorCode.MONGODB_STR_EXPECTED)
follower = query_user_get_by_id(follower_id)
following = query_user_get_by_id(following_id)
if len(follower) == 0:
raise MongoError(ErrorCode.MONGODB_FOLLOWER_NOT_FOUND)
if len(following) == 0:
raise MongoError(ErrorCode.MONGODB_FOLLOWED_NOT_FOUND)
User.objects(id=follower_id).update(
pull__user_following=following_id)
User.objects(id=following_id).update(
pull__user_follower=follower_id)
return 1
def parse_data(userId):
json_data = flask.request.json
user = User.get_or_none(User.userId == userId)
recipeId = json_data.get('recipeId')
recipe = Recipe.get_or_none(Recipe.id == recipeId)
msg = "Success"
code = 200
if not recipe:
msg = 'RecipeId \'%s\' does not exists' % recipeId
code = 400
return (user, recipe), msg, code
def query_user_update_status(user_id: str, user_status: str):
"""
:param user_id: user's unique id
:param user_status: user's new status
:return: array of User Model
"""
if type(user_id) != str or type(user_status) != str:
raise MongoError(ErrorCode.MONGODB_STR_EXPECTED)
if len(query_user_get_by_id(user_id)) == 0:
raise MongoError(ErrorCode.MONGODB_USER_NOT_FOUND)
if user_status not in VALID_USER_STATUS:
raise MongoError(ErrorCode.MONGODB_USER_INVALID_STATUS)
return User.objects(id=user_id).update(
user_status=user_status)
def create_user(self, **kwargs):
"""
Method to create user
:param kwargs:
:return:
"""
user = User(username=kwargs.get('usr'),
password=self._create_password_hash(kwargs.get('pwd')))
try:
self._SESSSION.add(user)
self._SESSSION.commit()
print("User saved in database.\n")
except IntegrityError:
print("Username already exist! Please try again.\n")
self._SESSSION.rollback()
except InvalidRequestError:
self._SESSSION.rollback()
def query_user_update_password(user_id: str, user_password: str):
"""
:param user_id: user's id
:param user_password: user's password
:return: array of User Model
"""
if type(user_id) != str or type(user_password) != str:
raise MongoError(ErrorCode.MONGODB_STR_EXPECTED)
users = query_user_get_by_id(user_id)
if len(users) == 0:
raise MongoError(ErrorCode.MONGODB_USER_NOT_FOUND)
old_password = users[0].user_password
if util_hash_encode(user_password) == old_password:
raise MongoError(ErrorCode.MONGODB_UPDATE_SAME_PASS)
return User.objects(id=user_id).update(
user_password=util_hash_encode(user_password))
def query_user_update_name(user_id: str, user_name: str):
"""
:param user_id: user's id
:param user_name: user's name
:return: array of User Model
"""
if type(user_id) != str or type(user_name) != str:
raise MongoError(ErrorCode.MONGODB_STR_EXPECTED)
users = query_user_get_by_id(user_id)
if len(users) == 0:
raise MongoError(ErrorCode.MONGODB_USER_NOT_FOUND)
old_name = users[0].user_name
if user_name == old_name:
raise MongoError(ErrorCode.MONGODB_UPDATE_SAME_NAME)
if len(query_user_get_by_name(user_name)) > 0:
raise MongoError(ErrorCode.MONGODB_USER_NAME_TAKEN)
return User.objects(id=user_id).update(user_name=user_name)
def add_recipe():
json_data = flask.request.json
# userId
userId = json_data.get('userId')
user = User.get_or_none(User.userId == userId)
if not user:
return flask.jsonify({'msg': 'Must provide valid userId'}), 400
# name
name = json_data.get('name')
if not name:
return flask.jsonify({'msg': 'Must provide non-empty name'}), 400
# name
serving = json_data.get('serving')
if not serving:
return flask.jsonify({'msg': 'Must provide non-empty serving'}), 400
# name
preparation_time = json_data.get('preparation_time')
if not preparation_time:
return flask.jsonify(
{'msg': 'Must provide non-empty preparation_time'}), 400
# name
cooking_time = json_data.get('cooking_time')
if not cooking_time:
return flask.jsonify({'msg':
'Must provide non-empty cooking_time'}), 400
recipe = Recipe(user=user,
name=name,
serving=serving,
preparation_time=preparation_time,
cooking_time=cooking_time)
if not recipe.save():
return flask.jsonify({'msg': 'Error in saving data'}), 400
return flask.jsonify({'msg': 'Success'}), 200
def login():
data = flask.request.json
if not data['email']:
return flask.jsonify({"msg": "Missing email"}), 400
if not data['password']:
return flask.jsonify({"msg": "Missing password"}), 400
user = User.get_or_none(User.email == data['email'])
successful_login = check_password_hash(user.pw_hash,
data['password']) if user else False
if successful_login:
access_token = create_access_token(identity=user.email)
user_dict = user.as_dict()
user_dict['access_token'] = access_token
return flask.jsonify(user_dict), 200
else:
if user is None: msg = "Email does not exists in database"
elif successful_login is False: msg = "Wrong password is provided"
else: msg = ''
return flask.jsonify({'msg': msg}), 400
def edit_user(userId: str):
json_data = flask.request.json
user = User.get(User.userId == userId)
isEdited = False
# name
name = json_data.get('name')
if name:
if user.name != name:
isEdited = True
user.name = name
# email
email = json_data.get('email')
if email:
if user.email != email:
isEdited = True
user.email = email
if isEdited:
if not user.save():
return flask.jsonify({'msg': 'Error in saving data'}), 400
return flask.jsonify({'msg': 'Success'}), 200
def add_comment():
json_data = flask.request.json
# userId
userId = json_data.get('userId')
user = User.get_or_none(User.userId == userId)
if not user:
return flask.jsonify({'msg': 'Must provide valid userId'}), 400
# recipeId
recipeId = json_data.get('recipeId')
recipe = Recipe.get_or_none(Recipe.id == recipeId)
if not recipe:
return flask.jsonify({'msg': 'Must provide valid recipeId'}), 400
# text
text = json_data.get('text')
if not text:
return flask.jsonify({'msg': 'Must provide non-empty text'}), 400
comment = Comment(user=user, recipe=recipe, text=text)
if not comment.save():
return flask.jsonify({'msg': 'Error in saving data'}), 400
return flask.jsonify({'msg': 'Success'}), 200
data = dict(name=name, email=email, password=password)
return test_url(url, method="POST", data=data, auth=False)
def test_login(email='', password=''):
url = 'http://*****:*****@gmail.com'
password = "******"
existing_user = User.get_or_none(User.email == email)
if existing_user:
existing_user.delete_instance()
# Must Fail (Sign Up)
assert_msg(test_signup(name="", email=email, password=password),
"Missing name") # Empty Name
assert_msg(test_signup(name=name, email="", password=password),
"Missing email") # Empty Email
assert_msg(test_signup(name=name, email=email, password=''),
"Missing password") # Empty Password
assert_msg(
test_signup(name=name,
email='*****@*****.**',
password=password),
"This email has been registered! Try another email!") # Taken Email
def userExists():
userId = flask.request.args.get('userId')
user = User.get_or_none(User.userId == userId)
return flask.jsonify(user is not None), 200
def likes(self):
from models.relation_like import LikeRelation
return User.select().join(
LikeRelation,
pw.JOIN.LEFT_OUTER).where(LikeRelation.recipe == self)
def query_user_update_details(**kw):
"""
Update user details
:param kw:
:key "user_id": user unique id, required
:key "user_first_name": (```str```, optional) new user first name
:key "user_last_name": (```str```, optional) new user last name
:key "user_phone": (```str```, optional) new user phone
:key "user_street1": (```str```, optional) new user street1
:key "user_street2": (```str```, optional) new user street2
:key "user_city": (```str```, optional) new user city
:key "user_state": (```str```, optional) new user state
:key "user_country": (```str```, optional) new user country
:key "user_zip": (```str```, optional) new user zip
\nAt least one key must be provided
:return: 1 if succeeded
"""
if 'user_id' not in kw:
raise MongoError(ErrorCode.MONGODB_MISSING_USER_ID)
for arg in kw:
if type(kw[arg]) != str:
raise MongoError(ErrorCode.MONGODB_STR_EXPECTED)
users = query_user_get_by_id(kw['user_id'])
if len(users) == 0:
raise MongoError(ErrorCode.MONGODB_USER_NOT_FOUND)
id = kw['user_id']
if 'user_first_name' in kw:
User.objects(id=id).update(
set__user_detail__user_first_name=kw['user_first_name'])
if 'user_last_name' in kw:
User.objects(id=id).update(
set__user_detail__user_last_name=kw['user_last_name'])
if 'user_phone' in kw:
User.objects(id=id).update(
set__user_detail__user_phone=kw['user_phone'])
if 'user_street1' in kw:
User.objects(id=id).update(
set__user_detail__user_street1=kw['user_street1'])
if 'user_street2' in kw:
User.objects(id=id).update(
set__user_detail__user_street2=kw['user_street2'])
if 'user_city' in kw:
User.objects(id=id).update(
set__user_detail__user_city=kw['user_city'])
if 'user_state' in kw:
User.objects(id=id).update(
set__user_detail__user_state=kw['user_state'])
if 'user_country' in kw:
User.objects(id=id).update(
set__user_detail__user_country=kw['user_country'])
if 'user_zip' in kw:
User.objects(id=id).update(set__user_detail__user_zip=kw['user_zip'])
return 1
def get_user(userId: str):
user = User.get_or_none(User.userId == userId)
return flask.jsonify({'msg': 'Success', 'data': user.as_dict()}), 200
def get_users():
query = User.select()
users = [c for c in query]
user_dicts = [c.as_dict() for c in users]
return flask.jsonify({'msg': 'Success', 'data': user_dicts}), 200
def wrapper(userId, *args, **kwargs):
user = User.get_or_none(User.userId == userId)
if user:
return func(userId, *args, **kwargs)
else:
return flask.jsonify({'msg': 'User does not exists'}), 400
def query_user_search_by_pattern(**kw):
"""
search user by pattern (re.Pattern)
:param kw: keyword arguments
:key "user_name": (optional) single keyword of username to be searched
:key "user_email": (optional) single keyword of email to be searched
:key "user_first_name": (optional) single keyword of first name to be
searched
:key "user_last_name": (optional) single keyword of last name to be
searched
:key "user_phone": (optional) single keyword of phone to be searched
:key "user_street1": (optional) single keyword of street1 to be
searched
:key "user_street2": (optional) single keyword of street2 to be
searched
:key "user_city": (optional) single keyword of city to be searched
:key "user_state": (optional) single keyword of state to be searched
:key "user_country": (optional) single keyword of country to be
searched
:key "user_zip": (optional) single keyword of zip to be searched
:key "user_status": (optional) single keyword of status to be searched
\nAt least one key must be provided
:return: array of searching results (User Model)
"""
# Check input param
if len(kw) == 0:
raise MongoError(ErrorCode.MONGODB_EMPTY_PARAM)
for arg in kw:
if type(kw[arg]) != re.Pattern:
raise MongoError(ErrorCode.MONGODB_RE_PATTERN_EXPECTED)
if 'pattern_name' in kw:
return User.objects(user_name=kw['pattern_name'])
elif 'pattern_email' in kw:
return User.objects(user_email=kw['pattern_email'])
elif 'pattern_first_name' in kw:
return User.objects(
user_detail__user_first_name=kw['pattern_first_name'])
elif 'pattern_last_name' in kw:
return User.objects(
user_detail__user_last_name=kw['pattern_last_name'])
elif 'pattern_phone' in kw:
return User.objects(user_detail__user_phone=kw['pattern_phone'])
elif 'pattern_street1' in kw:
return User.objects(user_detail__user_street1=kw['pattern_street1'])
elif 'pattern_street2' in kw:
return User.objects(user_detail__user_street2=kw['pattern_street2'])
elif 'pattern_city' in kw:
return User.objects(user_detail__user_city=kw['pattern_city'])
elif 'pattern_state' in kw:
return User.objects(user_detail__user_state=kw['pattern_state'])
elif 'pattern_country' in kw:
return User.objects(user_detail__user_country=kw['pattern_country'])
elif 'pattern_zip' in kw:
return User.objects(user_detail__user_zip=kw['pattern_zip'])
elif 'pattern_status' in kw:
return User.objects(user_status=kw['pattern_status'])
raise MongoError(ErrorCode.MONGODB_INVALID_SEARCH_PARAM)