added utilities folder which holds create_model, validate_model, delte_model, get_model_with_filters, added goals and goal descriptions, all of wave 5 tests have passed, added slack post api functionality to the mark complete function of tasks.

Author: MBsea21

app/__init__.py

@@ -1,7 +1,11 @@
-from flask import Flask
+from flask import Flask, request, jsonify
+from slack_sdk import WebClient
+from slack_sdk.errors import SlackApiError
 from .db import db, migrate
 from .models import task, goal
 from .routes.task_routes import tasks_bp
+from .routes.slack_routes import slack_bp
+from .routes.goal_routes import goals_bp
 import os
 
 def create_app(config=None):
@@ -20,5 +24,33 @@ def create_app(config=None):
 
     # Register Blueprints here
     app.register_blueprint(tasks_bp)
+    app.register_blueprint(slack_bp)
+    app.register_blueprint(goals_bp)
 
     return app
+
+# from flask import Flask
+# from .db import db, migrate
+# from .models import task, goal
+# from .routes.task_routes import tasks_bp
+# import os
+
+# def create_app(config=None):
+#     app = Flask(__name__)
+
+#     app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+#     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)
+
+#     return app
+

app/models/goal.py

@@ -1,5 +1,32 @@
 from sqlalchemy.orm import Mapped, mapped_column
 from ..db import db
+from datetime import datetime
+from app.routes.utilities_routes import create_model, validate_model, check_for_completion
+from typing import Optional
 
 class Goal(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)
+
+
+    def to_dict(self):
+        task_as_dict = {}
+        task_as_dict["id"] = self.id
+        task_as_dict["title"] = self.title
+        # task_as_dict["description"] = self.description
+        # task_as_dict["is_complete"] = check_for_completion(Goal,self)
+        
+        return task_as_dict
+
+
+
+    @classmethod
+    def from_dict(cls, goal_data):
+        new_task = cls(
+            title=goal_data["title"],
+            # description=goal_data["description"],
+            # completed_at=goal_data["completed_at"]
+        )
+        return new_task

app/models/task.py

@@ -1,6 +1,7 @@
 from sqlalchemy.orm import Mapped, mapped_column
 from ..db import db
 from datetime import datetime
+from app.routes.utilities_routes import create_model, validate_model, check_for_completion
 from typing import Optional
 
 class Task(db.Model):
@@ -9,5 +10,20 @@ class Task(db.Model):
     description: Mapped[str]
     completed_at: Mapped[Optional[datetime]]= mapped_column(nullable = True)
 
+    def to_dict(self):
+        task_as_dict = {}
+        task_as_dict["id"] = self.id
+        task_as_dict["title"] = self.title
+        task_as_dict["description"] = self.description
+        task_as_dict["is_complete"] = check_for_completion(Task,self)
+        
+        return task_as_dict
 
 
+    @classmethod
+    def from_dict(cls, task_data):
+        new_task = cls(
+            title=task_data["title"],
+            description=task_data["description"],
+        )
+        return new_task

app/routes/goal_routes.py

@@ -1 +1,42 @@
-from flask import Blueprint
+from flask import Blueprint, abort, make_response, request, Response
+from app.models.task import Task
+from ..db import db
+from datetime import datetime
+from app.routes.utilities_routes import create_model, validate_model, get_models_with_filters, check_for_completion, delete_model
+from app.models.goal import Goal
+import requests
+
+goals_bp = Blueprint("goals_bp",__name__, url_prefix= "/goals")
+
+
+@goals_bp.post("")
+def create_goal():
+    request_body = request.get_json()
+    return create_model(Goal,request_body)
+
+@goals_bp.get("")
+def get_goals():
+    request_arguements = request.args
+    return get_models_with_filters(Goal, request_arguements)
+
+@goals_bp.get("/<goal_id>")
+def get_one_goal(goal_id):
+    goal = validate_model(Goal, goal_id)
+    response = {"goal": goal.to_dict()}
+    return make_response(response, 200)
+
+@goals_bp.put("/<goal_id>")
+def update_goal(goal_id):
+    goal = validate_model(Goal, goal_id)
+    request_body = request.get_json()
+
+    goal_title = request_body["title"]
+    db.session.commit()
+
+    response_body = {"message": f"Goal #{goal_id} succesfully updated"}
+    return make_response(response_body, 200)
+
+@goals_bp.delete("/<goal_id>")
+def delete_goal(goal_id):
+    goal = validate_model(Goal, goal_id)
+    return delete_model(Goal, goal)

app/routes/slack_routes.py

@@ -0,0 +1,33 @@
+from flask import Blueprint, request, jsonify
+from slack_sdk import WebClient
+from slack_sdk.errors import SlackApiError
+import os
+
+# Initialize the Blueprint
+slack_bp = Blueprint('slack_bp', __name__)
+
+# Slack Bot Token from environment variable
+SLACK_BOT_TOKEN =" os.getenv("APITOKENHERE")
+client = WebClient(token=SLACK_BOT_TOKEN)
+
+@slack_bp.post('/send_message')
+def send_message():
+    data = request.get_json()
+    channel = data.get("channel")
+    message = data.get("message")
+
+    if not channel or not message:
+        return jsonify({"error": "Channel and message are required"}), 400
+
+    try:
+        # Make the chat.postMessage API call
+        response = client.chat_postMessage(channel=channel, text=message)
+        return jsonify({"ok": response["ok"], "message": "Message sent successfully!"}), 200
+    except SlackApiError as e:
+        # Handle Slack API error and print more details for debugging
+        error_message = e.response["error"]
+        print(f"Slack API Error: {error_message}")
+        return jsonify({"ok": False, "error": error_message}), 400
+    app.run(debug=True)
+
+

app/routes/task_routes.py

@@ -1,7 +1,9 @@
 from flask import Blueprint, abort, make_response, request, Response
 from app.models.task import Task
+from app.routes.utilities_routes import create_model, validate_model, get_models_with_filters, check_for_completion, delete_model
 from ..db import db
 from datetime import datetime
+import requests
 
 
 tasks_bp = Blueprint("tasks_bp", __name__, url_prefix="/tasks")
@@ -11,41 +13,8 @@
 @tasks_bp.post("")
 def create_task(): 
     request_body = request.get_json()
-    try: 
-        title = request_body["title"]
-    except: 
-        abort(make_response(invalid_data_response))
+    return create_model(Task,request_body)
 
-    try:
-        description = request_body["description"]
-    except: 
-        abort(make_response(invalid_data_response))
-
-    # is_complete = check_for_completion(request_body)
-    is_complete = False
-##completed_at not an attribute
-    try: 
-        completed_at = request_body["completed_at"]
-    except: 
-        completed_at = None
-    new_task = Task(title=title, description= description,completed_at= completed_at) 
-
-
-    db.session.add(new_task)
-    db.session.commit()
-    
-
-    is_complete = check_for_completion(new_task)
-    response = {"task":{
-        "id": new_task.id,
-        "title": new_task.title,
-        "description": new_task.description,
-        "is_complete": is_complete
-    }}
-
-    return response, 201
-
-#get all tasks with query paramaters added in 
 @tasks_bp.get("")
 def get_tasks():
     query = db.select(Task)
@@ -76,16 +45,16 @@ def get_tasks():
     tasks_response = []
 
     for task in tasks:  
-        tasks_response.append(get_dict(task))
+        tasks_response.append(task.to_dict())
 
     return tasks_response,200
 
 
 #get task by task id: 
 @tasks_bp.get("/<task_id>")
 def get_one_task(task_id):
-    task = validate_task(task_id)
-    task_dict = get_dict(task)
+    task = validate_model(Task,task_id)
+    task_dict = task.to_dict()
     response = {"task":task_dict}
     expected = {
         "task": {
@@ -102,7 +71,7 @@ def get_one_task(task_id):
 #update task
 @tasks_bp.put("/<task_id>")
 def update_task(task_id):
-    task = validate_task(task_id)
+    task = validate_model(Task,task_id)
 
     request_body = request.get_json()
     task.title = request_body["title"]
@@ -115,70 +84,60 @@ def update_task(task_id):
     task.completed_at = completed_at
     db.session.commit()
 
-    response = {"task":get_dict(task)}
+    response = {"task":task.to_dict()}
     return response, 200
 
 
 #Delete task
 @tasks_bp.delete("/<task_id>")
 def delete_task(task_id):
-    task = validate_task(task_id)
-    task_title = task.title
+    task = validate_model(Task,task_id)
+    return delete_model(Task, task)
+    # task_title = task.title
 
-    db.session.delete(task)
-    db.session.commit()
-    details = f"Task {task_id} \"{task_title}\" successfully deleted"
-    response_body = {"details" : details}
+    # db.session.delete(task)
+    # db.session.commit()
+    # details = f"Task {task_id} \"{task_title}\" successfully deleted"
+    # response_body = {"details" : details}
+
+    # return response_body
 
-    return response_body
 
+#route 2
 @tasks_bp.patch("/<task_id>/mark_complete")
 def mark_complete(task_id):
-    task = validate_task(task_id)
+    task = validate_model(Task, task_id)
     task.completed_at = datetime.now()
     db.session.commit()
-    response = {"task": get_dict(task)}
+
+    message = f"Task {task.title} has been marked as complete!"
+    
+    slack_url = "http://127.0.0.1:5000/send_message"
+    payload = {
+        "message": message,
+        "channel": "api-test-channel"
+    }
+
+    try:
+        response = requests.post(slack_url, json=payload)
+        response.raise_for_status()
+    except requests.exceptions.RequestException as e:
+        print(f"failed to send slack message: {e}")
+
+    response = {"task": task.to_dict()}
     return make_response(response, 200)
 
 @tasks_bp.patch("/<task_id>/mark_incomplete")
 def mark_incomplete(task_id):
-    task = validate_task(task_id)
+    task = validate_model(Task, task_id)
     task.completed_at = None
     db.session.commit()
-    response = {"task": get_dict(task)}
+    response = {"task": task.to_dict()}
     return make_response(response,200)
-#helperfunctions
 
-def check_for_completion(task):
-    completed_at = task.completed_at
-    if completed_at is None: 
-        return False
-    else: 
-        return True
-
-def get_dict(task):
-    return {
-        "id": task.id,
-        "title": task.title,
-        "description": task.description,
-        "is_complete": check_for_completion(task)
-    }
 
-def validate_task(task_id):
-    try:
-        task_id = int(task_id)
-    except:
-        response = ({"details" : "invalid data"},400)
-        abort(make_response(response))
-    
-    query = db.select(Task).where(Task.id == task_id)
-    task = db.session.scalar(query)
 
-    if not task:
-        response = ({"details": f"task {task_id} not found"},404)
-        abort(make_response(response))
-    
-    return task
+#helperfunctions