ff-admin-server/src/command/membershipCommandHandler.ts

import { dataSource } from "../data-source";
import { member } from "../entity/member";
import { membership } from "../entity/membership";
import { membershipStatus } from "../entity/membershipStatus";
import InternalException from "../exceptions/internalException";
import { CreateMembershipCommand, DeleteMembershipCommand, UpdateMembershipCommand } from "./membershipCommand";

export default abstract class MembershipCommandHandler {
  /**
   * @description create membership
   * @param {CreateMembershipCommand} createMembership
   * @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({
            start: createMembership.start,
            member: await dataSource
              .getRepository(member)
              .createQueryBuilder("member")
              .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,
            terminationReason: "beendet durch neuen Eintrag.",
          })
          .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} updateMembership
   * @returns {Promise<void>}
   */
  static async update(updateMembership: UpdateMembershipCommand): Promise<void> {
    return await dataSource
      .createQueryBuilder()
      .update(membership)
      .set({
        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} deleteMembership
   * @returns {Promise<void>}
   */
  static async delete(deleteMembership: DeleteMembershipCommand): Promise<void> {
    return await dataSource
      .createQueryBuilder()
      .delete()
      .from(membership)
      .where("id = :id", { id: deleteMembership.id })
      .andWhere("memberId = :memberId", { memberId: deleteMembership.memberId })
      .execute()
      .then(() => {})
      .catch((err) => {
        throw new InternalException("Failed deleting membership", err);
      });
  }
}