bruce-models 7.1.81 → 7.1.83

package/dist/bruce-models.umd.js

@@ -10740,6 +10740,24 @@
     }
 
     (function (DataLab) {
+        /**
+         * What a search returns, as opposed to which Entities it matches.
+         */
+        let ESelectType;
+        (function (ESelectType) {
+            // Whole Entity records. This is the default.
+            ESelectType["Entity"] = "ENTITY";
+            // Just the Entity IDs.
+            ESelectType["Id"] = "ID";
+            // The distinct Entity Type IDs of the matches, rather than the matches themselves.
+            ESelectType["EntityTypeId"] = "ENTITY_TYPE_ID";
+            // The internal (Bruce) attributes at the root of each record.
+            ESelectType["Internal"] = "Bruce";
+            // A calculation described by Output.
+            ESelectType["Calc"] = "CALC";
+            // A data schema built from the matches.
+            ESelectType["DataSchema"] = "DATA_SCHEMA";
+        })(ESelectType = DataLab.ESelectType || (DataLab.ESelectType = {}));
         let EReqKey;
         (function (EReqKey) {
             EReqKey["Primary"] = "PrimarySelection";
@@ -10826,6 +10844,59 @@
             });
         }
         DataLab.SuggestDataLabQueryByPrompt = SuggestDataLabQueryByPrompt;
+        /**
+         * Runs a DataLab query for the distinct Entity Type IDs of everything it matches.
+         */
+        function GetEntityTypeIds(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, query, skip, load, req: reqParams } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                if (!(query === null || query === void 0 ? void 0 : query[EReqKey.Primary])) {
+                    throw new Error("query must carry a PrimarySelection.");
+                }
+                skip = skip !== null && skip !== void 0 ? skip : 0;
+                load = load !== null && load !== void 0 ? load : 200;
+                // Cloned so asking this question of a query never changes what the caller goes on to run.
+                const body = Object.assign(Object.assign({}, query), { [EReqKey.Primary]: Object.assign(Object.assign({}, query[EReqKey.Primary]), { Select: { Type: ESelectType.EntityTypeId } }), Skip: skip, Load: load });
+                const res = yield api.POST("v3/datalab/runSearch", body, exports.Api.PrepReqParams(reqParams));
+                return {
+                    entityTypeIds: Array.isArray(res === null || res === void 0 ? void 0 : res.Items) ? res.Items : [],
+                    hasMore: Boolean(res === null || res === void 0 ? void 0 : res.NextPage)
+                };
+            });
+        }
+        DataLab.GetEntityTypeIds = GetEntityTypeIds;
+        /**
+         * Returns the distinct Entity Type IDs used inside one or more assembly hierarchies.
+         * The root Entity's own Type is included, since it is part of the hierarchy.
+         */
+        function GetAssemblyEntityTypeIds(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { api, rootEntityId, skip, load, req } = params;
+                const rootIds = Array.isArray(rootEntityId) ? rootEntityId : [rootEntityId];
+                if (!rootIds.length || rootIds.some(id => !id)) {
+                    throw new Error("rootEntityId must be provided.");
+                }
+                const criterion = {
+                    key: "root",
+                    RootID: rootIds
+                };
+                return GetEntityTypeIds({
+                    api,
+                    skip,
+                    load,
+                    req,
+                    query: {
+                        [EReqKey.Primary]: {
+                            Items: [criterion]
+                        }
+                    }
+                });
+            });
+        }
+        DataLab.GetAssemblyEntityTypeIds = GetAssemblyEntityTypeIds;
         /**
          * Runs a DataLab query.
          * @param params
@@ -10874,6 +10945,26 @@
             });
         }
         DataLab.Run = Run;
+        /**
+         * Runs one or more DataLab actions.
+         * This calls: POST v3/datalab/runAction
+         */
+        function RunAction(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, body, req } = params;
+                if (!body) {
+                    throw new Error("body is required.");
+                }
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                const res = yield api.POST("v3/datalab/runAction", body, exports.Api.PrepReqParams(req));
+                return {
+                    action: res
+                };
+            });
+        }
+        DataLab.RunAction = RunAction;
     })(exports.DataLab || (exports.DataLab = {}));
 
     (function (DataLabGroup) {
@@ -14717,6 +14808,70 @@
         ExportBrz.Export = Export;
     })(exports.ExportBrz || (exports.ExportBrz = {}));
 
+    (function (ExportCsv) {
+        /**
+         * Exports CSV for Entities selected by Filter.
+         * This calls: GET entities/ExportCSV
+         */
+        function Export(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, fileExport, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                if (!(fileExport === null || fileExport === void 0 ? void 0 : fileExport.BruceEntityType)) {
+                    throw ("fileExport.BruceEntityType is required.");
+                }
+                const urlParams = new URLSearchParams();
+                urlParams.append("BruceEntityType", fileExport.BruceEntityType);
+                appendStringParam(urlParams, "OrderBy", fileExport.OrderBy);
+                appendStringParam(urlParams, "SortOrder", fileExport.SortOrder);
+                appendStringParam(urlParams, "Filter", fileExport.Filter);
+                appendStringParam(urlParams, "LODType", fileExport.LODType);
+                if (fileExport.ZIP != null) {
+                    urlParams.append("ZIP", String(fileExport.ZIP));
+                }
+                if (fileExport.ColumnSettings) {
+                    urlParams.append("ColumnSettings", JSON.stringify(fileExport.ColumnSettings));
+                }
+                return api.GET(`entities/ExportCSV?${urlParams.toString()}`, exports.Api.PrepReqParams(req));
+            });
+        }
+        ExportCsv.Export = Export;
+        /**
+         * Exports CSV for a provided list of Entity IDs.
+         * This calls: POST entities/ExportCSV/{entityType_ID}
+         */
+        function ExportEntities(params) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, entityTypeId, fileExport, zip, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                if (!entityTypeId) {
+                    throw ("entityTypeId is required.");
+                }
+                if (!((_a = fileExport === null || fileExport === void 0 ? void 0 : fileExport.EntityIDs) === null || _a === void 0 ? void 0 : _a.length)) {
+                    throw ("fileExport.EntityIDs is required and must be a non-empty list.");
+                }
+                let url = `entities/ExportCSV/${exports.Api.Encode(entityTypeId)}`;
+                if (zip != null) {
+                    const urlParams = new URLSearchParams();
+                    urlParams.append("ZIP", String(zip));
+                    url += `?${urlParams.toString()}`;
+                }
+                return api.POST(url, fileExport, exports.Api.PrepReqParams(req));
+            });
+        }
+        ExportCsv.ExportEntities = ExportEntities;
+        function appendStringParam(urlParams, key, value) {
+            if (value != null && value !== "") {
+                urlParams.append(key, String(value));
+            }
+        }
+    })(exports.ExportCsv || (exports.ExportCsv = {}));
+
     (function (ExportUsd) {
         function Export(params) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -20255,7 +20410,7 @@
     })(exports.UrlUtils || (exports.UrlUtils = {}));
 
     // This is updated with the package.json version on build.
-    const VERSION = "7.1.81";
+    const VERSION = "7.1.83";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;