function exec()

in src/WebUI/dotnet/WebPortal/wwwroot/js/elasticsearch-js/elasticsearch.angular.js [17200:17317]
96 lines of code
35 McCabe index (conditional complexity)

	function exec(transport, spec, params, cb) {
	  var request = {
	    method: spec.method
	  };
	  var query = {};
	  var i;

	  // pass the timeout from the spec
	  if (spec.requestTimeout) {
	    request.requestTimeout = spec.requestTimeout;
	  }

	  if (!params.body && spec.paramAsBody) {
	    if (typeof spec.paramAsBody === 'object') {
	      params.body = {};
	      if (spec.paramAsBody.castToArray) {
	        params.body[spec.paramAsBody.body] = [].concat(params[spec.paramAsBody.param]);
	      } else {
	        params.body[spec.paramAsBody.body] = params[spec.paramAsBody.param];
	      }
	      delete params[spec.paramAsBody.param];
	    } else {
	      params.body = params[spec.paramAsBody];
	      delete params[spec.paramAsBody];
	    }
	  }

	  // verify that we have the body if needed
	  if (spec.needsBody && !params.body) {
	    throw new TypeError('A request body is required.');
	  }

	  // control params
	  if (spec.bulkBody) {
	    request.bulkBody = true;
	  }

	  if (spec.method === 'HEAD') {
	    request.castExists = true;
	  }

	  // pick the url
	  if (spec.url) {
	    // only one url option
	    request.path = resolveUrl(spec.url, params);
	  } else {
	    for (i = 0; i < spec.urls.length; i++) {
	      if (request.path = resolveUrl(spec.urls[i], params)) {
	        break;
	      }
	    }
	  }

	  if (!request.path) {
	    // there must have been some mimimun requirements that were not met
	    var minUrl = spec.url || spec.urls[spec.urls.length - 1];
	    throw new TypeError('Unable to build a path with those params. Supply at least ' + _.keys(minUrl.req).join(', '));
	  }

	  // build the query string
	  if (!spec.paramKeys) {
	    // build a key list on demand
	    spec.paramKeys = _.keys(spec.params);
	    spec.requireParamKeys = _.transform(spec.params, function (req, param, key) {
	      if (param.required) {
	        req.push(key);
	      }
	    }, []);
	  }

	  for (var key in params) {
	    if (params.hasOwnProperty(key) && params[key] != null) {
	      switch (key) {
	        case 'body':
	        case 'headers':
	        case 'requestTimeout':
	        case 'maxRetries':
	          request[key] = params[key];
	          break;
	        case 'ignore':
	          request.ignore = _.isArray(params[key]) ? params[key] : [params[key]];
	          break;
	        case 'method':
	          request.method = _.toUpperString(params[key]);
	          break;
	        default:
	          var paramSpec = spec.params[key];
	          if (paramSpec) {
	          // param keys don't always match the param name, in those cases it's stored in the param def as "name"
	            paramSpec.name = paramSpec.name || key;
	            if (params[key] != null) {
	              if (castType[paramSpec.type]) {
	                query[paramSpec.name] = castType[paramSpec.type](paramSpec, params[key], key);
	              } else {
	                query[paramSpec.name] = params[key];
	              }

	              if (paramSpec['default'] && query[paramSpec.name] === paramSpec['default']) {
	                delete query[paramSpec.name];
	              }
	            }
	          } else {
	            query[key] = params[key];
	          }
	      }
	    }
	  }

	  for (i = 0; i < spec.requireParamKeys.length; i ++) {
	    if (!query.hasOwnProperty(spec.requireParamKeys[i])) {
	      throw new TypeError('Missing required parameter ' + spec.requireParamKeys[i]);
	    }
	  }

	  request.query = query;

	  return transport.request(request, cb);
	}