fieldpine.ts

Go to the documentation of this file.

// Updated Fieldpine integration - now uses secure server-side API
import { FieldpineConfig } from './config';
import { apiClient, type ApiResponse } from './client/apiClient';
 
export class FieldpineIntegration {
  private config: FieldpineConfig;
 
  constructor(config: FieldpineConfig) {
    this.config = config;
  }
 
  // Legacy methods for backward compatibility
  setAuth(apiKey: string, retailerId?: string) {
    console.warn('setAuth is deprecated - authentication is now handled server-side');
  }
 
  getAuth() {
    console.warn('getAuth is deprecated - authentication is now handled server-side');
    return { apiKey: null, retailerId: null };
  }
 
  buildUrl(endpoint: string, params?: Record<string, any>) {
    console.warn('buildUrl is deprecated - API calls are now handled server-side');
    return '';
  }
 
  // Updated API methods using secure server endpoints
  async getProducts(params?: { limit?: number; search?: string; plu?: string; barcode?: string }): Promise<any> {
    // Note: 'search' parameter gets mapped to 'EnglishQuery' for OpenAPI
    const result = await apiClient.getProducts(params || {});
    if (!result.success) {
      throw new Error(result.error || 'Failed to fetch products');
    }
    return result.data;
  }
 
  async getProductById(id: string): Promise<any> {
    const result = await apiClient.getProductById(id);
    if (!result.success) {
      throw new Error(result.error || 'Failed to fetch product');
    }
    return result.data;
  }
 
  async getProductByPlu(plu: string): Promise<any> {
    return this.getProducts({ plu });
  }
 
  async getProductByBarcode(barcode: string): Promise<any> {
    return this.getProducts({ barcode });
  }
 
  async getLocations(params?: { source?: "openapi" | "elink"; want?: string }): Promise<any> {
    const result = await apiClient.getLocations(params || {});
    if (!result.success) {
      throw new Error(result.error || 'Failed to fetch locations');
    }
    return result.data;
  }
 
  async getCustomers(params?: { search?: string; limit?: number }): Promise<any> {
    const result = await apiClient.getCustomers(params || {});
    if (!result.success) {
      throw new Error(result.error || 'Failed to fetch customers');
    }
    return result.data;
  }
 
  async createSale(payload: any): Promise<any> {
    const result = await apiClient.createSale(payload);
    if (!result.success) {
      throw new Error(result.error || 'Failed to create sale');
    }
    return result.data;
  }
 
  // Legacy placeholder methods for backward compatibility
  async getPublicMessages(params?: { limit?: number }): Promise<any> {
    return { messages: [], params };
  }
 
  async getCurrentBill(): Promise<any> {
    return { currentBill: null };
  }
 
  async getCustomerById(id: string): Promise<any> {
    return { id, customer: null };
  }
 
  async updateCustomer(id: string, updates: Record<string, any>): Promise<any> {
    return { id, updated: false, updates };
  }
 
  async getSuppliers(params?: { limit?: number; search?: string }): Promise<any> {
    const result = await apiClient.getSuppliers(params || {});
    if (!result.success) {
      throw new Error(result.error || 'Failed to fetch suppliers');
    }
    return result.data;
  }
 
  async getSupplierById(id: string): Promise<any> {
    return { id, supplier: null };
  }
 
  async getStockOnHand(params?: { locationId?: string; productId?: string; limit?: number }): Promise<any> {
    return { stock: [], params };
  }
 
  async createStockAdjustment(adjustment: { productId: string; locationId: string; qty: number; reason?: string }): Promise<any> {
    return { accepted: false, adjustment };
  }
 
  async getStaff(params?: { limit?: number; search?: string }): Promise<any> {
    return { staff: [], params };
  }
 
  async getStaffById(id: string): Promise<any> {
    return { id, staff: null };
  }
 
  async getReportsSummary(params?: { dateFrom?: string; dateTo?: string; type?: string }): Promise<any> {
    return { reports: [], params };
  }
 
  async finalizeSale(saleId: string, tender: Array<{ type: string; amount: number }>): Promise<any> {
    return { saleId, finalized: false, tender };
  }
 
  async voidSale(saleId: string, reason?: string): Promise<any> {
    return { saleId, voided: false, reason };
  }
}
 
// Global instance - now SSR safe
function getFieldpineConfig() {
  if (typeof window === 'undefined') {
    // Server-side: try to load config file or use environment variables
    try {
      return require('./config').defaultConfig;
    } catch {
      // Config file doesn't exist, use environment variables
      return {
        baseUrl: process.env.NEXT_PUBLIC_FIELDPINE_BASE_URL || 'https://api.fieldpine.com',
        retailerId: process.env.NEXT_PUBLIC_FIELDPINE_RETAILER_ID || 'demo',
        apiKey: null
      };
    }
  }
  
  // Client-side: try localStorage first, then config file, then env vars
  if (typeof window !== "undefined") {
    try {
      const stored = localStorage.getItem("fieldpine_config");
      if (stored) {
        return JSON.parse(stored);
      }
    } catch (error) {
      console.warn('Error loading fieldpine config from localStorage:', error);
    }
  }
  
  try {
    return require('./config').defaultConfig;
  } catch {
    // Config file doesn't exist, use environment variables with CWA defaults
    return {
      baseUrl: process.env.NEXT_PUBLIC_FIELDPINE_BASE_URL || 'https://a1.fieldpine.com',
      retailerId: process.env.NEXT_PUBLIC_FIELDPINE_RETAILER_ID || 'CWA',
      apiKey: process.env.FIELDPINE_API_KEY || process.env.FIELDPINE_AUTH_HEADER || 'dWx1cnU6YWxpY2U=',
      minpos: parseInt(process.env.FIELDPINE_MIN_POS || '2370'),
      mingds: parseInt(process.env.FIELDPINE_MIN_GDS || '264'),
      uiname: process.env.FIELDPINE_UI_NAME || 'CWA Standard',
      password: process.env.NEXT_PUBLIC_DEMO_PASSWORD || 'emu'
    };
  }
}
 
let _fieldpineInstance: FieldpineIntegration | null = null;
 
export const fieldpine = new Proxy({} as FieldpineIntegration, {
  get(target, prop) {
    if (!_fieldpineInstance) {
      const config = getFieldpineConfig();
      _fieldpineInstance = new FieldpineIntegration(config);
    }
    return _fieldpineInstance[prop as keyof FieldpineIntegration];
  }
});