prebid.js 8.44.0 → 8.46.0

package/modules/jwplayerBidAdapter.js

@@ -0,0 +1,412 @@
+import { registerBidder } from '../src/adapters/bidderFactory.js';
+import { VIDEO } from '../src/mediaTypes.js';
+import { isArray, isFn, deepAccess, deepSetValue, getDNT, logError, logWarn } from '../src/utils.js';
+import { config } from '../src/config.js';
+import { hasPurpose1Consent } from '../src/utils/gpdr.js';
+
+const BIDDER_CODE = 'jwplayer';
+const BASE_URL = 'https://vpb-server.jwplayer.com/';
+const AUCTION_URL = BASE_URL + 'openrtb2/auction';
+const USER_SYNC_URL = BASE_URL + 'setuid';
+const GVLID = 1046;
+const SUPPORTED_AD_TYPES = [VIDEO];
+
+const VIDEO_ORTB_PARAMS = [
+  'pos',
+  'w',
+  'h',
+  'playbackend',
+  'mimes',
+  'minduration',
+  'maxduration',
+  'protocols',
+  'startdelay',
+  'placement',
+  'plcmt',
+  'skip',
+  'skipafter',
+  'minbitrate',
+  'maxbitrate',
+  'delivery',
+  'playbackmethod',
+  'api',
+  'linearity'
+];
+
+function getBidAdapter() {
+  function isBidRequestValid(bid) {
+    const params = bid && bid.params;
+    if (!params) {
+      return false;
+    }
+
+    return !!params.placementId && !!params.publisherId && !!params.siteId;
+  }
+
+  function buildRequests(bidRequests, bidderRequest) {
+    if (!bidRequests) {
+      return;
+    }
+
+    if (!hasContentUrl(bidderRequest.ortb2)) {
+      logError(`${BIDDER_CODE}: cannot bid without a valid Content URL. Please populate ortb2.site.content.url`);
+      return;
+    }
+
+    const warnings = getWarnings(bidderRequest);
+    warnings.forEach(warning => {
+      logWarn(`${BIDDER_CODE}: ${warning}`);
+    });
+
+    return bidRequests.map(bidRequest => {
+      const payload = buildRequest(bidRequest, bidderRequest);
+
+      return {
+        method: 'POST',
+        url: AUCTION_URL,
+        data: payload
+      }
+    });
+  }
+
+  function interpretResponse(serverResponse) {
+    const outgoingBidResponses = [];
+    const serverResponseBody = serverResponse.body;
+
+    logResponseWarnings(serverResponseBody);
+
+    const seatBids = serverResponseBody && serverResponseBody.seatbid;
+    if (!isArray(seatBids)) {
+      return outgoingBidResponses;
+    }
+
+    const cur = serverResponseBody.cur;
+
+    seatBids.forEach(seatBid => {
+      seatBid.bid.forEach(bid => {
+        const bidResponse = {
+          requestId: serverResponseBody.id,
+          cpm: bid.price,
+          currency: cur,
+          width: bid.w,
+          height: bid.h,
+          ad: bid.adm,
+          vastXml: bid.adm,
+          ttl: bid.ttl || 3600,
+          netRevenue: false,
+          creativeId: bid.adid,
+          dealId: bid.dealid,
+          meta: {
+            advertiserDomains: bid.adomain,
+            mediaType: VIDEO,
+            primaryCatId: bid.cat,
+          }
+        };
+
+        outgoingBidResponses.push(bidResponse);
+      });
+    });
+
+    return outgoingBidResponses;
+  }
+
+  function getUserSyncs(syncOptions, serverResponses, gdprConsent, uspConsent) {
+    if (!hasPurpose1Consent(gdprConsent)) {
+      return [];
+    }
+
+    const userSyncs = [];
+    const consentQueryParams = getUserSyncConsentQueryParams(gdprConsent);
+    const url = `https://ib.adnxs.com/getuid?${USER_SYNC_URL}?bidder=jwplayer&uid=$UID&f=i` + consentQueryParams
+
+    if (syncOptions.iframeEnabled) {
+      userSyncs.push({
+        type: 'iframe',
+        url
+      });
+    }
+
+    if (syncOptions.pixelEnabled) {
+      userSyncs.push({
+        type: 'image',
+        url
+      });
+    }
+
+    return userSyncs;
+  }
+
+  return {
+    code: BIDDER_CODE,
+    gvlid: GVLID,
+    supportedMediaTypes: SUPPORTED_AD_TYPES,
+    isBidRequestValid,
+    buildRequests,
+    interpretResponse,
+    getUserSyncs
+  }
+
+  function getUserSyncConsentQueryParams(gdprConsent) {
+    if (!gdprConsent) {
+      return '';
+    }
+
+    const consentString = gdprConsent.consentString;
+    if (!consentString) {
+      return '';
+    }
+
+    let gdpr = 0;
+    const gdprApplies = gdprConsent.gdprApplies;
+    if (typeof gdprApplies === 'boolean') {
+      gdpr = Number(gdprApplies)
+    }
+
+    return `&gdpr=${gdpr}&gdpr_consent=${consentString}`;
+  }
+
+  function buildRequest(bidRequest, bidderRequest) {
+    const openrtbRequest = {
+      id: bidRequest.bidId,
+      imp: getRequestImpressions(bidRequest, bidderRequest),
+      site: getRequestSite(bidRequest, bidderRequest),
+      device: getRequestDevice(bidderRequest.ortb2),
+      user: getRequestUser(bidderRequest.ortb2),
+    };
+
+    // GDPR Consent Params
+    if (bidderRequest.gdprConsent) {
+      deepSetValue(openrtbRequest, 'user.ext.consent', bidderRequest.gdprConsent.consentString);
+      deepSetValue(openrtbRequest, 'regs.ext.gdpr', (bidderRequest.gdprConsent.gdprApplies ? 1 : 0));
+    }
+
+    // CCPA
+    if (bidderRequest.uspConsent) {
+      deepSetValue(openrtbRequest, 'regs.ext.us_privacy', bidderRequest.uspConsent);
+    }
+
+    if (bidRequest.schain) {
+      deepSetValue(openrtbRequest, 'source.schain', bidRequest.schain);
+    }
+
+    openrtbRequest.tmax = bidderRequest.timeout || 200;
+
+    return JSON.stringify(openrtbRequest);
+  }
+
+  function getRequestImpressions(bidRequest) {
+    const impressionObject = {
+      id: bidRequest.adUnitCode,
+    };
+
+    impressionObject.video = getImpressionVideo(bidRequest);
+
+    const bidFloorData = getBidFloorData(bidRequest);
+    if (bidFloorData) {
+      impressionObject.bidfloor = bidFloorData.floor;
+      impressionObject.bidfloorcur = bidFloorData.currency;
+    }
+
+    impressionObject.ext = getImpressionExtension(bidRequest);
+
+    return [impressionObject];
+  }
+
+  function getImpressionVideo(bidRequest) {
+    const videoParams = deepAccess(bidRequest, 'mediaTypes.video', {});
+
+    const video = {};
+
+    VIDEO_ORTB_PARAMS.forEach((param) => {
+      if (videoParams.hasOwnProperty(param)) {
+        video[param] = videoParams[param];
+      }
+    });
+
+    setPlayerSize(video, videoParams);
+
+    if (!videoParams.plcmt) {
+      logWarn(`${BIDDER_CODE}: Please set a value to mediaTypes.video.plcmt`);
+    }
+
+    return video;
+  }
+
+  function getImpressionExtension(bidRequest) {
+    return {
+      prebid: {
+        bidder: {
+          jwplayer: {
+            placementId: bidRequest.params.placementId
+          }
+        }
+      }
+    };
+  }
+
+  function setPlayerSize(videoImp, videoParams) {
+    if (videoImp.w !== undefined && videoImp.h !== undefined) {
+      return;
+    }
+
+    const playerSize = getNormalizedPlayerSize(videoParams.playerSize);
+    if (!playerSize.length) {
+      logWarn(logWarn(`${BIDDER_CODE}: Video size has not been set. Please set values in video.h and video.w`));
+      return;
+    }
+
+    if (videoImp.w === undefined) {
+      videoImp.w = playerSize[0];
+    }
+
+    if (videoImp.h === undefined) {
+      videoImp.h = playerSize[1];
+    }
+  }
+
+  function getNormalizedPlayerSize(playerSize) {
+    if (!Array.isArray(playerSize)) {
+      return [];
+    }
+
+    if (Array.isArray(playerSize[0])) {
+      playerSize = playerSize[0];
+    }
+
+    if (playerSize.length < 2) {
+      return [];
+    }
+
+    return playerSize;
+  }
+
+  function getBidFloorData(bidRequest) {
+    const { params } = bidRequest;
+    const currency = params.currency || 'USD';
+
+    let floorData;
+    if (isFn(bidRequest.getFloor)) {
+      const bidFloorRequest = {
+        currency: currency,
+        mediaType: VIDEO,
+        size: '*'
+      };
+      floorData = bidRequest.getFloor(bidFloorRequest);
+    } else if (params.bidFloor) {
+      floorData = { floor: params.bidFloor, currency: currency };
+    }
+
+    return floorData;
+  }
+
+  function getRequestSite(bidRequest, bidderRequest) {
+    const site = bidderRequest.ortb2.site || {};
+
+    site.domain = site.domain || config.publisherDomain || window.location.hostname;
+    site.page = site.page || config.pageUrl || window.location.href;
+
+    const referer = bidderRequest.refererInfo && bidderRequest.refererInfo.referer;
+    if (!site.ref && referer) {
+      site.ref = referer;
+    }
+
+    const jwplayerPublisherExtChain = 'publisher.ext.jwplayer.';
+
+    deepSetValue(site, jwplayerPublisherExtChain + 'publisherId', bidRequest.params.publisherId);
+    deepSetValue(site, jwplayerPublisherExtChain + 'siteId', bidRequest.params.siteId);
+
+    return site;
+  }
+
+  function getRequestDevice(ortb2) {
+    const device = Object.assign({
+      h: screen.height,
+      w: screen.width,
+      ua: navigator.userAgent,
+      dnt: getDNT() ? 1 : 0,
+      js: 1
+    }, ortb2.device || {})
+
+    const language = getLanguage();
+    if (!device.language && language) {
+      device.language = language;
+    }
+
+    return device;
+  }
+
+  function getLanguage() {
+    const navigatorLanguage = navigator.language;
+    if (!navigatorLanguage) {
+      return;
+    }
+
+    const languageCodeSegments = navigatorLanguage.split('-');
+    if (!languageCodeSegments.length) {
+      return;
+    }
+
+    return languageCodeSegments[0];
+  }
+
+  function getRequestUser(ortb2) {
+    const user = ortb2.user || {};
+    if (config.getConfig('coppa') === true) {
+      user.coppa = true;
+    }
+
+    return user;
+  }
+
+  function hasContentUrl(ortb2) {
+    const site = ortb2.site;
+    const content = site && site.content;
+    return !!(content && content.url);
+  }
+
+  function getWarnings(bidderRequest) {
+    const content = bidderRequest.ortb2.site.content;
+    const contentChain = 'ortb2.site.content.';
+    const warnings = [];
+    if (!content.id) {
+      warnings.push(getMissingFieldMessage(contentChain + 'id'));
+    }
+
+    if (!content.title) {
+      warnings.push(getMissingFieldMessage(contentChain + 'title'));
+    }
+
+    if (!content.ext || !content.ext.description) {
+      warnings.push(getMissingFieldMessage(contentChain + 'ext.description'));
+    }
+
+    return warnings;
+  }
+
+  function getMissingFieldMessage(fieldName) {
+    return `Optional field ${fieldName} is not populated; we recommend populating for maximum performance.`
+  }
+
+  function logResponseWarnings(serverResponseBody) {
+    const warningPayload = deepAccess(serverResponseBody, 'ext.warnings');
+    if (!warningPayload) {
+      return;
+    }
+
+    const warningCategories = Object.keys(warningPayload);
+    warningCategories.forEach(category => {
+      const warnings = warningPayload[category];
+      if (!isArray(warnings)) {
+        return;
+      }
+
+      warnings.forEach(warning => {
+        logWarn(`${BIDDER_CODE}: [Bid Response][Warning Code: ${warning.code}] ${warning.message}`);
+      });
+    });
+  }
+}
+
+export const spec = getBidAdapter();
+
+registerBidder(spec);

package/modules/jwplayerBidAdapter.md

@@ -0,0 +1,72 @@
+# Overview
+
+```
+Module Name:  JWPlayer Bid Adapter
+Module Type:  Bidder Adapter
+Maintainer: boost-engineering@jwplayer.com
+```
+
+# Description
+
+Connects to JWPlayer's demand sources.
+
+JWPlayer bid adapter supports Video (instream and outstream).
+
+# Sample Ad Unit
+
+```markdown
+const adUnit = {
+    code: 'test-ad-unit',
+    mediaTypes: {
+    video: {
+        pos: 0,
+        w: 640,
+        h: 480,
+        mimes :  ['video/x-ms-wmv', 'video/mp4'],
+        minduration : 0,
+        maxduration: 60,
+        protocols : [2,3,7,5,6,8],
+        startdelay: 0,
+        placement: 1,
+        plcmt: 1,
+        skip: 1,
+        skipafter: 10,
+        playbackmethod: [3],
+        api: [2],
+        linearity: 1
+    }
+    },
+    bids: [{
+        bidder: 'jwplayer',
+        params: {
+            publisherId: 'test-publisher-id',
+            siteId: 'test-site-id',
+            placementId: 'test-placement-id'
+        }
+    }]
+};
+```
+
+# Sample ortb2 config
+
+```markdown
+pbjs.setConfig({
+    ortb2: {
+        site: {
+            publisher: {
+                id: 'test-publisher-id'
+            },
+            content: {
+                id: 'test-media-id',
+                url: 'test.mp4',
+                title: 'title of my media',
+                ext: {
+                    description: 'description of my media'
+                }
+            },
+            domain: 'test-domain.com',
+            page: 'https://www.test-domain.com/test.html',
+        }
+    }
+}
+```

package/modules/kargoAnalyticsAdapter.js

@@ -2,7 +2,7 @@ import { logError } from '../src/utils.js';
 import { ajax } from '../src/ajax.js';
 import adapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
 import adapterManager from '../src/adapterManager.js';
-import CONSTANTS from '../src/constants.json';
+import { EVENTS } from '../src/constants.js';
 
 const EVENT_URL = 'https://krk.kargo.com/api/v1/event';
 const KARGO_BIDDER_CODE = 'kargo';
@@ -23,11 +23,11 @@ var kargoAnalyticsAdapter = Object.assign(
   adapter({ analyticsType }), {
     track({ eventType, args }) {
       switch (eventType) {
-        case CONSTANTS.EVENTS.AUCTION_INIT: {
+        case EVENTS.AUCTION_INIT: {
           _logBidResponseData.auctionTimeout = args.timeout;
           break;
         }
-        case CONSTANTS.EVENTS.BID_RESPONSE: {
+        case EVENTS.BID_RESPONSE: {
           handleBidResponseData(args);
           break;
         }

package/modules/kargoBidAdapter.js

@@ -195,25 +195,19 @@ function buildRequests(validBidRequests, bidderRequest) {
 }
 
 function interpretResponse(response, bidRequest) {
-  let bids = response.body;
+  const bids = response.body;
   const bidResponses = [];
 
-  if (isEmpty(bids)) {
+  if (isEmpty(bids) || typeof bids !== 'object') {
     return bidResponses;
   }
 
-  if (typeof bids !== 'object') {
-    return bidResponses;
-  }
-
-  Object.entries(bids).forEach((entry) => {
-    const [bidID, adUnit] = entry;
-
+  for (const [bidID, adUnit] of Object.entries(bids)) {
     let meta = {
       mediaType: adUnit.mediaType && BIDDER.SUPPORTED_MEDIA_TYPES.includes(adUnit.mediaType) ? adUnit.mediaType : BANNER
     };
 
-    if (adUnit.metadata && adUnit.metadata.landingPageDomain) {
+    if (adUnit.metadata?.landingPageDomain) {
       meta.clickUrl = adUnit.metadata.landingPageDomain[0];
       meta.advertiserDomains = adUnit.metadata.landingPageDomain;
     }
@@ -243,7 +237,7 @@ function interpretResponse(response, bidRequest) {
     }
 
     bidResponses.push(bidResponse);
-  })
+  }
 
   return bidResponses;
 }

package/modules/konduitAnalyticsAdapter.js

@@ -4,7 +4,7 @@ import adapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
 import adapterManager from '../src/adapterManager.js';
 import { targeting } from '../src/targeting.js';
 import { config } from '../src/config.js';
-import CONSTANTS from '../src/constants.json';
+import {EVENTS} from '../src/constants.js';
 
 const TRACKER_HOST = 'tracker.konduit.me';
 const KONDUIT_PREBID_MODULE_VERSION = '1.0.0';
@@ -12,13 +12,13 @@ const KONDUIT_PREBID_MODULE_VERSION = '1.0.0';
 const analyticsType = 'endpoint';
 
 const eventDataComposerMap = {
-  [CONSTANTS.EVENTS.AUCTION_INIT]: obtainAuctionInfo,
-  [CONSTANTS.EVENTS.AUCTION_END]: obtainAuctionInfo,
-  [CONSTANTS.EVENTS.BID_REQUESTED]: obtainBidRequestsInfo,
-  [CONSTANTS.EVENTS.BID_TIMEOUT]: obtainBidTimeoutInfo,
-  [CONSTANTS.EVENTS.BID_RESPONSE]: obtainBidResponseInfo,
-  [CONSTANTS.EVENTS.BID_WON]: obtainWinnerBidInfo,
-  [CONSTANTS.EVENTS.NO_BID]: obtainNoBidInfo,
+  [EVENTS.AUCTION_INIT]: obtainAuctionInfo,
+  [EVENTS.AUCTION_END]: obtainAuctionInfo,
+  [EVENTS.BID_REQUESTED]: obtainBidRequestsInfo,
+  [EVENTS.BID_TIMEOUT]: obtainBidTimeoutInfo,
+  [EVENTS.BID_RESPONSE]: obtainBidResponseInfo,
+  [EVENTS.BID_WON]: obtainWinnerBidInfo,
+  [EVENTS.NO_BID]: obtainNoBidInfo,
 };
 
 // This function is copy from prebid core
@@ -43,7 +43,7 @@ function buildUrl(obj) {
 
 const getWinnerBidFromAggregatedEvents = () => {
   return konduitAnalyticsAdapter.context.aggregatedEvents
-    .filter(evt => evt.eventType === CONSTANTS.EVENTS.BID_WON)[0];
+    .filter(evt => evt.eventType === EVENTS.BID_WON)[0];
 };
 
 const isWinnerBidDetected = () => {
@@ -57,7 +57,7 @@ const konduitAnalyticsAdapter = Object.assign(
   adapter({ analyticsType }),
   {
     track ({ eventType, args }) {
-      if (CONSTANTS.EVENTS.AUCTION_INIT === eventType) {
+      if (EVENTS.AUCTION_INIT === eventType) {
         konduitAnalyticsAdapter.context.aggregatedEvents.splice(0);
       }
 
@@ -68,12 +68,12 @@ const konduitAnalyticsAdapter = Object.assign(
         });
       }
 
-      if (eventType === CONSTANTS.EVENTS.AUCTION_END) {
+      if (eventType === EVENTS.AUCTION_END) {
         if (!isWinnerBidDetected() && isWinnerBidExist()) {
-          const bidWonData = eventDataComposerMap[CONSTANTS.EVENTS.BID_WON](targeting.getWinningBids()[0]);
+          const bidWonData = eventDataComposerMap[EVENTS.BID_WON](targeting.getWinningBids()[0]);
 
           konduitAnalyticsAdapter.context.aggregatedEvents.push({
-            eventType: CONSTANTS.EVENTS.BID_WON,
+            eventType: EVENTS.BID_WON,
             data: bidWonData,
           });
         }

package/modules/liveIntentAnalyticsAdapter.js

@@ -1,7 +1,7 @@
 import {ajax} from '../src/ajax.js';
 import { generateUUID, logInfo, logWarn } from '../src/utils.js';
 import adapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
-import CONSTANTS from '../src/constants.json';
+import { EVENTS } from '../src/constants.js';
 import adapterManager from '../src/adapterManager.js';
 import { auctionManager } from '../src/auctionManager.js';
 import { getRefererInfo } from '../src/refererDetection.js';
@@ -11,7 +11,7 @@ const URL = 'https://wba.liadm.com/analytic-events';
 const GVL_ID = 148;
 const ADAPTER_CODE = 'liveintent';
 const DEFAULT_BID_WON_TIMEOUT = 2000;
-const { EVENTS: { AUCTION_END } } = CONSTANTS;
+const { AUCTION_END } = EVENTS;
 let bidWonTimeout;
 
 function handleAuctionEnd(args) {

package/modules/livewrappedAnalyticsAdapter.js

@@ -1,7 +1,7 @@
 import { timestamp, logInfo, getWindowTop } from '../src/utils.js';
 import {ajax} from '../src/ajax.js';
 import adapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
-import CONSTANTS from '../src/constants.json';
+import { EVENTS, STATUS } from '../src/constants.js';
 import adapterManager from '../src/adapterManager.js';
 import { getGlobal } from '../src/prebidGlobal.js';
 
@@ -28,11 +28,11 @@ let livewrappedAnalyticsAdapter = Object.assign(adapter({EMPTYURL, ANALYTICSTYPE
     logInfo('LIVEWRAPPED_EVENT:', [eventType, args]);
 
     switch (eventType) {
-      case CONSTANTS.EVENTS.AUCTION_INIT:
+      case EVENTS.AUCTION_INIT:
         logInfo('LIVEWRAPPED_AUCTION_INIT:', args);
         cache.auctions[args.auctionId] = {bids: {}, bidAdUnits: {}};
         break;
-      case CONSTANTS.EVENTS.BID_REQUESTED:
+      case EVENTS.BID_REQUESTED:
         logInfo('LIVEWRAPPED_BID_REQUESTED:', args);
         cache.auctions[args.auctionId].timeStamp = args.start;
 
@@ -73,11 +73,11 @@ let livewrappedAnalyticsAdapter = Object.assign(adapter({EMPTYURL, ANALYTICSTYPE
         });
         logInfo(livewrappedAnalyticsAdapter.requestEvents);
         break;
-      case CONSTANTS.EVENTS.BID_RESPONSE:
+      case EVENTS.BID_RESPONSE:
         logInfo('LIVEWRAPPED_BID_RESPONSE:', args);
 
         let bidResponse = cache.auctions[args.auctionId].bids[args.requestId];
-        bidResponse.isBid = args.getStatusCode() === CONSTANTS.STATUS.GOOD;
+        bidResponse.isBid = args.getStatusCode() === STATUS.GOOD;
         bidResponse.width = args.width;
         bidResponse.height = args.height;
         bidResponse.cpm = args.cpm;
@@ -101,7 +101,7 @@ let livewrappedAnalyticsAdapter = Object.assign(adapter({EMPTYURL, ANALYTICSTYPE
             };
         }
         break;
-      case CONSTANTS.EVENTS.BIDDER_DONE:
+      case EVENTS.BIDDER_DONE:
         logInfo('LIVEWRAPPED_BIDDER_DONE:', args);
         args.bids.forEach(doneBid => {
           let bid = cache.auctions[doneBid.auctionId].bids[doneBid.bidId || doneBid.requestId];
@@ -111,7 +111,7 @@ let livewrappedAnalyticsAdapter = Object.assign(adapter({EMPTYURL, ANALYTICSTYPE
           bid.readyToSend = 1;
         });
         break;
-      case CONSTANTS.EVENTS.BID_WON:
+      case EVENTS.BID_WON:
         logInfo('LIVEWRAPPED_BID_WON:', args);
         let wonBid = cache.auctions[args.auctionId].bids[args.requestId];
         wonBid.won = true;
@@ -123,7 +123,7 @@ let livewrappedAnalyticsAdapter = Object.assign(adapter({EMPTYURL, ANALYTICSTYPE
           livewrappedAnalyticsAdapter.sendEvents();
         }
         break;
-      case CONSTANTS.EVENTS.AD_RENDER_FAILED:
+      case EVENTS.AD_RENDER_FAILED:
         logInfo('LIVEWRAPPED_AD_RENDER_FAILED:', args);
         let adRenderFailedBid = cache.auctions[args.bid.auctionId].bids[args.bid.requestId];
         adRenderFailedBid.adRenderFailed = true;
@@ -133,13 +133,13 @@ let livewrappedAnalyticsAdapter = Object.assign(adapter({EMPTYURL, ANALYTICSTYPE
           livewrappedAnalyticsAdapter.sendEvents();
         }
         break;
-      case CONSTANTS.EVENTS.BID_TIMEOUT:
+      case EVENTS.BID_TIMEOUT:
         logInfo('LIVEWRAPPED_BID_TIMEOUT:', args);
         args.forEach(timeout => {
           cache.auctions[timeout.auctionId].bids[timeout.bidId].timeout = true;
         });
         break;
-      case CONSTANTS.EVENTS.AUCTION_END:
+      case EVENTS.AUCTION_END:
         logInfo('LIVEWRAPPED_AUCTION_END:', args);
         setTimeout(() => {
           livewrappedAnalyticsAdapter.sendEvents();