restore: revert to backup system from today (before Combined API)

- Restored app.py from app_backup_before_combined_api_20250905_2207.py
- Restored smart_warehouse_with_price.py from backup
- Back to GPT-5 enhanced warehouse search system
- Combined API experiments removed, returning to stable system

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

app.py

@@ -32,24 +32,11 @@ USE_IMPROVED_SEARCH = False
 #     print("Improved WhatsApp chatbot not available, using basic search")
 #     USE_IMPROVED_SEARCH = False
 
-# Import Combined API search - yeni tek API sistemi
-try:
-    from combined_api_search import (
-        get_warehouse_stock_combined_api,
-        search_products_combined_api,
-        format_product_result_whatsapp
-    )
-    USE_COMBINED_API = True
-    logger.info("✅ Combined API search system loaded")
-except ImportError:
-    USE_COMBINED_API = False
-    logger.info("❌ Combined API search not available")
-
-# Import GPT-5 powered smart warehouse search - backup olarak
+# Import GPT-5 powered smart warehouse search - complete BF algorithm
 try:
     from smart_warehouse_with_price import get_warehouse_stock_smart_with_price
     USE_GPT5_SEARCH = True
-    logger.info("✅ GPT-5 warehouse search loaded as backup")
+    logger.info("✅ GPT-5 complete smart warehouse with price (BF algorithm) loaded")
 except ImportError:
     USE_GPT5_SEARCH = False
     logger.info("❌ GPT-5 search not available")
@@ -137,29 +124,188 @@ else:
 
 # Mağaza stok bilgilerini çekme fonksiyonu
 def get_warehouse_stock(product_name):
-    """Combined API'den stok bilgilerini çek - yeni tek API sistemi"""
-    logger.info(f"🔍 get_warehouse_stock called for: {product_name}")
-    logger.info(f"🔧 USE_COMBINED_API = {USE_COMBINED_API}")
-    
-    # SADECE Combined API kullan - diğer sistemleri devre dışı bırak
-    if USE_COMBINED_API:
+    """B2B API'den mağaza stok bilgilerini çek - GPT-5 enhanced"""
+    # Try GPT-5 complete smart search (BF algorithm)
+    if USE_GPT5_SEARCH:
         try:
-            logger.info(f"🚀 Calling get_warehouse_stock_combined_api for: {product_name}")
-            combined_result = get_warehouse_stock_combined_api(product_name)
-            logger.info(f"📊 Combined API result: {combined_result}")
-            if combined_result and combined_result != ["Ürün bulunamadı"]:
-                logger.info(f"✅ Combined API ile bulundu: {product_name}")
-                return combined_result
-            else:
-                logger.info(f"❌ Combined API'de bulunamadı: {product_name}")
-                return ["Ürün bulunamadı"]
+            gpt5_result = get_warehouse_stock_smart_with_price(product_name)
+            if gpt5_result and isinstance(gpt5_result, list):
+                # Return directly if it's already formatted strings
+                if all(isinstance(item, str) for item in gpt5_result):
+                    return gpt5_result
+                # Format for WhatsApp if dict format
+                warehouse_info = []
+                for item in gpt5_result:
+                    if isinstance(item, dict):
+                        info = f"📦 {item.get('name', '')}"
+                        if item.get('variant'):
+                            info += f" ({item['variant']})"
+                        if item.get('warehouses'):
+                            info += f"\n📍 Mevcut: {', '.join(item['warehouses'])}"
+                        if item.get('price'):
+                            info += f"\n💰 {item['price']}"
+                        warehouse_info.append(info)
+                    else:
+                        warehouse_info.append(str(item))
+                return warehouse_info if warehouse_info else None
         except Exception as e:
-            logger.error(f"❌ Combined API search error: {e}")
-            return ["Combined API hatası"]
+            logger.error(f"GPT-5 warehouse search error: {e}")
+            # Continue to fallback search
     
-    # Combined API yoksa hata mesajı döndür
-    logger.error(f"❌ Combined API not available!")
-    return ["Combined API system not available"]
+    # Fallback to original search
+    try:
+        import re
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml-b2b-api-v2.php'
+        response = requests.get(warehouse_url, verify=False, timeout=15)
+        
+        if response.status_code != 200:
+            return None
+            
+        root = ET.fromstring(response.content)
+        
+        # Turkish character normalization function
+        turkish_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c', 'İ': 'i', 'I': 'i'}
+        
+        def normalize_turkish(text):
+            import unicodedata
+            text = unicodedata.normalize('NFD', text)
+            text = ''.join(char for char in text if unicodedata.category(char) != 'Mn')
+            for tr_char, en_char in turkish_map.items():
+                text = text.replace(tr_char, en_char)
+            return text
+        
+        # Normalize search product name
+        search_name = normalize_turkish(product_name.lower().strip())
+        search_name = search_name.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+        search_words = search_name.split()
+        
+        best_matches = []
+        exact_matches = []
+        variant_matches = []
+        candidates = []
+        
+        # Separate size/color words from product words
+        size_color_words = ['s', 'm', 'l', 'xl', 'xs', 'small', 'medium', 'large', 
+                           'turuncu', 'siyah', 'beyaz', 'mavi', 'kirmizi', 'yesil', 
+                           'orange', 'black', 'white', 'blue', 'red', 'green']
+        
+        variant_words = [word for word in search_words if word in size_color_words]
+        product_words = [word for word in search_words if word not in size_color_words]
+        
+        # Check if this is a size/color specific query
+        is_size_color_query = len(variant_words) > 0 and len(search_words) <= 4
+        
+        # İlk geçiş: Variant alanında beden/renk araması
+        if is_size_color_query:
+            for product in root.findall('Product'):
+                product_name_elem = product.find('ProductName')
+                variant_elem = product.find('ProductVariant')
+                
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
+                    normalized_product_name = normalize_turkish(xml_product_name.lower())
+                    
+                    # If there are product words, check if they match the product name
+                    product_name_matches = True
+                    if product_words:
+                        product_name_matches = all(word in normalized_product_name for word in product_words)
+                    
+                    # Only proceed if product name matches (or no product context)
+                    if product_name_matches:
+                        # Variant field check
+                        if variant_elem is not None and variant_elem.text:
+                            variant_text = normalize_turkish(variant_elem.text.lower().replace('-', ' '))
+                            
+                            # Check if all variant words are in variant field
+                            if all(word in variant_text for word in variant_words):
+                                variant_matches.append((product, xml_product_name, variant_text))
+            
+            if variant_matches:
+                candidates = variant_matches
+            else:
+                # Fallback to normal product name search
+                is_size_color_query = False
+        
+        # İkinci geçiş: Normal ürün adı tam eşleşmeleri (variant match yoksa)
+        if not is_size_color_query or not candidates:
+            for product in root.findall('Product'):
+                product_name_elem = product.find('ProductName')
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
+                    normalized_xml = normalize_turkish(xml_product_name.lower())
+                    normalized_xml = normalized_xml.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+                    xml_words = normalized_xml.split()
+                    
+                    # Tam eşleşme kontrolü - ilk iki kelime tam aynı olmalı
+                    if len(search_words) >= 2 and len(xml_words) >= 2:
+                        search_key = f"{search_words[0]} {search_words[1]}"
+                        xml_key = f"{xml_words[0]} {xml_words[1]}"
+                        
+                        if search_key == xml_key:
+                            exact_matches.append((product, xml_product_name, normalized_xml))
+            
+            # Eğer variant match varsa onu kullan, yoksa exact matches kullan
+            if not candidates:
+                candidates = exact_matches if exact_matches else []
+        
+        # Eğer hala bir match yoksa, fuzzy matching yap
+        if not candidates:
+            for product in root.findall('Product'):
+                product_name_elem = product.find('ProductName')
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
+                    normalized_xml = normalize_turkish(xml_product_name.lower())
+                    normalized_xml = normalized_xml.replace('(2026)', '').replace('(2025)', '').replace(' gen 3', '').replace(' gen', '').strip()
+                    xml_words = normalized_xml.split()
+                    
+                    # Ortak kelime sayısını hesapla
+                    common_words = set(search_words) & set(xml_words)
+                    
+                    # En az 2 ortak kelime olmalı VE ilk kelime aynı olmalı (marka kontrolü)
+                    if (len(common_words) >= 2 and 
+                        len(search_words) > 0 and len(xml_words) > 0 and 
+                        search_words[0] == xml_words[0]):
+                        best_matches.append((product, xml_product_name, normalized_xml, len(common_words)))
+            
+            # En çok ortak kelimeye sahip olanları seç
+            if best_matches:
+                max_common = max(match[3] for match in best_matches)
+                candidates = [(match[0], match[1], match[2]) for match in best_matches if match[3] == max_common]
+        
+        # Stok bilgilerini topla ve tekrarları önle
+        warehouse_stock_map = {}  # warehouse_name -> total_stock
+        
+        for product, xml_name, _ in candidates:
+            # New B2B API structure: Warehouse elements are direct children of Product
+            for warehouse in product.findall('Warehouse'):
+                name_elem = warehouse.find('Name')
+                stock_elem = warehouse.find('Stock')
+                
+                if name_elem is not None and stock_elem is not None:
+                    warehouse_name = name_elem.text if name_elem.text else "Bilinmeyen"
+                    try:
+                        stock_count = int(stock_elem.text) if stock_elem.text else 0
+                        if stock_count > 0:
+                            # Aynı mağaza için stokları topla
+                            if warehouse_name in warehouse_stock_map:
+                                warehouse_stock_map[warehouse_name] += stock_count
+                            else:
+                                warehouse_stock_map[warehouse_name] = stock_count
+                    except (ValueError, TypeError):
+                        pass
+        
+        if warehouse_stock_map:
+            # Mağaza stoklarını liste halinde döndür
+            all_warehouse_info = []
+            for warehouse_name, total_stock in warehouse_stock_map.items():
+                all_warehouse_info.append(f"{warehouse_name}: Stokta var")
+            return all_warehouse_info
+        else:
+            return ["Hiçbir mağazada stokta bulunmuyor"]
+        
+    except Exception as e:
+        print(f"Mağaza stok bilgisi çekme hatası: {e}")
+        return None
 
 # Trek bisiklet ürünlerini çekme - DÜZELTİLMİŞ VERSİYON
 try:
@@ -967,14 +1113,11 @@ def process_whatsapp_message_with_memory(user_message, phone_number):
             except Exception as e:
                 logger.error(f"❌ BF Space: Improved search error: {e}")
         
-        # Fallback to Combined API search if improved search didn't work
+        # Fallback to warehouse search if improved search didn't work
         if not product_found_improved:
             # Check if message seems to be asking about products
             product_keywords = ['fiyat', 'kaç', 'stok', 'var mı', 'mevcut', 'bisiklet', 'bike', 
-                              'trek', 'model', 'beden', 'renk', 'mağaza', 'nerede', 'hangi',
-                              'marlin', 'madone', 'fuel', 'domane', 'slash', 'remedy', 'session', 'procaliber',
-                              'roscoe', 'supercommuter', 'allant', 'verve', 'dual sport', 'fx', 'checkpoint',
-                              'émonda', 'speed concept', 'boone', 'crockett', 'stache', 'farley']
+                              'trek', 'model', 'beden', 'renk', 'mağaza', 'nerede', 'hangi']
             
             # Common non-product responses
             non_product_responses = ['süper', 'harika', 'güzel', 'teşekkür', 'tamam', 'olur',
@@ -983,36 +1126,28 @@ def process_whatsapp_message_with_memory(user_message, phone_number):
             is_product_query = False
             lower_message = user_message.lower()
             
-            logger.info(f"🔍 Product query detection for: '{user_message}'")
-            logger.info(f"🔤 Lower message: '{lower_message}'")
-            
             # Check if it's likely a product query
             if any(keyword in lower_message for keyword in product_keywords):
                 is_product_query = True
-                logger.info(f"✅ Product query detected via keywords")
             # Check if it's NOT a simple response
             elif lower_message not in non_product_responses and len(lower_message.split()) > 1:
                 # Multi-word queries might be product searches
                 is_product_query = True
-                logger.info(f"✅ Product query detected via multi-word rule")
             # Single short words are usually not products
             elif len(lower_message.split()) == 1 and len(lower_message) < 6:
                 is_product_query = False
-                logger.info(f"❌ Product query rejected - single short word")
-            
-            logger.info(f"🎯 Final is_product_query: {is_product_query}")
             
             if is_product_query:
-                # SADECE Combined API kullan
-                logger.info("📦 Using Combined API search")
+                # Use GPT-5 warehouse search for product queries
+                logger.info("📦 Using GPT-5 warehouse search")
                 warehouse_result = get_warehouse_stock(user_message)
                 if warehouse_result and warehouse_result != ['Ürün bulunamadı']:
                     warehouse_response = "\n".join(warehouse_result)
                     messages.append({
                         "role": "system",
-                        "content": f"COMBINED API STOK BİLGİSİ:\n{warehouse_response}\n\nBu bilgileri kullanarak kullanıcıya yardımcı ol. Fiyat, stok ve resim bilgilerini AYNEN kullan."
+                        "content": f"MAĞAZA STOK BİLGİSİ:\n{warehouse_response}\n\nBu bilgileri kullanarak kullanıcıya yardımcı ol. Fiyat ve stok bilgilerini AYNEN kullan."
                     })
-                    logger.info(f"✅ Combined API stock info added: {warehouse_response[:200]}...")
+                    logger.info(f"✅ Warehouse stock info added: {warehouse_response[:200]}...")
             else:
                 logger.info(f"🚫 Skipping product search for: '{user_message}'")