Feature/participates e rotas

src/application/expedicao/AdicionaParticipanteController.ts

@@ -0,0 +1,67 @@
+import { AdicionaParticipanteUseCase } from '@/domain/expedicao/AdcionaParticipanteUseCase'
+import {
+  HttpRequest, HttpResponse, StatusCode
+} from '@/library/http/common'
+import { BadRequestError } from '@/library/http/error/BadRequestError'
+import { ConflictError } from '@/library/http/error/ConflictError'
+import { HttpError } from '@/library/http/error/HttpError'
+import { InternalServerError } from '@/library/http/error/InternalServerError'
+import { NextHandler, RequestHandler } from '@/library/http/Server'
+
+interface Dependencies {
+  adicionaParticipanteUseCase: AdicionaParticipanteUseCase
+}
+
+interface CustomHttpRequest extends HttpRequest {
+  params: Record<string, string | undefined>
+  body: unknown
+  usuario?: {
+    id: number
+    tipo_usuario_id: number
+  }
+}
+
+export class AdicionaParticipanteController implements RequestHandler {
+  private readonly adicionaParticipanteUseCase: AdicionaParticipanteUseCase
+
+  constructor(dependencies: Dependencies) {
+    this.adicionaParticipanteUseCase = dependencies.adicionaParticipanteUseCase
+  }
+
+  async handle(request: CustomHttpRequest, _next: NextHandler): Promise<HttpResponse | HttpError> {
+    try {
+      // TODO: AUTENTICAÇÃO TEMPORARIAMENTE DESABILITADA
+
+      const { expedicaoId } = request.params
+      const { usuarioId } = request.body as { usuarioId?: number }
+      if (expedicaoId === undefined || expedicaoId === null || expedicaoId === '' || !/^\d+$/.test(expedicaoId)) {
+        return new BadRequestError({ message: 'expedicaoId inválido' })
+      }
+
+      if (usuarioId === undefined || typeof usuarioId !== 'number' || usuarioId <= 0) {
+        return new BadRequestError({ message: 'usuarioId inválido' })
+      }
+
+      const result = await this.adicionaParticipanteUseCase.execute(Number(expedicaoId), usuarioId)
+
+      if (result.left()) {
+        const error = result.value
+        if (error.name === 'DuplicateParticipantError') {
+          return new ConflictError({ message: error.message })
+        }
+        if (error.name === 'CollectionError') {
+          return new InternalServerError({ message: 'Falha interna ao adicionar participante' })
+        }
+        return new BadRequestError({ message: error.message })
+      }
+
+      return {
+        statusCode: StatusCode.Created,
+        body: { message: 'Participante adicionado com sucesso.' }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Erro inesperado ao adicionar participante'
+      return new InternalServerError({ message: errorMessage })
+    }
+  }
+}

src/application/expedicao/RemoveParticipanteController.ts

@@ -0,0 +1,58 @@
+import { RemoveParticipanteUseCase } from '@/domain/expedicao/RemoveParticipanteUseCase'
+import {
+  HttpRequest, HttpResponse, StatusCode
+} from '@/library/http/common'
+import { BadRequestError } from '@/library/http/error/BadRequestError'
+import { HttpError } from '@/library/http/error/HttpError'
+import { InternalServerError } from '@/library/http/error/InternalServerError'
+import { NextHandler, RequestHandler } from '@/library/http/Server'
+
+interface Dependencies {
+  removeParticipanteUseCase: RemoveParticipanteUseCase
+}
+
+interface CustomHttpRequest extends HttpRequest {
+  usuario?: {
+    id: number
+    tipo_usuario_id: number
+  }
+}
+
+export class RemoveParticipanteController implements RequestHandler {
+  private readonly removeParticipanteUseCase: RemoveParticipanteUseCase
+
+  constructor(dependencies: Dependencies) {
+    this.removeParticipanteUseCase = dependencies.removeParticipanteUseCase
+  }
+
+  async handle(request: CustomHttpRequest, _next: NextHandler): Promise<HttpResponse | HttpError> {
+    try {
+      const { expedicaoId, usuarioId } = request.params
+
+      if (expedicaoId === undefined || expedicaoId === null || expedicaoId === '' || typeof expedicaoId !== 'string' || !/^\d+$/.test(expedicaoId)) {
+        return new BadRequestError({ message: 'expedicaoId inválido' })
+      }
+
+      if (usuarioId === undefined || usuarioId === null || usuarioId === '' || typeof usuarioId !== 'string' || !/^\d+$/.test(usuarioId)) {
+        return new BadRequestError({ message: 'usuarioId inválido' })
+      }
+
+      const result = await this.removeParticipanteUseCase.execute(Number(expedicaoId), Number(usuarioId))
+
+      if (result.left()) {
+        if (result.value.name === 'CollectionError' || result.value.message.includes('Falha')) {
+          return new InternalServerError({ message: 'Falha interna ao remover participante' })
+        }
+        return new BadRequestError({ message: result.value.message })
+      }
+
+      return {
+        statusCode: StatusCode.NoContent,
+        body: undefined
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Erro inesperado ao remover participante'
+      return new InternalServerError({ message: errorMessage })
+    }
+  }
+}

src/application/expedicao/SubstituiRotaController.ts

@@ -0,0 +1,60 @@
+import { SubstituiRotasUseCase } from '@/domain/expedicao/SubstituiRotaUseCase'
+import {
+  HttpRequest, HttpResponse, StatusCode
+} from '@/library/http/common'
+import { BadRequestError } from '@/library/http/error/BadRequestError'
+import { HttpError } from '@/library/http/error/HttpError'
+import { InternalServerError } from '@/library/http/error/InternalServerError'
+import { NextHandler, RequestHandler } from '@/library/http/Server'
+
+interface Dependencies {
+  SubstituiRotasUseCase: SubstituiRotasUseCase
+}
+
+interface CustomHttpRequest extends HttpRequest {
+  usuario?: {
+    id: number
+    tipo_usuario_id: number
+  }
+}
+
+export class SubstituiRotasController implements RequestHandler {
+  private readonly SubstituiRotasUseCase: SubstituiRotasUseCase
+
+  constructor(dependencies: Dependencies) {
+    this.SubstituiRotasUseCase = dependencies.SubstituiRotasUseCase
+  }
+
+  async handle(request: CustomHttpRequest, _next: NextHandler): Promise<HttpResponse | HttpError> {
+    try {
+      const { expedicaoId } = request.params
+      const { rotas } = request.body as { rotas?: number[] }
+
+      if (expedicaoId === undefined || expedicaoId === null || expedicaoId === '' || typeof expedicaoId !== 'string' || !/^\d+$/.test(expedicaoId)) {
+        return new BadRequestError({ message: 'expedicaoId inválido' })
+      }
+
+      if (!rotas || !Array.isArray(rotas) || rotas.some(id => typeof id !== 'number' || id <= 0)) {
+        return new BadRequestError({ message: 'rotas inválidas' })
+      }
+
+      const result = await this.SubstituiRotasUseCase.execute(Number(expedicaoId), rotas)
+
+      if (result.left()) {
+        const error = result.value
+        if (error.name === 'CollectionError') {
+          return new InternalServerError({ message: 'Falha interna ao substituir rotas' })
+        }
+        return new BadRequestError({ message: error.message })
+      }
+
+      return {
+        statusCode: StatusCode.NoContent,
+        body: undefined
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Erro inesperado ao substituir rotas'
+      return new InternalServerError({ message: errorMessage })
+    }
+  }
+}

src/application/expedicao/index.ts

@@ -1,19 +1,25 @@
 import { type Knex } from 'knex'
 
+import { AdicionaParticipanteUseCase } from '@/domain/expedicao/AdcionaParticipanteUseCase'
 import { AtualizaExpedicaoUseCase } from '@/domain/expedicao/AtualizaExpedicaoUseCase'
 import { BuscaExpedicaoUseCase } from '@/domain/expedicao/BuscaExpedicaoUseCase'
 import { CadastraExpedicaoUseCase } from '@/domain/expedicao/CadastraExpedicaoUseCase'
 import { DeletaExpedicaoUseCase } from '@/domain/expedicao/DeletaExpedicaoUseCase'
 import { ListaExpedicoesUseCase } from '@/domain/expedicao/ListaExpedicoesUseCase'
+import { RemoveParticipanteUseCase } from '@/domain/expedicao/RemoveParticipanteUseCase'
+import { SubstituiRotasUseCase } from '@/domain/expedicao/SubstituiRotaUseCase'
 import { createExpedicaoCollection } from '@/factory/ExpedicaoCollectionFactory'
 import { Method } from '@/library/http/common'
 import { Route } from '@/library/http/Router'
 
+import { AdicionaParticipanteController } from './AdicionaParticipanteController'
 import { AtualizaExpedicaoController } from './AtualizaExpedicaoController'
 import { BuscaExpedicaoController } from './BuscaExpedicaoController'
 import { CadastraExpedicaoController } from './CadastraExpedicaoController'
 import { DeletaExpedicaoController } from './DeletaExpedicaoController'
 import { ListaExpedicoesController } from './ListaExpedicoesController'
+import { RemoveParticipanteController } from './RemoveParticipanteController'
+import { SubstituiRotasController } from './SubstituiRotaController'
 
 export function routes(knex: Knex): Route[] {
   const expedicaoCollection = createExpedicaoCollection()
@@ -63,6 +69,33 @@ export function routes(knex: Knex): Route[] {
           atualizaExpedicaoUseCase: new AtualizaExpedicaoUseCase({ expedicaoCollection })
         })
       ]
+    },
+    {
+      method: Method.Post,
+      path: '/v2/expedicoes/:expedicaoId/participantes',
+      handlers: [
+        new AdicionaParticipanteController({
+          adicionaParticipanteUseCase: new AdicionaParticipanteUseCase({ expedicaoCollection })
+        })
+      ]
+    },
+    {
+      method: Method.Delete,
+      path: '/v2/expedicoes/:expedicaoId/participantes/:usuarioId',
+      handlers: [
+        new RemoveParticipanteController({
+          removeParticipanteUseCase: new RemoveParticipanteUseCase({ expedicaoCollection })
+        })
+      ]
+    },
+    {
+      method: Method.Put,
+      path: '/v2/expedicoes/:expedicaoId/rotas',
+      handlers: [
+        new SubstituiRotasController({
+          SubstituiRotasUseCase: new SubstituiRotasUseCase({ expedicaoCollection })
+        })
+      ]
     }
   ]
 }

src/domain/expedicao/AdcionaParticipanteUseCase.ts

@@ -0,0 +1,19 @@
+import { Either } from '@/library/either/Either'
+
+import { ExpedicaoCollection } from './ExpedicaoCollection'
+
+interface Dependencies {
+  expedicaoCollection: ExpedicaoCollection
+}
+
+export class AdicionaParticipanteUseCase {
+  private readonly expedicaoCollection: ExpedicaoCollection
+
+  constructor(dependencies: Dependencies) {
+    this.expedicaoCollection = dependencies.expedicaoCollection
+  }
+
+  execute(expedicaoId: number, usuarioId: number): Promise<Either<Error, void>> {
+    return this.expedicaoCollection.addParticipant(expedicaoId, usuarioId)
+  }
+}

src/domain/expedicao/Expedicao.ts

@@ -12,6 +12,24 @@ export interface Attributes {
   updated_by: number | null
 }
 
+export interface ParticipanteDetalhado {
+  id: number
+  nome: string
+  email: string
+}
+
+export interface RotaDetalhada {
+  cidade_id: number
+  ordem: number
+  nome_cidade: string
+  estado: string
+}
+
+export interface ExpedicaoDetalhada extends Attributes {
+  participantes: ParticipanteDetalhado[]
+  rotas: RotaDetalhada[]
+}
+
 export type CreateAttributes =
   Omit<Attributes, 'id' | 'created_at' | 'updated_at' | 'updated_by'>
   & {

src/domain/expedicao/ExpedicaoCollection.ts

@@ -10,13 +10,13 @@ export interface ExpedicaoOrder {
 }
 
 export interface ExpedicaoFilters {
+  pagina?: number
+  limite?: number
   cidade_id?: number
   usuario_id?: number
   data_inicio_de?: string
   data_fim_ate?: string
   order?: ExpedicaoOrder
-  limite?: number
-  pagina?: number
 }
 
 export interface Paginated<T> {
@@ -39,6 +39,12 @@ export interface ExpedicaoCollection {
   findAll(filters: ExpedicaoFilters): Promise<Either<Error, Paginated<ExpedicaoListItem>>>
   findById(id: number): Promise<Either<Error, Attributes | null>>
   create(attributes: CreateAttributes): Promise<Either<Error, Attributes>>
+
+  addParticipant(expedicaoId: number, usuarioId: number): Promise<Either<Error, void>>
+  removeParticipant(expedicaoId: number, usuarioId: number): Promise<Either<Error, void>>
+
+  substituteRoute(expedicaoId: number, rotas: number[]): Promise<Either<Error, void>>
+
   delete(id: number): Promise<Either<Error, void>>
   update(id: number, attributes: UpdateAttributes): Promise<Either<Error, Attributes>>
 }

src/domain/expedicao/RemoveParticipanteUseCase.ts

@@ -0,0 +1,19 @@
+import { Either } from '@/library/either/Either'
+
+import { ExpedicaoCollection } from './ExpedicaoCollection'
+
+interface Dependencies {
+  expedicaoCollection: ExpedicaoCollection
+}
+
+export class RemoveParticipanteUseCase {
+  private readonly expedicaoCollection: ExpedicaoCollection
+
+  constructor(dependencies: Dependencies) {
+    this.expedicaoCollection = dependencies.expedicaoCollection
+  }
+
+  execute(expedicaoId: number, usuarioId: number): Promise<Either<Error, void>> {
+    return this.expedicaoCollection.removeParticipant(expedicaoId, usuarioId)
+  }
+}

src/domain/expedicao/SubstituiRotaUseCase.ts

@@ -0,0 +1,19 @@
+import { Either } from '@/library/either/Either'
+
+import { ExpedicaoCollection } from './ExpedicaoCollection'
+
+interface Dependencies {
+  expedicaoCollection: ExpedicaoCollection
+}
+
+export class SubstituiRotasUseCase {
+  private readonly expedicaoCollection: ExpedicaoCollection
+
+  constructor(dependencies: Dependencies) {
+    this.expedicaoCollection = dependencies.expedicaoCollection
+  }
+
+  execute(expedicaoId: number, rotas: number[]): Promise<Either<Error, void>> {
+    return this.expedicaoCollection.substituteRoute(expedicaoId, rotas)
+  }
+}