@hed-hog/contact 0.0.0

package/src/person-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) {}

package/src/person-type/person-type.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 { PersonTypeService } from './person-type.service';
+import { Role, DeleteDTO } from '@hed-hog/api';
+
+@Role()
+@Controller('person-type')
+export class PersonTypeController {
+  constructor(
+    @Inject(forwardRef(() => PersonTypeService))
+    private readonly personTypeService: PersonTypeService
+  ) {}
+
+  @Get()
+  async list(@Locale() locale, @Pagination() paginationParams) {
+    return this.personTypeService.list(locale, paginationParams);
+  }
+
+  @Get(':id')
+  async get(@Param('id', ParseIntPipe) id: number) {
+    return this.personTypeService.get(id);
+  }
+
+  @Post()
+  async create(@Body() data: CreateDTO) {
+    return this.personTypeService.create(data);
+  }
+
+  @Patch(':id')
+  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
+    return this.personTypeService.update({
+      id,
+      data
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.personTypeService.delete(data);
+  }
+}

package/src/person-type/person-type.enum.ts

@@ -0,0 +1,7 @@
+export enum PersonTypeEnum {
+  PHYSICAL = 1,
+
+  LEGAL = 2,
+
+  INTERNATIONAL = 3,
+}

package/src/person-type/person-type.module.ts

@@ -0,0 +1,18 @@
+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 { PersonTypeService } from './person-type.service';
+import { PersonTypeController } from './person-type.controller';
+
+@Module({
+  imports: [
+    forwardRef(() => AdminModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule)
+  ],
+  controllers: [PersonTypeController],
+  providers: [PersonTypeService],
+  exports: [PersonTypeService]
+})
+export class PersonTypeModule {}

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

@@ -0,0 +1,72 @@
+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 { DeleteDTO } from '@hed-hog/api';
+import { UpdateDTO } from './dto/update.dto';
+import { LocaleService } from '@hed-hog/api-locale';
+
+@Injectable()
+export class PersonTypeService {
+  private readonly modelName = 'person_type';
+  private readonly foreignKey = 'type_id';
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+    @Inject(forwardRef(() => LocaleService))
+    private readonly localeService: LocaleService
+  ) {}
+
+  async list(locale: string, paginationParams: PaginationDTO) {
+    return this.localeService.listModelWithLocale(
+      locale,
+      this.modelName,
+      paginationParams
+    );
+  }
+
+  async get(id: number) {
+    return this.localeService.getModelWithLocale(this.modelName, id);
+  }
+
+  async create(data: CreateDTO) {
+    return this.localeService.createModelWithLocale(
+      this.modelName,
+      this.foreignKey,
+      data
+    );
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    return this.localeService.updateModelWithLocale(
+      this.modelName,
+      this.foreignKey,
+      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_type.deleteMany({
+      where: {
+        id: {
+          in: ids
+        }
+      }
+    });
+  }
+}