@lifeready/core 1.0.1 → 1.0.2

package/src/lib/api/contact-card2.service.spec.ts

@@ -1,297 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { environment } from 'projects/lr-auth-app/src/environments/environment';
-import {
-  loginTestUser,
-  logoutUser,
-} from '../auth/life-ready-auth.service.spec';
-import {
-  lrConfigureTestingModule,
-  lrExpectAsyncThrow,
-  lrit,
-} from '../_common/tests';
-import { ContactCardQuery, ContactCardsQuery } from './contact-card2.gql';
-import {
-  ContactCard2Service,
-  CreateContactCardInput2,
-} from './contact-card2.service';
-import { LrGraphQLService } from './lr-graphql';
-import { ContactCardNode } from './types';
-
-const TIMEOUT = 1000 * 60 * 10;
-
-describe('ContactCard2Service', () => {
-  let ccService: ContactCard2Service;
-  let lrGraphQL: LrGraphQLService;
-
-  beforeEach(async () => {
-    lrConfigureTestingModule();
-    ccService = TestBed.inject(ContactCard2Service);
-    lrGraphQL = TestBed.inject(LrGraphQLService);
-  }, TIMEOUT);
-
-  async function clearContactCards() {
-    await Promise.all(
-      (await getContactCards()).map(async (cc) => {
-        const res = await lrGraphQL.lrMutate(
-          ccService.deleteContactCard(cc.id)
-        );
-        expect(res).toBeTruthy();
-      })
-    );
-
-    const list = await getContactCards();
-    expect(list.length).toBe(0);
-  }
-
-  async function getContactCards(): Promise<ContactCardNode[]> {
-    return (
-      await lrGraphQL.query({
-        query: ContactCardsQuery,
-      })
-    ).contactCards.edges.map((edge) => edge.node);
-  }
-
-  async function getContactCard(id) {
-    return (
-      await lrGraphQL.query({
-        query: ContactCardQuery,
-        variables: {
-          id,
-        },
-      })
-    ).contactCard;
-  }
-
-  lrit(
-    'should create single contact card',
-    async () => {
-      if (!environment.test) {
-        return;
-      }
-
-      const {
-        username: username1,
-        password: password1,
-      } = environment.test.users[0];
-      let res;
-      let cc1;
-
-      // ------------------------------------------------------
-      // Test User 1
-      // ------------------------------------------------------
-      await loginTestUser(username1, password1);
-
-      // Clear contact cards
-      await clearContactCards();
-
-      const card1: CreateContactCardInput2 = {
-        plainCipherDataJson: { secret: 1 },
-        publicDataJson: '',
-        publicSearchableJson: '',
-        plainDataJson: { name: { name: 'name 1' } },
-      };
-
-      // res = await ccService.createContactCard(card1);
-      res = (await lrGraphQL.lrMutate(ccService.createContactCard(card1)))
-        .createContactCard.contactCard;
-      cc1 = await getContactCard(res.id);
-      expect(cc1.id).toEqual(res.id);
-      expect(cc1.cipherDataClearJson).toEqual(card1.plainCipherDataJson);
-      expect(JSON.parse(cc1.publicData)).toEqual(card1.publicDataJson);
-      expect(JSON.parse(cc1.publicSearchable)).toEqual(
-        card1.publicSearchableJson
-      );
-    },
-    TIMEOUT
-  );
-
-  lrit(
-    'should create contact cards',
-    async () => {
-      if (!environment.test) {
-        return;
-      }
-
-      const {
-        username: username1,
-        password: password1,
-      } = environment.test.users[0];
-      const {
-        username: username2,
-        password: password2,
-      } = environment.test.users[1];
-      const {
-        username: username3,
-        password: password3,
-      } = environment.test.users[2];
-
-      let res;
-      let cc1: ContactCardNode;
-      let cc2: ContactCardNode;
-      let cc3: ContactCardNode;
-
-      const publicSearchableFilter = {
-        filter: [{ contains: { b: { c: 2 } } }],
-      };
-
-      // ------------------------------------------------------
-      // Signed out
-      // ------------------------------------------------------
-      await logoutUser();
-
-      (await lrExpectAsyncThrow(getContactCards())).toBeTruthy();
-
-      // ------------------------------------------------------
-      // Test User 1
-      // ------------------------------------------------------
-      await loginTestUser(username1, password1);
-
-      // Clear contact cards
-      await clearContactCards();
-
-      const card1: CreateContactCardInput2 = {
-        plainCipherDataJson: { secret: 1 },
-        publicDataJson: { public: 1 },
-        publicSearchableJson: { publicSearchable: 1 },
-        plainDataJson: { name: { name: 'name 1' } },
-      };
-
-      const card2: CreateContactCardInput2 = {
-        plainCipherDataJson: { secret: 2 },
-        publicDataJson: { public: 2 },
-        publicSearchableJson: { publicSearchable: 2 },
-        plainDataJson: { name: { name: 'name 2' } },
-      };
-
-      const card2Updated: CreateContactCardInput2 = {
-        plainCipherDataJson: { secret: 22 },
-        publicDataJson: { public: 22 },
-        publicSearchableJson: { publicSearchable: 22 },
-        plainDataJson: { name: { name: 'name 22' } },
-      };
-
-      const card3: CreateContactCardInput2 = {
-        plainCipherDataJson: { secret: 3 },
-        publicDataJson: { public: 3 },
-        publicSearchableJson: { publicSearchable: 3 },
-        plainDataJson: { name: { name: 'name 3' } },
-      };
-
-      // Create contact card 1
-      res = (await lrGraphQL.lrMutate(ccService.createContactCard(card1)))
-        .createContactCard.contactCard;
-      cc1 = await getContactCard(res.id);
-      expect(cc1.id).toEqual(res.id);
-      expect(JSON.parse(cc1.publicData)).toEqual(card1.publicDataJson);
-      expect(JSON.parse(cc1.publicSearchable)).toEqual(
-        card1.publicSearchableJson
-      );
-      expect(cc1.cipherDataClearJson).toEqual(card1.plainCipherDataJson);
-
-      // Create contact card 2
-      // res = await ccService.createContactCard(card2);
-      res = (await lrGraphQL.lrMutate(ccService.createContactCard(card2)))
-        .createContactCard.contactCard;
-      cc2 = await getContactCard(res.id);
-
-      // List
-      res = await getContactCards();
-      expect(res.length).toBe(2);
-
-      // Update
-      res = await lrGraphQL.lrMutate(
-        ccService.updateContactCard({
-          keyId: cc2.key.id,
-          id: cc2.id,
-          ...card2Updated,
-        })
-      );
-
-      const cc2Updated = await getContactCard(cc2.id);
-      expect(cc2Updated.id).toEqual(cc2.id);
-      expect(cc2Updated.cipherDataClearJson).toEqual(
-        card2Updated.plainCipherDataJson
-      );
-      expect(JSON.parse(cc2Updated.publicData)).toEqual(
-        card2Updated.publicDataJson
-      );
-      expect(JSON.parse(cc2Updated.publicSearchable)).toEqual(
-        card2Updated.publicSearchableJson
-      );
-      // Expecting keys to remain unchanged.
-      expect(cc2Updated.key.id).toEqual(cc2.key.id);
-
-      // Create contact card 3
-      // cc3 = await ccService.createContactCard(card3);
-      cc3 = (await lrGraphQL.lrMutate(ccService.createContactCard(card3)))
-        .createContactCard.contactCard;
-      res = await getContactCards();
-      expect(res.length).toEqual(3);
-      res = await lrGraphQL.lrMutate(ccService.deleteContactCard(cc3.id));
-      res = await getContactCards();
-      expect(res.length).toEqual(2);
-
-      // ------------------------------------------------------
-      // Signed out
-      // ------------------------------------------------------
-      await logoutUser();
-      (await lrExpectAsyncThrow(getContactCard(cc1.id))).toBeTruthy(
-        'Query should only available to logged in users'
-      );
-
-      // ------------------------------------------------------
-      // Test User 2
-      // ------------------------------------------------------
-      await loginTestUser(username2, password2);
-
-      (
-        await lrExpectAsyncThrow(
-          lrGraphQL.lrMutate(ccService.deleteContactCard(cc1.id))
-        )
-      ).toBeTruthy(
-        'Should not be able to delete the contact card of another user.'
-      );
-      (
-        await lrExpectAsyncThrow(
-          lrGraphQL.lrMutate(
-            ccService.updateContactCard({
-              keyId: cc2.key.id,
-              id: cc2.id,
-              ...card2,
-            })
-          )
-        )
-      ).toBeTruthy(
-        'Should not be able to update the contact card of another user.'
-      );
-
-      // // Should be able to search by public searchable
-      // res = await ccService.searchContactCard({
-      //   filter: [
-      //     {
-      //       contains: {
-      //         ...card1.publicSearchableJson,
-      //       },
-      //     },
-      //   ],
-      // });
-
-      // expect(res.length).toBe(1);
-      // expect(res[0].id).toBe(cc1.id);
-
-      // // Should not be able to search by public data
-      // res = await ccService.searchContactCard({
-      //   filter: [
-      //     {
-      //       contains: {
-      //         ...card1.publicDataJson,
-      //       },
-      //     },
-      //   ],
-      // });
-
-      // expect(res.length).toBe(0);
-    },
-    TIMEOUT
-  );
-});

package/src/lib/api/contact-card2.service.ts

@@ -1,139 +0,0 @@
-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 { MainContactCardPlainFields } from '../users/profile.types';
-import { RunOutsideAngular } from '../_common/run-outside-angular';
-import {
-  CreateContactCardMutation,
-  DeleteContactCardMutation,
-  UpdateContactCardMutation,
-} from './contact-card2.gql';
-import { LrMutation } from './lr-graphql';
-
-export interface CreateContactCardInput2 {
-  publicDataJson: any;
-  publicSearchableJson: any;
-  plainCipherDataJson: any;
-  plainDataJson: MainContactCardPlainFields;
-}
-
-// These contact name fields are enforced by the server so that it can send out emails with
-// appropriate format.
-export interface ContactCardName2 {
-  name: string;
-  title?: string;
-  firstName?: string;
-  lastName?: string;
-  // additional fields are not allowed by the server
-}
-
-export class OwnerPlainDataJson {
-  name: ContactCardName2;
-}
-
-export interface UpdateContactCardInput2 extends CreateContactCardInput2 {
-  id: string;
-  keyId: string;
-}
-
-@RunOutsideAngular({
-  ngZoneName: 'ngZone',
-})
-@Injectable({
-  providedIn: 'root',
-})
-export class ContactCard2Service {
-  constructor(
-    private keyFactory: KeyFactoryService,
-    private keyService: KeyService,
-    private encryptionService: EncryptionService,
-    private keyGraph: KeyGraphService,
-    private keyMetaService: KeyMetaService,
-    private ngZone: NgZone
-  ) {}
-
-  async createContactCard(input: CreateContactCardInput2) {
-    // Get encryption key
-    const rootKey = await this.keyService.getCurrentRootKey();
-    const key = await this.keyFactory.createKey();
-    const wrappedKey = await this.keyGraph.encryptToString(
-      rootKey.jwk,
-      key.toJSON(true)
-    );
-    const cipherData = await this.keyGraph.encryptToString(
-      key,
-      input.plainCipherDataJson
-    );
-
-    const params = await this.prepareContactCardInput(input);
-
-    return new LrMutation({
-      mutation: CreateContactCardMutation,
-      variables: {
-        input: {
-          ...params,
-          wrappingKeyId: rootKey.id,
-          wrappedKey,
-          cipherData,
-        },
-      },
-    });
-  }
-
-  async updateContactCard(input: UpdateContactCardInput2) {
-    // Get encryption key
-    const cipherData = await this.keyGraph.encryptToString(
-      input.keyId,
-      input.plainCipherDataJson
-    );
-
-    const params = await this.prepareContactCardInput(input);
-
-    return new LrMutation({
-      mutation: UpdateContactCardMutation,
-      variables: {
-        input: {
-          ...params,
-          id: input.id,
-          cipherData,
-        },
-      },
-    });
-  }
-
-  deleteContactCard(id: string) {
-    return new LrMutation({
-      mutation: DeleteContactCardMutation,
-      variables: {
-        input: {
-          id,
-        },
-      },
-    });
-  }
-
-  private async prepareContactCardInput(
-    input: CreateContactCardInput2
-  ): Promise<any> {
-    const sigPxk = await this.keyService.getCurrentSigPxk();
-    const publicDataSig = JSON.stringify(
-      await this.encryptionService.sign(sigPxk.jwk, input.publicDataJson)
-    );
-    const publicSearchableSig = JSON.stringify(
-      await this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson)
-    );
-    const plainDataSig = JSON.stringify(
-      await this.encryptionService.sign(sigPxk.jwk, input.plainDataJson)
-    );
-
-    return {
-      sigPxkId: sigPxk.id,
-      publicDataSig,
-      publicSearchableSig,
-      plainDataSig,
-    };
-  }
-}

package/src/lib/api/file.service.spec.ts

@@ -1,14 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { FileService } from './file.service';
-import { lrConfigureTestingModule } from '../_common/tests';
-
-describe('FileService', () => {
-  beforeEach(() => {
-    lrConfigureTestingModule();
-  });
-
-  it('should be created', () => {
-    const service: FileService = TestBed.inject(FileService);
-    expect(service).toBeTruthy();
-  });
-});

package/src/lib/api/file.service.ts

@@ -1,81 +0,0 @@
-import { HttpClient } from '@angular/common/http';
-import { Injectable, Inject } from '@angular/core';
-import { LR_CONFIG, LifeReadyConfig } from '../life-ready.config';
-import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
-
-export type FileContentContext = 'FILE_STATE';
-
-export interface UploadEncryptedFileOptions {
-  encryptedContent: string;
-  // TODO Add in the context field and make it mandatory
-  // context: FileContentContext;
-  fileName?: string;
-}
-
-@Injectable({
-  providedIn: 'root',
-})
-export class FileService {
-  constructor(
-    @Inject(LR_CONFIG) private config: LifeReadyConfig,
-    private http: HttpClient,
-    private lrAuth: LifeReadyAuthService
-  ) {}
-
-  async downloadEncryptedFile(fileStateNodeId: string): Promise<any> {
-    return JSON.parse(await this.downloadEncryptedFile2(fileStateNodeId));
-  }
-
-  async downloadEncryptedFile2(fileStateNodeId: string): Promise<string> {
-    const url = `${this.config.apiUrl}files/download/?file_state_node_id=${fileStateNodeId}`;
-
-    const content = await this.http
-      .get(url, {
-        responseType: 'text',
-        headers: {
-          Authorization: `Bearer ${(
-            await this.lrAuth.getUser()
-          ).getAccessJwtToken()}`,
-        },
-      })
-      .toPromise();
-
-    return content;
-  }
-
-  async loadFile(file: File): Promise<ArrayBuffer> {
-    return new Promise<ArrayBuffer>((resolve, reject) => {
-      const reader = new FileReader();
-      reader.onload = () => {
-        // OK to type cast here since we are using readAsArrayBuffer.
-        resolve(reader.result as ArrayBuffer);
-      };
-      reader.readAsArrayBuffer(file);
-    });
-  }
-
-  async uploadEncryptedFile(
-    options: UploadEncryptedFileOptions
-  ): Promise<string> {
-    const { encryptedContent, fileName } = options;
-
-    const formData = new FormData();
-    formData.append('content', new Blob([encryptedContent]), fileName);
-
-    const { content_resource } = await this.http
-      .post<{ content_resource }>(
-        `${this.config.apiUrl}files/upload/`,
-        formData,
-        {
-          headers: {
-            Authorization: `Bearer ${(
-              await this.lrAuth.getUser()
-            ).getAccessJwtToken()}`,
-          },
-        }
-      )
-      .toPromise();
-
-    return content_resource;
-  }
-}