исправь и напиши правльный способ сортировки 
function sortTable(column, order) {
    const rows = $('#tableBody > tr').get();
    const originalNumbers = rows.map((row, index) => ({
        row: row,
        originalNumber: $(row).children('td').first().text()
    }));

    rows.sort(function(a, b) {
        let A = $(a).children('td').eq(column).text().trim();
        let B = $(b).children('td').eq(column).text().trim();

        if (A === '' && B === '') return 0;
        if (A === '') return order === 'asc' ? 1 : -1;
        if (B === '') return order === 'asc' ? -1 : 1;

        if (column === 1 || column === 6) {  // Если это столбцы с датой или временем
            A = new Date(A.replace(/(\d{2})\.(\d{2})\.(\d{4}) (\d{2}):(\d{2}):(\d{2})/, '\$3-\$2-\$1T\$4:\$5:\$6'));
            B = new Date(B.replace(/(\d{2})\.(\d{2})\.(\d{4}) (\d{2}):(\d{2}):(\d{2})/, '\$3-\$2-\$1T\$4:\$5:\$6'));
            return order === 'asc' ? A - B : B - A;
        }

        if (column === 0 || column === 2) {  // Для столбцов с числами (№ и Номер)
            A = parseFloat(A) || 0;  // Если не число, то 0
            B = parseFloat(B) || 0;
            return order === 'asc' ? A - B : B - A;
        }

        if (column === 5) {  // Если это столбец с именем workers
            A = A.toLowerCase();
            B = B.toLowerCase();
        }

        // Для остальных столбцов используем строковое сравнение
        A = A.toString().toUpperCase();
        B = B.toString().toUpperCase();
        return order === 'asc' ? A.localeCompare(B) : B.localeCompare(A);
    });

    $('#tableBody').empty();
    rows.forEach((row, index) => {
        const $row = $(row);
        const originalData = originalNumbers.find(item => item.row === row);
        $row.children('td').first().text(originalData.originalNumber);

        // Восстанавливаем функциональность кнопок
        const dlCell = $row.find('td:eq(4)');
        const packCell = $row.find('td:eq(6)'); // Столбец "Время упаковки"
        const dlValue = dlCell.text().trim();
        const packValue = packCell.text().trim();

        if (!dlValue.startsWith('DL')) {
            dlCell.html('<button class="generate-button">Генерировать</button>')
                .find('button')
                .click(function() {
                    generateDL(index);
                });
        }

        if (dlValue.startsWith('DL') && !packValue) {
            packCell.html('<button class="pack-button">Упаковать</button>')
                .find('button')
                .click(function() {
                    packItem(index);
                });
        }

        $('#tableBody').append($row);
    });

    checkDuplicates();
}
@app.route('/export_excel')
def export_excel():
    try:
        date = request.args.get('date')
        sort_column = request.args.get('sort_column')
        sort_order = request.args.get('sort_order')
        
        if not date:
            return jsonify({"error": "Date parameter is required"}), 400
        
        # Получаем все записи для выбранной даты
        query = TableRow.query.filter_by(date=date)
        
        # Применяем сортировку, если указана
        if sort_column and sort_order:
            column_mapping = {
                '0': TableRow.row_number,
                '1': TableRow.timestamp,
                '2': TableRow.number,
                '3': TableRow.serial,
                '4': TableRow.dl_number,
                '5': TableRow.worker_name,
                '6': TableRow.pack_time,  # Время упаковки
                '7': TableRow.arma_type,  # Тип АРМА
                '8': TableRow.last_graf
            }
            if sort_column in column_mapping:
                column = column_mapping[sort_column]
                if sort_order == 'desc':
                    query = query.order_by(column.desc())
                else:
                    query = query.order_by(column.asc())
            else:
                return jsonify({"error": "Invalid sort column"}), 400
        
        rows = query.all()
        
        # Создаем DataFrame
        data = []
        for row in rows:
            # Безопасное преобразование номера
            try:
                number = int(row.number) if row.number and row.number.strip() else None
            except ValueError:
                number = None
            
            data.append({
                '№': row.row_number,
                'Время отправки': row.timestamp,
                'Номер': number,
                'Serial': row.serial,
                'Графа': row.dl_number,
                'Имя отправителя': row.worker_name,
                'Время упаковки': row.pack_time,  # Время упаковки
                'Тип АРМА': row.arma_type,  # Тип АРМА
                'last_graf': row.last_graf
            })
        
        df = pd.DataFrame(data)
        
        # Создаем Excel файл
        output = BytesIO()
        with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
            df.to_excel(writer, index=False, sheet_name='Sheet1')
            
            # Настраиваем форматирование
            workbook = writer.book
            worksheet = writer.sheets['Sheet1']
            
            # Автоматическая ширина столбцов
            for idx, col in enumerate(df.columns):
                series = df[col]
                max_len = max(
                    series.astype(str).map(len).max(),
                    len(str(col))
                ) + 2
                worksheet.set_column(idx, idx, max_len)
                
                # Форматирование числовых столбцов
                if col in ['Номер', 'Графа']:
                    num_format = workbook.add_format({'num_format': '0'})
                    worksheet.set_column(idx, idx, max_len, num_format)
        
        output.seek(0)
        
        return send_file(
            output,
            mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
            as_attachment=True,
            download_name=f'export_{date}.xlsx'
        )
    
    except Exception as e:
        print(f"Export error: {str(e)}")
        return jsonify({"error": str(e)}), 500