@orbe-agro/client-core 5.6.71 → 5.6.83

package/lib/base/configs/navigation.config/submenu/ativos/config/ativo.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 ativoSubmenu: NavigationTree = {
+    key: 'modules.ativos.ativo',
+    path: '/ativos/ativo',
+    title: 'Monitor de Ativos',
+    translateKey: 'nav.modules.ativos.ativo',
+    icon: 'ativo',
+    type: NAV_ITEM_TYPE_ITEM,
+    authority: [ADMIN],
+    subMenu: [],
+}
+
+export default ativoSubmenu

package/lib/base/configs/navigation.config/submenu/ativos/config/documentacao.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 documentacaoSubmenu: NavigationTree = {
+    key: 'modules.ativos.documentacao',
+    path: '/ativos/documentacao',
+    title: 'Documentação',
+    translateKey: 'nav.modules.ativos.documentacao',
+    icon: 'documentacao',
+    type: NAV_ITEM_TYPE_ITEM,
+    authority: [ADMIN],
+    subMenu: [],
+}
+
+export default documentacaoSubmenu

package/lib/base/configs/navigation.config/submenu/ativos/config/formularioCampos.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 formularioCamposSubmenu: NavigationTree = {
+    key: 'modules.ativos.formularioCampos',
+    path: '/ativos/formulario-campos',
+    title: 'Formulário de Campos',
+    translateKey: 'nav.modules.ativos.formularioCampos',
+    icon: 'formularioCampos',
+    type: NAV_ITEM_TYPE_ITEM,
+    authority: [ADMIN],
+    subMenu: [],
+}
+
+export default formularioCamposSubmenu

package/lib/base/configs/navigation.config/submenu/ativos/contratos.submenu.ts

@@ -0,0 +1,8 @@
+import { NavigationTree } from "@/@types/navigation"
+import documentacaoSubmenu from "./config/documentacao.submenu"
+
+const contratosSubmenu: NavigationTree[] = [
+    documentacaoSubmenu,
+]
+
+export default contratosSubmenu

package/lib/base/hooks/dm/businessPartner/useBusinessPartnerFindMonitorFornecedorList.tsx

@@ -2,17 +2,25 @@ import { apiFindMonitorFornecedor, generateQueryParams } from '@base/services'
 import { useBusinessPartnerFindMonitorFornecedorListStore } from '@base/store/dm/businesPartner/businessPartnerFindMonitorFornecedorListStore'
 import useSWR from 'swr'
 
-export default function useBusinessPartnerFindMonitorFornecedorList() {
+export default function useBusinessPartnerFindMonitorFornecedorList(options?: { enableAutoFetch?: boolean }) {
     const { tableParams, filterParams, setTableParams, setFilterParams } =
         useBusinessPartnerFindMonitorFornecedorListStore((state) => state)
 
+    const queryParams = generateQueryParams(filterParams, tableParams)
+
     const hasFilter = (typeof filterParams.businessPartner === 'string' && filterParams.businessPartner.trim() !== '')
         || (typeof filterParams.nomeCompletoBusinessPartner === 'string' && filterParams.nomeCompletoBusinessPartner.trim() !== '')
         || !!filterParams.id
 
+    // Se enableAutoFetch for false, só busca quando há filtros válidos
+    // Se enableAutoFetch for true ou undefined (padrão), sempre busca
+    const shouldFetch = options?.enableAutoFetch === false
+        ? hasFilter
+        : true
+
     const { data, error, isLoading, mutate } = useSWR(
-        hasFilter
-            ? ['/api/dm/business-partner/find-monitor-fornecedor', generateQueryParams(filterParams, tableParams)]
+        shouldFetch && hasFilter
+            ? ['/api/dm/business-partner/find-monitor-fornecedor', queryParams]
             : null,
         ([, params]) => apiFindMonitorFornecedor({ ...params }),
         { revalidateOnFocus: false },

package/lib/base/locales/lang/ptBR/modules/HubFiscal/hubFiscal.nav.ts

@@ -0,0 +1,8 @@
+
+export default {
+    hubFiscal: {
+        title: 'Hub Fiscal',
+        nfeEmitidas: 'NF-e Emitidas',
+        nfeRecebidas: 'NF-e Recebidas',   
+    },
+}

package/lib/base/services/http.ts

@@ -0,0 +1,47 @@
+import ApiService from '@/services/ApiService'
+
+/**
+ * Generic HTTP GET function that uses the existing ApiService structure
+ */
+export async function apiGet<T = any>(url: string, config?: { params?: Record<string, any> }) {
+    return ApiService.fetchDataWithAxios<T>({
+        url,
+        method: 'GET',
+        params: config?.params,
+    })
+}
+
+/**
+ * Generic HTTP POST function that uses the existing ApiService structure
+ */
+export async function apiPost<T = any>(url: string, data?: any, config?: { params?: Record<string, any> }) {
+    return ApiService.fetchDataWithAxios<T>({
+        url,
+        method: 'POST',
+        data,
+        params: config?.params,
+    })
+}
+
+/**
+ * Generic HTTP PUT function that uses the existing ApiService structure
+ */
+export async function apiPut<T = any>(url: string, data?: any, config?: { params?: Record<string, any> }) {
+    return ApiService.fetchDataWithAxios<T>({
+        url,
+        method: 'PUT',
+        data,
+        params: config?.params,
+    })
+}
+
+/**
+ * Generic HTTP DELETE function that uses the existing ApiService structure
+ */
+export async function apiDelete<T = any>(url: string, config?: { params?: Record<string, any> }) {
+    return ApiService.fetchDataWithAxios<T>({
+        url,
+        method: 'DELETE',
+        params: config?.params,
+    })
+}

package/lib/base/services/index.ts

@@ -1,5 +1,8 @@
 // Services exports from base
 
+// HTTP utilities for direct API calls
+export * from './http';
+
 // Exports do query.ts (mantendo nomes originais para funções únicas)
 export {
     getDefaultQueryParams,

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

@@ -0,0 +1,10 @@
+import nfeEndpointConfig from '@base/configs/endpoints.config/HubFiscal/nfe.endpoint.config'
+import ApiService from '@/services/ApiService'
+
+export async function apiGetNfes(body) {
+    return ApiService.fetchDataWithAxios({
+        url: nfeEndpointConfig.findAll,
+        method: 'post',
+        data: body,
+    })
+}

package/lib/base/services/modules/agendamento/AgendamentoService.ts

@@ -0,0 +1,234 @@
+import { IFilterParams, TQueryResponse } from '@base/@types/api'
+import {
+  TAgendamento,
+  TAgendamentoFormSchema,
+  TAgendamentoRequest,
+  TAgendamentoListParams,
+  TJanelaDisponivel,
+  TPainelJanelasRequest,
+  TPainelCalendarioRequest,
+  TPainelBiRequest,
+  TPainelBiData,
+  TBIAgendamento,
+  TBIPainelOrdemConsumo,
+  TCancelamentoRequest,
+} from '@base/@types/models/agendamento/agendamento'
+import { endpointsConfig } from '@base/configs'
+import ApiService from '@/services/ApiService'
+
+export async function apiGetAgendamentos(body?: IFilterParams) {
+  const queryParams = new URLSearchParams()
+
+  Object.entries(body || {}).forEach(([key, value]) => {
+    if (Array.isArray(value)) {
+      value.forEach((item) => queryParams.append(key, String(item)))
+    } else if (value !== undefined && value !== null) {
+      queryParams.append(key, String(value))
+    }
+  })
+
+  return ApiService.fetchDataWithAxios<TQueryResponse<TAgendamento>>({
+    url: `${endpointsConfig.agendamento.agendamentoCrud.findAll}?${queryParams.toString()}`,
+    method: 'get',
+  })
+}
+
+export async function apiGetAgendamentoById(id: string | number) {
+  return ApiService.fetchDataWithAxios<TAgendamento>({
+    url: `${endpointsConfig.agendamento.agendamentoCrud.findOne}/${id}`,
+    method: 'get',
+  })
+}
+
+export async function apiCreateAgendamento(data: TAgendamentoRequest | TAgendamentoFormSchema) {
+  return ApiService.fetchDataWithAxios<TAgendamento>({
+    url: endpointsConfig.agendamento.agendamentoCrud.add,
+    method: 'post',
+    data,
+  })
+}
+
+export async function apiUpdateAgendamento(
+  id: string | number,
+  data: TAgendamentoRequest | TAgendamentoFormSchema,
+) {
+  return ApiService.fetchDataWithAxios<TAgendamento>({
+    url: `${endpointsConfig.agendamento.agendamentoCrud.update}/${id}`,
+    method: 'patch',
+    data,
+  })
+}
+
+export async function apiDeleteAgendamento(id: string | number) {
+  return ApiService.fetchDataWithAxios({
+    url: `${endpointsConfig.agendamento.agendamentoCrud.delete}/${id}`,
+    method: 'delete',
+  })
+}
+
+export async function apiCancelarAgendamento(body?: TCancelamentoRequest) {
+  return ApiService.fetchDataWithAxios<any>({
+    url: endpointsConfig.agendamento.agendamentoCrud.cancel,
+    method: 'put',
+    data: body,
+  })
+}
+
+export async function apiCancelarAgendamentoById(id: number) {
+  return ApiService.fetchDataWithAxios<TAgendamento>({
+    url: `/agendamento/api/${id}/cancel`,
+    method: 'delete',
+  })
+}
+
+export async function apiGetBIAgendamento(
+  params?: Record<string, string | number | string[] | number[]>,
+) {
+  const queryParams = new URLSearchParams()
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (Array.isArray(value)) {
+      value.forEach((item) => queryParams.append(key, String(item)))
+    } else if (value !== undefined && value !== null) {
+      queryParams.append(key, String(value))
+    }
+  })
+
+  const queryString = queryParams.toString()
+
+  return ApiService.fetchDataWithAxios<TBIAgendamento>({
+    url: `${endpointsConfig.agendamento.agendamentoCrud.bi}${queryString ? `?${queryString}` : ''}`,
+    method: 'get',
+  })
+}
+
+export async function apiGetBIPainelOrdemConsumo() {
+  return ApiService.fetchDataWithAxios<TBIPainelOrdemConsumo>({
+    url: '/agendamento/api/ordem-consumo/painel/bi',
+    method: 'get',
+  })
+}
+
+export async function apiListAgendamentos(params: TAgendamentoListParams = {}) {
+  const queryParams = new URLSearchParams()
+  if (params.status) queryParams.append('status', params.status)
+  if (params.localId) queryParams.append('localId', params.localId.toString())
+  if (params.page !== undefined) queryParams.append('page', params.page.toString())
+  if (params.size !== undefined) queryParams.append('size', params.size.toString())
+
+  return ApiService.fetchDataWithAxios<TQueryResponse<TAgendamento>>({
+    url: `/agendamento/apis?${queryParams.toString()}`,
+    method: 'get',
+  })
+}
+
+export async function apiGetJanelasDisponiveis(params: {
+  localId: number
+  dataInicio: string
+  dataFim: string
+}) {
+  const queryParams = new URLSearchParams()
+  queryParams.append('localId', params.localId.toString())
+  queryParams.append('dataInicio', params.dataInicio)
+  queryParams.append('dataFim', params.dataFim)
+
+  return ApiService.fetchDataWithAxios<TJanelaDisponivel[]>({
+    url: `${endpointsConfig.agendamento.agendamentoCrud.janelasDisponiveis}?${queryParams.toString()}`,
+    method: 'get',
+  })
+}
+
+export async function apiGetJanelasOcupadas(localId: number) {
+  return ApiService.fetchDataWithAxios<TJanelaDisponivel[]>({
+    url: `${endpointsConfig.agendamento.agendamentoCrud.janelasOcupadas}?localId=${localId}`,
+    method: 'get',
+  })
+}
+
+export async function apiGetPainelJanelas(data: TPainelJanelasRequest) {
+  return ApiService.fetchDataWithAxios<TJanelaDisponivel[]>({
+    url: endpointsConfig.agendamento.agendamentoCrud.painelJanelas,
+    method: 'post',
+    data,
+  })
+}
+
+export async function apiGetPainelBi(params: TPainelBiRequest) {
+  return ApiService.fetchDataWithAxios<TPainelBiData>({
+    url: `${endpointsConfig.agendamento.agendamentoCrud.painelBi}?data=${params.data}&localId=${params.localId}`,
+    method: 'get',
+  })
+}
+
+export async function apiGetPainelCalendario(data: TPainelCalendarioRequest) {
+  return ApiService.fetchDataWithAxios<TJanelaDisponivel[]>({
+    url: endpointsConfig.agendamento.agendamentoCrud.painelCalendario,
+    method: 'post',
+    data,
+  })
+}
+
+export async function apiFindJanelasDisponiveis(
+  localId: number,
+  dataInicio?: string,
+  dataFim?: string,
+) {
+  return ApiService.fetchDataWithAxios<TJanelaDisponivel[]>({
+    url: endpointsConfig.agendamento.agendamentoCrud.janelasDisponiveis,
+    method: 'get',
+    params: {
+      localId,
+      dataInicio: dataInicio || new Date().toISOString().split('T')[0],
+      dataFim: dataFim || new Date().toISOString().split('T')[0],
+    },
+  })
+}
+
+export async function apiGerarRomaneios(data: Record<string, unknown>) {
+  return ApiService.fetchDataWithAxios<{
+    pesoTotal?: number
+    ordensAgendamento?: Record<string, unknown>[]
+  }>({
+    url: endpointsConfig.agendamento.agendamentoCrud.gerarRomaneios,
+    method: 'post',
+    data,
+  })
+}
+
+export async function apiFetchSafrasVinculadas(centroIdSAP: string) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<Record<string, unknown>>>({
+    url: endpointsConfig.agendamento.agendamentoCrud.safrasVinculadas,
+    method: 'get',
+    params: { centroIdSAP },
+  })
+}
+
+export async function apiFetchDepositos(centroIdSAP: string, tipoDeposito?: string) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<Record<string, unknown>>>({
+    url: endpointsConfig.agendamento.agendamentoCrud.depositos,
+    method: 'get',
+    params: { centroIdSAP, tipoDeposito },
+  })
+}
+
+export async function apiBuscaOrdemCarregamento(documentoVenda: string) {
+  return ApiService.fetchDataWithAxios<Record<string, unknown>>({
+    url: `${endpointsConfig.agendamento.agendamentoCrud.ordemCarregamento}/${documentoVenda}`,
+    method: 'get',
+  })
+}
+
+export async function apiFindAllAgendamentos(params: Record<string, unknown> = {}) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TAgendamento>>({
+    url: endpointsConfig.agendamento.agendamentoCrud.findAll,
+    method: 'get',
+    params,
+  })
+}
+
+export async function apiDownloadPdf(id: number) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TAgendamento>>({
+    url: `${endpointsConfig.agendamento.agendamentoCrud.pdf}/${id}/pdf`,
+    method: 'get',
+  })
+}

package/lib/base/services/modules/agendamento/ContratoVendaService.ts

@@ -0,0 +1,112 @@
+import { IFilterParams, TQueryResponse } from '@base/@types/api'
+import { TContratoVenda, TRelatorioCota } from '@base/@types/models/agendamento/contratoVenda'
+import { endpointsConfig } from '@base/configs'
+import ApiService from '@/services/ApiService'
+
+export async function apiFindContratoSaldo(params: Record<string, unknown>) {
+  const queryParams = new URLSearchParams()
+
+  Object.entries(params).forEach(([key, value]) => {
+    if (Array.isArray(value)) {
+      value.forEach((item) => queryParams.append(key, String(item)))
+    } else if (value !== undefined && value !== null) {
+      queryParams.append(key, String(value))
+    }
+  })
+
+  return ApiService.fetchDataWithAxios<TQueryResponse<TContratoVenda>>({
+    url: `${endpointsConfig.agendamento.contratoVenda.findAll}?${queryParams.toString()}`,
+    method: 'get',
+  })
+}
+
+export async function apiGetContratoVendaById(id: string | number) {
+  return ApiService.fetchDataWithAxios<TContratoVenda>({
+    url: `${endpointsConfig.agendamento.contratoVenda.findOne}/${id}`,
+    method: 'get',
+  })
+}
+
+export async function apiFindContratosComSaldoPorCliente(clienteId: string | number) {
+  return ApiService.fetchDataWithAxios<TContratoVenda[]>({
+    url: `${endpointsConfig.agendamento.contratoVenda.comSaldoByCliente}/${clienteId}`,
+    method: 'get',
+  })
+}
+
+export async function apiFindAllContratos(params: Record<string, unknown>) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TContratoVenda>>({
+    url: endpointsConfig.agendamento.contratoVenda.findContratos,
+    method: 'post',
+    data: params,
+  })
+}
+
+export async function apiFindACDVendasContrato(contratoNumero: string) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TContratoVenda>>({
+    url: endpointsConfig.agendamento.contratoVenda.findContratos,
+    method: 'post',
+    data: {
+      pageNumber: 1,
+      pageSize: 1,
+      filter: { contratoNumero },
+    },
+  })
+}
+
+export async function apiGetRelatorioCotas(body: IFilterParams) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TRelatorioCota>>({
+    url: endpointsConfig.agendamento.contratoVenda.relatorioCotas,
+    method: 'post',
+    data: body,
+  })
+}
+
+export async function apiGetContratosPeriodo(filter: Record<string, unknown>) {
+  return ApiService.fetchDataWithAxios<Record<string, unknown>[]>({
+    url: endpointsConfig.agendamento.contratoVenda.periodo,
+    method: 'post',
+    data: filter,
+  })
+}
+
+export async function apiGetContratosPeriodoCapacidade(filter: Record<string, unknown>) {
+  return ApiService.fetchDataWithAxios<Record<string, unknown>[]>({
+    url: endpointsConfig.agendamento.contratoVenda.periodoCapacidade,
+    method: 'post',
+    data: filter,
+  })
+}
+
+export async function apiGetAgendamentosContrato(params: {
+  pageNumber: number
+  pageSize: number
+  filter: Record<string, unknown>
+}) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<Record<string, unknown>>>({
+    url: '/agendamento/api-carga-descarga/agendamentos',
+    method: 'post',
+    data: params,
+  })
+}
+
+export async function apiGetCalendarioContrato(localId: number) {
+  const response = await ApiService.fetchDataWithAxios<TQueryResponse<Record<string, unknown>>>({
+    url: '/agendamento/api-carga-descarga/calendarios',
+    method: 'post',
+    data: {
+      filter: { 'local.id': localId },
+      pageNumber: 1,
+      pageSize: 1,
+    },
+  })
+  return response.content?.[0] || null
+}
+
+export async function apiGetLocaisContrato() {
+  const response = await ApiService.fetchDataWithAxios<TQueryResponse<Record<string, unknown>>>({
+    url: endpointsConfig.agendamento.local.findAll,
+    method: 'GET',
+  })
+  return response.content || []
+}

package/lib/base/services/modules/agendamento/ListaEmbarqueService.ts

@@ -0,0 +1,34 @@
+import {
+  TItemListaEmbarque,
+  TListaEmbarqueRequest,
+  TEventoAgendamento,
+  TRegistrarEventoRequest,
+} from '@base/@types/models/agendamento/listaEmbarque'
+import { endpointsConfig } from '@base/configs'
+import ApiService from '@/services/ApiService'
+
+export async function apiFindListaEmbarque(filter: TListaEmbarqueRequest) {
+  return ApiService.fetchDataWithAxios<TItemListaEmbarque[]>({
+    url: endpointsConfig.agendamento.listaEmbarque.find,
+    method: 'post',
+    data: filter,
+  })
+}
+
+export async function apiBuscarEventosAgendamento(agendamentoId: number) {
+  return ApiService.fetchDataWithAxios<TEventoAgendamento>({
+    url: `${endpointsConfig.agendamento.listaEmbarque.eventos}/${agendamentoId}/eventos`,
+    method: 'get',
+  })
+}
+
+export async function apiRegistrarEvento(
+  agendamentoId: number,
+  evento: TRegistrarEventoRequest,
+) {
+  return ApiService.fetchDataWithAxios<TEventoAgendamento>({
+    url: `${endpointsConfig.agendamento.listaEmbarque.eventos}/${agendamentoId}/eventos`,
+    method: 'post',
+    data: evento,
+  })
+}

package/lib/base/services/modules/agendamento/LocalService.ts

@@ -0,0 +1,107 @@
+import { IFilterParams, TQueryResponse } from '@base/@types/api'
+import { TLocal, TLocalFormSchema } from '@base/@types/models/agendamento/local'
+import { TJanela, TJanelaFormSchema } from '@base/@types/models/agendamento/janela'
+import { endpointsConfig } from '@base/configs'
+import ApiService from '@/services/ApiService'
+
+export async function apiGetLocals(body?: IFilterParams) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TLocal>>({
+    url: endpointsConfig.agendamento.local.findAll,
+    method: 'get',
+    params: body,
+  })
+}
+
+export async function apiGetLocalById(id: string | number) {
+  return ApiService.fetchDataWithAxios<TLocal>({
+    url: `${endpointsConfig.agendamento.local.findOne}/${id}`,
+    method: 'get',
+  })
+}
+
+export async function apiCreateLocal(data: TLocalFormSchema) {
+  const createLocalRequest: Record<string, unknown> = {
+    descricao: data.descricao,
+    tempoOperacao: data.tempoOperacao,
+    cotaOperacao: data.cotaOperacao,
+    permitirChamadaUsina: data.permitirChamadaUsina,
+    permitirCarregamento: data.permitirCarregamento,
+    centroId: data.centroId,
+    dataInicial: data.dataInicial,
+    dataFinal: data.dataFinal,
+    calendarioJanelas: data.calendarioJanelas.map((janela) => ({
+      data: janela.data,
+      horaInicial: janela.horaInicial,
+      horaFinal: janela.horaFinal,
+      habilitadoOperacao: janela.habilitadoOperacao,
+    })),
+  }
+
+  if (data.resumoSemanal && data.resumoSemanal.length > 0) {
+    createLocalRequest.resumoSemanal = data.resumoSemanal.map((slot) => ({
+      diaSemana: slot.diaSemana,
+      horaInicial: slot.horaInicial,
+      horaFinal: slot.horaFinal,
+      habilitado: slot.habilitado,
+    }))
+  }
+
+  return ApiService.fetchDataWithAxios<TLocal>({
+    url: endpointsConfig.agendamento.local.add,
+    method: 'post',
+    data: createLocalRequest,
+  })
+}
+
+export async function apiUpdateLocal(id: string | number, data: TLocalFormSchema) {
+  const updateLocalRequest: Record<string, unknown> = {
+    tempoOperacao: data.tempoOperacao,
+    cotaOperacao: data.cotaOperacao,
+    permitirChamadaUsina: data.permitirChamadaUsina,
+    permitirCarregamento: data.permitirCarregamento,
+    dataInicial: data.dataInicial,
+    dataFinal: data.dataFinal,
+  }
+
+  if (data.resumoSemanal && data.resumoSemanal.length > 0) {
+    updateLocalRequest.resumoSemanal = data.resumoSemanal.map((slot) => ({
+      diaSemana: slot.diaSemana,
+      horaInicial: slot.horaInicial,
+      horaFinal: slot.horaFinal,
+      habilitado: slot.habilitado,
+    }))
+  }
+
+  return ApiService.fetchDataWithAxios<TLocal>({
+    url: `${endpointsConfig.agendamento.local.update}/${id}`,
+    method: 'patch',
+    data: updateLocalRequest,
+  })
+}
+
+export async function apiGetJanelas(body?: IFilterParams) {
+  return ApiService.fetchDataWithAxios<TQueryResponse<TJanela>>({
+    url: endpointsConfig.agendamento.local.janelas,
+    method: 'get',
+    params: body,
+  })
+}
+
+export async function apiGetJanelaById(id: string) {
+  return ApiService.fetchDataWithAxios<TJanela>({
+    url: `${endpointsConfig.agendamento.local.findOneJanela}/${id}`,
+    method: 'get',
+  })
+}
+
+export async function apiUpdateJanela(id: string, data: TJanelaFormSchema) {
+  const payload = {
+    habilitadoOperacao: data.janela.habilitadoOperacao,
+  }
+
+  return ApiService.fetchDataWithAxios<TJanela>({
+    url: `${endpointsConfig.agendamento.local.updateJanela}/${id}`,
+    method: 'put',
+    data: payload,
+  })
+}