Merge conflicts

<<<<<<< HEAD import { Controller, Get, Post, Body, Put, Param, Delete, Query, ParseUUIDPipe, UseInterceptors, NotFoundException, } from '@nestjs/common';

import { Controller, Get, Post, Body, Put, Param, Delete, Query, ParseUUIDPipe, UseInterceptors } from '@nestjs/common';

develop import { PersonService } from './person.service'; import { CreatePersonDto, UpdatePersonDto } from './dto/create-person.dto'; import { v4 as uuid } from 'uuid'; import { Person } from '@/models/person.model'; import { PersonType } from '@nietpluis/common'; import { AddressDTO, CreateContactInfoDTO, CreateDetailDto } from '../details/dto/create-detail.dto'; import { VZLogger } from '../logger/logger.service'; <<<<<<< HEAD import { Result, VerificationTokenPayload } from '@/interfaces'; import EmailService from '../email/email.service'; import { ConfigService } from '@nestjs/config'; import { JwtService } from '@nestjs/jwt'; import { NotFoundInterceptor } from '@/interceptors/not-found.interceptor'; import { Public } from '@/decorators/public'; import { ActivateAccountDto } from '../details/dto/activate-account.dto'; ======= import { Result } from '@/interfaces'; import { NotFoundInterceptor } from '@/interceptors/not-found.interceptor'; develop

@controller('person') export class PersonController { constructor( private readonly personService: PersonService, private readonly mailService: EmailService, private readonly configService: ConfigService, private readonly logger: VZLogger, private readonly jwtService: JwtService ) {}

private createToken(payload: VerificationTokenPayload): string {
    return this.jwtService.sign(payload, {
        secret: this.configService.get('JWT_VERIFICATION_TOKEN_SECRET'),
        expiresIn: this.configService.get('JWT_VERIFICATION_TOKEN_EXPIRATION_TIME'),
    });
}

@Post()
async create(@Body() body: CreatePersonDto): Promise<Person | null> {
    try {
        const id = uuid();
        const addressId = uuid();

        const contact: CreateContactInfoDTO[] = body.details.contact.map((info) => ({
            id: uuid(),
            type: info.type,
            value: info.value,
            detailsId: id,
        }));

        const emailInfo = body.details.contact
            .filter((contactInfo) => {
                return contactInfo.type === 'email' ? contactInfo : undefined;
            })
            .first();

        const token = this.createToken({ email: emailInfo.value });

        let gpId = null;
        let address: AddressDTO = null;
        if (body.type === 'patient') {
            gpId = body.details.gp.id;
            address = { ...body.details.address, id: addressId };
        }

        const details: CreateDetailDto = { id, ...body.details, address, contact, gpId, token };

        body.details.id = id;

        const newPerson = await this.personService.create({ ...body, details });

        if (emailInfo) {
            await this.mailService.send({
                to: emailInfo.value,
                template: 'notification/person-added',
                vars: {
                    name: newPerson.details.fullName(),
                    title: 'Welkom bij Niet Pluis',
                    url: `${this.configService.get('BASE_URL')}/auth/email-activeren/${id}/${token}`,
                    preheader: 'U bent toegevoegd als contactpersoon op Niet Pluis',
                },
            });
        } else {
            this.logger.error(`No emailaddress found for user ${id}`, 'no trace');
        }

        return newPerson;
    } catch (error) {
        this.logger.error(error.message, error.trace);
    }

    return null;
}

@Get()
async findAll(@Query('type') type: PersonType, @Query('open') openReports: boolean) {
    const results: Result<Person> = {
        count: 0,
        results: [],
    };

    const personResults: void | Result<Person> = await this.personService
        .findAll(type, openReports)
        .catch((error) => {
            this.logger.error(error.message, error.trace);
        });

    return personResults ?? results;
}

@Get('find')
findByLastNameAndDOB(
    @Query('lastName') lastName: string,
    @Query('fistName') firstName: string,
    @Query('initials') initials: string,
    @Query('dob') dob?: string,
    @Query('type') type?: PersonType
) {
    if (dob) {
        return this.personService.findByLastNameAndDOB(lastName, dob);
    } else {
        return this.personService.find({ lastName, firstName, initials }, type);
    }
}

<<<<<<< HEAD @UseInterceptors(new NotFoundInterceptor('No user found for given id'))

@UseInterceptors(new NotFoundInterceptor('No person found for given id'))

develop @get(':id') findOne(@param('id', ParseUUIDPipe) id: string) { return this.personService.findOne(id); }

@Put(':id')
update(@Param('id', ParseUUIDPipe) id: string, @Body() updatePersonDto: UpdatePersonDto) {
    return this.personService.update(id, updatePersonDto);
}

@Delete(':id')
remove(@Param('id', ParseUUIDPipe) id: string) {
    return this.personService.remove(id);
}

@Public()
@Get('token/:token')
async checkToken(@Param() token: any): Promise<boolean> {
    return this.personService.checkToken(token.token);
}

@Public()
@Get('active/:id')
async active(@Param('id', ParseUUIDPipe) id: string): Promise<{ active: boolean }> {
    return { active: await this.personService.checkIfActive(id) };
}

@Public()
@Post('resend-activation')
async resendActivation(@Body() body: any): Promise<null> {
    const person = await this.personService.findByEmail(body.email);

    const newToken = await this.personService.updateToken(person, body.email);

    if (newToken) {
        try {
            await this.mailService.send({
                to: body.email,
                template: 'notification/person-added',
                vars: {
                    name: person.details.fullName(),
                    title: 'Uw nieuwe activatie link',
                    url: `${this.configService.get('BASE_URL')}/auth/email-activeren/${body.id}/${newToken}`,
                    preheader: 'Er is een nieuwe activatie link voor u aangevraagd',
                },
            });
        } catch (error) {
            this.logger.error(error.message, error.trace);
        }
    } else {
        this.logger.error('Could not update token', newToken);
    }

    return null;
}

@Public()
@Post('activate')
async activateAccount(@Body() body: ActivateAccountDto): Promise<boolean> {
    console.log('test');
    const person = await this.personService.findByIdAndToken(body.userId, body.token);

    if (!person) {
        throw new NotFoundException();
    }

    const activateAccountDto: ActivateAccountDto = {
        userId: body.userId,
        token: body.token,
    };

    return this.personService.activate(activateAccountDto);
}

}