sync and create change

src/command/protocolAgendaCommandHandler.ts

@@ -4,6 +4,30 @@ import InternalException from "../exceptions/internalException";
 import { SynchronizeProtocolAgendaCommand } from "./protocolAgendaCommand";
 
 export default abstract class ProtocolAgendaCommandHandler {
+  /**
+   * @description create protocolAgenda
+   * @param {number}
+   * @returns {Promise<number>}
+   */
+  static async create(protocolId: number): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(protocolAgenda)
+      .values({
+        topic: "",
+        context: "",
+        protocolId,
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new InternalException("Failed creating protocol", err);
+      });
+  }
+
   /**
    * @description sync protocolAgenda
    * @param {Array<SynchronizeProtocolAgendaCommand>}

src/command/protocolDecisionCommandHandler.ts

@@ -4,6 +4,29 @@ import InternalException from "../exceptions/internalException";
 import { SynchronizeProtocolDecisionCommand } from "./protocolDecisionCommand";
 
 export default abstract class ProtocolDecisionCommandHandler {
+  /**
+   * @description create protocolDecision
+   * @param {number}
+   * @returns {Promise<number>}
+   */
+  static async create(protocolId: number): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(protocolDecision)
+      .values({
+        topic: "",
+        context: "",
+        protocolId,
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new InternalException("Failed creating protocol", err);
+      });
+  }
   /**
    * @description sync protocolDecision
    * @param {Array<SynchronizeProtocolDecisionCommand>}

src/command/protocolPresenceCommandHandler.ts

@@ -21,13 +21,17 @@ export default abstract class ProtocolPresenceCommandHandler {
         let newMembers = syncProtocolPresences.memberIds.filter((r) => !currentPresence.includes(r));
         let removeMembers = currentPresence.filter((r) => !syncProtocolPresences.memberIds.includes(r));
 
-        await this.syncPresenceAdd(manager, syncProtocolPresences.protocolId, newMembers);
+        if (newMembers.length != 0) {
+          await this.syncPresenceAdd(manager, syncProtocolPresences.protocolId, newMembers);
+        }
 
-        await this.syncPresenceRemove(manager, syncProtocolPresences.protocolId, removeMembers);
+        if (removeMembers.length != 0) {
+          await this.syncPresenceRemove(manager, syncProtocolPresences.protocolId, removeMembers);
+        }
       })
       .then(() => {})
       .catch((err) => {
-        throw new InternalException("Failed saving user roles", err);
+        throw new InternalException("Failed saving protocol presence", err);
       });
   }
 
@@ -43,7 +47,7 @@ export default abstract class ProtocolPresenceCommandHandler {
       .values(
         memberIds.map((m) => ({
           protocolId,
-          memberIds: m,
+          memberId: m,
         }))
       )
       .execute();
@@ -59,7 +63,7 @@ export default abstract class ProtocolPresenceCommandHandler {
       .delete()
       .from(protocolPresence)
       .where("memberId IN (:...ids)", { ids: memberIds })
-      .andWhere("protcolId = :protocolId", { protocolId })
+      .andWhere("protocolId = :protocolId", { protocolId })
       .execute();
   }
 }

src/command/protocolVotingCommandHandler.ts

@@ -4,6 +4,29 @@ import InternalException from "../exceptions/internalException";
 import { SynchronizeProtocolVotingCommand } from "./protocolVotingCommand";
 
 export default abstract class ProtocolVotingCommandHandler {
+  /**
+   * @description create protocolVoting
+   * @param {number}
+   * @returns {Promise<number>}
+   */
+  static async create(protocolId: number): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(protocolVoting)
+      .values({
+        topic: "",
+        context: "",
+        protocolId,
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new InternalException("Failed creating protocol", err);
+      });
+  }
   /**
    * @description sync protocolVoting
    * @param {Array<SynchronizeProtocolVotingCommand>}