adserver-dashboard 1.0.0

package/PCM/src/services/CampaignImportConverter.js

@@ -0,0 +1,631 @@
+import { v4 as uuidv4 } from 'uuid';
+import { createHash } from 'crypto';
+import { validateSourceForImport, INTERNAL_SOURCES } from '../utils/sourceNormalizer.js';
+
+export const PayloadType = {
+  PROGRAMMATIC_STANDARD: 'PROGRAMMATIC_STANDARD',
+  DIRECT_STANDARD: 'DIRECT_STANDARD',
+  DIRECT_PUBLISHER_SPLIT: 'DIRECT_PUBLISHER_SPLIT'
+};
+
+export class CampaignImportConverter {
+  
+  static _validateAndGetSource(source, campaign) {
+    const rawSource = source || campaign?.source || 'external';
+    const validation = validateSourceForImport(rawSource);
+    
+    if (!validation.valid) {
+      const error = new Error(validation.error);
+      error.code = 'INVALID_SOURCE_FOR_IMPORT';
+      error.statusCode = 400;
+      throw error;
+    }
+    
+    return rawSource;
+  }
+
+  static convert(externalPayload, payloadType, options = {}) {
+    switch (payloadType) {
+      case PayloadType.PROGRAMMATIC_STANDARD:
+        return this.convertProgrammaticStandard(externalPayload, options);
+      case PayloadType.DIRECT_STANDARD:
+        return this.convertDirectStandard(externalPayload, options);
+      case PayloadType.DIRECT_PUBLISHER_SPLIT:
+        return this.convertDirectPublisherSplit(externalPayload, options);
+      default:
+        throw new Error(`Unknown payload type: ${payloadType}`);
+    }
+  }
+
+  static convertProgrammaticStandard(externalPayload, options = {}) {
+    const { campaign, lineItems = [] } = externalPayload;
+    const source = this._validateAndGetSource(options.source, campaign);
+    
+    const deal = this._buildProgrammaticDeal(campaign, source);
+    const convertedLineItems = lineItems.map((li, index) => 
+      this._buildProgrammaticLineItem(li, campaign, index, source)
+    );
+    
+    return {
+      type: PayloadType.PROGRAMMATIC_STANDARD,
+      deal,
+      lineItems: convertedLineItems,
+      metadata: {
+        convertedAt: new Date().toISOString(),
+        source,
+        originalLineItemCount: lineItems.length
+      }
+    };
+  }
+
+  static convertDirectStandard(externalPayload, options = {}) {
+    const { campaign, lineItems = [] } = externalPayload;
+    const source = this._validateAndGetSource(options.source, campaign);
+    
+    const deal = this._buildDirectDeal(campaign, source);
+    const convertedLineItems = lineItems.map((li, index) => 
+      this._buildDirectLineItem(li, campaign, index, source)
+    );
+    
+    return {
+      type: PayloadType.DIRECT_STANDARD,
+      deal,
+      lineItems: convertedLineItems,
+      metadata: {
+        convertedAt: new Date().toISOString(),
+        source,
+        originalLineItemCount: lineItems.length
+      }
+    };
+  }
+
+  static convertDirectPublisherSplit(externalPayload, options = {}) {
+    const { campaign, inventories = [] } = externalPayload;
+    const source = this._validateAndGetSource(options.source, campaign);
+    
+    const campaignWithTotal = { ...campaign, _totalInventories: inventories.length };
+    const deal = this._buildDirectDeal(campaignWithTotal, source);
+    const { scheduledInventories, nonScheduledInventories } = this._separateBySchedule(inventories);
+    
+    const lineItems = [];
+    let lineItemIndex = 0;
+    
+    for (const inv of scheduledInventories) {
+      lineItems.push(this._buildLineItemFromScheduledInventory(inv, campaignWithTotal, lineItemIndex++, source));
+    }
+    
+    const groups = this._groupInventoriesByPublisherAndDuration(nonScheduledInventories);
+    for (const group of Object.values(groups)) {
+      lineItems.push(this._buildLineItemFromPublisherGroup(group, campaignWithTotal, lineItemIndex++, source));
+    }
+    
+    const publisherGroups = this._groupInventoriesByPublisherForIO(inventories);
+    const publishers = Object.values(publisherGroups).map(g => ({
+      id: g.publisher.id,
+      name: g.publisher.name,
+      externalId: g.publisher.externalId || null
+    }));
+    
+    deal.publishers = publishers;
+    
+    return {
+      type: PayloadType.DIRECT_PUBLISHER_SPLIT,
+      deal,
+      lineItems,
+      metadata: {
+        convertedAt: new Date().toISOString(),
+        source,
+        originalInventoryCount: inventories.length,
+        scheduledInventoryCount: scheduledInventories.length,
+        groupedInventoryCount: nonScheduledInventories.length,
+        lineItemCount: lineItems.length,
+        publisherCount: Object.keys(publisherGroups).length,
+        publisherBreakdown: Object.entries(publisherGroups).map(([id, g]) => ({
+          publisherId: id,
+          publisherName: g.publisher.name,
+          inventoryCount: g.inventories.length
+        })),
+        groupBreakdown: Object.entries(groups).map(([key, g]) => ({
+          groupKey: key,
+          publisherId: g.publisher.id,
+          publisherName: g.publisher.name,
+          resolution: g.resolution,
+          duration: g.duration,
+          inventoryCount: g.inventories.length
+        }))
+      }
+    };
+  }
+
+  static _buildProgrammaticDeal(campaign, source) {
+    return {
+      source,
+      externalId: campaign.externalId || campaign.id || `ext-${Date.now()}`,
+      name: campaign.name,
+      mode: 'PROGRAMMATIC',
+      dealType: campaign.dealType || 'PRIVATE_AUCTION',
+      status: campaign.status || 'DRAFT',
+      currency: campaign.currency || 'USD',
+      advertiser: campaign.advertiser || {},
+      seller: campaign.seller,
+      account: campaign.account,
+      programmatic: {
+        buyers: campaign.buyers || [],
+        auctionType: this._resolveAuctionType(campaign.dealType, campaign.auctionType),
+        transactionType: campaign.transactionType || 'SPOT',
+        costType: campaign.costType || 'CPM',
+        deliveryGoal: campaign.deliveryGoal,
+        netCost: campaign.netCost,
+        netCostPerDay: campaign.netCostPerDay,
+        impressions: campaign.impressions,
+        published: campaign.published,
+        nonBillable: campaign.nonBillable,
+        stopBidRequests: campaign.stopBidRequests
+      }
+    };
+  }
+
+  static _buildDirectDeal(campaign, source) {
+    const budgetConfig = campaign.budgetSetup || {};
+    return {
+      source,
+      externalId: campaign.externalId || campaign.id || `ext-${Date.now()}`,
+      name: campaign.name,
+      mode: 'DIRECT',
+      dealType: 'DIRECT',
+      status: campaign.status || 'DRAFT',
+      currency: campaign.currency || campaign.marketSelection?.currency || 'USD',
+      startDate: campaign.startDate,
+      endDate: campaign.endDate,
+      timezoneId: campaign.timezoneId,
+      brand: campaign.brand,
+      clientType: campaign.clientType || 'DIRECT_ADVERTISER',
+      approvalEmails: campaign.approvalEmails || [],
+      advertiser: campaign.advertiser || {},
+      account: campaign.account || undefined,
+      _totalInventories: campaign._totalInventories,
+      direct: {
+        brand: campaign.brand,
+        clientType: campaign.clientType || 'DIRECT_ADVERTISER',
+        approvalEmails: campaign.approvalEmails || [],
+        marketSelection: campaign.marketSelection || {
+          country: campaign.country || 'US',
+          currency: campaign.currency || 'USD'
+        },
+        budgetSetup: budgetConfig.budgetAmount !== undefined ? budgetConfig : {
+          currency: campaign.currency || 'USD',
+          budgetAmount: campaign.budget || 0
+        },
+        campaignGoal: campaign.campaignGoal || {
+          type: 'IMPRESSIONS',
+          targetValue: campaign.targetImpressions || 0
+        }
+      }
+    };
+  }
+
+  static _buildProgrammaticLineItem(lineItem, campaign, index, source) {
+    const externalId = lineItem.externalId || lineItem.id || `li-${source}-${index}-${Date.now()}`;
+    
+    return {
+      source,
+      externalId,
+      name: lineItem.name || `${campaign.name} - Line Item ${index + 1}`,
+      dealType: campaign.dealType || 'PRIVATE_AUCTION',
+      creativeType: lineItem.creativeType || campaign.creativeType || 'DISPLAY',
+      status: lineItem.status || 'DRAFT',
+      startDate: lineItem.startDate || campaign.startDate,
+      endDate: lineItem.endDate || campaign.endDate,
+      timezoneId: lineItem.timezoneId || campaign.timezoneId,
+      currency: lineItem.currency || campaign.currency || 'USD',
+      resolutions: lineItem.resolutions || [],
+      schedule: lineItem.schedule || campaign.schedule,
+      pacing: lineItem.pacing || campaign.pacing,
+      priority: lineItem.priority,
+      customFees: lineItem.customFees,
+      frequencyCap: lineItem.frequencyCap,
+      trafficAllocation: lineItem.trafficAllocation,
+      inventorySource: lineItem.inventorySource,
+      programmatic: {
+        auctionType: this._resolveAuctionType(campaign.dealType, lineItem.auctionType || campaign.auctionType),
+        duration: lineItem.duration || campaign.duration,
+        impressionType: lineItem.impressionType || campaign.impressionType || 'SPOT',
+        thresholdCountPerDay: lineItem.thresholdCountPerDay,
+        deliveryGoal: lineItem.deliveryGoal,
+        costType: lineItem.costType || campaign.costType || 'CPM',
+        bidFloor: lineItem.bidFloor || campaign.bidFloor,
+        netCost: lineItem.netCost,
+        netCostPerDay: lineItem.netCostPerDay,
+        impressions: lineItem.impressions,
+        admCreativeSync: lineItem.admCreativeSync,
+        nonBillable: lineItem.nonBillable,
+        stopBidRequests: lineItem.stopBidRequests
+      },
+      inventories: this._convertInventories(lineItem.inventories || [])
+    };
+  }
+
+  static _buildDirectLineItem(lineItem, campaign, index, source) {
+    const externalId = lineItem.externalId || lineItem.id || `li-${source}-${index}-${Date.now()}`;
+    
+    return {
+      source,
+      externalId,
+      name: lineItem.name || `${campaign.name} - Line Item ${index + 1}`,
+      dealType: 'DIRECT',
+      creativeType: lineItem.creativeType || campaign.creativeType || 'DISPLAY',
+      status: lineItem.status || 'DRAFT',
+      startDate: lineItem.startDate || campaign.startDate,
+      endDate: lineItem.endDate || campaign.endDate,
+      timezoneId: lineItem.timezoneId || campaign.timezoneId,
+      currency: lineItem.currency || campaign.currency || 'USD',
+      resolutions: lineItem.resolutions || [],
+      schedule: lineItem.schedule || campaign.schedule,
+      pacing: lineItem.pacing || campaign.pacing,
+      creativeSource: lineItem.creativeSource || 'ADVERTISER',
+      priority: lineItem.priority,
+      customFees: lineItem.customFees,
+      frequencyCap: lineItem.frequencyCap,
+      trafficAllocation: lineItem.trafficAllocation,
+      inventorySource: lineItem.inventorySource,
+      direct: {
+        budgetSetup: lineItem.budgetSetup || campaign.budgetSetup,
+        campaignGoal: lineItem.campaignGoal || campaign.campaignGoal,
+        targeting: lineItem.targeting || campaign.targeting,
+        planning: lineItem.planning
+      },
+      targeting: lineItem.targeting || campaign.targeting,
+      deliveryTargeting: lineItem.deliveryTargeting || campaign.deliveryTargeting,
+      inventories: this._convertInventoriesWithPlanning(lineItem.inventories || [], lineItem.planning)
+    };
+  }
+
+  static _generateInventoryFingerprint(inventories) {
+    const identifiers = inventories.map(inv => {
+      const id = inv.id || inv.inventoryId;
+      if (id) return id;
+      return `fallback:${inv.name || 'unnamed'}:${inv.resolution || 'nores'}:${inv.duration || 'nodur'}`;
+    });
+    const sortedIds = identifiers.sort().join(',');
+    return createHash('md5').update(sortedIds).digest('hex').substring(0, 8);
+  }
+
+  static _buildLineItemFromPublisherGroup(group, campaign, index, source) {
+    const { publisher, duration, inventories } = group;
+    const campaignExtId = campaign.externalId || campaign.id || 'unknown';
+    const durationSlug = (duration || 'default').toString().replace(/[^\w]/g, '_');
+    const inventoryFingerprint = this._generateInventoryFingerprint(inventories);
+    const externalId = `${campaignExtId}-${publisher.id}-${durationSlug}-${inventoryFingerprint}`;
+    
+    const resolutions = [...new Set(inventories.map(inv => inv.resolution || inv.size).filter(Boolean))];
+    const sizes = [...new Set(inventories.map(inv => inv.size || inv.resolution).filter(Boolean))];
+    
+    const aggregatedPlanning = this._aggregatePlanning(inventories);
+    
+    // Explicitly pass campaign._totalInventories to maintain context during budget derivation
+    const budgetSetup = this._deriveBudgetFromPlanning(aggregatedPlanning, campaign, inventories.length);
+    
+    return {
+      source,
+      externalId,
+      name: `${campaign.name} - ${publisher.name}`,
+      mode: 'DIRECT',
+      dealType: 'DIRECT',
+      creativeType: campaign.creativeType || 'DISPLAY',
+      status: campaign.status || 'DRAFT',
+      startDate: campaign.startDate,
+      endDate: campaign.endDate,
+      timezoneId: campaign.timezoneId,
+      currency: campaign.currency || 'USD',
+      publisherId: publisher.id,
+      resolutions,
+      sizes,
+      schedule: campaign.schedule,
+      pacing: campaign.pacing,
+      creativeSource: campaign.creativeSource || 'ADVERTISER',
+      totalInventories: inventories.length,
+      priority: campaign.priority,
+      customFees: campaign.customFees,
+      frequencyCap: campaign.frequencyCap,
+      trafficAllocation: campaign.trafficAllocation,
+      inventorySource: campaign.inventorySource,
+      direct: {
+        budgetSetup,
+        campaignGoal: this._splitGoal(campaign.campaignGoal, inventories.length, campaign._totalInventories),
+        targeting: campaign.targeting,
+        planning: aggregatedPlanning
+      },
+      targeting: campaign.targeting,
+      deliveryTargeting: campaign.deliveryTargeting,
+      inventories: this._convertInventoriesWithPlanning(inventories, null)
+    };
+  }
+
+  static _separateBySchedule(inventories) {
+    const scheduledInventories = [];
+    const nonScheduledInventories = [];
+    
+    for (const inventory of inventories) {
+      if (inventory.schedule && Array.isArray(inventory.schedule) && inventory.schedule.length > 0) {
+        scheduledInventories.push(inventory);
+      } else {
+        nonScheduledInventories.push(inventory);
+      }
+    }
+    
+    return { scheduledInventories, nonScheduledInventories };
+  }
+
+  static _groupInventoriesByPublisherAndDuration(nonScheduledInventories) {
+    const groups = {};
+    
+    for (const inventory of nonScheduledInventories) {
+      const publisherId = inventory.publisher?.id || inventory.publisherId || 'unknown';
+      const publisherName = inventory.publisher?.name || inventory.publisherName || 'Unknown Publisher';
+      const publisherExternalId = inventory.publisher?.externalId ?? inventory.publisherExternalId ?? inventory.publisher_external_id ?? null;
+      const duration = inventory.duration || 'default';
+      
+      const groupKey = `${publisherId}-${duration}`;
+      
+      if (!groups[groupKey]) {
+        groups[groupKey] = {
+          publisher: { id: publisherId, name: publisherName, externalId: publisherExternalId },
+          duration,
+          inventories: []
+        };
+      }
+      
+      groups[groupKey].inventories.push(inventory);
+    }
+    
+    return groups;
+  }
+
+  static _buildLineItemFromScheduledInventory(inventory, campaign, index, source) {
+    const publisherId = inventory.publisher?.id || inventory.publisherId || 'unknown';
+    const publisherName = inventory.publisher?.name || inventory.publisherName || 'Unknown Publisher';
+    const resolution = inventory.resolution || inventory.size;
+    const inventoryName = inventory.name || inventory.adUnitCode || `Screen-${index + 1}`;
+    
+    const campaignExtId = campaign.externalId || campaign.id || 'unknown';
+    const resolutionSlug = (resolution || 'default').replace(/[^\w]/g, '_');
+    const durationSlug = (inventory.duration || campaign.duration || 'default').toString().replace(/[^\w]/g, '_');
+    const inventoryId = inventory.id || inventory.externalId || `inv-${index}`;
+    const externalId = `${campaignExtId}-${publisherId}-${resolutionSlug}-${durationSlug}-${inventoryId}`;
+    
+    const schedule = Array.isArray(inventory.schedule) && inventory.schedule.length > 0 
+      ? inventory.schedule 
+      : (campaign.schedule || []);
+    
+    return {
+      source,
+      externalId,
+      name: `${campaign.name} - ${publisherName} - ${inventoryName}`,
+      mode: 'DIRECT',
+      dealType: 'DIRECT',
+      creativeType: campaign.creativeType || 'DISPLAY',
+      status: campaign.status || 'DRAFT',
+      startDate: campaign.startDate,
+      endDate: campaign.endDate,
+      timezoneId: inventory.timezone || campaign.timezoneId,
+      currency: campaign.currency || 'USD',
+      publisherId,
+      resolutions: resolution ? [resolution] : [],
+      sizes: resolution ? [resolution] : [],
+      schedule,
+      pacing: campaign.pacing,
+      creativeSource: campaign.creativeSource || 'ADVERTISER',
+      totalInventories: 1,
+      priority: campaign.priority,
+      customFees: campaign.customFees,
+      frequencyCap: campaign.frequencyCap,
+      trafficAllocation: campaign.trafficAllocation,
+      inventorySource: campaign.inventorySource,
+      direct: {
+        budgetSetup: this._deriveBudgetFromPlanning(inventory.planning, campaign, 1),
+        campaignGoal: this._splitGoal(campaign.campaignGoal, 1, campaign._totalInventories),
+        targeting: campaign.targeting,
+        planning: inventory.planning
+      },
+      targeting: campaign.targeting,
+      deliveryTargeting: campaign.deliveryTargeting,
+      inventories: this._convertInventoriesWithPlanning([inventory], null)
+    };
+  }
+
+  static _groupInventoriesByPublisherForIO(inventories) {
+    const groups = {};
+    
+    for (const inventory of inventories) {
+      const publisherId = inventory.publisher?.id || inventory.publisherId || 'unknown';
+      const publisherName = inventory.publisher?.name || inventory.publisherName || 'Unknown Publisher';
+      const publisherExternalId = inventory.publisher?.externalId ?? inventory.publisherExternalId ?? inventory.publisher_external_id ?? null;
+      
+      if (!groups[publisherId]) {
+        groups[publisherId] = {
+          publisher: { id: publisherId, name: publisherName, externalId: publisherExternalId },
+          inventories: []
+        };
+      }
+      
+      groups[publisherId].inventories.push(inventory);
+    }
+    
+    return groups;
+  }
+
+  static _convertInventories(inventories) {
+    return inventories.map(inv => ({
+      id: inv.id || inv.externalId || `inv-${uuidv4()}`,
+      adUnitCode: inv.adUnitCode,
+      name: inv.name,
+      referenceId: inv.referenceId,
+      deviceId: inv.deviceId,
+      size: inv.size || inv.resolution,
+      publisher: inv.publisher ? {
+        id: inv.publisher.id,
+        name: inv.publisher.name,
+        externalId: inv.publisher.externalId ?? inv.publisherExternalId ?? inv.publisher_external_id ?? null
+      } : {
+        id: inv.publisherId,
+        name: inv.publisherName,
+        externalId: inv.publisherExternalId ?? inv.publisher_external_id ?? null
+      },
+      latitude: inv.latitude || inv.location?.lat,
+      longitude: inv.longitude || inv.location?.lng,
+      venueType: inv.venueType,
+      venueTypeIds: inv.venueTypeIds,
+      thumbnail: inv.thumbnail,
+      timezone: inv.timezone,
+      countryIso2: inv.countryIso2,
+      countryIso3: inv.countryIso3,
+      spotsPerHour: inv.spotsPerHour,
+      spotDuration: inv.spotDuration
+    }));
+  }
+
+  static _convertInventoriesWithPlanning(inventories, defaultPlanning) {
+    return inventories.map(inv => ({
+      ...this._convertInventories([inv])[0],
+      planning: inv.planning || defaultPlanning || undefined
+    }));
+  }
+
+  static _splitBudget(budgetSetup, groupSize, totalInventories) {
+    if (!budgetSetup) return undefined;
+    
+    const ratio = totalInventories > 0 ? groupSize / totalInventories : 1;
+    
+    return {
+      ...budgetSetup,
+      budgetAmount: budgetSetup.budgetAmount ? Math.round(budgetSetup.budgetAmount * ratio * 100) / 100 : undefined
+    };
+  }
+
+  static _deriveBudgetFromPlanning(planning, campaign, inventoryCount) {
+    const estimatedCost = planning?.pricing?.estimatedCost;
+    const budgetConfig = campaign.budgetSetup || {};
+    const campaignBudget = budgetConfig.budgetAmount ?? campaign.budget;
+    const totalInventories = campaign._totalInventories || inventoryCount;
+    
+    if (estimatedCost !== undefined && estimatedCost !== null) {
+      let budgetAmount = estimatedCost;
+      
+      if (campaignBudget !== undefined && campaignBudget !== null && campaignBudget > 0) {
+        const ratio = totalInventories > 0 ? inventoryCount / totalInventories : 1;
+        const maxAllocatedForThisGroup = campaignBudget * ratio;
+        
+        if (budgetAmount > maxAllocatedForThisGroup) {
+          console.log(`[Import] Capping budget ${budgetAmount} to proportional limit ${maxAllocatedForThisGroup.toFixed(2)} (Total Budget: ${campaignBudget}, Share: ${ratio.toFixed(2)})`);
+          budgetAmount = maxAllocatedForThisGroup;
+        }
+      }
+
+      return {
+        currency: campaign.currency || budgetConfig.currency || 'USD',
+        budgetType: budgetConfig.budgetType || 'TOTAL',
+        budgetAmount: Math.round(budgetAmount * 100) / 100
+      };
+    }
+    
+    return this._splitBudget(campaign.budgetSetup, inventoryCount, totalInventories);
+  }
+
+  static _splitGoal(campaignGoal, groupSize, totalInventories) {
+    if (!campaignGoal) return undefined;
+    
+    const ratio = totalInventories > 0 ? groupSize / totalInventories : 1;
+    
+    return {
+      ...campaignGoal,
+      targetValue: campaignGoal.targetValue ? Math.round(campaignGoal.targetValue * ratio) : undefined
+    };
+  }
+
+  static _aggregatePlanning(inventories) {
+    const plannings = inventories.map(i => i.planning).filter(Boolean);
+    if (plannings.length === 0) return undefined;
+    
+    return {
+      capacity: {
+        campaignDays: plannings[0]?.capacity?.campaignDays,
+        available: {
+          slots: this._sum(plannings, p => p.capacity?.available?.slots),
+          playTimeSec: this._sum(plannings, p => p.capacity?.available?.playTimeSec),
+          maxImpressions: this._sum(plannings, p => p.capacity?.available?.maxImpressions)
+        }
+      },
+      allocation: {
+        slots: this._sum(plannings, p => p.allocation?.slots),
+        playTimeSec: this._sum(plannings, p => p.allocation?.playTimeSec),
+        sov: this._avg(plannings, p => p.allocation?.sov),
+        sot: this._avg(plannings, p => p.allocation?.sot)
+      },
+      estimates: {
+        impressions: this._sum(plannings, p => p.estimates?.impressions),
+        reach: this._sum(plannings, p => p.estimates?.reach),
+        frequency: this._avg(plannings, p => p.estimates?.frequency)
+      },
+      pricing: {
+        cpm: this._avg(plannings, p => p.pricing?.cpm),
+        estimatedCost: this._sum(plannings, p => p.pricing?.estimatedCost)
+      }
+    };
+  }
+
+  static _sum(arr, getter) {
+    const values = arr.map(getter).filter(v => v !== undefined && v !== null);
+    return values.length > 0 ? values.reduce((a, b) => a + b, 0) : undefined;
+  }
+
+  static _avg(arr, getter) {
+    const values = arr.map(getter).filter(v => v !== undefined && v !== null);
+    return values.length > 0 ? values.reduce((a, b) => a + b, 0) / values.length : undefined;
+  }
+
+  static _resolveAuctionType(dealType, providedAuctionType) {
+    if (providedAuctionType) return providedAuctionType;
+    if (dealType === 'GUARANTEED' || dealType === 'PREFERRED_DEAL') return 3;
+    if (dealType === 'PRIVATE_AUCTION' || dealType === 'EVERGREEN_PMP') return 1;
+    return 1;
+  }
+
+  static toSyncPayload(convertedResult) {
+    const { deal, lineItems, campaignInventories, insertionOrders, type } = convertedResult;
+    const payload = {
+      ...deal,
+      lineItems: lineItems.map(li => ({ ...li, inventories: li.inventories || [] }))
+    };
+    if (type === PayloadType.DIRECT_NO_LINE_ITEMS) {
+      payload.campaignInventories = campaignInventories || [];
+      payload.insertionOrders = insertionOrders || [];
+    }
+    return payload;
+  }
+
+  static validateExternalPayload(externalPayload, payloadType) {
+    const errors = [];
+    if (!externalPayload.campaign) {
+      errors.push('campaign object is required');
+    } else if (!externalPayload.campaign.name) {
+      errors.push('campaign.name is required');
+    }
+    if (payloadType === PayloadType.DIRECT_PUBLISHER_SPLIT || payloadType === PayloadType.DIRECT_NO_LINE_ITEMS) {
+      if (!externalPayload.inventories || !Array.isArray(externalPayload.inventories)) {
+        errors.push(`inventories array is required for ${payloadType}`);
+      } else if (externalPayload.inventories.length === 0) {
+        errors.push(`inventories array cannot be empty for ${payloadType}`);
+      } else {
+        externalPayload.inventories.forEach((inv, idx) => {
+          const hasPubId = (inv.publisher && inv.publisher.id) || inv.publisherId;
+          if (!hasPubId) {
+            errors.push(`inventories[${idx}] missing publisher ID`);
+          }
+        });
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+}
+
+export default CampaignImportConverter;