/*global saveAs, saveTextAs */
|
define([
|
'dojo/_base/declare',
|
'dojo/_base/lang',
|
'dojo/_base/array',
|
'dojo/json',
|
'dojo/Deferred',
|
'esri/tasks/query',
|
'esri/tasks/QueryTask',
|
'esri/tasks/FeatureSet',
|
'esri/graphic',
|
'esri/SpatialReference',
|
'esri/tasks/ProjectParameters',
|
'esri/config',
|
'esri/geometry/webMercatorUtils',
|
'jimu/LayerInfos/LayerInfos',
|
'./utils',
|
'./GeojsonConverters'],
|
function(declare, lang, array, JSON, Deferred, Query, QueryTask, FeatureSet, Graphic,
|
SpatialReference, ProjectParameters, esriConfig, webMercatorUtils, LayerInfos,
|
jimuUtils, GeojsonConverters) {
|
/* global dojo */
|
var mo = {};
|
|
/**
|
* options should contain the following attributes:
|
* 1. type: type of the data source, can be mo.TYPE_TABLE or mo.TYPE_FEATURESET
|
* 2. filename: output file name
|
* 3. url: url of the data source if it is fetched remotely
|
* 4. data: data source if it is local.
|
* You can choose to use url or data, but not both of them.
|
*/
|
mo.createDataSource = function(options){
|
if(options.type === mo.TYPE_TABLE){
|
return new TableDS(options);
|
}else if(options.type === mo.TYPE_FEATURESET){
|
return new FeatureSetDS(options);
|
}else{
|
return null;
|
}
|
};
|
|
mo.TYPE_TABLE = 'table';
|
mo.TYPE_FEATURESET = 'FeatureSet';
|
mo.FORMAT_CSV = 'CSV';
|
mo.FORMAT_FEATURESET = 'FeatureSet';
|
mo.FORMAT_GEOJSON = 'GeoJSON';
|
|
var DataSource = declare(null, {
|
filename: undefined,
|
suffix: '.txt',
|
format: undefined,
|
nls: undefined,
|
|
constructor: function(){
|
this.nls = window.jimuNls.exportTo;
|
},
|
|
/**
|
* Calculate the string content of the exported data.
|
* Must be implemented by sub class.
|
*/
|
getExportString: function(){
|
|
},
|
|
/**
|
* Return the supported format array. Each item contains two attributes:
|
* label: the nls string for this format
|
* value: used to invoke the setFormat() method
|
*/
|
getSupportExportFormats: function(){
|
|
},
|
|
setFormat: function(value){
|
this.format = value;
|
},
|
|
download: function(){
|
this.getExportString().then(lang.hitch(this, function(str){
|
download(this.filename + this.suffix, str);
|
}));
|
},
|
|
exportToPortal: function(format, itemName){
|
/*jshint unused: false*/
|
}
|
});
|
|
/**
|
* options should include:
|
* featureSet or url,
|
* filename
|
*/
|
var FeatureSetDS = declare(DataSource, {
|
featureSet: null,
|
|
constructor: function(options){
|
this.inherited(arguments);
|
|
this.featureSet = options.data;
|
this.url = options.url;
|
this.filename = options.filename;
|
},
|
|
getExportString: function(){
|
if(this.format === mo.FORMAT_CSV){
|
this.suffix = '.csv';
|
return this._getAsCSVString();
|
}else if(this.format === mo.FORMAT_FEATURESET){
|
this.suffix = '.json';
|
return this._getAsFeatureSetString();
|
}else if(this.format === mo.FORMAT_GEOJSON){
|
this.suffix = '.geojson';
|
return this._getAsGeoJsonString();
|
}else{
|
var ret = new Deferred();
|
ret.resolve('');
|
return ret;
|
}
|
},
|
|
getSupportExportFormats: function(){
|
return [{
|
value: mo.FORMAT_CSV,
|
label: this.nls.toCSV
|
}, {
|
value: mo.FORMAT_FEATURESET,
|
label: this.nls.toFeatureCollection
|
}, {
|
value: mo.FORMAT_GEOJSON,
|
label: this.nls.toGeoJSON
|
}];
|
},
|
|
_getFeatureSet: function(){
|
var ret = new Deferred();
|
|
if(this.featureSet){
|
ret.resolve(this.featureSet);
|
}else if(this.url){
|
var query = new Query();
|
query.returnGeometry = true;
|
query.outFields = ['*'];
|
|
this.queryTask = new QueryTask(this.url);
|
this.queryTask.execute(query, lang.hitch(this, function(fs){
|
ret.resolve(fs);
|
}), lang.hitch(this, function(){
|
ret.resolve(null);
|
}));
|
}else{
|
ret.resolve(null);
|
}
|
|
return ret;
|
},
|
|
_getSpatialReference: function(featureset) {
|
if (featureset.spatialReference) {
|
return featureset.spatialReference;
|
}
|
// Get spatial refrence from graphics
|
var sf;
|
array.some(featureset.features, function(feature) {
|
if (feature.geometry && feature.geometry.spatialReference){
|
sf = feature.geometry.spatialReference;
|
return true;
|
}
|
});
|
return sf;
|
},
|
|
_projectToWGS84: function(featureset) {
|
var ret = new Deferred();
|
var sf = this._getSpatialReference(featureset);
|
if (!sf) {
|
ret.resolve([]);
|
} else {
|
var wkid = parseInt(sf.wkid, 10);
|
|
if (wkid === 4326) {
|
ret.resolve(featureset);
|
} else if (sf.isWebMercator()) {
|
var outFeatureset = new FeatureSet();
|
var features = [];
|
array.forEach(featureset.features, function(feature) {
|
var g = new Graphic();
|
g.attributes = feature.attributes;
|
g.geometry = webMercatorUtils.webMercatorToGeographic(feature.geometry);
|
features.push(g);
|
});
|
outFeatureset.features = features;
|
ret.resolve(outFeatureset);
|
} else {
|
var params = new ProjectParameters();
|
params.geometries = array.map(featureset.features, function(feature) {
|
return feature.geometry;
|
});
|
params.outSR = new SpatialReference(4326);
|
|
var gs = esriConfig && esriConfig.defaults && esriConfig.defaults.geometryService;
|
var existGS = gs && gs.declaredClass === "esri.tasks.GeometryService";
|
if (!existGS) {
|
gs = jimuUtils.getArcGISDefaultGeometryService();
|
}
|
|
gs.project(params).then(function(geometries) {
|
var outFeatureset = new FeatureSet();
|
var features = [];
|
array.forEach(featureset.features, function(feature, i) {
|
var g = new Graphic();
|
g.attributes = feature.attributes;
|
g.geometry = geometries[i];
|
features.push(g);
|
});
|
outFeatureset.features = features;
|
ret.resolve(outFeatureset);
|
}, function(err) {
|
console.error(err);
|
ret.resolve([]);
|
});
|
}
|
}
|
return ret;
|
},
|
|
_getAsFeatureSetString: function(){
|
return this._getFeatureSet().then(lang.hitch(this, function(fs){
|
var str = '';
|
if(fs){
|
var jsonObj = fs.toJson();
|
if(jsonObj){
|
str = JSON.stringify(jsonObj);
|
}
|
}
|
return str;
|
}));
|
},
|
|
_getAsGeoJsonString: function(){
|
return this._getFeatureSet()
|
.then(lang.hitch(this, function(fs) {
|
return this._projectToWGS84(fs);
|
}))
|
.then(lang.hitch(this, function(fs){
|
var str = '';
|
if(fs && fs.features && fs.features.length > 0){
|
var jsonObj = {
|
type: 'FeatureCollection',
|
features: []
|
};
|
array.forEach(fs.features, function(feature) {
|
jsonObj.features.push(GeojsonConverters.arcgisToGeoJSON(feature));
|
});
|
str = JSON.stringify(jsonObj);
|
}
|
return str;
|
}));
|
},
|
|
_getAsCSVString: function(){
|
return this._getFeatureSet().then(lang.hitch(this, function(fs){
|
var str = '';
|
if(fs){
|
str = this._createCSVFromFeatureSet(fs);
|
}
|
return str;
|
}));
|
},
|
|
_createCSVFromFeatureSet: function(featureSet){
|
var fields = this._generateFields(featureSet);
|
|
var datas = array.map(featureSet.features, function(feature){
|
var attributes = lang.clone(feature.attributes);
|
if (featureSet.geometryType === 'esriGeometryPoint' ||
|
featureSet.geometryType === 'point') {
|
if (feature.geometry) {
|
attributes.x = feature.geometry.x;
|
attributes.y = feature.geometry.y;
|
if (feature.geometry.spatialReference &&
|
feature.geometry.spatialReference.wkid) {
|
attributes.wkid = feature.geometry.spatialReference.wkid;
|
}
|
}
|
}
|
return attributes;
|
});
|
|
return createCSVString(fields, datas);
|
},
|
|
_generateFields: function(featureSet) {
|
var feature = featureSet.features[0];
|
var fields, item, layerId;
|
|
if(feature._layer) {
|
fields = feature._layer.fields;
|
layerId = feature._layer.id;
|
}
|
|
fields = lang.clone(fields || featureSet.fields);
|
if(!fields || fields.length === 0){
|
fields = [];
|
var attributes = feature.attributes;
|
for(item in attributes){
|
if(attributes.hasOwnProperty(item)){
|
fields.push({
|
name: item
|
});
|
}
|
}
|
}
|
|
var layerInfos = LayerInfos.getInstanceSync();
|
var layerInfo = layerInfos.getLayerInfoById(layerId);
|
if (layerInfo) {
|
var popupInfo = layerInfo.getPopupInfo();
|
if (!popupInfo) {
|
// Try another way to get popupInfo
|
popupInfo = layerInfo.layerObject.infoTemplate && layerInfo.layerObject.infoTemplate.info;
|
}
|
array.forEach(fields, lang.hitch(this, function(field) {
|
field.fieldInfo = this._findFieldInfo(popupInfo, field.name);
|
}));
|
}
|
|
if(featureSet.fieldAliases){
|
//Set of name-value pairs for the attribute's field and alias names.
|
array.forEach(fields, function(field) {
|
if (featureSet.fieldAliases[field.name]) {
|
field.alias = featureSet.fieldAliases[field.name];
|
}
|
});
|
}
|
if (featureSet.geometryType === 'esriGeometryPoint' ||
|
featureSet.geometryType === 'point') {
|
fields.push({
|
name: 'x',
|
type: 'esriFieldTypeDouble',
|
alias: 'x'
|
});
|
fields.push({
|
name: 'y',
|
type: 'esriFieldTypeDouble',
|
alias: 'y'
|
});
|
fields.push({
|
name: 'wkid',
|
type: 'esriFieldTypeInteger',
|
alias: 'wkid'
|
});
|
}
|
return fields;
|
},
|
|
_findFieldInfo: function(popupInfo, fieldName) {
|
if (!popupInfo) {
|
return null;
|
}
|
var fieldInfo;
|
array.some(popupInfo.fieldInfos, function(info) {
|
if (info.fieldName === fieldName) {
|
fieldInfo = info;
|
return true;
|
}
|
});
|
return fieldInfo;
|
}
|
});
|
|
/**
|
* options should include:
|
* table or url,
|
* filename
|
*/
|
var TableDS = declare(DataSource, {
|
table: null,
|
|
constructor: function(options){
|
this.inherited(arguments);
|
this.table = options.data;
|
this.url = options.url;
|
this.filename = options.filename;
|
},
|
|
getExportString: function(){
|
if(this.format === mo.FORMAT_CSV){
|
this.suffix = '.csv';
|
return this._getAsCSVString();
|
}else{
|
var ret = new Deferred();
|
ret.resolve('');
|
return ret;
|
}
|
},
|
|
getSupportExportFormats: function(){
|
return [{
|
value: mo.FORMAT_CSV,
|
label: this.nls.toCSV
|
}];
|
},
|
|
_getTableData: function(){
|
var ret = new Deferred();
|
|
if(this.table){
|
ret.resolve(this.table);
|
}else if(this.url){
|
var query = new Query();
|
query.outFields = ['*'];
|
|
this.queryTask = new QueryTask(this.url);
|
this.queryTask.execute(query, lang.hitch(this, function(data){
|
var table = {};
|
table.fields = data.fields;
|
table.datas = array.map(data.features, function(feature){
|
return feature.attributes;
|
});
|
ret.resolve(table);//RecordSet
|
}), lang.hitch(this, function(){
|
ret.resolve(null);
|
}));
|
}else{
|
ret.resolve(null);
|
}
|
|
return ret;
|
},
|
|
_getAsCSVString: function(){
|
return this._getTableData().then(lang.hitch(this, function(tableData){
|
var str = '', BOM = '\uFEFF';
|
if(tableData){
|
str = BOM + createCSVString(tableData.fields, tableData.datas);
|
}
|
return str;
|
}));
|
}
|
});
|
|
/*************
|
datas: Object[], Object properties depend on fields' name
|
fields: String[] | Object[]
|
String[]: field name array,
|
Object[]: Object is the same with layer definition
|
{
|
name:
|
type:
|
alias:
|
}
|
**************/
|
function createCSVString(fields, datas){
|
var textField = '"';
|
var content = '';
|
var len = datas.length,
|
n = fields.length,
|
comma = '',
|
value = '',
|
feature;
|
try {
|
array.forEach(fields, function(_field) {
|
if(typeof _field === 'string'){
|
content = content + comma + _field;
|
}else{
|
content = content + comma + (_field.alias || _field.name);
|
}
|
|
comma = ',';
|
});
|
|
content = content + '\r\n';
|
|
for (var i = 0; i < len; i++) {
|
comma = '';
|
feature = datas[i];
|
for (var m = 0; m < n; m++) {
|
var _field = fields[m];
|
value = feature[typeof _field === 'string'? _field: _field.name];
|
if (!value && typeof value !== 'number') {
|
value = '';
|
}
|
if (value) {
|
if(_field.type === 'esriFieldTypeDate'){
|
value = jimuUtils.localizeDateByFieldInfo(value, _field.fieldInfo);
|
}else if(_field.fieldInfo &&
|
(_field.type === 'esriFieldTypeDouble' ||
|
_field.type === 'esriFieldTypeSingle' ||
|
_field.type === 'esriFieldTypeInteger' ||
|
_field.type === 'esriFieldTypeSmallInteger')) {
|
value = jimuUtils.localizeNumberByFieldInfo(value, _field.fieldInfo);
|
}
|
}
|
|
if (value && /[",\r\n]/g.test(value)) {
|
value = textField + value.replace(/(")/g, '""') + textField;
|
}
|
content = content + comma + value;
|
comma = ',';
|
}
|
content = content + '\r\n';
|
}
|
return content;
|
} catch (err) {
|
return '';
|
}
|
}
|
|
function download(filename, text) {
|
if (dojo.isIE < 10) {
|
saveTextAs(text, filename, 'utf-8');
|
}else{
|
var blob = new Blob([text], {type: 'text/plain;charset=utf-8'});
|
// Use saveAs(blob, name, true) to turn off the auto-BOM stuff
|
saveAs(blob, filename, true);
|
}
|
}
|
|
return mo;
|
});
|
