Update main.py

main.py

@@ -540,7 +540,7 @@ def user_manage_listing(listing_id):
                 if field in data and data[field] != listing_data.get(field):
                     update_payload[field] = data[field]
                     requires_reapproval = True
-            
+
             # Allow user to change status to inactive/closed without re-approval
             if 'status' in data and data['status'] in ['inactive', 'closed']:
                 update_payload['status'] = data['status']
@@ -550,7 +550,7 @@ def user_manage_listing(listing_id):
                     update_payload['status'] = 'pending_approval'
                 else: # If no critical fields changed, allow status update if valid
                     update_payload['status'] = data['status'] # e.g., from inactive back to active if no critical changes
-            
+
             if requires_reapproval and update_payload.get('status') != 'pending_approval':
                 update_payload['status'] = 'pending_approval' # Ensure pending approval if critical fields changed
 
@@ -559,7 +559,7 @@ def user_manage_listing(listing_id):
 
             update_payload['last_updated_at'] = datetime.now(timezone.utc).isoformat()
             listing_ref.update(update_payload)
-            
+
             message = 'Listing updated successfully.'
             if requires_reapproval:
                 message += ' Listing status set to pending_approval due to significant changes.'
@@ -640,13 +640,13 @@ def admin_remove_listing(listing_id):
 
         if not listing_data or not isinstance(listing_data, dict):
             return jsonify({'error': 'Listing not found.'}), 404
-        
+
         lister_id = listing_data.get('lister_id')
         listing_type = listing_data.get('listing_type', 'item')
         crop_type = listing_data.get('crop_type', 'N/A')
 
         listing_ref.delete()
-        
+
         if lister_id:
             _send_system_notification(lister_id, f"Your {listing_type} listing for '{crop_type}' (ID: {listing_id}) has been removed by an administrator.", "listing_removed_by_admin", f"/my-listings")
 
@@ -660,12 +660,14 @@ def admin_remove_listing(listing_id):
 @app.route('/api/deals/propose', methods=['POST'])
 def propose_deal():
     auth_header = request.headers.get('Authorization')
-    uid = None # UID of the user making the proposal/offer
+    requester_uid = None # UID of the user making the API call (admin/user)
+    acting_uid = None # UID of the user on whose behalf the action is taken
+
     try:
         logger.info(f"Backend /api/deals/propose received headers: {request.headers}")
         logger.info(f"Backend /api/deals/propose received raw data: {request.get_data(as_text=True)}")
 
-        uid = verify_token(auth_header) # Can raise exceptions
+        requester_uid = verify_token(auth_header) # Can raise exceptions
         if not FIREBASE_INITIALIZED:
             return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 503
 
@@ -674,10 +676,29 @@ def propose_deal():
             logger.error("Backend /api/deals/propose: No JSON data received or failed to parse.")
             return jsonify({'error': 'Invalid JSON data received.'}), 400
 
+        on_behalf_of_uid = data.get('on_behalf_of_uid')
+
+        if on_behalf_of_uid:
+            # If acting on behalf of someone, verify the requester is an admin/facilitator
+            admin_or_facilitator_uid, _, _ = verify_admin_or_facilitator(auth_header) # This will raise if not admin/facilitator
+            acting_uid = on_behalf_of_uid
+            
+            # Verify the user on whose behalf we are acting exists and is a farmer (for WhatsApp farmers)
+            acting_user_profile = db.reference(f'users/{acting_uid}', app=db_app).get()
+            if not acting_user_profile:
+                return jsonify({'error': f'User {acting_uid} (on_behalf_of) not found.'}), 404
+            
+            # Constraint: WhatsApp farmers can only list produce, so they can only *propose* against demand listings.
+            # This means the acting_uid must be a farmer.
+            if not acting_user_profile.get('roles', {}).get('farmer') and acting_user_profile.get('account_type') != 'whatsapp_managed':
+                return jsonify({'error': f'User {acting_uid} is not a farmer or WhatsApp-managed farmer, cannot propose on their behalf.'}), 403
+            
+            logger.info(f"Admin/Facilitator {admin_or_facilitator_uid} proposing deal on behalf of {acting_uid}.")
+        else:
+            acting_uid = requester_uid # Regular user proposing
+
         listing_id = data.get('listing_id')
-        # 'quantity' from frontend is the quantity the proposer wants to transact
         proposed_quantity_by_user = data.get('quantity')
-        # 'price' from frontend is the price PER UNIT the proposer is offering/asking
         proposed_price_per_unit_by_user = data.get('price')
         notes = data.get('notes', "")
 
@@ -706,8 +727,8 @@ def propose_deal():
         original_lister_id = listing_data.get('lister_id')
         listing_type = listing_data.get('listing_type') # 'produce' or 'demand'
 
-        if original_lister_id == uid:
-            logger.error(f"Backend /api/deals/propose: User {uid} attempting to deal with own listing {listing_id}.")
+        if original_lister_id == acting_uid:
+            logger.error(f"Backend /api/deals/propose: User {acting_uid} attempting to deal with own listing {listing_id}.")
             return jsonify({'error': 'Cannot propose a deal to your own listing/demand.'}), 400
 
         deal_farmer_id = None
@@ -716,9 +737,13 @@ def propose_deal():
         notification_recipient_id = original_lister_id # The other party
 
         if listing_type == 'produce':
-            # Current user (proposer uid) is a BUYER, proposing to a FARMER's produce listing.
+            # Current user (proposer acting_uid) is a BUYER, proposing to a FARMER's produce listing.
+            # If acting on behalf of a WhatsApp farmer, they cannot be the buyer here.
+            if on_behalf_of_uid and acting_user_profile.get('account_type') == 'whatsapp_managed':
+                return jsonify({'error': 'WhatsApp farmers can only propose deals as a farmer (against demand listings).'}), 403
+
             deal_farmer_id = original_lister_id
-            deal_buyer_id = uid
+            deal_buyer_id = acting_uid
             deal_notes_prefix = "Buyer's proposal: "
 
             available_quantity = listing_data.get('quantity', 0)
@@ -727,8 +752,8 @@ def propose_deal():
                 return jsonify({'error': f'Proposed quantity ({proposed_quantity_by_user}) exceeds available quantity ({available_quantity}) for the listing.'}), 400
 
         elif listing_type == 'demand':
-            # Current user (proposer uid) is a FARMER, making an offer against a BUYER's demand listing.
-            deal_farmer_id = uid
+            # Current user (proposer acting_uid) is a FARMER, making an offer against a BUYER's demand listing.
+            deal_farmer_id = acting_uid
             deal_buyer_id = original_lister_id
             deal_notes_prefix = "Farmer's offer against demand: "
 
@@ -744,7 +769,7 @@ def propose_deal():
         deal_id = str(uuid.uuid4())
         deal_data_to_set = {
             'deal_id': deal_id,
-            'proposer_id': uid,
+            'proposer_id': acting_uid, # Use acting_uid here
             'listing_id': listing_id,
             'farmer_id': deal_farmer_id,
             'buyer_id': deal_buyer_id,
@@ -755,32 +780,57 @@ def propose_deal():
             'created_at': datetime.now(timezone.utc).isoformat(),
             'chat_room_id': f"deal_{deal_id}"
         }
+        # If an admin acted on behalf, record that
+        if on_behalf_of_uid:
+            deal_data_to_set['proxied_by_admin_uid'] = requester_uid
+
         db.reference(f'deals/{deal_id}', app=db_app).set(deal_data_to_set)
 
         _send_system_notification(
             notification_recipient_id,
-            f"You have a new proposal/offer from {uid[:6]}... regarding your {listing_type} for '{listing_data.get('crop_type')}'. Qty: {proposed_quantity_by_user}, Price/Unit: {proposed_price_per_unit_by_user}",
+            f"You have a new proposal/offer from {acting_uid[:6]}... regarding your {listing_type} for '{listing_data.get('crop_type')}'. Qty: {proposed_quantity_by_user}, Price/Unit: {proposed_price_per_unit_by_user}",
             "new_deal_proposal",
             f"/deals/{deal_id}"
         )
-        logger.info(f"Backend /api/deals/propose: Deal {deal_id} created successfully by UID {uid} for listing {listing_id}.")
+        logger.info(f"Backend /api/deals/propose: Deal {deal_id} created successfully by UID {acting_uid} for listing {listing_id}.")
         return jsonify({'success': True, 'message': 'Proposal/Offer submitted successfully.', 'deal': deal_data_to_set}), 201
 
     except Exception as e:
         # Log the original error before passing to generic handler
-        logger.error(f"Backend /api/deals/propose: Unhandled exception for UID {uid or 'unknown'}. Error: {str(e)}\n{traceback.format_exc()}")
-        return handle_route_errors(e, uid_context=uid or "propose_deal_unknown_user")
+        logger.error(f"Backend /api/deals/propose: Unhandled exception for UID {acting_uid or requester_uid or 'unknown'}. Error: {str(e)}\n{traceback.format_exc()}")
+        return handle_route_errors(e, uid_context=acting_uid or requester_uid or "propose_deal_unknown_user")
 
 @app.route('/api/deals/<deal_id>/respond', methods=['POST'])
 def respond_to_deal(deal_id):
     auth_header = request.headers.get('Authorization')
-    uid = None  # UID of the currently logged-in user responding
+    requester_uid = None # UID of the user making the API call (admin/user)
+    acting_uid = None  # UID of the user on whose behalf the action is taken
+
     try:
-        uid = verify_token(auth_header)
+        requester_uid = verify_token(auth_header)
         if not FIREBASE_INITIALIZED: return jsonify({'error': 'Server configuration error'}), 503
 
         data = request.get_json()
         response_action = data.get('action')  # 'accept' or 'reject'
+        on_behalf_of_uid = data.get('on_behalf_of_uid')
+
+        if on_behalf_of_uid:
+            # If acting on behalf of someone, verify the requester is an admin/facilitator
+            admin_or_facilitator_uid, _, _ = verify_admin_or_facilitator(auth_header) # This will raise if not admin/facilitator
+            acting_uid = on_behalf_of_uid
+
+            # Verify the user on whose behalf we are acting exists and is a farmer (for WhatsApp farmers)
+            acting_user_profile = db.reference(f'users/{acting_uid}', app=db_app).get()
+            if not acting_user_profile:
+                return jsonify({'error': f'User {acting_uid} (on_behalf_of) not found.'}), 404
+
+            # Constraint: WhatsApp farmers can only list produce, so they would only *respond* as a farmer.
+            if not acting_user_profile.get('roles', {}).get('farmer') and acting_user_profile.get('account_type') != 'whatsapp_managed':
+                return jsonify({'error': f'User {acting_uid} is not a farmer or WhatsApp-managed farmer, cannot respond on their behalf.'}), 403
+
+            logger.info(f"Admin/Facilitator {admin_or_facilitator_uid} responding to deal {deal_id} on behalf of {acting_uid}.")
+        else:
+            acting_uid = requester_uid # Regular user responding
 
         if response_action not in ['accept', 'reject']:
             return jsonify({'error': 'Invalid action. Must be "accept" or "reject".'}), 400
@@ -799,23 +849,23 @@ def respond_to_deal(deal_id):
         # Authorization Check: Who is allowed to respond?
         can_respond = False
         if current_deal_status == 'proposed':
-            if proposer_id == buyer_id_in_deal and uid == farmer_id_in_deal: # Buyer proposed, Farmer responds
+            if proposer_id == buyer_id_in_deal and acting_uid == farmer_id_in_deal: # Buyer proposed, Farmer responds
                 can_respond = True
-            elif proposer_id == farmer_id_in_deal and uid == buyer_id_in_deal: # Farmer proposed/countered, Buyer responds
+            elif proposer_id == farmer_id_in_deal and acting_uid == buyer_id_in_deal: # Farmer proposed/countered, Buyer responds
                 can_respond = True
         # Add other statuses if a different party needs to respond (e.g., after admin action)
 
         if not can_respond:
-            logger.warning(f"UID {uid} unauthorized to respond to deal {deal_id}. Deal status: {current_deal_status}, Proposer: {proposer_id}, Farmer: {farmer_id_in_deal}, Buyer: {buyer_id_in_deal}")
+            logger.warning(f"UID {acting_uid} unauthorized to respond to deal {deal_id}. Deal status: {current_deal_status}, Proposer: {proposer_id}, Farmer: {farmer_id_in_deal}, Buyer: {buyer_id_in_deal}")
             return jsonify({'error': 'Not authorized to respond to this deal at its current state.'}), 403
 
         update_time = datetime.now(timezone.utc).isoformat()
 
         # Determine the other party for notification
         other_party_id = None
-        if uid == farmer_id_in_deal:
+        if acting_uid == farmer_id_in_deal:
             other_party_id = buyer_id_in_deal
-        elif uid == buyer_id_in_deal:
+        elif acting_uid == buyer_id_in_deal:
             other_party_id = farmer_id_in_deal
 
         listing_id = deal_data.get('listing_id')
@@ -824,9 +874,13 @@ def respond_to_deal(deal_id):
             listing_data_for_notif = db.reference(f'listings/{listing_id}', app=db_app).get() or {}
         crop_type_for_notif = listing_data_for_notif.get('crop_type', 'your listing/demand')
 
+        update_payload = {}
+        if on_behalf_of_uid:
+            update_payload['proxied_by_admin_uid'] = requester_uid # Record who proxied the action
+
         if response_action == 'accept':
             # Quantity check (if applicable, e.g., if responding to a proposal against a produce listing)
-            if proposer_id == buyer_id_in_deal and uid == farmer_id_in_deal: # Farmer accepting buyer's proposal
+            if proposer_id == buyer_id_in_deal and acting_uid == farmer_id_in_deal: # Farmer accepting buyer's proposal
                 if listing_id and isinstance(listing_data_for_notif, dict):
                     available_quantity = listing_data_for_notif.get('quantity', 0)
                     proposed_quantity = deal_data.get('proposed_quantity', 0)
@@ -840,25 +894,21 @@ def respond_to_deal(deal_id):
                             _send_system_notification(other_party_id, f"Your deal proposal for '{crop_type_for_notif}' could not be accepted due to insufficient stock.", "deal_status_update", f"/deals/{deal_id}")
                         return jsonify({'success': False, 'error': 'Deal could not be accepted. Listing quantity is no longer sufficient.'}), 409
 
-            # If a buyer accepts a farmer's counter-offer, or farmer accepts buyer's initial proposal
-            # The deal moves to 'accepted_by_farmer' or 'accepted_by_buyer' then to admin.
-            # For simplicity, let's assume both lead to a state needing admin approval.
-            # We need a clear "who accepted" field.
-
             accepted_by_field = ""
             new_status = ""
-            if uid == farmer_id_in_deal:
+            if acting_uid == farmer_id_in_deal:
                 accepted_by_field = "farmer_accepted_at"
                 new_status = "accepted_by_farmer" # Farmer accepts buyer's proposal
                 notification_message_to_other_party = f"Your deal proposal for '{crop_type_for_notif}' has been ACCEPTED by the farmer. It is now pending admin approval."
-            elif uid == buyer_id_in_deal:
+            elif acting_uid == buyer_id_in_deal:
                 accepted_by_field = "buyer_accepted_at"
                 new_status = "accepted_by_buyer" # Buyer accepts farmer's offer/counter
                 notification_message_to_other_party = f"Your offer/counter-offer for '{crop_type_for_notif}' has been ACCEPTED by the buyer. It is now pending admin approval."
             else: # Should not happen due to auth check
                 return jsonify({'error': 'Internal error determining accepter role.'}), 500
 
-            deal_ref.update({'status': new_status, accepted_by_field: update_time, 'last_responder_id': uid})
+            update_payload.update({'status': new_status, accepted_by_field: update_time, 'last_responder_id': acting_uid})
+            deal_ref.update(update_payload)
 
             if other_party_id:
                 _send_system_notification(other_party_id, notification_message_to_other_party, "deal_status_update", f"/deals/{deal_id}")
@@ -867,31 +917,32 @@ def respond_to_deal(deal_id):
             admins_ref = db.reference('users', app=db_app).order_by_child('is_admin').equal_to(True).get()
             if admins_ref:
                 for admin_id_loop, _ in admins_ref.items():
-                     _send_system_notification(admin_id_loop, f"Deal ID {deal_id} for '{crop_type_for_notif}' has been accepted by {uid[:6]}... and needs your approval.", "admin_deal_approval_needed", f"/admin/deals/pending") # Path for admin to see pending deals
+                     _send_system_notification(admin_id_loop, f"Deal ID {deal_id} for '{crop_type_for_notif}' has been accepted by {acting_uid[:6]}... and needs your approval.", "admin_deal_approval_needed", f"/admin/deals/pending") # Path for admin to see pending deals
 
-            return jsonify({'success': True, 'message': f'Deal accepted by {("farmer" if uid == farmer_id_in_deal else "buyer")}, pending admin approval.'}), 200
+            return jsonify({'success': True, 'message': f'Deal accepted by {("farmer" if acting_uid == farmer_id_in_deal else "buyer")}, pending admin approval.'}), 200
 
         elif response_action == 'reject':
             rejected_by_field = ""
             new_status = ""
-            if uid == farmer_id_in_deal:
+            if acting_uid == farmer_id_in_deal:
                 rejected_by_field = "farmer_rejected_at" # Or just 'responded_at'
                 new_status = "rejected_by_farmer"
                 notification_message_to_other_party = f"Your deal proposal for '{crop_type_for_notif}' has been REJECTED by the farmer."
-            elif uid == buyer_id_in_deal:
+            elif acting_uid == buyer_id_in_deal:
                 rejected_by_field = "buyer_rejected_at"
                 new_status = "rejected_by_buyer"
                 notification_message_to_other_party = f"Your offer/counter-offer for '{crop_type_for_notif}' has been REJECTED by the buyer."
             else: # Should not happen
                 return jsonify({'error': 'Internal error determining rejector role.'}), 500
 
-            deal_ref.update({'status': new_status, rejected_by_field: update_time, 'last_responder_id': uid})
+            update_payload.update({'status': new_status, rejected_by_field: update_time, 'last_responder_id': acting_uid})
+            deal_ref.update(update_payload)
             if other_party_id:
                 _send_system_notification(other_party_id, notification_message_to_other_party, "deal_status_update", f"/deals/{deal_id}")
-            return jsonify({'success': True, 'message': f'Deal rejected by {("farmer" if uid == farmer_id_in_deal else "buyer")}.'}), 200
+            return jsonify({'success': True, 'message': f'Deal rejected by {("farmer" if acting_uid == farmer_id_in_deal else "buyer")}.'}), 200
 
     except Exception as e:
-        return handle_route_errors(e, uid_context=uid)
+        return handle_route_errors(e, uid_context=acting_uid or requester_uid)
 
 @app.route('/api/deals/<deal_id>/complete', methods=['POST'])
 def complete_deal_by_admin(deal_id):
@@ -1020,12 +1071,12 @@ def admin_remove_deal(deal_id):
 
         if not deal_data or not isinstance(deal_data, dict):
             return jsonify({'error': 'Deal not found.'}), 404
-        
+
         farmer_id = deal_data.get('farmer_id')
         buyer_id = deal_data.get('buyer_id')
         transporter_id = deal_data.get('assigned_transporter_id')
         listing_id = deal_data.get('listing_id')
-        
+
         crop_type = "N/A"
         if listing_id:
             listing_details = db.reference(f'listings/{listing_id}', app=db_app).get()
@@ -1033,7 +1084,7 @@ def admin_remove_deal(deal_id):
                 crop_type = listing_details.get('crop_type', 'N/A')
 
         deal_ref.delete()
-        
+
         message_to_parties = f"Deal ID {deal_id} for '{crop_type}' has been removed by an administrator."
         if farmer_id:
             _send_system_notification(farmer_id, message_to_parties, "deal_removed_by_admin", f"/my-deals")
@@ -1047,114 +1098,7 @@ def admin_remove_deal(deal_id):
     except Exception as e:
         return handle_route_errors(e, uid_context=admin_uid)
 
-# NEW: Admin Create Manual Deal (for WhatsApp farmers or any users)
-@app.route('/api/admin/deals/create-manual', methods=['POST'])
-def admin_create_manual_deal():
-    auth_header = request.headers.get('Authorization')
-    admin_uid = None
-    try:
-        admin_uid, _, _ = verify_admin_or_facilitator(auth_header)
-        if not FIREBASE_INITIALIZED: return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 503
-
-        data = request.get_json()
-        farmer_id = data.get('farmer_id')
-        buyer_id = data.get('buyer_id')
-        listing_id = data.get('listing_id')
-        quantity = data.get('quantity')
-        price_per_unit = data.get('price_per_unit')
-        notes = data.get('notes', "Admin-created deal.")
-
-        if not all([farmer_id, buyer_id, listing_id, quantity is not None, price_per_unit is not None]):
-            return jsonify({'error': 'farmer_id, buyer_id, listing_id, quantity, and price_per_unit are required.'}), 400
-
-        try:
-            quantity = int(quantity)
-            price_per_unit = float(price_per_unit)
-            if quantity <= 0 or price_per_unit <= 0:
-                raise ValueError("Quantity and price must be positive numbers.")
-        except ValueError as ve:
-            return jsonify({'error': f'Invalid quantity or price: {str(ve)}'}), 400
-
-        # Verify farmer and buyer exist and have correct roles or are whatsapp_managed
-        farmer_profile = db.reference(f'users/{farmer_id}', app=db_app).get()
-        buyer_profile = db.reference(f'users/{buyer_id}', app=db_app).get()
-
-        if not farmer_profile or (not farmer_profile.get('roles', {}).get('farmer') and farmer_profile.get('account_type') != 'whatsapp_managed'):
-            return jsonify({'error': 'Farmer ID invalid or user is not a farmer/WhatsApp farmer.'}), 400
-        if not buyer_profile or (not buyer_profile.get('roles', {}).get('buyer') and farmer_profile.get('account_type') != 'whatsapp_managed'):
-            return jsonify({'error': 'Buyer ID invalid or user is not a buyer/WhatsApp buyer.'}), 400
-        
-        # Verify listing
-        listing_ref = db.reference(f'listings/{listing_id}', app=db_app)
-        listing_data = listing_ref.get()
-
-        if not listing_data or listing_data.get('status') != 'active':
-            return jsonify({'error': 'Target listing not found or not active.'}), 404
-        
-        # Ensure the listing's lister matches the farmer/buyer in the deal
-        if listing_data.get('listing_type') == 'produce' and listing_data.get('lister_id') != farmer_id:
-            return jsonify({'error': 'Produce listing lister_id does not match provided farmer_id.'}), 400
-        if listing_data.get('listing_type') == 'demand' and listing_data.get('lister_id') != buyer_id:
-            return jsonify({'error': 'Demand listing lister_id does not match provided buyer_id.'}), 400
-
-        # Quantity check for produce listings
-        if listing_data.get('listing_type') == 'produce':
-            available_quantity = listing_data.get('quantity', 0)
-            if quantity > available_quantity:
-                return jsonify({'error': f'Proposed quantity ({quantity}) exceeds available quantity ({available_quantity}) for the listing.'}), 400
-
-        deal_id = str(uuid.uuid4())
-        deal_data_to_set = {
-            'deal_id': deal_id,
-            'proposer_id': admin_uid, # Admin is the proposer in this context
-            'listing_id': listing_id,
-            'farmer_id': farmer_id,
-            'buyer_id': buyer_id,
-            'proposed_quantity': quantity,
-            'proposed_price': price_per_unit,
-            'deal_notes': notes,
-            'status': 'active', # Admin-created deals are active immediately
-            'created_at': datetime.now(timezone.utc).isoformat(),
-            'admin_created_by': admin_uid,
-            'chat_room_id': f"deal_{deal_id}"
-        }
-        db.reference(f'deals/{deal_id}', app=db_app).set(deal_data_to_set)
-
-        # Update listing quantity if it's a produce listing
-        if listing_data.get('listing_type') == 'produce':
-            def update_listing_quantity_transaction(current_listing_data_tx):
-                if not current_listing_data_tx or not isinstance(current_listing_data_tx, dict):
-                    logger.error(f"AdminCreateManualDeal: Listing {listing_id} not found or malformed during transaction for deal {deal_id}.")
-                    return current_listing_data_tx
-                current_listing_quantity = current_listing_data_tx.get('quantity', 0)
-                new_listing_quantity = current_listing_quantity - quantity
-                updates = {}
-                if new_listing_quantity <= 0:
-                    updates['quantity'] = 0
-                    updates['status'] = 'closed'
-                else:
-                    updates['quantity'] = new_listing_quantity
-                current_listing_data_tx.update(updates)
-                return current_listing_data_tx
-            
-            transaction_result = listing_ref.transaction(update_listing_quantity_transaction)
-            if transaction_result is None and listing_ref.get() is not None:
-                logger.warning(f"AdminCreateManualDeal: Transaction to update listing {listing_id} for deal {deal_id} was aborted or listing became null. Deal created, but listing quantity may not be updated.")
-            elif listing_ref.get() is None:
-                logger.warning(f"AdminCreateManualDeal: Listing {listing_id} not found for deal {deal_id}. Deal created, but listing quantity not updated.")
-            else:
-                logger.info(f"AdminCreateManualDeal: Listing {listing_id} quantity updated via transaction for deal {deal_id}.")
-
-
-        # Notify farmer and buyer
-        crop_type_for_notif = listing_data.get('crop_type', 'item')
-        _send_system_notification(farmer_id, f"An administrator has created a deal for you regarding '{crop_type_for_notif}' (Deal ID: {deal_id}). Quantity: {quantity}, Price/Unit: {price_per_unit}.", "admin_created_deal", f"/deals/{deal_id}")
-        _send_system_notification(buyer_id, f"An administrator has created a deal for you regarding '{crop_type_for_notif}' (Deal ID: {deal_id}). Quantity: {quantity}, Price/Unit: {price_per_unit}.", "admin_created_deal", f"/deals/{deal_id}")
-
-        return jsonify({'success': True, 'message': 'Deal created manually by admin.', 'deal': deal_data_to_set}), 201
-
-    except Exception as e:
-        return handle_route_errors(e, uid_context=admin_uid)
+# Removed the admin_create_manual_deal endpoint as its functionality is now integrated into propose_deal and respond_to_deal.
 
 
 #--- END OF MODIFIED DEAL MANAGEMENT SECTION ---
@@ -1808,30 +1752,30 @@ def mark_notification_read(notification_id):
 # Helper for AI chat to fetch platform data
 def _fetch_platform_data_for_chat(query):
     if not FIREBASE_INITIALIZED: return "Firebase not ready.", False
-    
+
     listings_ref = db.reference('listings', app=db_app).order_by_child('status').equal_to('active')
     all_active_listings = listings_ref.get() or {}
-    
+
     relevant_listings = []
     query_lower = query.lower()
-    
+
     for lid, ldata in all_active_listings.items():
         if not ldata: continue
         crop_type = ldata.get('crop_type', '').lower()
         location = ldata.get('location', '').lower()
         listing_type = ldata.get('listing_type', '')
-        
+
         # Simple keyword matching for demonstration
         if any(keyword in query_lower for keyword in [crop_type, location, listing_type, 'maize', 'beans', 'harare', 'bulawayo']):
             relevant_listings.append(ldata)
-            
+
     if not relevant_listings:
         return "No active listings found matching your query.", False
-        
+
     summary = "Active Listings:\n"
     for l in relevant_listings[:5]: # Limit to top 5 for brevity
         summary += f"- {l.get('crop_type')} ({l.get('listing_type')}) in {l.get('location')}, Qty: {l.get('quantity')}, Price: {l.get('asking_price') or l.get('price_range')}\n"
-    
+
     return summary, True
 
 # Helper for AI chat to fetch price trends
@@ -1855,7 +1799,7 @@ def _get_price_trend_analysis_for_chat(crop_type=None, location=None):
                 'date': deal.get('admin_approved_at') or deal.get('created_at'),
                 'crop': deal_crop_type, 'location': deal_location
             })
-    
+
     if not price_data_points:
         return "Not enough historical data to generate price trends for the specified criteria.", False
 
@@ -1885,12 +1829,12 @@ def get_price_trends():
         if not gemini_client: return jsonify({'error': 'AI service not available.'}), 503
         if not FIREBASE_INITIALIZED: return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 503
         crop_type, location = request.args.get('crop_type'), request.args.get('location')
-        
+
         trend_analysis, success = _get_price_trend_analysis_for_chat(crop_type, location)
-        
+
         if not success:
             return jsonify({'message': trend_analysis}), 200 # trend_analysis contains the error message
-            
+
         return jsonify({'crop_type': crop_type, 'location': location, 'trend_analysis': trend_analysis}), 200
     except AttributeError as ae:
         logger.error(f"Gemini Response Attribute Error in get_price_trends: {ae}. Response object: {response_obj}")
@@ -2025,4 +1969,4 @@ def get_ai_chat_history():
 
 if __name__ == '__main__':
     app.run(debug=True, host="0.0.0.0", port=int(os.getenv("PORT", 7860)))
-
+`