prebid.js 6.6.0 → 6.10.0

package/modules/gnetBidAdapter.md

@@ -1,14 +1,14 @@
 # Overview
 
 ```
-Module Name: Gnet Bidder Adapter
+Module Name: Gnet RTB Bidder Adapter
 Module Type: Bidder Adapter
-Maintainer: roberto.wu@grumft.com
+Maintainer: bruno.bonanho@grumft.com
 ```
 
 # Description
 
-Connect to Gnet Project exchange for bids.
+Connect to Gnet RTB exchange for bids.
 
 # Test Parameters
 ```
@@ -24,7 +24,7 @@ Connect to Gnet Project exchange for bids.
                 {
                     bidder: 'gnet',
                     params: {
-                        websiteId: '4'
+                        websiteId: '1', adunitId: '1'
                     }
                 }
             ]

package/modules/goldbachBidAdapter.js

@@ -27,8 +27,8 @@ import { config } from '../src/config.js';
 import { registerBidder, getIabSubCategory } from '../src/adapters/bidderFactory.js';
 import { BANNER, NATIVE, VIDEO, ADPOD } from '../src/mediaTypes.js';
 import { auctionManager } from '../src/auctionManager.js';
-import find from 'core-js-pure/features/array/find.js';
-import includes from 'core-js-pure/features/array/includes.js';
+import find from 'prebidjs-polyfill/find.js';
+import includes from 'prebidjs-polyfill/includes.js';
 import { OUTSTREAM, INSTREAM } from '../src/video.js';
 
 const BIDDER_CODE = 'goldbach';

package/modules/gptPreAuction.js

@@ -1,7 +1,7 @@
 import { isGptPubadsDefined, isAdUnitCodeMatchingSlot, deepAccess, pick, logInfo } from '../src/utils.js';
 import { config } from '../src/config.js';
 import { getHook } from '../src/hook.js';
-import find from 'core-js-pure/features/array/find.js';
+import find from 'prebidjs-polyfill/find.js';
 
 const MODULE_NAME = 'GPT Pre-Auction';
 export let _currentConfig = {};

package/modules/gridBidAdapter.js

@@ -1,4 +1,4 @@
-import { isEmpty, deepAccess, logError, parseGPTSingleSizeArrayToRtbSize, generateUUID, logWarn } from '../src/utils.js';
+import { isEmpty, deepAccess, logError, parseGPTSingleSizeArrayToRtbSize, generateUUID, mergeDeep, logWarn } from '../src/utils.js';
 import { registerBidder } from '../src/adapters/bidderFactory.js';
 import { Renderer } from '../src/Renderer.js';
 import { VIDEO, BANNER } from '../src/mediaTypes.js';
@@ -173,10 +173,24 @@ export const spec = {
       };
     }
 
+    const ortb2UserData = config.getConfig('ortb2.user.data');
+    if (ortb2UserData && ortb2UserData.length) {
+      if (!user) {
+        user = { data: [] };
+      }
+      user = mergeDeep(user, { data: ortb2UserData });
+    }
+
     if (gdprConsent && gdprConsent.consentString) {
       userExt = {consent: gdprConsent.consentString};
     }
 
+    const ortb2UserExtDevice = config.getConfig('ortb2.user.ext.device');
+    if (ortb2UserExtDevice) {
+      userExt = userExt || {};
+      userExt.device = { ...ortb2UserExtDevice };
+    }
+
     if (userIdAsEids && userIdAsEids.length) {
       userExt = userExt || {};
       userExt.eids = [...userIdAsEids];

package/modules/gumgumBidAdapter.js

@@ -3,7 +3,7 @@ import { _each, deepAccess, logError, logWarn, parseSizesInput } from '../src/ut
 
 import { config } from '../src/config.js'
 import { getStorageManager } from '../src/storageManager.js';
-import includes from 'core-js-pure/features/array/includes';
+import includes from 'prebidjs-polyfill/includes.js';
 import { registerBidder } from '../src/adapters/bidderFactory.js'
 
 const storage = getStorageManager();
@@ -17,32 +17,48 @@ const TIME_TO_LIVE = 60
 const DELAY_REQUEST_TIME = 1800000; // setting to 30 mins
 
 let invalidRequestIds = {};
-let browserParams = {};
 let pageViewId = null;
 
 // TODO: potential 0 values for browserParams sent to ad server
 function _getBrowserParams(topWindowUrl) {
-  let topWindow
-  let topScreen
-  let topUrl
-  let ggad
-  let ns
-  function getNetworkSpeed() {
-    const connection = window.navigator && (window.navigator.connection || window.navigator.mozConnection || window.navigator.webkitConnection)
-    const Mbps = connection && (connection.downlink || connection.bandwidth)
-    return Mbps ? Math.round(Mbps * 1024) : null
+  const paramRegex = paramName => new RegExp(`[?#&](${paramName}=(.*?))($|&)`, 'i');
+
+  let browserParams = {};
+  let topWindow;
+  let topScreen;
+  let topUrl;
+  let ggad;
+  let ggdeal;
+  let ns;
+
+  function getNetworkSpeed () {
+    const connection = window.navigator && (window.navigator.connection || window.navigator.mozConnection || window.navigator.webkitConnection);
+    const Mbps = connection && (connection.downlink || connection.bandwidth);
+    return Mbps ? Math.round(Mbps * 1024) : null;
   }
-  function getOgURL() {
-    let ogURL = ''
-    const ogURLSelector = "meta[property='og:url']"
-    const head = document && document.getElementsByTagName('head')[0]
-    const ogURLElement = head.querySelector(ogURLSelector)
-    ogURL = ogURLElement ? ogURLElement.content : null
-    return ogURL
+
+  function getOgURL () {
+    let ogURL = '';
+    const ogURLSelector = "meta[property='og:url']";
+    const head = document && document.getElementsByTagName('head')[0];
+    const ogURLElement = head.querySelector(ogURLSelector);
+    ogURL = ogURLElement ? ogURLElement.content : null;
+    return ogURL;
   }
-  if (browserParams.vw) {
-    // we've already initialized browserParams, just return it.
-    return browserParams
+
+  function stripGGParams (url) {
+    const params = [
+      'ggad',
+      'ggdeal'
+    ];
+
+    return params.reduce((result, param) => {
+      const matches = url.match(paramRegex(param));
+      if (!matches) return result;
+      matches[1] && (result = result.replace(matches[1], ''));
+      matches[3] && (result = result.replace(matches[3], ''));
+      return result;
+    }, url);
   }
 
   try {
@@ -51,7 +67,7 @@ function _getBrowserParams(topWindowUrl) {
     topUrl = topWindowUrl || '';
   } catch (error) {
     logError(error);
-    return browserParams
+    return browserParams;
   }
 
   browserParams = {
@@ -59,23 +75,25 @@ function _getBrowserParams(topWindowUrl) {
     vh: topWindow.innerHeight,
     sw: topScreen.width,
     sh: topScreen.height,
-    pu: topUrl,
+    pu: stripGGParams(topUrl),
     ce: storage.cookiesAreEnabled(),
     dpr: topWindow.devicePixelRatio || 1,
     jcsi: JSON.stringify(JCSI),
     ogu: getOgURL()
-  }
+  };
 
-  ns = getNetworkSpeed()
+  ns = getNetworkSpeed();
   if (ns) {
-    browserParams.ns = ns
+    browserParams.ns = ns;
   }
 
-  ggad = (topUrl.match(/#ggad=(\w+)$/) || [0, 0])[1]
-  if (ggad) {
-    browserParams[isNaN(ggad) ? 'eAdBuyId' : 'adBuyId'] = ggad
-  }
-  return browserParams
+  ggad = (topUrl.match(paramRegex('ggad')) || [0, 0, 0])[2];
+  if (ggad) browserParams[isNaN(ggad) ? 'eAdBuyId' : 'adBuyId'] = ggad;
+
+  ggdeal = (topUrl.match(paramRegex('ggdeal')) || [0, 0, 0])[2];
+  if (ggdeal) browserParams.ggdeal = ggdeal;
+
+  return browserParams;
 }
 
 function getWrapperCode(wrapper, data) {
@@ -291,17 +309,17 @@ function buildRequests(validBidRequests, bidderRequest) {
     } = bidRequest;
     const { currency, floor } = _getFloor(mediaTypes, params.bidfloor, bidRequest);
     const eids = getEids(userId);
+    const gpid = deepAccess(ortb2Imp, 'ext.data.pbadslot') || deepAccess(ortb2Imp, 'ext.data.adserver.adslot');
     let sizes = [1, 1];
     let data = {};
-    let gpid = '';
 
     const date = new Date();
     const lt = date.getTime();
     const to = date.getTimezoneOffset();
-    if (to) {
-      lt && (data.lt = lt);
-      data.to = to;
-    }
+
+    // ADTS-174 Removed unnecessary checks to fix failing test
+    data.lt = lt;
+    data.to = to;
 
     // ADTS-169 add adUnitCode to requests
     if (adUnitCode) data.aun = adUnitCode
@@ -309,12 +327,8 @@ function buildRequests(validBidRequests, bidderRequest) {
     // ADTS-134 Retrieve ID envelopes
     for (const eid in eids) data[eid] = eids[eid];
 
-    // ADJS-1024 & ADSS-1297
-    if (deepAccess(ortb2Imp, 'ext.data.pbadslot')) {
-      gpid = deepAccess(ortb2Imp, 'ext.data.pbadslot')
-    } else if (deepAccess(ortb2Imp, 'ext.data.adserver.name')) {
-      gpid = ortb2Imp.ext.data.adserver.adslot
-    }
+    // ADJS-1024 & ADSS-1297 & ADTS-175
+    gpid && (data.gpid = gpid);
 
     if (mediaTypes.banner) {
       sizes = mediaTypes.banner.sizes;
@@ -384,7 +398,7 @@ function buildRequests(validBidRequests, bidderRequest) {
       sizes,
       url: BID_ENDPOINT,
       method: 'GET',
-      data: Object.assign(data, _getBrowserParams(topWindowUrl), _getDigiTrustQueryParams(userId), { gpid })
+      data: Object.assign(data, _getBrowserParams(topWindowUrl), _getDigiTrustQueryParams(userId))
     })
   });
   return bids;

package/modules/hadronIdSystem.js

@@ -0,0 +1,96 @@
+/**
+ * This module adds HadronID to the User ID module
+ * The {@link module:modules/userId} module is required
+ * @module modules/hadronIdSystem
+ * @requires module:modules/userId
+ */
+
+import {ajax} from '../src/ajax.js';
+import {getStorageManager} from '../src/storageManager.js';
+import {submodule} from '../src/hook.js';
+import { isFn, isStr, isPlainObject, logError } from '../src/utils.js';
+
+const MODULE_NAME = 'hadronId';
+const AU_GVLID = 561;
+
+export const storage = getStorageManager(AU_GVLID, 'hadron');
+
+/**
+ * Param or default.
+ * @param {String} param
+ * @param {String} defaultVal
+ */
+function paramOrDefault(param, defaultVal, arg) {
+  if (isFn(param)) {
+    return param(arg);
+  } else if (isStr(param)) {
+    return param;
+  }
+  return defaultVal;
+}
+
+/** @type {Submodule} */
+export const hadronIdSubmodule = {
+  /**
+   * used to link submodule with config
+   * @type {string}
+   */
+  name: MODULE_NAME,
+  /**
+   * decode the stored id value for passing to bid requests
+   * @function
+   * @param {{value:string}} value
+   * @returns {{hadronId:Object}}
+   */
+  decode(value) {
+    let hadronId = storage.getDataFromLocalStorage('auHadronId');
+    if (isStr(hadronId)) {
+      return {hadronId: hadronId};
+    }
+    return (value && typeof value['hadronId'] === 'string') ? { 'hadronId': value['hadronId'] } : undefined;
+  },
+  /**
+   * performs action to obtain id and return a value in the callback's response argument
+   * @function
+   * @param {SubmoduleConfig} [config]
+   * @returns {IdResponse|undefined}
+   */
+  getId(config) {
+    if (!isPlainObject(config.params)) {
+      config.params = {};
+    }
+    const url = paramOrDefault(config.params.url,
+      `https://id.hadron.ad.gt/api/v1/pbhid`,
+      config.params.urlArg);
+
+    const resp = function (callback) {
+      let hadronId = storage.getDataFromLocalStorage('auHadronId');
+      if (isStr(hadronId)) {
+        const responseObj = {hadronId: hadronId};
+        callback(responseObj);
+      } else {
+        const callbacks = {
+          success: response => {
+            let responseObj;
+            if (response) {
+              try {
+                responseObj = JSON.parse(response);
+              } catch (error) {
+                logError(error);
+              }
+            }
+            callback(responseObj);
+          },
+          error: error => {
+            logError(`${MODULE_NAME}: ID fetch encountered an error`, error);
+            callback();
+          }
+        };
+        ajax(url, callbacks, undefined, {method: 'GET'});
+      }
+    };
+    return {callback: resp};
+  }
+};
+
+submodule('userId', hadronIdSubmodule);

package/modules/hadronIdSystem.md

@@ -0,0 +1,35 @@
+## Audigent Hadron User ID Submodule
+
+Audigent Hadron ID Module. For assistance setting up your module please contact us at [prebid@audigent.com](prebid@audigent.com).
+
+### Prebid Params
+
+Individual params may be set for the Audigent Hadron ID Submodule. At least one identifier must be set in the params.
+
+```
+pbjs.setConfig({
+    usersync: {
+        userIds: [{
+            name: 'hadronId',
+            storage: {
+                name: 'hadronId',
+                type: 'html5'
+            }
+        }]
+    }
+});
+```
+## Parameter Descriptions for the `usersync` Configuration Section
+The below parameters apply only to the HadronID User ID Module integration.
+
+| Param under usersync.userIds[] | Scope | Type | Description | Example |
+| --- | --- | --- | --- | --- |
+| name | Required | String | ID value for the HadronID module - `"hadronId"` | `"hadronId"` |
+| storage | Required | Object | The publisher must specify the local storage in which to store the results of the call to get the user ID. This can be either cookie or HTML5 storage. | |
+| storage.type | Required | String | This is where the results of the user ID will be stored. The recommended method is `localStorage` by specifying `html5`. | `"html5"` |
+| storage.name | Required | String | The name of the cookie or html5 local storage where the user ID will be stored. | `"hadronid"` |
+| storage.expires | Optional | Integer | How long (in days) the user ID information will be stored. | `365` |
+| value | Optional | Object | Used only if the page has a separate mechanism for storing the Hadron ID. The value is an object containing the values to be sent to the adapters. In this scenario, no URL is called and nothing is added to local storage | `{"hadronId": "eb33b0cb-8d35-4722-b9c0-1a31d4064888"}` |
+| params | Optional | Object | Used to store params for the id system |
+| params.url | Optional | String | Set an alternate GET url for HadronId with this parameter |
+| params.urlArg | Optional | Object | Optional url parameter for params.url |

package/modules/hadronRtdProvider.js

@@ -0,0 +1,254 @@
+/**
+ * This module adds the Audigent Hadron provider to the real time data module
+ * The {@link module:modules/realTimeData} module is required
+ * The module will fetch real-time data from Audigent
+ * @module modules/hadronRtdProvider
+ * @requires module:modules/realTimeData
+ */
+import {ajax} from '../src/ajax.js';
+import {config} from '../src/config.js';
+import {getGlobal} from '../src/prebidGlobal.js';
+import {getStorageManager} from '../src/storageManager.js';
+import {submodule} from '../src/hook.js';
+import {isFn, isStr, isArray, deepEqual, isPlainObject, logError} from '../src/utils.js';
+
+const MODULE_NAME = 'realTimeData';
+const SUBMODULE_NAME = 'hadron';
+const AU_GVLID = 561;
+
+export const HALOID_LOCAL_NAME = 'auHadronId';
+export const RTD_LOCAL_NAME = 'auHadronRtd';
+export const storage = getStorageManager(AU_GVLID, SUBMODULE_NAME);
+
+/**
+ * Deep set an object unless value present.
+ * @param {Object} obj
+ * @param {String} path
+ * @param {Object} val
+ */
+function set(obj, path, val) {
+  const keys = path.split('.');
+  const lastKey = keys.pop();
+  const lastObj = keys.reduce((obj, key) => obj[key] = obj[key] || {}, obj);
+  lastObj[lastKey] = lastObj[lastKey] || val;
+}
+
+/**
+ * Deep object merging with array deduplication.
+ * @param {Object} target
+ * @param {Object} sources
+ */
+function mergeDeep(target, ...sources) {
+  if (!sources.length) return target;
+  const source = sources.shift();
+
+  if (isPlainObject(target) && isPlainObject(source)) {
+    for (const key in source) {
+      if (isPlainObject(source[key])) {
+        if (!target[key]) Object.assign(target, { [key]: {} });
+        mergeDeep(target[key], source[key]);
+      } else if (isArray(source[key])) {
+        if (!target[key]) {
+          Object.assign(target, { [key]: source[key] });
+        } else if (isArray(target[key])) {
+          source[key].forEach(obj => {
+            let e = 1;
+            for (let i = 0; i < target[key].length; i++) {
+              if (deepEqual(target[key][i], obj)) {
+                e = 0;
+                break;
+              }
+            }
+            if (e) {
+              target[key].push(obj);
+            }
+          });
+        }
+      } else {
+        Object.assign(target, { [key]: source[key] });
+      }
+    }
+  }
+
+  return mergeDeep(target, ...sources);
+}
+
+/**
+ * Lazy merge objects.
+ * @param {Object} target
+ * @param {Object} source
+ */
+function mergeLazy(target, source) {
+  if (!isPlainObject(target)) {
+    target = {};
+  }
+
+  if (!isPlainObject(source)) {
+    source = {};
+  }
+
+  return mergeDeep(target, source);
+}
+
+/**
+ * Param or default.
+ * @param {String} param
+ * @param {String} defaultVal
+ */
+function paramOrDefault(param, defaultVal, arg) {
+  if (isFn(param)) {
+    return param(arg);
+  } else if (isStr(param)) {
+    return param;
+  }
+  return defaultVal;
+}
+
+/**
+ * Add real-time data & merge segments.
+ * @param {Object} bidConfig
+ * @param {Object} rtd
+ * @param {Object} rtdConfig
+ */
+export function addRealTimeData(bidConfig, rtd, rtdConfig) {
+  if (rtdConfig.params && rtdConfig.params.handleRtd) {
+    rtdConfig.params.handleRtd(bidConfig, rtd, rtdConfig, config);
+  } else {
+    if (isPlainObject(rtd.ortb2)) {
+      let ortb2 = config.getConfig('ortb2') || {};
+      config.setConfig({ortb2: mergeLazy(ortb2, rtd.ortb2)});
+    }
+
+    if (isPlainObject(rtd.ortb2b)) {
+      let bidderConfig = config.getBidderConfig();
+
+      Object.keys(rtd.ortb2b).forEach(bidder => {
+        let rtdOptions = rtd.ortb2b[bidder] || {};
+
+        let bidderOptions = {};
+        if (isPlainObject(bidderConfig[bidder])) {
+          bidderOptions = bidderConfig[bidder];
+        }
+
+        config.setBidderConfig({
+          bidders: [bidder],
+          config: mergeLazy(bidderOptions, rtdOptions)
+        });
+      });
+    }
+  }
+}
+
+/**
+ * Real-time data retrieval from Audigent
+ * @param {Object} reqBidsConfigObj
+ * @param {function} onDone
+ * @param {Object} rtdConfig
+ * @param {Object} userConsent
+ */
+export function getRealTimeData(bidConfig, onDone, rtdConfig, userConsent) {
+  if (rtdConfig && isPlainObject(rtdConfig.params) && rtdConfig.params.segmentCache) {
+    let jsonData = storage.getDataFromLocalStorage(RTD_LOCAL_NAME);
+
+    if (jsonData) {
+      let data = JSON.parse(jsonData);
+
+      if (data.rtd) {
+        addRealTimeData(bidConfig, data.rtd, rtdConfig);
+        onDone();
+        return;
+      }
+    }
+  }
+
+  const userIds = (getGlobal()).getUserIds();
+
+  let hadronId = storage.getDataFromLocalStorage(HALOID_LOCAL_NAME);
+  if (isStr(hadronId)) {
+    (getGlobal()).refreshUserIds({submoduleNames: 'hadronId'});
+    userIds.hadronId = hadronId;
+    getRealTimeDataAsync(bidConfig, onDone, rtdConfig, userConsent, userIds);
+  } else {
+    var script = document.createElement('script');
+    script.type = 'text/javascript';
+
+    window.pubHadronCb = (hadronId) => {
+      userIds.hadronId = hadronId;
+      getRealTimeDataAsync(bidConfig, onDone, rtdConfig, userConsent, userIds);
+    }
+
+    const hadronIdUrl = rtdConfig.params && rtdConfig.params.hadronIdUrl;
+    script.src = paramOrDefault(hadronIdUrl, 'https://id.hadron.ad.gt/api/v1/hadronid', userIds);
+    document.getElementsByTagName('head')[0].appendChild(script);
+  }
+}
+
+/**
+ * Async rtd retrieval from Audigent
+ * @param {function} onDone
+ * @param {Object} rtdConfig
+ * @param {Object} userConsent
+ * @param {Object} userIds
+ */
+export function getRealTimeDataAsync(bidConfig, onDone, rtdConfig, userConsent, userIds) {
+  let reqParams = {};
+
+  if (isPlainObject(rtdConfig)) {
+    set(rtdConfig, 'params.requestParams.ortb2', config.getConfig('ortb2'));
+    reqParams = rtdConfig.params.requestParams;
+  }
+
+  if (isPlainObject(window.pubHadronPm)) {
+    reqParams.pubHadronPm = window.pubHadronPm;
+  }
+
+  const url = `https://seg.hadron.ad.gt/api/v1/rtd`;
+  ajax(url, {
+    success: function (response, req) {
+      if (req.status === 200) {
+        try {
+          const data = JSON.parse(response);
+          if (data && data.rtd) {
+            addRealTimeData(bidConfig, data.rtd, rtdConfig);
+            onDone();
+            storage.setDataInLocalStorage(RTD_LOCAL_NAME, JSON.stringify(data));
+          } else {
+            onDone();
+          }
+        } catch (err) {
+          logError('unable to parse audigent segment data');
+          onDone();
+        }
+      } else if (req.status === 204) {
+        // unrecognized partner config
+        onDone();
+      }
+    },
+    error: function () {
+      onDone();
+      logError('unable to get audigent segment data');
+    }
+  },
+  JSON.stringify({'userIds': userIds, 'config': reqParams}),
+  {contentType: 'application/json'}
+  );
+}
+
+/**
+ * Module init
+ * @param {Object} provider
+ * @param {Objkect} userConsent
+ * @return {boolean}
+ */
+function init(provider, userConsent) {
+  return true;
+}
+
+/** @type {RtdSubmodule} */
+export const hadronSubmodule = {
+  name: SUBMODULE_NAME,
+  getBidRequestData: getRealTimeData,
+  init: init
+};
+
+submodule(MODULE_NAME, hadronSubmodule);