customerMerge.js

Go to the documentation of this file.

/**
 * @file customerMerge.js
 * @module routes/customerMerge
 * @description Customer merge endpoints for consolidating duplicate customer records.
 * Provides comparison and merge operations with related data migration (tickets, invoices,
 * contracts, agents, hosting resources). Admin-only operations.
 * @requires express
 * @requires middleware/auth
 * @requires middleware/adminOnly
 * @requires middleware/tenant
 * @requires db
 * @author RMM-PSA Development Team
 * @copyright 2026 RMM-PSA Platform
 * @license Proprietary
 */
 
/**
 * @apiDefine CustomerMerge Customer Merge
 * Duplicate customer consolidation operations (admin only)
 */
 
const express = require('express');
const router = express.Router();
const authenticateToken = require('../middleware/auth');
const requireAdmin = require('../middleware/adminOnly');
const { setTenantContext } = require('../middleware/tenant');
const pool = require('../db');
 
router.use(authenticateToken, setTenantContext);
 
/**
 * @api {get} /api/customers/merge/compare/:id1/:id2 Compare customers
 * @apiName CompareCustomersForMerge
 * @apiGroup CustomerMerge
 * @apiDescription Compare two customer records to review data before merge.
 * Returns both customer details plus counts of related records (tickets, invoices,
 * contracts, agents, hosting resources). Enforces tenant isolation.
 * @apiParam {number} id1 First customer ID
 * @apiParam {number} id2 Second customer ID
 * @apiSuccess {object} customer1 First customer details and counts
 * @apiSuccess {number} customer1.customer_id Customer ID
 * @apiSuccess {string} customer1.name Customer name
 * @apiSuccess {string} customer1.email Customer email
 * @apiSuccess {number} customer1.tickets_count Number of tickets
 * @apiSuccess {number} customer1.invoices_count Number of invoices
 * @apiSuccess {number} customer1.contracts_count Number of contracts
 * @apiSuccess {number} customer1.agents_count Number of agents
 * @apiSuccess {number} customer1.hosting_apps_count Number of hosting apps
 * @apiSuccess {Object} customer2 Second customer details and counts (same structure)
 * @apiError (404) {String} error="One or both customers not found" Customer ID(s) not found or tenant mismatch
 * @apiError (500) {String} error="Failed to compare customers" Database query failed
 * @apiExample {curl} Example:
 *   curl -X GET http://localhost:3000/api/customers/merge/compare/42/43 \\
 *     -H "Authorization: Bearer YOUR_TOKEN"
 * @apiSuccessExample {json} Success-Response:
 *   HTTP/1.1 200 OK
 *   {
 *     "customer1": {
 *       "customer_id": 42,
 *       "name": "Acme Corp",
 *       "email": "contact@acme.com",
 *       "tickets_count": 15,
 *       "invoices_count": 8,
 *       "contracts_count": 2,
 *       "agents_count": 5,
 *       "hosting_apps_count": 3
 *     },
 *     "customer2": {
 *       "customer_id": 43,
 *       "name": "Acme Corporation",
 *       "email": "admin@acme.com",
 *       "tickets_count": 3,
 *       "invoices_count": 1,
 *       "contracts_count": 0,
 *       "agents_count": 2,
 *       "hosting_apps_count": 0
 *     }
 *   }
 */
router.get('/merge/compare/:id1/:id2', async (req, res) => {
  const { id1, id2 } = req.params;
  
  try {
    // Get customer details
    const [customer1, customer2] = await Promise.all([
      pool.query('SELECT * FROM customers WHERE customer_id = $1 AND tenant_id = $2', [id1, req.tenant.id]),
      pool.query('SELECT * FROM customers WHERE customer_id = $1 AND tenant_id = $2', [id2, req.tenant.id])
    ]);
 
    if (customer1.rows.length === 0 || customer2.rows.length === 0) {
      return res.status(404).json({ error: 'One or both customers not found' });
    }
 
    // Get counts of related data for both customers
    const [
      tickets1, tickets2,
      invoices1, invoices2,
      contracts1, contracts2,
      agents1, agents2,
      hostingApps1, hostingApps2
    ] = await Promise.all([
      pool.query('SELECT COUNT(*) FROM tickets WHERE customer_id = $1', [id1]),
      pool.query('SELECT COUNT(*) FROM tickets WHERE customer_id = $1', [id2]),
      pool.query('SELECT COUNT(*) FROM invoices WHERE customer_id = $1', [id1]),
      pool.query('SELECT COUNT(*) FROM invoices WHERE customer_id = $1', [id2]),
      pool.query('SELECT COUNT(*) FROM contracts WHERE customer_id = $1', [id1]),
      pool.query('SELECT COUNT(*) FROM contracts WHERE customer_id = $1', [id2]),
      pool.query('SELECT COUNT(*) FROM agents WHERE customer_id = $1', [id1]),
      pool.query('SELECT COUNT(*) FROM agents WHERE customer_id = $1', [id2]),
      pool.query('SELECT COUNT(*) FROM hosting_apps WHERE customer_id = $1', [id1]),
      pool.query('SELECT COUNT(*) FROM hosting_apps WHERE customer_id = $1', [id2])
    ]);
 
    res.json({
      customer1: {
        ...customer1.rows[0],
        tickets_count: parseInt(tickets1.rows[0].count),
        invoices_count: parseInt(invoices1.rows[0].count),
        contracts_count: parseInt(contracts1.rows[0].count),
        agents_count: parseInt(agents1.rows[0].count),
        hosting_apps_count: parseInt(hostingApps1.rows[0].count)
      },
      customer2: {
        ...customer2.rows[0],
        tickets_count: parseInt(tickets2.rows[0].count),
        invoices_count: parseInt(invoices2.rows[0].count),
        contracts_count: parseInt(contracts2.rows[0].count),
        agents_count: parseInt(agents2.rows[0].count),
        hosting_apps_count: parseInt(hostingApps2.rows[0].count)
      }
    });
  } catch (error) {
    console.error('[Customer Merge] Error comparing customers:', error);
    res.status(500).json({ error: 'Failed to compare customers' });
  }
});
 
/**
 * @api {post} /api/customers/merge Merge customers
 * @apiName MergeCustomers
 * @apiGroup CustomerMerge
 * @apiDescription Merge two customer records - migrate all data from secondary to primary, then delete secondary.
 * Admin only. Performs atomic transaction to migrate tickets, invoices, contracts, agents,
 * and hosting resources (apps, droplets, databases). Requires explicit admin authentication.
 * @apiParam {number} primary_customer_id Primary customer ID (data preserved)
 * @apiParam {number} secondary_customer_id Secondary customer ID (will be deleted after merge)
 * @apiSuccess {string} message="Customers merged successfully"
 * @apiSuccess {number} primary_customer_id Primary customer ID
 * @apiSuccess {number} secondary_customer_id Deleted secondary customer ID
 * @apiError (400) {String} error="Both customer IDs are required" Missing customer IDs
 * @apiError (400) {String} error="Cannot merge a customer with itself" Same ID provided for both
 * @apiError (403) {String} error="Forbidden" User not admin
 * @apiError (500) {String} error Error message from merge operation (transaction rolled back)
 * @apiExample {curl} Example:
 *   curl -X POST http://localhost:3000/api/customers/merge \\
 *     -H "Authorization: Bearer YOUR_TOKEN" \\
 *     -H "Content-Type: application/json" \\
 *     -d '{
 *       "primary_customer_id": 42,
 *       "secondary_customer_id": 43
 *     }'
 * @apiSuccessExample {json} Success-Response:
 *   HTTP/1.1 200 OK
 *   {
 *     "message": "Customers merged successfully",
 *     "primary_customer_id": 42,
 *     "secondary_customer_id": 43
 *   }
 */
router.post('/merge', requireAdmin, async (req, res) => {
  const { primary_customer_id, secondary_customer_id } = req.body;
 
  if (!primary_customer_id || !secondary_customer_id) {
    return res.status(400).json({ error: 'Both customer IDs are required' });
  }
 
  if (primary_customer_id === secondary_customer_id) {
    return res.status(400).json({ error: 'Cannot merge a customer with itself' });
  }
 
  const client = await pool.connect();
  
  try {
    await client.query('BEGIN');
 
    // Verify both customers exist and belong to this tenant
    const customersCheck = await client.query(
      'SELECT customer_id FROM customers WHERE customer_id IN ($1, $2) AND tenant_id = $3',
      [primary_customer_id, secondary_customer_id, req.tenant.id]
    );
 
    if (customersCheck.rows.length !== 2) {
      throw new Error('One or both customers not found or do not belong to this tenant');
    }
 
    // Migrate all related data from secondary to primary
    await client.query('UPDATE tickets SET customer_id = $1 WHERE customer_id = $2', [primary_customer_id, secondary_customer_id]);
    await client.query('UPDATE invoices SET customer_id = $1 WHERE customer_id = $2', [primary_customer_id, secondary_customer_id]);
    await client.query('UPDATE contracts SET customer_id = $1 WHERE customer_id = $2', [primary_customer_id, secondary_customer_id]);
    await client.query('UPDATE agents SET customer_id = $1 WHERE customer_id = $2', [primary_customer_id, secondary_customer_id]);
    await client.query('UPDATE hosting_apps SET customer_id = $1 WHERE customer_id = $2', [primary_customer_id, secondary_customer_id]);
    await client.query('UPDATE hosting_droplets SET customer_id = $1 WHERE customer_id = $2', [primary_customer_id, secondary_customer_id]);
    await client.query('UPDATE hosting_databases SET customer_id = $1 WHERE customer_id = $2', [primary_customer_id, secondary_customer_id]);
 
    // Delete the secondary customer
    await client.query('DELETE FROM customers WHERE customer_id = $1', [secondary_customer_id]);
 
    await client.query('COMMIT');
 
    res.json({ 
      message: 'Customers merged successfully',
      primary_customer_id,
      secondary_customer_id
    });
  } catch (error) {
    await client.query('ROLLBACK');
    console.error('[Customer Merge] Error merging customers:', error);
    res.status(500).json({ error: error.message || 'Failed to merge customers' });
  } finally {
    client.release();
  }
});
 
module.exports = router;