prebid.js 7.24.0 → 7.26.0

package/modules/admaticBidAdapter.js

@@ -1,94 +1,93 @@
 import { getValue, logError, deepAccess, getBidIdParameter, isArray } from '../src/utils.js';
-import { loadExternalScript } from '../src/adloader.js';
-import {registerBidder} from '../src/adapters/bidderFactory.js';
-
-const ENDPOINT_URL = 'https://layer.serve.admatic.com.tr/pb';
-const SYNC_URL = 'https://cdn.serve.admatic.com.tr/showad/sync.js';
+import { registerBidder } from '../src/adapters/bidderFactory.js';
+import { BANNER, VIDEO } from '../src/mediaTypes.js';
+const SYNC_URL = 'https://cdn.serve.admatic.com.tr/showad/sync.html';
 const BIDDER_CODE = 'admatic';
-
 export const spec = {
-  code: 'admatic',
-  supportedMediaTypes: ['video', 'banner'],
-  /**
-   * Determines whether or not the given bid request is valid.
-   *
-   * @param {BidRequest} bid The bid params to validate.
-   * @return boolean True if this is a valid bid, and false otherwise.
+  code: BIDDER_CODE,
+  aliases: [
+    {code: 'pixad'}
+  ],
+  supportedMediaTypes: [BANNER, VIDEO],
+  /** f
+   * @param {object} bid
+   * @return {boolean}
    */
-  isBidRequestValid: function(bid) {
+  isBidRequestValid: (bid) => {
     let isValid = false;
-    if (typeof bid.params !== 'undefined') {
-      let isValidNetworkId = _validateId(getValue(bid.params, 'networkId'));
-      isValid = isValidNetworkId;// && isValidTypeId;
+    if (bid?.params) {
+      const isValidNetworkId = _validateId(getValue(bid.params, 'networkId'));
+      const isValidHost = _validateString(getValue(bid.params, 'host'));
+      isValid = isValidNetworkId && isValidHost;
     }
 
     if (!isValid) {
-      logError('AdMatic networkId parameters are required. Bid aborted.');
+      logError(`${bid.bidder} networkId and host parameters are required. Bid aborted.`);
     }
     return isValid;
   },
+
   /**
-   * Make a server request from the list of BidRequests.
-   *
-   * @param {validBidRequests[]} an array of bids
-   * @return ServerRequest Info describing the request to the server.
+   * @param {BidRequest[]} validBidRequests
+   * @return {ServerRequest}
    */
-  buildRequests: function(validBidRequests, bidderRequest) {
+  buildRequests: (validBidRequests, bidderRequest) => {
     const bids = validBidRequests.map(buildRequestObject);
     const networkId = getValue(validBidRequests[0].params, 'networkId');
+    const host = getValue(validBidRequests[0].params, 'host');
     const currency = getValue(validBidRequests[0].params, 'currency') || 'TRY';
-
-    setTimeout(() => {
-      loadExternalScript(SYNC_URL, BIDDER_CODE);
-    }, bidderRequest.timeout);
+    const bidderName = validBidRequests[0].bidder;
 
     const payload = {
-      'user': {
-        'ua': navigator.userAgent
+      user: {
+        ua: navigator.userAgent
       },
-      'blacklist': [],
-      'site': {
-        'page': location.href,
-        'ref': location.origin,
-        'publisher': {
-          'name': location.hostname,
-          'publisherId': networkId
+      blacklist: [],
+      site: {
+        page: location.href,
+        ref: location.origin,
+        publisher: {
+          name: location.hostname,
+          publisherId: networkId
         }
       },
       imp: bids,
       ext: {
-        'cur': currency,
-        'type': 'admatic'
+        cur: currency,
+        bidder: bidderName
       }
     };
 
-    const payloadString = JSON.stringify(payload);
-    return {
-      method: 'POST',
-      url: ENDPOINT_URL,
-      data: payloadString,
-      options: {
-        contentType: 'application/json'
-      }
-    };
+    if (payload) {
+      return { method: 'POST', url: `https://${host}/pb?bidder=${bidderName}`, data: payload, options: { contentType: 'application/json' } };
+    }
+  },
+
+  getUserSyncs: function (syncOptions, responses) {
+    if (syncOptions.iframeEnabled) {
+      return [{
+        type: 'iframe',
+        url: SYNC_URL
+      }];
+    }
   },
+
   /**
-   * Unpack the response from the server into a list of bids.
-   *
-   * @param {*} serverResponse A successful response from the server.
-   * @return {Bid[]} An array of bids which were nested inside the server.
+   * @param {*} response
+   * @param {ServerRequest} request
+   * @return {Bid[]}
    */
   interpretResponse: (response, request) => {
     const body = response.body || response;
     const bidResponses = [];
-    if (body.data.length > 0) {
-      body.data.forEach(function (bid) {
+    if (body && body?.data && isArray(body.data)) {
+      body.data.forEach(bid => {
         const resbid = {
           requestId: bid.id,
           cpm: bid.price,
           width: bid.width,
           height: bid.height,
-          currency: body.cur,
+          currency: body.cur || 'TRY',
           netRevenue: true,
           ad: bid.party_tag,
           creativeId: bid.creative_id,
@@ -96,22 +95,68 @@ export const spec = {
             advertiserDomains: bid && bid.adomain ? bid.adomain : []
           },
           ttl: 360,
-          bidder: 'admatic',
-          timeToRespond: 1,
-          requestTimestamp: 1
+          bidder: bid.bidder
         };
+
         bidResponses.push(resbid);
       });
-    };
+    }
     return bidResponses;
   }
 };
 
+function enrichSlotWithFloors(slot, bidRequest) {
+  try {
+    const slotFloors = {};
+
+    if (bidRequest.getFloor) {
+      if (bidRequest.mediaTypes?.banner) {
+        slotFloors.banner = {};
+        const bannerSizes = parseSizes(deepAccess(bidRequest, 'mediaTypes.banner.sizes'))
+        bannerSizes.forEach(bannerSize => slotFloors.banner[parseSize(bannerSize).toString()] = bidRequest.getFloor({ size: bannerSize, mediaType: BANNER }));
+      }
+
+      if (bidRequest.mediaTypes?.video) {
+        slotFloors.video = {};
+        const videoSizes = parseSizes(deepAccess(bidRequest, 'mediaTypes.video.playerSize'))
+        videoSizes.forEach(videoSize => slotFloors.video[parseSize(videoSize).toString()] = bidRequest.getFloor({ size: videoSize, mediaType: VIDEO }));
+      }
+
+      if (Object.keys(slotFloors).length > 0) {
+        if (!slot) {
+          slot = {}
+        }
+        Object.assign(slot, {
+          floors: slotFloors
+        });
+      }
+    }
+  } catch (e) {
+    logError('Could not parse floors from Prebid: ' + e);
+  }
+}
+
+function parseSizes(sizes, parser = s => s) {
+  if (sizes == undefined) {
+    return [];
+  }
+  if (Array.isArray(sizes[0])) { // is there several sizes ? (ie. [[728,90],[200,300]])
+    return sizes.map(size => parser(size));
+  }
+  return [parser(sizes)]; // or a single one ? (ie. [728,90])
+}
+
+function parseSize(size) {
+  return size[0] + 'x' + size[1];
+}
+
 function buildRequestObject(bid) {
   const reqObj = {};
   reqObj.size = getSizes(bid);
   reqObj.id = getBidIdParameter('bidId', bid);
-  reqObj.floor = getValue(bid.params, 'floor') || 0.01;
+
+  enrichSlotWithFloors(reqObj, bid);
+
   return reqObj;
 }
 
@@ -144,4 +189,8 @@ function _validateId(id) {
   return (parseInt(id) > 0);
 }
 
+function _validateString(str) {
+  return (typeof str == 'string');
+}
+
 registerBidder(spec);

package/modules/admaticBidAdapter.md

@@ -19,7 +19,7 @@ Use `admatic` as bidder.
           bidder: 'admatic',
           params: { 
               networkId: 12345,
-              floor: 0.5
+              host: 'layer.serve.admatic.com.tr'
           }
       }]
     },{
@@ -29,7 +29,7 @@ Use `admatic` as bidder.
           bidder: 'admatic',
           params: { 
               networkId: 12345,
-              floor: 0.5
+              host: 'layer.serve.admatic.com.tr'
           }
       }]
     }];

package/modules/beopBidAdapter.js

@@ -1,4 +1,4 @@
-import { deepAccess, isArray, logWarn, triggerPixel, buildUrl, logInfo, getValue, getBidIdParameter } from '../src/utils.js';
+import { deepAccess, isArray, isStr, logWarn, triggerPixel, buildUrl, logInfo, getValue, getBidIdParameter } from '../src/utils.js';
 import { getRefererInfo } from '../src/refererDetection.js';
 import { registerBidder } from '../src/adapters/bidderFactory.js';
 import { config } from '../src/config.js';
@@ -40,6 +40,19 @@ export const spec = {
     const pageUrl = getPageUrl(bidderRequest.refererInfo, window);
     const gdpr = bidderRequest.gdprConsent;
     const firstSlot = slots[0];
+    const kwdsFromRequest = firstSlot.kwds;
+    let keywords = [];
+    if (kwdsFromRequest) {
+      if (isArray(kwdsFromRequest)) {
+        keywords = kwdsFromRequest;
+      } else if (isStr(kwdsFromRequest)) {
+        if (kwdsFromRequest.indexOf(',') != -1) {
+          keywords = kwdsFromRequest.split(',').map((e) => { return e.trim() });
+        } else {
+          keywords.push(kwdsFromRequest);
+        }
+      }
+    }
     const payloadObject = {
       at: new Date().toString(),
       nid: firstSlot.nid,
@@ -47,12 +60,13 @@ export const spec = {
       pid: firstSlot.pid,
       url: pageUrl,
       lang: (window.navigator.language || window.navigator.languages[0]),
-      kwds: bidderRequest.ortb2?.site?.keywords || [],
+      kwds: keywords,
       dbg: false,
       slts: slots,
       is_amp: deepAccess(bidderRequest, 'referrerInfo.isAmp'),
       tc_string: (gdpr && gdpr.gdprApplies) ? gdpr.consentString : null,
     };
+
     const payloadString = JSON.stringify(payloadObject);
     return {
       method: 'POST',
@@ -129,6 +143,7 @@ function beOpRequestSlotsMaker(bid) {
     sizes: isArray(bannerSizes) ? bannerSizes : bid.sizes,
     flr: floor,
     pid: getValue(bid.params, 'accountId'),
+    kwds: getValue(bid.params, 'keywords'),
     nid: getValue(bid.params, 'networkId'),
     nptnid: getValue(bid.params, 'networkPartnerId'),
     bid: getBidIdParameter('bidId', bid),

package/modules/captifyRtdProvider.js

@@ -0,0 +1,146 @@
+/**
+ * This module adds Captify real time data provider module
+ * The {@link module:modules/realTimeData} module is required
+ * The module will fetch segments (page-centric) from Captify live-classification server
+ * @module modules/captifyRtdProvider
+ * @requires module:modules/realTimeData
+ */
+import { submodule } from '../src/hook.js';
+import { getRefererInfo } from '../src/refererDetection.js';
+import { ajax } from '../src/ajax.js';
+import { config } from '../src/config.js';
+import {deepAccess, isArray, isEmptyStr, isNumber, logError} from '../src/utils.js';
+import {getGlobal} from '../src/prebidGlobal.js';
+
+const MODULE_NAME = 'realTimeData';
+const SUBMODULE_NAME = 'CaptifyRTDModule';
+const DEFAULT_LC_URL = 'https://live-classification.cpx.to/prebid-segments';
+
+const STATUS = {
+  SUCCESS: 200,
+  ACCEPTED: 202,
+};
+
+/**
+ * Set `appnexusAuctionKeywords` that appnexus bidder will read and send in request to Xandr
+ * @param {Array<number>} segments captify segments for Appnexus(Xandr) system, in form of [id1, id2, id3]
+ *                 where id1, id2, id3 - actual Xandr segment ids with keywords enabled
+ */
+export function setAppnexusSegments(segments) {
+  config.setConfig({
+    appnexusAuctionKeywords: {
+      'captify_segments': segments,
+    },
+  })
+}
+
+/**
+ * Function returns only bidders that contained both, in moduleConfig and at least one adUnit.
+ * @param {Array<string>} bidders Contains list of bidders, to set targeting for
+ * @param {Object} data Response of live-classification service
+ */
+export function addSegmentData(bidders, data) {
+  for (const bidder of bidders) {
+    if (bidder === 'appnexus') { setAppnexusSegments(data['xandr']) }
+  }
+}
+
+/**
+ * Function returns only bidders that contained in both, moduleConfig and at least one adUnit.
+ * @param {Object} moduleConfig Config object passed to the module
+ * @param {Object} reqBidsConfigObj Config object for the bidders; each adapter has its own entry
+ */
+export function getMatchingBidders(moduleConfig, reqBidsConfigObj) {
+  const biddersFromConf = deepAccess(moduleConfig, 'params.bidders');
+
+  const adUnitBidders = reqBidsConfigObj.adUnits
+    .flatMap(({bids}) => bids.map(({bidder}) => bidder))
+    .filter((e, i, a) => a.indexOf(e) === i);
+
+  if (!isArray(adUnitBidders) || !adUnitBidders.length) {
+    logError(SUBMODULE_NAME, 'Missing parameter bidders in bidRequestConfig');
+    return [];
+  }
+
+  return biddersFromConf.filter(bidder => adUnitBidders.includes(bidder));
+}
+
+/**
+ * Main function that sets Captify targeting for various bidders
+ * @param {Object} moduleConfig Config object passed to the module
+ * @param {Function} onDone callback function that executed when everything is done
+ * @param {Object} reqBidsConfigObj Config object for the bidders; each adapter has its own entry
+ * @param {Object} gcv contains data related to user consent, if applies
+ */
+export function setCaptifyTargeting(reqBidsConfigObj, onDone, moduleConfig, gcv) {
+  const pbjsVer = getGlobal();
+  const ref = getRefererInfo().referer;
+  const url = document.URL;
+  const pubId = moduleConfig.params.pubId;
+  const bidders = getMatchingBidders(moduleConfig, reqBidsConfigObj)
+  const requestBody = {
+    pubId,
+    ref,
+    url,
+    pbjsVer,
+    gcv
+  };
+  let requestUrl = moduleConfig.params.url;
+  if (!requestUrl || isEmptyStr(requestUrl)) {
+    requestUrl = DEFAULT_LC_URL;
+  }
+
+  if (!bidders.length) {
+    logError(SUBMODULE_NAME, 'There are no matched bidders to work with');
+    return;
+  }
+
+  ajax(requestUrl, {
+    success: function (response, req) {
+      if (req.status === STATUS.SUCCESS) {
+        try {
+          const data = JSON.parse(response);
+          if (data) {
+            addSegmentData(bidders, data);
+          }
+        } catch (e) {
+          logError(SUBMODULE_NAME, 'Unable to parse live-classification data' + e);
+        }
+      }
+      onDone();
+    },
+    error: function () {
+      onDone();
+      logError(SUBMODULE_NAME, 'Unable to get live-classification data');
+    }
+  },
+  JSON.stringify(requestBody),
+  {
+    contentType: 'application/json',
+    method: 'POST',
+  });
+}
+
+export function init(moduleConfig, userConsent) {
+  // Validate bidders
+  const biddersFromConf = deepAccess(moduleConfig, 'params.bidders');
+  if (!isArray(biddersFromConf) || !biddersFromConf.length) {
+    logError(SUBMODULE_NAME, 'Missing parameter bidders in moduleConfig');
+    return false
+  }
+  const publisherId = deepAccess(moduleConfig, 'params.pubId');
+  // Publisher Id
+  if (!isNumber(publisherId)) {
+    logError(SUBMODULE_NAME, 'Missing parameter pubId in moduleConfig');
+    return false
+  }
+  return true
+}
+
+export const captifySubmodule = {
+  name: SUBMODULE_NAME,
+  init: init,
+  setCaptifyTargeting
+};
+
+submodule(MODULE_NAME, captifySubmodule);

package/modules/captifyRtdProvider.md

@@ -0,0 +1,68 @@
+# Captify Real-Time Data Submodule
+
+# Overview
+
+    Module Name: Captify Rtd Provider
+    Module Type: Rtd Provider
+	Layout: integrationExamples/gpt/captifyRtdProvider_example.html
+    Maintainer: prebid@captify.tech
+
+# Description
+
+Captify uses publisher first-party on-site search data to power machine learning algorithms to create a suite of
+contextual based targeting solutions that activate in a cookieless environment.
+
+The RTD submodule allows bid requests to be classified by our live-classification service on the first ad call,
+maximising value for publishers by increasing scale for advertisers.
+
+Segments will be attached to bid request objects sent to different SSPs in order to optimize targeting.
+
+Contact prebid@captify.tech for information.
+
+### Publisher Usage
+
+Compile the Captify RTD module into your Prebid build:
+
+`npm ci && gulp build --modules=rtdModule,appnexusBidAdapter,captifyRtdProvider`
+
+Add the Captify RTD provider to your Prebid config.
+
+```javascript
+pbjs.setConfig({
+    realTimeData: {
+        auctionDelay: 1000,
+        dataProviders: [
+            {
+                name: "CaptifyRTDModule",
+                waitForIt: true,
+                params: {
+                    pubId: 123456,
+                    bidders: ['appnexus'],
+                }
+            }
+        ]
+    }
+});
+```
+
+### Parameter Description
+This module is configured as part of the `realTimeData.dataProviders` object.
+
+| Name           |Type           | Description                                                         |Mandatory | Notes  |
+| :------------- | :------------ | :------------------------------------------------------------------ |:---------|:------------ |
+| name           | String        | Real time data module name                                          | yes     | Always 'CaptifyRTDModule' |
+| waitForIt      | Boolean       | Should be `true` if there's an `auctionDelay` defined (recommended) | no      | Default `false` |
+| params         | Object        | |  | |
+| params.pubId   | Integer       | Partner ID, required to get results and provided by Captify         | yes      | Use 123456 for tests and speak to your Captify account manager to receive your pubId |
+| params.bidders | Array<String> | List of bidders for which you would like data to be set             | yes      | Currently only 'appnexus' supported |
+| params.url     | String        | Captify live-classification service url                             | no       | Defaults to `https://live-classification.cpx.to/prebid-segments`
+
+### Testing
+
+To view an example of available segments returned by Captify:
+
+`gulp serve --modules=rtdModule,captifyRtdProvider,appnexusBidAdapter`
+
+and then point your browser at:
+
+`http://localhost:9999/integrationExamples/gpt/captifyRtdProvider_example.html?pbjs_debug=true`

package/modules/concertBidAdapter.js

@@ -1,4 +1,4 @@
-import { logWarn, logMessage, debugTurnedOn, generateUUID } from '../src/utils.js';
+import { logWarn, logMessage, debugTurnedOn, generateUUID, deepAccess } from '../src/utils.js';
 import { registerBidder } from '../src/adapters/bidderFactory.js';
 import { getStorageManager } from '../src/storageManager.js';
 import { hasPurpose1Consent } from '../src/utils/gpdr.js';
@@ -178,7 +178,7 @@ export const spec = {
 
 registerBidder(spec);
 
-const storage = getStorageManager({bidderCode: BIDDER_CODE});
+export const storage = getStorageManager({bidderCode: BIDDER_CODE});
 
 /**
  * Check or generate a UID for the current user.
@@ -188,10 +188,24 @@ function getUid(bidderRequest) {
     return false;
   }
 
-  const CONCERT_UID_KEY = 'c_uid';
+  const sharedId = deepAccess(bidderRequest, 'userId._sharedid.id');
 
+  if (sharedId) {
+    return sharedId;
+  }
+
+  const LEGACY_CONCERT_UID_KEY = 'c_uid';
+  const CONCERT_UID_KEY = 'vmconcert_uid';
+
+  const legacyUid = storage.getDataFromLocalStorage(LEGACY_CONCERT_UID_KEY);
   let uid = storage.getDataFromLocalStorage(CONCERT_UID_KEY);
 
+  if (legacyUid) {
+    uid = legacyUid;
+    storage.setDataInLocalStorage(CONCERT_UID_KEY, uid);
+    storage.removeDataFromLocalStorage(LEGACY_CONCERT_UID_KEY);
+  }
+
   if (!uid) {
     uid = generateUUID();
     storage.setDataInLocalStorage(CONCERT_UID_KEY, uid);

package/modules/conversantAnalyticsAdapter.md

@@ -1,37 +1,36 @@
 # Overview
-- Module Name: Conversant Bidder Adapter
+- Module Name: Epsilon Analytics Adapter
 - Module Type: Analytics Adapter
-- Maintainer: mediapsr@conversantmedia.com
+- Maintainer: mediapsr@epsilon.com
 
 ## Description
 
-Analytics adapter for Conversant is used to track performance of Prebid auctions.  See the usage below for how to 
+Analytics adapter for Epsilon (formerly Conversant) is used to track performance of Prebid auctions.  See the usage below for how to 
 configure the adapter for your webpage. To enable analytics and gain access to the data publishers will need
- to contact their Conversant representative.
+ to contact their Epsilon representative (publishersupport@epsilon.com).
 
 ## Setup
 
-Before any analytics are recorded for your website you will need to have a Conversant representative turn
+Before any analytics are recorded for your website you will need to have an Epsilon representative turn
 on Prebid analytics for your website.  
 
-The simplest configuration to add Conversant Prebid analytics to your page is as follows:
+The simplest configuration to add Epsilon Prebid analytics to your page is as follows:
 
 ```
     pbjs.que.push(function() {
         pbjs.enableAnalytics({
             provider: 'conversant',
             options: {
-                site_id: '<YOUR_SITE_ID>'
+                site_id: <YOUR_SITE_ID>
             }
         })
     });
 ```
 
-Additionally the following options are supported:
+Additionally, the following options are supported:
 
-- **sampleRate**: Expects an integer from 0 to 100. By default only 50% (corresponds to a value of 50) of instances are enabled
-for Conversant Prebid Analytics. This field allows the publisher to override that percentage to sample
-at a higher or lower rate. '0' would completely disable sampling and '100' would capture every instance.
+- **cnvr_sampling**: Sample rate for analytics data. Value should be between 0 and 1 (inclusive), 0 == never sample, 
+1 == always sample, 0.5 == send analytics 50% of the time.
 
 ### Complete Example
 ```
@@ -39,8 +38,8 @@ at a higher or lower rate. '0' would completely disable sampling and '100' would
         pbjs.enableAnalytics({
             provider: 'conversant',
             options: {
-                site_id: '1234',
-                sampleRate: 90
+                site_id: 1234,
+                cnvr_sampling: 0.9
             }
         })
     });

package/modules/conversantBidAdapter.md

@@ -1,12 +1,12 @@
 # Overview
 
-- Module Name: Conversant Bidder Adapter
+- Module Name: Epsilon Bidder Adapter
 - Module Type: Bidder Adapter
-- Maintainer: mediapsr@conversantmedia.com
+- Maintainer: mediapsr@epsilon.com
 
 # Description
 
-Module that connects to Conversant's demand sources.  Supports banners and videos.
+Module that connects to Epsilon's (formerly Conversant) demand sources.  Supports banners and videos.
 
 # Test Parameters
 ```