def get_projects(page: int, category_name: str):
from .utils import load_projects_data
# Get projects from database.
if not category_name:
category_name = "science"
try:
category = Category.query.filter_by(name=category_name).first()
projects_query = (Project.query.filter_by(
category=category).order_by(Project.created.desc()).paginate(
page, current_app.config["PROJECTS_PER_PAGE"], False))
projects_data = load_projects_data(projects_query.items)
resp = message(True, "Projects data sent.")
resp["page"] = load_page_data(projects_query)
resp["projects"] = projects_data
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
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 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 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_data(data, user):
if not data:
return message(True, "Nothing to update."), 204
try:
from app import db
for key, value in data.items():
setattr(user, key, value)
# Commit changes to db.
db.session.commit()
return message(True, "User data updated."), 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
class PodcastService:
@staticmethod
def get(pdcast_id):
if not (song := Podcast.query.get(pdcast_id)):
return err_resp("Podcast file not found", "audio_404", 404)
try:
podcast_data = PodcastService.load_data(song)
resp = message(True, "Podcast data sent")
resp["podcast"] = podcast_data
return resp, 200
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()
def get_all_data():
""" Get all playlists data """
playlists = Playlist.query.all()
try:
playlist_data = playlists_schema.dump(playlists)
resp = message(True, "Playlists data sent")
resp["playlists"] = playlist_data
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
class SongService:
@staticmethod
def get(song_id):
if not (song := Song.query.get(song_id)):
return err_resp("Song not found", "audio_404", 404)
try:
song_data = SongService.load_data(song)
resp = message(True, "Song data sent")
resp["song"] = song_data
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
def __add_user(data, is_superuser=False):
# Required values
email = data["email"]
password = data["password"]
date_joined = data["date_joined"]
if type(date_joined) is str:
date_joined = dateutil.parser.parse(date_joined)
date_joined = date_joined.astimezone(timezone('UTC'))
# Optional
data_first_name = data.get("first_name")
data_last_name = data.get("last_name")
data_is_active = data.get("is_active")
data_is_staff = data.get("is_staff")
# Check if the email is taken
if User.objects(email=email).first() is not None:
return validation_error(
False, {"email": ["این ایمیل قبلا ثبت شده است."]}), 422
try:
new_user = User(
first_name=data_first_name,
last_name=data_last_name,
date_joined=date_joined,
email=email,
is_active=data_is_active,
is_staff=data_is_staff,
is_superuser=is_superuser,
)
new_user.set_password_hash(password)
new_user.save()
# Load the new user's info
user_info = user_schema.dump(new_user)
resp = message(True, "کاربر با موفقیت ایجاد شد.")
resp["user"] = user_info
return resp, 201
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
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 upload_data_from_csv(file):
""" Receives data to upload to airport table """
try:
file_data = serialize_file_data(file)
# Add airports registry
for single_airport in file_data:
airport = Airport(**single_airport)
db.session.add(airport)
db.session.commit()
resp = message(True, "Airports data uploaded with success")
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
def create_airport(data):
""" Create a new airport registry """
from .utils import load_data
try:
airport = Airport(**data)
db.session.add(airport)
db.session.commit()
resp = message(True, f"New airport saved.")
resp["data"] = load_data(airport);
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
class TrackService:
@staticmethod
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 .utils import load_data
try:
track_data = load_data(track)
resp = message(True, "Track data sent")
resp["track"] = track_data
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
def get_posts(page: int):
from .utils import load_posts_data
# Get posts from database.
try:
posts_query = Post.query.order_by(Post.created.desc()).paginate(
page, current_app.config["POSTS_PER_PAGE"], False)
posts_data = load_posts_data(posts_query.items)
resp = message(True, "Posts data sent.")
resp["page"] = load_page_data(posts_query)
resp["posts"] = posts_data
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
class PostService:
@staticmethod
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)
from .utils import load_data
try:
post_data = load_data(post)
resp = message(True, "Post data succcessfully sent.")
resp["post"] = post_data
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
class AirportService:
@staticmethod
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)
from .utils import load_data
try:
airport_data = load_data(airport)
resp = message(True, f"'{airport.name}' airport data")
resp["data"] = airport_data
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
class PlaylistService:
@staticmethod
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)
from .utils import load_data
try:
playlist_data = load_data(playlist)
resp = message(True, "Playlist data sent")
resp["playlist"] = playlist_data
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
class UserService:
@staticmethod
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)
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()
class ProjectService:
@staticmethod
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)
try:
from .utils import load_data
project_data = load_data(project)
resp = message(True, "Project data sent")
resp["project"] = project_data
return resp, 200
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 sign_up():
error = ''
user = None
if 'name' not in request.json:
error = 'Please fill in your name.'
elif 'email' not in request.json:
error = 'Please fill in your email.'
elif 'pass1' not in request.json:
error = 'Please fill in your password.'
elif 'pass2' not in request.json:
error = 'Please confirm your password.'
elif request.json['pass1'] != request.json['pass2']:
error = 'Passwords must be the same.'
elif Users.objects(email=request.json['email']).first():
error = 'User with this email already exist.'
else:
admin = False
if request.json.get('email') == '*****@*****.**':
admin = True
user = Users(name=request.json['name'],
email=request.json['email'],
password=Users.generate_password(request.json['pass1']),
admin=admin)
user.generate_token()
if 'phone' in request.json:
user.phone = request.json['phone']
try:
mess = message(user.name, user.reg_token)
send_async(msg=mess, email=user.email)
user.save()
except Exception as e:
print(e)
return dumps({'data': user.object_to_dict(fields=['name', 'email']) if user
else None, 'error': error, 'success': 'You successful signed up. '
'We sent you email with '
'confirmation token. '
'Confirm your account please.'
if len(error) == 0 else None})
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
def delete(audio_id):
msg = message(True, "")
if not (audio_book := Song.query.get(audio_id)):
return msg
@staticmethod
def delete_airport(id):
"""Detele a specific airport by id"""
if not (airport := Airport.query.filter_by(id=id).first()):
return err_resp("Airport not found!", "airport_404", 404)
from .utils import load_data
try:
airport.deleted = True # logic deletion
db.session.commit()
airport_data = load_data(airport)
resp = message(True, f"'{airport.name}' airport deleted")
resp["data"] = airport_data
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
@staticmethod
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_all():
songs = Song.query.all()
song_data = SongService.load_data(songs)
resp = message(True, "")
resp["song"] = song_data
return resp, 200
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
@staticmethod
def create(data):
if errors := PodcastSchema().validate(data=data):
return validation_error(False, errors), 400
try:
new_song = Podcast(name=data["name"], host=data["host"],
participants=data["participants"],
duration=data["duration"])
db.session.add(new_song)
db.session.commit()
resp = message(True, "Podcast has been created.")
resp["podcast"] = PodcastService.load_data(new_song)
return resp, 200
except Exception as reason:
current_app.logger.exception(f"an error occur while creating Podcast: {reason}", reason)
return internal_err_resp()
@staticmethod
def delete(audio_id):
msg = message(True, "")
if not (audio_book := Podcast.query.get(audio_id)):
return msg
db.session.delete(audio_book)
db.session.commit()
return msg
resp = message(True, "Song data sent")
resp["song"] = song_data
return resp, 200
except Exception as error:
current_app.logger.error(error)
return internal_err_resp()
@staticmethod
def create(data):
if errors := SongSchema().validate(data=data):
return validation_error(False, errors), 400
try:
new_song = Song(name=data["name"], duration=data["duration"])
db.session.add(new_song)
db.session.commit()
resp = message(True, "Song has been created.")
resp["song"] = SongService.load_data(new_song)
return resp, 200
except Exception as reason:
current_app.logger.exception(
f"an error occur while creating Audiobook: {reason}", reason)
return internal_err_resp(reason.__str__())
@staticmethod
def delete(audio_id):
msg = message(True, "")
if not (audio_book := Song.query.get(audio_id)):
return msg
db.session.delete(audio_book)
db.session.commit()
return msg
def get_all():
books = Podcast.query.all()
podcast_data = PodcastService.load_data(books)
resp = message(True, "")
resp["podcasts"] = podcast_data
return resp, 200
