erp_dekont_kalem_ekle

Instructions

Implementation Reference

• src/index.ts:492-544 (handler)

  Implements the core logic for the 'erp_dekont_kalem_ekle' tool by adding a new item (kalem) to an existing dekont (invoice) via the ERP API endpoint '/api/Dekont/Kalem'. Validates required parameters, constructs the request body, and calls the generic ERP API caller.

  private async addDekontKalem(args: any) {
    const { 
      DekontID, 
      StokID, 
      Miktar, 
      Tutar, 
      DovizID, 
      TutarDvz, 
      BA, 
      DepoID, 
      TeslimTarihi, 
      VergiID, 
      VergiOrani 
    } = args;
    
    if (!DekontID || !StokID || !Miktar || !Tutar) {
      throw new Error('DekontID, StokID, Miktar ve Tutar gerekli');
    }
  
    const kalemData = {
      KalemTipi: 7, // Sabit değer
      DekontID: parseInt(DekontID),
      KartID: parseInt(StokID),
      Miktar: parseFloat(Miktar),
      Tutar: parseFloat(Tutar),
      DovizID: parseInt(DovizID || '1'),
      TutarDvz: parseFloat(TutarDvz || '0'),
      BA: BA || 'A',
      SiparisStok: {
        DepoID: parseInt(DepoID || '1'),
        TeslimTarihi: TeslimTarihi || new Date().toISOString().split('T')[0],
        VergiDetaylari: [
          {
            VergiID: parseInt(VergiID || '1'),
            Oran: parseFloat(VergiOrani || '20'),
            Tutar: parseFloat(Tutar) * (parseFloat(VergiOrani || '20') / 100),
            TutarDvz: 0,
            DovizID: parseInt(DovizID || '1'),
            Matrah: parseFloat(Tutar),
            MatrahDvz: 0,
            BA: BA || 'A'
          }
        ]
      }
    };
  
    this.log('Dekont kalemi ekleniyor', 'info', kalemData);
  
    return await this.callErpApi('/api/Dekont/Kalem', 'POST', {
      KayitTipi: '1',
      body: kalemData
    });
  }

• src/index.ts:244-245 (registration)

  Registers the 'addDekontKalem' special handler in the tool dispatch switch statement within callSpecialHandler method, which is invoked for tools configured with handler: 'addDekontKalem' in tools.json (likely mapping to tool name 'erp_dekont_kalem_ekle').

  case 'addDekontKalem':
    return await this.addDekontKalem(args);

• src/index.ts:692-800 (helper)

  Generic helper method used by addDekontKalem to perform authenticated API calls to the ERP system, handling token management, headers, and error handling.

  private async callErpApi(endpoint: string, method: 'GET' | 'POST', args: any) {
    try {
      // Token'ı otomatik olarak al (cache'den veya yeni)
      let token = this.getCachedToken();
      if (!token) {
        this.log('Token bulunamadı, yeni token alınıyor...');
        token = await this.getErpToken();
      }
      
      // URL'nin harici olup olmadığını kontrol et
      const isExternalUrl = endpoint.startsWith('http://') || endpoint.startsWith('https://');
      const finalUrl = isExternalUrl ? endpoint : `${this.settings.erp.baseUrl}${endpoint}`;
      
      const config: any = {
        method,
        url: finalUrl,
        headers: {
          'Authorization': `Bearer ${encodeURIComponent(token)}`,
          ...this.settings.api.defaultHeaders,
        },
        timeout: this.settings.api.timeout,
      };
  
      // Harici URL için ek header'lar ekle
      if (isExternalUrl) {
        config.headers['X-Original-ERP-URL'] = `${this.settings.erp.baseUrl}${endpoint.replace(/^https?:\/\/[^\/]+/, '')}`;
        config.headers['X-ERP-Token'] = encodeURIComponent(token);
      }
  
      if (method === 'GET') {
        // Tüm parametreleri query string olarak ekle
        const queryParams = { ...args };
        delete queryParams.endpoint;
        delete queryParams.method;
        delete queryParams.body;
        
        if (Object.keys(queryParams).length > 0) {
          config.params = queryParams;
        }
      } else if (method === 'POST') {
        if (args.body) {
          config.data = args.body;
        }
        
        // POST için query parametreleri de ekle
        const queryParams = { ...args };
        delete queryParams.endpoint;
        delete queryParams.method;
        delete queryParams.body;
        
        if (Object.keys(queryParams).length > 0) {
          config.params = queryParams;
        }
      }
  
      this.log(`API çağrısı: ${method} ${endpoint}`, 'info', {
        url: config.url,
        method: config.method,
        params: config.params,
        isExternal: isExternalUrl
      });
      
      const response = await axios(config);
      
      this.log(`API başarılı: ${method} ${endpoint}`, 'info', {
        status: response.status,
        dataLength: JSON.stringify(response.data).length,
        isExternal: isExternalUrl
      });
      
      return {
        content: [
          {
            type: 'text',
            text: JSON.stringify(response.data, null, 2),
          },
        ],
      };
    } catch (error) {
      let errorMessage = 'Bilinmeyen hata';
      
      if (axios.isAxiosError(error)) {
        if (error.response) {
          errorMessage = `HTTP ${error.response.status}: ${error.response.statusText}`;
          if (error.response.data) {
            errorMessage += `\n${JSON.stringify(error.response.data, null, 2)}`;
          }
        } else if (error.request) {
          errorMessage = 'İstek gönderildi ancak yanıt alınamadı';
        } else {
          errorMessage = error.message;
        }
      } else if (error instanceof Error) {
        errorMessage = error.message;
      }
  
      this.log(`API hatası: ${method} ${endpoint}`, 'error', { error: errorMessage });
  
      return {
        content: [
          {
            type: 'text',
            text: `API Hatası: ${errorMessage}`,
          },
        ],
        isError: true,
      };
    }
  }

• src/index.ts:176-216 (registration)

  Dynamic tool registration and dispatching logic in setupToolHandlers: loads tools from config/tools.json, lists them via ListToolsRequestSchema, and dispatches to special handlers like 'addDekontKalem' based on tool config.

    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const { name, arguments: args } = request.params;
  
      try {
        const toolConfig = this.toolsConfig[name];
        if (!toolConfig) {
          throw new McpError(ErrorCode.MethodNotFound, `Bilinmeyen araç: ${name}`);
        }
  
        // Request bilgilerini logla
        this.log(`Tool çağrısı: ${name}`, 'info', { 
          tool: name, 
          params: args 
        });
  
        // Özel handler varsa onu kullan
        if (toolConfig.handler) {
          return await this.callSpecialHandler(toolConfig.handler, args);
        }
  
        // Normal API çağrısı
        if (toolConfig.endpoint && toolConfig.method) {
          return await this.callErpApi(toolConfig.endpoint, toolConfig.method as 'GET' | 'POST', args);
        }
  
        throw new McpError(ErrorCode.InternalError, `Tool konfigürasyonu eksik: ${name}`);
  
      } catch (error) {
        this.log(`Tool hatası: ${name}`, 'error', error);
        return {
          content: [
            {
              type: 'text',
              text: `Hata: ${error instanceof Error ? error.message : 'Bilinmeyen hata'}`,
            },
          ],
          isError: true,
        };
      }
    });
  }