adserver-dashboard 1.0.0

package/PCM/src/tests/testRunner.js

@@ -0,0 +1,248 @@
+/**
+ * Test Runner
+ * Executes unit tests and returns results
+ */
+
+import { dealTypeTests } from './dealTypeUnitTests.js';
+
+// Use environment variable or default to localhost for internal requests
+const API_BASE = process.env.API_BASE_URL || 'http://127.0.0.1:5000/api/v1/rest';
+
+export class TestRunner {
+  constructor(baseUrl = null) {
+    this.results = [];
+    this.createdDeals = [];
+    this.dealsByType = {}; // Track deals by type
+    this.apiBase = baseUrl || API_BASE;
+  }
+
+  async runAllTests() {
+    const startTime = Date.now();
+    this.results = [];
+    this.createdDeals = [];
+    this.dealsByType = {}; // Reset deal tracking
+
+    for (const test of dealTypeTests) {
+      const result = await this.runSingleTest(test);
+      this.results.push(result);
+    }
+
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+
+    const summary = this.getSummary();
+    summary.duration_ms = duration;
+
+    return {
+      summary,
+      results: this.results
+    };
+  }
+
+  async runSingleTest(test) {
+    const testResult = {
+      id: test.id,
+      name: test.name,
+      type: test.type,
+      status: 'pending',
+      actualStatus: null,
+      passed: false,
+      error: null,
+      response: null
+    };
+
+    try {
+      let response, data;
+      
+      // Make test payload unique per run
+      const uniquePayload = this.makeUniquePayload(test.payload);
+
+      // Determine endpoint based on test ID and type
+      // Line item tests: include 'LI-' in their ID
+      // Exception: CAMPAIGN_MODE and VALIDATION tests are always deal tests
+      // NESTED tests follow original logic (001 = deal, 002+ = line item)
+      const isAlwaysDealTest = test.type === 'CAMPAIGN_MODE' || test.type === 'VALIDATION' || test.type === 'DEAL_ID_GENERATION' || 
+                               test.type === 'AUCTION_TYPE' || test.type === 'COST_TYPE' || test.type === 'TRANSACTION_TYPE' ||
+                               test.type === 'PROGRAMMATIC_FIELDS' || test.type === 'STATUS';
+      const isLineItemTest = !isAlwaysDealTest && (test.id.includes('LI-') || (/_00[2-9]$/.test(test.id) || /_0[1-9][0-9]$/.test(test.id)));
+      
+      if (isLineItemTest) {
+        // Line item test - need parent deal first
+        const dealId = await this.ensureDealExists(test.type);
+        if (!dealId) {
+          testResult.status = 'skipped';
+          testResult.error = 'Parent deal not available';
+          return testResult;
+        }
+
+        ({ response, data } = await this.makeRequest('POST', `/deals/${dealId}/line-items`, uniquePayload));
+      } else {
+        // Deal test
+        ({ response, data } = await this.makeRequest('POST', '/deals', uniquePayload));
+        if (response.status === 201 && data.result?.dealId) {
+          this.createdDeals.push(data.result.dealId);
+          // Track deal by type for line item tests
+          this.dealsByType[test.type] = data.result.dealId;
+        }
+      }
+
+      testResult.actualStatus = response.status;
+      testResult.response = data;
+
+      // Check if test passed
+      if (test.expectedStatus === response.status) {
+        if (test.expectedError) {
+          // Negative test - should have specific error
+          const errorMessage = JSON.stringify(data).toLowerCase();
+          testResult.passed = errorMessage.includes(test.expectedError.toLowerCase());
+          testResult.status = testResult.passed ? 'passed' : 'failed';
+        } else {
+          // Positive test - should succeed
+          testResult.passed = true;
+          testResult.status = 'passed';
+          
+          // Validate deal ID prefix format if specified
+          if (test.expectedDealIdPrefix && data.result?.dealId) {
+            const dealId = data.result.dealId;
+            if (!dealId.startsWith(test.expectedDealIdPrefix)) {
+              testResult.passed = false;
+              testResult.status = 'failed';
+              testResult.error = `Expected dealId to start with '${test.expectedDealIdPrefix}', got '${dealId}'`;
+            }
+            // Validate the full format: PREFIX-I-XXXXX-XXXXX
+            const formatPattern = new RegExp(`^${test.expectedDealIdPrefix.replace('-I-', '-I-')}\\d{5}-\\d{5}$`);
+            if (testResult.passed && !formatPattern.test(dealId)) {
+              testResult.passed = false;
+              testResult.status = 'failed';
+              testResult.error = `Deal ID '${dealId}' does not match expected format '${test.expectedDealIdPrefix}XXXXX-XXXXX'`;
+            }
+          }
+          
+          // Validate auction type if expected
+          if (test.expectedAuctionType && data.result?.dealId && testResult.passed) {
+            const getDealResponse = await this.makeRequest('GET', `/deals/${data.result.dealId}`);
+            const auctionType = getDealResponse.data.result?.programmatic?.auctionType;
+            if (auctionType !== test.expectedAuctionType) {
+              testResult.passed = false;
+              testResult.status = 'failed';
+              testResult.error = `Expected auctionType ${test.expectedAuctionType}, got ${auctionType}`;
+            }
+          }
+          
+          // Validate impMultiplierType if expected
+          if (test.expectedImpMultiplierType && data.result?.dealId && testResult.passed) {
+            const getDealResponse = await this.makeRequest('GET', `/deals/${data.result.dealId}`);
+            const impMultiplierType = getDealResponse.data.result?.programmatic?.impMultiplierType;
+            if (impMultiplierType !== test.expectedImpMultiplierType) {
+              testResult.passed = false;
+              testResult.status = 'failed';
+              testResult.error = `Expected impMultiplierType '${test.expectedImpMultiplierType}', got '${impMultiplierType}'`;
+            }
+          }
+          
+          // Validate deal status if expected
+          if (test.expectedDealStatus && data.result?.status && testResult.passed) {
+            if (data.result.status !== test.expectedDealStatus) {
+              testResult.passed = false;
+              testResult.status = 'failed';
+              testResult.error = `Expected deal status '${test.expectedDealStatus}', got '${data.result.status}'`;
+            }
+          }
+          
+          // Handle updatePayload if present (for mode switch tests)
+          if (test.updatePayload && data.result?.dealId) {
+            const updateResponse = await this.makeRequest('PUT', `/deals/${data.result.dealId}`, test.updatePayload);
+            if (test.expectedUpdateStatus && updateResponse.response.status !== test.expectedUpdateStatus) {
+              testResult.passed = false;
+              testResult.status = 'failed';
+              testResult.error = `Update expected status ${test.expectedUpdateStatus}, got ${updateResponse.response.status}`;
+            }
+          }
+          
+          // Handle lineItemPayload if present (for lifecycle tests)
+          if (test.lineItemPayload && data.result?.dealId) {
+            const lineItemPayload = this.makeUniquePayload(test.lineItemPayload);
+            const liResponse = await this.makeRequest('POST', `/deals/${data.result.dealId}/line-items`, lineItemPayload);
+            if (test.expectedLineItemStatus && liResponse.response.status !== test.expectedLineItemStatus) {
+              testResult.passed = false;
+              testResult.status = 'failed';
+              testResult.error = `Line item expected status ${test.expectedLineItemStatus}, got ${liResponse.response.status}`;
+            }
+          }
+        }
+      } else {
+        testResult.passed = false;
+        testResult.status = 'failed';
+        testResult.error = `Expected status ${test.expectedStatus}, got ${response.status}`;
+      }
+
+    } catch (error) {
+      testResult.status = 'error';
+      testResult.error = error.message;
+      testResult.passed = false;
+    }
+
+    return testResult;
+  }
+
+  makeUniquePayload(payload) {
+    const timestamp = Date.now();
+    const uniquePayload = { ...payload };
+    
+    if (uniquePayload.externalId) {
+      uniquePayload.externalId = `${uniquePayload.externalId}-${timestamp}`;
+    }
+    
+    return uniquePayload;
+  }
+
+  async ensureDealExists(type) {
+    // Return the tracked deal ID for this type
+    return this.dealsByType[type] || this.createdDeals[0];
+  }
+
+  async makeRequest(method, path, body = null) {
+    const options = {
+      method,
+      headers: { 'Content-Type': 'application/json' }
+    };
+    if (body) options.body = JSON.stringify(body);
+
+    const response = await fetch(`${this.apiBase}${path}`, options);
+    const data = await response.json();
+    return { response, data };
+  }
+
+  async cleanup() {
+    for (const dealId of this.createdDeals) {
+      try {
+        await this.makeRequest('DELETE', `/deals/${dealId}`);
+      } catch (error) {
+        // Ignore cleanup errors
+      }
+    }
+  }
+
+  getSummary() {
+    const total = this.results.length;
+    const passed = this.results.filter(r => r.passed).length;
+    const failed = this.results.filter(r => r.status === 'failed').length;
+    const errors = this.results.filter(r => r.status === 'error').length;
+    const skipped = this.results.filter(r => r.status === 'skipped').length;
+
+    return {
+      total,
+      passed,
+      failed,
+      errors,
+      skipped,
+      success_rate: total > 0 ? ((passed / total) * 100).toFixed(2) + '%' : '0%'
+    };
+  }
+
+  getResultsByType(type) {
+    return this.results.filter(r => r.type === type);
+  }
+}
+
+export default TestRunner;

package/PCM/src/utils/caseConverter.js

@@ -0,0 +1,92 @@
+/**
+ * Recursively strips specified keys from an object
+ */
+export const stripKeys = (obj, keysToStrip) => {
+  if (obj === null || obj === undefined) return obj;
+  
+  if (Array.isArray(obj)) {
+    return obj.map(item => stripKeys(item, keysToStrip));
+  }
+  
+  if (typeof obj !== 'object') {
+    return obj;
+  }
+  
+  if (obj instanceof Date) {
+    return obj;
+  }
+  
+  const newObj = {};
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key) && !keysToStrip.includes(key)) {
+      newObj[key] = stripKeys(obj[key], keysToStrip);
+    }
+  }
+  return newObj;
+};
+
+/**
+ * Recursively converts object keys from snake_case to camelCase
+ * Handles nested objects and arrays
+ */
+export const toCamelCase = (obj) => {
+  if (obj === null || obj === undefined) return obj;
+  
+  // Handle arrays
+  if (Array.isArray(obj)) {
+    return obj.map(item => toCamelCase(item));
+  }
+  
+  // Handle non-object primitives
+  if (typeof obj !== 'object') {
+    return obj;
+  }
+  
+  // Handle Date objects
+  if (obj instanceof Date) {
+    return obj;
+  }
+  
+  // Convert object keys
+  const newObj = {};
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      const camelKey = key.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
+      newObj[camelKey] = toCamelCase(obj[key]); // Recursive call
+    }
+  }
+  return newObj;
+};
+
+/**
+ * Recursively converts object keys from camelCase to snake_case
+ * Handles nested objects and arrays
+ */
+export const toSnakeCase = (obj) => {
+  if (obj === null || obj === undefined) return obj;
+  
+  // Handle arrays
+  if (Array.isArray(obj)) {
+    return obj.map(item => toSnakeCase(item));
+  }
+  
+  // Handle non-object primitives
+  if (typeof obj !== 'object') {
+    return obj;
+  }
+  
+  // Handle Date objects
+  if (obj instanceof Date) {
+    return obj;
+  }
+  
+  // Convert object keys
+  const newObj = {};
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      const snakeKey = key.replace(/([A-Z])/g, '_$1').toLowerCase();
+      newObj[snakeKey] = toSnakeCase(obj[key]); // Recursive call
+    }
+  }
+  return newObj;
+};

package/PCM/src/utils/dealCalculations.js

@@ -0,0 +1,206 @@
+/**
+ * Calculate deal dates and metrics from line items
+ */
+
+/**
+ * Auto-calculate deal fields from line items
+ * @param {Array} lineItems - Array of line items (with inventories if available)
+ * @returns {Object} Calculated deal fields
+ */
+export function calculateDealMetrics(lineItems, mode = 'PROGRAMMATIC') {
+  if (!lineItems || lineItems.length === 0) {
+    const baseResult = {
+      start_date: null,
+      end_date: null,
+      net_cost: '0.00',
+      delivery_goal: 0,
+      impressions: 0,
+      net_cost_per_day: '0.00',
+      timezone_id: null,
+      publishers: [],
+      line_items_count: 0
+    };
+    if (mode === 'DIRECT') {
+      baseResult.planning = null;
+    }
+    return baseResult;
+  }
+
+  let startDate = null;
+  let endDate = null;
+  let netCost = 0;
+  let deliveryGoal = 0;
+  let impressions = 0;
+  let netCostPerDay = 0;
+  let timezoneId = null;
+  const publishersMap = new Map();
+
+  lineItems.forEach(item => {
+    // Calculate earliest start date
+    if (item.start_date) {
+      const itemStartDate = new Date(item.start_date);
+      if (!startDate || itemStartDate < startDate) {
+        startDate = itemStartDate;
+      }
+    }
+
+    // Calculate latest end date
+    if (item.end_date) {
+      const itemEndDate = new Date(item.end_date);
+      if (!endDate || itemEndDate > endDate) {
+        endDate = itemEndDate;
+      }
+    }
+
+    // Capture first non-null timezone (should be consistent across line items)
+    if (!timezoneId && item.timezone_id) {
+      timezoneId = item.timezone_id;
+    }
+
+    // Sum numeric fields
+    if (item.net_cost) {
+      netCost += parseFloat(item.net_cost);
+    }
+    if (item.delivery_goal) {
+      deliveryGoal += parseInt(item.delivery_goal);
+    }
+    if (item.impressions) {
+      impressions += parseInt(item.impressions);
+    }
+    if (item.net_cost_per_day) {
+      netCostPerDay += parseFloat(item.net_cost_per_day);
+    }
+
+    // Aggregate unique publishers from inventories
+    if (item.inventories && Array.isArray(item.inventories)) {
+      item.inventories.forEach(inv => {
+        const pubId = inv.publisher_id;
+        const pubName = inv.publisher_name;
+        const pubExternalId = inv.publisher_external_id || null;
+        if (pubId && !publishersMap.has(pubId)) {
+          publishersMap.set(pubId, { id: pubId, name: pubName || pubId, externalId: pubExternalId });
+        }
+      });
+    }
+  });
+
+  const result = {
+    start_date: startDate ? startDate.toISOString().split('T')[0] : null,
+    end_date: endDate ? endDate.toISOString().split('T')[0] : null,
+    net_cost: netCost.toFixed(2),
+    delivery_goal: deliveryGoal,
+    impressions: impressions,
+    net_cost_per_day: netCostPerDay.toFixed(2),
+    timezone_id: timezoneId,
+    publishers: Array.from(publishersMap.values()),
+    line_items_count: lineItems.length
+  };
+
+  if (mode === 'DIRECT') {
+    result.planning = aggregatePlanningFromLineItems(lineItems);
+  }
+
+  return result;
+}
+
+/**
+ * Aggregate planning data from line items for DIRECT campaigns
+ * Handles both camelCase and snake_case keys from database storage
+ * @param {Array} lineItems - Array of line items with planning data
+ * @returns {Object|null} Aggregated planning object
+ */
+export function aggregatePlanningFromLineItems(lineItems) {
+  if (!lineItems || lineItems.length === 0) {
+    return null;
+  }
+
+  const lineItemsWithPlanning = lineItems.filter(li => li.planning);
+  if (lineItemsWithPlanning.length === 0) {
+    return null;
+  }
+
+  const aggregated = {
+    capacity: {
+      campaignDays: 0,
+      available: {
+        slots: 0,
+        playTimeSec: 0,
+        maxImpressions: 0
+      }
+    },
+    allocation: {
+      slots: 0,
+      playTimeSec: 0,
+      sov: 0,
+      sot: 0
+    },
+    estimates: {
+      impressions: 0,
+      reach: 0,
+      frequency: 0
+    },
+    pricing: {
+      cpm: 0,
+      estimatedCost: 0
+    }
+  };
+
+  let maxCampaignDays = 0;
+  let totalWeight = 0;
+
+  lineItemsWithPlanning.forEach(li => {
+    const planning = li.planning;
+    
+    if (planning.capacity) {
+      const campaignDays = planning.capacity.campaignDays || planning.capacity.campaign_days || 0;
+      if (campaignDays > maxCampaignDays) {
+        maxCampaignDays = campaignDays;
+      }
+      if (planning.capacity.available) {
+        aggregated.capacity.available.slots += planning.capacity.available.slots || 0;
+        aggregated.capacity.available.playTimeSec += planning.capacity.available.playTimeSec || planning.capacity.available.play_time_sec || 0;
+        aggregated.capacity.available.maxImpressions += planning.capacity.available.maxImpressions || planning.capacity.available.max_impressions || 0;
+      }
+    }
+    
+    if (planning.allocation) {
+      aggregated.allocation.slots += planning.allocation.slots || 0;
+      aggregated.allocation.playTimeSec += planning.allocation.playTimeSec || planning.allocation.play_time_sec || 0;
+    }
+    
+    if (planning.estimates) {
+      aggregated.estimates.impressions += planning.estimates.impressions || 0;
+      aggregated.estimates.reach += planning.estimates.reach || 0;
+      totalWeight++;
+    }
+    
+    if (planning.pricing) {
+      aggregated.pricing.estimatedCost += planning.pricing.estimatedCost || planning.pricing.estimated_cost || 0;
+    }
+  });
+
+  aggregated.capacity.campaignDays = maxCampaignDays;
+  
+  if (aggregated.capacity.available.slots > 0) {
+    aggregated.allocation.sov = aggregated.allocation.slots / aggregated.capacity.available.slots;
+  }
+  if (aggregated.capacity.available.playTimeSec > 0) {
+    aggregated.allocation.sot = aggregated.allocation.playTimeSec / aggregated.capacity.available.playTimeSec;
+  }
+  
+  if (aggregated.estimates.reach > 0) {
+    aggregated.estimates.frequency = aggregated.estimates.impressions / aggregated.estimates.reach;
+    aggregated.estimates.frequency = Math.round(aggregated.estimates.frequency * 100) / 100;
+  }
+  
+  if (aggregated.estimates.impressions > 0) {
+    aggregated.pricing.cpm = (aggregated.pricing.estimatedCost / aggregated.estimates.impressions) * 1000;
+    aggregated.pricing.cpm = Math.round(aggregated.pricing.cpm * 100) / 100;
+  }
+  
+  aggregated.allocation.sov = Math.round(aggregated.allocation.sov * 100000) / 100000;
+  aggregated.allocation.sot = Math.round(aggregated.allocation.sot * 100000) / 100000;
+  aggregated.pricing.estimatedCost = Math.round(aggregated.pricing.estimatedCost * 100) / 100;
+
+  return aggregated;
+}

package/PCM/src/utils/lineItemPayloadNormalizer.js

@@ -0,0 +1,41 @@
+export function flattenLineItemPayload(payload) {
+  const flattened = { ...payload };
+  
+  // Flatten programmatic object if present
+  if (payload.programmatic) {
+    const programmatic = payload.programmatic;
+    
+    if (programmatic.auctionType !== undefined) flattened.auctionType = programmatic.auctionType;
+    if (programmatic.duration !== undefined) flattened.duration = programmatic.duration;
+    if (programmatic.impressionType !== undefined) flattened.impressionType = programmatic.impressionType;
+    if (programmatic.thresholdCountPerDay !== undefined) flattened.thresholdCountPerDay = programmatic.thresholdCountPerDay;
+    if (programmatic.deliveryGoal !== undefined) flattened.deliveryGoal = programmatic.deliveryGoal;
+    if (programmatic.costType !== undefined) flattened.costType = programmatic.costType;
+    if (programmatic.bidFloor !== undefined) flattened.bidFloor = programmatic.bidFloor;
+    if (programmatic.bidFloorBase !== undefined) flattened.bidFloorBase = programmatic.bidFloorBase;
+    if (programmatic.netCost !== undefined) flattened.netCost = programmatic.netCost;
+    if (programmatic.netCostPerDay !== undefined) flattened.netCostPerDay = programmatic.netCostPerDay;
+    if (programmatic.impressions !== undefined) flattened.impressions = programmatic.impressions;
+    if (programmatic.admCreativeSync !== undefined) flattened.admCreativeSync = programmatic.admCreativeSync;
+    if (programmatic.nonBillable !== undefined) flattened.nonBillable = programmatic.nonBillable;
+    if (programmatic.stopBidRequests !== undefined) flattened.stopBidRequests = programmatic.stopBidRequests;
+    if (programmatic.impMultiplier !== undefined) flattened.impMultiplier = programmatic.impMultiplier;
+    
+    delete flattened.programmatic;
+  }
+  
+  // Flatten direct object if present (pacing is now a common field, not in direct)
+  if (payload.direct) {
+    const direct = payload.direct;
+    
+    if (direct.budgetSetup !== undefined) flattened.budgetSetup = direct.budgetSetup;
+    if (direct.campaignGoal !== undefined) flattened.campaignGoal = direct.campaignGoal;
+    if (direct.targeting !== undefined) flattened.targeting = direct.targeting;
+    if (direct.planning !== undefined) flattened.planning = direct.planning;
+    if (direct.pricing !== undefined) flattened.pricing = direct.pricing;
+    
+    delete flattened.direct;
+  }
+  
+  return flattened;
+}

package/PCM/src/utils/payloadNormalizer.js

@@ -0,0 +1,34 @@
+const DIRECT_FIELDS = ['brand', 'clientType', 'approvalEmails', 'marketSelection', 'budgetSetup', 'campaignGoal'];
+const PROGRAMMATIC_FIELDS = ['buyers', 'auctionType', 'transactionType', 'costType', 'deliveryGoal', 'netCost', 'netCostPerDay', 'impressions', 'published', 'reopened', 'nonBillable', 'stopBidRequests', 'impMultiplierType'];
+
+export function flattenPayload(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return payload;
+  }
+
+  const result = { ...payload };
+
+  if (result.direct && typeof result.direct === 'object') {
+    for (const [key, value] of Object.entries(result.direct)) {
+      if (DIRECT_FIELDS.includes(key) && value !== undefined) {
+        result[key] = value;
+      }
+    }
+    delete result.direct;
+  }
+
+  if (result.programmatic && typeof result.programmatic === 'object') {
+    for (const [key, value] of Object.entries(result.programmatic)) {
+      if (PROGRAMMATIC_FIELDS.includes(key) && value !== undefined) {
+        result[key] = value;
+      }
+    }
+    delete result.programmatic;
+  }
+
+  return result;
+}
+
+export function normalizeRequestPayload(payload) {
+  return flattenPayload(payload);
+}

package/PCM/src/utils/sourceNormalizer.js

@@ -0,0 +1,56 @@
+export const SOURCE_TYPES = {
+  INTERNAL: 'INTERNAL',
+  EXTERNAL: 'EXTERNAL'
+};
+
+export const INTERNAL_SOURCES = ['influence'];
+
+export function normalizeSource(source) {
+  if (!source || typeof source !== 'string') {
+    return SOURCE_TYPES.EXTERNAL;
+  }
+  
+  const normalizedSource = source.toLowerCase().trim();
+  
+  if (INTERNAL_SOURCES.includes(normalizedSource)) {
+    return SOURCE_TYPES.INTERNAL;
+  }
+  
+  return SOURCE_TYPES.EXTERNAL;
+}
+
+export function isInternalSource(source) {
+  return normalizeSource(source) === SOURCE_TYPES.INTERNAL;
+}
+
+export function isExternalSource(source) {
+  return normalizeSource(source) === SOURCE_TYPES.EXTERNAL;
+}
+
+export function validateSourceForImport(source) {
+  if (!source) {
+    return { valid: true, normalizedSource: SOURCE_TYPES.EXTERNAL };
+  }
+  
+  const normalizedSourceValue = source.toLowerCase().trim();
+  
+  if (INTERNAL_SOURCES.includes(normalizedSourceValue)) {
+    return {
+      valid: false,
+      error: `Source '${source}' is reserved for internal operations and cannot be used in campaign imports. Use an external source identifier (e.g., 'broadsign', 'vistar', 'hivestack').`
+    };
+  }
+  
+  return { valid: true, normalizedSource: SOURCE_TYPES.EXTERNAL, rawSource: source };
+}
+
+export function getSourceDisplayInfo() {
+  return {
+    internalSources: INTERNAL_SOURCES,
+    description: {
+      INTERNAL: 'Campaigns created through AdOps UI or internal systems. Only "influence" is recognized as internal.',
+      EXTERNAL: 'Campaigns imported from external platforms (DSP, SSP, third-party systems). Any source other than "influence" is treated as external.'
+    },
+    importRestriction: 'The campaign import API does not accept "influence" as a valid source. Use platform-specific identifiers like "broadsign", "vistar", "hivestack", "place-exchange", etc.'
+  };
+}