round 4

api/child_api.py

@@ -1,21 +1,22 @@
 from flask import Blueprint, request, jsonify
 from tinydb import Query
-from db.db import child_db, task_db, reward_db
+from db.db import child_db, task_db, reward_db, pending_reward_db
 from api.reward_status import RewardStatus
 from api.child_tasks import ChildTask
 from api.child_rewards import ChildReward
-from events.sse import send_to_user, send_event_to_user
-from events.types.child_add import ChildAdd
-from events.types.child_delete import ChildDelete
-from events.types.child_update import ChildUpdate
+from events.sse import send_event_to_user
+from events.types.child_modified import ChildModified
+from events.types.child_reward_request import ChildRewardRequest
+from events.types.child_reward_triggered import ChildRewardTriggered
+from events.types.child_rewards_set import ChildRewardsSet
+from events.types.child_task_triggered import ChildTaskTriggered
+from events.types.child_tasks_set import ChildTasksSet
 from events.types.event import Event
 from events.types.event_types import EventType
-from events.types.reward_set import RewardSet
-from events.types.reward_update import RewardUpdate
-from events.types.task_set import TaskSet
-from events.types.task_update import TaskUpdate
+from api.pending_reward import PendingReward as PendingRewardResponse
 
 from models.child import Child
+from models.pending_reward import PendingReward
 from models.task import Task
 from models.reward import Reward
 
@@ -28,7 +29,7 @@ def get_child(id):
     result = child_db.search(ChildQuery.id == id)
     if not result:
         return jsonify({'error': 'Child not found'}), 404
-    return jsonify(result[0]), 200
+    return jsonify(Child.from_dict(result[0]).to_dict()), 200
 
 @child_api.route('/child/add', methods=['PUT'])
 def add_child():
@@ -43,7 +44,7 @@ def add_child():
 
     child = Child(name=name, age=age, image_id=image)
     child_db.insert(child.to_dict())
-    send_event_to_user("user123", Event(EventType.CHILD_ADD.value, ChildAdd(child.id, "set")))
+    send_event_to_user("user123", Event(EventType.CHILD_MODIFIED.value, ChildModified(child.id, ChildModified.OPERATION_ADD)))
     return jsonify({'message': f'Child {name} added.'}), 201
 
 @child_api.route('/child/<id>/edit', methods=['PUT'])
@@ -67,7 +68,7 @@ def edit_child(id):
     if image is not None:
         child['image_id'] = image
     child_db.update(child, ChildQuery.id == id)
-    send_event_to_user("user123", Event(EventType.CHILD_UPDATE.value, ChildUpdate(id, "set")))
+    send_event_to_user("user123", Event(EventType.CHILD_MODIFIED.value, ChildModified(id, ChildModified.OPERATION_EDIT)))
     return jsonify({'message': f'Child {id} updated.'}), 200
 
 @child_api.route('/child/list', methods=['GET'])
@@ -81,7 +82,7 @@ def delete_child(id):
     ChildQuery = Query()
     if child_db.remove(ChildQuery.id == id):
         send_event_to_user("user123",
-                           Event(EventType.CHILD_DELETE.value, ChildDelete(id, "deleted")))
+                           Event(EventType.CHILD_MODIFIED.value, ChildModified(id, ChildModified.OPERATION_DELETE)))
         return jsonify({'message': f'Child {id} deleted.'}), 200
     return jsonify({'error': 'Child not found'}), 404
 
@@ -127,7 +128,7 @@ def set_child_tasks(id):
             valid_task_ids.append(tid)
     # Replace tasks with validated IDs
     child_db.update({'tasks': valid_task_ids}, ChildQuery.id == id)
-    send_event_to_user("user123", Event(EventType.TASK_SET.value, TaskSet(id, "set")))
+    send_event_to_user("user123", Event(EventType.CHILD_TASKS_SET.value, ChildTasksSet(id, valid_task_ids)))
     return jsonify({
         'message': f'Tasks set for child {id}.',
         'task_ids': valid_task_ids,
@@ -275,7 +276,7 @@ def trigger_child_task(id):
         child.points = max(child.points, 0)
     # update the child in the database
     child_db.update({'points': child.points}, ChildQuery.id == id)
-    send_event_to_user("user123", Event(EventType.TASK_UPDATE.value, TaskUpdate(task.id, child.id,"complete", child.points)))
+    send_event_to_user("user123", Event(EventType.CHILD_TASK_TRIGGERED.value, ChildTaskTriggered(task.id, child.id,  child.points)))
 
     return jsonify({'message': f'{task.name} points assigned to {child.name}.', 'points': child.points, 'id': child.id}), 200
 
@@ -361,7 +362,7 @@ def set_child_rewards(id):
 
     # Replace rewards with validated IDs
     child_db.update({'rewards': valid_reward_ids}, ChildQuery.id == id)
-    send_event_to_user("user123", Event(EventType.REWARD_SET.value, RewardSet(id, "set")))
+    send_event_to_user("user123", Event(EventType.CHILD_REWARDS_SET.value, ChildRewardsSet(id, valid_reward_ids)))
     return jsonify({
         'message': f'Rewards set for child {id}.',
         'reward_ids': valid_reward_ids,
@@ -454,11 +455,23 @@ def trigger_child_reward(id):
     if not reward_result:
         return jsonify({'error': 'Reward not found in reward database'}), 404
     reward: Reward = Reward.from_dict(reward_result[0])
+
+    # Remove matching pending reward requests for this child and reward
+    PendingQuery = Query()
+    removed = pending_reward_db.remove(
+        (PendingQuery.child_id == child.id) & (PendingQuery.reward_id == reward.id)
+    )
+    if removed:
+        send_event_to_user("user123", Event(EventType.CHILD_REWARD_REQUEST.value, ChildRewardRequest(reward.id, child.id, ChildRewardRequest.REQUEST_GRANTED)))
+
+
     # update the child's points based on reward cost
     child.points -= reward.cost
     # update the child in the database
     child_db.update({'points': child.points}, ChildQuery.id == id)
-    send_event_to_user("user123", Event(EventType.REWARD_UPDATE.value, RewardUpdate(reward.id, child.id, "redeemed", child.points)))
+    send_event_to_user("user123", Event(EventType.CHILD_REWARD_TRIGGERED.value, ChildRewardTriggered(reward.id, child.id, child.points)))
+
+
     return jsonify({'message': f'{reward.name} assigned to {child.name}.', 'points': child.points, 'id': child.id}), 200
 
 @child_api.route('/child/<id>/affordable-rewards', methods=['GET'])
@@ -468,13 +481,13 @@ def list_affordable_rewards(id):
     if not result:
         return jsonify({'error': 'Child not found'}), 404
 
-    child = result[0]
-    points = child.get('points', 0)
-    reward_ids = child.get('rewards', [])
+    child = Child.from_dict(result[0])
+    points = child.points
+    reward_ids = child.rewards
     RewardQuery = Query()
     affordable = [
-        reward for reward_id in reward_ids
-        if (reward := reward_db.get(RewardQuery.id == reward_id)) and points >= reward.get('cost', 0)
+        Reward.from_dict(reward).to_dict() for reward_id in reward_ids
+        if (reward := reward_db.get(RewardQuery.id == reward_id)) and points >= Reward.from_dict(reward).cost
     ]
     return jsonify({'affordable_rewards': affordable}), 200
 
@@ -485,9 +498,9 @@ def reward_status(id):
     if not result:
         return jsonify({'error': 'Child not found'}), 404
 
-    child = result[0]
-    points = child.get('points', 0)
-    reward_ids = child.get('rewards', [])
+    child = Child.from_dict(result[0])
+    points = child.points
+    reward_ids = child.rewards
 
     RewardQuery = Query()
     statuses = []
@@ -496,8 +509,137 @@ def reward_status(id):
         if not reward:
             continue
         points_needed = max(0, reward.cost - points)
-        status = RewardStatus(reward.id, reward.name, points_needed, reward.cost, reward.image_id)
+        #check to see if this reward id and child id is in the pending rewards db if so set its redeeming flag to true
+        pending_query = Query()
+        pending = pending_reward_db.get((pending_query.child_id == child.id) & (pending_query.reward_id == reward.id))
+        status = RewardStatus(reward.id, reward.name, points_needed, reward.cost, pending, reward.image_id)
         statuses.append(status.to_dict())
 
-    statuses.sort(key=lambda s: s['points_needed'])
-    return jsonify({'reward_status': statuses}), 200
+    statuses.sort(key=lambda s: s['cost'])
+    return jsonify({'reward_status': statuses}), 200
+
+
+@child_api.route('/child/<id>/request-reward', methods=['POST'])
+def request_reward(id):
+    data = request.get_json()
+    reward_id = data.get('reward_id')
+    if not reward_id:
+        return jsonify({'error': 'reward_id is required'}), 400
+
+    ChildQuery = Query()
+    result = child_db.search(ChildQuery.id == id)
+    if not result:
+        return jsonify({'error': 'Child not found'}), 404
+
+    child = Child.from_dict(result[0])
+    if reward_id not in child.rewards:
+        return jsonify({'error': f'Reward not assigned to child {child.name}'}), 404
+
+    RewardQuery = Query()
+    reward_result = reward_db.search(RewardQuery.id == reward_id)
+    if not reward_result:
+        return jsonify({'error': 'Reward not found in reward database'}), 404
+
+    reward = Reward.from_dict(reward_result[0])
+
+    # Check if child has enough points
+    if child.points < reward.cost:
+        points_needed = reward.cost - child.points
+        return jsonify({
+            'error': 'Insufficient points',
+            'points_needed': points_needed,
+            'current_points': child.points,
+            'reward_cost': reward.cost
+        }), 400
+
+    pending = PendingReward(child_id=child.id, reward_id=reward.id)
+    pending_reward_db.insert(pending.to_dict())
+    send_event_to_user("user123", Event(EventType.CHILD_REWARD_REQUEST.value, ChildRewardRequest(child.id, reward.id, ChildRewardRequest.REQUEST_CREATED)))
+
+    return jsonify({
+        'message': f'Reward request for {reward.name} submitted for {child.name}.',
+        'reward_id': reward.id,
+        'reward_name': reward.name,
+        'child_id': child.id,
+        'child_name': child.name,
+        'cost': reward.cost
+    }), 200
+
+@child_api.route('/child/<id>/cancel-request-reward', methods=['POST'])
+def cancel_request_reward(id):
+    data = request.get_json()
+    reward_id = data.get('reward_id')
+    if not reward_id:
+        return jsonify({'error': 'reward_id is required'}), 400
+
+    ChildQuery = Query()
+    result = child_db.search(ChildQuery.id == id)
+    if not result:
+        return jsonify({'error': 'Child not found'}), 404
+
+    child = Child.from_dict(result[0])
+
+    # Remove matching pending reward request
+    PendingQuery = Query()
+    removed = pending_reward_db.remove(
+        (PendingQuery.child_id == child.id) & (PendingQuery.reward_id == reward_id)
+    )
+
+    if not removed:
+        return jsonify({'error': 'No pending request found for this reward'}), 404
+
+    # Notify user that the request was cancelled
+    send_event_to_user(
+        "user123",
+        Event(
+            EventType.CHILD_REWARD_REQUEST.value,
+            ChildRewardRequest(child.id, reward_id, ChildRewardRequest.REQUEST_CANCELLED)
+        )
+    )
+
+    return jsonify({
+        'message': f'Reward request cancelled for {child.name}.',
+        'child_id': child.id,
+        'reward_id': reward_id,
+        'removed_count': len(removed)
+    }), 200
+
+
+
+@child_api.route('/pending-rewards', methods=['GET'])
+def list_pending_rewards():
+    pending_rewards = pending_reward_db.all()
+    reward_responses = []
+
+    RewardQuery = Query()
+    ChildQuery = Query()
+
+    for pr in pending_rewards:
+        pending = PendingReward.from_dict(pr)
+
+        # Look up reward details
+        reward_result = reward_db.get(RewardQuery.id == pending.reward_id)
+        if not reward_result:
+            continue
+        reward = Reward.from_dict(reward_result)
+
+        # Look up child details
+        child_result = child_db.get(ChildQuery.id == pending.child_id)
+        if not child_result:
+            continue
+        child = Child.from_dict(child_result)
+
+        # Create response object
+        response = PendingRewardResponse(
+            _id=pending.id,
+            child_id=child.id,
+            child_name=child.name,
+            child_image_id=child.image_id,
+            reward_id=reward.id,
+            reward_name=reward.name,
+            reward_image_id=reward.image_id
+        )
+        reward_responses.append(response.to_dict())
+
+    return jsonify({'rewards': reward_responses}), 200
+

api/pending_reward.py

@@ -0,0 +1,20 @@
+class PendingReward:
+    def __init__(self, _id, child_id, child_name, child_image_id, reward_id, reward_name, reward_image_id):
+        self.id = _id
+        self.child_id = child_id
+        self.child_name = child_name
+        self.child_image_id = child_image_id
+        self.reward_id = reward_id
+        self.reward_name = reward_name
+        self.reward_image_id = reward_image_id
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'child_id': self.child_id,
+            'child_name': self.child_name,
+            'child_image_id': self.child_image_id,
+            'reward_id': self.reward_id,
+            'reward_name': self.reward_name,
+            'reward_image_id': self.reward_image_id
+        }

api/reward_api.py

@@ -4,9 +4,7 @@ from tinydb import Query
 from events.sse import send_event_to_user
 from events.types.event import Event
 from events.types.event_types import EventType
-from events.types.reward_created import RewardCreated
-from events.types.reward_deleted import RewardDeleted
-from events.types.reward_edited import RewardEdited
+from events.types.reward_modified import RewardModified
 from models.reward import Reward
 from db.db import reward_db, child_db
 
@@ -24,8 +22,8 @@ def add_reward():
         return jsonify({'error': 'Name, description, and cost are required'}), 400
     reward = Reward(name=name, description=description, cost=cost, image_id=image)
     reward_db.insert(reward.to_dict())
-    send_event_to_user("user123", Event(EventType.REWARD_CREATED.value,
-                                        RewardCreated(reward.id, "created")))
+    send_event_to_user("user123", Event(EventType.REWARD_MODIFIED.value,
+                                        RewardModified(reward.id, RewardModified.OPERATION_ADD)))
 
     return jsonify({'message': f'Reward {name} added.'}), 201
 
@@ -56,8 +54,8 @@ def delete_reward(id):
             if id in rewards:
                 rewards.remove(id)
                 child_db.update({'rewards': rewards}, ChildQuery.id == child.get('id'))
-                send_event_to_user("user123", Event(EventType.REWARD_DELETED.value,
-                                                    RewardDeleted(id, "created")))
+                send_event_to_user("user123", Event(EventType.REWARD_MODIFIED.value,
+                                                    RewardModified(id, RewardModified.OPERATION_DELETE)))
 
         return jsonify({'message': f'Reward {id} deleted.'}), 200
     return jsonify({'error': 'Reward not found'}), 404
@@ -100,7 +98,7 @@ def edit_reward(id):
 
     reward_db.update(updates, RewardQuery.id == id)
     updated = reward_db.get(RewardQuery.id == id)
-    send_event_to_user("user123", Event(EventType.REWARD_EDITED.value,
-                                        RewardEdited(id, "created")))
+    send_event_to_user("user123", Event(EventType.REWARD_MODIFIED.value,
+                                        RewardModified(id, RewardModified.OPERATION_EDIT)))
 
     return jsonify(updated), 200

api/reward_status.py

@@ -1,9 +1,10 @@
 class RewardStatus:
-    def __init__(self, id, name, points_needed, cost, image_id):
+    def __init__(self, id, name, points_needed, cost, redeeming, image_id):
         self.id = id
         self.name = name
         self.points_needed = points_needed
         self.cost = cost
+        self.redeeming = redeeming
         self.image_id = image_id
 
     def to_dict(self):
@@ -12,5 +13,6 @@ class RewardStatus:
             'name': self.name,
             'points_needed': self.points_needed,
             'cost': self.cost,
+            'redeeming': self.redeeming,
             'image_id': self.image_id
         }

api/task_api.py

@@ -4,9 +4,7 @@ from tinydb import Query
 from events.sse import send_event_to_user
 from events.types.event import Event
 from events.types.event_types import EventType
-from events.types.task_created import TaskCreated
-from events.types.task_deleted import TaskDeleted
-from events.types.task_edited import TaskEdited
+from events.types.task_modified import TaskModified
 from models.task import Task
 from db.db import task_db, child_db
 
@@ -24,8 +22,8 @@ def add_task():
         return jsonify({'error': 'Name, points, and is_good are required'}), 400
     task = Task(name=name, points=points, is_good=is_good, image_id=image)
     task_db.insert(task.to_dict())
-    send_event_to_user("user123", Event(EventType.TASK_CREATED.value,
-                                        TaskCreated(task.id, "created")))
+    send_event_to_user("user123", Event(EventType.TASK_MODIFIED.value,
+                                        TaskModified(task.id, TaskModified.OPERATION_ADD)))
     return jsonify({'message': f'Task {name} added.'}), 201
 
 @task_api.route('/task/<id>', methods=['GET'])
@@ -53,8 +51,8 @@ def delete_task(id):
             if id in tasks:
                 tasks.remove(id)
                 child_db.update({'tasks': tasks}, ChildQuery.id == child.get('id'))
-                send_event_to_user("user123", Event(EventType.TASK_DELETED.value,
-                                                    TaskDeleted(id, "deleted")))
+                send_event_to_user("user123", Event(EventType.TASK_MODIFIED.value,
+                                                    TaskModified(id, TaskModified.OPERATION_DELETE)))
 
         return jsonify({'message': f'Task {id} deleted.'}), 200
     return jsonify({'error': 'Task not found'}), 404
@@ -97,6 +95,6 @@ def edit_task(id):
 
     task_db.update(updates, TaskQuery.id == id)
     updated = task_db.get(TaskQuery.id == id)
-    send_event_to_user("user123", Event(EventType.TASK_EDITED.value,
-                                        TaskEdited(id, "edited")))
+    send_event_to_user("user123", Event(EventType.TASK_MODIFIED.value,
+                                        TaskModified(id, TaskModified.OPERATION_EDIT)))
     return jsonify(updated), 200