adserver-dashboard 1.0.0

package/client/src/lib/poi-types.ts

@@ -0,0 +1,75 @@
+export interface POIType {
+  id: string;
+  label: string;
+  category: string;
+}
+
+export const POI_TYPES: POIType[] = [
+  { id: 'rest_stop', label: 'Rest Stop', category: 'Travel' },
+  { id: 'public_bath', label: 'Public Bath', category: 'Services' },
+  { id: 'rv_park', label: 'RV Park', category: 'Travel' },
+  { id: 'restaurant', label: 'Restaurant', category: 'Food & Dining' },
+  { id: 'cafe', label: 'Cafe', category: 'Food & Dining' },
+  { id: 'fast_food', label: 'Fast Food', category: 'Food & Dining' },
+  { id: 'bar', label: 'Bar', category: 'Food & Dining' },
+  { id: 'hospital', label: 'Hospital', category: 'Healthcare' },
+  { id: 'pharmacy', label: 'Pharmacy', category: 'Healthcare' },
+  { id: 'doctor', label: 'Doctor', category: 'Healthcare' },
+  { id: 'dentist', label: 'Dentist', category: 'Healthcare' },
+  { id: 'school', label: 'School', category: 'Education' },
+  { id: 'university', label: 'University', category: 'Education' },
+  { id: 'library', label: 'Library', category: 'Education' },
+  { id: 'gas_station', label: 'Gas Station', category: 'Automotive' },
+  { id: 'car_wash', label: 'Car Wash', category: 'Automotive' },
+  { id: 'car_repair', label: 'Car Repair', category: 'Automotive' },
+  { id: 'parking', label: 'Parking', category: 'Automotive' },
+  { id: 'shopping_mall', label: 'Shopping Mall', category: 'Shopping' },
+  { id: 'supermarket', label: 'Supermarket', category: 'Shopping' },
+  { id: 'convenience_store', label: 'Convenience Store', category: 'Shopping' },
+  { id: 'clothing_store', label: 'Clothing Store', category: 'Shopping' },
+  { id: 'gym', label: 'Gym', category: 'Fitness' },
+  { id: 'spa', label: 'Spa', category: 'Fitness' },
+  { id: 'bank', label: 'Bank', category: 'Finance' },
+  { id: 'atm', label: 'ATM', category: 'Finance' },
+  { id: 'hotel', label: 'Hotel', category: 'Lodging' },
+  { id: 'motel', label: 'Motel', category: 'Lodging' },
+  { id: 'campground', label: 'Campground', category: 'Lodging' },
+  { id: 'airport', label: 'Airport', category: 'Transportation' },
+  { id: 'train_station', label: 'Train Station', category: 'Transportation' },
+  { id: 'bus_station', label: 'Bus Station', category: 'Transportation' },
+  { id: 'transit_station', label: 'Transit Station', category: 'Transportation' },
+  { id: 'taxi_stand', label: 'Taxi Stand', category: 'Transportation' },
+  { id: 'park', label: 'Park', category: 'Recreation' },
+  { id: 'amusement_park', label: 'Amusement Park', category: 'Recreation' },
+  { id: 'zoo', label: 'Zoo', category: 'Recreation' },
+  { id: 'aquarium', label: 'Aquarium', category: 'Recreation' },
+  { id: 'museum', label: 'Museum', category: 'Culture' },
+  { id: 'art_gallery', label: 'Art Gallery', category: 'Culture' },
+  { id: 'movie_theater', label: 'Movie Theater', category: 'Entertainment' },
+  { id: 'night_club', label: 'Night Club', category: 'Entertainment' },
+  { id: 'bowling_alley', label: 'Bowling Alley', category: 'Entertainment' },
+  { id: 'casino', label: 'Casino', category: 'Entertainment' },
+  { id: 'stadium', label: 'Stadium', category: 'Sports' },
+  { id: 'post_office', label: 'Post Office', category: 'Services' },
+  { id: 'laundry', label: 'Laundry', category: 'Services' },
+  { id: 'beauty_salon', label: 'Beauty Salon', category: 'Services' },
+  { id: 'hair_care', label: 'Hair Care', category: 'Services' },
+  { id: 'church', label: 'Church', category: 'Religious' },
+  { id: 'mosque', label: 'Mosque', category: 'Religious' },
+  { id: 'temple', label: 'Temple', category: 'Religious' },
+  { id: 'synagogue', label: 'Synagogue', category: 'Religious' },
+];
+
+export const POI_CATEGORIES = [...new Set(POI_TYPES.map(poi => poi.category))];
+
+export function getPOIsByCategory(category: string): POIType[] {
+  return POI_TYPES.filter(poi => poi.category === category);
+}
+
+export function getPOIById(id: string): POIType | undefined {
+  return POI_TYPES.find(poi => poi.id === id);
+}
+
+export function getPOILabel(id: string): string {
+  return getPOIById(id)?.label || id;
+}

package/client/src/lib/queryClient.ts

@@ -0,0 +1,144 @@
+import { QueryClient, QueryFunction } from "@tanstack/react-query";
+import * as oauthService from "./oauth-service";
+
+const DIRECT_CAMPAIGNS_API_BASE_URL = import.meta.env.VITE_OAUTH_API_URL;
+
+/**
+ * Convert relative paths to absolute URLs
+ * Handles /api/direct-io/* paths by prepending the Direct Campaigns API base URL
+ */
+function buildAbsoluteUrl(url: string): string {
+  // If URL is already absolute, return as-is
+  if (url.startsWith('http://') || url.startsWith('https://')) {
+    return url;
+  }
+  
+  // If URL is a /api/direct-io/* path, prepend the Direct Campaigns API base URL
+  if (url.startsWith('/api/direct-io/')) {
+    // Replace /api/direct-io/ with the full Direct Campaigns API base URL
+    const path = url.replace('/api/direct-io', '');
+    return `${DIRECT_CAMPAIGNS_API_BASE_URL}/api/v1/rest${path}`;
+  }
+  
+  // For other relative paths (local backend), keep as relative
+  return url;
+}
+
+async function throwIfResNotOk(res: Response) {
+  if (!res.ok) {
+    const text = (await res.text()) || res.statusText;
+    throw new Error(`${res.status}: ${text}`);
+  }
+}
+
+/**
+ * Enhanced fetch with automatic token refresh on 401
+ * Properly preserves request body and headers for retry
+ * Automatically injects Authorization header with Bearer token
+ */
+export async function fetchWithTokenRefresh(
+  url: string,
+  options: RequestInit = {},
+  isRetry = false
+): Promise<Response> {
+  // Convert relative paths to absolute URLs
+  const absoluteUrl = buildAbsoluteUrl(url);
+  
+  // Clone the options to preserve original body for potential retry
+  const clonedOptions = { ...options };
+  
+  // If body exists and is a string/object, preserve it
+  if (options.body) {
+    // Body can only be read once, so we need to preserve it
+    clonedOptions.body = options.body;
+  }
+
+  // Initialize headers if not present
+  const headers = new Headers(clonedOptions.headers || {});
+  
+  // Automatically inject OAuth token into Authorization header
+  const accessToken = oauthService.getAccessToken();
+  if (accessToken) {
+    headers.set('Authorization', `Bearer ${accessToken}`);
+  }
+
+  const res = await fetch(absoluteUrl, {
+    ...clonedOptions,
+    headers,
+  });
+
+  // If we get a 401 and this is not a retry, attempt token refresh
+  if (res.status === 401 && !isRetry && oauthService.isAuthenticated()) {
+    try {
+      // Attempt to refresh the token
+      await oauthService.refreshAccessToken();
+
+      // Retry the original request with the same options
+      // The new access token will be automatically injected
+      return await fetchWithTokenRefresh(url, options, true);
+    } catch (refreshError) {
+      // If refresh fails, clear auth state and throw
+      console.error('Token refresh failed:', refreshError);
+      oauthService.clearAuthStorage();
+      throw new Error('Session expired. Please log in again.');
+    }
+  }
+
+  return res;
+}
+
+export { buildAbsoluteUrl };
+
+export async function apiRequest(
+  method: string,
+  url: string,
+  data?: unknown | undefined,
+): Promise<Response> {
+  const res = await fetchWithTokenRefresh(url, {
+    method,
+    headers: data ? { "Content-Type": "application/json" } : {},
+    body: data ? JSON.stringify(data) : undefined,
+  });
+
+  await throwIfResNotOk(res);
+  return res;
+}
+
+type UnauthorizedBehavior = "returnNull" | "throw";
+export const getQueryFn: <T>(options: {
+  on401: UnauthorizedBehavior;
+}) => QueryFunction<T> =
+  ({ on401: unauthorizedBehavior }) =>
+  async ({ queryKey }) => {
+    // Join query key to create URL path
+    const urlPath = queryKey.join("/") as string;
+    
+    // Log for debugging
+    if (urlPath.includes('/api/direct-io/')) {
+      console.log('[QueryClient] Fetching from Direct Campaigns API:', urlPath);
+    }
+    
+    const res = await fetchWithTokenRefresh(urlPath);
+
+    if (unauthorizedBehavior === "returnNull" && res.status === 401) {
+      return null;
+    }
+
+    await throwIfResNotOk(res);
+    return await res.json();
+  };
+
+export const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      queryFn: getQueryFn({ on401: "throw" }),
+      refetchInterval: false,
+      refetchOnWindowFocus: false,
+      staleTime: Infinity,
+      retry: false,
+    },
+    mutations: {
+      retry: false,
+    },
+  },
+});

package/client/src/lib/recommendation-api.ts

@@ -0,0 +1,380 @@
+import { getAccessToken } from './oauth-service';
+import { API_CONFIG } from './api-config';
+
+const RECOMMENDATION_API_BASE = API_CONFIG.recommendation || `${API_CONFIG.inventory}/api/v1/recommendation`;
+
+export interface GeographyTargeting {
+  cities?: string[];
+  states?: string[];
+  geofences?: Array<{
+    type: string;
+    coordinates: number[][];
+    centerLng: number;
+    centerLat: number;
+  }>;
+}
+
+export interface AudienceTargeting {
+  audienceSegments?: string[];
+  demographics?: Record<string, string[]>;
+}
+
+export interface RecommendationRequest {
+  country: string;
+  startDate: string;
+  endDate: string;
+  productId?: string;
+  companyId?: string;
+  mediaOwnerIds?: string[];
+  geographyTargeting?: GeographyTargeting;
+  audienceTargeting?: AudienceTargeting;
+  brandId?: string;
+  budget?: number;
+  goal?: 'IMPRESSIONS' | 'REACH' | 'SOV';
+  goalValue?: number;
+  excludedInventoryIds?: string[];
+  excludedIabCategories?: string[];
+  topN?: number;
+}
+
+export interface RecommendationMetadata {
+  totalInventoriesScored?: number;
+  topNReturned?: number;
+  processingTimeMs?: number;
+}
+
+export interface RecommendationStatusResponse {
+  runId: string;
+  status: 'IN_PROGRESS' | 'COMPLETED';
+  completionPercentage?: number;
+  campaignId?: string;
+  productId?: string;
+  companyId?: string;
+  generatedAt?: string;
+  metadata?: RecommendationMetadata;
+  warnings?: string[];
+}
+
+export interface ComponentScores {
+  measureFit?: number;
+  geoFit?: number;
+  availability?: number;
+  budgetFit?: number;
+  audienceFit?: number;
+  brandFit?: number;
+  qualityFit?: number;
+  timeFit?: number;
+}
+
+export interface AvailabilitySummary {
+  availableSlots?: number;
+  totalSlots?: number;
+  availableDays?: number;
+  totalDays?: number;
+  availabilityPercentage?: number;
+  summary?: string;
+  allAvailable?: boolean;
+}
+
+export interface ForecastedMetrics {
+  estimatedImpressions?: number;
+  estimatedReach?: number;
+  estimatedSov?: number;
+  estimatedFrequency?: number;
+}
+
+export interface CostEstimate {
+  estimatedCost?: number;
+  currency?: string;
+  costPerImpression?: number;
+}
+
+export interface InventoryLocation {
+  countryId?: string;
+  countryName?: string;
+  stateId?: string;
+  stateName?: string;
+  cityId?: string;
+  cityName?: string;
+  locationCoordinates?: { latitude: number; longitude: number };
+}
+
+export interface InventoryDetails {
+  classification?: string;
+  type?: string;
+  format?: string;
+  environment?: string;
+  venueTypes?: string[];
+  orientation?: string;
+  sizes?: string[];
+  mediaOwnerId?: string;
+  mediaOwnerName?: string;
+  address?: string;
+  location?: InventoryLocation;
+}
+
+export interface RecommendedInventory {
+  inventoryId: string;
+  referenceId?: string;
+  name: string;
+  finalScore?: number;
+  componentScores?: ComponentScores;
+  why?: string;
+  availability?: AvailabilitySummary;
+  forecast?: ForecastedMetrics;
+  cost?: CostEstimate;
+  inventoryDetails?: InventoryDetails;
+  isSelected?: boolean;
+  isExcluded?: boolean;
+}
+
+export interface PaginationInfo {
+  page: number;
+  size: number;
+  totalElements: number;
+  totalPages: number;
+}
+
+export interface PaginatedRecommendationResponse {
+  runId: string;
+  campaignId?: string;
+  productId?: string;
+  companyId?: string;
+  recommendations: RecommendedInventory[];
+  pagination: PaginationInfo;
+}
+
+export interface RecommendationResultFilter {
+  inventoryIds?: string[];
+  referenceIds?: string[];
+  classifications?: string[];
+  types?: string[];
+  formats?: string[];
+  environments?: string[];
+  venueTypes?: string[];
+  orientations?: string[];
+  sizes?: string[];
+  mediaOwnerIds?: string[];
+  mediaOwnerNames?: string[];
+  countryIds?: string[];
+  countryNames?: string[];
+  stateIds?: string[];
+  stateNames?: string[];
+  cityIds?: string[];
+  cityNames?: string[];
+  currencies?: string[];
+  minFinalScore?: number;
+  maxFinalScore?: number;
+  minMeasureFit?: number;
+  maxMeasureFit?: number;
+  minGeoFit?: number;
+  maxGeoFit?: number;
+  minAvailability?: number;
+  maxAvailability?: number;
+  minBudgetFit?: number;
+  maxBudgetFit?: number;
+  minAudienceFit?: number;
+  maxAudienceFit?: number;
+  minBrandFit?: number;
+  maxBrandFit?: number;
+  minQualityFit?: number;
+  maxQualityFit?: number;
+  minTimeFit?: number;
+  maxTimeFit?: number;
+  minEstimatedImpressions?: number;
+  maxEstimatedImpressions?: number;
+  minEstimatedReach?: number;
+  maxEstimatedReach?: number;
+  minEstimatedFrequency?: number;
+  maxEstimatedFrequency?: number;
+  minEstimatedCost?: number;
+  maxEstimatedCost?: number;
+  minAvailabilityPercentage?: number;
+  maxAvailabilityPercentage?: number;
+  allAvailable?: boolean;
+}
+
+async function getHeaders(): Promise<Record<string, string>> {
+  const accessToken = getAccessToken();
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+  };
+  if (accessToken) {
+    headers['Authorization'] = `Bearer ${accessToken}`;
+  }
+  return headers;
+}
+
+export async function submitRecommendation(
+  lineItemId: string,
+  request: RecommendationRequest
+): Promise<RecommendationStatusResponse> {
+  const headers = await getHeaders();
+  
+  console.log('[Recommendation API] Submitting request:', JSON.stringify(request, null, 2));
+  console.log('[Recommendation API] Headers:', headers);
+  
+  const response = await fetch(
+    `${RECOMMENDATION_API_BASE}/recommendation/campaigns/${lineItemId}/recommendations`,
+    {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(request),
+    }
+  );
+
+  const result = await response.json();
+  console.log('[Recommendation API] Response:', JSON.stringify(result, null, 2));
+
+  if (!response.ok) {
+    throw new Error(result.message || result.error?.message || `Failed to submit recommendation: ${response.status}`);
+  }
+
+  // Check for API-level success flag (some APIs return 200 with success: false)
+  if (result.success === false) {
+    const errorDetails = result.error?.details || result.error?.message || result.message || 'Unknown error';
+    throw new Error(`Recommendation failed: ${errorDetails}`);
+  }
+
+  return result.data || result;
+}
+
+export async function getRecommendationStatus(
+  lineItemId: string,
+  request: RecommendationRequest
+): Promise<RecommendationStatusResponse> {
+  const headers = await getHeaders();
+  
+  console.log('[Recommendation API] Checking status with same payload:', JSON.stringify(request, null, 2));
+  
+  // Use same POST request with same payload to check status
+  const response = await fetch(
+    `${RECOMMENDATION_API_BASE}/recommendation/campaigns/${lineItemId}/recommendations`,
+    {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(request),
+    }
+  );
+
+  const result = await response.json();
+  console.log('[Recommendation API] Status response:', JSON.stringify(result, null, 2));
+
+  if (!response.ok) {
+    throw new Error(result.message || result.error?.message || `Failed to get recommendation status: ${response.status}`);
+  }
+
+  // Check for API-level success flag
+  if (result.success === false) {
+    const errorDetails = result.error?.details || result.error?.message || result.message || 'Unknown error';
+    throw new Error(`Status check failed: ${errorDetails}`);
+  }
+
+  return result.data || result;
+}
+
+export async function getRecommendationResults(
+  runId: string,
+  page: number = 0,
+  size: number = 20,
+  sort: string[] = ['finalScore,desc'],
+  filter?: RecommendationResultFilter
+): Promise<PaginatedRecommendationResponse> {
+  const headers = await getHeaders();
+  
+  const params = new URLSearchParams({
+    page: page.toString(),
+    size: size.toString(),
+  });
+  
+  sort.forEach(s => params.append('sort', s));
+
+  // TODO: Re-enable types filter when backend supports it
+  // const requestBody = {
+  //   types: ["Digital"],
+  //   ...(filter || {}),
+  // };
+  const requestBody = filter || {};
+
+  const response = await fetch(
+    `${RECOMMENDATION_API_BASE}/recommendation/runs/${runId}/results?${params.toString()}`,
+    {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(requestBody),
+    }
+  );
+
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(errorData.message || `Failed to get recommendation results: ${response.status}`);
+  }
+
+  const result = await response.json();
+  return result.data || result;
+}
+
+export interface PollingProgress {
+  status: 'IN_PROGRESS' | 'COMPLETED';
+  completionPercentage: number;
+  attempt: number;
+  maxAttempts: number;
+  elapsedSeconds: number;
+}
+
+export async function pollUntilCompleted(
+  lineItemId: string,
+  request: RecommendationRequest,
+  maxAttempts: number = 150,
+  intervalMs: number = 2000,
+  onProgress?: (progress: PollingProgress) => void
+): Promise<RecommendationStatusResponse> {
+  let attempts = 0;
+  const totalMinutes = Math.round((maxAttempts * intervalMs) / 60000);
+  
+  while (attempts < maxAttempts) {
+    const status = await getRecommendationStatus(lineItemId, request);
+    
+    const elapsedSeconds = Math.round((attempts + 1) * intervalMs / 1000);
+    const completionPercentage = status.completionPercentage ?? 0;
+
+    onProgress?.({
+      status: status.status,
+      completionPercentage,
+      attempt: attempts + 1,
+      maxAttempts,
+      elapsedSeconds,
+    });
+
+    if (status.status === 'COMPLETED') {
+      console.log(`[Recommendation API] Completed after ${attempts + 1} attempts (${elapsedSeconds}s)`);
+      return status;
+    }
+    
+    attempts++;
+    if (attempts % 15 === 0) {
+      console.log(`[Recommendation API] Still polling... attempt ${attempts}/${maxAttempts} (${Math.round(attempts * intervalMs / 1000)}s elapsed, ${totalMinutes}min max)`);
+    }
+    await new Promise(resolve => setTimeout(resolve, intervalMs));
+  }
+  
+  throw new Error(`Recommendation timed out after ${totalMinutes} minutes. Please try again.`);
+}
+
+export async function submitAndWaitForResults(
+  lineItemId: string,
+  request: RecommendationRequest,
+  page: number = 0,
+  size: number = 20
+): Promise<{ status: RecommendationStatusResponse; results: PaginatedRecommendationResponse }> {
+  const statusResponse = await submitRecommendation(lineItemId, request);
+  
+  let finalStatus = statusResponse;
+  if (statusResponse.status === 'IN_PROGRESS') {
+    finalStatus = await pollUntilCompleted(lineItemId, request);
+  }
+  
+  const results = await getRecommendationResults(finalStatus.runId, page, size);
+  
+  return { status: finalStatus, results };
+}

package/client/src/lib/storage-utils.ts

@@ -0,0 +1,104 @@
+/**
+ * Storage Utilities for OAuth Token Storage
+ * 
+ * Provides cookie-based operations for storing OAuth access and refresh tokens
+ * Uses Secure and SameSite=Strict flags for enhanced security
+ */
+
+const STORAGE_PREFIX = 'oauth_';
+const COOKIE_OPTIONS = {
+  path: '/',
+  sameSite: 'Strict',
+  // Secure flag will be applied only over HTTPS
+  secure: window.location.protocol === 'https:',
+};
+
+/**
+ * Set a cookie with the given key and value
+ */
+export function setItem(key: string, value: string): void {
+  try {
+    const cookieName = STORAGE_PREFIX + key;
+    
+    // Build cookie string
+    let cookieStr = `${encodeURIComponent(cookieName)}=${encodeURIComponent(value)}`;
+    cookieStr += `; path=${COOKIE_OPTIONS.path}`;
+    cookieStr += `; SameSite=${COOKIE_OPTIONS.sameSite}`;
+    
+    // Add Secure flag only for HTTPS
+    if (COOKIE_OPTIONS.secure) {
+      cookieStr += '; Secure';
+    }
+    
+    // Set token expiry to 7 days (can be overridden per token)
+    const maxAge = 7 * 24 * 60 * 60; // 7 days in seconds
+    cookieStr += `; Max-Age=${maxAge}`;
+    
+    document.cookie = cookieStr;
+    console.log(`[Storage] Cookie set: ${cookieName}`);
+  } catch (error) {
+    console.error('Failed to set cookie:', error);
+  }
+}
+
+/**
+ * Get a cookie value by key
+ */
+export function getItem(key: string): string | null {
+  try {
+    const cookieName = STORAGE_PREFIX + key;
+    const nameEQ = encodeURIComponent(cookieName) + '=';
+    
+    // Split cookies and find the one we're looking for
+    const cookies = document.cookie.split(';');
+    for (let i = 0; i < cookies.length; i++) {
+      let cookie = cookies[i].trim();
+      if (cookie.indexOf(nameEQ) === 0) {
+        return decodeURIComponent(cookie.substring(nameEQ.length));
+      }
+    }
+    
+    return null;
+  } catch (error) {
+    console.error('Failed to get cookie:', error);
+    return null;
+  }
+}
+
+/**
+ * Delete a cookie by setting its expiry to the past
+ */
+export function removeItem(key: string): void {
+  try {
+    const cookieName = STORAGE_PREFIX + key;
+    document.cookie = `${encodeURIComponent(cookieName)}=; path=/; expires=Thu, 01 Jan 1970 00:00:00 UTC; SameSite=Strict`;
+    console.log(`[Storage] Cookie deleted: ${cookieName}`);
+  } catch (error) {
+    console.error('Failed to remove cookie:', error);
+  }
+}
+
+/**
+ * Check if a cookie exists
+ */
+export function hasItem(key: string): boolean {
+  return getItem(key) !== null;
+}
+
+/**
+ * Clear all OAuth-related cookies
+ */
+export function clearAll(): void {
+  try {
+    const cookies = document.cookie.split(';');
+    cookies.forEach(cookie => {
+      const cookieName = cookie.split('=')[0].trim();
+      if (cookieName.startsWith(encodeURIComponent(STORAGE_PREFIX))) {
+        document.cookie = `${cookieName}=; path=/; expires=Thu, 01 Jan 1970 00:00:00 UTC; SameSite=Strict`;
+      }
+    });
+    console.log('[Storage] All OAuth cookies cleared');
+  } catch (error) {
+    console.error('Failed to clear cookies:', error);
+  }
+}