Philomena Kelly - Sharks

Procfile

@@ -0,0 +1 @@
+web: gunicorn 'app:create_app()'

ada-project-docs/wave_01.md

@@ -8,7 +8,7 @@ Tasks are entities that describe a task a user wants to complete. They contain a
 
 - title to name the task
 - description to hold details about the task
-- an optional datetime that the task is completed on
+- an optional datetime  that the task is completed on
 
 Our goal for this wave is to be able to create, read, update, and delete different tasks. We will create RESTful routes for this different operations.
 

app/__init__.py

@@ -31,4 +31,11 @@ def create_app(test_config=None):
 
     # Register Blueprints here
 
+    from .routes import tasks_bp
+    app.register_blueprint(tasks_bp)
+
+    from .routes import goals_bp
+    app.register_blueprint(goals_bp)
+
+
     return app

app/models/goal.py

@@ -1,5 +1,35 @@
 from app import db
+from datetime import datetime
 
 
 class Goal(db.Model):
     goal_id = db.Column(db.Integer, primary_key=True)
+    title = db.Column(db.String)
+    tasks = db.relationship("Task", back_populates="goal") 
+
+
+    def to_json(self, category=None):
+
+        goal_dict = { 
+                    "id": self.goal_id,
+                    "title": self.title,
+                    }
+
+        if category == "tasks":
+            goal_dict["tasks"] = [
+                task.to_json() for task in self.tasks
+            ]
+
+        return goal_dict
+
+
+    def update(self,req_body):
+        self.title = req_body["title"]
+
+
+    @classmethod
+    def create(cls,req_body):
+        new_goal = cls(
+            title=req_body['title'],
+        )
+        return new_goal

app/models/task.py

@@ -1,5 +1,46 @@
 from app import db
+from datetime import datetime
 
 
 class Task(db.Model):
     task_id = db.Column(db.Integer, primary_key=True)
+    title = db.Column(db.String)
+    description = db.Column(db.String)
+    completed_at = db.Column(db.DateTime, nullable=True)
+    is_complete = False
+    goal_id = db.Column(db.Integer, db.ForeignKey('goal.goal_id'))
+    goal = db.relationship("Goal", back_populates="tasks")
+
+
+    def to_json(self):
+        task_dict = { 
+                "id": self.task_id,
+                "title": self.title,
+                "description": self.description,
+                "is_complete" : self.is_complete
+                }
+
+        if self.goal_id:
+            task_dict["goal_id"] = self.goal_id
+
+        return task_dict
+
+    def written_out(cls):
+        return "task"
+
+    def update(self,req_body):
+        self.title = req_body["title"]
+        self.description = req_body["description"]
+
+        if req_body.get("completed_at"):
+            self.is_complete = True
+            self.completed_at = datetime.now()
+
+
+    @classmethod
+    def create(cls,req_body):
+        new_task = cls(
+            title=req_body['title'],
+            description=req_body['description'],
+        )
+        return new_task

app/routes.py

@@ -1 +1,255 @@
-from flask import Blueprint
+from os import abort
+from app import db
+from app.models.task import Task
+from flask import Blueprint, jsonify, abort, make_response, request
+from sqlalchemy.sql import text
+from datetime import datetime
+import requests
+import os
+from dotenv import load_dotenv
+from app.models.goal import Goal
+
+tasks_bp = Blueprint("tasks_bp", __name__, url_prefix="/tasks")
+goals_bp = Blueprint("goals_bp", __name__, url_prefix="/goals")
+
+
+@goals_bp.route("/<goal_id>/tasks", methods=["POST"])
+def create_task(goal_id):
+
+    goal = validate_object("goal", goal_id)
+
+    request_body = request.get_json()
+
+    for task in request_body["task_ids"]:
+        task = validate_object("task", task)
+        task.goal_id = goal_id
+
+    db.session.commit()
+
+    tasks = []
+
+    for task in goal.tasks:
+        tasks.append(task.task_id)
+
+    response = {
+        "id" : goal.goal_id,
+        "task_ids" : tasks
+    }
+
+    return make_response(jsonify(response), 200)    
+
+
+
+@goals_bp.route("/<goal_id>/tasks", methods=["GET"])
+def get_tasks_by_goals(goal_id):
+
+    goal = validate_object("goal", goal_id)
+
+    response = goal.to_json(category="tasks")
+
+    return make_response(jsonify(response), 200)    
+
+
+
+
+
+@goals_bp.route("", methods=["POST"])
+def create_one_goal():
+
+    request_body = request.get_json()
+
+    try:
+        new_goal = Goal.create(request_body)
+    except KeyError:
+        return make_response(jsonify({"details" : "Invalid data"}), 400)
+
+    db.session.add(new_goal)
+    db.session.commit()
+
+    response = { "goal": new_goal.to_json()}
+
+    return make_response(response, 201)
+
+
+
+@goals_bp.route("", methods=["GET"])
+def read_all_goals():
+    title_query = request.args.get("sort")
+
+    if title_query:
+        goals = Goal.query.order_by(text(f'title {title_query}'))
+    else:
+        goals = Goal.query.all()
+
+    goals_response = []
+    for goal in goals:
+        goals_response.append(
+            goal.to_json()
+        )
+    return make_response(jsonify(goals_response), 200)
+
+@goals_bp.route("/<goal_id>", methods=["GET"])
+def get_one_goal(goal_id):
+    goal = validate_object("goal", goal_id)
+
+    response = { "goal": goal.to_json()}
+
+    return make_response(response, 200)
+
+
+@goals_bp.route("/<goal_id>", methods=["PUT"])
+def update_one_goal(goal_id):
+
+    goal = validate_object("goal", goal_id)
+
+    request_body = request.get_json()
+
+    goal.update(request_body)
+
+    db.session.commit()
+
+    response = { "goal": goal.to_json()}
+    return make_response(response, 200)
+
+
+@goals_bp.route("/<goal_id>", methods=["DELETE"])
+def delete_one_goal(goal_id):
+
+    goal = validate_object("goal", goal_id)
+
+    db.session.delete(goal)
+    db.session.commit()
+
+    return make_response(jsonify({"details" : f"Goal {goal.goal_id} \"{goal.title}\" successfully deleted"}))
+
+
+@tasks_bp.route("", methods=["POST"])
+def create_task():
+
+    request_body = request.get_json()
+    try:
+        new_task = Task.create(request_body)
+    except KeyError:
+        return make_response(jsonify({"details" : "Invalid data"}), 400)
+
+    if request_body.get("completed_at"):
+        new_task.is_complete = True
+        new_task.completed_at = datetime.now()
+
+    db.session.add(new_task)
+    db.session.commit()
+
+    response = { "task": new_task.to_json()}
+
+    return make_response(response, 201)
+
+
+
+@tasks_bp.route("", methods=["GET"])
+def read_all_tasks():
+    title_query = request.args.get("sort")
+
+    if title_query:
+        tasks = Task.query.order_by(text(f'title {title_query}'))
+    else:
+        tasks = Task.query.all()
+
+    tasks_response = []
+    for task in tasks:
+        tasks_response.append(
+            task.to_json()
+        )
+    return make_response(jsonify(tasks_response), 200)
+
+
+@tasks_bp.route("/<task_id>", methods=["GET"])
+def get_one_task(task_id):
+    task = validate_object("task", task_id)
+
+    response = { "task": task.to_json()}
+
+    return make_response(response, 200)
+
+
+@tasks_bp.route("/<task_id>", methods=["PUT"])
+def update_one_task(task_id):
+
+    task = validate_object("task", task_id)
+
+    request_body = request.get_json()
+
+    task.update(request_body)
+
+    db.session.commit()
+
+    response = { "task": task.to_json()}
+    return make_response(response, 200)
+
+
+
+@tasks_bp.route("/<task_id>", methods=["DELETE"])
+def delete_one_task(task_id):
+
+    task = validate_object("task", task_id)
+
+    db.session.delete(task)
+    db.session.commit()
+
+    return make_response(jsonify({"details" : f"Task {task.task_id} \"{task.title}\" successfully deleted"}))
+
+
+@tasks_bp.route("<task_id>/mark_complete", methods=["PATCH"])
+def mark_task_completed(task_id):
+    task = validate_object("task", task_id)
+
+    task.is_complete = True
+    task.completed_at = datetime.now()
+
+    db.session.commit()
+
+    URL = "https://slack.com/api/chat.postMessage"
+    PARAMS = {'text' : f"Someone just completed the task {task.title}",
+    'channel' : 'task-notifications'}
+    HEADERS = {'Authorization' : f'Bearer {os.environ.get("TASKLIST_BOT_KEY")}'}
+    r = requests.get(url = URL, params = PARAMS, headers = HEADERS)
+
+    response = { "task": task.to_json()}
+
+    return response, 200
+
+
+@tasks_bp.route("<task_id>/mark_incomplete", methods=["PATCH"])
+def mark_task_incompleted(task_id):
+    task = validate_object("task", task_id)
+
+    task.is_complete = False
+    task.completed_at = None
+
+    db.session.commit()
+
+    response = { "task": task.to_json()}
+
+    return response, 200
+
+
+
+
+
+def validate_object(object_type, object_id):
+
+    try:
+        object_id = int(object_id)
+    except:
+        abort(make_response({"message":f"{object_type} {object_id} invalid"}, 400))
+
+    if object_type == "task":
+        item = Task.query.get(object_id)
+    elif object_type == "goal":
+        item = Goal.query.get(object_id)
+
+    if not item:
+        abort(make_response({"message":f"{object_type} {object_id} not found"}, 404))
+
+    return item
+
+

migrations/README

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