Merge pull request #103 from watson-developer-cloud/dev

added visual insights and the new events call to tradeoff analytics

Author: germanattanasio

services/alchemy_vision/v1.js

@@ -21,7 +21,6 @@ var requestFactory = require('../../lib/requestwrapper');
 var endpoints      = require('../../lib/alchemy_endpoints.json');
 var helper         = require('../../lib/helper');
 var isStream       = require('isstream');
-var pick           = require('object.pick');
 var omit           = require('object.omit');
 var fs             = require('fs');
 
@@ -54,18 +53,33 @@ function createRequest(method) {
         ' needs to be specified'));
       return;
     }
+    // always return json
+    params.outputMode = 'json';
 
     var parameters = {
       options: {
         url: endpoints[method][format],
-        method: 'POST',
-        json: true,
-        qs: extend({outputMode: 'json'}, params) // change default output to json
+        method: 'POST'
       },
       defaultOptions: this._options
     };
 
-    return requestFactory(parameters, errorFormatter(callback));
+    if (!params.image || !isStream(params.image)) {
+      // url or base64 images are considered 'not-raw'
+      params.imagePostMode = 'not-raw';
+      // send the parameters as form url-encoded
+      parameters.options.form = params;
+      return requestFactory(parameters, errorFormatter(callback));
+    } else {
+      params.imagePostMode = 'raw';
+      // send the parameters as query parameters
+      parameters.options.qs = omit(params,['image']);
+      // add the content-length to the headers
+      parameters.options.headers = {
+        'Content-Length': fs.statSync(params.image.path).size
+      };
+      return params.image.pipe(requestFactory(parameters, errorFormatter(callback)));
+    }
   };
 }
 
@@ -81,86 +95,16 @@ function AlchemyVision(options) {
 /**
  * Extracts images from a URL or html
  */
-AlchemyVision.prototype.getImageLinks = function(_params, callback ) {
-  var params = _params || {};
-  var accepted_formats = Object.keys(endpoints['image_link']);
-  var format = helper.getFormat(params, accepted_formats);
-
-  if (format === null) {
-    callback(new Error('Missing required parameters: ' + accepted_formats.join(', ') + ' needs to be specified'));
-    return;
-  }
-
-  var parameters = {
-    options: {
-      url: endpoints['image_link'][format],
-      method: 'POST',
-      json: true,
-      qs: extend({}, params,{outputMode: 'json'}) // change default output to json
-    },
-    defaultOptions: this._options
-  };
-
-  return requestFactory(parameters, errorFormatter(callback));
-};
+AlchemyVision.prototype.getImageLinks = createRequest('image_link');
 
 /**
  * Tags image with keywords
  */
-AlchemyVision.prototype.getImageKeywords = function(_params, callback) {
-  var params = extend({}, _params);
-  var accepted_formats = Object.keys(endpoints['image_keywords']);
-  var format = helper.getFormat(params, accepted_formats);
-
-  if (format === null) {
-    callback(new Error('Missing required parameters: ' + accepted_formats.join(', ') + ' needs to be specified'));
-    return;
-  }
-
-  var parameters = {
-    options: {
-      url: endpoints['image_keywords'][format],
-      method: 'POST',
-      json: true,
-      qs: {outputMode: 'json'} // change default output to json
-    },
-    defaultOptions: this._options
-  };
-
-  if (typeof(params.image) !== 'undefined') {
-
-    // check if image is stream or string
-    if ((typeof(params.image) !== 'string') && !isStream(params.image)) {
-      callback(new Error('Invalid arguments: image needs to be a stream or base64'));
-      return;
-    }
-
-    if (isStream(params.image)) {
-      params.imagePostMode = 'raw';
-      // handle raw images
-      parameters.options.body = params.image;
-
-    } else {
-      params.imagePostMode = 'not-raw';
-      parameters.options.formData = params;
-    }
-  } else {
-    parameters.options.formData = params;
-  }
-
-  return requestFactory(parameters, errorFormatter(callback));
-};
+AlchemyVision.prototype.getImageKeywords = createRequest('image_keywords');
 
 /**
  * Face detection and Recognition
  */
-AlchemyVision.prototype.recognizeFaces = function(_params, callback) {
-  var params = _params || {};
-
-  if (params.image && typeof(params.image) !== 'string')
-    params.imagePostMode = 'raw';
-
-  return createRequest('image_recognition').call(this, params, callback);
-};
+AlchemyVision.prototype.recognizeFaces = createRequest('image_recognition');
 
 module.exports = AlchemyVision;

services/tradeoff_analytics/v1.js

@@ -18,6 +18,7 @@
 
 var extend         = require('extend');
 var requestFactory = require('../../lib/requestwrapper');
+var omit           = require('object.omit');
 
 function TradeoffAnalytics(options) {
   // Default URL
@@ -39,19 +40,51 @@ function TradeoffAnalytics(options) {
  * @param  {String} params.subject Name of the decision problem
  * @param  {String} params.options A list of options. Typically, the rows in a
  *                                 table representation of your data
+ * @param  {String} params.metadataHeader Value of the x-watson-metadata header to be forwarded
+ * 								   for analytics purposes
  */
 TradeoffAnalytics.prototype.dilemmas = function(params, callback) {
+  params = params || {};
+  
   var parameters = {
     options: {
       method: 'POST',
       url: '/v1/dilemmas',
-      body: params,
-      json: true,
+      body: omit(params,['metadata_header']),
+      headers: {
+        'x-watson-metadata' : params.metadata_header
+      },
+      json: true
     },
     requiredParams: ['columns', 'subject', 'options'],
     defaultOptions: this._options
   };
   return requestFactory(parameters, callback);
 };
 
+ /**
+ * Forward events from the Tradeoff Analytics widget to the service
+ *
+ * @param  {String} params - the array of events to forward to the service
+ * @param  {String} params.metadataHeader Value of the x-watson-metadata header to be forwarded
+ * 								   for analytics purposes
+ */
+TradeoffAnalytics.prototype.events = function(params, callback) {
+  params = params || {};
+  
+  var parameters = {
+    options: {
+      method: 'POST',
+      url: '/v1/events',
+      body: omit(params,['metadata_header']),
+      headers: {
+        'x-watson-metadata' : params.metadata_header
+      },
+      json: true
+    },
+    defaultOptions: this._options
+  };
+  return requestFactory(parameters, callback);
+};
+
 module.exports = TradeoffAnalytics;

test/resources/ta_events.js

@@ -0,0 +1,28 @@
+[{
+	"widget_instance_uuid" : "e8d263d9-a0a7-43f4-81cf-2767ad246cb5",
+	"widget_show_uuid" : null,
+	"dilemma_call_uuid" : null,
+	"event_number" : 0,
+	"category" : "widget",
+	"action" : "started",
+	"object" : "basic",
+	"value" : {
+		"optionHighlighting" : false,
+		"favorites" : true,
+		"favoritesTab" : false,
+		"optionDetails" : true,
+		"filters" : true,
+		"filterHistogram" : false,
+		"objectivesOnly" : true,
+		"optimalsList" : true,
+		"autoExcludedList" : true,
+		"incompleteList" : true,
+		"tradeoffAnalyzer" : true,
+		"undoRedo" : false,
+		"exploreViz" : "both",
+		"questionEditor" : "editableNoToggle",
+		"bidiTextDir" : "auto",
+		"analytics" : "MetadataAndEvents"
+	},
+	"timestamp" : 1442414658641
+}]

test/test.tradeoff_analytics.v1.js

@@ -3,17 +3,20 @@
 var assert = require('assert');
 var watson = require('../lib/index');
 var nock   = require('nock');
+var extend = require('extend');
 
 describe('tradeoff_analytics', function() {
 
   var noop = function() {};
 
   var service_request = require('./resources/dilemma_problem');
+  var events_request = require('./resources/ta_events');
 
   var service_response = {};
 
   var service_path = '/v1/dilemmas';
-
+  var events_path = '/v1/events';
+  
   var service = {
     username: 'batman',
     password: 'bruce-wayne',
@@ -27,6 +30,11 @@ describe('tradeoff_analytics', function() {
       .persist()
       .post(service_path, service_request)
       .reply(200, service_response);
+   nock(service.url)
+      .persist()
+      .post(events_path, events_request)
+      .reply(200);
+ 
   });
 
   after(function() {
@@ -43,13 +51,33 @@ describe('tradeoff_analytics', function() {
     tradeoff_analytics.dilemmas({}, missingParameter);
     tradeoff_analytics.dilemmas(null, missingParameter);
     tradeoff_analytics.dilemmas(undefined, missingParameter);
+    
+    tradeoff_analytics.events({}, missingParameter);
+    tradeoff_analytics.events(null, missingParameter);
+    tradeoff_analytics.events(undefined, missingParameter);
   });
-
+  
   it('should generate a valid payload', function() {
-      var req = tradeoff_analytics.dilemmas(service_request, noop);
+	  var params = extend({}, service_request);
+	  params.metadata_header = 'test_header_content';
+      var req = tradeoff_analytics.dilemmas(params, noop);
       var body = new Buffer(req.body).toString('ascii');
       assert.equal(req.uri.href, service.url + service_path);
       assert.equal(body, JSON.stringify(service_request));
+      assert.notEqual(body, JSON.stringify(params));
+      assert.equal(req.headers['x-watson-metadata'], params.metadata_header);
+      assert.equal(req.method, 'POST');
+  });
+  
+  it('should forward the events correctly', function() {
+	  var params = extend({}, events_request);
+	  params.metadata_header = 'test_header_content';
+      var req = tradeoff_analytics.events(params, noop);
+      var body = new Buffer(req.body).toString('ascii');
+      assert.equal(req.uri.href, service.url + events_path);
+      assert.equal(body, JSON.stringify(events_request));
+      assert.notEqual(body, JSON.stringify(params));
+      assert.equal(req.headers['x-watson-metadata'], params.metadata_header);
       assert.equal(req.method, 'POST');
   });