def video_comments(user_info, video_id):
if request.method == 'POST':
result, err = video_service.addCommentToVideo(int(user_info["id"]), video_id, request.json)
if err:
return err
return success_response(201, result)
else:
result, err = video_service.getCommentsFromVideo(video_id)
if err:
return err
return success_response(200, result)
def authorize_user(self, token):
email = get_email(token)
if email not in self.db:
return error_response(401, 'Invalid Token')
user = self.db[email]
response_data = {'user': get_fields(user)}
return success_response(200, response_data)
def user_profile(user_info, user_id):
if request.method == 'GET':
requester_id = int(user_info["id"])
app.logger.debug(
"/users/%s || Requesting AuthServer for user profile", user_id)
response = users_service.getUserProfile(user_id)
if response.status_code != 200 or requester_id == user_id:
return response
profile_data = json.loads(response.get_data())
profile_data[
'friendship_status'] = users_service.getFriendshipStatus(
requester_id, user_id)
return success_response(200, profile_data)
if request.method == 'PUT':
requester_id = int(user_info["id"])
if requester_id != user_id:
return error_response(403, 'Forbidden')
return users_service.editUserProfile(user_id, request.get_json())
if request.method == 'DELETE':
if user_info != {} and not app.config[
'TESTING']: #It is only allowed to the webadmin to use
return error_response(403, 'Forbidden')
# Delete videos
video_service.removeLikesFromUser(user_id)
video_service.deleteCommentsFromUser(user_id)
response = video_service.deleteVideos(user_id)
return response if response.status_code != 204 else users_service.deleteUserProfile(
user_id)
def get_user_videos(self, user_id, video_searching):
response_data = []
for video_id, video in self.db.items():
is_private = (video['visibility'] == 'private' and 'visibility' not in video_searching)
if video['user_id'] == user_id and not is_private:
response_data.append(get_fields(video_id, video))
return success_response(200, response_data)
def user_pending_requests(user_info):
pending_ids = users_service.getPendingRequests(int(user_info["id"]))
app.logger.debug(
"/users/my_requests || %d user profiles to fetch from Auth Server",
len(pending_ids))
response_data = users_service.fetchUsersNames(pending_ids)
app.logger.debug("/users/my_requests || Fetched %d user profiles",
len(response_data))
return success_response(200, response_data)
def deleteVideos(self, user_id):
response = self.listVideosFromUser(user_id)
if response.status_code != 200:
return response
videos_data = json.loads(response.get_data())
for video in videos_data:
video_id = video['id']
response = self.deleteVideo(video_id)
if response.status_code != 204:
return response
return success_response(204, 'Videos deleted successfully')
def login(self, data):
email = data['email']
password = data['password']
if email not in self.db:
return error_response(401, 'Wrong credentials')
if not check_password_hash(password, self.db[email]['password']):
return error_response(401, 'Wrong credentials')
user = self.db[email]
response_data = {'token': get_token(email), 'user': get_fields(user)}
return success_response(200, response_data)
def get_video(user_info, video_id):
requester_id = int(user_info["id"])
video, err = video_service.getVideo(requester_id, video_id)
if err:
return err
if request.method == 'GET':
return success_response(200, video)
elif request.method == 'PATCH':
if requester_id != video['user_id']:
return error_response(403, 'Forbidden')
return video_service.editVideo(video_id, request.get_json())
elif request.method == 'DELETE':
if requester_id != video['user_id']:
return error_response(403, 'Forbidden')
return video_service.deleteVideo(video_id)
def user_friends(user_info, user_id):
if request.method == 'POST':
response = users_service.getUserProfile(user_id)
if response.status_code != 200:
return error_response(404, "Can't befriend inexistent user")
err = users_service.acceptFriendRequest(int(user_info["id"]),
user_id)
if err:
return error_response(400, err)
notification_service.friendRequestAccepted(user_info,
response.get_json())
return success_response(
200, {"message": "Friend accepted successfully"})
else:
friends_ids = users_service.getFriends(user_id)
app.logger.debug(
"/users/%d/friends || %d user profiles to fetch from Auth Server",
user_id, len(friends_ids))
response_data = users_service.fetchUsersNames(friends_ids)
app.logger.debug("/users/%d/friends || Fetched %d user profiles",
user_id, len(response_data))
return success_response(200, response_data)
def user_friend_request(user_info, user_id):
app.logger.debug(
"/users/%s/friend_request || Requesting AuthServer for user profile",
user_id)
response = users_service.getUserProfile(user_id)
if response.status_code != 200:
return error_response(
404, "Can't send friend request to inexistent user")
err = users_service.sendFriendRequest(int(user_info['id']), user_id)
if err:
return error_response(400, err)
notification_service.newFriendRequest(user_info, response.get_json())
return success_response(
200, {"message": "Friendship request sent successfully"})
def edit_video(self, video_id, data):
if any(elemen in data for elemen in ['id', 'author', 'user_id', 'url', 'date']):
return error_response(400, 'Invalid values')
if not validate_visibility(data['visibility']):
return error_response(400, 'Invalid visibility')
if not video_id in self.db:
return error_response(404, 'Video not found')
video = self.db[video_id]
for k,v in data.items():
if k in video:
video[k] = v
return success_response(200, get_fields(video_id, video))
def oauth_login(self, data):
if not "_" in data["idToken"]:
return error_response(400, "Cant verify google credentials")
email = data["idToken"].split("_")[1]
if email not in self.db:
id = self.generate_id()
username = email.split('@')[0]
username = "******" + username
self.db[email] = {
'id': id,
'email': email,
'username': username,
'profile': {}
}
user = self.db[email]
response_data = {'token': get_token(email), 'user': get_fields(user)}
return success_response(200, response_data)
def register(self, data):
email = data["email"]
username = data['username']
password = data['password']
hashed_password = get_hash(password)
if email in self.db or any(user['username'] == username
for user in self.db.values()):
return error_response(409, 'User already registered')
if not validate(email):
return error_response(400, 'Invalid email address')
id = self.generate_id()
self.db[email] = {
'id': id,
'email': email,
'password': hashed_password,
'username': username,
'profile': {}
}
response_data = {'id': id}
return success_response(200, response_data)
def add_video(self, data):
url = data['url']
author = data['author']
title = data['title']
visibility = data['visibility']
user_id = data['user_id']
description = data['description'] if 'description' in data else ''
thumb = data['thumb'] if 'thumb' in data else ''
if any(video['url'] == url for video in self.db.values()):
return error_response(409, 'Video already uploaded')
date = datetime.strptime(data['date'], '%m/%d/%y %H:%M:%S')
if date > datetime.now():
return error_response(400, 'Invalid date')
if not validate_visibility(data['visibility']):
return error_response(400, 'Invalid visibility')
id = self.generate_id()
self.db[id] = {'author': author, 'title': title, 'description': description, 'date': date, 'visibility': visibility,
'url': url, 'thumb': thumb, 'user_id': user_id}
response_data = {'id': id}
return success_response(201, response_data)
def home_videos(user_info):
requester_id = int(user_info["id"])
friends_ids = users_service.getFriends(requester_id)[:]
friends_ids.append(requester_id)
return success_response(200, rule_engine.prioritize_videos(user_info,video_service.listVideos(friends_ids)))
def get_video(self, video_id):
if not video_id in self.db:
return error_response(404, 'Video not found')
video = self.db[video_id]
response_data = get_fields(video_id, video)
return success_response(200, response_data)
def get_videos(self):
response_data = []
for video_id, video in self.db.items():
response_data.append(get_fields(video_id, video))
return success_response(200, response_data)
def video_likes(user_info, video_id):
err = video_service.addLikeToVideo(int(user_info['id']), video_id, request.json['liked'])
if err:
return err
return success_response(200, {'result':'Like updated'})
def get_users(self):
response_data = list(
map(lambda user: get_fields(user), self.db.values()))
return success_response(200, response_data)
def get_user_profile(self, user_id_request):
for v in self.db.values():
if v['id'] == str(user_id_request):
return success_response(200, get_fields(v))
return error_response(404, "User not found")
def edit_user_profile(self, user_id, body):
for v in self.db.values():
if v['id'] == str(user_id):
v['profile'] = body
return success_response(200, get_fields(v))
return error_response(404, "User not found")
