@lifeready/core 1.0.21 → 1.0.23

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,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHAtcGFzc3dvcmQtcmVzZXQudHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlL3NyYy9saWIvdHAtcGFzc3dvcmQtcmVzZXQvdHAtcGFzc3dvcmQtcmVzZXQudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEpTT05PYmplY3QgfSBmcm9tICcuLi9hcGkvdHlwZXMnO1xuaW1wb3J0IHsgS2V5IH0gZnJvbSAnLi4va2V5L2tleS50eXBlcyc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgVHBBc3NlbWJseUFwcHJvdmVycyB7XG4gIGlkOiBzdHJpbmc7XG4gIHRwOiB7XG4gICAgaWQ6IHN0cmluZztcbiAgfTtcbiAgc2hhcmVkS2V5OiBLZXk7XG4gIHNoYXJlZENpcGhlckRhdGE/OiBzdHJpbmc7XG4gIHNoYXJlZENpcGhlckRhdGFDbGVhckpzb24/OiBKU09OT2JqZWN0O1xuICBzaGFyZWRDaXBoZXJBcHByb3ZhbERhdGE/OiBzdHJpbmc7XG4gIHNoYXJlZENpcGhlckFwcHJvdmFsRGF0YUNsZWFySnNvbj86IEpTT05PYmplY3Q7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVHBTdWJBc3NlbWJseSB7XG4gIGlkOiBzdHJpbmc7XG4gIHNpbmdsZVJlamVjdDogYm9vbGVhbjtcbiAgcXVvcnVtOiBudW1iZXI7XG4gIHN1YmplY3RDaXBoZXJEYXRhOiBzdHJpbmc7XG4gIHBsYWluU3ViamVjdENpcGhlckRhdGE6IEpTT05PYmplY3Q7XG4gIGFwcHJvdmVyczogVHBBc3NlbWJseUFwcHJvdmVyc1tdO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFRwQXNzZW1ibHkge1xuICBzaW5nbGVSZWplY3Q6IGJvb2xlYW47XG4gIHF1b3J1bTogbnVtYmVyO1xuICBzdWJqZWN0S2V5OiBLZXk7XG4gIGFzc2VtYmx5S2V5OiBLZXk7XG4gIGFzc2VtYmx5Q2lwaGVyRGF0YTogc3RyaW5nO1xuICBwbGFpbkFzc2VtYmx5Q2lwaGVyRGF0YTogSlNPTk9iamVjdDtcbiAgc3ViQXNzZW1ibGllczogVHBTdWJBc3NlbWJseVtdO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFRwUGFzc3dvcmRSZXNldCB7XG4gIGlkOiBzdHJpbmc7XG4gIGFzc2VtYmx5OiBUcEFzc2VtYmx5O1xuICBhcHBsaWVkOiBib29sZWFuO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFJlcXVlc3RSZXNldFJlc3VsdCB7XG4gIGlkOiBzdHJpbmc7XG4gIGFzc29jaWF0ZV9yZXNldF91c2VyX3Rva2VuOiBzdHJpbmc7XG4gIHJlc2V0X3VzZXJuYW1lOiBzdHJpbmc7XG59XG4iXX0=

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,327 @@
+import { __awaiter } from "tslib";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { LrApolloService } from '../api/lr-apollo.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 { SharedContactCardService } from '../shared-contact-card/shared-contact-card.service';
+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":"","sources":["../../../../../../projects/core/src/lib/trusted-party/trusted-party.service.ts"],"names":[],"mappings":";AAAA,uDAAuD;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAEvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAK1E,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,wBAAwB,EAAE,MAAM,oDAAoD,CAAC;AAC9F,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EACL,oCAAoC,EACpC,qCAAqC,EACrC,0BAA0B,EAC1B,yBAAyB,EACzB,sBAAsB,EACtB,oBAAoB,EACpB,qBAAqB,EACrB,uBAAuB,GACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAQL,wBAAwB,EAExB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,uBAAuB,CAAC;;;;;;;;;;;;AAK/B,MAAM,OAAO,mBAAmB;IAG9B,YACU,IAAgB,EAChB,QAAyB,EACzB,wBAAkD,EAClD,WAAwB,EACxB,WAAiC,EACjC,kBAAsC,EACtC,eAAgC,EAChC,UAAsB,EACtB,UAA6B,EAC7B,iBAAoC;QATpC,SAAI,GAAJ,IAAI,CAAY;QAChB,aAAQ,GAAR,QAAQ,CAAiB;QACzB,6BAAwB,GAAxB,wBAAwB,CAA0B;QAClD,gBAAW,GAAX,WAAW,CAAa;QACxB,gBAAW,GAAX,WAAW,CAAsB;QACjC,uBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,oBAAe,GAAf,eAAe,CAAiB;QAChC,eAAU,GAAV,UAAU,CAAY;QACtB,eAAU,GAAV,UAAU,CAAmB;QAC7B,sBAAiB,GAAjB,iBAAiB,CAAmB;IAC3C,CAAC;IAES,iBAAiB;;YAC5B,MAAM,EAAE,GAAG,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAM;gBAC7C,KAAK,EAAE,sBAAsB;aAC9B,CAAC,CAAC;YACH,OAAO,MAAM,OAAO,CAAC,GAAG,CACtB,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CACnD,CAAC;QACJ,CAAC;KAAA;IAEY,oBAAoB;;YAC/B,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;YAC9C,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAM;gBACnE,KAAK,EAAE,yBAAyB;gBAChC,SAAS,EAAE;oBACT,MAAM,EAAE,IAAI,CAAC,EAAE;oBACf,SAAS,EAAE,KAAK;iBACjB;aACF,CAAC,CAAC;YAEH,OAAO;gBACL,OAAO,EAAE,CACP,MAAM,OAAO,CAAC,GAAG,CACf,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CACnD,CACF,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;gBAClB,OAAO,EAAE,CACP,MAAM,OAAO,CAAC,GAAG,CACf,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAO,CAAC,EAAE,EAAE;oBAC5B,OAAA,IAAI,CAAC,SAAS,CACZ,MAAM,IAAI,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,CACzD,CAAA;kBAAA,CACF,CACF,CACF;qBACE,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,wBAAwB,CAAC,SAAS,CAAC;qBAC9D,MAAM,CACL,CAAC,CAAC,EAAE,EAAE,CACJ,CAAC,CAAC,MAAM,KAAK,wBAAwB,CAAC,OAAO,IAAI,CAAC,CAAC,cAAc,CACpE;gBACH,WAAW,EAAE,CACX,MAAM,OAAO,CAAC,GAAG,CACf,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAO,CAAC,EAAE,EAAE;oBAChC,OAAA,IAAI,CAAC,SAAS,CACZ,MAAM,IAAI,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,CACzD,CAAA;kBAAA,CACF,CACF,CACF,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,wBAAwB,CAAC,SAAS,CAAC;aACjE,CAAC;QACJ,CAAC;KAAA;IAEY,eAAe,CAAC,OAAe;;YAC1C,MAAM,EAAE,EAAE,EAAE,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAM;gBAC5C,KAAK,EAAE,oBAAoB;gBAC3B,SAAS,EAAE,EAAE,OAAO,EAAE;aACvB,CAAC,CAAC;YACH,OAAO,MAAM,IAAI,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC;QACxC,CAAC;KAAA;IAEY,oBAAoB,CAC/B,WAAiC,oBAAoB,CAAC,OAAO;;YAE7D,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE;gBAC3B,IAAI,CAAC,iBAAiB,GAAG,MAAM,IAAI,CAAC,IAAI;qBACrC,GAAG,CAAqB,uCAAuC,CAAC;qBAChE,SAAS,EAAE,CAAC;aAChB;YACD,OAAO,OAAO,CAAC,OAAO,CACpB,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAC9D,CAAC;QACJ,CAAC;KAAA;IAEY,WAAW,CAAC,KAAa;;YACpC,IAAI;gBACF,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;gBAE1D,OAAO,IAAI;oBACT,CAAC,CAAC;wBACE,EAAE,EAAE,IAAI,CAAC,EAAE;wBACX,KAAK;wBACL,QAAQ,EAAE,IAAI,CAAC,QAAQ;wBACvB,cAAc,EAAE,IAAI,CAAC,MAAM;wBAC3B,IAAI,EAAE,IAAI,CAAC,aAAa;qBACzB;oBACH,CAAC,CAAC,IAAI,CAAC;aACV;YAAC,OAAO,CAAC,EAAE;gBACV,OAAO,IAAI,CAAC;aACb;QACH,CAAC;KAAA;IAEY,kBAAkB,CAAC,MAA0B;;YACxD,MAAM,MAAM,GAAG;gBACb,iBAAiB,EAAE,MAAM,CAAC,KAAK,CAAC,QAAQ;gBACxC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK;gBACzB,OAAO,EAAE;oBACP,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,IAAI;oBACvB,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK;oBACzB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO;oBAC7B,WAAW,EAAE,MAAM,CAAC,WAAW;iBAChC;gBACD,WAAW,EAAE;oBACX,wBAAwB,EAAE,IAAI;oBAC9B,yBAAyB,EAAE,MAAM,CAAC,eAAe;oBACjD,cAAc,EAAE;wBACd,IAAI,EAAE,IAAI,eAAe,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC;qBACvD;iBACF;aACF,CAAC;YACF,MAAM,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QACpD,CAAC;KAAA;IAEY,gBAAgB,CAAC,QAAgB;;YAC5C,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;gBACzB,QAAQ,EAAE,oCAAoC;gBAC9C,SAAS,EAAE;oBACT,KAAK,EAAE;wBACL,EAAE,EAAE,QAAQ;qBACb;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAEY,aAAa,CACxB,QAAgB,EAChB,WAAmB,EACnB,GAAW;;YAEX,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,cAAc,CAAC,QAAQ,EAAE;gBACtE,KAAK,EAAE,WAAW;gBAClB,MAAM,EAAE,GAAG;aACZ,CAAC,CAAC;YAEH,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;QAClC,CAAC;KAAA;IAEY,gBAAgB,CAC3B,MAAgC;;YAEhC,MAAM,MAAM,GAAoB;gBAC9B,EAAE,EAAE,MAAM,CAAC,QAAQ;gBACnB,KAAK,EAAE,MAAM,CAAC,WAAW;gBACzB,YAAY,EAAE,MAAM,CAAC,YAAY;gBACjC,oBAAoB,EAAE,IAAI;gBAC1B,oBAAoB,EAAE;oBACpB,wBAAwB,EAAE,IAAI;oBAC9B,yBAAyB,EAAE,MAAM,CAAC,eAAe;oBACjD,cAAc,EAAE;wBACd,IAAI,EAAE,IAAI,eAAe,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC;qBACvD;iBACF;aACF,CAAC;YAEF,MAAM,EAAE,EAAE,EAAE,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;YAEhE,OAAO,EAAE,CAAC,EAAE,CAAC;QACf,CAAC;KAAA;IAEY,iBAAiB,CAC5B,QAAgB,EAChB,WAAmB;;YAEnB,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;gBACzB,QAAQ,EAAE,qCAAqC;gBAC/C,SAAS,EAAE;oBACT,KAAK,EAAE;wBACL,EAAE,EAAE,QAAQ;wBACZ,KAAK,EAAE,WAAW;qBACnB;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAEY,iBAAiB,CAC5B,OAAkC;;YAElC,MAAM,EAAE,EAAE,EAAE,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,WAAW,CACtD,OAAO,CAAC,QAAQ,EAChB,OAAO,CAAC,sBAAsB,EAC9B,OAAO,CAAC,yBAAyB,EACjC,IAAI,CACL,CAAC;YACF,OAAO,EAAE,CAAC,EAAE,CAAC;QACf,CAAC;KAAA;IAEY,kBAAkB,CAAC,OAAe;;YAC7C,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;gBACzB,QAAQ,EAAE,0BAA0B;gBACpC,SAAS,EAAE;oBACT,KAAK,EAAE;wBACL,EAAE,EAAE,OAAO;qBACZ;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAEM,sBAAsB,CAC3B,UAAkB,EAClB,KAAa,EACb,YAA0B,EAC1B,WAAyB;QAEzB,OAAO,WAAW;YAChB,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,UAAU,EAAE,KAAK,EAAE,YAAY,EAAE,WAAW,CAAC;YACnE,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,UAAU,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IACzD,CAAC;IAEM,oBAAoB,CACzB,QAAgB,EAChB,KAAa,EACb,YAA0B,EAC1B,WAAwB;QAExB,OAAO,WAAW;YAChB,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,KAAK,EAAE,YAAY,EAAE,WAAW,CAAC;YACjE,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC;IACvD,CAAC;IAEa,cAAc,CAC1B,WAAmB,EACnB,KAAa,EACb,YAA0B,EAC1B,WAAwB;;YAExB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YACrD,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CACnD,YAAY,CAAC,aAAa,CAAC,SAAS,CAAC,EAAE,CACxC,CAAC;YACF,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CACrD,WAAW,CAAC,GAAG,EACf,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CACrB,CAAC;YAEF,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;gBACzB,QAAQ,EAAE,qBAAqB;gBAC/B,SAAS,EAAE;oBACT,KAAK,EAAE;wBACL,EAAE,EAAE,WAAW;wBACf,IAAI,EAAE,YAAY,CAAC,EAAE;wBACrB,UAAU,EAAE,WAAW;wBACvB,KAAK,EAAE,GAAG,CAAC,EAAE;wBACb,aAAa,EAAE,WAAW,CAAC,EAAE;wBAC7B,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;qBACvC;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAEa,gBAAgB,CAC5B,WAAmB,EACnB,cAAsB;;YAEtB,MAAM,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC;gBACzB,QAAQ,EAAE,uBAAuB;gBACjC,SAAS,EAAE;oBACT,KAAK,EAAE;wBACL,EAAE,EAAE,WAAW;wBACf,IAAI,EAAE,cAAc;qBACrB;iBACF;aACF,CAAC,CAAC;QACL,CAAC;KAAA;IAEY,eAAe,CAAC,EAAO;;;YAClC,IAAI;gBACF,MAAM,WAAW,GACf,EAAE,CAAC,iBAAiB;oBACpB,CAAC,MAAM,IAAI,CAAC,wBAAwB,CAAC,0BAA0B,CAC7D,EAAE,CAAC,iBAAiB,CACrB,CAAC,CAAC;gBACL,MAAM,aAAa,GACjB,EAAE,CAAC,aAAa;oBAChB,CAAC,MAAM,IAAI,CAAC,wBAAwB,CAAC,gCAAgC,CACnE,EAAE,CAAC,aAAa,CACjB,CAAC,CAAC;gBAEL,OAAO;oBACL,EAAE,EAAE,EAAE,CAAC,EAAE;oBACT,IAAI,EAAE,gBAAgB,CAAC,IAAI;oBAC3B,YAAY,EAAE,CAAC,CAAC,EAAE,CAAC,eAAe,CAAC,KAAK,CAAC,MAAM;oBAC/C,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,WAAW,CAAC,WAAW,CAAC,KAAK,CAAC,MAAM;oBACzD,IAAI,EAAE,WAAW,IAAI,WAAW,CAAC,IAAI,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI;oBAC9D,OAAO,EAAE,WAAW;oBACpB,eAAe,EAAE,aAAa;oBAC9B,aAAa,EAAE,EAAE,CAAC,oBAAoB,CAAC,aAAa;oBACpD,QAAQ,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ;oBAC3B,QAAQ,EAAE;wBACR,WAAW,EAAE;4BACX,SAAS,EACP,CAAC,OAAA,EAAE,CAAC,KAAK,CAAC,QAAQ,0CAAE,UAAU,KAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,QAAQ;yBAClE;qBACF;iBACF,CAAC;aACH;YAAC,OAAO,CAAC,EAAE;gBACV,OAAO,CAAC,KAAK,CAAC,kCAAkC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;gBACzD,OAAO,IAAI,CAAC;aACb;;KACF;IAEa,SAAS,CACrB,QAA8B;;;YAE9B,MAAM,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC;YACzC,MAAM,IAAI,GAAG,QAAQ,CAAC,WAAW;gBAC/B,CAAC,OAAC,QAAQ,CAAC,SAAS,0CAAE,IAAI,CAC1B,CAAC,CAAC,WAAW,IAAI,WAAW,CAAC,IAAI,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC;YAC7D,MAAM,KAAK,GAAG,QAAQ,CAAC,WAAW;gBAChC,CAAC,OAAC,QAAQ,CAAC,SAAS,0CAAE,KAAK,CAC3B,CAAC,CAAC,CAAC,WAAW,IAAI,WAAW,CAAC,KAAK,CAAC,IAAI,QAAQ,CAAC,qBAAqB,CAAC;YAEzE,OAAO;gBACL,EAAE,EAAE,QAAQ,CAAC,EAAE;gBACf,IAAI,EAAE,gBAAgB,CAAC,IAAI;gBAC3B,MAAM,EAAE,QAAQ,CAAC,KAA4C;gBAC7D,KAAK,EAAE,QAAQ,CAAC,KAAK;gBACrB,WAAW,EAAE,QAAQ,CAAC,eAAe;gBACrC,YAAY,EAAE,QAAQ,CAAC,YAAY;gBACnC,IAAI;gBACJ,KAAK;gBACL,QAAQ,EAAE,QAAQ,CAAC,WAAW;gBAC9B,cAAc,EAAE,QAAQ,CAAC,WAAW;oBAClC,CAAC,CAAC,QAAQ,CAAC,uBAAuB;oBAClC,CAAC,CAAC,QAAQ,CAAC,uBAAuB;gBACpC,aAAa,EAAE,QAAQ,CAAC,sBAAsB;gBAC9C,SAAS,EAAE,QAAQ,CAAC,GAAG,CAAC,yBAAyB;gBACjD,SAAS,EAAE,QAAQ,CAAC,SAAS;gBAC7B,OAAO,EAAE,WAAW;gBACpB,OAAO,EAAE,QAAQ,CAAC,OAAO;gBACzB,eAAe,EAAE,QAAQ,CAAC,aAAa;gBACvC,eAAe,EAAE,QAAQ,CAAC,SAAS;aACpC,CAAC;;KACH;;;;YA7VF,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;YA3CQ,UAAU;YAEV,eAAe;YAaf,wBAAwB;YACxB,WAAW;YAbX,oBAAoB;YAGpB,kBAAkB;YAMlB,eAAe;YACf,UAAU;YAFV,iBAAiB;YANjB,iBAAiB","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { HttpClient } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { LrApolloService } from '../api/lr-apollo.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 { SharedContactCardService } from '../shared-contact-card/shared-contact-card.service';\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"]}