improved backup restore

src/helpers/backupHelper.ts

@@ -1,6 +1,7 @@
 import { dataSource } from "../data-source";
 import { FileSystemHelper } from "./fileSystemHelper";
 import { EntityManager } from "typeorm";
+import uniqBy from "lodash.uniqby";
 import InternalException from "../exceptions/internalException";
 import UserService from "../service/user/userService";
 
@@ -137,7 +138,7 @@ export default abstract class BackupHelper {
       })
       .catch((err) => {
         this.transactionManager = undefined;
-        throw new InternalException("failed to restore backup - rolling back actions");
+        throw new InternalException("failed to restore backup - rolling back actions", err);
       });
   }
 
@@ -427,27 +428,45 @@ export default abstract class BackupHelper {
 
   private static async setMemberData(data: Array<any>): Promise<void> {
     await this.setMemberBase({
-      award: data
-        .map((d) => d.awards.map((c: any) => c.award))
-        .flat()
-        .map((d) => ({ ...d, id: undefined })),
-      communication_type: data
-        .map((d) => d.communications.map((c: any) => c.type))
-        .flat()
-        .map((d) => ({ ...d, id: undefined })),
-      executive_position: data
-        .map((d) => d.positions.map((c: any) => c.executivePosition))
-        .flat()
-        .map((d) => ({ ...d, id: undefined })),
-      membership_status: data
-        .map((d) => d.memberships.map((c: any) => c.status))
-        .flat()
-        .map((d) => ({ ...d, id: undefined })),
-      salutation: data.map((d) => d.salutation).map((d) => ({ ...d, id: undefined })),
-      qualification: data
-        .map((d) => d.qualifications.map((c: any) => c.qualification))
-        .flat()
-        .map((d) => ({ ...d, id: undefined })),
+      award: uniqBy(
+        data
+          .map((d) => d.awards.map((c: any) => c.award))
+          .flat()
+          .map((d) => ({ ...d, id: undefined })),
+        "award"
+      ),
+      communication_type: uniqBy(
+        data
+          .map((d) => d.communications.map((c: any) => c.type))
+          .flat()
+          .map((d) => ({ ...d, id: undefined })),
+        "type"
+      ),
+      executive_position: uniqBy(
+        data
+          .map((d) => d.positions.map((c: any) => c.executivePosition))
+          .flat()
+          .map((d) => ({ ...d, id: undefined })),
+        "position"
+      ),
+      membership_status: uniqBy(
+        data
+          .map((d) => d.memberships.map((c: any) => c.status))
+          .flat()
+          .map((d) => ({ ...d, id: undefined })),
+        "status"
+      ),
+      salutation: uniqBy(
+        data.map((d) => d.salutation).map((d) => ({ ...d, id: undefined })),
+        "salutation"
+      ),
+      qualification: uniqBy(
+        data
+          .map((d) => d.qualifications.map((c: any) => c.qualification))
+          .flat()
+          .map((d) => ({ ...d, id: undefined })),
+        "qualification"
+      ),
     });
 
     let salutation = await this.transactionManager.getRepository("salutation").find();
@@ -501,46 +520,55 @@ export default abstract class BackupHelper {
     await this.transactionManager.getRepository("member").save(dataWithMappedIds);
   }
   private static async setMemberBase(data: { [key: string]: Array<any> }): Promise<void> {
+    let salutation = await this.transactionManager.getRepository("salutation").find();
+    let communication = await this.transactionManager.getRepository("communication_type").find();
+    let membership = await this.transactionManager.getRepository("membership_status").find();
+    let award = await this.transactionManager.getRepository("award").find();
+    let qualification = await this.transactionManager.getRepository("qualification").find();
+    let position = await this.transactionManager.getRepository("executive_position").find();
+
     await this.transactionManager
       .createQueryBuilder()
       .insert()
       .into("award")
-      .values(data?.["award"] ?? [])
+      .values((data?.["award"] ?? []).filter((d) => !award.map((a) => a.award).includes(d.award)))
       .orIgnore()
       .execute();
     await this.transactionManager
       .createQueryBuilder()
       .insert()
       .into("communication_type")
-      .values(data?.["communication_type"] ?? [])
+      .values((data?.["communication_type"] ?? []).filter((d) => !communication.map((c) => c.type).includes(d.type)))
       .orIgnore()
       .execute();
     await this.transactionManager
       .createQueryBuilder()
       .insert()
       .into("executive_position")
-      .values(data?.["executive_position"] ?? [])
+      .values((data?.["executive_position"] ?? []).filter((d) => !position.map((p) => p.position).includes(d.position)))
       .orIgnore()
       .execute();
     await this.transactionManager
       .createQueryBuilder()
       .insert()
       .into("membership_status")
-      .values(data?.["membership_status"] ?? [])
+      .values((data?.["membership_status"] ?? []).filter((d) => !membership.map((m) => m.status).includes(d.status)))
       .orIgnore()
       .execute();
     await this.transactionManager
       .createQueryBuilder()
       .insert()
       .into("salutation")
-      .values(data?.["salutation"] ?? [])
+      .values((data?.["salutation"] ?? []).filter((d) => !salutation.map((s) => s.salutation).includes(d.salutation)))
       .orIgnore()
       .execute();
     await this.transactionManager
       .createQueryBuilder()
       .insert()
       .into("qualification")
-      .values(data?.["qualification"] ?? [])
+      .values(
+        (data?.["qualification"] ?? []).filter((d) => !qualification.map((q) => q.award).includes(d.qualification))
+      )
       .orIgnore()
       .execute();
   }
@@ -569,7 +597,12 @@ export default abstract class BackupHelper {
     await this.transactionManager.getRepository("protocol").save(dataWithMappedIds);
   }
   private static async setNewsletter(data: Array<any>, collectedIds: boolean): Promise<void> {
-    await this.setQueryStore(data.map((d) => d.recipientsByQueryId).map((d) => ({ ...d, id: undefined })));
+    await this.setQueryStore(
+      uniqBy(
+        data.map((d) => d.recipientsByQueryId).map((d) => ({ ...d, id: undefined })),
+        "query"
+      )
+    );
 
     let queries = await this.transactionManager.getRepository("query").find();
     let members = await this.transactionManager.getRepository("member").find();
@@ -601,7 +634,10 @@ export default abstract class BackupHelper {
   }
   private static async setNewsletterConfig(data: Array<any>): Promise<void> {
     await this.setMemberBase({
-      communication_type: data.map((d) => d.comType).map((d) => ({ ...d, id: undefined })),
+      communication_type: uniqBy(
+        data.map((d) => d.comType).map((d) => ({ ...d, id: undefined })),
+        "type"
+      ),
     });
 
     let types = await this.transactionManager.getRepository("communication_type").find();
@@ -621,7 +657,7 @@ export default abstract class BackupHelper {
       .createQueryBuilder()
       .insert()
       .into("award")
-      .values([...(data?.["calendar_type"] ?? []), ...usedTypes])
+      .values(uniqBy([...(data?.["calendar_type"] ?? []), ...usedTypes], "type"))
       .orIgnore()
       .execute();
 
@@ -636,7 +672,15 @@ export default abstract class BackupHelper {
     await this.transactionManager.getRepository("calendar").save(dataWithMappedIds);
   }
   private static async setQueryStore(data: Array<any>): Promise<void> {
-    await this.transactionManager.createQueryBuilder().insert().into("query").values(data).orIgnore().execute();
+    let query = await this.transactionManager.getRepository("query").find();
+
+    await this.transactionManager
+      .createQueryBuilder()
+      .insert()
+      .into("query")
+      .values(data.filter((d) => !query.map((s) => s.query).includes(d.query)))
+      .orIgnore()
+      .execute();
   }
   private static async setTemplate(data: { [key: string]: Array<any> }): Promise<void> {
     await this.transactionManager
@@ -664,7 +708,7 @@ export default abstract class BackupHelper {
       .createQueryBuilder()
       .insert()
       .into("role")
-      .values([...(data?.["role"] ?? []), ...usedRoles])
+      .values(uniqBy([...(data?.["role"] ?? []), ...usedRoles], "role"))
       .orIgnore()
       .execute();