adserver-dashboard 1.0.0

package/Influence-MW-AdServer-12-02-2026/scripts/create-remaining-diagrams.cjs

@@ -0,0 +1,270 @@
+const https = require('https');
+
+const MIRO_TOKEN = process.env.MIRO_ACCESS_TOKEN;
+const BOARD_ID = 'uXjVGHwGbyo=';
+const BOARD_URL = 'https://miro.com/app/board/uXjVGHwGbyo=';
+
+const COLORS = {
+  gray: '#6B7280',
+  grayLight: '#9CA3AF',
+  lightBlue: '#DBEAFE',
+  blue: '#3B82F6',
+  blueDark: '#1E40AF',
+  blueAccent: '#BFDBFE',
+  blueAccentDark: '#2563EB',
+  orange: '#FDBA74',
+  orangeDark: '#F97316',
+  green: '#BBF7D0',
+  greenDark: '#22C55E',
+  purple: '#E9D5FF',
+  purpleDark: '#9333EA',
+  yellow: '#FEF3C7',
+  yellowDark: '#F59E0B',
+  white: '#FFFFFF',
+  black: '#1a1a2e'
+};
+
+const SHAPE = { width: 140, height: 55 };
+const DIAMOND = { width: 120, height: 80 };
+const CIRCLE = { width: 70, height: 70 };
+
+function makeRequest(method, path, data = null) {
+  return new Promise((resolve, reject) => {
+    const encodedPath = path.replace(/=/g, '%3D');
+    const options = {
+      hostname: 'api.miro.com',
+      port: 443,
+      path: encodedPath,
+      method: method,
+      headers: {
+        'Authorization': `Bearer ${MIRO_TOKEN}`,
+        'Content-Type': 'application/json',
+        'Accept': 'application/json'
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => {
+        try {
+          const result = body ? JSON.parse(body) : {};
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(result);
+          } else {
+            console.error(`API Error ${res.statusCode}: ${body}`);
+            reject(new Error(`API Error ${res.statusCode}`));
+          }
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+
+    req.on('error', reject);
+    if (data) req.write(JSON.stringify(data));
+    req.end();
+  });
+}
+
+async function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function createFrame(title, x, y, width, height) {
+  console.log(`  Creating frame: ${title}`);
+  const result = await makeRequest('POST', `/v2/boards/${BOARD_ID}/frames`, {
+    data: { title, format: 'custom', type: 'freeform' },
+    style: { fillColor: '#F8F9FA' },
+    geometry: { width, height },
+    position: { x, y, origin: 'center' }
+  });
+  await sleep(200);
+  return result;
+}
+
+async function createShape(text, x, y, shapeType, fillColor, borderColor, width, height) {
+  const payload = {
+    data: { shape: shapeType, content: `<p style="text-align:center">${text}</p>` },
+    style: {
+      fillColor, borderColor, borderWidth: '2',
+      fontFamily: 'arial', fontSize: '11', textAlign: 'center', textAlignVertical: 'middle'
+    },
+    geometry: { width, height },
+    position: { x, y, origin: 'center' }
+  };
+  const result = await makeRequest('POST', `/v2/boards/${BOARD_ID}/shapes`, payload);
+  await sleep(120);
+  return result;
+}
+
+async function createConnector(startId, endId, startPos = null, endPos = null, caption = null, strokeColor = COLORS.black) {
+  const payload = {
+    startItem: { id: startId, position: startPos || { x: '100%', y: '50%' } },
+    endItem: { id: endId, position: endPos || { x: '0%', y: '50%' } },
+    style: { strokeColor, strokeWidth: '2', strokeStyle: 'normal', endStrokeCap: 'stealth' },
+    shape: 'elbowed'
+  };
+  if (caption) payload.captions = [{ content: caption, position: '50%' }];
+  const result = await makeRequest('POST', `/v2/boards/${BOARD_ID}/connectors`, payload);
+  await sleep(80);
+  return result;
+}
+
+async function createText(content, x, y, fontSize = 12, color = '#000000') {
+  const payload = {
+    data: { content: `<p>${content}</p>` },
+    style: { color, fontFamily: 'arial', fontSize: fontSize.toString(), textAlign: 'left' },
+    position: { x, y, origin: 'center' }
+  };
+  const result = await makeRequest('POST', `/v2/boards/${BOARD_ID}/texts`, payload);
+  await sleep(80);
+  return result;
+}
+
+async function createLegend(x, y, items) {
+  await createText('<strong>LEGEND</strong>', x + 40, y - 25, 13, COLORS.black);
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const itemY = y + (i * 30);
+    await createShape('', x, itemY, 'rectangle', item.color, item.border, 22, 16);
+    await createText(item.label, x + 75, itemY, 10, '#374151');
+  }
+}
+
+async function createDealCreationDiagram(baseX, baseY) {
+  console.log('\n  Adding Deal Creation Flow shapes...');
+  const col = 180;
+  const row = 100;
+  
+  const start = await createShape('New Deal', baseX - 600, baseY, 'circle', COLORS.yellow, COLORS.yellowDark, CIRCLE.width, CIRCLE.height);
+  
+  const b1 = await createShape('Enter Name', baseX - 600 + col, baseY, 'rectangle', COLORS.lightBlue, COLORS.blue, SHAPE.width, SHAPE.height);
+  const b2 = await createShape('Set Status', baseX - 600 + col*2, baseY, 'rectangle', COLORS.lightBlue, COLORS.blue, SHAPE.width, SHAPE.height);
+  const b3 = await createShape('External ID', baseX - 600 + col*3, baseY, 'rectangle', COLORS.lightBlue, COLORS.blue, SHAPE.width, SHAPE.height);
+  
+  const i1 = await createShape('Select SSP', baseX - 600 + col*4, baseY, 'rectangle', COLORS.green, COLORS.greenDark, SHAPE.width, SHAPE.height);
+  const i2 = await createShape('Select Media<br/>Owner', baseX - 600 + col*5, baseY, 'rectangle', COLORS.green, COLORS.greenDark, SHAPE.width, SHAPE.height);
+  
+  const t1 = await createShape('Deal<br/>Type?', baseX - 600 + col*6, baseY, 'rhombus', COLORS.orange, COLORS.orangeDark, DIAMOND.width, DIAMOND.height);
+  
+  const c1 = await createShape('Select Brand', baseX - 600 + col*3, baseY + row, 'rectangle', COLORS.purple, COLORS.purpleDark, SHAPE.width, SHAPE.height);
+  const c2 = await createShape('Agency?', baseX - 600 + col*4, baseY + row, 'rhombus', COLORS.purple, COLORS.purpleDark, DIAMOND.width, DIAMOND.height);
+  const c3 = await createShape('Select Agency', baseX - 600 + col*5, baseY + row, 'rectangle', COLORS.purple, COLORS.purpleDark, SHAPE.width, SHAPE.height);
+  
+  const bg1 = await createShape('Set Budget', baseX - 600 + col*3, baseY + row*2, 'rectangle', COLORS.blueAccent, COLORS.blueAccentDark, SHAPE.width, SHAPE.height);
+  const bg2 = await createShape('Set Goal', baseX - 600 + col*4, baseY + row*2, 'rectangle', COLORS.blueAccent, COLORS.blueAccentDark, SHAPE.width, SHAPE.height);
+  const bg3 = await createShape('Set Dates', baseX - 600 + col*5, baseY + row*2, 'rectangle', COLORS.blueAccent, COLORS.blueAccentDark, SHAPE.width, SHAPE.height);
+  
+  const save = await createShape('Save Deal', baseX - 600 + col*6, baseY + row*2, 'rectangle', COLORS.green, COLORS.greenDark, SHAPE.width, SHAPE.height);
+  const end = await createShape('Done', baseX - 600 + col*7, baseY + row*2, 'circle', COLORS.grayLight, COLORS.gray, CIRCLE.width, CIRCLE.height);
+
+  console.log('  Adding connectors...');
+  await createConnector(start.id, b1.id);
+  await createConnector(b1.id, b2.id);
+  await createConnector(b2.id, b3.id);
+  await createConnector(b3.id, i1.id);
+  await createConnector(i1.id, i2.id);
+  await createConnector(i2.id, t1.id);
+  await createConnector(t1.id, c1.id, { x: '50%', y: '100%' }, { x: '0%', y: '50%' }, '');
+  await createConnector(c1.id, c2.id);
+  await createConnector(c2.id, c3.id, { x: '100%', y: '50%' }, { x: '0%', y: '50%' }, 'Yes');
+  await createConnector(c2.id, bg1.id, { x: '50%', y: '100%' }, { x: '50%', y: '0%' }, 'No');
+  await createConnector(c3.id, bg2.id, { x: '50%', y: '100%' }, { x: '50%', y: '0%' });
+  await createConnector(bg1.id, bg2.id);
+  await createConnector(bg2.id, bg3.id);
+  await createConnector(bg3.id, save.id);
+  await createConnector(save.id, end.id);
+
+  await createLegend(baseX + 700, baseY - 50, [
+    { color: COLORS.yellow, border: COLORS.yellowDark, label: 'Start' },
+    { color: COLORS.lightBlue, border: COLORS.blue, label: 'Basic Info' },
+    { color: COLORS.green, border: COLORS.greenDark, label: 'Inventory Source' },
+    { color: COLORS.orange, border: COLORS.orangeDark, label: 'Deal Type' },
+    { color: COLORS.purple, border: COLORS.purpleDark, label: 'Client Config' },
+    { color: COLORS.blueAccent, border: COLORS.blueAccentDark, label: 'Budget & Goals' }
+  ]);
+}
+
+async function createLineItemFormDiagram(baseX, baseY) {
+  console.log('\n  Adding Line Item Form shapes...');
+  const col = 160;
+  const row = 90;
+  
+  await createText('<strong>FORM SECTIONS</strong>', baseX - 500, baseY - 80, 12, COLORS.black);
+  
+  const s1 = await createShape('1. Basic Info', baseX - 500, baseY, 'rectangle', COLORS.lightBlue, COLORS.blue, 130, 50);
+  const s2 = await createShape('2. Creative', baseX - 500 + col, baseY, 'rectangle', COLORS.lightBlue, COLORS.blue, 130, 50);
+  const s3 = await createShape('3. Targeting', baseX - 500 + col*2, baseY, 'rectangle', COLORS.lightBlue, COLORS.blue, 130, 50);
+  const s4 = await createShape('4. Inv Source', baseX - 500 + col*3, baseY, 'rectangle', COLORS.lightBlue, COLORS.blue, 130, 50);
+  const s5 = await createShape('5. Inv Select', baseX - 500 + col*4, baseY, 'rectangle', COLORS.lightBlue, COLORS.blue, 130, 50);
+  
+  await createText('<strong>TARGETING</strong>', baseX - 500 + col*2, baseY + row - 15, 11, COLORS.orangeDark);
+  const t1 = await createShape('Demographics', baseX - 500 + col, baseY + row, 'rectangle', COLORS.orange, COLORS.orangeDark, 110, 40);
+  const t2 = await createShape('Geography', baseX - 500 + col*2, baseY + row, 'rectangle', COLORS.orange, COLORS.orangeDark, 110, 40);
+  const t3 = await createShape('Income', baseX - 500 + col*3, baseY + row, 'rectangle', COLORS.orange, COLORS.orangeDark, 110, 40);
+  
+  const s6 = await createShape('6. Schedule', baseX - 500 + col*5, baseY, 'rectangle', COLORS.lightBlue, COLORS.blue, 130, 50);
+  const s7 = await createShape('7. Budget', baseX - 500 + col*6, baseY, 'rectangle', COLORS.lightBlue, COLORS.blue, 130, 50);
+  
+  await createText('<strong>ADVANCED</strong>', baseX - 500 + col*6, baseY + row - 15, 11, COLORS.purpleDark);
+  const a1 = await createShape('Custom Fees', baseX - 500 + col*5, baseY + row, 'rectangle', COLORS.purple, COLORS.purpleDark, 110, 40);
+  const a2 = await createShape('Frequency Cap', baseX - 500 + col*6, baseY + row, 'rectangle', COLORS.purple, COLORS.purpleDark, 110, 40);
+  
+  const save = await createShape('Save', baseX - 500 + col*7, baseY, 'rectangle', COLORS.green, COLORS.greenDark, 100, 50);
+
+  console.log('  Adding connectors...');
+  await createConnector(s1.id, s2.id);
+  await createConnector(s2.id, s3.id);
+  await createConnector(s3.id, s4.id);
+  await createConnector(s4.id, s5.id);
+  await createConnector(s5.id, s6.id);
+  await createConnector(s6.id, s7.id);
+  await createConnector(s7.id, save.id);
+  
+  await createConnector(s3.id, t1.id, { x: '0%', y: '100%' }, { x: '50%', y: '0%' });
+  await createConnector(t1.id, t2.id);
+  await createConnector(t2.id, t3.id);
+  
+  await createConnector(s7.id, a1.id, { x: '0%', y: '100%' }, { x: '50%', y: '0%' });
+  await createConnector(a1.id, a2.id);
+
+  await createLegend(baseX + 700, baseY - 30, [
+    { color: COLORS.lightBlue, border: COLORS.blue, label: 'Form Section' },
+    { color: COLORS.orange, border: COLORS.orangeDark, label: 'Targeting Options' },
+    { color: COLORS.purple, border: COLORS.purpleDark, label: 'Advanced Options' },
+    { color: COLORS.green, border: COLORS.greenDark, label: 'Save Action' }
+  ]);
+}
+
+async function main() {
+  try {
+    console.log('=== CREATING REMAINING INFLUENCE DIAGRAMS ===');
+    console.log(`Board: ${BOARD_URL}\n`);
+    
+    console.log('Creating Frame 5: Deal Creation Flow');
+    const f5 = await createFrame('Influence - Deal Creation Flow', 3000, 2650, 1800, 450);
+    await createDealCreationDiagram(3000, 2650);
+    
+    console.log('\nCreating Frame 6: Line Item Form Structure');
+    const f6 = await createFrame('Influence - Line Item Form Structure', 3000, 3250, 1600, 350);
+    await createLineItemFormDiagram(3000, 3250);
+    
+    console.log('\n=== ADDITIONAL MIRO DIAGRAMS CREATED ===\n');
+    console.log('Frame Links:');
+    console.log(`  5. Deal Creation Flow: ${BOARD_URL}?moveToWidget=${f5.id}`);
+    console.log(`  6. Line Item Form: ${BOARD_URL}?moveToWidget=${f6.id}`);
+    
+    console.log('\n--- PRD UPDATE INFO ---');
+    console.log(JSON.stringify({
+      dealCreation: `${BOARD_URL}?moveToWidget=${f5.id}`,
+      lineItemForm: `${BOARD_URL}?moveToWidget=${f6.id}`
+    }, null, 2));
+    
+  } catch (error) {
+    console.error('Error:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

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

@@ -0,0 +1,103 @@
+import express, { type Request, Response, NextFunction } from "express";
+import { registerRoutes } from "./routes";
+import { serveStatic } from "./static";
+import { createServer } from "http";
+
+const app = express();
+const httpServer = createServer(app);
+
+declare module "http" {
+  interface IncomingMessage {
+    rawBody: unknown;
+  }
+}
+
+app.use(
+  express.json({
+    verify: (req, _res, buf) => {
+      req.rawBody = buf;
+    },
+  }),
+);
+
+app.use(express.urlencoded({ extended: false }));
+
+export function log(message: string, source = "express") {
+  const formattedTime = new Date().toLocaleTimeString("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: true,
+  });
+
+  console.log(`${formattedTime} [${source}] ${message}`);
+}
+
+app.use((req, res, next) => {
+  const start = Date.now();
+  const path = req.path;
+  let capturedJsonResponse: Record<string, any> | undefined = undefined;
+
+  const originalResJson = res.json;
+  res.json = function (bodyJson, ...args) {
+    capturedJsonResponse = bodyJson;
+    return originalResJson.apply(res, [bodyJson, ...args]);
+  };
+
+  res.on("finish", () => {
+    const duration = Date.now() - start;
+    if (path.startsWith("/api")) {
+      let logLine = `${req.method} ${path} ${res.statusCode} in ${duration}ms`;
+      if (capturedJsonResponse) {
+        logLine += ` :: ${JSON.stringify(capturedJsonResponse)}`;
+      }
+
+      log(logLine);
+    }
+  });
+
+  next();
+});
+
+(async () => {
+  await registerRoutes(httpServer, app);
+
+  app.use((err: any, _req: Request, res: Response, next: NextFunction) => {
+    const status = err.status || err.statusCode || 500;
+    const message = err.message || "Internal Server Error";
+
+    console.error("Internal Server Error:", err);
+
+    if (res.headersSent) {
+      return next(err);
+    }
+
+    return res.status(status).json({ message });
+  });
+
+  // importantly only setup vite in development and after
+  // setting up all the other routes so the catch-all route
+  // doesn't interfere with the other routes
+  if (process.env.NODE_ENV === "production") {
+    serveStatic(app);
+  } else {
+    const { setupVite } = await import("./vite");
+    await setupVite(httpServer, app);
+  }
+
+  // ALWAYS serve the app on the port specified in the environment variable PORT
+  // Other ports are firewalled. Default to 5000 if not specified.
+  // this serves both the API and the client.
+  // It is the only port that is not firewalled.
+  const port = parseInt(process.env.PORT || "5000", 10);
+  httpServer.listen(
+    {
+      port,
+      host: "0.0.0.0",
+      reusePort: true,
+    },
+    () => {
+      log(`serving on port ${port}`);
+    },
+  );
+})();

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

@@ -0,0 +1,319 @@
+import type {
+  RecommendationRequest,
+  RecommendationResponse,
+  InventoryRecommendation,
+  RecommendationScoreComponents,
+  CampaignGoalType,
+  RECOMMENDATION_WEIGHTS,
+  AutoOptimizeRequest,
+  AutoOptimizeResult,
+} from "@shared/schema";
+import { randomUUID } from "crypto";
+
+const RECOMMENDATION_ENGINE_URL = process.env.RECOMMENDATION_ENGINE_URL || "";
+
+export class RecommendationService {
+  private useExternalEngine: boolean;
+
+  constructor() {
+    this.useExternalEngine = !!RECOMMENDATION_ENGINE_URL;
+  }
+
+  async getRecommendations(
+    request: RecommendationRequest,
+    screens: any[]
+  ): Promise<RecommendationResponse> {
+    if (this.useExternalEngine) {
+      return this.fetchExternalRecommendations(request);
+    }
+    return this.generateMockRecommendations(request, screens);
+  }
+
+  private async fetchExternalRecommendations(
+    request: RecommendationRequest
+  ): Promise<RecommendationResponse> {
+    try {
+      const response = await fetch(`${RECOMMENDATION_ENGINE_URL}/api/recommend`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(request),
+      });
+
+      if (!response.ok) {
+        throw new Error(`Recommendation engine returned ${response.status}`);
+      }
+
+      return await response.json();
+    } catch (error) {
+      console.error("Failed to fetch recommendations from external engine:", error);
+      throw error;
+    }
+  }
+
+  private generateMockRecommendations(
+    request: RecommendationRequest,
+    screens: any[]
+  ): RecommendationResponse {
+    const runId = randomUUID();
+    const goalType = request.goalType || "impressions";
+    const campaignDays = this.calculateCampaignDays(request.startDate, request.endDate);
+
+    const filteredScreens = screens.filter((screen) => {
+      if (request.country && screen.country !== request.country) return false;
+      if (request.geography?.cities?.length) {
+        if (!request.geography.cities.includes(screen.city)) return false;
+      }
+      return screen.status === "active";
+    });
+
+    const recommendations: InventoryRecommendation[] = filteredScreens
+      .map((screen) => this.scoreScreen(screen, request, campaignDays, goalType))
+      .sort((a, b) => b.score - a.score)
+      .slice(0, request.limit || 10);
+
+    const totalImpressions = recommendations.reduce(
+      (sum, r) => sum + r.metrics.estimatedImpressions,
+      0
+    );
+    const totalCost = recommendations.reduce(
+      (sum, r) => sum + r.metrics.estimatedCost,
+      0
+    );
+
+    return {
+      runId,
+      status: recommendations.length > 0 ? "success" : "no_matches",
+      recommendations,
+      summary: {
+        totalInventoriesAnalyzed: filteredScreens.length,
+        totalReturned: recommendations.length,
+        estimatedTotalImpressions: totalImpressions,
+        estimatedTotalCost: totalCost,
+        budgetUtilization: request.budget
+          ? Math.min(100, (totalCost / request.budget) * 100)
+          : 0,
+        goalAchievement: request.goalValue
+          ? Math.min(100, (totalImpressions / request.goalValue) * 100)
+          : undefined,
+      },
+      budgetAllocation: {
+        byClassification: {
+          digital: { percentage: 60, amount: totalCost * 0.6 },
+          classic: { percentage: 35, amount: totalCost * 0.35 },
+          audio: { percentage: 5, amount: totalCost * 0.05 },
+        },
+        byType: {
+          ooh: { percentage: 40, amount: totalCost * 0.4 },
+          transit: { percentage: 25, amount: totalCost * 0.25 },
+          retail: { percentage: 15, amount: totalCost * 0.15 },
+          network: { percentage: 10, amount: totalCost * 0.1 },
+          radio: { percentage: 5, amount: totalCost * 0.05 },
+          experiential: { percentage: 5, amount: totalCost * 0.05 },
+        },
+      },
+      warnings:
+        recommendations.length === 0
+          ? ["No inventory available matching your criteria"]
+          : [],
+      generatedAt: new Date().toISOString(),
+    };
+  }
+
+  private scoreScreen(
+    screen: any,
+    request: RecommendationRequest,
+    campaignDays: number,
+    goalType: CampaignGoalType
+  ): InventoryRecommendation {
+    const scoreComponents = this.calculateScoreComponents(screen, request, campaignDays, goalType);
+    const weights = this.getWeights(goalType);
+    
+    const finalScore = Math.round(
+      scoreComponents.measureFit * weights.measureFit +
+        scoreComponents.geoFit * weights.geoFit +
+        scoreComponents.availability * weights.availability +
+        scoreComponents.budgetFit * weights.budgetFit +
+        scoreComponents.audienceFit * weights.audienceFit +
+        scoreComponents.brandFit * weights.brandFit +
+        scoreComponents.qualityFit * weights.qualityFit +
+        scoreComponents.timeFit * weights.timeFit
+    );
+
+    const dailyImpressions = screen.dailyImpressions || 10000;
+    const cpm = parseFloat(screen.cpm) || 10;
+    const estimatedImpressions = dailyImpressions * campaignDays;
+    const estimatedCost = (estimatedImpressions / 1000) * cpm;
+
+    const whyReasons: string[] = [];
+    if (scoreComponents.geoFit > 80) whyReasons.push("excellent location match");
+    if (scoreComponents.measureFit > 80) whyReasons.push("high impression delivery");
+    if (scoreComponents.budgetFit > 80) whyReasons.push("cost-efficient");
+    if (scoreComponents.audienceFit > 70) whyReasons.push("strong audience alignment");
+    if (scoreComponents.qualityFit > 80) whyReasons.push("premium screen quality");
+
+    return {
+      inventoryId: screen.id,
+      inventoryName: screen.name,
+      screenType: screen.screenType,
+      classification: (screen.classification?.toLowerCase() as any) || "digital",
+      inventoryType: this.mapInventoryType(screen.inventoryType),
+      format: screen.format || "Digital Billboard",
+      location: {
+        city: screen.city || "Unknown",
+        country: screen.country || "Unknown",
+        latitude: parseFloat(screen.latitude) || 0,
+        longitude: parseFloat(screen.longitude) || 0,
+      },
+      score: finalScore,
+      scoreComponents,
+      metrics: {
+        estimatedImpressions,
+        estimatedReach: Math.round(estimatedImpressions * 0.4),
+        estimatedAdPlays: campaignDays * 60 * 18,
+        estimatedCost,
+        cpm,
+        dailyImpressions,
+      },
+      availability: {
+        availableDays: campaignDays,
+        totalDays: campaignDays,
+        summary: `${campaignDays}/${campaignDays} days available`,
+      },
+      whyRecommended:
+        whyReasons.length > 0
+          ? `Recommended: ${whyReasons.slice(0, 3).join(" • ")}`
+          : "Matches campaign criteria",
+      aiUsed: false,
+      warnings: [],
+    };
+  }
+
+  private calculateScoreComponents(
+    screen: any,
+    request: RecommendationRequest,
+    campaignDays: number,
+    goalType: CampaignGoalType
+  ): RecommendationScoreComponents {
+    const dailyImpressions = screen.dailyImpressions || 10000;
+    const totalImpressions = dailyImpressions * campaignDays;
+    
+    let measureFit = 50;
+    if (request.goalValue) {
+      const contribution = Math.min(totalImpressions / request.goalValue, 1);
+      measureFit = Math.round(contribution * 100);
+    } else {
+      measureFit = Math.min(100, Math.round(dailyImpressions / 5000));
+    }
+
+    let geoFit = 70;
+    if (request.geography?.cities?.includes(screen.city)) {
+      geoFit = 100;
+    } else if (request.country === screen.country) {
+      geoFit = 85;
+    }
+
+    const availability = 100;
+
+    let budgetFit = 50;
+    if (request.budget) {
+      const cpm = parseFloat(screen.cpm) || 10;
+      const cost = (totalImpressions / 1000) * cpm;
+      const proportion = cost / request.budget;
+      if (proportion <= 0.2) budgetFit = 95;
+      else if (proportion <= 0.5) budgetFit = 75;
+      else if (proportion <= 0.8) budgetFit = 50;
+      else if (proportion <= 1.2) budgetFit = 30;
+      else budgetFit = 10;
+    }
+
+    const audienceFit = 60 + Math.random() * 30;
+    const brandFit = request.brandName ? 70 + Math.random() * 20 : 50;
+
+    let qualityFit = 70;
+    if (screen.screenType === "led") qualityFit = 90;
+    else if (screen.screenType === "lcd") qualityFit = 80;
+
+    const timeFit = 75 + Math.random() * 20;
+
+    return {
+      measureFit: Math.round(measureFit),
+      geoFit: Math.round(geoFit),
+      availability: Math.round(availability),
+      budgetFit: Math.round(budgetFit),
+      audienceFit: Math.round(audienceFit),
+      brandFit: Math.round(brandFit),
+      qualityFit: Math.round(qualityFit),
+      timeFit: Math.round(timeFit),
+    };
+  }
+
+  private getWeights(goalType: CampaignGoalType) {
+    const weights: Record<string, Record<string, number>> = {
+      default: { measureFit: 0.20, geoFit: 0.20, availability: 0.10, budgetFit: 0.20, audienceFit: 0.10, brandFit: 0.10, qualityFit: 0.06, timeFit: 0.04 },
+      impressions: { measureFit: 0.25, geoFit: 0.20, availability: 0.10, budgetFit: 0.18, audienceFit: 0.10, brandFit: 0.08, qualityFit: 0.05, timeFit: 0.04 },
+      reach: { measureFit: 0.22, geoFit: 0.22, availability: 0.12, budgetFit: 0.15, audienceFit: 0.12, brandFit: 0.08, qualityFit: 0.05, timeFit: 0.04 },
+      sov: { measureFit: 0.25, geoFit: 0.15, availability: 0.15, budgetFit: 0.20, audienceFit: 0.08, brandFit: 0.08, qualityFit: 0.05, timeFit: 0.04 },
+      ad_plays: { measureFit: 0.28, geoFit: 0.15, availability: 0.12, budgetFit: 0.18, audienceFit: 0.10, brandFit: 0.08, qualityFit: 0.05, timeFit: 0.04 },
+      carbon_emission: { measureFit: 0.18, geoFit: 0.15, availability: 0.10, budgetFit: 0.15, audienceFit: 0.10, brandFit: 0.08, qualityFit: 0.20, timeFit: 0.04 },
+    };
+    return weights[goalType] || weights.default;
+  }
+
+  private calculateCampaignDays(startDate: string, endDate: string): number {
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+    const diffTime = Math.abs(end.getTime() - start.getTime());
+    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24)) + 1;
+    return Math.max(1, diffDays);
+  }
+
+  private mapInventoryType(type: string | null): any {
+    const typeMap: Record<string, string> = {
+      OOH: "ooh",
+      Transit: "transit",
+      Retail: "retail",
+      Network: "network",
+      Radio: "radio",
+      Experiential: "experiential",
+    };
+    return typeMap[type || ""] || "ooh";
+  }
+
+  async autoOptimize(
+    request: AutoOptimizeRequest,
+    deal: any,
+    screens: any[]
+  ): Promise<AutoOptimizeResult> {
+    const recRequest: RecommendationRequest = {
+      country: deal.countries?.[0] || "US",
+      startDate: deal.startDate,
+      endDate: deal.endDate,
+      budget: request.budget || parseFloat(deal.budget) || undefined,
+      goalType: request.goalType || (deal.goalType as CampaignGoalType),
+      goalValue: request.goalValue || deal.goalValue,
+      brandName: undefined,
+      limit: request.maxInventories || 5,
+    };
+
+    const recommendations = await this.getRecommendations(recRequest, screens);
+
+    return {
+      lineItemId: request.lineItemId,
+      selectedInventories: recommendations.recommendations,
+      scheduleCreated: false,
+      summary: {
+        inventoriesAdded: recommendations.recommendations.length,
+        estimatedImpressions: recommendations.summary.estimatedTotalImpressions,
+        estimatedCost: recommendations.summary.estimatedTotalCost,
+        budgetRemaining: request.budget
+          ? request.budget - recommendations.summary.estimatedTotalCost
+          : 0,
+      },
+      warnings: recommendations.warnings,
+    };
+  }
+}
+
+export const recommendationService = new RecommendationService();