adserver-dashboard 1.0.0

package/PCM/src/services/ChangeHistoryService.js

@@ -0,0 +1,316 @@
+import ChangeHistory from '../models/ChangeHistory.js';
+
+const IGNORED_FIELDS = ['updated_at', 'created_at', 'version'];
+
+const FIELD_LABELS = {
+  deal_id: 'Deal ID',
+  name: 'Name',
+  status: 'Status',
+  deal_type: 'Deal Type',
+  mode: 'Mode',
+  brand: 'Brand',
+  client_type: 'Client Type',
+  currency: 'Currency',
+  start_date: 'Start Date',
+  end_date: 'End Date',
+  cost_type: 'Cost Type',
+  bid_floor: 'Bid Floor',
+  budget_setup: 'Budget Setup',
+  campaign_goal: 'Campaign Goal',
+  targeting: 'Targeting',
+  delivery_targeting: 'Delivery Targeting',
+  pacing: 'Pacing',
+  schedule: 'Schedule',
+  buyers: 'Buyers',
+  advertiser: 'Advertiser',
+  publishers: 'Publishers',
+  market_selection: 'Market Selection',
+  approval_emails: 'Approval Emails',
+  creative_type: 'Creative Type',
+  creative_source: 'Creative Source',
+  resolutions: 'Resolutions',
+  planning: 'Planning'
+};
+
+class ChangeHistoryService {
+  static compareValues(oldVal, newVal) {
+    if (oldVal === newVal) return false;
+    if (oldVal === null && newVal === null) return false;
+    if (oldVal === undefined && newVal === undefined) return false;
+    
+    if (typeof oldVal === 'object' && typeof newVal === 'object') {
+      return JSON.stringify(oldVal) !== JSON.stringify(newVal);
+    }
+    
+    return true;
+  }
+
+  static getChangedFields(previousData, currentData) {
+    const changes = [];
+    const allKeys = new Set([
+      ...Object.keys(previousData || {}),
+      ...Object.keys(currentData || {})
+    ]);
+
+    for (const key of allKeys) {
+      if (IGNORED_FIELDS.includes(key)) continue;
+      
+      const prevVal = previousData?.[key];
+      const currVal = currentData?.[key];
+      
+      if (this.compareValues(prevVal, currVal)) {
+        changes.push({
+          field: key,
+          previousValue: prevVal,
+          currentValue: currVal
+        });
+      }
+    }
+
+    return changes;
+  }
+
+  static formatValue(value) {
+    if (value === null || value === undefined) return null;
+    if (typeof value === 'object') return value;
+    return value;
+  }
+
+  static generateSummary(action, entityType, changes, entityName) {
+    if (action === 'CREATE') {
+      return `${entityType} "${entityName || 'Unknown'}" created`;
+    }
+    
+    if (action === 'DELETE') {
+      return `${entityType} "${entityName || 'Unknown'}" deleted`;
+    }
+    
+    if (action === 'STATUS_CHANGE') {
+      const statusChange = changes.find(c => c.field === 'status');
+      if (statusChange) {
+        return `Status changed from ${statusChange.previousValue} to ${statusChange.currentValue}`;
+      }
+    }
+    
+    if (action === 'UPDATE') {
+      const fieldNames = changes.map(c => FIELD_LABELS[c.field] || c.field);
+      if (fieldNames.length <= 3) {
+        return `Updated: ${fieldNames.join(', ')}`;
+      }
+      return `Updated ${fieldNames.length} fields`;
+    }
+    
+    return `${action} on ${entityType}`;
+  }
+
+  static async trackCreate(entityType, entity, context = {}) {
+    const entityData = entity.toJSON ? entity.toJSON() : entity;
+    const entityName = entityData.name || entityData.deal_id || entityData.id;
+    
+    await ChangeHistory.create({
+      entity_type: entityType,
+      entity_id: entityData.id,
+      deal_id: entityType === 'DEAL' ? entityData.deal_id : entityData.deal_id,
+      line_item_id: entityType === 'LINE_ITEM' ? entityData.external_id : null,
+      action: 'CREATE',
+      field_name: null,
+      previous_value: null,
+      current_value: entityData,
+      changed_by: context.userId,
+      changed_by_email: context.userEmail,
+      request_id: context.requestId,
+      ip_address: context.ipAddress,
+      user_agent: context.userAgent,
+      summary: this.generateSummary('CREATE', entityType, [], entityName),
+      metadata: {
+        entityName,
+        mode: entityData.mode,
+        dealType: entityData.deal_type
+      }
+    });
+  }
+
+  static async trackUpdate(entityType, previousEntity, currentEntity, context = {}) {
+    const prevData = previousEntity.toJSON ? previousEntity.toJSON() : previousEntity;
+    const currData = currentEntity.toJSON ? currentEntity.toJSON() : currentEntity;
+    
+    const changes = this.getChangedFields(prevData, currData);
+    
+    if (changes.length === 0) return;
+
+    const entityName = currData.name || currData.deal_id || currData.id;
+    const isStatusChange = changes.length === 1 && changes[0].field === 'status';
+    const action = isStatusChange ? 'STATUS_CHANGE' : 'UPDATE';
+
+    const historyEntries = changes.map(change => ({
+      entity_type: entityType,
+      entity_id: currData.id,
+      deal_id: entityType === 'DEAL' ? currData.deal_id : currData.deal_id,
+      line_item_id: entityType === 'LINE_ITEM' ? currData.external_id : null,
+      action,
+      field_name: change.field,
+      previous_value: this.formatValue(change.previousValue),
+      current_value: this.formatValue(change.currentValue),
+      changed_by: context.userId,
+      changed_by_email: context.userEmail,
+      request_id: context.requestId,
+      ip_address: context.ipAddress,
+      user_agent: context.userAgent,
+      summary: this.generateSummary(action, entityType, changes, entityName),
+      metadata: {
+        entityName,
+        totalChanges: changes.length,
+        changedFields: changes.map(c => c.field)
+      }
+    }));
+
+    await ChangeHistory.bulkCreate(historyEntries);
+  }
+
+  static async trackDelete(entityType, entity, context = {}) {
+    const entityData = entity.toJSON ? entity.toJSON() : entity;
+    const entityName = entityData.name || entityData.deal_id || entityData.id;
+    
+    await ChangeHistory.create({
+      entity_type: entityType,
+      entity_id: entityData.id,
+      deal_id: entityType === 'DEAL' ? entityData.deal_id : entityData.deal_id,
+      line_item_id: entityType === 'LINE_ITEM' ? entityData.external_id : null,
+      action: 'DELETE',
+      field_name: null,
+      previous_value: entityData,
+      current_value: null,
+      changed_by: context.userId,
+      changed_by_email: context.userEmail,
+      request_id: context.requestId,
+      ip_address: context.ipAddress,
+      user_agent: context.userAgent,
+      summary: this.generateSummary('DELETE', entityType, [], entityName),
+      metadata: { entityName }
+    });
+  }
+
+  static async getHistory(entityType, entityId, options = {}) {
+    const { limit = 50, offset = 0, action, startDate, endDate } = options;
+    
+    const where = { entity_type: entityType, entity_id: entityId };
+    
+    if (action) where.action = action;
+    if (startDate || endDate) {
+      const { Op } = await import('sequelize');
+      where.created_at = {};
+      if (startDate) where.created_at[Op.gte] = new Date(startDate);
+      if (endDate) where.created_at[Op.lte] = new Date(endDate);
+    }
+
+    const { count, rows } = await ChangeHistory.findAndCountAll({
+      where,
+      order: [['created_at', 'DESC']],
+      limit,
+      offset
+    });
+
+    return {
+      total: count,
+      items: rows.map(row => this.formatHistoryEntry(row)),
+      pagination: {
+        limit,
+        offset,
+        hasMore: offset + rows.length < count
+      }
+    };
+  }
+
+  static async getDealHistory(dealId, options = {}) {
+    const { limit = 50, offset = 0, includeLineItems = false, action, startDate, endDate } = options;
+    const { Op } = await import('sequelize');
+    
+    const where = { deal_id: dealId };
+    if (!includeLineItems) {
+      where.entity_type = 'DEAL';
+    }
+    
+    if (action) {
+      where.action = action;
+    }
+    
+    if (startDate || endDate) {
+      where.created_at = {};
+      if (startDate) where.created_at[Op.gte] = new Date(startDate);
+      if (endDate) where.created_at[Op.lte] = new Date(endDate);
+    }
+
+    const { count, rows } = await ChangeHistory.findAndCountAll({
+      where,
+      order: [['created_at', 'DESC']],
+      limit,
+      offset
+    });
+
+    return {
+      total: count,
+      items: rows.map(row => this.formatHistoryEntry(row)),
+      pagination: { limit, offset, hasMore: offset + rows.length < count }
+    };
+  }
+
+  static async getMinifiedHistory(dealId, options = {}) {
+    const { limit = 100, includeLineItems = true } = options;
+    const { Op } = await import('sequelize');
+    
+    const where = { deal_id: dealId };
+    if (!includeLineItems) {
+      where.entity_type = 'DEAL';
+    }
+
+    const rows = await ChangeHistory.findAll({
+      where,
+      attributes: ['id', 'entity_type', 'action', 'field_name', 'summary', 'changed_by', 'created_at'],
+      order: [['created_at', 'DESC']],
+      limit
+    });
+
+    return rows.map(row => ({
+      id: row.id,
+      entityType: row.entity_type,
+      action: row.action,
+      field: row.field_name,
+      summary: row.summary,
+      changedBy: row.changed_by,
+      timestamp: row.created_at
+    }));
+  }
+
+  static formatHistoryEntry(row) {
+    return {
+      id: row.id,
+      entityType: row.entity_type,
+      entityId: row.entity_id,
+      dealId: row.deal_id,
+      lineItemId: row.line_item_id,
+      action: row.action,
+      field: row.field_name,
+      fieldLabel: FIELD_LABELS[row.field_name] || row.field_name,
+      previousValue: row.previous_value,
+      currentValue: row.current_value,
+      changedBy: row.changed_by,
+      changedByEmail: row.changed_by_email,
+      requestId: row.request_id,
+      summary: row.summary,
+      metadata: row.metadata,
+      timestamp: row.created_at
+    };
+  }
+
+  static extractContext(req) {
+    return {
+      userId: req.headers['x-user-id'] || req.headers['x-changed-by'],
+      userEmail: req.headers['x-user-email'],
+      requestId: req.requestId,
+      ipAddress: req.ip || req.headers['x-forwarded-for'],
+      userAgent: req.headers['user-agent']
+    };
+  }
+}
+
+export default ChangeHistoryService;

package/PCM/src/services/DealIdService.js

@@ -0,0 +1,94 @@
+import DealIdCounter from '../models/DealIdCounter.js';
+import sequelize from '../config/db.js';
+
+const DEAL_TYPE_PREFIXES = {
+  'GUARANTEED': 'GD',
+  'PREFERRED_DEAL': 'PD',
+  'PRIVATE_AUCTION': 'PA',
+  'EVERGREEN_PMP': 'EG'
+};
+
+const MODE_PREFIX = {
+  'DIRECT': 'DIR'
+};
+
+class DealIdService {
+  static getPrefix(dealType, mode) {
+    if (mode === 'DIRECT') {
+      return MODE_PREFIX['DIRECT'];
+    }
+    return DEAL_TYPE_PREFIXES[dealType] || 'GD';
+  }
+
+  static formatSequence(num) {
+    const padded = String(num).padStart(10, '0');
+    return `${padded.slice(0, 5)}-${padded.slice(5)}`;
+  }
+
+  static async generateDealId(dealType, mode, transaction = null) {
+    const prefix = this.getPrefix(dealType, mode);
+    
+    const executeWithTransaction = async (txn) => {
+      const counter = await DealIdCounter.findOne({
+        where: { prefix },
+        lock: true,
+        transaction: txn
+      });
+
+      if (!counter) {
+        await DealIdCounter.create({
+          prefix,
+          current_value: 1
+        }, { transaction: txn });
+        
+        return `${prefix}-I-${this.formatSequence(1)}`;
+      }
+
+      const newValue = parseInt(counter.current_value, 10) + 1;
+      await counter.update({ current_value: newValue }, { transaction: txn });
+      
+      return `${prefix}-I-${this.formatSequence(newValue)}`;
+    };
+
+    if (transaction) {
+      return executeWithTransaction(transaction);
+    } else {
+      return sequelize.transaction(executeWithTransaction);
+    }
+  }
+
+  static async getCurrentCounter(prefix) {
+    const counter = await DealIdCounter.findOne({
+      where: { prefix }
+    });
+    return counter ? parseInt(counter.current_value, 10) : 0;
+  }
+
+  static async resetCounter(prefix, value = 0) {
+    const counter = await DealIdCounter.findOne({
+      where: { prefix }
+    });
+    if (counter) {
+      await counter.update({ current_value: value });
+    }
+    return counter;
+  }
+
+  static isValidDealIdFormat(dealId) {
+    const pattern = /^(GD|PD|PA|EG|DIR)-I-\d{5}-\d{5}$/;
+    return pattern.test(dealId);
+  }
+
+  static parseDealId(dealId) {
+    const match = dealId.match(/^(GD|PD|PA|EG|DIR)-I-(\d{5})-(\d{5})$/);
+    if (!match) return null;
+    
+    return {
+      prefix: match[1],
+      identifier: 'I',
+      sequence: parseInt(match[2] + match[3], 10)
+    };
+  }
+}
+
+export default DealIdService;

package/PCM/src/services/DealResponseFormatter.js

@@ -0,0 +1,90 @@
+const DIRECT_FIELDS = ['brand', 'clientType', 'approvalEmails', 'marketSelection', 'budgetSetup', 'campaignGoal', 'planning'];
+const PROGRAMMATIC_FIELDS = ['buyers', 'auctionType', 'transactionType', 'costType', 'deliveryGoal', 'netCost', 'netCostPerDay', 'impressions', 'published', 'reopened', 'nonBillable', 'stopBidRequests', 'impMultiplierType'];
+const JSONB_FIELDS = ['seller', 'account', 'advertiser', 'publishers', 'metadata', 'targeting'];
+
+class DealResponseFormatter {
+  static formatDealResponse(deal, options = {}) {
+    const dealData = deal.toJSON ? deal.toJSON() : { ...deal };
+    const result = {};
+    
+    for (const [key, value] of Object.entries(dealData)) {
+      const camelKey = this.toCamelCase(key);
+      
+      if (DIRECT_FIELDS.includes(camelKey)) {
+        continue;
+      }
+      if (PROGRAMMATIC_FIELDS.includes(camelKey)) {
+        continue;
+      }
+      
+      if (JSONB_FIELDS.includes(camelKey) && value !== null && value !== undefined) {
+        result[camelKey] = this.deepToCamelCase(value);
+      } else {
+        result[camelKey] = value;
+      }
+    }
+    
+    const mode = dealData.mode || 'PROGRAMMATIC';
+    
+    if (mode === 'DIRECT') {
+      result.direct = {};
+      for (const field of DIRECT_FIELDS) {
+        const snakeField = this.toSnakeCase(field);
+        let fieldValue = dealData[snakeField] ?? dealData[field];
+        if (fieldValue !== undefined && fieldValue !== null) {
+          result.direct[field] = this.deepToCamelCase(fieldValue);
+        }
+      }
+      
+      if (options.campaignInventorySummary) {
+        result.direct.campaignInventorySummary = options.campaignInventorySummary;
+      }
+      
+      if (options.insertionOrders) {
+        result.insertionOrders = options.insertionOrders.map(io => this.deepToCamelCase(io));
+      }
+    } else {
+      result.programmatic = {};
+      for (const field of PROGRAMMATIC_FIELDS) {
+        const snakeField = this.toSnakeCase(field);
+        let fieldValue = dealData[snakeField] ?? dealData[field];
+        if (fieldValue !== undefined && fieldValue !== null) {
+          result.programmatic[field] = this.deepToCamelCase(fieldValue);
+        }
+      }
+    }
+    
+    return result;
+  }
+
+  static formatDealList(deals) {
+    return deals.map(deal => this.formatDealResponse(deal));
+  }
+
+  static deepToCamelCase(obj) {
+    if (obj === null || obj === undefined) return obj;
+    if (Array.isArray(obj)) {
+      return obj.map(item => this.deepToCamelCase(item));
+    }
+    if (typeof obj === 'object') {
+      const result = {};
+      for (const [key, value] of Object.entries(obj)) {
+        result[this.toCamelCase(key)] = this.deepToCamelCase(value);
+      }
+      return result;
+    }
+    return obj;
+  }
+
+  static toCamelCase(str) {
+    if (!str || typeof str !== 'string') return str;
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+  }
+
+  static toSnakeCase(str) {
+    if (!str || typeof str !== 'string') return str;
+    return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+  }
+}
+
+export default DealResponseFormatter;