dattatable 2.11.6 → 2.11.8

package/build/common/listCfg.d.ts

@@ -19,7 +19,6 @@ export interface ILookupData {
     items: {
         [key: string]: object | string;
     }[];
-    srcField: string;
 }
 export interface IGenerateLookupDataProps {
     lookupFields: Types.SP.FieldLookup[];
@@ -41,7 +40,10 @@ export interface IValidateLookupsProps {
 export declare class ListConfig {
     private static InternalFields;
     static createLookupListData(props: ICreateLookupData): PromiseLike<void>;
+    static fixMMSFields(webUrl: string, listName: string): PromiseLike<void>;
     static generate(props: IListConfigProps): PromiseLike<IListConfig>;
     static generateLookupListData(props: IGenerateLookupDataProps): PromiseLike<ILookupData[]>;
+    private static getMMSLookupListId;
+    static readList(webUrl: string, listName: string, lookupField: string): PromiseLike<ILookupData>;
     static validateLookups(props: IValidateLookupsProps): PromiseLike<Helper.ISPConfigProps>;
 }

package/build/common/listCfg.js

@@ -103,6 +103,59 @@ var ListConfig = /** @class */ (function () {
             });
         });
     };
+    // Fixes the MMS fields to ensure the list property is configured correctly
+    ListConfig.fixMMSFields = function (webUrl, listName) {
+        var _this = this;
+        // Return a promise
+        return new Promise(function (resolve, reject) {
+            // Show a loading dialog
+            loadingDialog_1.LoadingDialog.setHeader("Validating MMS Fields");
+            loadingDialog_1.LoadingDialog.setBody("Getting the list '" + listName + "' fields...");
+            loadingDialog_1.LoadingDialog.show();
+            // Get the hidden list
+            _this.getMMSLookupListId(webUrl).then(function (listId) {
+                var mmsListId = "{" + listId + "}";
+                // Load the list fields
+                (0, gd_sprest_bs_1.Web)(webUrl).Lists(listName).Fields().execute(function (fields) {
+                    // Parse the fields
+                    gd_sprest_bs_1.Helper.Executor(fields.results, function (field) {
+                        // See if this is not a MMS field
+                        if (field.TypeDisplayName != "Managed Metadata") {
+                            return;
+                        }
+                        // Return a promise
+                        return new Promise(function (resolve) {
+                            // Get the schema for this field
+                            var parser = new DOMParser();
+                            var schemaXml = parser.parseFromString(field.SchemaXml, "application/xml");
+                            var xmlField = schemaXml.querySelector("Field");
+                            // See if the list property is correct
+                            if (xmlField.getAttribute("List") == mmsListId) {
+                                // Check the next field
+                                resolve(null);
+                            }
+                            else {
+                                // Update the list property
+                                xmlField.setAttribute("List", mmsListId);
+                                // Update the schema value and check the next field
+                                field.update({ SchemaXml: xmlField.outerHTML }).execute(resolve, function () {
+                                    // Log the error
+                                    console.error("Error updating the MMS list property for field: " + field.InternalName);
+                                    // Check the next field
+                                    resolve(null);
+                                });
+                            }
+                        });
+                    }).then(resolve, reject);
+                }, reject);
+            }, function () {
+                // Error getting the list data
+                console.error("Error getting the taxonomy hidden list.");
+                // Resolve the request
+                resolve();
+            });
+        });
+    };
     // Generates the list configuration
     ListConfig.generate = function (props) {
         var _this = this;
@@ -414,6 +467,7 @@ var ListConfig = /** @class */ (function () {
     };
     // Generates the lookup list data
     ListConfig.generateLookupListData = function (props) {
+        var _this = this;
         var lookupListData = [];
         // See if we are showing a loading dialog
         if (props.showDialog) {
@@ -444,69 +498,18 @@ var ListConfig = /** @class */ (function () {
                 return new Promise(function (resolve) {
                     // Get the source list
                     (0, gd_sprest_bs_1.Web)(props.srcWebUrl).Lists().getById(lookupField.LookupList).execute(function (list) {
-                        var fields = [];
-                        // Get the list content type fields
-                        list.ContentTypes().query({ Expand: ["Fields"] }).execute(function (cts) {
-                            // Parse the content type fields
-                            for (var i = 0; i < cts.results[0].Fields.results.length; i++) {
-                                var field = cts.results[0].Fields.results[i];
-                                // Add the field link
-                                fields.push(field);
-                            }
-                        });
-                        // Get the list items
-                        list.Items().query({
-                            GetAllItems: true,
-                            Top: 5000,
-                            OrderBy: ["Id"]
-                        }).execute(function (items) {
-                            var lookupItems = [];
-                            // Parse the items
-                            for (var i = 0; i < items.results.length; i++) {
-                                var lookupItem = {};
-                                // Parse the field links
-                                for (var j = 0; j < fields.length; j++) {
-                                    var field = fields[j];
-                                    var value = items.results[i][field.InternalName];
-                                    // Ensure a value exists
-                                    if (value == null) {
-                                        continue;
-                                    }
-                                    // See if this is a collection
-                                    if (value.results) {
-                                        // Set the results
-                                        value = { results: value.results };
-                                    }
-                                    // Add the value, based on the type
-                                    switch (field.FieldTypeKind) {
-                                        case gd_sprest_bs_1.SPTypes.FieldType.URL:
-                                            lookupItem[field.InternalName] = {
-                                                Description: value.Description,
-                                                Url: value.Url
-                                            };
-                                            break;
-                                        default:
-                                            // Set the value
-                                            lookupItem[field.InternalName] = value;
-                                            break;
-                                    }
-                                }
-                                // Add the lookup item
-                                lookupItems.push(lookupItem);
-                            }
-                            // Save the item data
-                            lookupListData.push({
-                                field: lookupField.LookupField,
-                                items: lookupItems,
-                                list: list.Title,
-                                srcField: lookupField.InternalName
-                            });
+                        // Read the list
+                        _this.readList(props.srcWebUrl, list.Title, lookupField.LookupField).then(function (data) {
                             // Set the flag
                             lookupLists[listId] = true;
+                            // Save the item data
+                            lookupListData.push(data);
                             // Check the next list
                             resolve(null);
-                        }, true); // Set the flag to run this after the previous request completes
+                        }, resolve);
                     }, function () {
+                        // Log
+                        console.error("Error: List with id '".concat(lookupField.LookupList, "' does not exist in web '").concat(props.srcWebUrl, "'."));
                         // Check the next list
                         resolve(null);
                     });
@@ -517,6 +520,83 @@ var ListConfig = /** @class */ (function () {
             }, reject);
         });
     };
+    // Gets the taxonomy hidden list
+    ListConfig.getMMSLookupListId = function (webUrl) {
+        // Return a promise
+        return new Promise(function (resolve, reject) {
+            // Query the web for the hidden list
+            (0, gd_sprest_bs_1.Web)(webUrl).Lists("TaxonomyHiddenList").execute(function (list) {
+                // Resolve the request
+                resolve(list.Id);
+            }, reject);
+        });
+    };
+    // Generates the lookup list data
+    ListConfig.readList = function (webUrl, listName, lookupField) {
+        // Return a promise
+        return new Promise(function (resolve, reject) {
+            // Get the source list
+            (0, gd_sprest_bs_1.Web)(webUrl).Lists(listName).execute(function (list) {
+                var fields = [];
+                // Get the list content type fields
+                list.ContentTypes().query({ Expand: ["Fields"] }).execute(function (cts) {
+                    // Parse the content type fields
+                    for (var i = 0; i < cts.results[0].Fields.results.length; i++) {
+                        var field = cts.results[0].Fields.results[i];
+                        // Add the field link
+                        fields.push(field);
+                    }
+                });
+                // Get the list items
+                list.Items().query({
+                    GetAllItems: true,
+                    Top: 5000,
+                    OrderBy: ["Id"]
+                }).execute(function (items) {
+                    var lookupItems = [];
+                    // Parse the items
+                    for (var i = 0; i < items.results.length; i++) {
+                        var lookupItem = {};
+                        // Parse the field links
+                        for (var j = 0; j < fields.length; j++) {
+                            var field = fields[j];
+                            var value = items.results[i][field.InternalName];
+                            // Ensure a value exists
+                            if (value == null) {
+                                continue;
+                            }
+                            // See if this is a collection
+                            if (value.results) {
+                                // Set the results
+                                value = { results: value.results };
+                            }
+                            // Add the value, based on the type
+                            switch (field.FieldTypeKind) {
+                                case gd_sprest_bs_1.SPTypes.FieldType.URL:
+                                    lookupItem[field.InternalName] = {
+                                        Description: value.Description,
+                                        Url: value.Url
+                                    };
+                                    break;
+                                default:
+                                    // Set the value
+                                    lookupItem[field.InternalName] = value;
+                                    break;
+                            }
+                        }
+                        // Add the lookup item
+                        lookupItems.push(lookupItem);
+                    }
+                    // Resolve the request
+                    resolve({
+                        field: lookupField,
+                        items: lookupItems,
+                        list: list.Title
+                    });
+                }, true); // Set the flag to run this after the previous request completes
+            }, reject);
+        });
+    };
     // Validates the lookup fields
     ListConfig.validateLookups = function (props) {
         var _this = this;