adserver-dashboard 1.0.0

package/PCM/src/services/EmailNotificationService.js

@@ -0,0 +1,315 @@
+import fetch from 'node-fetch';
+import { ApprovalEmailBodyDTO, OTPEmailBodyDTO, DecisionEmailBodyDTO, EmailRequestDTO } from '../dto/EmailRequestDTO.js';
+
+const NOTIFICATION_URL = process.env.NOTIFICATION_URL || '';
+const MAIL_ENABLED = process.env.MAIL_ENABLED === 'true';
+const MAIL_FROM = process.env.MAIL_FROM || 'notification@movingwalls.com';
+const LAYOUT_COMPANY_NAME = process.env.LAYOUT_COMPANY_NAME || 'Influence';
+const LAYOUT_ADDRESS = process.env.LAYOUT_ADDRESS || '';
+const LAYOUT_PHONE_NUMBER = process.env.LAYOUT_PHONE_NUMBER || '';
+const LAYOUT_EMAIL = process.env.LAYOUT_EMAIL || '';
+const DIRECT_APPROVAL_LINK = process.env.DIRECT_APPROVAL_LINK || '';
+const NOTIFICATION_TIMEOUT_MS = parseInt(process.env.NOTIFICATION_TIMEOUT_MS || '10000');
+
+const TEMPLATES = {
+  APPROVAL_REQUEST: process.env.TEMPLATE_APPROVAL_REQUEST || 'lmx_influence_rfa.tpl',
+  OTP: process.env.TEMPLATE_OTP || 'lmx_EmailVerificationCode.tpl',
+  DECISION_APPROVED: process.env.TEMPLATE_DECISION_APPROVED || 'lmx_influence_public_approved.tpl',
+  DECISION_REJECTED: process.env.TEMPLATE_DECISION_REJECTED || 'lmx_influence_public_rejected.tpl'
+};
+
+export class EmailNotificationService {
+  constructor() {
+    this.notificationUrl = NOTIFICATION_URL;
+    this.enabled = MAIL_ENABLED;
+    this.fromEmail = MAIL_FROM;
+    this.layoutConfig = {
+      layoutCompanyName: LAYOUT_COMPANY_NAME,
+      layoutAddress: LAYOUT_ADDRESS,
+      layoutPhoneNumber: LAYOUT_PHONE_NUMBER,
+      layoutEmail: LAYOUT_EMAIL
+    };
+    this.directApprovalLink = DIRECT_APPROVAL_LINK;
+    this.templates = TEMPLATES;
+    this.timeoutMs = NOTIFICATION_TIMEOUT_MS;
+  }
+
+  async sendApprovalRequestEmailAsync(params, historyCallback = null) {
+    setImmediate(() => {
+      this._sendApprovalRequestEmail(params, historyCallback)
+        .catch(err => console.error('[EmailService] Async approval email error:', err.message));
+    });
+    return { queued: true };
+  }
+
+  async _sendApprovalRequestEmail(params, historyCallback) {
+    const { 
+      approverEmail, 
+      dealId, 
+      dealName, 
+      budget,
+      currency = 'USD',
+      noLineItems = 0,
+      publisherName = '',
+      approvalLink,
+      user = {},
+      logoUrl = null
+    } = params;
+
+    const bodyDTO = new ApprovalEmailBodyDTO({
+      user,
+      approverEmail,
+      dealName,
+      dealId,
+      budget: `${currency} ${budget}`,
+      noLineItems,
+      approvalLink,
+      publisherName,
+      logoUrl,
+      ...this.layoutConfig
+    });
+
+    const emailRequest = new EmailRequestDTO({
+      from: this.fromEmail,
+      to: [approverEmail],
+      subject: `[Influence] New Deal ${dealId} Pending Approval`,
+      body: bodyDTO,
+      template: this.templates.APPROVAL_REQUEST
+    });
+
+    const result = await this._sendEmail(emailRequest);
+
+    console.log(`[EmailService] Notification Result [${emailRequest.subject}]:`, JSON.stringify({
+      success: result.success,
+      endpoint: this.notificationUrl,
+      payload: emailRequest.toPayload(),
+      response: result.response || result.error
+    }, null, 2));
+
+    if (historyCallback) {
+      try {
+        await historyCallback({
+          action: 'APPROVAL_EMAIL_SENT',
+          success: result.success,
+          approverEmail,
+          error: result.error || null,
+          requestPayload: emailRequest.toPayload(),
+          responseDetails: result.response || null,
+          endpoint: this.notificationUrl,
+          timestamp: new Date().toISOString()
+        });
+      } catch (err) {
+        console.error('[EmailService] Failed to record history:', err.message);
+      }
+    }
+
+    return result;
+  }
+
+  async sendOTPEmailAsync(params, historyCallback = null) {
+    setImmediate(() => {
+      this._sendOTPEmail(params, historyCallback)
+        .catch(err => console.error('[EmailService] Async OTP email error:', err.message));
+    });
+    return { queued: true };
+  }
+
+  async _sendOTPEmail(params, historyCallback) {
+    const { 
+      approverEmail, 
+      otpCode,
+      mediaownerName = '',
+      user = {},
+      logoUrl = null
+    } = params;
+
+    const bodyDTO = new OTPEmailBodyDTO({
+      user,
+      approverEmail,
+      code: otpCode,
+      mediaownerName,
+      logoUrl,
+      ...this.layoutConfig
+    });
+
+    const emailRequest = new EmailRequestDTO({
+      from: this.fromEmail,
+      to: [approverEmail],
+      subject: `[Influence] OTP Verification`,
+      body: bodyDTO,
+      template: this.templates.OTP
+    });
+
+    const result = await this._sendEmail(emailRequest);
+
+    console.log(`[EmailService] Notification Result [${emailRequest.subject}]:`, JSON.stringify({
+      success: result.success,
+      endpoint: this.notificationUrl,
+      payload: emailRequest.toPayload(),
+      response: result.response || result.error
+    }, null, 2));
+
+    if (historyCallback) {
+      try {
+        await historyCallback({
+          action: 'OTP_EMAIL_SENT',
+          success: result.success,
+          approverEmail,
+          error: result.error || null,
+          requestPayload: emailRequest.toPayload(),
+          responseDetails: result.response || null,
+          endpoint: this.notificationUrl,
+          timestamp: new Date().toISOString()
+        });
+      } catch (err) {
+        console.error('[EmailService] Failed to record history:', err.message);
+      }
+    }
+
+    return result;
+  }
+
+  async sendDecisionEmailAsync(params, historyCallback = null) {
+    setImmediate(() => {
+      this._sendDecisionEmail(params, historyCallback)
+        .catch(err => console.error('[EmailService] Async decision email error:', err.message));
+    });
+    return { queued: true };
+  }
+
+  async _sendDecisionEmail(params, historyCallback) {
+    const { 
+      sellerEmail,
+      dealId, 
+      dealName, 
+      budget,
+      currency = 'USD',
+      noLineItems = 0,
+      decision,
+      approverEmail,
+      user = {},
+      logoUrl = null
+    } = params;
+
+    if (!sellerEmail) {
+      console.log('[EmailService] No seller email provided, skipping decision notification');
+      return { success: true, skipped: true, reason: 'No seller email' };
+    }
+
+    const bodyDTO = new DecisionEmailBodyDTO({
+      user,
+      sellerEmail,
+      dealName,
+      dealId,
+      budget: `${currency} ${budget}`,
+      noLineItems,
+      approverEmail,
+      logoUrl,
+      ...this.layoutConfig
+    });
+
+    const template = decision === 'APPROVED' 
+      ? this.templates.DECISION_APPROVED 
+      : this.templates.DECISION_REJECTED;
+
+    const emailRequest = new EmailRequestDTO({
+      from: this.fromEmail,
+      to: [sellerEmail],
+      subject: `[Influence] Deal ${dealId} ${decision === 'APPROVED' ? 'Approved' : 'Rejected'}`,
+      body: bodyDTO,
+      template
+    });
+
+    const result = await this._sendEmail(emailRequest);
+
+    console.log(`[EmailService] Notification Result [${emailRequest.subject}]:`, JSON.stringify({
+      success: result.success,
+      endpoint: this.notificationUrl,
+      payload: emailRequest.toPayload(),
+      response: result.response || result.error
+    }, null, 2));
+
+    if (historyCallback) {
+      try {
+        await historyCallback({
+          action: 'DECISION_EMAIL_SENT',
+          success: result.success,
+          sellerEmail,
+          decision,
+          error: result.error || null,
+          requestPayload: emailRequest.toPayload(),
+          responseDetails: result.response || null,
+          endpoint: this.notificationUrl,
+          timestamp: new Date().toISOString()
+        });
+      } catch (err) {
+        console.error('[EmailService] Failed to record history:', err.message);
+      }
+    }
+
+    return result;
+  }
+
+  async _sendEmail(emailRequest) {
+    if (!this.enabled) {
+      console.log('[EmailService] Email disabled, would send:', JSON.stringify(emailRequest.toPayload(), null, 2));
+      return { success: true, simulated: true };
+    }
+
+    if (!this.notificationUrl) {
+      console.error('[EmailService] NOTIFICATION_URL not configured');
+      return { success: false, error: 'NOTIFICATION_URL not configured' };
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+
+    try {
+      const payload = emailRequest.toPayload();
+      
+      console.log('[EmailService] Sending email to:', payload.to.join(', '));
+
+      const response = await fetch(this.notificationUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error('[EmailService] Failed to send email:', response.status, errorText);
+        return { success: false, error: `HTTP ${response.status}: ${errorText}` };
+      }
+
+      const responseData = await response.json().catch(() => ({}));
+      console.log('[EmailService] Email sent successfully');
+      return { success: true, response: responseData };
+
+    } catch (error) {
+      clearTimeout(timeoutId);
+      
+      if (error.name === 'AbortError') {
+        console.error('[EmailService] Request timeout after', this.timeoutMs, 'ms');
+        return { success: false, error: 'Request timeout' };
+      }
+      
+      console.error('[EmailService] Error sending email:', error.message);
+      return { success: false, error: error.message };
+    }
+  }
+
+  buildApprovalLink(encryptedToken) {
+    const baseUrl = this.directApprovalLink || DIRECT_APPROVAL_LINK;
+    if (!baseUrl) {
+      return `?token=${encodeURIComponent(encryptedToken)}`;
+    }
+    return `${baseUrl}?token=${encodeURIComponent(encryptedToken)}`;
+  }
+}
+
+export default new EmailNotificationService();

package/PCM/src/services/LineItemResponseFormatter.js

@@ -0,0 +1,122 @@
+import { toCamelCase } from '../utils/caseConverter.js';
+
+class LineItemResponseFormatter {
+  static formatResponse(lineItem, includeInventories = false, includeCreatives = false) {
+    if (!lineItem) return null;
+    
+    const data = lineItem.dataValues ? lineItem.dataValues : lineItem;
+    const camelData = toCamelCase(data);
+    
+    // Common fields (always at root level)
+    const commonFields = {
+      id: camelData.id,
+      source: camelData.source,
+      externalId: camelData.externalId,
+      dealId: camelData.dealId,
+      name: camelData.name,
+      mode: camelData.mode,
+      dealType: camelData.dealType,
+      creativeType: camelData.creativeType,
+      duration: camelData.duration, // Common field for both DIRECT and PROGRAMMATIC
+      timezoneId: camelData.timezoneId,
+      startDate: camelData.startDate,
+      endDate: camelData.endDate,
+      sizes: camelData.sizes,
+      resolutions: camelData.resolutions,
+      schedule: camelData.schedule,
+      currency: camelData.currency,
+      publisherId: camelData.publisherId,
+      creativeRotationType: camelData.creativeRotationType,
+      creativeSource: camelData.creativeSource,
+      totalInventories: camelData.totalInventories,
+      isPlaying: camelData.isPlaying,
+      status: camelData.status,
+      pacing: camelData.pacing, // Common field for both DIRECT and PROGRAMMATIC
+      planning: camelData.mode === 'DIRECT' ? camelData.planning : undefined, // Also at root level for DIRECT mode
+      targeting: camelData.targeting, // Available for both PROGRAMMATIC and DIRECT modes (filters inventories)
+      deliveryTargeting: camelData.mode === 'DIRECT' ? camelData.deliveryTargeting : undefined, // DIRECT mode only (real-time signals)
+      metadata: camelData.metadata,
+      priority: camelData.priority,
+      customFees: camelData.customFees,
+      frequencyCap: camelData.frequencyCap,
+      trafficAllocation: camelData.trafficAllocation !== null ? parseFloat(camelData.trafficAllocation) : undefined,
+      inventorySource: camelData.inventorySource,
+      version: camelData.version,
+      createdAt: camelData.createdAt,
+      updatedAt: camelData.updatedAt
+    };
+    
+    // Programmatic-specific fields (duration is now a common field)
+    const programmaticFields = {
+      auctionType: camelData.auctionType,
+      impressionType: camelData.impressionType,
+      thresholdCountPerDay: camelData.thresholdCountPerDay,
+      deliveryGoal: camelData.deliveryGoal,
+      costType: camelData.costType,
+      bidFloor: camelData.bidFloor,
+      bidFloorBase: camelData.bidFloorBase !== null ? parseFloat(camelData.bidFloorBase) : undefined,
+      netCost: camelData.netCost,
+      netCostPerDay: camelData.netCostPerDay,
+      impressions: camelData.impressions,
+      admCreativeSync: camelData.admCreativeSync,
+      nonBillable: camelData.nonBillable,
+      stopBidRequests: camelData.stopBidRequests,
+      impMultiplier: camelData.impMultiplier
+    };
+    
+    // Direct-specific fields (pacing is now common, at root level)
+    const directFields = {
+      budgetSetup: camelData.budgetSetup,
+      campaignGoal: camelData.campaignGoal,
+      targeting: camelData.targeting,
+      deliveryTargeting: camelData.deliveryTargeting,
+      planning: camelData.planning,
+      pricing: camelData.pricing
+    };
+    
+    // Build response based on mode (fallback to dealType for backward compatibility)
+    const response = { ...commonFields };
+    const effectiveMode = camelData.mode || (camelData.dealType === 'DIRECT' ? 'DIRECT' : 'PROGRAMMATIC');
+    
+    if (effectiveMode === 'PROGRAMMATIC') {
+      response.programmatic = this.cleanObject(programmaticFields);
+    } else if (effectiveMode === 'DIRECT') {
+      response.direct = this.cleanObject(directFields);
+    } else {
+      // If mode is not set, include programmatic fields for backward compatibility
+      response.programmatic = this.cleanObject(programmaticFields);
+    }
+    
+    // Include inventories if requested
+    if (includeInventories && camelData.LineItemInventories) {
+      response.inventories = camelData.LineItemInventories.map(inv => 
+        toCamelCase(inv.dataValues ? inv.dataValues : inv)
+      );
+    }
+    
+    // Include creatives if requested
+    if (includeCreatives && camelData.LineItemCreatives) {
+      response.creatives = camelData.LineItemCreatives.map(creative => 
+        toCamelCase(creative.dataValues ? creative.dataValues : creative)
+      );
+    }
+    
+    return this.cleanObject(response);
+  }
+  
+  static formatListResponse(lineItems, includeInventories = false, includeCreatives = false) {
+    return lineItems.map(item => this.formatResponse(item, includeInventories, includeCreatives));
+  }
+  
+  static cleanObject(obj) {
+    const cleaned = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (value !== null && value !== undefined) {
+        cleaned[key] = value;
+      }
+    }
+    return cleaned;
+  }
+}
+
+export default LineItemResponseFormatter;