def login(data):
# Assign vars
email = data["email"]
password = data["password"]
try:
# Fetch user data
user = User.query.filter_by(email=email).first()
if not (user):
return err_resp(
"The email you have entered does not match any account.",
"email_404",
404,
)
elif user and user.verify_password(password):
user_info = user_schema.dump(user)
access_token = create_access_token(identity=user.id)
resp = message(True, "Successfully logged in.")
resp["access_token"] = access_token
resp["user"] = user_info
return resp, 200
return err_resp("Failed to log in, password may be incorrect.",
"password_invalid", 401)
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
def register(data):
# Assign vars
## Required values
email = data["email"]
username = data["username"]
password = data["password"]
## Optional
data_name = data.get("name")
# Check if the email is taken
if User.query.filter_by(email=email).first() is not None:
return err_resp("Email is already being used.", "email_taken", 403)
# Check if the username is taken
if User.query.filter_by(username=username).first() is not None:
return err_resp("Username is already taken.", "username_taken",
403)
try:
new_user = User(
email=email,
username=username,
name=data_name,
password=password,
joined_date=datetime.utcnow(),
)
db.session.add(new_user)
db.session.flush()
# Load the new user's info
user_info = user_schema.dump(new_user)
# Commit changes to DB
db.session.commit()
# Create an access token
access_token = create_access_token(identity=new_user.id)
resp = message(True, "User has been registered.")
resp["access_token"] = access_token
resp["user"] = user_info
return resp, 201
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
class AuthService:
@staticmethod
def login(data):
# Assign vars
email = data["email"]
password = data["password"]
try:
# Fetch user data
if not (user := User.query.filter_by(email=email).first()):
return err_resp(
"The email you have entered does not match any account.",
"email_404",
404,
)
elif user and user.verify_password(password):
user_info = user_schema.dump(user)
access_token = create_access_token(identity=user.id)
resp = message(True, "Successfully logged in.")
resp["access_token"] = access_token
resp["user"] = user_info
return resp, 200
return err_resp("Failed to log in, password may be incorrect.",
"password_invalid", 401)
def login(data):
# Assign vars
email = data["email"]
password = data["password"]
try:
# Fetch user data
if not (user :=
User.objects(email=email).get_not_trashed().first()):
return err_resp(
"ایمیل یا رمزعبور صحیح نمیباشد.",
"credentials_mismatch",
401,
)
elif user and user.check_password(password):
user_info = user_schema.dump(user)
access_token = create_access_token(identity=str(user.id))
refresh_token = create_refresh_token(identity=str(user.id))
resp = message(True, "ورود موفقیت آمیز.")
resp["access_token"] = access_token
resp["refresh_token"] = refresh_token
resp["user"] = user_info
return resp, 200
def update_data(data, public_id, current_user):
""" Update a Project """
if not data:
return message(True, "Nothing to update."), 204
if not (project :=
Project.query.filter_by(public_id=public_id).first()):
return err_resp("Project not found!", "project_404", 404)
def update(audio_id, file_type, file):
audio_service = AudioService.audios[FiletypeEnum(file_type).value]
content_type = file.content_type
if content_type.split("/")[0] != "audio":
return err_resp("Only Audio file format is allowed",
"invalid_audio_format", 400)
audio = audio_service.get_object(audio_id)
uploaded_time = datetime.datetime.now()
if audio:
fname = secure_filename(file.filename)
fname = f"{uploaded_time}__{audio.id}__{fname}"
save_path = AudioService.check_upload_dir(file_type) / fname
file.save(save_path.__str__())
resp = audio_service.update(audio_id, save_path, uploaded_time)
return resp
else:
resp = err_resp("Audio data not found in database", "404_notfound",
404)
return resp
def create(data, project_public_id, current_user):
# Assign the vars
caption = data["caption"]
image_hash = data.get("image_hash")
# Check if the project exists
if not (project :=
Project.query.filter_by(public_id=project_public_id).first()):
return err_resp("Can't create post without project.",
"project_404", 404)
def create(data: dict):
try:
filetype = data["filetype"]
data.pop("filetype")
resp = getattr(AudioService.audios[filetype],
"create").__call__(data)
return resp
except KeyError as reason:
return err_resp(
f"{reason} is not a valid audio file type, try one"
f" of audio_book, song or podcast", "400_badRequest", 400)
def put(self, file_type, audio_id):
""" Upload an audio file given its id and file type"""
try:
file = request.files[file_type]
return AudioService.update(audio_id, file_type, file)
except BadRequestKeyError as e:
current_app.logger.exception("file not found in the request files",
e)
return err_resp(
"Unable to find file in request files.."
" please kindly use the filetype passed"
" ast path param as the key while uploading",
"bad_request_400", 400)
def get_user_data(username):
""" Get user data by username """
user = User.query.filter_by(username=username).first()
if not (user):
return err_resp("User not found!", "user_404", 404)
from .utils import load_data
try:
user_data = load_data(user)
resp = message(True, "User data sent")
resp["user"] = user_data
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
def create(data, current_user):
# Assign the vars
title = data["title"]
difficulty = data["difficulty"]
time_required = data["time_required"]
abstract = data["abstract"]
objective = data["objective"]
safety = data.get("safety")
content = data["content"]
category_id = data["category_id"]
# Check if current_user is a creator.
if not current_user.has_role(Permission.CREATE):
return err_resp("User is not a creator.", "user_not_creator", 403)
# Create a new project
try:
from uuid import uuid4
from .utils import create_and_load
project = Project(
public_id=str(uuid4().int)[:15],
creator_id=current_user.id,
title=title,
difficulty=difficulty,
time_required=time_required,
abstract=abstract,
objective=objective,
safety=safety,
content=content,
category_id=category_id,
)
project_data = create_and_load(project)
resp = message(True, "Project created.")
resp["project"] = project_data
return resp, 201
except Exception as error:
current_app.logger.error(error)
return internal_err_resp
def get_all_user_data():
""" Get user data by username """
users = User.query.all()
if not (users):
return err_resp("User not found!", "user_404", 404)
from .utils import load_data
try:
user_data_list = []
for user in users:
user_data = load_data(user)
if user_data:
user_data_list.append(user_data)
resp = message(True, "User data sent")
resp["users"] = user_data_list
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
def update(audio_id, file_path, uploaded_time):
if not (podcast := Podcast.query.get(audio_id)):
return err_resp("Podcast not found", "podcast_404", 404)
def get(pdcast_id):
if not (song := Podcast.query.get(pdcast_id)):
return err_resp("Podcast file not found", "audio_404", 404)
def get_data(public_id):
""" Get Post data by its public id """
if not (post := Post.query.filter_by(public_id=public_id).first()):
return err_resp("Post not found!", "post_404", 404)
def update(data, public_id, current_user):
if not (post := Post.query.filter_by(public_id=public_id).first()):
return err_resp("Post not found.", "post_404", 404)
def get_data(public_id):
""" Get Project data by its public id """
if not (project :=
Project.query.filter_by(public_id=public_id).first()):
return err_resp("Project not found!", "project_404", 404)
def get_user_data(username):
""" Get user data by username """
if not (user := User.query.filter_by(username=username).first()):
return err_resp("User not found!", "user_404", 404)
def get(song_id):
if not (song := Song.query.get(song_id)):
return err_resp("Song not found", "audio_404", 404)
def get_playlist_data(playlist_id):
""" Get playlist data by playlist_id """
if not (playlist := Playlist.query.filter_by(id=playlist_id).first()):
return err_resp("Playlist not found!", "playlist_404", 404)
def update(audio_id, file_path, uploaded_time):
if not (song := Song.query.get(audio_id)):
return err_resp("Song not found", "song_404", 404)
if (post.author.public_id == current_user.public_id
or current_user.has_role(Permission.MODERATE)
or current_user.has_role(Permission.ADMIN)):
try:
from .utils import delete_post
delete_post(post)
resp = message(True, "Post deleted.")
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
return err_resp("Insufficient permissions!", "user_unauthorized", 401)
@staticmethod
def update(data, public_id, current_user):
if not (post := Post.query.filter_by(public_id=public_id).first()):
return err_resp("Post not found.", "post_404", 404)
# Check if the current user is the owner.
if post.author.public_id == current_user.public_id:
try:
from app import db
if (caption := data.get("caption")):
post.caption = caption
# Commit changes to db.
def get_user_data(id):
""" Get user data by id """
if not (user := User.query.filter_by(id=id).first()):
return err_resp("User not found!", "user_404", 404)
def update_airport(id, data):
"""Update a specific airport by id"""
if not (airport := Airport.query.filter_by(id=id).first()):
return err_resp("Airport not found!", "airport_404", 404)
def get_track_data(track_id):
""" Get track data by track_id """
if not (track := Track.query.filter_by(id=track_id).first()):
return err_resp("Track not found!", "track_404", 404)
from app import db
for key, value in data.items():
# Make sure that the key is allowed to be updated.
if key in allowed:
setattr(project, key, value)
db.session.commit()
return message(True, "Post data updated."), 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
return err_resp("User is not the creator.", "user_unauthorized", 401)
@staticmethod
def create(data, current_user):
# Assign the vars
title = data["title"]
difficulty = data["difficulty"]
time_required = data["time_required"]
abstract = data["abstract"]
objective = data["objective"]
safety = data.get("safety")
content = data["content"]
category_id = data["category_id"]
def get_airport_data(id):
""" Get airport data by id """
if not (airport := Airport.query.filter_by(id=id).first()):
return err_resp("Airport not found!", "airport_404", 404)
def delete(public_id, current_user):
if not (post := Post.query.filter_by(public_id=public_id).first()):
return err_resp("Post not found.", "project_404", 404)
