backend-development-course/app/__init__.py

from flask import Flask, request, jsonify
import time
import json
import uuid

from marshmallow import Schema, fields
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config.from_pyfile('config.py', silent=True)

db = SQLAlchemy(app)

class UserModel(db.Model):
    __tablename__ = "user"
    uuid = db.Column(db.String(32), unique=True, primary_key=True, nullable=False)
    name = db.Column(db.String(64), nullable=False)

class CategoryModel(db.Model):
    __tablename__ = "category"
    uuid = db.Column(db.String(32), unique=True, primary_key=True, nullable=False)
    name = db.Column(db.String(64), nullable=False)

class RecordModel(db.Model):
    __tablename__ = "record"
    uuid = db.Column(db.String(32), primary_key=True, nullable=False)
    user_uuid = db.Column(db.String(32), db.ForeignKey('user.uuid'))
    cat_uuid = db.Column(db.String(32), db.ForeignKey('category.uuid'))
    date = db.Column(db.Date)
    amount = db.Column(db.Integer)

class UserSchema(Schema):
    uuid = fields.Str()
    name = fields.Str()

class CategorySchema(Schema):
    uuid = fields.Str()
    name = fields.Str()

class RecordSchema(Schema):
    uuid = fields.Str()
    user_uuid = fields.Str()
    cat_uuid = fields.Str()
    date = fields.Date()
    amount = fields.Integer()

user_schema = UserSchema()
users_schema = UserSchema(many = True)

category_schema = CategorySchema()
categories_schema = CategorySchema(many = True)

record_schema = RecordSchema()
records_schema = RecordSchema(many = True)

# "migration"
with app.app_context():
    db.create_all()

@app.route("/healthcheck")
def ep_healthcheck():
    return {
        "date": time.strftime('%Y.%m.%d %H:%M:%S'),
        "status": "OK"
    }

@app.route("/reset_users_because_postman_is_dumb_like_that")
def ep_reset():
    db.session.query(UserModel).delete()
    db.session.commit()
    return {}, 200

@app.route("/users", methods = ["GET"])
def ep_users_get():
    result = db.session.query(UserModel).all()
    return users_schema.dumps(result)

@app.route("/user/<user_id>", methods = ["GET"])
def ep_user_get(user_id):
    result = db.session.query(UserModel).filter(UserModel.uuid == user_id).all()

    if len(result) == 1:
        return user_schema.dumps(result[0]), 200
    else:
        return {}, 404

@app.route("/user", methods = ["POST"])
def ep_user_post():
    body = request.json

    if not body:
        return {}, 403

    if 'uuid' in body:
        return {}, 403

    body.update({'uuid': uuid.uuid4().hex})

    try:
        _ = user_schema.load(body)
    except ValidationError as e:
        return {}, 403

    u = UserModel(**body)

    try:
        db.session.add(u)
        db.session.commit()
    except Exception as e:
        db.session.rollback()
        return {}, 403

    return jsonify(user_schema.load(body)), 200

@app.route("/user/<user_id>", methods = ["DELETE"])
def ep_user_delete(user_id):
    try:
        result = db.session.query(UserModel).filter(UserModel.uuid == user_id).all()
    except Exception as e:
        return {}, 403

    if len(result) == 0:
        return {}, 404

    db.session.query(UserModel).filter(UserModel.uuid == user_id).delete()
    db.session.commit()

    return user_schema.dumps(result[0]), 200

@app.route("/category", methods = ["GET"])
def ep_category_get():
    body = request.json

    if 'uuid' in body:
        category = ldb.get_category(body['uuid'])

        if 'uuid' in category:
            return category
        else:
            return category, 404
    else:
        return {}, 403

@app.route("/category", methods = ["POST"])
def ep_category_post():
    body = request.json

    if 'name' in body:
        r = ldb.add_category(body['name'])

        if 'uuid' in r:
            return r
        else:
            return r, 403
    else:
        return {}, 403

@app.route("/category", methods = ["DELETE"])
def ep_category_delete():
    body = request.json

    if 'uuid' in body:
        category = ldb.del_category(body['uuid'])

        if 'uuid' in category:
            return category
        else:
            return category, 404
    else:
        return {}, 403

@app.route("/record/<record_id>", methods = ["GET"])
def ep_record_get(record_id):
    r = ldb.get_record(record_id)

    if 'uuid' in r:
        return r
    else:
        return r, 404

@app.route("/record", methods = ["GET"])
def ep_record_get_filtered():
    options = {}

    if 'user_id' in request.json:
        options['user_id'] = request.json['user_id']

    if 'cat_id' in request.json:
        options['cat_id'] = request.json['cat_id']

    if len(list(options.keys())) == 0:
        return [], 400

    r = ldb.filter_records(options)

    return json.dumps(r)

@app.route("/record/<record_id>", methods = ["DELETE"])
def ep_record_del(record_id):
    r = ldb.del_record(record_id)

    if 'uuid' in r:
        return r
    else:
        return r, 404

@app.route("/record", methods = ["POST"])
def ep_record_post():
    body = request.json

    if 'user_id' not in body:
        return {}, 400

    if 'cat_id' not in body:
        return {}, 400

    if 'amount' not in body:
        return {}, 400

    r = ldb.add_record(body['user_id'], body['cat_id'], body['amount'])

    if 'uuid' in r:
        return r
    else:
        return r, 403