adserver-dashboard 1.0.0

package/PCM/src/services/CampaignModeService.js

@@ -0,0 +1,273 @@
+/**
+ * Campaign Mode Service
+ * Utility service for handling PROGRAMMATIC vs DIRECT campaign workflows
+ * Centralizes mode-specific validation, defaults, and business logic
+ */
+
+export const CAMPAIGN_MODES = {
+  PROGRAMMATIC: 'PROGRAMMATIC',
+  DIRECT: 'DIRECT'
+};
+
+export const CLIENT_TYPES = {
+  DIRECT_ADVERTISER: 'DIRECT_ADVERTISER',
+  AGENCY: 'AGENCY'
+};
+
+export const CAMPAIGN_GOAL_TYPES = {
+  IMPRESSIONS: 'IMPRESSIONS',
+  REACH: 'REACH',
+  SHARE_OF_VOICE: 'SHARE_OF_VOICE'
+};
+
+export const DEAL_TYPES = {
+  GUARANTEED: 'GUARANTEED',
+  PREFERRED_DEAL: 'PREFERRED_DEAL',
+  PRIVATE_AUCTION: 'PRIVATE_AUCTION',
+  EVERGREEN_PMP: 'EVERGREEN_PMP',
+  DIRECT: 'DIRECT'
+};
+
+export const AUCTION_TYPES = {
+  FIRST_PRICE: 1,
+  SECOND_PRICE: 2,
+  FIXED_PRICE: 3
+};
+
+export class CampaignModeService {
+  static isDirectMode(mode) {
+    return mode === CAMPAIGN_MODES.DIRECT;
+  }
+
+  static isProgrammaticMode(mode) {
+    return mode === CAMPAIGN_MODES.PROGRAMMATIC || !mode;
+  }
+
+  static getRequiredFieldsForMode(mode) {
+    if (this.isDirectMode(mode)) {
+      return {
+        required: ['brand', 'clientType', 'marketSelection', 'budgetSetup', 'campaignGoal'],
+        optional: ['approvalEmails']
+      };
+    }
+    return {
+      required: [],
+      optional: ['brand', 'clientType', 'approvalEmails', 'marketSelection', 'budgetSetup', 'campaignGoal']
+    };
+  }
+
+  static validateDirectModeFields(data) {
+    const errors = [];
+    
+    if (!this.isDirectMode(data.mode)) {
+      return { valid: true, errors: [] };
+    }
+
+    if (!data.brand) {
+      errors.push({ field: 'brand', message: 'Brand is required for DIRECT mode' });
+    }
+    if (!data.clientType) {
+      errors.push({ field: 'clientType', message: 'Client type is required for DIRECT mode' });
+    }
+    if (!data.marketSelection) {
+      errors.push({ field: 'marketSelection', message: 'Market selection is required for DIRECT mode' });
+    }
+    if (!data.budgetSetup) {
+      errors.push({ field: 'budgetSetup', message: 'Budget setup is required for DIRECT mode' });
+    }
+    if (!data.campaignGoal) {
+      errors.push({ field: 'campaignGoal', message: 'Campaign goal is required for DIRECT mode' });
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  static applyDefaults(data) {
+    const result = { ...data };
+    
+    if (!result.mode) {
+      result.mode = CAMPAIGN_MODES.PROGRAMMATIC;
+    }
+
+    if (this.isDirectMode(result.mode)) {
+      result.dealType = 'DIRECT';
+    }
+
+    if (!result.status) {
+      result.status = 'GENERATED';
+    }
+
+    if (this.isProgrammaticMode(result.mode) && result.dealType) {
+      result.auctionType = this.getDefaultAuctionType(result.dealType, result.auctionType);
+      
+      if (result.impMultiplierType === undefined) {
+        result.impMultiplierType = 'MAD';
+      }
+    }
+
+    if (result.budgetSetup && result.budgetSetup.budgetAmount === undefined) {
+      result.budgetSetup.budgetAmount = null;
+    }
+
+    if (result.campaignGoal && result.campaignGoal.targetValue === undefined) {
+      result.campaignGoal.targetValue = null;
+    }
+
+    return result;
+  }
+
+  static getDefaultAuctionType(dealType, providedAuctionType) {
+    if (dealType === DEAL_TYPES.GUARANTEED || dealType === DEAL_TYPES.PREFERRED_DEAL) {
+      return AUCTION_TYPES.FIXED_PRICE;
+    }
+    if (dealType === DEAL_TYPES.PRIVATE_AUCTION || dealType === DEAL_TYPES.EVERGREEN_PMP) {
+      return providedAuctionType || AUCTION_TYPES.FIRST_PRICE;
+    }
+    return providedAuctionType;
+  }
+
+  static validateAuctionType(dealType, auctionType) {
+    if (dealType === DEAL_TYPES.GUARANTEED || dealType === DEAL_TYPES.PREFERRED_DEAL) {
+      if (auctionType && auctionType !== AUCTION_TYPES.FIXED_PRICE) {
+        return { valid: false, error: 'Auction type must be 3 (fixed price) for GUARANTEED and PREFERRED_DEAL deals' };
+      }
+    }
+    if (dealType === DEAL_TYPES.PRIVATE_AUCTION || dealType === DEAL_TYPES.EVERGREEN_PMP) {
+      if (auctionType && auctionType !== AUCTION_TYPES.FIRST_PRICE && auctionType !== AUCTION_TYPES.SECOND_PRICE) {
+        return { valid: false, error: 'Auction type must be 1 (first price) or 2 (second price) for PRIVATE_AUCTION and EVERGREEN_PMP deals' };
+      }
+    }
+    return { valid: true };
+  }
+
+  static validateCostType(dealType, costType) {
+    if (costType === 'CPS' && dealType === DEAL_TYPES.GUARANTEED) {
+      return { valid: false, error: 'CPS cost type is not available for GUARANTEED deals' };
+    }
+    return { valid: true };
+  }
+
+  static buildAdvertiserFromClientType(data) {
+    if (!this.isDirectMode(data.mode) || data.source !== 'influence') {
+      return null;
+    }
+    
+    return {
+      id: '',
+      seatId: '',
+      name: data.brand || ''
+    };
+  }
+
+  static sanitizeForUpdate(existingData, updateData, newMode = null) {
+    const result = { ...updateData };
+    
+    const resultingMode = newMode || updateData.mode || existingData.mode;
+    
+    if (existingData.mode === CAMPAIGN_MODES.DIRECT && resultingMode === CAMPAIGN_MODES.PROGRAMMATIC) {
+      result.brand = result.brand !== undefined ? result.brand : null;
+      result.clientType = result.clientType !== undefined ? result.clientType : null;
+      result.approvalEmails = null;
+      result.marketSelection = null;
+      result.budgetSetup = null;
+      result.campaignGoal = null;
+    }
+
+    return result;
+  }
+
+  static getWorkflowInfo(mode) {
+    if (this.isDirectMode(mode)) {
+      return {
+        mode: CAMPAIGN_MODES.DIRECT,
+        description: 'Traditional direct campaign with approval workflow',
+        requiredFields: ['brand', 'clientType', 'approvalEmails', 'marketSelection', 'budgetSetup', 'campaignGoal'],
+        features: ['Approval workflow', 'Budget planning', 'Market targeting', 'Goal tracking']
+      };
+    }
+    return {
+      mode: CAMPAIGN_MODES.PROGRAMMATIC,
+      description: 'Standard programmatic deal workflow',
+      requiredFields: ['source', 'externalId'],
+      features: ['Programmatic buying', 'Real-time bidding', 'Automated delivery']
+    };
+  }
+
+  static validateCampaignGoal(campaignGoal) {
+    if (!campaignGoal) return { valid: true, errors: [] };
+
+    const errors = [];
+    const validTypes = Object.values(CAMPAIGN_GOAL_TYPES);
+
+    if (!campaignGoal.type) {
+      errors.push({ field: 'campaignGoal.type', message: 'Goal type is required' });
+    } else if (!validTypes.includes(campaignGoal.type)) {
+      errors.push({ 
+        field: 'campaignGoal.type', 
+        message: `Goal type must be one of: ${validTypes.join(', ')}` 
+      });
+    }
+
+    if (campaignGoal.targetValue !== undefined && campaignGoal.targetValue !== null) {
+      if (typeof campaignGoal.targetValue !== 'number' || campaignGoal.targetValue < 0) {
+        errors.push({ 
+          field: 'campaignGoal.targetValue', 
+          message: 'Target value must be a non-negative number' 
+        });
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  static validateBudgetSetup(budgetSetup) {
+    if (!budgetSetup) return { valid: true, errors: [] };
+
+    const errors = [];
+
+    if (!budgetSetup.currency) {
+      errors.push({ field: 'budgetSetup.currency', message: 'Currency is required' });
+    }
+
+    if (budgetSetup.budgetAmount !== undefined && budgetSetup.budgetAmount !== null) {
+      if (typeof budgetSetup.budgetAmount !== 'number' || budgetSetup.budgetAmount < 0) {
+        errors.push({ 
+          field: 'budgetSetup.budgetAmount', 
+          message: 'Budget amount must be a non-negative number' 
+        });
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  static validateMarketSelection(marketSelection) {
+    if (!marketSelection) return { valid: true, errors: [] };
+
+    const errors = [];
+
+    if (!marketSelection.country) {
+      errors.push({ field: 'marketSelection.country', message: 'Country is required' });
+    }
+
+    if (!marketSelection.currency) {
+      errors.push({ field: 'marketSelection.currency', message: 'Currency is required' });
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+}
+
+export default CampaignModeService;

package/PCM/src/services/CampaignStatusService.js

@@ -0,0 +1,395 @@
+import { normalizeSource, SOURCE_TYPES as NORMALIZED_SOURCE_TYPES } from '../utils/sourceNormalizer.js';
+
+export const CAMPAIGN_STATUSES = {
+  GENERATED: 'GENERATED',
+  REQUESTED: 'REQUESTED',
+  PENDING: 'PENDING',
+  APPROVED: 'APPROVED',
+  LIVE: 'LIVE',
+  COMPLETED: 'COMPLETED',
+  EXPIRED: 'EXPIRED',
+  REJECTED: 'REJECTED',
+  ARCHIVED: 'ARCHIVED',
+  REOPENED: 'REOPENED'
+};
+
+export const WORKFLOW_TYPES = {
+  DIRECT: 'DIRECT',
+  PROGRAMMATIC: 'PROGRAMMATIC'
+};
+
+export const SOURCE_TYPES = {
+  INTERNAL: 'INTERNAL',
+  EXTERNAL: 'EXTERNAL'
+};
+
+export const TRANSITION_OWNERS = {
+  USER: 'USER',
+  DSP: 'DSP',
+  MQ_WORKER: 'MQ_WORKER',
+  SCHEDULER: 'SCHEDULER',
+  ADMIN: 'ADMIN'
+};
+
+const VALID_TRANSITIONS = {
+  [CAMPAIGN_STATUSES.GENERATED]: [
+    CAMPAIGN_STATUSES.REQUESTED,
+    CAMPAIGN_STATUSES.PENDING,
+    CAMPAIGN_STATUSES.APPROVED,
+    CAMPAIGN_STATUSES.REJECTED,
+    CAMPAIGN_STATUSES.ARCHIVED
+  ],
+  [CAMPAIGN_STATUSES.REQUESTED]: [
+    CAMPAIGN_STATUSES.PENDING,
+    CAMPAIGN_STATUSES.APPROVED,
+    CAMPAIGN_STATUSES.REJECTED,
+    CAMPAIGN_STATUSES.ARCHIVED
+  ],
+  [CAMPAIGN_STATUSES.PENDING]: [
+    CAMPAIGN_STATUSES.APPROVED,
+    CAMPAIGN_STATUSES.REJECTED,
+    CAMPAIGN_STATUSES.ARCHIVED
+  ],
+  [CAMPAIGN_STATUSES.APPROVED]: [
+    CAMPAIGN_STATUSES.LIVE,
+    CAMPAIGN_STATUSES.EXPIRED,
+    CAMPAIGN_STATUSES.REJECTED,
+    CAMPAIGN_STATUSES.ARCHIVED,
+    CAMPAIGN_STATUSES.REOPENED
+  ],
+  [CAMPAIGN_STATUSES.LIVE]: [
+    CAMPAIGN_STATUSES.COMPLETED,
+    CAMPAIGN_STATUSES.ARCHIVED,
+    CAMPAIGN_STATUSES.REOPENED
+  ],
+  [CAMPAIGN_STATUSES.COMPLETED]: [
+    CAMPAIGN_STATUSES.ARCHIVED,
+    CAMPAIGN_STATUSES.REOPENED
+  ],
+  [CAMPAIGN_STATUSES.EXPIRED]: [
+    CAMPAIGN_STATUSES.ARCHIVED,
+    CAMPAIGN_STATUSES.REOPENED
+  ],
+  [CAMPAIGN_STATUSES.REJECTED]: [
+    CAMPAIGN_STATUSES.ARCHIVED,
+    CAMPAIGN_STATUSES.REOPENED
+  ],
+  [CAMPAIGN_STATUSES.ARCHIVED]: [
+    CAMPAIGN_STATUSES.REOPENED
+  ],
+  [CAMPAIGN_STATUSES.REOPENED]: [
+    CAMPAIGN_STATUSES.PENDING,
+    CAMPAIGN_STATUSES.APPROVED,
+    CAMPAIGN_STATUSES.LIVE,
+    CAMPAIGN_STATUSES.ARCHIVED
+  ]
+};
+
+const STATUSES_ALLOWING_REOPEN = [
+  CAMPAIGN_STATUSES.APPROVED,
+  CAMPAIGN_STATUSES.LIVE,
+  CAMPAIGN_STATUSES.COMPLETED,
+  CAMPAIGN_STATUSES.EXPIRED,
+  CAMPAIGN_STATUSES.REJECTED,
+  CAMPAIGN_STATUSES.ARCHIVED
+];
+
+const EDITABLE_STATUSES = [
+  CAMPAIGN_STATUSES.GENERATED,
+  CAMPAIGN_STATUSES.REQUESTED,
+  CAMPAIGN_STATUSES.REOPENED
+];
+
+const PACING_EDITABLE_STATUSES = [
+  CAMPAIGN_STATUSES.GENERATED,
+  CAMPAIGN_STATUSES.REQUESTED,
+  CAMPAIGN_STATUSES.REOPENED,
+  CAMPAIGN_STATUSES.APPROVED,
+  CAMPAIGN_STATUSES.LIVE
+];
+
+const BUDGET_EDITABLE_STATUSES = [
+  CAMPAIGN_STATUSES.GENERATED,
+  CAMPAIGN_STATUSES.REQUESTED,
+  CAMPAIGN_STATUSES.REOPENED,
+  CAMPAIGN_STATUSES.APPROVED
+];
+
+const STRUCTURE_EDITABLE_STATUSES = [
+  CAMPAIGN_STATUSES.GENERATED,
+  CAMPAIGN_STATUSES.REQUESTED,
+  CAMPAIGN_STATUSES.REOPENED
+];
+
+class CampaignStatusService {
+  isValidTransition(fromStatus, toStatus) {
+    const validNextStatuses = VALID_TRANSITIONS[fromStatus];
+    if (!validNextStatuses) {
+      return false;
+    }
+    return validNextStatuses.includes(toStatus);
+  }
+
+  getValidTransitions(currentStatus) {
+    return VALID_TRANSITIONS[currentStatus] || [];
+  }
+
+  canReopen(currentStatus) {
+    return STATUSES_ALLOWING_REOPEN.includes(currentStatus);
+  }
+
+  canEditPacing(status, source = SOURCE_TYPES.INTERNAL) {
+    if (source === SOURCE_TYPES.EXTERNAL) {
+      return [CAMPAIGN_STATUSES.APPROVED, CAMPAIGN_STATUSES.LIVE].includes(status);
+    }
+    return PACING_EDITABLE_STATUSES.includes(status);
+  }
+
+  canEditBudget(status, source = SOURCE_TYPES.INTERNAL) {
+    if (source === SOURCE_TYPES.EXTERNAL) {
+      return status === CAMPAIGN_STATUSES.APPROVED;
+    }
+    return BUDGET_EDITABLE_STATUSES.includes(status);
+  }
+
+  canEditStructure(status, source = SOURCE_TYPES.INTERNAL) {
+    if (source === SOURCE_TYPES.EXTERNAL) {
+      return false;
+    }
+    return STRUCTURE_EDITABLE_STATUSES.includes(status);
+  }
+
+  getEditableFields(status, source = SOURCE_TYPES.INTERNAL, workflow = WORKFLOW_TYPES.DIRECT) {
+    const fields = {
+      pacing: this.canEditPacing(status, source),
+      budget: this.canEditBudget(status, source),
+      structure: this.canEditStructure(status, source),
+      inventory: this.canEditStructure(status, source),
+      lineItems: this.canEditStructure(status, source),
+      dates: this.canEditStructure(status, source),
+      creatives: this.canEditStructure(status, source),
+      commercialTerms: this.canEditStructure(status, source)
+    };
+
+    return fields;
+  }
+
+  validateTransition(campaign, toStatus, context = {}) {
+    const { owner = TRANSITION_OWNERS.USER, source, workflow } = context;
+    const currentStatus = campaign.status;
+    const rawSource = source || campaign.source;
+    const campaignSource = (rawSource === SOURCE_TYPES.INTERNAL || rawSource === SOURCE_TYPES.EXTERNAL) 
+      ? rawSource 
+      : normalizeSource(rawSource);
+    const campaignWorkflow = workflow || campaign.mode || WORKFLOW_TYPES.DIRECT;
+
+    const errors = [];
+
+    if (!this.isValidTransition(currentStatus, toStatus)) {
+      errors.push({
+        code: 'INVALID_TRANSITION',
+        message: `Cannot transition from ${currentStatus} to ${toStatus}`,
+        allowedTransitions: this.getValidTransitions(currentStatus)
+      });
+    }
+
+    if (toStatus === CAMPAIGN_STATUSES.REOPENED && !this.canReopen(currentStatus)) {
+      errors.push({
+        code: 'REOPEN_NOT_ALLOWED',
+        message: `Cannot reopen campaign from status ${currentStatus}. Allowed from: ${STATUSES_ALLOWING_REOPEN.join(', ')}`
+      });
+    }
+
+    if (toStatus === CAMPAIGN_STATUSES.LIVE) {
+      if (owner !== TRANSITION_OWNERS.MQ_WORKER) {
+        errors.push({
+          code: 'LIVE_REQUIRES_DELIVERY',
+          message: 'LIVE status can only be set by MQ_WORKER when delivery is confirmed (first ad play or first bid win).',
+          allowedOwner: TRANSITION_OWNERS.MQ_WORKER
+        });
+      }
+    }
+
+    if (toStatus === CAMPAIGN_STATUSES.COMPLETED || toStatus === CAMPAIGN_STATUSES.EXPIRED) {
+      if (owner !== TRANSITION_OWNERS.SCHEDULER) {
+        errors.push({
+          code: 'SCHEDULER_ONLY',
+          message: `${toStatus} status can only be set by SCHEDULER based on end date or delivery events.`,
+          allowedOwner: TRANSITION_OWNERS.SCHEDULER
+        });
+      }
+    }
+
+    if (campaignWorkflow === WORKFLOW_TYPES.PROGRAMMATIC && campaignSource === SOURCE_TYPES.EXTERNAL) {
+      if (toStatus === CAMPAIGN_STATUSES.APPROVED) {
+        if (owner !== TRANSITION_OWNERS.DSP && owner !== TRANSITION_OWNERS.MQ_WORKER) {
+          errors.push({
+            code: 'DSP_APPROVAL_REQUIRED',
+            message: 'External PROGRAMMATIC deals require buyer acceptance from DSP for APPROVED status.',
+            allowedOwners: [TRANSITION_OWNERS.DSP, TRANSITION_OWNERS.MQ_WORKER]
+          });
+        }
+      }
+      if (toStatus === CAMPAIGN_STATUSES.REJECTED) {
+        if (owner !== TRANSITION_OWNERS.DSP && owner !== TRANSITION_OWNERS.MQ_WORKER) {
+          errors.push({
+            code: 'DSP_REJECTION_REQUIRED',
+            message: 'External PROGRAMMATIC deals can only be rejected by DSP.',
+            allowedOwners: [TRANSITION_OWNERS.DSP, TRANSITION_OWNERS.MQ_WORKER]
+          });
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      fromStatus: currentStatus,
+      toStatus,
+      workflow: campaignWorkflow,
+      source: campaignSource
+    };
+  }
+
+  validateUpdate(campaign, updateData, context = {}) {
+    const { source, workflow } = context;
+    const campaignSource = source || campaign.source || SOURCE_TYPES.INTERNAL;
+    const campaignWorkflow = workflow || campaign.mode || WORKFLOW_TYPES.DIRECT;
+    const status = campaign.status;
+
+    const errors = [];
+    const warnings = [];
+
+    const editableFields = this.getEditableFields(status, campaignSource, campaignWorkflow);
+
+    const structuralFields = ['lineItems', 'inventories', 'dates', 'creatives', 'startDate', 'endDate'];
+    const budgetFields = ['budget', 'budgetSetup', 'budgetAmount', 'budgetType'];
+    const pacingFields = ['pacing', 'pacingType', 'dailyCap', 'hourlyCap'];
+
+    for (const field of Object.keys(updateData)) {
+      if (structuralFields.includes(field) && !editableFields.structure) {
+        errors.push({
+          code: 'FIELD_NOT_EDITABLE',
+          field,
+          message: `Cannot modify ${field} when status is ${status}${campaignSource === SOURCE_TYPES.EXTERNAL ? ' (external source)' : ''}`
+        });
+      }
+
+      if (budgetFields.includes(field) && !editableFields.budget) {
+        errors.push({
+          code: 'FIELD_NOT_EDITABLE',
+          field,
+          message: `Cannot modify ${field} when status is ${status}${campaignSource === SOURCE_TYPES.EXTERNAL ? ' (external source)' : ''}`
+        });
+      }
+    }
+
+    for (const field of Object.keys(updateData)) {
+      if (pacingFields.includes(field) && !editableFields.pacing) {
+        warnings.push({
+          code: 'PACING_NOT_EDITABLE',
+          field,
+          message: `Pacing updates are restricted for status ${status}`
+        });
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      editableFields,
+      status,
+      source: campaignSource,
+      workflow: campaignWorkflow
+    };
+  }
+
+  getStatusDefinition(status, workflow = WORKFLOW_TYPES.DIRECT) {
+    const definitions = {
+      [CAMPAIGN_STATUSES.GENERATED]: {
+        [WORKFLOW_TYPES.DIRECT]: 'AdOps creates draft from IO / sales request',
+        [WORKFLOW_TYPES.PROGRAMMATIC]: 'Media Owner creates deal via UI/API'
+      },
+      [CAMPAIGN_STATUSES.REQUESTED]: {
+        [WORKFLOW_TYPES.DIRECT]: 'Planner pushes draft for review (rare)',
+        [WORKFLOW_TYPES.PROGRAMMATIC]: 'DSP sends structured deal request'
+      },
+      [CAMPAIGN_STATUSES.PENDING]: {
+        [WORKFLOW_TYPES.DIRECT]: 'Approval emails done, IO sent, waiting for signed IO. Validation required: inventory, budget, schedule',
+        [WORKFLOW_TYPES.PROGRAMMATIC]: 'Deal pushed to DSP, awaiting buyer acceptance'
+      },
+      [CAMPAIGN_STATUSES.APPROVED]: {
+        [WORKFLOW_TYPES.DIRECT]: 'Signed IO received, AdOps approves',
+        [WORKFLOW_TYPES.PROGRAMMATIC]: 'Buyer accepts deal in DSP, inventory hard reserved'
+      },
+      [CAMPAIGN_STATUSES.LIVE]: {
+        [WORKFLOW_TYPES.DIRECT]: 'Start date reached + first CMS ad play confirmed',
+        [WORKFLOW_TYPES.PROGRAMMATIC]: 'First valid bid request/win received'
+      },
+      [CAMPAIGN_STATUSES.COMPLETED]: {
+        [WORKFLOW_TYPES.DIRECT]: 'End date reached OR goal met',
+        [WORKFLOW_TYPES.PROGRAMMATIC]: 'End date reached OR goal met'
+      },
+      [CAMPAIGN_STATUSES.EXPIRED]: {
+        [WORKFLOW_TYPES.DIRECT]: 'Start date passed, no creative or play',
+        [WORKFLOW_TYPES.PROGRAMMATIC]: 'Approved deal, no bids received'
+      },
+      [CAMPAIGN_STATUSES.REJECTED]: {
+        [WORKFLOW_TYPES.DIRECT]: 'Client withdrew or IO not signed',
+        [WORKFLOW_TYPES.PROGRAMMATIC]: 'Buyer rejected deal in DSP'
+      },
+      [CAMPAIGN_STATUSES.ARCHIVED]: {
+        [WORKFLOW_TYPES.DIRECT]: 'Campaign moved to cold storage after validity period',
+        [WORKFLOW_TYPES.PROGRAMMATIC]: 'Campaign moved to cold storage after validity period'
+      },
+      [CAMPAIGN_STATUSES.REOPENED]: {
+        [WORKFLOW_TYPES.DIRECT]: 'Closed campaign reopened - allows modification of dates, inventory, floor rates',
+        [WORKFLOW_TYPES.PROGRAMMATIC]: 'Closed campaign reopened - allows modification of dates, inventory, floor rates'
+      }
+    };
+
+    return definitions[status]?.[workflow] || 'Unknown status';
+  }
+
+  getTransitionOwnership() {
+    return {
+      [TRANSITION_OWNERS.USER]: 'Manual approval via User / UI',
+      [TRANSITION_OWNERS.DSP]: 'Buyer accept/reject from DSP',
+      [TRANSITION_OWNERS.MQ_WORKER]: 'Delivery confirmation (first play/bid)',
+      [TRANSITION_OWNERS.SCHEDULER]: 'End date checks, expiration',
+      [TRANSITION_OWNERS.ADMIN]: 'Archival, reopening'
+    };
+  }
+
+  getWorkflowRules() {
+    return {
+      sameDayApproval: {
+        description: 'When campaign is APPROVED on the same date as start date',
+        rules: [
+          'APPROVED does not automatically mean LIVE',
+          'Campaign stays in APPROVED until delivery confirmation',
+          'LIVE transition requires first ad play (Direct) or first bid win (Programmatic)',
+          'Between APPROVED → LIVE: pacing updates allowed, budget allocation allowed'
+        ]
+      },
+      externalSource: {
+        description: 'Externally sourced campaigns are execution-only',
+        cannotModify: [
+          'Campaign structure',
+          'Line items',
+          'Inventory',
+          'Dates',
+          'Creatives',
+          'Commercial terms'
+        ],
+        canModify: {
+          APPROVED: ['Pacing', 'Budget allocation'],
+          LIVE: ['Pacing only']
+        }
+      }
+    };
+  }
+}
+
+export default new CampaignStatusService();