controles/static/js/table_sort.js

// Função para converter data DD/MM/YYYY para objeto Date
function converterDataParaComparacao(dataStr) {
    console.log('Convertendo data para comparação:', dataStr);
    
    if (!dataStr) return null;
    
    try {
        // Se já estiver no formato ISO
        if (/^\d{4}-\d{2}-\d{2}/.test(dataStr)) {
            const data = new Date(dataStr);
            console.log('Data ISO convertida:', data);
            return data;
        }
        
        // Se estiver no formato DD/MM/YYYY
        if (/^\d{2}\/\d{2}\/\d{4}/.test(dataStr)) {
            const [dia, mes, ano] = dataStr.split('/').map(Number);
            const data = new Date(ano, mes - 1, dia);
            console.log('Data DD/MM/YYYY convertida:', data);
            return data;
        }
        
        console.warn('Formato de data não reconhecido:', dataStr);
        return null;
    } catch (error) {
        console.error('Erro ao converter data:', error, 'Data:', dataStr);
        return null;
    }
}

// Função para ordenar tabelas
function configurarOrdenacaoTabela(tabelaId) {
    console.log('Configurando ordenação para tabela:', tabelaId);
    
    const table = document.getElementById(tabelaId);
    if (!table) {
        console.warn('Tabela não encontrada:', tabelaId);
        return;
    }
    
    const headers = table.querySelectorAll('th[data-sort]');
    headers.forEach(header => {
        if (header.dataset.sort) {
            header.addEventListener('click', () => {
                const column = header.dataset.sort;
                const tbody = table.getElementsByTagName('tbody')[0];
                const rows = Array.from(tbody.getElementsByTagName('tr'));
                
                console.log('Ordenando coluna:', column);
                
                rows.sort((a, b) => {
                    const aValue = a.querySelector(`td[data-${column}]`).dataset[column];
                    const bValue = b.querySelector(`td[data-${column}]`).dataset[column];
                    
                    // Ordenação por data
                    if (column === 'data' || 
                        column === 'data_vencimento' || 
                        column === 'data_alteracao' ||
                        column === 'data_pagamento' ||
                        column === 'data_venda' ||
                        column === 'data_relatorio') {
                        const aDate = converterDataParaComparacao(aValue);
                        const bDate = converterDataParaComparacao(bValue);
                        
                        // Se alguma data for inválida
                        if (!aDate && !bDate) return 0;
                        if (!aDate) return 1;
                        if (!bDate) return -1;
                        
                        return aDate - bDate;
                    }
                    
                    // Ordenação por valor monetário
                    if (column === 'valor' || 
                        column === 'valor_total' || 
                        column === 'valor_antigo' || 
                        column === 'valor_novo') {
                        const aNum = parseFloat(aValue.replace(/[^\d,-]/g, '').replace(',', '.'));
                        const bNum = parseFloat(bValue.replace(/[^\d,-]/g, '').replace(',', '.'));
                        return aNum - bNum;
                    }
                    
                    // Ordenação padrão para texto
                    return aValue.localeCompare(bValue);
                });
                
                // Alternar direção da ordenação
                if (header.classList.contains('asc')) {
                    rows.reverse();
                    header.classList.remove('asc');
                    header.classList.add('desc');
                    console.log('Ordenação descendente');
                } else {
                    header.classList.remove('desc');
                    header.classList.add('asc');
                    console.log('Ordenação ascendente');
                }
                
                // Atualizar tabela
                tbody.innerHTML = '';
                rows.forEach(row => tbody.appendChild(row));
            });
        }
    });
}

// Configurar ordenação para todas as tabelas que precisam
document.addEventListener('DOMContentLoaded', function() {
    console.log('Configurando ordenação para todas as tabelas...');
    
    const tabelas = [
        'materiaisTable',
        'vendasTable',
        'cotasTable',
        'pagamentosTable'
    ];
    
    tabelas.forEach(tabelaId => {
        configurarOrdenacaoTabela(tabelaId);
    });
});

document.addEventListener('DOMContentLoaded', function() {
    console.log('Carregando script table_sort.js...');
    
    // Função para comparar datas no formato DD/MM/YYYY
    function compararDatas(a, b) {
        if (!a || !b) return 0;
        
        const [diaA, mesA, anoA] = a.split('/').map(Number);
        const [diaB, mesB, anoB] = b.split('/').map(Number);
        
        const dataA = new Date(anoA, mesA - 1, diaA);
        const dataB = new Date(anoB, mesB - 1, diaB);
        
        return dataA - dataB;
    }
    
    // Função para comparar valores monetários
    function compararValores(a, b) {
        const valorA = parseFloat(a.replace('R$ ', '').replace('.', '').replace(',', '.'));
        const valorB = parseFloat(b.replace('R$ ', '').replace('.', '').replace(',', '.'));
        
        if (isNaN(valorA)) return -1;
        if (isNaN(valorB)) return 1;
        
        return valorA - valorB;
    }
    
    // Configurar ordenação para todas as tabelas com classe 'table-sort'
    document.querySelectorAll('table.table-sort').forEach(tabela => {
        const tbody = tabela.querySelector('tbody');
        const headers = tabela.querySelectorAll('th[data-sort]');
        
        headers.forEach(header => {
            const tipoOrdenacao = header.dataset.sort;
            
            header.addEventListener('click', () => {
                const rows = Array.from(tbody.querySelectorAll('tr'));
                const colIndex = Array.from(header.parentNode.children).indexOf(header);
                
                rows.sort((rowA, rowB) => {
                    const cellA = rowA.children[colIndex].dataset[tipoOrdenacao] || rowA.children[colIndex].textContent.trim();
                    const cellB = rowB.children[colIndex].dataset[tipoOrdenacao] || rowB.children[colIndex].textContent.trim();
                    
                    switch (tipoOrdenacao) {
                        case 'data':
                            return compararDatas(cellA, cellB);
                        case 'valor':
                            return compararValores(cellA, cellB);
                        case 'numero':
                            return parseFloat(cellA) - parseFloat(cellB);
                        default:
                            return cellA.localeCompare(cellB);
                    }
                });
                
                if (header.classList.contains('asc')) {
                    rows.reverse();
                    header.classList.remove('asc');
                    header.classList.add('desc');
                } else {
                    header.classList.remove('desc');
                    header.classList.add('asc');
                }
                
                // Remover classes de ordenação de outros headers
                headers.forEach(h => {
                    if (h !== header) {
                        h.classList.remove('asc', 'desc');
                    }
                });
                
                // Atualizar tabela
                tbody.innerHTML = '';
                rows.forEach(row => tbody.appendChild(row));
            });
        });
    });
});