adserver-dashboard 1.0.0

package/PCM/src/routes/digitalSignage.js

@@ -0,0 +1,242 @@
+import express from 'express';
+import { Op } from 'sequelize';
+import Deal from '../models/Deal.js';
+import LineItem from '../models/LineItem.js';
+import LineItemInventory from '../models/LineItemInventory.js';
+import LineItemCreative from '../models/LineItemCreative.js';
+
+const router = express.Router();
+
+const ACTIVE_DEAL_STATUSES = ['APPROVED', 'LIVE'];
+const ACTIVE_LINE_ITEM_STATUSES = ['APPROVED', 'LIVE'];
+
+const formatCreative = (creative) => ({
+  creativeId: creative.creative_id,
+  creativeUri: creative.creative_uri,
+  mimeType: creative.mime_type,
+  duration: creative.duration,
+  resolution: creative.resolution
+});
+
+const formatSchedule = (schedule) => {
+  if (!schedule) return null;
+  return schedule;
+};
+
+const formatPacing = (pacing) => {
+  if (!pacing) return null;
+  return pacing;
+};
+
+const generateAdPlayConfirmUrl = (req, dealId, lineItemId, inventoryId) => {
+  const baseUrl = `${req.protocol}://${req.get('host')}`;
+  return `${baseUrl}/api/v2/rest/ds/confirm/${dealId}/${lineItemId}/${inventoryId}`;
+};
+
+const formatDealForSignage = (deal, lineItem, inventory, creatives, req) => {
+  const publisher = {
+    id: inventory.publisher_id,
+    name: inventory.publisher_name,
+    domain: inventory.publisher_domain
+  };
+
+  const inventoryInfo = {
+    id: inventory.id,
+    deviceId: inventory.device_id,
+    name: inventory.name,
+    referenceId: inventory.reference_id
+  };
+
+  const formattedCreatives = creatives.map(formatCreative);
+
+  const response = {
+    name: deal.name,
+    dealId: deal.deal_id,
+    mode: (lineItem.mode || deal.mode)?.toLowerCase() || 'direct',
+    dealType: deal.deal_type,
+    startDate: deal.start_date,
+    endDate: deal.end_date,
+    lineItem: {
+      id: lineItem.external_id || lineItem.id,
+      name: lineItem.name,
+      creativeType: lineItem.creative_type,
+      duration: lineItem.duration
+    },
+    publisher,
+    inventory: inventoryInfo,
+    schedule: formatSchedule(lineItem.schedule),
+    pacing: formatPacing(lineItem.pacing),
+    creatives: formattedCreatives
+  };
+
+  if (deal.mode === 'DIRECT') {
+    response.direct = {
+      budgetSetup: deal.budget_setup || lineItem.budget_setup,
+      campaignGoal: deal.campaign_goal || lineItem.campaign_goal
+    };
+    
+    if (lineItem.delivery_targeting) {
+      response.deliveryTargeting = {
+        signals: lineItem.delivery_targeting.signals || lineItem.delivery_targeting,
+        ad_play_confirm_url: generateAdPlayConfirmUrl(req, deal.deal_id, lineItem.external_id || lineItem.id, inventory.id)
+      };
+    } else {
+      response.deliveryTargeting = {
+        signals: {},
+        ad_play_confirm_url: generateAdPlayConfirmUrl(req, deal.deal_id, lineItem.external_id || lineItem.id, inventory.id)
+      };
+    }
+  }
+
+  if (deal.mode === 'PROGRAMMATIC') {
+    const baseUrl = `${req.protocol}://${req.get('host')}`;
+    response.programmatic = {
+      dealVastUri: `${baseUrl}/api/v2/rest/ds/vast/${deal.deal_id}`,
+      vastUri: `${baseUrl}/api/v2/rest/ds/vast/${deal.deal_id}/${lineItem.external_id || lineItem.id}`,
+      jsonUri: `${baseUrl}/api/v2/rest/ds/json/${deal.deal_id}/${lineItem.external_id || lineItem.id}`
+    };
+  }
+
+  return response;
+};
+
+router.get('/deals/:identifier', async (req, res, next) => {
+  try {
+    const { identifier } = req.params;
+
+    const inventories = await LineItemInventory.findAll({
+      where: {
+        [Op.or]: [
+          { id: identifier },
+          { device_id: identifier },
+          { reference_id: identifier }
+        ]
+      }
+    });
+
+    if (inventories.length === 0) {
+      return res.status(404).json({
+        requestId: req.requestId,
+        status: 404,
+        error: 'No inventory or device found with the provided identifier'
+      });
+    }
+
+    const lineItemIds = [...new Set(inventories.map(inv => inv.line_item_id))];
+    const dealIds = [...new Set(inventories.map(inv => inv.deal_id))];
+
+    const lineItems = await LineItem.findAll({
+      where: {
+        external_id: { [Op.in]: lineItemIds },
+        status: { [Op.in]: ACTIVE_LINE_ITEM_STATUSES },
+        is_playing: true
+      }
+    });
+
+    if (lineItems.length === 0) {
+      return res.json({
+        requestId: req.requestId,
+        status: 200,
+        result: []
+      });
+    }
+
+    const activeLineItemIds = lineItems.map(li => li.external_id);
+
+    const deals = await Deal.findAll({
+      where: {
+        deal_id: { [Op.in]: dealIds },
+        status: { [Op.in]: ACTIVE_DEAL_STATUSES },
+        is_playing: true
+      }
+    });
+
+    if (deals.length === 0) {
+      return res.json({
+        requestId: req.requestId,
+        status: 200,
+        result: []
+      });
+    }
+
+    const activeDealIds = deals.map(d => d.deal_id);
+    const dealMap = new Map(deals.map(d => [d.deal_id, d]));
+    const lineItemMap = new Map(lineItems.map(li => [li.external_id, li]));
+
+    const creatives = await LineItemCreative.findAll({
+      where: {
+        line_item_id: { [Op.in]: activeLineItemIds },
+        deal_id: { [Op.in]: activeDealIds },
+        status: 'APPROVED'
+      }
+    });
+
+    const creativesByLineItem = new Map();
+    for (const creative of creatives) {
+      const key = creative.line_item_id;
+      if (!creativesByLineItem.has(key)) {
+        creativesByLineItem.set(key, []);
+      }
+      creativesByLineItem.get(key).push(creative);
+    }
+
+    const results = [];
+
+    for (const inventory of inventories) {
+      const lineItem = lineItemMap.get(inventory.line_item_id);
+      if (!lineItem) continue;
+
+      const deal = dealMap.get(inventory.deal_id);
+      if (!deal) continue;
+
+      const lineItemCreatives = creativesByLineItem.get(inventory.line_item_id) || [];
+
+      const matchedCreatives = lineItemCreatives.filter(c => {
+        if (!c.inventory_ids || c.inventory_ids.length === 0) return true;
+        return c.inventory_ids.includes(inventory.id);
+      });
+
+      if (matchedCreatives.length === 0 && deal.mode === 'DIRECT') {
+        continue;
+      }
+
+      results.push(formatDealForSignage(deal, lineItem, inventory, matchedCreatives, req));
+    }
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: results
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post('/confirm/:dealId/:lineItemId/:inventoryId', async (req, res, next) => {
+  try {
+    const { dealId, lineItemId, inventoryId } = req.params;
+
+    const inventory = await LineItemInventory.findOne({
+      where: {
+        id: inventoryId,
+        line_item_id: lineItemId,
+        deal_id: dealId
+      }
+    });
+
+    if (!inventory) {
+      return res.status(404).json({
+        requestId: req.requestId,
+        status: 404,
+        error: 'Invalid confirmation parameters'
+      });
+    }
+
+    res.status(204).send();
+  } catch (error) {
+    next(error);
+  }
+});
+
+export default router;

package/PCM/src/routes/insertionOrders.js

@@ -0,0 +1,380 @@
+import express from 'express';
+import { Op } from 'sequelize';
+import PublisherInsertionOrder from '../models/PublisherInsertionOrder.js';
+import Deal from '../models/Deal.js';
+import { toCamelCase, toSnakeCase } from '../utils/caseConverter.js';
+import Joi from 'joi';
+
+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 insertionOrderSchema = Joi.object({
+  publisherId: Joi.string().required(),
+  publisherName: Joi.string().optional(),
+  ioNumber: Joi.string().optional(),
+  status: Joi.string().valid('DRAFT', 'PENDING', 'APPROVED', 'LIVE', 'COMPLETED', 'ARCHIVED').optional(),
+  budgetAmount: Joi.number().optional(),
+  currency: Joi.string().optional(),
+  startDate: Joi.date().optional(),
+  endDate: Joi.date().optional(),
+  summary: Joi.object().optional(),
+  externalSyncReference: Joi.object().optional(),
+  metadata: Joi.object().optional()
+});
+
+const publishIOSchema = Joi.object({
+  publisherId: Joi.string().required()
+});
+
+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'
+      });
+    }
+
+    if (deal.mode !== 'DIRECT') {
+      return res.status(400).json({
+        code: 'INVALID_MODE',
+        message: 'Insertion orders are only available for DIRECT mode deals'
+      });
+    }
+
+    const where = { deal_id: deal.deal_id };
+
+    if (req.query.publisherId) {
+      where.publisher_id = req.query.publisherId;
+    }
+
+    if (req.query.status) {
+      where.status = req.query.status.toUpperCase();
+    }
+
+    if (req.query.published !== undefined) {
+      where.published = req.query.published === 'true';
+    }
+
+    if (req.query.search) {
+      const searchTerm = `%${req.query.search}%`;
+      where[Op.or] = [
+        { io_number: { [Op.iLike]: searchTerm } },
+        { publisher_name: { [Op.iLike]: searchTerm } },
+        { publisher_id: { [Op.iLike]: searchTerm } }
+      ];
+    }
+
+    const { count, rows } = await PublisherInsertionOrder.findAndCountAll({
+      where,
+      limit,
+      offset,
+      order: [['created_at', 'DESC']]
+    });
+
+    const insertionOrders = rows.map(io => toCamelCase(io.toJSON()));
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        data: insertionOrders,
+        pagination: {
+          page,
+          limit,
+          total: count,
+          totalPages: Math.ceil(count / limit)
+        },
+        campaignBudget: {
+          budgetAmount: deal.budget_setup?.budgetAmount,
+          currency: deal.budget_setup?.currency || deal.currency
+        }
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.get('/:ioId', async (req, res, next) => {
+  try {
+    const { dealId, ioId } = req.params;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    let io = await PublisherInsertionOrder.findOne({
+      where: { id: ioId, deal_id: deal.deal_id }
+    });
+
+    if (!io) {
+      io = await PublisherInsertionOrder.findOne({
+        where: { publisher_id: ioId, deal_id: deal.deal_id }
+      });
+    }
+
+    if (!io) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Insertion order not found'
+      });
+    }
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        ...toCamelCase(io.toJSON()),
+        campaignBudget: {
+          budgetAmount: deal.budget_setup?.budgetAmount,
+          currency: deal.budget_setup?.currency || deal.currency
+        }
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post('/', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    if (deal.mode !== 'DIRECT') {
+      return res.status(400).json({
+        code: 'INVALID_MODE',
+        message: 'Insertion orders are only available for DIRECT mode deals'
+      });
+    }
+
+    const { error, value } = insertionOrderSchema.validate(req.body);
+    if (error) {
+      error.name = 'ValidationError';
+      return next(error);
+    }
+
+    const existing = await PublisherInsertionOrder.findOne({
+      where: { deal_id: deal.deal_id, publisher_id: value.publisherId }
+    });
+
+    if (existing) {
+      return res.status(409).json({
+        code: 'CONFLICT',
+        message: 'Insertion order for this publisher already exists'
+      });
+    }
+
+    const ioData = toSnakeCase(value);
+    ioData.deal_id = deal.deal_id;
+
+    if (!ioData.currency && deal.budget_setup?.currency) {
+      ioData.currency = deal.budget_setup.currency;
+    } else if (!ioData.currency) {
+      ioData.currency = deal.currency;
+    }
+
+    if (!ioData.start_date && deal.start_date) {
+      ioData.start_date = deal.start_date;
+    }
+    if (!ioData.end_date && deal.end_date) {
+      ioData.end_date = deal.end_date;
+    }
+
+    const io = await PublisherInsertionOrder.create(ioData);
+
+    res.status(201).json({
+      requestId: req.requestId,
+      status: 201,
+      result: toCamelCase(io.toJSON())
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.put('/:ioId', async (req, res, next) => {
+  try {
+    const { dealId, ioId } = req.params;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    let io = await PublisherInsertionOrder.findOne({
+      where: { id: ioId, deal_id: deal.deal_id }
+    });
+
+    if (!io) {
+      io = await PublisherInsertionOrder.findOne({
+        where: { publisher_id: ioId, deal_id: deal.deal_id }
+      });
+    }
+
+    if (!io) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Insertion order not found'
+      });
+    }
+
+    const updateData = toSnakeCase(req.body);
+    delete updateData.id;
+    delete updateData.deal_id;
+    delete updateData.publisher_id;
+
+    updateData.version = (io.version || 1) + 1;
+
+    await io.update(updateData);
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: toCamelCase(io.toJSON())
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+router.post('/publish', async (req, res, next) => {
+  try {
+    const { dealId } = req.params;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    if (deal.mode !== 'DIRECT') {
+      return res.status(400).json({
+        code: 'INVALID_MODE',
+        message: 'Insertion orders are only available for DIRECT mode deals'
+      });
+    }
+
+    const { error, value } = publishIOSchema.validate(req.body);
+    if (error) {
+      error.name = 'ValidationError';
+      return next(error);
+    }
+
+    const io = await PublisherInsertionOrder.findOne({
+      where: { deal_id: deal.deal_id, publisher_id: value.publisherId }
+    });
+
+    if (!io) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Insertion order for this publisher not found'
+      });
+    }
+
+    await io.update({
+      published: true,
+      published_at: new Date(),
+      status: 'LIVE'
+    });
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      result: {
+        ...toCamelCase(io.toJSON()),
+        message: 'Insertion order published successfully'
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+router.delete('/:ioId', async (req, res, next) => {
+  try {
+    const { dealId, ioId } = req.params;
+
+    const deal = await findDealByIdentifier(dealId);
+    if (!deal) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Deal not found'
+      });
+    }
+
+    let io = null;
+    
+    if (UUID_REGEX.test(ioId)) {
+      io = await PublisherInsertionOrder.findOne({
+        where: { id: ioId, deal_id: deal.deal_id }
+      });
+    }
+
+    if (!io) {
+      io = await PublisherInsertionOrder.findOne({
+        where: { publisher_id: ioId, deal_id: deal.deal_id }
+      });
+    }
+
+    if (!io) {
+      return res.status(404).json({
+        code: 'NOT_FOUND',
+        message: 'Insertion order not found'
+      });
+    }
+
+    if (io.published) {
+      return res.status(400).json({
+        code: 'CANNOT_DELETE',
+        message: 'Cannot delete published insertion order'
+      });
+    }
+
+    await io.destroy();
+
+    res.json({
+      requestId: req.requestId,
+      status: 200,
+      message: 'Insertion order deleted successfully'
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+export default router;