Zoisite Luwam Ghebremicael

Procfile

@@ -0,0 +1,2 @@
+release: flask db upgrade
+web: gunicorn "app:create_app()"

app/__init__.py

@@ -3,6 +3,7 @@
 from flask_migrate import Migrate
 import os
 from dotenv import load_dotenv
+from flask_cors import CORS
 
 
 db = SQLAlchemy()
@@ -12,15 +13,14 @@
 
 def create_app(test_config=None):
     app = Flask(__name__)
+    CORS(app)
     app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
 
     if test_config is None:
-        app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get(
-            "SQLALCHEMY_DATABASE_URI")
+        app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DATABASE_URL")
     else:
         app.config["TESTING"] = True
-        app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get(
-            "SQLALCHEMY_TEST_DATABASE_URI")
+        app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get( "SQLALCHEMY_TEST_DATABASE_URI")
 
     # Import models here for Alembic setup
     from app.models.task import Task
@@ -30,5 +30,10 @@ def create_app(test_config=None):
     migrate.init_app(app, db)
 
     # Register Blueprints here
+    from .task_routes import tasks_bp
+    app.register_blueprint(tasks_bp)
 
+    from .goal_routes import goals_bp
+    app.register_blueprint(goals_bp)
+
     return app

app/goal_routes.py

@@ -0,0 +1,90 @@
+import os
+import requests
+from flask import Blueprint, jsonify, make_response, request
+from app import db
+from app.models.goal import Goal 
+from app.models.task import Task
+from app.helper import validate_goal, validate_task
+
+#CREATE BP/ENDPOINT
+goals_bp = Blueprint("goals", __name__, url_prefix="/goals")
+
+# GET all goals - GET[READ] - /goals
+@goals_bp.route("", methods =["GET"])
+def get_all_goals():
+    # if request.args.get("sort") == "asc":
+    #     goals = Goal.query.order_by(Goal.title.asc())
+    # elif request.args.get("sort") == "desc":
+    #     goals = Goal.query.order_by(Goal.title.desc())
+    # else:
+    goals = Goal.query.all()
+    goals_response = []
+    for goal in goals:
+        goals_response.append(goal.to_json())
+
+    return jsonify(goals_response), 200
+
+# GET one goal - /goals/<id>  - [READ]
+@goals_bp.route("/<id>", methods=["GET"])
+def get_one_goal(id):
+    goal = validate_goal(id)
+    return jsonify({"goal":goal.to_json()}), 200
+
+#POST  - /goals - [CREATE]
+@goals_bp.route("", methods= ["POST"])
+def create_goal():
+    request_body = request.get_json()
+    new_goal = Goal.create_dict(request_body)
+    db.session.add(new_goal)
+    db.session.commit()
+    return make_response({"goal":new_goal.to_json()}), 201
+
+#UPDATE one goal- PUT /goals/<id>  [UPDATE]
+@goals_bp.route("/<id>",methods=["PUT"])
+def update_goal(id):
+    goal = validate_goal(id)
+    request_body = request.get_json()
+    goal.update_dict(request_body)
+    db.session.commit()
+
+    return jsonify({"goal":goal.to_json()}), 200
+
+#DELETE one goal -DELETE /goals/<id> [DELETE]
+@goals_bp.route("/<id>", methods=["DELETE"])
+def delete_goal(id):
+    goal_to_delete = validate_goal(id)
+
+    db.session.delete(goal_to_delete)
+    db.session.commit()
+
+    message = {"details": f'Goal 1 "{goal_to_delete.title}" successfully deleted'}
+    return make_response(message, 200)
+
+#POST tasks ids to goal  /goals/1/tasks [CREATE]
+@goals_bp.route("/<id>/tasks", methods=["POST"])
+def post_task_ids_to_goal(id):
+    goal = validate_goal(id)
+    request_body = request.get_json()
+
+    validated_task = []
+    [validated_task.append(validate_task(task_id)) for task_id in request_body["task_ids"]]
+    # for task_id in request_body["task_ids"]:
+    #     task = validate_task(task_id)
+    #     validated_task.append(task)
+
+    [goal.tasks.append(task) for task in validated_task if task not in goal.tasks]
+    # for task in validated_task:
+    #     if task not in goal.tasks:
+    #         goal.tasks.append(task)
+
+    db.session.commit()
+
+
+    return make_response({"id" : goal.goal_id, "task_ids":request_body["task_ids"]}), 200
+
+# GET one goal - /goals/<id>  - [READ]
+@goals_bp.route("/<id>/tasks", methods=["GET"])
+def get_tasks_in_one_goal(id):
+    goal = validate_goal(id)
+    goal_with_tasks = [Task.to_json(task) for task in goal.tasks]
+    return jsonify({"id":goal.goal_id, "title":goal.title, "tasks":goal_with_tasks}), 200

app/helper.py

@@ -0,0 +1,31 @@
+from flask import abort, make_response
+from app.models.goal import Goal
+from app.models.task import Task
+
+def validate_task(id):
+    try:
+        id = int(id)
+    except:
+        abort(make_response({"message": f"Task {id} is invalid"}, 400))
+
+    task = Task.query.get(id)
+
+    if not task:
+        abort(make_response({"message": f"Task {id} not found"}, 404))
+
+    return task
+
+
+def validate_goal(id):
+    try:
+        id = int(id)
+    except:
+        abort(make_response({"message": f"Goal {id} is invalid"}, 400))
+
+    goal = Goal.query.get(id)
+
+    if not goal:
+        abort(make_response({"message": f"Goal {id} not found"}, 404))
+
+    return goal
+

app/models/goal.py

@@ -1,5 +1,53 @@
 from app import db
+from flask import abort, make_response, jsonify
 
-
+# Define the Goal class: it represents a goal in the database
 class Goal(db.Model):
+    # Define the goal_id column as the primary key for the Goal table
     goal_id = db.Column(db.Integer, primary_key=True)
+
+    # Define the title column as a string that cannot be null
+    title = db.Column(db.String, nullable = False)
+
+
+    # Establish a one-to-many relationship with the Task model(many tasks)
+    # The `tasks` attribute holds a list of Task objects related to this Goal
+    # `back_populates` refers to the "goal" relationship defined in the Task model
+    tasks = db.relationship("Task", back_populates="goal", lazy=True)
+
+
+    # Convert a Goal object to a JSON-serializable dictionary
+    def to_json(self):
+        return{
+            "id": self.goal_id,
+            "title": self.title
+        }
+
+    # Update the Goal object's attributes based on the provided request body
+    def update_dict(self, request_body):
+        self.title = request_body["title"]
+
+
+    # @classmethod decorator indicates that create_dict is a class method associated 
+    # with the class itself rather than any particular instance of the class
+
+    # cls parameter: a reference to the class (Goal in this case) and is used 
+    # to call the class’s constructor (cls(...)), allowing the method to create a new instance of the class.
+
+    # create_dict method is designed to create a new Goal object using data provided in a dictionary (response_body).
+    @classmethod
+    # When the create_dict method creates a new Goal object, it does so by calling the class constructor (cls(...))
+    def create_dict(cls, response_body):
+        try:
+            # Create a new Goal object by calling the class constructor (cls(...)) 
+            # Extract the "title" value from response_body and pass it to the Goal constructor
+            # to set the title attribute of the new Goal instance.
+            new_goal = cls(
+                title = response_body["title"]
+            )
+        except KeyError:
+            # If the "title" key is missing from the response body, return a 400 error
+            abort(make_response(jsonify({"details": "Invalid data"}), 400))                              
+        return new_goal
+
+

app/models/task.py

@@ -1,5 +1,49 @@
 from app import db
-
+from flask import abort, make_response, jsonify
+from datetime import datetime
 
 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, nullable = False)
+    description = db.Column(db.String, nullable = False )
+    completed_at = db.Column(db.DateTime, default = None, nullable = True)
+    #child - many to one (the task are the children/ many children(tasks) to one parent(goal))
+    goal_id = db.Column(db.Integer, db.ForeignKey("goal.goal_id"), nullable=True)
+    goal = db.relationship("Goal", back_populates="tasks")
+
+
+    def to_json(self):
+        is_complete = True if self.completed_at else False;
+
+        task_return = {
+            "id": self.task_id,
+            "title": self.title,
+            "description": self.description,
+            "is_complete": is_complete
+        }
+
+        if self.goal_id:
+            task_return["goal_id"] = self.goal_id
+
+        return task_return
+
+    def update_dict(self, request_body):
+        self.title = request_body["title"]
+        self.description = request_body["description"]
+
+    def patch_complete(self, request_body):
+        self.completed_at = datetime.utcnow()
+
+    def patch_incomplete(self,request_body):
+        self.completed_at = None
+
+    @classmethod
+    def create_dict(cls, response_body):
+        try:
+            new_task = cls(
+                title = response_body["title"],
+                description = response_body["description"]
+            )
+        except KeyError:
+            abort(make_response(jsonify({"details": "Invalid data"}), 400))                              
+        return new_task

app/task_routes.py

@@ -0,0 +1,95 @@
+import os, requests
+from flask import Blueprint, jsonify, make_response, request
+from app import db
+from app.models.task import Task
+from app.helper import validate_task
+
+#CREATE BP/ENDPOINT
+tasks_bp = Blueprint("tasks", __name__, url_prefix= "/tasks") 
+
+# GET all tasks - /tasks [READ] 
+@tasks_bp.route("", methods =["GET"])
+def get_all_tasks():
+    if request.args.get("sort") == "asc":
+        tasks = Task.query.order_by(Task.title.asc())
+    elif request.args.get("sort") == "desc":
+        tasks = Task.query.order_by(Task.title.desc())
+    else:
+        tasks = Task.query.all()
+    tasks_response = []
+    for task in tasks:
+        tasks_response.append(task.to_json())
+
+    return jsonify(tasks_response), 200
+
+# GET one task - /tasks/<id>  [READ]
+@tasks_bp.route("/<id>", methods=["GET"])
+def get_one_task(id):
+    task = validate_task(id)
+    return jsonify({"task":task.to_json()}), 200
+
+#POST  - /tasks [CREATE]
+@tasks_bp.route("", methods= ["POST"])
+def create_task():
+    request_body = request.get_json()
+    new_task = Task.create_dict(request_body)
+
+    db.session.add(new_task)
+    db.session.commit()
+
+    return make_response({"task":new_task.to_json()}), 201
+
+#PUT one task - /tasks/<id>  [UPDATE]
+@tasks_bp.route("/<id>",methods=["PUT"])
+def update_task(id):
+    task = validate_task(id)
+    request_body = request.get_json()
+    task.update_dict(request_body)
+
+    db.session.commit()
+
+    return jsonify({"task":task.to_json()}), 200
+
+#DELETE one task - /tasks/<id> [DELETE]
+@tasks_bp.route("/<id>", methods=["DELETE"])
+def delete_task(id):
+    task_to_delete = validate_task(id)
+
+    db.session.delete(task_to_delete)
+    db.session.commit()
+
+    message = {"details": f'Task 1 "{task_to_delete.title}" successfully deleted'}
+    return make_response(message, 200)
+
+#PATCH /tasks/1/mark_incomplete [UPDATE]
+@tasks_bp.route("/<id>/mark_incomplete", methods = ["PATCH"])
+def mark_incompleted(id):
+    task_to_incomplete = validate_task(id)
+    request_body = request.get_json()
+    task_to_incomplete.patch_incomplete(request_body)
+
+    db.session.commit()
+
+    return jsonify({"task":task_to_incomplete.to_json()}), 200
+
+# PATCH tasks/<id>/mark_complete [UPDATE]
+@tasks_bp.route("/<id>/mark_complete", methods=["PATCH"])
+def mark_completed(id):
+    task_to_complete = validate_task(id)
+    request_body = request.get_json()
+    task_to_complete.patch_complete(request_body)
+
+    db.session.commit()
+
+    PATH = "https://slack.com/api/chat.postMessage"
+
+    query_params = {
+        "channel": "api-test-channel",
+        "text": f'Task {task_to_complete.title} has been completed!'
+    }
+
+    the_headers = {"Authorization": os.environ.get("SLACK_API_KEY")}
+
+    requests.post(PATH, params=query_params, headers=the_headers)
+
+    return jsonify({"task":task_to_complete.to_json()}), 200

migrations/README

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