vantuz 3.1.0 → 3.1.2

package/cli.js

@@ -360,7 +360,10 @@ async function handleCommand(input, engine, env) {
 
                 console.log(c('cyan', `\n  Son ${Math.min(limit, orders.length)} sipariş:`));
                 orders.slice(0, limit).forEach((o, i) => {
-                    console.log(`  ${i + 1}. ${o._icon} #${o.orderNumber || o.id} - ${o.totalPrice || 'N/A'} TL`);
+                    const date = new Date(o.orderDate || o.createdDate).toLocaleDateString('tr-TR');
+                    const status = o.status;
+                    const statusColor = status === 'Delivered' ? 'green' : status === 'Cancelled' ? 'red' : 'yellow';
+                    console.log(`  ${i + 1}. ${o._icon} #${o.orderNumber} - ${c(statusColor, status)} - ${o.totalPrice} TL (${date})`);
                 });
             } catch (e) {
                 console.log(c('red', `  ❌ Hata: ${e.message}`));

package/core/channels.js

@@ -1,255 +1,45 @@
 /**
- * 📱 CHANNEL MANAGER
- * WhatsApp ve Telegram entegrasyonu
+ * 📱 CHANNEL MANAGER (OpenClaw)
+ * OpenClaw Gateway entegrasyonu
  * 
- * OpenClaw altyapısı üzerine kurulu
+ * NOT: WhatsApp bağlantısı için OpenClaw Gateway CLI kullanılmalıdır:
+ * > openclaw channels login
  */
 
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import axios from 'axios';
 import { log } from './ai-provider.js';
 
 const VANTUZ_HOME = path.join(os.homedir(), '.vantuz');
 const CONFIG_PATH = path.join(VANTUZ_HOME, '.env');
 
-// ═══════════════════════════════════════════════════════════════════════════
-// CHANNEL BASE CLASS
-// ═══════════════════════════════════════════════════════════════════════════
-
-class Channel {
-    constructor(name, config) {
-        this.name = name;
-        this.config = config;
-        this.connected = false;
-    }
-
-    async connect() {
-        throw new Error('connect() must be implemented');
-    }
-
-    async send(to, message) {
-        throw new Error('send() must be implemented');
-    }
-
-    async startListening(onMessage) {
-        throw new Error('startListening() must be implemented');
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// WHATSAPP (via WhatsApp Business API / Twilio / Meta Cloud API)
-// ═══════════════════════════════════════════════════════════════════════════
-
-export class WhatsAppChannel extends Channel {
-    constructor(config) {
-        super('whatsapp', config);
-        this.apiUrl = config.apiUrl || 'https://graph.facebook.com/v17.0';
-        this.phoneNumberId = config.phoneNumberId;
-        this.accessToken = config.accessToken;
-    }
-
-    async connect() {
-        if (!this.phoneNumberId || !this.accessToken) {
-            log('ERROR', 'WhatsApp: phoneNumberId veya accessToken eksik');
-            return false;
-        }
-
-        try {
-            // Verify connection
-            const response = await axios.get(
-                `${this.apiUrl}/${this.phoneNumberId}`,
-                {
-                    headers: { 'Authorization': `Bearer ${this.accessToken}` }
-                }
-            );
-            this.connected = response.status === 200;
-            log('INFO', 'WhatsApp bağlantısı kuruldu', { phoneNumberId: this.phoneNumberId });
-            return true;
-        } catch (e) {
-            log('ERROR', 'WhatsApp bağlantı hatası', { error: e.message });
-            return false;
-        }
-    }
-
-    async send(to, message) {
-        if (!this.connected) {
-            await this.connect();
-        }
-
-        try {
-            const response = await axios.post(
-                `${this.apiUrl}/${this.phoneNumberId}/messages`,
-                {
-                    messaging_product: 'whatsapp',
-                    recipient_type: 'individual',
-                    to: to,
-                    type: 'text',
-                    text: { body: message }
-                },
-                {
-                    headers: {
-                        'Authorization': `Bearer ${this.accessToken}`,
-                        'Content-Type': 'application/json'
-                    }
-                }
-            );
-
-            log('INFO', 'WhatsApp mesaj gönderildi', { to, messageId: response.data?.messages?.[0]?.id });
-            return { success: true, messageId: response.data?.messages?.[0]?.id };
-        } catch (e) {
-            log('ERROR', 'WhatsApp gönderme hatası', { error: e.message });
-            return { success: false, error: e.message };
-        }
-    }
-
-    // Webhook handler için
-    handleWebhook(body) {
-        const entry = body.entry?.[0];
-        const changes = entry?.changes?.[0];
-        const value = changes?.value;
-        const message = value?.messages?.[0];
-
-        if (message) {
-            return {
-                from: message.from,
-                text: message.text?.body || '',
-                timestamp: message.timestamp,
-                messageId: message.id
-            };
-        }
-        return null;
-    }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// TELEGRAM (via Telegram Bot API)
-// ═══════════════════════════════════════════════════════════════════════════
-
-export class TelegramChannel extends Channel {
-    constructor(config) {
-        super('telegram', config);
-        this.botToken = config.botToken;
-        this.apiUrl = `https://api.telegram.org/bot${this.botToken}`;
-    }
-
-    async connect() {
-        if (!this.botToken) {
-            log('ERROR', 'Telegram: botToken eksik');
-            return false;
-        }
-
-        try {
-            const response = await axios.get(`${this.apiUrl}/getMe`);
-            if (response.data.ok) {
-                this.botInfo = response.data.result;
-                this.connected = true;
-                log('INFO', 'Telegram bağlantısı kuruldu', { username: this.botInfo.username });
-                return true;
-            }
-            return false;
-        } catch (e) {
-            log('ERROR', 'Telegram bağlantı hatası', { error: e.message });
-            return false;
-        }
-    }
-
-    async send(chatId, message, options = {}) {
-        if (!this.connected) {
-            await this.connect();
-        }
-
-        try {
-            const response = await axios.post(`${this.apiUrl}/sendMessage`, {
-                chat_id: chatId,
-                text: message,
-                parse_mode: options.parseMode || 'HTML',
-                ...options
-            });
-
-            log('INFO', 'Telegram mesaj gönderildi', { chatId, messageId: response.data?.result?.message_id });
-            return { success: true, messageId: response.data?.result?.message_id };
-        } catch (e) {
-            log('ERROR', 'Telegram gönderme hatası', { error: e.message });
-            return { success: false, error: e.message };
-        }
-    }
-
-    async setWebhook(url) {
-        try {
-            const response = await axios.post(`${this.apiUrl}/setWebhook`, {
-                url: url,
-                allowed_updates: ['message', 'callback_query']
-            });
-            log('INFO', 'Telegram webhook ayarlandı', { url });
-            return response.data.ok;
-        } catch (e) {
-            log('ERROR', 'Telegram webhook hatası', { error: e.message });
-            return false;
-        }
-    }
-
-    async getUpdates(offset = 0) {
-        try {
-            const response = await axios.post(`${this.apiUrl}/getUpdates`, {
-                offset,
-                timeout: 30
-            });
-            return response.data.result || [];
-        } catch (e) {
-            log('ERROR', 'Telegram getUpdates hatası', { error: e.message });
-            return [];
-        }
+export class ChannelManager {
+    constructor() {
+        this.status = {
+            whatsapp: { connected: false, mode: 'gateway' },
+            telegram: { connected: false, mode: 'gateway' }
+        };
     }
 
-    // Long polling mode
-    async startPolling(onMessage) {
-        let offset = 0;
-        log('INFO', 'Telegram polling başlatıldı');
-
-        while (true) {
-            try {
-                const updates = await this.getUpdates(offset);
-
-                for (const update of updates) {
-                    offset = update.update_id + 1;
+    async initAll() {
+        // OpenClaw Gateway durumunu kontrol et (varsayım)
+        // Gerçekte Gateway ayrı bir process olarak çalışır
 
-                    if (update.message?.text) {
-                        const msg = {
-                            chatId: update.message.chat.id,
-                            from: update.message.from,
-                            text: update.message.text,
-                            messageId: update.message.message_id
-                        };
+        const env = this._loadEnv();
 
-                        // Callback
-                        if (onMessage) {
-                            const response = await onMessage(msg);
-                            if (response) {
-                                await this.send(msg.chatId, response);
-                            }
-                        }
-                    }
-                }
-            } catch (e) {
-                log('ERROR', 'Polling hatası', { error: e.message });
-                await new Promise(r => setTimeout(r, 5000));
-            }
+        if (env.TELEGRAM_BOT_TOKEN) {
+            this.status.telegram.connected = true;
+            this.status.telegram.info = 'Bot Token Configured';
         }
-    }
-}
 
-// ═══════════════════════════════════════════════════════════════════════════
-// CHANNEL MANAGER
-// ═══════════════════════════════════════════════════════════════════════════
+        // WhatsApp için kullanıcı manuel login olmalı
+        this.status.whatsapp.info = 'Run "openclaw channels login" to connect';
 
-export class ChannelManager {
-    constructor() {
-        this.channels = {};
+        return this.status;
     }
 
-    loadEnv() {
+    _loadEnv() {
         const env = {};
         try {
             if (fs.existsSync(CONFIG_PATH)) {
@@ -265,58 +55,8 @@ export class ChannelManager {
         return env;
     }
 
-    async initAll() {
-        const env = this.loadEnv();
-        const results = {};
-
-        // WhatsApp
-        if (env.WHATSAPP_PHONE_NUMBER_ID && env.WHATSAPP_ACCESS_TOKEN) {
-            const wa = new WhatsAppChannel({
-                phoneNumberId: env.WHATSAPP_PHONE_NUMBER_ID,
-                accessToken: env.WHATSAPP_ACCESS_TOKEN
-            });
-            if (await wa.connect()) {
-                this.channels.whatsapp = wa;
-                results.whatsapp = true;
-            }
-        }
-
-        // Telegram
-        if (env.TELEGRAM_BOT_TOKEN) {
-            const tg = new TelegramChannel({
-                botToken: env.TELEGRAM_BOT_TOKEN
-            });
-            if (await tg.connect()) {
-                this.channels.telegram = tg;
-                results.telegram = true;
-            }
-        }
-
-        return results;
-    }
-
-    getChannel(name) {
-        return this.channels[name];
-    }
-
-    getConnected() {
-        return Object.keys(this.channels);
-    }
-
-    async broadcast(message, channels = 'all') {
-        const targets = channels === 'all'
-            ? Object.keys(this.channels)
-            : channels.split(',');
-
-        const results = {};
-        for (const ch of targets) {
-            if (this.channels[ch]) {
-                // Not: WhatsApp ve Telegram için farklı recipient gerekir
-                // Bu örnek bir demonstration, gerçek kullanımda recipient listesi lazım
-                results[ch] = 'Channel ready';
-            }
-        }
-        return results;
+    getStatus() {
+        return this.status;
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vantuz",
-  "version": "3.1.0",
+  "version": "3.1.2",
   "description": "Yapay Zeka Destekli E-Ticaret Yönetim Platformu - 7 Pazaryeri + WhatsApp/Telegram",
   "type": "module",
   "main": "cli.js",

package/plugins/vantuz/platforms/trendyol.js

@@ -122,16 +122,16 @@ export class TrendyolAPI {
 
     async getOrders(params = {}) {
         const {
-            status, // Created, Picking, Invoiced, Shipped, Cancelled, Delivered
-            startDate,
-            endDate,
+            status,
+            startDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).getTime(), // Son 30 gün
+            endDate = Date.now(),
             page = 0,
             size = 50,
             orderNumber
         } = params;
 
         return await this._request('GET', `/suppliers/${this.supplierId}/orders`, null, {
-            status, startDate, endDate, page, size, orderNumber
+            status, startDate, endDate, page, size, orderNumber, orderByDirection: 'DESC', orderByField: 'PackageLastModifiedDate'
         });
     }