ff-admin-server/src/command/club/member/memberAwardCommandHandler.ts

import { dataSource } from "../../../data-source";
import { memberAwards } from "../../../entity/club/member/memberAwards";
import InternalException from "../../../exceptions/internalException";
import { CreateMemberAwardCommand, DeleteMemberAwardCommand, UpdateMemberAwardCommand } from "./memberAwardCommand";

export default abstract class MemberAwardCommandHandler {
  /**
   * @description create memberAward
   * @param {CreateMemberAwardCommand} createMemberAward
   * @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,
        memberId: createMemberAward.memberId,
        awardId: createMemberAward.awardId,
      })
      .execute()
      .then((result) => {
        return result.identifiers[0].id;
      })
      .catch((err) => {
        throw new InternalException("Failed creating memberAward", err);
      });
  }

  /**
   * @description update memberAward
   * @param {UpdateMemberAwardCommand} updateMemberAward
   * @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: updateMemberAward.awardId,
      })
      .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} deleteMemberAward
   * @returns {Promise<void>}
   */
  static async delete(deleteMemberAward: DeleteMemberAwardCommand): Promise<void> {
    return await dataSource
      .createQueryBuilder()
      .delete()
      .from(memberAwards)
      .where("id = :id", { id: deleteMemberAward.id })
      .andWhere("memberId = :memberId", { memberId: deleteMemberAward.memberId })
      .execute()
      .then(() => {})
      .catch((err) => {
        throw new InternalException("Failed deleting memberAward", err);
      });
  }
}