@hed-hog/contact 0.0.0

package/src/person/person-document/person-document.controller.ts

@@ -0,0 +1,68 @@
+import { Pagination } from '@hed-hog/api-pagination';
+import { Role } from '@hed-hog/api';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Inject,
+  forwardRef
+} from '@nestjs/common';
+import { PersonDocumentService } from './person-document.service';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { DeleteDTO } from '@hed-hog/api';
+
+@Role()
+@Controller('person/:personId/person-document')
+export class PersonDocumentController {
+  constructor(
+    @Inject(forwardRef(() => PersonDocumentService))
+    private readonly personDocumentService: PersonDocumentService
+  ) {}
+
+  @Post()
+  create(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Body() data: CreateDTO
+  ) {
+    return this.personDocumentService.create(personId, data);
+  }
+
+  @Get()
+  list(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Pagination() paginationParams
+  ) {
+    return this.personDocumentService.list(paginationParams, personId);
+  }
+
+  @Get(':id')
+  get(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Param('id', ParseIntPipe) id: number
+  ) {
+    return this.personDocumentService.get(personId, id);
+  }
+
+  @Patch(':id')
+  update(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Param('id', ParseIntPipe) id: number,
+    @Body() data: UpdateDTO
+  ) {
+    return this.personDocumentService.update(personId, id, data);
+  }
+
+  @Delete()
+  delete(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Body() { ids }: DeleteDTO
+  ) {
+    return this.personDocumentService.delete(personId, { ids });
+  }
+}

package/src/person/person-document/person-document.service.ts

@@ -0,0 +1,79 @@
+import { PaginationService, PaginationDTO } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  Injectable,
+  NotFoundException,
+  BadRequestException
+} from '@nestjs/common';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { DeleteDTO } from '@hed-hog/api';
+
+@Injectable()
+export class PersonDocumentService {
+  constructor(
+    private readonly prismaService: PrismaService,
+    private readonly paginationService: PaginationService
+  ) {}
+
+  async create(personId: number, data: CreateDTO) {
+    return this.prismaService.person_document.create({
+      data: {
+        person_id: personId,
+        ...data
+      }
+    });
+  }
+
+  async get(personId: number, id: number) {
+    return this.prismaService.person_document.findFirst({
+      where: {
+        person_id: personId,
+        id: id
+      }
+    });
+  }
+
+  async list(paginationParams: PaginationDTO, personId?: number) {
+    const where: any = {};
+    if (personId !== undefined) where.person_id = personId;
+
+    return this.paginationService.paginate(
+      this.prismaService.person_document,
+      {
+        fields: 'primary,value,issued_at,expiry_at',
+        ...paginationParams
+      },
+      {
+        where
+      }
+    );
+  }
+
+  async update(personId: number, id: number, data: UpdateDTO) {
+    return this.prismaService.person_document.updateMany({
+      where: {
+        person_id: personId,
+        id: id
+      },
+      data
+    });
+  }
+
+  async delete(personId: number, { ids }: DeleteDTO) {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        'You must select at least one item to delete.'
+      );
+    }
+
+    return this.prismaService.person_document.deleteMany({
+      where: {
+        person_id: personId,
+        id: {
+          in: ids
+        }
+      }
+    });
+  }
+}

package/src/person/person-user/dto/create.dto.ts

@@ -0,0 +1,6 @@
+import { IsNumber } from 'class-validator';
+
+export class CreateDTO {
+  @IsNumber()
+  user_id: number;
+}

package/src/person/person-user/dto/update.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateDTO } from './create.dto';
+
+export class UpdateDTO extends PartialType(CreateDTO) {}

package/src/person/person-user/person-user.controller.ts

@@ -0,0 +1,68 @@
+import { Pagination } from '@hed-hog/api-pagination';
+import { Role } from '@hed-hog/api';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Inject,
+  forwardRef
+} from '@nestjs/common';
+import { PersonUserService } from './person-user.service';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { DeleteDTO } from '@hed-hog/api';
+
+@Role()
+@Controller('person/:personId/person-user')
+export class PersonUserController {
+  constructor(
+    @Inject(forwardRef(() => PersonUserService))
+    private readonly personUserService: PersonUserService
+  ) {}
+
+  @Post()
+  create(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Body() data: CreateDTO
+  ) {
+    return this.personUserService.create(personId, data);
+  }
+
+  @Get()
+  list(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Pagination() paginationParams
+  ) {
+    return this.personUserService.list(paginationParams, personId);
+  }
+
+  @Get(':id')
+  get(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Param('id', ParseIntPipe) id: number
+  ) {
+    return this.personUserService.get(personId, id);
+  }
+
+  @Patch(':id')
+  update(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Param('id', ParseIntPipe) id: number,
+    @Body() data: UpdateDTO
+  ) {
+    return this.personUserService.update(personId, id, data);
+  }
+
+  @Delete()
+  delete(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Body() { ids }: DeleteDTO
+  ) {
+    return this.personUserService.delete(personId, { ids });
+  }
+}

package/src/person/person-user/person-user.service.ts

@@ -0,0 +1,79 @@
+import { PaginationService, PaginationDTO } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  Injectable,
+  NotFoundException,
+  BadRequestException
+} from '@nestjs/common';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { DeleteDTO } from '@hed-hog/api';
+
+@Injectable()
+export class PersonUserService {
+  constructor(
+    private readonly prismaService: PrismaService,
+    private readonly paginationService: PaginationService
+  ) {}
+
+  async create(personId: number, data: CreateDTO) {
+    return this.prismaService.person_user.create({
+      data: {
+        person_id: personId,
+        ...data
+      }
+    });
+  }
+
+  async get(personId: number, id: number) {
+    return this.prismaService.person_user.findFirst({
+      where: {
+        person_id: personId,
+        id: id
+      }
+    });
+  }
+
+  async list(paginationParams: PaginationDTO, personId?: number) {
+    const where: any = {};
+    if (personId !== undefined) where.person_id = personId;
+
+    return this.paginationService.paginate(
+      this.prismaService.person_user,
+      {
+        fields: '',
+        ...paginationParams
+      },
+      {
+        where
+      }
+    );
+  }
+
+  async update(personId: number, id: number, data: UpdateDTO) {
+    return this.prismaService.person_user.updateMany({
+      where: {
+        person_id: personId,
+        id: id
+      },
+      data
+    });
+  }
+
+  async delete(personId: number, { ids }: DeleteDTO) {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        'You must select at least one item to delete.'
+      );
+    }
+
+    return this.prismaService.person_user.deleteMany({
+      where: {
+        person_id: personId,
+        id: {
+          in: ids
+        }
+      }
+    });
+  }
+}

package/src/person/person-value/dto/create.dto.ts

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class CreateDTO {
+  @IsString()
+  value: string;
+}

package/src/person/person-value/dto/update.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateDTO } from './create.dto';
+
+export class UpdateDTO extends PartialType(CreateDTO) {}

package/src/person/person-value/person-value.controller.ts

@@ -0,0 +1,68 @@
+import { Pagination } from '@hed-hog/api-pagination';
+import { Role } from '@hed-hog/api';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Inject,
+  forwardRef
+} from '@nestjs/common';
+import { PersonValueService } from './person-value.service';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { DeleteDTO } from '@hed-hog/api';
+
+@Role()
+@Controller('person/:personId/person-value')
+export class PersonValueController {
+  constructor(
+    @Inject(forwardRef(() => PersonValueService))
+    private readonly personValueService: PersonValueService
+  ) {}
+
+  @Post()
+  create(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Body() data: CreateDTO
+  ) {
+    return this.personValueService.create(personId, data);
+  }
+
+  @Get()
+  list(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Pagination() paginationParams
+  ) {
+    return this.personValueService.list(paginationParams, personId);
+  }
+
+  @Get(':id')
+  get(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Param('id', ParseIntPipe) id: number
+  ) {
+    return this.personValueService.get(personId, id);
+  }
+
+  @Patch(':id')
+  update(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Param('id', ParseIntPipe) id: number,
+    @Body() data: UpdateDTO
+  ) {
+    return this.personValueService.update(personId, id, data);
+  }
+
+  @Delete()
+  delete(
+    @Param('personId', ParseIntPipe) personId: number,
+    @Body() { ids }: DeleteDTO
+  ) {
+    return this.personValueService.delete(personId, { ids });
+  }
+}

package/src/person/person-value/person-value.service.ts

@@ -0,0 +1,79 @@
+import { PaginationService, PaginationDTO } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  Injectable,
+  NotFoundException,
+  BadRequestException
+} from '@nestjs/common';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { DeleteDTO } from '@hed-hog/api';
+
+@Injectable()
+export class PersonValueService {
+  constructor(
+    private readonly prismaService: PrismaService,
+    private readonly paginationService: PaginationService
+  ) {}
+
+  async create(personId: number, data: CreateDTO) {
+    return this.prismaService.person_value.create({
+      data: {
+        person_id: personId,
+        ...data
+      }
+    });
+  }
+
+  async get(personId: number, id: number) {
+    return this.prismaService.person_value.findFirst({
+      where: {
+        person_id: personId,
+        id: id
+      }
+    });
+  }
+
+  async list(paginationParams: PaginationDTO, personId?: number) {
+    const where: any = {};
+    if (personId !== undefined) where.person_id = personId;
+
+    return this.paginationService.paginate(
+      this.prismaService.person_value,
+      {
+        fields: 'value',
+        ...paginationParams
+      },
+      {
+        where
+      }
+    );
+  }
+
+  async update(personId: number, id: number, data: UpdateDTO) {
+    return this.prismaService.person_value.updateMany({
+      where: {
+        person_id: personId,
+        id: id
+      },
+      data
+    });
+  }
+
+  async delete(personId: number, { ids }: DeleteDTO) {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        'You must select at least one item to delete.'
+      );
+    }
+
+    return this.prismaService.person_value.deleteMany({
+      where: {
+        person_id: personId,
+        id: {
+          in: ids
+        }
+      }
+    });
+  }
+}

package/src/person/person.controller.ts

@@ -0,0 +1,55 @@
+import { Pagination } from '@hed-hog/api-pagination';
+import { Locale } from '@hed-hog/api-locale';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  forwardRef
+} from '@nestjs/common';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { PersonService } from './person.service';
+import { Role, DeleteDTO } from '@hed-hog/api';
+
+@Role()
+@Controller('person')
+export class PersonController {
+  constructor(
+    @Inject(forwardRef(() => PersonService))
+    private readonly personService: PersonService
+  ) {}
+
+  @Get()
+  async list(@Pagination() paginationParams) {
+    return this.personService.list(paginationParams);
+  }
+
+  @Get(':id')
+  async get(@Param('id', ParseIntPipe) id: number) {
+    return this.personService.get(id);
+  }
+
+  @Post()
+  async create(@Body() data: CreateDTO) {
+    return this.personService.create(data);
+  }
+
+  @Patch(':id')
+  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
+    return this.personService.update({
+      id,
+      data
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.personService.delete(data);
+  }
+}

package/src/person/person.module.ts

@@ -0,0 +1,45 @@
+import { AdminModule } from "@hed-hog/admin";
+import { PaginationModule } from "@hed-hog/api-pagination";
+import { PrismaModule } from "@hed-hog/api-prisma";
+import { forwardRef, Module } from "@nestjs/common";
+import { PersonValueController } from "./person-value/person-value.controller";
+import { PersonValueService } from "./person-value/person-value.service";
+import { PersonAddressController } from "./person-address/person-address.controller";
+import { PersonAddressService } from "./person-address/person-address.service";
+import { PersonContactController } from "./person-contact/person-contact.controller";
+import { PersonContactService } from "./person-contact/person-contact.service";
+import { PersonDocumentController } from "./person-document/person-document.controller";
+import { PersonDocumentService } from "./person-document/person-document.service";
+import { PersonCustomController } from "./person-custom/person-custom.controller";
+import { PersonCustomService } from "./person-custom/person-custom.service";
+import { PersonUserController } from "./person-user/person-user.controller";
+import { PersonUserService } from "./person-user/person-user.service";
+import { PersonController } from "./person.controller";
+import { PersonService } from "./person.service";
+@Module({
+  imports: [
+    forwardRef(() => AdminModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+  ],
+  controllers: [
+    PersonValueController,
+    PersonAddressController,
+    PersonContactController,
+    PersonDocumentController,
+    PersonCustomController,
+    PersonUserController,
+    PersonController,
+  ],
+  providers: [
+    PersonValueService,
+    PersonAddressService,
+    PersonContactService,
+    PersonDocumentService,
+    PersonCustomService,
+    PersonUserService,
+    PersonService,
+  ],
+  exports: [forwardRef(() => PersonService)],
+})
+export class PersonModule {}

package/src/person/person.service.ts

@@ -0,0 +1,83 @@
+import { DeleteDTO } from '@hed-hog/api';
+import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  forwardRef,
+} from '@nestjs/common';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+
+@Injectable()
+export class PersonService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  async list(paginationParams: PaginationDTO) {
+    const fields = ['name'];
+    const OR: any[] = this.prismaService.createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    if (paginationParams.search && !isNaN(+paginationParams.search)) {
+      OR.push({ id: { equals: +paginationParams.search } });
+    }
+
+    return this.paginationService.paginate(
+      this.prismaService.person,
+      paginationParams,
+      {
+        where: {
+          OR,
+        },
+        include: {
+          person_address: true,
+          person_contact: true,
+          person_document: true,
+        },
+      },
+    );
+  }
+
+  async get(id: number) {
+    return this.prismaService.person.findUnique({
+      where: { id: id },
+    });
+  }
+
+  async create(data: CreateDTO) {
+    return this.prismaService.person.create({
+      data,
+    });
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    return this.prismaService.person.update({
+      where: { id: id },
+      data,
+    });
+  }
+
+  async delete({ ids }: DeleteDTO) {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        'You must select at least one item to delete.',
+      );
+    }
+
+    return this.prismaService.person.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+}

package/src/person-address-type/dto/create.dto.ts

@@ -0,0 +1,7 @@
+import { IsString } from 'class-validator';
+import { WithLocaleDTO } from '@hed-hog/api-locale';
+
+export class CreateDTO extends WithLocaleDTO {
+  @IsString()
+  slug: string;
+}

package/src/person-address-type/dto/update.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateDTO } from './create.dto';
+
+export class UpdateDTO extends PartialType(CreateDTO) {}