@orbe-agro/client-core 5.6.134 → 5.6.136

package/dist/base/services/modules/juridico/municipiosService.js

@@ -0,0 +1,42 @@
+import ApiService from "../../../../@ecme/services/ApiService.js";
+const municipiosService = {
+  getAll: async () => {
+    try {
+      console.log("Fazendo requisição para /dados-mestres/api/municipio/find");
+      const response = await ApiService.fetchDataWithAxios({
+        url: "/dados-mestres/api/municipio/find",
+        method: "POST",
+        data: {
+          id: null,
+          municipio: null,
+          codigo: null,
+          pageable: {
+            pageNumber: 1,
+            pageSize: 1e4,
+            sort: [{
+              sortField: "municipio",
+              sortOrder: "asc"
+            }]
+          }
+        }
+      });
+      console.log("Resposta da API:", response);
+      const municipios = response.content || [];
+      return municipios.map((municipio) => ({
+        id: municipio.id,
+        nome: municipio.municipio,
+        uf: municipio.uf,
+        codigo: municipio.codigo,
+        ativo: true
+        // Assumindo que todos os retornados estão ativos
+      }));
+    } catch (error) {
+      console.error("Error fetching municipalities:", error);
+      return [];
+    }
+  }
+};
+export {
+  municipiosService
+};
+//# sourceMappingURL=municipiosService.js.map

package/dist/base/services/modules/juridico/municipiosService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"municipiosService.js","sources":["../../../../../lib/base/services/modules/juridico/municipiosService.ts"],"sourcesContent":["import ApiService from '@/services/ApiService'\nimport { TQueryResponse } from '@base/@types/api'\n\nexport const municipiosService = {\n    getAll: async (): Promise<any[]> => {\n        try {\n            console.log('Fazendo requisição para /dados-mestres/api/municipio/find')\n            \n            // Usando o ApiService padrão do projeto que já inclui o X-Service-Token\n            const response = await ApiService.fetchDataWithAxios<TQueryResponse<any>>({\n                url: '/dados-mestres/api/municipio/find',\n                method: 'POST',\n                data: {\n                    id: null,\n                    municipio: null,\n                    codigo: null,\n                    pageable: {\n                        pageNumber: 1,\n                        pageSize: 10000,\n                        sort: [{\n                            sortField: 'municipio',\n                            sortOrder: 'asc'\n                        }]\n                    }\n                }\n            })\n            \n            console.log('Resposta da API:', response)\n            \n            // A resposta é paginada, então pegamos o conteúdo\n            const municipios = response.content || []\n            \n            // Mapear para o formato esperado pelo frontend\n            return municipios.map((municipio: any) => ({\n                id: municipio.id,\n                nome: municipio.municipio,\n                uf: municipio.uf,\n                codigo: municipio.codigo,\n                ativo: true // Assumindo que todos os retornados estão ativos\n            }))\n        } catch (error) {\n            console.error('Error fetching municipalities:', error)\n            return []\n        }\n    }\n}"],"names":[],"mappings":";AAGO,MAAM,oBAAoB;AAAA,EAC7B,QAAQ,YAA4B;AAChC,QAAI;AACA,cAAQ,IAAI,2DAA2D;AAGvE,YAAM,WAAW,MAAM,WAAW,mBAAwC;AAAA,QACtE,KAAK;AAAA,QACL,QAAQ;AAAA,QACR,MAAM;AAAA,UACF,IAAI;AAAA,UACJ,WAAW;AAAA,UACX,QAAQ;AAAA,UACR,UAAU;AAAA,YACN,YAAY;AAAA,YACZ,UAAU;AAAA,YACV,MAAM,CAAC;AAAA,cACH,WAAW;AAAA,cACX,WAAW;AAAA,YAAA,CACd;AAAA,UAAA;AAAA,QACL;AAAA,MACJ,CACH;AAED,cAAQ,IAAI,oBAAoB,QAAQ;AAGxC,YAAM,aAAa,SAAS,WAAW,CAAA;AAGvC,aAAO,WAAW,IAAI,CAAC,eAAoB;AAAA,QACvC,IAAI,UAAU;AAAA,QACd,MAAM,UAAU;AAAA,QAChB,IAAI,UAAU;AAAA,QACd,QAAQ,UAAU;AAAA,QAClB,OAAO;AAAA;AAAA,MAAA,EACT;AAAA,IACN,SAAS,OAAO;AACZ,cAAQ,MAAM,kCAAkC,KAAK;AACrD,aAAO,CAAA;AAAA,IACX;AAAA,EACJ;AACJ;"}

package/dist/base/services/modules/juridico/termosService.js

@@ -0,0 +1,108 @@
+import ApiServiceJ from "../../../../@ecme/services/ApiServiceJ.js";
+const BASE_URL = "/juridico/api/juridico/termos";
+const termosService = {
+  create: async (termo) => {
+    try {
+      console.log("Payload being sent:", termo);
+      const response = await ApiServiceJ.fetchDataWithAxios({
+        url: BASE_URL,
+        method: "POST",
+        data: termo,
+        serviceKeyEnvName: "JURIDICO_API_KEY"
+      });
+      return response;
+    } catch (error) {
+      console.error("Detailed error:", error.response?.data);
+      throw error;
+    }
+  },
+  downloadPdf: async (id) => {
+    console.log("Chamando download com ID:", id);
+    try {
+      const response = await ApiServiceJ.fetchDataWithAxios({
+        url: `${BASE_URL}/download/${id}`,
+        method: "GET",
+        responseType: "arraybuffer",
+        headers: {
+          "Accept": "application/pdf, application/json;q=0.9, */*;q=0.8"
+        },
+        serviceKeyEnvName: "JURIDICO_API_KEY"
+      });
+      console.log("Resposta recebida:", response);
+      return response;
+    } catch (error) {
+      console.error("Erro completo:", error);
+      throw error;
+    }
+  },
+  downloadPdfDocuSign: async (id) => {
+    const response = await ApiServiceJ.fetchDataWithAxios({
+      url: `${BASE_URL}/${id}/docusign/download`,
+      method: "GET",
+      responseType: "arraybuffer",
+      headers: {
+        "Accept": "application/pdf, application/json;q=0.9, */*;q=0.8"
+      },
+      serviceKeyEnvName: "JURIDICO_API_KEY"
+    });
+    return response;
+  },
+  aprovarRejeitar: async (data) => {
+    return ApiServiceJ.fetchDataWithAxios({
+      url: `${BASE_URL}/aprovar-rejeitar`,
+      method: "PUT",
+      data,
+      serviceKeyEnvName: "JURIDICO_API_KEY"
+    });
+  },
+  getById: async (id) => {
+    const response = await ApiServiceJ.fetchDataWithAxios({
+      url: `${BASE_URL}/${id}`,
+      method: "GET",
+      serviceKeyEnvName: "JURIDICO_API_KEY"
+    });
+    return response;
+  },
+  getContratoDocusign: async (id) => {
+    const response = await ApiServiceJ.fetchDataWithAxios({
+      url: `${BASE_URL}/${id}/contrato-docusign`,
+      method: "GET",
+      serviceKeyEnvName: "JURIDICO_API_KEY"
+    });
+    return response;
+  },
+  attachEnvelope: async (id, envelopeId) => {
+    await ApiServiceJ.fetchDataWithAxios({
+      url: `${BASE_URL}/${id}/docusign/envelope`,
+      method: "PUT",
+      data: { envelopeId },
+      serviceKeyEnvName: "JURIDICO_API_KEY"
+    });
+  },
+  enviarEnvelope: async (id) => {
+    await ApiServiceJ.fetchDataWithAxios({
+      url: `${BASE_URL}/${id}/docusign/enviar`,
+      method: "POST",
+      serviceKeyEnvName: "JURIDICO_API_KEY"
+    });
+  },
+  syncStatusDocuSign: async () => {
+    await ApiServiceJ.fetchDataWithAxios({
+      url: `${BASE_URL}/docusign/sync-status`,
+      method: "PUT",
+      serviceKeyEnvName: "JURIDICO_API_KEY"
+    });
+  },
+  getRecipientsStatus: async (id) => {
+    const response = await ApiServiceJ.fetchDataWithAxios({
+      url: `${BASE_URL}/${id}/docusign/recipients`,
+      method: "GET",
+      serviceKeyEnvName: "JURIDICO_API_KEY"
+    });
+    return response || [];
+  }
+};
+export {
+  termosService
+};
+//# sourceMappingURL=termosService.js.map

package/dist/base/services/modules/juridico/termosService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"termosService.js","sources":["../../../../../lib/base/services/modules/juridico/termosService.ts"],"sourcesContent":["import ApiServiceJ from '@/services/ApiServiceJ'\nimport { TTermo } from '@base/@types/api/request/juridico/termos/termo'\nimport { TTermoFormSchema } from '@base/@types/api/request/juridico/termos/types'\n\n\nconst BASE_URL = '/juridico/api/juridico/termos'\n\nexport const termosService = {\n    create: async (termo: TTermoFormSchema): Promise<{ id: number }> => {\n        try {\n            console.log('Payload being sent:', termo)\n            \n            const response = await ApiServiceJ.fetchDataWithAxios<{ id: number }, TTermoFormSchema>({\n                url: BASE_URL,\n                method: 'POST',\n                data: termo,\n                serviceKeyEnvName: 'JURIDICO_API_KEY',\n            })\n            return response\n        } catch (error: any) {\n            console.error('Detailed error:', error.response?.data)\n            throw error\n        }\n    },\n    \n    downloadPdf: async (id: number): Promise<ArrayBuffer> => {\n        console.log('Chamando download com ID:', id)\n        try {\n            const response = await ApiServiceJ.fetchDataWithAxios<ArrayBuffer>({\n                url: `${BASE_URL}/download/${id}`,\n                method: 'GET',\n                responseType: 'arraybuffer',\n                headers: {\n                    'Accept': 'application/pdf, application/json;q=0.9, */*;q=0.8'\n                },\n                serviceKeyEnvName: 'JURIDICO_API_KEY',\n            })\n            console.log('Resposta recebida:', response)\n            return response\n        } catch (error: any) {\n            console.error('Erro completo:', error)\n            throw error\n        }\n    },\n    downloadPdfDocuSign: async (id: number): Promise<ArrayBuffer> => {\n        const response = await ApiServiceJ.fetchDataWithAxios<ArrayBuffer>({\n            url: `${BASE_URL}/${id}/docusign/download`,\n            method: 'GET',\n            responseType: 'arraybuffer',\n            headers: {\n                'Accept': 'application/pdf, application/json;q=0.9, */*;q=0.8'\n            },\n            serviceKeyEnvName: 'JURIDICO_API_KEY',\n        })\n        return response\n    },\n    aprovarRejeitar: async (data: {\n        termoId: number;\n        status: 'APROVADO' | 'REJEITADO';\n        justificativaRejeicao?: string;\n    }) => {\n        return ApiServiceJ.fetchDataWithAxios({\n            url: `${BASE_URL}/aprovar-rejeitar`,\n            method: 'PUT',\n            data,\n            serviceKeyEnvName: 'JURIDICO_API_KEY',\n        })\n    },\n\n    getById: async (id: number): Promise<TTermo> => {\n        const response = await ApiServiceJ.fetchDataWithAxios<TTermo>({\n            url: `${BASE_URL}/${id}`,\n            method: 'GET',\n            serviceKeyEnvName: 'JURIDICO_API_KEY',\n        })\n        return response\n    },\n\n    getContratoDocusign: async (id: number): Promise<{ envelopeId: string; contratoId: number }> => {\n        const response = await ApiServiceJ.fetchDataWithAxios<{ envelopeId: string; contratoId: number }>({\n            url: `${BASE_URL}/${id}/contrato-docusign`,\n            method: 'GET',\n            serviceKeyEnvName: 'JURIDICO_API_KEY',\n        })\n        return response\n    },\n\n    attachEnvelope: async (id: number, envelopeId: string): Promise<void> => {\n        await ApiServiceJ.fetchDataWithAxios<void, { envelopeId: string }>({\n            url: `${BASE_URL}/${id}/docusign/envelope`,\n            method: 'PUT',\n            data: { envelopeId },\n            serviceKeyEnvName: 'JURIDICO_API_KEY',\n        })\n    },\n    enviarEnvelope: async (id: number): Promise<void> => {\n        await ApiServiceJ.fetchDataWithAxios<void>({\n            url: `${BASE_URL}/${id}/docusign/enviar`,\n            method: 'POST',\n            serviceKeyEnvName: 'JURIDICO_API_KEY',\n        })\n    },\n    syncStatusDocuSign: async (): Promise<void> => {\n        await ApiServiceJ.fetchDataWithAxios<void>({\n            url: `${BASE_URL}/docusign/sync-status`,\n            method: 'PUT',\n            serviceKeyEnvName: 'JURIDICO_API_KEY',\n        })\n    },\n    getRecipientsStatus: async (id: number): Promise<Array<{ name: string; email: string; status?: string }>> => {\n        const response = await ApiServiceJ.fetchDataWithAxios<Array<{ name: string; email: string; status?: string }>>({\n            url: `${BASE_URL}/${id}/docusign/recipients`,\n            method: 'GET',\n            serviceKeyEnvName: 'JURIDICO_API_KEY',\n        })\n        return response || []\n    },\n}"],"names":[],"mappings":";AAKA,MAAM,WAAW;AAEV,MAAM,gBAAgB;AAAA,EACzB,QAAQ,OAAO,UAAqD;AAChE,QAAI;AACA,cAAQ,IAAI,uBAAuB,KAAK;AAExC,YAAM,WAAW,MAAM,YAAY,mBAAqD;AAAA,QACpF,KAAK;AAAA,QACL,QAAQ;AAAA,QACR,MAAM;AAAA,QACN,mBAAmB;AAAA,MAAA,CACtB;AACD,aAAO;AAAA,IACX,SAAS,OAAY;AACjB,cAAQ,MAAM,mBAAmB,MAAM,UAAU,IAAI;AACrD,YAAM;AAAA,IACV;AAAA,EACJ;AAAA,EAEA,aAAa,OAAO,OAAqC;AACrD,YAAQ,IAAI,6BAA6B,EAAE;AAC3C,QAAI;AACA,YAAM,WAAW,MAAM,YAAY,mBAAgC;AAAA,QAC/D,KAAK,GAAG,QAAQ,aAAa,EAAE;AAAA,QAC/B,QAAQ;AAAA,QACR,cAAc;AAAA,QACd,SAAS;AAAA,UACL,UAAU;AAAA,QAAA;AAAA,QAEd,mBAAmB;AAAA,MAAA,CACtB;AACD,cAAQ,IAAI,sBAAsB,QAAQ;AAC1C,aAAO;AAAA,IACX,SAAS,OAAY;AACjB,cAAQ,MAAM,kBAAkB,KAAK;AACrC,YAAM;AAAA,IACV;AAAA,EACJ;AAAA,EACA,qBAAqB,OAAO,OAAqC;AAC7D,UAAM,WAAW,MAAM,YAAY,mBAAgC;AAAA,MAC/D,KAAK,GAAG,QAAQ,IAAI,EAAE;AAAA,MACtB,QAAQ;AAAA,MACR,cAAc;AAAA,MACd,SAAS;AAAA,QACL,UAAU;AAAA,MAAA;AAAA,MAEd,mBAAmB;AAAA,IAAA,CACtB;AACD,WAAO;AAAA,EACX;AAAA,EACA,iBAAiB,OAAO,SAIlB;AACF,WAAO,YAAY,mBAAmB;AAAA,MAClC,KAAK,GAAG,QAAQ;AAAA,MAChB,QAAQ;AAAA,MACR;AAAA,MACA,mBAAmB;AAAA,IAAA,CACtB;AAAA,EACL;AAAA,EAEA,SAAS,OAAO,OAAgC;AAC5C,UAAM,WAAW,MAAM,YAAY,mBAA2B;AAAA,MAC1D,KAAK,GAAG,QAAQ,IAAI,EAAE;AAAA,MACtB,QAAQ;AAAA,MACR,mBAAmB;AAAA,IAAA,CACtB;AACD,WAAO;AAAA,EACX;AAAA,EAEA,qBAAqB,OAAO,OAAoE;AAC5F,UAAM,WAAW,MAAM,YAAY,mBAA+D;AAAA,MAC9F,KAAK,GAAG,QAAQ,IAAI,EAAE;AAAA,MACtB,QAAQ;AAAA,MACR,mBAAmB;AAAA,IAAA,CACtB;AACD,WAAO;AAAA,EACX;AAAA,EAEA,gBAAgB,OAAO,IAAY,eAAsC;AACrE,UAAM,YAAY,mBAAiD;AAAA,MAC/D,KAAK,GAAG,QAAQ,IAAI,EAAE;AAAA,MACtB,QAAQ;AAAA,MACR,MAAM,EAAE,WAAA;AAAA,MACR,mBAAmB;AAAA,IAAA,CACtB;AAAA,EACL;AAAA,EACA,gBAAgB,OAAO,OAA8B;AACjD,UAAM,YAAY,mBAAyB;AAAA,MACvC,KAAK,GAAG,QAAQ,IAAI,EAAE;AAAA,MACtB,QAAQ;AAAA,MACR,mBAAmB;AAAA,IAAA,CACtB;AAAA,EACL;AAAA,EACA,oBAAoB,YAA2B;AAC3C,UAAM,YAAY,mBAAyB;AAAA,MACvC,KAAK,GAAG,QAAQ;AAAA,MAChB,QAAQ;AAAA,MACR,mBAAmB;AAAA,IAAA,CACtB;AAAA,EACL;AAAA,EACA,qBAAqB,OAAO,OAAiF;AACzG,UAAM,WAAW,MAAM,YAAY,mBAA4E;AAAA,MAC3G,KAAK,GAAG,QAAQ,IAAI,EAAE;AAAA,MACtB,QAAQ;AAAA,MACR,mBAAmB;AAAA,IAAA,CACtB;AACD,WAAO,YAAY,CAAA;AAAA,EACvB;AACJ;"}

package/lib/@ecme/services/ApiServiceJ.ts

@@ -0,0 +1,30 @@
+import ApiService from './ApiService'
+import type { AxiosRequestConfig } from 'axios'
+
+const ApiServiceJ = {
+    fetchDataWithAxios<Response = unknown, Request = Record<string, unknown>>(
+        param: AxiosRequestConfig<Request> & { serviceKeyEnvName?: 'JURIDICO_API_KEY' | 'DOCUSIGN_API_KEY' },
+    ) {
+        const { serviceKeyEnvName, headers: originalHeaders, ...rest } = param
+
+        const headers = { ...(originalHeaders || {}) }
+
+        if (serviceKeyEnvName) {
+            const rawSecret = (import.meta.env as any)[serviceKeyEnvName] ?? ''
+
+            if (rawSecret) {
+                headers['X-API-KEY'] = window.btoa(String(rawSecret))
+            } else {
+                console.warn(
+                    `[ApiService] Variável de ambiente '${serviceKeyEnvName}' não encontrada em import.meta.env.`
+                )
+            }
+        }
+
+        return ApiService.fetchDataWithAxios<Response, Request>({
+            ...rest,
+            headers,
+        })
+    },
+}
+export default ApiServiceJ

package/lib/base/@types/api/request/juridico/termos/termo.ts

@@ -0,0 +1,53 @@
+export type TTermo = {
+    id: number
+    ativo: boolean
+    tipoContrato: string
+    dataCadastro: string
+    usuarioCadastro: string
+    fornecedor: {
+        id: number
+        nome: string
+        cpfCnpj: string
+        endereco: {
+            ativo: boolean
+            bairro: string
+            rua: string
+            numero: string
+            cep: string
+            municipio: {
+                id: number
+                nome: string
+                uf: string
+            }
+        }
+    }
+    representante: {
+        ativo: boolean
+        nome: string
+        cpf: string
+        email: string
+        tipo: string
+    }
+    testemunhaCereal: {
+        ativo: boolean
+        nome: string
+        cpf: string
+        email: string
+        tipo: string
+    }
+    testemunhaFornecedor: {
+        ativo: boolean
+        nome: string
+        cpf: string
+        email: string
+        tipo: string
+    }
+    numeroTermo: string
+    dataTermo: string
+    arquivoPdf: string
+    envelopeId?: string
+    statusDocuSign?: string
+    dataUltimaSincronizacaoDocuSign?: string
+    status?: 'PENDENTE' | 'APROVADO' | 'REJEITADO'
+    justificativaRejeicao: string | null
+}

package/lib/base/@types/api/request/juridico/termos/types.ts

@@ -0,0 +1,112 @@
+import { TRoles } from '@base/@types/models/adm/user'
+
+//TODO arrumar os anys
+export type TGeneralFormFields = {
+    username: string
+    name: string
+    email: string
+    telefone?: string
+    celular?: string
+    empresa?: any
+    departamento?: any
+}
+
+export type TRolesFormFields = {
+    roles?: TRoles[] | undefined
+    ativo?: boolean
+    primeiroLogin?: boolean
+    selecionaDeposito?: boolean
+    selecionaCentro?: boolean
+    pesagemManual?: boolean
+}
+
+export enum TipoContrato {
+    PRE_CONTRATUAL = 'PRE_CONTRATUAL',
+    CONTRATUAL = 'CONTRATUAL',
+    CADASTRO = 'CADASTRO'
+}
+
+export enum TipoAssinante {
+    REPRESENTANTE = 'REPRESENTANTE',
+    TESTEMUNHA_CEREAL = 'TESTEMUNHA_CEREAL',
+    TESTEMUNHA_FORNECEDOR = 'TESTEMUNHA_FORNECEDOR'
+}
+
+export enum UF {
+    AC = 'AC',
+    AL = 'AL',
+    AP = 'AP',
+    AM = 'AM',
+    BA = 'BA',
+    CE = 'CE',
+    DF = 'DF',
+    ES = 'ES',
+    GO = 'GO',
+    MA = 'MA',
+    MT = 'MT',
+    MS = 'MS',
+    MG = 'MG',
+    PA = 'PA',
+    PB = 'PB',
+    PR = 'PR',
+    PE = 'PE',
+    PI = 'PI',
+    RJ = 'RJ',
+    RN = 'RN',
+    RS = 'RS',
+    RO = 'RO',
+    RR = 'RR',
+    SC = 'SC',
+    SP = 'SP',
+    SE = 'SE',
+    TO = 'TO'
+}
+
+export interface TMunicipio {
+    id: number
+    nome: string
+    uf: UF
+    ativo?: boolean
+    codigo?: string
+}
+
+export type TEnderecoFornecedor = {
+    id?: number
+    ativo: boolean
+    bairro: string
+    rua: string
+    numero: string
+    cep: string
+    municipioId: number
+}
+
+export type TFornecedor = {
+    id?: number
+    nome: string
+    cpfCnpj: string
+    ativo: boolean
+    endereco: TEnderecoFornecedor
+}
+
+export type TAssinante = {
+    id?: number
+    nome: string
+    cpf: string
+    email: string
+    ativo: boolean
+    tipo: TipoAssinante
+}
+
+export type TTermoFormSchema = {
+    id?: number
+    ativo: boolean
+    tipoContrato: TipoContrato
+    dataCadastro: Date
+    usuarioCadastro: string
+    fornecedor: TFornecedor
+    representante: TAssinante
+    numeroTermo: string
+    testemunhaCereal: TAssinante
+    dataTermo: Date
+    testemunhaFornecedor: TAssinante
+}

package/lib/base/configs/endpoints.config/HubFiscal/nfe.endpoint.config.ts

@@ -2,7 +2,8 @@ const NFE_API_PATH = '/hub-fiscal/api/nfe'
 
 const nfeEndpointConfig = {
     findAll: `${NFE_API_PATH}/find`,
-    getPdf: `${NFE_API_PATH}/pdf/`, 
+    getPdf: `${NFE_API_PATH}/pdf/`,
+    addObservacao: `${NFE_API_PATH}/observacao`, 
 }
 
 export default nfeEndpointConfig

package/lib/base/services/modules/HubFiscal/NfeService.ts

@@ -14,4 +14,12 @@ export async function apiGetPdf(id) {
         url: nfeEndpointConfig.getPdf + id,
         method: 'get',
     })
+}
+
+export async function apiAddObservacao(body) {
+    return ApiService.fetchDataWithAxios({
+        url: nfeEndpointConfig.addObservacao,
+        method: 'post',
+        data: body,
+    })
 }

package/lib/base/services/modules/juridico/JuridicoService.ts

@@ -0,0 +1,52 @@
+import { IFilterParams, TQueryResponse } from '@base/@types/api'
+import ApiServiceJ from '@/services/ApiServiceJ'
+import { TTermo } from '@base/@types/api/request/juridico/termos/termo'
+
+export async function apiGetTermos(body?: IFilterParams) {
+    const response = await ApiServiceJ.fetchDataWithAxios<TTermo[]>({
+        url: '/juridico/api/juridico/termos/listar',
+        method: 'get',
+        serviceKeyEnvName: 'JURIDICO_API_KEY',
+    })
+    
+    // Aplicar filtros no frontend (já que o backend não suporta filtros)
+    let filteredResponse = response || []
+    
+    if (body) {
+        if (body.id) {
+            filteredResponse = filteredResponse.filter((termo: TTermo) =>
+                termo.id?.toString().includes(body.id as string)
+            )
+        }
+        if (body.fornecedor) {
+            const searchTerm = (body.fornecedor as string).toLowerCase()
+            filteredResponse = filteredResponse.filter((termo: TTermo) =>
+                termo.fornecedor?.nome?.toLowerCase().includes(searchTerm)
+            )
+        }
+        if (body.usuarioCadastro) {
+            const searchTerm = (body.usuarioCadastro as string).toLowerCase()
+            filteredResponse = filteredResponse.filter((termo: TTermo) =>
+                termo.usuarioCadastro?.toLowerCase().includes(searchTerm)
+            )
+        }
+        if (body.dataCadastro) {
+            const searchDate = body.dataCadastro as string
+            filteredResponse = filteredResponse.filter((termo: TTermo) => {
+                if (!termo.dataCadastro) return false
+                const termoDate = new Date(termo.dataCadastro).toISOString().split('T')[0]
+                return termoDate === searchDate
+            })
+        }
+    }
+    
+    const paginatedResponse = {
+        content: filteredResponse,
+        size: filteredResponse.length,
+        totalElements: filteredResponse.length,
+        totalPages: 1,
+        number: 0
+    }
+    
+    return paginatedResponse as TQueryResponse<TTermo>
+}

package/lib/base/services/modules/juridico/docusignService.ts

@@ -0,0 +1,154 @@
+import ApiServiceJ from '@/services/ApiServiceJ'
+
+export type TSignerUpdate = {
+    email: string
+    recipientId: string
+    name?: string
+}
+
+export type TSendEnvelopeRequest = {
+    subject: string
+    signers: { email: string; name: string }[]
+    documentBase64: string
+    documentId?: string
+}
+
+export type TEnvelopeOutput = {
+    envelopeId: string
+    status?: string
+    updatedDateTime?: string
+}
+
+export const docusignService = {
+    sendEnvelope: async (payload: TSendEnvelopeRequest): Promise<TEnvelopeOutput> => {
+        const request = {
+            brandId: '',
+            emailSubject: payload.subject,
+            status: 'sent',
+            createdDateTime: new Date().toISOString(),
+            completedDateTime: null,
+            deletedDateTime: null,
+            deliveredDateTime: null,
+            sentDateTime: null,
+            documents: [
+                {
+                    documentId: payload.documentId,
+                    name: 'Termo',
+                    fileExtension: 'pdf',
+                    documentBase64: payload.documentBase64,
+                },
+            ],
+            recipients: {
+                signers: payload.signers.map((s, idx) => ({
+                    emailBody: '',
+                    emailSubject: payload.subject,
+                    email: s.email,
+                    name: s.name,
+                    recipientId: String(idx + 1),
+                    routingOrder: String(idx + 1),
+                    signHereTabs: [],
+                })),
+            },
+        }
+
+        console.log('[DocuSign] POST /send-envelopeId — request:', request)
+
+        try {
+            const response = await ApiServiceJ.fetchDataWithAxios<{
+                status?: string
+                envelopeId: string
+            }, typeof request>({
+                url: '/docusign/api/docusign/send-envelopeId',
+                method: 'POST',
+                data: request,
+                headers: { 'Content-Type': 'application/json' },
+                serviceKeyEnvName: 'DOCUSIGN_API_KEY',
+            })
+
+            console.log('[DocuSign] POST /send-envelopeId — response:', response)
+
+            return {
+                envelopeId: response.envelopeId,
+                status: response.status,
+            }
+        } catch (err) {
+            console.error('[DocuSign] POST /send-envelopeId — error:', err)
+            throw err
+        }
+    },
+
+    listEnvelopes: async (date: string, status: string): Promise<TEnvelopeOutput[]> => {
+        const response = await ApiServiceJ.fetchDataWithAxios<{
+            resultSetSize: string
+            totalSetSize: string
+            envelopes: Array<{
+                createdDateTime: string
+                statusChangedDateTime?: string
+                envelopeId: string
+                status: string
+            }>
+        }, Record<string, unknown>>({
+            url: `/docusign/api/docusign/list-status-envelopeId/${date}`,
+            method: 'GET',
+            params: { status },
+            serviceKeyEnvName: 'DOCUSIGN_API_KEY',
+        })
+
+        return (response.envelopes || []).map((e) => ({
+            envelopeId: e.envelopeId,
+            status: e.status,
+            updatedDateTime: e.statusChangedDateTime ?? e.createdDateTime,
+        }))
+    },
+
+    listRecipients: async (envelopeId: string) => {
+        const response = await ApiServiceJ.fetchDataWithAxios<{
+            signers: Array<{ name: string; email: string; status?: string }>
+        }, Record<string, unknown>>({
+            url: `/docusign/api/docusign/list-status-recipients/${envelopeId}`,
+            method: 'GET',
+            serviceKeyEnvName: 'DOCUSIGN_API_KEY',
+        })
+
+        return response.signers || []
+    },
+
+    voidEnvelope: async (envelopeId: string, reason: string) => {
+        await ApiServiceJ.fetchDataWithAxios<void, Record<string, unknown>>({
+            url: `/docusign/api/docusign/voided-envelope/${envelopeId}`,
+            method: 'PUT',
+            params: { voidedReason: reason },
+            serviceKeyEnvName: 'DOCUSIGN_API_KEY',
+        })
+    },
+
+    updateRecipients: async (envelopeId: string, signers: TSignerUpdate[]) => {
+        const request = {
+            signers: signers.map((s) => ({
+                email: s.email,
+                recipientId: s.recipientId,
+            })),
+        }
+
+        await ApiServiceJ.fetchDataWithAxios<void, typeof request>({
+            url: `/docusign/api/docusign/update-email/${envelopeId}`,
+            method: 'PUT',
+            data: request,
+            serviceKeyEnvName: 'DOCUSIGN_API_KEY',
+        })
+    },
+
+    downloadSignedPdf: async (envelopeId: string, documentId: string): Promise<ArrayBuffer> => {
+        const response = await ApiServiceJ.fetchDataWithAxios<{ pdfBase64: string }>({
+            url: `/docusign/api/docusign/download-pdf/${envelopeId}/${documentId}`,
+            method: 'GET',
+            serviceKeyEnvName: 'DOCUSIGN_API_KEY',
+        })
+        const b64 = response?.pdfBase64 || ''
+        const binary = atob(b64)
+        const len = binary.length
+        const bytes = new Uint8Array(len)
+        for (let i = 0; i < len; i++) bytes[i] = binary.charCodeAt(i)
+        return bytes.buffer
+    },
+}

package/lib/base/services/modules/juridico/municipiosService.ts

@@ -0,0 +1,46 @@
+import ApiService from '@/services/ApiService'
+import { TQueryResponse } from '@base/@types/api'
+
+export const municipiosService = {
+    getAll: async (): Promise<any[]> => {
+        try {
+            console.log('Fazendo requisição para /dados-mestres/api/municipio/find')
+            
+            // Usando o ApiService padrão do projeto que já inclui o X-Service-Token
+            const response = await ApiService.fetchDataWithAxios<TQueryResponse<any>>({
+                url: '/dados-mestres/api/municipio/find',
+                method: 'POST',
+                data: {
+                    id: null,
+                    municipio: null,
+                    codigo: null,
+                    pageable: {
+                        pageNumber: 1,
+                        pageSize: 10000,
+                        sort: [{
+                            sortField: 'municipio',
+                            sortOrder: 'asc'
+                        }]
+                    }
+                }
+            })
+            
+            console.log('Resposta da API:', response)
+            
+            // A resposta é paginada, então pegamos o conteúdo
+            const municipios = response.content || []
+            
+            // Mapear para o formato esperado pelo frontend
+            return municipios.map((municipio: any) => ({
+                id: municipio.id,
+                nome: municipio.municipio,
+                uf: municipio.uf,
+                codigo: municipio.codigo,
+                ativo: true // Assumindo que todos os retornados estão ativos
+            }))
+        } catch (error) {
+            console.error('Error fetching municipalities:', error)
+            return []
+        }
+    }
+}