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
+