adserver-dashboard 1.0.0

package/PCM/src/routes/lineItems.js

@@ -0,0 +1,926 @@
+import express from 'express';
+import { Op } from 'sequelize';
+import sequelize from '../config/db.js';
+import { lineItemSchema, lineItemUpdateSchema, inventoriesBulkUpdateSchema } from '../validators/lineItemValidator.js';
+import LineItem from '../models/LineItem.js';
+import LineItemInventory from '../models/LineItemInventory.js';
+import Deal from '../models/Deal.js';
+import { calculateDealMetrics } from '../utils/dealCalculations.js';
+import { toCamelCase, toSnakeCase } from '../utils/caseConverter.js';
+import LineItemResponseFormatter from '../services/LineItemResponseFormatter.js';
+import { flattenLineItemPayload } from '../utils/lineItemPayloadNormalizer.js';
+import CampaignModeService from '../services/CampaignModeService.js';
+import ChangeHistoryService from '../services/ChangeHistoryService.js';
+import LineItemStatusService, { LINE_ITEM_STATUSES } from '../services/LineItemStatusService.js';
+import { normalizeSource } from '../utils/sourceNormalizer.js';
+import { TRANSITION_OWNERS } from '../services/CampaignStatusService.js';
+
+const router = express.Router({ mergeParams: true });
+
+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;
+};
+
+const recalculateDealMetrics = async (dealId) => {
+  const deal = await Deal.findOne({ where: { deal_id: dealId } });
+  if (!deal) return;
+  
+  const lineItems = await LineItem.findAll({ 
+    where: { 
+      deal_id: dealId,
+      [Op.or]: [
+        { status: { [Op.ne]: 'ARCHIVED' } },
+        { status: null }
+      ]
+    },
+    include: [{
+      model: LineItemInventory,
+      as: 'inventories'
+    }]
+  });
+  const calculatedMetrics = calculateDealMetrics(lineItems.map(li => li.toJSON()), deal.mode || 'PROGRAMMATIC');
+  
+  await deal.update(calculatedMetrics);
+};
+
+router.get('/', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+    const page = parseInt(req.query.page) || 1;
+    const limit = parseInt(req.query.limit) || 10;
+    const offset = (page - 1) * limit;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    const where = { deal_id: deal.deal_id };
+
+    if (req.query.search) {
+      const searchTerm = `%${req.query.search}%`;
+      where[Op.or] = [
+        { name: { [Op.iLike]: searchTerm } },
+        { external_id: { [Op.iLike]: searchTerm } }
+      ];
+    }
+
+    if (req.query.status) {
+      where.status = req.query.status.toUpperCase();
+    }
+
+    if (req.query.creativeType) {
+      where.creative_type = req.query.creativeType.toUpperCase();
+    }
+
+    if (req.query.publisherId) {
+      where.publisher_id = req.query.publisherId;
+    }
+
+    const { count, rows } = await LineItem.findAndCountAll({
+      where,
+      limit,
+      offset,
+      order: [['created_at', 'DESC']]
+    });
+
+    const lineItems = LineItemResponseFormatter.formatListResponse(rows);
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        data: lineItems,
+        pagination: {
+          page,
+          limit,
+          total: count,
+          totalPages: Math.ceil(count / limit)
+        }
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.get('/:lineItemId', async (req, res, next) => {
+  try {
+    const { dealId, lineItemId } = req.params;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    let lineItem = await LineItem.findOne({ 
+      where: { deal_id: deal.deal_id, external_id: lineItemId }
+    });
+
+    if (!lineItem && /^[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(lineItemId)) {
+      lineItem = await LineItem.findOne({ 
+        where: { deal_id: deal.deal_id, id: lineItemId }
+      });
+    }
+
+    if (!lineItem) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Line item not found'
+      });
+    }
+
+    const result = LineItemResponseFormatter.formatResponse(lineItem);
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post('/', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+    const bodyInCamelCase = toCamelCase(req.body);
+    const flattenedBody = flattenLineItemPayload(bodyInCamelCase);
+    const { error, value } = lineItemSchema.validate(flattenedBody);
+    
+    if (error) {
+      error.name = 'ValidationError';
+      return next(error);
+    }
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    const { inventories, ...lineItemData } = value;
+    
+    // Define mode-specific fields (pacing and duration are common - not in either list)
+    const programmaticFlatFields = ['auctionType', 'impressionType', 'thresholdCountPerDay', 
+      'deliveryGoal', 'costType', 'bidFloor', 'netCost', 'netCostPerDay', 'impressions', 
+      'admCreativeSync', 'nonBillable', 'stopBidRequests', 'impMultiplier'];
+    const directFlatFields = ['budgetSetup', 'campaignGoal', 'deliveryTargeting', 'planning'];
+    // Note: targeting is allowed for both modes, only deliveryTargeting is DIRECT-only
+    // Note: duration is common field for both PROGRAMMATIC and DIRECT modes
+    
+    // Enforce mode-specific fields - reject cross-mode data
+    if (deal.mode === 'PROGRAMMATIC') {
+      const crossModeFields = directFlatFields.filter(f => lineItemData[f] !== undefined);
+      if (crossModeFields.length > 0) {
+        return res.status(400).json({
+          code: 'VALIDATION_ERROR',
+          message: `Cannot include DIRECT fields for a PROGRAMMATIC deal line item: ${crossModeFields.join(', ')}`
+        });
+      }
+    }
+    
+    if (deal.mode === 'DIRECT') {
+      const crossModeFields = programmaticFlatFields.filter(f => lineItemData[f] !== undefined);
+      if (crossModeFields.length > 0) {
+        return res.status(400).json({
+          code: 'VALIDATION_ERROR',
+          message: `Cannot include PROGRAMMATIC fields for a DIRECT deal line item: ${crossModeFields.join(', ')}`
+        });
+      }
+    }
+    
+    // Pacing business rules: optional for both modes
+    // For GUARANTEED: if pacing is provided, force type to 'even'
+    if (deal.mode === 'PROGRAMMATIC' && deal.deal_type === 'GUARANTEED' && lineItemData.pacing) {
+      lineItemData.pacing = { type: 'even', dailyCap: lineItemData.pacing?.dailyCap, hourlyCap: lineItemData.pacing?.hourlyCap };
+    }
+    // For non-guaranteed PROGRAMMATIC and DIRECT: pacing is optional, user can define any type
+    
+    // Validate thresholdCountPerDay is required for GUARANTEED deals
+    if (deal.deal_type === 'GUARANTEED' && lineItemData.thresholdCountPerDay === undefined) {
+      const validationError = new Error('thresholdCountPerDay is required for GUARANTEED line items');
+      validationError.name = 'ValidationError';
+      validationError.details = [{ message: 'thresholdCountPerDay is required for GUARANTEED line items', path: ['thresholdCountPerDay'], type: 'any.required' }];
+      return next(validationError);
+    }
+    
+    // Validate auction type and cost type business rules for programmatic mode
+    // dealType is derived from parent deal, not from request payload
+    if (deal.mode === 'PROGRAMMATIC') {
+      const effectiveAuctionType = lineItemData.auctionType;
+      const effectiveCostType = lineItemData.costType;
+      
+      if (effectiveAuctionType !== undefined) {
+        const auctionValidation = CampaignModeService.validateAuctionType(deal.deal_type, 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);
+        }
+      }
+      
+      if (effectiveCostType !== undefined) {
+        const costTypeValidation = CampaignModeService.validateCostType(deal.deal_type, 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);
+        }
+      }
+    }
+    
+    // Extract nested mode-specific fields before converting to snake_case
+    if (lineItemData.direct && lineItemData.direct.pricing) {
+      lineItemData.pricing = lineItemData.direct.pricing;
+    }
+    if (lineItemData.programmatic && lineItemData.programmatic.bidFloorBase !== undefined) {
+      lineItemData.bidFloorBase = lineItemData.programmatic.bidFloorBase;
+    }
+    
+    const lineItemSnake = toSnakeCase(lineItemData);
+    lineItemSnake.deal_id = deal.deal_id;
+    lineItemSnake.source = deal.source;
+    lineItemSnake.mode = deal.mode;
+    lineItemSnake.deal_type = deal.deal_type;
+    
+    if (inventories && inventories.length > 0) {
+      lineItemSnake.total_inventories = inventories.length;
+      
+      if (!lineItemSnake.resolutions || lineItemSnake.resolutions.length === 0) {
+        const derivedResolutions = [...new Set(
+          inventories
+            .map(inv => inv.resolution || inv.size)
+            .filter(Boolean)
+        )];
+        if (derivedResolutions.length > 0) {
+          lineItemSnake.resolutions = derivedResolutions;
+        }
+      }
+      
+      if (!lineItemSnake.sizes || lineItemSnake.sizes.length === 0) {
+        const derivedSizes = [...new Set(
+          inventories
+            .map(inv => inv.size || inv.resolution)
+            .filter(Boolean)
+        )];
+        if (derivedSizes.length > 0) {
+          lineItemSnake.sizes = derivedSizes;
+        }
+      }
+    }
+
+    const lineItem = await LineItem.create(lineItemSnake);
+
+    if (inventories && inventories.length > 0) {
+      for (const inv of inventories) {
+        const normalizedInv = { ...inv };
+        
+        if (inv.publisher) {
+          normalizedInv.publisherId = inv.publisher.id || inv.publisherId;
+          normalizedInv.publisherName = inv.publisher.name || inv.publisherName;
+          normalizedInv.publisherExternalId = inv.publisher.externalId ?? inv.publisherExternalId ?? inv.publisher_external_id ?? null;
+          delete normalizedInv.publisher;
+        } else if (inv.publisherExternalId !== undefined || inv.publisher_external_id !== undefined) {
+          normalizedInv.publisherExternalId = inv.publisherExternalId ?? inv.publisher_external_id ?? null;
+        }
+        
+        if (typeof inv.venueTypeIds === 'string') {
+          normalizedInv.venueTypeIds = [inv.venueTypeIds];
+        }
+        
+        const metadataFields = {};
+        const fieldsToMoveToMetadata = ['spotsPerHour', 'spotDuration', 'clients', 'group', 'transit', 'networkId', 'packageId'];
+        for (const field of fieldsToMoveToMetadata) {
+          if (normalizedInv[field] !== undefined) {
+            metadataFields[field] = normalizedInv[field];
+            delete normalizedInv[field];
+          }
+        }
+        
+        if (Object.keys(metadataFields).length > 0) {
+          normalizedInv.metadata = { ...normalizedInv.metadata, ...metadataFields };
+        }
+        
+        const invSnake = toSnakeCase(normalizedInv);
+        await LineItemInventory.create({
+          id: inv.id,
+          line_item_id: lineItem.id,
+          deal_id: deal.deal_id,
+          ...invSnake
+        });
+      }
+    }
+
+    await recalculateDealMetrics(deal.deal_id);
+
+    await ChangeHistoryService.trackCreate('LINE_ITEM', lineItem, ChangeHistoryService.extractContext(req));
+
+    res.status(201).json({
+      requestId: req.requestId,
+      status: 201,
+      result: {
+        id: lineItem.id,
+        externalId: lineItem.external_id,
+        dealId: lineItem.deal_id,
+        mode: lineItem.mode,
+        dealType: lineItem.deal_type,
+        createdAt: lineItem.created_at
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.put('/:lineItemId', async (req, res, next) => {
+  try {
+    const { dealId, lineItemId } = req.params;
+    const bodyInCamelCase = toCamelCase(req.body);
+    const flattenedBody = flattenLineItemPayload(bodyInCamelCase);
+    const { error, value } = lineItemUpdateSchema.validate(flattenedBody);
+    
+    if (error) {
+      error.name = 'ValidationError';
+      return next(error);
+    }
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    let lineItem = await LineItem.findOne({ 
+      where: { deal_id: deal.deal_id, external_id: lineItemId }
+    });
+
+    if (!lineItem && /^[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(lineItemId)) {
+      lineItem = await LineItem.findOne({ 
+        where: { deal_id: deal.deal_id, id: lineItemId }
+      });
+    }
+
+    if (!lineItem) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Line item not found'
+      });
+    }
+
+    // Define mode-specific fields (pacing and duration are common - not in either list)
+    const programmaticFlatFields = ['auctionType', 'impressionType', 'thresholdCountPerDay', 
+      'deliveryGoal', 'costType', 'bidFloor', 'netCost', 'netCostPerDay', 'impressions', 
+      'admCreativeSync', 'nonBillable', 'stopBidRequests', 'impMultiplier'];
+    const directFlatFields = ['budgetSetup', 'campaignGoal', 'deliveryTargeting', 'planning'];
+    // Note: targeting is allowed for both modes, only deliveryTargeting is DIRECT-only
+    // Note: duration is common field for both PROGRAMMATIC and DIRECT modes
+    
+    // Enforce mode-specific fields - reject cross-mode data
+    if (deal.mode === 'PROGRAMMATIC') {
+      const crossModeFields = directFlatFields.filter(f => value[f] !== undefined);
+      if (crossModeFields.length > 0) {
+        return res.status(400).json({
+          code: 'VALIDATION_ERROR',
+          message: `Cannot include DIRECT fields for a PROGRAMMATIC deal line item: ${crossModeFields.join(', ')}`
+        });
+      }
+    }
+    
+    if (deal.mode === 'DIRECT') {
+      const crossModeFields = programmaticFlatFields.filter(f => value[f] !== undefined);
+      if (crossModeFields.length > 0) {
+        return res.status(400).json({
+          code: 'VALIDATION_ERROR',
+          message: `Cannot include PROGRAMMATIC fields for a DIRECT deal line item: ${crossModeFields.join(', ')}`
+        });
+      }
+    }
+    
+    // Pacing business rules for PROGRAMMATIC mode on update
+    if (deal.mode === 'PROGRAMMATIC' && value.pacing !== undefined) {
+      if (deal.deal_type === 'GUARANTEED') {
+        // GUARANTEED: pacing type is fixed to 'even', only allow dailyCap/hourlyCap updates
+        value.pacing = { type: 'even', dailyCap: value.pacing?.dailyCap, hourlyCap: value.pacing?.hourlyCap };
+      }
+    }
+    // DIRECT mode: user can set any pacing type
+    
+    // Extract nested mode-specific fields before converting to snake_case
+    if (value.direct && value.direct.pricing) {
+      value.pricing = value.direct.pricing;
+    }
+    if (value.programmatic && value.programmatic.bidFloorBase !== undefined) {
+      value.bidFloorBase = value.programmatic.bidFloorBase;
+    }
+    
+    const updateData = toSnakeCase(value);
+    
+    updateData.version = lineItem.version + 1;
+
+    const previousData = lineItem.toJSON();
+    await lineItem.update(updateData);
+    await ChangeHistoryService.trackUpdate('LINE_ITEM', previousData, lineItem, ChangeHistoryService.extractContext(req));
+
+    await recalculateDealMetrics(deal.deal_id);
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        id: lineItem.id,
+        externalId: lineItem.external_id,
+        name: lineItem.name,
+        version: lineItem.version,
+        updatedAt: lineItem.updated_at
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.delete('/:lineItemId', async (req, res, next) => {
+  try {
+    const { dealId, lineItemId } = req.params;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    let lineItem = await LineItem.findOne({ 
+      where: { deal_id: deal.deal_id, external_id: lineItemId }
+    });
+
+    if (!lineItem && /^[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(lineItemId)) {
+      lineItem = await LineItem.findOne({ 
+        where: { deal_id: deal.deal_id, id: lineItemId }
+      });
+    }
+
+    if (!lineItem) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Line item not found'
+      });
+    }
+
+    const previousData = lineItem.toJSON();
+    await lineItem.update({ status: 'ARCHIVED' });
+    await ChangeHistoryService.trackUpdate('LINE_ITEM', previousData, lineItem, ChangeHistoryService.extractContext(req));
+
+    await recalculateDealMetrics(deal.deal_id);
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        dealId: dealId,
+        externalId: lineItem.external_id,
+        status: 'ARCHIVED'
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.get('/:lineItemId/inventories', async (req, res, next) => {
+  try {
+    const { dealId, lineItemId } = req.params;
+    const page = parseInt(req.query.page) || 1;
+    const limit = parseInt(req.query.limit) || 10;
+    const offset = (page - 1) * limit;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    let lineItem = await LineItem.findOne({ 
+      where: { deal_id: deal.deal_id, external_id: lineItemId }
+    });
+
+    if (!lineItem && /^[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(lineItemId)) {
+      lineItem = await LineItem.findOne({ 
+        where: { deal_id: deal.deal_id, id: lineItemId }
+      });
+    }
+
+    if (!lineItem) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Line item not found'
+      });
+    }
+
+    const { count, rows } = await LineItemInventory.findAndCountAll({
+      where: { line_item_id: lineItem.id, deal_id: deal.deal_id },
+      limit,
+      offset,
+      order: [['created_at', 'DESC']]
+    });
+
+    const inventories = rows.map(inv => {
+      const camelInv = toCamelCase(inv.toJSON());
+      if (camelInv.publisherId || camelInv.publisherName) {
+        camelInv.publisher = {
+          id: camelInv.publisherId,
+          name: camelInv.publisherName
+        };
+      }
+      
+      const fieldsFromMetadata = ['spotsPerHour', 'spotDuration', 'clients', 'group', 'transit', 'networkId', 'packageId'];
+      if (camelInv.metadata) {
+        for (const field of fieldsFromMetadata) {
+          if (camelInv.metadata[field] !== undefined) {
+            camelInv[field] = camelInv.metadata[field];
+          }
+        }
+      }
+      return camelInv;
+    });
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        data: inventories,
+        pagination: {
+          page,
+          limit,
+          total: count,
+          totalPages: Math.ceil(count / limit)
+        }
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.put('/:lineItemId/inventories', async (req, res, next) => {
+  try {
+    const { dealId, lineItemId } = req.params;
+    const bodyInCamelCase = toCamelCase(req.body);
+    const { error, value } = inventoriesBulkUpdateSchema.validate(bodyInCamelCase);
+    
+    if (error) {
+      error.name = 'ValidationError';
+      return next(error);
+    }
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    let lineItem = await LineItem.findOne({ 
+      where: { deal_id: deal.deal_id, external_id: lineItemId }
+    });
+
+    if (!lineItem && /^[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(lineItemId)) {
+      lineItem = await LineItem.findOne({ 
+        where: { deal_id: deal.deal_id, id: lineItemId }
+      });
+    }
+
+    if (!lineItem) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Line item not found'
+      });
+    }
+
+    const { inventories } = value;
+
+    const transaction = await sequelize.transaction();
+    
+    try {
+      await LineItemInventory.destroy({
+        where: { 
+          line_item_id: lineItem.id, 
+          deal_id: deal.deal_id 
+        },
+        transaction
+      });
+
+      const createdInventories = [];
+      if (inventories && inventories.length > 0) {
+        for (const inv of inventories) {
+          const normalizedInv = { ...inv };
+          
+          if (inv.publisher) {
+            normalizedInv.publisherId = inv.publisher.id || inv.publisherId;
+            normalizedInv.publisherName = inv.publisher.name || inv.publisherName;
+            normalizedInv.publisherExternalId = inv.publisher.externalId ?? inv.publisherExternalId ?? inv.publisher_external_id ?? null;
+            delete normalizedInv.publisher;
+          } else if (inv.publisherExternalId !== undefined || inv.publisher_external_id !== undefined) {
+            normalizedInv.publisherExternalId = inv.publisherExternalId ?? inv.publisher_external_id ?? null;
+          }
+          
+          if (typeof inv.venueTypeIds === 'string') {
+            normalizedInv.venueTypeIds = [inv.venueTypeIds];
+          }
+          
+          const metadataFields = {};
+          const fieldsToMoveToMetadata = ['spotsPerHour', 'spotDuration', 'clients', 'group', 'transit', 'networkId', 'packageId'];
+          for (const field of fieldsToMoveToMetadata) {
+            if (normalizedInv[field] !== undefined) {
+              metadataFields[field] = normalizedInv[field];
+              delete normalizedInv[field];
+            }
+          }
+          
+          if (Object.keys(metadataFields).length > 0) {
+            normalizedInv.metadata = { ...normalizedInv.metadata, ...metadataFields };
+          }
+          
+          const invSnake = toSnakeCase(normalizedInv);
+          const createdInv = await LineItemInventory.create({
+            id: inv.id,
+            line_item_id: lineItem.id,
+            deal_id: deal.deal_id,
+            ...invSnake
+          }, { transaction });
+          createdInventories.push(createdInv);
+        }
+      }
+
+      await lineItem.update({ 
+        total_inventories: createdInventories.length,
+        version: lineItem.version + 1
+      }, { transaction });
+
+      await transaction.commit();
+
+      await recalculateDealMetrics(deal.deal_id);
+
+      res.json({
+        requestId: req.requestId,
+        status: 200,
+        result: {
+          lineItemId: lineItem.external_id || lineItem.id,
+          inventoriesCount: createdInventories.length,
+          message: 'Inventories replaced successfully'
+        }
+      });
+    } catch (txError) {
+      await transaction.rollback();
+      throw txError;
+    }
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.get('/:lineItemId/inventories/minified', async (req, res, next) => {
+  try {
+    const { dealId, lineItemId } = req.params;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    let lineItem = await LineItem.findOne({ 
+      where: { deal_id: deal.deal_id, external_id: lineItemId }
+    });
+
+    if (!lineItem && /^[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(lineItemId)) {
+      lineItem = await LineItem.findOne({ 
+        where: { deal_id: deal.deal_id, id: lineItemId }
+      });
+    }
+
+    if (!lineItem) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Line item not found'
+      });
+    }
+
+    const inventories = await LineItemInventory.findAll({
+      where: { line_item_id: lineItem.id, deal_id: deal.deal_id },
+      attributes: ['id', 'name', 'publisher_id', 'publisher_name', 'publisher_external_id', 'size'],
+      order: [['name', 'ASC']]
+    });
+
+    const minifiedInventories = inventories.map(inv => ({
+      id: inv.id,
+      name: inv.name,
+      publisher: {
+        id: inv.publisher_id,
+        name: inv.publisher_name,
+        externalId: inv.publisher_external_id || null
+      },
+      resolution: inv.size
+    }));
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        data: minifiedInventories,
+        total: minifiedInventories.length
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post('/:lineItemId/status', async (req, res, next) => {
+  try {
+    const { dealId, lineItemId } = 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(LINE_ITEM_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'
+      });
+    }
+
+    let lineItem = await LineItem.findOne({ 
+      where: { deal_id: deal.deal_id, external_id: lineItemId }
+    });
+    
+    if (!lineItem && /^[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(lineItemId)) {
+      lineItem = await LineItem.findOne({ 
+        where: { deal_id: deal.deal_id, id: lineItemId }
+      });
+    }
+
+    if (!lineItem) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Line item not found'
+      });
+    }
+
+    const transitionOwner = owner || TRANSITION_OWNERS.USER;
+    const sourceType = normalizeSource(deal.source);
+
+    const validation = LineItemStatusService.validateTransition(
+      { status: lineItem.status, source: sourceType },
+      newStatus.toUpperCase(),
+      { owner: transitionOwner, source: sourceType, campaignStatus: deal.status }
+    );
+
+    if (!validation.valid) {
+      return res.status(400).json({
+        code: 'INVALID_STATUS_TRANSITION',
+        message: validation.errors[0]?.message || 'Invalid status transition',
+        errors: validation.errors,
+        currentStatus: lineItem.status,
+        requestedStatus: newStatus.toUpperCase(),
+        allowedTransitions: LineItemStatusService.getValidTransitions(lineItem.status),
+        campaignStatus: deal.status
+      });
+    }
+
+    const previousStatus = lineItem.status;
+    await lineItem.update({ status: newStatus.toUpperCase() });
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        lineItemId: lineItem.id,
+        externalId: lineItem.external_id,
+        dealId: deal.deal_id,
+        previousStatus,
+        currentStatus: lineItem.status,
+        transitionOwner,
+        reason,
+        updatedAt: lineItem.updated_at
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.get('/:lineItemId/status/transitions', async (req, res, next) => {
+  try {
+    const { dealId, lineItemId } = req.params;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    let lineItem = await LineItem.findOne({ 
+      where: { deal_id: deal.deal_id, external_id: lineItemId }
+    });
+    
+    if (!lineItem && /^[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(lineItemId)) {
+      lineItem = await LineItem.findOne({ 
+        where: { deal_id: deal.deal_id, id: lineItemId }
+      });
+    }
+
+    if (!lineItem) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Line item not found'
+      });
+    }
+
+    const sourceType = normalizeSource(deal.source);
+    const validTransitions = LineItemStatusService.getValidTransitions(lineItem.status);
+    const editableFields = LineItemStatusService.getEditableFields(lineItem.status, sourceType);
+    const statusDefinition = LineItemStatusService.getStatusDefinition(lineItem.status);
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        lineItemId: lineItem.id,
+        externalId: lineItem.external_id,
+        dealId: deal.deal_id,
+        currentStatus: lineItem.status,
+        campaignStatus: deal.status,
+        source: sourceType,
+        validTransitions,
+        statusDefinition,
+        editableFields,
+        canReopen: LineItemStatusService.canReopen(lineItem.status),
+        transitionOwnership: LineItemStatusService.getTransitionOwnership()
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.get('/status/definitions', async (req, res) => {
+  const definitions = {};
+  for (const status of Object.values(LINE_ITEM_STATUSES)) {
+    definitions[status] = LineItemStatusService.getStatusDefinition(status);
+  }
+
+  res.json({
+    requestId: req.requestId,
+    status: 200,
+    result: {
+      statuses: LINE_ITEM_STATUSES,
+      definitions,
+      transitionOwnership: LineItemStatusService.getTransitionOwnership()
+    }
+  });
+});
+
+export default router;