adserver-dashboard 1.0.0

package/Influence-MW-AdServer-12-02-2026/server/routes.ts

@@ -0,0 +1,1890 @@
+import type { Express } from "express";
+import { createServer, type Server } from "http";
+import archiver from "archiver";
+import { storage } from "./storage";
+import {
+  insertAdvertiserSchema,
+  insertAgencySchema,
+  insertBrandSchema,
+  insertMediaOwnerSchema,
+  insertVenueSchema,
+  insertScreenSchema,
+  insertDealSchema,
+  insertLineItemSchema,
+  insertSspPartnerSchema,
+  insertDspPartnerSchema,
+  insertCreativeSchema,
+  insertCreativeFolderSchema,
+  insertLineItemCreativeSchema,
+  insertSignalSchema,
+  insertSignalRuleSchema,
+  insertProofOfPlaySchema,
+  insertPlaylogUploadSchema,
+  insertGeoTargetingRuleSchema,
+} from "@shared/schema";
+import { z } from "zod";
+
+function validateBody<T>(schema: z.ZodSchema<T>, body: unknown): { success: true; data: T } | { success: false; error: string } {
+  const result = schema.safeParse(body);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ') };
+}
+
+export async function registerRoutes(
+  httpServer: Server,
+  app: Express
+): Promise<Server> {
+  // Dashboard
+  app.get("/api/dashboard/metrics", async (req, res) => {
+    const metrics = await storage.getDashboardMetrics();
+    res.json(metrics);
+  });
+
+  // Advertisers
+  app.get("/api/advertisers", async (req, res) => {
+    const advertisers = await storage.getAdvertisers();
+    res.json(advertisers);
+  });
+
+  app.get("/api/advertisers/:id", async (req, res) => {
+    const advertiser = await storage.getAdvertiser(req.params.id);
+    if (!advertiser) {
+      return res.status(404).json({ error: "Advertiser not found" });
+    }
+    res.json(advertiser);
+  });
+
+  app.post("/api/advertisers", async (req, res) => {
+    const validation = validateBody(insertAdvertiserSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const advertiser = await storage.createAdvertiser(validation.data);
+    res.status(201).json(advertiser);
+  });
+
+  app.patch("/api/advertisers/:id", async (req, res) => {
+    const validation = validateBody(insertAdvertiserSchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const advertiser = await storage.updateAdvertiser(req.params.id, validation.data);
+    if (!advertiser) {
+      return res.status(404).json({ error: "Advertiser not found" });
+    }
+    res.json(advertiser);
+  });
+
+  app.delete("/api/advertisers/:id", async (req, res) => {
+    const deleted = await storage.deleteAdvertiser(req.params.id);
+    if (!deleted) {
+      return res.status(404).json({ error: "Advertiser not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Agencies
+  app.get("/api/agencies", async (req, res) => {
+    const agencies = await storage.getAgencies();
+    res.json(agencies);
+  });
+
+  app.get("/api/agencies/:id", async (req, res) => {
+    const agency = await storage.getAgency(req.params.id);
+    if (!agency) {
+      return res.status(404).json({ error: "Agency not found" });
+    }
+    res.json(agency);
+  });
+
+  app.post("/api/agencies", async (req, res) => {
+    const validation = validateBody(insertAgencySchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const agency = await storage.createAgency(validation.data);
+    res.status(201).json(agency);
+  });
+
+  app.patch("/api/agencies/:id", async (req, res) => {
+    const validation = validateBody(insertAgencySchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const agency = await storage.updateAgency(req.params.id, validation.data);
+    if (!agency) {
+      return res.status(404).json({ error: "Agency not found" });
+    }
+    res.json(agency);
+  });
+
+  app.delete("/api/agencies/:id", async (req, res) => {
+    const deleted = await storage.deleteAgency(req.params.id);
+    if (!deleted) {
+      return res.status(404).json({ error: "Agency not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Brands
+  app.get("/api/brands", async (req, res) => {
+    const brands = await storage.getBrands();
+    res.json(brands);
+  });
+
+  app.get("/api/brands/:id", async (req, res) => {
+    const brand = await storage.getBrand(req.params.id);
+    if (!brand) {
+      return res.status(404).json({ error: "Brand not found" });
+    }
+    res.json(brand);
+  });
+
+  app.post("/api/brands", async (req, res) => {
+    const validation = validateBody(insertBrandSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const brand = await storage.createBrand(validation.data);
+    res.status(201).json(brand);
+  });
+
+  app.patch("/api/brands/:id", async (req, res) => {
+    const validation = validateBody(insertBrandSchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const brand = await storage.updateBrand(req.params.id, validation.data);
+    if (!brand) {
+      return res.status(404).json({ error: "Brand not found" });
+    }
+    res.json(brand);
+  });
+
+  app.delete("/api/brands/:id", async (req, res) => {
+    const deleted = await storage.deleteBrand(req.params.id);
+    if (!deleted) {
+      return res.status(404).json({ error: "Brand not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Media Owners
+  app.get("/api/media-owners", async (req, res) => {
+    const mediaOwners = await storage.getMediaOwners();
+    res.json(mediaOwners);
+  });
+
+  app.get("/api/media-owners/:id", async (req, res) => {
+    const mediaOwner = await storage.getMediaOwner(req.params.id);
+    if (!mediaOwner) {
+      return res.status(404).json({ error: "Media owner not found" });
+    }
+    res.json(mediaOwner);
+  });
+
+  app.post("/api/media-owners", async (req, res) => {
+    const validation = validateBody(insertMediaOwnerSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const mediaOwner = await storage.createMediaOwner(validation.data);
+    res.status(201).json(mediaOwner);
+  });
+
+  app.patch("/api/media-owners/:id", async (req, res) => {
+    const validation = validateBody(insertMediaOwnerSchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const mediaOwner = await storage.updateMediaOwner(req.params.id, validation.data);
+    if (!mediaOwner) {
+      return res.status(404).json({ error: "Media owner not found" });
+    }
+    res.json(mediaOwner);
+  });
+
+  app.delete("/api/media-owners/:id", async (req, res) => {
+    const deleted = await storage.deleteMediaOwner(req.params.id);
+    if (!deleted) {
+      return res.status(404).json({ error: "Media owner not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Venues
+  app.get("/api/venues", async (req, res) => {
+    const venues = await storage.getVenues();
+    res.json(venues);
+  });
+
+  app.get("/api/venues/:id", async (req, res) => {
+    const venue = await storage.getVenue(req.params.id);
+    if (!venue) {
+      return res.status(404).json({ error: "Venue not found" });
+    }
+    res.json(venue);
+  });
+
+  app.post("/api/venues", async (req, res) => {
+    const validation = validateBody(insertVenueSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const venue = await storage.createVenue(validation.data);
+    res.status(201).json(venue);
+  });
+
+  app.patch("/api/venues/:id", async (req, res) => {
+    const validation = validateBody(insertVenueSchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const venue = await storage.updateVenue(req.params.id, validation.data);
+    if (!venue) {
+      return res.status(404).json({ error: "Venue not found" });
+    }
+    res.json(venue);
+  });
+
+  app.delete("/api/venues/:id", async (req, res) => {
+    const deleted = await storage.deleteVenue(req.params.id);
+    if (!deleted) {
+      return res.status(404).json({ error: "Venue not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Screens
+  app.get("/api/screens", async (req, res) => {
+    const { country, sspId, mediaOwnerId } = req.query;
+    let screens = await storage.getScreens();
+    
+    // Apply filters if provided
+    if (country) {
+      const countries = (country as string).split(',').map(c => c.trim());
+      screens = screens.filter(s => s.country && countries.includes(s.country));
+    }
+    if (sspId) {
+      screens = screens.filter(s => s.sspId === sspId);
+    }
+    if (mediaOwnerId) {
+      screens = screens.filter(s => s.mediaOwnerId === mediaOwnerId);
+    }
+    
+    res.json(screens);
+  });
+
+  app.get("/api/screens/:id", async (req, res) => {
+    const screen = await storage.getScreen(req.params.id);
+    if (!screen) {
+      return res.status(404).json({ error: "Screen not found" });
+    }
+    res.json(screen);
+  });
+
+  app.post("/api/screens", async (req, res) => {
+    const validation = validateBody(insertScreenSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    if (validation.data.venueId) {
+      const venue = await storage.getVenue(validation.data.venueId);
+      if (!venue) {
+        return res.status(400).json({ error: "Referenced venue does not exist" });
+      }
+    }
+    const screen = await storage.createScreen(validation.data);
+    res.status(201).json(screen);
+  });
+
+  app.patch("/api/screens/:id", async (req, res) => {
+    const validation = validateBody(insertScreenSchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    if (validation.data.venueId) {
+      const venue = await storage.getVenue(validation.data.venueId);
+      if (!venue) {
+        return res.status(400).json({ error: "Referenced venue does not exist" });
+      }
+    }
+    const screen = await storage.updateScreen(req.params.id, validation.data);
+    if (!screen) {
+      return res.status(404).json({ error: "Screen not found" });
+    }
+    res.json(screen);
+  });
+
+  app.delete("/api/screens/:id", async (req, res) => {
+    const deleted = await storage.deleteScreen(req.params.id);
+    if (!deleted) {
+      return res.status(404).json({ error: "Screen not found" });
+    }
+    res.status(204).send();
+  });
+
+  app.post("/api/screens/:id/sync-playlogs", async (req, res) => {
+    const screen = await storage.getScreen(req.params.id);
+    if (!screen) {
+      return res.status(404).json({ error: "Screen not found" });
+    }
+    const playerStatuses = await storage.getPlayerStatuses([req.params.id]);
+    const playerStatus = playerStatuses[0];
+    if (!playerStatus || playerStatus.status !== "online") {
+      return res.status(400).json({ error: "Player is not online. Cannot sync playlogs." });
+    }
+    const now = new Date();
+    const syncedRecords = [];
+    for (let i = 0; i < 3; i++) {
+      const startTime = new Date(now.getTime() - (i + 1) * 60 * 1000);
+      const endTime = new Date(startTime.getTime() + 15000);
+      const record = await storage.createProofOfPlayRecord({
+        screenId: screen.id,
+        playerId: playerStatus.playerId,
+        creativeId: null,
+        dealId: null,
+        lineItemId: null,
+        startTimestamp: startTime.toISOString(),
+        endTimestamp: endTime.toISOString(),
+        durationSeconds: 15,
+        impressionCount: 1,
+        mediaFileUrl: null,
+        proofImageUrl: null,
+        proofVideoUrl: null,
+        source: "cms",
+        status: "processed",
+      });
+      syncedRecords.push(record);
+    }
+    res.json({ success: true, message: `Synced ${syncedRecords.length} playlog records from CMS.`, records: syncedRecords });
+  });
+
+  // Player Statuses
+  app.get("/api/player-statuses", async (req, res) => {
+    const { screenIds } = req.query;
+    const ids = screenIds ? (screenIds as string).split(",") : undefined;
+    const statuses = await storage.getPlayerStatuses(ids);
+    res.json(statuses);
+  });
+
+  // Deals
+  app.get("/api/deals", async (req, res) => {
+    const deals = await storage.getDeals();
+    res.json(deals);
+  });
+
+  app.get("/api/deals/:id", async (req, res) => {
+    const deal = await storage.getDeal(req.params.id);
+    if (!deal) {
+      return res.status(404).json({ error: "Deal not found" });
+    }
+    res.json(deal);
+  });
+
+  app.post("/api/deals", async (req, res) => {
+    const validation = validateBody(insertDealSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    if (validation.data.advertiserId) {
+      const advertiser = await storage.getAdvertiser(validation.data.advertiserId);
+      if (!advertiser) {
+        return res.status(400).json({ error: "Referenced advertiser does not exist" });
+      }
+    }
+    const now = new Date().toISOString();
+    const changedBy = req.body.createdBy || "System";
+    validation.data.createdBy = changedBy;
+    validation.data.createdAt = now;
+    const deal = await storage.createDeal(validation.data);
+    
+    await storage.createChangeLog({
+      entityType: "deal",
+      entityId: deal.id,
+      action: "created",
+      changedBy,
+      changedAt: now,
+      description: `Deal "${deal.name}" created`,
+    });
+    
+    res.status(201).json(deal);
+  });
+
+  app.patch("/api/deals/:id", async (req, res) => {
+    const validation = validateBody(insertDealSchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    if (validation.data.advertiserId) {
+      const advertiser = await storage.getAdvertiser(validation.data.advertiserId);
+      if (!advertiser) {
+        return res.status(400).json({ error: "Referenced advertiser does not exist" });
+      }
+    }
+    
+    const existing = await storage.getDeal(req.params.id);
+    if (!existing) {
+      return res.status(404).json({ error: "Deal not found" });
+    }
+    
+    const changes: Record<string, { old: unknown; new: unknown }> = {};
+    for (const [key, value] of Object.entries(validation.data)) {
+      if (key !== "updatedAt" && (existing as any)[key] !== value) {
+        changes[key] = { old: (existing as any)[key], new: value };
+      }
+    }
+    
+    validation.data.updatedAt = new Date().toISOString();
+    const deal = await storage.updateDeal(req.params.id, validation.data);
+    
+    const changedBy = req.body.changedBy || "System";
+    if (Object.keys(changes).length > 0) {
+      await storage.createChangeLog({
+        entityType: "deal",
+        entityId: req.params.id,
+        action: "updated",
+        changedBy,
+        changedAt: validation.data.updatedAt,
+        changes,
+        description: `Deal "${deal?.name}" updated`,
+      });
+    }
+    
+    res.json(deal);
+  });
+
+  app.delete("/api/deals/:id", async (req, res) => {
+    const deleted = await storage.deleteDeal(req.params.id);
+    if (!deleted) {
+      return res.status(404).json({ error: "Deal not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Duplicate deal
+  app.post("/api/deals/:id/duplicate", async (req, res) => {
+    const deal = await storage.getDeal(req.params.id);
+    if (!deal) {
+      return res.status(404).json({ error: "Deal not found" });
+    }
+    
+    const now = new Date().toISOString();
+    const { id, createdAt, updatedAt, ...dealData } = deal;
+    const duplicated = await storage.createDeal({
+      ...dealData,
+      name: `${deal.name} (Copy)`,
+      status: "paused",
+    });
+    
+    res.status(201).json(duplicated);
+  });
+
+  // Line Items (now directly under Deals - 4-level hierarchy)
+  app.get("/api/line-items", async (req, res) => {
+    const items = await storage.getLineItems();
+    res.json(items);
+  });
+
+  app.get("/api/line-items/:id", async (req, res) => {
+    const item = await storage.getLineItem(req.params.id);
+    if (!item) {
+      return res.status(404).json({ error: "Line item not found" });
+    }
+    res.json(item);
+  });
+
+  app.post("/api/line-items", async (req, res) => {
+    const validation = validateBody(insertLineItemSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    if (validation.data.dealId) {
+      const deal = await storage.getDeal(validation.data.dealId);
+      if (!deal) {
+        return res.status(400).json({ error: "Referenced deal does not exist" });
+      }
+    }
+    if (validation.data.trafficAllocation != null) {
+      if (validation.data.trafficAllocation < 0 || validation.data.trafficAllocation > 100) {
+        return res.status(400).json({ error: "Traffic allocation must be between 0 and 100" });
+      }
+    }
+    if (validation.data.priority != null) {
+      if (validation.data.priority < 1 || validation.data.priority > 10) {
+        return res.status(400).json({ error: "Priority must be between 1 and 10" });
+      }
+    }
+    const now = new Date().toISOString();
+    const changedBy = req.body.createdBy || "System";
+    validation.data.createdBy = changedBy;
+    validation.data.createdAt = now;
+    const item = await storage.createLineItem(validation.data);
+    
+    await storage.createChangeLog({
+      entityType: "line_item",
+      entityId: item.id,
+      action: "created",
+      changedBy,
+      changedAt: now,
+      description: `Line Item "${item.name}" created`,
+    });
+    
+    res.status(201).json(item);
+  });
+
+  app.patch("/api/line-items/:id", async (req, res) => {
+    const validation = validateBody(insertLineItemSchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    if (validation.data.dealId) {
+      const deal = await storage.getDeal(validation.data.dealId);
+      if (!deal) {
+        return res.status(400).json({ error: "Referenced deal does not exist" });
+      }
+    }
+    if (validation.data.trafficAllocation != null) {
+      if (validation.data.trafficAllocation < 0 || validation.data.trafficAllocation > 100) {
+        return res.status(400).json({ error: "Traffic allocation must be between 0 and 100" });
+      }
+    }
+    if (validation.data.priority != null) {
+      if (validation.data.priority < 1 || validation.data.priority > 10) {
+        return res.status(400).json({ error: "Priority must be between 1 and 10" });
+      }
+    }
+
+    const existing = await storage.getLineItem(req.params.id);
+    if (!existing) {
+      return res.status(404).json({ error: "Line item not found" });
+    }
+
+    const changes: Record<string, { old: unknown; new: unknown }> = {};
+    for (const [key, value] of Object.entries(validation.data)) {
+      if (key !== "updatedAt" && (existing as any)[key] !== value) {
+        changes[key] = { old: (existing as any)[key], new: value };
+      }
+    }
+
+    validation.data.updatedAt = new Date().toISOString();
+    const item = await storage.updateLineItem(req.params.id, validation.data);
+
+    const changedBy = req.body.changedBy || "System";
+    if (Object.keys(changes).length > 0) {
+      await storage.createChangeLog({
+        entityType: "line_item",
+        entityId: req.params.id,
+        action: "updated",
+        changedBy,
+        changedAt: validation.data.updatedAt,
+        changes,
+        description: `Line Item "${item?.name}" updated`,
+      });
+    }
+
+    res.json(item);
+  });
+
+  app.delete("/api/line-items/:id", async (req, res) => {
+    const deleted = await storage.deleteLineItem(req.params.id);
+    if (!deleted) {
+      return res.status(404).json({ error: "Line item not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Duplicate line item
+  app.post("/api/line-items/:id/duplicate", async (req, res) => {
+    const item = await storage.getLineItem(req.params.id);
+    if (!item) {
+      return res.status(404).json({ error: "Line item not found" });
+    }
+    
+    const duplicated = await storage.createLineItem({
+      name: `${item.name} (Copy)`,
+      dealId: item.dealId,
+      mediaOwnerId: item.mediaOwnerId,
+      status: "paused",
+      startDate: item.startDate,
+      endDate: item.endDate,
+      budget: item.budget,
+      cpm: item.cpm,
+      priority: item.priority,
+      trafficAllocation: item.trafficAllocation,
+      targetImpressions: item.targetImpressions,
+      deliveredImpressions: 0,
+      creativeType: item.creativeType,
+      creativeDuration: item.creativeDuration,
+      floorRateType: item.floorRateType,
+      floorRate: item.floorRate,
+      pushToDsp: item.pushToDsp,
+    });
+    
+    res.status(201).json(duplicated);
+  });
+
+  // SSP Partners
+  app.get("/api/ssp-partners", async (req, res) => {
+    const partners = await storage.getSspPartners();
+    res.json(partners);
+  });
+
+  app.get("/api/ssp-partners/:id", async (req, res) => {
+    const partner = await storage.getSspPartner(req.params.id);
+    if (!partner) {
+      return res.status(404).json({ error: "SSP partner not found" });
+    }
+    res.json(partner);
+  });
+
+  app.post("/api/ssp-partners", async (req, res) => {
+    const validation = validateBody(insertSspPartnerSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const partner = await storage.createSspPartner(validation.data);
+    res.status(201).json(partner);
+  });
+
+  app.patch("/api/ssp-partners/:id", async (req, res) => {
+    const validation = validateBody(insertSspPartnerSchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const partner = await storage.updateSspPartner(req.params.id, validation.data);
+    if (!partner) {
+      return res.status(404).json({ error: "SSP partner not found" });
+    }
+    res.json(partner);
+  });
+
+  app.delete("/api/ssp-partners/:id", async (req, res) => {
+    const deleted = await storage.deleteSspPartner(req.params.id);
+    if (!deleted) {
+      return res.status(404).json({ error: "SSP partner not found" });
+    }
+    res.status(204).send();
+  });
+
+  // DSP Partners
+  app.get("/api/dsp-partners", async (req, res) => {
+    const partners = await storage.getDspPartners();
+    res.json(partners);
+  });
+
+  app.get("/api/dsp-partners/:id", async (req, res) => {
+    const partner = await storage.getDspPartner(req.params.id);
+    if (!partner) {
+      return res.status(404).json({ error: "DSP partner not found" });
+    }
+    res.json(partner);
+  });
+
+  app.post("/api/dsp-partners", async (req, res) => {
+    const validation = validateBody(insertDspPartnerSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const partner = await storage.createDspPartner(validation.data);
+    res.status(201).json(partner);
+  });
+
+  app.patch("/api/dsp-partners/:id", async (req, res) => {
+    const validation = validateBody(insertDspPartnerSchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const partner = await storage.updateDspPartner(req.params.id, validation.data);
+    if (!partner) {
+      return res.status(404).json({ error: "DSP partner not found" });
+    }
+    res.json(partner);
+  });
+
+  app.delete("/api/dsp-partners/:id", async (req, res) => {
+    const deleted = await storage.deleteDspPartner(req.params.id);
+    if (!deleted) {
+      return res.status(404).json({ error: "DSP partner not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Traffic Allocation Endpoints
+  app.get("/api/deals/:id/traffic-summary", async (req, res) => {
+    const deal = await storage.getDeal(req.params.id);
+    if (!deal) {
+      return res.status(404).json({ error: "Deal not found" });
+    }
+    const summary = await storage.getDealTrafficSummary(req.params.id);
+    res.json(summary);
+  });
+
+  // Get line items for a deal (4-level hierarchy)
+  app.get("/api/deals/:id/line-items", async (req, res) => {
+    const deal = await storage.getDeal(req.params.id);
+    if (!deal) {
+      return res.status(404).json({ error: "Deal not found" });
+    }
+    const lineItems = await storage.getLineItemsByDeal(req.params.id);
+    res.json(lineItems);
+  });
+
+  // Request Acceptance - Push deal to DSP
+  app.post("/api/deals/:id/request-acceptance", async (req, res) => {
+    const deal = await storage.getDeal(req.params.id);
+    if (!deal) {
+      return res.status(404).json({ error: "Deal not found" });
+    }
+
+    // Validate deal is programmatic (not traditional)
+    if (deal.dealType === "traditional") {
+      return res.status(400).json({ error: "Request Acceptance is only available for programmatic deals" });
+    }
+
+    // Check that deal has at least one line item
+    const lineItems = await storage.getLineItemsByDeal(req.params.id);
+    if (lineItems.length === 0) {
+      return res.status(400).json({ error: "At least one line item is required to request acceptance" });
+    }
+
+    // In production, this would push to the DSP's API
+    // For now, we'll simulate the request by updating the deal
+    // source indicates it was pushed via Influence SSP
+    const updatedDeal = await storage.updateDeal(req.params.id, {
+      source: "influence_ssp",
+      externalDealId: `DEAL-${Date.now()}`, // Simulated deal ID from SSP
+    });
+
+    res.json({
+      success: true,
+      message: "Deal has been pushed to DSP for acceptance. Awaiting DSP response.",
+      deal: updatedDeal,
+      lineItemCount: lineItems.length,
+      dspId: deal.dspId || "dsp-activate-default",
+      dealId: updatedDeal?.externalDealId,
+      status: "pending_acceptance",
+    });
+  });
+
+  // Creative Folders
+  app.get("/api/creative-folders", async (req, res) => {
+    const folders = await storage.getCreativeFolders();
+    res.json(folders);
+  });
+
+  app.post("/api/creative-folders", async (req, res) => {
+    const validation = validateBody(insertCreativeFolderSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const folder = await storage.createCreativeFolder(validation.data);
+    res.status(201).json(folder);
+  });
+
+  app.delete("/api/creative-folders/:id", async (req, res) => {
+    const deleted = await storage.deleteCreativeFolder(req.params.id);
+    if (!deleted) {
+      return res.status(404).json({ error: "Creative folder not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Creatives
+  app.get("/api/creatives", async (req, res) => {
+    const { folderId, type, status, search } = req.query;
+    const filters: { folderId?: string; type?: string; status?: string; search?: string } = {};
+    
+    if (folderId) filters.folderId = folderId as string;
+    if (type) filters.type = type as string;
+    if (status) filters.status = status as string;
+    if (search) filters.search = search as string;
+    
+    const creatives = await storage.getCreatives(Object.keys(filters).length > 0 ? filters : undefined);
+    res.json(creatives);
+  });
+
+  // Get assignable creatives (only Tier 1 approved) - must come before :id route
+  app.get("/api/creatives/assignable", async (req, res) => {
+    const creatives = await storage.getAssignableCreatives();
+    res.json(creatives);
+  });
+
+  app.get("/api/creatives/:id", async (req, res) => {
+    const creative = await storage.getCreative(req.params.id);
+    if (!creative) {
+      return res.status(404).json({ error: "Creative not found" });
+    }
+    res.json(creative);
+  });
+
+  app.post("/api/creatives", async (req, res) => {
+    const validation = validateBody(insertCreativeSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    if (validation.data.folderId) {
+      const folder = await storage.getCreativeFolder(validation.data.folderId);
+      if (!folder) {
+        return res.status(400).json({ error: "Referenced folder does not exist" });
+      }
+    }
+    const creative = await storage.createCreative(validation.data);
+    res.status(201).json(creative);
+  });
+
+  app.patch("/api/creatives/:id", async (req, res) => {
+    const validation = validateBody(insertCreativeSchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    if (validation.data.folderId) {
+      const folder = await storage.getCreativeFolder(validation.data.folderId);
+      if (!folder) {
+        return res.status(400).json({ error: "Referenced folder does not exist" });
+      }
+    }
+    const creative = await storage.updateCreative(req.params.id, validation.data);
+    if (!creative) {
+      return res.status(404).json({ error: "Creative not found" });
+    }
+    res.json(creative);
+  });
+
+  app.delete("/api/creatives/:id", async (req, res) => {
+    const deleted = await storage.deleteCreative(req.params.id);
+    if (!deleted) {
+      return res.status(404).json({ error: "Creative not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Line Item Creative Assignments (Tier 2 approval workflow)
+  // Get all line item creative assignments
+  app.get("/api/line-item-creatives", async (req, res) => {
+    const assignments = await storage.getAllLineItemCreatives();
+    res.json(assignments);
+  });
+
+  // Get creatives assigned to a line item
+  app.get("/api/line-items/:id/creatives", async (req, res) => {
+    const lineItem = await storage.getLineItem(req.params.id);
+    if (!lineItem) {
+      return res.status(404).json({ error: "Line item not found" });
+    }
+    const assignments = await storage.getLineItemCreativeWithDetails(req.params.id);
+    res.json(assignments);
+  });
+
+  // Assign a creative to a line item
+  app.post("/api/line-items/:id/creatives", async (req, res) => {
+    const lineItem = await storage.getLineItem(req.params.id);
+    if (!lineItem) {
+      return res.status(404).json({ error: "Line item not found" });
+    }
+
+    const { creativeId, displayOrder, weight } = req.body;
+    if (!creativeId) {
+      return res.status(400).json({ error: "creativeId is required" });
+    }
+
+    // Validate creative exists and is accepted (Tier 1 approved)
+    const creative = await storage.getCreative(creativeId);
+    if (!creative) {
+      return res.status(400).json({ error: "Creative not found" });
+    }
+    if (creative.status !== "accepted") {
+      return res.status(400).json({ 
+        error: "Only Tier 1 approved (Accepted) creatives can be assigned to line items" 
+      });
+    }
+
+    // Check if already assigned
+    const existingAssignments = await storage.getLineItemCreatives(req.params.id);
+    const alreadyAssigned = existingAssignments.some(a => a.creativeId === creativeId);
+    if (alreadyAssigned) {
+      return res.status(400).json({ error: "Creative is already assigned to this line item" });
+    }
+
+    const assignment = await storage.assignCreativeToLineItem({
+      lineItemId: req.params.id,
+      creativeId,
+      tier2Status: "pending",
+      assignedAt: new Date().toISOString(),
+      displayOrder: displayOrder ?? existingAssignments.length,
+      weight: weight ?? 100,
+    });
+
+    res.status(201).json(assignment);
+  });
+
+  // Remove a creative from a line item
+  app.delete("/api/line-items/:lineItemId/creatives/:creativeId", async (req, res) => {
+    const removed = await storage.removeCreativeFromLineItem(
+      req.params.lineItemId, 
+      req.params.creativeId
+    );
+    if (!removed) {
+      return res.status(404).json({ error: "Creative assignment not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Get a single creative assignment by ID
+  app.get("/api/line-item-creatives/:id", async (req, res) => {
+    const assignment = await storage.getLineItemCreativeById(req.params.id);
+    if (!assignment) {
+      return res.status(404).json({ error: "Creative assignment not found" });
+    }
+    res.json(assignment);
+  });
+
+  // Update a creative assignment (Tier 2 approval)
+  app.patch("/api/line-item-creatives/:id", async (req, res) => {
+    const validation = validateBody(insertLineItemCreativeSchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+
+    // If approving/rejecting/requesting changes, add timestamp and default reviewer
+    if (validation.data.tier2Status === "approved" || validation.data.tier2Status === "rejected" || validation.data.tier2Status === "changes_requested") {
+      validation.data.tier2ReviewedAt = new Date().toISOString();
+      if (!validation.data.tier2ReviewedBy) {
+        validation.data.tier2ReviewedBy = "Media Owner";
+      }
+    }
+
+    const updated = await storage.updateLineItemCreative(req.params.id, validation.data);
+    if (!updated) {
+      return res.status(404).json({ error: "Creative assignment not found" });
+    }
+    res.json(updated);
+  });
+
+  // Tier 2 Approve a creative assignment
+  app.post("/api/line-item-creatives/:id/approve", async (req, res) => {
+    const { reviewedBy } = req.body;
+    const updated = await storage.updateLineItemCreative(req.params.id, {
+      tier2Status: "approved",
+      tier2ReviewedBy: reviewedBy ?? "Media Owner",
+      tier2ReviewedAt: new Date().toISOString(),
+    });
+    if (!updated) {
+      return res.status(404).json({ error: "Creative assignment not found" });
+    }
+    res.json(updated);
+  });
+
+  // Tier 2 Reject a creative assignment
+  app.post("/api/line-item-creatives/:id/reject", async (req, res) => {
+    const { reviewedBy, reason } = req.body;
+    if (!reason) {
+      return res.status(400).json({ error: "Rejection reason is required" });
+    }
+    const updated = await storage.updateLineItemCreative(req.params.id, {
+      tier2Status: "rejected",
+      tier2ReviewedBy: reviewedBy ?? "Media Owner",
+      tier2ReviewedAt: new Date().toISOString(),
+      tier2RejectionReason: reason,
+    });
+    if (!updated) {
+      return res.status(404).json({ error: "Creative assignment not found" });
+    }
+    res.json(updated);
+  });
+
+  // Change Logs (Audit Trail)
+  app.get("/api/change-logs", async (req, res) => {
+    const { entityType, entityId, limit } = req.query;
+    
+    if (entityType && entityId) {
+      const validTypes = ["deal", "order", "line_item", "creative"];
+      if (!validTypes.includes(entityType as string)) {
+        return res.status(400).json({ error: "Invalid entity type" });
+      }
+      const logs = await storage.getChangeLogs(entityType as any, entityId as string);
+      return res.json(logs);
+    }
+    
+    const logs = await storage.getRecentChangeLogs(limit ? parseInt(limit as string) : 50);
+    res.json(logs);
+  });
+
+  app.get("/api/change-logs/:entityType/:entityId", async (req, res) => {
+    const { entityType, entityId } = req.params;
+    const validTypes = ["deal", "order", "line_item", "creative"];
+    if (!validTypes.includes(entityType)) {
+      return res.status(400).json({ error: "Invalid entity type" });
+    }
+    const logs = await storage.getChangeLogs(entityType as any, entityId);
+    res.json(logs);
+  });
+
+  app.get("/api/change-logs/hierarchy/:entityType/:entityId", async (req, res) => {
+    const { entityType, entityId } = req.params;
+    const validTypes = ["deal", "order", "line_item", "creative"];
+    if (!validTypes.includes(entityType)) {
+      return res.status(400).json({ error: "Invalid entity type" });
+    }
+    const logs = await storage.getHierarchicalChangeLogs(entityType as any, entityId);
+    res.json(logs);
+  });
+
+  // Signals
+  app.get("/api/signals", async (req, res) => {
+    const signals = await storage.getSignals();
+    res.json(signals);
+  });
+
+  app.get("/api/signals/:id", async (req, res) => {
+    const signal = await storage.getSignal(req.params.id);
+    if (!signal) {
+      return res.status(404).json({ error: "Signal not found" });
+    }
+    res.json(signal);
+  });
+
+  app.post("/api/signals", async (req, res) => {
+    const validation = validateBody(insertSignalSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const now = new Date().toISOString();
+    validation.data.createdAt = now;
+    const signal = await storage.createSignal(validation.data);
+    res.status(201).json(signal);
+  });
+
+  app.patch("/api/signals/:id", async (req, res) => {
+    const validation = validateBody(insertSignalSchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const signal = await storage.updateSignal(req.params.id, validation.data);
+    if (!signal) {
+      return res.status(404).json({ error: "Signal not found" });
+    }
+    res.json(signal);
+  });
+
+  app.delete("/api/signals/:id", async (req, res) => {
+    const deleted = await storage.deleteSignal(req.params.id);
+    if (!deleted) {
+      return res.status(404).json({ error: "Signal not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Signal Rules
+  app.get("/api/signals/:id/rules", async (req, res) => {
+    const signal = await storage.getSignal(req.params.id);
+    if (!signal) {
+      return res.status(404).json({ error: "Signal not found" });
+    }
+    const rules = await storage.getSignalRules(req.params.id);
+    res.json(rules);
+  });
+
+  app.post("/api/signals/:id/rules", async (req, res) => {
+    const signal = await storage.getSignal(req.params.id);
+    if (!signal) {
+      return res.status(404).json({ error: "Signal not found" });
+    }
+    const validation = validateBody(insertSignalRuleSchema, { ...req.body, signalId: req.params.id });
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const rule = await storage.createSignalRule(validation.data);
+    res.status(201).json(rule);
+  });
+
+  app.patch("/api/signals/:id/rules/:ruleId", async (req, res) => {
+    const signal = await storage.getSignal(req.params.id);
+    if (!signal) {
+      return res.status(404).json({ error: "Signal not found" });
+    }
+    const existingRule = await storage.getSignalRule(req.params.ruleId);
+    if (!existingRule || existingRule.signalId !== req.params.id) {
+      return res.status(404).json({ error: "Signal rule not found" });
+    }
+    const validation = validateBody(insertSignalRuleSchema.partial(), req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const rule = await storage.updateSignalRule(req.params.ruleId, validation.data);
+    res.json(rule);
+  });
+
+  app.delete("/api/signals/:id/rules/:ruleId", async (req, res) => {
+    const signal = await storage.getSignal(req.params.id);
+    if (!signal) {
+      return res.status(404).json({ error: "Signal not found" });
+    }
+    const existingRule = await storage.getSignalRule(req.params.ruleId);
+    if (!existingRule || existingRule.signalId !== req.params.id) {
+      return res.status(404).json({ error: "Signal rule not found" });
+    }
+    const deleted = await storage.deleteSignalRule(req.params.ruleId);
+    if (!deleted) {
+      return res.status(404).json({ error: "Signal rule not found" });
+    }
+    res.status(204).send();
+  });
+
+  // POIs
+  app.get("/api/pois", async (req, res) => {
+    const { country } = req.query;
+    const pois = await storage.getPOIs(country as string | undefined);
+    res.json(pois);
+  });
+
+  app.get("/api/pois/:id", async (req, res) => {
+    const poi = await storage.getPOI(req.params.id);
+    if (!poi) {
+      return res.status(404).json({ error: "POI not found" });
+    }
+    res.json(poi);
+  });
+
+  // Player Status (read-only from CMS)
+  app.get("/api/player-status", async (req, res) => {
+    const { screenIds } = req.query;
+    const ids = screenIds ? (screenIds as string).split(",") : undefined;
+    const statuses = await storage.getPlayerStatuses(ids);
+    res.json(statuses);
+  });
+
+  app.get("/api/player-status/:screenId", async (req, res) => {
+    const status = await storage.getPlayerStatus(req.params.screenId);
+    if (!status) {
+      return res.status(404).json({ error: "Player status not found for this screen" });
+    }
+    res.json(status);
+  });
+
+  // Player status by line item (for Line Item Creatives page)
+  // In production, this would query Inventory Management to get screens assigned to this line item
+  // For the demo, we map line items to sample screens based on line item index
+  app.get("/api/line-items/:lineItemId/player-status", async (req, res) => {
+    const { lineItemId } = req.params;
+    const lineItem = await storage.getLineItem(lineItemId);
+    if (!lineItem) {
+      return res.status(404).json({ error: "Line item not found" });
+    }
+    
+    // Get all player statuses
+    const allStatuses = await storage.getPlayerStatuses();
+    
+    // For demo purposes, distribute screens across line items based on hash of line item ID
+    // In production, this would query the actual screen-to-line-item mappings from Inventory Management
+    const lineItemHash = lineItemId.split('').reduce((acc, char) => acc + char.charCodeAt(0), 0);
+    const statusCount = allStatuses.length;
+    
+    // Each line item gets a subset of screens (at least 2)
+    const startIndex = lineItemHash % statusCount;
+    const numScreens = Math.max(2, Math.min(statusCount, (lineItemHash % 4) + 2));
+    
+    const assignedStatuses = [];
+    for (let i = 0; i < numScreens; i++) {
+      assignedStatuses.push(allStatuses[(startIndex + i) % statusCount]);
+    }
+    
+    res.json(assignedStatuses);
+  });
+
+  // Proof of Play
+  app.get("/api/proof-of-play", async (req, res) => {
+    const { dealId, lineItemId, creativeId, mediaOwnerId, source, status, startDate, endDate } = req.query;
+    const records = await storage.getProofOfPlayRecords({
+      dealId: dealId as string | undefined,
+      lineItemId: lineItemId as string | undefined,
+      creativeId: creativeId as string | undefined,
+      mediaOwnerId: mediaOwnerId as string | undefined,
+      source: source as string | undefined,
+      status: status as string | undefined,
+      startDate: startDate as string | undefined,
+      endDate: endDate as string | undefined,
+    });
+    res.json(records);
+  });
+
+  app.get("/api/proof-of-play/:id", async (req, res) => {
+    const record = await storage.getProofOfPlayRecord(req.params.id);
+    if (!record) {
+      return res.status(404).json({ error: "Proof of play record not found" });
+    }
+    res.json(record);
+  });
+
+  app.post("/api/proof-of-play", async (req, res) => {
+    const validation = validateBody(insertProofOfPlaySchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    try {
+      const record = await storage.createProofOfPlayRecord(validation.data);
+      res.status(201).json(record);
+    } catch (error) {
+      res.status(400).json({ error: "Failed to create proof of play record" });
+    }
+  });
+
+  app.post("/api/proof-of-play/screenshot", async (req, res) => {
+    const { screenId, imageData } = req.body;
+    if (!screenId || !imageData) {
+      return res.status(400).json({ error: "screenId and imageData are required" });
+    }
+    if (typeof imageData !== "string" || !imageData.startsWith("data:image/")) {
+      return res.status(400).json({ error: "Invalid image data format" });
+    }
+    const maxSize = 5 * 1024 * 1024;
+    if (imageData.length > maxSize) {
+      return res.status(400).json({ error: "Image data too large (max 5MB)" });
+    }
+    const screen = await storage.getScreen(screenId);
+    if (!screen) {
+      return res.status(404).json({ error: "Screen not found" });
+    }
+    const now = new Date().toISOString();
+    const record = await storage.createProofOfPlayRecord({
+      screenId,
+      playerId: "webcam-capture",
+      creativeId: null,
+      dealId: null,
+      lineItemId: null,
+      startTimestamp: now,
+      endTimestamp: now,
+      durationSeconds: 0,
+      impressionCount: 1,
+      mediaFileUrl: null,
+      proofImageUrl: imageData,
+      proofVideoUrl: null,
+      source: "cms",
+      status: "processed",
+    });
+    res.status(201).json(record);
+  });
+
+  app.patch("/api/proof-of-play/:id", async (req, res) => {
+    const record = await storage.updateProofOfPlayRecord(req.params.id, req.body);
+    if (!record) {
+      return res.status(404).json({ error: "Proof of play record not found" });
+    }
+    res.json(record);
+  });
+
+  app.delete("/api/proof-of-play/:id", async (req, res) => {
+    const success = await storage.deleteProofOfPlayRecord(req.params.id);
+    if (!success) {
+      return res.status(404).json({ error: "Proof of play record not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Playlog Uploads
+  app.get("/api/playlogs", async (req, res) => {
+    const { dealId, lineItemId, mediaOwnerId, status } = req.query;
+    const uploads = await storage.getPlaylogUploads({
+      dealId: dealId as string | undefined,
+      lineItemId: lineItemId as string | undefined,
+      mediaOwnerId: mediaOwnerId as string | undefined,
+      status: status as string | undefined,
+    });
+    res.json(uploads);
+  });
+
+  // Playlog Template Download - must be before :id route
+  app.get("/api/playlogs/template", async (req, res) => {
+    const { dealId, lineItemId, dealName, lineItemName, format } = req.query;
+    
+    const dealIdValue = dealId ? String(dealId) : "[Enter Deal ID]";
+    const lineItemIdValue = lineItemId ? String(lineItemId) : "[Enter Line Item ID]";
+    const sampleNote = dealName ? `Sample for ${dealName}` : "Sample row - replace with your data";
+    
+    // Guidelines section as comments
+    const guidelines = `# PLAYLOG UPLOAD TEMPLATE
+# ========================
+# 
+# INSTRUCTIONS:
+# 1. Do NOT modify or delete the header row below
+# 2. The sample row shows the expected format - replace it with your data
+# 3. Duration and Impressions are calculated automatically by the Measure platform
+# 4. Date format: ISO 8601 with timezone (e.g. 2024-01-15T10:00:00Z)
+#
+# COLUMN DESCRIPTIONS:
+# - Deal ID: The Deal ID from Influence platform (required for mapping)
+# - Line Item ID: The Line Item ID from Influence platform (required for mapping)  
+# - Reference ID: Your inventory/screen reference ID
+# - Player ID: Player device ID (optional - leave blank if same as Reference ID)
+# - Creative ID: Creative ID from Influence or your internal reference
+# - Start Time: When the content started playing (ISO 8601 format)
+# - End Time: When the content finished playing (ISO 8601 format)
+# - Notes: Optional notes for this record
+#
+# TIPS:
+# - Select Deal and Line Item on the upload page to pre-fill IDs in this template
+# - You can upload Excel (.xlsx) files - they will be automatically converted
+# - Each row represents one play event
+#
+`;
+
+    const templateCSV = `${guidelines}Deal ID,Line Item ID,Reference ID,Player ID,Creative ID,Start Time,End Time,Notes
+${dealIdValue},${lineItemIdValue},INV-REF-001,,CREATIVE-001,2024-01-15T10:00:00Z,2024-01-15T10:00:15Z,${sampleNote}`;
+    
+    res.setHeader("Content-Type", "text/csv");
+    res.setHeader("Content-Disposition", "attachment; filename=playlog_template.csv");
+    res.send(templateCSV);
+  });
+
+  app.get("/api/playlogs/:id", async (req, res) => {
+    const upload = await storage.getPlaylogUpload(req.params.id);
+    if (!upload) {
+      return res.status(404).json({ error: "Playlog upload not found" });
+    }
+    res.json(upload);
+  });
+
+  app.post("/api/playlogs/upload", async (req, res) => {
+    const validation = validateBody(insertPlaylogUploadSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    try {
+      const upload = await storage.createPlaylogUpload(validation.data);
+      res.status(201).json(upload);
+    } catch (error) {
+      res.status(400).json({ error: "Failed to create playlog upload" });
+    }
+  });
+
+  app.patch("/api/playlogs/:id", async (req, res) => {
+    const upload = await storage.updatePlaylogUpload(req.params.id, req.body);
+    if (!upload) {
+      return res.status(404).json({ error: "Playlog upload not found" });
+    }
+    res.json(upload);
+  });
+
+  app.delete("/api/playlogs/:id", async (req, res) => {
+    const success = await storage.deletePlaylogUpload(req.params.id);
+    if (!success) {
+      return res.status(404).json({ error: "Playlog upload not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Geotargeting Rules
+  app.get("/api/geotargeting/:entityType/:entityId", async (req, res) => {
+    const { entityType, entityId } = req.params;
+    const rules = await storage.getGeoTargetingRules(entityType, entityId);
+    res.json(rules);
+  });
+
+  app.get("/api/geotargeting/rule/:id", async (req, res) => {
+    const rule = await storage.getGeoTargetingRule(req.params.id);
+    if (!rule) {
+      return res.status(404).json({ error: "Geotargeting rule not found" });
+    }
+    res.json(rule);
+  });
+
+  app.post("/api/geotargeting", async (req, res) => {
+    const validation = validateBody(insertGeoTargetingRuleSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    try {
+      const rule = await storage.createGeoTargetingRule(validation.data);
+      res.status(201).json(rule);
+    } catch (error) {
+      res.status(400).json({ error: "Failed to create geotargeting rule" });
+    }
+  });
+
+  app.patch("/api/geotargeting/:id", async (req, res) => {
+    const updateSchema = insertGeoTargetingRuleSchema.partial();
+    const validation = validateBody(updateSchema, req.body);
+    if (!validation.success) {
+      return res.status(400).json({ error: validation.error });
+    }
+    const rule = await storage.updateGeoTargetingRule(req.params.id, validation.data);
+    if (!rule) {
+      return res.status(404).json({ error: "Geotargeting rule not found" });
+    }
+    res.json(rule);
+  });
+
+  app.delete("/api/geotargeting/:id", async (req, res) => {
+    const success = await storage.deleteGeoTargetingRule(req.params.id);
+    if (!success) {
+      return res.status(404).json({ error: "Geotargeting rule not found" });
+    }
+    res.status(204).send();
+  });
+
+  // Transit Routes and Zones
+  app.get("/api/transit/routes", async (req, res) => {
+    const { city } = req.query;
+    const routes = await storage.getTransitRoutes(city as string | undefined);
+    res.json(routes);
+  });
+
+  app.get("/api/transit/routes/:id", async (req, res) => {
+    const route = await storage.getTransitRoute(req.params.id);
+    if (!route) {
+      return res.status(404).json({ error: "Transit route not found" });
+    }
+    res.json(route);
+  });
+
+  app.get("/api/transit/zones", async (req, res) => {
+    const { city } = req.query;
+    const zones = await storage.getTransitZones(city as string | undefined);
+    res.json(zones);
+  });
+
+  app.get("/api/transit/zones/:id", async (req, res) => {
+    const zone = await storage.getTransitZone(req.params.id);
+    if (!zone) {
+      return res.status(404).json({ error: "Transit zone not found" });
+    }
+    res.json(zone);
+  });
+
+  // POI Search with category filtering
+  app.get("/api/poi/search", async (req, res) => {
+    const { query, category, country, limit = "20" } = req.query;
+    let pois = await storage.getPOIs(country as string | undefined);
+    
+    if (query) {
+      const searchTerm = (query as string).toLowerCase();
+      pois = pois.filter(poi => 
+        poi.name.toLowerCase().includes(searchTerm) ||
+        (poi.address && poi.address.toLowerCase().includes(searchTerm)) ||
+        (poi.city && poi.city.toLowerCase().includes(searchTerm))
+      );
+    }
+    
+    if (category) {
+      const categories = (category as string).split(',').map(c => c.toLowerCase().trim());
+      pois = pois.filter(poi => 
+        poi.category && categories.some(cat => poi.category!.toLowerCase().includes(cat))
+      );
+    }
+    
+    res.json(pois.slice(0, parseInt(limit as string, 10)));
+  });
+
+  // Creative Specifications endpoint - returns keyed object for frontend consumption
+  app.get("/api/creative-specs", async (req, res) => {
+    const specs: Record<string, {
+      formats: string[];
+      maxFileSize: string;
+      maxFileSizeBytes: number;
+      dimensions: Array<{ width: number; height: number; label: string }>;
+      maxDuration?: number;
+      notes: string[];
+    }> = {
+      display: {
+        formats: ["JPG", "JPEG", "PNG", "GIF", "WEBP"],
+        maxFileSize: "5 MB",
+        maxFileSizeBytes: 5 * 1024 * 1024,
+        dimensions: [
+          { width: 1920, height: 1080, label: "Full HD (16:9)" },
+          { width: 1080, height: 1920, label: "Portrait Full HD (9:16)" },
+          { width: 3840, height: 2160, label: "4K UHD (16:9)" },
+          { width: 1280, height: 720, label: "HD (16:9)" },
+          { width: 1024, height: 768, label: "Standard (4:3)" },
+        ],
+        notes: ["RGB color mode", "72-300 DPI resolution"],
+      },
+      video: {
+        formats: ["MP4", "MOV", "WEBM", "AVI"],
+        maxFileSize: "100 MB",
+        maxFileSizeBytes: 100 * 1024 * 1024,
+        dimensions: [
+          { width: 1920, height: 1080, label: "Full HD (16:9)" },
+          { width: 1080, height: 1920, label: "Portrait Full HD (9:16)" },
+          { width: 3840, height: 2160, label: "4K UHD (16:9)" },
+        ],
+        maxDuration: 60,
+        notes: ["H.264 or H.265 codec", "AAC audio", "25-60 fps", "Duration: 5-60 seconds"],
+      },
+      html: {
+        formats: ["HTML", "ZIP"],
+        maxFileSize: "10 MB",
+        maxFileSizeBytes: 10 * 1024 * 1024,
+        dimensions: [
+          { width: 1920, height: 1080, label: "Full HD (16:9)" },
+          { width: 1080, height: 1920, label: "Portrait Full HD (9:16)" },
+        ],
+        notes: [
+          "Self-contained HTML5",
+          "No external dependencies",
+          "Must include index.html",
+          "Responsive design recommended",
+        ],
+      },
+      native: {
+        formats: ["JPG", "JPEG", "PNG"],
+        maxFileSize: "2 MB",
+        maxFileSizeBytes: 2 * 1024 * 1024,
+        dimensions: [
+          { width: 1200, height: 628, label: "Native (1.91:1)" },
+          { width: 1080, height: 1080, label: "Square (1:1)" },
+        ],
+        notes: ["Headline: max 50 characters", "Description: max 150 characters"],
+      },
+    };
+    res.json(specs);
+  });
+
+  // =====================================================
+  // RECOMMENDATION ENGINE ROUTES
+  // =====================================================
+
+  // Get inventory recommendations based on campaign parameters
+  app.post("/api/recommendations", async (req, res) => {
+    try {
+      const { recommendationRequestSchema } = await import("@shared/schema");
+      const validation = recommendationRequestSchema.safeParse(req.body);
+      if (!validation.success) {
+        return res.status(400).json({ 
+          error: validation.error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ') 
+        });
+      }
+
+      const { recommendationService } = await import("./recommendation-service");
+      const screens = await storage.getScreens();
+      const recommendations = await recommendationService.getRecommendations(validation.data, screens);
+      res.json(recommendations);
+    } catch (error: any) {
+      console.error("Error getting recommendations:", error);
+      res.status(500).json({ error: error.message || "Failed to get recommendations" });
+    }
+  });
+
+  // Auto-optimize a line item with AI-recommended inventory
+  app.post("/api/line-items/:id/auto-optimize", async (req, res) => {
+    try {
+      const { autoOptimizeRequestSchema } = await import("@shared/schema");
+      const validation = autoOptimizeRequestSchema.safeParse(req.body);
+      if (!validation.success) {
+        return res.status(400).json({ 
+          error: validation.error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ') 
+        });
+      }
+
+      const lineItem = await storage.getLineItem(req.params.id);
+      if (!lineItem) {
+        return res.status(404).json({ error: "Line item not found" });
+      }
+
+      const deal = await storage.getDeal(lineItem.dealId);
+      if (!deal) {
+        return res.status(404).json({ error: "Deal not found" });
+      }
+
+      const { recommendationService } = await import("./recommendation-service");
+      const screens = await storage.getScreens();
+
+      const optimizeRequest = {
+        lineItemId: req.params.id,
+        dealId: lineItem.dealId,
+        budget: validation.data.budget || (lineItem.budget ? parseFloat(lineItem.budget) : undefined),
+        goalType: validation.data.goalType || (deal as any).goalType,
+        goalValue: validation.data.goalValue || (deal as any).goalValue,
+        maxInventories: validation.data.maxInventories || 5,
+        preferredTypes: validation.data.preferredTypes,
+      };
+
+      const result = await recommendationService.autoOptimize(optimizeRequest, deal, screens);
+      
+      // Persist the recommended inventories to the line item
+      const existingScreens = (lineItem as any).selectedScreens || [];
+      const newScreenIds = result.selectedInventories.map(inv => inv.inventoryId);
+      const mergedScreenIds = [...new Set([...existingScreens, ...newScreenIds])];
+      
+      await storage.updateLineItem(req.params.id, {
+        selectedScreens: mergedScreenIds,
+      } as any);
+      
+      res.json(result);
+    } catch (error: any) {
+      console.error("Error auto-optimizing line item:", error);
+      res.status(500).json({ error: error.message || "Failed to auto-optimize" });
+    }
+  });
+
+  // Get recommendations for a specific deal
+  app.get("/api/deals/:id/recommendations", async (req, res) => {
+    try {
+      const deal = await storage.getDeal(req.params.id);
+      if (!deal) {
+        return res.status(404).json({ error: "Deal not found" });
+      }
+
+      const { recommendationService } = await import("./recommendation-service");
+      const screens = await storage.getScreens();
+
+      const request = {
+        country: (deal as any).countries?.[0] || "US",
+        startDate: deal.startDate,
+        endDate: deal.endDate,
+        budget: deal.budget ? parseFloat(deal.budget) : undefined,
+        goalType: (deal as any).goalType,
+        goalValue: (deal as any).goalValue,
+        limit: parseInt(req.query.limit as string) || 10,
+      };
+
+      const recommendations = await recommendationService.getRecommendations(request, screens);
+      res.json(recommendations);
+    } catch (error: any) {
+      console.error("Error getting deal recommendations:", error);
+      res.status(500).json({ error: error.message || "Failed to get recommendations" });
+    }
+  });
+
+  // ============================================================
+  // VAST Tag Distribution
+  // ============================================================
+
+  function generateVastUrl(dealId: string, lineItemId: string, host: string): string {
+    return `${host}/vast/v1/${dealId}/${lineItemId}?screen_id={screen_id}&player_id={player_id}`;
+  }
+
+  function generateVastHtml(dealName: string, lineItemName: string, vastUrl: string): string {
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>VAST Player - ${lineItemName}</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{background:#000;display:flex;align-items:center;justify-content:center;height:100vh;overflow:hidden}
+#player{width:100%;height:100%;position:relative}
+video{width:100%;height:100%;object-fit:contain}
+#fallback{color:#fff;text-align:center;font-family:Arial,sans-serif;position:absolute;top:50%;left:50%;transform:translate(-50%,-50%)}
+#status{position:fixed;bottom:10px;right:10px;color:#666;font-size:11px;font-family:monospace}
+</style>
+</head>
+<body>
+<div id="player">
+<video id="ad-video" autoplay muted playsinline></video>
+<div id="fallback" style="display:none">
+<p>Waiting for ad content...</p>
+</div>
+</div>
+<div id="status">VAST Player v1.0</div>
+<script>
+(function(){
+var VAST_URL="${vastUrl}";
+var POLL_INTERVAL=60000;
+var video=document.getElementById("ad-video");
+var fallback=document.getElementById("fallback");
+var status=document.getElementById("status");
+
+function log(msg){status.textContent=msg;console.log("[VAST]",msg)}
+
+function fetchVast(){
+log("Fetching VAST...");
+fetch(VAST_URL).then(function(r){return r.text()}).then(function(xml){
+var parser=new DOMParser();
+var doc=parser.parseFromString(xml,"text/xml");
+var mediaFiles=doc.querySelectorAll("MediaFile");
+if(mediaFiles.length>0){
+var mediaUrl=mediaFiles[0].textContent.trim();
+if(video.src!==mediaUrl){
+video.src=mediaUrl;
+video.play().catch(function(){});
+fallback.style.display="none";
+log("Playing: "+mediaUrl.split("/").pop());
+}
+}else{
+fallback.style.display="block";
+log("No media in VAST response");
+}
+}).catch(function(e){
+fallback.style.display="block";
+log("Error: "+e.message);
+});
+}
+
+video.addEventListener("ended",function(){fetchVast()});
+video.addEventListener("error",function(){
+fallback.style.display="block";
+log("Video error - retrying...");
+setTimeout(fetchVast,5000);
+});
+
+fetchVast();
+setInterval(fetchVast,POLL_INTERVAL);
+})();
+</script>
+</body>
+</html>`;
+  }
+
+  app.get("/api/deals/:id/distribution", async (req, res) => {
+    const deal = await storage.getDeal(req.params.id);
+    if (!deal) {
+      return res.status(404).json({ error: "Deal not found" });
+    }
+
+    if (!deal.acceptanceSent) {
+      return res.status(400).json({ error: "Distribution is only available after deal activation" });
+    }
+
+    const lineItems = await storage.getLineItemsByDeal(req.params.id);
+    const host = `${req.protocol}://${req.get("host")}`;
+
+    const distribution = lineItems.map((li) => ({
+      lineItemId: li.id,
+      lineItemName: li.name,
+      status: li.status,
+      creativeType: li.creativeType,
+      vastUrl: generateVastUrl(req.params.id, li.id, host),
+    }));
+
+    res.json({
+      dealId: req.params.id,
+      dealName: deal.name,
+      dealType: deal.dealType,
+      lineItems: distribution,
+    });
+  });
+
+  app.get("/api/deals/:dealId/line-items/:lineItemId/vast-tag/html", async (req, res) => {
+    const deal = await storage.getDeal(req.params.dealId);
+    if (!deal) {
+      return res.status(404).json({ error: "Deal not found" });
+    }
+
+    const lineItems = await storage.getLineItemsByDeal(req.params.dealId);
+    const lineItem = lineItems.find((li) => li.id === req.params.lineItemId);
+    if (!lineItem) {
+      return res.status(404).json({ error: "Line item not found" });
+    }
+
+    const host = `${req.protocol}://${req.get("host")}`;
+    const vastUrl = generateVastUrl(req.params.dealId, req.params.lineItemId, host);
+    const html = generateVastHtml(deal.name, lineItem.name, vastUrl);
+
+    const sanitizedName = lineItem.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+    res.setHeader("Content-Type", "text/html");
+    res.setHeader("Content-Disposition", `attachment; filename="vast-player-${sanitizedName}.html"`);
+    res.send(html);
+  });
+
+  app.get("/api/deals/:dealId/line-items/:lineItemId/vast-tag/zip", async (req, res) => {
+    const deal = await storage.getDeal(req.params.dealId);
+    if (!deal) {
+      return res.status(404).json({ error: "Deal not found" });
+    }
+
+    const lineItems = await storage.getLineItemsByDeal(req.params.dealId);
+    const lineItem = lineItems.find((li) => li.id === req.params.lineItemId);
+    if (!lineItem) {
+      return res.status(404).json({ error: "Line item not found" });
+    }
+
+    const host = `${req.protocol}://${req.get("host")}`;
+    const vastUrl = generateVastUrl(req.params.dealId, req.params.lineItemId, host);
+    const html = generateVastHtml(deal.name, lineItem.name, vastUrl);
+
+    const sanitizedName = lineItem.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+
+    res.setHeader("Content-Type", "application/zip");
+    res.setHeader("Content-Disposition", `attachment; filename="vast-player-${sanitizedName}.zip"`);
+
+    const archive = archiver("zip", { zlib: { level: 9 } });
+    archive.pipe(res);
+    archive.append(html, { name: `vast-player-${sanitizedName}/index.html` });
+    archive.append(
+      JSON.stringify({ name: lineItem.name, dealId: req.params.dealId, lineItemId: req.params.lineItemId, vastUrl }, null, 2),
+      { name: `vast-player-${sanitizedName}/config.json` }
+    );
+    archive.finalize();
+  });
+
+  app.get("/api/deals/:id/distribution/download-all", async (req, res) => {
+    const deal = await storage.getDeal(req.params.id);
+    if (!deal) {
+      return res.status(404).json({ error: "Deal not found" });
+    }
+
+    if (!deal.acceptanceSent) {
+      return res.status(400).json({ error: "Distribution is only available after deal activation" });
+    }
+
+    const lineItems = await storage.getLineItemsByDeal(req.params.id);
+    if (lineItems.length === 0) {
+      return res.status(400).json({ error: "No line items found for this deal" });
+    }
+
+    const host = `${req.protocol}://${req.get("host")}`;
+    const sanitizedDealName = deal.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+
+    res.setHeader("Content-Type", "application/zip");
+    res.setHeader("Content-Disposition", `attachment; filename="vast-players-${sanitizedDealName}.zip"`);
+
+    const archive = archiver("zip", { zlib: { level: 9 } });
+    archive.pipe(res);
+
+    lineItems.forEach((li) => {
+      const vastUrl = generateVastUrl(req.params.id, li.id, host);
+      const html = generateVastHtml(deal.name, li.name, vastUrl);
+      const sanitizedLiName = li.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+      archive.append(html, { name: `${sanitizedDealName}/${sanitizedLiName}/index.html` });
+      archive.append(
+        JSON.stringify({ name: li.name, dealId: req.params.id, lineItemId: li.id, vastUrl }, null, 2),
+        { name: `${sanitizedDealName}/${sanitizedLiName}/config.json` }
+      );
+    });
+
+    archive.finalize();
+  });
+
+  // VAST endpoint (simulated response)
+  app.get("/vast/v1/:dealId/:lineItemId", async (req, res) => {
+    const deal = await storage.getDeal(req.params.dealId);
+    if (!deal) {
+      return res.status(404).send('<VAST version="3.0"/>');
+    }
+
+    const lineItems = await storage.getLineItemsByDeal(req.params.dealId);
+    const lineItem = lineItems.find((li) => li.id === req.params.lineItemId);
+    if (!lineItem) {
+      return res.status(404).send('<VAST version="3.0"/>');
+    }
+
+    res.setHeader("Content-Type", "application/xml");
+    res.send(`<?xml version="1.0" encoding="UTF-8"?>
+<VAST version="3.0">
+  <Ad id="${lineItem.id}">
+    <InLine>
+      <AdSystem>Influence DOOH Adserver</AdSystem>
+      <AdTitle>${lineItem.name}</AdTitle>
+      <Impression><![CDATA[${req.protocol}://${req.get("host")}/api/track/impression?deal=${req.params.dealId}&li=${req.params.lineItemId}&screen=${req.query.screen_id || ""}&player=${req.query.player_id || ""}]]></Impression>
+      <Creatives>
+        <Creative>
+          <Linear>
+            <Duration>00:00:15</Duration>
+            <MediaFiles>
+              <MediaFile delivery="progressive" type="video/mp4" width="1920" height="1080">
+                <![CDATA[${req.protocol}://${req.get("host")}/api/creatives/${lineItem.id}/media]]>
+              </MediaFile>
+            </MediaFiles>
+          </Linear>
+        </Creative>
+      </Creatives>
+    </InLine>
+  </Ad>
+</VAST>`);
+  });
+
+  return httpServer;
+}