tango-app-api-payment-subscription 3.5.6 → 3.5.8

package/src/controllers/invoice.controller.js

@@ -17,6 +17,7 @@ import { symbolFor } from '../utils/currency.js';
 import { invoiceStatusEnum } from '../dtos/validation.dtos.js';
 import { findOneApplicationDefault } from '../services/applicationDefault.service.js';
 import * as assignedStoreService from '../services/assignedStore.service.js';
+import { getUsdInrRate } from './brandsBilling.controller.js';
 
 // Pulls CSM + Finance head emails (stored under applicationDefault
 // type=invoice, subType=heads) AND the per-client CSMs assigned via
@@ -141,7 +142,8 @@ export async function createInvoice( req, res ) {
         clientId: req.body.clientId,
         groupId: req.body.groupId || undefined,
         groupName: req.body.groupName || '',
-        companyName: req.body.companyName || '',
+        // Company (registered) name is always stored uppercase on invoices.
+        companyName: ( req.body.companyName || '' ).toUpperCase(),
         companyAddress: req.body.companyAddress || '',
         GSTNumber: req.body.GSTNumber || '',
         PlaceOfSupply: req.body.PlaceOfSupply || '',
@@ -284,7 +286,7 @@ export async function createInvoice( req, res ) {
         amount: Math.round( amount ),
         invoiceIndex: req.body.invoiceId ? findInvoice.invoiceIndex : invoiceNo,
         tax: taxList,
-        companyName: group.registeredCompanyName,
+        companyName: ( group.registeredCompanyName || '' ).toUpperCase(),
         companyAddress: address,
         PlaceOfSupply: group.placeOfSupply,
         GSTNumber: group.gst,
@@ -371,6 +373,10 @@ async function buildAnnexureRows( invoiceInfo, getgroup ) {
   const billingMonthEnd = new Date( billingMonth.endOf( 'month' ).toISOString() );
   const monthDays = billingMonth.daysInMonth();
   const invoiceCurrency = symbolFor( invoiceInfo.currency );
+  // basepricing negotiatePrice is stored in INR. For non-INR invoices the
+  // annexure must convert it to the invoice currency, otherwise the INR number
+  // is shown verbatim under a $ symbol (e.g. ₹1650 rendered as "$1,650").
+  const annexFx = invoiceInfo.currency === 'dollar' ? ( await getUsdInrRate() ) : 1;
 
   const annexClient = await clientService.findOne( { clientId: invoiceInfo.clientId }, { 'planDetails.product': 1 } );
   const billingTypeMap = {};
@@ -431,7 +437,9 @@ async function buildAnnexureRows( invoiceInfo, getgroup ) {
         units = s.trafficCameraCount;
       }
     }
-    const price = Number( s.standard?.negotiatePrice ) || 0;
+    // Convert the INR negotiatePrice into the invoice currency (annexFx = 1 for
+    // INR invoices, = USD→INR rate for dollar invoices, so divide).
+    const price = ( Number( s.standard?.negotiatePrice ) || 0 ) / annexFx;
     const runningCost = s.workingdays >= monthDays ?
       Math.round( price * units * 100 ) / 100 :
       Math.round( ( price / monthDays ) * s.workingdays * units * 100 ) / 100;
@@ -525,6 +533,10 @@ export async function invoiceDownload( req, res ) {
         billingCurrency: virtualAccount?.currency,
         virtualaccountNumber: virtualAccount ? virtualAccount?.accountNumber : '',
         virtualifsc: virtualAccount ? virtualAccount?.ifsc : '',
+        // GST applies only to domestic (INR) invoices. Gate the tax block on the
+        // invoice's OWN currency — not the payment-account currency, which is
+        // null/non-inr for many INR invoices and was dropping the GST rows.
+        gstApplicable: invoiceInfo.currency === 'inr',
       };
 
       if ( invoiceData?.tax?.length ) {
@@ -589,9 +601,20 @@ export async function invoiceDownload( req, res ) {
           // Load configured CSM + Finance heads PLUS the per-client CSMs from
           // userAssignedStore as CC recipients on the invoice mail.
           const ccEmails = await getInvoiceCcEmails( invoiceInfo.clientId );
-          console.log( fromEmail, getgroup.generateInvoiceTo, ccEmails, attachments );
-
-          const result = await sendEmailWithSES( getgroup.generateInvoiceTo, mailSubject, mailbody, attachments, fromEmail, ccEmails.length ? ccEmails : undefined );
+          // De-duplicate recipients so nobody gets the invoice 2-3 times:
+          // unique TO list, and drop from CC anyone already in TO (overlap
+          // between generateInvoiceTo, invoice heads and assigned CSMs was the
+          // cause of duplicate mails).
+          const toEmails = [ ...new Set(
+              ( getgroup.generateInvoiceTo || [] ).map( ( e ) => String( e || '' ).trim() ).filter( Boolean ),
+          ) ];
+          const toSet = new Set( toEmails.map( ( e ) => e.toLowerCase() ) );
+          const dedupedCc = [ ...new Set(
+              ( ccEmails || [] ).map( ( e ) => String( e || '' ).trim() ).filter( Boolean ),
+          ) ].filter( ( e ) => !toSet.has( e.toLowerCase() ) );
+          console.log( fromEmail, toEmails, dedupedCc, attachments );
+
+          const result = await sendEmailWithSES( toEmails, mailSubject, mailbody, attachments, fromEmail, dedupedCc.length ? dedupedCc : undefined );
           console.log( result );
           let logObj = {
             userName: req.user?.userName,
@@ -706,6 +729,8 @@ async function buildInvoicePdfBuffer( invoiceId ) {
     billingCurrency: virtualAccount?.currency,
     virtualaccountNumber: virtualAccount ? virtualAccount?.accountNumber : '',
     virtualifsc: virtualAccount ? virtualAccount?.ifsc : '',
+    // GST applies only to domestic (INR) invoices; gate on the invoice currency.
+    gstApplicable: invoiceInfo.currency === 'inr',
   };
 
   if ( invoiceData?.tax?.length ) {
@@ -1289,8 +1314,12 @@ async function standardPrice( group, getClient, baseDate ) {
     return product;
   } );
 
-  // Combine overallStore and eachStore products
-  return [ ...products, ...eachStoreProducts ];
+  // Combine overallStore and eachStore products. Sort by product name so the
+  // persisted order is deterministic — MongoDB $group output order isn't
+  // guaranteed, which made products "interchange" between the Plans view, the
+  // stored invoice and regenerated invoices / PDF.
+  return [ ...products, ...eachStoreProducts ]
+      .sort( ( a, b ) => String( a.productName || '' ).localeCompare( String( b.productName || '' ) ) );
 }
 
 
@@ -1424,7 +1453,10 @@ async function stepPrice( group, getClient ) {
       },
     },
     {
+      // productName first so order is deterministic across views/PDF, then
+      // workingdays so step rows stay grouped consistently.
       $sort: {
+        productName: 1,
         workingdays: -1,
       },
     },
@@ -1853,6 +1885,24 @@ export async function clientInvoiceList( req, res ) {
     }
 
     if ( req.body.export ) {
+      // Due Status — mirrors the UI cell (getDueStatus) exactly so the column
+      // matches what reviewers see on screen. Paid / no-due-date show a dash;
+      // otherwise it's overdue / due today / due in N days from TODAY at
+      // day-granularity (time-of-day ignored on both ends).
+      const today = dayjs().startOf( 'day' );
+      const dueStatusOf = ( inv ) => {
+        if ( inv.paymentStatus === 'paid' || !inv.dueDate ) {
+          return '—';
+        }
+        const days = dayjs( inv.dueDate ).startOf( 'day' ).diff( today, 'day' );
+        if ( days < 0 ) {
+          return `Overdue by ${-days} day${days === -1 ? '' : 's'}`;
+        }
+        if ( days === 0 ) {
+          return 'Due today';
+        }
+        return `Due in ${days} day${days === 1 ? '' : 's'}`;
+      };
       const exportdata = [];
       count.forEach( ( element ) => {
         exportdata.push( {
@@ -1861,9 +1911,13 @@ export async function clientInvoiceList( req, res ) {
           'Invoice #': element.invoice,
           'Billing date': dayjs( element.billingDate ).format( 'DD MMM, YYYY' ),
           'Due Date': element.dueDate ? dayjs( element.dueDate ).format( 'DD MMM, YYYY' ) : '',
+          'Due Status': dueStatusOf( element ),
           'Group Name': element.groupName,
           'Amount Excl. GST': element.amount,
-          'GST Amount': element.gstAmount,
+          // GST only applies to domestic (INR) invoices. International invoices
+          // (dollar / euro / etc.) are billed without GST — show a dash to
+          // match the on-screen column rather than a misleading 0.
+          'GST Amount': element.currency === 'inr' ? element.gstAmount : '—',
           'Amount Incl. GST': element.totalAmount,
           'Stores': element.stores,
           'Payment Status': element.paymentStatus,
@@ -1895,35 +1949,42 @@ export async function clientInvoiceList( req, res ) {
       }
     }
 
-    // Card totals — computed over the user's full client scope (findClients),
-    // NOT the currently-filtered/paged view, so the cards stay stable as the
-    // user narrows the list with filters. Outstanding is everything unpaid;
-    // Overdue is the past-due subset; Pending Payment is the approved-but-
-    // unpaid subset. "Outstanding amount" uses totalAmount - paidAmount so a
-    // partially-paid invoice contributes only its remaining balance.
+    // Card totals — computed over the CURRENTLY-FILTERED result set (`count`
+    // holds every invoice matching the active filters, pre-pagination), so the
+    // cards reflect exactly what the filters select. Dollar invoices are
+    // converted to INR at today's rate so all three totals are a single ₹
+    // figure. Outstanding = unpaid remaining (totalAmount - paidAmount);
+    // Overdue = past-due unpaid subset; Pending Payment = approved-but-unpaid.
+    const usdRate = await getUsdInrRate();
     const now = new Date();
-    const remaining = { $subtract: [
-      { $ifNull: [ '$totalAmount', { $ifNull: [ '$amount', 0 ] } ] },
-      { $ifNull: [ '$paidAmount', 0 ] },
-    ] };
-    const cardsAggregate = await invoiceService.aggregate( [
-      { $match: { clientId: { $in: findClients }, paymentStatus: { $ne: 'paid' } } },
-      { $group: {
-        _id: null,
-        outstandingAmount: { $sum: remaining },
-        outstandingCount: { $sum: 1 },
-        overdueAmount: { $sum: { $cond: [ { $lt: [ '$dueDate', now ] }, remaining, 0 ] } },
-        overdueCount: { $sum: { $cond: [ { $lt: [ '$dueDate', now ] }, 1, 0 ] } },
-        pendingPaymentAmount: { $sum: { $cond: [ { $eq: [ '$status', 'approved' ] }, remaining, 0 ] } },
-        pendingPaymentCount: { $sum: { $cond: [ { $eq: [ '$status', 'approved' ] }, 1, 0 ] } },
-      } },
-    ] );
-    const cards = cardsAggregate[0] || {
+    const cards = {
       outstandingAmount: 0, outstandingCount: 0,
       overdueAmount: 0, overdueCount: 0,
       pendingPaymentAmount: 0, pendingPaymentCount: 0,
     };
-    delete cards._id;
+    for ( const inv of count ) {
+      if ( inv.paymentStatus === 'paid' ) {
+        continue;
+      }
+      const fx = inv.currency === 'dollar' ? usdRate : 1;
+      const total = Number( inv.totalAmount ) || Number( inv.amount ) || 0;
+      const paid = Number( inv.paidAmount ) || 0;
+      const remaining = Math.max( 0, total - paid ) * fx;
+
+      cards.outstandingAmount += remaining;
+      cards.outstandingCount += 1;
+      if ( inv.dueDate && new Date( inv.dueDate ) < now ) {
+        cards.overdueAmount += remaining;
+        cards.overdueCount += 1;
+      }
+      if ( inv.status === 'approved' ) {
+        cards.pendingPaymentAmount += remaining;
+        cards.pendingPaymentCount += 1;
+      }
+    }
+    cards.outstandingAmount = Math.round( cards.outstandingAmount * 100 ) / 100;
+    cards.overdueAmount = Math.round( cards.overdueAmount * 100 ) / 100;
+    cards.pendingPaymentAmount = Math.round( cards.pendingPaymentAmount * 100 ) / 100;
 
     res.sendSuccess( { count: count.length, data: invoiceList, cards } );
   } catch ( error ) {
@@ -2460,7 +2521,10 @@ async function transitionInvoiceStatus( req, res, fromStatus, toStatus ) {
       return res.sendError( 'Invoice not found', 404 );
     }
 
-    if ( invoice.status !== fromStatus ) {
+    // Legacy 'pending' invoices are equivalent to the first CSM stage, so the
+    // CSM transition accepts either 'pendingCsm' or 'pending' as the source.
+    const acceptedFrom = fromStatus === 'pendingCsm' ? [ 'pendingCsm', 'pending' ] : [ fromStatus ];
+    if ( !acceptedFrom.includes( invoice.status ) ) {
       return res.sendError(
           `Invoice is currently at status '${invoice.status}', not '${fromStatus}'. Another user may have advanced it.`,
           409,

package/src/controllers/paymentReminder.controller.js

@@ -0,0 +1,81 @@
+import * as paymentReminderService from '../services/paymentReminder.service.js';
+import { logger } from 'tango-app-api-middleware';
+
+// Payment reminder config (Billing Settings page). One document per brand
+// (clientId): recipient emails + five toggleable reminder templates. Returns
+// sensible defaults when a brand has no config saved yet.
+const DEFAULTS = () => ( {
+  reminderEmails: [],
+  templates: {
+    preDue: { enabled: true, daysBefore: 3 },
+    onDue: { enabled: true },
+    onHold: { enabled: true },
+    suspend: { enabled: true },
+    deactivated: { enabled: false },
+  },
+} );
+
+export async function getPaymentReminder( req, res ) {
+  try {
+    const clientId = req.params.clientId || req.query.clientId;
+    if ( !clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+    const existing = await paymentReminderService.findOne( { clientId } );
+    if ( !existing ) {
+      return res.sendSuccess( { clientId, ...DEFAULTS(), isDefault: true } );
+    }
+    return res.sendSuccess( existing );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'getPaymentReminder' } );
+    return res.sendError( error, 500 );
+  }
+}
+
+export async function savePaymentReminder( req, res ) {
+  try {
+    const b = req.body || {};
+    if ( !b.clientId ) {
+      return res.sendError( 'clientId is required', 400 );
+    }
+
+    // Normalize recipients: trim, drop blanks, de-dupe.
+    const emails = Array.isArray( b.reminderEmails ) ? b.reminderEmails : [];
+    const reminderEmails = [ ...new Set(
+        emails.map( ( e ) => String( e || '' ).trim() ).filter( Boolean ),
+    ) ];
+
+    const t = b.templates || {};
+    const bool = ( v, d ) => ( typeof v === 'boolean' ? v : d );
+    let daysBefore = Number( t.preDue?.daysBefore );
+    if ( !Number.isFinite( daysBefore ) ) {
+      daysBefore = 3;
+    }
+    daysBefore = Math.min( 365, Math.max( 1, Math.round( daysBefore ) ) );
+
+    const templates = {
+      preDue: { enabled: bool( t.preDue?.enabled, true ), daysBefore },
+      onDue: { enabled: bool( t.onDue?.enabled, true ) },
+      onHold: { enabled: bool( t.onHold?.enabled, true ) },
+      suspend: { enabled: bool( t.suspend?.enabled, true ) },
+      deactivated: { enabled: bool( t.deactivated?.enabled, false ) },
+    };
+
+    await paymentReminderService.upsert(
+        { clientId: b.clientId },
+        {
+          clientId: b.clientId,
+          reminderEmails,
+          templates,
+          updatedBy: req.user?.email || req.user?.userName || '',
+        },
+    );
+
+    const saved = await paymentReminderService.findOne( { clientId: b.clientId } );
+    logger.info?.( { function: 'savePaymentReminder', clientId: b.clientId } );
+    return res.sendSuccess( saved );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'savePaymentReminder' } );
+    return res.sendError( error, 500 );
+  }
+}

package/src/controllers/paymentReminderTrigger.controller.js

@@ -0,0 +1,194 @@
+import * as paymentReminderService from '../services/paymentReminder.service.js';
+import * as invoiceService from '../services/invoice.service.js';
+import * as clientService from '../services/clientPayment.services.js';
+import dayjs from 'dayjs';
+import fs from 'fs';
+import path from 'path';
+import Handlebars from '../utils/validations/helper/handlebar.helper.js';
+import { logger, sendEmailWithSES } from 'tango-app-api-middleware';
+import { symbolFor } from '../utils/currency.js';
+
+// ---------------------------------------------------------------------------
+// Payment reminder sender. Triggered by a cron job (POST /…/trigger). For each
+// brand that has a reminder config, it finds the unpaid invoices and decides
+// which single reminder stage applies based on the OLDEST unpaid invoice's
+// days-past-due, then emails the enabled template to the configured recipients.
+//
+//   Stage          When                              Template
+//   beforeDue      due in N days (config daysBefore) reminderBeforeDue
+//   onDue          due today                         reminderOnDue
+//   onHold         1..29 days overdue                reminderOnHold
+//   suspend        30..59 days overdue               reminderSuspended
+//   deactivated    60+ days overdue                  reminderDeactivated
+//
+// One email per brand per run (the most severe applicable stage), listing all
+// that brand's unpaid invoices. Disabled stages are skipped.
+// ---------------------------------------------------------------------------
+
+const HBS_DIR = path.resolve( path.dirname( '' ) ) + '/src/hbs';
+let partialsRegistered = false;
+function ensurePartials() {
+  if ( partialsRegistered ) {
+    return;
+  }
+  const partial = fs.readFileSync( `${HBS_DIR}/partials/invoiceSummaryTable.hbs`, 'utf8' );
+  Handlebars.registerPartial( 'invoiceSummaryTable', partial );
+  partialsRegistered = true;
+}
+
+const TEMPLATE_FILE = {
+  beforeDue: 'reminderBeforeDue.hbs',
+  onDue: 'reminderOnDue.hbs',
+  onHold: 'reminderOnHold.hbs',
+  suspend: 'reminderSuspended.hbs',
+  deactivated: 'reminderDeactivated.hbs',
+};
+const SUBJECT = {
+  beforeDue: ( v ) => `Payment reminder — due on ${v.dueDate}`,
+  onDue: ( v ) => `Payment due today — ${v.totalDue} outstanding`,
+  onHold: () => 'Action needed: payment overdue — your account is on hold',
+  suspend: () => 'Important: account suspended — payment 30+ days overdue',
+  deactivated: () => 'Final notice: account deactivated — payment 60+ days overdue',
+};
+
+const templateCache = {};
+function renderTemplate( stage, data ) {
+  ensurePartials();
+  if ( !templateCache[stage] ) {
+    const html = fs.readFileSync( `${HBS_DIR}/${TEMPLATE_FILE[stage]}`, 'utf8' );
+    templateCache[stage] = Handlebars.compile( html );
+  }
+  return templateCache[stage]( data );
+}
+
+// Resolve the single applicable stage from days-past-due (negative = not yet
+// due) of the OLDEST unpaid invoice, honoring which stages are enabled.
+function resolveStage( daysPastDue, templates ) {
+  const t = templates || {};
+  if ( daysPastDue >= 60 ) {
+    return t.deactivated?.enabled ? 'deactivated' : null;
+  }
+  if ( daysPastDue >= 30 ) {
+    return t.suspend?.enabled ? 'suspend' : null;
+  }
+  if ( daysPastDue >= 1 ) {
+    return t.onHold?.enabled ? 'onHold' : null;
+  }
+  if ( daysPastDue === 0 ) {
+    return t.onDue?.enabled ? 'onDue' : null;
+  }
+  // Not yet due — only fire the pre-due heads-up on exactly the configured
+  // lead day (e.g. 3 days before), so the cron doesn't email every day.
+  const lead = Number( t.preDue?.daysBefore ) || 3;
+  if ( t.preDue?.enabled && daysPastDue === -lead ) {
+    return 'beforeDue';
+  }
+  return null;
+}
+
+export async function triggerPaymentReminders( req, res ) {
+  try {
+    const today = dayjs().startOf( 'day' );
+    // Optional dry-run: ?dryRun=true renders + reports but sends nothing.
+    const dryRun = String( req.query?.dryRun || req.body?.dryRun || '' ) === 'true';
+    const SES = JSON.parse( process.env.SES );
+    const fromEmail = SES.accountsEmail || SES.adminEmail;
+    const logo = `${JSON.parse( process.env.URL ).apiDomain}/logo.png`;
+
+    const configs = await paymentReminderService.find( {} );
+    const summary = { brandsProcessed: 0, emailsSent: 0, skipped: 0, byStage: {}, errors: [] };
+
+    for ( const cfg of configs ) {
+      summary.brandsProcessed++;
+      const clientId = cfg.clientId;
+      const recipients = ( cfg.reminderEmails || [] ).filter( Boolean );
+      if ( !clientId || !recipients.length ) {
+        summary.skipped++;
+        continue;
+      }
+
+      // Unpaid invoices for this brand (unpaid OR partial — anything with a
+      // remaining balance). Newest data only; paid invoices excluded.
+      const invoices = await invoiceService.find(
+          { clientId, paymentStatus: { $ne: 'paid' } },
+          { invoice: 1, billingDate: 1, dueDate: 1, amount: 1, totalAmount: 1, paidAmount: 1, currency: 1, companyName: 1 },
+      );
+      if ( !invoices.length ) {
+        summary.skipped++;
+        continue;
+      }
+
+      // Oldest due date drives the stage.
+      let oldestDue = null;
+      for ( const inv of invoices ) {
+        if ( !inv.dueDate ) {
+          continue;
+        }
+        const d = dayjs( inv.dueDate ).startOf( 'day' );
+        if ( !oldestDue || d.isBefore( oldestDue ) ) {
+          oldestDue = d;
+        }
+      }
+      if ( !oldestDue ) {
+        summary.skipped++;
+        continue;
+      }
+      const daysPastDue = today.diff( oldestDue, 'day' );
+      const stage = resolveStage( daysPastDue, cfg.templates );
+      if ( !stage ) {
+        summary.skipped++;
+        continue;
+      }
+
+      // Build the invoice rows + total (convert nothing — show each invoice in
+      // its own currency symbol; total assumes a single currency per brand).
+      let total = 0;
+      let currency = 'inr';
+      const rows = invoices.map( ( inv ) => {
+        const sym = symbolFor( inv.currency );
+        currency = inv.currency || currency;
+        const remaining = Math.max( 0, ( Number( inv.totalAmount ) || Number( inv.amount ) || 0 ) - ( Number( inv.paidAmount ) || 0 ) );
+        total += remaining;
+        return {
+          invoiceNumber: inv.invoice,
+          invoiceDate: inv.billingDate ? dayjs( inv.billingDate ).format( 'DD MMM YYYY' ) : '',
+          dueDate: inv.dueDate ? dayjs( inv.dueDate ).format( 'DD MMM YYYY' ) : '',
+          amountDue: `${sym} ${remaining.toLocaleString( 'en-IN', { minimumFractionDigits: 2, maximumFractionDigits: 2 } )}`,
+        };
+      } );
+      const totalDue = `${symbolFor( currency )} ${total.toLocaleString( 'en-IN', { minimumFractionDigits: 2, maximumFractionDigits: 2 } )}`;
+
+      const client = await clientService.findOne( { clientId }, { clientName: 1 } );
+      const data = {
+        clientName: client?.clientName || invoices[0]?.companyName || 'Customer',
+        companyName: 'Team Tango',
+        dueDate: oldestDue.format( 'DD MMM YYYY' ),
+        totalDue,
+        invoices: rows,
+        logo,
+      };
+
+      const html = renderTemplate( stage, data );
+      const subject = SUBJECT[stage]( data );
+
+      summary.byStage[stage] = ( summary.byStage[stage] || 0 ) + 1;
+      if ( dryRun ) {
+        continue;
+      }
+      try {
+        await sendEmailWithSES( recipients, subject, html, '', fromEmail );
+        console.log( '🚀 ~ triggerPaymentReminders ~ recipients:', recipients );
+        summary.emailsSent++;
+      } catch ( sendErr ) {
+        logger.error( { error: sendErr, function: 'triggerPaymentReminders.send', clientId } );
+        summary.errors.push( { clientId, error: String( sendErr?.message || sendErr ) } );
+      }
+    }
+
+    logger.info?.( { function: 'triggerPaymentReminders', dryRun, summary } );
+    return res.sendSuccess( summary );
+  } catch ( error ) {
+    logger.error( { error: error, function: 'triggerPaymentReminders' } );
+    return res.sendError( error, 500 );
+  }
+}