Upload 7 files

app.py

@@ -60,7 +60,7 @@ else:
 
 # Mağaza stok bilgilerini çekme fonksiyonu
 def get_warehouse_stock(product_name):
-    """B2B API'den mağaza stok bilgilerini çek"""
+    """B2B API'den mağaza stok bilgilerini çek - İyileştirilmiş versiyon"""
     try:
         import re
         warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml.php'
@@ -71,71 +71,134 @@ def get_warehouse_stock(product_name):
             
         root = ET.fromstring(response.content)
         
-        # Ürünü ara
-        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.lower().strip()
-                search_name = product_name.lower().strip()
-                
-                # Fuzzy matching - normalize both names
-                # Turkish character normalization
-                turkish_map = {'ı': 'i', 'ğ': 'g', 'ü': 'u', 'ş': 's', 'ö': 'o', 'ç': 'c', 'İ': 'i', 'I': 'i'}
+        # 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 = []
+        
+        # Check if this is a size/color specific query (like "M Turuncu")
+        is_size_color_query = (len(search_words) <= 3 and 
+                               any(word in ['s', 'm', 'l', 'xl', 'xs', 'small', 'medium', 'large', 
+                                           'turuncu', 'siyah', 'beyaz', 'mavi', 'kirmizi', 'yesil', 
+                                           'orange', 'black', 'white', 'blue', 'red', 'green'] 
+                                   for word in search_words))
+        
+        # İ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('Variant')
                 
-                def normalize_turkish(text):
-                    # First normalize Unicode (İ → i̇ → i)
-                    import unicodedata
-                    text = unicodedata.normalize('NFD', text)
-                    text = ''.join(char for char in text if unicodedata.category(char) != 'Mn')  # Remove diacritics
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
                     
-                    # Then Turkish character mapping
-                    for tr_char, en_char in turkish_map.items():
-                        text = text.replace(tr_char, en_char)
-                    return text
-                
-                # Remove common variations for better matching
-                normalized_search = normalize_turkish(search_name.replace('(2026)', '').replace('(2025)', '').replace(' - ', ' ').strip())
-                normalized_xml = normalize_turkish(xml_product_name.replace('(2026)', '').replace('(2025)', '').replace(' - ', ' ').strip())
-                
-                # Extract key product identifiers (first 2-3 meaningful words)
-                search_words = normalized_search.split()
-                xml_words = normalized_xml.split()
-                
-                # Calculate similarity score based on common words
-                common_words = set(search_words) & set(xml_words)
-                
-                # Check if we have enough common words (at least 2 key words match)
-                # OR if the first two words match (brand + model number usually)
-                search_key = ' '.join(search_words[:2]) if len(search_words) >= 2 else normalized_search
-                xml_key = ' '.join(xml_words[:2]) if len(xml_words) >= 2 else normalized_xml
-                
-                # Match if:
-                # 1. First two words are the same (e.g., "marlin 6", "checkpoint sl")
-                # 2. OR we have at least 2 common words
-                # 3. OR one contains the other (for partial matches)
-                if (search_key == xml_key or
-                    len(common_words) >= 2 or
-                    search_key in normalized_xml or
-                    xml_key in normalized_search):
-                    warehouses = product.find('Warehouses')
-                    if warehouses is not None:
-                        warehouse_info = []
-                        for warehouse in warehouses.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:
-                                        warehouse_info.append(f"{warehouse_name}: {stock_count} adet")
-                                except (ValueError, TypeError):
-                                    pass
+                    # Variant field check
+                    if variant_elem is not None and variant_elem.text:
+                        variant_text = normalize_turkish(variant_elem.text.lower().replace('-', ' '))
                         
-                        return warehouse_info if warehouse_info else ["Hiçbir mağazada stokta bulunmuyor"]
-        
-        return ["Ürün bulunamadı"]
+                        # Check if all search words are in variant field
+                        if all(word in variant_text for word in search_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:
+            warehouses = product.find('Warehouses')
+            if warehouses is not None:
+                for warehouse in warehouses.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}: {total_stock} adet")
+            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}")
@@ -752,8 +815,6 @@ def process_whatsapp_message_with_memory(user_message, phone_number):
                 if product_result['is_product_query'] and product_result['response']:
                     # Check if user is asking about specific warehouse/store location
                     if any(keyword in user_message.lower() for keyword in ['mağaza', 'mağazada', 'nerede', 'hangi mağaza', 'şube']):
-                        print(f"DEBUG: Mağaza sorusu algılandı: {user_message}")
-                        
                         # First, always search for products using improved search
                         # This will find products even with partial/typo names
                         warehouse_info_parts = []
@@ -766,7 +827,6 @@ def process_whatsapp_message_with_memory(user_message, phone_number):
                             product_names = re.findall(r'\*([^*]+)\*', product_result['response'])
                             
                             if product_names:
-                                print(f"DEBUG: Response'tan {len(product_names)} ürün adı çıkarıldı")
                                 for product_name in product_names[:3]:  # Max 3 products
                                     # Clean up the product name
                                     product_name = product_name.strip()
@@ -779,9 +839,7 @@ def process_whatsapp_message_with_memory(user_message, phone_number):
                                     if product_name in ['Stokta mevcut', 'Stokta yok', 'Fiyat:', 'Kampanya:', 'İndirim:', 'Birden fazla ürün buldum:']:
                                         continue
                                     
-                                    print(f"DEBUG: Mağaza stogu kontrol ediliyor: {product_name}")
                                     warehouse_stock = get_warehouse_stock(product_name)
-                                    print(f"DEBUG: Mağaza stok sonucu: {warehouse_stock}")
                                     
                                     if warehouse_stock and warehouse_stock != ['Ürün bulunamadı'] and warehouse_stock != ['Hiçbir mağazada stokta bulunmuyor']:
                                         warehouse_info_parts.append(f"{product_name} mağaza stogu:")
@@ -791,12 +849,9 @@ def process_whatsapp_message_with_memory(user_message, phone_number):
                         
                         # If still no warehouse info, use products_found as backup
                         if not warehouse_info_parts and product_result['products_found']:
-                            print(f"DEBUG: Response'tan bulunamadı, products_found kullanılıyor")
                             for product in product_result['products_found'][:2]:
                                 product_name = product[2]  # Full product name
-                                print(f"DEBUG: Mağaza stogu kontrol ediliyor: {product_name}")
                                 warehouse_stock = get_warehouse_stock(product_name)
-                                print(f"DEBUG: Mağaza stok sonucu: {warehouse_stock}")
                                 
                                 if warehouse_stock and warehouse_stock != ['Ürün bulunamadı'] and warehouse_stock != ['Hiçbir mağazada stokta bulunmuyor']:
                                     warehouse_info_parts.append(f"{product_name} mağaza stogu:")
@@ -806,15 +861,12 @@ def process_whatsapp_message_with_memory(user_message, phone_number):
                         
                         if warehouse_info_parts:
                             warehouse_response = "\n".join(warehouse_info_parts)
-                            print(f"DEBUG: ChatGPT'ye gönderilecek mağaza bilgisi: {warehouse_response}")
                             messages.append({
                                 "role": "system",
                                 "content": f"MAĞAZA STOK BİLGİSİ (BF Space):\n{warehouse_response}\n\nSADECE bu bilgileri kullanarak kullanıcıya yardımcı ol."
                             })
                             product_found_improved = True
                             logger.info("✅ BF Space: Warehouse stock info used")
-                        else:
-                            print("DEBUG: Hiç mağaza bilgisi bulunamadı")
                     
                     if not product_found_improved:
                         # Use improved search response directly
@@ -824,7 +876,6 @@ def process_whatsapp_message_with_memory(user_message, phone_number):
                         })
                         product_found_improved = True
                         logger.info("✅ BF Space: Improved product search used")
-                        print(f"DEBUG: Improved search found response: {product_result['response'][:100]}...")
             except Exception as e:
                 logger.error(f"❌ BF Space: Improved search error: {e}")
         

search_marlin_products.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+import requests
+import xml.etree.ElementTree as ET
+
+def search_marlin_products():
+    """B2B API'den MARLIN ürünlerini listele"""
+    try:
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml.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
+        
+        marlin_products = []
+        
+        # MARLIN içeren tüm ürünleri bul
+        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())
+                
+                if 'marlin' in normalized_xml:
+                    # Stok durumunu kontrol et
+                    has_stock = False
+                    stock_info = []
+                    
+                    warehouses = product.find('Warehouses')
+                    if warehouses is not None:
+                        for warehouse in warehouses.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:
+                                        stock_info.append(f"{warehouse_name}: {stock_count}")
+                                        has_stock = True
+                                except (ValueError, TypeError):
+                                    pass
+                    
+                    marlin_products.append({
+                        'name': xml_product_name,
+                        'has_stock': has_stock,
+                        'stock_info': stock_info
+                    })
+        
+        return marlin_products
+        
+    except Exception as e:
+        print(f"Arama hatası: {e}")
+        return None
+
+def search_turuncu_products():
+    """B2B API'den TURUNCU içeren ürünleri listele"""
+    try:
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml.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
+        
+        turuncu_products = []
+        
+        # TURUNCU içeren tüm ürünleri bul
+        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())
+                
+                if 'turuncu' in normalized_xml:
+                    # Stok durumunu kontrol et
+                    has_stock = False
+                    stock_info = []
+                    
+                    warehouses = product.find('Warehouses')
+                    if warehouses is not None:
+                        for warehouse in warehouses.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:
+                                        stock_info.append(f"{warehouse_name}: {stock_count}")
+                                        has_stock = True
+                                except (ValueError, TypeError):
+                                    pass
+                    
+                    turuncu_products.append({
+                        'name': xml_product_name,
+                        'has_stock': has_stock,
+                        'stock_info': stock_info
+                    })
+        
+        return turuncu_products
+        
+    except Exception as e:
+        print(f"Arama hatası: {e}")
+        return None
+
+if __name__ == "__main__":
+    print("=== MARLIN ÜRÜNLERİ ===")
+    marlin_products = search_marlin_products()
+    if marlin_products:
+        print(f"Toplam {len(marlin_products)} MARLIN ürünü bulundu:")
+        for i, product in enumerate(marlin_products, 1):
+            print(f"{i:2}. {product['name']}")
+            if product['has_stock']:
+                print(f"    STOKTA: {', '.join(product['stock_info'])}")
+            else:
+                print(f"    STOKTA DEĞİL")
+            print()
+    
+    print("\n" + "="*50)
+    print("=== TURUNCU ÜRÜNLERİ ===")
+    turuncu_products = search_turuncu_products()
+    if turuncu_products:
+        print(f"Toplam {len(turuncu_products)} TURUNCU ürünü bulundu:")
+        for i, product in enumerate(turuncu_products, 1):
+            print(f"{i:2}. {product['name']}")
+            if product['has_stock']:
+                print(f"    STOKTA: {', '.join(product['stock_info'])}")
+            else:
+                print(f"    STOKTA DEĞİL")
+            print()

test_final.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# Final test with updated get_warehouse_stock function from app.py
+
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Import the updated function from app.py
+from app import get_warehouse_stock
+
+if __name__ == "__main__":
+    test_cases = [
+        "M Turuncu",
+        "Marlin 6 M Turuncu",
+        "L Siyah",
+        "S Beyaz"
+    ]
+    
+    for test_case in test_cases:
+        print(f"\n=== Testing: {test_case} ===")
+        try:
+            result = get_warehouse_stock(test_case)
+            if result:
+                print("Sonuç:")
+                for item in result:
+                    print(f"  • {item}")
+            else:
+                print("Sonuç bulunamadı")
+        except Exception as e:
+            print(f"Hata: {e}")
+        print("-" * 50)

test_m_turuncu.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+import requests
+import xml.etree.ElementTree as ET
+
+def get_warehouse_stock(product_name):
+    """B2B API'den mağaza stok bilgilerini çek - İyileştirilmiş versiyon"""
+    try:
+        import re
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml.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()
+        
+        print(f"DEBUG: Aranan ürün: '{product_name}' -> normalize: '{search_name}' -> kelimeler: {search_words}")
+        
+        best_matches = []
+        exact_matches = []
+        color_size_matches = []  # For size/color specific searches
+        
+        # Check if this is a size/color query (like "M Turuncu")
+        is_size_color_query = len(search_words) <= 2 and any(word in ['s', 'm', 'l', 'xl', 'xs', 'small', 'medium', 'large', 'turuncu', 'siyah', 'beyaz', 'mavi', 'kirmizi', 'yesil'] for word in search_words)
+        
+        if is_size_color_query:
+            print(f"DEBUG: Beden/renk araması algılandı: {search_words}")
+            # For size/color queries, look for products containing these terms
+            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())
+                    
+                    # Check if all search words appear in the product name
+                    if all(word in normalized_xml for word in search_words):
+                        color_size_matches.append((product, xml_product_name, normalized_xml))
+                        print(f"DEBUG: BEDEN/RENK EŞLEŞME: '{xml_product_name}'")
+            
+            candidates = color_size_matches
+        else:
+            # Normal product search logic
+            # İlk geçiş: Tam eşleşmeleri bul
+            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))
+                            print(f"DEBUG: TAM EŞLEŞME: '{xml_product_name}'")
+            
+            # Eğer tam eşleşme varsa, sadece onları kullan
+            candidates = exact_matches if exact_matches else []
+            
+            # Eğer tam eşleşme yoksa, fuzzy matching yap
+            if not candidates:
+                print("DEBUG: Tam eşleşme yok, fuzzy matching yapılıyor...")
+                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)))
+                            print(f"DEBUG: FUZZY EŞLEŞME: '{xml_product_name}' (ortak: {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]
+        
+        print(f"DEBUG: Toplam {len(candidates)} aday ürün bulundu")
+        
+        # Stok bilgilerini topla ve tekrarları önle
+        warehouse_stock_map = {}  # warehouse_name -> total_stock
+        
+        for product, xml_name, _ in candidates:
+            warehouses = product.find('Warehouses')
+            if warehouses is not None:
+                for warehouse in warehouses.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
+                                print(f"DEBUG: STOK BULUNDU - {warehouse_name}: {stock_count} adet ({xml_name})")
+                        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}: {total_stock} adet")
+            return all_warehouse_info
+        else:
+            print("DEBUG: Hiçbir mağazada stok bulunamadı")
+            return ["Hiçbir mağazada stokta bulunmuyor"]
+        
+    except Exception as e:
+        print(f"Mağaza stok bilgisi çekme hatası: {e}")
+        return None
+
+if __name__ == "__main__":
+    # Test the function with different M Turuncu variations
+    test_cases = [
+        "M Turuncu",
+        "m turuncu", 
+        "M TURUNCU",
+        "Medium Turuncu",
+        "Marlin 6 M Turuncu"
+    ]
+    
+    for test_case in test_cases:
+        print(f"=== Testing: {test_case} ===")
+        result = get_warehouse_stock(test_case)
+        print(f"Result: {result}")
+        print()

test_updated_warehouse.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+import requests
+import xml.etree.ElementTree as ET
+
+def get_warehouse_stock(product_name):
+    """B2B API'den mağaza stok bilgilerini çek - Final Updated Version"""
+    try:
+        import re
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml.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 = []
+        
+        # Check if this is a size/color specific query (like "M Turuncu")
+        is_size_color_query = (len(search_words) <= 3 and 
+                               any(word in ['s', 'm', 'l', 'xl', 'xs', 'small', 'medium', 'large', 
+                                           'turuncu', 'siyah', 'beyaz', 'mavi', 'kirmizi', 'yesil', 
+                                           'orange', 'black', 'white', 'blue', 'red', 'green'] 
+                                   for word in search_words))
+        
+        # İ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('Variant')
+                
+                if product_name_elem is not None and product_name_elem.text:
+                    xml_product_name = product_name_elem.text.strip()
+                    
+                    # 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 search words are in variant field
+                        if all(word in variant_text for word in search_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:
+            warehouses = product.find('Warehouses')
+            if warehouses is not None:
+                for warehouse in warehouses.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}: {total_stock} adet")
+            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
+
+if __name__ == "__main__":
+    test_cases = [
+        "M Turuncu",
+        "Marlin 6 M Turuncu",
+        "L Siyah"
+    ]
+    
+    for test_case in test_cases:
+        print(f"\n=== Testing: {test_case} ===")
+        result = get_warehouse_stock(test_case)
+        if result:
+            print("Sonuç:")
+            for item in result:
+                print(f"  • {item}")
+        else:
+            print("Sonuç bulunamadı")
+        print("-" * 50)

test_variant.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+import requests
+import xml.etree.ElementTree as ET
+
+def test_variant_search(product_name):
+    """B2B API'den variant field'ı kontrol et"""
+    try:
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml.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_words = search_name.split()
+        
+        print(f"DEBUG: Aranan: '{product_name}' -> normalize: '{search_name}' -> kelimeler: {search_words}")
+        
+        variant_matches = []
+        
+        # Check variant field for M-TURUNCU like patterns
+        for product in root.findall('Product'):
+            product_name_elem = product.find('ProductName')
+            variant_elem = product.find('Variant')
+            
+            if product_name_elem is not None and product_name_elem.text:
+                xml_product_name = product_name_elem.text.strip()
+                
+                # Check variant field
+                if variant_elem is not None and variant_elem.text:
+                    variant_text = variant_elem.text.strip()
+                    variant_normalized = normalize_turkish(variant_text.lower().replace('-', ' '))
+                    
+                    # Check if all search words are in variant field
+                    if all(word in variant_normalized for word in search_words):
+                        # Check for stock
+                        warehouses = product.find('Warehouses')
+                        stock_info = []
+                        if warehouses is not None:
+                            for warehouse in warehouses.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:
+                                            stock_info.append(f"{warehouse_name}: {stock_count}")
+                                    except (ValueError, TypeError):
+                                        pass
+                        
+                        variant_matches.append({
+                            'product_name': xml_product_name,
+                            'variant': variant_text,
+                            'variant_normalized': variant_normalized,
+                            'stock_info': stock_info
+                        })
+                        
+                        print(f"DEBUG: VARIANT MATCH - {xml_product_name}")
+                        print(f"       Variant: {variant_text} -> {variant_normalized}")
+                        if stock_info:
+                            print(f"       Stok: {', '.join(stock_info)}")
+                        else:
+                            print(f"       Stokta yok")
+        
+        return variant_matches
+        
+    except Exception as e:
+        print(f"Hata: {e}")
+        return None
+
+if __name__ == "__main__":
+    # Test different cases
+    test_cases = [
+        "M Turuncu",
+        "m turuncu", 
+        "L Siyah",
+        "S Beyaz"
+    ]
+    
+    for test_case in test_cases:
+        print(f"\n=== Testing: {test_case} ===")
+        result = test_variant_search(test_case)
+        
+        if result:
+            print(f"Toplam {len(result)} variant match bulundu:")
+            for i, match in enumerate(result, 1):
+                print(f"{i}. {match['product_name']} - {match['variant']}")
+                if match['stock_info']:
+                    print(f"   Stokta: {', '.join(match['stock_info'])}")
+                else:
+                    print(f"   Stokta değil")
+        else:
+            print("Variant match bulunamadı")
+        print("-" * 50)

test_warehouse.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+import requests
+import xml.etree.ElementTree as ET
+
+def get_warehouse_stock(product_name):
+    """B2B API'den mağaza stok bilgilerini çek - İyileştirilmiş versiyon"""
+    try:
+        import re
+        warehouse_url = 'https://video.trek-turkey.com/bizimhesap-warehouse-xml.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()
+        
+        print(f"DEBUG: Aranan ürün: '{product_name}' -> normalize: '{search_name}' -> kelimeler: {search_words}")
+        
+        best_matches = []
+        exact_matches = []
+        
+        # İlk geçiş: Tam eşleşmeleri bul
+        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))
+                        print(f"DEBUG: TAM EŞLEŞME bulundu: '{xml_product_name}'")
+        
+        # Eğer tam eşleşme varsa, sadece onları kullan
+        candidates = exact_matches if exact_matches else []
+        
+        # Eğer tam eşleşme yoksa, fuzzy matching yap
+        if not candidates:
+            print("DEBUG: Tam eşleşme yok, fuzzy matching yapılıyor...")
+            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)))
+                        print(f"DEBUG: FUZZY EŞLEŞME: '{xml_product_name}' (ortak: {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]
+        
+        print(f"DEBUG: Toplam {len(candidates)} aday ürün bulundu")
+        
+        # Stok bilgilerini topla ve tekrarları önle
+        warehouse_stock_map = {}  # warehouse_name -> total_stock
+        
+        for product, xml_name, _ in candidates:
+            warehouses = product.find('Warehouses')
+            if warehouses is not None:
+                for warehouse in warehouses.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
+                                print(f"DEBUG: STOK BULUNDU - {warehouse_name}: {stock_count} adet ({xml_name})")
+                        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}: {total_stock} adet")
+            return all_warehouse_info
+        else:
+            print("DEBUG: Hiçbir mağazada stok bulunamadı")
+            return ["Hiçbir mağazada stokta bulunmuyor"]
+        
+    except Exception as e:
+        print(f"Mağaza stok bilgisi çekme hatası: {e}")
+        return None
+
+if __name__ == "__main__":
+    # Test the function with different inputs
+    test_cases = [
+        "MARLIN 6 (2026)",
+        "Marlin 6"
+    ]
+    
+    for test_case in test_cases:
+        print(f"=== Testing: {test_case} ===")
+        result = get_warehouse_stock(test_case)
+        print(f"Result: {result}")
+        print()