Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 | 1x | /**
* Interface de dialogue avec les webservices
*
* @module Protocols
* @private
* @alias Gp.Protocols
*/
import Helper from "../Utils/Helper";
import XHR from "./XHR";
import JSONP from "./JSONP";
var Protocol = {
/**
* Interface unique d"envoi d"une requête.
*
* @method send
* @static
* @param {Object} options - options generales
* @param {String} options.url - url du service
* @param {String} options.method - GET, POST, PUT, DELETE
* @param {String} options.protocol - XHR | JSONP
* @param {String} options.format - format de la reponse du service : json, xml ou null (brute)...
* @param {String} options.wrap - encapsuler la reponse du service dans du JSON : true|false (true par defaut sur le protocole JSONP)
* @param {String} options.callbackSuffix - suffixe de la fonction de callback (JSONP uniquement) (ex: si callbackSuffix="", la fonction s'appellera "callback")
* @param {String} options.timeOut - 0 ms
* @param {Boolean} options.nocache - true|false
* @param {Object|String} options.data - content (post) ou param (get)
* @param {Object|String} options.headers - (post) ex. referer
* @param {Object|String} options.content - (post) ex. "application/json"
* @param {String} options.scope - this (TODO)
* @param {Function} options.onResponse - callback
* @param {Function} options.onFailure - callback
* @param {Function} options.onTimeOut - callback
* @param {String} options.proxyUrl - (TODO)
*/
send : function (options) {
// INFO
// "output" - param est interne à la classe "Protocol" (parametrable via "wrap"), et à ajouter à l"url
// ce param est independant du service car il est géré par le filtre LUA :
// ex. json|xml (json par defaut).
// Ce param. permet d"encapsuler du XML dans du JSON :
// {http : {status:200, error:null},xml :"réponse du service"}
// Utile pour les services qui ne repondent que du XML (ex. Geocodage)
//
// |-------------------------------------------------|
// | \service | | | |
// | output\ format| json | xml | remarques |
// |--------\------|------|-----|--------------------|
// | json | json | json| json/xml encapsulé |
// | xml | json | xml | param inactif |
// |-------------------------------------------------|
// ex. le service demande une reponse native au "format" json et avec un "output" json.
// on a donc une reponse json encapsulé dans un json : ce qu'on ne souhaite pas !
// dans ce cas on ne renseigne pas output=json
// INFO
// "wrap" - choix d"encapsuler ou non les reponses dans du JSON.
// Par defaut, on encapsule uniquement les reponses sur le protocole JSONP (et qui sont en xml) !
// INFO
// "callback" - param est interne à la classe "Protocol" (non parametrable), et à ajouter à l"url
// ce param est independant du service car il est géré aussi par le filtre LUA :
// ex. callback|null
// Ce param. permet de renvoyer une reponse javascript :
// callback ({http : {status:200, error:null},xml :"réponse du service"})
// Ce param. est non renseigné par defaut car pour du JSONP, on utilise le
// le protocol JSONP, et ce dernier implemente déjà le callback !
// settings par defaut
var settings = options || {
method : "GET",
// protocol : "JSONP",
protocol : "XHR",
timeOut : 0,
format : null,
wrap : true,
nocache : true,
output : "json",
callback : null,
callbackSuffix : null
};
// on determine l'environnement d'execution : browser ou non ?
// et on stoppe pour nodeJS... sur un protocole JSONP !
if (typeof window === "undefined" && options.protocol === "JSONP") {
console.log("Value (s) for parameter (s) 'protocol=JSONP (instead use XHR)' not supported to NodeJS");
return;
}
if (options.protocol === "XHR" || options.format === "json") {
settings.wrap = false;
} else if (options.protocol === "JSONP" && options.format === "xml") {
settings.wrap = true;
}
settings.callback = null; // FIXME non géré !?
settings.output = settings.wrap ? "json" : null;
// on encapsule les reponses dans un objet JSON
if (settings.wrap) {
var params = {};
params.output = settings.output;
params.callback = settings.callback;
delete params.callback; // FIXME non géré !?
settings.url = Helper.normalyzeUrl(options.url, params);
}
// choix de l"implementation :
// XHR ou JSONP
switch (settings.protocol) {
case "XHR":
// on normalise l'url (gestion du cache)
if (options.method === "GET" && options.nocache) {
settings.url = Helper.normalyzeUrl(settings.url, {
t : new Date().getTime()
});
}
// appel du service en XHR
XHR.call(settings);
break;
case "JSONP":
// on normalise l'url si les params. sont renseignés dans la string|object "data"
if (settings.data) {
settings.url = Helper.normalyzeUrl(settings.url, settings.data);
}
// appel du service en JSONP
JSONP.call(settings);
break;
default:
throw new Error("protocol not supported (XHR|JSONP) !");
}
}
};
export default Protocol;
|