apiClient.ts

Go to the documentation of this file.

// Client-side API helper for secure server communication
// Replaces direct Fieldpine API calls with server-side proxy calls
 
interface ApiResponse<T = any> {
  success: boolean;
  data?: T;
  error?: string;
}
 
class ApiClient {
  private baseUrl: string;
 
  constructor() {
    this.baseUrl = '/api';
  }
 
  // Generic request method for API calls
  async request<T = any>(
    endpoint: string,
    options: RequestInit = {}
  ): Promise<ApiResponse<T>> {
    return this.requestInternal(endpoint, options);
  }
 
  // Generic GET method - convenience wrapper
  async get<T = any>(endpoint: string): Promise<T> {
    const response = await this.requestInternal<T>(endpoint);
    // For backward compatibility, return just the data
    // Check if response has the structure we expect
    if (response && typeof response === 'object' && 'success' in response) {
      return response as T;
    }
    return response as T;
  }
 
  private async requestInternal<T = any>(
    endpoint: string,
    options: RequestInit = {}
  ): Promise<ApiResponse<T>> {
    const url = `${this.baseUrl}${endpoint}`;
    
    const defaultHeaders = {
      'Content-Type': 'application/json',
    };
 
    try {
      const response = await fetch(url, {
        ...options,
        headers: {
          ...defaultHeaders,
          ...options.headers,
        },
        credentials: 'same-origin', // Include cookies
      });
 
      // Handle 401 Unauthorized - redirect to login
      if (response.status === 401) {
        console.log('401 Unauthorized - redirecting to login');
        // Use window.location for immediate redirect
        if (typeof window !== 'undefined') {
          window.location.href = '/pages/login';
        }
        return {
          success: false,
          error: 'Authentication required',
        };
      }
 
      const result = await response.json();
 
      if (!response.ok) {
        throw new Error(result.error || `HTTP ${response.status}`);
      }
 
      return result;
    } catch (error) {
      console.error(`API request failed: ${endpoint}`, error);
      return {
        success: false,
        error: error instanceof Error ? error.message : 'Unknown error',
      };
    }
  }
 
  // Authentication
  async login(username: string, password: string, storeId?: string): Promise<ApiResponse<{ user: any; store?: any; redirect: string }>> {
    return this.requestInternal('/auth/login', {
      method: 'POST',
      body: JSON.stringify({ username, password, storeId }),
    });
  }
 
  async logout(): Promise<ApiResponse> {
    return this.requestInternal('/auth/logout', { method: 'POST' });
  }
 
  // Products
  async getProducts(params: {
    search?: string;
    plu?: string;
    barcode?: string;
    limit?: number;
    skip?: number;
    filter?: string;
    source?: 'openapi' | 'elink'; // Optional source preference
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined && key !== 'source') {
          acc[key] = value.toString();
        }
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    
    // Determine which API version to use
    const apiVersion = params.source || 'openapi'; // Default to OpenAPI
    const endpoint = query ? `/v1/${apiVersion}/products?${query}` : `/v1/${apiVersion}/products`;
    
    // Try primary choice first, then fallback
    try {
      return await this.requestInternal(endpoint);
    } catch (error) {
      // Fallback to alternative API if primary fails
      if (apiVersion === 'openapi') {
        const fallbackEndpoint = query ? `/v1/elink/products?${query}` : '/v1/elink/products';
        return this.requestInternal(fallbackEndpoint);
      } else {
        const fallbackEndpoint = query ? `/v1/openapi/products?${query}` : '/v1/openapi/products';
        return this.requestInternal(fallbackEndpoint);
      }
    }
  }
 
  async getProductById(id: string): Promise<ApiResponse<any>> {
    return this.requestInternal(`/products/${id}`);
  }
 
  async getProduct(id: string | number): Promise<ApiResponse<any>> {
    return this.requestInternal(`/v1/openapi/products/${id}`);
  }
 
  // Sales
  async createSale(saleData: any): Promise<ApiResponse<any>> {
    return this.requestInternal('/sales', {
      method: 'POST',
      body: JSON.stringify(saleData),
    });
  }
 
  // Dashboard
  async getDashboard(): Promise<ApiResponse<any>> {
    return this.requestInternal('/dashboard');
  }
 
  // Customers
  async getCustomers(params: {
    search?: string;
    limit?: number;
    type?: 'list' | 'single' | 'search';
    id?: number;
    source?: 'openapi' | 'elink'; // Optional source preference
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined && key !== 'source') {
          acc[key] = value.toString();
        }
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    
    // Determine which API version to use
    const apiVersion = params.source || 'openapi'; // Default to OpenAPI
    const endpoint = query ? `/v1/${apiVersion}/customers?${query}` : `/v1/${apiVersion}/customers`;
    
    // Try primary choice first, then fallback
    try {
      return await this.requestInternal(endpoint);
    } catch (error) {
      // Fallback to alternative API if primary fails
      if (apiVersion === 'openapi') {
        const fallbackEndpoint = query ? `/v1/elink/customers?${query}` : '/v1/elink/customers';
        return this.requestInternal(fallbackEndpoint);
      } else {
        const fallbackEndpoint = query ? `/v1/openapi/customers?${query}` : '/v1/openapi/customers';
        return this.requestInternal(fallbackEndpoint);
      }
    }
  }
 
  // Suppliers
  async getSuppliers(params: {
    search?: string;
    limit?: number;
    source?: 'openapi' | 'elink'; // Optional source preference
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined && key !== 'source') {
          acc[key] = value.toString();
        }
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    
    // Determine which API version to use
    const apiVersion = params.source || 'openapi'; // Default to OpenAPI
    const endpoint = query ? `/v1/${apiVersion}/suppliers?${query}` : `/v1/${apiVersion}/suppliers`;
    
    return this.requestInternal(endpoint);
  }
 
  // OpenAPI Methods - Comprehensive implementation
 
  // Products Search with Natural Language
  async searchProducts(params: {
    querytext?: string;
    want?: string;
    like?: string;
    limit?: number;
    option?: string;
    ref?: string;
    inputmethod?: string;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/openapi/products-search?${query}` : '/v1/openapi/products-search');
  }
 
  // Barcodes
  async decodeBarcode(scan: string, geo?: string): Promise<ApiResponse<any>> {
    const params = new URLSearchParams({ scan });
    if (geo) params.append('geo', geo);
    return this.requestInternal(`/v1/openapi/barcodes?${params.toString()}`);
  }
 
  // WebGroups
  async getWebGroups(): Promise<ApiResponse<any[]>> {
    return this.requestInternal('/v1/openapi/webgroups');
  }
 
  // Reorder Levels
  async getReorderLevels(params: {
    pid?: number;
    locid?: number;
    want?: string;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/openapi/reorder-levels?${query}` : '/v1/openapi/reorder-levels');
  }
 
  async setReorderLevel(locid: number, pid: number, levels: {
    ReorderLevel?: number;
    ReorderMax?: number;
  }): Promise<ApiResponse<any>> {
    return this.requestInternal(`/v1/openapi/reorder-levels/${locid}/${pid}`, {
      method: 'POST',
      body: JSON.stringify(levels)
    });
  }
 
  async deleteReorderLevel(locid: number, pid: number): Promise<ApiResponse<any>> {
    return this.requestInternal(`/v1/openapi/reorder-levels/${locid}/${pid}`, {
      method: 'DELETE'
    });
  }
 
  // Supplier Part Codes
  async getSupplierPartCodes(params: {
    spid?: number;
    pid?: number;
    enabled?: boolean;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/openapi/supplier-part-codes?${query}` : '/v1/openapi/supplier-part-codes');
  }
 
  // Purchase Orders
  async getPurchaseOrders(params: {
    location?: number;
    spid?: number;
    state?: string;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/openapi/purchase-orders?${query}` : '/v1/openapi/purchase-orders');
  }
 
  async createPurchaseOrder(order: any): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/openapi/purchase-orders', {
      method: 'POST',
      body: JSON.stringify(order)
    });
  }
 
  async parsePurchaseOrder(text: string): Promise<ApiResponse<any>> {
    return this.requestInternal(`/v1/openapi/purchase-order/parse?text=${encodeURIComponent(text)}`);
  }
 
  // Stock2 - Stock Movements
  async getStockMovements(params: {
    locid?: number;
    pid?: number;
    from?: string;
    to?: string;
    detail?: string;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/openapi/stock2/movements?${query}` : '/v1/openapi/stock2/movements');
  }
 
  // Stock2 - Stock Counts
  async getStockCounts(params: {
    locid?: number;
    pid?: number;
    depid?: number;
    want?: string;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/openapi/stock2/count?${query}` : '/v1/openapi/stock2/count');
  }
 
  async recordStockCount(count: any): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/openapi/stock2/count', {
      method: 'POST',
      body: JSON.stringify(count)
    });
  }
 
  async deleteStockCount(key: string): Promise<ApiResponse<any>> {
    return this.requestInternal(`/v1/openapi/stock2/count/${key}`, {
      method: 'DELETE'
    });
  }
 
  async getStockCountSummary(params: {
    locid?: number;
    pid?: number;
    depid?: number;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/openapi/stock2/count-summary?${query}` : '/v1/openapi/stock2/count-summary');
  }
 
  // Shelf Visits
  async getShelfVisits(params: {
    locid?: number;
    pid?: number;
    from?: string;
    to?: string;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/openapi/shelf-visits?${query}` : '/v1/openapi/shelf-visits');
  }
 
  async recordShelfVisit(visit: any, params?: { CardNo?: string; Pass?: string }): Promise<ApiResponse<any>> {
    const query = params ? new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value;
        return acc;
      }, {} as Record<string, string>)
    ).toString() : '';
    return this.requestInternal(query ? `/v1/openapi/shelf-visits?${query}` : '/v1/openapi/shelf-visits', {
      method: 'POST',
      body: JSON.stringify(visit)
    });
  }
 
  // Stocktakes
  async getStocktakes(params: {
    location?: number;
    state?: string;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/openapi/stocktakes?${query}` : '/v1/openapi/stocktakes');
  }
 
  async getBuckStocktakes(params: {
    filter?: 'current' | 'complete' | 'all';
  } = {}): Promise<ApiResponse<any>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/buck/stocktakes?${query}` : '/v1/buck/stocktakes');
  }
 
  async getBuckStocktakeStatus(id: number): Promise<ApiResponse<any>> {
    return this.requestInternal(`/v1/buck/stocktake/status?id=${id}`);
  }
 
  // Stock Transfers
  async getStockTransfer(id: string, srcuid?: number): Promise<ApiResponse<any>> {
    const query = srcuid ? `?srcuid=${srcuid}` : '';
    return this.requestInternal(`/v1/openapi/stock-transfers/${id}${query}`);
  }
 
  async receiveStockTransfer(id: string, location?: number): Promise<ApiResponse<any>> {
    const query = location ? `?location=${location}` : '';
    return this.requestInternal(`/v1/openapi/stock-transfers/${id}/receive${query}`, {
      method: 'POST'
    });
  }
 
  // Product Writeoff
  async writeoffProduct(id: string, params: {
    location?: number;
    qty?: number;
    reason?: number;
  }): Promise<ApiResponse<any>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(`/v1/openapi/products/${id}/writeoff?${query}`, {
      method: 'POST'
    });
  }
 
  // Pricebook Specials
  async getPricebookSpecials(params: {
    spid?: number;
    from?: string;
    to?: string;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/openapi/pricebook-specials?${query}` : '/v1/openapi/pricebook-specials');
  }
 
  // Supplier Marketing Messages
  async getSupplierMarketingMessages(params: {
    spid?: number;
    pid?: number;
    from?: string;
    to?: string;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/openapi/supplier-marketing-messages?${query}` : '/v1/openapi/supplier-marketing-messages');
  }
 
  // Customer Accounts (uses elink/BUCK API)
  async getAccounts(params: { type?: 'list' | 'summary' | 'search'; search?: string } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/accounts?${query}` : '/v1/accounts');
  }
 
  async createOrUpdateAccount(data: any): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/accounts', {
      method: 'POST',
      body: JSON.stringify({
        action: data.id ? 'update' : 'create',
        data
      })
    });
  }
 
  async getRecentAccountSales(): Promise<ApiResponse<any[]>> {
    return this.requestInternal('/v1/accounts/sales');
  }
 
  async getAccountCustomers(accountId: number): Promise<ApiResponse<any[]>> {
    return this.requestInternal(`/v1/accounts/customers?accountId=${accountId}`);
  }
 
  async linkCustomerToAccount(customerId: number, accountId: number): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/accounts/customers', {
      method: 'POST',
      body: JSON.stringify({
        action: 'link',
        customerId,
        accountId
      })
    });
  }
 
  async unlinkCustomerFromAccount(customerId: number): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/accounts/customers', {
      method: 'POST',
      body: JSON.stringify({
        action: 'unlink',
        customerId,
        accountId: 0
      })
    });
  }
 
  // Sales Reports
  async searchSales(params: {
    query: string;
    limit?: number;
    ref?: number;
    inputMethod?: string;
  }): Promise<ApiResponse<any>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(`/v1/sales/search?${query}`);
  }
 
  // Locations
  async getLocations(params: { source?: 'openapi' | 'elink'; want?: string } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/locations?${query}` : '/v1/locations');
  }
 
  async saveLocation(data: {
    id?: number;
    name: string;
    phone?: string;
    email?: string;
    latitude?: number;
    longitude?: number;
    storeType?: string;
  }): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/locations', {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }
 
  // Departments
  // async getDepartments(params: { want?: string } = {}): Promise<ApiResponse<any[]>> {
  //   const query = new URLSearchParams(
  //     Object.entries(params).reduce((acc, [key, value]) => {
  //       if (value !== undefined) acc[key] = value.toString();
  //       return acc;
  //     }, {} as Record<string, string>)
  //   ).toString();
  //   return this.requestInternal(query ? `/v1/departments?${query}` : '/v1/departments');
  // }
 
  // Payment Types
  async getPaymentTypes(params: { want?: string } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/openapi/payment-types?${query}` : '/v1/openapi/payment-types');
  }
 
  // Discounts
  async getDiscounts(): Promise<ApiResponse<any[]>> {
    return this.requestInternal('/v1/discounts');
  }
 
  // Stocktake
  async lookupProductByBarcode(barcode: string): Promise<ApiResponse<any>> {
    return this.requestInternal(`/v1/stocktake?barcode=${encodeURIComponent(barcode)}`);
  }
 
  async recordStocktakeCount(params: {
    productId: number;
    quantity: number;
    barcode: string;
    storeId?: string;
    reference?: string;
  }): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/stocktake', {
      method: 'POST',
      body: JSON.stringify(params)
    });
  }
 
  // Account Financial Data (Aged Debtors, etc.)
  async getAccountFinancialData(params: {
    limit?: number;
    search?: string;
    showZeroBalance?: boolean;
    showRetired?: boolean;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/accounts/financial?${query}` : '/v1/accounts/financial');
  }
 
  // Payment Types
  async getPaymentTypesList(): Promise<ApiResponse<any[]>> {
    return this.requestInternal('/v1/payment-types');
  }
 
  // Price Changes
  async getPriceChanges(params: {
    limit?: number;
    search?: string;
    pluList?: string;
    showType?: string;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/price-changes?${query}` : '/v1/price-changes');
  }
 
  // Sales List
  async getSalesList(params: {
    limit?: number;
    fields?: string;
    filters?: string[];
  } = {}): Promise<ApiResponse<any>> {
    const query = new URLSearchParams();
    if (params.limit) query.append('limit', params.limit.toString());
    if (params.fields) query.append('fields', params.fields);
    if (params.filters) {
      params.filters.forEach(filter => query.append('filter', filter));
    }
    return this.requestInternal(`/v1/sales/list?${query.toString()}`);
  }
 
  // Sales by Customer
  async getSales(params: {
    customerId?: number;
    accountId?: number;
    limit?: number;
    from?: string;
    to?: string;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/sales?${query}` : '/v1/sales');
  }
 
  // Contact Logs
  async getContactLogs(params: {
    customerId?: number;
    accountId?: number;
    limit?: number;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/contact-logs?${query}` : '/v1/contact-logs');
  }
 
  async saveContactLog(params: {
    customerId?: number;
    accountId?: number;
    message: string;
    reminder?: string;
  }): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/contact-logs', {
      method: 'POST',
      body: JSON.stringify(params)
    });
  }
 
  // Customer Statistics and Analytics
  async getCustomerStats(params: {
    customerId: number;
    type?: 'product-performance' | 'brands';
    limit?: number;
  }): Promise<ApiResponse<any>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/stats?${query}` : '/v1/stats');
  }
 
  async getDepartments(): Promise<ApiResponse<any[]>> {
    return this.requestInternal('/v1/elink/departments');
  }
 
  async getDepartmentHierarchy(): Promise<ApiResponse<Record<number, number[]>>> {
    return this.requestInternal('/v1/departments/hierarchy');
  }
 
  async saveDepartmentHierarchy(hierarchy: Record<number, number[]>): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/departments/hierarchy', {
      method: 'POST',
      body: JSON.stringify({ hierarchy }),
    });
  }
 
  // Update Customer
  async updateCustomer(
    customerId: number,
    data: {
      name?: string;
      company?: string;
      phone?: string;
      phone2?: string;
      mobile?: string;
      email?: string;
      division?: string;
    }
  ): Promise<ApiResponse<any>> {
    return this.requestInternal(`/v1/elink/customers/${customerId}`, {
      method: 'PUT',
      body: JSON.stringify(data),
    });
  }
 
  // Staff Management
  async getStaff(params: {
    id?: number;
    includeRights?: boolean;
    want?: string;
  } = {}): Promise<ApiResponse<any>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/elink/staff?${query}` : '/v1/elink/staff');
  }
 
  async getStaffUsage(params?: { staffId?: string; fromDate?: string; toDate?: string }): Promise<ApiResponse<any>> {
    const queryParams = new URLSearchParams();
    if (params?.staffId) queryParams.append('staffId', params.staffId);
    if (params?.fromDate) queryParams.append('fromDate', params.fromDate);
    if (params?.toDate) queryParams.append('toDate', params.toDate);
    
    const queryString = queryParams.toString();
    const endpoint = queryString ? `/v1/elink/staff/used?${queryString}` : '/v1/elink/staff/used';
    
    return this.requestInternal(endpoint);
  }
 
  async getStaffUsageDetail(params: { staffId: string; fromDate?: string; toDate?: string }): Promise<ApiResponse<any>> {
    const queryParams = new URLSearchParams();
    queryParams.append('staffId', params.staffId);
    if (params?.fromDate) queryParams.append('fromDate', params.fromDate);
    if (params?.toDate) queryParams.append('toDate', params.toDate);
    
    const queryString = queryParams.toString();
    return this.requestInternal(`/v1/elink/staff/used/detail?${queryString}`);
  }
 
  async getStaffRights(): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/elink/staff/rights');
  }
 
  async saveStaff(data: {
    id?: number;
    name: string;
    active?: boolean;
    password?: string;
    barcode?: string;
    formalName?: string;
    mainLocation?: string;
    printedName?: string;
    firstName?: string;
    lastName?: string;
    nickName?: string;
    startDate?: string;
    leaveDate?: string;
    privateEmail?: string;
    workEmail?: string;
    onlineLogin?: string;
    onlinePassword?: string;
    isCustomerRep?: boolean;
    isAccountRep?: boolean;
    remoteProfile?: number;
    autoLoginFrom?: string;
    loginWhere?: number;
    roles?: number[];
  }): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/elink/staff', {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }
 
  // Employee Management
  async getEmployees(params: {
    id?: number;
  } = {}): Promise<ApiResponse<any>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/elink/employees?${query}` : '/v1/elink/employees');
  }
 
  async saveEmployee(data: {
    id?: number;
    shortName: string;
    fullName: string;
    posLoginId?: string;
    startDate?: string;
    endDate?: string;
    mainLocation?: string;
    jobTitle?: string;
    jobCode?: string;
    departmentId?: string;
    externalId?: string;
    nztaUid?: string;
  }): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/elink/employees', {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }
 
  async getTopology(): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/elink/topology');
  }
 
  // Reports - Sales Detail (line-by-line)
  async getSalesDetail(params: {
    startDate?: string;
    endDate?: string;
    locationId?: string;
    departmentId?: string;
    limit?: number;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/reports/sales-detail?${query}` : '/v1/reports/sales-detail');
  }
 
  // Reports - Grouped Sales
  async getSalesGrouped(params: {
    startDate?: string;
    endDate?: string;
    groupBy?: 'product' | 'supplier' | 'department' | 'location' | 'teller';
    limit?: number;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/reports/sales-grouped?${query}` : '/v1/reports/sales-grouped');
  }
 
  // Analytics - Pareto Analysis (80/20 rule)
  async getParetoAnalysis(params: {
    startDate?: string;
    endDate?: string;
    type?: 'basketrate' | 'grossmargin' | 'returns' | 'volume' | 'revenue';
    limit?: number;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/analytics/pareto?${query}` : '/v1/analytics/pareto');
  }
 
  // Reports - Purchase Orders Summary
  async getPurchaseOrdersSummary(params: {
    startDate?: string;
    endDate?: string;
    status?: 'pending' | 'received' | 'cancelled';
    supplierId?: string;
    limit?: number;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/reports/purchase-orders?${query}` : '/v1/reports/purchase-orders');
  }
 
  // Inventory - Goods Movements
  async getGoodsMovements(params: {
    startDate?: string;
    endDate?: string;
    type?: 'transfer' | 'adjustment' | 'writeoff' | 'stocktake' | 'return';
    locationId?: string;
    productId?: string;
    limit?: number;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/inventory/movements?${query}` : '/v1/inventory/movements');
  }
 
  // Analytics - Product Performance (Most critical - 432 uses!)
  async getProductPerformance(params: {
    customerId?: string;
    locationId?: string;
    groupBy?: 'pid' | 'product' | 'spid' | 'supplier' | 'dept' | 'department';
    sortBy?: '1' | '2' | '3'; // 1=volume, 2=revenue, 3=profit
    limit?: number;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/analytics/product-performance?${query}` : '/v1/analytics/product-performance');
  }
 
  // Configuration - Base Settings
  async getBaseSettings(params: {
    key?: string;
    section?: string;
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/config/base-settings?${query}` : '/v1/config/base-settings');
  }
 
  async updateBaseSetting(key: string, value: any): Promise<ApiResponse<any>> {
    return this.requestInternal('/v1/config/base-settings', {
      method: 'POST',
      body: JSON.stringify({ key, value })
    });
  }
 
  // Reports - Sales Totals
  async getSalesTotals(params: {
    startDate?: string;
    endDate?: string;
    groupBy?: 'day' | 'week' | 'month' | 'location' | 'teller' | 'department';
    locationId?: string;
    tellerId?: string;
    sortBy?: 'date' | 'revenue' | 'units';
  } = {}): Promise<ApiResponse<any[]>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/reports/sales-totals?${query}` : '/v1/reports/sales-totals');
  }
 
  // Stats - Today's Statistics (for dashboard)
  async getStatsToday(params: {
    locationId?: string;
  } = {}): Promise<ApiResponse<any>> {
    const query = new URLSearchParams(
      Object.entries(params).reduce((acc, [key, value]) => {
        if (value !== undefined) acc[key] = value.toString();
        return acc;
      }, {} as Record<string, string>)
    ).toString();
    return this.requestInternal(query ? `/v1/stats/today?${query}` : '/v1/stats/today');
  }
  // BUCK Data - Loyalty Campaigns and Printer-Cartridge relationships
  async getBuckData(params: {
    table: string;
    want?: string;
    filter?: string;
    limit?: number;
  }): Promise<ApiResponse<any>> {
    // Support loyalty campaigns
    if (params.table === 'retailmax.elink.loyalty.campaign') {
      return this.requestInternal('/v1/buck/loyalty/campaigns');
    }
    // Support printer-cartridge relationships
    if (params.table === 'retailmax.elink.printercartridge') {
      const query = new URLSearchParams();
      if (params.want) query.append('want', params.want);
      if (params.filter) query.append('filter', params.filter);
      if (params.limit) query.append('limit', params.limit.toString());
      const queryString = query.toString();
      return this.requestInternal(queryString ? `/v1/elink/printer-cartridge?${queryString}` : '/v1/elink/printer-cartridge');
    }
    throw new Error(`BUCK table ${params.table} not supported yet`);
  }}
 
export const apiClient = new ApiClient();
export type { ApiResponse };