prebid.js 6.7.0 → 6.11.0

package/modules/trustpidSystem.js

@@ -0,0 +1,197 @@
+/**
+ * This module adds TrustPid provided by Vodafone Sales and Services Limited to the User ID module
+ * The {@link module:modules/userId} module is required
+ * @module modules/trustpidSystem
+ * @requires module:modules/userId
+ */
+import { logInfo, logError } from '../src/utils.js';
+import { submodule } from '../src/hook.js';
+import { getStorageManager } from '../src/storageManager.js';
+
+const MODULE_NAME = 'trustpid';
+const LOG_PREFIX = 'Trustpid module'
+let mnoAcronym = '';
+let mnoDomain = '';
+
+export const storage = getStorageManager(null, MODULE_NAME);
+
+/**
+ * Handle an event for an iframe.
+ * Takes the body.url parameter from event and returns the string domain.
+ * i.e.: "fc.vodafone.de"
+ * @param event
+ */
+function messageHandler(event) {
+  let msg;
+  try {
+    if (event && event.data && typeof event.data === 'string' && event.data) {
+      msg = JSON.parse(event.data);
+      if (msg.msgType === 'MNOSELECTOR' && msg.body && msg.body.url) {
+        let URL = msg.body.url.split('//');
+        let domainURL = URL[1].split('/');
+        mnoDomain = domainURL[0];
+        logInfo(`${LOG_PREFIX}: Message handler set domain to ${mnoDomain}`);
+        getDomainAcronym(mnoDomain);
+      }
+    }
+  } catch (e) {
+    logError(e);
+  }
+}
+
+/**
+ * Properly sets the trustpid acronym depending on the domain value.
+ * @param domain
+ */
+function getDomainAcronym(domain) {
+  let acronym = '';
+  const prefix = '-';
+  switch (domain) {
+    case 'tmi.mno.link':
+      acronym = 'ndye';
+      break;
+    case 'tmi.vodafone.de':
+      acronym = 'pqnx';
+      break;
+    case 'tmi.telekom.de':
+      acronym = 'avgw';
+      break;
+    case 'tmi.tmid.es':
+      acronym = 'kjws';
+      break;
+    case 'uat.mno.link':
+      acronym = 'xxxx';
+      break;
+    case 'es.tmiservice.orange.com':
+      acronym = 'aplw';
+      break;
+    default:
+      return 'none';
+  }
+  return mnoAcronym = prefix + acronym;
+}
+
+// Set a listener to handle the iframe response message.
+window.addEventListener('message', messageHandler, false);
+
+/**
+ * Get the "umid" from html5 local storage to make it available to the UserId module.
+ * @param config
+ * @returns {{trustpid: (*|string), acr: (string)}}
+ */
+function getTrustpidFromStorage() {
+  // Get the domain either from localStorage or global
+  let domain = JSON.parse(storage.getDataFromLocalStorage('fcIdConnectDomain')) || mnoDomain;
+  logInfo(`${LOG_PREFIX}: Local storage domain: ${domain}`);
+
+  if (!domain) {
+    logInfo(`${LOG_PREFIX}: Local storage domain not found, returning null`);
+    return {
+      trustpid: null,
+      acr: null,
+    };
+  }
+
+  // Get the acronym from global
+  let acronym = mnoAcronym;
+  // if acronym is empty, but "domain" is available, get the acronym from domain
+  if (!acronym) {
+    getDomainAcronym(domain);
+    acronym = mnoAcronym;
+  }
+
+  logInfo(`${LOG_PREFIX}: Domain acronym found: ${acronym}`);
+
+  // Domain is correct in both local storage and idGraph, but no acronym is existing for the domain
+  if (domain && !acronym) {
+    return {
+      trustpid: null,
+      acr: null
+    }
+  }
+
+  let fcIdConnectObject;
+  let fcIdConnectData = JSON.parse(storage.getDataFromLocalStorage('fcIdConnectData'));
+  logInfo(`${LOG_PREFIX}: Local storage fcIdConnectData: ${JSON.stringify(fcIdConnectData)}`);
+
+  if (fcIdConnectData &&
+    fcIdConnectData.connectId &&
+    Array.isArray(fcIdConnectData.connectId.idGraph) &&
+    fcIdConnectData.connectId.idGraph.length > 0) {
+    fcIdConnectObject = fcIdConnectData.connectId.idGraph.find(item => {
+      return item.domain === domain;
+    });
+  }
+  logInfo(`${LOG_PREFIX}: Local storage fcIdConnectObject for domain: ${JSON.stringify(fcIdConnectObject)}`);
+
+  return {
+    trustpid: (fcIdConnectObject && fcIdConnectObject.umid)
+      ? fcIdConnectObject.umid
+      : null,
+    acr: acronym,
+  };
+}
+
+/** @type {Submodule} */
+export const trustpidSubmodule = {
+  /**
+   * Used to link submodule with config
+   * @type {string}
+   */
+  name: MODULE_NAME,
+  /**
+   * Decodes the stored id value for passing to bid requests.
+   * @function
+   * @returns {{trustpid: string} | null}
+   */
+  decode(bidId) {
+    logInfo(`${LOG_PREFIX}: Decoded ID value ${JSON.stringify(bidId)}`);
+    return bidId.trustpid ? bidId : null;
+  },
+  /**
+   * Get the id from helper function and initiate a new user sync.
+   * @param config
+   * @returns {{callback: result}|{id: {trustpid: string}}}
+   */
+  getId: function(config) {
+    const data = getTrustpidFromStorage();
+    if (data.trustpid) {
+      logInfo(`${LOG_PREFIX}: Local storage ID value ${JSON.stringify(data)}`);
+      return {id: {trustpid: data.trustpid + data.acr}};
+    } else {
+      if (!config) {
+        config = {};
+      }
+      if (!config.params) {
+        config.params = {};
+      }
+      if (typeof config.params.maxDelayTime === 'undefined' || config.params.maxDelayTime === null) {
+        config.params.maxDelayTime = 1000;
+      }
+      // Current delay and delay step in milliseconds
+      let currentDelay = 0;
+      const delayStep = 50;
+      const result = (callback) => {
+        const data = getTrustpidFromStorage();
+        if (!data.trustpid) {
+          if (currentDelay > config.params.maxDelayTime) {
+            logInfo(`${LOG_PREFIX}: No trustpid value set after ${config.params.maxDelayTime} max allowed delay time`);
+            callback(null);
+          } else {
+            currentDelay += delayStep;
+            setTimeout(() => {
+              result(callback);
+            }, delayStep);
+          }
+        } else {
+          const dataToReturn = { trustpid: data.trustpid + data.acr };
+          logInfo(`${LOG_PREFIX}: Returning ID value data of ${JSON.stringify(dataToReturn)}`);
+          callback(dataToReturn);
+        }
+      };
+      return { callback: result };
+    }
+  },
+};
+
+submodule('userId', trustpidSubmodule);

package/modules/trustpidSystem.md

@@ -0,0 +1,45 @@
+## trustpid User Id Submodule
+
+trustpid User Id Module.
+
+First, make sure to add the trustpid submodule to your Prebid.js package with:
+
+```
+gulp build --modules=userId,adfBidAdapter,trustpidSystem
+```
+
+The following configuration parameters are available:
+
+```
+pbjs.setConfig({
+  userSync: {
+    userIds: [
+      {
+        name: 'trustpid',
+        params: {
+          maxDelayTime: 1000, 
+        },
+        bidders: ["adf"],
+        storage: {
+          type: "html5",
+          name: "trustpid",
+          expires: 1, //days
+        },
+      }
+    ],
+  }
+});
+```
+
+## Parameter Descriptions
+
+| Param under userSync.userIds[] | Scope | Type | Description | Example |
+| --- | --- | --- | --- | --- |
+| name | Required | String | The name of the module | `"trustpid"`
+| params | Required | Object | Object with configuration parameters for trustpid User Id submodule | - |
+| params.maxDelayTime | Required | Integer | Max amount of time (in seconds) before looking into storage for data | 2500 |
+| bidders | Required | Array of Strings | An array of bidder codes to which this user ID may be sent. Currently required and supporting AdformOpenRTB | `["adf"]` |
+| storage | Required | Object | Local storage configuration object | - |
+| storage.type | Required | String | Type of the storage that would be used to store user ID. Must be `"html5"` to utilise HTML5 local storage. | `"html5"` |
+| storage.name | Required | String | The name of the key in local storage where the user ID will be stored. | `"trustpid"` |
+| storage.expires | Required | Integer | How long (in days) the user ID information will be stored. For safety reasons, this information is required.| `1` |

package/modules/undertoneBidAdapter.js

@@ -12,6 +12,20 @@ const FRAME_USER_SYNC = 'https://cdn.undertone.com/js/usersync.html';
 const PIXEL_USER_SYNC_1 = 'https://usr.undertone.com/userPixel/syncOne?id=1&of=2';
 const PIXEL_USER_SYNC_2 = 'https://usr.undertone.com/userPixel/syncOne?id=2&of=2';
 
+function getBidFloor(bidRequest, mediaType) {
+  if (typeof bidRequest.getFloor !== 'function') {
+    return 0;
+  }
+
+  const floor = bidRequest.getFloor({
+    currency: 'USD',
+    mediaType: mediaType,
+    size: '*'
+  });
+
+  return (floor && floor.currency === 'USD' && floor.floor) || 0;
+}
+
 function getCanonicalUrl() {
   try {
     let doc = window.top.document;
@@ -134,6 +148,9 @@ export const spec = {
         params: bidReq.params
       };
       const videoMediaType = deepAccess(bidReq, 'mediaTypes.video');
+      const mediaType = videoMediaType ? VIDEO : BANNER;
+      bid.mediaType = mediaType;
+      bid.bidfloor = getBidFloor(bidReq, mediaType);
       if (videoMediaType) {
         bid.video = {
           playerSize: deepAccess(bidReq, 'mediaTypes.video.playerSize') || null,
@@ -142,7 +159,6 @@ export const spec = {
           maxDuration: deepAccess(bidReq, 'params.video.maxDuration') || null,
           skippable: deepAccess(bidReq, 'params.video.skippable') || null
         };
-        bid.mediaType = 'video';
       }
       payload['x-ut-hb-params'].push(bid);
     });

package/modules/userId/eids.js

@@ -5,6 +5,15 @@ const USER_IDS_CONFIG = {
 
   // key-name : {config}
 
+  // trustpid
+  'trustpid': {
+    source: 'trustpid.com',
+    atype: 1,
+    getValue: function (data) {
+      return data;
+    },
+  },
+
   // intentIqId
   'intentIqId': {
     source: 'intentiq.com',
@@ -146,7 +155,13 @@ const USER_IDS_CONFIG = {
     atype: 1
   },
 
-  // haloId
+  // hadronId
+  'hadronId': {
+    source: 'audigent.com',
+    atype: 1
+  },
+
+  // haloId (deprecated in 7.0, use hadronId)
   'haloId': {
     source: 'audigent.com',
     atype: 1

package/modules/userId/eids.md

@@ -2,6 +2,14 @@
 
 ```
 userIdAsEids = [
+    {
+        source: 'trustpid.com',
+        uids: [{
+            id: 'some-random-id-value',
+            atype: 1
+        }]
+    },
+
     {
         source: 'pubcid.org',
         uids: [{
@@ -28,7 +36,7 @@ userIdAsEids = [
             atype: 1
         }]
     },
-    
+
     {
         source: 'neustar.biz',
         uids: [{
@@ -203,7 +211,7 @@ userIdAsEids = [
             id: 'some-random-id-value',
             atype: 3
         }]
-    }, 
+    },
     {
          source: 'kpuid.com',
          uids: [{

package/modules/userId/userId.md

@@ -1,6 +1,7 @@
 ## User ID Example Configuration
 
 Example showing `cookie` storage for user id data for each of the submodules
+
 ```
 pbjs.setConfig({
     userSync: {
@@ -147,10 +148,23 @@ pbjs.setConfig({
 ```
 
 Example showing `localStorage` for user id data for some submodules
+
 ```
 pbjs.setConfig({
     userSync: {
-        userIds: [{
+        userIds: [
+            {
+            name: 'trustpid',
+            params: {
+              maxDelayTime: 2500
+            },
+            bidders: ['adform'],
+            storage: {
+              type: 'html5',
+              name: 'trustpid',
+              expires: 60
+            }
+        }, {
             name: "unifiedId",
             params: {
                 partner: "prebid",
@@ -278,7 +292,7 @@ pbjs.setConfig({
                  name: "knssoId",
                  expires: 30
                   },
-        }   
+        }
         },
         {
             name: 'imuid',
@@ -312,6 +326,7 @@ pbjs.setConfig({
 ```
 
 Example showing how to configure a `value` object to pass directly to bid adapters
+
 ```
 pbjs.setConfig({
     userSync: {

package/modules/vibrantmediaBidAdapter.js

@@ -0,0 +1,220 @@
+/*
+ * Vibrant Media Ltd.
+ *
+ * Prebid Adapter for sending bid requests to the prebid server and bid responses back to the client
+ *
+ * Note: Only BANNER and VIDEO are currently supported by the prebid server.
+ */
+
+import {logError, logInfo} from '../src/utils.js';
+import {registerBidder} from '../src/adapters/bidderFactory.js';
+import {BANNER, NATIVE, VIDEO} from '../src/mediaTypes.js';
+import {OUTSTREAM} from '../src/video.js';
+
+const BIDDER_CODE = 'vibrantmedia';
+const VIBRANT_MEDIA_PREBID_URL = 'https://prebid.intellitxt.com/prebid';
+const SUPPORTED_MEDIA_TYPES = [BANNER, NATIVE, VIDEO];
+
+/**
+ * Returns whether the given bid request contains at least one supported media request, which has valid data. (We can
+ * ignore invalid/unsupported ones, as they will be filtered out by the prebid server.)
+ *
+ * @param {*} bidRequest the bid requests sent by the Prebid API.
+ *
+ * @return {boolean} true if the given bid request contains at least one supported media request with valid details,
+ *                   otherwise false.
+ */
+const areValidSupportedMediaTypesPresent = function(bidRequest) {
+  const mediaTypes = Object.keys(bidRequest.mediaTypes);
+
+  return mediaTypes.some(function(mediaType) {
+    if (mediaType === BANNER) {
+      return true;
+    } else if (mediaType === VIDEO) {
+      return (bidRequest.mediaTypes[VIDEO].context === OUTSTREAM);
+    } else if (mediaType === NATIVE) {
+      return !!bidRequest.mediaTypes[NATIVE].image;
+    }
+
+    return false;
+  });
+};
+
+/**
+ * Returns whether the given URL contains just a domain, and not (for example) a subdirectory or query parameters.
+ * @param {string} url the URL to check.
+ * @returns {boolean} whether the URL contains just a domain.
+ */
+const isBaseUrl = function(url) {
+  const urlMinusScheme = url.substring(url.indexOf('://') + 3);
+  const endOfDomain = urlMinusScheme.indexOf('/');
+  return (endOfDomain === -1) || (endOfDomain === (urlMinusScheme.length - 1));
+};
+
+/**
+ * Returns transformed bid requests that are in a format native to the prebid server.
+ *
+ * @param {*[]} bidRequests the bid requests sent by the Prebid API.
+ *
+ * @returns {*[]} the transformed bid requests.
+ */
+const transformBidRequests = function(bidRequests) {
+  const transformedBidRequests = [];
+
+  bidRequests.forEach(function(bidRequest) {
+    const params = bidRequest.params || {};
+    const transformedBidRequest = {
+      code: bidRequest.adUnitCode || bidRequest.code,
+      id: bidRequest.placementId || params.placementId || params.invCode,
+      requestId: bidRequest.bidId || bidRequest.transactionId,
+      bidder: bidRequest.bidder,
+      mediaTypes: bidRequest.mediaTypes,
+      bids: bidRequest.bids,
+      sizes: bidRequest.sizes
+    };
+
+    transformedBidRequests.push(transformedBidRequest);
+  });
+
+  return transformedBidRequests;
+};
+
+/** @type {BidderSpec} */
+export const spec = {
+  code: BIDDER_CODE,
+  supportedMediaTypes: SUPPORTED_MEDIA_TYPES,
+
+  /**
+   * Transforms the 'raw' bid params into ones that this adapter can use, prior to creating the bid request.
+   *
+   * @param {object} bidParams the params to transform.
+   *
+   * @returns {object} the bid params.
+   */
+  transformBidParams: function(bidParams) {
+    return bidParams;
+  },
+
+  /**
+   * Determines whether or not the given bid request is valid. For all bid requests passed to the buildRequests
+   * function, each will have been passed to this function and this function will have returned true.
+   *
+   * @param {object} bid the bid params to validate.
+   *
+   * @return {boolean} true if this is a valid bid, otherwise false.
+   * @see SUPPORTED_MEDIA_TYPES
+   */
+  isBidRequestValid: function(bid) {
+    const areBidRequestParamsValid = !!(bid.params.placementId || (bid.params.member && bid.params.invCode));
+    return areBidRequestParamsValid && areValidSupportedMediaTypesPresent(bid);
+  },
+
+  /**
+   * Return a prebid server request from the list of bid requests.
+   *
+   * @param {BidRequest[]}  validBidRequests an array of bids validated via the isBidRequestValid function.
+   * @param {BidderRequest} bidderRequest    an object with data common to all bid requests.
+   *
+   * @return ServerRequest Info describing the request to the prebid server.
+   */
+  buildRequests: function(validBidRequests, bidderRequest) {
+    const transformedBidRequests = transformBidRequests(validBidRequests);
+
+    var url = window.parent.location.href;
+
+    if ((window.self === window.top) && (!url || (url.substr(0, 4) !== 'http') || isBaseUrl(url))) {
+      url = document.URL;
+    }
+
+    url = encodeURIComponent(url);
+
+    const prebidData = {
+      url,
+      gdpr: bidderRequest.gdprConsent,
+      usp: bidderRequest.uspConsent,
+      window: {
+        width: window.innerWidth,
+        height: window.innerHeight,
+      },
+      biddata: transformedBidRequests,
+    };
+
+    return {
+      method: 'POST',
+      url: VIBRANT_MEDIA_PREBID_URL,
+      data: JSON.stringify(prebidData)
+    };
+  },
+
+  /**
+   * Translate the Kormorant prebid server response into a list of bids.
+   *
+   * @param {ServerResponse} serverResponse a successful response from the prebid server.
+   * @param {BidRequest}     bidRequest     the original bid request associated with this response.
+   *
+   * @return {Bid[]} an array of bids returned by the prebid server, translated into the expected Prebid.js format.
+   */
+  interpretResponse: function(serverResponse, bidRequest) {
+    const bids = serverResponse.body;
+
+    bids.forEach(function(bid) {
+      bid.adResponse = serverResponse;
+    });
+
+    return bids;
+  },
+
+  /**
+   * Called if the Prebid API gives up waiting for a prebid server response.
+   *
+   * Example timeout data:
+   *
+   * [{
+   *   "bidder": "example",
+   *   "bidId": "51ef8751f9aead",
+   *   "params": {
+   *     ...
+   *   },
+   *   "adUnitCode": "div-gpt-ad-1460505748561-0",
+   *   "timeout": 3000,
+   *   "auctionId": "18fd8b8b0bd757"
+   * }]
+   *
+   * @param {{}} timeoutData data relating to the timeout.
+   */
+  onTimeout: function(timeoutData) {
+    logError('Timed out waiting for bids: ' + JSON.stringify(timeoutData));
+  },
+
+  /**
+   * Called when a bid returned by the prebid server is successful.
+   *
+   * Example bid won data:
+   *
+   * {
+   *   "bidder": "example",
+   *   "width": 300,
+   *   "height": 250,
+   *   "adId": "330a22bdea4cac",
+   *   "mediaType": "banner",
+   *   "cpm": 0.28
+   *   "ad": "...",
+   *   "requestId": "418b37f85e772c",
+   *   "adUnitCode": "div-gpt-ad-1460505748561-0",
+   *   "size": "350x250",
+   *   "adserverTargeting": {
+   *     "hb_bidder": "example",
+   *     "hb_adid": "330a22bdea4cac",
+   *     "hb_pb": "0.20",
+   *     "hb_size": "350x250"
+   *   }
+   * }
+   *
+   * @param {*} bidData the data associated with the won bid. See example above for data format.
+   */
+  onBidWon: function(bidData) {
+    logInfo('Bid won: ' + JSON.stringify(bidData));
+  }
+};
+
+registerBidder(spec);

package/modules/vibrantmediaBidAdapter.md

@@ -0,0 +1,92 @@
+## Overview
+
+**Module Name:** Vibrant Media Bidder Adapter
+
+**Module Type:** Bidder Adapter
+
+**Maintainer:** kormorant@vibrantmedia.com
+
+## Description
+
+Module that allows Vibrant Media to provide ad bids for banner, native and video (outstream only).
+
+## Test Parameters
+
+```javascript
+var adUnits = [
+  // Banner ad unit
+  {
+    code: 'test-banner',
+    mediaTypes: {
+      banner: {
+        sizes: [[300, 250], [300, 600]]
+      }
+    },
+    bids: [{
+      bidder: 'vibrantmedia',
+      params: {
+        placementId: 12345
+      }
+    }]
+  },
+
+  // Video (outstream) ad unit
+  {
+    code: 'test-video-outstream',
+    sizes: [[300, 250]],
+    mediaTypes: {
+      video: {
+        playerSize: [[300, 250]],
+        context: 'outstream',
+        minduration: 1,      // Minimum ad duration, in seconds
+        maxduration: 60,     // Maximum ad duration, in seconds
+        skip: 0,             // 1 - true, 0 - false
+        skipafter: 5,        // Number of seconds before the video can be skipped
+        playbackmethod: [2], // Auto-play without sound
+        protocols: [1, 2, 3] // VAST 1.0, 2.0 and 3.0
+      }
+    },
+    bids: [
+      {
+        bidder: 'vibrantmedia',
+        params: {
+          placementId: 67890,
+          video: {
+            skippable: true,
+            playback_method: 'auto_play_sound_off'
+          }
+        }
+      }
+    ]
+  },
+
+  // Native ad unit
+  {
+    code: 'test-native',
+    mediaTypes: {
+      native: {
+        image: {
+          required: true,
+          sizes: [300, 250]
+        },
+        title: {
+          required: true
+        },
+        sponsoredBy: {
+          required: true
+        },
+        clickUrl: {
+          required: true
+        },
+      }
+    },
+    bids: [{
+      bidder: 'vibrantmedia',
+      params: {
+        placementId: 13579,
+        allowSmallerSizes: true
+      }
+    }]
+  }
+];
+```