bruce-models 7.1.95 → 7.1.97

package/dist/bruce-models.umd.js

@@ -372,6 +372,9 @@
             // Manage own records only (eg: own draft bookmarks within a Project View).
             // Only implemented for Bookmarks at the moment.
             EAction["MANAGE_OWN"] = "MANAGE_OWN";
+            // Full CRUD over every record this one owns, and nothing on this record beyond reading it.
+            // Eg: "manage_content:et:<id>" manages that type's Entities without editing the type.
+            EAction["MANAGE_CONTENT"] = "MANAGE_CONTENT";
             EAction["VIEW"] = "VIEW";
             EAction["CREATE"] = "CREATE";
             EAction["EDIT"] = "EDIT";
@@ -434,10 +437,16 @@
          * Builds a concept permission string.
          * Omit recordId for an account-wide permission, eg: "view:pv".
          * Pass recordId for a record-specific permission, eg: "view:pv:abc123".
+         * Pass ownedConcept to narrow it to one kind of record that record owns,
+         * eg: "edit:et:abc123:e" for that Entity Type's Entities and nothing else.
          */
-        function buildPermission(action, concept, recordId) {
+        function buildPermission(action, concept, recordId, ownedConcept) {
             const base = `${action.toLowerCase()}:${concept}`;
-            return recordId ? `${base}:${recordId}` : base;
+            if (!recordId) {
+                return base;
+            }
+            const record = `${base}:${recordId}`;
+            return ownedConcept ? `${record}:${ownedConcept}` : record;
         }
         AccountConcept.buildPermission = buildPermission;
         /**
@@ -474,11 +483,27 @@
             if (!matchedConcept) {
                 return null;
             }
-            const recordId = rest.length > matchedLen ? rest.substring(matchedLen + 1) : undefined;
+            const tail = rest.length > matchedLen ? rest.substring(matchedLen + 1) : undefined;
+            // A fourth segment narrows the grant to one kind of record the named record owns.
+            // Anything that is not a concept token stays part of the record ID.
+            let recordId = tail;
+            let ownedConcept;
+            if (tail) {
+                const lastColon = tail.lastIndexOf(":");
+                if (lastColon > 0) {
+                    const candidate = tail.substring(lastColon + 1);
+                    const matched = Object.values(EConcept).find(t => t === candidate);
+                    if (matched) {
+                        ownedConcept = matched;
+                        recordId = tail.substring(0, lastColon);
+                    }
+                }
+            }
             return {
                 action: matchedAction,
                 concept: matchedConcept,
-                recordId
+                recordId,
+                ownedConcept
             };
         }
         AccountConcept.parsePermission = parsePermission;
@@ -2897,6 +2922,20 @@
     })(exports.AccountFeatures || (exports.AccountFeatures = {}));
 
     (function (AccountInvite) {
+        // Error type returned when inviting a user who already has access to the account.
+        // Their group membership is changed directly rather than offered to them.
+        AccountInvite.ERROR_ALREADY_MEMBER = "AlreadyMember";
+        /**
+         * Returns whether a failed Create was refused because the user is already in the account.
+         * @param error the value thrown by Create.
+         * @returns
+         */
+        function IsAlreadyMemberError(error) {
+            var _a, _b;
+            const type = (_b = (_a = error === null || error === void 0 ? void 0 : error.ERROR) === null || _a === void 0 ? void 0 : _a.Type) !== null && _b !== void 0 ? _b : error === null || error === void 0 ? void 0 : error.Type;
+            return type === AccountInvite.ERROR_ALREADY_MEMBER;
+        }
+        AccountInvite.IsAlreadyMemberError = IsAlreadyMemberError;
         /**
          * Possible invite statuses.
          */
@@ -2907,6 +2946,8 @@
             EStatus["Sent"] = "Sent";
             EStatus["NotSent"] = "Not sent";
             EStatus["Accepted"] = "Accepted";
+            // Closed because the user accepted another invite to the same account.
+            EStatus["Superseded"] = "Superseded";
         })(EStatus = AccountInvite.EStatus || (AccountInvite.EStatus = {}));
         /**
          * Returns whether an invite is still awaiting a response from its recipient.
@@ -2921,6 +2962,16 @@
             return invite.Status === EStatus.Sent || invite.Status === EStatus.NotSent;
         }
         AccountInvite.IsPending = IsPending;
+        /**
+         * Ways an invited user can prove they are who the invitation was addressed to.
+         */
+        let EIdentityProof;
+        (function (EIdentityProof) {
+            // Confirming the password they already hold.
+            EIdentityProof["Password"] = "Password";
+            // Signing in, by whichever method their account allows, and returning.
+            EIdentityProof["Session"] = "Session";
+        })(EIdentityProof = AccountInvite.EIdentityProof || (AccountInvite.EIdentityProof = {}));
         /**
          * Possible invite methods.
          */
@@ -2957,6 +3008,66 @@
             });
         }
         AccountInvite.GetByCode = GetByCode;
+        /**
+         * Returns one invite by its ID. Requires the session to be an account owner or admin.
+         * @param params
+         * @returns
+         */
+        function GetByID(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, id, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetGuardianApi();
+                }
+                const invite = yield api.GET(`v3/accountInvite/${id}`, exports.Api.PrepReqParams(req));
+                return {
+                    invite: invite
+                };
+            });
+        }
+        AccountInvite.GetByID = GetByID;
+        /**
+         * Returns a list of invites grouped by the invited user.
+         * Paging covers users rather than invites, so a user's invitations never straddle a page.
+         * @param params
+         * @returns
+         */
+        function GetListByUser(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const res = yield GetList(Object.assign(Object.assign({}, params), { groupByUser: true }));
+                return {
+                    users: res.invites,
+                    totalCount: res.totalCount,
+                    hasNextPage: res.hasNextPage,
+                    userGroups: res.userGroups
+                };
+            });
+        }
+        AccountInvite.GetListByUser = GetListByUser;
+        /**
+         * Re-delivers an invitation that is still open, renewing its code and expiry.
+         * @param params
+         * @returns
+         */
+        function Resend(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let { api, id, emailTemplateKey, req } = params;
+                if (!api) {
+                    api = exports.ENVIRONMENT.Api().GetGuardianApi();
+                }
+                if (!id) {
+                    throw new Error("An invite ID must be provided.");
+                }
+                const invite = yield api.POST("v3/resendAccountInvite", {
+                    ID: id,
+                    "Email.Template": emailTemplateKey
+                }, exports.Api.PrepReqParams(req));
+                return {
+                    invite: invite
+                };
+            });
+        }
+        AccountInvite.Resend = Resend;
         /**
          * Returns a list of invites matching provided criteria.
          * For example you can get a list of invites for a specific account or user (or both).
@@ -2965,7 +3076,7 @@
          */
         function GetList(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { api, accountId, userId, status, expired, expandUsers, expandGroups, pageSize, pageIndex, req } = params;
+                let { api, accountId, userId, status, expired, expandUsers, expandGroups, groupByUser, pageSize, pageIndex, req } = params;
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetGuardianApi();
                 }
@@ -2992,6 +3103,9 @@
                 if (expand.length) {
                     urlParams.append("Expand", expand.join(","));
                 }
+                if (groupByUser) {
+                    urlParams.append("GroupBy", "User");
+                }
                 if (pageSize !== undefined && pageSize !== null) {
                     urlParams.append("PageSize", String(pageSize));
                 }
@@ -3028,19 +3142,23 @@
          */
         function Update(params) {
             return __awaiter(this, void 0, void 0, function* () {
-                let { api, code, id, status, groupIds, user, req } = params;
+                let { api, code, id, status, groupIds, user, password, req } = params;
                 if (!api) {
                     api = exports.ENVIRONMENT.Api().GetGuardianApi();
                 }
                 if (!code && !id) {
                     throw new Error("Either an invite ID or InviteCode must be provided.");
                 }
+                if (!status && !groupIds) {
+                    throw new Error("Either a status or User Groups must be provided.");
+                }
                 const invite = yield api.POST("v3/accountInvite", {
                     ID: id,
                     InviteCode: code,
                     Status: status,
                     "UserGroup.ID": groupIds,
-                    User: user
+                    User: user,
+                    Password: password
                 }, exports.Api.PrepReqParams(req));
                 return {
                     invite: invite
@@ -7973,8 +8091,9 @@
             return { result: null, attrPath: null, eValue: null };
         }
         function _getGradientTrace(value, entity, defaultToMin) {
-            const min = +value.points[0].position;
-            const max = +value.points[value.points.length - 1].position;
+            const points = value.points.slice().sort((a, b) => +a.position - +b.position);
+            const min = +points[0].position;
+            const max = +points[points.length - 1].position;
             const attrPaths = parseLegacyPath(value.field);
             for (let i = 0; i < attrPaths.length; i++) {
                 const attrPath = attrPaths[i];
@@ -7989,14 +8108,14 @@
                     continue;
                 }
                 if (eValue >= max) {
-                    return { result: exports.Color.ColorFromStr(value.points[value.points.length - 1].color), attrPath, eValue };
+                    return { result: exports.Color.ColorFromStr(points[points.length - 1].color), attrPath, eValue };
                 }
                 else if (eValue <= min) {
-                    return { result: exports.Color.ColorFromStr(value.points[0].color), attrPath, eValue };
+                    return { result: exports.Color.ColorFromStr(points[0].color), attrPath, eValue };
                 }
-                for (let j = 0; j < value.points.length - 1; j++) {
-                    const pointA = value.points[j];
-                    const pointB = value.points[j + 1];
+                for (let j = 0; j < points.length - 1; j++) {
+                    const pointA = points[j];
+                    const pointB = points[j + 1];
                     if (eValue >= pointA.position && eValue <= pointB.position) {
                         if (pointA.position == pointB.position) {
                             return { result: exports.Color.ColorFromStr(pointA.color), attrPath, eValue };
@@ -8018,7 +8137,7 @@
                 }
             }
             // Fallback to min (static, no data path resolved).
-            return { result: exports.Color.ColorFromStr(value.points[0].color), attrPath: null, eValue: null };
+            return { result: exports.Color.ColorFromStr(points[0].color), attrPath: null, eValue: null };
         }
         /**
          * Like Calculate, but also returns an 'effective' key describing how the value
@@ -22459,8 +22578,8 @@
             function ForgotPassword(params) {
                 return __awaiter(this, void 0, void 0, function* () {
                     let { api, accountId, email, req: reqParams } = params;
-                    if (!accountId || !email) {
-                        throw ("Account ID and email are required.");
+                    if (!email) {
+                        throw new Error("An email address is required.");
                     }
                     if (!api) {
                         api = exports.ENVIRONMENT.Api().GetGuardianApi();
@@ -22469,21 +22588,9 @@
                     if (accountId) {
                         url += "?Account=" + accountId;
                     }
-                    const req = api.POST(url, {
+                    yield api.POST(url, {
                         Email: email
                     }, reqParams);
-                    const prom = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
-                        try {
-                            const data = yield req;
-                            res({
-                                userId: data.ID
-                            });
-                        }
-                        catch (e) {
-                            rej(e);
-                        }
-                    }));
-                    return prom;
                 });
             }
             LoginUser.ForgotPassword = ForgotPassword;
@@ -22494,22 +22601,29 @@
              */
             function ForgotPasswordComplete(params) {
                 return __awaiter(this, void 0, void 0, function* () {
-                    let { api, code, userId, password, req: reqParams } = params;
+                    let { api, code, email, userId, password, req: reqParams } = params;
                     if (!api) {
                         api = exports.ENVIRONMENT.Api().GetGuardianApi();
                     }
-                    const { user } = yield Get({
-                        api: api,
-                        userId: userId,
-                        accountId: "",
-                        req: reqParams
-                    });
+                    if (!email && !userId) {
+                        throw new Error("Either an email or a user ID must be provided.");
+                    }
+                    // Callers holding only an ID still need the address resolved, but a caller that already
+                    // knows it should not have to read the user record back to reset a password.
+                    if (!email && userId) {
+                        const { user } = yield Get({
+                            api: api,
+                            userId: userId,
+                            accountId: "",
+                            req: reqParams
+                        });
+                        email = user.Email;
+                    }
                     const res = yield api.POST("v3/userForgotPassword/complete", {
                         ID: userId,
-                        Email: user.Email,
+                        Email: email,
                         ActivationCode: code,
-                        Password: password,
-                        FullName: user.FullName
+                        Password: password
                     }, reqParams);
                     return {
                         user: res
@@ -23156,7 +23270,7 @@
     })(exports.UrlUtils || (exports.UrlUtils = {}));
 
     // This is updated with the package.json version on build.
-    const VERSION = "7.1.95";
+    const VERSION = "7.1.97";
 
     exports.VERSION = VERSION;
     exports.AbstractApi = AbstractApi;