--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/pyams_gis/resources/js/leaflet-esri-gp-2.0.1.js Thu May 18 17:23:48 2017 +0200
@@ -0,0 +1,281 @@
+/* esri-leaflet-gp - v2.0.1 - Fri Sep 09 2016 14:42:04 GMT-0700 (PDT)
+ * Copyright (c) 2016 Environmental Systems Research Institute, Inc.
+ * Apache-2.0 */
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('leaflet'), require('esri-leaflet')) :
+ typeof define === 'function' && define.amd ? define(['exports', 'leaflet', 'esri-leaflet'], factory) :
+ (factory((global.L = global.L || {}, global.L.esri = global.L.esri || {}, global.L.esri.GP = global.L.esri.GP || {}),global.L,global.L.esri));
+}(this, function (exports,L,esriLeaflet) { 'use strict';
+
+ L = 'default' in L ? L['default'] : L;
+
+ var version = "2.0.1";
+
+ var Task$1 = esriLeaflet.Task.extend({
+
+ includes: L.Mixin.Events,
+
+ // setters: {}, we don't use these because we don't know the ParamName OR value of custom GP services
+ params: {},
+ resultParams: {},
+
+ initialize: function (options) {
+ // don't replace parent initialize
+ esriLeaflet.Task.prototype.initialize.call(this, options);
+
+ // if path isn't supplied in options, try and determine if its sync or async to set automatically
+ if (!this.options.path) {
+ // assume initially, that service is synchronous
+ this.options.async = false;
+ this.options.path = 'execute';
+
+ // the parameters below seem wonky to me, but work for both CORS and JSONP requests
+ this._service.metadata(function (error, results) {
+ if (!error) {
+ if (results.executionType === 'esriExecutionTypeSynchronous') {
+ this.options.async = false;
+ this.options.path = 'execute';
+ } else {
+ this.options.async = true;
+ this.options.path = 'submitJob';
+ }
+ this.fire('initialized');
+ } else {
+ // if check fails, hopefully its synchronous
+ this.options.async = false;
+ this.options.path = 'execute';
+ return;
+ }
+ }, this);
+ } else {
+ // if path is custom, hopefully its synchronous
+ if (this.options.async !== true && this.options.path !== 'submitJob') {
+ this.options.async = false;
+ }
+ }
+ },
+
+ // doc for various GPInput types can be found here
+ // http://resources.arcgis.com/en/help/arcgis-rest-api/index.html#/GP_Result/02r3000000q7000000/
+
+ // set booleans, numbers, strings
+ setParam: function (paramName, paramValue) {
+ if (typeof paramValue === 'boolean') {
+ this.params[paramName] = paramValue;
+ return;
+ } else if (typeof paramValue !== 'object') { // strings, numbers
+ this.params[paramName] = paramValue;
+ return;
+ } else {
+ // otherwise assume its latlng, marker, bounds or geojson
+ this._setGeometry(paramName, paramValue);
+ }
+ },
+
+ // not sure how best to handle passing more than one parameter at once
+ // setParams: function(inputArray) {
+ // if (L.Util.isArray(inputArray)) {
+ // for (var i = 0; i < inputArray.length; i++) {
+ // this.setParam(inputArray[i]);
+ // }
+ // }
+ // },
+
+ // give developer opportunity to point out where the output is going to be available
+ setOutputParam: function (paramName) {
+ this.params.outputParam = paramName;
+ },
+
+ /* necessary because of the design requirement that resultParams be specified
+ for async elevation services in order to get Zs (unnecessarily confusing)*/
+ gpAsyncResultParam: function (paramName, paramValue) {
+ this.resultParams[paramName] = paramValue;
+ },
+
+ // we currently expect a single geometry or feature (ported from: Tasks.Query._setGeometry)
+ _setGeometry: function (paramName, geometry) {
+ var processedInput = {
+ 'geometryType': '',
+ 'features': []
+ };
+
+ // convert bounds to extent and finish
+ if (geometry instanceof L.LatLngBounds) {
+ // set geometry + type
+ processedInput.features.push({'geometry': L.esri.Util.boundsToExtent(geometry)});
+ processedInput.geometryType = L.esri.Util.geojsonTypeToArcGIS(geometry.type);
+ }
+
+ // convert L.Marker > L.LatLng
+ if (geometry.getLatLng) {
+ geometry = geometry.getLatLng();
+ }
+
+ // convert L.LatLng to a geojson point and continue;
+ if (geometry instanceof L.LatLng) {
+ geometry = {
+ type: 'Point',
+ coordinates: [geometry.lng, geometry.lat]
+ };
+ }
+
+ // handle L.GeoJSON, pull out the first geometry
+ if (geometry instanceof L.GeoJSON) {
+ // reassign geometry to the GeoJSON value (we are assuming that only one feature is present)
+ geometry = geometry.getLayers()[0].feature.geometry;
+ processedInput.features.push({'geometry': esriLeaflet.Util.geojsonToArcGIS(geometry)});
+ processedInput.geometryType = esriLeaflet.Util.geojsonTypeToArcGIS(geometry.type);
+ }
+
+ // Handle L.Polyline and L.Polygon
+ if (geometry.toGeoJSON) {
+ geometry = geometry.toGeoJSON();
+ }
+
+ // handle GeoJSON feature by pulling out the geometry
+ if (geometry.type === 'Feature') {
+ // get the geometry of the geojson feature
+ geometry = geometry.geometry;
+ }
+
+ // confirm that our GeoJSON is a point, line or polygon
+ if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') {
+ processedInput.features.push({'geometry': esriLeaflet.Util.geojsonToArcGIS(geometry)});
+ processedInput.geometryType = esriLeaflet.Util.geojsonTypeToArcGIS(geometry.type);
+ } else {
+ if (console && console.warn) {
+ console.warn('invalid geometry passed as GP input. Should be an L.LatLng, L.LatLngBounds, L.Marker or GeoJSON Point Line or Polygon object');
+ }
+ }
+
+ this.params[paramName] = processedInput;
+ return;
+ },
+
+ run: function (callback, context) {
+ this._done = false;
+
+ if (this.options.async === true) {
+ /* eslint-disable */
+ this._service.request(this.options.path, this.params, function (error, response) {
+ this._currentJobId = response.jobId;
+ this.checkJob(this._currentJobId, callback, context);
+ }, this);
+ /* eslint-enable */
+ } else {
+ return this._service.request(this.options.path, this.params, function (error, response) {
+ callback.call(context, error, (response && this.processGPOutput(response)), response);
+ }, this);
+ }
+ },
+
+ checkJob: function (jobId, callback, context) {
+ var pollJob = function () {
+ /* eslint-disable */
+ this._service.request('jobs/' + jobId, {}, function polledJob (error, response) {
+ if (response.jobStatus === 'esriJobSucceeded') {
+ if (!this._done) {
+ this._done = true;
+ // to do:
+ // refactor to make an array of async requests for output
+ this._service.request('jobs/' + jobId + '/results/' + this.params.outputParam, this.resultParams, function processJobResult (error, response) {
+ callback.call(context, error, (response && this.processAsyncOutput(response)), response);
+ }, this);
+ }
+ window.clearInterval(counter);
+ } else if (response.jobStatus === 'esriJobFailed') {
+ callback.call(context, 'Job Failed', null);
+ window.clearInterval(counter);
+ }
+ }, this);
+ /* eslint-enable */
+ }.bind(this);
+
+ var counter = window.setInterval(pollJob, this._service.options.asyncInterval * 1000);
+ },
+
+ processGPOutput: function (response) {
+ var processedResponse = {};
+
+ // grab syncronous results
+ if (this.options.async === false) {
+ // loop through results and pass back, parsing esri json
+ for (var i = 0; i < response.results.length; i++) {
+ /* jshint ignore:start */
+ processedResponse[response.results[i].paramName];
+ /* jshint ignore:end */
+ if (response.results[i].dataType === 'GPFeatureRecordSetLayer') {
+ var featureCollection = esriLeaflet.Util.responseToFeatureCollection(response.results[i].value);
+ processedResponse[response.results[i].paramName] = featureCollection;
+ } else {
+ processedResponse[response.results[i].paramName] = response.results[i].value;
+ }
+ }
+ } else { // grab async results slightly differently
+ processedResponse.jobId = this._currentJobId;
+ // var responseValue = response.value;
+ }
+
+ // if output is a raster layer, we also need to stub out a MapService url using jobid
+ if (this.options.async === true && response.dataType === 'GPRasterDataLayer') {
+ var baseURL = this.options.url;
+ var n = baseURL.indexOf('GPServer');
+ var serviceURL = baseURL.slice(0, n) + 'MapServer/';
+ processedResponse.outputMapService = serviceURL + 'jobs/' + this._currentJobId;
+ }
+
+ return processedResponse;
+ },
+
+ processAsyncOutput: function (response) {
+ var processedResponse = {};
+ processedResponse.jobId = this._currentJobId;
+
+ // if output is a raster layer, we also need to stub out a MapService url using jobid
+ if (this.options.async === true && response.dataType === 'GPRasterDataLayer') {
+ var baseURL = this.options.url;
+ var n = baseURL.indexOf('GPServer');
+ var serviceURL = baseURL.slice(0, n) + 'MapServer/';
+ processedResponse.outputMapService = serviceURL + 'jobs/' + this._currentJobId;
+ }
+
+ // if output is GPFeatureRecordSetLayer, convert to GeoJSON
+ if (response.dataType === 'GPFeatureRecordSetLayer') {
+ var featureCollection = esriLeaflet.Util.responseToFeatureCollection(response.value);
+ processedResponse[response.paramName] = featureCollection;
+ } else {
+ processedResponse[response.paramName] = response.value;
+ }
+
+ return processedResponse;
+ }
+
+ });
+
+ function task (options) {
+ return new Task$1(options);
+ }
+
+ var Service$1 = esriLeaflet.Service.extend({
+ options: {
+ asyncInterval: 1
+ },
+
+ createTask: function () {
+ return new Task$1(this, this.options);
+ }
+
+ });
+
+ function service (options) {
+ return new Service$1(options);
+ }
+
+ exports.VERSION = version;
+ exports.Task = Task$1;
+ exports.task = task;
+ exports.Service = Service$1;
+ exports.service = service;
+
+}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"esri-leaflet-gp-debug.js","sources":["../package.json","../src/Tasks/Geoprocessing.js","../src/Services/Geoprocessing.js"],"sourcesContent":["{\n  \"name\": \"esri-leaflet-gp\",\n  \"description\": \"A Leaflet plugin for interacting with ArcGIS geoprocessing services.\",\n  \"version\": \"2.0.1\",\n  \"author\": \"John Gravois <jgravois@esri.com> (http://johngravois.com)\",\n  \"browser\": \"dist/esri-leaflet-gp-debug.js\",\n  \"bugs\": {\n    \"url\": \"https://github.com/jgravois/esri-leaflet-gp/issues\"\n  },\n  \"contributors\": [\n    \"John Gravois <jgravois@esri.com> (http://johngravois.com)\",\n    \"Nicholas Furness <nfurness@esri.com> (http://nixta.github.io/)\",\n    \"Patrick Arlt <parlt@esri.com> (http://patrickarlt.com)\",\n    \"Rowan Winsemius\"\n  ],\n  \"dependencies\": {\n    \"leaflet\": \"^1.0.0-rc.3\",\n    \"esri-leaflet\": \"^2.0.0\"\n  },\n  \"devDependencies\": {\n    \"chai\": \"2.3.0\",\n    \"gh-release\": \"^2.0.0\",\n    \"highlight.js\": \"^8.0.0\",\n    \"http-server\": \"^0.8.5\",\n    \"isparta\": \"^3.0.3\",\n    \"istanbul\": \"^0.4.2\",\n    \"karma\": \"^0.12.24\",\n    \"karma-chai-sinon\": \"^0.1.3\",\n    \"karma-coverage\": \"^0.5.3\",\n    \"karma-mocha\": \"^0.1.0\",\n    \"karma-mocha-reporter\": \"^0.2.5\",\n    \"karma-phantomjs-launcher\": \"^0.2.0\",\n    \"karma-sourcemap-loader\": \"^0.3.5\",\n    \"mkdirp\": \"^0.5.1\",\n    \"phantomjs\": \"^1.9.17\",\n    \"rollup\": \"^0.25.4\",\n    \"rollup-plugin-json\": \"^2.0.0\",\n    \"rollup-plugin-node-resolve\": \"^1.4.0\",\n    \"rollup-plugin-uglify\": \"^0.1.0\",\n    \"semistandard\": \"^7.0.5\",\n    \"sinon\": \"^1.11.1\",\n    \"sinon-chai\": \"2.7.0\",\n    \"snazzy\": \"^2.0.1\",\n    \"uglify-js\": \"^2.6.1\",\n    \"watch\": \"^0.17.1\"\n  },\n  \"homepage\": \"https://github.com/jgravois/esri-leaflet-gp\",\n  \"jsnext:main\": \"src/EsriLeafletGP.js\",\n  \"jspm\": {\n    \"registry\": \"npm\",\n    \"format\": \"es6\",\n    \"main\": \"src/EsriLeafletGP.js\"\n  },\n  \"license\": \"Apache-2.0\",\n  \"main\": \"dist/esri-leaflet-gp-debug.js\",\n  \"readmeFilename\": \"README.md\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"git@github.com:jgravois/esri-leaflet-gp.git\"\n  },\n  \"scripts\": {\n    \"prebuild\": \"mkdirp dist\",\n    \"build\": \"rollup -c profiles/debug.js & rollup -c profiles/production.js\",\n    \"lint\": \"semistandard src/**/*.js | snazzy\",\n    \"prepublish\": \"npm run build\",\n    \"pretest\": \"npm run build\",\n    \"test\": \"npm run lint && karma start\",\n    \"release\": \"./scripts/release.sh\",\n    \"start\": \"watch 'npm run build' src & http-server -p 5000 -c-1 -o\"\n  }\n}\n","/*\nto do:\nsetParam([])\n*/\n\nimport L from 'leaflet';\nimport { Task as BaseTask, Util } from 'esri-leaflet';\n\nexport var Task = BaseTask.extend({\n\n  includes: L.Mixin.Events,\n\n  // setters: {}, we don't use these because we don't know the ParamName OR value of custom GP services\n  params: {},\n  resultParams: {},\n\n  initialize: function (options) {\n    // don't replace parent initialize\n    BaseTask.prototype.initialize.call(this, options);\n\n    // if path isn't supplied in options, try and determine if its sync or async to set automatically\n    if (!this.options.path) {\n      // assume initially, that service is synchronous\n      this.options.async = false;\n      this.options.path = 'execute';\n\n      // the parameters below seem wonky to me, but work for both CORS and JSONP requests\n      this._service.metadata(function (error, results) {\n        if (!error) {\n          if (results.executionType === 'esriExecutionTypeSynchronous') {\n            this.options.async = false;\n            this.options.path = 'execute';\n          } else {\n            this.options.async = true;\n            this.options.path = 'submitJob';\n          }\n          this.fire('initialized');\n        } else {\n          // if check fails, hopefully its synchronous\n          this.options.async = false;\n          this.options.path = 'execute';\n          return;\n        }\n      }, this);\n    } else {\n      // if path is custom, hopefully its synchronous\n      if (this.options.async !== true && this.options.path !== 'submitJob') {\n        this.options.async = false;\n      }\n    }\n  },\n\n  // doc for various GPInput types can be found here\n  // http://resources.arcgis.com/en/help/arcgis-rest-api/index.html#/GP_Result/02r3000000q7000000/\n\n  // set booleans, numbers, strings\n  setParam: function (paramName, paramValue) {\n    if (typeof paramValue === 'boolean') {\n      this.params[paramName] = paramValue;\n      return;\n    } else if (typeof paramValue !== 'object') { // strings, numbers\n      this.params[paramName] = paramValue;\n      return;\n    } else {\n      // otherwise assume its latlng, marker, bounds or geojson\n      this._setGeometry(paramName, paramValue);\n    }\n  },\n\n  // not sure how best to handle passing more than one parameter at once\n  // setParams: function(inputArray) {\n  //   if (L.Util.isArray(inputArray)) {\n  //     for (var i = 0; i < inputArray.length; i++) {\n  //       this.setParam(inputArray[i]);\n  //     }\n  //   }\n  // },\n\n  // give developer opportunity to point out where the output is going to be available\n  setOutputParam: function (paramName) {\n    this.params.outputParam = paramName;\n  },\n\n  /* necessary because of the design requirement that resultParams be specified\n  for async elevation services in order to get Zs (unnecessarily confusing)*/\n  gpAsyncResultParam: function (paramName, paramValue) {\n    this.resultParams[paramName] = paramValue;\n  },\n\n  // we currently expect a single geometry or feature (ported from: Tasks.Query._setGeometry)\n  _setGeometry: function (paramName, geometry) {\n    var processedInput = {\n      'geometryType': '',\n      'features': []\n    };\n\n    // convert bounds to extent and finish\n    if (geometry instanceof L.LatLngBounds) {\n      // set geometry + type\n      processedInput.features.push({'geometry': L.esri.Util.boundsToExtent(geometry)});\n      processedInput.geometryType = L.esri.Util.geojsonTypeToArcGIS(geometry.type);\n    }\n\n    // convert L.Marker > L.LatLng\n    if (geometry.getLatLng) {\n      geometry = geometry.getLatLng();\n    }\n\n    // convert L.LatLng to a geojson point and continue;\n    if (geometry instanceof L.LatLng) {\n      geometry = {\n        type: 'Point',\n        coordinates: [geometry.lng, geometry.lat]\n      };\n    }\n\n    // handle L.GeoJSON, pull out the first geometry\n    if (geometry instanceof L.GeoJSON) {\n      // reassign geometry to the GeoJSON value  (we are assuming that only one feature is present)\n      geometry = geometry.getLayers()[0].feature.geometry;\n      processedInput.features.push({'geometry': Util.geojsonToArcGIS(geometry)});\n      processedInput.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n    }\n\n    // Handle L.Polyline and L.Polygon\n    if (geometry.toGeoJSON) {\n      geometry = geometry.toGeoJSON();\n    }\n\n    // handle GeoJSON feature by pulling out the geometry\n    if (geometry.type === 'Feature') {\n      // get the geometry of the geojson feature\n      geometry = geometry.geometry;\n    }\n\n    // confirm that our GeoJSON is a point, line or polygon\n    if (geometry.type === 'Point' || geometry.type === 'LineString' || geometry.type === 'Polygon') {\n      processedInput.features.push({'geometry': Util.geojsonToArcGIS(geometry)});\n      processedInput.geometryType = Util.geojsonTypeToArcGIS(geometry.type);\n    } else {\n      if (console && console.warn) {\n        console.warn('invalid geometry passed as GP input. Should be an L.LatLng, L.LatLngBounds, L.Marker or GeoJSON Point Line or Polygon object');\n      }\n    }\n\n    this.params[paramName] = processedInput;\n    return;\n  },\n\n  run: function (callback, context) {\n    this._done = false;\n\n    if (this.options.async === true) {\n      /* eslint-disable */\n      this._service.request(this.options.path, this.params, function (error, response) {\n        this._currentJobId = response.jobId;\n        this.checkJob(this._currentJobId, callback, context);\n      }, this);\n      /* eslint-enable */\n    } else {\n      return this._service.request(this.options.path, this.params, function (error, response) {\n        callback.call(context, error, (response && this.processGPOutput(response)), response);\n      }, this);\n    }\n  },\n\n  checkJob: function (jobId, callback, context) {\n    var pollJob = function () {\n      /* eslint-disable */\n      this._service.request('jobs/' + jobId, {}, function polledJob (error, response) {\n        if (response.jobStatus === 'esriJobSucceeded') {\n          if (!this._done) {\n            this._done = true;\n            // to do:\n            // refactor to make an array of async requests for output\n            this._service.request('jobs/' + jobId + '/results/' + this.params.outputParam, this.resultParams, function processJobResult (error, response) {\n              callback.call(context, error, (response && this.processAsyncOutput(response)), response);\n            }, this);\n          }\n          window.clearInterval(counter);\n        } else if (response.jobStatus === 'esriJobFailed') {\n          callback.call(context, 'Job Failed', null);\n          window.clearInterval(counter);\n        }\n      }, this);\n      /* eslint-enable */\n    }.bind(this);\n\n    var counter = window.setInterval(pollJob, this._service.options.asyncInterval * 1000);\n  },\n\n  processGPOutput: function (response) {\n    var processedResponse = {};\n\n    // grab syncronous results\n    if (this.options.async === false) {\n      // loop through results and pass back, parsing esri json\n      for (var i = 0; i < response.results.length; i++) {\n        /* jshint ignore:start */\n        processedResponse[response.results[i].paramName];\n        /* jshint ignore:end */\n        if (response.results[i].dataType === 'GPFeatureRecordSetLayer') {\n          var featureCollection = Util.responseToFeatureCollection(response.results[i].value);\n          processedResponse[response.results[i].paramName] = featureCollection;\n        } else {\n          processedResponse[response.results[i].paramName] = response.results[i].value;\n        }\n      }\n    } else { // grab async results slightly differently\n      processedResponse.jobId = this._currentJobId;\n      // var responseValue = response.value;\n    }\n\n    // if output is a raster layer, we also need to stub out a MapService url using jobid\n    if (this.options.async === true && response.dataType === 'GPRasterDataLayer') {\n      var baseURL = this.options.url;\n      var n = baseURL.indexOf('GPServer');\n      var serviceURL = baseURL.slice(0, n) + 'MapServer/';\n      processedResponse.outputMapService = serviceURL + 'jobs/' + this._currentJobId;\n    }\n\n    return processedResponse;\n  },\n\n  processAsyncOutput: function (response) {\n    var processedResponse = {};\n    processedResponse.jobId = this._currentJobId;\n\n    // if output is a raster layer, we also need to stub out a MapService url using jobid\n    if (this.options.async === true && response.dataType === 'GPRasterDataLayer') {\n      var baseURL = this.options.url;\n      var n = baseURL.indexOf('GPServer');\n      var serviceURL = baseURL.slice(0, n) + 'MapServer/';\n      processedResponse.outputMapService = serviceURL + 'jobs/' + this._currentJobId;\n    }\n\n    // if output is GPFeatureRecordSetLayer, convert to GeoJSON\n    if (response.dataType === 'GPFeatureRecordSetLayer') {\n      var featureCollection = Util.responseToFeatureCollection(response.value);\n      processedResponse[response.paramName] = featureCollection;\n    } else {\n      processedResponse[response.paramName] = response.value;\n    }\n\n    return processedResponse;\n  }\n\n});\n\nexport function task (options) {\n  return new Task(options);\n}\n\nexport default task;\n","import { Service as BaseService } from 'esri-leaflet';\nimport { Task } from '../Tasks/Geoprocessing';\n\nexport var Service = BaseService.extend({\n  options: {\n    asyncInterval: 1\n  },\n\n  createTask: function () {\n    return new Task(this, this.options);\n  }\n\n});\n\nexport function service (options) {\n  return new Service(options);\n}\n\nexport default service;\n"],"names":["Task","BaseTask","Util","Service","BaseService"],"mappings":"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"}
\ No newline at end of file