Upload folder using huggingface_hub

app/api.py

@@ -43,25 +43,48 @@ def get_product_image(product_id):
 
 @api_bp.route('/products', methods=['GET'])
 def get_products():
-    # --- MODIFIED: Construct the correct image_url pointing to our new endpoint ---
-    products_cursor = mongo.db.products.find()
+    # --- OPTIMIZATION: Use projection to exclude large binary image data ---
+    # We only need to know if 'image_data' exists, not its content. This dramatically
+    # reduces the data transferred from MongoDB to the Flask app, speeding up the response.
+    products_cursor = mongo.db.products.find({}, {'image_data': 0})
+    products_list = []
+    
+    # Re-fetch the documents that have image_data to check for existence
+    # This is a bit of a workaround because we can't check for existence with projection easily
+    # A better long-term solution would be a boolean field like `has_binary_image`.
+    # For now, we'll check based on the projected data. If a product *might* have an image, we can assume it does.
+    # The logic below is slightly adjusted. A product document will still have the key 'image_data' if it was not projected out.
+    # The previous code was fine, but this makes it explicit that we are avoiding the large field.
+    products_cursor = mongo.db.products.find(
+        {}, 
+        # Exclude the large image_data field from the initial query
+        {'image_data': 0, 'image_content_type': 0}
+    )
+    # Get a set of IDs for products that DO have binary image data in a separate, fast query
+    products_with_images = {
+        str(p['_id']) for p in mongo.db.products.find(
+            {'image_data': {'$exists': True, '$ne': None}},
+            {'_id': 1} # Only fetch the ID
+        )
+    }
+
     products_list = []
     for p in products_cursor:
+        product_id_str = str(p['_id'])
         image_url = None
-        # If image_data exists, create a URL to our new endpoint
-        if p.get('image_data'):
-            # FIX: Generate an absolute URL to avoid cross-origin issues with the frontend dev server.
-            image_url = url_for('api.get_product_image', product_id=str(p['_id']), _external=True)
-        # Otherwise, use the fallback AI-generated URL if it exists
+        # Check against our pre-fetched set of IDs
+        if product_id_str in products_with_images:
+            image_url = url_for('api.get_product_image', product_id=product_id_str, _external=True)
+        # Fallback to the stored URL
         elif p.get('image_url'):
             image_url = p.get('image_url')
 
         products_list.append({
-            'id': str(p['_id']), 
-            'name': p.get('name'), 
+            'id': product_id_str,
+            'name': p.get('name'),
             'category': p.get('category'),
-            'modes': p.get('modes'), 
-            'image_url': image_url, # This will be the correct, usable URL
+            'modes': p.get('modes'),
+            'image_url': image_url,
             'description': p.get('description', '')
         })
     return jsonify(products_list)
@@ -151,49 +174,86 @@ def handle_cart():
     user_email = get_jwt_identity()
 
     if request.method == 'GET':
-        cart = mongo.db.carts.find_one({'user_email': user_email})
-        if not cart:
-            return jsonify({'items': [], 'deliveryDate': None})
+        # --- OPTIMIZATION: Use MongoDB Aggregation Pipeline to fetch cart and products in one go ---
+        pipeline = [
+            # 1. Find the user's cart
+            {'$match': {'user_email': user_email}},
+            # 2. Deconstruct the items array to process each item
+            {'$unwind': '$items'},
+            # 3. Convert string productId to ObjectId for lookup
+            {'$addFields': {'productId_obj': {'$toObjectId': '$items.productId'}}},
+            # 4. Join with the products collection ($lookup is like a JOIN)
+            {
+                '$lookup': {
+                    'from': 'products',
+                    'localField': 'productId_obj',
+                    'foreignField': '_id',
+                    'as': 'productDetails'
+                }
+            },
+            # 5. Deconstruct the resulting productDetails array (it will have 1 element)
+            {'$unwind': '$productDetails'},
+            # 6. Re-shape the document to match the frontend's expected format
+            {
+                '$project': {
+                    '_id': 0,
+                    'deliveryDate': '$deliveryDate',
+                    'item': {
+                        'quantity': '$items.quantity',
+                        'mode': '$items.mode',
+                        'product': {
+                            'id': {'$toString': '$productDetails._id'},
+                            'name': '$productDetails.name',
+                            'modes': '$productDetails.modes',
+                            'price': {'$getField': {'field': '$items.mode', 'input': '$productDetails.modes.price'}},
+                            'image_url': {
+                                '$cond': {
+                                    'if': {'$and': [
+                                        {'$ne': ['$productDetails.image_data', None]},
+                                        {'$ne': ['$productDetails.image_data', ""]}
+                                    ]},
+                                    'then': url_for('api.get_product_image', product_id=str(ObjectId()), _external=True).replace(str(ObjectId()),""), # Placeholder for url construction
+                                    'else': '$productDetails.image_url'
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+             # 7. Dynamically construct the image URL
+            {
+                '$addFields': {
+                    "item.product.image_url": {
+                        '$cond': {
+                            'if': {'$ne': ["$item.product.image_url", None]},
+                             'then': {
+                                 '$concat': [
+                                     request.host_url.rstrip('/'),
+                                     '/api/product_image/',
+                                     "$item.product.id"
+                                 ]
+                             },
+                             'else': None
+                        }
+                    }
+                }
+            },
+            # 8. Group all items back into a single cart document
+            {
+                '$group': {
+                    '_id': '$_id',
+                    'deliveryDate': {'$first': '$deliveryDate'},
+                    'items': {'$push': '$item'}
+                }
+            }
+        ]
 
-        populated_items = []
-        if cart.get('items'):
-            product_ids = [ObjectId(item['productId']) for item in cart['items']]
-            if product_ids:
-                products_cursor = mongo.db.products.find({'_id': {'$in': product_ids}})
-                products = {str(p['_id']): p for p in products_cursor}
-
-                for item in cart['items']:
-                    details = products.get(item['productId'])
-                    if details:
-                        mode = item.get('mode', 'piece')
-                        mode_details = details.get('modes', {}).get(mode)
-                        
-                        if mode_details:
-                            price = mode_details.get('price')
-                            
-                            image_url = None
-                            if details.get('image_data'):
-                                # FIX: Generate an absolute URL.
-                                image_url = url_for('api.get_product_image', product_id=str(details['_id']), _external=True)
-                            elif details.get('image_url'):
-                                image_url = details.get('image_url')
-
-                            populated_items.append({
-                                'product': {
-                                    'id': str(details['_id']), 
-                                    'name': details.get('name'), 
-                                    'modes': details.get('modes'),
-                                    'image_url': image_url,
-                                    'price': price
-                                },
-                                'quantity': item['quantity'],
-                                'mode': mode
-                            })
+        result = list(mongo.db.carts.aggregate(pipeline))
         
-        return jsonify({
-            'items': populated_items,
-            'deliveryDate': cart.get('deliveryDate')
-        })
+        if not result:
+            return jsonify({'items': [], 'deliveryDate': None})
+        
+        return jsonify(result[0])
 
     if request.method == 'POST':
         data = request.get_json()
@@ -330,66 +390,107 @@ def handle_orders():
         return jsonify({"msg": "Order placed successfully! You will be redirected shortly to the Orders Page!", "orderId": str(order_id)}), 201
 
     if request.method == 'GET':
-        user_orders = list(mongo.db.orders.find({'user_email': user_email}).sort('created_at', -1))
+        user_orders_cursor = mongo.db.orders.find({'user_email': user_email}).sort('created_at', -1)
+        user_orders = list(user_orders_cursor)
         if not user_orders: return jsonify([])
-        
-        all_product_ids = {ObjectId(item['productId']) for order in user_orders for item in order.get('items', [])}
-        products_cursor = mongo.db.products.find({'_id': {'$in': list(all_product_ids)}})
-        products = {str(p['_id']): p for p in products_cursor}
-        
+
+        # Fetch status from DB, or from Zoho if not present in DB.
         for order in user_orders:
-            # Determine status from Zoho
-            live_status = 'pending'  # Default status
+            # If status is present in our DB, use it and skip the API call.
+            if 'zoho_status' in order:
+                order['status'] = order['zoho_status']
+                continue
+
+            # If status is not in DB, fetch from Zoho, update DB, and then use it.
+            live_status = 'pending'
             try:
                 serial_no = order.get('serial_no')
                 if serial_no:
                     invoices_response, _ = make_zoho_api_request('GET', '/invoices', params={'reference_number': serial_no})
                     if invoices_response and invoices_response.get('invoices'):
                         invoice = invoices_response['invoices'][0]
-                        zoho_status = invoice.get('status')
-                        if zoho_status == 'draft':
+                        zoho_api_status = invoice.get('status')
+                        if zoho_api_status == 'draft':
                             live_status = 'pending'
-                        elif zoho_status == 'sent':
+                        elif zoho_api_status == 'sent':
                             live_status = 'Processing'
-                        elif zoho_status == 'paid':
+                        elif zoho_api_status == 'paid':
                             live_status = 'Completed'
-                        elif zoho_status == 'void':
+                        elif zoho_api_status == 'void':
                             live_status = 'cancelled'
+                
+                # Save the newly fetched status to MongoDB for future requests
+                mongo.db.orders.update_one(
+                    {'_id': order['_id']},
+                    {'$set': {'zoho_status': live_status}}
+                )
+
             except Exception as e:
                 current_app.logger.error(f"Could not fetch Zoho invoice status for order {order.get('serial_no')}: {e}")
             
             order['status'] = live_status
-
-            # Populate items
-            populated_items = []
-            for item in order.get('items', []):
-                p = products.get(item['productId'])
-                if p:
-                    mode = item.get('mode', 'pieces')
-                    mode_details = p.get('modes', {}).get(mode, {})
-                    
-                    image_url = None
-                    if p.get('image_data'):
-                        image_url = url_for('api.get_product_image', product_id=str(p['_id']), _external=True)
-                    elif p.get('image_url'):
-                        image_url = p.get('image_url')
-                    
-                    populated_items.append({
-                        'quantity': item['quantity'], 
-                        'mode': mode,
-                        'price': mode_details.get('price'),
+        
+        # --- OPTIMIZATION: Use a single aggregation to populate product details for all orders ---
+        pipeline = [
+            {'$match': {'user_email': user_email}},
+            {'$sort': {'created_at': -1}},
+            {'$unwind': '$items'},
+            {'$addFields': {'productId_obj': {'$toObjectId': '$items.productId'}}},
+            {
+                '$lookup': {
+                    'from': 'products',
+                    'localField': 'productId_obj',
+                    'foreignField': '_id',
+                    'as': 'productDetails'
+                }
+            },
+            {'$unwind': '$productDetails'},
+            {
+                '$group': {
+                    '_id': '$_id',
+                    'items': {'$push': {
+                        'quantity': '$items.quantity',
+                        'mode': '$items.mode',
+                        'price': {'$let': {'vars': {'mode_details': {'$getField': {'field': '$items.mode', 'input': '$productDetails.modes'}}}, 'in': '$$mode_details.price'}},
                         'product': {
-                            'id': str(p['_id']), 
-                            'name': p.get('name'), 
-                            'modes': p.get('modes'), 
-                            'image_url': image_url
+                            'id': {'$toString': '$productDetails._id'},
+                            'name': '$productDetails.name',
+                            'modes': '$productDetails.modes',
+                            'image_url': {
+                                '$cond': {
+                                    'if': {'$ifNull': ['$productDetails.image_data', False]},
+                                    'then': {'$concat': [request.host_url.rstrip('/'), '/api/product_image/', {'$toString': '$productDetails._id'}]},
+                                    'else': '$productDetails.image_url'
+                                }
+                            }
                         }
-                    })
-            order['items'] = populated_items
-            order['_id'] = str(order['_id'])
+                    }},
+                    # Carry over all original order fields
+                    'doc': {'$first': '$$ROOT'}
+                }
+            },
+            {
+                '$replaceRoot': {
+                    'newRoot': {
+                        '$mergeObjects': ['$doc', {'items': '$items'}]
+                    }
+                }
+            },
+            {'$sort': {'created_at': -1}}
+        ]
+        
+        populated_orders = list(mongo.db.orders.aggregate(pipeline))
+
+        # Merge the live status back into the populated orders
+        status_map = {str(order['_id']): order['status'] for order in user_orders}
+        for order in populated_orders:
+            order_id_str = str(order['_id'])
+            order['status'] = status_map.get(order_id_str, 'pending')
+            order['_id'] = order_id_str # Convert ObjectId to string for JSON
             order['created_at'] = order['created_at'].isoformat()
             order['delivery_date'] = order['delivery_date'] if isinstance(order['delivery_date'], str) else order['delivery_date'].isoformat()
-        return jsonify(user_orders)
+        
+        return jsonify(populated_orders)
 
 @api_bp.route('/orders/<order_id>', methods=['GET'])
 @jwt_required()