Taekwondo-Admin/packages/api/src/services/membersService.ts

import express from "express";
import {
    type MemberCreateArgs,
    type MemberDto,
    mapDbMemberToMember,
} from "../dtos/member.js";
import { inject, Injectable } from "../infrastructure/di/index.js";
import { ErrorStates } from "../infrastructure/errorStates.js";
import { DatabaseService } from "./db/prisma.js";

@Injectable()
export class MembersService {
    private readonly database = inject(DatabaseService);

    public async getMembers(request: express.Request): Promise<MemberDto[]> {
        const dbMembers = await this.database.doRequest(
            async prisma => await prisma.member.findMany(),
            request,
        );
        return dbMembers.map(mapDbMemberToMember);
    }

    public async getMemberById(
        memberId: string,
        request: express.Request,
    ): Promise<MemberDto> {
        const member = await this.database.doRequest(
            async prisma =>
                await prisma.member.findFirst({ where: { id: memberId } }),
            request,
        );

        if (!member) {
            throw new Error(`Member with id ${memberId} not found`, {
                cause: ErrorStates.ENTITY_NOT_FOUND,
            });
        }

        return mapDbMemberToMember(member);
    }

    public async createMember(
        createArgs: MemberCreateArgs,
        request: express.Request,
    ): Promise<MemberDto> {
        const x = {
            ...createArgs,
            geburtsdatum: createArgs.geburtsdatum
                ? createArgs.geburtsdatum
                : null,
        };
        const newMember = await this.database.doRequest(
            async prisma => await prisma.member.create({ data: x }),
            request,
        );
        return mapDbMemberToMember(newMember);
    }

    public async updateMember(
        member: MemberDto,
        request: express.Request,
    ): Promise<MemberDto> {
        const id = member.id;
        if (!id) {
            throw new Error("Member id is required for update", {
                cause: ErrorStates.BAD_REQUEST,
            });
        }

        const modifiedMember = await this.database.doRequest(
            async prisma =>
                await prisma.member.update({
                    data: {
                        ...member,
                        id: id,
                        letztePruefung: member.letztePruefung
                            ? member.letztePruefung
                            : null,
                        geburtsdatum: member.geburtsdatum
                            ? member.geburtsdatum
                            : null,
                        kuendigungzum: member.kuendigungzum
                            ? member.kuendigungzum
                            : null,
                    },
                    where: { id: id },
                }),
            request,
        );

        return mapDbMemberToMember(modifiedMember);
    }

    public async scheduleDeletion(
        memberId: string,
        cancelDate: Date | null,
        request: express.Request,
    ) {
        await this.database.doRequest(
            prisma =>
                prisma.member.update({
                    where: { id: memberId },
                    data: { kuendigungzum: cancelDate },
                }),
            request,
        );
    }
}