text: /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements.  See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership.  The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  'use strict';
  /** @module odata/net */
  
  
  var http = require('http');
  var utils    = require('./../utils.js');
  var url = require("url");
  
  
  var defined = utils.defined;
  var delay = utils.delay;
  
  var ticks = 0;
  
  /* Checks whether the specified request can be satisfied with a JSONP request.
   * @param request - Request object to check.
   * @returns {Boolean} true if the request can be satisfied; false otherwise.
  
   * Requests that 'degrade' without changing their meaning by going through JSONP
   * are considered usable.
   *
   * We allow data to come in a different format, as the servers SHOULD honor the Accept
   * request but may in practice return content with a different MIME type.
   */
  function canUseJSONP(request) {
      return false;
  }
  
  
  
  /** Checks whether the specified URL is an absolute URL.
   * @param {String} url - URL to check.
   * @returns {Boolean} true if the url is an absolute URL; false otherwise.
  */
  function isAbsoluteUrl(url) {
      return url.indexOf("http://") === 0 ||
             url.indexOf("https://") === 0 ||
             url.indexOf("file://") === 0;
  }
  
  /** Checks whether the specified URL is local to the current context.
   * @param {String} url - URL to check.
   * @returns {Boolean} true if the url is a local URL; false otherwise.
   */
  function isLocalUrl(url) {
  
      if (!isAbsoluteUrl(url)) {
          return true;
      }
  
      // URL-embedded username and password will not be recognized as same-origin URLs.
      var location = window.location;
      var locationDomain = location.protocol + "//" + location.host + "/";
      return (url.indexOf(locationDomain) === 0);
  }
  
  
  /** Reads response headers into array.
   * @param {Object} inHeader
   * @param {Array} outHeader
   */
  function readResponseHeaders(inHeader, outHeader) {
      for (var property in inHeader) {
          
          if (inHeader.hasOwnProperty(property)) {
              outHeader[property] = inHeader[property];
          }
      }
  }
  
      
  
  
  
  exports.defaultHttpClient = {
      formatQueryString: "$format=json",
  
      
      /** Performs a network request.
       * @param {Object} request - Request description
       * @param {Function} success - Success callback with the response object.
       * @param {Function} error - Error callback with an error object.
       * @returns {Object} Object with an 'abort' method for the operation.
       */
      request: function (request, success, error) {
  
          var result = {};
          var done = false;
          
          var options = url.parse(request.requestUri);
          options.method = request.method || "GET";
          options.headers = {};
          //options.auth = request.user + ':' + request.password;
          //add headers
          var name;
          if (request.headers) {
              for (name in request.headers) {
                  options.headers[name] = request.headers[name];
              }
          }   
          
  
          var xhr = http.request(options);
  
          result.abort = function () {
              if (done) {
                  return;
              }
  
              done = true;
              if (xhr) {
                  xhr.abort();
                  xhr = null;
              }
  
              error({ message: "Request aborted" });
          };
  
          // Set the timeout if available.
          if (request.timeoutMS) {
              xhr.setTimeout(request.timeoutMS,function () {
                  if (!done) {
                      done = true;
                      xhr = null;
                      error({ message: "Request timed out" });
                  }
              });
          }
  
          xhr.on('error', function(e) {
              var response = { requestUri: url, statusCode: 400, statusText: e.message };
              error({ message: "HTTP request failed", request: request, response: response });
          });
               
  
          xhr.on('response', function (resp) {
              if (done || xhr === null) {
                  return;
              }
  
              var headers = [];
              readResponseHeaders(resp.headers, headers);
                          
              var body = '';
  
              resp.on('data', function(chunk) {
                  body+=chunk;
              });
              resp.on('end', function() {
                  // do what you do
                  var response = { requestUri: url, statusCode: resp.statusCode, statusText: '', headers: headers, body: body };
  
                  done = true;
                  xhr = null;
                  if (resp.statusCode >= 200 && resp.statusCode <= 299) {
                      success(response);
                  } else {
                      error({ message: "HTTP request failed", request: request, response: response });
                  }   
              });
          });
  
          //xhr.open(request.method || "GET", url, true,);
          if (request.body) {
              xhr.write(request.body);
          }
          xhr.end();
  
          return result;
      }
  };
  
  
  
  exports.canUseJSONP = canUseJSONP;
  exports.isAbsoluteUrl = isAbsoluteUrl;
  exports.isLocalUrl = isLocalUrl;