adicionadas novas funcionalidades, agora o app mostra se tem um atendimento em progresso, antes de iniciar o chamado de outro cliente

alteração da rota para o pusher e portas de comunicação
adicionados novas funcionalidades para filtro de chamados, e busca a se há algum na fila na inicialização
2025-12-15 00:35:11 -03:00 · 2025-12-14 23:53:04 -03:00 · 2025-11-10 01:20:11 -03:00 · 2025-07-12 12:26:16 -03:00 · 2025-07-09 21:03:42 -03:00 · 2025-07-04 22:03:11 -03:00
9 changed files with 460 additions and 202 deletions
--- a/floating.js
+++ b/floating.js
@ -3,6 +3,11 @@ const countSpan = document.getElementById('count');

 // Atualiza a contagem e a cor do botão quando recebe do main process
 window.electronAPI.onUpdateCount((value) => {
+    // Se estiver em atendimento, ignora qualquer atualização de contagem
+    if (floatButton.classList.contains('em-atendimento')) {
+        return;
+    }
+
    countSpan.innerHTML = value ?? 0;
    // Verifica a contagem para mudar a cor
    if (value > 0) {
@ -12,10 +17,50 @@ window.electronAPI.onUpdateCount((value) => {
    }
 });

+// Altera a cor do botão com base no status do atendimento
+window.electronAPI.onAtendimentoStatusChanged((status) => {
+    if (status === 'iniciado') {
+        const nomeAtendimento = localStorage.getItem('atendimentoAtualNome');
+        floatButton.classList.remove('has-items');
+        floatButton.classList.add('em-atendimento');
+        countSpan.innerHTML = '-'; // Mostra o hífen
+        if (nomeAtendimento) {
+            floatButton.setAttribute('title', `Atendendo: ${nomeAtendimento}`);
+        }
+    } else { // 'finalizado'
+        floatButton.classList.remove('em-atendimento');
+        floatButton.setAttribute('title', 'Chamar próximo da fila');
+        // Solicita uma atualização imediata da contagem para refletir o estado atual da fila
+        window.electronAPI.refreshCount();
+    }
+});
+
+// Ao carregar, verifica se já existe um atendimento em andamento
+document.addEventListener('DOMContentLoaded', () => {
+    const atendimentoAtual = localStorage.getItem('atendimentoAtual');
+    if (atendimentoAtual) {
+        const nomeAtendimento = localStorage.getItem('atendimentoAtualNome');
+        floatButton.classList.remove('has-items');
+        floatButton.classList.add('em-atendimento');
+        countSpan.innerHTML = '-'; // Mostra o hífen
+        if (nomeAtendimento) {
+            floatButton.setAttribute('title', `Atendendo: ${nomeAtendimento}`);
+        }
+    } else {
+        floatButton.setAttribute('title', 'Chamar próximo da fila');
+    }
+});
+
 // Mostra a janela principal ao clicar
 floatButton.addEventListener('click', () => {
    window.electronAPI.showMainWindow();
 });

+// Adiciona um listener para o evento de clique com o botão direito
+floatButton.addEventListener('contextmenu', (e) => {
+    e.preventDefault(); // Impede o menu padrão do navegador
+    window.electronAPI.showMenu(); // Chama a função para mostrar o menu no processo principal
+});
+
 // Ajuste inicial do cursor
 floatButton.style.cursor = 'pointer';
--- a/floating_preload.js
+++ b/floating_preload.js
@ -2,7 +2,8 @@ const { contextBridge, ipcRenderer } = require('electron');

 contextBridge.exposeInMainWorld('electronAPI', {
    onUpdateCount: (callback) => ipcRenderer.on('update-count', (_event, value) => callback(value)),
-    showMainWindow: () => ipcRenderer.send('chamar-fila')
-    // Remova a linha abaixo:
-    // startDrag: (offset) => ipcRenderer.send('drag-float-window', offset)
+    onAtendimentoStatusChanged: (callback) => ipcRenderer.on('atendimento-status-changed', (_event, status) => callback(status)),
+    refreshCount: () => ipcRenderer.send('refresh-count'),
+    showMainWindow: () => ipcRenderer.send('chamar-fila'),
+    showMenu: () => ipcRenderer.send('show-context-menu')
 });
--- a/index.html
+++ b/index.html
@ -1,17 +1,19 @@
 <!DOCTYPE html>
 <html>
+
 <head>
    <meta charset="UTF-8">
    <meta http-equiv="Content-Security-Policy" content="
        default-src 'self'; 
        script-src 'self' 'unsafe-inline'; 
        style-src 'self' 'unsafe-inline'; 
-        connect-src 'self' ws://autoatend.linco.work:6001 ws://localhost:6001;
+        connect-src 'self' ws://autoatend.linco.work:6001 ws://localhost:6001 wss://aa.linco.work:443;
    ">
    <title>Tela de Atendimento</title>
    <link rel="stylesheet" href="style.css">
    <script src="res/js/jquery/jquery.js"></script>
 </head>
+
 <body>
    <div id="list-view">
        <h1>Fila</h1>
@ -47,4 +49,5 @@
    <script src="renderer.js"></script>

 </body>
+
 </html>
--- a/main.js
+++ b/main.js
@ -1,4 +1,5 @@
-const { app, BrowserWindow, ipcMain, screen, net, dialog } = require('electron');
+const { app, BrowserWindow, ipcMain, screen, net, dialog, Menu } = require('electron');
+// const { app: singleInstanceLock } = require('electron-single-instance');
 const path = require('path');
 const fs = require('fs');

@ -15,13 +16,15 @@ const dataPath = path.join(__dirname, 'data.json'); // Caminho para o JSON (back
 const apiUrl = 'https://autoatend.linco.work/api/v1/';
 // const apiUrl = 'http://_lara10-autoatend.devel/api/v1/';

-const pusherUrl = 'autoatend.linco.work';
+const pusherUrl = 'aa.linco.work';
 // const pusherUrl = 'localhost';


 autoUpdater.autoDownload = false;
 autoUpdater.autoInstallOnAppQuit = true;

+//impede que o app seja executado mais de uma vez
+const gotTheLock = app.requestSingleInstanceLock();

 // Função modificada para buscar dados da API
 async function readData() {
@ -47,10 +50,10 @@ async function readData() {
 async function fetchDataFromAPI() {
    //executa uma vez e a cada 30 segundos

-    //TODO propicio para fazer um websockt nessas funções que repetem a chamada  de requisições em busca de alterações
-
-    getDataAndUpdateFloatingBtn();
+    //!primeira requisição é feita para API
+    getFirstData();

+    //! as outras é o websockt que solicita a chamada  de requisições em busca de alterações
    const updData = setInterval(() => {
        getDataAndUpdateFloatingBtn();
    }, 3000);
@ -62,10 +65,61 @@ async function fetchDataFromAPI() {
    }, 300000);
 }

+async function getFirstData() {
+
+    const token = await getAuthToken();
+    const colabId = await floatingWin.webContents.executeJavaScript("localStorage.getItem('idOperator')")
+    const url = apiUrl + 'get-proximos/' + colabId;
+
+    //!  checa se o token e o colabId existem
+    if (!token && !colabId) { console.warn("Token or colabId not found in localStorage. API requests will not be made."); return; }
+
+    //!  faz o request
+    const request = net.request({
+        method: 'GET',
+        url: url,
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': 'Bearer ' + token
+        }
+    });
+
+    //! busca pela resposta
+    request.on('response', (response) => {
+        let rawData = '';
+        response.on('data', (chunk) => { rawData += chunk; });
+        response.on('end', () => {
+            try {
+                const parsedData = JSON.parse(rawData);
+                let proximos = parsedData;
+                if (response.statusCode === 200) {
+                    floatingWin.webContents.executeJavaScript("localStorage.setItem('proximos','" + JSON.stringify(proximos) + "')");
+                    let count = proximos.length;
+                    floatingWin.webContents.send('update-count', count);
+                } else {
+                    console.error(`Erro na requisição: Status code ${response.statusCode}`, parsedData);
+                }
+            } catch (error) {
+                console.error("Erro ao analisar a resposta JSON:", error);
+                mainWin.webContents.send('api-error', {
+                    message: `Erro ao processar resposta do servidor.`
+                });
+            }
+        });
+    });
+    request.on('error', (error) => {
+        console.error("Erro na requisição:", error);
+    });
+
+    request.end();
+
+    return JSON.parse(await floatingWin.webContents.executeJavaScript("localStorage.getItem('proximos')"));
+}
+
 // Função para coletar a lista de atendimentos do servidor, vai ser chamada uma vez e a cada 30s
 async function getDataAndUpdateFloatingBtn() {

-    const proximos = JSON.parse(await floatingWin.webContents.executeJavaScript("localStorage.getItem('proximos')"));
+    const proximos = JSON.parse(await floatingWin.webContents.executeJavaScript("localStorage.getItem('proximos')")) ?? [];
    let count = proximos.length;

    //lista a contagem no botão flutuante
@ -275,6 +329,17 @@ if(pjson.isBuildNow){
 }


+if (!gotTheLock) {
+    app.quit();
+} else {
+    app.on('second-instance', () => {
+        if (mainWin) {
+            if (mainWin.isMinimized()) {
+                mainWin.restore();
+            }
+            mainWin.focus();
+        }
+    });

    // Inicialização do aplicativo modificada para verificar autenticação
    app.whenReady().then(async () => {
@ -318,6 +383,10 @@ app.whenReady().then(async () => {

    });

+}
+
+
+
 // Função para verificar se já existe um operador selecionado
 async function getSelectedOperator() {
    return new Promise((resolve) => {
@ -393,13 +462,10 @@ ipcMain.handle('get-count', async () => {
 // Ouvir pedido para mostrar a janela principal
 ipcMain.on('chamar-fila', async () => {

-    const countFila = async () => {
-        const proximos = JSON.parse(await floatingWin.webContents.executeJavaScript("localStorage.getItem('proximos')"));
-        return proximos.length;
-    }
-
-    const requestData = async () =>{
+    // Primeiro, verifica se já existe um atendimento em andamento
+    const atendimentoAtualId = await floatingWin.webContents.executeJavaScript("localStorage.getItem('atendimentoAtual')");

+    const showMainWindow = () => {
        if (mainWin) {
            if (!mainWin.isVisible()) {
                mainWin.show();
@ -414,6 +480,24 @@ ipcMain.on('chamar-fila', async () => {
                mainWin.focus();
            });
        }
+    }
+
+    // Se um atendimento já estiver em andamento, apenas mostra a janela principal.
+    // A lógica em renderer.js cuidará de exibir a tela de observação.
+    if (atendimentoAtualId) {
+        showMainWindow();
+        return; // Interrompe a execução aqui
+    }
+
+    // Se não houver atendimento em andamento, continua com a lógica original.
+    const countFila = async () => {
+        const proximos = JSON.parse(await floatingWin.webContents.executeJavaScript("localStorage.getItem('proximos')")) ?? [];
+        return proximos.length;
+    }
+
+    const requestData = async () => {
+
+


        const colabId = await getSelectedOperatorId();
@ -439,14 +523,14 @@ ipcMain.on('chamar-fila', async () => {
            response.on('end', () => {
                try {
                    const parsedData = JSON.parse(rawData);
-
                    if (response.statusCode === 200) {
                        mainWin.webContents.send('select-atend-id', parsedData.data);
-                        if(parsedData.data.Status === 'Atendendo'){
+                        if (parsedData.data && (parsedData.data.Status === 'Fila' || parsedData.data.Status === 'Chamado')) { showMainWindow(); } else
+                            if (parsedData.data && parsedData.data.Status === 'Atendendo') {
                                let options2 = {
                                    'title': 'Precisa finalizar antes de chamar o próximo.',
                                    'message': 'Em andamento',
-                                'detail': 'Já possui um atendimento em andamento (Chamado/Atendendo), continue e finalize por favor!',
+                                    'detail': 'Já possui um atendimento em andamento (Atendendo: ' + parsedData.data.clientName + '), continue e finalize por favor!',
                                    'type': 'error',
                                    'noLink': true,
                                    'buttons': ['Depois', 'Continuar'],
@ -454,6 +538,9 @@ ipcMain.on('chamar-fila', async () => {
                                dialog.showMessageBox(floatingWin, options2).then(result => {
                                    if (result.response) {
                                        mainWin.webContents.send('show-observation');
+                                        showMainWindow();
+                                    } else {
+                                        mainWin.hide();
                                    };
                                });
                            }
@ -495,20 +582,26 @@ ipcMain.on('chamar-fila', async () => {
    };


-    if(await countFila() > 0){
+    if (await countFila()) {
        dialog.showMessageBox(floatingWin, options).then(result => {
            if (result.response) {
                requestData();
            };
        });
-    }
-    
-    else {
+    } else {
        requestData();
    }

 });

+// Ouve um pedido da janela flutuante para forçar a atualização da contagem
+ipcMain.on('refresh-count', async () => {
+    if (floatingWin) {
+        const proximos = JSON.parse(await floatingWin.webContents.executeJavaScript("localStorage.getItem('proximos')")) ?? [];
+        floatingWin.webContents.send('update-count', proximos.length);
+    }
+});
+
 ipcMain.on('select-atend-id', (itemId) => {
    selectedItemId = itemId;
    console.log(selectedItemId);
@ -521,9 +614,9 @@ ipcMain.on('iniciar-atendimento', async (event, itemId) => {
    const colabId = await floatingWin.webContents.executeJavaScript("localStorage.getItem('idOperator')")
    //TODO inicia o atendimento o id do atendimento deve ser requisitado do backend

-    const url = apiUrl + 'iniciar-atendimento/'+itemId; // URL de exemplo para enviar a solicitação
+    const url = apiUrl + 'iniciar-atendimento/' + itemId; // URL para enviar a solicitação

-    // Simula o envio de uma solicitação POST com o ID do item
+    // envio de uma solicitação POST com o ID do item
    const request = net.request({
        method: 'GET',
        url: url,
@ -558,6 +651,20 @@ ipcMain.on('iniciar-atendimento', async (event, itemId) => {
    // A janela principal já mudou a UI ao enviar o evento 'next-step'
 });

+// Ouve quando um atendimento é iniciado e notifica a janela flutuante
+ipcMain.on('atendimento-iniciado', (event, itemId) => {
+    if (floatingWin) {
+        floatingWin.webContents.send('atendimento-status-changed', 'iniciado');
+    }
+});
+
+// Ouve quando um atendimento é finalizado e notifica a janela flutuante
+ipcMain.on('atendimento-finalizado', () => {
+    if (floatingWin) {
+        floatingWin.webContents.send('atendimento-status-changed', 'finalizado');
+    }
+});
+
 // Ouvir clique no botão "Salvar"
 ipcMain.on('save-observation', async (event, { itemId, observation }) => {

@ -854,12 +961,65 @@ ipcMain.on('token-exists', async () => {


 ipcMain.on('sair', () => {
-    operatorWin.webContents.executeJavaScript(`
+    let exec = `
            localStorage.removeItem("idOperator");
            localStorage.removeItem("selectedOperator");
            localStorage.removeItem("salaOperator");
            localStorage.removeItem("servicosOperator");
-    `).then(() => {
-        app.exit();
+        `;
+
+    let options = {
+        'title': 'Deseja realmente sair?',
+        'message': 'Tem certeza que deseja fechar o Auto Atendimento?',
+        'type': 'question',
+        'buttons': ['Não', 'Sim'],
+        'defaultId': 0,
+        'cancelId': 0,
+    };
+
+    dialog.showMessageBox(floatingWin, options).then(result => {
+        if (result.response === 1) { // Se o usuário clicou em "Sim" (índice 1)
+            if (floatingWin) {
+                floatingWin.webContents.executeJavaScript(exec).then(() => { app.exit(); });
+            } else if (operatorWin) {
+                operatorWin.webContents.executeJavaScript(exec).then(() => { app.exit(); });
+            }
+        }
    });
+
+});
+
+
+ipcMain.on('show-context-menu', (event) => {
+    const template = [
+        {
+            label: 'Chamar Fila',
+            click: () => {
+                // Lógica para chamar atendimento
+                if (floatingWin) {
+                    ipcMain.emit('chamar-fila');
+                }
+            }
+        },
+        {
+            label: 'Trocar Colab',
+            click: () => {
+                // Lógica para chamar atendimento
+                if (floatingWin) {
+                    ipcMain.emit('logout');
+                }
+            }
+        },
+        {
+            label: 'Sair',
+            click: () => {
+                // Lógica para fechar o aplicativo
+                if (floatingWin) {
+                    ipcMain.emit('sair');
+                }
+            }
+        }
+    ];
+    const menu = Menu.buildFromTemplate(template);
+    menu.popup({ window: floatingWin });
 });
--- a/package-lock.json
+++ b/package-lock.json
@ -1,15 +1,16 @@
 {
-  "name": "electronjs",
-  "version": "1.0.0",
+  "name": "autoatendcolab",
+  "version": "1.0.7",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
-      "name": "electronjs",
-      "version": "1.0.0",
+      "name": "autoatendcolab",
+      "version": "1.0.7",
      "license": "ISC",
      "dependencies": {
        "@electron/remote": "^2.1.2",
+        "electron-single-instance": "^0.0.2",
        "electron-updater": "^6.6.2",
        "jquery": "^3.7.1"
      },
@ -2609,6 +2610,12 @@
        "chokidar": "^3.5.2"
      }
    },
+    "node_modules/electron-single-instance": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/electron-single-instance/-/electron-single-instance-0.0.2.tgz",
+      "integrity": "sha512-HWZ0BsGpFRuUU+8Cpf0ecDHYOqptuUyjup62sYnkl19//DtysiTZzeIWO9YXdbow3JErti/Zyi2yHO2e0yn1ew==",
+      "license": "MIT"
+    },
    "node_modules/electron-updater": {
      "version": "6.6.2",
      "resolved": "https://registry.npmjs.org/electron-updater/-/electron-updater-6.6.2.tgz",
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "autoatendcolab",
-  "version": "1.0.7",
+  "version": "1.1.3",
  "main": "main.js",
  "isBuildNow": true,
  "scripts": {
@ -38,6 +38,7 @@
  "description": "Sistema auxiliar para colaboradores de autoatendimento",
  "dependencies": {
    "@electron/remote": "^2.1.2",
+    "electron-single-instance": "^0.0.2",
    "electron-updater": "^6.6.2",
    "jquery": "^3.7.1"
  },
--- a/preload.js
+++ b/preload.js
@ -14,6 +14,10 @@ contextBridge.exposeInMainWorld('electronAPI', {
    //inicia o atendimento atual
    iniciaAtendimento: (itemId) => ipcRenderer.send('iniciar-atendimento', itemId),

+    //notifica sobre o status do atendimento
+    atendimentoIniciado: (itemId) => ipcRenderer.send('atendimento-iniciado', itemId),
+    atendimentoFinalizado: () => ipcRenderer.send('atendimento-finalizado'),
+
    showObservation: (callback) => ipcRenderer.on('show-observation', (_event) => callback() ),
    //salva a observação do atendimento
    saveObservation: (data) => ipcRenderer.send('save-observation', data),
--- a/renderer.js
+++ b/renderer.js
@ -38,24 +38,32 @@ async function initializePusher() {
    const channelLocal = localStorage.getItem('channel');
    const colabId = localStorage.getItem('idOperator');

-    if (channelLocal && PUSHER_APP_KEY) {
+    //! checa se ja tem o colabId
+    if (channelLocal && colabId && PUSHER_APP_KEY) {
        Pusher.logToConsole = true;

        var pusher = new Pusher(PUSHER_APP_KEY, {
            wsHost: host,
-            wsPort: 6001,
-            wssPort: 6001,
-            forceTLS: false,
+            wsPort: 80,
+            wssPort: 443,
+            forceTLS: true,
            enableStats: false,
-            enabledTransports: ['ws','wss'],
+            enabledTransports: ['wss', 'ws'],
            cluster: 'mt1'
        });

-        var channel = pusher.subscribe('chat.' + channelLocal + '_' + colabId);
+        let channel;
+        if (pusher.connection.state === 'connected') {
+            pusher.unsubscribe('chat.' + channelLocal + '_' + colabId);
+        }
+
+        channel = pusher.subscribe('chat.' + channelLocal + '_' + colabId);
+
        channel.bind('message-sent', function (r) {
-            let count = r.data.fila.original.length;
-                console.log(r.data.fila.original);
-                localStorage.setItem('proximos',JSON.stringify(r.data.fila.original));
+            let data = r.data.fila.original;
+            let count = data.length;
+            console.log(data);
+            localStorage.setItem('proximos', JSON.stringify(data));

            populateList(r.data.currentData.original);

@ -73,21 +81,21 @@ async function initializePusher() {

 initializePusher();

-
 //chama o proximo da fila ao abrir a janela de atendimentos
 window.electronAPI.selectAtendID((data) => {
    nextButton.disabled = true;
    if (!data) {
        queueNumber.innerHTML = 'Ninguem aguardando atendimento, fechando a janela em alguns segundos...';
-        setTimeout(() => {
-            window.close();
-        },5000);
        return;
    }
    // Reseta a view para a lista sempre que os dados são carregados ao clicar no botão para abrir a janela
    populateList(data);
    showListView();
+
+    // Garante que o item selecionado (ID e Nome) seja o que veio da chamada, sobrescrevendo o da lista.
    selectedItemId = data.id ?? null;
+    selectedItemName = data.clientName ?? '';
+
    //data.senhaGen
    queueNumber.innerHTML = data ? `NA VEZ: <u>${data.clientName.toUpperCase()}</u>  -  ${data.descricaoServico.toUpperCase()}` : 'Ninguem aguardando atendimento';
    selectedItemNameSpan.innerHTML = data ? `<u> ${data.clientName.toUpperCase()} </u> <i style="float:right;">[ ${data.senhaGen} ]</i>` : 'Ninguem aguardando atendimento';
@ -100,23 +108,21 @@ window.electronAPI.showObservation(()=>{

 // Função para popular a lista de itens
 function populateList(currentData) {
+    const atendimentoEmAndamentoId = localStorage.getItem('atendimentoAtual');
+    const atendimentoEmAndamentoNome = localStorage.getItem('atendimentoAtualNome');
+
+    if (atendimentoEmAndamentoId) {
+        itemList.innerHTML = `<li>Atendimento com <strong>${(atendimentoEmAndamentoNome || '').toUpperCase()}</strong> em andamento.</li>`;
+        queueNumber.innerHTML = `EM ATENDIMENTO: <u>${(atendimentoEmAndamentoNome || '').toUpperCase()}</u>`;
+        nextButton.disabled = true;
+        return;
+    }
+
    let datastorage = localStorage.getItem('proximos');

    // Adiciona os outros itens apenas para visualização (opcional)
    const proximos = JSON.parse(datastorage);
-    // var count = 6;
-    
-    // itemList.innerHTML = ''; // Limpa a lista anterior
-
-    // const dec_counter = setInterval(() => {
-    //     --count;
-    //     counterStart.innerHTML = `[ ${count} ]`;
-    //     if (count <= 0) {
-    //         counterStart.innerHTML = '';
-    //         nextButton.disabled = !currentData;
-    //         clearInterval(dec_counter);
-    //     }
-    // },1000);
+    itemList.innerHTML = '';

    setTimeout(() => {
        nextButton.disabled = !currentData;
@ -150,6 +156,19 @@ function populateList(currentData) {
 }


+// Verifica o estado ao carregar a janela
+document.addEventListener('DOMContentLoaded', () => {
+    const atendimentoEmAndamentoId = localStorage.getItem('atendimentoAtual');
+    if (atendimentoEmAndamentoId) {
+        // Se um atendimento está em andamento, a tela de observação deve ser mostrada
+        selectedItemId = atendimentoEmAndamentoId;
+        selectedItemName = localStorage.getItem('atendimentoAtualNome');
+        selectedItemNameSpan.innerHTML = `<u> ${(selectedItemName || '').toUpperCase()} </u>`;
+        showObservationView();
+    }
+});
+
+
 //mostra a tela de listagem e permite iniciar o atendimento
 function showListView() {
    listView.style.display = 'block';
@ -171,6 +190,12 @@ function showObservationView() {
 // // Evento do botão "Iniciar atendimento"
 nextButton.addEventListener('click', () => {
    if (selectedItemId !== null) {
+        // Salva o estado de atendimento no localStorage
+        localStorage.setItem('atendimentoAtual', selectedItemId);
+        localStorage.setItem('atendimentoAtualNome', selectedItemName);
+
+        // Notifica o main process e muda a view
+        window.electronAPI.atendimentoIniciado(selectedItemId);
        window.electronAPI.iniciaAtendimento(selectedItemId);
        showObservationView(); // Muda para a tela de observação
    } else {
@ -189,6 +214,11 @@ logoutButton.addEventListener('click',()=>{
 saveButton.addEventListener('click', () => {
    const observation = observationText.value;
    if (selectedItemId !== null) {
+        // Limpa o estado de atendimento
+        localStorage.removeItem('atendimentoAtual');
+        localStorage.removeItem('atendimentoAtualNome');
+        window.electronAPI.atendimentoFinalizado();
+
        window.electronAPI.saveObservation({ itemId: selectedItemId, observation: observation });
        window.location.reload();
    }
--- a/style.css
+++ b/style.css
@ -78,6 +78,13 @@ body#floating{
    animation: pulse-border .5s infinite;
 }

+/* Nova classe para quando estiver em atendimento */
+#float-button.em-atendimento {
+    background-color: var(--danger-color); /* Vermelho */
+    border: 4px solid var(--dark-danger-color);
+    animation: pulse-border .2s infinite; /* Pulso mais rápido */
+}
+
@keyframes pulse-border {
    0% {
        border-color: var(--medium-gold);
Author	SHA1	Message	Date
Eder Moraes	1598ccd22f	adicionadas novas funcionalidades, agora o app mostra se tem um atendimento em progresso, antes de iniciar o chamado de outro cliente	2025-12-15 00:35:11 -03:00
Eder Moraes	8280bb2ff6	alteração da rota para o pusher e portas de comunicação	2025-12-14 23:53:04 -03:00
Eder Moraes	97b4d2c90e	adicionados novas funcionalidades para filtro de chamados, e busca a se há algum na fila na inicialização	2025-11-10 01:20:11 -03:00
Eder Moraes	54cfba5cc4	adicionado menu de contexto com opções para chamar fila, trocar de colab e sair do app	2025-07-12 12:26:16 -03:00
Eder Moraes	4906da2bf0	alterações no comportamento do inicio do atendimento, janela carregada somente depois das opções selecionadas.	2025-07-09 21:03:42 -03:00
Eder Moraes	75d795bd92	correções para o modulo colabs, estava bugando a fila de atendimento	2025-07-04 22:03:11 -03:00
Eder Moraes	97fa71f231	evita abertura de multiplas instancias	2025-06-20 11:08:13 -03:00