@lifeready/core 1.0.0 → 1.0.1

package/src/lib/scenario/scenario-setup.service.ts

@@ -0,0 +1,369 @@
+import { LrException } from './../_common/exceptions';
+import { Injectable } from '@angular/core';
+import { PreparedPermissions } from './../api/key-exchange.types';
+import {
+  CreateScenarioApprovalGroups,
+  UpdateScenarioApprovalGroups,
+} from './approvals/scenario-approval.types';
+import { ScenarioApproverService } from './approvals/scenario-approver.service';
+import { ScenarioClaimantService } from './claimants/scenario-claimant.service';
+import { ScenarioReceiverService } from './receivers/scenario-receiver.service';
+import {
+  Receiver,
+  UpdateScenarioReceiverItemInput,
+} from './receivers/scenario-receiver.types';
+import { ScenarioService } from './scenario.service';
+import {
+  NewScenario,
+  UpdatedScenarioClaimant,
+  UpdatedScenarioReceiver,
+  UpdateScenario,
+} from './scenario.types';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ScenarioSetupService {
+  constructor(
+    private scenarioService: ScenarioService,
+    private scenarioClaimantService: ScenarioClaimantService,
+    private scenarioApproverService: ScenarioApproverService,
+    private scenarioReceiverService: ScenarioReceiverService
+  ) {}
+
+  public async setupScenario(
+    newScenario: NewScenario
+  ): Promise<{ scenarioId: string; error?: LrException }> {
+    const scenarioId = await this.scenarioService.createScenario({
+      plainSubjectCipherData: {
+        event: newScenario.event,
+        name: newScenario.name,
+      },
+    });
+
+    try {
+      await Promise.all(
+        newScenario.claimants.map((x) =>
+          this.updateClaimant(scenarioId, newScenario.event, x)
+        )
+      );
+
+      const scenario = await this.scenarioService.getScenario(scenarioId);
+      if (newScenario.approvalGroups.length) {
+        const approvalGroups: CreateScenarioApprovalGroups = {
+          scenarioId,
+          keyId: scenario.keyId,
+          event: scenario.event,
+          singleReject: false,
+          quorum: 1,
+          plainAssemblyCipherData: null,
+
+          approvalGroups: newScenario.approvalGroups.map((x) => ({
+            quorum: x.quorum,
+            singleReject: x.singleReject,
+            plainSubAssemblyCipherData: { name: x.name },
+            approvers: x.approvers.map((y) => ({
+              trustedPartyId: y.trustedPartyId,
+              trustedPartySharedKeyId: y.trustedPartySharedKeyId,
+              plainSharedCipherData: {
+                message: y.message,
+                event: newScenario.event,
+              },
+            })),
+          })),
+        };
+        scenario.assemblyKeyId = await this.scenarioApproverService.createScenarioApproverAssembly(
+          approvalGroups
+        );
+      }
+      await Promise.all(
+        newScenario.receivers.map((x) =>
+          this.updateReceiver(
+            scenarioId,
+            scenario.assemblyKeyId,
+            newScenario.event,
+            x
+          )
+        )
+      );
+    } catch (e) {
+      return { scenarioId, error: e };
+    }
+    return { scenarioId };
+  }
+
+  public async updateScenario(updateScenario: UpdateScenario): Promise<void> {
+    const params = {
+      scenarioId: updateScenario.scenarioId,
+      keyId: updateScenario.keyId,
+      plainSubjectCipherData: {
+        event: updateScenario.event,
+        name: updateScenario.name,
+      },
+    };
+    await this.scenarioService.updateScenario(params);
+
+    await Promise.all(
+      updateScenario.claimants.map((x) =>
+        this.updateClaimant(updateScenario.scenarioId, updateScenario.event, x)
+      )
+    );
+    await Promise.all(
+      updateScenario.deletedClaimantIds.map((x) =>
+        this.scenarioClaimantService.deleteClaimant(x)
+      )
+    );
+
+    const assemblyKeyId = await this.updateApprovalGroups(updateScenario);
+
+    await Promise.all(
+      updateScenario.receivers.map((x) =>
+        this.updateReceiver(
+          updateScenario.scenarioId,
+          assemblyKeyId,
+          updateScenario.event,
+          x
+        )
+      )
+    );
+    await Promise.all(
+      updateScenario.deletedReceiverIds.map((x) =>
+        this.scenarioReceiverService.deleteReceiver(x)
+      )
+    );
+  }
+
+  private async updateClaimant(
+    scenarioId: string,
+    event: string,
+    claimant: UpdatedScenarioClaimant
+  ) {
+    if (claimant.claimantId) {
+      await this.scenarioClaimantService.updateClaimant({
+        id: claimant.claimantId,
+        keyId: claimant.keyId,
+        plainSharedCipherData: { message: claimant.message, event },
+      });
+    } else {
+      await this.scenarioClaimantService.addClaimant({
+        scenarioId,
+        trustedPartyId: claimant.trustedPartyId,
+        trustedPartySharedKeyId: claimant.trustedPartySharedKeyId,
+        plainSharedCipherData: { message: claimant.message, event },
+      });
+    }
+  }
+
+  private async updateApprovalGroups(
+    updateScenario: UpdateScenario
+  ): Promise<string> {
+    if (updateScenario.assemblyKeyId) {
+      if (updateScenario.approvalGroups.length) {
+        const approvalGroups: UpdateScenarioApprovalGroups = {
+          scenarioId: updateScenario.scenarioId,
+          assemblyKeyId: updateScenario.assemblyKeyId,
+
+          singleReject: false,
+          quorum: 1,
+
+          approvalGroups: updateScenario.approvalGroups.map((x) => ({
+            subAssemblyId: x.subAssemblyId,
+            quorum: x.quorum,
+            singleReject: x.singleReject,
+            plainSubAssemblyCipherData: { name: x.name },
+            approvers: x.approvers.map((y) => ({
+              approverId: y.approverId,
+              keyId: y.keyId,
+              trustedPartyId: y.trustedPartyId,
+              trustedPartySharedKeyId: y.trustedPartySharedKeyId,
+              plainSharedCipherData: {
+                message: y.message,
+                event: updateScenario.event,
+              },
+            })),
+            deletedApproverIds: x.deletedApproverIds,
+          })),
+          deletedGroupIds: updateScenario.deletedGroupIds,
+        };
+        await this.scenarioApproverService.updateScenarioApproverAssembly(
+          approvalGroups
+        );
+        return updateScenario.assemblyKeyId;
+      } else {
+        const { receivers } = await this.scenarioService.getScenario(
+          updateScenario.scenarioId
+        );
+        await this.scenarioApproverService.deleteScenarioApproverAssembly(
+          updateScenario.scenarioId,
+          updateScenario.event,
+          receivers
+        );
+        return null;
+      }
+      // update or delete
+    } else if (updateScenario.approvalGroups.length) {
+      const { receivers } = await this.scenarioService.getScenario(
+        updateScenario.scenarioId
+      );
+
+      const approvalGroups: CreateScenarioApprovalGroups = {
+        scenarioId: updateScenario.scenarioId,
+        keyId: updateScenario.keyId,
+        event: updateScenario.event,
+        singleReject: false,
+        quorum: 1,
+        approvalGroups: updateScenario.approvalGroups.map((x) => ({
+          quorum: x.quorum,
+          singleReject: x.singleReject,
+          plainSubAssemblyCipherData: { name: x.name },
+          approvers: x.approvers.map((y) => ({
+            trustedPartyId: y.trustedPartyId,
+            trustedPartySharedKeyId: y.trustedPartySharedKeyId,
+            plainSharedCipherData: {
+              message: y.message,
+              event: updateScenario.event,
+            },
+          })),
+        })),
+        receivers,
+      };
+      return await this.scenarioApproverService.createScenarioApproverAssembly(
+        approvalGroups
+      );
+    }
+    return null;
+  }
+
+  private async updateReceiver(
+    scenarioId: string,
+    assemblyKeyId: string,
+    event: string,
+    receiver: UpdatedScenarioReceiver
+  ) {
+    let receiverId = receiver.receiverId;
+
+    // Currently deleting all receivers below assembly logic.
+    if (receiverId) {
+      await this.scenarioReceiverService.updateReceiver({
+        id: receiver.receiverId,
+        keyId: receiver.keyId,
+        plainSharedCipherData: { message: receiver.message, event },
+      });
+    } else {
+      const newReceiver = {
+        scenarioId,
+        trustedPartyId: receiver.trustedPartyId,
+        trustedPartySharedKeyId: receiver.trustedPartySharedKeyId,
+        plainSharedCipherData: { message: receiver.message, event },
+      };
+      receiverId = await this.scenarioReceiverService.addReceiver(newReceiver);
+    }
+    const loadedReceiver = await this.scenarioReceiverService.getReceiver(
+      receiverId
+    );
+    await this.updateReceiverItems(
+      scenarioId,
+      assemblyKeyId,
+      loadedReceiver,
+      receiver.permissions
+    );
+  }
+
+  private async updateReceiverItems(
+    scenarioId: string,
+    assemblyKeyId: string,
+    receiver: Receiver,
+    permissions: PreparedPermissions
+  ) {
+    permissions = permissions || {};
+    permissions.categories = permissions.categories || [];
+    permissions.records = permissions.records || [];
+
+    await Promise.all(
+      permissions.categories
+        .filter(
+          (x) =>
+            !receiver.categories.some((y) => y.category.id === x.categoryId)
+        )
+        .map(async (x) => {
+          const params = {
+            scenarioId,
+            assemblyKeyId,
+            receiverId: receiver.id,
+            receiverKeyId: receiver.keyId,
+            accessRole: x.accessLevel,
+            categoryId: x.categoryId,
+          };
+          await this.scenarioReceiverService.addReceiverCategory(params);
+        })
+    );
+    await Promise.all(
+      permissions.records
+        .filter(
+          (x) => !receiver.records.some((y) => y.record.id === x.recordId)
+        )
+        .map(async (x) => {
+          const params = {
+            scenarioId,
+            assemblyKeyId,
+            receiverId: receiver.id,
+            receiverKeyId: receiver.keyId,
+            accessRole: x.accessLevel,
+            recordId: x.recordId,
+          };
+          await this.scenarioReceiverService.addReceiverRecord(params);
+        })
+    );
+
+    await Promise.all(
+      permissions.categories
+        .map((x) => ({
+          accessLevel: x.accessLevel,
+          category: receiver.categories.find(
+            (y) => y.category.id === x.categoryId
+          ),
+        }))
+        .filter((x) => x.category)
+        .map(async (x) => {
+          const params: UpdateScenarioReceiverItemInput = {
+            id: x.category.id,
+            keyId: x.category.keyId,
+            accessRole: x.accessLevel,
+          };
+          await this.scenarioReceiverService.updateReceiverItem(params);
+        })
+    );
+    await Promise.all(
+      permissions.records
+        .map((x) => ({
+          accessLevel: x.accessLevel,
+          record: receiver.records.find((y) => y.record.id === x.recordId),
+        }))
+        .filter((x) => x.record)
+        .map(async (x) => {
+          const params: UpdateScenarioReceiverItemInput = {
+            id: x.record.id,
+            keyId: x.record.keyId,
+            accessRole: x.accessLevel,
+          };
+          await this.scenarioReceiverService.updateReceiverItem(params);
+        })
+    );
+
+    await Promise.all(
+      receiver.categories
+        .filter(
+          (x) =>
+            !permissions.categories.some((y) => y.categoryId === x.category.id)
+        )
+        .map((x) => this.scenarioReceiverService.deleteReceiverItem(x.id))
+    );
+    await Promise.all(
+      receiver.records
+        .filter(
+          (x) => !permissions.records.some((y) => y.recordId === x.record.id)
+        )
+        .map((x) => this.scenarioReceiverService.deleteReceiverItem(x.id))
+    );
+  }
+}