bruce-models 4.8.0 → 4.8.2

package/dist/bruce-models.umd.js

@@ -2559,21 +2559,24 @@
          */
         function ReIndex(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { api, entityTypeId: typeId, req } = params;
-                if (!typeId) {
-                    throw ("Type ID is required.");
-                }
+                let { api, entityTypeId: typeId, req, dataTransformId, reSaveAll } = params;
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetBruceApi();
                 }
                 const urlParams = new URLSearchParams();
-                if (params.dataTransformId) {
-                    urlParams.append("dataTransformID", String(params.dataTransformId));
+                if (dataTransformId) {
+                    urlParams.append("dataTransformID", String(dataTransformId));
                 }
-                const url = `entitytype/${typeId}/reindex?${urlParams.toString()}`;
+                if (reSaveAll) {
+                    urlParams.append("reSaveAll", "true");
+                }
+                let url = typeId ? `entityType/${typeId}/reindex` : "entities/reindex";
+                url += "?" + urlParams.toString();
                 req = exports.Api.PrepReqParams(req);
-                const pa = yield api.POST(url, {}, req);
-                return pa;
+                const res = yield api.POST(url, {}, req);
+                return {
+                    pendingActionId: res.PendingActionID
+                };
             });
         }
         EntityType.ReIndex = ReIndex;
@@ -10548,6 +10551,128 @@
             });
         }
         PendingAction.Cancel = Cancel;
+        /**
+         * Resolves when the Pending Action is no longer running.
+         * @param params
+         *
+         * @example
+         * try {
+         *    const { action } = await PendingAction.OnCompletion({ actionId: 123 });
+         * }
+         * catch (e) {
+         *    // Threw because the action failed to be found.
+         *    // Most likely scenarios are invalid actionId or server connection issues.
+         *    // If it's related to server connection issues then wait a bit and relaunch.
+         * }
+         *
+         * // Here is how you can stop the loop on early disposal.
+         * let disposed = false;
+         * const { action } = await PendingAction.OnCompletion({
+         *     actionId: 123,
+         *     isDisposed: () => {
+         *         return disposed;
+         *     }
+         * });
+         * // Action will resolve as null if it was disposed early.
+         */
+        function OnCompletion(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, actionId, req: reqParams, interval: intMs, isDisposed, onMessage } = params;
+                if (!actionId) {
+                    throw ("Action ID is required.");
+                }
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetBruceApi();
+                }
+                if (!intMs || intMs <= 0) {
+                    intMs = 3000;
+                }
+                // Map of found messages.
+                const returnedMsgs = new Map();
+                const returnedMsgsArr = [];
+                const res = yield new Promise((res, rej) => {
+                    let msgInterval = null;
+                    if (onMessage != null) {
+                        msgInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                            try {
+                                const { messages } = yield GetMessages({
+                                    api,
+                                    actionId,
+                                    order: exports.Api.ESortOrder.Desc,
+                                    startIndex: 0,
+                                    amount: 5
+                                });
+                                for (let i = 0; i < messages.length; i++) {
+                                    const message = messages[i];
+                                    // If this is a new message we'll notify the callback.
+                                    // We'll also add it to the map so we don't notify it again, and to return it later.
+                                    if (!returnedMsgs.has(message.ID)) {
+                                        returnedMsgs.set(message.ID, true);
+                                        returnedMsgsArr.push(message);
+                                        onMessage(message);
+                                    }
+                                }
+                            }
+                            catch (e) {
+                                clearInterval(msgInterval);
+                            }
+                        }), 1000);
+                    }
+                    let interval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                        if (isDisposed && isDisposed()) {
+                            clearInterval(interval);
+                            if (msgInterval) {
+                                clearInterval(msgInterval);
+                            }
+                            res(null);
+                        }
+                        try {
+                            const { action } = yield Get({
+                                api,
+                                actionId,
+                                req: reqParams
+                            });
+                            if (action.Status !== EStatus.InProgress) {
+                                clearInterval(interval);
+                                if (msgInterval) {
+                                    clearInterval(msgInterval);
+                                }
+                                res(action);
+                            }
+                        }
+                        catch (e) {
+                            clearInterval(interval);
+                            if (msgInterval) {
+                                clearInterval(msgInterval);
+                            }
+                            rej(e);
+                        }
+                    }), intMs);
+                });
+                // Gather latest 30 messages.
+                if (!isDisposed || !isDisposed()) {
+                    const { messages } = yield GetMessages({
+                        api,
+                        actionId,
+                        order: exports.Api.ESortOrder.Desc,
+                        startIndex: 0,
+                        amount: 30
+                    });
+                    for (let i = 0; i < messages.length; i++) {
+                        const message = messages[i];
+                        if (!returnedMsgs.has(message.ID)) {
+                            returnedMsgs.set(message.ID, true);
+                            returnedMsgsArr.push(message);
+                        }
+                    }
+                }
+                return {
+                    action: res,
+                    messages: returnedMsgsArr
+                };
+            });
+        }
+        PendingAction.OnCompletion = OnCompletion;
     })(exports.PendingAction || (exports.PendingAction = {}));
 
     // Some dead accounts that we don't want to show in the UI.
@@ -13916,7 +14041,7 @@
     })(exports.DataSource || (exports.DataSource = {}));
 
     // This is updated with the package.json version on build.
-    const VERSION = "4.8.0";
+    const VERSION = "4.8.2";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;