Update Roxot prebid analytic adapter

package.json

@@ -25,7 +25,7 @@
     "babel-plugin-transform-es3-member-expression-literals": "^6.8.0",
     "babel-plugin-transform-es3-property-literals": "^6.8.0",
     "babel-plugin-transform-object-assign": "^6.8.0",
-    "babel-preset-es2015": "^6.5.0",
+    "babel-preset-es2015": "^6.24.1",
     "block-loader": "^2.1.0",
     "chai": "^3.3.0",
     "coveralls": "^2.11.11",

src/adapters/analytics/AnalyticsAdapter.js

@@ -6,6 +6,7 @@ const events = require('src/events');
 const utils = require('../../utils');
 
 const AUCTION_INIT = CONSTANTS.EVENTS.AUCTION_INIT;
+const AUCTION_END = CONSTANTS.EVENTS.AUCTION_END;
 const BID_REQUESTED = CONSTANTS.EVENTS.BID_REQUESTED;
 const BID_TIMEOUT = CONSTANTS.EVENTS.BID_TIMEOUT;
 const BID_RESPONSE = CONSTANTS.EVENTS.BID_RESPONSE;
@@ -105,6 +106,7 @@ export default function AnalyticsAdapter({ url, analyticsType, global, handler }
         [BID_TIMEOUT]: args => this.enqueue({ eventType: BID_TIMEOUT, args }),
         [BID_WON]: args => this.enqueue({ eventType: BID_WON, args }),
         [BID_ADJUSTMENT]: args => this.enqueue({ eventType: BID_ADJUSTMENT, args }),
+        [AUCTION_END]: args => this.enqueue({ eventType: AUCTION_END, args }),
         [AUCTION_INIT]: args => {
           args.config = config.options;  // enableAnaltyics configuration object
           this.enqueue({ eventType: AUCTION_INIT, args });

src/adapters/analytics/roxot.js

@@ -1,19 +1,98 @@
-import { ajax } from 'src/ajax';
-import adapter from 'AnalyticsAdapter';
+import {ajax} from "src/ajax";
+import adapter from "AnalyticsAdapter";
+import CONSTANTS from "src/constants.json";
 
 const utils = require('../../utils');
 
-const url = '//d.rxthdr.com/analytics';
+const url = '//pa.rxthdr.com/analytic';
 const analyticsType = 'endpoint';
 
-export default Object.assign(adapter(
-  {
-    url,
-    analyticsType
+let auctionInitConst = CONSTANTS.EVENTS.AUCTION_INIT;
+let auctionEndConst = CONSTANTS.EVENTS.AUCTION_END;
+let bidWonConst = CONSTANTS.EVENTS.BID_WON;
+
+let initOptions = {publisherIds: []};
+let bidWon = {options: {}, events: []};
+let eventStack = {options: {}, events: []};
+
+let auctionStatus = 'not_started';
+
+function checkOptions() {
+  if (typeof initOptions.publisherIds === 'undefined') {
+    return false;
   }
-  ),
+
+  return initOptions.publisherIds.length > 0;
+}
+
+function buildBidWon(eventType, args) {
+  bidWon.options = initOptions;
+  bidWon.events = [{args: args, eventType: eventType}];
+}
+
+function buildEventStack() {
+  eventStack.options = initOptions;
+}
+
+function send(eventType, data, sendDataType) {
+  let fullUrl = url + '?publisherIds[]=' + initOptions.publisherIds.join('&publisherIds[]=') + '&host=' + window.location.hostname;
+
+  ajax(
+    fullUrl,
+    (result) => utils.logInfo('Event ' + eventType + ' sent ' + sendDataType + ' to roxot prebid analytic with result' + result),
+    JSON.stringify(data)
+  );
+}
+
+function pushEvent(eventType, args) {
+  eventStack.events.push({eventType, args});
+}
+
+function flushEvents() {
+  eventStack.events = [];
+}
+
+let roxotAdapter = Object.assign(adapter({url, analyticsType}),
   {
-    track({ eventType, args }) {
-      ajax(url, (result) => utils.logInfo('Event ' + eventType + ' sent to roxot analytics with result ' + result), JSON.stringify({ eventType, args }));
+    track({eventType, args}) {
+      if (!checkOptions()) {
+        return;
+      }
+
+      let info = Object.assign({}, args);
+
+      if (info && info.ad) {
+        info.ad = "";
+      }
+
+      if (eventType === auctionInitConst) {
+        auctionStatus = 'started';
+        flushEvents();
+      }
+
+      if ((eventType === bidWonConst) && auctionStatus === 'not_started') {
+        buildBidWon(eventType,info);
+        send(eventType, bidWon, 'bidWon');
+        return;
+      }
+
+      if (eventType === auctionEndConst) {
+        buildEventStack(eventType);
+        send(eventType, eventStack, 'eventStack');
+        flushEvents();
+        auctionStatus = 'not_started';
+      } else {
+        pushEvent(eventType, info);
+      }
     }
   });
+
+roxotAdapter.originEnableAnalytics = roxotAdapter.enableAnalytics;
+
+roxotAdapter.enableAnalytics = function (config) {
+  initOptions = config.options;
+  utils.logInfo('Roxot Analytics enabled with config', initOptions);
+  roxotAdapter.originEnableAnalytics(config);
+};
+
+export default roxotAdapter;

test/spec/adapters/analytics/roxot_analytic_spec.js

@@ -0,0 +1,35 @@
+import roxotAnalytic from 'src/adapters/analytics/roxot';
+let events = require('../../../../src/events');
+let adaptermanager = require('../../../../src/adaptermanager');
+let constants = require('../../../../src/constants.json');
+
+describe('Roxot Prebid Analytic', function () {
+
+  describe('enableAnalytics', function () {
+
+
+    it('should catch all events', function () {
+      sinon.spy(roxotAnalytic, 'track');
+
+      adaptermanager.registerAnalyticsAdapter({
+        code: 'roxot',
+        adapter: roxotAnalytic
+      });
+
+      adaptermanager.enableAnalytics({
+        provider: 'roxot',
+        options: {
+          publisherIds: ['test_roxot_prebid_analytid_publisher_id']
+        }
+      });
+
+      events.emit(constants.EVENTS.AUCTION_INIT, {});
+      events.emit(constants.EVENTS.AUCTION_END, {});
+      events.emit(constants.EVENTS.BID_REQUESTED, {});
+      events.emit(constants.EVENTS.BID_RESPONSE, {});
+      events.emit(constants.EVENTS.BID_WON, {});
+
+      sinon.assert.callCount(roxotAnalytic.track, 5);
+    });
+  });
+});