member related data commands

src/command/communicationCommand.ts

@@ -0,0 +1,28 @@
+export interface CreateCommunicationCommand {
+  preferred: boolean;
+  mobile: string;
+  email: string;
+  city: string;
+  street: string;
+  streetNumber: number;
+  streetNumberAddition: string;
+  memberId: number;
+  typeId: number;
+}
+
+export interface UpdateCommunicationCommand {
+  id: number;
+  preferred: boolean;
+  mobile: string;
+  email: string;
+  city: string;
+  street: string;
+  streetNumber: number;
+  streetNumberAddition: string;
+  memberId: number;
+}
+
+export interface DeleteCommunicationCommand {
+  id: number;
+  memberId: number;
+}

src/command/communicationCommandHandler.ts

@@ -0,0 +1,96 @@
+import { dataSource } from "../data-source";
+import { communication } from "../entity/communication";
+import { communicationType } from "../entity/communicationType";
+import { user } from "../entity/user";
+import InternalException from "../exceptions/internalException";
+import {
+  CreateCommunicationCommand,
+  DeleteCommunicationCommand,
+  UpdateCommunicationCommand,
+} from "./communicationCommand";
+
+export default abstract class CommunicationCommandHandler {
+  /**
+   * @description create communication
+   * @param CreateCommunicationCommand
+   * @returns {Promise<number>}
+   */
+  static async create(createCommunication: CreateCommunicationCommand): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(communication)
+      .values({
+        preferred: createCommunication.preferred,
+        mobile: createCommunication.mobile,
+        email: createCommunication.email,
+        city: createCommunication.city,
+        street: createCommunication.street,
+        streetNumber: createCommunication.streetNumber,
+        streetNumberAddition: createCommunication.streetNumberAddition,
+        member: await dataSource
+          .getRepository(user)
+          .createQueryBuilder("user")
+          .where("id = :id", { id: createCommunication.memberId })
+          .getOneOrFail(),
+        type: await dataSource
+          .getRepository(communicationType)
+          .createQueryBuilder("communication")
+          .where("id = :id", { id: createCommunication.typeId })
+          .getOneOrFail(),
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new InternalException("Failed creating communication", err);
+      });
+  }
+
+  /**
+   * @description update communication
+   * @param UpdateCommunicationCommand
+   * @returns {Promise<void>}
+   */
+  static async update(updateCommunication: UpdateCommunicationCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(communication)
+      .set({
+        preferred: updateCommunication.preferred,
+        mobile: updateCommunication.mobile,
+        email: updateCommunication.email,
+        city: updateCommunication.city,
+        street: updateCommunication.street,
+        streetNumber: updateCommunication.streetNumber,
+        streetNumberAddition: updateCommunication.streetNumberAddition,
+      })
+      .where("id = :id", { id: updateCommunication.id })
+      .andWhere("memberId = :memberId", { memberId: updateCommunication.memberId })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed updating communication", err);
+      });
+  }
+
+  /**
+   * @description delete communication
+   * @param DeleteCommunicationCommand
+   * @returns {Promise<void>}
+   */
+  static async delete(deletCommunication: DeleteCommunicationCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(communication)
+      .where("id = :id", { id: deletCommunication.id })
+      .andWhere("memberId = :memberId", { memberId: deletCommunication.memberId })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed deleting communication", err);
+      });
+  }
+}

src/command/memberAwardCommand.ts

@@ -0,0 +1,21 @@
+export interface CreateMemberAwardCommand {
+  given: boolean;
+  note?: string;
+  date: Date;
+  memberId: number;
+  awardId: number;
+}
+
+export interface UpdateMemberAwardCommand {
+  id: number;
+  given: boolean;
+  note?: string;
+  date: Date;
+  memberId: number;
+  awardId: number;
+}
+
+export interface DeleteMemberAwardCommand {
+  id: number;
+  memberId: number;
+}

src/command/memberAwardCommandHandler.ts

@@ -0,0 +1,89 @@
+import { dataSource } from "../data-source";
+import { award } from "../entity/award";
+import { memberAwards } from "../entity/memberAwards";
+import { user } from "../entity/user";
+import InternalException from "../exceptions/internalException";
+import { CreateMemberAwardCommand, DeleteMemberAwardCommand, UpdateMemberAwardCommand } from "./memberAwardCommand";
+
+export default abstract class MemberAwardCommandHandler {
+  /**
+   * @description create memberAward
+   * @param CreateMemberAwardCommand
+   * @returns {Promise<number>}
+   */
+  static async create(createMemberAward: CreateMemberAwardCommand): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(memberAwards)
+      .values({
+        given: createMemberAward.given,
+        note: createMemberAward.note,
+        date: createMemberAward.date,
+        member: await dataSource
+          .getRepository(user)
+          .createQueryBuilder("user")
+          .where("id = :id", { id: createMemberAward.memberId })
+          .getOneOrFail(),
+        award: await dataSource
+          .getRepository(award)
+          .createQueryBuilder("award")
+          .where("id = :id", { id: createMemberAward.awardId })
+          .getOneOrFail(),
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new InternalException("Failed creating memberAward", err);
+      });
+  }
+
+  /**
+   * @description update memberAward
+   * @param UpdateMemberAwardCommand
+   * @returns {Promise<void>}
+   */
+  static async update(updateMemberAward: UpdateMemberAwardCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(memberAwards)
+      .set({
+        given: updateMemberAward.given,
+        note: updateMemberAward.note,
+        date: updateMemberAward.date,
+        award: await dataSource
+          .getRepository(award)
+          .createQueryBuilder("award")
+          .where("id = :id", { id: updateMemberAward.awardId })
+          .getOneOrFail(),
+      })
+      .where("id = :id", { id: updateMemberAward.id })
+      .andWhere("memberId = :memberId", { memberId: updateMemberAward.memberId })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed updating memberAward", err);
+      });
+  }
+
+  /**
+   * @description delete memberAward
+   * @param DeleteMemberAwardCommand
+   * @returns {Promise<void>}
+   */
+  static async delete(deletMemberAward: DeleteMemberAwardCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(memberAwards)
+      .where("id = :id", { id: deletMemberAward.id })
+      .andWhere("memberId = :memberId", { memberId: deletMemberAward.memberId })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed deleting memberAward", err);
+      });
+  }
+}

src/command/memberCommand.ts

@@ -17,6 +17,11 @@ export interface UpdateMemberCommand {
   birthdate: Date;
 }
 
+export interface UpdateMemberNewsletterCommand {
+  id: number;
+  communicationId: number;
+}
+
 export interface DeleteMemberCommand {
   id: number;
 }

src/command/memberCommandHandler.ts

@@ -1,7 +1,14 @@
 import { dataSource } from "../data-source";
+import { communication } from "../entity/communication";
 import { member } from "../entity/member";
 import InternalException from "../exceptions/internalException";
-import { CreateMemberCommand, DeleteMemberCommand, UpdateMemberCommand } from "./memberCommand";
+import CommunicationService from "../service/communicationService";
+import {
+  CreateMemberCommand,
+  DeleteMemberCommand,
+  UpdateMemberCommand,
+  UpdateMemberNewsletterCommand,
+} from "./memberCommand";
 
 export default abstract class MemberCommandHandler {
   /**
@@ -55,6 +62,32 @@ export default abstract class MemberCommandHandler {
       });
   }
 
+  /**
+   * @description update member newsletter
+   * @param UpdateMemberCommand
+   * @returns {Promise<void>}
+   */
+  static async updateNewsletter(updateMember: UpdateMemberNewsletterCommand): Promise<void> {
+    console.log(updateMember);
+    return await dataSource
+      .createQueryBuilder()
+      .update(member)
+      .set({
+        sendNewsletter: await dataSource
+          .getRepository(communication)
+          .createQueryBuilder("communication")
+          .where("id = :id", { id: updateMember.communicationId })
+          .andWhere("memberId = :memberId", { memberId: updateMember.id })
+          .getOneOrFail(),
+      })
+      .where("id = :id", { id: updateMember.id })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed updating member", err);
+      });
+  }
+
   /**
    * @description delete member
    * @param DeleteMemberCommand

src/command/memberExecutivePositionCommand.ts

@@ -0,0 +1,21 @@
+export interface CreateMemberExecutivePositionCommand {
+  note?: string;
+  start: Date;
+  end?: Date;
+  memberId: number;
+  executivePositionId: number;
+}
+
+export interface UpdateMemberExecutivePositionCommand {
+  id: number;
+  note?: string;
+  start: Date;
+  end?: Date;
+  memberId: number;
+  executivePositionId: number;
+}
+
+export interface DeleteMemberExecutivePositionCommand {
+  id: number;
+  memberId: number;
+}

src/command/memberExecutivePositionCommandHandler.ts

@@ -0,0 +1,93 @@
+import { dataSource } from "../data-source";
+import { executivePosition } from "../entity/executivePosition";
+import { memberExecutivePositions } from "../entity/memberExecutivePositions";
+import { user } from "../entity/user";
+import InternalException from "../exceptions/internalException";
+import {
+  CreateMemberExecutivePositionCommand,
+  DeleteMemberExecutivePositionCommand,
+  UpdateMemberExecutivePositionCommand,
+} from "./memberExecutivePositionCommand";
+
+export default abstract class MemberExecutivePositionCommandHandler {
+  /**
+   * @description create memberExecutivePosition
+   * @param CreateMemberExecutivePositionCommand
+   * @returns {Promise<number>}
+   */
+  static async create(createMemberExecutivePosition: CreateMemberExecutivePositionCommand): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(memberExecutivePositions)
+      .values({
+        note: createMemberExecutivePosition.note,
+        start: createMemberExecutivePosition.start,
+        end: createMemberExecutivePosition.end,
+        member: await dataSource
+          .getRepository(user)
+          .createQueryBuilder("user")
+          .where("id = :id", { id: createMemberExecutivePosition.memberId })
+          .getOneOrFail(),
+        executivePosition: await dataSource
+          .getRepository(executivePosition)
+          .createQueryBuilder("executivePosition")
+          .where("id = :id", { id: createMemberExecutivePosition.executivePositionId })
+          .getOneOrFail(),
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new InternalException("Failed creating memberExecutivePosition", err);
+      });
+  }
+
+  /**
+   * @description update memberExecutivePosition
+   * @param UpdateMemberExecutivePositionCommand
+   * @returns {Promise<void>}
+   */
+  static async update(updateMemberExecutivePosition: UpdateMemberExecutivePositionCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(memberExecutivePositions)
+      .set({
+        note: updateMemberExecutivePosition.note,
+        start: updateMemberExecutivePosition.start,
+        end: updateMemberExecutivePosition.end,
+        executivePosition: await dataSource
+          .getRepository(executivePosition)
+          .createQueryBuilder("executivePosition")
+          .where("id = :id", { id: updateMemberExecutivePosition.executivePositionId })
+          .getOneOrFail(),
+      })
+      .where("id = :id", { id: updateMemberExecutivePosition.id })
+      .andWhere("memberId = :memberId", { memberId: updateMemberExecutivePosition.memberId })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed updating memberExecutivePosition", err);
+      });
+  }
+
+  /**
+   * @description delete memberExecutivePosition
+   * @param DeleteMemberExecutivePositionCommand
+   * @returns {Promise<void>}
+   */
+  static async delete(deletMemberExecutivePosition: DeleteMemberExecutivePositionCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(memberExecutivePositions)
+      .where("id = :id", { id: deletMemberExecutivePosition.id })
+      .andWhere("memberId = :memberId", { memberId: deletMemberExecutivePosition.memberId })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed deleting memberExecutivePosition", err);
+      });
+  }
+}

src/command/memberQualificationCommand.ts

@@ -0,0 +1,21 @@
+export interface CreateMemberQualificationCommand {
+  note?: string;
+  start: Date;
+  memberId: number;
+  qualificationId: number;
+}
+
+export interface UpdateMemberQualificationCommand {
+  id: number;
+  note?: string;
+  start: Date;
+  end?: Date;
+  terminationReason?: string;
+  memberId: number;
+  qualificationId: number;
+}
+
+export interface DeleteMemberQualificationCommand {
+  id: number;
+  memberId: number;
+}

src/command/memberQualificationCommandHandler.ts

@@ -0,0 +1,93 @@
+import { dataSource } from "../data-source";
+import { qualification } from "../entity/qualification";
+import { memberQualifications } from "../entity/memberQualifications";
+import { user } from "../entity/user";
+import InternalException from "../exceptions/internalException";
+import {
+  CreateMemberQualificationCommand,
+  DeleteMemberQualificationCommand,
+  UpdateMemberQualificationCommand,
+} from "./memberQualificationCommand";
+
+export default abstract class MemberQualificationCommandHandler {
+  /**
+   * @description create memberQualification
+   * @param CreateMemberQualificationCommand
+   * @returns {Promise<number>}
+   */
+  static async create(createMemberQualification: CreateMemberQualificationCommand): Promise<number> {
+    return await dataSource
+      .createQueryBuilder()
+      .insert()
+      .into(memberQualifications)
+      .values({
+        note: createMemberQualification.note,
+        start: createMemberQualification.start,
+        member: await dataSource
+          .getRepository(user)
+          .createQueryBuilder("user")
+          .where("id = :id", { id: createMemberQualification.memberId })
+          .getOneOrFail(),
+        qualification: await dataSource
+          .getRepository(qualification)
+          .createQueryBuilder("qualification")
+          .where("id = :id", { id: createMemberQualification.qualificationId })
+          .getOneOrFail(),
+      })
+      .execute()
+      .then((result) => {
+        return result.identifiers[0].id;
+      })
+      .catch((err) => {
+        throw new InternalException("Failed creating memberQualification", err);
+      });
+  }
+
+  /**
+   * @description update memberQualification
+   * @param UpdateMemberQualificationCommand
+   * @returns {Promise<void>}
+   */
+  static async update(updateMemberQualification: UpdateMemberQualificationCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(memberQualifications)
+      .set({
+        note: updateMemberQualification.note,
+        start: updateMemberQualification.start,
+        end: updateMemberQualification.end,
+        terminationReason: updateMemberQualification.terminationReason,
+        qualification: await dataSource
+          .getRepository(qualification)
+          .createQueryBuilder("qualification")
+          .where("id = :id", { id: updateMemberQualification.qualificationId })
+          .getOneOrFail(),
+      })
+      .where("id = :id", { id: updateMemberQualification.id })
+      .andWhere("memberId = :memberId", { memberId: updateMemberQualification.memberId })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed updating memberQualification", err);
+      });
+  }
+
+  /**
+   * @description delete memberQualification
+   * @param DeleteMemberQualificationCommand
+   * @returns {Promise<void>}
+   */
+  static async delete(deletMemberQualification: DeleteMemberQualificationCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(memberQualifications)
+      .where("id = :id", { id: deletMemberQualification.id })
+      .andWhere("memberId = :memberId", { memberId: deletMemberQualification.memberId })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed deleting memberQualification", err);
+      });
+  }
+}

src/command/membershipCommand.ts

@@ -0,0 +1,21 @@
+export interface CreateMembershipCommand {
+  internalId?: string;
+  start: Date;
+  memberId: number;
+  statusId: number;
+}
+
+export interface UpdateMembershipCommand {
+  id: number;
+  internalId?: string;
+  start: Date;
+  end?: Date;
+  terminationReason?: string;
+  memberId: number;
+  statusId: number;
+}
+
+export interface DeleteMembershipCommand {
+  id: number;
+  memberId: number;
+}

src/command/membershipCommandHandler.ts

@@ -0,0 +1,107 @@
+import { dataSource } from "../data-source";
+import { membership } from "../entity/membership";
+import { membershipStatus } from "../entity/membershipStatus";
+import { user } from "../entity/user";
+import InternalException from "../exceptions/internalException";
+import { CreateMembershipCommand, DeleteMembershipCommand, UpdateMembershipCommand } from "./membershipCommand";
+
+export default abstract class MembershipCommandHandler {
+  /**
+   * @description create membership
+   * @param CreateMembershipCommand
+   * @returns {Promise<number>}
+   */
+  static async create(createMembership: CreateMembershipCommand): Promise<number> {
+    let insertid = -1;
+    return await dataSource
+      .transaction(async (manager) => {
+        await manager
+          .createQueryBuilder()
+          .insert()
+          .into(membership)
+          .values({
+            internalId: createMembership.internalId,
+            start: createMembership.start,
+            member: await dataSource
+              .getRepository(user)
+              .createQueryBuilder("user")
+              .where("id = :id", { id: createMembership.memberId })
+              .getOneOrFail(),
+            status: await dataSource
+              .getRepository(membershipStatus)
+              .createQueryBuilder("membershipStatus")
+              .where("id = :id", { id: createMembership.statusId })
+              .getOneOrFail(),
+          })
+          .execute()
+          .then((result) => {
+            insertid = result.identifiers[0].id;
+          });
+
+        await manager
+          .createQueryBuilder()
+          .update(membership)
+          .set({
+            end: createMembership.start,
+          })
+          .where("end IS NULL")
+          .andWhere("memberId = :memberId", { memberId: createMembership.memberId })
+          .andWhere("id <> :id", { id: insertid })
+          .execute();
+      })
+      .then(() => {
+        return insertid;
+      })
+      .catch((err) => {
+        throw new InternalException("Failed creating membership", err);
+      });
+  }
+
+  /**
+   * @description update membership
+   * @param UpdateMembershipCommand
+   * @returns {Promise<void>}
+   */
+  static async update(updateMembership: UpdateMembershipCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .update(membership)
+      .set({
+        internalId: updateMembership.internalId,
+        start: updateMembership.start,
+        end: updateMembership.end,
+        terminationReason: updateMembership.terminationReason,
+        status: await dataSource
+          .getRepository(membershipStatus)
+          .createQueryBuilder("membershipStatus")
+          .where("id = :id", { id: updateMembership.statusId })
+          .getOneOrFail(),
+      })
+      .where("id = :id", { id: updateMembership.id })
+      .andWhere("memberId = :memberId", { memberId: updateMembership.memberId })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed updating membership", err);
+      });
+  }
+
+  /**
+   * @description delete membership
+   * @param DeleteMembershipCommand
+   * @returns {Promise<void>}
+   */
+  static async delete(deletMembership: DeleteMembershipCommand): Promise<void> {
+    return await dataSource
+      .createQueryBuilder()
+      .delete()
+      .from(membership)
+      .where("id = :id", { id: deletMembership.id })
+      .andWhere("memberId = :memberId", { memberId: deletMembership.memberId })
+      .execute()
+      .then(() => {})
+      .catch((err) => {
+        throw new InternalException("Failed deleting membership", err);
+      });
+  }
+}