Dragonflies - Malik

README.md

@@ -46,7 +46,8 @@ At submission time, no matter where you are, submit the project via Learn.
 This project is designed to fulfill the features described in detail in each wave. The tests are meant to only guide your development.
 
 1. [Setup](ada-project-docs/setup.md)
-1. [Testing](ada-project-docs/testing.md)
+1. [Testing](ada-project-docs/testing.md) 
+code coverage: pytest --cov=app --cov-report html --cov-report term
 1. [Wave 1: CRUD for one model](ada-project-docs/wave_01.md)
 1. [Wave 2: Using query params](ada-project-docs/wave_02.md)
 1. [Wave 3: Creating custom endpoints](ada-project-docs/wave_03.md)

app/__init__.py

@@ -1,6 +1,10 @@
 from flask import Flask
 from .db import db, migrate
 from .models import task, goal
+from .routes.task_routes import bp as tasks_bp
+from .routes.goal_routes import bp as goals_bp
+from dotenv import load_dotenv
+load_dotenv()
 import os
 
 def create_app(config=None):
@@ -10,13 +14,14 @@ def create_app(config=None):
     app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('SQLALCHEMY_DATABASE_URI')
 
     if config:
-        # Merge `config` into the app's configuration
-        # to override the app's default settings for testing
+
         app.config.update(config)
 
     db.init_app(app)
     migrate.init_app(app, db)
 
     # Register Blueprints here
+    app.register_blueprint(tasks_bp)
+    app.register_blueprint(goals_bp)
 
     return app

app/models/goal.py

@@ -1,5 +1,26 @@
-from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from .task import Task
 from ..db import db
 
 class Goal(db.Model):
     id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    title: Mapped[str]
+    tasks: Mapped[list["Task"]] = relationship("Task", back_populates="goal")
+
+    def to_dict(self, include_tasks=False):
+        goal_dict = {
+            "id": self.id,
+            "title": self.title,
+        }
+
+        if include_tasks:
+            goal_dict["tasks"] = [task.to_dict(include_goal_id=True) for task in self.tasks]
+
+        return goal_dict
+
+    @classmethod
+    def from_dict(cls, goal_data):
+        new_goal = cls(title=goal_data["title"])
+        return new_goal

app/models/task.py

@@ -1,5 +1,37 @@
-from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy import ForeignKey
+from typing import Optional, TYPE_CHECKING
+if TYPE_CHECKING:
+    from .goal import Goal
 from ..db import db
+from datetime import datetime
 
 class Task(db.Model):
     id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    title: Mapped[str] = mapped_column(nullable=False)
+    description: Mapped[str]
+    completed_at: Mapped[datetime] = mapped_column(nullable=True)
+    goal_id: Mapped[Optional[int]] = mapped_column(ForeignKey("goal.id"))
+    goal: Mapped[Optional["Goal"]] = relationship("Goal", back_populates="tasks")
+
+    def to_dict(self, include_goal_id=False):
+        task_dict = {
+            "id": self.id,
+            "title": self.title,
+            "description": self.description,
+            "is_complete": self.completed_at is not None
+        }
+
+        if include_goal_id and self.goal_id is not None:
+            task_dict["goal_id"] = self.goal_id
+
+        return task_dict
+
+    @classmethod
+    def from_dict(cls, task_data):
+        new_task = cls(title=task_data["title"],
+                    description=task_data["description"],
+                    completed_at=task_data.get("completed_at"),
+                    goal_id=task_data.get("goal_id"))
+
+        return new_task

app/routes/goal_routes.py

@@ -1 +1,89 @@
-from flask import Blueprint
+from flask import Blueprint, abort, make_response, request, Response
+from dotenv import load_dotenv
+from app.models.goal import Goal
+from app.models.task import Task
+from .route_utilities import validate_model, create_model_from_dict
+import os
+import requests
+from ..db import db
+load_dotenv()
+
+
+bp = Blueprint("goals_bp", __name__, url_prefix="/goals")
+
+# create a new goal
+@bp.post("")
+def create_goal():
+    request_body = request.get_json()
+
+    try:
+        new_goal = create_model_from_dict(Goal, request_body)
+    except KeyError as e:
+        response = {"details": "Invalid data"}
+        abort(make_response(response, 400))
+
+    return {"goal": new_goal.to_dict()}, 201
+
+# get all goals
+@bp.get("")
+def get_all_goals():
+    query = db.select(Goal)
+
+    goals = db.session.scalars(query)
+
+    return [goal.to_dict() for goal in goals]
+
+# get one goal
+@bp.get("/<goal_id>")
+def get_one_goal(goal_id):
+    goal = validate_model(Goal, goal_id)
+
+    return {"goal": goal.to_dict()}, 200
+
+# update one goal
+@bp.put("/<goal_id>")
+def update_goal(goal_id):
+    goal = validate_model(Goal, goal_id)
+
+    request_body = request.get_json()
+
+    goal.title = request_body["title"]
+
+    db.session.commit()
+
+    return Response(status=204, mimetype="application/json")
+
+# delete one goal
+@bp.delete("/<goal_id>")
+def delete_goal(goal_id):
+    goal = validate_model(Goal, goal_id)
+    db.session.delete(goal)
+    db.session.commit()
+
+    return Response(status=204, mimetype="application/json")
+
+# add list of tasks to a goal
+@bp.post("/<goal_id>/tasks")
+def add_tasks_to_goal(goal_id):
+    goal = validate_model(Goal, goal_id)
+    request_body = request.get_json()
+
+    task_ids = request_body.get("task_ids", []) 
+
+    for task in goal.tasks:
+        task.goal_id = None
+
+    for task_id in task_ids: 
+        task = validate_model(Task, task_id)
+        task.goal_id = goal.id
+
+    db.session.commit()
+
+    return {"id": goal.id, "task_ids": task_ids}, 200
+
+# getting tasks of one goal
+@bp.get("/<goal_id>/tasks")
+def get_tasks_of_goal(goal_id):
+    goal = validate_model(Goal, goal_id)
+
+    return goal.to_dict(include_tasks=True), 200

app/routes/route_utilities.py

@@ -0,0 +1,25 @@
+from flask import abort, make_response
+from ..db import db
+
+def validate_model(cls, model_id):
+    try:
+        model_id = int(model_id)
+    except:
+        response = {"message": f"{cls.__name__} {model_id} is invalid"}
+        abort(make_response(response, 400))
+
+    query = db.select(cls).where(cls.id == model_id)
+    model = db.session.scalar(query)
+
+    if not model:
+        response = {"message": f"{cls.__name__} {model_id} is not found"}
+        abort(make_response(response, 404))
+
+    return model
+
+def create_model_from_dict(cls, data):
+    model = cls.from_dict(data)
+    db.session.add(model)
+    db.session.commit()
+    return model 
+

app/routes/task_routes.py

@@ -1 +1,112 @@
-from flask import Blueprint
+from flask import Blueprint, abort, make_response, request, Response
+from dotenv import load_dotenv
+from app.models.task import Task
+from .route_utilities import validate_model, create_model_from_dict
+from datetime import datetime, timezone
+import os
+import requests
+from ..db import db
+load_dotenv()
+
+bp = Blueprint("tasks_bp", __name__, url_prefix="/tasks")
+
+# create a new task
+@bp.post("")
+def create_task():
+    request_body = request.get_json()
+
+    try:
+        new_task = create_model_from_dict(Task, request_body)
+
+    except KeyError as error:
+        response = {"details": "Invalid data"}
+        abort(make_response(response, 400))
+
+    return {"task": new_task.to_dict()}, 201
+
+# read all tasks
+@bp.get("")
+def get_all_tasks():
+    query = db.select(Task)
+
+    sort = request.args.get("sort")
+
+    if sort == "asc":
+        query = query.order_by(Task.title.asc())
+    elif sort == "desc":
+        query = query.order_by(Task.title.desc())
+
+    tasks = db.session.scalars(query)
+
+    tasks_response = [task.to_dict() for task in tasks]
+
+    return tasks_response 
+
+# read one task 
+@bp.get("/<task_id>")
+def get_one_task(task_id):
+    task = validate_model(Task, task_id)
+
+    return {"task": task.to_dict(include_goal_id=True)}, 200
+
+# update task
+@bp.put("/<task_id>")
+def update_one_task(task_id):
+    task = validate_model(Task, task_id)
+    request_body = request.get_json()
+
+    task.title = request_body["title"]
+    task.description = request_body["description"]
+
+    db.session.commit()
+
+    return Response(status=204, mimetype="application/json")
+
+# delete task
+@bp.delete("/<task_id>")
+def delete_one_task(task_id):
+    task = validate_model(Task, task_id)
+
+    db.session.delete(task)
+    db.session.commit()
+
+    return Response(status=204, mimetype="application/json")
+
+@bp.patch("/<task_id>/mark_complete")
+def mark_task_complete(task_id):
+    task = validate_model(Task, task_id)
+
+    task.completed_at = datetime.now(timezone.utc)
+
+    db.session.commit()
+
+    # send slack message
+    slack_token = os.environ.get("SLACK_BOT_TOKEN")
+    slack_channel = os.environ.get("SLACK_CHANNEL")
+
+    if slack_token and slack_channel:
+        slack_message = {
+            "channel": slack_channel,
+            "text": f"Someone just completed the task {task.title}"
+        }
+
+        headers = {
+            "Authorization": f"Bearer {slack_token}",
+            "Content-Type": "application/json"
+        }
+
+        # sends request to slack
+        slack_response = requests.post("https://slack.com/api/chat.postMessage", json=slack_message, headers=headers)
+
+    return Response(status=204, mimetype="application/json")
+
+@bp.patch("/<task_id>/mark_incomplete")
+def mark_task_incomplete(task_id):
+    task = validate_model(Task, task_id)
+
+    task.completed_at = None
+
+    db.session.commit()
+
+    return Response(status=204, mimetype="application/json")
+

migrations/README

@@ -0,0 +1 @@
+Single-database configuration for Flask.

migrations/alembic.ini

@@ -0,0 +1,50 @@
+# 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,flask_migrate
+
+[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
+
+[logger_flask_migrate]
+level = INFO
+handlers =
+qualname = flask_migrate
+
+[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