Sharks Kassidy Buslach task-list-api

ada-project-docs/wave_04.md

@@ -98,9 +98,13 @@ 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?
+- ---- Allows the bot to post on channels
 - What is the URL and HTTP method for this endpoint?
+- ---- http = POST "https://slack.com/api/chat.postMessage"
 - What are the _two_ _required_ arguments for this endpoint?
+- ---- Token, channel, (attachment,block, text)
 - How does this endpoint relate to the Slackbot API key (token) we just created?
+-  ---- The token is required in the response of the request body in the JSON
 
 Now, visit https://api.slack.com/methods/chat.postMessage/test.
 
@@ -119,8 +123,11 @@ 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?
+    - We see the message in slack but no success message.
 - Did we get an error emssage? If so, why?
+  - I tested without text and we get an error message 
 - What is the shape of this JSON? Is it a JSON object or array? What keys and values are there?
+It is a nested dictionary with some keys nested with dictionaries and some nested with lists.
 
 ### Verify with Postman
 

app/__init__.py

@@ -9,7 +9,6 @@
 migrate = Migrate()
 load_dotenv()
 
-
 def create_app(test_config=None):
     app = Flask(__name__)
     app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
@@ -28,7 +27,13 @@ def create_app(test_config=None):
 
     db.init_app(app)
     migrate.init_app(app, db)
+    from app.models.task import Task
+    from app.models.goal import Goal
 
     # Register Blueprints here
+    from .routes import task_db
+    from .routes import goal_db
+    app.register_blueprint(task_db)
+    app.register_blueprint(goal_db)
 
     return app

app/models/goal.py

@@ -2,4 +2,37 @@
 
 
 class Goal(db.Model):
-    goal_id = db.Column(db.Integer, primary_key=True)
+    goal_id = db.Column(db.Integer, primary_key=True, autoincrement = True)
+    title = db.Column(db.String)
+    tasks = db.relationship("Task", back_populates="goal", lazy = True)
+
+    def goal_to_json(self):
+        json_response = {
+            "id": self.goal_id,
+            "title": self.title
+        }
+        if self.tasks:
+            json_response["tasks"]= self.title
+
+        return json_response
+
+    def update_goal(self, request_body):
+        self.title = request_body["title"]
+
+
+    @classmethod
+    def create_goal(cls, request_body):
+        new_goal = cls(
+        title = request_body["title"])
+
+        return new_goal
+
+
+    def add_tasks(self, response_body):
+        if response_body["task_ids"]:
+            self.tasks = response_body["task_ids"]
+
+
+
+
+# goal_id = goal_id,

app/models/helper.py

@@ -0,0 +1,39 @@
+from .task import Task
+from .goal import Goal
+from flask import abort, make_response
+
+def validate_id(task_id):
+    try:
+        task_id = int(task_id)
+    except:
+        return abort(make_response({"message": f"Task {task_id} is not valid"}, 400))
+    task = Task.query.get(task_id)
+    if not task:
+        return abort(make_response({"message": f"Task {task_id} does not exist"}, 404))
+
+    return task
+
+
+def validate_goal_id(goal_id):
+    try:
+        goal_id = int(goal_id)
+    except:
+        return abort(make_response({"message": f"Goal {goal_id} is not valid"}, 400))
+    goal = Goal.query.get(goal_id)
+    if not goal:
+        return abort(make_response({"message": f"Goal {goal_id} does not exist"}, 404))
+
+    return goal
+
+def validate_data(request_body):
+    # return abort(make_response(f"Invalid data"),400)
+    if 'title' not in request_body:
+        return abort(make_response({"details":f"Invalid data"},400))
+    elif 'description' not in request_body:
+        return abort(make_response({"details":f"Invalid data"},400))
+    return request_body
+
+def validate_goal(request_body):
+    if 'title' not in request_body:
+        return abort(make_response({"details":f"Invalid data"},400))
+    return request_body

app/models/task.py

@@ -1,5 +1,49 @@
 from app import db
+from flask import make_response
+from sqlalchemy import asc
+from datetime import datetime
+from app.models.goal import Goal
 
 
 class Task(db.Model):
-    task_id = db.Column(db.Integer, primary_key=True)
+    task_id = db.Column(db.Integer, primary_key=True, autoincrement = True)
+    title = db.Column(db.String)
+    description = db.Column(db.String)
+    completed_at = db.Column(db.DateTime, nullable = True, default = None)
+    goal_id = db.Column(db.Integer, db.ForeignKey('goal.goal_id'))
+    goal = db.relationship("Goal", back_populates="tasks")
+
+    def to_json(self):
+        json_response = {
+            "id": self.task_id,
+            "title": self.title,
+            "description":self.description
+        }
+        if self.completed_at:
+            json_response["is_complete"] = True
+        else:
+            json_response["is_complete"] = False
+
+        if self.goal_id:
+            json_response["goal_id"] =self.goal_id
+
+        return json_response
+
+    def update_task(self, request_body):
+        self.title = request_body["title"]
+        self.description = request_body["description"]
+        if self.completed_at:
+            if self.completed_at == request_body['completed_at']:
+                self.completed_at = datetime.utcnow()
+
+
+
+    @classmethod
+    def create_task(cls, request_body):
+
+        new_task = cls(title = request_body["title"],
+                    description = request_body["description"],
+                    completed_at = request_body.get("completed_at", None)
+            )
+
+        return new_task

app/routes.py

@@ -1 +1,175 @@
-from flask import Blueprint
+from flask import Blueprint, jsonify, make_response, request, abort
+from requests import session
+from app.models.task import Task
+from app.models.goal import Goal
+from app.models.helper import validate_id, validate_data, validate_goal_id, validate_goal
+from app import db
+from sqlalchemy import asc, desc
+from datetime import datetime
+import requests
+import os 
+
+task_db = Blueprint("tasks",__name__, url_prefix = "/tasks")
+goal_db = Blueprint("goals", __name__, url_prefix = "/goals")
+
+# guard clause for invalid sort request 
+@task_db.route("", methods = ["GET"])
+def get_all_tasks():
+    task_response = []
+    sort_query = request.args.get("sort")
+    if not sort_query:
+        ordered_tasks = Task.query.all()
+    elif sort_query == "asc":
+        ordered_tasks = Task.query.order_by(asc(Task.title)).all()
+    elif sort_query == "desc":
+        ordered_tasks = Task.query.order_by(desc(Task.title)).all()
+
+    for task in ordered_tasks:
+        task_response.append(task.to_json())
+    return jsonify(task_response), 200
+
+@task_db.route("/<task_id>", methods = ["GET"])
+def get_one_task(task_id):
+    task_response = []
+    task = validate_id(task_id)
+    return jsonify({"task": task.to_json()}), 200
+
+@task_db.route("", methods = ["POST"])
+def create_one_response():
+    request_body = request.get_json()
+    valid_data = validate_data(request_body)
+    new_task = Task.create_task(valid_data)
+    db.session.add(new_task)
+    db.session.commit()
+    return jsonify({"task":new_task.to_json()}), 201
+
+
+@task_db.route("/<task_id>", methods = ["PUT"])
+def update_task(task_id):
+    task = validate_id(task_id)
+    request_body = request.get_json()
+    task.update_task(request_body)
+
+    db.session.commit()
+    return jsonify({"task":task.to_json()}), 200
+
+@task_db.route("/<task_id>", methods = ["DELETE"])
+def delete_task(task_id):
+    task = validate_id(task_id)
+    task_title = Task.query.get(task_id)
+    db.session.delete(task)
+    db.session.commit()
+    return {
+        "details": f'Task {task_id} \"{task_title.title}\" successfully deleted'}, 200 
+
+# @task_db.route("/<task_id>/mark_complete", methods = ["PATCH"])
+# def mark_task_complete(task_id):
+#     task = validate_id(task_id)
+
+#     task.completed_at = datetime.now()
+
+#     db.session.commit()
+#     return jsonify({"task":task.to_json()}), 200
+
+@task_db.route("/<task_id>/mark_incomplete", methods = ["PATCH"])
+def mark_task_incomplete(task_id):
+    task = validate_id(task_id)
+
+    task.completed_at = None
+
+    db.session.commit()
+    return jsonify({"task":task.to_json()}), 200
+
+TOKEN = os.environ.get("SLACK_TOKEN")
+SLACK_URL = os.environ.get("SLACK_URL")
+@task_db.route("/<task_id>/mark_complete", methods = ["PATCH"])
+def mark_task_complete_by_slack_bot(task_id):
+    task = validate_id(task_id)
+    validated_task = task.query.get(task_id)
+    task.completed_at = datetime.now()
+
+    headers = {"Authorization":f"Bearer {TOKEN}"}
+    data = {
+        "channel":"task-notifications",
+        "text": f"Someone just completed the task {task.title}."
+    }
+    res = requests.post(SLACK_URL, headers=headers, data=data)
+
+    db.session.commit()
+    return jsonify({"task":task.to_json()}), 200
+
+
+@goal_db.route("/<goal_id>", methods = ["GET"])
+def get_one_goal(goal_id):
+    goal_response = []
+    goal = validate_goal_id(goal_id)
+    return jsonify({"goal": goal.goal_to_json()}), 200
+
+@goal_db.route("", methods = ["GET"])
+def get_all_goals():
+    goal_response = []
+    goals = Goal.query.all()
+    for goal in goals:
+        goal_response.append(goal.goal_to_json())
+
+    return jsonify(goal_response), 200
+
+@goal_db.route("", methods = ["POST"])
+def create_goals():
+    request_body = request.get_json()
+    is_valid = validate_goal(request_body)
+    new_goal = Goal.create_goal(is_valid)
+
+    db.session.add(new_goal)
+    db.session.commit()
+
+    return jsonify({"goal":new_goal.goal_to_json()}), 201
+
+@goal_db.route("/<goal_id>", methods = ["DELETE"])
+def delete_task(goal_id):
+    goal = validate_goal_id(goal_id)
+    goal_title = Goal.query.get(goal_id)
+    db.session.delete(goal_title)
+    db.session.commit()
+    return {
+        "details": f'Goal {goal_id} \"{goal_title.title}\" successfully deleted'}, 200 
+
+@goal_db.route("/<goal_id>", methods = ["PUT"])
+def update_task(goal_id):
+    goal = validate_goal_id(goal_id)
+    request_body = request.get_json()
+    goal.update_goal(request_body)
+
+    db.session.commit()
+    return jsonify({"Goal":goal.goal_to_json()}), 200
+
+
+
+@goal_db.route("/<goal_id>/tasks", methods = ["GET"])
+def get_all_goals_and_tasks(goal_id):
+    valid_goal = validate_goal_id(goal_id)
+
+    task_response = []
+    for task in valid_goal.tasks:
+        task_response.append(task.to_json())
+
+
+    result = {"id": valid_goal.goal_id,
+    "title":valid_goal.title,
+    "tasks": task_response}
+
+    return result, 200
+
+@goal_db.route("/<goal_id>/tasks", methods = ["POST"])
+def create_one_goal(goal_id):
+    valid_goal = validate_goal_id(goal_id)
+    request_body = request.get_json()
+
+
+    for task_id in request_body["task_ids"]:
+        validate_id(task_id)
+        task = Task.query.get(task_id)
+        valid_goal.tasks.append(task)
+    db.session.commit()
+
+    return {"id":valid_goal.goal_id,"task_ids":request_body["task_ids"]}, 200

migrations/README

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