Centralized_Reporting_Backend/src/services/integration/integrationService.js

const ZohoClient = require('../../integrations/zoho/client');

class IntegrationService {
  constructor(userId) {
    this.userId = userId;
    this.clients = {
      zoho: new ZohoClient(userId)
    };
  }

  async getData(provider, service, resource, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }

    const method = this.getMethodName(service, resource);
   
    if (!client[method]) {
      throw new Error(`Resource ${resource} not supported for ${provider} ${service}`);
    }

    // Handle special cases that require additional parameters
    if (method === 'getTasks' && service === 'projects' && params.projectId) {
      return await client.getProjectTasks(params.projectId, params);
    }

    // Handle getAllProjectTasks for projects tasks without projectId
    if (method === 'getTasks' && service === 'projects' && !params.projectId) {
      return await client.getAllProjectTasks(params);
    }

    // Handle CRM tasks (no special parameters needed)
    if (method === 'getTasks' && service === 'crm') {
      return await client[method](params);
    }

    return await client[method](params);
  }

  getMethodName(service, resource) {
    const resourceMap = {
      // CRM
      'leads': 'Leads',
      'contacts': 'Contacts', 
      'deals': 'Deals',
      'sales_orders': 'SalesOrders',
      'purchase_orders': 'PurchaseOrders',
      'invoices': 'Invoices',
      // People
      'employees': 'Employees',
      'departments': 'Departments',
      'timesheets': 'Timesheets',
      'leave_requests': 'LeaveRequests',
      'attendance': 'Attendance',
      // Books
      'organizations': 'Organizations',
      'customers': 'Customers',
      'vendors': 'Vendors',
      'items': 'Items',
      'estimates': 'Estimates',
      'bills': 'Bills',
      'expenses': 'Expenses',
      'bank_accounts': 'BankAccounts',
      'bank_transactions': 'BankTransactions',
      'reports': 'Reports',
      // Projects
      'projects': 'Projects',
      'tasks': 'Tasks'
    };

    const resourceName = resourceMap[resource] || resource;
    return `get${resourceName}`;
  }

  async getAvailableServices(provider) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    return client.getAvailableServices();
  }

  async getAvailableResources(provider, service) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    return client.getAvailableResources(service);
  }

  async getPortals(provider) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Portals are only available for Zoho provider');
    }
    return await client.getPortals();
  }

  async getAllProjects(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('All projects are only available for Zoho provider');
    }
    return await client.getAllProjects(params);
  }

  async getAllProjectTasks(provider, portalId, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('All project tasks are only available for Zoho provider');
    }
    return await client.getAllProjectTasks(portalId, params);
  }

  async getAllProjectTaskLists(provider, portalId, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('All project task lists are only available for Zoho provider');
    }
    return await client.getAllProjectTaskLists(portalId, params);
  }

  async getAllProjectIssues(provider, portalId, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('All project issues are only available for Zoho provider');
    }
    return await client.getAllProjectIssues(portalId, params);
  }

  async getAllProjectPhases(provider, portalId, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('All project phases are only available for Zoho provider');
    }
    return await client.getAllProjectPhases(portalId, params);
  }

  async getSalesOrders(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Sales Orders are only available for Zoho provider');
    }
    return await client.getSalesOrders(params);
  }

  async getPurchaseOrders(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Purchase Orders are only available for Zoho provider');
    }
    return await client.getPurchaseOrders(params);
  }

  async getInvoices(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Invoices are only available for Zoho provider');
    }
    return await client.getInvoices(params);
  }

  // Zoho People specific methods
  async getDepartments(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Departments are only available for Zoho provider');
    }
    return await client.getDepartments(params);
  }

  async getLeaveRequests(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Leave Requests are only available for Zoho provider');
    }
    return await client.getLeaveRequests(params);
  }

  async getAttendance(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Attendance is only available for Zoho provider');
    }
    return await client.getAttendance(params);
  }

  // Zoho Books specific methods
  async getOrganizations(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Organizations are only available for Zoho provider');
    }
    return await client.getOrganizations(params);
  }

  async getCustomers(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Customers are only available for Zoho provider');
    }
    return await client.getCustomers(params);
  }

  async getVendors(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Vendors are only available for Zoho provider');
    }
    return await client.getVendors(params);
  }

  async getItems(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Items are only available for Zoho provider');
    }
    return await client.getItems(params);
  }

  async getEstimates(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Estimates are only available for Zoho provider');
    }
    return await client.getEstimates(params);
  }

  async getBills(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Bills are only available for Zoho provider');
    }
    return await client.getBills(params);
  }

  async getExpenses(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Expenses are only available for Zoho provider');
    }
    return await client.getExpenses(params);
  }

  async getBankAccounts(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Bank Accounts are only available for Zoho provider');
    }
    return await client.getBankAccounts(params);
  }

  async getBankTransactions(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Bank Transactions are only available for Zoho provider');
    }
    return await client.getBankTransactions(params);
  }

  async getReports(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Reports are only available for Zoho provider');
    }
    return await client.getReports(params);
  }

  async getBooksSalesOrders(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Books Sales Orders are only available for Zoho provider');
    }
    return await client.getBooksSalesOrders(params);
  }

  async getBooksPurchaseOrders(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Books Purchase Orders are only available for Zoho provider');
    }
    return await client.getBooksPurchaseOrders(params);
  }

  async getContacts(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Contacts are only available for Zoho provider');
    }
    return await client.getContacts(params);
  }

  async getBooksContacts(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Books Contacts are only available for Zoho provider');
    }
    return await client.getBooksContacts(params);
  }

  async getBooksInvoices(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Books Invoices are only available for Zoho provider');
    }
    return await client.getBooksInvoices(params);
  }

  // Zoho People Forms API methods
  async getEmployeeForms(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Employee Forms are only available for Zoho provider');
    }
    return await client.getEmployeeForms(params);
  }

  async getEmployeeById(provider, recordId, formLinkName = 'employee') {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Employee Details are only available for Zoho provider');
    }
    return await client.getEmployeeById(recordId, formLinkName);
  }

  async getAttendanceEntries(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Attendance Entries are only available for Zoho provider');
    }
    return await client.getAttendanceEntries(params);
  }

  async getShiftConfiguration(provider, params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Shift Configuration is only available for Zoho provider');
    }
    return await client.getShiftConfiguration(params);
  }

  async getLeaveData(provider, formLinkName = 'leave', params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Leave Data is only available for Zoho provider');
    }
    return await client.getLeaveData(formLinkName, params);
  }

  async getGoalsData(provider, formLinkName = 'goals', params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Goals Data is only available for Zoho provider');
    }
    return await client.getGoalsData(formLinkName, params);
  }

  async getPerformanceData(provider, formLinkName = 'performance', params = {}) {
    const client = this.clients[provider];
    if (!client) {
      throw new Error(`Provider ${provider} not supported`);
    }
    if (provider !== 'zoho') {
      throw new Error('Performance Data is only available for Zoho provider');
    }
    return await client.getPerformanceData(formLinkName, params);
  }
}

module.exports = IntegrationService;