cadastro de expedições, evidências e eventos do diário de campo

.env.example

@@ -8,6 +8,7 @@ CORS_METHODS=HEAD,GET,POST,PUT,PATCH,DELETE
 CORS_ALLOWED_HEADERS=Content-Type,Authorization,X-Requested-With
 
 STORAGE_PATH=./uploads
+EVIDENCIA_MAX_FILE_SIZE_MB=200
 
 RECAPTCHA_SECRET_KEY=6LcYYYYYYYYYYYYYY
 

.gitignore

@@ -3,6 +3,10 @@ dist/
 coverage/
 node_modules/
 
+# Yarn Berry local state — este projeto usa Yarn Classic (yarn lockfile v1)
+.yarnrc.yml
+.yarn/
+
 uploads/
 mysql/data/
 postgresql/

.vscode/settings.json

@@ -18,5 +18,6 @@
   "liveServer.settings.port": 5501,
   "[javascript]": {
     "editor.tabSize": 4
-  }
+  },
+  "js/ts.tsdk.path": "./node_modules/typescript/lib"
 }

compose.integration.yml

@@ -1,3 +1,5 @@
+name: hcf-api-test
+
 services:
   postgres:
     image: postgis/postgis:18-3.6

package.json

@@ -72,6 +72,7 @@
 		"@types/express": "5.0.5",
 		"@types/jsonwebtoken": "9.0.10",
 		"@types/morgan": "1.9.10",
+		"@types/multer": "^2.2.0",
 		"@types/pg": "^8.16.0",
 		"@types/react": "19.2.2",
 		"@types/react-dom": "19.2.2",

src/application/create-app.ts

@@ -13,7 +13,11 @@ import { assets, upload } from '../config/directory'
 import legacyErrors from '../middlewares/erros-middleware'
 import { generatePreview, reportPreview } from '../reports/controller'
 import { routes as createEstadoRoutes } from './estado'
+import { routes as createEventoRoutes } from './evento'
+import { routes as createEvidenciaRoutes } from './evidencia'
+import { routes as createExpedicoesRoutes } from './expedicao'
 import { routes as createFaseSucessionalRoutes } from './fase-sucessional'
+import { routes as createLembreteRoutes } from './lembrete'
 import { routes as createPaisRoutes } from './pais'
 import { assertCookieSafeOrigins } from './parseCorsOrigins'
 import { routes as createRelevoRoutes } from './relevo'
@@ -62,10 +66,14 @@ export function createApp({
   const routes: Route[] = [
     ...createPaisRoutes(knex),
     ...createEstadoRoutes(knex),
+    ...createEventoRoutes(knex),
     ...createSoloRoutes(knex),
     ...createRelevoRoutes(knex),
     ...createFaseSucessionalRoutes(knex),
     ...createVegetacaoRoutes(knex),
+    ...createEvidenciaRoutes(knex),
+    ...createExpedicoesRoutes(knex),
+    ...createLembreteRoutes(knex),
     ...createUsuarioSessaoRoutes(knex)
   ]
   const origins = assertCookieSafeOrigins(cors.origins)
@@ -122,7 +130,7 @@ export function createApp({
 
   for (const route of routes) {
     const sanitizedPath = `/api/${route.path}`.replaceAll(/\/{2,}/g, '/').replaceAll(/\/$/g, '')
-    application.endpoint(route.method, sanitizedPath, ...route.handlers)
+    application.endpoint(route.method, sanitizedPath, route.handlers, route.middlewares)
   }
 
   if (legacyRouter) {

src/application/evento/AtualizarEventoController.ts

@@ -0,0 +1,153 @@
+import { AtualizarEventoUseCase, Input as AtualizarEventoInput } from '@/domain/evento/AtualizarEventoUseCase'
+import { EVENTO_TIPOS, EventoTipo } from '@/domain/evento/Evento'
+import { CheckViolationError } from '@/infrastructure/error/CheckViolationError'
+import { ForeignKeyViolationError } from '@/infrastructure/error/ForeignKeyViolationError'
+import { InfrastructureError } from '@/infrastructure/error/InfrastructureError'
+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 { NotFoundError } from '@/library/http/error/NotFoundError'
+import { UnprocessableEntityError } from '@/library/http/error/UnprocessableEntityError'
+import { NextHandler, RequestHandler } from '@/library/http/Server'
+
+import { parseColeta } from './coleta-parsing'
+
+interface Dependencies {
+  atualizarEventoUseCase: AtualizarEventoUseCase
+}
+
+interface Body {
+  tipo?: unknown
+  capturado_em?: unknown
+  latitude?: unknown
+  longitude?: unknown
+  altitude?: unknown
+  observacoes?: unknown
+  coleta?: unknown
+}
+
+export class AtualizarEventoController implements RequestHandler {
+  private readonly atualizarEventoUseCase: AtualizarEventoUseCase
+
+  constructor(dependencies: Dependencies) {
+    this.atualizarEventoUseCase = dependencies.atualizarEventoUseCase
+  }
+
+  async handle(request: HttpRequest, _next: NextHandler): Promise<HttpResponse | HttpError> {
+    const { eventoId: rawEventoId } = request.params as { eventoId?: string }
+    const eventoId = parseId(rawEventoId, 'eventoId')
+    if (eventoId instanceof Error) return new BadRequestError({ message: eventoId.message })
+
+    const body = (request.body ?? {}) as Body
+
+    // Substituir por request.usuario.id assim que a
+    // autenticação for integrada.
+    const input: AtualizarEventoInput = { id: eventoId, updated_by: null }
+
+    if (body.tipo !== undefined) {
+      const tipo = parseTipo(body.tipo)
+      if (tipo instanceof Error) return new BadRequestError({ message: tipo.message })
+      input.tipo = tipo
+    }
+
+    if (body.capturado_em !== undefined) {
+      const capturadoEm = parseDate(body.capturado_em, 'capturado_em')
+      if (capturadoEm instanceof Error) return new BadRequestError({ message: capturadoEm.message })
+      input.capturado_em = capturadoEm
+    }
+
+    if (body.latitude !== undefined) {
+      const latitude = parseOptionalNumber(body.latitude, 'latitude')
+      if (latitude instanceof Error) return new BadRequestError({ message: latitude.message })
+      input.latitude = latitude
+    }
+
+    if (body.longitude !== undefined) {
+      const longitude = parseOptionalNumber(body.longitude, 'longitude')
+      if (longitude instanceof Error) return new BadRequestError({ message: longitude.message })
+      input.longitude = longitude
+    }
+
+    if (body.altitude !== undefined) {
+      const altitude = parseOptionalNumber(body.altitude, 'altitude')
+      if (altitude instanceof Error) return new BadRequestError({ message: altitude.message })
+      input.altitude = altitude
+    }
+
+    if (body.observacoes !== undefined) {
+      const observacoes = parseOptionalString(body.observacoes, 'observacoes')
+      if (observacoes instanceof Error) return new BadRequestError({ message: observacoes.message })
+      input.observacoes = observacoes
+    }
+
+    if (body.coleta !== undefined) {
+      const coleta = body.coleta === null ? null : parseColeta(body.coleta)
+      if (coleta instanceof Error) return new BadRequestError({ message: coleta.message })
+      input.coleta = coleta
+    }
+
+    const result = await this.atualizarEventoUseCase.execute(input)
+
+    if (result.left()) {
+      const error = result.value
+      if (error instanceof ForeignKeyViolationError) return new NotFoundError({ message: error.message })
+      if (error instanceof CheckViolationError) return new UnprocessableEntityError({ message: error.message })
+      if (!(error instanceof InfrastructureError)) return new BadRequestError({ message: error.message })
+      return new InternalServerError({ message: error.message })
+    }
+
+    if (!result.value) {
+      return new NotFoundError({ message: 'Evento não encontrado' })
+    }
+
+    return { body: result.value, statusCode: StatusCode.Ok }
+  }
+}
+
+function parseId(raw: unknown, field: string): number | Error {
+  if (typeof raw !== 'string' || !/^\d+$/.test(raw)) {
+    return new Error(`${field} inválido`)
+  }
+  return Number(raw)
+}
+
+function parseTipo(raw: unknown): EventoTipo | Error {
+  if (typeof raw !== 'string' || !EVENTO_TIPOS.includes(raw as EventoTipo)) {
+    return new Error(`tipo inválido. Use um de: ${EVENTO_TIPOS.join(', ')}`)
+  }
+  return raw as EventoTipo
+}
+
+function parseDate(raw: unknown, field: string): Date | Error {
+  if (typeof raw !== 'string') {
+    return new Error(`${field} inválido. Use uma data no formato ISO 8601`)
+  }
+  const date = new Date(raw)
+  if (Number.isNaN(date.getTime())) {
+    return new Error(`${field} inválido. Use uma data no formato ISO 8601`)
+  }
+  return date
+}
+
+function parseOptionalNumber(raw: unknown, field: string): number | null | Error {
+  if (raw === undefined || raw === null) {
+    return null
+  }
+  if (typeof raw !== 'number' || Number.isNaN(raw)) {
+    return new Error(`${field} inválido`)
+  }
+  return raw
+}
+
+function parseOptionalString(raw: unknown, field: string): string | null | Error {
+  if (raw === undefined || raw === null) {
+    return null
+  }
+  if (typeof raw !== 'string') {
+    return new Error(`${field} inválido`)
+  }
+  return raw
+}

src/application/evento/BuscarEventoController.ts

@@ -0,0 +1,51 @@
+import { BuscarEventoPorIdUseCase } from '@/domain/evento/BuscarEventoPorIdUseCase'
+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 { NotFoundError } from '@/library/http/error/NotFoundError'
+import { NextHandler, RequestHandler } from '@/library/http/Server'
+
+interface Dependencies {
+  buscarEventoPorIdUseCase: BuscarEventoPorIdUseCase
+}
+
+export class BuscarEventoController implements RequestHandler {
+  private readonly buscarEventoPorIdUseCase: BuscarEventoPorIdUseCase
+
+  constructor(dependencies: Dependencies) {
+    this.buscarEventoPorIdUseCase = dependencies.buscarEventoPorIdUseCase
+  }
+
+  async handle(request: HttpRequest, _next: NextHandler): Promise<HttpResponse | HttpError> {
+    const { eventoId } = request.params as { eventoId?: string }
+
+    if (
+      eventoId === undefined
+      || eventoId === null
+      || eventoId === ''
+      || !/^\d+$/.test(eventoId)
+    ) {
+      return new BadRequestError({ message: 'eventoId inválido' })
+    }
+
+    const result = await this.buscarEventoPorIdUseCase.execute({
+      id: Number(eventoId)
+    })
+
+    if (result.left()) {
+      return new InternalServerError({ message: result.value.message })
+    }
+
+    if (!result.value) {
+      return new NotFoundError({ message: 'Evento não encontrado' })
+    }
+
+    return {
+      statusCode: StatusCode.Ok,
+      body: result.value
+    }
+  }
+}