define([
|
'dojo/_base/array',
|
'dojo/_base/lang',
|
'dojo/Deferred',
|
'dojo/promise/all',
|
'dojo/string',
|
'esri/arcade/arcade',
|
'esri/arcade/Feature',
|
'esri/tasks/RelationshipQuery',
|
'jimu/utils',
|
'jimu/LayerStructure'
|
],
|
function(
|
array, lang, Deferred, all, string,
|
Arcade, ArcadeFeature, RelationshipQuery, jimuUtils, LayerStructure) {
|
var mo = {};
|
/*------------------------------------------------------------------------------------------------------------------*/
|
/********read arcade expr info*********/
|
mo.readExprInfo = {};
|
//public functions
|
/** Get arcade profiles by type.
|
* @param {string} type, arcade profile types, it could be three types:render, label, infoTemplate.
|
it's optional, if no type or wrong type, it retruns all the profiles.
|
* @return {object} when type is one of the three strings above.
|
format: {render:[],label:[],infoTemplate:[]}
|
{array} when type is none or others, every item in array is a object.
|
item's format depends on the type of arcade profile's type.
|
eg: infoTemplate's format is {layer:'layerId',expressionInfos:[]}
|
//https://developers.arcgis.com/javascript/3/jshelp/arcade.html#popups
|
*/
|
mo.readExprInfo.getArcadeProfilesByType = function(map, operlayer, /* optional */ type){
|
var args = {
|
map: map,
|
layer: operlayer
|
};
|
if(type === 'render'){
|
return mo.readExprInfo._getArcadeRender(args);
|
}else if(type === 'label'){
|
return mo.readExprInfo._getArcadeLabel(args);
|
}else if(type === 'infoTemplate'){
|
return mo.readExprInfo._getArcadeInfoTemplate(args);
|
}else{
|
return mo.readExprInfo._getAllArcade(args);
|
}
|
};
|
|
//private functions
|
mo.readExprInfo._getArcadeRender = function(args) {
|
return mo.readExprInfo._lookupArcadeRender({layers: mo.readExprInfo._checkPassInLayer(args)});
|
};
|
|
mo.readExprInfo._getArcadeInfoTemplate = function(args) {
|
return mo.readExprInfo._lookupArcadeInfoTemplate({layers: mo.readExprInfo._checkPassInLayer(args)});
|
};
|
|
mo.readExprInfo._getArcadeLabel = function(args) {
|
return mo.readExprInfo._lookupArcadeLabel({layers: mo.readExprInfo._checkPassInLayer(args)});
|
};
|
|
mo.readExprInfo._getAllArcade = function(args) {
|
var render = mo.readExprInfo._getArcadeRender(args);
|
var infoTemplate = mo.readExprInfo._getArcadeInfoTemplate(args);
|
var label = mo.readExprInfo._getArcadeLabel(args);
|
// var arcadeObj = Object.assign(infoTemplate, render, label);
|
// return arcadeObj;
|
return {
|
render: render,
|
infoTemplate: infoTemplate,
|
label: label
|
};
|
};
|
|
mo.readExprInfo._checkPassInLayer = function(args) {
|
var layerList = [];
|
if(typeof(args) !== 'undefined') {
|
if(typeof(args.layer) !== 'undefined') {
|
if((args.layer !== null) && (args.layer !== '')) {
|
//layerList.push(args.layer);
|
layerList = mo.readExprInfo._getAllMapLayers(args);
|
} else {
|
layerList = mo.readExprInfo._getAllMapLayers();
|
}
|
} else {
|
layerList = mo.readExprInfo._getAllMapLayers();
|
}
|
} else {
|
layerList = mo.readExprInfo._getAllMapLayers();
|
}
|
return layerList;
|
};
|
|
//This gets all the operational layers and gets the info and places it in a custom data object.
|
mo.readExprInfo._getAllMapLayers = function(args) {
|
var lookupId = "";
|
var layerList = [];
|
var layerStructure = LayerStructure.getInstance();
|
// if(typeof(args) !== 'undefined') {
|
if(args && args.layer) {
|
lookupId = args.layer.id;
|
}
|
if(lookupId !== "") {
|
var foundLayer = layerStructure.getNodeById(lookupId);
|
// if(foundLayer !== 'undefined') {
|
if(foundLayer) {
|
layerList.push(foundLayer._layerInfo.layerObject);
|
}
|
} else {
|
//No layer ID passed in, just get all layers.
|
layerStructure.traversal(function(layerNode) {
|
//check to see if type exist and if it's not any tiles
|
if(typeof(layerNode._layerInfo.layerObject.type) !== 'undefined') {
|
if((layerNode._layerInfo.layerObject.type).indexOf("tile") === -1) {
|
layerList.push(layerNode._layerInfo.layerObject);
|
}
|
} else {
|
//It is a grouped Map service
|
layerList.push(layerNode._layerInfo.layerObject);
|
}
|
});
|
}
|
return layerList;
|
};
|
|
mo.readExprInfo._lookupArcadeRender = function(args) {
|
var lyrArcadeExpr = [];
|
if(args.layers.length > 0) {
|
array.forEach(args.layers, lang.hitch(this, function(layer) {
|
var expObj = {};
|
//Only add if there is a renderer object, maps services do not have this.
|
if(typeof(layer.renderer) !== 'undefined') {
|
var lyrObjRender = layer.renderer;
|
if(typeof(lyrObjRender.valueExpression) !== 'undefined') {
|
expObj.layer = layer.id;
|
expObj.valueExpression = lyrObjRender.valueExpression;
|
expObj.valueExpressionTitle = lyrObjRender.valueExpressionTitle;
|
if(typeof(lyrObjRender.values) !== 'undefined') {
|
expObj.values = lyrObjRender.values;
|
}
|
if(typeof(lyrObjRender.visualVariables) !== 'undefined') {
|
expObj.visualVariables = lyrObjRender.visualVariables;
|
}
|
}
|
if(Object.keys(expObj).length > 1 && expObj.constructor === Object) {
|
lyrArcadeExpr.push(expObj);
|
}else{ //if layer has no arcade expressionInfos
|
lyrArcadeExpr.push({
|
layer: layer.id,
|
valueExpression: null,
|
valueExpressionTitle: null,
|
values: null,
|
visualVariables: null
|
});
|
}
|
}
|
}));
|
}
|
return lyrArcadeExpr;
|
};
|
|
mo.readExprInfo._lookupArcadeInfoTemplate = function(args) {
|
var lyrArcadeExpr = [];
|
if(args.layers.length > 0) {
|
array.forEach(args.layers, lang.hitch(this, function(layer) {
|
var expObj = {};
|
//InfoTemplate handling for feature layers
|
if(typeof(layer.infoTemplate) !== 'undefined') {
|
if(typeof(layer.infoTemplate.info.expressionInfos) !== 'undefined') {
|
if(layer.infoTemplate.info.expressionInfos.length > 0) {
|
expObj.layer = layer.id;
|
expObj.expressionInfos = layer.infoTemplate.info.expressionInfos;
|
}
|
}
|
} else {
|
//feature handling for map service
|
if(typeof(layer.infoTemplates) !== 'undefined') {
|
//check if it template is arcade and only store it if it is.
|
//Arcade is stored in the group level, not sublayers
|
for (var key in layer.infoTemplates) {
|
if((layer.infoTemplates).hasOwnProperty(key)) {
|
if(typeof(layer.infoTemplates[key].infoTemplate.info.expressionInfos) !== 'undefined') {
|
var arcadeNode = layer.infoTemplates[key].infoTemplate;
|
if(arcadeNode.info.expressionInfos.length > 0) {
|
expObj.layer = layer.id;
|
expObj.expressionInfos = arcadeNode.info.expressionInfos;
|
}
|
}
|
}
|
}
|
} else {
|
//no infoTemplates defined
|
}
|
}
|
if(Object.keys(expObj).length > 1 && expObj.constructor === Object) {
|
lyrArcadeExpr.push(expObj);
|
}else{ //if layer has no arcade expressionInfos
|
lyrArcadeExpr.push({
|
layer: layer.id,
|
expressionInfos: null
|
});
|
}
|
|
}));
|
}
|
return lyrArcadeExpr;
|
};
|
|
mo.readExprInfo._lookupArcadeLabel = function(args) {
|
var lyrArcadeExpr = [];
|
if(args.layers.length > 0) {
|
array.forEach(args.layers, lang.hitch(this, function(layer) {
|
var expObj = {};
|
var lyrObj = layer;
|
if(typeof(lyrObj.labelingInfo) !== 'undefined') {
|
array.forEach(lyrObj.labelingInfo, lang.hitch(this, function(labelInfo) {
|
//check if 'name' exists, it is present when Arcade is used
|
if(typeof(labelInfo.name) !== 'undefined') {
|
expObj.layer = layer.id;
|
expObj.name = labelInfo.name;
|
expObj.labelingInfo = labelInfo;
|
expObj.expression = labelInfo.labelExpressionInfo.expression;
|
}
|
}));
|
}
|
if(Object.keys(expObj).length > 1 && expObj.constructor === Object) {
|
lyrArcadeExpr.push(expObj);
|
}else{ //if layer has no arcade expressionInfos
|
lyrArcadeExpr.push({
|
layer: layer.id,
|
name: null,
|
labelingInfo: null,
|
expression: null
|
});
|
}
|
}));
|
}
|
return lyrArcadeExpr;
|
};
|
|
|
/********************custom arcade expression***********************/
|
mo.customExpr = {};
|
/**
|
* Get one graphic's all attributes by custom expressionInfos.
|
* @param {array} expressionInfos, every item is an object, likes: {name,title,expression}
|
* @param {object} graphic, it contains geometry, a symbol, attributes, or an infoTemplate
|
* @return {object} attributes object, including orginal attributes and custom arcade attributes
|
*/
|
mo.customExpr.getAttributesFromCustomArcadeExpr = function (expressionInfos, graphic, layerDefinition) {
|
var parsedExprs = mo.InfoTemplate._parseArcadeExpressions(expressionInfos);
|
var graphicAttrs = mo.InfoTemplate._combineFeatureAttributesAndExpressionResolutions(graphic, parsedExprs,
|
layerDefinition);
|
return graphicAttrs;
|
};
|
|
/**
|
* Get Graphics's attributes value list by custom expressionInfos.
|
* @param {array} expressionInfos, every item is an object, likes: {name,title,expression}
|
* @param {array} graphicList, graphic object array.
|
* @return {array} every item in array is an object, it contains the attributes's values by custom expressionInfos.
|
*/
|
mo.customExpr.getAttributesValueFromCustomArcadeExprBatch = function (expressionInfos, graphicList, layerDefinition) {
|
var features = [];
|
for(var key in graphicList){
|
features.push(graphicList[key]);
|
}
|
var parsedExprs = mo.InfoTemplate._parseArcadeExpressions(expressionInfos);
|
|
var customExprTemplates = mo.InfoTemplate._getExprNamesArrayFromPopupExprInfos(expressionInfos);
|
customExprTemplates.relationships = null;
|
customExprTemplates.parsedExpressions = parsedExprs;
|
|
var def = new Deferred();
|
var labelDef = mo.InfoTemplate._getPopupFieldsValueFromArcadeFeatures(features, customExprTemplates,
|
layerDefinition);
|
labelDef.then(function(customFieldsValueArray){
|
def.resolve(customFieldsValueArray);
|
});
|
return def;
|
};
|
|
|
/********************Render***********************/
|
|
|
/********************Label***********************/
|
|
|
/********************InfoTemplate***********************/
|
mo.InfoTemplate = {};
|
/**
|
* Get one graphic's all attributes.
|
* @param {operlayer} layer that need to have id, popupInfo, layerObject(has fields).
|
* @param {object} graphic, it contains geometry, a symbol, attributes, or an infoTemplate
|
* @return {object} attributes object, including orginal attributes and arcade attributes
|
format:{'OBJECTID':1, 'expression/expr1':"394-Waterous", 'relationships/0/CHAINS':123}
|
*/
|
mo.InfoTemplate.getAttributesFromInfoTemplate = function (map, operlayer, graphic) {
|
var layerDefinition = {fields: []};
|
if(operlayer.layerObject && operlayer.layerObject.fields){
|
layerDefinition.fields = operlayer.layerObject.fields;
|
}
|
var arcadeTemplate = mo.readExprInfo.getArcadeProfilesByType(map, operlayer, 'infoTemplate');
|
var expressionInfos = arcadeTemplate[0].expressionInfos;
|
if(!expressionInfos){
|
return graphic.attributes;
|
}
|
var parsedExprs = mo.InfoTemplate._parseArcadeExpressions(expressionInfos);
|
var graphicAttrs = mo.InfoTemplate._combineFeatureAttributesAndExpressionResolutions(graphic, parsedExprs,
|
layerDefinition);
|
return graphicAttrs;
|
};
|
|
/**
|
* Get Graphics's attributes value list which configurate in InfoTemplate.
|
* @param {operlayer} layer that need to have id, popupInfo, layerObject(has fields).
|
* @param {array} graphicList, graphic object array.
|
* @return {array} every item in array is an object
|
it contains the attributes's values which configurate in InfoTemplate.
|
format:[["278-Waterous","Waterous---str"],["279-Clow Corporation","Clow Corporation---str"]]
|
*/
|
mo.InfoTemplate.getAttributesValueFromInfoTemplateBatch = function (map, operlayer, graphicList) {
|
var layerDefinition = {fields: []};
|
if(operlayer.layerObject && operlayer.layerObject.fields){
|
layerDefinition.fields = operlayer.layerObject.fields;
|
}
|
var features = [];
|
for(var key in graphicList){
|
features.push(graphicList[key]);
|
}
|
var arcadeTemplate = mo.readExprInfo.getArcadeProfilesByType(map, operlayer, 'infoTemplate');
|
var expressionInfos = arcadeTemplate[0].expressionInfos;
|
var def = new Deferred();
|
if(!expressionInfos){//layer has no arcade infotemplate
|
def.resolve([]);
|
return def;
|
}
|
var parsedExprs = mo.InfoTemplate._parseArcadeExpressions(expressionInfos);
|
var popupExprTemplates = null;
|
var popupDesc = operlayer.popupInfo.description;
|
//from popupDesc
|
if(popupDesc !== null){
|
popupExprTemplates = mo.InfoTemplate._convertPopupDescToFieldNamesArray(popupDesc);
|
popupExprTemplates.relationships = mo.InfoTemplate._getRelationshipQueries(operlayer);
|
}else{ //from expressionInfos
|
popupExprTemplates = mo.InfoTemplate._getExprNamesArrayFromPopupExprInfos(expressionInfos);
|
popupExprTemplates.relationships = null; //doesn't support relationships in this case.
|
}
|
//add parsedExpr
|
popupExprTemplates.parsedExpressions = parsedExprs;
|
|
var labelDef = mo.InfoTemplate._getPopupFieldsValueFromArcadeFeatures(features, popupExprTemplates,
|
layerDefinition);
|
labelDef.then(function(popupFieldsValueArray){
|
def.resolve(popupFieldsValueArray);
|
});
|
return def;
|
};
|
|
// Get relationshipQueries from a layer.
|
mo.InfoTemplate._getRelationshipQueries = function (operLayer) {
|
var hasRelationships = false, relationships = {}, relationshipFieldPattern = /\{relationships\/\d+\//gm,
|
relationshipIdPattern = /\d+/, matches;
|
|
matches = operLayer.popupInfo.description.match(relationshipFieldPattern);
|
if (matches) {
|
hasRelationships = true;
|
array.forEach(matches, function (match) {
|
var relatedQuery, id = match.match(relationshipIdPattern)[0];
|
if (!relationships.hasOwnProperty(id)) {
|
relatedQuery = new RelationshipQuery();
|
relatedQuery.outFields = ['*'];
|
relatedQuery.relationshipId = id;
|
relatedQuery.returnGeometry = false;
|
relationships[id] = {
|
operLayer: operLayer,
|
relatedQuery: relatedQuery
|
};
|
}
|
});
|
}
|
return hasRelationships? relationships : null;
|
};
|
|
/**
|
* Converts the arcade exprs obj of a custom popup into a multiline label specification;
|
* @param {array} popupExprInfos, an arry of objects by customing popup arcade exprs in configuration.
|
every object, likes: {name,title,expression}
|
* @return {array} an array of exprs's name, format: ["${expression/expr1}"]
|
*/
|
mo.InfoTemplate._getExprNamesArrayFromPopupExprInfos = function (popupExprInfos) {
|
var exprNames = [];
|
for(var key in popupExprInfos){
|
var exprName = popupExprInfos[key].name;
|
exprNames.push('${expression/' + exprName + '}');
|
}
|
return exprNames;
|
};
|
|
/**
|
* Converts the text of a custom popup into an array of fields's name.
|
* conversion splits text into lines on <br>s,
|
* removes HTML tags, and changes field tags from popup style to string.substitute form.
|
* @param {string} popupDesc, popup's descriptions.
|
* format: "<font face='Arial' size='3'>{OBJECTID}<br />{relationships/0/Creator}<br />{expression/expr0}</font>"
|
* @return {array} an array of fields' name
|
* format: ["${OBJECTID}","${relationships/0/CreationDate}","${expression/expr0}"]
|
*/
|
mo.InfoTemplate._convertPopupDescToFieldNamesArray = function (popupDesc) {
|
// e.g., Occupant<br/>{FULLADDR}<br />{MUNICIPALITY}, IL {PSTLZIP5}
|
// Sanitize the description after converting <br>s and </p>s to line breaks
|
var descEOLs1 = mo.InfoTemplate._convertEndParasToEOLs(popupDesc);
|
var descEOLs2 = mo.InfoTemplate._convertBreaksToEOLs(descEOLs1);
|
var desc = mo.InfoTemplate._sanitizeNoTags(descEOLs2).trim();
|
|
// Change the open brace used for attribute names to "${" so that we can use dojo/string's substitute()
|
desc = desc.replace(/\{/gi, '${');
|
|
// Remove non-breaking spaces, which aren't rendered correctly in CSV output and aren't needed in PDF output
|
desc = desc.replace(/\u00a0/gi, ' ');
|
|
// Split on the line breaks
|
desc = desc.split('\n');
|
|
// Trim each line, since HTML pretty much does that
|
desc = array.map(desc, function (line) {
|
return line.trim();
|
});
|
|
return desc;
|
};
|
|
/**
|
* Removes HTML tags from string.
|
* @param {string} taggedText String to clean
|
* @return {string} Cleaned string
|
*/
|
mo.InfoTemplate._sanitizeNoTags = function (taggedText) {
|
var cleanedText, tagBody, tagOrComment;
|
|
cleanedText = jimuUtils.sanitizeHTML(taggedText);
|
|
// Remove remaining tags
|
// From Stack Overflow https://stackoverflow.com/a/430240/5090610
|
// CC BY-SA 3.0 (https://creativecommons.org/licenses/by-sa/3.0/)
|
// Mike Samuel (https://stackoverflow.com/users/20394/mike-samuel)
|
tagBody = '(?:[^"\'>]|"[^"]*"|\'[^\']*\')*';
|
tagOrComment = new RegExp(
|
'<(?:' +
|
// Comment body.
|
'!--(?:(?:-*[^->])*--+|-?)' +
|
// Special "raw text" elements whose content should be elided.
|
'|script\\b' + tagBody + '>[\\s\\S]*?</script\\s*' +
|
'|style\\b' + tagBody + '>[\\s\\S]*?</style\\s*' +
|
// Regular name
|
'|/?[a-z]' +
|
tagBody +
|
')>',
|
'gi');
|
function removeTags(html) {
|
var oldHtml;
|
do {
|
oldHtml = html;
|
html = html.replace(tagOrComment, '');
|
} while (html !== oldHtml);
|
return html.replace(/</g, '<');
|
}
|
|
cleanedText = removeTags(cleanedText);
|
return cleanedText;
|
};
|
|
/**
|
* Creates fields's value from popup configuration by arcade features.
|
* @param {array} features, Arcade features whose attributes are to be
|
* used to populate labels
|
* @param {array} popupExprTemplates as created by _convertPopupDescToFieldNamesArray
|
format: [
|
"${OBJECTID}","${relationships/0/CreationDate}","${expression/expr0}",
|
relationships: as created by _getRelationshipQueries,
|
parsedExpressions: as created by _parseArcadeExpressions
|
]
|
* @return {Deferred} Array of labels; each label is an array of label line strings
|
*/
|
mo.InfoTemplate._getPopupFieldsValueFromArcadeFeatures = function (features, popupExprTemplates, layerDefinition) {
|
var deferred = new Deferred(), content = [], promises = [], relatedRecordsFound = 0;
|
|
if (popupExprTemplates.relationships) {
|
// For each feature,
|
array.forEach(features, function (feature) {
|
|
// For each relationship in the label,
|
mo.InfoTemplate._objEach(popupExprTemplates.relationships, function (relationship, relationshipId) {
|
var promise = new Deferred(), relatedQuery = relationship.relatedQuery, objectId;
|
promises.push(promise);
|
|
// Query the relationship for this feature
|
objectId = feature.attributes[relationship.operLayer.layerObject.objectIdField];
|
relatedQuery.objectIds = [objectId];
|
relationship.operLayer.layerObject.queryRelatedFeatures(relatedQuery, function (relatedRecords) {
|
var labels = [], relatedFeatures;
|
|
if (relatedRecords[objectId] && relatedRecords[objectId].features) {
|
relatedFeatures = relatedRecords[objectId].features;
|
|
array.forEach(relatedFeatures, function (relatedFeature) {
|
var labelLines = [], attributes, prefix, newKey;
|
|
// Merge the base and related feature attributes and create the label
|
// Prefix related feature's attributes with "relationships/<id>/" to match popup
|
attributes = feature.attributes;
|
prefix = 'relationships/' + relationshipId + '/';
|
mo.InfoTemplate._objEach(relatedFeature.attributes, function (value, key) {
|
newKey = prefix + key;
|
attributes[newKey] = value;
|
});
|
|
// Substitute attribute values and resolved Arcade expressions into label lines
|
array.forEach(popupExprTemplates, function (labelLineRule) {
|
labelLines.push(string.substitute(labelLineRule,
|
mo.InfoTemplate._combineFeatureAttributesAndExpressionResolutions(
|
feature, popupExprTemplates.parsedExpressions, layerDefinition),
|
mo.InfoTemplate._useEmptyStringForNull));
|
});
|
labels.push(labelLines);
|
});
|
}
|
|
promise.resolve(labels);
|
});
|
});
|
});
|
|
all(promises).then(function (results) {
|
// Look at the related records for each found address
|
array.forEach(results, function (labels) {
|
// For each found address, save its labels
|
array.forEach(labels, function (labelLines) {
|
++relatedRecordsFound;
|
content.push(labelLines);
|
});
|
});
|
console.log(relatedRecordsFound + ' related address features found');
|
deferred.resolve(content);
|
});
|
|
}else {
|
array.forEach(features, function (feature) {
|
var labelLines = [];
|
// Substitute attribute values and resolved Arcade expressions into label lines
|
array.forEach(popupExprTemplates, function (labelLineRule) {
|
labelLines.push(string.substitute(labelLineRule,
|
mo.InfoTemplate._combineFeatureAttributesAndExpressionResolutions(
|
feature, popupExprTemplates.parsedExpressions, layerDefinition),
|
mo.InfoTemplate._useEmptyStringForNull));
|
});
|
content.push(labelLines);
|
});
|
deferred.resolve(content);
|
}
|
|
return deferred;
|
};
|
|
/**
|
* Parses Arcade expression infos.
|
* @param {array} expressionInfos Expression info list from popupInfo
|
* @return {object} List of parsed expressions keyed by the expression name
|
*/
|
mo.InfoTemplate._parseArcadeExpressions = function (expressionInfos) {
|
var parsedExpressions;
|
if (Array.isArray(expressionInfos) && expressionInfos.length > 0) {
|
parsedExpressions = {};
|
array.forEach(expressionInfos, function (info) {
|
parsedExpressions[info.name] = Arcade.parseScript(info.expression);
|
});
|
}
|
return parsedExpressions;
|
};
|
|
/**
|
* Initializes the Arcade context with an ArcadeFeature.
|
* @param {object} feature Feature to convert into an ArcadeFeature and to add to the context's vars object
|
* @return {object} Arcade context object
|
*/
|
mo.InfoTemplate._initArcadeContext = function (feature, layerDefinition) {
|
var context = {
|
vars: {}
|
};
|
context.vars.$feature = ArcadeFeature.createFromGraphicLikeObject(feature.geometry, feature.attributes,
|
layerDefinition);
|
return context;
|
};
|
|
/**
|
* Creates a list of feature attributes and resolved Arcade expressions for the feature.
|
* @param {object} feature Feature whose attributes are to be used
|
* @param {object} parsedExpressions Parsed Arcade expressions keyed by the expression name; each expression
|
* is resolved and added to the output object keyed by 'expression/' + the expression's name
|
* @return {object} Combination of feature attributes and resolved expressions
|
*/
|
mo.InfoTemplate._combineFeatureAttributesAndExpressionResolutions = function (feature, parsedExpressions,
|
layerDefinition) {
|
var attributesAndExpressionResolutions, arcadeContext, name, resolvedExpression;
|
|
// Resolve Arcade expressions for this feature; convert to string in case its return type is not already string
|
attributesAndExpressionResolutions = lang.mixin({}, feature.attributes);
|
if (parsedExpressions) {
|
arcadeContext = mo.InfoTemplate._initArcadeContext(feature, layerDefinition);
|
|
for (name in parsedExpressions) {
|
resolvedExpression = Arcade.executeScript(parsedExpressions[name], arcadeContext);
|
attributesAndExpressionResolutions['expression/' + name] =
|
resolvedExpression ? resolvedExpression.toString() : '';
|
}
|
}
|
|
return attributesAndExpressionResolutions;
|
};
|
|
/**
|
* Converts </p>s into CRLFs.
|
* @param {string} html Text to scan
|
* @return {string} Converted text
|
*/
|
mo.InfoTemplate._convertEndParasToEOLs = function (html) {
|
var html2 = html, matches = html.match(/<\/p>/gi);
|
array.forEach(matches, function (match) {
|
html2 = html2.replace(match, '\n');
|
});
|
return html2;
|
};
|
|
/**
|
* Converts <br>s into CRLFs.
|
* @param {string} html Text to scan
|
* @return {string} Converted text
|
*/
|
mo.InfoTemplate._convertBreaksToEOLs = function (html) {
|
var html2 = html, matches = html.match(/<br\s*\/?>/gi);
|
array.forEach(matches, function (match) {
|
html2 = html2.replace(match, '\n');
|
});
|
return html2;
|
};
|
|
/**
|
* Insures that a string is not undefined or null.
|
* @param {string} str String to check
|
* @return {string} str, or '' if str is undefined, null, or empty
|
*/
|
mo.InfoTemplate._useEmptyStringForNull = function (str) {
|
return str ? str : '';
|
};
|
|
/**
|
* Interates over the items in an associative array (forIn).
|
* @param {object} obj Object to interate over
|
* @param {function} fcn Function to call for each item
|
* @param {object} scope Scope to apply to function call
|
*/
|
mo.InfoTemplate._objEach = function (obj, fcn, scope){
|
var key;
|
for (key in obj){
|
if(obj.hasOwnProperty(key)){
|
fcn.call(scope, obj[key], key);
|
}
|
}
|
};
|
return mo;
|
|
});
|
