#!/usr/bin/env python3
"""
Amazon Bot - Otomatik Kurulum Scripti
Bu script Amazon Bot'u sıfırdan kurmak için gereken tüm işlemleri otomatik yapar.
"""
import os
import sys
import subprocess
import shutil
import json
import platform
from pathlib import Path
from typing import Dict, List, Optional, Tuple
# Renk kodları
class Colors:
    RED = '\033[91m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    BLUE = '\033[94m'
    MAGENTA = '\033[95m'
    CYAN = '\033[96m'
    WHITE = '\033[97m'
    BOLD = '\033[1m'
    END = '\033[0m'
def print_colored(message: str, color: str = Colors.WHITE) -> None:
    """Renkli mesaj yazdır"""
    print(f"{color}{message}{Colors.END}")
def print_step(step_num: int, message: str) -> None:
    """Adım numarası ile mesaj yazdır"""
    print_colored(f"\n{step_num}. {message}", Colors.CYAN + Colors.BOLD)
def print_success(message: str) -> None:
    """Başarı mesajı yazdır"""
    print_colored(f"✅ {message}", Colors.GREEN)
def print_warning(message: str) -> None:
    """Uyarı mesajı yazdır"""
    print_colored(f"⚠️ {message}", Colors.YELLOW)
def print_error(message: str) -> None:
    """Hata mesajı yazdır"""
    print_colored(f"❌ {message}", Colors.RED)
def print_info(message: str) -> None:
    """Bilgi mesajı yazdır"""
    print_colored(f"ℹ️ {message}", Colors.BLUE)
def run_command(command: str, check: bool = True, shell: bool = True) -> Tuple[bool, str]:
    """Komut çalıştır ve sonucu döndür"""
    try:
        result = subprocess.run(
            command,
            shell=shell,
            capture_output=True,
            text=True,
            check=check
        )
        return True, result.stdout.strip()
    except subprocess.CalledProcessError as e:
        return False, e.stderr.strip()
def check_python_version() -> bool:
    """Python versiyonunu kontrol et"""
    print_step(1, "Python versiyonu kontrol ediliyor...")
    
    version = sys.version_info
    if version.major == 3 and version.minor >= 8:
        print_success(f"Python {version.major}.{version.minor}.{version.micro} uygun")
        return True
    else:
        print_error(f"Python 3.8+ gerekli. Mevcut: {version.major}.{version.minor}.{version.micro}")
        print_info("Python'u https://python.org adresinden indirin")
        return False
def check_git() -> bool:
    """Git kurulumunu kontrol et"""
    print_step(2, "Git kurulumu kontrol ediliyor...")
    
    success, output = run_command("git --version", check=False)
    if success:
        print_success(f"Git mevcut: {output}")
        return True
    else:
        print_warning("Git bulunamadı")
        print_info("Git'i https://git-scm.com adresinden indirin")
        return False
def create_virtual_environment() -> bool:
    """Sanal ortam oluştur"""
    print_step(3, "Sanal ortam oluşturuluyor...")
    
    venv_path = Path("venv")
    if venv_path.exists():
        print_warning("Sanal ortam zaten mevcut")
        return True
    
    success, output = run_command(f"{sys.executable} -m venv venv")
    if success:
        print_success("Sanal ortam oluşturuldu")
        return True
    else:
        print_error(f"Sanal ortam oluşturulamadı: {output}")
        return False
def get_pip_command() -> str:
    """Platform'a göre pip komutu döndür"""
    system = platform.system()
    if system == "Windows":
        return "venv\\Scripts\\pip"
    else:
        return "venv/bin/pip"
def get_python_command() -> str:
    """Platform'a göre python komutu döndür"""
    system = platform.system()
    if system == "Windows":
        return "venv\\Scripts\\python"
    else:
        return "venv/bin/python"
def install_requirements() -> bool:
    """Gereksinimleri yükle"""
    print_step(4, "Python paketleri yükleniyor...")
    
    # requirements.txt dosyası var mı kontrol et
    if not Path("requirements.txt").exists():
        print_error("requirements.txt dosyası bulunamadı")
        return False
    
    pip_cmd = get_pip_command()
    
    # Pip'i güncelle
    print_info("pip güncelleniyor...")
    success, output = run_command(f"{pip_cmd} install --upgrade pip")
    if not success:
        print_warning(f"pip güncellemesi başarısız: {output}")
    
    # Paketleri yükle
    print_info("Paketler yükleniyor...")
    success, output = run_command(f"{pip_cmd} install -r requirements.txt")
    if success:
        print_success("Python paketleri yüklendi")
        return True
    else:
        print_error(f"Paket yükleme başarısız: {output}")
        return False
def install_playwright() -> bool:
    """Playwright browser'ını yükle"""
    print_step(5, "Playwright browser yükleniyor...")
    
    python_cmd = get_python_command()
    
    # Playwright'i yükle
    success, output = run_command(f"{python_cmd} -m playwright install chromium")
    if success:
        print_success("Playwright chromium yüklendi")
        return True
    else:
        print_error(f"Playwright yükleme başarısız: {output}")
        return False
def create_env_file() -> bool:
    """Çevre değişkenleri dosyası oluştur"""
    print_step(6, ".env dosyası oluşturuluyor...")
    
    # .env zaten varsa yedekle
    env_path = Path(".env")
    if env_path.exists():
        backup_path = Path(".env.backup")
        shutil.copy2(env_path, backup_path)
        print_warning(f".env dosyası {backup_path} olarak yedeklendi")
    
    # .env.example'dan kopyala
    example_path = Path(".env.example")
    if not example_path.exists():
        print_error(".env.example dosyası bulunamadı")
        return False
    
    shutil.copy2(example_path, env_path)
    print_success(".env dosyası oluşturuldu")
    return True
def collect_user_input() -> Dict[str, str]:
    """Kullanıcıdan konfigürasyon bilgilerini al"""
    print_step(7, "Konfigürasyon bilgileri alınıyor...")
    
    config = {}
    
    print_colored("\n📧 Amazon Hesap Bilgileri", Colors.YELLOW + Colors.BOLD)
    config['AMAZON_EMAIL'] = input("Amazon e-posta adresinizi girin: ").strip()
    config['AMAZON_PASSWORD'] = input("Amazon şifrenizi girin: ").strip()
    
    print_colored("\n🤖 Bot Ayarları", Colors.YELLOW + Colors.BOLD)
    dry_run = input("Test modu (DRY_RUN) aktif olsun mu? [Y/n]: ").strip().lower()
    config['DRY_RUN'] = "False" if dry_run == 'n' else "True"
    
    headless = input("Tarayıcı gizli modda (headless) çalışsın mı? [y/N]: ").strip().lower()
    config['HEADLESS'] = "True" if headless == 'y' else "False"
    
    loop_wait = input("Döngü aralığı (dakika) [2]: ").strip()
    config['LOOP_WAIT_MINUTES'] = loop_wait if loop_wait else "2"
    
    print_colored("\n📧 Gmail API Ayarları (2FA İçin)", Colors.YELLOW + Colors.BOLD)
    print_info("2FA (İki Faktörlü Kimlik Doğrulama) olan hesaplar için Gmail API gereklidir")
    print_info("Gmail API, Amazon'dan gelen doğrulama kodlarını otomatik okur")
    
    gmail_setup = input("Gmail API kurmak ister misiniz? [Y/n]: ").strip().lower()
    
    if gmail_setup != 'n':
        print_info("Gmail API kurulumu için:")
        print_info("1. Google Cloud Console'a gidin (console.cloud.google.com)")
        print_info("2. Yeni proje oluşturun")
        print_info("3. Gmail API'yi aktifleştirin")
        print_info("4. OAuth 2.0 credentials oluşturun")
        print_info("5. credentials.json dosyasını indirin")
        print_info("6. Dosyayı proje klasörüne koyun")
        
        config['GMAIL_ENABLED'] = "True"
        config['GMAIL_2FA_ENABLED'] = "True"
        
        print_warning("Gmail API kurulumu manuel olarak tamamlanmalı!")
        print_info("Detaylar için INSTALLATION.md dosyasını kontrol edin")
    else:
        config['GMAIL_ENABLED'] = "False"
        config['GMAIL_2FA_ENABLED'] = "False"
    
    print_colored("\n📱 Telegram Ayarları (Opsiyonel)", Colors.YELLOW + Colors.BOLD)
    telegram_setup = input("Telegram bildirimi kurmak ister misiniz? [y/N]: ").strip().lower()
    
    if telegram_setup == 'y':
        print_info("Telegram bot kurulumu için:")
        print_info("1. @BotFather'a gidin")
        print_info("2. /newbot komutu ile bot oluşturun")
        print_info("3. Token'ı kopyalayın")
        
        config['TELEGRAM_BOT_TOKEN'] = input("Telegram Bot Token: ").strip()
        
        print_info("4. Bot'a bir mesaj gönderin")
        print_info("5. https://api.telegram.org/bot<TOKEN>/getUpdates adresini ziyaret edin")
        print_info("6. 'chat':{'id':123456} değerini bulun")
        
        config['TELEGRAM_CHAT_ID'] = input("Telegram Chat ID: ").strip()
        config['ENABLE_NOTIFICATIONS'] = "True"
    else:
        config['TELEGRAM_BOT_TOKEN'] = ""
        config['TELEGRAM_CHAT_ID'] = ""
        config['ENABLE_NOTIFICATIONS'] = "False"
    
    return config
def update_env_file(config: Dict[str, str]) -> bool:
    """Çevre değişkenleri dosyasını güncelle"""
    print_step(8, ".env dosyası güncelleniyor...")
    
    env_path = Path(".env")
    if not env_path.exists():
        print_error(".env dosyası bulunamadı")
        return False
    
    # Mevcut .env dosyasını oku
    with open(env_path, 'r', encoding='utf-8') as f:
        lines = f.readlines()
    
    # Yeni değerleri uygula
    updated_lines = []
    for line in lines:
        line = line.strip()
        if '=' in line and not line.startswith('#'):
            key = line.split('=')[0]
            if key in config:
                value = config[key]
                # String değerleri tırnak içine al
                if key in ['AMAZON_EMAIL', 'AMAZON_PASSWORD', 'TELEGRAM_BOT_TOKEN', 'TELEGRAM_CHAT_ID']:
                    updated_lines.append(f'{key}="{value}"\n')
                else:
                    updated_lines.append(f'{key}={value}\n')
            else:
                updated_lines.append(line + '\n')
        else:
            updated_lines.append(line + '\n')
    
    # Güncellenmiş dosyayı yaz
    with open(env_path, 'w', encoding='utf-8') as f:
        f.writelines(updated_lines)
    
    print_success(".env dosyası güncellendi")
    return True
def setup_gmail_api() -> bool:
    """Gmail API kurulumu kontrol et"""
    print_step(9, "Gmail API kurulumu kontrol ediliyor...")
    
    # credentials.json dosyası var mı kontrol et
    credentials_path = Path("credentials.json")
    if credentials_path.exists():
        print_success("credentials.json bulundu")
        
        # setup_gmail_api.py çalıştırma seçeneği sun
        python_cmd = get_python_command()
        run_setup = input("Gmail API authentication'u şimdi çalıştırmak ister misiniz? [y/N]: ").strip().lower()
        
        if run_setup == 'y':
            print_info("Gmail API authentication çalıştırılıyor...")
            success, output = run_command(f"{python_cmd} setup_gmail_api.py", check=False)
            if success:
                print_success("Gmail API authentication tamamlandı")
                return True
            else:
                print_warning(f"Gmail API authentication başarısız: {output}")
                print_info("Daha sonra manuel olarak 'python setup_gmail_api.py' çalıştırın")
                return True
        else:
            print_info("Gmail API authentication'u daha sonra manuel olarak çalıştırın")
            print_info("Komut: python setup_gmail_api.py")
            return True
    else:
        print_warning("credentials.json dosyası bulunamadı")
        print_info("Gmail API kurulumu için:")
        print_info("1. Google Cloud Console'a gidin")
        print_info("2. Gmail API'yi aktifleştirin")
        print_info("3. OAuth 2.0 credentials oluşturun")
        print_info("4. credentials.json dosyasını indirin ve buraya koyun")
        print_info("5. 'python setup_gmail_api.py' komutunu çalıştırın")
        return True
def setup_products_json() -> bool:
    """Ürün listesi dosyasını ayarla"""
    print_step(10, "Ürün listesi ayarlanıyor...")
    
    products_path = Path("app/products.json")
    if products_path.exists():
        print_warning("products.json zaten mevcut, atlanıyor")
        return True
    
    # Varsayılan ürün listesi oluştur
    default_products = [
        {
            "asin": "B0F3JWFL56",
            "target_price": 299.99,
            "name": "Xiaomi TV Box S (Test Ürünü)"
        }
    ]
    
    with open(products_path, 'w', encoding='utf-8') as f:
        json.dump(default_products, f, indent=2, ensure_ascii=False)
    
    print_success("products.json oluşturuldu")
    print_info("Ürün listesini düzenlemek için app/products.json dosyasını açın")
    return True
def test_installation() -> bool:
    """Kurulumu test et"""
    print_step(11, "Kurulum test ediliyor...")
    
    python_cmd = get_python_command()
    
    # Basit import testi
    test_script = '''
import sys
sys.path.append('.')
try:
    from app import config
    print("✅ Config import edildi")
    
    from app.utils.logger import get_logger
    print("✅ Logger import edildi")
    
    from app.tasks.price_checker import check_product_price
    print("✅ Price checker import edildi")
    
    from app.tasks.purchase import purchase_product_with_buynow
    print("✅ Purchase import edildi")
    
    # Gmail API test (varsa)
    try:
        from app.utils.gmail_reader import GmailReader
        print("✅ Gmail Reader import edildi")
        
        # Gmail API bağlantısı test et
        gmail = GmailReader()
        if gmail.is_connected():
            print("✅ Gmail API bağlantısı aktif")
        else:
            print("⚠️ Gmail API bağlantısı yok (normal, credentials gerekli)")
    except Exception as e:
        print(f"ℹ️ Gmail API test atlandi: {e}")
    
    print("🎉 Tüm modüller başarıyla import edildi!")
    
except Exception as e:
    print(f"❌ Import hatası: {e}")
    sys.exit(1)
'''
    
    success, output = run_command(f'{python_cmd} -c "{test_script}"')
    if success:
        print_success("Import testleri başarılı")
        print_colored(output, Colors.GREEN)
        return True
    else:
        print_error(f"Import testleri başarısız: {output}")
        return False
def create_run_scripts() -> bool:
    """Çalıştırma scriptleri oluştur"""
    print_step(12, "Çalıştırma scriptleri oluşturuluyor...")
    
    system = platform.system()
    python_cmd = get_python_command()
    
    if system == "Windows":
        # Windows batch dosyası
        run_script = f'''@echo off
echo Amazon Bot başlatılıyor...
{python_cmd} -m app.main
pause
'''
        with open("run_bot.bat", 'w', encoding='utf-8') as f:
            f.write(run_script)
        
        # Test scripti
        test_script = f'''@echo off
echo Amazon Bot test ediliyor...
{python_cmd} test_simple.py
pause
'''
        with open("test_bot.bat", 'w', encoding='utf-8') as f:
            f.write(test_script)
        
        print_success("Windows scriptleri oluşturuldu: run_bot.bat, test_bot.bat")
    
    else:
        # Linux/macOS bash dosyası
        run_script = f'''#!/bin/bash
echo "Amazon Bot başlatılıyor..."
{python_cmd} -m app.main
'''
        with open("run_bot.sh", 'w', encoding='utf-8') as f:
            f.write(run_script)
        os.chmod("run_bot.sh", 0o755)
        
        # Test scripti
        test_script = f'''#!/bin/bash
echo "Amazon Bot test ediliyor..."
{python_cmd} test_simple.py
'''
        with open("test_bot.sh", 'w', encoding='utf-8') as f:
            f.write(test_script)
        os.chmod("test_bot.sh", 0o755)
        
        print_success("Linux/macOS scriptleri oluşturuldu: run_bot.sh, test_bot.sh")
    
    return True
def print_final_instructions() -> None:
    """Son talimatları yazdır"""
    print_colored("\n" + "="*60, Colors.GREEN + Colors.BOLD)
    print_colored("🎉 AMAZON BOT KURULUMU TAMAMLANDI!", Colors.GREEN + Colors.BOLD)
    print_colored("="*60, Colors.GREEN + Colors.BOLD)
    
    print_colored("\n📋 Sonraki Adımlar:", Colors.YELLOW + Colors.BOLD)
    
    print_colored("1. Konfigürasyonu Kontrol Edin:", Colors.CYAN)
    print_info("   - .env dosyasını açın ve ayarları kontrol edin")
    print_info("   - app/products.json dosyasını düzenleyin")
    
    print_colored("2. İlk Test Yapın:", Colors.CYAN)
    system = platform.system()
    if system == "Windows":
        print_info("   - test_bot.bat dosyasını çalıştırın")
        print_info("   - Veya: venv\\Scripts\\python test_simple.py")
    else:
        print_info("   - ./test_bot.sh dosyasını çalıştırın")
        print_info("   - Veya: venv/bin/python test_simple.py")
    
    print_colored("3. Gmail API Kurulumu (2FA İçin):", Colors.CYAN)
    if system == "Windows":
        print_info("   - venv\\Scripts\\python setup_gmail_api.py")
    else:
        print_info("   - venv/bin/python setup_gmail_api.py")
    print_info("   - credentials.json dosyasını indirin ve buraya koyun")
    print_info("   - Detaylar: INSTALLATION.md -> Gmail API Kurulumu")
    
    print_colored("4. Login Test Yapın:", Colors.CYAN)
    if system == "Windows":
        print_info("   - venv\\Scripts\\python debug_login_flow.py")
    else:
        print_info("   - venv/bin/python debug_login_flow.py")
    
    print_colored("5. Bot'u Başlatın (Test Modu):", Colors.CYAN)
    if system == "Windows":
        print_info("   - run_bot.bat dosyasını çalıştırın")
        print_info("   - Veya: venv\\Scripts\\python -m app.main")
    else:
        print_info("   - ./run_bot.sh dosyasını çalıştırın")
        print_info("   - Veya: venv/bin/python -m app.main")
    
    print_colored("\n⚠️ Önemli Uyarılar:", Colors.RED + Colors.BOLD)
    print_warning("- İlk çalıştırma mutlaka DRY_RUN=True modunda olmalı!")
    print_warning("- Gerçek satın alma yapmadan önce test edin!")
    print_warning("- Log dosyalarını takip edin!")
    
    print_colored("\n📚 Dokümantasyon:", Colors.BLUE)
    print_info("- README.md: Genel kullanım")
    print_info("- INSTALLATION.md: Detaylı kurulum")
    print_info("- CONFIGURATION.md: Ayar seçenekleri")
    print_info("- TROUBLESHOOTING.md: Sorun giderme")
    
    print_colored("\n🎯 Başarılı kurulum! Bot'unuz kullanıma hazır.", Colors.GREEN + Colors.BOLD)
def main() -> None:
    """Ana kurulum fonksiyonu"""
    print_colored("🛒 AMAZON BOT - OTOMATİK KURULUM", Colors.MAGENTA + Colors.BOLD)
    print_colored("="*50, Colors.MAGENTA)
    print_info("Bu script Amazon Bot'u otomatik olarak kuracak")
    print_warning("Kurulum yaklaşık 5-10 dakika sürebilir")
    
    input("\nDevam etmek için Enter'a basın...")
    
    # Kurulum adımları
    steps = [
        ("Python versiyonu kontrol", check_python_version),
        ("Git kurulumu kontrol", check_git),
        ("Sanal ortam oluşturma", create_virtual_environment),
        ("Python paketlerini yükleme", install_requirements),
        ("Playwright browser yükleme", install_playwright),
        (".env dosyası oluşturma", create_env_file),
        ("Kullanıcı girişi alma", lambda: collect_user_input()),
        (".env dosyasını güncelleme", lambda: update_env_file(config)),
        ("Gmail API kurulumu", setup_gmail_api),
        ("Ürün listesi ayarlama", setup_products_json),
        ("Kurulum testi", test_installation),
        ("Çalıştırma scriptleri", create_run_scripts)
    ]
    
    config = {}
    failed_steps = []
    
    for i, (step_name, step_func) in enumerate(steps, 1):
        try:
            if step_name == "Kullanıcı girişi alma":
                config = step_func()
                if config:
                    print_success("Konfigürasyon bilgileri alındı")
                else:
                    failed_steps.append(step_name)
            elif step_name == ".env dosyasını güncelleme":
                if not step_func():
                    failed_steps.append(step_name)
            else:
                if not step_func():
                    failed_steps.append(step_name)
                    print_error(f"Adım başarısız: {step_name}")
        except KeyboardInterrupt:
            print_error("\nKurulum kullanıcı tarafından iptal edildi")
            sys.exit(1)
        except Exception as e:
            print_error(f"Beklenmeyen hata ({step_name}): {e}")
            failed_steps.append(step_name)
    
    # Sonuçları göster
    if failed_steps:
        print_colored(f"\n⚠️ {len(failed_steps)} adım başarısız:", Colors.YELLOW + Colors.BOLD)
        for step in failed_steps:
            print_error(f"- {step}")
        print_info("Başarısız adımları TROUBLESHOOTING.md dosyasından kontrol edin")
    else:
        print_success("\n✅ Tüm kurulum adımları başarılı!")
    
    print_final_instructions()
if __name__ == "__main__":
    main()

# 📦 Amazon Bot - Detaylı Kurulum Rehberi
Bu rehber Amazon Bot'u sıfırdan kurmanız için gereken tüm adımları içerir.
## 📋 Sistem Gereksinimleri
### 🖥️ İşletim Sistemi
- **Windows 10/11** (Önerilen)
- **macOS 10.15+**
- **Ubuntu 18.04+** / **Debian 10+**
### 🐍 Python Gereksinimleri
- **Python 3.8 veya üzeri** (Zorunlu)
- **pip paket yöneticisi** (Python ile birlikte gelir)
- **Git** (proje indirmek için //zorunlu değil)
### 💾 Donanım Gereksinimleri
- **RAM**: En az 4GB (8GB önerilen)
- **Depolama**: En az 1GB boş alan
- **İnternet**: Kararlı internet bağlantısı
### 🌐 Hesap Gereksinimleri
- **Amazon.com.tr hesabı** (aktif)
- **Telegram hesabı** (bildirimler için)
- **Gmail hesabı** (2FA için - opsiyonel)
---
## 🚀 Adım 1: Python Kurulumu
### Windows
```powershell
# Python'u resmi siteden indirin: https://python.org
# Kurulum sırasında "Add Python to PATH" seçeneğini işaretleyin
# Kurulumu doğrulayın
python --version
pip --version
```
### macOS
```bash
# Homebrew ile (önerilen)
brew install python3
# Veya resmi siteden: https://python.org
# Kurulumu doğrulayın
python3 --version
pip3 --version
```
### Ubuntu/Debian
```bash
# Sistem paketlerini güncelleyin
sudo apt update
# Python ve pip kurun
sudo apt install python3 python3-pip git
# Kurulumu doğrulayın
python3 --version
pip3 --version
```
---
## 📥 Adım 2: Proje İndirme
### Git ile İndirme (Önerilen)
```bash
# Projeyi klonlayın
git clone https://github.com/your-username/amazon-bot.git
# Proje dizinine geçin
cd amazon-bot
# Proje yapısını kontrol edin
ls -la
```
### ZIP ile İndirme
```bash
# GitHub'dan ZIP dosyasını indirin
# https://github.com/your-username/amazon-bot/archive/main.zip
# ZIP'i çıkarın ve dizin adını değiştirin
unzip amazon-bot-main.zip
mv amazon-bot-main amazon-bot
cd amazon-bot
```
---
## 🔧 Adım 3: Sanal Ortam Kurulumu (Önerilen)
### Windows
```powershell
# Sanal ortam oluşturun
python -m venv venv
# Sanal ortamı etkinleştirin
venv\Scripts\activate
# Aktif olduğunu doğrulayın (komut satırında (venv) görünmeli)
```
### macOS/Linux
```bash
# Sanal ortam oluşturun
python3 -m venv venv
# Sanal ortamı etkinleştirin
source venv/bin/activate
# Aktif olduğunu doğrulayın (komut satırında (venv) görünmeli)
```
---
## 📦 Adım 4: Bağımlılık Kurulumu
```bash
# Sanal ortamın aktif olduğundan emin olun
# Komut satırında (venv) yazısı görünmeli
# Python paketlerini yükleyin
pip install -r requirements.txt
# Playwright browser'ını kurun
playwright install chromium
# Kurulumları doğrulayın
pip list | grep playwright
pip list | grep python-dotenv
```
### Kurulum Doğrulama
```bash
# Test scripti çalıştırın
python test_simple.py
# Başarılı çıktı:
# ✅ Sys path eklendi
# ✅ Config yüklendi
# ✅ Helpers import edildi
# ✅ Purchase module import edildi
# 🎉 Tüm import'lar başarılı!
```
---
## ⚙️ Adım 5: Konfigürasyon
### .env Dosyası Oluşturma
```bash
# .env.example dosyasını kopyalayın
cp .env.example .env
# Windows'da:
copy .env.example .env
```
### .env Dosyasını Düzenleme
```bash
# Linux/macOS
nano .env
# Windows
notepad .env
# Veya herhangi bir text editör kullanın
```
### Kritik Ayarlar
```bash
# Amazon Hesap Bilgileri (ZORUNLU)
AMAZON_EMAIL="your_email@gmail.com"
AMAZON_PASSWORD="your_strong_password"
# Bot Güvenlik Ayarları (ZORUNLU)
DRY_RUN=True  # ← İLK KURULUMDA MUTLAKA True!
HEADLESS=False  # Test için False
LOOP_WAIT_MINUTES=2
# Telegram Bildirimleri (ÖNERİLEN)
TELEGRAM_BOT_TOKEN=""  # Sonra ayarlayacağız
TELEGRAM_CHAT_ID=""
```
---
## 🤖 Adım 6: Telegram Bot Kurulumu
### Bot Oluşturma
1. **Telegram'da @BotFather'ı bulun**
2. `/newbot` komutunu gönderin
3. **Bot adını girin**: `Amazon Price Bot`
4. **Username girin**: `your_amazon_bot`
5. **Token'ı kopyalayın**: `123456789:ABCDEF...`
### Chat ID Bulma
```bash
# Bot token'ı .env dosyasına ekleyin
TELEGRAM_BOT_TOKEN="123456789:ABCDEF..."
# Chat ID'yi bulma scripti çalıştırın
python get_chat_id.py
# Bot'a Telegram'dan bir mesaj gönderin
# Script size Chat ID'nizi verecek
```
### .env'ye Chat ID Ekleme
```bash
# .env dosyasına ekleyin
TELEGRAM_CHAT_ID="987654321"
ENABLE_NOTIFICATIONS="True"
```
---
## 🛍️ Adım 7: Ürün Listesi Hazırlama
### products.json Düzenleme
```json
[
  {
    "asin": "B0F3JWFL56",
    "target_price": 299.99,
    "name": "Xiaomi TV Box S (Test Ürünü)"
  },
  {
    "asin": "B08JD4TBM3",
    "target_price": 199.99,
    "name": "Kingston USB 128GB"
  }
]
```
### ASIN Kodu Bulma
1. **Amazon'da istediğiniz ürüne gidin**
2. **URL'yi kontrol edin**: `amazon.com.tr/dp/B0F3JWFL56`
3. **B0F3JWFL56 kısmı ASIN kodudur**
---
## 📧 Adım 8: Gmail API Kurulumu (Opsiyonel - 2FA için)
### Gmail API Nedir?
Gmail API, Amazon'un 2FA kodlarını otomatik olarak Gmail'den okumaya yarar. Bu sayede manuel kod girmenize gerek kalmaz.
### Google Cloud Console Kurulumu
#### 1. Google Cloud Console'a Giriş
```bash
1. https://console.cloud.google.com adresine gidin
2. Google hesabınızla giriş yapın
3. Yeni proje oluşturun: "Amazon Bot Gmail API"
```
#### 2. Gmail API'yi Etkinleştirin
```bash
1. Sol menüden "APIs & Services" > "Library" seçin
2. "Gmail API" araması yapın
3. Gmail API'ye tıklayın ve "ENABLE" butonuna basın
```
#### 3. OAuth Credentials Oluşturun
```bash
1. "APIs & Services" > "Credentials" gidin
2. "+ CREATE CREDENTIALS" > "OAuth client ID" seçin
3. Application type: "Desktop application" seçin
4. Name: "Amazon Bot Gmail Reader" yazın
5. "CREATE" butonuna basın
6. Çıkan pencerede "DOWNLOAD JSON" yapın
7. İndirilen dosyayı "gmail_credentials.json" olarak bot klasörüne koyun
```
#### 4. OAuth Consent Screen Ayarları
```bash
1. "OAuth consent screen" tabına gidin
2. User Type: "External" seçin (kişisel hesap için)
3. App name: "Amazon Bot Gmail Reader"
4. User support email: Gmail adresiniz
5. Developer contact: Gmail adresiniz
6. "SAVE AND CONTINUE" ile ilerleyin
7. Scopes adımında hiçbir şey eklemeyin, "SAVE AND CONTINUE"
8. Test users kısmında Gmail adresinizi ekleyin: "+ ADD USERS"
9. "SAVE AND CONTINUE" ile tamamlayın
```
### Yerel Kurulum
#### 1. Gmail Credentials Dosyası
```bash
# gmail_credentials.json dosyasının bot klasöründe olduğundan emin olun
ls -la gmail_credentials.json
# Dosya yoksa Google Cloud Console'dan tekrar indirin
```
#### 2. .env Dosyasına Gmail Ayarları Ekleyin
```bash
# .env dosyasını düzenleyin
nano .env
# Şu satırları ekleyin:
GMAIL_ENABLED=True
GMAIL_CREDENTIALS_FILE="gmail_credentials.json"
GMAIL_TOKEN_FILE="gmail_token.pickle"
```
#### 3. Gmail API İlk Yetkilendirme
```bash
# Gmail API kurulum scripti oluşturun
cat > setup_gmail_api.py << 'EOF'
#!/usr/bin/env python3
"""Gmail API İlk Kurulum ve Yetkilendirme"""
import os
import sys
from dotenv import load_dotenv
load_dotenv()
print("📧 Gmail API Kurulum Başlatılıyor...")
print("=" * 50)
# Kontroller
if not os.path.exists('gmail_credentials.json'):
    print("❌ gmail_credentials.json bulunamadı!")
    print("🔧 Google Cloud Console'dan credentials indirin")
    sys.exit(1)
print("✅ Gmail credentials dosyası bulundu")
# Gmail API'yi import et ve authenticate et
try:
    from app.utils.gmail_reader import gmail_reader
    
    print("\n🔐 Gmail API Yetkilendirme başlatılıyor...")
    print("⚠️  Tarayıcınızda Google yetkilendirme sayfası açılacak")
    print("⚠️  Gmail hesabınızla giriş yapın ve izinleri onaylayın")
    print("⚠️  Bu işlem sadece BİR KEZ yapılır")
    
    input("\n🚀 Devam etmek için ENTER'a basın...")
    
    # Authenticate
    result = gmail_reader.authenticate()
    
    if result:
        print("\n✅ Gmail API yetkilendirme BAŞARILI!")
        print("✅ gmail_token.pickle dosyası oluşturuldu")
        
        # Test et
        print("\n🧪 Gmail API test ediliyor...")
        test_result = gmail_reader.test_connection()
        
        if test_result:
            print("✅ Gmail API test BAŞARILI!")
            print("\n🎉 KURULUM TAMAMLANDI!")
            print("🤖 Artık bot otomatik kod okuyacak")
        else:
            print("❌ Gmail API test başarısız")
    else:
        print("❌ Gmail API yetkilendirme başarısız")
        
except Exception as e:
    print(f"❌ Hata: {e}")
    print("\n🔧 Çözüm önerileri:")
    print("1. Google Cloud Console'da Gmail API aktif mi?")
    print("2. OAuth credentials doğru mu?")
    print("3. İnternet bağlantınız var mı?")
print("\nScript tamamlandı.")
EOF
# Script'i çalıştırın
python setup_gmail_api.py
```
#### 4. Yetkilendirme Süreci
```bash
# Script çalıştığında:
1. Tarayıcınızda Google yetkilendirme sayfası açılacak
2. Gmail hesabınızla giriş yapın
3. "Amazon Bot Gmail Reader" için izin verin
4. "gmail_token.pickle" dosyası oluşacak
5. Bot artık otomatik kod okuyabilecek
```
#### 5. Kurulum Doğrulama
```bash
# Token dosyasının oluştuğunu kontrol edin
ls -la gmail_token.pickle
# Test scripti ile kontrol edin
python -c "
from app.utils.gmail_reader import GmailReader
gmail = GmailReader()
if gmail.is_connected():
    print('✅ Gmail API bağlantısı başarılı')
else:
    print('❌ Gmail API bağlantısı başarısız')
"
```
### Hızlı Kurulum (Otomatik)
Otomatik kurulum scripti kullanarak Gmail API'yi hızlıca kurabilirsiniz:
```bash
# Otomatik kurulum scripti çalıştırın
python setup.py
# Script size Gmail API kurulumu soracak
# "Y" diyerek kabul edin
# Credentials dosyasını indirin ve gmail_credentials.json olarak kaydedin
# Sonra şu komutu çalıştırın:
python setup_gmail_api.py
```
### Sorun Giderme
#### Gmail API Bağlantı Sorunları
```bash
# 1. Credentials dosyası kontrolü
ls -la gmail_credentials.json
# 2. Token dosyası yenileme
rm gmail_token.pickle
python setup_gmail_api.py
# 3. Gmail API test
python -c "
from app.utils.gmail_reader import GmailReader
gmail = GmailReader()
print('Bağlantı durumu:', gmail.is_connected())
"
```
#### OAuth 403 Hatası
```bash
# Google Cloud Console'da:
1. OAuth consent screen'i "External" olarak ayarlayın
2. Test users kısmına Gmail adresinizi ekleyin
3. Gmail API'nin "ENABLED" olduğundan emin olun
```
### Gmail API Güvenlik Notları
#### ⚠️ Önemli Güvenlik Uyarıları
- `gmail_credentials.json` dosyasını KESİNLİKLE Git'e göndermeyin
- `gmail_token.pickle` dosyasını paylaşmayın
- Sadece kendi Gmail hesabınızı kullanın
- OAuth app'ınızı "Test" modunda bırakın (kişisel kullanım için)
#### 🔒 .gitignore Eklentileri
```bash
# .gitignore dosyasına ekleyin (zaten mevcut olmalı)
echo "gmail_credentials.json" >> .gitignore
echo "gmail_token.pickle" >> .gitignore
# ⚠️ NOT: setup_gmail_api.py dosyasını gitignore'a EKLEMEYİN!
# Bu dosya repository'de kalmalı ki başkaları kullanabilsin
```
---
## 🧪 Adım 9: İlk Test
### Bağlantı Testi
```bash
# Basit bağlantı testi
python test_simple.py
# Beklenen çıktı:
# ✅ Config yüklendi - DRY_RUN: True
# ✅ Helpers import edildi
# ✅ Purchase module import edildi
# 🎉 Tüm import'lar başarılı!
```
### Login Testi
```bash
# Amazon login testi (güvenli)
python debug_login_flow.py
# Bu test:
# - Amazon giriş sayfasını açar
# - Email/şifre girişi yapar
# - auth.json dosyası oluşturur
# - Tarayıcıyı kapatmaz (manuel kontrol için)
```
### Satın Alma Flow Testi
```bash
# DRY_RUN modunda satın alma testi
python test_purchase_flow.py
# Bu test:
# - Ürün sayfasını açar
# - "Şimdi Al" butonunu bulur
# - Checkout sürecini simüle eder
# - GERÇEK SATIN ALMA YAPMAZ!
```
---
## 🚀 Adım 9: İlk Çalıştırma
### Test Modu Çalıştırma
```bash
# Ana bot'u test modunda çalıştırın
python -m app.main
# Beklenen çıktı:
# 🔄 DÖNGÜ #1 BAŞLADI
# 🔍 Xiaomi TV Box S kontrol ediliyor...
# 💰 Xiaomi TV Box S: 350.99TL - Amazon.com.tr
# ⏳ Xiaomi TV Box S: Hedef fiyat beklenıyor (fark: +51.00TL)
```
### İlk Başarılı Test Kontrolü
✅ **Başarılı test göstergeleri:**
- Bot çalışıyor ve ürün fiyatlarını okuyabiliyor
- Telegram bildirimleri gelmeye başladı
- Log dosyası oluşturuldu (`amazon_bot_log_*.txt`)
- Hata mesajı yok
---
## 🔧 Yaygın Kurulum Sorunları
### Python Bulunamadı Hatası
```bash
# Windows'da PATH sorunu
# Python'u tekrar kurun ve "Add to PATH" seçin
# Linux'ta alternatif
python3 -m app.main
```
### pip Kurulum Hataları
```bash
# Pip'i güncelleyin
pip install --upgrade pip
# Tekrar deneyin
pip install -r requirements.txt
```
### Playwright Browser Hatası
```bash
# Browser'ı yeniden kurun
playwright install chromium
# Sistem bağımlılıkları (Linux)
sudo apt install libnss3 libatk-bridge2.0-0 libdrm2 libxkbcommon0 libxcomposite1 libxdamage1 libxrandr2 libgbm1 libxss1 libasound2
```
### .env Dosyası Tanınmıyor
```bash
# Dosya konumunu kontrol edin
ls -la .env
# Eğer yoksa yeniden oluşturun
cp .env.example .env
```
### Amazon Giriş Sorunu
```bash
# auth.json dosyasını silin
rm auth.json
# Login debug'ı çalıştırın
python debug_login_flow.py
# Manuel giriş yapın ve session'ı kaydedin
```
---
## ✅ Kurulum Doğrulama Checklist
Kurulumunuzu tamamlamadan önce bu listeyi kontrol edin:
- [ ] **Python 3.8+ kurulu ve çalışıyor**
- [ ] **Git kurulu (proje indirmek için)**
- [ ] **Proje dosyaları indirilmiş**
- [ ] **Sanal ortam oluşturulmuş ve aktif**
- [ ] **requirements.txt yüklenmiş**
- [ ] **Playwright chromium kurulmuş**
- [ ] **.env dosyası oluşturulmuş ve doldurulmuş**
- [ ] **DRY_RUN=True ayarlanmış**
- [ ] **Telegram bot oluşturulmuş**
- [ ] **Chat ID bulunmuş**
- [ ] **products.json düzenlenmiş**
- [ ] **test_simple.py başarıyla çalışıyor**
- [ ] **debug_login_flow.py ile giriş başarılı**
- [ ] **Ana bot çalışıyor ve fiyat okuyabiliyor**
---
## 🎯 Sonraki Adımlar
Kurulum tamamlandıktan sonra:
1. **[CONFIGURATION.md](CONFIGURATION.md)** - Detaylı ayar seçenekleri
2. **[TROUBLESHOOTING.md](TROUBLESHOOTING.md)** - Sorun giderme
3. **Gmail API kurulumu** (2FA için)
4. **Production moda geçiş** (DRY_RUN=False)
---
## 📞 Yardım Gerekirse
Kurulum sırasında sorun yaşarsanız:
1. **Log dosyalarını kontrol edin** (`amazon_bot_log_*.txt`)
2. **GitHub Issues açın** - log dosyalarını ekleyin
3. **Telegram grubuna katılın** - anlık yardım
4. **Discord sunucusuna katılın** - topluluk desteği
**Başarılı kurulum dileklerimizle! 🚀**