refactor: padronizar dominios service-types e documents

apps/api/src/main/java/br/org/apae/api/servicearea/interfaces/controllers/ServiceAreaController.java

@@ -18,7 +18,7 @@
 
 import java.util.List;
 
-@RequestMapping("/service-areas")
+@RequestMapping({ "/service-areas", "/service-types" })
 public interface ServiceAreaController {
 
     @Operation(summary = "Cadastrar área de atendimento", description = "Cria uma nova área de atendimento no sistema.", responses = {

apps/api/src/test/java/br/org/apae/api/controllers/servicearea/ServiceAreaControllerTest.java

@@ -40,6 +40,7 @@
 class ServiceAreaControllerTest {
 
     private static final String URI = "/service-areas";
+    private static final String SERVICE_TYPES_URI = "/service-types";
 
     @Autowired
     private MockMvc mockMvc;
@@ -150,6 +151,24 @@ void shouldReturnEmptyListWhenThereAreNoServiceAreas() throws Exception {
 
             verify(service).findAllServiceAreas();
         }
+
+        @Test
+        @DisplayName("Deve listar areas de atendimento pela rota padronizada /service-types")
+        void shouldGetAllServiceAreasThroughServiceTypesRoute() throws Exception {
+            List<ServiceAreaResponseDTO> response = List.of(
+                    new ServiceAreaResponseDTO(1, "Fisioterapia")
+            );
+
+            when(service.findAllServiceAreas()).thenReturn(response);
+
+            mockMvc.perform(get(SERVICE_TYPES_URI))
+                    .andExpect(status().isOk())
+                    .andExpect(jsonPath("$.length()").value(1))
+                    .andExpect(jsonPath("$[0].id").value(1))
+                    .andExpect(jsonPath("$[0].area").value("Fisioterapia"));
+
+            verify(service).findAllServiceAreas();
+        }
     }
 
     @Nested

apps/management-app/src/app/(protected)/service-types/[id]/edit/page.tsx

@@ -0,0 +1,5 @@
+import { EditServiceTypePage } from "@/domains/service-types/pages/edit-service-type-page";
+
+export default function Page() {
+  return <EditServiceTypePage />;
+}

apps/management-app/src/app/(protected)/service-types/page.tsx

@@ -0,0 +1,5 @@
+import { ServiceTypesPage } from "@/domains/service-types/pages/service-types-page";
+
+export default function Page() {
+  return <ServiceTypesPage />;
+}

apps/management-app/src/app/api/patients/[id]/documents/route.ts

@@ -0,0 +1,105 @@
+import { AxiosError } from "axios";
+import { NextRequest, NextResponse } from "next/server";
+
+import { createBaseApi } from "@/lib/axios";
+
+const categoryRouteMap: Record<string, string> = {
+  medical: "medicals",
+  medicals: "medicals",
+  medicos: "medicals",
+  personal: "personals",
+  personals: "personals",
+  pessoais: "personals",
+  school: "schools",
+  schools: "schools",
+  escolares: "schools",
+};
+
+function normalizeCategory(category: string | null) {
+  if (!category) {
+    return null;
+  }
+
+  return categoryRouteMap[category.toLowerCase()] || null;
+}
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { id } = await params;
+  const category = normalizeCategory(request.nextUrl.searchParams.get("category"));
+  const year = request.nextUrl.searchParams.get("year");
+  const type = request.nextUrl.searchParams.get("type");
+
+  if (!category) {
+    return NextResponse.json({ message: "Categoria de documento invalida." }, { status: 400 });
+  }
+
+  try {
+    const api = await createBaseApi();
+    const searchParams = new URLSearchParams();
+
+    if (year) {
+      searchParams.set("year", year);
+    }
+
+    const suffix = searchParams.size > 0 ? `?${searchParams.toString()}` : "";
+    const response = await api.get(`/patients/${id}/documents/${category}${suffix}`);
+    const documents = Array.isArray(response.data) ? response.data : [];
+    const filteredDocuments = type
+      ? documents.filter((document: { type?: string }) => document.type === type)
+      : documents;
+
+    return NextResponse.json(filteredDocuments);
+  } catch (error) {
+    const err = error as AxiosError;
+    return NextResponse.json(
+      { message: err.response?.data || "Erro ao buscar documentos" },
+      { status: err.response?.status || 500 },
+    );
+  }
+}
+
+export async function POST(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> },
+) {
+  const { id } = await params;
+
+  try {
+    const incomingFormData = await request.formData();
+    const file = incomingFormData.get("file");
+    const category = incomingFormData.get("category");
+    const type = incomingFormData.get("type");
+    const year = incomingFormData.get("year");
+
+    if (!(file instanceof File) || typeof category !== "string" || typeof type !== "string") {
+      return NextResponse.json({ message: "Dados de upload invalidos." }, { status: 400 });
+    }
+
+    const formData = new FormData();
+    formData.append("file", file);
+    formData.append("category", category);
+    formData.append("type", type);
+
+    if (typeof year === "string" && year.trim()) {
+      formData.append("year", year);
+    }
+
+    const api = await createBaseApi();
+    const response = await api.post(`/patients/${id}/documents`, formData, {
+      headers: {
+        "Content-Type": "multipart/form-data",
+      },
+    });
+
+    return NextResponse.json(response.data, { status: response.status });
+  } catch (error) {
+    const err = error as AxiosError;
+    return NextResponse.json(
+      { message: err.response?.data || "Erro ao enviar documento" },
+      { status: err.response?.status || 500 },
+    );
+  }
+}