Inspiration Board Backend

app/__init__.py

@@ -19,13 +19,20 @@ def create_app():
 
     # Import models here for Alembic setup
     # from app.models.ExampleModel import ExampleModel
+    from .models.board import Board
+    from .models.card import Card
 
     db.init_app(app)
     migrate.init_app(app, db)
 
     # Register Blueprints here
     # from .routes import example_bp
     # app.register_blueprint(example_bp)
+    from .routes.board_routes import board_bp
+    app.register_blueprint(board_bp)
+
+    from .routes.card_routes import cards_bp
+    app.register_blueprint(cards_bp)
 
     CORS(app)
     return app

app/models/board.py

@@ -1 +1,8 @@
 from app import db
+
+
+class Board(db.Model):
+    board_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    title = db.Column(db.String)
+    owner = db.Column(db.String)
+    cards = db.relationship("Card", back_populates="board", lazy= True)

app/models/card.py

@@ -1 +1,17 @@
 from app import db
+
+
+class Card(db.Model):
+    card_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
+    message = db.Column(db.String)
+    like_count = db.Column(db.Integer, default=0)
+    board_id = db.Column(db.Integer, db.ForeignKey(
+        'board.board_id'), nullable=True)
+    board = db.relationship("Board", back_populates="cards")
+
+    def get_dict(self):
+        return {
+            'card_id': self.card_id,
+            'message':  self.message,
+            'like_count': self.like_count
+        }

app/routes/board_routes.py

@@ -0,0 +1,152 @@
+from flask import Blueprint, request, jsonify, make_response
+from flask import abort
+from app import db
+from os import abort
+import os
+import requests
+
+from app.models.board import Board
+from app.models.card import Card
+
+board_bp = Blueprint("board_bp", __name__, url_prefix="/boards")
+
+# 1. POST - Create a new board, by filling out a form. The form includes "title" and "owner" name of the board.
+# POST displays ERROR msg if empty/blank/invalid/missing "title" or "owner" input.
+
+
+@board_bp.route("", methods=["POST"])
+def create_one_board():
+    request_body = request.get_json()
+    request_body = validate_board_input(request_body)
+
+    new_board = Board(
+        title=request_body['title'], owner=request_body['owner'])
+
+    db.session.add(new_board)
+    db.session.commit()
+    return {
+        'id': new_board.board_id,
+        'title': new_board.title,
+        'msg': f'{new_board.owner} created {new_board.title}'
+    }, 201
+
+# helper function:
+
+
+def validate_board_input(request_body):
+    if "title" not in request_body or "title" == "":
+        abort(make_response(
+            {"details": "Invalid data. Title missing or invalid from board"}, 400))
+    if "owner" not in request_body or "owner" == "":
+        abort(make_response(
+            {"details": "Invalid data. Owner missing or invalid from board"}, 400))
+    return request_body
+
+# GET- Read; View a list of all boards
+
+
+@board_bp.route("", methods=["GET"])
+def get_all_boards():
+    boards = Board.query.all()
+    boards_response = []
+    for board in boards:
+        boards_response.append({
+            "id": board.board_id,
+            "owner": board.owner,
+            "title": board.title,
+            # not returning card list at this time. May want to add in later.
+        })
+
+    return jsonify(boards_response), 200
+# GET - Read; Select a specific board
+
+
+@board_bp.route("/<board_id>", methods=["GET"])
+def get_one_board(board_id):
+    chosen_board = validate_board(board_id)
+
+    response = {
+        "id": chosen_board.board_id,
+        "owner": chosen_board.owner,
+        "title": chosen_board.title,
+        # not returning card list at this time. May want to add in later.
+    }
+    return jsonify(response), 200
+
+
+# GET- Read all cards in a selected board
+@board_bp.route("/<board_id>/cards", methods=["GET"])
+def get_all_cards_for_board(board_id):
+    chosen_board = validate_board(board_id)
+    chosen_board_cards = []
+    for card in chosen_board.cards:
+        chosen_board_cards.append({
+            'card_id': card.card_id,
+            'message': card.message,
+            'like_count': card.like_count,
+            'board_id': card.board_id
+        })
+    return jsonify(chosen_board_cards), 200
+
+
+# Helper function to validate board_id:
+
+def validate_board(board_id):
+    try:
+        board_id = int(board_id)
+    except:
+        abort(make_response(
+            {"message": f"Board: {board_id} is not a valid board id"}, 400))
+    board = Board.query.get(board_id)
+    if not board:
+        abort(make_response(
+            {"message": f"Board: #{board_id} not found"}, 404))
+    return board
+
+# POST: Create a new card for the selected board,
+# by filling out a form and filling out a "message."
+# See an error message if I try to make the card's "message" more than 40 characters.
+# All error messages can look like a new section on the screen, a red outline around the input field, and/or disabling the input, as long as it's visible
+# See an error message if I try to make a new card with an empty/blank/invalid/missing "message."
+
+
+@board_bp.route("/<board_id>/card", methods=["POST"])
+def create_card_for_board(board_id):
+    board = validate_board(board_id)
+    request_body = request.get_json()
+
+    if len(request_body["message"]) > 0 and len(request_body["message"]) <= 40:
+        new_card = Card(
+            message=request_body["message"],
+            board=board,
+        )
+    else:
+        abort(make_response(
+            {"message": f"Card message for board #{board_id} too long, please keep it under 40 characters"}, 400))
+
+    db.session.add(new_card)
+    db.session.commit()
+
+    SLACK_URL = 'https://slack.com/api/chat.postMessage'
+    msg_to_post = {"text": f"Someone just created the card {new_card.message}", "channel" : "C03M57Y7JDC"}
+    auth = os.environ.get('SLACK_BOT_TOKEN')
+    requests.post(SLACK_URL, json=msg_to_post, headers={'Authorization': f'Bearer {auth}'})
+
+    return {
+        'msg': f'Succesfully created new card for {board.title}',
+        'message': new_card.message,
+        'card_id': new_card.card_id,
+        'like_count': new_card.like_count,
+        'board_id': board_id
+    }, 201
+
+
+@board_bp.route('/<board_id>', methods=['DELETE'])
+def delete_one_board(board_id):
+    board = validate_board(board_id)
+
+    db.session.delete(board)
+    db.session.commit()
+
+    rsp = {'msg': f'Board #{board.board_id} successfully deleted!'}
+    return jsonify(rsp), 200

app/routes/card_routes.py

@@ -0,0 +1,77 @@
+from flask import Blueprint, request, jsonify, make_response
+from flask import abort
+from app import db
+from os import abort
+
+from app.models.card import Card
+
+
+cards_bp = Blueprint('cards', __name__, url_prefix='/cards')
+
+
+# @cards_bp.route('', methods=['GET'])
+# def get_all_cards():
+#     cards = Card.query.all()
+#     cards_response = []
+#     for card in cards:
+#         cards_response.append({
+#             'message': card.message,
+#             'card_id': card.card_id,
+#             'like_count': card.like_count
+#         })
+#     return jsonify(cards_response), 200
+
+
+# @cards_bp.route('/<card_id>', methods=['GET'])
+# def get_one_card(card_id):
+#     card = validate_card(card_id)
+#     return jsonify({
+#         'message': card.message,
+#         'card_id': card.card_id,
+#         'like_count': card.like_count
+#     }), 200
+
+
+@cards_bp.route('/<card_id>', methods=['PUT'])
+def update_one_card(card_id):
+    card = validate_card(card_id)
+    try:
+        card.like_count += 1
+    except KeyError:
+        return {
+            'msg': 'Update failed. like_count is required!'
+        }, 400
+
+    db.session.commit()
+    return jsonify({
+        'message': card.message,
+        'card_id': card.card_id,
+        'like_count': card.like_count
+    }), 200
+
+
+@cards_bp.route('/<card_id>', methods=['DELETE'])
+def delete_one_card(card_id):
+    card = validate_card(card_id)
+
+    db.session.delete(card)
+    db.session.commit()
+
+    rsp = {'msg': f'Card #{card.card_id} successfully deleted!'}
+    return jsonify(rsp), 200
+
+
+def validate_card(card_id):
+    try:
+        card_id = int(card_id)
+    except:
+        rsp = {"msg": f"Card with id {card_id} is invalid."}
+        abort(make_response(rsp, 400))
+
+    card = Card.query.get(card_id)
+
+    if not card:
+        rsp = {'msg': f'Could not find card with id {card_id}.'}
+        abort(make_response(rsp, 404))
+
+    return card

migrations/README

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

migrations/alembic.ini

@@ -0,0 +1,45 @@
+# A generic, single database configuration.
+
+[alembic]
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S