@esri/solution-common 1.3.14 → 1.4.1

package/dist/esm/featureServiceHelpers.d.ts

@@ -19,7 +19,7 @@
  * @module featureServiceHelpers
  */
 export { queryFeatures as rest_queryFeatures, addFeatures as rest_addFeatures } from "@esri/arcgis-rest-feature-layer";
-import { IDependency, IItemTemplate, INumberValuePair, UserSession } from "./interfaces";
+import { IDependency, IFeatureServiceProperties, IItemTemplate, INumberValuePair, UserSession } from "./interfaces";
 /**
  * Templatize the ID, url, field references ect
  *
@@ -46,10 +46,18 @@ export declare function deleteViewProps(layer: any): void;
  *
  * @param layer The data layer instance with field name references within
  * @param fieldInfos the object that stores the cached field infos
- * @param isPortal Controls what properties should be removed.
  * @returns An updated instance of the fieldInfos
  */
-export declare function cacheFieldInfos(layer: any, fieldInfos: any, isPortal: boolean): any;
+export declare function cacheFieldInfos(layer: any, fieldInfos: any): any;
+/**
+ * Cache the stored contingent values so we can add them in subsequent addToDef calls
+ *
+ * @param id The layer id for the associated values to be stored with
+ * @param fieldInfos The object that stores the cached field infos
+ * @param itemTemplate The current itemTemplate being processed
+ * @returns An updated instance of the fieldInfos
+ */
+export declare function cacheContingentValues(id: string, fieldInfos: any, itemTemplate: IItemTemplate): any;
 /**
  * Helper function to cache a single property into the fieldInfos object
  * This property will be removed from the layer instance.
@@ -139,6 +147,18 @@ export declare function updateSettingsFieldInfos(itemTemplate: IItemTemplate, se
  * @private
  */
 export declare function updateTemplateForInvalidDesignations(template: IItemTemplate, authentication: UserSession): Promise<IItemTemplate>;
+/**
+ * Get the contingent values for each layer in the service.
+ * Remove key props that cannot be included with the addToDef call on deploy.
+ * Store the values alongside other key feature service properties in the template
+ *
+ * @param properties the current feature services properties
+ * @param adminUrl the current feature service url
+ * @param authentication Credentials for the request to AGOL
+ * @returns A promise that will resolve when the contingent values have been fetched.
+ * This function will update the provided properties argument when contingent values are found.
+ */
+export declare function processContingentValues(properties: IFeatureServiceProperties, adminUrl: string, authentication: UserSession): Promise<void>;
 /**
  * Replace the field name reference templates with the new field names after deployment.
  *
@@ -332,73 +352,35 @@ export declare function updateLayerFieldReferences(itemTemplate: IItemTemplate,
  */
 export declare function postProcessFields(itemTemplate: IItemTemplate, layerInfos: any, popupInfos: any, adminLayerInfos: any, templateDictionary: any): Promise<any>;
 /**
- * when deploying to portal if a view has a different typeIdField than what it being set on the source service
- *  we need to pass it via an updateDef call or it will be set as the typeIdField of the source service
- *
- * @param item current layer or table
- * @returns name of field to set for typeIdField in the update call
- * @private
- */
-export declare function _getTypeIdField(item: any): string;
-/**
- * Update a views field visibility to match that of the source
- *  Fields that are marked as visible false on a view are all set to
- *  visible true when added with the layer definition
+ * View field domain, alias, editable, and visible props can contain
+ * different values from the source.
  *
- * @param fieldInfo current layers or tables fieldInfo
- * @returns Array of fields that should not be visible in the view
- * @private
- */
-export declare function _getFieldVisibilityUpdates(fieldInfo: any): any[];
-/**
- *  view field domains can contain different values than the source feature service field domains
- *  use the cached domain when it differs from the source view field domain
+ * We need to check and set isFieldOverride to true when this occurs and false when it does not
  *
  * @param fieldInfo current view layer or table fieldInfo
- * @param fieldUpdates any existing field updates
- * @returns Array of fields to be updated
- * @private
- */
-export declare function _validateDomains(fieldInfo: any, fieldUpdates: any[]): any[];
-/**
- *  Get portal field updates to be added with an updateDefinition call after the
- * initial addToDef
+ * @param item that stores the view fields
  *
- * @param field the current field instance
- * @param names the alias of domain field names
- * @param fields the alias or domain fields
- * @param key the field key to evaluate
- * @param fieldUpdates any existing field updates
- * @private
- */
-export declare function _getPortalViewFieldUpdates(field: any, names: string[], fields: any[], key: string, fieldUpdates: any[]): void;
-/**
- *  view field domains can contain different values than the source feature service field domains
- *  use the cached domain when it differs from the source view field domain
- *
- * @param fieldInfo current view layer or table fieldInfo
- * @param fieldUpdates any existing field updates
- * @returns Array of fields to be updated
+ * This function will update the item that is provided
  * @private
  */
-export declare function _validateViewDomainsAndAlias(fieldInfo: any, item: any): void;
+export declare function _validateViewFieldInfos(fieldInfo: any, item: any): void;
 /**
- *  Get array of domain fields and names and alias fields and names
+ *  Get arrays of fields and names for domain, alias, and editable props
  *
  * @param fieldInfo current view layer or table fieldInfo
  * @private
  */
-export declare function _getDomainAndAliasInfos(fieldInfo: any): any;
+export declare function _getViewFieldInfos(fieldInfo: any): any;
 /**
  * Set isViewOverride for view fields when they have differences from the source FS field
  *
  * @param field the field instance we are testing
  * @param names array of field names
- * @param fields array of fields
+ * @param vals array of values
  * @param key the field key to compare
  * @private
  */
-export declare function _isViewFieldOverride(field: any, names: string[], fields: any[], key: string): void;
+export declare function _isViewFieldOverride(field: any, names: string[], vals: any[], key: string): void;
 /**
  * Add popup info back to the layer item
  *

package/dist/esm/featureServiceHelpers.js

@@ -20,9 +20,9 @@
  */
 // ------------------------------------------------------------------------------------------------------------------ //
 export { queryFeatures as rest_queryFeatures, addFeatures as rest_addFeatures } from "@esri/arcgis-rest-feature-layer";
-import { checkUrlPathTermination, deleteProp, fail, getProp, setCreateProp, setProp } from "./generalHelpers";
+import { checkUrlPathTermination, deleteProp, deleteProps, fail, getProp, setCreateProp, setProp } from "./generalHelpers";
 import { replaceInTemplate, templatizeTerm, templatizeIds } from "./templatization";
-import { getFinalServiceUpdates, addToServiceDefinition, getLayerUpdates, getRequest, rest_request } from "./restHelpers";
+import { addToServiceDefinition, getLayerUpdates, getRequest, rest_request } from "./restHelpers";
 import { isTrackingViewTemplate, templatizeTracker } from "./trackingHelpers";
 //#endregion ------------------------------------------------------------------------------------------------------------//
 //#region Public functions ----------------------------------------------------------------------------------------------//
@@ -121,10 +121,9 @@ export function deleteViewProps(layer) {
  *
  * @param layer The data layer instance with field name references within
  * @param fieldInfos the object that stores the cached field infos
- * @param isPortal Controls what properties should be removed.
  * @returns An updated instance of the fieldInfos
  */
-export function cacheFieldInfos(layer, fieldInfos, isPortal) {
+export function cacheFieldInfos(layer, fieldInfos) {
     // cache the source fields as they are in the original source
     if (layer && layer.fields) {
         fieldInfos[layer.id] = {
@@ -137,19 +136,34 @@ export function cacheFieldInfos(layer, fieldInfos, isPortal) {
     // and will have associated updateDefinition calls when deploying to portal
     // as well as online for relationships...as relationships added with addToDef will cause failure
     const props = {
-        editFieldsInfo: isPortal,
-        types: isPortal,
-        templates: isPortal,
+        editFieldsInfo: false,
+        types: false,
+        templates: false,
         relationships: true,
-        drawingInfo: isPortal,
-        timeInfo: isPortal,
-        viewDefinitionQuery: isPortal
+        drawingInfo: false,
+        timeInfo: false,
+        viewDefinitionQuery: false
     };
     Object.keys(props).forEach(k => {
         _cacheFieldInfo(layer, k, fieldInfos, props[k]);
     });
     return fieldInfos;
 }
+/**
+ * Cache the stored contingent values so we can add them in subsequent addToDef calls
+ *
+ * @param id The layer id for the associated values to be stored with
+ * @param fieldInfos The object that stores the cached field infos
+ * @param itemTemplate The current itemTemplate being processed
+ * @returns An updated instance of the fieldInfos
+ */
+export function cacheContingentValues(id, fieldInfos, itemTemplate) {
+    const contingentValues = getProp(itemTemplate, 'properties.contingentValues');
+    if (contingentValues && contingentValues[id]) {
+        fieldInfos[id]['contingentValues'] = contingentValues[id];
+    }
+    return fieldInfos;
+}
 /**
  * Helper function to cache a single property into the fieldInfos object
  * This property will be removed from the layer instance.
@@ -169,7 +183,7 @@ export function _cacheFieldInfo(layer, prop, fieldInfos, removeProp) {
         // editFieldsInfo does not come through unless its with the layer
         // when it's being added
         /* istanbul ignore else */
-        if (removeProp && prop !== "editFieldsInfo") {
+        if (removeProp) {
             layer[prop] = null;
         }
     }
@@ -395,6 +409,57 @@ export function updateTemplateForInvalidDesignations(template, authentication) {
         }
     });
 }
+/**
+ * Get the contingent values for each layer in the service.
+ * Remove key props that cannot be included with the addToDef call on deploy.
+ * Store the values alongside other key feature service properties in the template
+ *
+ * @param properties the current feature services properties
+ * @param adminUrl the current feature service url
+ * @param authentication Credentials for the request to AGOL
+ * @returns A promise that will resolve when the contingent values have been fetched.
+ * This function will update the provided properties argument when contingent values are found.
+ */
+export function processContingentValues(properties, adminUrl, authentication) {
+    return new Promise((resolve, reject) => {
+        if (getProp(properties, 'service.isView')) {
+            // views will inherit from the source service
+            resolve();
+        }
+        else {
+            const layersAndTables = (properties.layers || []).concat(properties.tables || []);
+            const layerIds = [];
+            const contingentValuePromises = layersAndTables.reduce((prev, cur) => {
+                /* istanbul ignore else */
+                if (cur.hasContingentValuesDefinition) {
+                    prev.push(rest_request(`${adminUrl}/${cur['id']}/contingentValues?f=json`, { authentication }));
+                    layerIds.push(cur['id']);
+                }
+                return prev;
+            }, []);
+            if (contingentValuePromises.length > 0) {
+                Promise.all(contingentValuePromises).then((results) => {
+                    const contingentValues = {};
+                    results.forEach((r, i) => {
+                        deleteProp(r, 'typeCodes');
+                        /* istanbul ignore else */
+                        if (getProp(r, 'stringDicts') && getProp(r, 'contingentValuesDefinition')) {
+                            r.contingentValuesDefinition['stringDicts'] = r.stringDicts;
+                            deleteProp(r, 'stringDicts');
+                        }
+                        deleteProps(getProp(r, 'contingentValuesDefinition'), ['layerID', 'layerName', 'geometryType', 'hasSubType']);
+                        contingentValues[layerIds[i]] = r;
+                    });
+                    properties.contingentValues = contingentValues;
+                    resolve();
+                }, reject);
+            }
+            else {
+                resolve();
+            }
+        }
+    });
+}
 /**
  * Replace the field name reference templates with the new field names after deployment.
  *
@@ -503,16 +568,12 @@ export function addFeatureServiceLayersAndTables(itemTemplate, templateDictionar
                     // eslint-disable-next-line @typescript-eslint/no-floating-promises
                     updateLayerFieldReferences(itemTemplate, fieldInfos, popupInfos, adminLayerInfos, templateDictionary).then(r => {
                         // Update relationships and layer definitions
-                        let updates = getLayerUpdates({
+                        const updates = getLayerUpdates({
                             message: "updated layer definition",
                             objects: r.layerInfos.fieldInfos,
                             itemTemplate: r.itemTemplate,
                             authentication
                         }, templateDictionary.isPortal);
-                        // Get any updates for the service that should be performed after updates to the layers
-                        if (templateDictionary.isPortal) {
-                            updates = getFinalServiceUpdates(r.itemTemplate, authentication, updates);
-                        }
                         // Process the updates sequentially
                         updates
                             .reduce((prev, update) => {
@@ -569,7 +630,9 @@ export function addFeatureServiceDefinition(serviceUrl, listToAdd, templateDicti
             listToAdd.forEach((toAdd, i) => {
                 let item = toAdd.item;
                 const originalId = item.id;
-                fieldInfos = cacheFieldInfos(item, fieldInfos, templateDictionary.isPortal);
+                fieldInfos = cacheFieldInfos(item, fieldInfos);
+                // cache the values to be added in seperate addToDef calls
+                fieldInfos = cacheContingentValues(item.id, fieldInfos, itemTemplate);
                 /* istanbul ignore else */
                 if (item.isView) {
                     deleteViewProps(item);
@@ -585,9 +648,7 @@ export function addFeatureServiceDefinition(serviceUrl, listToAdd, templateDicti
                     // update adminLayerInfo before add to definition with view source fieldInfo settings
                     item.adminLayerInfo = replaceInTemplate(item.adminLayerInfo, templateDictionary);
                     /* istanbul ignore else */
-                    if (!templateDictionary.isPortal &&
-                        fieldInfos &&
-                        fieldInfos.hasOwnProperty(item.id)) {
+                    if (fieldInfos && fieldInfos.hasOwnProperty(item.id)) {
                         Object.keys(templateDictionary).some(k => {
                             if (templateDictionary[k].itemId === itemTemplate.itemId) {
                                 fieldInfos[item.id]["sourceServiceFields"] =
@@ -600,7 +661,7 @@ export function addFeatureServiceDefinition(serviceUrl, listToAdd, templateDicti
                         });
                         // view field domain and alias can contain different values than the source field
                         // we need to set isViewOverride when added fields that differ from the source field
-                        _validateViewDomainsAndAlias(fieldInfos[item.id], item);
+                        _validateViewFieldInfos(fieldInfos[item.id], item);
                     }
                 }
                 /* istanbul ignore else */
@@ -752,7 +813,6 @@ export function _updateForPortal(item, itemTemplate, templateDictionary) {
     }
     // not allowed to set sourceSchemaChangesAllowed or isView for portal
     // these are set when you create the service
-    deleteProp(item, "sourceSchemaChangesAllowed");
     deleteProp(item, "isView");
     return item;
 }
@@ -1028,25 +1088,10 @@ export function postProcessFields(itemTemplate, layerInfos, popupInfos, adminLay
                         // more than case change when deployed to protal so keep track of the new names
                         layerInfo["newEditFieldsInfo"] = JSON.parse(JSON.stringify(item.editFieldsInfo));
                     }
-                    // fields that are marked as visible false on a view are all set to
-                    // visible true when added with the layer definition
-                    // update the field visibility to match that of the source
                     /* istanbul ignore else */
                     if (isView && templateInfo && templateDictionary.isPortal) {
                         // when the item is a view bring over the source service fields so we can compare the domains
                         layerInfo["sourceServiceFields"] = templateInfo.sourceServiceFields;
-                        let fieldUpdates = _getFieldVisibilityUpdates(layerInfo);
-                        // view field domains can contain different values than the source field domains
-                        // use the cached view domain when it differs from the source view domain
-                        fieldUpdates = _validateDomains(layerInfo, fieldUpdates);
-                        /* istanbul ignore else */
-                        if (fieldUpdates.length > 0) {
-                            layerInfo.fields = fieldUpdates;
-                        }
-                        layerInfo.typeIdField = _getTypeIdField(item);
-                        const fieldNames = layerInfo.newFields.map((f) => f.name);
-                        _validateTemplatesFields(layerInfo, fieldNames);
-                        _validateTypesTemplates(layerInfo, fieldNames);
                     }
                 }
             });
@@ -1062,141 +1107,35 @@ export function postProcessFields(itemTemplate, layerInfos, popupInfos, adminLay
     });
 }
 /**
- * when deploying to portal if a view has a different typeIdField than what it being set on the source service
- *  we need to pass it via an updateDef call or it will be set as the typeIdField of the source service
+ * View field domain, alias, editable, and visible props can contain
+ * different values from the source.
  *
- * @param item current layer or table
- * @returns name of field to set for typeIdField in the update call
- * @private
- */
-export function _getTypeIdField(item) {
-    const typeIdFields = item.fields.filter((f) => {
-        return (f.name &&
-            item.typeIdField &&
-            f.name.toLowerCase() === item.typeIdField.toLowerCase());
-    });
-    return Array.isArray(typeIdFields) && typeIdFields.length === 1
-        ? typeIdFields[0].name
-        : item.typeIdField;
-}
-/**
- * Update a views field visibility to match that of the source
- *  Fields that are marked as visible false on a view are all set to
- *  visible true when added with the layer definition
- *
- * @param fieldInfo current layers or tables fieldInfo
- * @returns Array of fields that should not be visible in the view
- * @private
- */
-export function _getFieldVisibilityUpdates(fieldInfo) {
-    const visibilityUpdates = [];
-    if (fieldInfo && fieldInfo["sourceFields"] && fieldInfo["newFields"]) {
-        const sourceFields = fieldInfo["sourceFields"].reduce((hash, f) => {
-            hash[String(f.name).toLocaleLowerCase()] = f.visible;
-            return hash;
-        }, {});
-        fieldInfo["newFields"].forEach((f) => {
-            const name = String(f.name).toLocaleLowerCase();
-            // only add fields that are not visible
-            if (sourceFields.hasOwnProperty(name) && !sourceFields[name]) {
-                visibilityUpdates.push({
-                    name: f.name,
-                    visible: sourceFields[name]
-                });
-            }
-        });
-    }
-    return visibilityUpdates;
-}
-/**
- *  view field domains can contain different values than the source feature service field domains
- *  use the cached domain when it differs from the source view field domain
+ * We need to check and set isFieldOverride to true when this occurs and false when it does not
  *
  * @param fieldInfo current view layer or table fieldInfo
- * @param fieldUpdates any existing field updates
- * @returns Array of fields to be updated
- * @private
- */
-export function _validateDomains(fieldInfo, fieldUpdates) {
-    const domainAliasInfos = _getDomainAndAliasInfos(fieldInfo);
-    const domainFields = domainAliasInfos.domainFields;
-    const domainNames = domainAliasInfos.domainNames;
-    const aliasFields = domainAliasInfos.aliasFields;
-    const aliasNames = domainAliasInfos.aliasNames;
-    // loop through the fields from the new view service
-    // add an update when the domains don't match
-    fieldInfo.newFields.forEach((field) => {
-        _getPortalViewFieldUpdates(field, domainNames, domainFields, "domain", fieldUpdates);
-        _getPortalViewFieldUpdates(field, aliasNames, aliasFields, "alias", fieldUpdates);
-    });
-    return fieldUpdates;
-}
-/**
- *  Get portal field updates to be added with an updateDefinition call after the
- * initial addToDef
+ * @param item that stores the view fields
  *
- * @param field the current field instance
- * @param names the alias of domain field names
- * @param fields the alias or domain fields
- * @param key the field key to evaluate
- * @param fieldUpdates any existing field updates
+ * This function will update the item that is provided
  * @private
  */
-export function _getPortalViewFieldUpdates(field, names, fields, key, fieldUpdates) {
-    if (field.hasOwnProperty(key) && field[key]) {
-        const i = names.indexOf(String(field.name).toLocaleLowerCase());
-        if (JSON.stringify(field[key]) !== (i > -1 ? JSON.stringify(fields[i]) : "")) {
-            // should mixin the update if the field already has some other update
-            let hasUpdate = false;
-            fieldUpdates.some((update) => {
-                if (update.name === field.name) {
-                    hasUpdate = true;
-                    update[key] = field[key];
-                }
-                return hasUpdate;
-            });
-            if (!hasUpdate) {
-                const update = { name: field.name };
-                update[key] = field[key];
-                fieldUpdates.push(update);
-            }
-        }
-    }
-}
-/**
- *  view field domains can contain different values than the source feature service field domains
- *  use the cached domain when it differs from the source view field domain
- *
- * @param fieldInfo current view layer or table fieldInfo
- * @param fieldUpdates any existing field updates
- * @returns Array of fields to be updated
- * @private
- */
-export function _validateViewDomainsAndAlias(fieldInfo, item) {
-    const domainAliasInfos = _getDomainAndAliasInfos(fieldInfo);
-    const domainFields = domainAliasInfos.domainFields;
-    const domainNames = domainAliasInfos.domainNames;
-    const aliasFields = domainAliasInfos.aliasFields;
-    const aliasNames = domainAliasInfos.aliasNames;
-    // loop through the fields from the item
-    // add isViewOverride when the domains or alias don't match
+export function _validateViewFieldInfos(fieldInfo, item) {
+    const fieldInfos = _getViewFieldInfos(fieldInfo);
     item.fields.map((field) => {
-        _isViewFieldOverride(field, domainNames, domainFields, "domain");
-        _isViewFieldOverride(field, aliasNames, aliasFields, "alias");
+        Object.keys(fieldInfos).forEach(fi => {
+            _isViewFieldOverride(field, fieldInfos[fi].names, fieldInfos[fi].vals, fi);
+        });
         return field;
     });
 }
 /**
- *  Get array of domain fields and names and alias fields and names
+ *  Get arrays of fields and names for domain, alias, and editable props
  *
  * @param fieldInfo current view layer or table fieldInfo
  * @private
  */
-export function _getDomainAndAliasInfos(fieldInfo) {
-    const domainFields = [];
-    const domainNames = [];
-    const aliasFields = [];
-    const aliasNames = [];
+export function _getViewFieldInfos(fieldInfo) {
+    const fieldInfos = {};
+    const fieldOverrideKeys = ["domain", "alias", "editable"];
     /* istanbul ignore else */
     if (fieldInfo.sourceServiceFields) {
         Object.keys(fieldInfo.sourceServiceFields).forEach(k => {
@@ -1204,44 +1143,49 @@ export function _getDomainAndAliasInfos(fieldInfo) {
             if (fieldInfo.sourceServiceFields[k]) {
                 Object.keys(fieldInfo.sourceServiceFields[k]).forEach(_k => {
                     fieldInfo.sourceServiceFields[k][_k].forEach((field) => {
-                        /* istanbul ignore else */
-                        if (field.hasOwnProperty("domain") && field.domain) {
-                            domainFields.push(field.domain);
-                            domainNames.push(String(field.name).toLocaleLowerCase());
-                        }
-                        /* istanbul ignore else */
-                        if (field.hasOwnProperty("alias") && field.alias) {
-                            aliasFields.push(field.alias);
-                            aliasNames.push(String(field.name).toLocaleLowerCase());
-                        }
+                        fieldOverrideKeys.forEach(o_k => {
+                            /* istanbul ignore else */
+                            if (field.hasOwnProperty(o_k)) {
+                                const name = String(field.name).toLocaleLowerCase();
+                                const v = field[o_k];
+                                if (getProp(fieldInfos, o_k)) {
+                                    fieldInfos[o_k].names.push(name);
+                                    fieldInfos[o_k].vals.push(v);
+                                }
+                                else {
+                                    fieldInfos[o_k] = {
+                                        names: [name],
+                                        vals: [v]
+                                    };
+                                }
+                            }
+                        });
                     });
                 });
             }
         });
     }
-    return {
-        aliasFields,
-        aliasNames,
-        domainFields,
-        domainNames
-    };
+    return fieldInfos;
 }
 /**
  * Set isViewOverride for view fields when they have differences from the source FS field
  *
  * @param field the field instance we are testing
  * @param names array of field names
- * @param fields array of fields
+ * @param vals array of values
  * @param key the field key to compare
  * @private
  */
-export function _isViewFieldOverride(field, names, fields, key) {
+export function _isViewFieldOverride(field, names, vals, key) {
     /* istanbul ignore else */
-    if (field.hasOwnProperty(key) && field[key]) {
+    if (field.hasOwnProperty(key)) {
         const i = names.indexOf(String(field.name).toLocaleLowerCase());
+        const isOverride = JSON.stringify(field[key]) !== (i > -1 ? JSON.stringify(vals[i]) : "");
+        const overrideSet = field.hasOwnProperty('isViewOverride');
+        // need to skip this check if isViewOverride has already been set to true
         /* istanbul ignore else */
-        if (JSON.stringify(field[key]) !== (i > -1 ? JSON.stringify(fields[i]) : "")) {
-            field.isViewOverride = true;
+        if (((overrideSet && !field.isViewOverride) || !overrideSet)) {
+            field.isViewOverride = isOverride;
         }
     }
 }