@lifeready/core 1.0.0 → 1.0.1

package/src/lib/record/record-attachment.service.ts

@@ -0,0 +1,101 @@
+import { Injectable } from '@angular/core';
+import { FileType, DeleteFileMutation, CreateFileMutation } from './record.gql';
+import { NewAttachment, NewOrUpdatedAttachment } from './record.types';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { KeyMetaService } from '../cryptography/key-meta.service';
+import { FileService } from '../api/file.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class RecordAttachmentService {
+  constructor(
+    private fileService: FileService,
+    private lrApollo: LrApolloService,
+    private keyMetaService: KeyMetaService,
+    private keyGraph: KeyGraphService
+  ) {}
+
+  async downloadAttachment(
+    fileStateNodeId: string,
+    keyId: string
+  ): Promise<any> {
+    const encryptedFile = await this.fileService.downloadEncryptedFile(
+      fileStateNodeId
+    );
+
+    return await this.keyGraph.decryptFile(keyId, encryptedFile);
+  }
+
+  async uploadAttachments(
+    recordId: string,
+    attachments: NewOrUpdatedAttachment[]
+  ): Promise<string[]> {
+    const fileIds = await Promise.all(
+      (attachments || []).map(async (x) => {
+        if (x.fileId) {
+          if (x.isDeleted) {
+            await this.deleteAttachment(x.fileId);
+            return null;
+          } else {
+            return x.fileId;
+          }
+        } else {
+          return await this.addAttachment(recordId, x);
+        }
+      })
+    );
+    return fileIds.filter((x) => x);
+  }
+
+  private async addAttachment(
+    recordId: string,
+    attachment: NewAttachment
+  ): Promise<string> {
+    const secureContent = {
+      name: attachment.name,
+      fieldId: attachment.fieldId,
+      fileType: attachment.file.type,
+      fileSize: attachment.file.size,
+      lastModified: attachment.file.lastModified,
+    };
+    const fileContent = await this.fileService.loadFile(attachment.file);
+    const doubleWrappedContent = await this.keyMetaService.doubleWrapContent(
+      secureContent,
+      [recordId],
+      fileContent
+    );
+
+    const contentId = await this.fileService.uploadEncryptedFile({
+      encryptedContent: doubleWrappedContent.cipherFileContent,
+      fileName: attachment.name,
+    });
+
+    // Save file
+    const response = await this.lrApollo.mutate<any>({
+      mutation: CreateFileMutation,
+      variables: {
+        input: {
+          plainMeta: JSON.stringify({ fileType: FileType.RecordAttachment }),
+          wrappedStateKey: doubleWrappedContent.doubleWrappedKey,
+          cipherMeta: doubleWrappedContent.cipherMeta,
+          parentDirectories: doubleWrappedContent.wrappedKeys.map((x) => ({
+            directoryId: x.directoryId,
+            wrappingKeyId: x.wrappingKeyId,
+            wrappedFileKey: x.wrappedKey,
+          })),
+          contentResource: contentId,
+        },
+      },
+    });
+    return response.createFile.file.id;
+  }
+
+  async deleteAttachment(fileId: string): Promise<void> {
+    await this.lrApollo.mutate({
+      mutation: DeleteFileMutation,
+      variables: { fileId },
+    });
+  }
+}

package/src/lib/record/record.gql.ts

@@ -0,0 +1,192 @@
+import gql from 'graphql-tag';
+import { KeyGraphFragment } from '../_common/queries.gql';
+import {
+  DEFAULT_BREADCRUMB_DEPTH,
+  parentCategoriesField,
+  AccessFields,
+} from '../category/category.gql';
+
+export enum FileType {
+  RecordContent = 'record-content',
+  RecordAttachment = 'record-attachment',
+}
+
+export const RecordContentFilter = JSON.stringify({
+  filter: [
+    {
+      contains: {
+        fileType: FileType.RecordContent,
+      },
+    },
+  ],
+});
+
+export const RecordAttachmentFilter = JSON.stringify({
+  filter: [
+    {
+      contains: {
+        fileType: FileType.RecordAttachment,
+      },
+    },
+  ],
+});
+
+export const GetRecordQuery = (depth = DEFAULT_BREADCRUMB_DEPTH) => gql`
+query Record(
+  $id: LrRelayIdInput!,
+  $cachedKeyIds: [LrRelayIdInput!],
+  $categoryFilter: LrJSONFilter,
+  $contentFilter: LrJSONFilter,
+  $attachmentsFilter: LrJSONFilter,
+) {
+  record: directory(id: $id) {
+    id
+    keyId
+    archived
+    plainMeta
+    cipherMeta
+    created
+    modified
+    ${AccessFields}
+    ${parentCategoriesField(depth)}
+    content: childFileLinks(plainMeta: $contentFilter) {
+      edges {
+        node {
+          childFile {
+            id
+            keyId
+            archived
+            currentVersion {
+              state {
+                id
+                keyId
+                plainMeta
+                cipherMeta
+                created
+                modified
+              }
+            }
+            versions {
+              edges {
+                node {
+                  operation
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    attachments: childFileLinks(plainMeta: $attachmentsFilter) {
+      edges {
+        node {
+          childFile {
+            id
+            keyId
+            archived
+            currentVersion {
+              state {
+                id
+                keyId
+                plainMeta
+                cipherMeta
+                contentResource
+              }
+            }
+            versions {
+              edges {
+                node {
+                  operation
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  keyGraph(cachedKeyIds: $cachedKeyIds) {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment}
+`;
+
+export const CreateRecordContainerMutation = gql`
+  mutation CreateRecordContainer(
+    $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 CreateRecordMutation = gql`
+  mutation CreateFile($input: CreateFileInput!) {
+    createFile(input: $input) {
+      file {
+        id
+      }
+    }
+  }
+`;
+
+export const UpdateRecordContainerMutation = gql`
+  mutation UpdateRecord($input: UpdateDirectoryInput!) {
+    updateDirectory(input: $input) {
+      directory {
+        id
+      }
+    }
+  }
+`;
+
+export const UpdateRecordMutation = gql`
+  mutation UpdateFile($input: UpdateFileInput!) {
+    updateFile(input: $input) {
+      file {
+        id
+      }
+    }
+  }
+`;
+
+export const DeleteRecordMutation = gql`
+  mutation DeleteRecord($recordId: LrRelayIdInput!) {
+    deleteDirectory(input: { directoryId: $recordId }) {
+      id
+    }
+  }
+`;
+
+export const CreateFileMutation = gql`
+  mutation CreateFile($input: CreateFileInput!) {
+    createFile(input: $input) {
+      file {
+        id
+      }
+    }
+  }
+`;
+
+export const DeleteFileMutation = gql`
+  mutation DeleteFile($fileId: LrRelayIdInput!) {
+    deleteFile(input: { fileId: $fileId }) {
+      id
+    }
+  }
+`;