Update smart_warehouse_with_price.py - sync with WhatsApp version for better product matching

smart_warehouse_with_price.py

@@ -7,8 +7,8 @@ import json
 import xml.etree.ElementTree as ET
 import time
 
-# Cache configuration - 12 hours
-CACHE_DURATION = 43200  # 12 hours
+# Cache configuration - 2 hours (reduced from 12 hours for more accurate results)
+CACHE_DURATION = 7200  # 2 hours
 cache = {
     'warehouse_xml': {'data': None, 'time': 0},
     'trek_xml': {'data': None, 'time': 0},
@@ -21,10 +21,9 @@ def get_cached_trek_xml():
     current_time = time.time()
     
     if cache['trek_xml']['data'] and (current_time - cache['trek_xml']['time'] < CACHE_DURATION):
-        print("🚴 Using cached Trek XML (12-hour cache)")
+        cache_age = (current_time - cache['trek_xml']['time']) / 60  # in minutes
         return cache['trek_xml']['data']
     
-    print("📡 Fetching fresh Trek XML...")
     try:
         url = 'https://www.trekbisiklet.com.tr/output/8582384479'
         response = requests.get(url, verify=False, timeout=10)
@@ -36,9 +35,139 @@ def get_cached_trek_xml():
         else:
             return None
     except Exception as e:
-        print(f"Trek XML fetch error: {e}")
         return None
 
+def apply_price_rounding(price_str):
+    """Apply the same price rounding formula used in app.py"""
+    if not price_str:
+        return price_str
+    
+    try:
+        price_float = float(price_str)
+        if price_float > 200000:
+            return str(round(price_float / 5000) * 5000)
+        elif price_float > 30000:
+            return str(round(price_float / 1000) * 1000)
+        elif price_float > 10000:
+            return str(round(price_float / 100) * 100)
+        else:
+            return str(round(price_float / 10) * 10)
+    except:
+        return price_str
+
+def get_product_price_and_link_by_sku(product_code):
+    """Get price and link from Trek XML using improved SKU matching with new XML fields
+    Uses: stockCode, rootProductStockCode, isOptionOfAProduct, isOptionedProduct
+    Level 1: Search variants by stockCode where isOptionOfAProduct=1  
+    Level 2: Search main products by stockCode where isOptionOfAProduct=0
+    Level 3: Search by rootProductStockCode for variant-to-main mapping
+    """
+    try:
+        # Import XML parsing for cleaner approach
+        import xml.etree.ElementTree as ET
+        
+        # Get cached Trek XML
+        xml_content = get_cached_trek_xml()
+        if not xml_content:
+            return None, None
+            
+        # Convert bytes to string if needed
+        if isinstance(xml_content, bytes):
+            xml_content = xml_content.decode('utf-8')
+        
+        # Parse XML properly instead of regex
+        try:
+            root = ET.fromstring(xml_content)
+        except:
+            # Fallback to regex if XML parsing fails
+            return get_product_price_and_link_by_sku_regex(product_code)
+        
+        # Level 1: Search variants first (isOptionOfAProduct=1)
+        for item in root.findall('.//item'):
+            is_option_element = item.find('isOptionOfAProduct')
+            stock_code_element = item.find('stockCode')
+            
+            if (is_option_element is not None and is_option_element.text == '1' and
+                stock_code_element is not None and stock_code_element.text and stock_code_element.text.strip() == product_code):
+                
+                price_element = item.find('priceTaxWithCur')
+                link_element = item.find('productLink')
+                
+                if price_element is not None and link_element is not None:
+                    rounded_price = apply_price_rounding(price_element.text)
+                    return rounded_price, link_element.text
+        
+        # Level 2: Search main products (isOptionOfAProduct=0)  
+        for item in root.findall('.//item'):
+            is_option_element = item.find('isOptionOfAProduct')
+            stock_code_element = item.find('stockCode')
+            
+            if (is_option_element is not None and is_option_element.text == '0' and
+                stock_code_element is not None and stock_code_element.text and stock_code_element.text.strip() == product_code):
+                
+                price_element = item.find('priceTaxWithCur')
+                link_element = item.find('productLink')
+                
+                if price_element is not None and link_element is not None:
+                    rounded_price = apply_price_rounding(price_element.text)
+                    return rounded_price, link_element.text
+        
+        # Level 3: Search by rootProductStockCode (variant parent lookup)
+        for item in root.findall('.//item'):
+            root_stock_element = item.find('rootProductStockCode')
+            
+            if (root_stock_element is not None and root_stock_element.text and root_stock_element.text.strip() == product_code):
+                price_element = item.find('priceTaxWithCur')
+                link_element = item.find('productLink')
+                
+                if price_element is not None and link_element is not None:
+                    rounded_price = apply_price_rounding(price_element.text)
+                    return rounded_price, link_element.text
+        
+        # Not found
+        return None, None
+        
+    except Exception as e:
+        return None, None
+
+def get_product_price_and_link_by_sku_regex(product_code):
+    """Fallback regex method for SKU lookup if XML parsing fails"""
+    try:
+        xml_content = get_cached_trek_xml()
+        if isinstance(xml_content, bytes):
+            xml_content = xml_content.decode('utf-8')
+        
+        # Level 1: Search in variants first (isOptionOfAProduct=1)
+        variant_pattern = rf'<isOptionOfAProduct>1</isOptionOfAProduct>.*?<stockCode><!\[CDATA\[{re.escape(product_code)}\]\]></stockCode>.*?(?=<item>|$)'
+        variant_match = re.search(variant_pattern, xml_content, re.DOTALL)
+        
+        if variant_match:
+            section = variant_match.group(0)
+            price_match = re.search(r'<price><!\[CDATA\[(.*?)\]\]></price>', section)
+            link_match = re.search(r'<producturl><!\[CDATA\[(.*?)\]\]></producturl>', section)
+            
+            if price_match and link_match:
+                rounded_price = apply_price_rounding(price_match.group(1))
+                return rounded_price, link_match.group(1)
+        
+        # Level 2: Search in main products (isOptionOfAProduct=0)
+        main_pattern = rf'<isOptionOfAProduct>0</isOptionOfAProduct>.*?<stockCode><!\[CDATA\[{re.escape(product_code)}\]\]></stockCode>.*?(?=<item>|$)'
+        main_match = re.search(main_pattern, xml_content, re.DOTALL)
+        
+        if main_match:
+            section = main_match.group(0)
+            price_match = re.search(r'<price><!\[CDATA\[(.*?)\]\]></price>', section)
+            link_match = re.search(r'<producturl><!\[CDATA\[(.*?)\]\]></producturl>', section)
+            
+            if price_match and link_match:
+                rounded_price = apply_price_rounding(price_match.group(1))
+                return rounded_price, link_match.group(1)
+        
+        return None, None
+        
+    except Exception as e:
+        return None, None
+
 def get_product_price_and_link(product_name, variant=None):
     """Get price and link from Trek website XML"""
     try:
@@ -49,19 +178,33 @@ def get_product_price_and_link(product_name, variant=None):
             
         root = ET.fromstring(xml_content)
         
-        # Normalize search terms
-        search_name = product_name.lower()
-        search_variant = variant.lower() if variant else ""
+        # Turkish character normalization FIRST (before lower())
+        tr_map = {
+            'İ': 'i', 'I': 'i', 'ı': 'i',  # All I variations to i
+            'Ğ': 'g', 'ğ': 'g',
+            'Ü': 'u', 'ü': 'u', 
+            'Ş': 's', 'ş': 's',
+            'Ö': 'o', 'ö': 'o',
+            'Ç': 'c', 'ç': 'c'
+        }
         
-        # Turkish character normalization
-        tr_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c'}
+        # Apply normalization to original (before lower)
+        search_name_normalized = product_name
+        search_variant_normalized = variant if variant else ""
         for tr, en in tr_map.items():
-            search_name = search_name.replace(tr, en)
-            search_variant = search_variant.replace(tr, en)
+            search_name_normalized = search_name_normalized.replace(tr, en)
+            search_variant_normalized = search_variant_normalized.replace(tr, en)
+        
+        # Now lowercase
+        search_name = search_name_normalized.lower()
+        search_variant = search_variant_normalized.lower()
         
         best_match = None
         best_score = 0
         
+        # Clean search name - remove year and parentheses
+        clean_search = re.sub(r'\s*\(\d{4}\)\s*', '', search_name).strip()
+        
         for item in root.findall('item'):
             # Get product name
             rootlabel_elem = item.find('rootlabel')
@@ -72,12 +215,24 @@ def get_product_price_and_link(product_name, variant=None):
             for tr, en in tr_map.items():
                 item_name = item_name.replace(tr, en)
             
-            # Calculate match score
+            # Clean item name too
+            clean_item = re.sub(r'\s*\(\d{4}\)\s*', '', item_name).strip()
+            
+            # Calculate match score with priority for exact matches
             score = 0
-            name_parts = search_name.split()
-            for part in name_parts:
-                if part in item_name:
-                    score += 1
+            
+            # Exact match gets highest priority
+            if clean_search == clean_item:
+                score += 100
+            # Check if starts with exact product name (e.g., "fx 2" in "fx 2 kirmizi")
+            elif clean_item.startswith(clean_search + " ") or clean_item == clean_search:
+                score += 50
+            else:
+                # Partial matching
+                name_parts = clean_search.split()
+                for part in name_parts:
+                    if part in clean_item:
+                        score += 1
             
             # Check variant if specified
             if variant and search_variant in item_name:
@@ -120,7 +275,6 @@ def get_product_price_and_link(product_name, variant=None):
         return None, None
         
     except Exception as e:
-        print(f"Error getting price/link: {e}")
         return None, None
 
 def get_cached_warehouse_xml():
@@ -128,28 +282,23 @@ def get_cached_warehouse_xml():
     current_time = time.time()
     
     if cache['warehouse_xml']['data'] and (current_time - cache['warehouse_xml']['time'] < CACHE_DURATION):
-        print("📦 Using cached warehouse XML (12-hour cache)")
+        cache_age = (current_time - cache['warehouse_xml']['time']) / 60  # in minutes
         return cache['warehouse_xml']['data']
     
-    print("📡 Fetching fresh warehouse XML...")
     for attempt in range(3):
         try:
             url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
             timeout_val = 10 + (attempt * 5)
             response = requests.get(url, verify=False, timeout=timeout_val)
             xml_text = response.text
-            print(f"DEBUG - XML fetched: {len(xml_text)} characters (attempt {attempt+1})")
-            
             cache['warehouse_xml']['data'] = xml_text
             cache['warehouse_xml']['time'] = current_time
             
             return xml_text
         except requests.exceptions.Timeout:
-            print(f"XML fetch timeout (attempt {attempt+1}/3, timeout={timeout_val}s)")
             if attempt == 2:
                 return None
         except Exception as e:
-            print(f"XML fetch error: {e}")
             return None
     
     return None
@@ -180,14 +329,24 @@ def get_warehouse_stock_smart_with_price(user_message, previous_result=None):
         'kesinlikle', 'elbette', 'tabii', 'tabiki', 'doğru', 'yanlış'
     ]
     
+    # Check if message is just a simple response
     if clean_message in non_product_words:
         return None
-    
-    # Kısa tek kelimeler genellikle ürün adı değil
-    if len(clean_message.split()) == 1 and len(clean_message) < 5:
+
+    # Brand keywords that should ALWAYS trigger product search regardless of length
+    brand_keywords = ['gobik', 'trek', 'bontrager', 'kask', 'shimano', 'sram', 'garmin', 'wahoo']
+
+    # Check if message contains a brand keyword
+    contains_brand = any(brand in clean_message for brand in brand_keywords)
+
+    # Check if it's a single word that's likely not a product
+    # BUT allow if it contains a known brand
+    if not contains_brand and len(clean_message.split()) == 1 and len(clean_message) < 5:
+        # Short single words are usually not product names
         return None
     
-    # Soru kontrolü - bunlar ürün araması değil
+    # Check if this is a question rather than a product search
+    # BUT skip this check if message contains a known brand
     question_indicators = [
         'musun', 'müsün', 'misin', 'mısın', 'miyim', 'mıyım',
         'musunuz', 'müsünüz', 'misiniz', 'mısınız',
@@ -195,31 +354,48 @@ def get_warehouse_stock_smart_with_price(user_message, previous_result=None):
         'ulaşamıyor', 'yapamıyor', 'gönderemiyor', 'edemiyor',
         '?'
     ]
+
+    # If message contains question indicators, it's likely not a product search
+    # EXCEPTION: If message contains a brand keyword, still search for products
+    if not contains_brand:
+        for indicator in question_indicators:
+            if indicator in clean_message:
+                return None
     
-    for indicator in question_indicators:
-        if indicator in clean_message:
-            return None
+    # Normalize cache key for consistent caching (Turkish chars + lowercase)
+    def normalize_for_cache(text):
+        """Normalize text for cache key"""
+        tr_map = {'İ': 'i', 'I': 'i', 'ı': 'i', 'Ğ': 'g', 'ğ': 'g', 'Ü': 'u', 'ü': 'u', 
+                  'Ş': 's', 'ş': 's', 'Ö': 'o', 'ö': 'o', 'Ç': 'c', 'ç': 'c'}
+        for tr, en in tr_map.items():
+            text = text.replace(tr, en)
+        return text.lower().strip()
     
     # Check search cache first
-    cache_key = user_message.lower()
+    cache_key = normalize_for_cache(user_message)
     current_time = time.time()
+    
     if cache_key in cache['search_results']:
         cached = cache['search_results'][cache_key]
         if current_time - cached['time'] < CACHE_DURATION:
-            print(f"✅ Using cached result for '{user_message}' (12-hour cache)")
+            cache_age = (current_time - cached['time']) / 60  # in minutes
             return cached['data']
+        else:
+            pass
     
     OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
     
     # Check if user is asking about specific warehouse
     warehouse_keywords = {
         'caddebostan': 'Caddebostan',
-        'ortaköy': 'Ortaköy', 
+        'ortaköy': 'Ortaköy',
         'ortakoy': 'Ortaköy',
         'alsancak': 'Alsancak',
         'izmir': 'Alsancak',
         'bahçeköy': 'Bahçeköy',
-        'bahcekoy': 'Bahçeköy'
+        'bahcekoy': 'Bahçeköy',
+        'sarıyer': 'Bahçeköy',
+        'sariyer': 'Bahçeköy'
     }
     
     user_lower = user_message.lower()
@@ -269,7 +445,35 @@ def get_warehouse_stock_smart_with_price(user_message, previous_result=None):
     if asked_warehouse:
         warehouse_filter = f"\nIMPORTANT: User is asking specifically about {asked_warehouse} warehouse. Only return products available in that warehouse."
     
-    # GPT prompt with enhanced instructions
+    # Debug logging
+    # Check if the target product exists
+    # Normalize Turkish characters for comparison
+    def normalize_turkish(text):
+        text = text.upper()
+        replacements = {'I': 'İ', 'Ç': 'C', 'Ş': 'S', 'Ğ': 'G', 'Ü': 'U', 'Ö': 'O'}
+        # Also try with İ -> I conversion
+        text2 = text.replace('İ', 'I')
+        return text, text2
+    
+    search_term = user_message.upper()
+    search_norm1, search_norm2 = normalize_turkish(search_term)
+    
+    matching_products = []
+    for p in products_summary:
+        p_name = p['name'].upper()
+        # Check both original and normalized versions
+        if (search_term in p_name or 
+            search_norm1 in p_name or 
+            search_norm2 in p_name or
+            search_term.replace('I', 'İ') in p_name):
+            matching_products.append(p)
+    
+    if matching_products:
+        pass
+    else:
+        pass
+    
+    # GPT-5 prompt with enhanced instructions
     smart_prompt = f"""User is asking: "{user_message}"
 
 FIRST CHECK: Is this actually a product search?
@@ -309,19 +513,42 @@ Examples of correct responses:
 - "45" (single product found)  
 - "-1" (no products found)"""
 
+    # Check if we have API key before making the request
+    if not OPENAI_API_KEY:
+        # Try to find in Trek XML directly as fallback, but avoid tool products
+        user_message_normalized = user_message.upper()
+        tool_indicators = ['SUPER B', 'ANAHTAR', 'TAKIMI', 'PENSE', 'TOOL', 'ADAPTÖR', 'CONVERTER']
+        should_skip_trek_lookup = any(indicator in user_message_normalized for indicator in tool_indicators)
+        
+        price, link = None, None
+        if not should_skip_trek_lookup:
+            price, link = get_product_price_and_link(user_message)
+            
+        if price and link:
+            return [
+                f"🚲 **{user_message.title()}**",
+                f"💰 Fiyat: {price}",
+                f"🔗 Link: {link}",
+                "",
+                "⚠️ **Stok durumu kontrol edilemiyor**",
+                "📞 Güncel stok için mağazalarımızı arayın:",
+                "• Caddebostan: 0543 934 0438",
+                "• Alsancak: 0543 936 2335"
+            ]
+        return None
+    
     headers = {
         "Content-Type": "application/json",
         "Authorization": f"Bearer {OPENAI_API_KEY}"
     }
     
+    # GPT-5.2 modeli temperature ve max_tokens desteklemiyor
     payload = {
         "model": "gpt-5.2-chat-latest",
         "messages": [
             {"role": "system", "content": "You are a product matcher. Find ALL matching products. Return only index numbers."},
             {"role": "user", "content": smart_prompt}
-        ],
-        
-        "max_tokens": 100
+        ]
     }
     
     try:
@@ -336,11 +563,31 @@ Examples of correct responses:
             result = response.json()
             indices_str = result['choices'][0]['message']['content'].strip()
             
-            print(f"DEBUG - GPT response: '{indices_str}'")
-            
-            # Handle empty response
+            # Handle empty response - try Trek XML as fallback, but avoid tool products  
             if not indices_str or indices_str == "-1":
-                return None  # GPT'ye bırak, "Ürün bulunamadı" deme
+                # Try to find in Trek XML directly, but skip tools
+                user_message_normalized = user_message.upper()
+                tool_indicators = ['SUPER B', 'ANAHTAR', 'TAKIMI', 'PENSE', 'TOOL', 'ADAPTÖR', 'CONVERTER']
+                should_skip_trek_lookup = any(indicator in user_message_normalized for indicator in tool_indicators)
+                
+                price, link = None, None
+                if not should_skip_trek_lookup:
+                    price, link = get_product_price_and_link(user_message)
+                    
+                if price and link:
+                    # Found in Trek XML but not in warehouse stock!
+                    return [
+                        f"🚲 **{user_message.title()}**",
+                        f"💰 Fiyat: {price}",
+                        f"🔗 Link: {link}",
+                        "",
+                        "❌ **Stok Durumu: TÜKENDİ**",
+                        "",
+                        "📞 Stok güncellemesi veya ön sipariş için mağazalarımızı arayabilirsiniz:",
+                        "• Caddebostan: 0543 934 0438",
+                        "• Alsancak: 0543 936 2335"
+                    ]
+                return None
             
             try:
                 # Filter out empty strings and parse indices
@@ -361,13 +608,33 @@ Examples of correct responses:
                         # Get product details
                         name_match = re.search(r'<ProductName><!\[CDATA\[(.*?)\]\]></ProductName>', product_block)
                         variant_match = re.search(r'<ProductVariant><!\[CDATA\[(.*?)\]\]></ProductVariant>', product_block)
+                        productcode_match = re.search(r'<ProductCode><!\[CDATA\[(.*?)\]\]></ProductCode>', product_block)
                         
                         if name_match:
                             product_name = name_match.group(1)
                             variant = variant_match.group(1) if variant_match else ""
                             
-                            # Get price and link from Trek website
-                            price, link = get_product_price_and_link(product_name, variant)
+                            # Get price and link from Trek website - TRY SKU FIRST (NEW METHOD)
+                            price, link = None, None
+                            
+                            # Try SKU-based lookup first if ProductCode exists
+                            product_code = productcode_match.group(1) if productcode_match else None
+                            if product_code and product_code.strip():
+                                price, link = get_product_price_and_link_by_sku(product_code.strip())
+                                
+                            # Fallback to name-based if SKU didn't work, but be more careful about matching
+                            if not price or not link:
+                                # Only do name-based fallback if the product might reasonably be sold by Trek
+                                # Avoid tools/accessories that clearly don't belong to Trek's bicycle catalog
+                                product_name_normalized = product_name.upper()
+                                
+                                # Skip name-based fallback for obvious tools/non-bike products
+                                tool_indicators = ['SUPER B', 'ANAHTAR', 'TAKIMI', 'PENSE', 'TOOL', 'ADAPTÖR', 'CONVERTER']
+                                
+                                should_skip_fallback = any(indicator in product_name_normalized for indicator in tool_indicators)
+                                
+                                if not should_skip_fallback:
+                                    price, link = get_product_price_and_link(product_name, variant)
                             
                             variant_info = {
                                 'name': product_name,
@@ -451,26 +718,41 @@ Examples of correct responses:
                                     result.append(f"• {v['variant']}: {warehouses_str}")
                             
                     else:
-                        return None  # Stok yoksa GPT'ye bırak
+                        # No warehouse stock found - check if product exists in Trek
+                        # But be careful not to match tools/accessories with bikes
+                        user_message_normalized = user_message.upper()
+                        tool_indicators = ['SUPER B', 'ANAHTAR', 'TAKIMI', 'PENSE', 'TOOL', 'ADAPTÖR', 'CONVERTER']
+                        should_skip_trek_lookup = any(indicator in user_message_normalized for indicator in tool_indicators)
+                        
+                        price, link = None, None
+                        if not should_skip_trek_lookup:
+                            price, link = get_product_price_and_link(user_message)
+                            
+                        if price and link:
+                            result.append(f"❌ **Stok Durumu: TÜM MAĞAZALARDA TÜKENDİ**")
+                            result.append("")
+                            result.append(f"💰 Web Fiyatı: {price}")
+                            result.append(f"🔗 Ürün Detayları: {link}")
+                            result.append("")
+                            result.append("📞 Stok güncellemesi veya ön sipariş için:")
+                            result.append("• Caddebostan: 0543 934 0438")
+                            result.append("• Alsancak: 0543 936 2335")
+                        else:
+                            return None
                 
                 # Cache the result before returning
                 cache['search_results'][cache_key] = {
                     'data': result,
                     'time': current_time
                 }
-                print(f"💾 Cached result for '{user_message}' (12-hour cache)")
-                
                 return result
                 
             except (ValueError, IndexError) as e:
-                print(f"DEBUG - Error parsing indices: {e}")
                 return None
         else:
-            print(f"GPT API error: {response.status_code}")
             return None
             
     except Exception as e:
-        print(f"Error calling GPT: {e}")
         return None
 
 def format_warehouse_name(wh_name):