define([
|
'exports',
|
'dojo/_base/lang',
|
'dojo/_base/array',
|
'dojo/_base/html',
|
'dojo/has',
|
'dojo/Deferred',
|
'jimu/utils',
|
'esri/lang',
|
'esri/tasks/QueryTask',
|
'esri/tasks/query',
|
'esri/graphic',
|
"jimu/ArcadeUtils"],
|
function(exports, lang, array, html, has, Deferred, jimuUtils, esriLang, QueryTask, Query,
|
Graphic, ArcadeUtils) {
|
/*
|
** filename String no file extension
|
** datas Object[]
|
** columns Object[]
|
*/
|
exports.exportCSV = function(filename, datas, columns) {
|
return exports._createCSVStr(datas, columns).then(function(content) {
|
return exports._download(filename + '.csv', content);
|
});
|
};
|
|
/*
|
** filename String no file extension
|
** layer FeatureLayer or LayerDefinition Object; if is FeatureLayer, layer.loaded must be true
|
** options Object
|
** options: {
|
** datas: Array of feature.attributes; if not null only exported this datas to CSV
|
** fromClient: if true get data from layer.graphics,
|
** if false get first `layer.maxRecordCount` data from server
|
** outFields: Array of Field; if null export all fields of layer
|
** filterExpression: set where clause from featureService
|
** formatNumber: Boolean. if true localize number type field
|
** formatDate: Boolean. if true localize date type field
|
** formatCodedValue: Boolean. if true use description instead of codedvalue
|
** popupInfo: https://developers.arcgis.com/javascript/jshelp/intro_popuptemplate.html
|
** }
|
*/
|
exports.exportCSVFromFeatureLayer = function(filename, layer, options) {
|
options = options || {};
|
var exportOptions = {
|
datas: options.datas,
|
objectIds: options.objectIds,
|
fromClient: options.fromClient,
|
withGeometry: options.withGeometry,
|
outFields: options.outFields,
|
filterExpression : options.filterExpression,
|
outSpatialReference: options.outSpatialReference,
|
arcadeExpressions: options.arcadeExpressions
|
};
|
return exports._getExportData(layer, exportOptions).then(function(result) {
|
var formattedOptions = {
|
formatNumber: options.formatNumber,
|
formatDate: options.formatDate,
|
formatCodedValue: options.formatCodedValue,
|
richText: {
|
clearFormat: options.richTextFieldsToClear && !!options.richTextFieldsToClear.length,
|
fieldsToClear: options.richTextFieldsToClear || []
|
},
|
popupInfo: options.popupInfo
|
};
|
return exports._formattedData(layer, result, formattedOptions)
|
.then(function(formattedResult) {
|
return exports.exportCSV(filename, formattedResult.datas, formattedResult.columns);
|
});
|
});
|
};
|
|
/*
|
** filename String no file extension
|
** definition LayerDefinition Object
|
** attributes Array of graphic.attributes
|
** options: {
|
** datas: Array of feature.attributes; if not null only exported this datas to CSV
|
** fromClient: if true get data from layer.graphics,
|
** if false get first `layer.maxRecordCount` data from server
|
** outFields: Array of Field; if null export all fields of layer
|
** filterExpression: set where clause from featureService
|
** formatNumber: Boolean. if true localize number type field
|
** formatDate: Boolean. if true localize date type field
|
** formatCodedValue: Boolean. if true use description instead of codedvalue
|
** popupInfo: https://developers.arcgis.com/javascript/jshelp/intro_popuptemplate.html
|
** }
|
*/
|
exports.exportCSVByAttributes = function(filename, definition, attributes, options) {
|
options = lang.mixin({}, options);
|
options.datas = attributes;
|
return exports.exportCSVFromFeatureLayer(filename, definition, options);
|
};
|
|
/*
|
** filename String no file extension
|
** definition LayerDefinition Object
|
** graphics Array of graphic
|
** options: {
|
** datas: Array of feature.attributes; if not null only exported this datas to CSV
|
** fromClient: if true get data from layer.graphics,
|
** if false get first `layer.maxRecordCount` data from server
|
** outFields: Array of Field; if null export all fields of layer
|
** filterExpression: set where clause from featureService
|
** formatNumber: Boolean. if true localize number type field
|
** formatDate: Boolean. if true localize date type field
|
** formatCodedValue: Boolean. if true use description instead of codedvalue
|
** popupInfo: https://developers.arcgis.com/javascript/jshelp/intro_popuptemplate.html
|
** }
|
*/
|
exports.exportCSVByGraphics = function(filename, definition, graphics, options) {
|
var attributes = array.map(graphics, function(graphic) {
|
return graphic.attributes;
|
});
|
return exports.exportCSVByAttributes(filename, definition, attributes, options);
|
};
|
|
exports._createCSVStr = function(datas, columns) {
|
var def = new Deferred();
|
var textField = '"';
|
var content = "";
|
var len = 0,
|
n = 0,
|
comma = "",
|
value = "";
|
try {
|
columns = array.map(columns, function(f){
|
if(typeof f === 'string'){
|
return {name: f};
|
}else{
|
return f;
|
}
|
});
|
array.forEach(columns, function(_field) {
|
var _fieldText = _field.alias || _field.name;
|
// append "" to fields that include commas
|
if(_fieldText.toString().indexOf(",") > -1) {
|
_fieldText = '"' + _fieldText + '"';
|
}
|
content = content + comma + _fieldText;
|
comma = ",";
|
});
|
|
content = content + "\r\n";
|
len = datas.length;
|
n = columns.length;
|
for (var i = 0; i < len; i++) {
|
comma = "";
|
for (var m = 0; m < n; m++) {
|
var _field = columns[m];
|
value = datas[i][_field.name];
|
if (!value && typeof value !== "number") {
|
value = "";
|
}
|
if (value && /[",\r\n]/g.test(value)) {
|
value = textField + value.replace(/(")/g, '""') + textField;
|
}
|
content = content + comma + value;
|
comma = ",";
|
}
|
content = content + "\r\n";
|
}
|
def.resolve(content);
|
} catch (err) {
|
console.error(err);
|
def.resolve("");
|
}
|
|
return def;
|
};
|
|
exports._isIE11 = function() {
|
return jimuUtils.has('ie') === 11;
|
};
|
|
exports._isEdge = function() {
|
return jimuUtils.has('edge');
|
};
|
|
exports._getDownloadUrl = function(text) {
|
var BOM = "\uFEFF";
|
// Add BOM to text for open in excel correctly
|
if (window.Blob && window.URL && window.URL.createObjectURL) {
|
var csvData = new Blob([BOM + text], { type: 'text/csv' });
|
return URL.createObjectURL(csvData);
|
} else {
|
return 'data:attachment/csv;charset=utf-8,' + BOM + encodeURIComponent(text);
|
}
|
};
|
|
exports._download = function(filename, text) {
|
var def = new Deferred();
|
try {
|
if (has('ie') && has('ie') < 10) {
|
// has module unable identify ie11 and Edge
|
var oWin = window.top.open("about:blank", "_blank");
|
oWin.document.write('sep=,\r\n' + text);
|
oWin.document.close();
|
oWin.document.execCommand('SaveAs', true, filename);
|
oWin.close();
|
}else if (has("ie") === 10 || exports._isIE11() || exports._isEdge()) {
|
var BOM = "\uFEFF";
|
var csvData = new Blob([BOM + text], { type: 'text/csv' });
|
navigator.msSaveBlob(csvData, filename);
|
} else {
|
var link = html.create("a", {
|
href: exports._getDownloadUrl(text),
|
target: '_blank',
|
download: filename
|
}, document.body);
|
if (has('safari')) {
|
// # First create an event
|
var click_ev = document.createEvent("MouseEvents");
|
// # initialize the event
|
click_ev.initEvent("click", true /* bubble */ , true /* cancelable */ );
|
// # trigger the evevnt/
|
link.dispatchEvent(click_ev);
|
} else {
|
link.click();
|
}
|
|
html.destroy(link);
|
}
|
def.resolve();
|
} catch(e) {
|
def.reject(e);
|
}
|
return def;
|
};
|
|
exports._getExportData = function(layer, options) {
|
var def = new Deferred();
|
var _outFields = null;
|
var _queryOutFields = [];
|
var data = options.datas;
|
var withGeometry = options.withGeometry;
|
var withExpressionFields = !!options.arcadeExpressions;
|
|
_outFields = options.outFields;
|
if (!_outFields || !_outFields.length) {
|
_outFields = layer.fields;
|
}
|
_outFields = lang.clone(_outFields);
|
|
if (withGeometry && !(data && data.length > 0)) {// only for fromClient or server
|
// data is null, we should retrieve data from server.
|
// for query params, here we clone _outFields to _queryOutFields before x and y appended to _outFields,
|
// or we clone all fields from layer object, if it contains arcade expressions.
|
// because the fields of service might not contain field x or field y.
|
if(withExpressionFields) {
|
var _outFieldsWithoutExprs = array.filter(layer.fields, function(field) {
|
return field.name.indexOf('expression/') === -1;
|
});
|
_queryOutFields = lang.clone(_outFieldsWithoutExprs);
|
} else {
|
_queryOutFields = lang.clone(_outFields);
|
}
|
|
var name = "";
|
if (_outFields.indexOf('x') !== -1) {
|
name = '_x';
|
} else {
|
name = 'x';
|
}
|
_outFields.push({
|
'name': name,
|
alias: name,
|
format: {
|
'digitSeparator': false,
|
'places': 6
|
},
|
show: true,
|
type: "esriFieldTypeDouble"
|
});
|
if (_outFields.indexOf('y') !== -1) {
|
name = '_y';
|
} else {
|
name = 'y';
|
}
|
_outFields.push({
|
'name': name,
|
alias: name,
|
format: {
|
'digitSeparator': false,
|
'places': 6
|
},
|
show: true,
|
type: "esriFieldTypeDouble"
|
});
|
}
|
|
if (data && data.length > 0) {
|
if(withExpressionFields) {
|
data = exports._getAttrsWithExpressionsBatch(data, options.arcadeExpressions);
|
}
|
def.resolve({
|
'data': data || [],
|
'outFields': _outFields
|
});
|
} else {
|
// var g = null;
|
if (options.fromClient) {
|
data = array.map(layer.graphics, function(graphic) {
|
var attrs = withGeometry ? getAttrsWithXY(graphic) : lang.clone(graphic);
|
attrs = withExpressionFields ?
|
exports._getAttrsWithExpressions(attrs, options.arcadeExpressions) : attrs;
|
return attrs;
|
});
|
def.resolve({
|
'data': data || [],
|
'outFields': _outFields
|
});
|
} else {
|
exports._getExportDataFromServer(layer, _queryOutFields, options)
|
.then(function(data) {
|
if(withExpressionFields) {
|
data = exports._getAttrsWithExpressionsBatch(data, options.arcadeExpressions);
|
}
|
def.resolve({
|
'data': data || [],
|
'outFields': _outFields
|
});
|
});
|
}
|
}
|
|
return def;
|
};
|
|
exports._getExportDataFromServer = function(layer, outFields, options) {
|
var def = new Deferred();
|
if (layer.declaredClass !== 'esri.layers.FeatureLayer') {
|
def.resolve([]);
|
return def;
|
}
|
var qt = new QueryTask(layer.url);
|
var query = new Query();
|
query.where = options.filterExpression ||
|
(layer.getDefinitionExpression && layer.getDefinitionExpression()) || "1=1";
|
var oFields = outFields;
|
if (oFields.length > 0) {
|
var oNames = array.map(oFields, function(field) {
|
return field.name;
|
});
|
query.outFields = oNames;
|
} else {
|
query.outFields = ["*"];
|
}
|
query.objectIds = options.objectIds;
|
query.returnGeometry = options.withGeometry;
|
query.outSR = options.spatialReference;
|
|
qt.execute(query, function(results) {
|
var data = array.map(results.features, function(feature) {
|
return getAttrsWithXY(feature);
|
});
|
def.resolve(data);
|
}, function(err) {
|
console.error(err);
|
def.resolve([]);
|
});
|
|
return def;
|
};
|
|
exports._formattedData = function(layer, dataOptions, formattedOptions) {
|
var def = new Deferred();
|
var formattedDatas = [];
|
|
var datas = dataOptions.data;
|
var outFields = dataOptions.outFields;
|
|
for (var i = 0, len = datas.length; i < len; i++) {
|
var aliasData = {};
|
for (var j = 0; j < outFields.length; j++) {
|
var _field = outFields[j];
|
aliasData[_field.name] = exports._getExportValue(
|
datas[i][_field.name],
|
_field,
|
layer.objectIdField,
|
layer.typeIdField,
|
datas[i][layer.typeIdField],
|
layer.types,
|
formattedOptions
|
);
|
}
|
formattedDatas.push(aliasData);
|
}
|
|
var columns = array.map(outFields, function(oField) {
|
return {
|
alias: oField.alias,
|
name: oField.name
|
}
|
});
|
|
def.resolve({
|
datas: formattedDatas,
|
columns: columns
|
});
|
return def;
|
};
|
|
exports._getExportValue = function(data, field, pk, typeIdField,
|
typeData, types, formattedOptions) {
|
var pInfos = formattedOptions.popupInfo;
|
function getFormatInfo(fieldName) {
|
if (pInfos && esriLang.isDefined(pInfos.fieldInfos)) {
|
for (var i = 0, len = pInfos.fieldInfos.length; i < len; i++) {
|
var f = pInfos.fieldInfos[i];
|
if (f.fieldName === fieldName) {
|
return f.format;
|
}
|
}
|
}
|
|
return null;
|
}
|
var fieldsToClear = formattedOptions.richText.fieldsToClear;
|
function isRichTextField(fieldName) {
|
for (var i = 0, len = fieldsToClear.length; i < len; i++) {
|
var f = fieldsToClear[i];
|
if (f.fieldName === fieldName) {
|
return true;
|
}
|
}
|
return false;
|
}
|
var isDomain = !!field.domain && formattedOptions.formatCodedValue;
|
var isDate = field.type === "esriFieldTypeDate" && formattedOptions.formatDate;
|
var isOjbectIdField = pk && (field.name === pk);
|
var isTypeIdField = typeIdField && (field.name === typeIdField);
|
var isRichTextField = field.type === "esriFieldTypeString" &&
|
formattedOptions.richText.clearFormat &&
|
isRichTextField(field.name);
|
|
if (isDate) {
|
return jimuUtils.fieldFormatter.getFormattedDate(data, getFormatInfo(field.name));
|
}
|
if (isTypeIdField) {
|
return jimuUtils.fieldFormatter.getTypeName(data, types);
|
}
|
if (isDomain) {
|
return jimuUtils.fieldFormatter.getCodedValue(field.domain, data);
|
}
|
if (isRichTextField) {
|
if(data) {
|
var d = document.createElement('span');
|
d.innerHTML = data;
|
return d.textContent || d.innerText || '';
|
} else {
|
return data;
|
}
|
}
|
if (!isDomain && !isDate && !isOjbectIdField && !isTypeIdField && !isRichTextField) {
|
var codeValue = null;
|
if (pk && types && types.length > 0) {
|
var typeChecks = array.filter(types, function(item) {
|
// value of typeIdField has been changed above
|
return item.id === typeData;
|
});
|
var typeCheck = typeChecks && typeChecks[0];
|
|
if (typeCheck && typeCheck.domains &&
|
typeCheck.domains[field.name] && typeCheck.domains[field.name].codedValues) {
|
codeValue = jimuUtils.fieldFormatter.getCodedValue(
|
typeCheck.domains[field.name],
|
data
|
);
|
}
|
}
|
return codeValue !== null ? codeValue : data;
|
}
|
|
return data;
|
};
|
|
exports._getAttrsWithExpressions = function(attributes, arcadeExpressions) {
|
var expressionInfos = lang.getObject('expressionInfos', false, arcadeExpressions),
|
layerDefinition = lang.getObject('layerDefinition', false, arcadeExpressions),
|
graphic = new Graphic(null, null, attributes);
|
return ArcadeUtils.customExpr.getAttributesFromCustomArcadeExpr(
|
expressionInfos, graphic, layerDefinition) || attributes;
|
};
|
|
exports._getAttrsWithExpressionsBatch = function(odata, arcadeExpressions) {
|
var data = [];
|
data = array.map(odata, function(attrs) {
|
return exports._getAttrsWithExpressions(attrs, arcadeExpressions);
|
});
|
return data;
|
};
|
|
function getAttrsWithXY(graphic) {
|
var attrs = lang.clone(graphic.attributes);
|
var geometry = graphic.geometry;
|
if (geometry && geometry.type === 'point') {
|
if ('x' in attrs) {
|
attrs._x = geometry.x;
|
} else {
|
attrs.x = geometry.x;
|
}
|
|
if ('y' in attrs) {
|
attrs._y = geometry.y;
|
} else {
|
attrs.y = geometry.y;
|
}
|
}
|
|
return attrs;
|
}
|
|
});
|
