initial refactor of prebidServerBidAdapter working w/o tests

modules/prebidServerBidAdapter.js

@@ -0,0 +1,343 @@
+import Adapter from 'src/adapter';
+import bidfactory from 'src/bidfactory';
+import * as utils from 'src/utils';
+import { ajax } from 'src/ajax';
+import { STATUS, S2S } from 'src/constants';
+import { cookieSet } from 'src/cookie.js';
+import adaptermanager from 'src/adaptermanager';
+import { config } from 'src/config';
+import { VIDEO } from 'src/mediaTypes';
+import CONSTANTS from 'src/constants.json';
+
+const getConfig = config.getConfig;
+
+const TYPE = S2S.SRC;
+const cookieSetUrl = 'https://acdn.adnxs.com/cookieset/cs.js';
+let _synced = false;
+
+let _s2sConfigDefaults = {
+  enabled: false,
+  endpoint: CONSTANTS.S2S.DEFAULT_ENDPOINT,
+  timeout: 1000,
+  maxBids: 1,
+  adapter: CONSTANTS.S2S.ADAPTER,
+  syncEndpoint: CONSTANTS.S2S.SYNC_ENDPOINT,
+  cookieSet: true,
+  bidders: []
+};
+let _s2sConfig = _s2sConfigDefaults;
+
+/**
+ * Set config for server to server header bidding
+ * @typedef {Object} options - required
+ * @property {boolean} enabled enables S2S bidding
+ * @property {string[]} bidders bidders to request S2S
+ *  === optional params below ===
+ * @property {string} [endpoint] endpoint to contact
+ * @property {number} [timeout] timeout for S2S bidders - should be lower than `pbjs.requestBids({timeout})`
+ * @property {string} [adapter] adapter code to use for S2S
+ * @property {string} [syncEndpoint] endpoint URL for syncing cookies
+ * @property {boolean} [cookieSet] enables cookieSet functionality
+ */
+export function setS2sConfig(options) {
+  let keys = Object.keys(options);
+  if (!keys.includes('accountId')) {
+    utils.logError('accountId missing in Server to Server config');
+    return;
+  }
+
+  if (!keys.includes('bidders')) {
+    utils.logError('bidders missing in Server to Server config');
+    return;
+  }
+  _s2sConfig = Object.assign({}, _s2sConfigDefaults, options);
+  if (options.syncEndpoint) {
+    queueSync(options.bidders);
+  }
+}
+getConfig('s2sConfig', ({s2sConfig}) => setS2sConfig(s2sConfig));
+
+/**
+ * @param  {Array} bidderCodes list of bidders to request user syncs for.
+ */
+function queueSync(bidderCodes) {
+  if (_synced) {
+    return;
+  }
+  _synced = true;
+  const payload = JSON.stringify({
+    uuid: utils.generateUUID(),
+    bidders: bidderCodes
+  });
+  ajax(_s2sConfig.syncEndpoint, (response) => {
+    try {
+      response = JSON.parse(response);
+      response.bidder_status.forEach(bidder => doBidderSync(bidder.usersync.type, bidder.usersync.url, bidder.bidder));
+    } catch (e) {
+      utils.logError(e);
+    }
+  },
+  payload, {
+    contentType: 'text/plain',
+    withCredentials: true
+  });
+}
+
+/**
+ * Try to convert a value to a type.
+ * If it can't be done, the value will be returned.
+ *
+ * @param {string} typeToConvert The target type. e.g. "string", "number", etc.
+ * @param {*} value The value to be converted into typeToConvert.
+ */
+function tryConvertType(typeToConvert, value) {
+  if (typeToConvert === 'string') {
+    return value && value.toString();
+  } else if (typeToConvert === 'number') {
+    return Number(value);
+  } else {
+    return value;
+  }
+}
+
+const tryConvertString = tryConvertType.bind(null, 'string');
+const tryConvertNumber = tryConvertType.bind(null, 'number');
+
+const paramTypes = {
+  'appnexus': {
+    'member': tryConvertString,
+    'invCode': tryConvertString,
+    'placementId': tryConvertNumber
+  },
+  'rubicon': {
+    'accountId': tryConvertNumber,
+    'siteId': tryConvertNumber,
+    'zoneId': tryConvertNumber
+  },
+  'indexExchange': {
+    'siteID': tryConvertNumber
+  },
+  'audienceNetwork': {
+    'placementId': tryConvertString
+  },
+  'pubmatic': {
+    'publisherId': tryConvertString,
+    'adSlot': tryConvertString
+  },
+  'districtm': {
+    'member': tryConvertString,
+    'invCode': tryConvertString,
+    'placementId': tryConvertNumber
+  },
+  'pulsepoint': {
+    'cf': tryConvertString,
+    'cp': tryConvertNumber,
+    'ct': tryConvertNumber
+  },
+};
+
+let _cookiesQueued = false;
+
+/**
+ * Bidder adapter for Prebid Server
+ */
+export function PrebidServer() {
+  let baseAdapter = new Adapter('prebidServer');
+
+  function convertTypes(adUnits) {
+    adUnits.forEach(adUnit => {
+      adUnit.bids.forEach(bid => {
+        const types = paramTypes[bid.bidder] || [];
+        Object.keys(types).forEach(key => {
+          if (bid.params[key]) {
+            const converted = types[key](bid.params[key]);
+            if (converted !== bid.params[key]) {
+              utils.logMessage(`Mismatched type for Prebid Server : ${bid.bidder} : ${key}. Required Type:${types[key]}`);
+            }
+            bid.params[key] = converted;
+
+            // don't send invalid values
+            if (isNaN(bid.params[key])) {
+              delete bid.params.key;
+            }
+          }
+        });
+      });
+    });
+  }
+
+  /* Prebid executes this function when the page asks to send out bid requests */
+  baseAdapter.callBids = function(bidRequest, bidRequests, addBidResponse, done, ajax) {
+    const isDebug = !!getConfig('debug');
+    const adUnits = utils.cloneJson(bidRequest.ad_units);
+    adUnits.forEach(adUnit => {
+      let videoMediaType = utils.deepAccess(adUnit, 'mediaTypes.video');
+      if (videoMediaType) {
+        // pbs expects a ad_unit.video attribute if the imp is video
+        adUnit.video = Object.assign({}, videoMediaType);
+        delete adUnit.mediaTypes;
+        // default is assumed to be 'banner' so if there is a video type we assume video only until PBS can support multi format auction.
+        adUnit.media_types = [VIDEO];
+      }
+    });
+    convertTypes(adUnits);
+    let requestJson = {
+      account_id: _s2sConfig.accountId,
+      tid: bidRequest.tid,
+      max_bids: _s2sConfig.maxBids,
+      timeout_millis: _s2sConfig.timeout,
+      secure: _s2sConfig.secure,
+      url: utils.getTopWindowUrl(),
+      prebid_version: '$prebid.version$',
+      ad_units: adUnits.filter(hasSizes),
+      is_debug: isDebug
+    };
+
+    // in case config.bidders contains invalid bidders, we only process those we sent requests for.
+    const requestedBidders = requestJson.ad_units.map(adUnit => adUnit.bids.map(bid => bid.bidder).filter(utils.uniques)).reduce(utils.flatten).filter(utils.uniques);
+    function processResponse(response) {
+      handleResponse(response, requestedBidders, bidRequests, addBidResponse, done);
+    }
+    const payload = JSON.stringify(requestJson);
+    ajax(_s2sConfig.endpoint, processResponse, payload, {
+      contentType: 'text/plain',
+      withCredentials: true
+    });
+  };
+
+  // at this point ad units should have a size array either directly or mapped so filter for that
+  function hasSizes(unit) {
+    return unit.sizes && unit.sizes.length;
+  }
+
+  /**
+   * Run a cookie sync for the given type, url, and bidder
+   *
+   * @param {string} type the type of sync, "image", "redirect", "iframe"
+   * @param {string} url the url to sync
+   * @param {string} bidder name of bidder doing sync for
+   */
+  function doBidderSync(type, url, bidder) {
+    if (!url) {
+      utils.logError(`No sync url for bidder "${bidder}": ${url}`);
+    } else if (type === 'image' || type === 'redirect') {
+      utils.logMessage(`Invoking image pixel user sync for bidder: "${bidder}"`);
+      utils.triggerPixel(url);
+    } else if (type == 'iframe') {
+      utils.logMessage(`Invoking iframe user sync for bidder: "${bidder}"`);
+      utils.insertUserSyncIframe(url);
+    } else {
+      utils.logError(`User sync type "${type}" not supported for bidder: "${bidder}"`);
+    }
+  }
+
+  /* Notify Prebid of bid responses so bids can get in the auction */
+  function handleResponse(response, requestedBidders, bidRequests, addBidResponse, done) {
+    let result;
+    try {
+      result = JSON.parse(response);
+
+      if (result.status === 'OK' || result.status === 'no_cookie') {
+        if (result.bidder_status) {
+          result.bidder_status.forEach(bidder => {
+            if (bidder.no_cookie && !_cookiesQueued) {
+              doBidderSync(bidder.usersync.type, bidder.usersync.url, bidder.bidder);
+            }
+          });
+        }
+
+        // do client-side syncs if available
+        requestedBidders.forEach(bidder => {
+          let clientAdapter = adaptermanager.getBidAdapter(bidder);
+          if (clientAdapter && clientAdapter.registerSyncs) {
+            clientAdapter.registerSyncs();
+          }
+        });
+
+        if (result.bids) {
+          result.bids.forEach(bidObj => {
+            let bidRequest = utils.getBidRequest(bidObj.bid_id, bidRequests);
+            let cpm = bidObj.price;
+            let status;
+            if (cpm !== 0) {
+              status = STATUS.GOOD;
+            } else {
+              status = STATUS.NO_BID;
+            }
+
+            let bidObject = bidfactory.createBid(status, bidRequest);
+            bidObject.source = TYPE;
+            bidObject.creative_id = bidObj.creative_id;
+            bidObject.bidderCode = bidObj.bidder;
+            bidObject.cpm = cpm;
+            // From ORTB see section 4.2.3: adm Optional means of conveying ad markup in case the bid wins; supersedes the win notice if markup is included in both.
+            if (bidObj.media_type === VIDEO) {
+              bidObject.mediaType = VIDEO;
+              if (bidObj.adm) {
+                bidObject.vastXml = bidObj.adm;
+              }
+              if (bidObj.nurl) {
+                bidObject.vastUrl = bidObj.nurl;
+              }
+            } else {
+              if (bidObj.adm && bidObj.nurl) {
+                bidObject.ad = bidObj.adm;
+                bidObject.ad += utils.createTrackPixelHtml(decodeURIComponent(bidObj.nurl));
+              } else if (bidObj.adm) {
+                bidObject.ad = bidObj.adm;
+              } else if (bidObj.nurl) {
+                bidObject.adUrl = bidObj.nurl
+              }
+            }
+
+            bidObject.width = bidObj.width;
+            bidObject.height = bidObj.height;
+            bidObject.adserverTargeting = bidObj.ad_server_targeting;
+            if (bidObj.deal_id) {
+              bidObject.dealId = bidObj.deal_id;
+            }
+
+            addBidResponse(bidObj.code, bidObject);
+          });
+        }
+
+        // const receivedBidIds = result.bids ? result.bids.map(bidObj => bidObj.bid_id) : [];
+
+        // issue a no-bid response for every bid request that can not be matched with received bids
+        // requestedBidders.forEach(bidder => {
+        //   utils
+        //     .getBidderRequestAllAdUnits(bidder)
+        //     .bids.filter(bidRequest => !receivedBidIds.includes(bidRequest.bidId))
+        //     .forEach(bidRequest => {
+        //       let bidObject = bidfactory.createBid(STATUS.NO_BID, bidRequest);
+        //       bidObject.source = TYPE;
+        //       bidObject.adUnitCode = bidRequest.placementCode;
+        //       bidObject.bidderCode = bidRequest.bidder;
+        //       addBidResponse(bidObject.adUnitCode, bidObject);
+        //     });
+        // });
+      }
+      if (result.status === 'no_cookie' && _s2sConfig.cookieSet) {
+        // cookie sync
+        cookieSet(cookieSetUrl);
+      }
+    } catch (error) {
+      utils.logError(error);
+    }
+
+    if (!result || (result.status && result.status.includes('Error'))) {
+      utils.logError('error parsing response: ', result.status);
+    }
+
+    done();
+  }
+
+  return Object.assign(this, {
+    callBids: baseAdapter.callBids,
+    setBidderCode: baseAdapter.setBidderCode,
+    type: TYPE
+  });
+}
+
+adaptermanager.registerBidAdapter(new PrebidServer(), 'prebidServer');
+