Snow Leopards C18 - Anna Lord, Bukunmi Gesinde, Emily Son, Katherine Abrikian

README.md

@@ -1,3 +1,13 @@
+## Overview
+Part of a full-stack project involving four team members. Completed in 8 days (including planning time) over three weeks.<br /><br />
+**Front-end owners:** [@kalawac](https://github.com/kalawac/), [@annalord](https://github.com/annalord/)<br />
+**Back-end owners:** [@emilyiscoding](https://github.com/EmilyIsCoding/), [@bukunmig](https://github.com/BukunmiG/)<br />
+### Related Links
+- [Deployed project](http://hackspoboard.herokuapp.com/)
+- [Front-end repo](https://github.com/kalawac/front-end-inspiration-board)<br />
+- [Back-end repo](https://github.com/EmilyIsCoding/back-end-inspiration-board/)<br />
+- [Ada C-18 repo with general full-stack project overview and requirements](https://github.com/Ada-C18/full-stack-inspiration-board)
+
 # Inspiration Board: Back-end Layer
 
 This scaffold includes the following:

app/__init__.py

@@ -10,22 +10,33 @@
 load_dotenv()
 
 
-def create_app():
+def create_app(test_config=None):
     app = Flask(__name__)
-    app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
 
-    app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get(
-        "SQLALCHEMY_DATABASE_URI")
+    if not test_config:
+        app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+        app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get(
+            "SQLALCHEMY_DATABASE_URI")
+    else:
+        app.config["TESTING"] = True
+        app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
+        app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("SQLALCHEMY_TEST_DATABASE_URI")
 
     # Import models here for Alembic setup
     # from app.models.ExampleModel import ExampleModel
+    from app.models.board import Board
+    from app.models.card import Card
+    from app.models.user import User
+
 
     db.init_app(app)
     migrate.init_app(app, db)
 
     # Register Blueprints here
-    # from .routes import example_bp
-    # app.register_blueprint(example_bp)
+    from . import board_routes, card_routes, user_routes
+    app.register_blueprint(board_routes.bp)
+    app.register_blueprint(card_routes.bp)
+    app.register_blueprint(user_routes.bp)
 
     CORS(app)
     return app

app/board_routes.py

@@ -0,0 +1,71 @@
+from flask import Blueprint, request, jsonify, make_response, abort
+from app import db
+from app.models.board import Board
+from datetime import datetime
+
+
+bp = Blueprint("boards_bp", __name__, url_prefix="/boards")
+
+def validate_model(cls, model_id):
+    try:
+        model_id = int(model_id)
+    except:
+        abort(make_response({"message":f"{cls.__name__} {model_id} invalid"}, 400))
+
+    model = cls.query.get(model_id)
+
+    if not model:
+        abort(make_response({"message":f"{cls.__name__} {model_id} not found"}, 404))
+
+    return model
+
+@bp.route("", methods=["POST"])
+def create_board():
+    request_body = request.get_json()
+
+    if request_body["title"] is None:
+        abort(make_response({"message":"Please include a title"}, 400))
+
+    # if request_body["owner"] is None:
+    #     abort(make_response({"message":"Please include an owner"}, 400))
+    # Since we have a login, they can't encounter this error in the first place
+
+    date = str(datetime.utcnow())
+
+    new_board = Board.from_dict({'date_created': date, 'title':request_body["title"], 
+                                'owner_id':request_body['user_id'], 'card_color': request_body['card_color'], 'visible':True})
+
+    db.session.add(new_board)
+    db.session.commit()
+
+    return make_response(jsonify(new_board.to_dict()), 201)
+
+@bp.route("", methods=["GET"])
+def read_all_boards():
+
+    title_query = request.args.get("title")
+    if title_query:
+        boards = Board.query.filter_by(title=title_query)
+    else:
+        boards = Board.query.all()
+
+    boards_response = []
+
+    for board in boards:
+        boards_response.append(board.to_dict())
+
+    return jsonify(boards_response)
+
+@bp.route("<board_id>", methods=["GET"])
+def read_one_board(board_id):
+    board = validate_model(Board, board_id)
+    return board.to_dict()
+
+@bp.route("<board_id>", methods=["DELETE"])
+def delete_board(board_id):
+    board = validate_model(Board, board_id)
+
+    db.session.delete(board)
+    db.session.commit()
+
+    return make_response(jsonify(f"Board #{board.id} successfully deleted"))

app/card_routes.py

@@ -0,0 +1,81 @@
+from flask import Blueprint, request, jsonify, make_response, abort
+from app import db
+from app.models.card import Card
+from datetime import datetime
+from app.board_routes import validate_model
+from app.models.board import Board
+
+
+bp = Blueprint("cards_bp", __name__, url_prefix="/cards")
+
+# Create a card [POST]
+@bp.route("", methods=["POST"])
+def create_card():
+    request_body = request.get_json()
+
+    if not request_body["user_id"]:
+        abort(make_response({"message": "No user ID present"}, 400))
+
+    if not request_body["message"]:
+        abort(make_response({"message": "No message in card"}, 400))
+
+    date = str(datetime.utcnow())
+
+    new_card = Card.from_dict({'date_created': date, 
+                                'likes': 0 ,
+                                'message':request_body["message"],
+                                'board_id': request_body["board_id"],
+                                'author_id':request_body['user_id']})
+    db.session.add(new_card)
+    db.session.commit()
+
+    return make_response(jsonify(new_card.to_dict()), 201)
+
+# Get information on a card by ID [GET] 200 will come automatically
+@bp.route("/<id>", methods=["GET"])
+def read_card(id):
+    card = validate_model(Card, id)
+    return card.to_dict()
+
+# Get information on all cards associated with a board [GET]
+@bp.route("/board/<board_id>", methods=["GET"])
+def read_all_cards_on_board(board_id):
+    board = validate_model(Board, board_id)
+
+    cards = board.cards
+
+    cards_response = []
+
+    for card in cards:
+        cards_response.append(card.to_dict())
+
+    return jsonify(cards_response)
+
+
+# Update information on a card [PUT] &[PATCH]
+@bp.route("/<id>", methods=["PUT"])
+def update_card(id):
+    card = validate_model(Card, id)
+    request_body = request.get_json()
+
+    card.message = request_body["message"]
+    db.session.commit()
+    return jsonify(card.to_dict())
+
+
+@bp.route("/<id>/like", methods=["PATCH"])
+def update_card_likes(id):
+    card = validate_model(Card, id)
+    card.likes += 1
+
+    db.session.commit()
+    return jsonify(card.to_dict())
+
+
+# Delete card from database / board [DELETE]
+@bp.route("/<id>", methods=["DELETE"])
+def delete_card(id):
+    card = validate_model(Card, id)
+    db.session.delete(card)
+    db.session.commit()
+    return make_response(f"card {id} deleted", 200)

app/models/board.py

@@ -1 +1,37 @@
 from app import db
+
+class Board(db.Model):
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    date_created = db.Column(db.DateTime)
+    title = db.Column(db.String)
+    visible = db.Column(db.Boolean)
+    cards = db.relationship("Card", back_populates="board")
+    owner_id = db.Column(db.Integer, db.ForeignKey("user.id"))
+    owner = db.relationship("User", back_populates="boards")
+    card_color = db.Column(db.String)
+
+    def to_dict(self):
+        board_dict = {
+            "id": self.id,
+            "date_created": self.date_created,
+            "title": self.title,
+            "visible": self.visible,
+            "owner": self.owner.name,
+            "num_cards": (len(self.cards) if self.cards else 0)
+        }
+        if self.card_color:
+            board_dict["card_color"] = self.card_color
+
+        return board_dict
+
+    @classmethod
+    def from_dict(cls, board_data):
+        new_board = Board( 
+            date_created=board_data["date_created"],
+            title=board_data["title"],
+            visible=board_data["visible"],
+            owner_id=board_data["owner_id"],
+            card_color=board_data["card_color"]
+            )
+
+        return new_board

app/models/card.py

@@ -1 +1,36 @@
 from app import db
+
+class Card(db.Model):
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    date_created = db.Column(db.DateTime)
+    likes = db.Column(db.Integer)
+    message = db.Column(db.String)
+    board_id = db.Column(db.Integer, db.ForeignKey('board.id'))
+    board = db.relationship("Board", back_populates="cards")
+    author_id = db.Column(db.Integer, db.ForeignKey("user.id"))
+    author = db.relationship("User", back_populates="cards")
+
+    def to_dict(self):
+        card_dict = {
+            "id": self.id,
+            "date_created": self.date_created,
+            "likes": self.likes,
+            "message": self.message,
+            "author_id": self.author_id,
+        }
+
+        if self.board:
+            card_dict["board_id"] = self.board.id
+
+        return card_dict
+
+    @classmethod
+    def from_dict(cls, card_data):
+        new_card = Card(
+            date_created=card_data["date_created"],
+            likes = card_data["likes"], 
+            message = card_data["message"],
+            board_id = card_data["board_id"],
+            author_id = card_data["author_id"])
+
+        return new_card

app/models/user.py

@@ -0,0 +1,7 @@
+from app import db
+
+class User(db.Model):
+    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    name = db.Column(db.String)
+    boards = db.relationship("Board", back_populates="owner")
+    cards = db.relationship("Card", back_populates="author")

app/user_routes.py

@@ -0,0 +1,54 @@
+from flask import Blueprint, request, jsonify, make_response, abort
+from app import db
+from app.models.user import User
+
+bp = Blueprint("users_bp", __name__, url_prefix="/users")
+
+def validate_model(cls, name):
+    model = cls.query.filter(cls.name == name).one_or_none()
+
+    if not model:
+        abort(make_response({"message":f"{cls.__name__} {name} not found"}, 404))
+
+    return model
+
+@bp.route("", methods=["POST"])
+def create_user():
+    request_body = request.get_json()
+
+    if request_body["name"] == "":
+        abort(make_response({"message":"Please include a name"}, 400))
+
+    users = User.query.all()
+
+    for user in users:
+        if request_body["name"] == user.name:
+            abort(make_response({"message":f"{request_body['name']} is taken. Please choose another name."}, 400))
+
+    new_user = User(name=request_body["name"])
+
+    db.session.add(new_user)
+    db.session.commit()
+
+    return make_response(jsonify({"id": new_user.id, "name": new_user.name}), 201)
+
+@bp.route("", methods=["GET"])
+def read_all_users():
+    users = User.query.all()
+
+    users_response = []
+    for user in users:
+        users_response.append(
+            {
+                "id": user.id,
+                "name": user.name
+            }
+        )
+    return jsonify(users_response)
+
+@bp.route("/<name>", methods=["GET"])
+def read_one_user(name):
+    user = validate_model(User, name)
+
+    return make_response(jsonify({"id": user.id, "name": user.name}), 200) 
+

migrations/README

@@ -0,0 +1 @@
+Generic single-database configuration.