Task List Api

ada-project-docs/wave_04.md

@@ -99,10 +99,11 @@ Visit https://api.slack.com/methods/chat.postMessage to read about the Slack API
 
 Answer the following questions. These questions will help you become familiar with the API, and make working with it easier.
 
-- What is the responsibility of this endpoint?
-- What is the URL and HTTP method for this endpoint?
-- What are the _two_ _required_ arguments for this endpoint?
-- How does this endpoint relate to the Slackbot API key (token) we just created?
+- What is the responsibility of this endpoint? This endpoint sends a message to a channel
+- What is the URL and HTTP method for this endpoint? POST
+https://slack.com/api/chat.postMessage
+- What are the _two_ _required_ arguments for this endpoint? token and channel
+- How does this endpoint relate to the Slackbot API key (token) we just created? This is what we will need to pass into the headers of the request so that we can be authenticated and granted access within scope of the token. In this case, to be able to send a message.
 
 Now, visit https://api.slack.com/methods/chat.postMessage/test.
 
@@ -121,9 +122,9 @@ Press the "Test Method" button!
 
 Scroll down to see the HTTP response. Answer the following questions:
 
-- Did we get a success message? If so, did we see the message in our actual Slack workspace?
-- Did we get an error message? If so, why?
-- What is the shape of this JSON? Is it a JSON object or array? What keys and values are there?
+- Did we get a success message? If so, did we see the message in our actual Slack workspace? The value of "ok" is true in the response that I received. I can see the message in #test-slack-api.
+- Did we get an error message? If so, why? No
+- What is the shape of this JSON? Is it a JSON object or array? What keys and values are there? I get a JSON object with four keys: ok, channel, ts, and message. The message and blocks keys have nested JSON objects. 
 
 ### Verify with Postman
 

app/__init__.py

@@ -1,6 +1,8 @@
 from flask import Flask
 from .db import db, migrate
 from .models import task, goal
+from .routes.task_routes import bp as task_bp
+from .routes.goal_routes import bp as goal_bp
 import os
 
 def create_app(config=None):
@@ -18,5 +20,7 @@ def create_app(config=None):
     migrate.init_app(app, db)
 
     # Register Blueprints here
+    app.register_blueprint(task_bp)
+    app.register_blueprint(goal_bp)
 
     return app

app/models/goal.py

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

app/models/task.py

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

app/routes/goal_routes.py

@@ -1 +1,75 @@
-from flask import Blueprint
+from flask import Blueprint, request, Response, abort, make_response
+import requests
+import os
+from .route_utilities import validate_model, create_model
+from ..models.goal import Goal
+from ..models.task import Task
+from ..db import db
+
+
+bp=Blueprint("goal_bp", __name__, url_prefix="/goals")
+
+@bp.get("")
+def get_goals():
+    query=db.select(Goal)
+    goals = db.session.scalars(query.order_by(Goal.id))
+    goals_response=[]
+    for goal in goals:
+        goals_response.append(goal.to_dict())
+    return goals_response
+
+@bp.get("/<id>")
+def get_one_goals(id):
+    goal = validate_model(Goal, id)
+    return {"goal": goal.to_dict()},200 
+
+@bp.get("/<goal_id>/tasks")
+def get_one_goal_tasks(goal_id):
+    goal = validate_model(Goal,goal_id)
+    response_body = goal.to_dict()
+
+    if goal.tasks:
+        tasks = [task.to_dict() for task in goal.tasks]
+        response_body["tasks"] = tasks
+    else:
+        response_body["tasks"] = []
+
+    return response_body 
+
+@bp.post("")
+def create_goal():
+    request_body = request.get_json()
+    response = create_model(Goal, request_body)
+    return {"goal": response[0]}, response[1]
+
+@bp.post("/<goal_id>/tasks")
+def create_tasks_with_goal_id(goal_id):
+
+    goal = validate_model(Goal,goal_id)
+    request_body = request.get_json()
+    tasks = request_body.get("task_ids",[])
+
+    if goal.tasks:
+        goal.tasks.clear()
+
+    goal.tasks = [validate_model(Task, task) for task in tasks]
+
+    db.session.commit()
+
+    return make_response({"id":goal.id, "task_ids":tasks},200)
+
+@bp.put("/<id>")
+def update_goal(id):
+    goal = validate_model(Goal, id)
+    request_body = request.get_json()
+    goal.title=request_body["title"]
+    db.session.commit()
+    return Response(status=204, mimetype="application/json")
+
+@bp.delete("/<id>")
+def delete_goal(id):
+    goal = validate_model(Goal, id)
+    db.session.delete(goal)
+    db.session.commit()
+    return Response(status=204, mimetype="application/json")
+

app/routes/route_utilities.py

@@ -0,0 +1,43 @@
+from flask import abort, make_response
+from ..db import db
+
+def validate_model(cls, model_id):
+    try:
+        model_id = int(model_id)
+    except ValueError:
+        invalid_response = {"message": f"{cls.__name__} id ({model_id}) is invalid."}
+        abort(make_response(invalid_response, 400))
+
+    query = db.select(cls).where(cls.id == model_id)
+    model = db.session.scalar(query)
+
+    if not model:     
+        not_found = {"message": f"{cls.__name__} with id ({model_id}) not found."}
+        abort(make_response(not_found, 404))
+
+    return model
+
+def create_model(cls, model_data):
+    try:
+        new_model = cls.from_dict(model_data)
+    except KeyError as e:
+        response = {"details": "Invalid data"}
+        abort(make_response(response, 400))
+
+    db.session.add(new_model)
+    db.session.commit()
+
+    return new_model.to_dict(), 201
+
+def get_models_with_filters(cls, filters=None):
+    query = db.select(cls)
+
+    if filters:
+        for attribute, value in filters.items():
+            if hasattr(cls, attribute):
+                query = query.where(getattr(cls, attribute).ilike(f"%{value}%"))
+
+    models = db.session.scalars(query.order_by(cls.id))
+    models_response = [model.to_dict() for model in models]
+
+    return models_response, 200

app/routes/task_routes.py

@@ -1 +1,98 @@
-from flask import Blueprint
+from flask import Blueprint, request, Response, abort, make_response
+import requests
+import os
+from .route_utilities import validate_model, create_model
+from datetime import datetime
+from ..models.task import Task
+from ..db import db
+
+bp=Blueprint("tasks_bp", __name__, url_prefix="/tasks")
+
+@bp.post("")
+def create_task():
+    request_body = request.get_json()
+    response = create_model(Task, request_body)
+    return {"task": response[0]}, response[1]
+
+@bp.get("")
+def get_tasks():
+    query = db.select(Task)
+
+    sort_param = request.args.get("sort")
+
+    if sort_param == "asc":
+        tasks = db.session.scalars(query.order_by(Task.title.asc()))
+    elif sort_param == "desc":
+        tasks = db.session.scalars(query.order_by(Task.title.desc()))
+    else:
+        tasks = db.session.scalars(query.order_by(Task.id))
+
+    tasks_response = []
+    for task in tasks:
+        valid_task = task.to_dict()
+        if not has_special_chars(valid_task["title"]):
+            tasks_response.append(valid_task)
+    return tasks_response
+
+def has_special_chars(title):
+    special_chars = "#$%()*+,-./:;<=>?@[\]^_`{|}~"
+    for char in title:   
+        if char in special_chars:
+            raise ValueError
+    return False
+
+@bp.get("/<id>")
+def get_one_task(id):
+    task = validate_model(Task, id)
+    return {"task": task.to_dict()},200 
+
+@bp.put("/<id>")
+def update_task(id):
+    task = validate_model(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")
+
+@bp.patch("/<id>/mark_complete")
+def mark_task_complete(id):
+    task = validate_model(Task, id)
+
+    data = {
+            "token": f"{os.environ.get('SLACK_API_TOKEN')}",
+            "channel":"test-slack-api",
+            "text":"Someone just completed the task My Beautiful Task"
+            }
+    response = requests.post("https://slack.com/api/chat.postMessage", data=data, 
+                                headers={
+                                    "Authorization": f"Bearer {os.environ.get('SLACK_API_TOKEN')}"
+                                })
+
+    if not task.completed_at:
+        task.completed_at = datetime.now()
+
+    db.session.commit()
+    return Response(status=204, mimetype="application/json")
+
+@bp.patch("/<id>/mark_incomplete")
+def mark_task_incomplete(id):
+    task = validate_model(Task, id)
+
+    if task.completed_at:
+        task.completed_at = None
+
+    db.session.commit()
+    return Response(status=204, mimetype="application/json")
+
+@bp.delete("/<id>")
+def delete_task(id):
+    task = validate_model(Task, id)
+    db.session.delete(task)
+    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