adserver-dashboard 1.0.0

package/PCM/src/routes/deals.js

@@ -0,0 +1,1638 @@
+import express from 'express';
+import { Op } from 'sequelize';
+import { dealSchema, dealUpdateSchema, dealSyncSchema } from '../validators/dealValidator.js';
+import { lineItemSchema } from '../validators/lineItemValidator.js';
+import Deal from '../models/Deal.js';
+import LineItem from '../models/LineItem.js';
+import LineItemInventory from '../models/LineItemInventory.js';
+import LineItemCreative from '../models/LineItemCreative.js';
+import PublisherInsertionOrder from '../models/PublisherInsertionOrder.js';
+import sequelize from '../config/db.js';
+import { calculateDealMetrics } from '../utils/dealCalculations.js';
+import { toCamelCase, toSnakeCase, stripKeys } from '../utils/caseConverter.js';
+import { flattenPayload } from '../utils/payloadNormalizer.js';
+import CampaignModeService from '../services/CampaignModeService.js';
+import DealIdService from '../services/DealIdService.js';
+import DealResponseFormatter from '../services/DealResponseFormatter.js';
+import { CampaignImportConverter, PayloadType } from '../services/CampaignImportConverter.js';
+import ChangeHistoryService from '../services/ChangeHistoryService.js';
+import CampaignStatusService, { CAMPAIGN_STATUSES, WORKFLOW_TYPES, SOURCE_TYPES, TRANSITION_OWNERS } from '../services/CampaignStatusService.js';
+import LineItemStatusService, { LINE_ITEM_STATUSES } from '../services/LineItemStatusService.js';
+import { normalizeSource, validateSourceForImport, getSourceDisplayInfo, isInternalSource } from '../utils/sourceNormalizer.js';
+import ApprovalService from '../services/ApprovalService.js';
+
+const router = express.Router();
+
+const findDealByIdentifier = async (identifier) => {
+  let deal = await Deal.findOne({ where: { deal_id: identifier } });
+  
+  if (!deal && /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(identifier)) {
+    deal = await Deal.findOne({ where: { id: identifier } });
+  }
+  
+  return deal;
+};
+
+router.get('/', async (req, res, next) => {
+  try {
+    const page = parseInt(req.query.page) || 1;
+    const limit = parseInt(req.query.limit) || 10;
+    const offset = (page - 1) * limit;
+
+    const where = {};
+
+    if (req.query.search) {
+      const searchTerm = `%${req.query.search}%`;
+      where[Op.or] = [
+        { name: { [Op.iLike]: searchTerm } },
+        { deal_id: { [Op.iLike]: searchTerm } },
+        { external_id: { [Op.iLike]: searchTerm } },
+        { brand: { [Op.iLike]: searchTerm } }
+      ];
+    }
+
+    if (req.query.source) {
+      where.source = { [Op.iLike]: `%${req.query.source}%` };
+    }
+
+    if (req.query.mode) {
+      where.mode = req.query.mode.toUpperCase();
+    }
+
+    if (req.query.dealType) {
+      where.deal_type = req.query.dealType.toUpperCase();
+    }
+
+    if (req.query.status) {
+      where.status = req.query.status.toUpperCase();
+    }
+
+    if (req.query.currency) {
+      where.currency = req.query.currency.toUpperCase();
+    }
+
+    if (req.query.brand) {
+      where.brand = { [Op.iLike]: `%${req.query.brand}%` };
+    }
+
+    if (req.query.advertiser) {
+      where[Op.and] = where[Op.and] || [];
+      where[Op.and].push(
+        sequelize.where(
+          sequelize.cast(sequelize.col('advertiser'), 'text'),
+          { [Op.iLike]: `%${req.query.advertiser}%` }
+        )
+      );
+    }
+
+    if (req.query.seller) {
+      where[Op.and] = where[Op.and] || [];
+      where[Op.and].push(
+        sequelize.where(
+          sequelize.cast(sequelize.col('seller'), 'text'),
+          { [Op.iLike]: `%${req.query.seller}%` }
+        )
+      );
+    }
+
+    if (req.query.publisher) {
+      where[Op.and] = where[Op.and] || [];
+      where[Op.and].push(
+        sequelize.where(
+          sequelize.cast(sequelize.col('publishers'), 'text'),
+          { [Op.iLike]: `%${req.query.publisher}%` }
+        )
+      );
+    }
+
+    if (req.query.startDate) {
+      where.start_date = { [Op.gte]: req.query.startDate };
+    }
+
+    if (req.query.endDate) {
+      where.end_date = { [Op.lte]: req.query.endDate };
+    }
+
+    const { count, rows } = await Deal.findAndCountAll({
+      where,
+      limit,
+      offset,
+      order: [['created_at', 'DESC']]
+    });
+
+    const { publisherId } = req.query;
+    
+    // Format deals and include insertion orders for DIRECT deals
+    const deals = await Promise.all(rows.map(async (deal) => {
+      const formatOptions = {};
+      
+      // Always include insertion orders for DIRECT deals (filter by publisherId if provided)
+      if (deal.mode === 'DIRECT') {
+        const ioWhere = { deal_id: deal.deal_id };
+        if (publisherId) {
+          ioWhere.publisher_id = publisherId;
+        }
+        const insertionOrders = await PublisherInsertionOrder.findAll({ where: ioWhere });
+        formatOptions.insertionOrders = insertionOrders.map(io => io.toJSON());
+      }
+      
+      return DealResponseFormatter.formatDealResponse(deal, formatOptions);
+    }));
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        data: deals,
+        pagination: {
+          page,
+          limit,
+          total: count,
+          totalPages: Math.ceil(count / limit)
+        }
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post('/', async (req, res, next) => {
+  try {
+    const bodyInCamelCase = toCamelCase(req.body);
+    const flattenedBody = flattenPayload(bodyInCamelCase);
+    
+    const originalAuctionType = flattenedBody.auctionType;
+    const originalCostType = flattenedBody.costType;
+    
+    const dataWithDefaults = CampaignModeService.applyDefaults(flattenedBody);
+    
+    const { error, value } = dealSchema.validate(dataWithDefaults);
+    if (error) {
+      error.name = 'ValidationError';
+      return next(error);
+    }
+
+    const modeValidation = CampaignModeService.validateDirectModeFields(value);
+    if (!modeValidation.valid) {
+      const validationError = new Error('Campaign mode validation failed');
+      validationError.name = 'ValidationError';
+      validationError.details = modeValidation.errors.map(e => ({
+        message: e.message,
+        path: [e.field],
+        type: 'campaign.mode.required'
+      }));
+      return next(validationError);
+    }
+
+    const auctionValidation = CampaignModeService.validateAuctionType(value.dealType, originalAuctionType);
+    if (!auctionValidation.valid) {
+      const validationError = new Error(auctionValidation.error);
+      validationError.name = 'ValidationError';
+      validationError.details = [{ message: auctionValidation.error, path: ['auctionType'], type: 'auction.type.invalid' }];
+      return next(validationError);
+    }
+
+    const costTypeValidation = CampaignModeService.validateCostType(value.dealType, originalCostType);
+    if (!costTypeValidation.valid) {
+      const validationError = new Error(costTypeValidation.error);
+      validationError.name = 'ValidationError';
+      validationError.details = [{ message: costTypeValidation.error, path: ['costType'], type: 'cost.type.invalid' }];
+      return next(validationError);
+    }
+
+    const dealData = toSnakeCase(value);
+
+    if (dealData.external_id) {
+      const existingDeal = await Deal.findOne({
+        where: { source: dealData.source, external_id: dealData.external_id }
+      });
+
+      if (existingDeal) {
+        return res.status(409).json({
+          code: 'CONFLICT',
+          message: 'Deal already exists'
+        });
+      }
+    }
+
+    const generatedDealId = await DealIdService.generateDealId(value.dealType, value.mode);
+    dealData.deal_id = generatedDealId;
+
+    const deal = await Deal.create(dealData);
+
+    await ChangeHistoryService.trackCreate('DEAL', deal, ChangeHistoryService.extractContext(req));
+
+    res.status(201).json({
+      requestId: req.requestId,
+      status: 201,
+      result: {
+        id: deal.id,
+        dealId: deal.deal_id,
+        source: deal.source,
+        externalId: deal.external_id,
+        status: deal.status,
+        createdAt: deal.created_at,
+        updatedAt: deal.updated_at,
+        version: deal.version
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.get('/:dealId', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+    const { embed, publisherId } = req.query;
+
+    let deal = await Deal.findOne({ where: { deal_id: dealId } });
+
+    if (!deal && /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(dealId)) {
+      deal = await Deal.findOne({ where: { id: dealId } });
+    }
+
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    const formatOptions = {};
+    
+    // Always include insertion orders for DIRECT deals (filter by publisherId if provided)
+    if (deal.mode === 'DIRECT') {
+      const ioWhere = { deal_id: deal.deal_id };
+      if (publisherId) {
+        ioWhere.publisher_id = publisherId;
+      }
+      const insertionOrders = await PublisherInsertionOrder.findAll({ where: ioWhere });
+      formatOptions.insertionOrders = insertionOrders.map(io => io.toJSON());
+    }
+
+    const result = DealResponseFormatter.formatDealResponse(deal, formatOptions);
+
+    const embedList = embed ? embed.split(',') : [];
+    if (embedList.includes('lineItems')) {
+      const lineItemWhere = { deal_id: deal.deal_id };
+      if (publisherId) {
+        lineItemWhere.publisher_id = publisherId;
+      }
+      const lineItems = await LineItem.findAll({ where: lineItemWhere });
+      result.lineItems = lineItems.map(li => toCamelCase(li.toJSON()));
+    }
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.put('/:dealId', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+    const bodyInCamelCase = toCamelCase(req.body);
+    const flattenedBody = flattenPayload(bodyInCamelCase);
+    const { error, value } = dealUpdateSchema.validate(flattenedBody);
+    
+    if (error) {
+      error.name = 'ValidationError';
+      return next(error);
+    }
+
+    let deal = await Deal.findOne({ where: { deal_id: dealId } });
+
+    if (!deal && /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(dealId)) {
+      deal = await Deal.findOne({ where: { id: dealId } });
+    }
+
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    const editableStatuses = ['REQUESTED', 'GENERATED', 'PENDING'];
+    const isStatusOnlyUpdate = Object.keys(value).length === 1 && value.status !== undefined;
+    
+    if (deal.mode === 'PROGRAMMATIC' && !editableStatuses.includes(deal.status) && !isStatusOnlyUpdate) {
+      return res.status(400).json({
+        code: 'VALIDATION_ERROR',
+        message: `PROGRAMMATIC deals can only be edited when status is REQUESTED, GENERATED, or PENDING. Current status: ${deal.status}`
+      });
+    }
+
+    if (['APPROVED', 'LIVE'].includes(deal.status) && 
+        (value.dealType || value.startDate || value.endDate)) {
+      return res.status(400).json({
+        code: 'VALIDATION_ERROR',
+        message: 'Cannot update immutable fields for APPROVED or LIVE deals'
+      });
+    }
+
+    const currentMode = deal.mode;
+    const newMode = value.mode || currentMode;
+    
+    const existingDealCamel = toCamelCase(deal.toJSON());
+    
+    if (CampaignModeService.isDirectMode(newMode)) {
+      const mergedData = {
+        brand: value.brand !== undefined ? value.brand : existingDealCamel.brand,
+        clientType: value.clientType !== undefined ? value.clientType : existingDealCamel.clientType,
+        mode: newMode,
+        approvalEmails: value.approvalEmails !== undefined ? value.approvalEmails : existingDealCamel.approvalEmails,
+        marketSelection: value.marketSelection !== undefined ? value.marketSelection : existingDealCamel.marketSelection,
+        budgetSetup: value.budgetSetup !== undefined ? value.budgetSetup : existingDealCamel.budgetSetup,
+        campaignGoal: value.campaignGoal !== undefined ? value.campaignGoal : existingDealCamel.campaignGoal
+      };
+      
+      const modeValidation = CampaignModeService.validateDirectModeFields(mergedData);
+      if (!modeValidation.valid) {
+        const validationError = new Error('DIRECT mode requires all campaign mode fields');
+        validationError.name = 'ValidationError';
+        validationError.details = modeValidation.errors.map(e => ({
+          message: e.message,
+          path: [e.field],
+          type: 'campaign.mode.required'
+        }));
+        return next(validationError);
+      }
+    }
+    
+    let sanitizedValue = { ...value };
+    if (currentMode === 'DIRECT' && newMode === 'PROGRAMMATIC') {
+      sanitizedValue.approvalEmails = null;
+      sanitizedValue.marketSelection = null;
+      sanitizedValue.budgetSetup = null;
+      sanitizedValue.campaignGoal = null;
+    }
+
+    if (CampaignModeService.isProgrammaticMode(newMode)) {
+      const effectiveDealType = value.dealType || deal.deal_type;
+      const effectiveAuctionType = value.auctionType !== undefined ? value.auctionType : deal.auction_type;
+      const effectiveCostType = value.costType !== undefined ? value.costType : deal.cost_type;
+      
+      const auctionValidation = CampaignModeService.validateAuctionType(effectiveDealType, effectiveAuctionType);
+      if (!auctionValidation.valid) {
+        const validationError = new Error(auctionValidation.error);
+        validationError.name = 'ValidationError';
+        validationError.details = [{ message: auctionValidation.error, path: ['auctionType'], type: 'auction.type.invalid' }];
+        return next(validationError);
+      }
+
+      const costTypeValidation = CampaignModeService.validateCostType(effectiveDealType, effectiveCostType);
+      if (!costTypeValidation.valid) {
+        const validationError = new Error(costTypeValidation.error);
+        validationError.name = 'ValidationError';
+        validationError.details = [{ message: costTypeValidation.error, path: ['costType'], type: 'cost.type.invalid' }];
+        return next(validationError);
+      }
+      
+      if (value.dealType && !value.auctionType) {
+        sanitizedValue.auctionType = CampaignModeService.getDefaultAuctionType(value.dealType, effectiveAuctionType);
+      }
+    }
+
+    const updateData = toSnakeCase(sanitizedValue);
+    updateData.version = deal.version + 1;
+
+    const previousData = deal.toJSON();
+    await deal.update(updateData);
+    await ChangeHistoryService.trackUpdate('DEAL', previousData, deal, ChangeHistoryService.extractContext(req));
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        id: deal.id,
+        dealId: deal.deal_id,
+        status: deal.status,
+        version: deal.version,
+        updatedAt: deal.updated_at
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.delete('/:dealId', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+
+    let deal = await Deal.findOne({ where: { deal_id: dealId } });
+
+    if (!deal && /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(dealId)) {
+      deal = await Deal.findOne({ where: { id: dealId } });
+    }
+
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    const previousData = deal.toJSON();
+    await deal.update({ status: 'ARCHIVED' });
+    await ChangeHistoryService.trackUpdate('DEAL', previousData, deal, ChangeHistoryService.extractContext(req));
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        dealId: deal.deal_id,
+        status: 'ARCHIVED'
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post('/:dealId/status', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+    const { status: newStatus, owner, reason } = req.body;
+
+    if (!newStatus) {
+      return res.status(400).json({
+        code: 'VALIDATION_ERROR',
+        message: 'Status is required'
+      });
+    }
+
+    const validStatuses = Object.values(CAMPAIGN_STATUSES);
+    if (!validStatuses.includes(newStatus.toUpperCase())) {
+      return res.status(400).json({
+        code: 'VALIDATION_ERROR',
+        message: `Invalid status. Valid values: ${validStatuses.join(', ')}`
+      });
+    }
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    const transitionOwner = owner || TRANSITION_OWNERS.USER;
+    const sourceType = normalizeSource(deal.source);
+    const workflowType = deal.mode === 'PROGRAMMATIC' ? WORKFLOW_TYPES.PROGRAMMATIC : WORKFLOW_TYPES.DIRECT;
+
+    const validation = CampaignStatusService.validateTransition(
+      { status: deal.status, source: sourceType, mode: workflowType },
+      newStatus.toUpperCase(),
+      { owner: transitionOwner, source: sourceType, workflow: workflowType }
+    );
+
+    if (!validation.valid) {
+      return res.status(400).json({
+        code: 'INVALID_STATUS_TRANSITION',
+        message: validation.errors[0]?.message || 'Invalid status transition',
+        errors: validation.errors,
+        currentStatus: deal.status,
+        requestedStatus: newStatus.toUpperCase(),
+        allowedTransitions: CampaignStatusService.getValidTransitions(deal.status),
+        workflow: workflowType,
+        source: sourceType
+      });
+    }
+
+    const previousData = deal.toJSON();
+    await deal.update({ 
+      status: newStatus.toUpperCase(),
+      version: deal.version + 1
+    });
+    await ChangeHistoryService.trackUpdate('DEAL', previousData, deal, {
+      ...ChangeHistoryService.extractContext(req),
+      transitionOwner,
+      reason
+    });
+
+    let cascadedLineItems = [];
+    let skippedLineItems = [];
+    const cascadeStatus = LineItemStatusService.getCascadeStatus(newStatus.toUpperCase());
+    if (cascadeStatus && LineItemStatusService.shouldCascadeStatus(newStatus.toUpperCase())) {
+      const lineItems = await LineItem.findAll({ where: { deal_id: deal.deal_id } });
+      
+      for (const li of lineItems) {
+        if (li.status === cascadeStatus) continue;
+        if (li.status === 'ARCHIVED') {
+          skippedLineItems.push({
+            lineItemId: li.id,
+            externalId: li.external_id,
+            reason: 'Archived line items are not updated by cascade'
+          });
+          continue;
+        }
+
+        const validation = LineItemStatusService.validateTransition(
+          { status: li.status, source: sourceType },
+          cascadeStatus,
+          { owner: TRANSITION_OWNERS.ADMIN, source: sourceType, campaignStatus: newStatus.toUpperCase() }
+        );
+
+        if (!validation.valid) {
+          skippedLineItems.push({
+            lineItemId: li.id,
+            externalId: li.external_id,
+            reason: validation.errors[0]?.message || 'Invalid transition'
+          });
+          continue;
+        }
+
+        const liPrevious = li.status;
+        await li.update({ status: cascadeStatus });
+        cascadedLineItems.push({
+          lineItemId: li.id,
+          externalId: li.external_id,
+          previousStatus: liPrevious,
+          currentStatus: cascadeStatus
+        });
+      }
+    }
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        id: deal.id,
+        dealId: deal.deal_id,
+        previousStatus: previousData.status,
+        currentStatus: deal.status,
+        workflow: workflowType,
+        source: sourceType,
+        transitionOwner,
+        reason,
+        version: deal.version,
+        updatedAt: deal.updated_at,
+        cascadedLineItems: cascadedLineItems.length > 0 ? cascadedLineItems : undefined,
+        skippedLineItems: skippedLineItems.length > 0 ? skippedLineItems : undefined
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post('/:dealId/reopen', async (req, res, next) => {
+  const transaction = await sequelize.transaction();
+  
+  try {
+    const { dealId } = req.params;
+    const { reason } = req.body;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      await transaction.rollback();
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    if (deal.mode !== 'DIRECT') {
+      await transaction.rollback();
+      return res.status(400).json({
+        code: 'INVALID_MODE',
+        message: 'Reopen is only available for DIRECT deals'
+      });
+    }
+
+    if (!CampaignStatusService.canReopen(deal.status)) {
+      await transaction.rollback();
+      return res.status(400).json({
+        code: 'CANNOT_REOPEN',
+        message: `Cannot reopen deal with status ${deal.status}`,
+        currentStatus: deal.status,
+        allowedStatuses: ['APPROVED', 'LIVE', 'COMPLETED', 'EXPIRED', 'REJECTED', 'ARCHIVED']
+      });
+    }
+
+    const sourceType = normalizeSource(deal.source);
+    const workflowType = WORKFLOW_TYPES.DIRECT;
+
+    const validation = CampaignStatusService.validateTransition(
+      { status: deal.status, source: sourceType, mode: workflowType },
+      'REOPENED',
+      { owner: TRANSITION_OWNERS.USER, source: sourceType, workflow: workflowType }
+    );
+
+    if (!validation.valid) {
+      await transaction.rollback();
+      return res.status(400).json({
+        code: 'INVALID_STATUS_TRANSITION',
+        message: validation.errors[0]?.message || 'Invalid status transition',
+        errors: validation.errors,
+        currentStatus: deal.status,
+        requestedStatus: 'REOPENED'
+      });
+    }
+
+    const previousData = deal.toJSON();
+    await deal.update({ 
+      status: 'REOPENED',
+      version: deal.version + 1
+    }, { transaction });
+
+    await ChangeHistoryService.trackUpdate('DEAL', previousData, deal, {
+      ...ChangeHistoryService.extractContext(req),
+      transitionOwner: TRANSITION_OWNERS.USER,
+      reason
+    });
+
+    let cascadedLineItems = [];
+    let skippedLineItems = [];
+    const lineItems = await LineItem.findAll({ where: { deal_id: deal.deal_id }, transaction });
+    
+    for (const li of lineItems) {
+      if (li.status === 'REOPENED') {
+        skippedLineItems.push({
+          lineItemId: li.id,
+          externalId: li.external_id,
+          reason: 'Already in REOPENED status'
+        });
+        continue;
+      }
+      if (li.status === 'ARCHIVED') {
+        skippedLineItems.push({
+          lineItemId: li.id,
+          externalId: li.external_id,
+          reason: 'Archived line items are not updated by reopen'
+        });
+        continue;
+      }
+
+      const liValidation = LineItemStatusService.validateTransition(
+        { status: li.status, source: sourceType },
+        'REOPENED',
+        { owner: TRANSITION_OWNERS.ADMIN, source: sourceType, campaignStatus: 'REOPENED', isReopenCascade: true }
+      );
+
+      if (!liValidation.valid) {
+        skippedLineItems.push({
+          lineItemId: li.id,
+          externalId: li.external_id,
+          reason: liValidation.errors[0]?.message || 'Invalid transition'
+        });
+        continue;
+      }
+
+      const liPrevious = li.status;
+      await li.update({ status: 'REOPENED' }, { transaction });
+      cascadedLineItems.push({
+        lineItemId: li.id,
+        externalId: li.external_id,
+        previousStatus: liPrevious,
+        currentStatus: 'REOPENED'
+      });
+    }
+
+    await transaction.commit();
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        id: deal.id,
+        dealId: deal.deal_id,
+        previousStatus: previousData.status,
+        currentStatus: 'REOPENED',
+        reason,
+        version: deal.version,
+        updatedAt: deal.updated_at,
+        cascadedLineItems: cascadedLineItems.length > 0 ? cascadedLineItems : undefined,
+        skippedLineItems: skippedLineItems.length > 0 ? skippedLineItems : undefined
+      }
+    });
+  } catch (error) {
+    await transaction.rollback();
+    next(error);
+  }
+});
+
+router.get('/:dealId/status/transitions', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    const sourceType = normalizeSource(deal.source);
+    const workflowType = deal.mode === 'PROGRAMMATIC' ? WORKFLOW_TYPES.PROGRAMMATIC : WORKFLOW_TYPES.DIRECT;
+
+    const validTransitions = CampaignStatusService.getValidTransitions(deal.status);
+    const editableFields = CampaignStatusService.getEditableFields(deal.status, sourceType, workflowType);
+    const statusDefinition = CampaignStatusService.getStatusDefinition(deal.status, workflowType);
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        dealId: deal.deal_id,
+        currentStatus: deal.status,
+        workflow: workflowType,
+        source: sourceType,
+        statusDefinition,
+        validTransitions,
+        editableFields,
+        canReopen: CampaignStatusService.canReopen(deal.status),
+        workflowRules: CampaignStatusService.getWorkflowRules(),
+        transitionOwnership: CampaignStatusService.getTransitionOwnership()
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.get('/status/definitions', async (req, res) => {
+  const { workflow } = req.query;
+  const workflowType = workflow?.toUpperCase() === 'PROGRAMMATIC' ? WORKFLOW_TYPES.PROGRAMMATIC : WORKFLOW_TYPES.DIRECT;
+
+  const definitions = {};
+  for (const status of Object.values(CAMPAIGN_STATUSES)) {
+    definitions[status] = CampaignStatusService.getStatusDefinition(status, workflowType);
+  }
+
+  res.json({
+    requestId: req.requestId,
+    status: 200,
+    result: {
+      workflow: workflowType,
+      statuses: CAMPAIGN_STATUSES,
+      definitions,
+      transitionOwnership: CampaignStatusService.getTransitionOwnership(),
+      workflowRules: CampaignStatusService.getWorkflowRules()
+    }
+  });
+});
+
+router.post('/:dealId/approval/request', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+    const { frontendUrl } = req.body;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    if (deal.mode !== 'DIRECT') {
+      return res.status(400).json({
+        code: 'INVALID_MODE',
+        message: 'Approval workflow is only available for DIRECT campaigns'
+      });
+    }
+
+    const emails = deal.approval_emails || [];
+    
+    if (emails.length === 0) {
+      const result = await ApprovalService.autoApprove(deal.deal_id, req.requestId);
+      return res.json({
+        requestId: req.requestId,
+        status: 200,
+        result
+      });
+    }
+
+    const result = await ApprovalService.initiateApprovalWorkflow(deal.deal_id, emails, req.requestId, { frontendUrl });
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.get('/:dealId/approval/history', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    const history = await ApprovalService.getApprovalHistory(deal.deal_id);
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        dealId: deal.deal_id,
+        approvalHistory: history,
+        summary: {
+          total: history.length,
+          pending: history.filter(h => h.status === 'PENDING').length,
+          approved: history.filter(h => h.status === 'APPROVED').length,
+          rejected: history.filter(h => h.status === 'REJECTED').length
+        }
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post('/:dealId/approval/resend', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+    const { frontendUrl, emails } = req.body;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    const result = await ApprovalService.resendApprovalEmails(deal.deal_id, req.requestId, { 
+      frontendUrl, 
+      emails 
+    });
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result
+    });
+  } catch (error) {
+    if (error.statusCode) {
+      return res.status(error.statusCode).json({
+        code: error.code || 'ERROR',
+        message: error.message
+      });
+    }
+    next(error);
+  }
+});
+
+router.post('/sync', async (req, res, next) => {
+  try {
+    const syncData = req.body;
+
+    if (!Array.isArray(syncData)) {
+      return res.status(400).json({
+        code: 'VALIDATION_ERROR',
+        message: 'Sync payload must be an array'
+      });
+    }
+
+    const results = [];
+
+    for (const item of syncData) {
+      const { deal, line_items } = item;
+
+      if (!deal) {
+        results.push({
+          success: false,
+          error: 'Missing deal object'
+        });
+        continue;
+      }
+
+      const transaction = await sequelize.transaction();
+      
+      try {
+        const dealCamel = toCamelCase(deal);
+        const flattenedDeal = flattenPayload(dealCamel);
+        
+        const { error: dealValidationError, value: validatedDeal } = dealSyncSchema.validate(flattenedDeal, { abortEarly: false, stripUnknown: true });
+        if (dealValidationError) {
+          throw new Error(`Deal validation failed: ${dealValidationError.details.map(d => d.message).join(', ')}`);
+        }
+        
+        const dealWithDefaults = CampaignModeService.applyDefaults(validatedDeal);
+
+        // Find existing deal by unique constraint (source + external_id)
+        let dealRecord = await Deal.findOne({
+          where: {
+            source: deal.source || dealWithDefaults.source,
+            external_id: deal.external_id || deal.externalId || dealWithDefaults.externalId
+          },
+          transaction
+        });
+
+        let finalDealData = dealWithDefaults;
+        
+        if (dealRecord) {
+          if (dealWithDefaults.dealId && dealWithDefaults.dealId !== dealRecord.deal_id) {
+            throw new Error(`Cannot change deal ID of existing deal. Current ID: ${dealRecord.deal_id}, Attempted: ${dealWithDefaults.dealId}`);
+          }
+          
+          const existingDealCamel = toCamelCase(dealRecord.toJSON());
+          const currentMode = existingDealCamel.mode;
+          const newMode = dealWithDefaults.mode || currentMode;
+          
+          // Validate DIRECT mode requirements on update
+          if (CampaignModeService.isDirectMode(newMode)) {
+            const mergedData = {
+              brand: dealWithDefaults.brand !== undefined ? dealWithDefaults.brand : existingDealCamel.brand,
+              clientType: dealWithDefaults.clientType !== undefined ? dealWithDefaults.clientType : existingDealCamel.clientType,
+              mode: newMode,
+              approvalEmails: dealWithDefaults.approvalEmails !== undefined ? dealWithDefaults.approvalEmails : existingDealCamel.approvalEmails,
+              marketSelection: dealWithDefaults.marketSelection !== undefined ? dealWithDefaults.marketSelection : existingDealCamel.marketSelection,
+              budgetSetup: dealWithDefaults.budgetSetup !== undefined ? dealWithDefaults.budgetSetup : existingDealCamel.budgetSetup,
+              campaignGoal: dealWithDefaults.campaignGoal !== undefined ? dealWithDefaults.campaignGoal : existingDealCamel.campaignGoal
+            };
+            
+            const modeValidation = CampaignModeService.validateDirectModeFields(mergedData);
+            if (!modeValidation.valid) {
+              throw new Error(`DIRECT mode validation failed: ${modeValidation.errors.map(e => e.message).join(', ')}`);
+            }
+          }
+          
+          // Sanitize when switching from DIRECT to PROGRAMMATIC
+          if (currentMode === 'DIRECT' && newMode === 'PROGRAMMATIC') {
+            finalDealData = { ...dealWithDefaults };
+            finalDealData.approvalEmails = null;
+            finalDealData.marketSelection = null;
+            finalDealData.budgetSetup = null;
+            finalDealData.campaignGoal = null;
+          }
+          
+          const sanitizedForUpdate = stripKeys(finalDealData, ['dealId', 'deal_id', 'id']);
+          const dealData = toSnakeCase(sanitizedForUpdate);
+          await dealRecord.update(dealData, { transaction });
+        } else {
+          // Validate DIRECT mode requirements on create
+          if (CampaignModeService.isDirectMode(dealWithDefaults.mode)) {
+            const modeValidation = CampaignModeService.validateDirectModeFields(dealWithDefaults);
+            if (!modeValidation.valid) {
+              throw new Error(`DIRECT mode validation failed: ${modeValidation.errors.map(e => e.message).join(', ')}`);
+            }
+          }
+          
+          const dealData = toSnakeCase(finalDealData);
+          
+          if (!dealData.deal_id) {
+            const generatedDealId = await DealIdService.generateDealId(
+              dealWithDefaults.dealType || 'GUARANTEED',
+              dealWithDefaults.mode,
+              transaction
+            );
+            dealData.deal_id = generatedDealId;
+          } else {
+            if (!DealIdService.isValidDealIdFormat(dealData.deal_id)) {
+              throw new Error(`Invalid deal ID format: ${dealData.deal_id}. Expected format: {PREFIX}-I-XXXXX-XXXXX where PREFIX is GD, PD, PA, EG, or DIR`);
+            }
+            
+            const existingDealWithId = await Deal.findOne({
+              where: { deal_id: dealData.deal_id },
+              transaction
+            });
+            if (existingDealWithId) {
+              throw new Error(`Deal ID ${dealData.deal_id} already exists`);
+            }
+          }
+          
+          dealRecord = await Deal.create(dealData, { transaction });
+        }
+
+        let lineItemsProcessed = 0;
+        let inventoriesProcessed = 0;
+        let creativesProcessed = 0;
+
+        if (line_items && Array.isArray(line_items)) {
+          for (const lineItemData of line_items) {
+            const { line_item, inventories, creatives } = lineItemData;
+
+            if (line_item) {
+              // Validate line item using Joi schema
+              const lineItemCamelCase = toCamelCase(line_item);
+              const { error: lineItemError } = lineItemSchema.validate(lineItemCamelCase);
+              
+              if (lineItemError) {
+                throw new Error(`Line item validation failed: ${lineItemError.message}`);
+              }
+              
+              const lineItemPayload = toSnakeCase(line_item);
+              lineItemPayload.deal_id = dealRecord.deal_id;
+              lineItemPayload.source = dealRecord.source;
+
+              // Find existing line item by unique constraint (source + external_id)
+              let lineItemRecord = await LineItem.findOne({
+                where: {
+                  source: lineItemPayload.source,
+                  external_id: lineItemPayload.external_id
+                },
+                transaction
+              });
+
+              if (lineItemRecord) {
+                // Update existing line item (exclude id and other non-updatable fields)
+                const { id, ...updatePayload } = lineItemPayload;
+                await lineItemRecord.update(updatePayload, { transaction });
+              } else {
+                // Create new line item
+                lineItemRecord = await LineItem.create(lineItemPayload, { transaction });
+              }
+              lineItemsProcessed++;
+
+              if (inventories && Array.isArray(inventories)) {
+                for (const inventory of inventories) {
+                  const inventoryPayload = toSnakeCase(inventory);
+                  inventoryPayload.line_item_id = lineItemRecord.id;
+                  inventoryPayload.deal_id = dealRecord.deal_id;
+
+                  await LineItemInventory.upsert(inventoryPayload, {
+                    transaction
+                  });
+                  inventoriesProcessed++;
+                }
+              }
+
+              if (creatives && Array.isArray(creatives)) {
+                for (const creative of creatives) {
+                  const creativePayload = toSnakeCase(creative);
+                  creativePayload.line_item_id = lineItemRecord.id;
+                  creativePayload.deal_id = dealRecord.deal_id;
+
+                  // Find existing creative by unique constraint (creative_id + deal_id)
+                  let creativeRecord = await LineItemCreative.findOne({
+                    where: {
+                      creative_id: creativePayload.creative_id,
+                      deal_id: creativePayload.deal_id
+                    },
+                    transaction
+                  });
+
+                  if (creativeRecord) {
+                    // Update existing creative (exclude id from update)
+                    const { id, ...updateCreativePayload } = creativePayload;
+                    await creativeRecord.update(updateCreativePayload, { transaction });
+                  } else {
+                    // Create new creative
+                    await LineItemCreative.create(creativePayload, { transaction });
+                  }
+                  creativesProcessed++;
+                }
+              }
+            }
+          }
+        }
+
+        // Auto-calculate deal metrics from line items (including publishers from inventories)
+        if (lineItemsProcessed > 0) {
+          const lineItemRecords = await LineItem.findAll({
+            where: { deal_id: dealRecord.deal_id },
+            include: [{
+              model: LineItemInventory,
+              as: 'inventories'
+            }],
+            transaction
+          });
+          
+          const calculatedMetrics = calculateDealMetrics(lineItemRecords.map(li => li.toJSON()), dealRecord.mode || 'PROGRAMMATIC');
+          await dealRecord.update(calculatedMetrics, { transaction });
+        }
+
+        await transaction.commit();
+
+        results.push({
+          success: true,
+          deal_id: dealRecord.deal_id,
+          line_items_processed: lineItemsProcessed,
+          inventories_processed: inventoriesProcessed,
+          creatives_processed: creativesProcessed
+        });
+      } catch (error) {
+        await transaction.rollback();
+        
+        results.push({
+          success: false,
+          deal_id: deal?.deal_id || deal?.external_id || 'unknown',
+          error: error.message,
+          error_type: error.name
+        });
+      }
+    }
+
+    const successCount = results.filter(r => r.success).length;
+    const failureCount = results.filter(r => !r.success).length;
+
+    const httpStatus = failureCount > 0 && successCount === 0 ? 400 : 200;
+
+    res.status(httpStatus).json({
+      requestId: req.requestId,
+      status: httpStatus,
+      result: {
+        total: results.length,
+        successful: successCount,
+        failed: failureCount,
+        items: results.length === 1 ? results[0] : results
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.get('/:dealId/inventories/minified', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    const inventories = await LineItemInventory.findAll({
+      where: { deal_id: deal.deal_id },
+      attributes: ['id', 'name', 'publisher_id', 'publisher_name', 'publisher_external_id', 'size'],
+      order: [['name', 'ASC']]
+    });
+
+    const uniqueInventories = new Map();
+    for (const inv of inventories) {
+      if (!uniqueInventories.has(inv.id)) {
+        uniqueInventories.set(inv.id, {
+          id: inv.id,
+          name: inv.name,
+          publisher: {
+            id: inv.publisher_id,
+            name: inv.publisher_name,
+            externalId: inv.publisher_external_id || null
+          },
+          resolution: inv.size
+        });
+      }
+    }
+
+    const minifiedInventories = Array.from(uniqueInventories.values());
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        data: minifiedInventories,
+        total: minifiedInventories.length
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post('/import/convert', async (req, res, next) => {
+  try {
+    const { payloadType, externalPayload, options = {} } = req.body;
+    
+    if (!payloadType) {
+      return res.status(400).json({
+        code: 'VALIDATION_ERROR',
+        message: 'payloadType is required. Valid values: PROGRAMMATIC_STANDARD, DIRECT_STANDARD, DIRECT_PUBLISHER_SPLIT'
+      });
+    }
+    
+    if (!Object.values(PayloadType).includes(payloadType)) {
+      return res.status(400).json({
+        code: 'VALIDATION_ERROR',
+        message: `Invalid payloadType: ${payloadType}. Valid values: ${Object.values(PayloadType).join(', ')}`
+      });
+    }
+    
+    if (!externalPayload) {
+      return res.status(400).json({
+        code: 'VALIDATION_ERROR',
+        message: 'externalPayload is required'
+      });
+    }
+    
+    const validation = CampaignImportConverter.validateExternalPayload(externalPayload, payloadType);
+    if (!validation.valid) {
+      return res.status(400).json({
+        code: 'VALIDATION_ERROR',
+        message: 'External payload validation failed',
+        errors: validation.errors
+      });
+    }
+    
+    const convertedResult = CampaignImportConverter.convert(externalPayload, payloadType, options);
+    
+    const syncPayload = CampaignImportConverter.toSyncPayload(convertedResult);
+    
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        converted: convertedResult,
+        syncPayload,
+        metadata: convertedResult.metadata
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post('/import', async (req, res, next) => {
+  try {
+    const { payloadType, externalPayload, options = {} } = req.body;
+
+    console.log('[Import] External Platform Request Payload:', JSON.stringify({
+      payloadType,
+      externalPayloadSize: externalPayload ? JSON.stringify(externalPayload).length : 0,
+      externalPayload: externalPayload
+    }, null, 2));
+    
+    if (!payloadType) {
+      return res.status(400).json({
+        code: 'VALIDATION_ERROR',
+        message: 'payloadType is required. Valid values: PROGRAMMATIC_STANDARD, DIRECT_STANDARD, DIRECT_PUBLISHER_SPLIT'
+      });
+    }
+    
+    if (!Object.values(PayloadType).includes(payloadType)) {
+      return res.status(400).json({
+        code: 'VALIDATION_ERROR',
+        message: `Invalid payloadType: ${payloadType}. Valid values: ${Object.values(PayloadType).join(', ')}`
+      });
+    }
+    
+    if (!externalPayload) {
+      return res.status(400).json({
+        code: 'VALIDATION_ERROR',
+        message: 'externalPayload is required'
+      });
+    }
+    
+    const validation = CampaignImportConverter.validateExternalPayload(externalPayload, payloadType);
+    if (!validation.valid) {
+      return res.status(400).json({
+        code: 'VALIDATION_ERROR',
+        message: 'External payload validation failed',
+        errors: validation.errors
+      });
+    }
+    
+    const convertedResult = CampaignImportConverter.convert(externalPayload, payloadType, options);
+    const { deal: dealData, lineItems } = convertedResult;
+    
+    const transaction = await sequelize.transaction();
+    
+    try {
+      const dealCamel = toCamelCase(dealData);
+      const flattenedDeal = flattenPayload(dealCamel);
+      
+      const { error: dealValidationError, value: validatedDeal } = dealSyncSchema.validate(flattenedDeal, { abortEarly: false, stripUnknown: true });
+      if (dealValidationError) {
+        throw new Error(`Deal validation failed: ${dealValidationError.details.map(d => d.message).join(', ')}`);
+      }
+      
+      const dealWithDefaults = CampaignModeService.applyDefaults(validatedDeal);
+      
+      if (CampaignModeService.isDirectMode(dealWithDefaults.mode)) {
+        const modeValidation = CampaignModeService.validateDirectModeFields(dealWithDefaults);
+        if (!modeValidation.valid) {
+          throw new Error(`DIRECT mode validation failed: ${modeValidation.errors.map(e => e.message).join(', ')}`);
+        }
+      }
+      
+      const dealSnake = toSnakeCase(dealWithDefaults);
+      
+      let dealRecord = await Deal.findOne({
+        where: {
+          source: dealSnake.source,
+          external_id: dealSnake.external_id
+        },
+        transaction
+      });
+      
+      const isExistingDeal = !!dealRecord;
+      
+      if (dealRecord) {
+        // Upsert is ONLY allowed when the deal is in REOPENED status
+        if (dealRecord.status !== 'REOPENED') {
+          await transaction.rollback();
+          return res.status(409).json({
+            code: 'UPSERT_NOT_ALLOWED',
+            message: `Cannot update existing campaign. Deal ${dealRecord.deal_id} must be in REOPENED status to accept updates via import.`,
+            currentStatus: dealRecord.status,
+            requiredStatus: 'REOPENED',
+            dealId: dealRecord.deal_id,
+            hint: 'Use POST /deals/{dealId}/reopen to reopen the campaign before re-importing.'
+          });
+        }
+        
+        const sanitizedForUpdate = stripKeys(dealSnake, ['deal_id', 'id']);
+        await dealRecord.update(sanitizedForUpdate, { transaction });
+      } else {
+        if (!dealSnake.deal_id) {
+          const generatedDealId = await DealIdService.generateDealId(
+            dealWithDefaults.dealType || 'GUARANTEED',
+            dealWithDefaults.mode,
+            transaction
+          );
+          dealSnake.deal_id = generatedDealId;
+        }
+        dealRecord = await Deal.create(dealSnake, { transaction });
+      }
+      
+      let lineItemsProcessed = 0;
+      let lineItemsArchived = 0;
+      let inventoriesProcessed = 0;
+      let insertionOrdersCreated = 0;
+      let insertionOrdersArchived = 0;
+      
+      // Track which line item externalIds are in the current payload
+      const incomingLineItemExternalIds = new Set(lineItems.map(li => li.externalId));
+      
+      // Track which publishers are in the current payload
+      const incomingPublisherIds = new Set(
+        convertedResult.metadata?.publisherBreakdown?.map(p => p.publisherId) || []
+      );
+      
+      if (payloadType === PayloadType.DIRECT_PUBLISHER_SPLIT && convertedResult.metadata?.publisherBreakdown) {
+        const publisherLineItemMap = {};
+        for (const li of lineItems) {
+          const pubId = li.publisherId;
+          if (pubId) {
+            if (!publisherLineItemMap[pubId]) {
+              publisherLineItemMap[pubId] = [];
+            }
+            publisherLineItemMap[pubId].push(li);
+          }
+        }
+        
+        for (const pubInfo of convertedResult.metadata.publisherBreakdown) {
+          const pubLineItems = publisherLineItemMap[pubInfo.publisherId] || [];
+          
+          const pubStartDates = pubLineItems.map(li => li.startDate).filter(Boolean);
+          const pubEndDates = pubLineItems.map(li => li.endDate).filter(Boolean);
+          const pubStartDate = pubStartDates.length > 0 ? pubStartDates.sort()[0] : null;
+          const pubEndDate = pubEndDates.length > 0 ? pubEndDates.sort().reverse()[0] : null;
+          
+          const pubBudgets = pubLineItems.map(li => li.direct?.budgetSetup?.budgetAmount || 0);
+          const pubTotalBudget = pubBudgets.reduce((sum, b) => sum + b, 0);
+          
+          const existingIO = await PublisherInsertionOrder.findOne({
+            where: {
+              deal_id: dealRecord.deal_id,
+              publisher_id: pubInfo.publisherId
+            },
+            transaction
+          });
+          
+          if (!existingIO) {
+            await PublisherInsertionOrder.create({
+              deal_id: dealRecord.deal_id,
+              publisher_id: pubInfo.publisherId,
+              publisher_name: pubInfo.publisherName,
+              status: 'DRAFT',
+              currency: dealRecord.currency,
+              start_date: pubStartDate,
+              end_date: pubEndDate,
+              budget_amount: pubTotalBudget > 0 ? pubTotalBudget : null
+            }, { transaction });
+            insertionOrdersCreated++;
+          } else if (existingIO.status === 'ARCHIVED') {
+            await existingIO.update({ 
+              status: 'DRAFT',
+              start_date: pubStartDate,
+              end_date: pubEndDate,
+              budget_amount: pubTotalBudget > 0 ? pubTotalBudget : null
+            }, { transaction });
+          } else {
+            await existingIO.update({ 
+              start_date: pubStartDate,
+              end_date: pubEndDate,
+              budget_amount: pubTotalBudget > 0 ? pubTotalBudget : null
+            }, { transaction });
+          }
+        }
+        
+        // Archive insertion orders for publishers no longer in payload (only for existing deals)
+        if (isExistingDeal) {
+          const allExistingIOs = await PublisherInsertionOrder.findAll({
+            where: {
+              deal_id: dealRecord.deal_id,
+              status: { [Op.ne]: 'ARCHIVED' }
+            },
+            transaction
+          });
+          
+          for (const io of allExistingIOs) {
+            if (!incomingPublisherIds.has(io.publisher_id)) {
+              await io.update({ status: 'ARCHIVED' }, { transaction });
+              insertionOrdersArchived++;
+            }
+          }
+        }
+      }
+      
+      for (const lineItemData of lineItems) {
+        const lineItemCamel = toCamelCase(lineItemData);
+        const { error: lineItemError } = lineItemSchema.validate(lineItemCamel, { stripUnknown: true });
+        
+        if (lineItemError) {
+          throw new Error(`Line item validation failed: ${lineItemError.message}`);
+        }
+        
+        const flattenedLineItem = { ...lineItemData };
+        if (flattenedLineItem.direct && typeof flattenedLineItem.direct === 'object') {
+          const directFlatFields = ['budgetSetup', 'campaignGoal', 'targeting', 'planning'];
+          for (const [key, value] of Object.entries(flattenedLineItem.direct)) {
+            if (directFlatFields.includes(key) && value !== undefined) {
+              flattenedLineItem[key] = value;
+            }
+          }
+          delete flattenedLineItem.direct;
+        }
+        
+        const lineItemPayload = toSnakeCase(flattenedLineItem);
+        lineItemPayload.deal_id = dealRecord.deal_id;
+        lineItemPayload.source = dealRecord.source;
+        
+        const inventories = lineItemPayload.inventories || [];
+        delete lineItemPayload.inventories;
+        
+        let lineItemRecord = await LineItem.findOne({
+          where: {
+            source: lineItemPayload.source,
+            external_id: lineItemPayload.external_id
+          },
+          transaction
+        });
+        
+        if (lineItemRecord) {
+          const { id, ...updatePayload } = lineItemPayload;
+          await lineItemRecord.update(updatePayload, { transaction });
+        } else {
+          lineItemRecord = await LineItem.create(lineItemPayload, { transaction });
+        }
+        lineItemsProcessed++;
+        
+        for (const inventory of inventories) {
+          const inventoryPayload = toSnakeCase(inventory);
+          inventoryPayload.line_item_id = lineItemRecord.id;
+          inventoryPayload.deal_id = dealRecord.deal_id;
+          
+          await LineItemInventory.upsert(inventoryPayload, { transaction });
+          inventoriesProcessed++;
+        }
+      }
+      
+      // Archive line items no longer in payload (only for existing deals with DIRECT_PUBLISHER_SPLIT)
+      if (isExistingDeal && payloadType === PayloadType.DIRECT_PUBLISHER_SPLIT) {
+        const existingLineItems = await LineItem.findAll({
+          where: {
+            deal_id: dealRecord.deal_id,
+            source: dealRecord.source,
+            status: { [Op.ne]: 'ARCHIVED' }
+          },
+          transaction
+        });
+        
+        for (const li of existingLineItems) {
+          if (!incomingLineItemExternalIds.has(li.external_id)) {
+            await li.update({ status: 'ARCHIVED' }, { transaction });
+            lineItemsArchived++;
+          }
+        }
+      }
+      
+      if (payloadType === PayloadType.DIRECT_PUBLISHER_SPLIT) {
+        const allStartDates = lineItems.map(li => li.startDate).filter(Boolean);
+        const allEndDates = lineItems.map(li => li.endDate).filter(Boolean);
+        
+        const dealUpdates = {};
+        if (!dealRecord.start_date && allStartDates.length > 0) {
+          dealUpdates.start_date = allStartDates.sort()[0];
+        }
+        if (!dealRecord.end_date && allEndDates.length > 0) {
+          dealUpdates.end_date = allEndDates.sort().reverse()[0];
+        }
+        
+        if (Object.keys(dealUpdates).length > 0) {
+          await dealRecord.update(dealUpdates, { transaction });
+        }
+      }
+      
+      await transaction.commit();
+      
+      const updatedDeal = await Deal.findByPk(dealRecord.id);
+      const formattedDeal = DealResponseFormatter.formatDealResponse(updatedDeal);
+      
+      res.status(201).json({
+        requestId: req.requestId,
+        status: 201,
+        result: {
+          deal: formattedDeal,
+          summary: {
+            payloadType,
+            isUpdate: isExistingDeal,
+            lineItemsProcessed,
+            lineItemsArchived,
+            inventoriesProcessed,
+            insertionOrdersCreated,
+            insertionOrdersArchived,
+            ...convertedResult.metadata
+          }
+        }
+      });
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    }
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.get('/:dealId/history', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+    const { limit = 50, offset = 0, includeLineItems = 'true', action, startDate, endDate } = req.query;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    const history = await ChangeHistoryService.getDealHistory(deal.deal_id, {
+      limit: parseInt(limit),
+      offset: parseInt(offset),
+      includeLineItems: includeLineItems === 'true',
+      action,
+      startDate,
+      endDate
+    });
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        dealId: deal.deal_id,
+        ...history
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.get('/:dealId/history/minified', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+    const { limit = 100, includeLineItems = 'true' } = req.query;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    const logs = await ChangeHistoryService.getMinifiedHistory(deal.deal_id, {
+      limit: parseInt(limit),
+      includeLineItems: includeLineItems === 'true'
+    });
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        dealId: deal.deal_id,
+        logs
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+export default router;