bruce-models 5.9.2 → 5.9.4

package/dist/bruce-models.umd.js

@@ -40,6 +40,7 @@
         (function (ECacheKey) {
             ECacheKey["Id"] = ":";
             ECacheKey["ListId"] = "::";
+            ECacheKey["Assembly"] = "assembly";
             ECacheKey["Entity"] = "entity";
             ECacheKey["EntityType"] = "entitytype";
             ECacheKey["ProjectView"] = "projectview";
@@ -1725,6 +1726,198 @@
         ENVIRONMENT.Reset = Reset;
     })(exports.ENVIRONMENT || (exports.ENVIRONMENT = {}));
 
+    (function (Assembly) {
+        /**
+         * Returns an assembly record by ID.
+         * @param params
+         * @returns
+         */
+        function Get(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, assemblyId, req: reqParams } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                if (!assemblyId) {
+                    throw ("Assembly ID is required.");
+                }
+                const key = GetCacheKey(assemblyId);
+                const cache = api.GetCacheItem(key, reqParams);
+                if (cache === null || cache === void 0 ? void 0 : cache.found) {
+                    return cache.data;
+                }
+                const prom = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const data = yield api.GET(`v3/assembly/${assemblyId}`, exports.Api.PrepReqParams(reqParams));
+                        res({
+                            assembly: data
+                        });
+                    }
+                    catch (e) {
+                        rej(e);
+                    }
+                }));
+                api.SetCacheItem({
+                    key,
+                    value: prom,
+                    req: reqParams
+                });
+                return prom;
+            });
+        }
+        Assembly.Get = Get;
+        /**
+         * Gets a list of assembly records.
+         * @param params
+         * @returns
+         */
+        function GetList(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, req: reqParams } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                const req = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        let url = "v3/assemblies";
+                        const urlParams = new URLSearchParams();
+                        if (params.pageSize != null) {
+                            urlParams.append("PageSize", String(params.pageSize));
+                        }
+                        if (params.pageIndex != null) {
+                            urlParams.append("PageIndex", String(params.pageIndex));
+                        }
+                        if (params.parentId) {
+                            urlParams.append("ParentID", String(params.parentId));
+                        }
+                        if (params.search) {
+                            urlParams.append("Search", params.search);
+                        }
+                        if (params.withTilesets != null) {
+                            urlParams.append("WithTilesets", String(params.withTilesets));
+                        }
+                        url += "?" + urlParams.toString();
+                        const data = yield api.GET(url, exports.Api.PrepReqParams(reqParams));
+                        const result = {};
+                        result.assemblies = data.Items ? data.Items : [];
+                        if (data.TotalCount != null) {
+                            result.totalCount = data.TotalCount;
+                        }
+                        if (data.NextPage != null) {
+                            result.nextPage = data.NextPage;
+                        }
+                        if (data.NextPageURL != null) {
+                            result.nextPageUrl = data.NextPageURL;
+                        }
+                        res(result);
+                    }
+                    catch (e) {
+                        rej(e);
+                    }
+                }));
+                return req;
+            });
+        }
+        Assembly.GetList = GetList;
+        /**
+         * Creates or updates an assembly record.
+         * @param params
+         * @returns
+         */
+        function Update(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, assembly: data, req: reqParams } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                if (!data.ID) {
+                    data.ID = 0;
+                }
+                const url = `v3/assembly/${data.ID}`;
+                const res = yield api.POST(url, data, exports.Api.PrepReqParams(reqParams));
+                api.Cache.Remove(GetCacheKey(data.ID));
+                return {
+                    assembly: res
+                };
+            });
+        }
+        Assembly.Update = Update;
+        /**
+         * Deletes an assembly record.
+         * @param params
+         */
+        function Delete(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, assemblyId, req: reqParams } = params;
+                if (!assemblyId) {
+                    throw ("Assembly ID is required.");
+                }
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                yield api.DELETE(`v3/assembly/${assemblyId}`, exports.Api.PrepReqParams(reqParams));
+                api.Cache.Remove(GetCacheKey(assemblyId));
+            });
+        }
+        Assembly.Delete = Delete;
+        /**
+         * Deletes a list of assembly records based on specified conditions.
+         * @param params
+         */
+        function DeleteList(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, req: reqParams } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                let url = "v3/assemblies";
+                const urlParams = new URLSearchParams();
+                if (params.invalidRootIds) {
+                    urlParams.append("InvalidRootEntityID", "true");
+                }
+                url += "?" + urlParams.toString();
+                yield api.DELETE(url, exports.Api.PrepReqParams(reqParams));
+                api.Cache.RemoveByStartsWith(exports.Api.ECacheKey.Assembly);
+            });
+        }
+        Assembly.DeleteList = DeleteList;
+        /**
+         * Runs a job to locate existing assemblies by searching for root Entity IDs.
+         * Each unregistered root Entity ID will be used to create a new assembly.
+         *
+         * WARNING: on completion, you should kill cache.
+         * Eg: api.Cache.RemoveByStartsWith(Api.ECacheKey.Assembly);
+         * @param params
+         */
+        function SyncWithRootEntityIDs(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!params) {
+                    params = {};
+                }
+                let { api, req: reqParams } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                return yield api.POST("v3/assembly/resyncrootentitiestoassemblies", {}, exports.Api.PrepReqParams(reqParams));
+            });
+        }
+        Assembly.SyncWithRootEntityIDs = SyncWithRootEntityIDs;
+        /**
+         * Returns cache identifier for an assembly by ID.
+         * Example: {
+         *     const api: BruceApi.Api = ...;
+         *     const key = GetCacheKey(5);
+         *     api.Cache.Remove(key);
+         * }
+         * @param assemblyId
+         * @returns
+         */
+        function GetCacheKey(assemblyId) {
+            return `${exports.Api.ECacheKey.Assembly}${exports.Api.ECacheKey.Id}${assemblyId}`;
+        }
+        Assembly.GetCacheKey = GetCacheKey;
+    })(exports.Assembly || (exports.Assembly = {}));
+
     (function (AnnDocument) {
         /**
          * The types of supported annotated documents.
@@ -15114,7 +15307,7 @@
     })(exports.Scenario || (exports.Scenario = {}));
 
     // This is updated with the package.json version on build.
-    const VERSION = "5.9.2";
+    const VERSION = "5.9.4";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;