Source: jDrupal/src/services/services.js

  1. /**
  2.  * The Drupal services JSON object.
  3.  */
  4. Drupal.services = {};
  6. /**
  7.  * Drupal Services XMLHttpRequest Object.
  8.  * @param {Object} options
  9.  */
  10. Drupal.services.call = function(options) {
  11.   try {
  13.     options.debug = false;
  15.     // Make sure the settings have been provided for Services.
  16.     if (!services_ready()) {
  17.       var error = 'Set the site_path and endpoint on Drupal.settings!';
  18.       options.error(null, null, error);
  19.       return;
  20.     }
  22.     module_invoke_all('services_preprocess', options);
  24.     // Build the Request, URL and extract the HTTP method.
  25.     var request = new XMLHttpRequest();
  26.     var url = Drupal.settings.site_path +
  27.               Drupal.settings.base_path + '?q=';
  28.     // Use an endpoint, unless someone passed in an empty string.
  29.     if (typeof options.endpoint === 'undefined') { url += Drupal.settings.endpoint + '/'; }
  30.     else if (options.endpoint != '') { url += options.endpoint + '/'; }
  31.     url += options.path;
  32.     var method = options.method.toUpperCase();
  33.     if (Drupal.settings.debug) { console.log(method + ': ' + url); }
  35.     // Watch for net::ERR_CONNECTION_REFUSED and other oddities.
  36.     request.onreadystatechange = function() {
  37.       if (request.readyState == 4 && request.status == 0) {
  38.         if (options.error) { options.error(request, 0, 'xhr network status problem'); }
  39.       }
  40.     };
  42.     // Request Success Handler
  43.     request.onload = function(e) {
  44.       try {
  45.         if (request.readyState == 4) {
  46.           // Build a human readable response title.
  47.           var title = request.status + ' - ' + request.statusText;
  48.           // 200 OK
  49.           if (request.status == 200) {
  50.             if (Drupal.settings.debug) { console.log('200 - OK'); }
  51.             // Extract the JSON result, or throw an error if the response wasn't
  52.             // JSON.
  54.             // Extract the JSON result if the server sent back JSON, otherwise
  55.             // hand back the response as is.
  56.             var result = null;
  57.             var response_header = request.getResponseHeader('Content-Type');
  58.             if (response_header.indexOf('application/json') != -1) {
  59.               result = JSON.parse(request.responseText);
  60.             }
  61.             else { result = request.responseText; }
  63.             // Give modules a chance to pre post process the results, send the
  64.             // results to the success callback, then give modules a chance to
  65.             // post process the results.
  66.             module_invoke_all(
  67.               'services_request_pre_postprocess_alter',
  68.               options,
  69.               result
  70.             );
  71.             options.success(result);
  72.             module_invoke_all(
  73.               'services_request_postprocess_alter',
  74.               options,
  75.               result
  76.             );
  77.             module_invoke_all('services_postprocess', options, result);
  78.           }
  79.           else {
  80.             // Not OK...
  81.             console.log(method + ': ' + url + ' - ' + title);
  82.             if (Drupal.settings.debug) {
  83.               if (!in_array(request.status, [403, 503])) { console.log(request.responseText); }
  84.               console.log(request.getAllResponseHeaders());
  85.             }
  86.             if (typeof options.error !== 'undefined') {
  87.               var message = request.responseText || '';
  88.               if (!message || message == '') { message = title; }
  89.               options.error(request, request.status, message);
  90.             }
  91.             module_invoke_all('services_postprocess', options, request);
  92.           }
  93.         }
  94.         else {
  95.           console.log('Drupal.services.call - request.readyState = ' + request.readyState);
  96.         }
  97.       }
  98.       catch (error) {
  99.         // Not OK...
  100.         if (Drupal.settings.debug) {
  101.           console.log(method + ': ' + url + ' - ' + request.statusText);
  102.           console.log(request.responseText);
  103.           console.log(request.getAllResponseHeaders());
  104.         }
  105.         console.log('Drupal.services.call - onload - ' + error);
  106.       }
  107.     };
  109.     // Get the CSRF Token and Make the Request.
  110.     services_get_csrf_token({
  111.         debug: options.debug,
  112.         success: function(token) {
  113.           try {
  114.             // Async, or sync? By default we'll use async if none is provided.
  115.             var async = true;
  116.             if (typeof options.async !== 'undefined' &&
  117.               options.async === false) { async = false; }
  119.             // Open the request.
  120.             request.open(method, url, async);
  122.             // Determine content type header, if necessary.
  123.             var contentType = null;
  124.             if (method == 'POST') {
  125.               contentType = 'application/json';
  126.               // The user login resource needs a url encoded data string.
  127.               if (options.service == 'user' &&
  128.                 options.resource == 'login') {
  129.                 contentType = 'application/x-www-form-urlencoded';
  130.               }
  131.             }
  132.             else if (method == 'PUT') { contentType = 'application/json'; }
  134.             // Anyone overriding the content type?
  135.             if (options.contentType) { contentType = options.contentType; }
  137.             // Set the content type on the header, if we have one.
  138.             if (contentType) {
  139.               request.setRequestHeader('Content-type', contentType);
  140.             }
  142.             // Add the token to the header if we have one.
  143.             if (token) {
  144.               request.setRequestHeader('X-CSRF-Token', token);
  145.             }
  147.             // Any timeout handling?
  148.             if (options.timeout) {
  149.               request.timeout = options.timeout;
  150.               if (options.ontimeout) { request.ontimeout = options.ontimeout; }
  151.             }
  153.             // Send the request with or without data.
  154.             if (typeof options.data !== 'undefined') {
  155.               // Print out debug information if debug is enabled. Don't print
  156.               // out any sensitive debug data containing passwords.
  157.               if (Drupal.settings.debug) {
  158.                 var show = true;
  159.                 if (
  160.                     (options.service == 'user' && in_array(options.resource, ['login', 'create', 'update'])) ||
  161.                     (options.service == 'file' && options.resource == 'create')
  162.                 ) { show = false; }
  163.                 if (show) {
  164.                   if (typeof options.data === 'object') {
  165.                     console.log(JSON.stringify(options.data));
  166.                   }
  167.                   else { console.log(options.data); }
  168.                 }
  169.               }
  170.               request.send(options.data);
  171.             }
  172.             else { request.send(null); }
  174.           }
  175.           catch (error) {
  176.             console.log(
  177.               'Drupal.services.call - services_get_csrf_token - success - ' +
  178.               error
  179.             );
  180.           }
  181.         },
  182.         error: function(xhr, status, message) {
  183.           try {
  184.             if (options.error) { options.error(xhr, status, message); }
  185.           }
  186.           catch (error) {
  187.             console.log(
  188.               'Drupal.services.call - services_get_csrf_token - error - ' +
  189.               error
  190.             );
  191.           }
  192.         }
  193.     });
  195.   }
  196.   catch (error) {
  197.     console.log('Drupal.services.call - error - ' + error);
  198.   }
  199. };
  201. /**
  202.  * Gets the CSRF token from Services.
  203.  * @param {Object} options
  204.  */
  205. function services_get_csrf_token(options) {
  206.   try {
  208.     var token;
  210.     // Are we resetting the token?
  211.     if (options.reset) { Drupal.sessid = null; }
  213.     // Do we already have a token? If we do, return it to the success callback.
  214.     if (Drupal.sessid) { token = Drupal.sessid; }
  215.     if (token) {
  216.       if (options.success) { options.success(token); }
  217.       return;
  218.     }
  220.     // We don't have a token, let's get it from Drupal...
  222.     // Build the Request and URL.
  223.     var token_request = new XMLHttpRequest();
  224.     options.token_url = Drupal.settings.site_path + Drupal.settings.base_path + '?q=services/session/token';
  226.     module_invoke_all('csrf_token_preprocess', options);
  228.     // Watch for net::ERR_CONNECTION_REFUSED and other oddities.
  229.     token_request.onreadystatechange = function() {
  230.       if (token_request.readyState == 4 && token_request.status == 0) {
  231.         if (options.error) { options.error(token_request, 0, 'xhr network status problem for csrf token'); }
  232.       }
  233.     };
  235.     // Token Request Success Handler
  236.     token_request.onload = function(e) {
  237.       try {
  238.         if (token_request.readyState == 4) {
  239.           var title = token_request.status + ' - ' +
  240.             http_status_code_title(token_request.status);
  241.           if (token_request.status != 200) { // Not OK
  242.             if (options.error) { options.error(token_request, token_request.status, token_request.responseText); }
  243.           }
  244.           else { // OK
  245.             // Set Drupal.sessid with the token, then return the token to the success function.
  246.             token = token_request.responseText.trim();
  247.             Drupal.sessid = token;
  248.             if (options.success) { options.success(token); }
  249.           }
  250.         }
  251.         else {
  252.           console.log('services_get_csrf_token - readyState - ' + token_request.readyState);
  253.         }
  254.       }
  255.       catch (error) {
  256.         console.log('services_get_csrf_token - token_request. onload - ' + error);
  257.       }
  258.     };
  260.     // Open the token request.
  261.     token_request.open('GET', options.token_url, true);
  263.     // Send the token request.
  264.     token_request.send(null);
  265.   }
  266.   catch (error) { console.log('services_get_csrf_token - ' + error); }
  267. }
  269. /**
  270.  * Checks if we're ready to make a Services call.
  271.  * @return {Boolean}
  272.  */
  273. function services_ready() {
  274.   try {
  275.     var result = true;
  276.     if (Drupal.settings.site_path == '') {
  277.       result = false;
  278.       console.log('jDrupal\'s Drupal.settings.site_path is not set!');
  279.     }
  280.     if (Drupal.settings.endpoint == '') {
  281.       result = false;
  282.       console.log('jDrupal\'s Drupal.settings.endpoint is not set!');
  283.     }
  284.     return result;
  285.   }
  286.   catch (error) { console.log('services_ready - ' + error); }
  287. }
  289. /**
  290.  * Given the options for a service call, the service name and the resource name,
  291.  * this will attach the names and their values as properties on the options.
  292.  * @param {Object} options
  293.  * @param {String} service
  294.  * @param {String} resource
  295.  */
  296. function services_resource_defaults(options, service, resource) {
  297.   if (!options.service) { options.service = service; }
  298.   if (!options.resource) { options.resource = resource; }
  299. }
  301. /**
  302.  * Returns true if the entity_id is already queued for the service resource,
  303.  * false otherwise.
  304.  * @param {String} service
  305.  * @param {String} resource
  306.  * @param {Number} entity_id
  307.  * @param {String} callback_type
  308.  * @return {Boolean}
  309.  */
  310. function _services_queue_already_queued(service, resource, entity_id, callback_type) {
  311.   try {
  312.     var queued = false;
  313.     if (typeof Drupal.services_queue[service][resource][entity_id] !== 'undefined') {
  314.       var queue = Drupal.services_queue[service][resource][entity_id];
  315.       if (queue[callback_type].length != 0) { queued = true; }
  316.     }
  317.     return queued;
  318.   }
  319.   catch (error) { console.log('_services_queue_already_queued - ' + error); }
  320. }
  322. /**
  323.  * Adds an entity id to the service resource queue.
  324.  * @param {String} service
  325.  * @param {String} resource
  326.  * @param {Number} entity_id
  327.  */
  328. function _services_queue_add_to_queue(service, resource, entity_id) {
  329.   try {
  330.     Drupal.services_queue[service][resource][entity_id] = {
  331.       entity_id: entity_id,
  332.       success: [],
  333.       error: []
  334.     };
  335.   }
  336.   catch (error) { console.log('_services_queue_add_to_queue - ' + error); }
  337. }
  339. /**
  340.  * An internal function used to reset a services callback queue for a given entity CRUD op.
  341.  * @param {String} entity_type
  342.  * @param {String} resource - create, retrieve, update, delete, index, etc
  343.  * @param {Number} entity_id
  344.  * @param {String} callback_type - success or error
  345.  * @private
  346.  */
  347. function _services_queue_clear(entity_type, resource, entity_id, callback_type) {
  348.   try {
  349.     Drupal.services_queue[entity_type]['retrieve'][entity_id][callback_type] = [];
  350.   }
  351.   catch (error) { console.log('_services_queue_clear - ' + error); }
  352. }
  354. /**
  355.  * Removes an entity id from the service resource queue.
  356.  * @param {String} service
  357.  * @param {String} resource
  358.  * @param {Number} entity_id
  359.  */
  360. function _services_queue_remove_from_queue(service, resource, entity_id) {
  361.   console.log('WARNING: services_queue_remove_from_queue() not done yet!');
  362. }
  364. /**
  365.  * Adds a callback function to the service resource queue.
  366.  * @param {String} service
  367.  * @param {String} resource
  368.  * @param {Number} entity_id
  369.  * @param {String} callback_type
  370.  * @param {Function} callback
  371.  */
  372. function _services_queue_callback_add(service, resource, entity_id, callback_type, callback) {
  373.   try {
  374.     Drupal.services_queue[service][resource][entity_id][callback_type].push(
  375.       callback
  376.     );
  377.   }
  378.   catch (error) { console.log('_services_queue_callback_add - ' + error); }
  379. }
  381. /**
  382.  * Returns the number of callback functions for the service resource queue.
  383.  * @param {String} service
  384.  * @param {String} resource
  385.  * @param {Number} entity_id
  386.  * @param {String} callback_type
  387.  * @return {Number}
  388.  */
  389. function _services_queue_callback_count(service, resource, entity_id,
  390.   callback_type) {
  391.   try {
  392.     var length =
  393.       Drupal.services_queue[service][resource][entity_id][callback_type].length;
  394.     return length;
  395.   }
  396.   catch (error) { console.log('_services_queue_callback_count - ' + error); }
  397. }