adserver-dashboard 1.0.0

package/client/src/lib/deal-helpers.ts

@@ -0,0 +1,220 @@
+// Deal Type Helper Utilities
+// Provides utilities for working with deal types, modes, auction types, and cost structures
+
+// Re-export all types from the shared schema
+export {
+  dealModeEnum,
+  dealTypeEnum,
+  auctionTypeEnum,
+  type AuctionType,
+  transactionTypeEnum,
+  costTypeEnum,
+  dealStatusEnum,
+  dealSchema,
+  insertDealSchema,
+  type Deal,
+  type InsertDeal,
+  lineItemStatusEnum,
+  pricingModelEnum,
+  lineItemSchema,
+  insertLineItemSchema,
+  type LineItem,
+  type InsertLineItem,
+  creativeTypeEnum,
+  creativeStatusEnum,
+  creativeSchema,
+  insertCreativeSchema,
+  type Creative,
+  type InsertCreative,
+  billboardTypeEnum,
+  billboardEnvironmentEnum,
+  billboardOrientationEnum,
+  billboardSchema,
+  insertBillboardSchema,
+  type Billboard,
+  type InsertBillboard,
+  billboardPanelSchema,
+  insertBillboardPanelSchema,
+  type BillboardPanel,
+  type InsertBillboardPanel,
+  billboardExposureSchema,
+  insertBillboardExposureSchema,
+  type BillboardExposure,
+  type InsertBillboardExposure,
+  billboardExternalIdSchema,
+  insertBillboardExternalIdSchema,
+  type BillboardExternalId,
+  type InsertBillboardExternalId,
+  mediaOwnerSchema,
+  insertMediaOwnerSchema,
+  type MediaOwner,
+  type InsertMediaOwner,
+  dspSchema,
+  insertDspSchema,
+  type DSP,
+  type InsertDSP,
+  sspSchema,
+  insertSspSchema,
+  type SSP,
+  type InsertSSP,
+  userSchema,
+  insertUserSchema,
+  type User,
+  type InsertUser,
+  bulkSyncRequestSchema,
+  type BulkSyncRequest,
+} from "../../../shared/schema";
+
+/**
+ * Determine the default auction type based on deal type
+ *
+ * Mapping:
+ * - GUARANTEED -> 3 (Fixed Price)
+ * - PREFERRED_DEAL -> 3 (Fixed Price)
+ * - PRIVATE_AUCTION -> 1 (First Price)
+ * - EVERGREEN_PMP -> 2 (Second Price)
+ * - DIRECT -> 3 (Fixed Price) - default for direct deals
+ *
+ * @param dealType The deal type
+ * @returns The auction type number (1, 2, or 3)
+ */
+export function getDefaultAuctionType(dealType: string): number {
+  switch (dealType.toUpperCase()) {
+    case "GUARANTEED":
+      return 3; // Fixed Price
+    case "PREFERRED_DEAL":
+      return 3; // Fixed Price
+    case "PRIVATE_AUCTION":
+      return 1; // First Price
+    case "EVERGREEN_PMP":
+      return 2; // Second Price
+    case "DIRECT":
+      return 3; // Fixed Price
+    default:
+      return 3; // Default to Fixed Price
+  }
+}
+
+/**
+ * Get the deal ID prefix based on deal mode and type
+ *
+ * Mapping:
+ * - DIRECT mode -> "DIR"
+ * - PROGRAMMATIC + GUARANTEED -> "GD"
+ * - PROGRAMMATIC + PRIVATE_AUCTION -> "PA"
+ * - PROGRAMMATIC + EVERGREEN_PMP -> "EG"
+ * - PROGRAMMATIC + PREFERRED_DEAL -> "PD"
+ *
+ * @param mode The deal mode (DIRECT or PROGRAMMATIC)
+ * @param dealType The deal type
+ * @returns The deal ID prefix string
+ */
+export function getDealPrefix(mode: string, dealType: string): string {
+  const upperMode = mode.toUpperCase();
+  const upperDealType = dealType.toUpperCase();
+
+  if (upperMode === "DIRECT") {
+    return "DIR";
+  }
+
+  if (upperMode === "PROGRAMMATIC") {
+    switch (upperDealType) {
+      case "GUARANTEED":
+        return "GD";
+      case "PRIVATE_AUCTION":
+        return "PA";
+      case "EVERGREEN_PMP":
+        return "EG";
+      case "PREFERRED_DEAL":
+        return "PD";
+      default:
+        return "PD"; // Default for programmatic
+    }
+  }
+
+  return "DIR"; // Default fallback
+}
+
+/**
+ * Validate cost type restrictions based on deal type
+ *
+ * Restrictions:
+ * - GUARANTEED only allows CPM
+ * - All other deal types allow CPM, CPD, CPS
+ *
+ * @param dealType The deal type
+ * @param costType The cost type (CPM, CPD, CPS)
+ * @returns true if the cost type is valid for this deal type
+ */
+export function isValidCostType(dealType: string, costType: string): boolean {
+  const upperDealType = dealType.toUpperCase();
+  const upperCostType = costType.toUpperCase();
+
+  // Validate that costType is a valid option
+  const validCostTypes = ["CPM", "CPD", "CPS"];
+  if (!validCostTypes.includes(upperCostType)) {
+    return false;
+  }
+
+  // GUARANTEED deals only allow CPM
+  if (upperDealType === "GUARANTEED") {
+    return upperCostType === "CPM";
+  }
+
+  // All other deal types allow CPM, CPD, CPS
+  return validCostTypes.includes(upperCostType);
+}
+
+/**
+ * Check if a deal mode supports targeting features
+ *
+ * Support levels:
+ * - DIRECT -> supports full targeting + deliveryTargeting + planning
+ * - PROGRAMMATIC -> supports basic targeting only
+ *
+ * @param mode The deal mode
+ * @returns true if the mode supports targeting features
+ */
+export function isDealModeSupportsTargeting(mode: string): boolean {
+  const upperMode = mode.toUpperCase();
+  return upperMode === "DIRECT" || upperMode === "PROGRAMMATIC";
+}
+
+/**
+ * Check if a deal mode supports planning data
+ *
+ * Support:
+ * - DIRECT -> true
+ * - PROGRAMMATIC -> false
+ *
+ * @param mode The deal mode
+ * @returns true if the mode supports planning data
+ */
+export function isDealModeSupportsPlanning(mode: string): boolean {
+  const upperMode = mode.toUpperCase();
+  return upperMode === "DIRECT";
+}
+
+/**
+ * Get a human-readable label for an auction type
+ *
+ * Mapping:
+ * - 1 -> "First Price"
+ * - 2 -> "Second Price"
+ * - 3 -> "Fixed Price"
+ *
+ * @param auctionType The auction type number
+ * @returns The human-readable label
+ */
+export function getAuctionTypeLabel(auctionType: number): string {
+  switch (auctionType) {
+    case 1:
+      return "First Price";
+    case 2:
+      return "Second Price";
+    case 3:
+      return "Fixed Price";
+    default:
+      return "Unknown";
+  }
+}

package/client/src/lib/dsp-buyer-api.ts

@@ -0,0 +1,196 @@
+import { directCampaignAuth } from "./auth-service";
+
+const SSP_API_BASE_URL = import.meta.env.VITE_SSP_API_URL || "https://mw-api-gtwy-pprd.movingwalls.com/ssp-project/api/v2/rest";
+
+export interface DspBuyer {
+  createdDate: string;
+  lastModifiedDate: string;
+  id: string;
+  dspId: string;
+  dsp: string | null;
+  name: string;
+  ip: string;
+  country: string;
+  buyerAccountId: string | null;
+  seatId: string;
+  seatName: string;
+  emailAddress: string;
+}
+
+export interface DspBuyerListParams {
+  page?: number;
+  size?: number;
+  sort?: string;
+  searchText?: string;
+  name?: string;
+  dspId?: string;
+}
+
+export interface CreateDspBuyerPayload {
+  name: string;
+  dspId: string | null;
+  seatId: string;
+  seatName: string;
+  buyerAccountId: string;
+  emailAddress: string;
+  country: string;
+}
+
+async function sspRequest<T>(url: string, method: string = "GET", body?: any): Promise<T> {
+  const options: RequestInit = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "Accept-language": "en",
+    },
+  };
+  if (body) {
+    options.body = JSON.stringify(body);
+  }
+  const response = await directCampaignAuth.fetch(url, options);
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`API Error ${response.status}: ${errorText}`);
+  }
+  const text = await response.text();
+  if (!text) return {} as T;
+  return JSON.parse(text);
+}
+
+export async function listDspBuyers(params: DspBuyerListParams = {}): Promise<DspBuyer[]> {
+  const searchParams = new URLSearchParams();
+  searchParams.set("page", String(params.page ?? 0));
+  searchParams.set("size", String(params.size ?? 10));
+  searchParams.set("sort", params.sort ?? "lastModifiedDate,desc");
+  if (params.searchText) {
+    searchParams.set("searchText", params.searchText);
+  }
+  if (params.name) {
+    searchParams.set("name", params.name);
+  }
+  const url = `${SSP_API_BASE_URL}/dsp-buyer?${searchParams.toString()}`;
+  const result = await sspRequest<any>(url);
+  if (Array.isArray(result)) return result;
+  if (result && Array.isArray(result.content)) return result.content;
+  return [];
+}
+
+export async function getDspBuyer(buyerId: string): Promise<DspBuyer> {
+  const url = `${SSP_API_BASE_URL}/dsp-buyer/${buyerId}`;
+  return sspRequest<DspBuyer>(url);
+}
+
+export async function createDspBuyer(payload: CreateDspBuyerPayload): Promise<{ message: string }> {
+  const url = `${SSP_API_BASE_URL}/dsp-buyer/create`;
+  return sspRequest<{ message: string }>(url, "POST", payload);
+}
+
+export async function updateDspBuyer(buyerId: string, payload: DspBuyer): Promise<{ message: string }> {
+  const url = `${SSP_API_BASE_URL}/dsp-buyer/${buyerId}/update`;
+  return sspRequest<{ message: string }>(url, "PUT", payload);
+}
+
+export async function deleteDspBuyer(buyerId: string): Promise<{ message: string }> {
+  const url = `${SSP_API_BASE_URL}/dsp-buyer/${buyerId}`;
+  return sspRequest<{ message: string }>(url, "DELETE");
+}
+
+export interface Dsp {
+  id: string;
+  name: string;
+  emailAddress: string;
+  ip: string;
+  country: string;
+  url: string;
+  billingName: string;
+  billingAddress: string;
+  parameters: any;
+  authentication: {
+    type: string;
+    url: string;
+    credentials: {
+      username: string;
+      password: string;
+      authId: string;
+      authSecret: string;
+      token: string;
+    };
+    httpMethod: string;
+    expiryTime: string | null;
+  } | null;
+  accessTokenKey: string;
+  accessTokenSecret: string;
+  clientKey: string | null;
+  clientSecret: string | null;
+  dealType: string[];
+  creativeType: string[];
+  transactionTypes: Record<string, string[]>;
+  inventoryAccess: { id: string; name: string; iso2: string; iso3: string }[];
+  currencyAccess: string[];
+  rateType: string | null;
+  disclaimer: string | null;
+  creativeOnlineApproval: boolean;
+  dealAutoApproval: boolean;
+  dealReopen: boolean;
+  customDealId: boolean;
+  report: {
+    type: string;
+    email: string;
+    fields: string[] | null;
+    schedule: string | null;
+    timezone: string;
+    status: boolean;
+  } | null;
+  lineItemsPerOrder: number;
+  enableAspectRatio: boolean;
+  displayAspectRatio: string | null;
+  createdDate: string;
+  createdBy: string;
+  lastModifiedBy: string;
+  lastModifiedDate: string;
+}
+
+export interface DspListParams {
+  page?: number;
+  size?: number;
+  sort?: string;
+  searchText?: string;
+}
+
+export interface DspDropdownItem {
+  id: string;
+  name: string;
+}
+
+export async function getDsp(dspId: string): Promise<Dsp> {
+  const url = `${SSP_API_BASE_URL}/dsp/${dspId}`;
+  return sspRequest<Dsp>(url);
+}
+
+export async function listDsps(params: DspListParams = {}): Promise<Dsp[]> {
+  const searchParams = new URLSearchParams();
+  searchParams.set("page", String(params.page ?? 0));
+  searchParams.set("size", String(params.size ?? 10));
+  searchParams.set("sort", params.sort ?? "lastModifiedDate,desc");
+  if (params.searchText) {
+    searchParams.set("searchText", params.searchText);
+  }
+  const url = `${SSP_API_BASE_URL}/dsp?${searchParams.toString()}`;
+  return sspRequest<Dsp[]>(url);
+}
+
+export async function getDspDropdownList(): Promise<DspDropdownItem[]> {
+  const MASTER_API_BASE_URL = import.meta.env.VITE_SSP_API_URL?.replace('/ssp-project/api/v2/rest', '/master/api/v2/rest') || "https://mw-api-gtwy-pprd.movingwalls.com/master/api/v2/rest";
+  const url = `${MASTER_API_BASE_URL}/dropdown?module=DSP`;
+  const result = await sspRequest<any>(url);
+  let items: any[] = [];
+  if (Array.isArray(result)) items = result;
+  else if (result && Array.isArray(result.content)) items = result.content;
+  else if (result && Array.isArray(result.data)) items = result.data;
+
+  return items.map((item: any) => ({
+    id: item.id || item.code || item.name || item.value || "",
+    name: item.value || item.label || item.description || item.name || item.id || "",
+  }));
+}

package/client/src/lib/geo-import-api.ts

@@ -0,0 +1,151 @@
+import { API_CONFIG } from './api-config';
+import { getAccessToken } from './oauth-service';
+import type {
+  GeoImportFilesParams,
+  GeoImportFilesResponse,
+  GeoImportLocationsResponse,
+  UploadGeoCoordinatesResponse,
+  GeoImportDeleteResponse,
+} from '@/types/geofencing';
+
+class GeoImportApiClient {
+  private baseUrl: string;
+
+  constructor() {
+    this.baseUrl = API_CONFIG.directCampaign;
+  }
+
+  private getHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+
+    const accessToken = getAccessToken();
+    if (accessToken) {
+      headers['Authorization'] = `Bearer ${accessToken}`;
+    }
+
+    return headers;
+  }
+
+  private getFormHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {};
+
+    const accessToken = getAccessToken();
+    if (accessToken) {
+      headers['Authorization'] = `Bearer ${accessToken}`;
+    }
+
+    return headers;
+  }
+
+  async getGeoImportFiles(params: GeoImportFilesParams = {}): Promise<GeoImportFilesResponse> {
+    const queryParams = new URLSearchParams();
+    if (params.page) queryParams.append('page', String(params.page));
+    if (params.limit) queryParams.append('limit', String(params.limit));
+    if (params.countryName) queryParams.append('countryName', params.countryName);
+    if (params.search) queryParams.append('search', params.search);
+
+    const queryString = queryParams.toString();
+    const url = `${this.baseUrl}/api/v1/geo-import/files${queryString ? `?${queryString}` : ''}`;
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: this.getHeaders(),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: 'Failed to fetch files' }));
+      throw new Error(error.message || `HTTP ${response.status}`);
+    }
+
+    return response.json();
+  }
+
+  async uploadGeoCoordinates(file: File, countryName: string): Promise<UploadGeoCoordinatesResponse> {
+    const formData = new FormData();
+    formData.append('file', file);
+    formData.append('countryName', countryName);
+
+    const url = `${this.baseUrl}/api/v1/geo-import/upload`;
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: this.getFormHeaders(),
+      body: formData,
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: 'Failed to upload file' }));
+      throw new Error(error.message || `HTTP ${response.status}`);
+    }
+
+    return response.json();
+  }
+
+  async deleteGeoImportFile(fileId: string): Promise<GeoImportDeleteResponse> {
+    const url = `${this.baseUrl}/api/v1/geo-import/files/${fileId}`;
+
+    const response = await fetch(url, {
+      method: 'DELETE',
+      headers: this.getHeaders(),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: 'Failed to delete file' }));
+      throw new Error(error.message || `HTTP ${response.status}`);
+    }
+
+    return response.json();
+  }
+
+  async downloadGeoImportFile(fileId: string): Promise<Blob> {
+    const url = `${this.baseUrl}/api/v1/geo-import/files/${fileId}/download`;
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: this.getFormHeaders(),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: 'Failed to download file' }));
+      throw new Error(error.message || `HTTP ${response.status}`);
+    }
+
+    return response.blob();
+  }
+
+  async downloadTemplate(): Promise<Blob> {
+    const url = `${this.baseUrl}/api/v1/geo-import/template`;
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: this.getFormHeaders(),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: 'Failed to download template' }));
+      throw new Error(error.message || `HTTP ${response.status}`);
+    }
+
+    return response.blob();
+  }
+
+  async getGeoImportLocations(fileId: string): Promise<GeoImportLocationsResponse> {
+    const url = `${this.baseUrl}/api/v1/geo-import/files/${fileId}/locations`;
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: this.getHeaders(),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: 'Failed to fetch locations' }));
+      throw new Error(error.message || `HTTP ${response.status}`);
+    }
+
+    return response.json();
+  }
+}
+
+export const geoImportApi = new GeoImportApiClient();