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 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 | 1x 1x 1x 1x |
import Logger from "../../Utils/LoggerByDefault";
import _ from "../../Utils/MessagesResources";
import ErrorService from "../../Exceptions/ErrorService";
import CommonService from "../CommonService";
import DefaultUrlService from "../DefaultUrlService";
import AltiRequestFactory from "./Request/AltiRequestFactory";
import AltiResponseFactory from "./Response/AltiResponseFactory";
/**
* @classdesc
*
* Appel du service d'altimétrie du Géoportail
*
* @todo gestion du parma. output et callback
* @todo outputFormat (REST) et format (WPS)
* @todo La reponse JSON peut encapsuler un XML !
*
* @constructor
* @extends {Gp.Services.CommonService}
* @alias Gp.Services.Alti
* @param {Object} options - options spécifiques au service (+ les options heritées)
*
* @param {Array.<Object>} options.positions - Tableau ({lon:float,lat:float}) contenant les coordonnées des points (CRS:84)
* dont on veut connaître les altitudes (ou à partir desquelles on va calculer le profil).
* Chaque élément du tableau est un objet JavaScript avec deux attributs : lon et lat, qui sont des flottants.
* Minimum 2 éléments si on souhaite calculer un profil altimétrique (ElevationLine).
* Maximum 50 éléments.
*
* @param {String} options.outputFormat - Le format de la réponse du service alti : 'xml' ou 'json'.
* Ce paramètre déterminera l'extension '.xml' ou '.json' du service dans le cas de l'API REST,
* ou la valeur du paramètre 'format' dans le cas de la norme WPS.
* Nécessaire si serverUrl est renseigné, et qu'on souhaite passer par l'API REST,
* pour connaître le format dans lequel sera fournie la réponse (pour son traitement).
* Non nécessaire pour la norme WPS. Par défaut, ce paramètre vaut 'json'.
*
* @param {Number} [options.sampling] - Nombre de points à utiliser pour déterminer le tracé d'un profil altimétrique, compris entre 2 et 5000.
* A spécifier lorsqu'on souhaite accéder à cette fonctionnalité.
* Dans ce cas, les points fournis en entrée (au minimum de deux) servent à déterminer l'axe planimétrique
* le long duquel le profil doit être calculé.
* Si le paramètre sampling n'est pas spécifié ou moins de deux points sont fournis,
* c'est le service Elevation qui sera interrogé (altitudes simples calculées pour les points fournis).
* Une valeur de sampling strictement inférieure à 2 déclenchera un échantillonnage avec la valeur par défaut du service (3 points).
*
* @param {String} [options.api] - Manière d'accéder au service : 'REST' (via l'API REST) ou 'WPS' (via la norme WPS).
* Par défaut, on utilise l'API REST.
*
* @param {Boolean} [options.zonly] - Permet de ne récupérer que les altitudes en sortie s'il vaut 'true'.
* Vaut 'false' par défaut.
*
* @param {String} [options.resource] - Resource utilisée pour réaliser le calcul.
*
* @example
* var options = {
* apiKey : null,
* serverUrl : 'http://localhost/service/',
* protocol : 'JSONP', // JSONP|XHR
* proxyURL : null,
* httpMethod : 'GET', // GET|POST
* timeOut : 10000, // ms
* rawResponse : false, // true|false
* scope : null, // this
* onSuccess : function (response) {},
* onFailure : function (error) {},
* // spécifique au service
* positions : [{lon:, lat:}, {lon:, lat:}],
* outputFormat : 'json' // json|xml
* sampling : 3,
* api : 'REST', // REST|WPS
* zonly : false // false|true,
* resource : "resource-par-defaut"
* };
*
*/
function Alti (options) {
if (!(this instanceof Alti)) {
throw new TypeError(_.getMessage("CLASS_CONSTRUCTOR", "Alti"));
}
/**
* Nom de la classe (heritage)
* FIXME instance ou classe ?
*/
this.CLASSNAME = "Alti";
// appel du constructeur par heritage
CommonService.apply(this, arguments);
this.logger = Logger.getLogger("Gp.Services.Alti");
this.logger.trace("[Constructeur Alti (options)]");
// #####################
// analyse des options
// #####################
if (!options.positions) {
throw new Error(_.getMessage("PARAM_MISSING", "positions"));
}
if (options.positions.length === 0) {
throw new Error(_.getMessage("PARAM_EMPTY", "positions"));
}
// ajout des options spécifiques au service
this.options.positions = options.positions;
// format de réponse du service : "json" ou "xml" (valeur par défaut), en minuscule !
this.options.outputFormat = (typeof options.outputFormat === "string") ? options.outputFormat.toLowerCase() : "xml";
// ressource utilisée pour le calcul altimétrique
this.options.resource = options.resource || "ign_rge_alti_wld";
// sampling
this.options.sampling = options.sampling || null;
// type d'api utilisé pour requeter le service, en majuscule !
this.options.api = (typeof options.api === "string") ? options.api.toUpperCase() : "REST";
// l'api ne peut être interrogée qu'en GET.
if (this.options.api === "REST") {
this.options.httpMethod = "GET";
}
// param. zonly
this.options.zonly = options.zonly || false;
// param. measures
this.options.measures = options.measures || false;
// gestion de l'url du service par defaut
// si l'url n'est pas renseignée, il faut utiliser les urls par defaut
// en fonction du type d'api, REST ou WPS, du format de reponse demandé (outputFormat)
// ainsi que sur le type de service (profil ou elevation)
if (!this.options.serverUrl) {
var lstUrlByDefault = DefaultUrlService.Alti.newUrl();
var urlFound = null;
switch (this.options.api) {
case "WPS":
urlFound = lstUrlByDefault.wps;
break;
case "REST":
var key = (options.sampling ? "profil" : "elevation") + "-" + this.options.outputFormat;
urlFound = lstUrlByDefault[key];
break;
default:
throw new Error(_.getMessage("PARAM_UNKNOWN", "api"));
}
if (!urlFound) {
throw new Error("Url by default not found !");
}
this.options.serverUrl = urlFound;
this.logger.trace("Server URL by default : " + this.options.serverUrl);
}
// gestion du type de service
// si l'extension de l'url est .json ou .xml, on surcharge le format de sortie (outputFormat)
var idx = this.options.serverUrl.lastIndexOf(".");
if (idx !== -1) {
var extension = this.options.serverUrl.substring(idx + 1);
if (extension && extension.length < 5) { // FIXME extension de moins de 4 car. ...
this.logger.trace("Server Extension URL : " + extension);
switch (extension.toLowerCase()) {
case "json":
case "xml":
this.options.outputFormat = extension.toLowerCase();
break;
default:
throw new Error("type of service : unknown or unsupported (json or xml) !");
}
}
}
}
/**
* @lends module:Alti#
*/
Alti.prototype = Object.create(CommonService.prototype, {
// todo
// getter/setter
});
/**
* Constructeur (alias)
*/
Alti.prototype.constructor = Alti;
/**
* Création de la requête (overwrite)
*
* @param {Function} error - callback des erreurs
* @param {Function} success - callback
*/
Alti.prototype.buildRequest = function (error, success) {
// utilisation en mode callback
var options = {
httpMethod : this.options.httpMethod,
// callback
onSuccess : function (result) {
// sauvegarde de la requete !
this.request = result;
success.call(this, this.request);
},
onError : error,
scope : this,
// spécifique au service :
resource : this.options.resource,
positions : this.options.positions,
outputFormat : this.options.outputFormat,
sampling : this.options.sampling,
api : this.options.api,
zonly : this.options.zonly,
measures : this.options.measures
};
AltiRequestFactory.build(options);
};
/**
* Analyse de la reponse (overwrite)
*
* @param {Function} error - callback des erreurs
* @param {Function} success - callback
*/
Alti.prototype.analyzeResponse = function (error, success) {
// INFO
// Factory pour masquer la complexité du retour du service qui renvoie soit
// - une 'string' qui contient du XML ou JSON natif en mode XHR
// - un objet JSON qui est natif ou encapsulé
if (this.response) {
var options = {
response : this.response,
outputFormat : this.options.outputFormat, // utile pour parser la string en mode XHR : JSON ou XML !
rawResponse : this.options.rawResponse,
onError : error,
onSuccess : success,
scope : this
};
AltiResponseFactory.build(options);
} else {
error.call(this, new ErrorService(_.getMessage("SERVICE_RESPONSE_EMPTY")));
}
};
export default Alti;
|