feat(person): add person with bucket filename

Author: douglasfdev

src/api/modules/v1/controllers/files/FileController.ts

@@ -22,23 +22,23 @@ class Files implements IFileController {
     // deno-lint-ignore no-explicit-any
     } catch (er: Error | any | unknown) {
       ctx.response.status = Status.BadRequest;
+      log.error(er.message);
       ctx.response.body = {
         error: er.message,
       };
-      log.error(er.message);
     }
   }
 
   public async listAllFiles(ctx: RouterContext<string>) {
     try {
       ctx.response.status = Status.OK;
-      ctx.response.body = await FileService.listFiles();
+      return ctx.response.body = await FileService.listFiles();
     } catch (er: Error | any | unknown) {
       ctx.response.status = Status.BadRequest;
-      ctx.response.body = {
+      log.error(er.message);
+      return ctx.response.body = {
         error: er.message,
       };
-      log.error(er.message);
     }
   }
 }

src/api/modules/v1/controllers/person/PersonController.ts

@@ -18,10 +18,14 @@ class PersonController {
     }
   }
 
-  public create(ctx: RouterContext<string>) {
+  public async create(ctx: RouterContext<string>) {
     try {
       const body = ctx.request.body();
-      console.log(body);
+      const { filename } = await body.value;
+
+      const person = await PersonService.create(filename);
+
+      return ctx.response.body = person;
     } catch (er) {
       ctx.response.status = Status.BadRequest;
       log.error(er.message);

src/api/modules/v1/routes/person.ts

@@ -4,5 +4,6 @@ import { PersonController } from '$controllers';
 const person = new Router();
 
 person.get("listPersons/", PersonController.listPersons);
+person.post("createPerson", PersonController.create)
 
 export { person };

src/api/modules/v1/services/file/FileService.ts

@@ -1,18 +1,15 @@
 import { FormDataFile } from "$deps";
 import { S3 } from "$components";
 import { IFileDTO, IFileService, IPersonDTO } from "$common";
-import { FileRespository, PersonRepository } from "$repositories";
-import { PersonService } from "$services";
+import { FileRespository } from "$repositories";
 
 class FileService implements IFileService {
   private s3: typeof S3;
   private fileRepository: typeof FileRespository;
-  private personService: typeof PersonService;
 
   constructor(s3: typeof S3) {
     this.s3 = s3;
     this.fileRepository = FileRespository;
-    this.personService = PersonService;
   }
 
   public async handlerFilesPerson(files: Array<FormDataFile>): Promise<void> {
@@ -40,21 +37,6 @@ class FileService implements IFileService {
         await this.s3.handlerBucket(whithoutHeader, filename);
 
         await this.fileRepository.handleCreate(filename);
-
-        const readS3 = await this.s3.readFileFromS3(filename) as Array<string>;
-
-        for (const result of readS3) {
-          const [name, age, sex, size, weight] = result.split(",");
-          const personObject = {
-            name,
-            age: Number(age),
-            sex,
-            size: Number(size),
-            weight: Number(weight)
-          }
-
-          await this.personService.create(personObject)
-        }
       }
     }
   }

src/api/modules/v1/services/person/PersonService.ts

@@ -1,27 +1,49 @@
 import { PersonRepository } from "$repositories";
 import { IPersonDTO } from "$common";
+import { S3 } from "$components";
 
 class PersonService {
-  private personRpository: typeof PersonRepository
+  private personRpository: typeof PersonRepository;
+  private s3: typeof S3;
 
   constructor() {
     this.personRpository = PersonRepository;
+    this.s3 = S3;
   }
 
   public async listPerson() {
     return this.personRpository.listPersons();
   }
 
-  public async create(personDTO: Partial<IPersonDTO>): Promise<IPersonDTO> {
-    return this.createPerson(personDTO);
+  public async create(filename: string): Promise<Array<Partial<IPersonDTO>>> {
+    return this.createPerson(filename);
   }
 
-  private async createPerson(personDTO: Partial<IPersonDTO>): Promise<IPersonDTO> {
-    if (!personDTO) {
-      throw new Error(`Person ${personDTO} is required`);
+  private async createPerson(
+      filename: string
+  ): Promise<Array<Partial<IPersonDTO>>> {
+    if (!filename) {
+      throw new Error(`Archive is required`);
     }
 
-    return this.personRpository.createPersons(personDTO);
+    const person: Array<Partial<IPersonDTO>> = []
+    const readS3 = await this.s3.readFileFromS3(filename) as Array<string>;
+
+    for (const result of readS3) {
+      const [name, age, sex, size, weight] = result.split(",");
+      const personObject: Partial<IPersonDTO> = {
+        name,
+        age: Number(age),
+        sex,
+        size: Number(size),
+        weight: Number(weight)
+      }
+
+      await this.personRpository.createPersons(personObject);
+      person.push(personObject);
+    }
+
+    return person;
   }
 }