feat(catalogue): Add merchant-level catalogue ID generation and date field validators

- Implement generate_merchant_catalogue_id method with sequential numbering format (MERCHANT_PREFIX-SEQUENTIAL_NUMBER)
- Add merchant_id-based catalogue ID generation with UUID fallback for robustness
- Add field validators to handle empty string to None conversion in gift_card_schema for updated_at field
- Add field validators to handle empty string to None conversion in promotion_schema for start_date and end_date fields
- Add field validators to handle empty string to None conversion in supplier_schema for date-related fields
- Add field validators to handle empty string to None conversion in taxonomy_schema for timestamp fields
- Add comprehensive test suite (test_catalogue_id_generation.py) to validate catalogue ID generation logic
- Improves data consistency by ensuring empty strings are properly converted to None across all schemas

app/models/catalogue_models.py

@@ -27,10 +27,48 @@ UNCATEGORIZED_DEFAULT = "Uncategorized"
 
 class CatalogueModel:
     
+    @staticmethod
+    async def generate_merchant_catalogue_id(merchant_id: str) -> str:
+        """
+        Generate a simple, merchant-level catalogue ID.
+        Format: MERCHANT_PREFIX-SEQUENTIAL_NUMBER
+        
+        Args:
+            merchant_id: The merchant identifier
+            
+        Returns:
+            str: Generated catalogue ID (e.g., "MER123-00001")
+        """
+        try:
+            # Get the count of existing catalogues for this merchant
+            count = await db['catalogues'].count_documents({"merchant_id": merchant_id})
+            
+            # Generate sequential ID with merchant prefix
+            merchant_prefix = merchant_id[:6].upper() if len(merchant_id) >= 6 else merchant_id.upper()
+            sequential_number = str(count + 1).zfill(5)
+            catalogue_id = f"{merchant_prefix}-{sequential_number}"
+            
+            logger.info("Generated merchant catalogue ID", extra={
+                "merchant_id": merchant_id,
+                "catalogue_id": catalogue_id
+            })
+            
+            return catalogue_id
+        except Exception as e:
+            logger.error("Error generating merchant catalogue ID", exc_info=e)
+            # Fallback to UUID if generation fails
+            return str(uuid.uuid4())
+    
     @staticmethod
     async def create_catalogue_item(data: Dict[str, Any]) -> str:
         try:
-            catalogue_id = str(uuid.uuid4())
+            merchant_id = data.get("merchant_id")
+            if merchant_id:
+                catalogue_id = await CatalogueModel.generate_merchant_catalogue_id(merchant_id)
+            else:
+                # Fallback to UUID if no merchant_id
+                catalogue_id = str(uuid.uuid4())
+            
             data['catalogue_id'] = catalogue_id
             data = convert_dates(data)
             result = await db['catalogues'].insert_one(data)

app/schemas/gift_card_schema.py

@@ -146,6 +146,13 @@ class GiftCardTemplateResponse(GiftCardTemplateBase):
     created_at: datetime = Field(..., description="Created timestamp")
     updated_at: Optional[datetime] = Field(None, description="Last modified timestamp")
 
+    @field_validator('updated_at', mode='before')
+    @classmethod
+    def empty_str_to_none(cls, v):
+        if v == '' or v is None:
+            return None
+        return v
+
     class Config:
         populate_by_name = True
         json_encoders = {

app/schemas/promotion_schema.py

@@ -29,6 +29,13 @@ class PromotionMetaData(BaseModel):
     max_discount: Optional[float]= Field(None, description="Cap on discount amount")
     start_date: datetime = Field(..., description="Start date of validity period (ISO 8601 format, e.g. YYYY-MM-DD)")
     end_date: datetime = Field(..., description="End date of validity period (ISO 8601 format, e.g. YYYY-MM-DD)")
+
+    @field_validator('start_date', 'end_date', mode='before')
+    @classmethod
+    def empty_str_to_none_dates(cls, v):
+        if v == '' or v is None:
+            return None
+        return v
     usage_limit: Optional[int] = Field(None, description="Total uses allowed")
     per_user_limit: Optional[int] = Field(0, description="Max uses per user")
     used_count: int = Field(0, description="Total times the coupon has been used")
@@ -44,7 +51,7 @@ class PromotionMetaData(BaseModel):
     
     
 class PromotionUpdate(BaseModel):
-    
+
     title: Optional[str] = None
     description: Optional[str] = None
 
@@ -64,6 +71,13 @@ class PromotionUpdate(BaseModel):
     auto_apply: Optional[bool] = None
     stackable: Optional[bool] = None
 
+    @field_validator('start_date', 'end_date', mode='before')
+    @classmethod
+    def empty_str_to_none(cls, v):
+        if v == '' or v is None:
+            return None
+        return v
+
     @field_validator("end_date")
     def check_end_date(cls, v, info):
         start_date = info.data.get("start_date")

app/schemas/supplier_schema.py

@@ -1,7 +1,7 @@
 from datetime import date, datetime
 from typing import Any, Dict, List, Optional
 from fastapi import Query
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, validator
 
 
 class Contact(BaseModel):
@@ -68,6 +68,12 @@ class Supplier(BaseModel):
     created_at: Optional[datetime] = Field(None, description="Creation timestamp")
     updated_at: Optional[datetime] = Field(None, description="Last update timestamp")
 
+    @validator('associated_since', 'last_supplied_date', 'created_at', 'updated_at', pre=True)
+    def empty_str_to_none(cls, v):
+        if v == '' or v is None:
+            return None
+        return v
+
     
 class SupplierListFilter(BaseModel):
     filters: Optional[Dict[str, Any]] = None

app/schemas/taxonomy_schema.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 from typing import Dict, List, Literal, Optional
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, validator
 
 class UOMConversionDetail(BaseModel):
     alt_uom: str = Field(..., description="Alternative unit of measurement")
@@ -34,6 +34,11 @@ class TaxonomyInfo(BaseModel):
     created_by: Optional[str] = Field(None, description="User who created this record")
     created_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="Creation timestamp")
     updated_at: Optional[datetime] = Field(default_factory=datetime.utcnow, description="Last update timestamp")
+
+    @validator('created_at', 'updated_at', pre=True)
+    def empty_str_to_none(cls, v):
+        if v == '' or v is None:
+            return None
+        return v
     
     
-    

test_catalogue_id_generation.py

@@ -0,0 +1,145 @@
+"""
+Test script for the new merchant-level catalogue ID generation.
+This tests the generate_merchant_catalogue_id method.
+"""
+import asyncio
+import sys
+import os
+from unittest.mock import AsyncMock, MagicMock, patch, Mock
+
+# Add the parent directory to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+async def test_catalogue_id_generation():
+    """Test the new catalogue ID generation logic"""
+    
+    # Mock all the dependencies before importing
+    mock_modules = {
+        'insightfy_utils': Mock(),
+        'insightfy_utils.logging': Mock(),
+        'app.constants': Mock(),
+        'app.constants.collections': Mock(),
+        'app.repositories': Mock(),
+        'app.repositories.db': Mock(),
+        'app.repositories.inventory_repository': Mock(),
+        'app.schemas': Mock(),
+        'app.schemas.catalogue_schema': Mock(),
+        'app.schemas.inventory_schema': Mock(),
+        'app.utils': Mock(),
+        'app.utils.catalogue_utils': Mock(),
+        'app.utils.info_widget_utils': Mock(),
+        'app.sql': Mock(),
+    }
+    
+    for name, mock_module in mock_modules.items():
+        sys.modules[name] = mock_module
+    
+    # Mock get_logger
+    sys.modules['insightfy_utils.logging'].get_logger = Mock(return_value=Mock())
+    
+    # Import after mocking
+    from app.models.catalogue_models import CatalogueModel
+    
+    print("=" * 60)
+    print("Testing Merchant-Level Catalogue ID Generation")
+    print("=" * 60)
+    
+    # Test Case 1: Normal merchant ID with existing catalogues
+    print("\n[Test 1] Merchant with 5 existing catalogues")
+    with patch('app.models.catalogue_models.db') as mock_db:
+        mock_db.__getitem__.return_value.count_documents = AsyncMock(return_value=5)
+        
+        catalogue_id = await CatalogueModel.generate_merchant_catalogue_id("merchant123")
+        print(f"  Merchant ID: merchant123")
+        print(f"  Generated ID: {catalogue_id}")
+        print(f"  Expected format: MERCHA-00006")
+        assert catalogue_id == "MERCHA-00006", f"Expected MERCHA-00006, got {catalogue_id}"
+        print("  ✓ PASSED")
+    
+    # Test Case 2: New merchant with no catalogues
+    print("\n[Test 2] New merchant with 0 catalogues")
+    with patch('app.models.catalogue_models.db') as mock_db:
+        mock_db.__getitem__.return_value.count_documents = AsyncMock(return_value=0)
+        
+        catalogue_id = await CatalogueModel.generate_merchant_catalogue_id("newmerchant")
+        print(f"  Merchant ID: newmerchant")
+        print(f"  Generated ID: {catalogue_id}")
+        print(f"  Expected format: NEWMER-00001")
+        assert catalogue_id == "NEWMER-00001", f"Expected NEWMER-00001, got {catalogue_id}"
+        print("  ✓ PASSED")
+    
+    # Test Case 3: Short merchant ID
+    print("\n[Test 3] Short merchant ID (less than 6 chars)")
+    with patch('app.models.catalogue_models.db') as mock_db:
+        mock_db.__getitem__.return_value.count_documents = AsyncMock(return_value=10)
+        
+        catalogue_id = await CatalogueModel.generate_merchant_catalogue_id("abc")
+        print(f"  Merchant ID: abc")
+        print(f"  Generated ID: {catalogue_id}")
+        print(f"  Expected format: ABC-00011")
+        assert catalogue_id == "ABC-00011", f"Expected ABC-00011, got {catalogue_id}"
+        print("  ✓ PASSED")
+    
+    # Test Case 4: Large number of catalogues (sequential numbering)
+    print("\n[Test 4] Merchant with 999 catalogues")
+    with patch('app.models.catalogue_models.db') as mock_db:
+        mock_db.__getitem__.return_value.count_documents = AsyncMock(return_value=999)
+        
+        catalogue_id = await CatalogueModel.generate_merchant_catalogue_id("store456")
+        print(f"  Merchant ID: store456")
+        print(f"  Generated ID: {catalogue_id}")
+        print(f"  Expected format: STORE4-01000")
+        assert catalogue_id == "STORE4-01000", f"Expected STORE4-01000, got {catalogue_id}"
+        print("  ✓ PASSED")
+    
+    # Test Case 5: Error handling - fallback to UUID
+    print("\n[Test 5] Error handling - should fallback to UUID")
+    with patch('app.models.catalogue_models.db') as mock_db:
+        mock_db.__getitem__.return_value.count_documents = AsyncMock(side_effect=Exception("DB Error"))
+        
+        catalogue_id = await CatalogueModel.generate_merchant_catalogue_id("errormerchant")
+        print(f"  Merchant ID: errormerchant")
+        print(f"  Generated ID: {catalogue_id}")
+        print(f"  Expected: UUID format (36 chars with dashes)")
+        assert len(catalogue_id) == 36 and catalogue_id.count('-') == 4, "Should be UUID format"
+        print("  ✓ PASSED - Fallback to UUID works")
+    
+    # Test Case 6: Integration with create_catalogue_item
+    print("\n[Test 6] Integration with create_catalogue_item")
+    with patch('app.models.catalogue_models.db') as mock_db, \
+         patch('app.models.catalogue_models.convert_dates') as mock_convert:
+        
+        mock_db.__getitem__.return_value.count_documents = AsyncMock(return_value=42)
+        mock_convert.side_effect = lambda x: x
+        
+        # Mock insert_one to return a result with inserted_id
+        mock_result = MagicMock()
+        mock_result.inserted_id = "mongo_object_id_123"
+        mock_db.__getitem__.return_value.insert_one = AsyncMock(return_value=mock_result)
+        
+        test_data = {
+            "merchant_id": "testmerch",
+            "catalogue_name": "Test Product",
+            "catalogue_type": "Product",
+            "retail_price": 100.0
+        }
+        
+        result = await CatalogueModel.create_catalogue_item(test_data)
+        print(f"  Merchant ID: testmerch")
+        print(f"  Catalogue ID in data: {test_data.get('catalogue_id')}")
+        print(f"  Expected format: TESTME-00043")
+        assert test_data['catalogue_id'] == "TESTME-00043", f"Expected TESTME-00043, got {test_data['catalogue_id']}"
+        print("  ✓ PASSED - create_catalogue_item uses new ID generation")
+    
+    print("\n" + "=" * 60)
+    print("All Tests PASSED! ✓")
+    print("=" * 60)
+    print("\nSummary:")
+    print("  • Sequential numbering works correctly")
+    print("  • Merchant prefix extraction works")
+    print("  • Error handling with UUID fallback works")
+    print("  • Integration with create_catalogue_item works")
+    print("\nThe new merchant-level catalogue ID generation is working as expected!")
+
+if __name__ == "__main__":
+    asyncio.run(test_catalogue_id_generation())