@hed-hog/contact 0.0.137 → 0.0.148

package/dist/person-relation-type/person-relation-type.service.d.ts

@@ -18,7 +18,7 @@ export declare class PersonRelationTypeService {
         pageSize: number;
         prev: number;
         next: number;
-        data: any;
+        data: any[];
     }>;
     get(id: number): Promise<any>;
     create(data: CreateDTO): Promise<any>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hed-hog/contact",
-  "version": "0.0.137",
+  "version": "0.0.148",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
@@ -10,10 +10,10 @@
     "@nestjs/jwt": "^11",
     "@nestjs/mapped-types": "*",
     "@hed-hog/api-mail": "0.0.7",
+    "@hed-hog/api-locale": "0.0.11",
+    "@hed-hog/core": "0.0.145",
     "@hed-hog/api-prisma": "0.0.4",
-    "@hed-hog/api-locale": "0.0.10",
-    "@hed-hog/core": "0.0.137",
-    "@hed-hog/api-pagination": "0.0.4",
+    "@hed-hog/api-pagination": "0.0.5",
     "@hed-hog/api": "0.0.3"
   },
   "exports": {

package/src/address-type/address-type.controller.ts

@@ -31,25 +31,25 @@ export class PersonAddressTypeController {
   }
 
   @Get(':id')
-  async get(@Param('id', ParseIntPipe) id: number) {
-    return this.personAddressTypeService.get(id);
+  async get(@Param('id', ParseIntPipe) id: number, @Locale() locale: string) {
+    return this.personAddressTypeService.get(id, locale);
   }
 
   @Post()
-  async create(@Body() data: CreateDTO) {
-    return this.personAddressTypeService.create(data);
+  async create(@Locale() locale: string, @Body() data: CreateDTO) {
+    return this.personAddressTypeService.create(data, locale);
   }
 
   @Patch(':id')
-  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
+  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO, @Locale() locale: string) {
     return this.personAddressTypeService.update({
       id,
       data
-    });
+    }, locale);
   }
 
   @Delete()
-  async delete(@Body() data: DeleteDTO) {
-    return this.personAddressTypeService.delete(data);
+  async delete(@Body() data: DeleteDTO, @Locale() locale: string) {
+    return this.personAddressTypeService.delete(data, locale);
   }
 }

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

@@ -3,10 +3,11 @@ import { LocaleService, getLocaleText } from '@hed-hog/api-locale';
 import { PaginationDTO } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
-    BadRequestException,
-    Inject,
-    Injectable,
-    forwardRef
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+  forwardRef
 } from '@nestjs/common';
 import { CreateDTO } from './dto/create.dto';
 import { UpdateDTO } from './dto/update.dto';
@@ -31,11 +32,25 @@ export class PersonAddressTypeService {
     );
   }
 
-  async get(id: number) {
+  async get(id: number, locale: string) {
+    const addressType = await this.prismaService.address_type.findUnique({ where: { id }});
+
+    if (!addressType) {
+      throw new NotFoundException(
+        getLocaleText('addressTypeNotFound', locale, `Address Type with ID ${id} not found`).replace('{{item}}', 'Address Type')
+      );
+    }
+
     return this.localeService.getModelWithLocale(this.modelName, id);
   }
 
-  async create(data: CreateDTO) {
+  async create(data: CreateDTO, locale: string) {
+    if (!data.locale || Object.keys(data.locale).length === 0) {
+      throw new BadRequestException(
+        getLocaleText('localeRequired', locale, 'At least one locale is required')
+      );
+    }
+
     return this.localeService.createModelWithLocale(
       this.modelName,
       this.foreignKey,
@@ -43,7 +58,23 @@ export class PersonAddressTypeService {
     );
   }
 
-  async update({ id, data }: { id: number; data: UpdateDTO }) {
+  async update({ id, data }: { id: number; data: UpdateDTO }, locale: string) {
+    const addressTypeExists = await this.prismaService.address_type.findUnique({
+      where: { id }
+    });
+
+    if (!addressTypeExists) {
+      throw new NotFoundException(
+        getLocaleText('addressTypeNotFound', locale, `Address Type with ID ${id} not found`).replace('{{item}}', 'Address Type')
+      );
+    }
+
+    if (data.locale && Object.keys(data.locale).length === 0) {
+      throw new BadRequestException(
+        getLocaleText('localeRequired', locale, 'At least one locale is required')
+      );
+    }
+
     return this.localeService.updateModelWithLocale(
       this.modelName,
       this.foreignKey,
@@ -52,7 +83,7 @@ export class PersonAddressTypeService {
     );
   }
 
-  async delete({ ids }: DeleteDTO, locale: string = 'en') {
+  async delete({ ids }: DeleteDTO, locale: string) {
     if (ids == undefined || ids == null) {
       throw new BadRequestException(
         getLocaleText(
@@ -63,6 +94,22 @@ export class PersonAddressTypeService {
       );
     }
 
+    const existingAddressTypes = await this.prismaService.address_type.findMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+
+    if (existingAddressTypes.length !== ids.length) {
+      const existingIds = existingAddressTypes.map((item) => item.id);
+      const missingIds = ids.filter((id) => !existingIds.includes(id));
+      throw new NotFoundException(
+        getLocaleText('addressTypesNotFound', locale, `Address Types with IDs ${missingIds.join(', ')} not found`).replace('{{items}}', 'Address Types')
+      );
+    }
+
     return this.prismaService.address_type.deleteMany({
       where: {
         id: {

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

@@ -1,10 +1,19 @@
-import { getLocaleText, WithLocaleDTO } from '@hed-hog/api-locale';
-import { IsString } from 'class-validator';
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsNotEmpty, IsObject, IsString } from 'class-validator';
 
-export class CreateDTO extends WithLocaleDTO {
+export class CreateDTO {
   @IsString({
     message: (args) =>
       getLocaleText('validation.codeMustBeString', args.value),
   })
   code: string;
+
+  @IsObject({
+    message: (args) =>
+      getLocaleText('validation.localeMustBeObject', args.value),
+  })
+  @IsNotEmpty({
+    message: (args) => getLocaleText('validation.localeRequired', args.value),
+  })
+  locale: Record<string, { name: string }>;
 }

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

@@ -1,4 +1,9 @@
 import { PartialType } from '@nestjs/mapped-types';
+import { IsObject, IsOptional } from 'class-validator';
 import { CreateDTO } from './create.dto';
 
-export class UpdateDTO extends PartialType(CreateDTO) {}
+export class UpdateDTO extends PartialType(CreateDTO) {
+  @IsOptional()
+  @IsObject()
+  locale?: Record<string, { name: string }>;
+}

package/src/contact-type/contact-type.controller.ts

@@ -31,25 +31,25 @@ export class PersonContactTypeController {
   }
 
   @Get(':id')
-  async get(@Param('id', ParseIntPipe) id: number) {
-    return this.personContactTypeService.get(id);
+  async get(@Param('id', ParseIntPipe) id: number, @Locale() locale: string) {
+    return this.personContactTypeService.get(id, locale);
   }
 
   @Post()
-  async create(@Body() data: CreateDTO) {
-    return this.personContactTypeService.create(data);
+  async create(@Body() data: CreateDTO, @Locale() locale: string) {
+    return this.personContactTypeService.create(data, locale);
   }
 
   @Patch(':id')
-  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
+  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO, @Locale() locale: string) {
     return this.personContactTypeService.update({
       id,
       data
-    });
+    }, locale);
   }
 
   @Delete()
-  async delete(@Body() data: DeleteDTO) {
-    return this.personContactTypeService.delete(data);
+  async delete(@Body() data: DeleteDTO, @Locale() locale: string) {
+    return this.personContactTypeService.delete(data, locale);
   }
 }

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

@@ -3,10 +3,11 @@ import { LocaleService, getLocaleText } from '@hed-hog/api-locale';
 import { PaginationDTO } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
-    BadRequestException,
-    Inject,
-    Injectable,
-    forwardRef
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+  forwardRef
 } from '@nestjs/common';
 import { CreateDTO } from './dto/create.dto';
 import { UpdateDTO } from './dto/update.dto';
@@ -31,11 +32,27 @@ export class PersonContactTypeService {
     );
   }
 
-  async get(id: number) {
+  async get(id: number, locale: string) {
+    const contactType = await this.prismaService.contact_type.findUnique({
+      where: { id }
+    });
+
+    if (!contactType) {
+      throw new NotFoundException(
+        getLocaleText('contactTypeNotFound', locale, `Contact Type with ID ${id} not found`).replace('{{item}}', 'Contact Type')
+      );
+    }
+
     return this.localeService.getModelWithLocale(this.modelName, id);
   }
 
-  async create(data: CreateDTO) {
+  async create(data: CreateDTO, locale: string) {
+    if (!data.locale || Object.keys(data.locale).length === 0) {
+      throw new BadRequestException(
+        getLocaleText('localeRequired', locale, 'At least one locale is required')
+      );
+    }
+
     return this.localeService.createModelWithLocale(
       this.modelName,
       this.foreignKey,
@@ -43,7 +60,23 @@ export class PersonContactTypeService {
     );
   }
 
-  async update({ id, data }: { id: number; data: UpdateDTO }) {
+  async update({ id, data }: { id: number; data: UpdateDTO }, locale: string) {
+    const contactTypeExists = await this.prismaService.contact_type.findUnique({
+      where: { id }
+    });
+
+    if (!contactTypeExists) {
+      throw new NotFoundException(
+        getLocaleText('contactTypeNotFound', locale, `Contact Type with ID ${id} not found`).replace('{{item}}', 'Contact Type')
+      );
+    }
+
+    if (data.locale && Object.keys(data.locale).length === 0) {
+      throw new BadRequestException(
+        getLocaleText('localeRequired', locale, 'At least one locale is required')
+      );
+    }
+
     return this.localeService.updateModelWithLocale(
       this.modelName,
       this.foreignKey,
@@ -52,7 +85,7 @@ export class PersonContactTypeService {
     );
   }
 
-  async delete({ ids }: DeleteDTO, locale: string = 'en') {
+  async delete({ ids }: DeleteDTO, locale: string) {
     if (ids == undefined || ids == null) {
       throw new BadRequestException(
         getLocaleText(
@@ -63,6 +96,22 @@ export class PersonContactTypeService {
       );
     }
 
+    const existingContactTypes = await this.prismaService.contact_type.findMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+
+    if (existingContactTypes.length !== ids.length) {
+      const existingIds = existingContactTypes.map((item) => item.id);
+      const missingIds = ids.filter((id) => !existingIds.includes(id));
+      throw new NotFoundException(
+        getLocaleText('contactTypesNotFound', locale, `Contact Types with IDs ${missingIds.join(', ')} not found`).replace('{{items}}', 'Contact Types')
+      );
+    }
+
     return this.prismaService.contact_type.deleteMany({
       where: {
         id: {

package/src/contact-type/dto/create.dto.ts

@@ -1,10 +1,19 @@
-import { getLocaleText, WithLocaleDTO } from '@hed-hog/api-locale';
-import { IsString } from 'class-validator';
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsNotEmpty, IsObject, IsString } from 'class-validator';
 
-export class CreateDTO extends WithLocaleDTO {
+export class CreateDTO {
   @IsString({
     message: (args) =>
       getLocaleText('validation.codeMustBeString', args.value),
   })
   code: string;
+
+  @IsObject({
+    message: (args) =>
+      getLocaleText('validation.localeMustBeObject', args.value),
+  })
+  @IsNotEmpty({
+    message: (args) => getLocaleText('validation.localeRequired', args.value),
+  })
+  locale: Record<string, { name: string }>;
 }

package/src/contact-type/dto/update.dto.ts

@@ -1,4 +1,9 @@
 import { PartialType } from '@nestjs/mapped-types';
+import { IsObject, IsOptional } from 'class-validator';
 import { CreateDTO } from './create.dto';
 
-export class UpdateDTO extends PartialType(CreateDTO) {}
+export class UpdateDTO extends PartialType(CreateDTO) {
+  @IsOptional()
+  @IsObject()
+  locale?: Record<string, { name: string }>;
+}

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

@@ -31,25 +31,25 @@ export class PersonDocumentTypeController {
   }
 
   @Get(':id')
-  async get(@Param('id', ParseIntPipe) id: number) {
-    return this.personDocumentTypeService.get(id);
+  async get(@Param('id', ParseIntPipe) id: number, @Locale() locale: string) {
+    return this.personDocumentTypeService.get(id, locale);
   }
 
   @Post()
-  async create(@Body() data: CreateDTO) {
-    return this.personDocumentTypeService.create(data);
+  async create(@Body() data: CreateDTO, @Locale() locale: string) {
+    return this.personDocumentTypeService.create(data, locale);
   }
 
   @Patch(':id')
-  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
+  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO, @Locale() locale: string) {
     return this.personDocumentTypeService.update({
       id,
       data
-    });
+    }, locale);
   }
 
   @Delete()
-  async delete(@Body() data: DeleteDTO) {
-    return this.personDocumentTypeService.delete(data);
+  async delete(@Body() data: DeleteDTO, @Locale() locale: string) {
+    return this.personDocumentTypeService.delete(data, locale);
   }
 }

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

@@ -3,10 +3,11 @@ import { LocaleService, getLocaleText } from '@hed-hog/api-locale';
 import { PaginationDTO } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
-    BadRequestException,
-    Inject,
-    Injectable,
-    forwardRef
+  BadRequestException,
+  Inject,
+  Injectable,
+  NotFoundException,
+  forwardRef
 } from '@nestjs/common';
 import { CreateDTO } from './dto/create.dto';
 import { UpdateDTO } from './dto/update.dto';
@@ -31,11 +32,27 @@ export class PersonDocumentTypeService {
     );
   }
 
-  async get(id: number) {
+  async get(id: number, locale: string) {
+    const documentType = await this.prismaService.document_type.findUnique({
+      where: { id }
+    });
+
+    if (!documentType) {
+      throw new NotFoundException(
+        getLocaleText('documentTypeNotFound', locale, `Document Type with ID ${id} not found`).replace('{{item}}', 'Document Type')
+      );
+    }
+
     return this.localeService.getModelWithLocale(this.modelName, id);
   }
 
-  async create(data: CreateDTO) {
+  async create(data: CreateDTO, locale: string) {
+    if (!data.locale || Object.keys(data.locale).length === 0) {
+      throw new BadRequestException(
+        getLocaleText('localeRequired', locale, 'At least one locale is required')
+      );
+    }
+
     return this.localeService.createModelWithLocale(
       this.modelName,
       this.foreignKey,
@@ -43,7 +60,22 @@ export class PersonDocumentTypeService {
     );
   }
 
-  async update({ id, data }: { id: number; data: UpdateDTO }) {
+  async update({ id, data }: { id: number; data: UpdateDTO }, locale: string) {
+    const documentTypeExists = await this.prismaService.document_type.findUnique({
+      where: { id }
+    });
+
+    if (!documentTypeExists) {
+      throw new NotFoundException(
+        getLocaleText('documentTypeNotFound', locale, `Document Type with ID ${id} not found`).replace('{{item}}', 'Document Type')
+      );
+    }
+
+    if (data.locale && Object.keys(data.locale).length === 0) {
+      throw new BadRequestException(
+        getLocaleText('localeRequired', locale, 'At least one locale is required')
+      );
+    }
     return this.localeService.updateModelWithLocale(
       this.modelName,
       this.foreignKey,
@@ -52,7 +84,7 @@ export class PersonDocumentTypeService {
     );
   }
 
-  async delete({ ids }: DeleteDTO, locale: string = 'en') {
+  async delete({ ids }: DeleteDTO, locale: string) {
     if (ids == undefined || ids == null) {
       throw new BadRequestException(
         getLocaleText(
@@ -63,6 +95,22 @@ export class PersonDocumentTypeService {
       );
     }
 
+    const existingDocumentTypes = await this.prismaService.document_type.findMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+
+    if (existingDocumentTypes.length !== ids.length) {
+      const existingIds = existingDocumentTypes.map((item) => item.id);
+      const missingIds = ids.filter((id) => !existingIds.includes(id));
+      throw new NotFoundException(
+        getLocaleText('documentTypesNotFound', locale, `Document Types with IDs ${missingIds.join(', ')} not found`).replace('{{items}}', 'Document Types')
+      );
+    }
+
     return this.prismaService.document_type.deleteMany({
       where: {
         id: {

package/src/document-type/dto/create.dto.ts

@@ -1,7 +1,7 @@
-import { getLocaleText, WithLocaleDTO } from '@hed-hog/api-locale';
-import { IsBoolean, IsString } from 'class-validator';
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsBoolean, IsNotEmpty, IsObject, IsString } from 'class-validator';
 
-export class CreateDTO extends WithLocaleDTO {
+export class CreateDTO {
   @IsString({
     message: (args) =>
       getLocaleText('validation.codeMustBeString', args.value),
@@ -16,4 +16,13 @@ export class CreateDTO extends WithLocaleDTO {
 
   @IsBoolean()
   is_unique: boolean;
+
+  @IsObject({
+    message: (args) =>
+      getLocaleText('validation.localeMustBeObject', args.value),
+  })
+  @IsNotEmpty({
+    message: (args) => getLocaleText('validation.localeRequired', args.value),
+  })
+  locale: Record<string, { name: string }>;
 }

package/src/document-type/dto/update.dto.ts

@@ -1,4 +1,9 @@
 import { PartialType } from '@nestjs/mapped-types';
+import { IsObject, IsOptional } from 'class-validator';
 import { CreateDTO } from './create.dto';
 
-export class UpdateDTO extends PartialType(CreateDTO) {}
+export class UpdateDTO extends PartialType(CreateDTO) {
+  @IsOptional()
+  @IsObject()
+  locale?: Record<string, { name: string }>;
+}

package/src/language/en.json

@@ -1,6 +1,13 @@
 {
   "deleteItemsRequired": "You must select at least one item to delete.",
+  "localeRequired": "Name is required.",
   "personNotFound": "Person not found",
+  "addressTypeNotFound": "Address Type not found",
+  "contactTypeNotFound": "Contact Type not found",
+  "documentTypeNotFound": "Document Type not found",
+  "addressTypesNotFound": "Address Types not found",
+  "contactTypesNotFound": "Contact Types not found",
+  "documentTypesNotFound": "Document Types not found",
   "moreThanOnePrimaryContact": "More than one contact of the same type cannot be marked as primary.",
   "moreThanOnePrimaryAddress": "More than one address of the same type cannot be marked as primary.",
   "moreThanOnePrimaryDocument": "More than one document of the same type cannot be marked as primary.",

package/src/language/pt.json

@@ -1,6 +1,13 @@
 {
   "deleteItemsRequired": "Você deve selecionar pelo menos um item para excluir.",
+  "localeRequired": "Nome é obrigatório.",
   "personNotFound": "Pessoa não encontrada",
+  "addressTypeNotFound": "Tipo de Endereço não encontrado",
+  "contactTypeNotFound": "Tipo de Contato não encontrado",
+  "documentTypeNotFound": "Tipo de Documento não encontrado",
+  "addressTypesNotFound": "Tipos de Endereço não encontrados",
+  "contactTypesNotFound": "Tipos de Contato não encontrados",
+  "documentTypesNotFound": "Tipos de Documento não encontrados",  
   "moreThanOnePrimaryContact": "Não é permitido mais de um contato do mesmo tipo marcado como principal.",
   "moreThanOnePrimaryAddress": "Não é permitido mais de um endereço do mesmo tipo marcado como principal.",
   "moreThanOnePrimaryDocument": "Não é permitido mais de um documento do mesmo tipo marcado como principal.",

package/src/person/person.controller.ts

@@ -38,7 +38,7 @@ export class PersonController {
 
   @Get(':id')
   async get(@Param('id', ParseIntPipe) id: number, @Locale() locale: string) {
-    return this.personService.get(id);
+    return this.personService.get(locale, id);
   }
 
   @Post()

package/src/person/person.module.ts

@@ -1,21 +1,7 @@
-import { CoreModule } from "@hed-hog/core";
 import { PaginationModule } from "@hed-hog/api-pagination";
 import { PrismaModule } from "@hed-hog/api-prisma";
+import { CoreModule } from "@hed-hog/core";
 import { forwardRef, Module } from "@nestjs/common";
-import { PersonAddressController } from "./address/address.controller";
-import { PersonAddressService } from "./address/address.service";
-import { PersonContactController } from "./contact/contact.controller";
-import { PersonContactService } from "./contact/contact.service";
-import { PersonDocumentController } from "./document/document.controller";
-import { PersonDocumentService } from "./document/document.service";
-import { PersonCompanyController } from "./person-company/person-company.controller";
-import { PersonCompanyService } from "./person-company/person-company.service";
-import { PersonIndividualController } from "./person-individual/person-individual.controller";
-import { PersonIndividualService } from "./person-individual/person-individual.service";
-import { PersonMetadataController } from "./person-metadata/person-metadata.controller";
-import { PersonMetadataService } from "./person-metadata/person-metadata.service";
-import { PersonRelationController } from "./person-relation/person-relation.controller";
-import { PersonRelationService } from "./person-relation/person-relation.service";
 import { PersonController } from "./person.controller";
 import { PersonService } from "./person.service";
 @Module({
@@ -25,23 +11,9 @@ import { PersonService } from "./person.service";
     forwardRef(() => PaginationModule),
   ],
   controllers: [
-    PersonMetadataController,
-    PersonAddressController,
-    PersonContactController,
-    PersonDocumentController,
-    PersonRelationController,
-    PersonIndividualController,
-    PersonCompanyController,
     PersonController,
   ],
   providers: [
-    PersonMetadataService,
-    PersonAddressService,
-    PersonContactService,
-    PersonDocumentService,
-    PersonRelationService,
-    PersonIndividualService,
-    PersonCompanyService,
     PersonService,
   ],
   exports: [forwardRef(() => PersonService)],