Re_Backend/src/services/dealer.service.ts

/**
 * Dealer Service
 * Handles dealer-related operations for claim management
 * Fetches from dealers table and checks if dealer is logged in (domain_id exists in users table)
 */

import { UserModel } from '../models/mongoose/User.schema';
import { Dealer } from '../models/Dealer';
import { Op } from 'sequelize';
import logger from '../utils/logger';

export interface DealerInfo {
  dealerId: string;
  userId?: string | null; // User ID if dealer is logged in
  email: string; // domain_id from dealers table
  dealerCode: string; // dlrcode from dealers table
  dealerName: string; // dealership from dealers table
  displayName: string; // dealer_principal_name from dealers table
  phone?: string; // dp_contact_number from dealers table
  department?: string;
  designation?: string;
  isLoggedIn: boolean; // Whether dealer's domain_id exists in users table
  salesCode?: string | null;
  serviceCode?: string | null;
  gearCode?: string | null;
  gmaCode?: string | null;
  region?: string | null;
  state?: string | null;
  district?: string | null;
  city?: string | null;
  dealerPrincipalName?: string | null;
  dealerPrincipalEmailId?: string | null;
}

/**
 * Get all dealers from dealers table
 * Checks if dealer is logged in by matching domain_id with users.email
 * @param searchTerm - Optional search term to filter dealers
 * @param limit - Maximum number of records to return (default: 10)
 */
export async function getAllDealers(searchTerm?: string, limit: number = 10): Promise<DealerInfo[]> {
  try {
    // Build where clause for search
    const whereClause: any = {
      isActive: true,
    };

    if (searchTerm && searchTerm.trim()) {
      whereClause[Op.or] = [
        { dealership: { [Op.iLike]: `%${searchTerm}%` } as any },
        { dealerPrincipalName: { [Op.iLike]: `%${searchTerm}%` } as any },
        { domainId: { [Op.iLike]: `%${searchTerm}%` } as any },
        { dlrcode: { [Op.iLike]: `%${searchTerm}%` } as any },
        { salesCode: { [Op.iLike]: `%${searchTerm}%` } as any },
        { gearCode: { [Op.iLike]: `%${searchTerm}%` } as any },
      ];
    }

    const dealers = await Dealer.findAll({
      where: whereClause,
      order: [['dealership', 'ASC']],
      limit: limit, // Always limit results to specified limit (default 10)
    });

    // Get all domain_ids to check which dealers are logged in
    const domainIds = dealers
      .map((d) => d.domainId)
      .filter((id): id is string => id !== null && id !== undefined);

    // Check which domain_ids exist in users table
    const loggedInUsers = await UserModel.find({
      email: { $in: domainIds },
      isActive: true,
    }).select('userId email displayName phone department designation');

    // Create a map of email -> user for quick lookup
    const userMap = new Map(loggedInUsers.map((u) => [u.email.toLowerCase(), u]));

    // Map dealers to DealerInfo with login status
    return dealers.map((dealer) => {
      const domainId = dealer.domainId?.toLowerCase() || '';
      const user = domainId ? userMap.get(domainId) : null;
      const isLoggedIn = !!user;

      return {
        dealerId: dealer.dealerId,
        userId: user?.userId || null,
        email: dealer.domainId || '',
        dealerCode: dealer.dlrcode || '',
        dealerName: dealer.dealership || dealer.dealerPrincipalName || '',
        displayName: dealer.dealerPrincipalName || dealer.dealership || '',
        phone: dealer.dpContactNumber || undefined,
        department: user?.department || undefined,
        designation: user?.designation || undefined,
        isLoggedIn,
        salesCode: dealer.salesCode || null,
        serviceCode: dealer.serviceCode || null,
        gearCode: dealer.gearCode || null,
        gmaCode: dealer.gmaCode || null,
        region: dealer.region || null,
        state: dealer.state || null,
        district: dealer.district || null,
        city: dealer.city || null,
        dealerPrincipalName: dealer.dealerPrincipalName || null,
        dealerPrincipalEmailId: dealer.dealerPrincipalEmailId || null,
      };
    });
  } catch (error) {
    logger.error('[DealerService] Error fetching dealers:', error);
    throw error;
  }
}

/**
 * Get dealer by code (dlrcode)
 * Checks if dealer is logged in by matching domain_id with users.email
 */
export async function getDealerByCode(dealerCode: string): Promise<DealerInfo | null> {
  try {
    const dealer = await Dealer.findOne({
      where: {
        dlrcode: dealerCode,
        isActive: true,
      },
    });

    if (!dealer) {
      return null;
    }

    // Check if dealer is logged in (domain_id exists in users table)
    let user = null;
    if (dealer.domainId) {
      user = await UserModel.findOne({
        email: dealer.domainId.toLowerCase(),
        isActive: true,
      }).select('userId email displayName phone department designation');
    }

    const isLoggedIn = !!user;

    return {
      dealerId: dealer.dealerId,
      userId: user?.userId || null,
      email: dealer.domainId || '',
      dealerCode: dealer.dlrcode || '',
      dealerName: dealer.dealership || dealer.dealerPrincipalName || '',
      displayName: dealer.dealerPrincipalName || dealer.dealership || '',
      phone: dealer.dpContactNumber || user?.phone || undefined,
      department: user?.department || undefined,
      designation: user?.designation || undefined,
      isLoggedIn,
      salesCode: dealer.salesCode || null,
      serviceCode: dealer.serviceCode || null,
      gearCode: dealer.gearCode || null,
      gmaCode: dealer.gmaCode || null,
      region: dealer.region || null,
      state: dealer.state || null,
      district: dealer.district || null,
      city: dealer.city || null,
      dealerPrincipalName: dealer.dealerPrincipalName || null,
      dealerPrincipalEmailId: dealer.dealerPrincipalEmailId || null,
    };
  } catch (error) {
    logger.error('[DealerService] Error fetching dealer by code:', error);
    throw error;
  }
}

/**
 * Get dealer by email (domain_id)
 * Checks if dealer is logged in by matching domain_id with users.email
 */
export async function getDealerByEmail(email: string): Promise<DealerInfo | null> {
  try {
    const dealer = await Dealer.findOne({
      where: {
        domainId: { [Op.iLike]: email.toLowerCase() } as any,
        isActive: true,
      },
    });

    if (!dealer) {
      return null;
    }

    // Check if dealer is logged in (domain_id exists in users table)
    let user = null;
    if (dealer.domainId) {
      user = await UserModel.findOne({
        email: dealer.domainId.toLowerCase(),
        isActive: true,
      }).select('userId email displayName phone department designation');
    }

    const isLoggedIn = !!user;

    return {
      dealerId: dealer.dealerId,
      userId: user?.userId || null,
      email: dealer.domainId || '',
      dealerCode: dealer.dlrcode || '',
      dealerName: dealer.dealership || dealer.dealerPrincipalName || '',
      displayName: dealer.dealerPrincipalName || dealer.dealership || '',
      phone: dealer.dpContactNumber || user?.phone || undefined,
      department: user?.department || undefined,
      designation: user?.designation || undefined,
      isLoggedIn,
      salesCode: dealer.salesCode || null,
      serviceCode: dealer.serviceCode || null,
      gearCode: dealer.gearCode || null,
      gmaCode: dealer.gmaCode || null,
      region: dealer.region || null,
      state: dealer.state || null,
      district: dealer.district || null,
      city: dealer.city || null,
      dealerPrincipalName: dealer.dealerPrincipalName || null,
      dealerPrincipalEmailId: dealer.dealerPrincipalEmailId || null,
    };
  } catch (error) {
    logger.error('[DealerService] Error fetching dealer by email:', error);
    throw error;
  }
}

/**
 * Search dealers by name, code, or email
 * Uses getAllDealers with search term
 * @param searchTerm - Search term to filter dealers
 * @param limit - Maximum number of records to return (default: 10)
 */
export async function searchDealers(searchTerm: string, limit: number = 10): Promise<DealerInfo[]> {
  try {
    return await getAllDealers(searchTerm, limit);
  } catch (error) {
    logger.error('[DealerService] Error searching dealers:', error);
    throw error;
  }
}