My_task_list_api

app/__init__.py

@@ -1,5 +1,7 @@
 from flask import Flask
 from .db import db, migrate
+from .routes.task_routes import tasks_bp
+from .routes.goal_routes import goals_bp 
 from .models import task, goal
 import os
 
@@ -10,13 +12,11 @@ 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, url_prefix="/tasks")
+    app.register_blueprint(goals_bp, url_prefix="/goals")
     return app

app/models/goal.py

@@ -1,5 +1,27 @@
-from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy import Integer, String
 from ..db import db
 
 class Goal(db.Model):
-    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    __tablename__ = "goals"
+
+    id: Mapped[int]    = mapped_column(Integer, primary_key=True, autoincrement=True)
+    title: Mapped[str] = mapped_column(String, nullable=False)
+
+    tasks: Mapped[list["Task"]] = relationship(
+        "Task",
+        back_populates="goal",
+        cascade="all, delete-orphan"
+    )
+
+    def to_dict(self) -> dict:
+        return {
+            "id":    self.id,
+            "title": self.title
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(
+            title=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 sqlalchemy import Integer, String, Text, DateTime, ForeignKey
 from ..db import db
 
 class Task(db.Model):
-    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    __tablename__ = "tasks"
+
+    id:           Mapped[int]       = mapped_column(Integer, primary_key=True, autoincrement=True)
+    title:        Mapped[str]       = mapped_column(String, nullable=False)
+    description:  Mapped[str]       = mapped_column(Text, nullable=False)
+    completed_at: Mapped[DateTime]  = mapped_column(DateTime, nullable=True)
+
+    # ← NEW: FK to goals.id
+    goal_id:      Mapped[int|None]  = mapped_column(
+                           ForeignKey("goals.id"),
+                           nullable=True
+    )
+    goal:         Mapped["Goal"]    = relationship(
+                           "Goal",
+                           back_populates="tasks"
+    )
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(
+            title        = data["title"],
+            description  = data["description"],
+            completed_at = data.get("completed_at")
+        )
+
+    def to_dict(self):
+        return {
+            "id":           self.id,
+            "title":        self.title,
+            "description":  self.description,
+            "is_complete":  bool(self.completed_at)
+        }

app/routes/goal_routes.py

@@ -1 +1,108 @@
-from flask import Blueprint
+from flask import Blueprint, abort, make_response, request, Response
+from ..models.goal import Goal
+from ..models.task import Task
+from ..db import db
+
+goals_bp = Blueprint("goals_bp", __name__, url_prefix="/goals")
+
+def validate_goal(goal_id):
+    try:
+        gid = int(goal_id)
+    except ValueError:
+        invalid = {"message": f"Goal id '{goal_id}' is invalid. Must be an integer."}
+        abort(make_response(invalid, 400))
+
+    goal = db.session.get(Goal, gid)
+    if not goal:
+        not_found = {"message": f"Goal with id '{goal_id}' not found."}
+        abort(make_response(not_found, 404))
+
+    return goal
+
+@goals_bp.post("")
+def create_goal():
+    request_body = request.get_json() or {}
+    if "title" not in request_body:
+        return make_response({"details": "Invalid data"}, 400)
+
+    new_goal = Goal.from_dict(request_body)
+    db.session.add(new_goal)
+    db.session.commit()
+
+    return {"goal": new_goal.to_dict()}, 201
+
+@goals_bp.get("")
+def get_all_goals():
+    query = db.select(Goal).order_by(Goal.id)
+    goals = db.session.scalars(query)
+
+    goals_response = [g.to_dict() for g in goals]
+    return goals_response, 200
+
+@goals_bp.get("/<id>")
+def get_one_goal(id):
+    goal = validate_goal(id)
+    return {"goal": goal.to_dict()}, 200
+
+@goals_bp.put("/<id>")
+def update_goal(id):
+    goal = validate_goal(id)
+    request_body = request.get_json() or {}
+    if "title" not in request_body:
+        return make_response({"details": "Invalid data"}, 400)
+
+    goal.title = request_body["title"]
+    db.session.commit()
+
+    return Response(status=204, mimetype="application/json")
+
+@goals_bp.delete("/<id>")
+def delete_goal(id):
+    goal = validate_goal(id)
+    db.session.delete(goal)
+    db.session.commit()
+
+    return Response(status=204, mimetype="application/json")
+#------------------Wave 6------------------------
+@goals_bp.post("/<goal_id>/tasks")
+def assign_tasks_to_goal(goal_id):
+    goal = validate_goal(goal_id)
+
+    data = request.get_json() or {}
+    if "task_ids" not in data or not isinstance(data["task_ids"], list):
+        return make_response({"details": "Invalid data"}, 400)
+
+    tasks_to_assign = []
+    for tid in data["task_ids"]:
+        task = db.session.get(Task, tid)
+        if not task:
+            abort(make_response(
+                {"message": f"Task with id '{tid}' not found."},
+                404
+            ))
+        tasks_to_assign.append(task)
+
+    goal.tasks = tasks_to_assign
+    db.session.commit()
+
+    return {"id": goal.id, "task_ids": data["task_ids"]}, 200
+
+@goals_bp.get("/<goal_id>/tasks")
+def get_tasks_for_goal(goal_id):
+    goal = validate_goal(goal_id)
+
+    tasks_list = []
+    for t in goal.tasks:
+        tasks_list.append({
+            "id":           t.id,
+            "goal_id":      t.goal_id,        
+            "title":        t.title,
+            "description":  t.description,
+            "is_complete":  bool(t.completed_at)
+        })
+
+    return {
+        "id":    goal.id,
+        "title": goal.title,
+        "tasks": tasks_list
+    }, 200

app/routes/task_routes.py

@@ -1 +1,132 @@
-from flask import Blueprint
+import os
+from flask import Blueprint, abort, make_response, request, Response
+from app.models.task import Task
+from datetime import datetime, timezone
+from ..db import db
+import requests
+
+tasks_bp = Blueprint("tasks_bp", __name__, url_prefix="/tasks")
+
+def validate_task(task_id):
+
+    try:
+        tid = int(task_id)
+    except ValueError:
+        abort(make_response(
+            {"message": f"Task id '{task_id}' is invalid. Must be an integer."},
+            400
+        ))
+
+    task = db.session.get(Task, tid)
+    if not task:
+        not_found = {"message": f"Task with id '{task_id}' not found."}
+        abort(make_response(not_found, 404))
+
+    return task
+
+@tasks_bp.post("")
+def create_task():
+    request_body = request.get_json() or {}
+    if "title" not in request_body or "description" not in request_body:
+        return make_response({"details": "Invalid data"}, 400)
+
+    new_task = Task.from_dict(request_body)
+    db.session.add(new_task)
+    db.session.commit()
+
+    return {"task": new_task.to_dict()}, 201
+
+@tasks_bp.get("")
+def get_all_tasks():
+
+    query = db.select(Task)
+
+    sort_param = request.args.get("sort") #Checks the URL for ?sort=asc or ?sort=desc
+    if sort_param == "asc":
+        query = query.order_by(Task.title)
+    elif sort_param == "desc":
+        query = query.order_by(Task.title.desc())
+    else:
+        query = query.order_by(Task.id)
+
+    tasks = db.session.scalars(query) #Executes the query
+
+    tasks_response = []
+    for task in tasks:
+        tasks_response.append({
+            "id":          task.id,
+            "title":       task.title,
+            "description": task.description,
+            "is_complete": bool(task.completed_at)
+        })
+
+    return tasks_response, 200
+
+@tasks_bp.patch("/<id>/mark_complete")
+def mark_complete(id):
+    task = validate_task(id)
+
+    task.completed_at = datetime.now(timezone.utc)
+    db.session.commit()
+    token = os.environ.get('SLACK_BOT_TOKEN', "")
+
+    url = "https://slack.com/api/chat.postMessage"
+    headers = {
+        "Authorization": "Bearer " + token,
+        "Content-Type": "application/json; charset=utf-8"
+    }
+    payload = {
+        "channel": "test-slack-api",
+        "text": "Someone just completed the task: " + task.title
+    }
+
+    requests.post(url, headers=headers, json=payload)
+
+    return Response(status=204, mimetype="application/json")
+
+@tasks_bp.patch("/<id>/mark_incomplete")
+def mark_incomplete(id):
+    task = validate_task(id)
+
+    # clear completed_at
+    task.completed_at = None
+    db.session.commit()
+
+    return Response(status=204, mimetype="application/json")
+
+@tasks_bp.get("/<id>")
+def get_one_task(id):
+    task = validate_task(id)
+
+    task_data = {
+        "id":           task.id,
+        "title":        task.title,
+        "description":  task.description,
+        "is_complete":  bool(task.completed_at)
+    }
+
+    if task.goal_id is not None:
+        task_data["goal_id"] = task.goal_id
+
+    return {"task": task_data}, 200
+
+@tasks_bp.put("/<id>")
+def update_task(id):
+    task = validate_task(id)
+    request_body = request.get_json() or {}
+    if "title" not in request_body or "description" not in request_body:
+        return make_response({"details": "Invalid data"}, 400)
+
+    task.title       = request_body["title"]
+    task.description = request_body["description"]
+
+    db.session.commit()
+
+    return Response(status=204, mimetype="application/json")
+
+@tasks_bp.delete("/<id>")
+def delete_task(id):
+    task = validate_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