@lifeready/core 0.6.0-beta.1

package/esm2015/lib/api/contact-card.gql.js

@@ -0,0 +1,79 @@
+import { KeyGraphField } from '../_common/queries.gql';
+import gql from 'graphql-tag';
+export const ContactCardFields = `
+id
+publicData
+publicSearchable
+cipherData
+key {
+  id
+}
+`;
+export const ContactCardQuery = gql `
+query ContactCardQuery(
+$id: LrRelayIdInput!
+) {
+contactCard (
+  id: $id
+) {
+  ${ContactCardFields}
+}
+${KeyGraphField}
+}`;
+export const SearchContactCardQuery = gql `
+query SearchContactCardQuery(
+  $publicSearchable: LrJSONFilter!
+) {
+  searchContactCards(
+    publicSearchable: $publicSearchable
+    orderBy: "created"
+  ) {
+    edges {
+      node {
+        ${ContactCardFields}
+      }
+    }
+  }
+  ${KeyGraphField}
+}`;
+export const ContactCardListQuery = gql `
+query ContactCardListQuery {
+  contactCards(
+    orderBy: "created"
+  ) {
+    edges {
+      node {
+        ${ContactCardFields}
+      }
+    }
+  }
+  ${KeyGraphField}
+}`;
+export const CreateContactCardMutation = gql `
+mutation CreateContactCardMutation(
+  $input: CreateContactCardInput!
+) {
+  createContactCard(input: $input) {
+    contactCard {
+      ${ContactCardFields}
+    }
+  }
+}`;
+export const UpdateContactCardMutation = gql `
+mutation UpdateContactCardMutation(
+  $input: UpdateContactCardInput!
+) {
+  updateContactCard(input: $input) {
+    contactCard {
+      ${ContactCardFields}
+    }
+  }
+}`;
+export const DeleteContactCardMutation = gql `
+  mutation DeleteContactCardMutation($input: DeleteContactCardInput!) {
+    deleteContactCard(input: $input) {
+      id
+    }
+  }
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/api/contact-card.service.js

@@ -0,0 +1,154 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyService } from '../cryptography/key.service';
+import { LrApolloService } from './lr-apollo.service';
+import { SearchContactCardQuery, ContactCardListQuery, ContactCardQuery, CreateContactCardMutation, UpdateContactCardMutation, DeleteContactCardMutation, } from './contact-card.gql';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../cryptography/key-factory.service";
+import * as i2 from "../cryptography/key.service";
+import * as i3 from "./lr-apollo.service";
+import * as i4 from "../cryptography/key-graph.service";
+import * as i5 from "../cryptography/encryption.service";
+import * as i6 from "../cryptography/key-meta.service";
+export class ContactCard {
+}
+export class ContactCardService {
+    constructor(keyFactory, keyService, lrApollo, keyGraph, encryptionService, keyMetaService) {
+        this.keyFactory = keyFactory;
+        this.keyService = keyService;
+        this.lrApollo = lrApollo;
+        this.keyGraph = keyGraph;
+        this.encryptionService = encryptionService;
+        this.keyMetaService = keyMetaService;
+    }
+    decryptContactCard(cc) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ret = Object.assign(Object.assign({}, cc), { publicDataJson: JSON.parse(cc.publicData), publicSearchableJson: JSON.parse(cc.publicSearchable) });
+            if (cc.key) {
+                const key = yield this.keyGraph.getJwkKey(cc.key.id);
+                // TODO: verify signature
+                ret.plainCipherDataJson = yield this.encryptionService.decrypt(key, cc.cipherData);
+            }
+            return ret;
+        });
+    }
+    decryptContactCardEdges(hasEdges) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.all(hasEdges.edges.map((edge) => __awaiter(this, void 0, void 0, function* () {
+                const cc = edge.node;
+                return yield this.decryptContactCard(cc);
+            })));
+        });
+    }
+    // { "filter": [{ "contains": { "a": true } }] }
+    searchContactCard(publicSearchable) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.lrApollo.query({
+                query: SearchContactCardQuery,
+                variables: {
+                    publicSearchable: JSON.stringify(publicSearchable),
+                },
+            });
+            return yield this.decryptContactCardEdges(data.searchContactCards);
+        });
+    }
+    getContactCardList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.lrApollo.query({
+                query: ContactCardListQuery,
+            });
+            return yield this.decryptContactCardEdges(data.contactCards);
+        });
+    }
+    getContactCard(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.lrApollo.query({
+                query: ContactCardQuery,
+                variables: {
+                    id,
+                },
+            });
+            return yield this.decryptContactCard(data.contactCard);
+        });
+    }
+    prepareContactCardInput(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sigPxk = yield this.keyService.getCurrentSigPxk();
+            const publicDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.publicDataJson));
+            const publicSearchableSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson));
+            const plainDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.plainDataJson));
+            return {
+                sigPxkId: sigPxk.id,
+                publicDataSig,
+                publicSearchableSig,
+                plainDataSig,
+            };
+        });
+    }
+    createContactCard(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get encryption key
+            const rootKey = yield this.keyService.getCurrentRootKey();
+            const key = yield this.keyFactory.createKey();
+            const wrappedKey = yield this.keyGraph.encryptToString(rootKey.jwk, key.toJSON(true));
+            const cipherData = yield this.keyGraph.encryptToString(key, input.plainCipherDataJson);
+            const params = yield this.prepareContactCardInput(input);
+            const data = yield this.lrApollo.mutate({
+                mutation: CreateContactCardMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, params), { wrappingKeyId: rootKey.id, wrappedKey,
+                        cipherData }),
+                },
+            });
+            return data.createContactCard.contactCard;
+        });
+    }
+    updateContactCard(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get encryption key
+            const cc = yield this.getContactCard(input.id);
+            const key = yield this.keyGraph.getJwkKey(cc.key.id);
+            const cipherData = yield this.keyGraph.encryptToString(key, input.plainCipherDataJson);
+            const params = yield this.prepareContactCardInput(input);
+            const data = yield this.lrApollo.mutate({
+                mutation: UpdateContactCardMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, params), { id: input.id, cipherData }),
+                },
+            });
+            return data.updateContactCard.contactCard;
+        });
+    }
+    deleteContactCard(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = yield this.lrApollo.mutate({
+                mutation: DeleteContactCardMutation,
+                variables: {
+                    input: {
+                        id,
+                    },
+                },
+            });
+            return data.deleteContactCard.id;
+        });
+    }
+}
+ContactCardService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ContactCardService_Factory() { return new ContactCardService(i0.ɵɵinject(i1.KeyFactoryService), i0.ɵɵinject(i2.KeyService), i0.ɵɵinject(i3.LrApolloService), i0.ɵɵinject(i4.KeyGraphService), i0.ɵɵinject(i5.EncryptionService), i0.ɵɵinject(i6.KeyMetaService)); }, token: ContactCardService, providedIn: "root" });
+ContactCardService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+ContactCardService.ctorParameters = () => [
+    { type: KeyFactoryService },
+    { type: KeyService },
+    { type: LrApolloService },
+    { type: KeyGraphService },
+    { type: EncryptionService },
+    { type: KeyMetaService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contact-card.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/api/contact-card.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HasKeyGraph, Key } from '../cryptography/cryptography.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 { HasEdges } from '../_common/types';\r\nimport { LrApolloService } from './lr-apollo.service';\r\nimport {\r\n  SearchContactCardQuery,\r\n  ContactCardListQuery,\r\n  ContactCardQuery,\r\n  CreateContactCardMutation,\r\n  UpdateContactCardMutation,\r\n  DeleteContactCardMutation,\r\n} from './contact-card.gql';\r\nimport { KeyFactoryService } from '../cryptography/key-factory.service';\r\nimport { MainContactCardPlainFields } from '../users/profile.types';\r\nimport { KeyMetaService } from '../cryptography/key-meta.service';\r\n\r\ninterface ContactCardQuery extends HasKeyGraph {\r\n  contactCard: ContactCard;\r\n}\r\n\r\ninterface SearchContactCardQuery extends HasKeyGraph {\r\n  searchContactCards: HasEdges<ContactCard>;\r\n}\r\n\r\ninterface ContactCardListQuery extends HasKeyGraph {\r\n  contactCards: HasEdges<ContactCard>;\r\n}\r\n\r\nexport class ContactCard {\r\n  id: string;\r\n  key: Key;\r\n  sigPxk: Key;\r\n  publicData: string;\r\n  publicDataSig: string;\r\n  publicSearchable: string;\r\n  publicSearchableSig: string;\r\n  plainData: string;\r\n  plainDataSig: string;\r\n  cipherData: string;\r\n  // Parse/decrypted versions of the above.\r\n  publicDataJson: any;\r\n  publicSearchableJson: any;\r\n  plainCipherDataJson: any;\r\n  plainDataJson: any;\r\n}\r\n\r\nexport interface CreateContactCardInput {\r\n  publicDataJson: any;\r\n  publicSearchableJson: any;\r\n  plainCipherDataJson: any;\r\n  plainDataJson: MainContactCardPlainFields;\r\n}\r\n\r\nexport interface UpdateContactCardInput extends CreateContactCardInput {\r\n  id: string;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class ContactCardService {\r\n  constructor(\r\n    private keyFactory: KeyFactoryService,\r\n    private keyService: KeyService,\r\n    private lrApollo: LrApolloService,\r\n    private keyGraph: KeyGraphService,\r\n    private encryptionService: EncryptionService,\r\n    private keyMetaService: KeyMetaService\r\n  ) {}\r\n\r\n  async decryptContactCard(cc: ContactCard): Promise<ContactCard> {\r\n    const ret = {\r\n      ...cc,\r\n      publicDataJson: JSON.parse(cc.publicData),\r\n      publicSearchableJson: JSON.parse(cc.publicSearchable),\r\n    };\r\n\r\n    if (cc.key) {\r\n      const key = await this.keyGraph.getJwkKey(cc.key.id);\r\n      // TODO: verify signature\r\n      ret.plainCipherDataJson = await this.encryptionService.decrypt(\r\n        key,\r\n        cc.cipherData\r\n      );\r\n    }\r\n\r\n    return ret;\r\n  }\r\n\r\n  async decryptContactCardEdges(\r\n    hasEdges: HasEdges<ContactCard>\r\n  ): Promise<ContactCard[]> {\r\n    return Promise.all(\r\n      hasEdges.edges.map(async (edge: any) => {\r\n        const cc = edge.node as ContactCard;\r\n        return await this.decryptContactCard(cc);\r\n      })\r\n    );\r\n  }\r\n\r\n  // { \"filter\": [{ \"contains\": { \"a\": true } }] }\r\n  async searchContactCard(publicSearchable: object): Promise<ContactCard[]> {\r\n    const data = await this.lrApollo.query<SearchContactCardQuery>({\r\n      query: SearchContactCardQuery,\r\n      variables: {\r\n        publicSearchable: JSON.stringify(publicSearchable),\r\n      },\r\n    });\r\n\r\n    return await this.decryptContactCardEdges(data.searchContactCards);\r\n  }\r\n\r\n  async getContactCardList(): Promise<ContactCard[]> {\r\n    const data = await this.lrApollo.query<ContactCardListQuery>({\r\n      query: ContactCardListQuery,\r\n    });\r\n\r\n    return await this.decryptContactCardEdges(data.contactCards);\r\n  }\r\n\r\n  async getContactCard(id: string): Promise<ContactCard> {\r\n    const data = await this.lrApollo.query<ContactCardQuery>({\r\n      query: ContactCardQuery,\r\n      variables: {\r\n        id,\r\n      },\r\n    });\r\n\r\n    return await this.decryptContactCard(data.contactCard);\r\n  }\r\n\r\n  private async prepareContactCardInput(\r\n    input: CreateContactCardInput\r\n  ): Promise<any> {\r\n    const sigPxk = await this.keyService.getCurrentSigPxk();\r\n    const publicDataSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, input.publicDataJson)\r\n    );\r\n    const publicSearchableSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson)\r\n    );\r\n    const plainDataSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, input.plainDataJson)\r\n    );\r\n\r\n    return {\r\n      sigPxkId: sigPxk.id,\r\n      publicDataSig,\r\n      publicSearchableSig,\r\n      plainDataSig,\r\n    };\r\n  }\r\n\r\n  async createContactCard(input: CreateContactCardInput): Promise<ContactCard> {\r\n    // Get encryption key\r\n    const rootKey = await this.keyService.getCurrentRootKey();\r\n    const key = await this.keyFactory.createKey();\r\n    const wrappedKey = await this.keyGraph.encryptToString(\r\n      rootKey.jwk,\r\n      key.toJSON(true)\r\n    );\r\n    const cipherData = await this.keyGraph.encryptToString(\r\n      key,\r\n      input.plainCipherDataJson\r\n    );\r\n\r\n    const params = await this.prepareContactCardInput(input);\r\n\r\n    const data = await this.lrApollo.mutate<{\r\n      createContactCard: { contactCard: ContactCard };\r\n    }>({\r\n      mutation: CreateContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          ...params,\r\n          wrappingKeyId: rootKey.id,\r\n          wrappedKey,\r\n          cipherData,\r\n        },\r\n      },\r\n    });\r\n\r\n    return data.createContactCard.contactCard;\r\n  }\r\n\r\n  async updateContactCard(input: UpdateContactCardInput): Promise<ContactCard> {\r\n    // Get encryption key\r\n    const cc = await this.getContactCard(input.id);\r\n    const key = await this.keyGraph.getJwkKey(cc.key.id);\r\n    const cipherData = await this.keyGraph.encryptToString(\r\n      key,\r\n      input.plainCipherDataJson\r\n    );\r\n\r\n    const params = await this.prepareContactCardInput(input);\r\n\r\n    const data = await this.lrApollo.mutate<{\r\n      updateContactCard: { contactCard: ContactCard };\r\n    }>({\r\n      mutation: UpdateContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          ...params,\r\n          id: input.id,\r\n          cipherData,\r\n        },\r\n      },\r\n    });\r\n\r\n    return data.updateContactCard.contactCard;\r\n  }\r\n\r\n  async deleteContactCard(id: string): Promise<string> {\r\n    const data = await this.lrApollo.mutate<any>({\r\n      mutation: DeleteContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          id,\r\n        },\r\n      },\r\n    });\r\n\r\n    return data.deleteContactCard.id;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/api/contact-card2.gql.js

@@ -0,0 +1,60 @@
+import { gqlTyped } from '../_common/ast';
+export const ContactCardFragment = gqlTyped `
+  fragment ContactCardFragment on ContactCardNode {
+    id
+    publicData
+    publicSearchable
+    cipherData
+    key {
+        id
+    }
+  }
+`;
+export const CreateContactCardMutation = gqlTyped `
+  mutation CreateContactCardMutation(
+    $input: CreateContactCardInput!
+  ) {
+    createContactCard(input: $input) {
+      contactCard {
+        id
+      }
+    }
+  }
+`;
+export const UpdateContactCardMutation = gqlTyped `
+  mutation UpdateContactCardMutation($input: UpdateContactCardInput!) {
+    updateContactCard(input: $input) {
+      contactCard {
+        id
+      }
+    }
+  }
+`;
+export const DeleteContactCardMutation = gqlTyped `
+  mutation DeleteContactCardMutation($input: DeleteContactCardInput!) {
+    deleteContactCard(input: $input) {
+      id
+    }
+  }
+`;
+export const ContactCardsQuery = gqlTyped `
+  query ContactCardsQuery {
+    contactCards(orderBy: "created") {
+      edges {
+        node {
+          ...ContactCardFragment
+        }
+      }
+    }
+  }
+  ${ContactCardFragment}
+`;
+export const ContactCardQuery = gqlTyped `
+  query ContactCardQuery($id: LrRelayIdInput!) {
+    contactCard(id: $id) {
+      ...ContactCardFragment
+    }
+  }
+  ${ContactCardFragment}
+`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/api/contact-card2.service.js

@@ -0,0 +1,103 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, NgZone } from '@angular/core';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyFactoryService } from '../cryptography/key-factory.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { KeyService } from '../cryptography/key.service';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import { CreateContactCardMutation, DeleteContactCardMutation, UpdateContactCardMutation, } from './contact-card2.gql';
+import { LrMutation } from './lr-graphql';
+import * as i0 from "@angular/core";
+import * as i1 from "../cryptography/key-factory.service";
+import * as i2 from "../cryptography/key.service";
+import * as i3 from "../cryptography/encryption.service";
+import * as i4 from "../cryptography/key-graph.service";
+import * as i5 from "../cryptography/key-meta.service";
+export class OwnerPlainDataJson {
+}
+let ContactCard2Service = class ContactCard2Service {
+    constructor(keyFactory, keyService, encryptionService, keyGraph, keyMetaService, ngZone) {
+        this.keyFactory = keyFactory;
+        this.keyService = keyService;
+        this.encryptionService = encryptionService;
+        this.keyGraph = keyGraph;
+        this.keyMetaService = keyMetaService;
+        this.ngZone = ngZone;
+    }
+    createContactCard(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get encryption key
+            const rootKey = yield this.keyService.getCurrentRootKey();
+            const key = yield this.keyFactory.createKey();
+            const wrappedKey = yield this.keyGraph.encryptToString(rootKey.jwk, key.toJSON(true));
+            const cipherData = yield this.keyGraph.encryptToString(key, input.plainCipherDataJson);
+            const params = yield this.prepareContactCardInput(input);
+            return new LrMutation({
+                mutation: CreateContactCardMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, params), { wrappingKeyId: rootKey.id, wrappedKey,
+                        cipherData }),
+                },
+            });
+        });
+    }
+    updateContactCard(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get encryption key
+            const cipherData = yield this.keyGraph.encryptToString(input.keyId, input.plainCipherDataJson);
+            const params = yield this.prepareContactCardInput(input);
+            return new LrMutation({
+                mutation: UpdateContactCardMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, params), { id: input.id, cipherData }),
+                },
+            });
+        });
+    }
+    deleteContactCard(id) {
+        return new LrMutation({
+            mutation: DeleteContactCardMutation,
+            variables: {
+                input: {
+                    id,
+                },
+            },
+        });
+    }
+    prepareContactCardInput(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sigPxk = yield this.keyService.getCurrentSigPxk();
+            const publicDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.publicDataJson));
+            const publicSearchableSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson));
+            const plainDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.plainDataJson));
+            return {
+                sigPxkId: sigPxk.id,
+                publicDataSig,
+                publicSearchableSig,
+                plainDataSig,
+            };
+        });
+    }
+};
+ContactCard2Service.ɵprov = i0.ɵɵdefineInjectable({ factory: function ContactCard2Service_Factory() { return new ContactCard2Service(i0.ɵɵinject(i1.KeyFactoryService), i0.ɵɵinject(i2.KeyService), i0.ɵɵinject(i3.EncryptionService), i0.ɵɵinject(i4.KeyGraphService), i0.ɵɵinject(i5.KeyMetaService), i0.ɵɵinject(i0.NgZone)); }, token: ContactCard2Service, providedIn: "root" });
+ContactCard2Service.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+ContactCard2Service.ctorParameters = () => [
+    { type: KeyFactoryService },
+    { type: KeyService },
+    { type: EncryptionService },
+    { type: KeyGraphService },
+    { type: KeyMetaService },
+    { type: NgZone }
+];
+ContactCard2Service = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], ContactCard2Service);
+export { ContactCard2Service };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contact-card2.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/api/contact-card2.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport { KeyFactoryService } from '../cryptography/key-factory.service';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\nimport { KeyMetaService } from '../cryptography/key-meta.service';\r\nimport { KeyService } from '../cryptography/key.service';\r\nimport { MainContactCardPlainFields } from '../users/profile.types';\r\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\r\nimport {\r\n  CreateContactCardMutation,\r\n  DeleteContactCardMutation,\r\n  UpdateContactCardMutation,\r\n} from './contact-card2.gql';\r\nimport { LrMutation } from './lr-graphql';\r\n\r\nexport interface CreateContactCardInput2 {\r\n  publicDataJson: any;\r\n  publicSearchableJson: any;\r\n  plainCipherDataJson: any;\r\n  plainDataJson: MainContactCardPlainFields;\r\n}\r\n\r\n// These contact name fields are enforced by the server so that it can send out emails with\r\n// appropriate format.\r\nexport interface ContactCardName2 {\r\n  name: string;\r\n  title?: string;\r\n  firstName?: string;\r\n  lastName?: string;\r\n  // additional fields are not allowed by the server\r\n}\r\n\r\nexport class OwnerPlainDataJson {\r\n  name: ContactCardName2;\r\n}\r\n\r\nexport interface UpdateContactCardInput2 extends CreateContactCardInput2 {\r\n  id: string;\r\n  keyId: string;\r\n}\r\n\r\n@RunOutsideAngular({\r\n  ngZoneName: 'ngZone',\r\n})\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class ContactCard2Service {\r\n  constructor(\r\n    private keyFactory: KeyFactoryService,\r\n    private keyService: KeyService,\r\n    private encryptionService: EncryptionService,\r\n    private keyGraph: KeyGraphService,\r\n    private keyMetaService: KeyMetaService,\r\n    private ngZone: NgZone\r\n  ) {}\r\n\r\n  async createContactCard(input: CreateContactCardInput2) {\r\n    // Get encryption key\r\n    const rootKey = await this.keyService.getCurrentRootKey();\r\n    const key = await this.keyFactory.createKey();\r\n    const wrappedKey = await this.keyGraph.encryptToString(\r\n      rootKey.jwk,\r\n      key.toJSON(true)\r\n    );\r\n    const cipherData = await this.keyGraph.encryptToString(\r\n      key,\r\n      input.plainCipherDataJson\r\n    );\r\n\r\n    const params = await this.prepareContactCardInput(input);\r\n\r\n    return new LrMutation({\r\n      mutation: CreateContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          ...params,\r\n          wrappingKeyId: rootKey.id,\r\n          wrappedKey,\r\n          cipherData,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  async updateContactCard(input: UpdateContactCardInput2) {\r\n    // Get encryption key\r\n    const cipherData = await this.keyGraph.encryptToString(\r\n      input.keyId,\r\n      input.plainCipherDataJson\r\n    );\r\n\r\n    const params = await this.prepareContactCardInput(input);\r\n\r\n    return new LrMutation({\r\n      mutation: UpdateContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          ...params,\r\n          id: input.id,\r\n          cipherData,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  deleteContactCard(id: string) {\r\n    return new LrMutation({\r\n      mutation: DeleteContactCardMutation,\r\n      variables: {\r\n        input: {\r\n          id,\r\n        },\r\n      },\r\n    });\r\n  }\r\n\r\n  private async prepareContactCardInput(\r\n    input: CreateContactCardInput2\r\n  ): Promise<any> {\r\n    const sigPxk = await this.keyService.getCurrentSigPxk();\r\n    const publicDataSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, input.publicDataJson)\r\n    );\r\n    const publicSearchableSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson)\r\n    );\r\n    const plainDataSig = JSON.stringify(\r\n      await this.encryptionService.sign(sigPxk.jwk, input.plainDataJson)\r\n    );\r\n\r\n    return {\r\n      sigPxkId: sigPxk.id,\r\n      publicDataSig,\r\n      publicSearchableSig,\r\n      plainDataSig,\r\n    };\r\n  }\r\n}\r\n"]}

package/esm2015/lib/api/file.service.js

@@ -0,0 +1,74 @@
+import { __awaiter } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Injectable, Inject } from '@angular/core';
+import { LR_CONFIG } from '../life-ready.config';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../life-ready.config";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../auth/life-ready-auth.service";
+export class FileService {
+    constructor(config, http, lrAuth) {
+        this.config = config;
+        this.http = http;
+        this.lrAuth = lrAuth;
+    }
+    downloadEncryptedFile(fileStateNodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.parse(yield this.downloadEncryptedFile2(fileStateNodeId));
+        });
+    }
+    downloadEncryptedFile2(fileStateNodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${this.config.apiUrl}files/download/?file_state_node_id=${fileStateNodeId}`;
+            const content = yield this.http
+                .get(url, {
+                responseType: 'text',
+                headers: {
+                    Authorization: `Bearer ${(yield this.lrAuth.getUser()).getAccessJwtToken()}`,
+                },
+            })
+                .toPromise();
+            return content;
+        });
+    }
+    loadFile(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.onload = () => {
+                    // OK to type cast here since we are using readAsArrayBuffer.
+                    resolve(reader.result);
+                };
+                reader.readAsArrayBuffer(file);
+            });
+        });
+    }
+    uploadEncryptedFile(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { encryptedContent, fileName } = options;
+            const formData = new FormData();
+            formData.append('content', new Blob([encryptedContent]), fileName);
+            const { content_resource } = yield this.http
+                .post(`${this.config.apiUrl}files/upload/`, formData, {
+                headers: {
+                    Authorization: `Bearer ${(yield this.lrAuth.getUser()).getAccessJwtToken()}`,
+                },
+            })
+                .toPromise();
+            return content_resource;
+        });
+    }
+}
+FileService.ɵprov = i0.ɵɵdefineInjectable({ factory: function FileService_Factory() { return new FileService(i0.ɵɵinject(i1.LR_CONFIG), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i3.LifeReadyAuthService)); }, token: FileService, providedIn: "root" });
+FileService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+FileService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LR_CONFIG,] }] },
+    { type: HttpClient },
+    { type: LifeReadyAuthService }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IkM6L1Byb2plY3RzL3Rlc3QvcHJvamVjdHMvY29yZS9zcmMvIiwic291cmNlcyI6WyJsaWIvYXBpL2ZpbGUuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ25ELE9BQU8sRUFBRSxTQUFTLEVBQW1CLE1BQU0sc0JBQXNCLENBQUM7QUFDbEUsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0saUNBQWlDLENBQUM7Ozs7O0FBY3ZFLE1BQU0sT0FBTyxXQUFXO0lBQ3RCLFlBQzZCLE1BQXVCLEVBQzFDLElBQWdCLEVBQ2hCLE1BQTRCO1FBRlQsV0FBTSxHQUFOLE1BQU0sQ0FBaUI7UUFDMUMsU0FBSSxHQUFKLElBQUksQ0FBWTtRQUNoQixXQUFNLEdBQU4sTUFBTSxDQUFzQjtJQUNuQyxDQUFDO0lBRUUscUJBQXFCLENBQUMsZUFBdUI7O1lBQ2pELE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxlQUFlLENBQUMsQ0FBQyxDQUFDO1FBQ3hFLENBQUM7S0FBQTtJQUVLLHNCQUFzQixDQUFDLGVBQXVCOztZQUNsRCxNQUFNLEdBQUcsR0FBRyxHQUFHLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxzQ0FBc0MsZUFBZSxFQUFFLENBQUM7WUFFekYsTUFBTSxPQUFPLEdBQUcsTUFBTSxJQUFJLENBQUMsSUFBSTtpQkFDNUIsR0FBRyxDQUFDLEdBQUcsRUFBRTtnQkFDUixZQUFZLEVBQUUsTUFBTTtnQkFDcEIsT0FBTyxFQUFFO29CQUNQLGFBQWEsRUFBRSxVQUFVLENBQ3ZCLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLEVBQUUsQ0FDNUIsQ0FBQyxpQkFBaUIsRUFBRSxFQUFFO2lCQUN4QjthQUNGLENBQUM7aUJBQ0QsU0FBUyxFQUFFLENBQUM7WUFFZixPQUFPLE9BQU8sQ0FBQztRQUNqQixDQUFDO0tBQUE7SUFFSyxRQUFRLENBQUMsSUFBVTs7WUFDdkIsT0FBTyxJQUFJLE9BQU8sQ0FBYyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRTtnQkFDbEQsTUFBTSxNQUFNLEdBQUcsSUFBSSxVQUFVLEVBQUUsQ0FBQztnQkFDaEMsTUFBTSxDQUFDLE1BQU0sR0FBRyxHQUFHLEVBQUU7b0JBQ25CLDZEQUE2RDtvQkFDN0QsT0FBTyxDQUFDLE1BQU0sQ0FBQyxNQUFxQixDQUFDLENBQUM7Z0JBQ3hDLENBQUMsQ0FBQztnQkFDRixNQUFNLENBQUMsaUJBQWlCLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDakMsQ0FBQyxDQUFDLENBQUM7UUFDTCxDQUFDO0tBQUE7SUFFSyxtQkFBbUIsQ0FDdkIsT0FBbUM7O1lBRW5DLE1BQU0sRUFBRSxnQkFBZ0IsRUFBRSxRQUFRLEVBQUUsR0FBRyxPQUFPLENBQUM7WUFFL0MsTUFBTSxRQUFRLEdBQUcsSUFBSSxRQUFRLEVBQUUsQ0FBQztZQUNoQyxRQUFRLENBQUMsTUFBTSxDQUFDLFNBQVMsRUFBRSxJQUFJLElBQUksQ0FBQyxDQUFDLGdCQUFnQixDQUFDLENBQUMsRUFBRSxRQUFRLENBQUMsQ0FBQztZQUVuRSxNQUFNLEVBQUUsZ0JBQWdCLEVBQUUsR0FBRyxNQUFNLElBQUksQ0FBQyxJQUFJO2lCQUN6QyxJQUFJLENBQ0gsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sZUFBZSxFQUNwQyxRQUFRLEVBQ1I7Z0JBQ0UsT0FBTyxFQUFFO29CQUNQLGFBQWEsRUFBRSxVQUFVLENBQ3ZCLE1BQU0sSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLEVBQUUsQ0FDNUIsQ0FBQyxpQkFBaUIsRUFBRSxFQUFFO2lCQUN4QjthQUNGLENBQ0Y7aUJBQ0EsU0FBUyxFQUFFLENBQUM7WUFFZixPQUFPLGdCQUFnQixDQUFDO1FBQzFCLENBQUM7S0FBQTs7OztZQWpFRixVQUFVLFNBQUM7Z0JBQ1YsVUFBVSxFQUFFLE1BQU07YUFDbkI7Ozs0Q0FHSSxNQUFNLFNBQUMsU0FBUztZQW5CWixVQUFVO1lBR1Ysb0JBQW9CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cENsaWVudCB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcclxuaW1wb3J0IHsgSW5qZWN0YWJsZSwgSW5qZWN0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IExSX0NPTkZJRywgTGlmZVJlYWR5Q29uZmlnIH0gZnJvbSAnLi4vbGlmZS1yZWFkeS5jb25maWcnO1xyXG5pbXBvcnQgeyBMaWZlUmVhZHlBdXRoU2VydmljZSB9IGZyb20gJy4uL2F1dGgvbGlmZS1yZWFkeS1hdXRoLnNlcnZpY2UnO1xyXG5cclxuZXhwb3J0IHR5cGUgRmlsZUNvbnRlbnRDb250ZXh0ID0gJ0ZJTEVfU1RBVEUnO1xyXG5cclxuZXhwb3J0IGludGVyZmFjZSBVcGxvYWRFbmNyeXB0ZWRGaWxlT3B0aW9ucyB7XHJcbiAgZW5jcnlwdGVkQ29udGVudDogc3RyaW5nO1xyXG4gIC8vIFRPRE8gQWRkIGluIHRoZSBjb250ZXh0IGZpZWxkIGFuZCBtYWtlIGl0IG1hbmRhdG9yeVxyXG4gIC8vIGNvbnRleHQ6IEZpbGVDb250ZW50Q29udGV4dDtcclxuICBmaWxlTmFtZT86IHN0cmluZztcclxufVxyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290JyxcclxufSlcclxuZXhwb3J0IGNsYXNzIEZpbGVTZXJ2aWNlIHtcclxuICBjb25zdHJ1Y3RvcihcclxuICAgIEBJbmplY3QoTFJfQ09ORklHKSBwcml2YXRlIGNvbmZpZzogTGlmZVJlYWR5Q29uZmlnLFxyXG4gICAgcHJpdmF0ZSBodHRwOiBIdHRwQ2xpZW50LFxyXG4gICAgcHJpdmF0ZSBsckF1dGg6IExpZmVSZWFkeUF1dGhTZXJ2aWNlXHJcbiAgKSB7fVxyXG5cclxuICBhc3luYyBkb3dubG9hZEVuY3J5cHRlZEZpbGUoZmlsZVN0YXRlTm9kZUlkOiBzdHJpbmcpOiBQcm9taXNlPGFueT4ge1xyXG4gICAgcmV0dXJuIEpTT04ucGFyc2UoYXdhaXQgdGhpcy5kb3dubG9hZEVuY3J5cHRlZEZpbGUyKGZpbGVTdGF0ZU5vZGVJZCkpO1xyXG4gIH1cclxuXHJcbiAgYXN5bmMgZG93bmxvYWRFbmNyeXB0ZWRGaWxlMihmaWxlU3RhdGVOb2RlSWQ6IHN0cmluZyk6IFByb21pc2U8c3RyaW5nPiB7XHJcbiAgICBjb25zdCB1cmwgPSBgJHt0aGlzLmNvbmZpZy5hcGlVcmx9ZmlsZXMvZG93bmxvYWQvP2ZpbGVfc3RhdGVfbm9kZV9pZD0ke2ZpbGVTdGF0ZU5vZGVJZH1gO1xyXG5cclxuICAgIGNvbnN0IGNvbnRlbnQgPSBhd2FpdCB0aGlzLmh0dHBcclxuICAgICAgLmdldCh1cmwsIHtcclxuICAgICAgICByZXNwb25zZVR5cGU6ICd0ZXh0JyxcclxuICAgICAgICBoZWFkZXJzOiB7XHJcbiAgICAgICAgICBBdXRob3JpemF0aW9uOiBgQmVhcmVyICR7KFxyXG4gICAgICAgICAgICBhd2FpdCB0aGlzLmxyQXV0aC5nZXRVc2VyKClcclxuICAgICAgICAgICkuZ2V0QWNjZXNzSnd0VG9rZW4oKX1gLFxyXG4gICAgICAgIH0sXHJcbiAgICAgIH0pXHJcbiAgICAgIC50b1Byb21pc2UoKTtcclxuXHJcbiAgICByZXR1cm4gY29udGVudDtcclxuICB9XHJcblxyXG4gIGFzeW5jIGxvYWRGaWxlKGZpbGU6IEZpbGUpOiBQcm9taXNlPEFycmF5QnVmZmVyPiB7XHJcbiAgICByZXR1cm4gbmV3IFByb21pc2U8QXJyYXlCdWZmZXI+KChyZXNvbHZlLCByZWplY3QpID0+IHtcclxuICAgICAgY29uc3QgcmVhZGVyID0gbmV3IEZpbGVSZWFkZXIoKTtcclxuICAgICAgcmVhZGVyLm9ubG9hZCA9ICgpID0+IHtcclxuICAgICAgICAvLyBPSyB0byB0eXBlIGNhc3QgaGVyZSBzaW5jZSB3ZSBhcmUgdXNpbmcgcmVhZEFzQXJyYXlCdWZmZXIuXHJcbiAgICAgICAgcmVzb2x2ZShyZWFkZXIucmVzdWx0IGFzIEFycmF5QnVmZmVyKTtcclxuICAgICAgfTtcclxuICAgICAgcmVhZGVyLnJlYWRBc0FycmF5QnVmZmVyKGZpbGUpO1xyXG4gICAgfSk7XHJcbiAgfVxyXG5cclxuICBhc3luYyB1cGxvYWRFbmNyeXB0ZWRGaWxlKFxyXG4gICAgb3B0aW9uczogVXBsb2FkRW5jcnlwdGVkRmlsZU9wdGlvbnNcclxuICApOiBQcm9taXNlPHN0cmluZz4ge1xyXG4gICAgY29uc3QgeyBlbmNyeXB0ZWRDb250ZW50LCBmaWxlTmFtZSB9ID0gb3B0aW9ucztcclxuXHJcbiAgICBjb25zdCBmb3JtRGF0YSA9IG5ldyBGb3JtRGF0YSgpO1xyXG4gICAgZm9ybURhdGEuYXBwZW5kKCdjb250ZW50JywgbmV3IEJsb2IoW2VuY3J5cHRlZENvbnRlbnRdKSwgZmlsZU5hbWUpO1xyXG5cclxuICAgIGNvbnN0IHsgY29udGVudF9yZXNvdXJjZSB9ID0gYXdhaXQgdGhpcy5odHRwXHJcbiAgICAgIC5wb3N0PHsgY29udGVudF9yZXNvdXJjZSB9PihcclxuICAgICAgICBgJHt0aGlzLmNvbmZpZy5hcGlVcmx9ZmlsZXMvdXBsb2FkL2AsXHJcbiAgICAgICAgZm9ybURhdGEsXHJcbiAgICAgICAge1xyXG4gICAgICAgICAgaGVhZGVyczoge1xyXG4gICAgICAgICAgICBBdXRob3JpemF0aW9uOiBgQmVhcmVyICR7KFxyXG4gICAgICAgICAgICAgIGF3YWl0IHRoaXMubHJBdXRoLmdldFVzZXIoKVxyXG4gICAgICAgICAgICApLmdldEFjY2Vzc0p3dFRva2VuKCl9YCxcclxuICAgICAgICAgIH0sXHJcbiAgICAgICAgfVxyXG4gICAgICApXHJcbiAgICAgIC50b1Byb21pc2UoKTtcclxuXHJcbiAgICByZXR1cm4gY29udGVudF9yZXNvdXJjZTtcclxuICB9XHJcbn1cclxuIl19