@orbe-agro/client-core 5.6.135 → 5.6.137

package/lib/base/configs/navigation.config/modules.submenu/centralNfe/submenu.centralNfe.ts

@@ -3,6 +3,7 @@ import { ADMIN } from '@/constants/roles.constant'
 import { NavigationTree } from '@/@types/navigation'
 import cadastrosSubmenu from '../../submenu/centralNfe/cadastros.submenu'
 import nfeSubmenu from '../../submenu/centralNfe/config/nfe.submenu'
+import recepcaoFisicaSubmenu from '../../submenu/centralNfe/config/recepcaoFisica.submenu'
 
 const subMenuCentralNfe: NavigationTree =
 {
@@ -15,6 +16,7 @@ const subMenuCentralNfe: NavigationTree =
     authority: [ADMIN],
     subMenu: [
         nfeSubmenu,
+        recepcaoFisicaSubmenu,
         {
             key: 'modules.centralNfe.cadastros',
             path: '',

package/lib/base/configs/navigation.config/submenu/centralNfe/config/recepcaoFisica.submenu.ts

@@ -0,0 +1,16 @@
+import { NAV_ITEM_TYPE_ITEM } from '@/constants/navigation.constant'
+import { ADMIN } from '@/constants/roles.constant'
+import { NavigationTree } from '@/@types/navigation'
+
+const recepcaoFisicaSubmenu: NavigationTree = {
+    key: 'centralNfe.recepcaoFisica.table',
+    path: '/central-nfe/recepcao-fisica',
+    title: 'Monitor - Recepção Física',
+    translateKey: 'nav.modules.centralNfe.recepcaoFisica',
+    icon: 'recepcaoFisica',
+    type: NAV_ITEM_TYPE_ITEM,
+    authority: [ADMIN],
+    subMenu: [],
+}
+
+export default recepcaoFisicaSubmenu

package/lib/base/services/modules/centralNfe/index.ts

@@ -3,4 +3,5 @@ export * from './intervaloPrecoXml/IntervaloPrecoXmlService'
 export * from './vinculoUnidadeMedida/VinculoUnidadeMedidaService'
 export * from './cnpjLiberadoNota/CnpjLiberadoNotaService'
 export * from './cnpjExcecaoNota/CnpjExcecaoNotaService'
-export * from './nfe/NfeService'
+export * from './nfe/NfeService'
+export * from './recepcaoFisica/RecepcaoFisicaService'

package/lib/base/services/modules/centralNfe/recepcaoFisica/RecepcaoFisicaService.ts

@@ -0,0 +1,32 @@
+import ApiService from "@/services/ApiService";
+import endpointConfig from "@base/configs/endpoints.config/endpoints.navigation";
+
+const RECEPCAO_FISICA_ENDPOINT = endpointConfig.centralNfe.recepcaoFisica;
+
+export async function apiCreateRecepcaoFisica(
+    body: { chaveAcesso: string; ordensCompraPrevisao: string[] },
+    userId: number,
+) {
+    return ApiService.fetchDataWithAxios<void>({
+        url: RECEPCAO_FISICA_ENDPOINT.create.endpoint,
+        method: RECEPCAO_FISICA_ENDPOINT.create.httpMethod,
+        data: body,
+        headers: { 'X-User-Id': userId },
+    })
+}
+
+export async function apiFindMonitorRecepcaoFisica(body: any) {
+    return ApiService.fetchDataWithAxios<any>({
+        url: RECEPCAO_FISICA_ENDPOINT.findMonitor.endpoint,
+        method: RECEPCAO_FISICA_ENDPOINT.findMonitor.httpMethod,
+        data: body,
+    })
+}
+
+export async function apiFindOrdensCompraRecepcaoFisica(cnpj: string) {
+    return ApiService.fetchDataWithAxios<any[]>({
+        url: RECEPCAO_FISICA_ENDPOINT.findOrdensCompra.endpoint,
+        method: RECEPCAO_FISICA_ENDPOINT.findOrdensCompra.httpMethod,
+        params: { cnpj },
+    })
+}

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 []
+        }
+    }
+}

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

@@ -0,0 +1,118 @@
+import ApiServiceJ from '@/services/ApiServiceJ'
+import { TTermo } from '@base/@types/api/request/juridico/termos/termo'
+import { TTermoFormSchema } from '@base/@types/api/request/juridico/termos/types'
+
+
+const BASE_URL = '/juridico/api/juridico/termos'
+
+export const termosService = {
+    create: async (termo: TTermoFormSchema): Promise<{ id: number }> => {
+        try {
+            console.log('Payload being sent:', termo)
+            
+            const response = await ApiServiceJ.fetchDataWithAxios<{ id: number }, TTermoFormSchema>({
+                url: BASE_URL,
+                method: 'POST',
+                data: termo,
+                serviceKeyEnvName: 'JURIDICO_API_KEY',
+            })
+            return response
+        } catch (error: any) {
+            console.error('Detailed error:', error.response?.data)
+            throw error
+        }
+    },
+    
+    downloadPdf: async (id: number): Promise<ArrayBuffer> => {
+        console.log('Chamando download com ID:', id)
+        try {
+            const response = await ApiServiceJ.fetchDataWithAxios<ArrayBuffer>({
+                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: any) {
+            console.error('Erro completo:', error)
+            throw error
+        }
+    },
+    downloadPdfDocuSign: async (id: number): Promise<ArrayBuffer> => {
+        const response = await ApiServiceJ.fetchDataWithAxios<ArrayBuffer>({
+            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: {
+        termoId: number;
+        status: 'APROVADO' | 'REJEITADO';
+        justificativaRejeicao?: string;
+    }) => {
+        return ApiServiceJ.fetchDataWithAxios({
+            url: `${BASE_URL}/aprovar-rejeitar`,
+            method: 'PUT',
+            data,
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+    },
+
+    getById: async (id: number): Promise<TTermo> => {
+        const response = await ApiServiceJ.fetchDataWithAxios<TTermo>({
+            url: `${BASE_URL}/${id}`,
+            method: 'GET',
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+        return response
+    },
+
+    getContratoDocusign: async (id: number): Promise<{ envelopeId: string; contratoId: number }> => {
+        const response = await ApiServiceJ.fetchDataWithAxios<{ envelopeId: string; contratoId: number }>({
+            url: `${BASE_URL}/${id}/contrato-docusign`,
+            method: 'GET',
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+        return response
+    },
+
+    attachEnvelope: async (id: number, envelopeId: string): Promise<void> => {
+        await ApiServiceJ.fetchDataWithAxios<void, { envelopeId: string }>({
+            url: `${BASE_URL}/${id}/docusign/envelope`,
+            method: 'PUT',
+            data: { envelopeId },
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+    },
+    enviarEnvelope: async (id: number): Promise<void> => {
+        await ApiServiceJ.fetchDataWithAxios<void>({
+            url: `${BASE_URL}/${id}/docusign/enviar`,
+            method: 'POST',
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+    },
+    syncStatusDocuSign: async (): Promise<void> => {
+        await ApiServiceJ.fetchDataWithAxios<void>({
+            url: `${BASE_URL}/docusign/sync-status`,
+            method: 'PUT',
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+    },
+    getRecipientsStatus: async (id: number): Promise<Array<{ name: string; email: string; status?: string }>> => {
+        const response = await ApiServiceJ.fetchDataWithAxios<Array<{ name: string; email: string; status?: string }>>({
+            url: `${BASE_URL}/${id}/docusign/recipients`,
+            method: 'GET',
+            serviceKeyEnvName: 'JURIDICO_API_KEY',
+        })
+        return response || []
+    },
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbe-agro/client-core",
-  "version": "5.6.135",
+  "version": "5.6.137",
   "description": "Biblioteca principal de componentes e utilidades para os microfrontends do Orbe Agro.",
   "type": "module",
   "main": "./dist/index.js",