@lifeready/core 0.6.0-beta.1

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

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

package/esm2015/lib/trusted-parties/trusted-party.types.js

@@ -0,0 +1,41 @@
+import { TrustedPartyDetails } from './../users/profile.types';
+export class TrustedPartyRole {
+}
+export var TrustedPartyRoleType;
+(function (TrustedPartyRoleType) {
+    TrustedPartyRoleType["General"] = "general";
+    TrustedPartyRoleType["Scenario"] = "scenario";
+})(TrustedPartyRoleType || (TrustedPartyRoleType = {}));
+export var TrustedPartyType;
+(function (TrustedPartyType) {
+    TrustedPartyType["User"] = "user";
+    TrustedPartyType["Organisation"] = "organisation";
+})(TrustedPartyType || (TrustedPartyType = {}));
+export var TrustedPartyInviteStatus;
+(function (TrustedPartyInviteStatus) {
+    TrustedPartyInviteStatus["Invited"] = "IN_PROGRESS";
+    TrustedPartyInviteStatus["Cancelled"] = "CANCELLED";
+    TrustedPartyInviteStatus["Declined"] = "DECLINED";
+    TrustedPartyInviteStatus["Completed"] = "COMPLETED";
+})(TrustedPartyInviteStatus || (TrustedPartyInviteStatus = {}));
+export class TrustedParties {
+}
+export class SharedTrustedPartyDetails extends TrustedPartyDetails {
+}
+export class TrustedPartyInvite {
+}
+export class TPFeatures {
+}
+export class SharedVaultFeature {
+}
+export class TrustedParty {
+}
+export class FoundTrustedParty {
+}
+export class InviteTrustedParty {
+}
+export class AcceptTrustedPartyInvite {
+}
+export class ConfirmTrustedPartyInvite {
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/trusted-parties/trusted-party2.gql.js

@@ -0,0 +1,87 @@
+import { gqlTyped } from '../_common/ast';
+export const DeleteTpMutation = gqlTyped `
+mutation DeleteTpMutation($input: DeleteTpInput!) {
+  deleteTp(input: $input) {
+    id
+  }
+}
+`;
+export const ShareDirectoryMutation = gqlTyped `
+  mutation ShareDirectoryMutation($input: ShareDirectoryInput!) {
+    shareDirectory(input: $input) {
+      tpDirectory {
+        id
+      }
+    }
+  }
+`;
+export const UnshareDirectoryMutation = gqlTyped `
+  mutation UnshareDirectoryMutation($input: UnshareDirectoryInput!) {
+    unshareDirectory(input: $input) {
+      tpDirectory {
+        id
+      }
+    }
+  }
+`;
+export const ShareFileMutation = gqlTyped `
+  mutation ShareFileMutation($input: ShareFileInput!) {
+    shareFile(input: $input) {
+      tpFile {
+        id
+      }
+    }
+  }
+`;
+export const UnshareFileMutation = gqlTyped `
+  mutation UnshareFileMutation($input: UnshareFileInput!) {
+    unshareFile(input: $input) {
+      tpFile {
+        id
+      }
+    }
+  }
+`;
+export const TpCurrentUserSharedKeyQuery = gqlTyped `
+query TpCurrentUserSharedKeyQuery($id: LrRelayIdInput!) {
+  tp(id: $id){
+    currentUserSharedKey {
+      userSharedKey {
+        sharedKey {
+          id
+        }
+        mkSharedKey {
+          id
+        }
+        mkPxk {
+          id
+        }
+        mkReshareRequestCipher
+        mkReshareRequestSent
+        mkReshareResponseCipher
+        mkReshareResponseSent
+      }
+    }
+  }
+}
+`;
+export const RequestTpMkReshareMutation = gqlTyped `
+mutation RequestTpMkReshareMutation($input: RequestTpMkReshareInput!) {
+  requestTpMkReshare(input: $input) {
+    id
+  }
+}`;
+export const RespondTpMkReshareMutation = gqlTyped `
+  mutation RespondTpMkReshareMutation($input: RespondTpMkReshareInput!) {
+    respondTpMkReshare(input: $input) {
+      id
+    }
+  }
+`;
+export const CompleteTpMkReshareMutation = gqlTyped `
+mutation CompleteTpMkReshareMutation($input: CompleteTpMkReshareInput!) {
+  completeTpMkReshare(input: $input) {
+    id
+  }
+}`;
+//# sourceMappingURL=data:application/json;base64,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