@orbe-agro/client-core 5.6.260 → 5.6.261

package/lib/@ecme/views/concepts/ai/Chat/hooks/useChatConversations.tsx

@@ -0,0 +1,128 @@
+import useSWR from 'swr'
+import Notification from '@/components/ui/Notification'
+import toast from '@/components/ui/toast'
+import {
+    apiDeleteConversation,
+    apiGetConversations,
+    apiRenameConversation,
+} from '@/services/AiService'
+import { useSessionUser } from '@/store/authStore'
+import { usGenerativeChatStore } from '../store/generativeChatStore'
+import { resumoParaHistorico } from '../utils'
+import type { ChatHistories, GetConversationsResponse } from '../types'
+
+const avisarFalha = (mensagem: string) => {
+    toast.push(
+        <Notification type="danger" duration={3000}>
+            {mensagem}
+        </Notification>,
+        { placement: 'top-center' },
+    )
+}
+
+/**
+ * A lista de conversas do usuário, persistida no backend, e as ações sobre ela.
+ *
+ * Renomear e excluir são otimistas: a tela muda na hora e volta ao estado
+ * anterior se o backend recusar.
+ */
+const useChatConversations = () => {
+    const {
+        setChatHistory,
+        setChatHistoryName,
+        setSelectedConversation,
+    } = usGenerativeChatStore()
+
+    const userId = useSessionUser((state) => state.user.userId)
+    const signedIn = useSessionUser((state) => state.session.signedIn)
+
+    // O usuário faz parte da chave: cada um tem o próprio cache, e o de quem
+    // saiu nunca é servido a quem entrou. Sem sessão, não busca nada.
+    //
+    // Sem `revalidateIfStale: false` de propósito: cada vez que a lista monta,
+    // ela confere o backend. Com ele, o SWR servia o cache antigo, não chamava
+    // o `onSuccess`, e a lista só aparecia depois de um F5.
+    useSWR(
+        signedIn && userId ? ['/ai/chat/conversations', userId] : null,
+        // O dono viaja junto com a resposta para o `onSuccess` conferir.
+        async ([, dono]: [string, string]) => ({
+            dono,
+            resumos: await apiGetConversations<GetConversationsResponse>(),
+        }),
+        {
+            revalidateOnFocus: false,
+            revalidateOnReconnect: false,
+            onSuccess: ({ dono, resumos }) => {
+                // Resposta atrasada de quem já saiu: descarta, senão a lista
+                // de um usuário cairia na tela do outro.
+                if (dono !== useSessionUser.getState().user.userId) {
+                    return
+                }
+                // Lido na hora, e não da closure: a resposta pode chegar
+                // depois de o usuário já ter começado uma conversa.
+                const atual = usGenerativeChatStore.getState().chatHistory
+                setChatHistory(mesclar(atual, resumos))
+            },
+        },
+    )
+
+    const remover = async (id: string) => {
+        const { chatHistory, selectedConversation } =
+            usGenerativeChatStore.getState()
+
+        setChatHistory(chatHistory.filter((item) => item.id !== id))
+        if (selectedConversation === id) {
+            setSelectedConversation('')
+        }
+
+        try {
+            await apiDeleteConversation(id)
+        } catch {
+            setChatHistory(chatHistory)
+            avisarFalha('Não foi possível excluir a conversa.')
+        }
+    }
+
+    const renomear = async (id: string, title: string) => {
+        const anterior = usGenerativeChatStore
+            .getState()
+            .chatHistory.find((item) => item.id === id)?.title
+
+        setChatHistoryName({ id, title })
+
+        try {
+            await apiRenameConversation(id, title)
+        } catch {
+            if (anterior !== undefined) {
+                setChatHistoryName({ id, title: anterior })
+            }
+            avisarFalha('Não foi possível renomear a conversa.')
+        }
+    }
+
+    return { remover, renomear }
+}
+
+/**
+ * Junta a lista do backend com o que já está na tela.
+ *
+ * - Conversa que já existe no store fica como está: pode ter mensagens
+ *   carregadas ou um stream em andamento.
+ * - Conversa criada nesta sessão e que o backend ainda não conhece não pode
+ *   sumir: ela aparece primeiro, como ao ser criada.
+ */
+function mesclar(
+    atual: ChatHistories,
+    resumos: GetConversationsResponse,
+): ChatHistories {
+    const noStore = new Map(atual.map((chat) => [chat.id, chat]))
+    const doBackend = new Set(resumos.map((resumo) => resumo.id))
+
+    const soNaTela = atual.filter((chat) => !doBackend.has(chat.id))
+    const daLista = resumos.map(
+        (resumo) => noStore.get(resumo.id) ?? resumoParaHistorico(resumo),
+    )
+    return [...soNaTela, ...daLista]
+}
+
+export default useChatConversations

package/lib/@ecme/views/concepts/ai/Chat/hooks/useChatSend.ts

@@ -3,6 +3,7 @@ import { resumeChat, streamChat } from '@/services/AiService'
 import { useAuth } from '@/auth'
 import dayjs from 'dayjs'
 import uniqueId from 'lodash/uniqueId'
+import { novoIdDeConversa } from '../utils'
 import type { ChatEvent, Conversation, ToolCall } from '../types'
 
 /** Resposta genérica exibida no chat quando a comunicação com a IA falha. */
@@ -203,14 +204,14 @@ const useChatSend = () => {
             creteMyMessage(selectedConversation, prompt)
             await sendMessage(selectedConversation, prompt)
         } else {
-            const newId = uniqueId('ai-chat-')
+            const newId = novoIdDeConversa()
             pushChatHistory({
                 id: newId,
                 title: prompt,
                 lastConversation: '',
                 createdTime: dayjs().unix(),
                 updatedTime: dayjs().unix(),
-                enable: false,
+                enable: true,
             })
             creteMyMessage(newId, prompt)
             await createConversation(newId, prompt)

package/lib/@ecme/views/concepts/ai/Chat/hooks/useConversationMessages.ts

@@ -0,0 +1,68 @@
+import { useEffect, useState } from 'react'
+import { apiGetChatHistory } from '@/services/AiService'
+import { usGenerativeChatStore } from '../store/generativeChatStore'
+import { mensagemDoHistorico } from '../utils'
+import type { Conversation, HistoryChat } from '../types'
+
+/**
+ * Busca as mensagens da conversa selecionada quando ela veio da lista do
+ * backend e ainda não foi aberta nesta sessão.
+ *
+ * Busca uma vez por conversa: depois disso `loaded` fica true e as mensagens
+ * novas chegam pelo streaming, como em qualquer conversa.
+ */
+const useConversationMessages = () => {
+    const { selectedConversation, chatHistory, setConversationMessages } =
+        usGenerativeChatStore()
+    const [carregando, setCarregando] = useState(false)
+
+    const pendente =
+        chatHistory.find((chat) => chat.id === selectedConversation)?.loaded ===
+        false
+
+    useEffect(() => {
+        if (!selectedConversation || !pendente) {
+            return
+        }
+
+        // Trocar de conversa no meio da busca não pode gravar a resposta
+        // atrasada na tela errada.
+        let cancelado = false
+        setCarregando(true)
+
+        // O usuário pode ter enviado algo enquanto a busca corria: o que já
+        // está na tela vem depois do histórico, e não some.
+        const gravar = (antigas: Conversation[]) => {
+            const naTela =
+                usGenerativeChatStore
+                    .getState()
+                    .chatHistory.find((chat) => chat.id === selectedConversation)
+                    ?.conversation ?? []
+            setConversationMessages(selectedConversation, [...antigas, ...naTela])
+        }
+
+        apiGetChatHistory<HistoryChat[]>(selectedConversation)
+            .then((resposta) => {
+                if (cancelado) return
+                gravar((resposta[0]?.conversation ?? []).map(mensagemDoHistorico))
+            })
+            .catch(() => {
+                // Marca como carregada mesmo assim: sem isto, cada render
+                // tentaria de novo. A conversa segue utilizável, porque a
+                // memória está no backend.
+                if (!cancelado) gravar([])
+            })
+            .finally(() => {
+                if (!cancelado) setCarregando(false)
+            })
+
+        return () => {
+            cancelado = true
+            setCarregando(false)
+        }
+    }, [selectedConversation, pendente, setConversationMessages])
+
+    return { carregando }
+}
+
+export default useConversationMessages

package/lib/@ecme/views/concepts/ai/Chat/store/generativeChatStore.ts

@@ -1,4 +1,5 @@
 import { create } from 'zustand'
+import { useSessionUser } from '@/store/authStore'
 import type { ChatHistories, ChatHistory, Conversation } from '../types'
 
 type RenameDialog = {
@@ -24,12 +25,16 @@ type GenerativeChatAction = {
     setIsTyping: (payload: boolean) => void
     pushChatHistory: (payload: ChatHistory) => void
     pushConversation: (id: string, conversation: Conversation) => void
+    /** Grava as mensagens buscadas no backend e marca a conversa como carregada. */
+    setConversationMessages: (id: string, conversation: Conversation[]) => void
     updateConversation: (
         chatId: string,
         messageId: string,
         patch: Partial<Conversation>,
     ) => void
     disabledChatFresh: (id: string) => void
+    /** Volta ao estado inicial. Chamado sozinho quando o usuário da sessão muda. */
+    reset: () => void
 }
 
 const initialState: GenerativeChatState = {
@@ -48,6 +53,14 @@ export const usGenerativeChatStore = create<
     GenerativeChatState & GenerativeChatAction
 >((set, get) => ({
     ...initialState,
+    // Arrays novos: `setSelectedConversationRecord` muta o array no lugar, e
+    // reusar o do initialState traria de volta o que ele acumulou.
+    reset: () =>
+        set(() => ({
+            ...initialState,
+            selectedConversationRecord: [],
+            chatHistory: [],
+        })),
     setSelectedConversation: (payload) =>
         set(() => ({ selectedConversation: payload })),
     setChatHistory: (payload) => set(() => ({ chatHistory: payload })),
@@ -74,8 +87,18 @@ export const usGenerativeChatStore = create<
 
             return { selectedConversationRecord: record }
         }),
+    // Conversa criada nesta sessão já nasce carregada: as mensagens estão aqui,
+    // não há o que buscar no backend.
     pushChatHistory: (payload) =>
-        set(() => ({ chatHistory: [payload, ...get().chatHistory] })),
+        set(() => ({
+            chatHistory: [{ loaded: true, ...payload }, ...get().chatHistory],
+        })),
+    setConversationMessages: (id, conversation) =>
+        set(() => ({
+            chatHistory: get().chatHistory.map((chat) =>
+                chat.id === id ? { ...chat, conversation, loaded: true } : chat,
+            ),
+        })),
     pushConversation: (id, conversation) =>
         set(() => ({
             chatHistory: get().chatHistory.map((chat) =>
@@ -131,3 +154,23 @@ export const usGenerativeChatStore = create<
             return { chatHistory }
         }),
 }))
+
+/**
+ * O chat pertence ao usuário da sessão: trocou o usuário, zera o chat.
+ *
+ * Login e logout acontecem sem recarregar a página, e este store é um singleton
+ * do módulo. Sem isto, o próximo usuário via as conversas do anterior.
+ *
+ * Olha o `signedIn` além do `userId` porque o logout faz `setUser({})`, e o
+ * `setUser` faz MERGE: o `userId` antigo continua lá depois de sair.
+ *
+ * É uma assinatura, e não um efeito de componente, para zerar ANTES do próximo
+ * render: a lista antiga nem chega a piscar na tela.
+ */
+useSessionUser.subscribe((atual, anterior) => {
+    const trocouUsuario = atual.user.userId !== anterior.user.userId
+    const saiu = anterior.session.signedIn && !atual.session.signedIn
+    if (trocouUsuario || saiu) {
+        usGenerativeChatStore.getState().reset()
+    }
+})

package/lib/@ecme/views/concepts/ai/Chat/types.ts

@@ -131,8 +131,36 @@ export type ChatHistory = {
     createdTime: number
     updatedTime: number
     enable: boolean
+    /**
+     * false quando a conversa veio da lista do backend e as mensagens ainda
+     * não foram buscadas. Conversas criadas nesta sessão já nascem carregadas.
+     */
+    loaded?: boolean
 }
 
 export type ChatHistories = ChatHistory[]
 
 export type GetChatHistoryResponse = ChatHistories
+
+/**
+ * Mensagem como o backend devolve no /ai/chat/history: o `timestamp` vem em
+ * segundos (epoch), e não como Date.
+ */
+export type HistoryMessage = Omit<Conversation, 'timestamp'> & {
+    timestamp: number
+}
+
+/** Uma conversa do /ai/chat/history, com as mensagens no formato do backend. */
+export type HistoryChat = Omit<ChatHistory, 'conversation'> & {
+    conversation: HistoryMessage[]
+}
+
+/** Resumo de uma conversa, como vem do GET /ai/chat/conversations. */
+export type ConversationSummary = {
+    id: string
+    title: string
+    createdTime: number
+    updatedTime: number
+}
+
+export type GetConversationsResponse = ConversationSummary[]

package/lib/@ecme/views/concepts/ai/Chat/utils.ts

@@ -1,3 +1,36 @@
+import dayjs from 'dayjs'
+import type {
+    ChatHistory,
+    Conversation,
+    ConversationSummary,
+    HistoryMessage,
+} from './types'
+
+/**
+ * Id de uma conversa nova.
+ *
+ * Precisa ser único entre recargas: o backend guarda a memória por este id.
+ * Um contador por página (como o `uniqueId` do lodash) recomeça no F5, e o
+ * "novo chat" herdaria a memória de uma conversa antiga.
+ */
+export const novoIdDeConversa = (): string => crypto.randomUUID()
+
+/** Conversa da lista do backend, ainda sem as mensagens. */
+export const resumoParaHistorico = (
+    resumo: ConversationSummary,
+): ChatHistory => ({
+    ...resumo,
+    lastConversation: '',
+    enable: true,
+    loaded: false,
+})
+
+/** Mensagem do /ai/chat/history no formato do chat (timestamp em Date). */
+export const mensagemDoHistorico = (mensagem: HistoryMessage): Conversation => ({
+    ...mensagem,
+    timestamp: dayjs.unix(mensagem.timestamp).toDate(),
+})
+
 export const getStringPosition = (
     string: string,
     subString: string,

package/lib/base/configs/endpoints.config/transportadora/contratoFrete.ts

@@ -17,6 +17,8 @@ const contratoFrete = {
     enviarSap: {endpoint: `${CONTRATO_FRETE_URL}/enviar-sap/`, method: 'get'},
     uploadArquivo: {endpoint: `${CONTRATO_FRETE_URL}/upload-arquivo`, method: 'post'},
     findDocumento: {endpoint: `${CONTRATO_FRETE_URL}/find/documento/`, method: 'get'},
+    updateStatusPedagio: {endpoint: `${CONTRATO_FRETE_URL}/update/status-pedagio`, method: 'put'},
+    pagamentoPedagio: {endpoint: `${CONTRATO_FRETE_URL}/pagamento-pedagio`, method: 'post'},
 }
 export default contratoFrete
 

package/lib/base/services/modules/transportadora/ContratoFrete/ContratoFreteService.ts

@@ -126,4 +126,18 @@ export async function apiFindDocumentoViagem(documento: string, tipo: string) {
         url: `${CONTRATO_FRETE_PROJECT_ENDPOINT.findDocumento.endpoint}${documento}/${tipo}`,
         method: CONTRATO_FRETE_PROJECT_ENDPOINT.findDocumento.method,
     })
+}
+
+export async function apiUpdateStatusPedagio(id: number, statusPedagio: string) {
+    return ApiService.fetchDataWithAxios<TContratoFrete>({
+        url: `${CONTRATO_FRETE_PROJECT_ENDPOINT.updateStatusPedagio.endpoint}/${id}/${statusPedagio}`,
+        method: CONTRATO_FRETE_PROJECT_ENDPOINT.updateStatusPedagio.method,
+    })
+}
+
+export async function apiPagamentoPedagio(id: number) {
+    return ApiService.fetchDataWithAxios<TContratoFrete>({
+        url: `${CONTRATO_FRETE_PROJECT_ENDPOINT.pagamentoPedagio.endpoint}/${id}`,
+        method: CONTRATO_FRETE_PROJECT_ENDPOINT.pagamentoPedagio.method,
+    }) 
 }

package/package.json

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