def associate_user_to_plan(plan_id):
schema, errors = assciation_user_plan_schema.load(request.get_json())
if errors:
return json.dumps(ValidationError.new_from_marshmallow_error_dict(errors)), HTTPStatus.BAD_REQUEST
try:
user_id = schema["user"]
plan = Plan.query.filter_by(id=plan_id).first()
if plan is None:
return json.dumps(ObjectNotFound().new_detailed("plan", "id", plan_id)), HTTPStatus.NOT_FOUND
user = User.query.filter_by(id=user_id).first()
if user is None:
return json.dumps(ObjectNotFound().new_detailed("user", "id", user_id)), HTTPStatus.NOT_FOUND
if user in plan.users:
return json.dumps(PlanAlreadyAssociatedError.new("user", "user_id", user_id)), HTTPStatus.BAD_REQUEST
plan.users.append(user)
db.session.add(plan)
db.session.commit()
plan.notify_association(user)
return json.dumps(assciation_user_plan_schema.dump(plan).data)
except Exception as e:
return json.dumps(ResponseError.new_generic_error()), HTTPStatus.INTERNAL_SERVER_ERROR
def create_exercise():
schema, errors = exercise_schema.load(request.get_json())
if errors:
return json.dumps(ValidationError.new_from_marshmallow_error_dict(errors)), HTTPStatus.BAD_REQUEST
try:
exercise = Exercise(name=schema["name"], sets=schema["sets"], reps=schema["reps"])
plan = Plan.query.filter(Plan.id == schema["plan"], Plan.deleted_at.is_(None)).first()
if plan is None:
return json.dumps(ObjectNotFound.new_detailed("plan", "plan", schema["plan"])), HTTPStatus.BAD_REQUEST
workout_day_list = list(filter(lambda x: x.number == schema["day_number"], plan.days))
if len(plan.days) > 0 and len(workout_day_list) > 0:
workout_day = workout_day_list[0]
else:
workout_day = Day(number=1, plan=plan)
exercise.day = workout_day
exercise.plan = plan
db.session.add(exercise)
db.session.commit()
except Exception as e:
return json.dumps(ResponseError.new_generic_error()), HTTPStatus.INTERNAL_SERVER_ERROR
return json.dumps(exercise_schema.dump(exercise).data)
def edit_plan(id):
schema, errors = plan_schema.load(request.get_json())
if errors:
return json.dumps(ValidationError.new_from_marshmallow_error_dict(errors)), HTTPStatus.BAD_REQUEST
try:
plan = Plan.query.filter_by(id=id).first()
if plan is None:
return json.dumps(ObjectNotFound().new()), HTTPStatus.NOT_FOUND
if Plan.query.filter_by(name=schema["name"]).count() > 0:
return json.dumps(
ObjectAlreadyRegisteredError().new("plan", "name", schema["name"])), HTTPStatus.BAD_REQUEST
for key, val in schema.items():
setattr(plan, key, val)
db.session.add(plan)
db.session.commit()
plan.notify_users()
except Exception as e:
return json.dumps(ResponseError.new_generic_error()), HTTPStatus.INTERNAL_SERVER_ERROR
return json.dumps(plan_schema.dump(plan).data)
def add_workout_day(plan_id):
schema, errors = day_schema.load(request.get_json())
if errors:
return json.dumps(ValidationError.new_from_marshmallow_error_dict(errors)), HTTPStatus.BAD_REQUEST
try:
plan = Plan.query.filter_by(id=plan_id).first()
if plan is None:
return json.dumps(ObjectNotFound().new()), HTTPStatus.NOT_FOUND
day_number = int(schema["number"])
if Plan.query.filter(Plan.days.any(number=day_number)).count() > 0:
return json.dumps(
ObjectAlreadyRegisteredError().new("day", "number", schema["number"])), HTTPStatus.BAD_REQUEST
schema["exercises"] = list({val["name"].strip().title(): val for val in schema["exercises"]}.values())
exercises = [Exercise(**item) for item in schema["exercises"]]
day = Day(number=schema["number"], plan=plan, exercises=exercises)
db.session.add(day)
db.session.commit()
plan.notify_users()
return json.dumps(day_schema.dump(day).data)
except Exception as e:
return json.dumps(ResponseError.new_generic_error()), HTTPStatus.INTERNAL_SERVER_ERROR
def edit_user(id):
try:
schema, errors = user_edit_schema.load(request.get_json())
if errors:
return json.dumps(
ValidationError.new_from_marshmallow_error_dict(
errors)), HTTPStatus.BAD_REQUEST
user = User.query.filter(User.id == id,
User.deleted_at.is_(None)).first()
if user is None:
return json.dumps(ObjectNotFound().new()), HTTPStatus.NOT_FOUND
if g.logged_user.id != id:
return json.dumps(
ResponseError.new_generic_error(
"You are not authorized to to this operation.")
), HTTPStatus.FORBIDDEN
for key, val in schema.items():
if key != "password":
setattr(user, key, val)
else:
user.set_password(val)
db.session.add(user)
db.session.commit()
except Exception as e:
return json.dumps(ResponseError.new_generic_error()
), HTTPStatus.INTERNAL_SERVER_ERROR
return json.dumps(user_schema.dump(user).data)
def get_exercise(id):
try:
exercise = Exercise.query.filter_by(id=id).first()
if exercise is None:
return json.dumps(ObjectNotFound().new()), HTTPStatus.NOT_FOUND
return exercise_schema.dumps(exercise).data
except Exception as e:
return json.dumps(ResponseError.new_generic_error()), HTTPStatus.INTERNAL_SERVER_ERROR
def get_plan(plan_id):
try:
plan = Plan.query.filter_by(id=plan_id).first()
if plan is None:
return json.dumps(ObjectNotFound().new()), HTTPStatus.NOT_FOUND
return json.dumps(plan_full_schema.dump(plan).data)
except Exception as e:
return json.dumps(ResponseError.new_generic_error()), HTTPStatus.INTERNAL_SERVER_ERROR
def delete_workout_day(plan_id, day_number):
day = Day.query.filter(Day.plan_id == plan_id, Day.number == day_number).first()
if day is None:
return json.dumps(ObjectNotFound().new()), HTTPStatus.NOT_FOUND
for exercise in day.exercises:
db.session.delete(exercise)
db.session.delete(day)
db.session.commit()
return json.dumps({}), HTTPStatus.OK
def delete_exercise(id):
try:
exercise = Exercise.query.filter(Exercise.id == id).first()
if exercise is None:
return json.dumps(ObjectNotFound().new()), HTTPStatus.NOT_FOUND
exercise.deleted_at = datetime.utcnow()
db.session.delete(exercise)
db.session.commit()
return json.dumps({}), HTTPStatus.OK
except Exception as e:
return json.dumps(ResponseError.new_generic_error()), HTTPStatus.INTERNAL_SERVER_ERROR
def delete_plan(id):
try:
plan = Plan.query.filter(Plan.id == id, Plan.deleted_at.is_(None)).first()
if plan is None:
return json.dumps(ObjectNotFound().new()), HTTPStatus.NOT_FOUND
plan.deleted_at = datetime.utcnow()
db.session.add(plan)
db.session.commit()
return plan_full_schema.dumps(plan).data, HTTPStatus.OK
except Exception as e:
return json.dumps(ResponseError.new_generic_error()), HTTPStatus.INTERNAL_SERVER_ERROR
def get_workout_days(plan_id):
try:
page = int(request.args.get("page", 1))
query = Day.query.filter_by(plan_id=plan_id)
days_paginator = query.paginate(page, int(app.config["ITEMS_PER_PAGE"]))
if days_paginator is None or query.count() == 0:
return json.dumps(ObjectNotFound().new()), HTTPStatus.NOT_FOUND
paginated_data = PaginatorHelper.get_paginator_dict(days_paginator)
return day_list_schema.dumps(paginated_data).data
except Exception as e:
return json.dumps(ResponseError.new_generic_error()), HTTPStatus.INTERNAL_SERVER_ERROR
def edit_exercise(id):
schema, errors = exercise_edit_schema.load(request.get_json())
if errors:
return json.dumps(ValidationError.new_from_marshmallow_error_dict(errors)), HTTPStatus.BAD_REQUEST
try:
exercise = Exercise.query.filter_by(id=id).first()
if exercise is None:
return json.dumps(ObjectNotFound().new()), HTTPStatus.NOT_FOUND
for key, val in schema.items():
setattr(exercise, key, val)
exercise_schema.updated_at = datetime.utcnow()
db.session.add(exercise)
db.session.commit()
return exercise_schema.dumps(exercise).data
except Exception as e:
return json.dumps(ResponseError.new_generic_error()), HTTPStatus.INTERNAL_SERVER_ERROR
def delete_user(id):
try:
user_model = User.query.filter(User.id == id,
User.deleted_at.is_(None)).first()
if user_model is None:
return json.dumps(ObjectNotFound().new()), HTTPStatus.NOT_FOUND
if g.logged_user.id != id:
return json.dumps(
ResponseError.new_generic_error(
"You are not authorized to to this operation.")
), HTTPStatus.FORBIDDEN
user_model.deleted_at = datetime.utcnow()
db.session.add(user_model)
db.session.commit()
return json.dumps(user_schema.dump(user_model).data), HTTPStatus.OK
except Exception as e:
return json.dumps(ResponseError.new_generic_error()
), HTTPStatus.INTERNAL_SERVER_ERROR