@lifeready/core 1.0.21 → 1.0.22

package/esm2015/lib/tp-password-reset/tp-password-reset.service.js

@@ -0,0 +1,92 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, Injector, NgZone } from '@angular/core';
+import { LrMutation, LrService } from '../api/lr-graphql';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import { TP_PASSWORD_RESET_SLIP39_PASSPHRASE } from './tp-password-reset.constants';
+import { TpPasswordResetAssemblyController } from './tp-password-reset.controller';
+import { CancelTpPasswordResetRequestMutation, CreateTpPasswordResetMutation, DeleteTpPasswordResetMutation, UpdateTpPasswordResetMutation, } from './tp-password-reset.gql';
+import { TpPasswordResetPrivateService } from './tp-password-reset.private.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./tp-password-reset.private.service";
+import * as i2 from "./tp-password-reset.controller";
+let TpPasswordResetService = class TpPasswordResetService extends LrService {
+    constructor(ngZone, injector, privateService, assemblyController) {
+        super(injector);
+        this.ngZone = ngZone;
+        this.injector = injector;
+        this.privateService = privateService;
+        this.assemblyController = assemblyController;
+        this.slip39Passphrase = TP_PASSWORD_RESET_SLIP39_PASSPHRASE;
+    }
+    cancelResetRequest() {
+        return this.mutate(this.cancelResetRequestMutation());
+    }
+    cancelResetRequestMutation() {
+        return new LrMutation({
+            mutation: CancelTpPasswordResetRequestMutation,
+        });
+    }
+    deleteReset() {
+        return this.mutate(this.deleteResetMutation());
+    }
+    deleteResetMutation() {
+        return new LrMutation({
+            mutation: DeleteTpPasswordResetMutation,
+        });
+    }
+    validateApprovers(approvers) {
+        return this.assemblyController.validateApprovers(approvers);
+    }
+    createReset(input) {
+        return this.mutate(this.createResetMutation(input));
+    }
+    createResetMutation(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { mutationInput } = yield this.assemblyController.prepareCreate(input);
+            return new LrMutation({
+                mutation: CreateTpPasswordResetMutation,
+                variables: {
+                    input: {
+                        assembly: Object.assign({}, mutationInput),
+                    },
+                },
+            });
+        });
+    }
+    updateReset(input) {
+        return this.mutate(this.updateResetMutation(input));
+    }
+    updateResetMutation(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const passwordReset = yield this.privateService.getReset();
+            const { mutationInput } = yield this.assemblyController.prepareUpdate(input, passwordReset.assembly);
+            return new LrMutation({
+                mutation: UpdateTpPasswordResetMutation,
+                variables: {
+                    input: {
+                        assembly: Object.assign({}, mutationInput),
+                    },
+                },
+            });
+        });
+    }
+};
+TpPasswordResetService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TpPasswordResetService_Factory() { return new TpPasswordResetService(i0.ɵɵinject(i0.NgZone), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1.TpPasswordResetPrivateService), i0.ɵɵinject(i2.TpPasswordResetAssemblyController)); }, token: TpPasswordResetService, providedIn: "root" });
+TpPasswordResetService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+TpPasswordResetService.ctorParameters = () => [
+    { type: NgZone },
+    { type: Injector },
+    { type: TpPasswordResetPrivateService },
+    { type: TpPasswordResetAssemblyController }
+];
+TpPasswordResetService = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], TpPasswordResetService);
+export { TpPasswordResetService };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/tp-password-reset/tp-password-reset.types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHAtcGFzc3dvcmQtcmVzZXQudHlwZXMuanMiLCJzb3VyY2VSb290IjoiL29wdC9hdGxhc3NpYW4vcGlwZWxpbmVzL2FnZW50L2J1aWxkL3Byb2plY3RzL2NvcmUvc3JjLyIsInNvdXJjZXMiOlsibGliL3RwLXBhc3N3b3JkLXJlc2V0L3RwLXBhc3N3b3JkLXJlc2V0LnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBKU09OT2JqZWN0IH0gZnJvbSAnLi4vYXBpL3R5cGVzJztcbmltcG9ydCB7IEtleSB9IGZyb20gJy4uL2tleS9rZXkudHlwZXMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFRwQXNzZW1ibHlBcHByb3ZlcnMge1xuICBpZDogc3RyaW5nO1xuICB0cDoge1xuICAgIGlkOiBzdHJpbmc7XG4gIH07XG4gIHNoYXJlZEtleTogS2V5O1xuICBzaGFyZWRDaXBoZXJEYXRhPzogc3RyaW5nO1xuICBzaGFyZWRDaXBoZXJEYXRhQ2xlYXJKc29uPzogSlNPTk9iamVjdDtcbiAgc2hhcmVkQ2lwaGVyQXBwcm92YWxEYXRhPzogc3RyaW5nO1xuICBzaGFyZWRDaXBoZXJBcHByb3ZhbERhdGFDbGVhckpzb24/OiBKU09OT2JqZWN0O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFRwU3ViQXNzZW1ibHkge1xuICBpZDogc3RyaW5nO1xuICBzaW5nbGVSZWplY3Q6IGJvb2xlYW47XG4gIHF1b3J1bTogbnVtYmVyO1xuICBzdWJqZWN0Q2lwaGVyRGF0YTogc3RyaW5nO1xuICBwbGFpblN1YmplY3RDaXBoZXJEYXRhOiBhbnk7XG4gIGFwcHJvdmVyczogVHBBc3NlbWJseUFwcHJvdmVyc1tdO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFRwQXNzZW1ibHkge1xuICBzaW5nbGVSZWplY3Q6IGJvb2xlYW47XG4gIHF1b3J1bTogbnVtYmVyO1xuICBzdWJqZWN0S2V5OiBLZXk7XG4gIGFzc2VtYmx5S2V5OiBLZXk7XG4gIGFzc2VtYmx5Q2lwaGVyRGF0YTogc3RyaW5nO1xuICBwbGFpbkFzc2VtYmx5Q2lwaGVyRGF0YTogYW55O1xuICBzdWJBc3NlbWJsaWVzOiBUcFN1YkFzc2VtYmx5W107XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVHBQYXNzd29yZFJlc2V0IHtcbiAgaWQ6IHN0cmluZztcbiAgYXNzZW1ibHk6IFRwQXNzZW1ibHk7XG4gIGFwcGxpZWQ6IGJvb2xlYW47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmVxdWVzdFJlc2V0UmVzdWx0IHtcbiAgaWQ6IHN0cmluZztcbiAgYXNzb2NpYXRlX3Jlc2V0X3VzZXJfdG9rZW46IHN0cmluZztcbiAgcmVzZXRfdXNlcm5hbWU6IHN0cmluZztcbn1cbiJdfQ==

package/esm2015/lib/trusted-party/trusted-party.gql.js

@@ -0,0 +1,148 @@
+import gql from 'graphql-tag';
+import { SharedContactCardFields } from '../shared-contact-card/shared-contact-card.service';
+import { KeyExchangeFields, UserSharedKeyFields, } from '../key-exchange/key-exchange.gql';
+import { KeyGraphField } from '../_common/queries.gql';
+export const TrustedPartyProperties = `
+  id
+  user {
+    id
+    username
+  }
+  other{
+    id
+    username,
+    features {
+      shareVault
+    }
+  }
+  sharedContactCard {
+    ${SharedContactCardFields}
+  }
+  myContactCard {
+    ${SharedContactCardFields}
+  }
+  sharedScenarios {
+    edges {
+      node {
+        id
+      }
+    }
+  }
+  sharedItems {
+    directories {
+      edges {
+        node {
+          id
+        }
+      }
+    }
+  }
+  currentUserSharedKey {
+    userSharedKey {
+      keyExchange {
+        ${KeyExchangeFields}
+      }
+      ${UserSharedKeyFields}
+    }
+  }`;
+export const GetTrustedPartiesQuery = gql `
+query GetTrustedPartiesQuery {
+  tps {
+    edges {
+      node {
+        ${TrustedPartyProperties}
+      }
+    }
+  }
+  ${KeyGraphField}
+}`;
+export const GetAllTrustedPartiesQuery = gql `
+query GetAllTrustedPartiesQuery($userId: ID, $isExpired: Boolean, $inviteState: String, $sentInviteState: String) {
+  tps {
+    edges {
+      node {
+        ${TrustedPartyProperties}
+      }
+    }
+  }
+  invites: keyExchanges(
+    responder: $userId
+    isExpired: $isExpired
+    state: $inviteState
+    orderBy: "state,-created"
+  ) {
+    edges {
+      node {
+        ${KeyExchangeFields}
+      }
+    }
+  }
+  sentInvites: keyExchanges(
+    initiator: $userId
+    isExpired: $isExpired
+    state: $sentInviteState
+    orderBy: "state,-created"
+  ) {
+    edges {
+      node {
+        ${KeyExchangeFields}
+      }
+    }
+  }
+  ${KeyGraphField}
+}`;
+export const GetTrustedPartyQuery = gql `
+query GetTrustedPartyQuery($partyId: LrRelayIdInput!) {
+  tp(id: $partyId) {
+    ${TrustedPartyProperties}
+  }
+  ${KeyGraphField}
+}`;
+export const DeclineTrustedPartyInvitationMutation = gql `
+  mutation DeclineKeyExchange($input: DeclineKeyExchangeInput!) {
+    declineKeyExchange(input: $input) {
+      keyExchange {
+        id
+      }
+    }
+  }
+`;
+export const CancelTrustedPartyInvitationMutation = gql `
+  mutation CancelKeyExchange($input: CancelKeyExchangeInput!) {
+    cancelKeyExchange(input: $input) {
+      keyExchange {
+        id
+      }
+    }
+  }
+`;
+export const DeleteTrustedPartyMutation = gql `
+  mutation DeleteTpMutation($input: DeleteTpInput!) {
+    deleteTp(input: $input) {
+      id
+    }
+  }
+`;
+export const ShareCategoryMutation = gql `
+  mutation ShareDirectory($input: ShareDirectoryInput!) {
+    shareDirectory(input: $input) {
+      tpDirectory {
+        item {
+          plainMeta
+        }
+      }
+    }
+  }
+`;
+export const UnshareCategoryMutation = gql `
+  mutation UnshareDirectory($input: UnshareDirectoryInput!) {
+    unshareDirectory(input: $input) {
+      tpDirectory {
+        item {
+          plainMeta
+        }
+      }
+    }
+  }
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/trusted-party/trusted-party.service.js

@@ -0,0 +1,326 @@
+import { __awaiter } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { SharedContactCardService } from '../shared-contact-card/shared-contact-card.service';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { EncryptionService } from '../encryption/encryption.service';
+import { KeyExchangeService } from '../key-exchange/key-exchange.service';
+import { KeyFactoryService } from '../key/key-factory.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { KeyService } from '../key/key.service';
+import { ContactCardName } from '../profile/profile.types';
+import { UserService } from '../user/user.service';
+import { CancelTrustedPartyInvitationMutation, DeclineTrustedPartyInvitationMutation, DeleteTrustedPartyMutation, GetAllTrustedPartiesQuery, GetTrustedPartiesQuery, GetTrustedPartyQuery, ShareCategoryMutation, UnshareCategoryMutation, } from './trusted-party.gql';
+import { TrustedPartyInviteStatus, TrustedPartyRoleType, TrustedPartyType, } from './trusted-party.types';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../api/lr-apollo.service";
+import * as i3 from "../shared-contact-card/shared-contact-card.service";
+import * as i4 from "../user/user.service";
+import * as i5 from "../auth/life-ready-auth.service";
+import * as i6 from "../key-exchange/key-exchange.service";
+import * as i7 from "../key/key-graph.service";
+import * as i8 from "../key/key.service";
+import * as i9 from "../key/key-factory.service";
+import * as i10 from "../encryption/encryption.service";
+export class TrustedPartyService {
+    constructor(http, lrApollo, sharedContactCardService, userService, authService, keyExchangeService, keyGraphService, keyService, keyFactory, encryptionService) {
+        this.http = http;
+        this.lrApollo = lrApollo;
+        this.sharedContactCardService = sharedContactCardService;
+        this.userService = userService;
+        this.authService = authService;
+        this.keyExchangeService = keyExchangeService;
+        this.keyGraphService = keyGraphService;
+        this.keyService = keyService;
+        this.keyFactory = keyFactory;
+        this.encryptionService = encryptionService;
+    }
+    getTrustedParties() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tps } = yield this.lrApollo.query({
+                query: GetTrustedPartiesQuery,
+            });
+            return yield Promise.all(tps.edges.map((x) => this.mapTrustedParty(x.node)));
+        });
+    }
+    getAllTrustedParties() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const user = yield this.authService.getUser();
+            const { tps, invites, sentInvites } = yield this.lrApollo.query({
+                query: GetAllTrustedPartiesQuery,
+                variables: {
+                    userId: user.id,
+                    isExpired: false,
+                },
+            });
+            return {
+                parties: (yield Promise.all(tps.edges.map((x) => this.mapTrustedParty(x.node)))).filter((x) => x),
+                invites: (yield Promise.all(invites.edges.map((x) => __awaiter(this, void 0, void 0, function* () {
+                    return this.mapInvite(yield this.keyExchangeService.decryptKeyExchange(x.node));
+                }))))
+                    .filter((x) => x.status !== TrustedPartyInviteStatus.Completed)
+                    .filter((x) => x.status !== TrustedPartyInviteStatus.Invited || x.actionRequired),
+                sentInvites: (yield Promise.all(sentInvites.edges.map((x) => __awaiter(this, void 0, void 0, function* () {
+                    return this.mapInvite(yield this.keyExchangeService.decryptKeyExchange(x.node));
+                })))).filter((x) => x.status !== TrustedPartyInviteStatus.Completed),
+            };
+        });
+    }
+    getTrustedParty(partyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tp } = yield this.lrApollo.query({
+                query: GetTrustedPartyQuery,
+                variables: { partyId },
+            });
+            return yield this.mapTrustedParty(tp);
+        });
+    }
+    getTrustedPartyRoles(roleType = TrustedPartyRoleType.General) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.trustedPartyRoles) {
+                this.trustedPartyRoles = yield this.http
+                    .get('/assets/meta/trusted-party-roles.json')
+                    .toPromise();
+            }
+            return Promise.resolve(this.trustedPartyRoles.filter((x) => x.roleType === roleType));
+        });
+    }
+    findByEmail(email) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const user = yield this.userService.getUserByEmail(email);
+                return user
+                    ? {
+                        id: user.id,
+                        email,
+                        username: user.username,
+                        isTrustedParty: user.haveTp,
+                        isMe: user.isCurrentUser,
+                    }
+                    : null;
+            }
+            catch (e) {
+                return null;
+            }
+        });
+    }
+    inviteTrustedParty(invite) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = {
+                responderUsername: invite.party.username,
+                email: invite.party.email,
+                message: {
+                    name: invite.party.name,
+                    email: invite.party.email,
+                    message: invite.party.message,
+                    permissions: invite.permissions,
+                },
+                contactCard: {
+                    plainOwnerCipherDataJson: null,
+                    plainSharedCipherDataJson: invite.mySharedDetails,
+                    ownerPlainData: {
+                        name: new ContactCardName(invite.mySharedDetails.name),
+                    },
+                },
+            };
+            yield this.keyExchangeService.initiateOtk(params);
+        });
+    }
+    cancelInvitation(inviteId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: CancelTrustedPartyInvitationMutation,
+                variables: {
+                    input: {
+                        id: inviteId,
+                    },
+                },
+            });
+        });
+    }
+    getInvitation(inviteId, inviteToken, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exchange = yield this.keyExchangeService.getKeyExchange(inviteId, {
+                token: inviteToken,
+                otKeyK: key,
+            });
+            return this.mapInvite(exchange);
+        });
+    }
+    acceptInvitation(invite) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = {
+                id: invite.inviteId,
+                token: invite.inviteToken,
+                decryptedOtk: invite.decryptedOtk,
+                initiatorContactCard: null,
+                responderContactCard: {
+                    plainOwnerCipherDataJson: null,
+                    plainSharedCipherDataJson: invite.mySharedDetails,
+                    ownerPlainData: {
+                        name: new ContactCardName(invite.mySharedDetails.name),
+                    },
+                },
+            };
+            const { tp } = yield this.keyExchangeService.respondOtk(params);
+            return tp.id;
+        });
+    }
+    declineInvitation(inviteId, inviteToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: DeclineTrustedPartyInvitationMutation,
+                variables: {
+                    input: {
+                        id: inviteId,
+                        token: inviteToken,
+                    },
+                },
+            });
+        });
+    }
+    confirmInvitation(confirm) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { tp } = yield this.keyExchangeService.completeOtk(confirm.inviteId, confirm.initiatorRootKeyCipher, confirm.initiatorOneTimePbkCipher, null);
+            return tp.id;
+        });
+    }
+    removeTrustedParty(partyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: DeleteTrustedPartyMutation,
+                variables: {
+                    input: {
+                        id: partyId,
+                    },
+                },
+            });
+        });
+    }
+    setCategoryAccessLevel(categoryId, keyId, trustedParty, accessLevel) {
+        return accessLevel
+            ? this.shareDirectory(categoryId, keyId, trustedParty, accessLevel)
+            : this.unshareDirectory(categoryId, trustedParty.id);
+    }
+    setRecordAccessLevel(recordId, keyId, trustedParty, accessLevel) {
+        return accessLevel
+            ? this.shareDirectory(recordId, keyId, trustedParty, accessLevel)
+            : this.unshareDirectory(recordId, trustedParty.id);
+    }
+    shareDirectory(directoryId, keyId, trustedParty, accessLevel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = yield this.keyGraphService.getKey(keyId);
+            const wrappingKey = yield this.keyGraphService.getKey(trustedParty.userSharedKey.sharedKey.id);
+            const wrappedKey = yield this.encryptionService.encrypt(wrappingKey.jwk, key.jwk.toJSON(true));
+            yield this.lrApollo.mutate({
+                mutation: ShareCategoryMutation,
+                variables: {
+                    input: {
+                        id: directoryId,
+                        tpId: trustedParty.id,
+                        accessRole: accessLevel,
+                        keyId: key.id,
+                        wrappingKeyId: wrappingKey.id,
+                        wrappedKey: JSON.stringify(wrappedKey),
+                    },
+                },
+            });
+        });
+    }
+    unshareDirectory(directoryId, trustedPartyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.lrApollo.mutate({
+                mutation: UnshareCategoryMutation,
+                variables: {
+                    input: {
+                        id: directoryId,
+                        tpId: trustedPartyId,
+                    },
+                },
+            });
+        });
+    }
+    mapTrustedParty(tp) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const contactCard = tp.sharedContactCard &&
+                    (yield this.sharedContactCardService.decryptTrustedPartyDetails(tp.sharedContactCard));
+                const myContactCard = tp.myContactCard &&
+                    (yield this.sharedContactCardService.decryptSharedTrustedPartyDetails(tp.myContactCard));
+                return {
+                    id: tp.id,
+                    type: TrustedPartyType.User,
+                    hasScenarios: !!tp.sharedScenarios.edges.length,
+                    hasSharedVault: !!tp.sharedItems.directories.edges.length,
+                    name: contactCard && contactCard.name && contactCard.name.name,
+                    details: contactCard,
+                    mySharedDetails: myContactCard,
+                    userSharedKey: tp.currentUserSharedKey.userSharedKey,
+                    username: tp.other.username,
+                    features: {
+                        sharedVault: {
+                            hasAccess: (((_a = tp.other.features) === null || _a === void 0 ? void 0 : _a.shareVault) || ['noaccess'])[0] === 'access',
+                        },
+                    },
+                };
+            }
+            catch (e) {
+                console.error('Failed to decrypt Trusted Party.', e, tp);
+                return null;
+            }
+        });
+    }
+    mapInvite(exchange) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const contactCard = exchange.contactCard;
+            const name = exchange.isInitiator
+                ? (_a = exchange.myMessage) === null || _a === void 0 ? void 0 : _a.name : contactCard && contactCard.name && contactCard.name.name;
+            const email = exchange.isInitiator
+                ? (_b = exchange.myMessage) === null || _b === void 0 ? void 0 : _b.email : (contactCard && contactCard.email) || exchange.responderEmailAddress;
+            return {
+                id: exchange.id,
+                type: TrustedPartyType.User,
+                status: exchange.state,
+                token: exchange.token,
+                tokenExpiry: exchange.tokenExpiryTime,
+                decryptedOtk: exchange.decryptedOtk,
+                name,
+                email,
+                isSender: exchange.isInitiator,
+                actionRequired: exchange.isInitiator
+                    ? exchange.initiatorActionRequired
+                    : exchange.responderActionRequired,
+                rootKeyCipher: exchange.initiatorRootKeyCipher,
+                pbkCipher: exchange.otk.initiatorOneTimePbkCipher,
+                isExpired: exchange.isExpired,
+                details: contactCard,
+                message: exchange.message,
+                mySharedDetails: exchange.myContactCard,
+                mySharedMessage: exchange.myMessage,
+            };
+        });
+    }
+}
+TrustedPartyService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TrustedPartyService_Factory() { return new TrustedPartyService(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.LrApolloService), i0.ɵɵinject(i3.SharedContactCardService), i0.ɵɵinject(i4.UserService), i0.ɵɵinject(i5.LifeReadyAuthService), i0.ɵɵinject(i6.KeyExchangeService), i0.ɵɵinject(i7.KeyGraphService), i0.ɵɵinject(i8.KeyService), i0.ɵɵinject(i9.KeyFactoryService), i0.ɵɵinject(i10.EncryptionService)); }, token: TrustedPartyService, providedIn: "root" });
+TrustedPartyService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+TrustedPartyService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: LrApolloService },
+    { type: SharedContactCardService },
+    { type: UserService },
+    { type: LifeReadyAuthService },
+    { type: KeyExchangeService },
+    { type: KeyGraphService },
+    { type: KeyService },
+    { type: KeyFactoryService },
+    { type: EncryptionService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trusted-party.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/trusted-party/trusted-party.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { LrApolloService } from '../api/lr-apollo.service';\nimport { SharedContactCardService } from '../shared-contact-card/shared-contact-card.service';\nimport { LifeReadyAuthService } from '../auth/life-ready-auth.service';\nimport { AccessLevel } from '../category/category.types';\nimport { EncryptionService } from '../encryption/encryption.service';\nimport { KeyExchangeService } from '../key-exchange/key-exchange.service';\nimport {\n  DecryptedKeyExchange,\n  RespondOtkInput,\n} from '../key-exchange/key-exchange.types';\nimport { KeyFactoryService } from '../key/key-factory.service';\nimport { KeyGraphService } from '../key/key-graph.service';\nimport { KeyService } from '../key/key.service';\nimport { ContactCardName } from '../profile/profile.types';\nimport { UserService } from '../user/user.service';\nimport {\n  CancelTrustedPartyInvitationMutation,\n  DeclineTrustedPartyInvitationMutation,\n  DeleteTrustedPartyMutation,\n  GetAllTrustedPartiesQuery,\n  GetTrustedPartiesQuery,\n  GetTrustedPartyQuery,\n  ShareCategoryMutation,\n  UnshareCategoryMutation,\n} from './trusted-party.gql';\nimport {\n  AcceptTrustedPartyInvite,\n  ConfirmTrustedPartyInvite,\n  FoundTrustedParty,\n  InviteTrustedParty,\n  TrustedParties,\n  TrustedParty,\n  TrustedPartyInvite,\n  TrustedPartyInviteStatus,\n  TrustedPartyRole,\n  TrustedPartyRoleType,\n  TrustedPartyType,\n} from './trusted-party.types';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class TrustedPartyService {\n  private trustedPartyRoles: TrustedPartyRole[];\n\n  constructor(\n    private http: HttpClient,\n    private lrApollo: LrApolloService,\n    private sharedContactCardService: SharedContactCardService,\n    private userService: UserService,\n    private authService: LifeReadyAuthService,\n    private keyExchangeService: KeyExchangeService,\n    private keyGraphService: KeyGraphService,\n    private keyService: KeyService,\n    private keyFactory: KeyFactoryService,\n    private encryptionService: EncryptionService\n  ) {}\n\n  public async getTrustedParties(): Promise<TrustedParty[]> {\n    const { tps } = await this.lrApollo.query<any>({\n      query: GetTrustedPartiesQuery,\n    });\n    return await Promise.all(\n      tps.edges.map((x) => this.mapTrustedParty(x.node))\n    );\n  }\n\n  public async getAllTrustedParties(): Promise<TrustedParties> {\n    const user = await this.authService.getUser();\n    const { tps, invites, sentInvites } = await this.lrApollo.query<any>({\n      query: GetAllTrustedPartiesQuery,\n      variables: {\n        userId: user.id,\n        isExpired: false,\n      },\n    });\n\n    return {\n      parties: (\n        await Promise.all<TrustedParty>(\n          tps.edges.map((x) => this.mapTrustedParty(x.node))\n        )\n      ).filter((x) => x),\n      invites: (\n        await Promise.all<TrustedPartyInvite>(\n          invites.edges.map(async (x) =>\n            this.mapInvite(\n              await this.keyExchangeService.decryptKeyExchange(x.node)\n            )\n          )\n        )\n      )\n        .filter((x) => x.status !== TrustedPartyInviteStatus.Completed)\n        .filter(\n          (x) =>\n            x.status !== TrustedPartyInviteStatus.Invited || x.actionRequired\n        ),\n      sentInvites: (\n        await Promise.all<TrustedPartyInvite>(\n          sentInvites.edges.map(async (x) =>\n            this.mapInvite(\n              await this.keyExchangeService.decryptKeyExchange(x.node)\n            )\n          )\n        )\n      ).filter((x) => x.status !== TrustedPartyInviteStatus.Completed),\n    };\n  }\n\n  public async getTrustedParty(partyId: string): Promise<TrustedParty> {\n    const { tp } = await this.lrApollo.query<any>({\n      query: GetTrustedPartyQuery,\n      variables: { partyId },\n    });\n    return await this.mapTrustedParty(tp);\n  }\n\n  public async getTrustedPartyRoles(\n    roleType: TrustedPartyRoleType = TrustedPartyRoleType.General\n  ): Promise<TrustedPartyRole[]> {\n    if (!this.trustedPartyRoles) {\n      this.trustedPartyRoles = await this.http\n        .get<TrustedPartyRole[]>('/assets/meta/trusted-party-roles.json')\n        .toPromise();\n    }\n    return Promise.resolve(\n      this.trustedPartyRoles.filter((x) => x.roleType === roleType)\n    );\n  }\n\n  public async findByEmail(email: string): Promise<FoundTrustedParty> {\n    try {\n      const user = await this.userService.getUserByEmail(email);\n\n      return user\n        ? {\n            id: user.id,\n            email,\n            username: user.username,\n            isTrustedParty: user.haveTp,\n            isMe: user.isCurrentUser,\n          }\n        : null;\n    } catch (e) {\n      return null;\n    }\n  }\n\n  public async inviteTrustedParty(invite: InviteTrustedParty): Promise<void> {\n    const params = {\n      responderUsername: invite.party.username,\n      email: invite.party.email,\n      message: {\n        name: invite.party.name,\n        email: invite.party.email,\n        message: invite.party.message,\n        permissions: invite.permissions,\n      },\n      contactCard: {\n        plainOwnerCipherDataJson: null,\n        plainSharedCipherDataJson: invite.mySharedDetails,\n        ownerPlainData: {\n          name: new ContactCardName(invite.mySharedDetails.name),\n        },\n      },\n    };\n    await this.keyExchangeService.initiateOtk(params);\n  }\n\n  public async cancelInvitation(inviteId: string): Promise<void> {\n    await this.lrApollo.mutate({\n      mutation: CancelTrustedPartyInvitationMutation,\n      variables: {\n        input: {\n          id: inviteId,\n        },\n      },\n    });\n  }\n\n  public async getInvitation(\n    inviteId: string,\n    inviteToken: string,\n    key: string\n  ): Promise<TrustedPartyInvite> {\n    const exchange = await this.keyExchangeService.getKeyExchange(inviteId, {\n      token: inviteToken,\n      otKeyK: key,\n    });\n\n    return this.mapInvite(exchange);\n  }\n\n  public async acceptInvitation(\n    invite: AcceptTrustedPartyInvite\n  ): Promise<string> {\n    const params: RespondOtkInput = {\n      id: invite.inviteId,\n      token: invite.inviteToken,\n      decryptedOtk: invite.decryptedOtk,\n      initiatorContactCard: null,\n      responderContactCard: {\n        plainOwnerCipherDataJson: null,\n        plainSharedCipherDataJson: invite.mySharedDetails,\n        ownerPlainData: {\n          name: new ContactCardName(invite.mySharedDetails.name),\n        },\n      },\n    };\n\n    const { tp } = await this.keyExchangeService.respondOtk(params);\n\n    return tp.id;\n  }\n\n  public async declineInvitation(\n    inviteId: string,\n    inviteToken: string\n  ): Promise<void> {\n    await this.lrApollo.mutate({\n      mutation: DeclineTrustedPartyInvitationMutation,\n      variables: {\n        input: {\n          id: inviteId,\n          token: inviteToken,\n        },\n      },\n    });\n  }\n\n  public async confirmInvitation(\n    confirm: ConfirmTrustedPartyInvite\n  ): Promise<string> {\n    const { tp } = await this.keyExchangeService.completeOtk(\n      confirm.inviteId,\n      confirm.initiatorRootKeyCipher,\n      confirm.initiatorOneTimePbkCipher,\n      null\n    );\n    return tp.id;\n  }\n\n  public async removeTrustedParty(partyId: string): Promise<void> {\n    await this.lrApollo.mutate({\n      mutation: DeleteTrustedPartyMutation,\n      variables: {\n        input: {\n          id: partyId,\n        },\n      },\n    });\n  }\n\n  public setCategoryAccessLevel(\n    categoryId: string,\n    keyId: string,\n    trustedParty: TrustedParty,\n    accessLevel?: AccessLevel\n  ): Promise<void> {\n    return accessLevel\n      ? this.shareDirectory(categoryId, keyId, trustedParty, accessLevel)\n      : this.unshareDirectory(categoryId, trustedParty.id);\n  }\n\n  public setRecordAccessLevel(\n    recordId: string,\n    keyId: string,\n    trustedParty: TrustedParty,\n    accessLevel: AccessLevel\n  ): Promise<void> {\n    return accessLevel\n      ? this.shareDirectory(recordId, keyId, trustedParty, accessLevel)\n      : this.unshareDirectory(recordId, trustedParty.id);\n  }\n\n  private async shareDirectory(\n    directoryId: string,\n    keyId: string,\n    trustedParty: TrustedParty,\n    accessLevel: AccessLevel\n  ): Promise<void> {\n    const key = await this.keyGraphService.getKey(keyId);\n    const wrappingKey = await this.keyGraphService.getKey(\n      trustedParty.userSharedKey.sharedKey.id\n    );\n    const wrappedKey = await this.encryptionService.encrypt(\n      wrappingKey.jwk,\n      key.jwk.toJSON(true)\n    );\n\n    await this.lrApollo.mutate({\n      mutation: ShareCategoryMutation,\n      variables: {\n        input: {\n          id: directoryId,\n          tpId: trustedParty.id,\n          accessRole: accessLevel,\n          keyId: key.id,\n          wrappingKeyId: wrappingKey.id,\n          wrappedKey: JSON.stringify(wrappedKey),\n        },\n      },\n    });\n  }\n\n  private async unshareDirectory(\n    directoryId: string,\n    trustedPartyId: string\n  ): Promise<void> {\n    await this.lrApollo.mutate({\n      mutation: UnshareCategoryMutation,\n      variables: {\n        input: {\n          id: directoryId,\n          tpId: trustedPartyId,\n        },\n      },\n    });\n  }\n\n  public async mapTrustedParty(tp: any): Promise<TrustedParty> {\n    try {\n      const contactCard =\n        tp.sharedContactCard &&\n        (await this.sharedContactCardService.decryptTrustedPartyDetails(\n          tp.sharedContactCard\n        ));\n      const myContactCard =\n        tp.myContactCard &&\n        (await this.sharedContactCardService.decryptSharedTrustedPartyDetails(\n          tp.myContactCard\n        ));\n\n      return {\n        id: tp.id,\n        type: TrustedPartyType.User, // TODO: when partners\n        hasScenarios: !!tp.sharedScenarios.edges.length,\n        hasSharedVault: !!tp.sharedItems.directories.edges.length,\n        name: contactCard && contactCard.name && contactCard.name.name,\n        details: contactCard,\n        mySharedDetails: myContactCard,\n        userSharedKey: tp.currentUserSharedKey.userSharedKey,\n        username: tp.other.username,\n        features: {\n          sharedVault: {\n            hasAccess:\n              (tp.other.features?.shareVault || ['noaccess'])[0] === 'access',\n          },\n        },\n      };\n    } catch (e) {\n      console.error('Failed to decrypt Trusted Party.', e, tp);\n      return null;\n    }\n  }\n\n  private async mapInvite(\n    exchange: DecryptedKeyExchange\n  ): Promise<TrustedPartyInvite> {\n    const contactCard = exchange.contactCard;\n    const name = exchange.isInitiator\n      ? exchange.myMessage?.name\n      : contactCard && contactCard.name && contactCard.name.name;\n    const email = exchange.isInitiator\n      ? exchange.myMessage?.email\n      : (contactCard && contactCard.email) || exchange.responderEmailAddress;\n\n    return {\n      id: exchange.id,\n      type: TrustedPartyType.User, // todo when partners\n      status: exchange.state as unknown as TrustedPartyInviteStatus,\n      token: exchange.token,\n      tokenExpiry: exchange.tokenExpiryTime,\n      decryptedOtk: exchange.decryptedOtk,\n      name,\n      email,\n      isSender: exchange.isInitiator,\n      actionRequired: exchange.isInitiator\n        ? exchange.initiatorActionRequired\n        : exchange.responderActionRequired,\n      rootKeyCipher: exchange.initiatorRootKeyCipher,\n      pbkCipher: exchange.otk.initiatorOneTimePbkCipher,\n      isExpired: exchange.isExpired,\n      details: contactCard,\n      message: exchange.message,\n      mySharedDetails: exchange.myContactCard,\n      mySharedMessage: exchange.myMessage,\n    };\n  }\n}\n"]}