prebid.js 9.52.0 → 9.53.2

package/modules/fanAdapter.js

@@ -1,176 +1,370 @@
-import * as utils from '../src/utils.js';
-import { ajax } from '../src/ajax.js';
-import { BANNER, NATIVE } from '../src/mediaTypes.js';
+import { ortbConverter } from '../libraries/ortbConverter/converter.js';
 import { registerBidder } from '../src/adapters/bidderFactory.js';
-
-/**
- * @typedef {import('../src/adapters/bidderFactory.js').BidderRequest} BidderRequest
- * @typedef {import('../src/adapters/bidderFactory.js').BidRequest} BidRequest
- * @typedef {import('../src/adapters/bidderFactory.js').Bid} Bid
- * @typedef {import('../src/adapters/bidderFactory.js').ServerResponse} ServerResponse
- */
+import { BANNER, VIDEO } from '../src/mediaTypes.js';
+import { deepAccess, deepSetValue, logInfo, logWarn, logError, triggerPixel } from '../src/utils.js';
+import { getStorageManager } from '../src/storageManager.js';
+import { Renderer } from '../src/Renderer.js';
+import { getGptSlotInfoForAdUnitCode } from '../libraries/gptUtils/gptUtils.js';
 
 const BIDDER_CODE = 'freedomadnetwork';
-const BASE_URL = 'https://srv.freedomadnetwork.com';
+const BIDDER_VERSION = '0.2.0';
+const NETWORK_ENDPOINTS = {
+  'fan': 'https://srv.freedomadnetwork.com/ortb',
+  'armanet': 'https://srv.armanet.us/ortb',
+  'test': 'http://localhost:8001/ortb',
+};
 
-/**
- * Build OpenRTB request from bidRequest and bidderRequest
- *
- * @param {BidRequest} bid
- * @param {BidderRequest} bidderRequest
- * @returns {Request}
- */
-function buildBidRequest(bid, bidderRequest) {
-  const payload = {
-    id: bid.bidId,
-    tmax: bidderRequest.timeout,
-    placements: [bid.params.placementId],
-    at: 1,
-    user: {}
-  }
+const DEFAULT_ENDPOINT = NETWORK_ENDPOINTS['fan'];
+const DEFAULT_CURRENCY = 'USD';
+const DEFAULT_TTL = 300;
 
-  const gdprConsent = utils.deepAccess(bidderRequest, 'gdprConsent');
-  if (!!gdprConsent && gdprConsent.gdprApplies) {
-    payload.user.gdpr = 1;
-    payload.user.consent = gdprConsent.consentString;
-  }
+export const storage = getStorageManager({bidderCode: BIDDER_CODE});
 
-  const uspConsent = utils.deepAccess(bidderRequest, 'uspConsent');
-  if (uspConsent) {
-    payload.user.usp = uspConsent;
-  }
+const converter = ortbConverter({
+  context: {
+    netRevenue: true,
+    ttl: DEFAULT_TTL,
+    currency: DEFAULT_CURRENCY
+  },
+
+  imp(buildImp, bidRequest, context) {
+    const imp = buildImp(bidRequest, context);
+
+    // Add custom fields to impression
+    if (bidRequest.params.placementId) {
+      imp.tagid = bidRequest.params.placementId;
+    }
+
+    // Add floor price
+    if (bidRequest.params.bidFloor) {
+      imp.bidfloor = parseFloat(bidRequest.params.bidFloor);
+      imp.bidfloorcur = bidRequest.params.bidFloorCur || DEFAULT_CURRENCY;
+    }
+
+    // Add custom extensions
+    deepSetValue(imp, 'ext.prebid.storedrequest.id', bidRequest.params.placementId);
+    deepSetValue(imp, 'ext.bidder', {
+      network: bidRequest.params.network || 'fan',
+      placementId: bidRequest.params.placementId
+    });
+
+    return imp;
+  },
+
+  request(buildRequest, imps, bidderRequest, context) {
+    const request = buildRequest(imps, bidderRequest, context);
+
+    // First price auction
+    request.at = 1;
+    request.cur = [DEFAULT_CURRENCY];
+
+    // Add source information
+    deepSetValue(request, 'source.tid', bidderRequest.auctionId);
+
+    // Add custom extensions
+    deepSetValue(request, 'ext.prebid.channel', BIDDER_CODE);
+    deepSetValue(request, 'ext.prebid.version', BIDDER_VERSION);
+
+    // Add user extensions
+    const firstBid = imps[0];
+    const pbUser = firstBid.userId || {};
+    request.user = request.user || {};
+    request.user.ext = request.user.ext || {};
 
-  return {
-    method: 'POST',
-    url: BASE_URL + '/pb/req',
-    data: JSON.stringify(payload),
-    options: {
-      contentType: 'application/json',
-      withCredentials: false,
-      customHeaders: {
-        'Accept-Language': 'en;q=10',
-      },
-    },
-    originalBidRequest: bid
+    if (pbUser.tdid) {
+      request.user.ext.tdid = pbUser.tdid;
+    }
+
+    if (window.geck) {
+      request.user.ext.adi = window.geck;
+    }
+
+    if (pbUser.pubcid) {
+      request.user.ext.pubcid = pbUser.pubcid;
+    }
+
+    if (pbUser.id5id?.uid) {
+      request.user.ext.id5id = pbUser.id5id.uid;
+    }
+
+    if (pbUser.lipb?.lipbid) {
+      request.user.ext.lipbid = pbUser.lipb.lipbid;
+    }
+
+    return request;
+  },
+
+  bidResponse(buildBidResponse, bid, context) {
+    const { bidRequest } = context;
+    const bidResponse = buildBidResponse(bid, context);
+
+    // Add custom bid response fields
+    bidResponse.meta = bidResponse.meta || {};
+    bidResponse.meta.networkName = BIDDER_CODE;
+    bidResponse.meta.advertiserDomains = bid.adomain || [];
+
+    if (bid.ext && bid.ext.libertas) {
+      bidResponse.meta.libertas = bid.ext.libertas;
+    }
+
+    // Add tracking URLs
+    if (bid.nurl) {
+      bidResponse.nurl = bid.nurl;
+    }
+
+    // Handle different ad formats
+    if (bidResponse.mediaType === BANNER) {
+      bidResponse.ad = bid.adm;
+      bidResponse.width = bid.w;
+      bidResponse.height = bid.h;
+    } else if (bidResponse.mediaType === VIDEO) {
+      bidResponse.vastXml = bid.adm;
+      bidResponse.width = bid.w;
+      bidResponse.height = bid.h;
+    }
+
+    // Add renderer if needed for outstream video
+    if (bidResponse.mediaType === VIDEO && bid.ext.libertas.ovp) {
+      bidResponse.width = bid.w;
+      bidResponse.height = bid.h;
+      bidResponse.renderer = createRenderer(bidRequest, bid.ext.libertas.vp);
+    }
+
+    return bidResponse;
   }
-}
+});
 
 export const spec = {
   code: BIDDER_CODE,
-  isBidRequestValid: function(bid) {
-    if (!bid) {
-      utils.logWarn(BIDDER_CODE, 'Invalid bid', bid);
+  supportedMediaTypes: [BANNER, VIDEO],
+
+  isBidRequestValid(bid) {
+    // Validate minimum required parameters
+    if (!bid.params) {
+      logError(`${BIDDER_CODE}: bid.params is required`);
 
       return false;
     }
 
-    if (!bid.params) {
-      utils.logWarn(BIDDER_CODE, 'bid.params is required');
+    // Validate placement ID
+    if (!bid.params.placementId) {
+      logError(`${BIDDER_CODE}: placementId is required`);
 
       return false;
     }
 
-    if (!bid.params.placementId) {
-      utils.logWarn(BIDDER_CODE, 'bid.params.placementId is required');
+    // Validate network parameter
+    if (bid.params.network && !NETWORK_ENDPOINTS[bid.params.network]) {
+      logError(`${BIDDER_CODE}: Invalid network: ${bid.params.network}`);
 
       return false;
     }
 
-    var banner = utils.deepAccess(bid, 'mediaTypes.banner');
-    if (banner === undefined) {
+    // Validate media types
+    if (!bid.mediaTypes || (!bid.mediaTypes.banner && !bid.mediaTypes.video)) {
+      logError(`${BIDDER_CODE}: Only banner and video mediaTypes are supported`);
+
       return false;
     }
 
+    // Validate video parameters if video mediaType is present
+    if (bid.mediaTypes.video) {
+      const video = bid.mediaTypes.video;
+      if (!video.mimes || !Array.isArray(video.mimes) || video.mimes.length === 0) {
+        logError(`${BIDDER_CODE}: video.mimes is required for video ads`);
+
+        return false;
+      }
+
+      if (!video.playerSize || !Array.isArray(video.playerSize)) {
+        logError(`${BIDDER_CODE}: video.playerSize is required for video ads`);
+
+        return false;
+      }
+    }
+
     return true;
   },
 
-  buildRequests: function(validBidRequests, bidderRequest) {
-    return validBidRequests.map(bid => buildBidRequest(bid, bidderRequest));
+  /**
+   * Make server requests from the list of BidRequests
+   */
+  buildRequests(validBidRequests, bidderRequest) {
+    const requestsByNetwork = validBidRequests.reduce((acc, bid) => {
+      const network = bid.params.network || 'fan';
+      if (!acc[network]) {
+        acc[network] = [];
+      }
+      acc[network].push(bid);
+
+      return acc;
+    }, {});
+
+    return Object.entries(requestsByNetwork).map(([network, bids]) => {
+      const data = converter.toORTB({
+        bidRequests: bids,
+        bidderRequest,
+        context: { network }
+      });
+
+      return {
+        method: 'POST',
+        url: NETWORK_ENDPOINTS[network] || DEFAULT_ENDPOINT,
+        data,
+        options: {
+          contentType: 'application/json',
+          withCredentials: false
+        },
+        bids
+      };
+    });
   },
 
   /**
-   * Unpack the response from the server into a list of bids.
-   *
-   * @param {ServerResponse} serverResponse A successful response from the server.
-   * @return {Bid[]} An array of bids which were nested inside the server.
+   * Unpack the response from the server into a list of bids
    */
-  interpretResponse: function (serverResponse, bidRequest) {
-    const serverBody = serverResponse.body;
-    let bidResponses = [];
-
-    if (!serverBody) {
-      return bidResponses;
-    }
-
-    serverBody.forEach((response) => {
-      const bidResponse = {
-        requestId: response.id,
-        bidid: response.bidid,
-        impid: response.impid,
-        userId: response.userId,
-        cpm: response.cpm,
-        currency: response.currency,
-        width: response.width,
-        height: response.height,
-        ad: response.payload,
-        ttl: response.ttl,
-        creativeId: response.crid,
-        netRevenue: response.netRevenue,
-        trackers: response.trackers,
-        meta: {
-          mediaType: response.mediaType,
-          advertiserDomains: response.domains,
-        }
-      };
+  interpretResponse(serverResponse, bidRequest) {
+    if (!serverResponse.body) {
+      return [];
+    }
 
-      bidResponses.push(bidResponse);
+    const response = converter.fromORTB({
+      response: serverResponse.body,
+      request: bidRequest.data,
     });
 
-    return bidResponses;
+    return response.bids || [];
   },
 
   /**
-   * Register bidder specific code, which will execute if a bid from this bidder won the auction
-   *
-   * @param {Bid} bid The bid that won the auction
+   * Handle bidder errors
    */
-  onBidWon: function (bid) {
-    if (!bid) {
-      return;
-    }
+  onBidderError: function(error) {
+    logError(`${BIDDER_CODE} bidder error`, error);
+  },
 
-    const payload = {
-      id: bid.bidid,
-      impid: bid.impid,
-      t: bid.cpm,
-      u: bid.userId,
+  /**
+   * Register user sync pixels
+   */
+  getUserSyncs(syncOptions, serverResponses, gdprConsent, uspConsent, gppConsent) {
+    if (!syncOptions.iframeEnabled && !syncOptions.pixelEnabled) {
+      return [];
     }
 
-    ajax(BASE_URL + '/pb/imp', null, JSON.stringify(payload), {
-      method: 'POST',
-      customHeaders: {
-        'Accept-Language': 'en;q=10',
-      },
+    const syncs = [];
+    const seenUrls = new Set();
+
+    serverResponses.forEach(response => {
+      const userSync = deepAccess(response.body, 'ext.sync');
+      if (!userSync) {
+        return;
+      }
+
+      if (syncOptions.iframeEnabled && userSync.iframe) {
+        userSync.iframe.forEach(sync => {
+          const url = buildSyncUrl(sync.url, gdprConsent, uspConsent, gppConsent);
+          if (!seenUrls.has(url)) {
+            seenUrls.add(url);
+            syncs.push({
+              type: 'iframe',
+              url
+            });
+          }
+        });
+      }
+
+      if (syncOptions.pixelEnabled && userSync.image) {
+        userSync.image.forEach(sync => {
+          const url = buildSyncUrl(sync.url, gdprConsent, uspConsent, gppConsent);
+          if (!seenUrls.has(url)) {
+            seenUrls.add(url);
+            syncs.push({
+              type: 'image',
+              url
+            });
+          }
+        });
+      }
     });
 
-    if (bid.trackers && bid.trackers.length > 0) {
-      for (var i = 0; i < bid.trackers.length; i++) {
-        if (bid.trackers[i].type == 0) {
-          utils.triggerPixel(bid.trackers[i].url);
+    return syncs;
+  },
+
+  /**
+   * Handle bid won event
+   */
+  onBidWon(bid) {
+    logInfo(`${BIDDER_CODE}: Bid won`, bid);
+
+    if (bid.nurl) {
+      triggerPixel(bid.nurl);
+    }
+
+    if (bid.meta.libertas.pxl && bid.meta.libertas.pxl.length > 0) {
+      for (var i = 0; i < bid.meta.libertas.pxl.length; i++) {
+        if (bid.meta.libertas.pxl[i].type == 0) {
+          triggerPixel(bid.meta.libertas.pxl[i].url);
         }
       }
     }
   },
-  onSetTargeting: function(bid) {},
-  onBidderError: function(error) {
-    utils.logError(`${BIDDER_CODE} bidder error`, error);
-  },
-  getUserSyncs: function(syncOptions, serverResponses, gdprConsent, uspConsent) {
-    const syncs = [];
-    return syncs;
-  },
-  onTimeout: function(timeoutData) {},
-  supportedMediaTypes: [BANNER, NATIVE]
+};
+
+/**
+ * Build sync URL with privacy parameters
+ */
+function buildSyncUrl(baseUrl, gdprConsent, uspConsent, gppConsent) {
+  try {
+    const url = new URL(baseUrl);
+
+    if (gdprConsent) {
+      url.searchParams.set('gdpr', gdprConsent.gdprApplies ? '1' : '0');
+      if (gdprConsent.consentString) {
+        url.searchParams.set('gdpr_consent', gdprConsent.consentString);
+      }
+    }
+
+    if (uspConsent) {
+      url.searchParams.set('us_privacy', uspConsent);
+    }
+
+    if (gppConsent?.gppString) {
+      url.searchParams.set('gpp', gppConsent.gppString);
+      if (gppConsent.applicableSections?.length) {
+        url.searchParams.set('gpp_sid', gppConsent.applicableSections.join(','));
+      }
+    }
+
+    return url.toString();
+  } catch (e) {
+    logWarn(`${BIDDER_CODE}: Invalid sync URL: ${baseUrl}`);
+
+    return baseUrl;
+  }
+}
+
+/**
+ * Create renderer for outstream video
+ */
+function createRenderer(bid, videoPlayerUrl) {
+  const renderer = Renderer.install({
+    url: videoPlayerUrl,
+    loaded: false,
+    adUnitCode: bid.adUnitCode,
+  });
+
+  try {
+    renderer.setRender(function (bidResponse) {
+      const divId = document.getElementById(bid.adUnitCode) ? bid.adUnitCode : getGptSlotInfoForAdUnitCode(bid.adUnitCode).divId;
+      const adUnit = document.getElementById(divId);
+
+      window.createOutstreamPlayer(adUnit, bidResponse.vastXml, bid.width, bid.height);
+    });
+  } catch (error) {
+    logWarn('Renderer error: setRender() failed', error);
+  }
+
+  return renderer;
 }
 
 registerBidder(spec);

package/modules/ixBidAdapter.js

@@ -1188,6 +1188,11 @@ function addFPD(bidderRequest, r, fpd, site, user) {
     if (ipv6) {
       deepSetValue(r, 'device.ipv6', ipv6);
     }
+
+    const geo = fpd.device.geo;
+    if (geo) {
+      deepSetValue(r, 'device.geo', geo);
+    }
   }
 
   // regulations from ortb2

package/modules/jixieIdSystem.js

@@ -0,0 +1,186 @@
+/**
+ * This module adds the jixie to the User ID module
+ * The {@link module:modules/userId} module is required
+ * @module modules/jixieIdSystem
+ * @requires module:modules/userId
+ */
+
+import { submodule } from '../src/hook.js';
+import { getStorageManager } from '../src/storageManager.js';
+import { ajax } from '../src/ajax.js';
+import { parseUrl, buildUrl, isPlainObject, timestamp } from '../src/utils.js';
+import { MODULE_TYPE_UID } from '../src/activities/modules.js';
+
+/**
+ * @typedef {import('../modules/userId/index.js').Submodule} Submodule
+ * @typedef {import('../modules/userId/index.js').SubmoduleConfig} SubmoduleConfig
+ * @typedef {import('../modules/userId/index.js').ConsentData} ConsentData
+ * @typedef {import('../modules/userId/index.js').IdResponse} IdResponse
+ */
+
+const MODULE_NAME = 'jixieId';
+const STD_JXID_KEY = '_jxx';
+const PBJS_JXID_KEY = 'pbjx_jxx';
+const PBJS_IDLOGSTR_KEY = 'pbjx_idlog';
+const TRACKER_EP_FROM_IDMODULE = 'https://traid.jixie.io/api/usersyncpbjs'
+const CK_LIFE_DAYS = 365;
+const ONE_YEAR_IN_MS = 365 * 24 * 60 * 60 * 1000;
+
+export const storage = getStorageManager({ moduleType: MODULE_TYPE_UID, moduleName: MODULE_NAME });
+
+/**
+ * remove any property in obj that is null or undefined
+ * @param {*} obj
+ */
+function removeNullProp(obj) {
+  for (const key in obj) {
+    if (obj[key] === null || obj[key] === undefined) {
+      delete obj[key];
+    }
+  }
+}
+
+/**
+ * save the info returned by our endpoint into cookie
+ * @param {object} response
+ */
+function persistExtInfo(response) {
+  let o = response;
+  if (o) {
+    const ageMS = (CK_LIFE_DAYS) * 24 * 60 * 60 * 1000;
+    const expireDT = new Date(timestamp() + ageMS).toUTCString();
+    if (o.client_id) {
+      storage.setCookie(PBJS_JXID_KEY, o.client_id, expireDT);
+    }
+    if (o.idlog) {
+      storage.setCookie(PBJS_IDLOGSTR_KEY, o.idlog, expireDT);
+    }
+  }
+}
+
+/**
+ * build the full url to call the jixie endpoint
+ * @param {Object} params - config params from the pbjs setup
+ * @param {Object} gdprConsent
+ * @returns {string} a full url to call by ajax
+ */
+function buildIdCallUrl(params, gdprConsent) {
+  let url = parseUrl(params.idendpoint || TRACKER_EP_FROM_IDMODULE);
+
+  if (gdprConsent) {
+    url.search.gdpr_consent = gdprConsent && gdprConsent.gdprApplies ? gdprConsent.consentString : '';
+  }
+  if (params) {
+    if (params.accountid) { url.search.accountid = params.accountid; }
+    url.search.client_id = storage.getCookie(PBJS_JXID_KEY);
+    url.search.idlog = storage.getCookie(PBJS_IDLOGSTR_KEY);
+    if (Array.isArray(params.pubExtIds)) {
+      params.pubExtIds.forEach((extId) => {
+        if (extId.ckname) {
+          url.search[extId.pname] = storage.getCookie(extId.ckname);
+        } else if (extId.lsname) {
+          url.search[extId.pname] = storage.getDataFromLocalStorage(extId.lsname);
+        }
+      });
+    }
+  }
+  removeNullProp(url.search);
+  return buildUrl(url);
+}
+
+/**
+ * just to check if the page has jixie publisher script planted
+ * @returns {boolean}
+ */
+function pgHasJxEvtScript() {
+  return ((window && window.jixie_o));
+}
+
+/**
+ * analyze the log string from the server side to see if it is now time to
+ * call the server again
+ * @param {*} logstr a formatted string
+ * @return {boolean}
+ */
+function shouldCallSrv(logstr) {
+  if (!logstr) return true;
+  let now = Date.now();
+  let tsStr = logstr.split('_')[0];
+  let ts = parseInt(tsStr, 10);
+  if (!(tsStr.length == 13 && ts && ts >= (now - ONE_YEAR_IN_MS) && ts <= (now + ONE_YEAR_IN_MS))) {
+    ts = undefined;
+  }
+  return (ts === undefined || (ts && now > ts));
+}
+
+/** @type {Submodule} */
+export const jixieIdSubmodule = {
+  /**
+   * used to link submodule with config
+   * @type {string}
+   */
+  name: MODULE_NAME,
+  /**
+   * decode the stored id value for passing to bid requests
+   * @function
+   * @param {string} value
+   * @returns {{jixieId: string} | undefined}
+   */
+  decode(value) {
+    return (value != null && value.length > 0 ? { jixieId: value } : undefined);
+  },
+  /**
+   * performs action to obtain id
+   * Use a publink cookie first if it is present, otherwise use prebids copy, if neither are available callout to get a new id
+   * @function
+   * @param {SubmoduleConfig} [config] Config object with params and storage properties
+   * @param {ConsentData|undefined} gdprConsent GDPR consent
+   * @returns {IdResponse}
+   */
+  getId(config, gdprConsent) {
+    if (!isPlainObject(config.params)) {
+      config.params = {};
+    }
+    const options = { method: 'GET', withCredentials: true };
+    const resp = function(callback) {
+      let jxId;
+      // If page has jixie script we use the standard jixie id cookie
+      if (pgHasJxEvtScript()) {
+        jxId = storage.getCookie(config.params.stdjxidckname || STD_JXID_KEY);
+        callback(jxId || null);
+        return;
+      }
+      // Case of no jixie script runs on this site:
+      jxId = storage.getCookie(PBJS_JXID_KEY);
+      let idLogStr = storage.getCookie(PBJS_IDLOGSTR_KEY);
+      if (jxId && !shouldCallSrv(idLogStr)) {
+        callback(jxId);
+      } else {
+        let handleResponse = function(responseText, xhr) {
+          if (xhr.status === 200) {
+            let response = JSON.parse(responseText);
+            if (response && response.data && response.data.success) {
+              response = response.data
+              persistExtInfo(response);
+              callback(response.client_id);
+              if (response.telcoep) {
+                ajax(response.telcoep, undefined, undefined, options);
+              }
+            }
+          }
+        };
+        ajax(
+          buildIdCallUrl(config.params, gdprConsent && gdprConsent.gdpr ? gdprConsent.gdpr : null), handleResponse, undefined, options
+        );
+      }
+    };
+    return { callback: resp };
+  },
+  eids: {
+    'jixieId': {
+      source: 'jixie.io',
+      atype: 3
+    },
+  },
+};
+submodule('userId', jixieIdSubmodule);