def GetUserStats(username):
user_stats = db.GetUserStats(username)
if (user_stats == None):
log2term(
'E',
f'Failed to fetch stats for user {username} from the database')
return {}
log2term('I', f"Fetched stats for user {username} from the database")
return user_stats.to_dictionary()
def GetVideo(video_id):
user = db.GetVideo(video_id)
if user == None:
log2term(
'E',
f"Failed to fetch video data for video {video_id} from the database"
)
return {}
log2term('I', f"Fetched information for video with ID {video_id}")
return user.to_dictionary()
def readYAML(filename=str):
try:
stream = open("config.yaml", 'r')
config = yaml.safe_load(stream)
except yaml.YAMLError as e:
log2term('F', f'While opening config file: {e}')
os.kill(pid, signal.SIGINT) # Kill server
flask_logs_dict = config["flask_logs"]
me.set(flask_logs_dict["address"], flask_logs_dict["port"])
def NewAdmin(username):
new_admin = db.NewAdmin(username)
if new_admin == None:
log2term('E',
f"Failed to add user {username} as admin to the database")
return {}
log2term(
'I',
f"User with username {username} was successfully promoted to admin")
return {"username": new_admin}
def GetUser(username):
user = db.GetUser(username)
if (user == None):
log2term(
'W',
f"There's no user with username {username} registered in the database"
)
return {}
log2term('I', f"Fetched information for user {username} from the database")
return user.to_dictionary()
def GetAdmin(username):
admin = db.GetAdmin(username)
if (admin == None):
log2term(
'W',
f"There's no admin with username {username} registered in the database"
)
return {}
log2term('I', f"User with username {username} is an admin")
return admin.to_dictionary()
def NewVideo(username):
video_data = request.get_json()
url = video_data["url"]
desc = video_data["desc"]
video_id = db.NewVideo(url, desc, username)
if video_id == None:
log2term('E', 'Failed to add new video to the database')
return {}
log2term('I', f'New video with ID {video_id} was added to the database')
return {"video_id": video_id}
def NewAnswer(question_id):
answer_data = request.get_json()
username = answer_data["username"]
answer = answer_data["answer"]
new_answer = db.NewAnswer(answer, question_id, username)
if new_answer == None:
log2term(
'E',
f'Failed to create new answer for question with ID {question_id}')
return {}
log2term('I', f'Created new answer with ID {new_answer}')
return {"answer_id": new_answer}
def NewQuestion(video_id):
question_data = request.get_json()
username = question_data["username"]
question = question_data["question"]
instant = question_data["instant"]
new_question = db.NewQuestion(question, instant, username, video_id)
if new_question == None:
log2term(
'E', f'Failed to create new question for video with Id {video_id}')
return {}
log2term('I', f'Created new question with ID {new_question}')
return {"question_id": new_question}
def GetVideos(username):
# Fetch videos according to username
user_videos = []
other_users_videos = []
my_videos = db.GetUserVideos(username)
other_videos = db.GetOtherUsersVideos(username)
if (my_videos == None):
log2term('W', f'There were no videos found for user {username}')
else:
log2term('I', f"Fetched all the videos posted by uder {username}")
for video in my_videos:
video_dict = video.to_dictionary()
user_videos.append(video_dict) # This is a list
# Create a list with all of the videos from other users
if (other_videos == None):
log2term('W',
f'There were no videos found for other users ({username})')
else:
log2term(
'I',
f"Fetched all the videos which weren't posted by user {username}")
for video in other_videos:
video_dict = video.to_dictionary()
other_users_videos.append(video_dict) # This is a list
return {
'user_videos': user_videos,
"other_users_videos": other_users_videos
} # A dict must be returned
def GetUsers():
# Get entire list of users (including users who are admins)
all_users = db.ListAllUsers()
if (all_users == None):
log2term('W', f"There are no users registered in the database")
return {"users": None}
users = []
for user in all_users:
user_dict = user.to_dictionary()
users.append(user_dict)
log2term('I', f"Fetched entire list of users from the database")
return {"users": users}
def GetAdmins():
# Get entire lis of admins
all_admins = db.ListAllAdmins()
if (all_admins == None):
log2term('W', f"There are no admins registered in the database")
return {"admins": None}
admins = []
for admin in all_admins:
admin_dict = admin.to_dictionary()
admins.append(admin_dict)
log2term('I', f"Fetched entire list of admins from the database")
return {"admins": admins}
def AdminExists(username) -> bool:
response = requests.get(
f"http://{flask_users.addr}:{flask_users.port}/API/admins/{username}/")
if response.json() == {}:
log2term('W', f"User with username {username} is not an admin")
return False
# Log the request to the users flask server
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.GET_ADMIN.value}",\n"username": "******",\n"origin_addr": "{me.addr}",\n"origin_port": "{me.port}",\n"dest_addr": "{flask_users.addr}",\n"dest_port": "{flask_users.port}",\n"content": "{username}"\n}}'
requests.post(url, headers=headers, data=body)
log2term('D', f"User {username} is an admin")
return True
def GetLogs():
# Get entire list of logs
all_logs = db.ListAllLogs()
if (all_logs == None):
log2term('W', f"There are no logs registered in the database")
return {"logs": None}
logs = []
for log in all_logs:
log_dict = log.to_dictionary()
log_dict["event_type"] = str(EventType(log_dict["event_type"]).name)
logs.append(log_dict)
log2term('I', f"Fetched entire list of logs from the database")
return {"logs": logs}
def NewQuestion(video_id):
question_data = request.get_json()
username = question_data["username"]
# Log the request to the proxy
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.POST_NEW_QUESTION.value}",\n"username": "******",\n"origin_addr": "-",\n"origin_port": "-",\n"dest_addr": "{me.addr}",\n"dest_port": "{me.port}",\n"content": "For video {video_id}"\n}}'
requests.post(url, headers=headers, data=body)
if VideoExists(video_id) == False:
log2term(
'E',
f"Can't create a question about video {video_id} since the video doesn't exist in the database"
)
return {}
if UserExists(username) == False:
log2term(
'E',
f"Can't create the question submitted by user {username} since this user doesn't exist in the database"
)
return {}
response = requests.post(
f"http://{flask_QAs.addr}:{flask_QAs.port}//API/videos/{video_id}/new_question/",
json=question_data)
if response != None:
question_id = response.json()
question_id = question_id["question_id"]
# Log the request to the QAs flask server
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.POST_NEW_QUESTION.value}",\n"username": "******",\n"origin_addr": "{me.addr}",\n"origin_port": "{me.port}",\n"dest_addr": "{flask_QAs.addr}",\n"dest_port": "{flask_QAs.port}",\n"content": "New question with ID {question_id} for video {video_id}"\n}}'
requests.post(url, headers=headers, data=body)
requests.put(
f"http://{flask_users.addr}:{flask_users.port}/API/{username}/stats/questions/"
)
# Log the request to the users flask server
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.PUT_USERSTATS_QUESTION.value}",\n"username": "******",\n"origin_addr": "{me.addr}",\n"origin_port": "{me.port}",\n"dest_addr": "{flask_users.addr}",\n"dest_port": "{flask_users.port}",\n"content": "For user {username}, regarding question {question_id}"\n}}'
requests.post(url, headers=headers, data=body)
return response.json()
def QuestionExists(question_id) -> bool:
response = requests.get(
f"http://{flask_QAs.addr}:{flask_QAs.port}/API/questions/{question_id}/"
)
if response.json() == {}:
log2term('W', f"There's no question with ID {question_id}")
return False
# Log the request to the QAs flask server
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.GET_QAS.value}",\n"username": "******",\n"origin_addr": "{me.addr}",\n"origin_port": "{me.port}",\n"dest_addr": "{flask_QAs.addr}",\n"dest_port": "{flask_QAs.port}",\n"content": "{question_id}"\n}}'
requests.post(url, headers=headers, data=body)
log2term('D', f"Question with ID {question_id} exists in the database")
return True
def NewAnswer(question_id):
answer_data = request.get_json()
username = answer_data["username"]
# Log the request to the proxy
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.POST_NEW_ANSWER.value}",\n"username": "******",\n"origin_addr": "-",\n"origin_port": "-",\n"dest_addr": "{me.addr}",\n"dest_port": "{me.port}",\n"content": "For question {question_id}"\n}}'
requests.post(url, headers=headers, data=body)
if QuestionExists(question_id) == False:
log2term(
'E',
f"Can't create an answer to question {question_id} since it doesn't exist in the database"
)
return {}
if UserExists(username) == False:
log2term(
'E',
f"Can't create an answer submitted by user {username} since this user doesn't exist in the database"
)
return {}
response = requests.post(
f"http://{flask_QAs.addr}:{flask_QAs.port}/API/questions/{question_id}/new_answer/",
json=answer_data)
response_json = response.json()
if response != None:
# Log the request to the QAs flask server
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.POST_NEW_ANSWER.value}",\n"username": "******",\n"origin_addr": "{me.addr}",\n"origin_port": "{me.port}",\n"dest_addr": "{flask_QAs.addr}",\n"dest_port": "{flask_QAs.port}",\n"content": "For question {question_id}. New answer with ID {response_json["answer_id"]}"\n}}'
requests.post(url, headers=headers, data=body)
requests.put(
f"http://{flask_users.addr}:{flask_users.port}/API/{username}/stats/answers/"
)
# Log the request to the users flask server
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.PUT_USERSTATS_ANSWER.value}",\n"username": "******",\n"origin_addr": "{me.addr}",\n"origin_port": "{me.port}",\n"dest_addr": "{flask_users.addr}",\n"dest_port": "{flask_users.port}",\n"content": "For user {username}, regarding answer {response_json["answer_id"]}"\n}}'
requests.post(url, headers=headers, data=body)
return response_json
def NewUser(username):
user_data = request.get_json()
email = user_data["email"]
name = user_data["name"]
new_user = db.NewUser(username, email, name)
# Check if user was added to de DB
if new_user == None:
log2term('E', f"Failed to add user {username} to the database")
return {}
log2term(
'I',
f"New user with username {username} was successfully added to the database"
)
return {"username": new_user}
def NewLog():
log_data = request.get_json()
event_type = log_data["event_type"]
username = log_data["username"]
origin_addr = log_data["origin_addr"]
origin_port = log_data["origin_port"]
dest_addr = log_data["dest_addr"]
dest_port = log_data["dest_port"]
content = log_data["content"]
log_id = db.NewLog(event_type, username, origin_addr, origin_port,
dest_addr, dest_port, content)
if log_id == None:
log2term('E', 'Failed to add log to the database')
return {}
log2term('I', f'New log with ID {log_id} was added to the database')
return {"log_id": log_id}
def NewVideo(username):
data = request.get_json()
# Log the request to the proxy
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.POST_NEW_VIDEO.value}",\n"username": "******",\n"origin_addr": "-",\n"origin_port": "-",\n"dest_addr": "{me.addr}",\n"dest_port": "{me.port}",\n"content": "-"\n}}'
requests.post(url, headers=headers, data=body)
if UserExists(username) == False:
return {}
response = requests.post(
f"http://{flask_videos.addr}:{flask_videos.port}/API/{username}/videos/",
json=data)
if response.json() == {}:
log2term('E', f"Failed to add new video to the database")
return {}
video_id = response.json()
video_id = video_id["video_id"]
log2term('D', f"Video with ID {video_id} was added to the database")
# Log the request to the videos flask server
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.POST_NEW_VIDEO.value}",\n"username": "******",\n"origin_addr": "{me.addr}",\n"origin_port": "{me.port}",\n"dest_addr": "{flask_videos.addr}",\n"dest_port": "{flask_videos.port}",\n"content": "New video with ID {video_id}"\n}}'
requests.post(url, headers=headers, data=body)
requests.put(
f"http://{flask_users.addr}:{flask_users.port}/API/{username}/stats/videos<Z/"
)
# Log the request to the users flask server (to iterate the videos counter un the user's stats)
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.PUT_USERSTATS_VIDEO.value}",\n"username": "******",\n"origin_addr": "{me.addr}",\n"origin_port": "{me.port}",\n"dest_addr": "{flask_users.addr}",\n"dest_port": "{flask_users.port}",\n"content": "For user {username} regarding video {video_id}"\n}}'
requests.post(url, headers=headers, data=body)
return response.json()
def NewUser(username, email, name):
if UserExists(username) == True:
log2term(
'E',
f"Can't add user {username} to users databse since it already exists"
)
return {}
url = f'http://{flask_users.addr}:{flask_users.port}/API/new_user/{username}/'
body = f'{{"name":"{name}", "email":"{email}"}}'
json_body = json.loads(body)
response = requests.post(url, json=json_body)
if response.json() == {}:
log2term('E', f"Failed to add user {username} to the database")
return {}
# Log the request to the users flask server
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.POST_NEW_USER.value}",\n"username": "******",\n"origin_addr": "{me.addr}",\n"origin_port": "{me.port}",\n"dest_addr": "{flask_users.addr}",\n"dest_port": "{flask_users.port}",\n"content": "{username}"\n}}'
requests.post(url, headers=headers, data=body)
log2term(
'D',
f"New user with username {username} was successfully added to the database"
)
return response.json()
def Dashboard():
# Check if user is loggen in
if fenix_blueprint.session.authorized == False:
return redirect(url_for("fenix-example.login"))
else:
try:
print("HERE")
user_data = (
fenix_blueprint.session.get("/api/fenix/v1/person/")).json()
print("HERE")
except TokenExpiredError as e:
log2term('E', f'{e.__class__.__name__}. Logging out...')
return redirect(url_for("LogOut"))
# Extract user information
username = user_data['username']
email = user_data['email']
name = user_data['name']
# Check if user already exists in DB
is_admin = False
if UserExists(username) == False:
NewUser(username=username, email=email, name=name)
log2term('I', f'New user {username} registered to the database')
else:
log2term('I',
f'User {username} is already registered to the database')
# Checking if user, that already exists, is an admin
if AdminExists(username) == True:
is_admin = True
log2term('I', f'User {username} is an admin')
else:
log2term('I', f'User {username} is not an admin')
return render_template("dashboard.html",
username=username,
is_admin=is_admin)
def Video(video_id):
# Check if user is loggen in
if fenix_blueprint.session.authorized == False:
return redirect(url_for("fenix-example.login"))
else:
try:
user_data = (
fenix_blueprint.session.get("/api/fenix/v1/person/")).json()
except TokenExpiredError as e:
log2term('E', f'{e.__class__.__name__}. Logging out...')
return redirect(url_for("LogOut"))
# Extract user information
username = user_data['username']
# Check if video is registered to the database
if VideoExists(video_id) == False:
log2term('E', f"Video {video_id} doesn't exist in the database")
return abort(404)
# Get video information needed for the html template
video_info = GetVideo(video_id)
# Find the author's name through its username
response = requests.get(
f'http://{flask_users.addr}:{flask_users.port}/API/users/{video_info["posted_by"]}/'
)
user = response.json()
user_name = user["name"]
return render_template("video.html",
video_id=video_id,
video_url=video_info["url"],
video_desc=video_info["desc"],
video_posted_by=video_info["posted_by"],
video_posted_by_name=user_name,
video_views=video_info["views"],
username=username)
def GetUserStats(username):
# Log the request to the proxy
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.GET_USERSTATS.value}",\n"username": "******",\n"origin_addr": "-",\n"origin_port": "-",\n"dest_addr": "{me.addr}",\n"dest_port": "{me.port}",\n"content": "{username}"\n}}'
requests.post(url, headers=headers, data=body)
if UserExists(username) == False:
return {}
response = requests.get(
f"http://{flask_users.addr}:{flask_users.port}/API/{username}/stats/")
if (response == None):
log2term('W', f'There were no stats found for user {username}')
return {}
# Log the request to the users flask server
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.GET_USERSTATS.value}",\n"username": "******",\n"origin_addr": "{me.addr}",\n"origin_port": "{me.port}",\n"dest_addr": "{flask_users.addr}",\n"dest_port": "{flask_users.port}",\n"content": "{username}"\n}}'
requests.post(url, headers=headers, data=body)
return response.json()
def NewAdmin(username):
data = request.get_json()
author = data["author"] # Post request's author
# Log the request to the proxy
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.POST_NEW_ADMIN.value}",\n"username": "******",\n"origin_addr": "-",\n"origin_port": "-",\n"dest_addr": "{me.addr}",\n"dest_port": "{me.port}",\n"content": "{username}"\n}}'
requests.post(url, headers=headers, data=body)
if UserExists(username) == False:
log2term(
'E',
f"Can't promote user {username} to admin since it doesn't exist in the users database"
)
return {}
# Check if admin is already registered to the database
if AdminExists(username) == True:
log2term(
'E',
f"Can't promote user {username} to admin since that user is already an admin"
)
return {}
response = requests.post(
f"http://{flask_users.addr}:{flask_users.port}/API/new_admin/{username}/"
)
if response == None:
log2term('E',
f"Failed to add user {username} as admin to the database")
return {}
log2term('I',
f"Successfully added user {username} as admin to the database")
# Log the request to the users flask server
url = f"http://{flask_logs.addr}:{flask_logs.port}/API/new_log/"
headers = {'Content-Type': 'application/json'}
body = f'{{\n"event_type": "{EventType.POST_NEW_ADMIN.value}",\n"username": "******",\n"origin_addr": "{me.addr}",\n"origin_port": "{me.port}",\n"dest_addr": "{flask_users.addr}",\n"dest_port": "{flask_users.port}",\n"content": "{username}"\n}}'
requests.post(url, headers=headers, data=body)
return response.json()
def GetVideoQuestionsAndAnswers(video_id):
# Fetch videos according to username
video_questions = []
questions = db.GetVideoQuestions(video_id)
if (questions == None):
log2term(
'W', f'There were no questions found for video with ID {video_id}')
else:
log2term('I',
f'Fetched all the questions for video with ID {video_id}')
for question in questions:
question_dict = question.to_dictionary()
# Fetch question answers
question_answers = []
answers = db.GetQuestionAnswers(question_dict["id"])
if (answers == None):
log2term(
'W',
f'There were no answers found for question with ID {question_dict["id"]}'
)
else:
log2term(
'I',
f'Fetched all the answers for question with ID {question_dict["id"]}'
)
for answer in answers:
answer_dict = answer.to_dictionary()
question_answers.append(answer_dict)
# Adding question's answers to question's dict
question_dict["answers"] = question_answers
# Add question's info to question' list
video_questions.append(question_dict)
return {"video_questions": video_questions}
def AddAnswer(username):
user_answers = db.Add2Answers(username)
log2term('I',
f"The answers counter was iterated in user {username}'s stats")
return {"user_answers": user_answers}
def AddQuestion(username):
user_questions = db.Add2Questions(username)
log2term('I',
f"The questions counter was iterated in user {username}'s stats")
return {"user_questions": user_questions}
def AddView(username):
user_views = db.AddView2User(username)
log2term('I', f"The views counter was iterated in user {username}'s stats")
return {"user_views": user_views}
def AddVideo(username):
user_videos = db.Add2VideosPosted(username)
log2term('I',
f"The videos counter was iterated in user {user_videos}'s stats")
return {"user_videos": user_videos}
