@lifeready/core 1.0.0 → 1.0.1

package/src/lib/auth/two-factor.service.ts

@@ -0,0 +1,69 @@
+import { Injectable } from '@angular/core';
+import { CognitoUser } from '@aws-amplify/auth';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { LrBadArgumentException } from '../_common/exceptions';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class TwoFactorService {
+  constructor(private auth: AuthClass) {}
+
+  public async getPreferredMFA(): Promise<string> {
+    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();
+
+    return await this.auth.getPreferredMFA(cognitoUser);
+  }
+
+  public async setPreferredMFA(
+    method: 'TOTP' | 'SMS' | 'NOMFA'
+  ): Promise<void> {
+    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();
+
+    await this.auth.setPreferredMFA(cognitoUser, method);
+  }
+
+  public async setPhoneNumber(phone): Promise<void> {
+    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();
+
+    await this.auth.updateUserAttributes(cognitoUser, {
+      phone_number: phone,
+    });
+  }
+
+  public async getSMSCode() {
+    await this.auth.verifyCurrentUserAttribute('phone_number');
+  }
+
+  public async verifySMSCode(verificationCode: string) {
+    await this.auth.verifyCurrentUserAttributeSubmit(
+      'phone_number',
+      verificationCode
+    );
+  }
+
+  public async getSoftwareToken(): Promise<{ code: string; codeUri: string }> {
+    const [cognitoUser, userInfo] = await Promise.all([
+      this.auth.currentAuthenticatedUser(),
+      this.auth.currentUserInfo(),
+    ]);
+
+    const code = await this.auth.setupTOTP(cognitoUser);
+
+    const email = userInfo.attributes.email;
+    if (!email) {
+      throw new LrBadArgumentException('No email associated with user.');
+    }
+
+    return {
+      code,
+      codeUri: `otpauth://totp/${email}?secret=${code}&issuer=LifeReady`,
+    };
+  }
+
+  public async verifySoftwareToken(totpCode: string): Promise<void> {
+    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();
+
+    await this.auth.verifyTotpToken(cognitoUser, totpCode);
+  }
+}

package/src/lib/category/category-meta.service.spec.ts

@@ -0,0 +1,28 @@
+import { TestBed } from '@angular/core/testing';
+import { CategoryMetaService } from './category-meta.service';
+import { CategoryService } from './category.service';
+import { HttpClient } from '@angular/common/http';
+
+const http = jasmine.createSpyObj('HttpClient', ['']);
+const categoryService = jasmine.createSpyObj<CategoryService>(
+  'CategoryService',
+  ['getCategories', 'getCategory']
+);
+
+describe('CategoryMetaService', () => {
+  let service: CategoryMetaService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [
+        { provide: CategoryService, useValue: categoryService },
+        { provide: HttpClient, useValue: http },
+      ],
+    });
+    service = TestBed.inject(CategoryMetaService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/category/category-meta.service.ts

@@ -0,0 +1,125 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { CategoryService } from './category.service';
+import {
+  AccessLevel,
+  Category,
+  CurrentCategory,
+  DefaultCategory,
+  VaultCategory,
+} from './category.types';
+
+export class LoadedCategoryTree {
+  categories: CurrentCategory[];
+  missingCategories: string[][];
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class CategoryMetaService {
+  private categories: DefaultCategory[];
+
+  constructor(
+    private http: HttpClient,
+    private categoryService: CategoryService
+  ) {}
+
+  public async getCoreCategories(): Promise<DefaultCategory[]> {
+    if (!this.categories) {
+      this.categories = await this.http
+        .get<DefaultCategory[]>('/assets/meta/categories.json')
+        .toPromise();
+    }
+    return Promise.resolve(this.categories);
+  }
+
+  async loadCategories(
+    categoryTrees: string[][],
+    selectedCategoryId?: string,
+    trustedPartyId?: string
+  ): Promise<LoadedCategoryTree> {
+    const rootCategories = trustedPartyId
+      ? (await this.categoryService.getTrustedPartyCategories(trustedPartyId))
+          .categories
+      : await this.categoryService.getCategories();
+
+    const selectedCategory = selectedCategoryId
+      ? await this.categoryService.getCategory(selectedCategoryId)
+      : null;
+
+    const categoryPromises = categoryTrees.map(async (x) => ({
+      categoryTree: x,
+      category: await this.loadCategory(
+        [...x],
+        rootCategories,
+        selectedCategory
+      ),
+    }));
+
+    const loadedCategories = await Promise.all(categoryPromises);
+
+    const loadedCategoryTree: LoadedCategoryTree = {
+      categories: [],
+      missingCategories: [],
+    };
+
+    loadedCategories.forEach((x) =>
+      x.category
+        ? loadedCategoryTree.categories.push(x.category)
+        : loadedCategoryTree.missingCategories.push(x.categoryTree)
+    );
+
+    return loadedCategoryTree;
+  }
+
+  async loadCategoriesForRole(
+    categories: { category: string[]; accessLevel: AccessLevel }[]
+  ): Promise<{ category: CurrentCategory; accessLevel: AccessLevel }[]> {
+    const rootCategories = await this.categoryService.getCategories();
+
+    return await Promise.all(
+      categories.map(async (x) => ({
+        category: await this.loadCategory([...x.category], rootCategories),
+        accessLevel: x.accessLevel,
+      }))
+    );
+  }
+
+  private async loadCategory(
+    categoryTree: string[],
+    categories: Category[],
+    selectedCategory?: VaultCategory
+  ): Promise<CurrentCategory> {
+    const name = categoryTree.shift();
+
+    const currentCategory = categories.find(
+      (x) => x.code === name && !x.isCustom
+    );
+
+    if (currentCategory) {
+      if (categoryTree.length) {
+        const { subCategories } = await this.categoryService.getCategory(
+          currentCategory.id
+        );
+        return this.loadCategory(categoryTree, subCategories, selectedCategory);
+      } else {
+        const { category } = await this.categoryService.getCategory(
+          currentCategory.id
+        );
+
+        if (
+          selectedCategory &&
+          selectedCategory.category.parents.some((x) => x.id === category.id)
+        ) {
+          return selectedCategory.category;
+        }
+        return category;
+      }
+    } else if (categoryTree.length) {
+      return this.loadCategory(categoryTree, categories, selectedCategory);
+    } else {
+      return null;
+    }
+  }
+}

package/src/lib/category/category.gql.ts

@@ -0,0 +1,449 @@
+import { HasKeyGraph } from './../cryptography/cryptography.types';
+import { KeyGraphFragment } from '../_common/queries.gql';
+import gql from 'graphql-tag';
+import { HasKeyGraphEdges, HasEdges } from '../_common/types';
+
+export const DEFAULT_BREADCRUMB_DEPTH = 5;
+export const DEFAULT_DESCENDANTS_DEPTH = 5;
+
+export enum DirectoryType {
+  Vault = 'vault',
+  Category = 'category',
+  Record = 'record',
+}
+
+export const DefaultVaultFilter = JSON.stringify({
+  filter: [
+    {
+      contains: {
+        directoryType: DirectoryType.Vault,
+        default: true,
+      },
+    },
+  ],
+});
+
+export const CategoryFilter = JSON.stringify({
+  filter: [
+    {
+      contains: {
+        directoryType: DirectoryType.Category,
+      },
+    },
+  ],
+});
+
+export const RecordFilter = JSON.stringify({
+  filter: [
+    {
+      contains: {
+        directoryType: DirectoryType.Record,
+      },
+    },
+  ],
+});
+
+export const AccessFields = `
+accessRoles {
+  role
+  method
+  inheritedFrom {
+    id
+  }
+  trustedParty {
+    id
+  }
+  isIssuer
+}`;
+
+const descendantDirectories = `
+descendantDirectories(depth: ${DEFAULT_DESCENDANTS_DEPTH}, plainMeta: $categoryFilter, archived: false) {
+  recordsCount: directoriesCount(plainMeta: $recordFilter, archived: false)
+}
+`;
+
+export const CategoryFields = `
+  id
+  keyId
+  archived
+  plainMeta
+  cipherMeta
+  ${AccessFields}
+  ${descendantDirectories}
+`;
+
+export const VaultFields = `
+  id
+  keyId
+  plainMeta
+  cipherMeta
+`;
+
+export const GetRootDirectoryIdsQuery = gql`
+  query GetRootDirectoryIdsQuery($archived: Boolean) {
+    rootDirectories(archived: $archived) {
+      edges {
+        node {
+          id
+        }
+      }
+    }
+  }
+`;
+
+export const GetCategoriesQuery = gql`
+query GetCategories($vaultFilter: LrJSONFilter!, $categoryFilter: LrJSONFilter!, $recordFilter: LrJSONFilter!, $archived: Boolean, $cachedKeyIds: [LrRelayIdInput!])
+{
+  vaults: rootDirectories(plainMeta: $vaultFilter) {
+    edges {
+      node {
+        childDirectoryLinks(plainMeta: $categoryFilter, orderBy: "created", archived: $archived) {
+          edges {
+            node {
+              childDirectory {
+                ${CategoryFields}
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  keyGraph(cachedKeyIds: $cachedKeyIds) {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment}
+`;
+
+export const GetVaultsQuery = gql`
+query GetVaults($plainMetaFilter: LrJSONFilter!, $cachedKeyIds: [LrRelayIdInput!])
+{
+  list: rootDirectories(plainMeta: $plainMetaFilter, orderBy: "created") {
+    edges {
+      node {
+        ${VaultFields}
+      }
+    }
+  }
+  keyGraph(cachedKeyIds: $cachedKeyIds) {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment}
+`;
+
+export interface GetTrustedPartyCategoriesQueryType extends HasKeyGraph {
+  tp: {
+    sharedItems: {
+      list: HasEdges<any>;
+      records: HasEdges<any>;
+    };
+  };
+}
+
+export const GetTrustedPartyCategoriesQuery = gql`
+query GetTrustedPartyCategoriesQuery($trustedPartyId: LrRelayIdInput!, $categoryFilter: LrJSONFilter!, $recordFilter: LrJSONFilter!, $contentFilter: LrJSONFilter, $cachedKeyIds: [LrRelayIdInput!])
+{
+  tp(id: $trustedPartyId) {
+    sharedItems {
+      list: directories(plainMeta: $categoryFilter, orderBy: "created") {
+        edges {
+          node {
+            ${CategoryFields}
+          }
+        }
+      }
+      records: directories(plainMeta: $recordFilter, orderBy: "created") {
+        edges {
+          node {
+            id
+            keyId
+            archived
+            plainMeta
+            cipherMeta
+            created
+            modified
+            ${AccessFields}
+            content: childFileLinks(plainMeta: $contentFilter) {
+              edges {
+                node {
+                  childFile {
+                    id
+                    archived
+                    currentVersion {
+                      state {
+                        keyId
+                        plainMeta
+                        cipherMeta
+                        created
+                        modified
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  keyGraph(cachedKeyIds: $cachedKeyIds) {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment}
+`;
+
+export interface GetMySharedCategoriesQueryType extends HasKeyGraph {
+  tp: {
+    myItems: {
+      list: HasEdges<any>;
+      records: HasEdges<any>;
+    };
+  };
+}
+
+export const GetMySharedCategoriesQuery = gql`
+query GetMySharedCategoriesQuery($trustedPartyId: LrRelayIdInput!, $categoryFilter: LrJSONFilter!, $recordFilter: LrJSONFilter!, $contentFilter: LrJSONFilter, $cachedKeyIds: [LrRelayIdInput!])
+{
+  tp(id: $trustedPartyId) {
+    myItems {
+      list: directories(plainMeta: $categoryFilter, orderBy: "created") {
+        edges {
+          node {
+            ${CategoryFields}
+          }
+        }
+      }
+      records: directories(plainMeta: $recordFilter, orderBy: "created") {
+        edges {
+          node {
+            id
+            keyId
+            archived
+            plainMeta
+            cipherMeta
+            created
+            modified
+            ${AccessFields}
+            content: childFileLinks(plainMeta: $contentFilter) {
+              edges {
+                node {
+                  childFile {
+                    id
+                    archived
+                    currentVersion {
+                      state {
+                        keyId
+                        plainMeta
+                        cipherMeta
+                        created
+                        modified
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  keyGraph(cachedKeyIds: $cachedKeyIds) {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment}
+`;
+
+export const parentCategoriesField = (depth = DEFAULT_BREADCRUMB_DEPTH) => {
+  if (!depth) {
+    return '';
+  }
+  return `
+parentCategories: parentDirectoryLinks(plainMeta: $categoryFilter) {
+  edges {
+    node {
+      parentDirectory {
+        id
+        keyId
+        archived
+        plainMeta
+        cipherMeta
+        ${parentCategoriesField(depth - 1)}
+        ${AccessFields}
+      }
+    }
+  }
+}
+`;
+};
+
+export const GetCategoryQuery = (
+  depth: number = DEFAULT_BREADCRUMB_DEPTH
+) => gql`
+query GetCategory(
+  $id: LrRelayIdInput!,
+  $categoryFilter: LrJSONFilter!,
+  $recordFilter: LrJSONFilter!,
+  $contentFilter: LrJSONFilter,
+  $cachedKeyIds: [LrRelayIdInput!]) {
+  category: directory(id: $id) {
+    id
+    keyId
+    archived
+    plainMeta
+    cipherMeta
+    ${AccessFields}
+    ${descendantDirectories}
+    ${parentCategoriesField(depth)}
+    subCategories: childDirectoryLinks(plainMeta: $categoryFilter, orderBy: "created") {
+      edges {
+        node {
+          childDirectory {
+            ${CategoryFields}
+          }
+        }
+      }
+    }
+    records: childDirectoryLinks(plainMeta: $recordFilter, orderBy: "created") {
+      edges {
+        node {
+          childDirectory {
+            id
+            keyId
+            archived
+            plainMeta
+            cipherMeta
+            created
+            modified
+            ${AccessFields}
+            content: childFileLinks(plainMeta: $contentFilter) {
+              edges {
+                node {
+                  childFile {
+                    id
+                    archived
+                    currentVersion {
+                      state {
+                        keyId
+                        plainMeta
+                        cipherMeta
+                        created
+                        modified
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  keyGraph(cachedKeyIds: $cachedKeyIds) {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment} `;
+
+export const GetCategoryKeyIdQuery = gql`
+  query GetCategoryKeyIdQuery(
+    $id: LrRelayIdInput!
+    $cachedKeyIds: [LrRelayIdInput!]
+  ) {
+    category: directory(id: $id) {
+      keyId
+    }
+    keyGraph(cachedKeyIds: $cachedKeyIds) {
+      ...KeyGraphFragment
+    }
+  }
+  ${KeyGraphFragment}
+`;
+
+export const CreateCategoryMutation = gql`
+  mutation CreateCategory(
+    $plainMeta: LrJSONString
+    $cipherMeta: String
+    $parentDirectories: [ParentDirectoryInput!]
+    $parentRootDirectory: ParentRootDirectoryInput
+  ) {
+    new: createDirectory(
+      input: {
+        plainMeta: $plainMeta
+        cipherMeta: $cipherMeta
+        parentDirectories: $parentDirectories
+        parentRootDirectory: $parentRootDirectory
+      }
+    ) {
+      category: directory {
+        id
+        keyId
+      }
+    }
+  }
+`;
+
+export const CreateVaultMutation = gql`
+  mutation CreateCategory(
+    $plainMeta: LrJSONString
+    $cipherMeta: String
+    $parentRootDirectory: ParentRootDirectoryInput
+  ) {
+    new: createDirectory(
+      input: {
+        plainMeta: $plainMeta
+        cipherMeta: $cipherMeta
+        parentRootDirectory: $parentRootDirectory
+      }
+    ) {
+      vault: directory {
+        id
+        keyId
+      }
+    }
+  }
+`;
+
+export const UpdateCategoryMutation = gql`
+  mutation UpdateCategory($input: UpdateDirectoryInput!) {
+    updateDirectory(input: $input) {
+      directory {
+        id
+      }
+    }
+  }
+`;
+
+export const DeleteCategoryMutation = gql`
+  mutation DeleteCategory($categoryId: LrRelayIdInput!) {
+    deleteDirectory(input: { directoryId: $categoryId }) {
+      id
+    }
+  }
+`;
+
+export const ArchiveDirectoryMutation = gql`
+  mutation ArchiveDirectory($input: ArchiveDirectoryInput!) {
+    archiveDirectory(input: $input) {
+      directory {
+        id
+      }
+    }
+  }
+`;
+
+export const UnarchiveDirectoryMutation = gql`
+  mutation UnarchiveDirectory($input: UnarchiveDirectoryInput!) {
+    unarchiveDirectory(input: $input) {
+      directory {
+        id
+      }
+    }
+  }
+`;

package/src/lib/category/category.service.spec.ts

@@ -0,0 +1,26 @@
+import { TestBed } from '@angular/core/testing';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { lrConfigureTestingModule } from '../_common/tests';
+import { CategoryService } from './category.service';
+
+const keyMetaService = jasmine.createSpyObj<KeyMetaService>('PasswordService', [
+  'wrapContent',
+]);
+const lrApollo = jasmine.createSpyObj<LrApolloService>('PasswordService', [
+  'query',
+  'mutate',
+]);
+
+describe('FolderService', () => {
+  let service: CategoryService;
+
+  beforeEach(async () => {
+    lrConfigureTestingModule();
+    service = TestBed.inject(CategoryService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});