adserver-dashboard 1.0.0

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

@@ -0,0 +1,399 @@
+import { getAccessToken } from './oauth-service';
+import { API_CONFIG } from './api-config';
+
+const INVENTORY_API_BASE = `${API_CONFIG.inventory}/api/v1`;
+
+export interface InventorySearchFilters {
+  archived?: boolean;
+  searchText?: string;
+  venueType?: string;
+  publisherId?: string;
+}
+
+export interface InventoryPlanning {
+  capacity: {
+    campaignDays: number;
+    available: {
+      slots: number;
+      playTimeSec: number;
+      maxImpressions: number;
+    };
+  };
+  allocation: {
+    slots: number;
+    playTimeSec: number;
+    sov: number;
+    sot: number;
+  };
+  estimates: {
+    impressions: number;
+    reach: number;
+    frequency: number;
+  };
+  pricing: {
+    cpm: number;
+    estimatedCost: number;
+  };
+}
+
+export interface ExternalId {
+  platform: string;
+  externalId: string;
+  createdAt?: string;
+  createdBy?: string;
+}
+
+export interface InventoryItem {
+  id: string;
+  name: string;
+  code?: string;
+  address?: string;
+  size?: string;
+  resolution?: string;
+  publisherId?: string;
+  publisherName?: string;
+  latitude?: number;
+  longitude?: number;
+  venueType?: string;
+  timezone?: string;
+  countryIso2?: string;
+  countryIso3?: string;
+  thumbnail?: string;
+  tags?: string[];
+  operatingHours?: string;
+  type?: string;
+  status?: string;
+  planning?: InventoryPlanning;
+  externalIds?: ExternalId[];
+  geoms?: string[];
+  timeZone?: string;
+  mediaOwnerId?: string;
+  mediaOwnerName?: string;
+  typeName?: string;
+  typePath?: string;
+  panels?: Array<{
+    id: string;
+    pixelWidth: number;
+    pixelHeight: number;
+    physicalWidth?: number;
+    physicalHeight?: number;
+    panelCount?: number;
+  }>;
+  digitalFields?: {
+    spotDuration?: number;
+    spotsPerLoop?: number;
+    loopsPerHour?: number;
+    playerCount?: number;
+  };
+}
+
+function generateFakePlanningData(campaignDays: number = 45): InventoryPlanning {
+  const baseImpressions = Math.floor(Math.random() * 15000000) + 5000000;
+  const baseReach = Math.floor(baseImpressions * (0.15 + Math.random() * 0.15));
+  const frequency = parseFloat((baseImpressions / baseReach).toFixed(2));
+  const cpm = parseFloat((Math.random() * 3000 + 1500).toFixed(2));
+  const estimatedCost = Math.floor((baseImpressions / 1000) * cpm);
+  const sov = parseFloat((Math.random() * 0.05 + 0.01).toFixed(4));
+  
+  return {
+    capacity: {
+      campaignDays,
+      available: {
+        slots: Math.floor(Math.random() * 100000) + 100000,
+        playTimeSec: Math.floor(Math.random() * 2000000) + 1000000,
+        maxImpressions: baseImpressions + Math.floor(Math.random() * 10000000),
+      },
+    },
+    allocation: {
+      slots: Math.floor(Math.random() * 5000) + 2000,
+      playTimeSec: Math.floor(Math.random() * 50000) + 30000,
+      sov,
+      sot: sov,
+    },
+    estimates: {
+      impressions: baseImpressions,
+      reach: baseReach,
+      frequency,
+    },
+    pricing: {
+      cpm,
+      estimatedCost,
+    },
+  };
+}
+
+export interface InventorySearchResponse {
+  data: InventoryItem[];
+  pagination?: {
+    page: number;
+    pageSize: number;
+    totalCount: number;
+    totalPages: number;
+  };
+}
+
+export async function searchInventories(
+  filters: InventorySearchFilters = {},
+  page: number = 1,
+  pageSize: number = 10
+): Promise<InventorySearchResponse> {
+  const params = new URLSearchParams({
+    page: page.toString(),
+    pageSize: pageSize.toString(),
+  });
+
+  const accessToken = getAccessToken();
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+  };
+
+  if (accessToken) {
+    headers['Authorization'] = `Bearer ${accessToken}`;
+  }
+
+  const body = {
+    archived: filters.archived ?? false,
+    ...filters,
+  };
+
+  const response = await fetch(`${INVENTORY_API_BASE}/inventories/search?${params}`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch inventories: ${response.status}`);
+  }
+
+  // Read pagination from response headers
+  const totalCount = parseInt(response.headers.get('x-total-count') || '0', 10);
+  const totalPages = parseInt(response.headers.get('x-total-pages') || '1', 10);
+  const currentPage = parseInt(response.headers.get('x-page') || page.toString(), 10);
+  const currentPageSize = parseInt(response.headers.get('x-page-size') || pageSize.toString(), 10);
+
+  const result = await response.json();
+
+  const items: InventoryItem[] = Array.isArray(result) 
+    ? result 
+    : (result?.data || result?.result || result?.inventories || []);
+
+  return {
+    data: items.map((item: any) => ({
+      // Preserve ALL original JAD API fields for inventory update payload
+      ...item,
+      // Add normalized/fallback fields for UI display
+      id: item.id || item._id,
+      name: item.name || item.displayName || 'Unknown',
+      code: item.code || item.inventoryCode || item.id?.slice(0, 8).toUpperCase(),
+      address: item.address || item.location || item.locationAddress,
+      size: item.size || item.resolution || '1920x1080',
+      resolution: item.resolution || item.size,
+      publisherId: item.publisherId || item.publisher?.id || `pub-${(item.id || '').slice(0, 8)}`,
+      publisherName: item.publisherName || item.publisher?.name || 'Media Owner',
+      latitude: item.latitude || item.lat || item.location?.lat || 3.1488,
+      longitude: item.longitude || item.lng || item.lon || item.location?.lng || 101.713,
+      venueType: item.venueType || item.venue?.type || 'SHOPPING_MALL',
+      timezone: item.timezone || item.timezoneId || 'Asia/Kuala_Lumpur',
+      countryIso2: item.countryIso2 || item.country?.iso2 || 'MY',
+      countryIso3: item.countryIso3 || item.country?.iso3 || 'MYS',
+      thumbnail: item.thumbnail || item.thumbnailUrl || item.imageUrl,
+      tags: item.tags || [],
+      operatingHours: item.operatingHours || '24 Hours',
+      type: item.type || 'screen',
+      status: item.status,
+      planning: item.planning || generateFakePlanningData(),
+    })),
+    pagination: {
+      page: currentPage,
+      pageSize: currentPageSize,
+      totalCount,
+      totalPages,
+    },
+  };
+}
+
+export interface VenueType {
+  taxonomyId: string;
+  name: string;
+  path: string;
+  parentId?: string;
+  parentName?: string;
+}
+
+export async function fetchVenueTypes(): Promise<VenueType[]> {
+  const accessToken = getAccessToken();
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+  };
+
+  if (accessToken) {
+    headers['Authorization'] = `Bearer ${accessToken}`;
+  }
+
+  try {
+    const response = await fetch(`${INVENTORY_API_BASE}/venue-taxonomies`, {
+      method: 'GET',
+      headers,
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch venue types: ${response.status}`);
+    }
+
+    const result = await response.json();
+    const items = Array.isArray(result) ? result : (result?.data || result?.types || result?.result || []);
+    return items.map((item: any) => ({
+      taxonomyId: item.taxonomyId || item.id || item._id,
+      name: item.name || item.label || item.typeName,
+      path: item.path || item.typePath,
+      parentId: item.parentId,
+      parentName: item.parentName,
+    }));
+  } catch (error) {
+    console.error('Failed to fetch venue types from API:', error);
+    return [];
+  }
+}
+
+async function inventoryGet<T>(path: string): Promise<T[]> {
+  const accessToken = getAccessToken();
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+  if (accessToken) headers['Authorization'] = `Bearer ${accessToken}`;
+  try {
+    const response = await fetch(`${INVENTORY_API_BASE}${path}`, { method: 'GET', headers });
+    if (!response.ok) throw new Error(`${response.status}`);
+    const result = await response.json();
+    return Array.isArray(result) ? result : (result?.data || result?.result || []);
+  } catch (error) {
+    console.error(`Failed to fetch ${path}:`, error);
+    return [];
+  }
+}
+
+export async function fetchPanelResolutions(): Promise<string[]> {
+  const items = await inventoryGet<any>('/panel-resolutions');
+  return items.map((item: any) => {
+    if (typeof item === 'string') return item;
+    if (item.width && item.height) return `${item.width}x${item.height}`;
+    if (item.resolution) return item.resolution;
+    if (item.value) return item.value;
+    return String(item);
+  }).filter(Boolean);
+}
+
+export async function fetchPriceDurations(): Promise<number[]> {
+  const items = await inventoryGet<any>('/price-durations');
+  return items.map((item: any) => {
+    if (typeof item === 'number') return item;
+    if (item.duration != null) return Number(item.duration);
+    if (item.seconds != null) return Number(item.seconds);
+    if (item.value != null) return Number(item.value);
+    return Number(item);
+  }).filter((n: number) => !isNaN(n) && n > 0);
+}
+
+export interface Company {
+  id: string;
+  name: string;
+  domain: string;
+  status: string;
+  is_active: boolean;
+  seat_id: number;
+  company_type?: {
+    id: string;
+    name: string;
+    code: string;
+    description: string;
+    is_supplier_side: boolean;
+    is_demand_side: boolean;
+  };
+  currency_code: string;
+  supported_currencies: string[];
+  timezone: string;
+}
+
+const AUTH_API_BASE = `${API_CONFIG.auth}/api/v1`;
+
+export async function fetchCompanies(): Promise<Company[]> {
+  const accessToken = getAccessToken();
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+  };
+
+  if (accessToken) {
+    headers['Authorization'] = `Bearer ${accessToken}`;
+  }
+
+  try {
+    const response = await fetch(`${AUTH_API_BASE}/companies?is_ssp=true`, {
+      method: 'GET',
+      headers,
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch companies: ${response.status}`);
+    }
+
+    const result = await response.json();
+    return result?.data || [];
+  } catch (error) {
+    console.error('Failed to fetch companies from API:', error);
+    return [];
+  }
+}
+
+export interface InventoryTypeItem {
+  path: string;
+  name: string;
+  description?: string;
+}
+
+export async function fetchInventoryTypes(parentPath?: string): Promise<InventoryTypeItem[]> {
+  const accessToken = getAccessToken();
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+  if (accessToken) headers['Authorization'] = `Bearer ${accessToken}`;
+  
+  try {
+    const url = parentPath 
+      ? `${INVENTORY_API_BASE}/inventory-types?parent=${parentPath}`
+      : `${INVENTORY_API_BASE}/inventory-types`;
+    const response = await fetch(url, { method: 'GET', headers });
+    if (!response.ok) throw new Error(`Failed to fetch inventory types: ${response.status}`);
+    const result = await response.json();
+    return Array.isArray(result) ? result : (result?.data || []);
+  } catch (error) {
+    console.error('Failed to fetch inventory types:', error);
+    return [];
+  }
+}
+
+export interface InventoryDisplayFormat {
+  id: number;
+  name: string;
+  inventoryTypePath: string;
+}
+
+export async function fetchInventoryDisplayFormats(): Promise<InventoryDisplayFormat[]> {
+  const accessToken = getAccessToken();
+  const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+  if (accessToken) headers['Authorization'] = `Bearer ${accessToken}`;
+  
+  try {
+    const response = await fetch(`${INVENTORY_API_BASE}/inventory-display-formats`, { method: 'GET', headers });
+    if (!response.ok) throw new Error(`Failed to fetch inventory display formats: ${response.status}`);
+    const result = await response.json();
+    return Array.isArray(result) ? result : (result?.data || []);
+  } catch (error) {
+    console.error('Failed to fetch inventory display formats:', error);
+    return [];
+  }
+}
+
+export const InventoryAPI = {
+  search: searchInventories,
+  fetchVenueTypes,
+  fetchCompanies,
+  fetchInventoryTypes,
+  fetchInventoryDisplayFormats,
+};