Добавлено (2025-10-07, 13:24)
---------------------------------------------
Отлично! Проблема в том, что функция `loadWellData` пытается обработать отдельный INU файл как ZIP архив. Нужно добавить проверку типа файла и разную логику обработки для ZIP и INU файлов.

Вот исправления:

## 1. Обновить функцию `loadWellData`:

```javascript
async function loadWellData(file, fileNumber) {
// Запускаем keep-alive при начале загрузки
startKeepAlive();

showLoading('Анализ файла...');
const wellDataElement = document.getElementById('wellData');
wellDataElement.innerHTML = '<div class="loading"><p>Загрузка данных...</p></div>';

try {
console.log('Начало загрузки файла:', file.name);
updateLoadingText('Чтение файла...');
updateProgress(5, 'Подготовка...');

const fileObj = await file.handle.getFile();
console.log('Размер файла:', fileObj.size, 'байт');
console.log('Тип файла:', fileObj.type);
console.log('Имя файла:', fileObj.name);

// ОПРЕДЕЛЯЕМ ТИП ФАЙЛА
const isZipFile = fileObj.name.toLowerCase().endsWith('.zip');
const isInuFile = fileObj.name.toLowerCase().endsWith('.inu');

console.log('isZipFile:', isZipFile, 'isInuFile:', isInuFile);

if (isZipFile) {
// СУЩЕСТВУЮЩАЯ ЛОГИКА ДЛЯ ZIP АРХИВОВ
if (fileObj.size > 1500 * 1024 * 1024) {
throw new Error('Файл слишком большой для обработки в браузере (максимум 1500 МБ)');
}

updateLoadingText('Распаковка архива...');
updateProgress(15, 'Распаковка архива...');

const arrayBuffer = await Promise.race([
fileObj.arrayBuffer(),
new Promise((_, reject) =>
setTimeout(() => reject(new Error('Таймаут чтения файла')), 30000)
)
]);

console.log('ArrayBuffer прочитан, размер:', arrayBuffer.byteLength);

updateLoadingText('Обработка данных...');
updateProgress(25, 'Обработка ZIP...');

const zip = await Promise.race([
JSZip.loadAsync(arrayBuffer),
new Promise((_, reject) =>
setTimeout(() => reject(new Error('Таймаут распаковки архива')), 45000)
)
]);

console.log('ZIP распакован, файлов:', Object.keys(zip.files).length);

currentZip = zip;

// ДАЛЕЕ СУЩЕСТВУЮЩАЯ ЛОГИКА ДЛЯ ZIP...
// [остальной код обработки ZIP архива остается без изменений]

} else if (isInuFile) {
// НОВАЯ ЛОГИКА ДЛЯ ОТДЕЛЬНЫХ INU ФАЙЛОВ
console.log('Обработка отдельного INU файла');
updateLoadingText('Чтение INU файла...');
updateProgress(30, 'Чтение XML данных...');

// Читаем содержимое INU файла как текст
const xmlContent = await Promise.race([
fileObj.text(),
new Promise((_, reject) =>
setTimeout(() => reject(new Error('Таймаут чтения INU файла')), 30000)
)
]);

console.log('INU файл прочитан, размер:', xmlContent.length, 'символов');

// Для INU файлов создаем виртуальный "архив" с одним файлом
currentZip = null; // Сбрасываем текущий ZIP

// Определяем тип файла по имени
const fileType = getFileType(fileObj.name);
console.log('Тип INU файла:', fileType);

updateProgress(50, 'Анализ данных скважины...');

// Ищем скважины в INU файле
const wells = detectWellsInContent(xmlContent, fileObj.name);
console.log('Найдено скважин в INU файле:', wells.length);

if (wells.length === 0) {
throw new Error('В INU файле не найдено данных скважин');
}

// Сохраняем XML контент для быстрого доступа
fileCache.set(fileObj.name, xmlContent);

// ЕДИНАЯ ЛОГИКА ДЛЯ ВСЕХ СЛУЧАЕВ (как в ZIP обработке)
if (wells.length === 1) {
// Одна скважина - сразу загружаем и отображаем
const well = wells[0];
console.log(`Одна скважина найдена: ${well.wellId}, загружаем напрямую`);

updateProgress(70, 'Загрузка данных скважины...');
await parseWellDataUniversal(xmlContent, well.wellId, fileType);

updateProgress(100, 'Готово!');
setTimeout(() => {
hideLoading();
stopKeepAlive();
displayWellData(fileType, fileNumber, file.name, well.wellId);
}, 100);

} else {
// Несколько скважин - показываем список
console.log(`Найдено ${wells.length} скважин, показываем список`);

currentMultiWellData = {
wells: wells,
fileNames: [fileObj.name],
fileType: fileType,
xmlContent: xmlContent // Сохраняем XML контент для мульти-файла
};
currentMultiFileName = file.name;

updateProgress(100, 'Готово!');
setTimeout(() => {
hideLoading();
stopKeepAlive();
showWellsList(wells, file.name, 1);
updateWellHeaderForMultiFile(fileType, file.name);
wellDataElement.innerHTML = '<div class="loading"><p>Выберите скважину из списка</p></div>';
}, 100);
}

} else {
throw new Error('Неподдерживаемый формат файла. Поддерживаются только .zip и .inu файлы');
}

} catch (error) {
// Гарантированно останавливаем keep-alive при ошибке
stopKeepAlive();
hideLoading();

console.error('Ошибка загрузки данных:', error);
wellDataElement.innerHTML = `
<div class="error">
<p><strong>Ошибка загрузки данных:</strong> ${error.message}</p>
<p>Попробуйте выбрать другой файл</p>
${error.message.includes('Таймаут') ? `
<div style="margin-top: 15px; padding: 10px; background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 4px;">
<strong>Совет:</strong> Попробуйте выбрать меньший файл или проверьте стабильность интернет-соединения
</div>
` : ''}
</div>
`;
}
}
```

## 2. Обновить функцию `selectFileManually` для поддержки INU:

```javascript
async function selectFileManually() {
try {
const input = document.createElement('input');
input.type = 'file';
input.accept = '.inu,.zip'; // Разрешаем оба формата
input.onchange = async (e) => {
const file = e.target.files[0];
if (file) {
// ОЧИСТКА СПИСКА ПРИ ВЫБОРЕ НОВОГО ФАЙЛА
clearFileList();
clearCaches();

// Создаем временный file handle-like объект
const tempFile = {
name: file.name,
handle: { getFile: () => Promise.resolve(file) }
};

await loadWellData(tempFile, 0);
}
};
input.click();
} catch (error) {
console.error('Ошибка выбора файла:', error);
alert('Ошибка при выборе файла: ' + error.message);
}
}
```

## 3. Обновить функцию `parseWellDataFromMulti` для работы с INU:

```javascript
async function parseWellDataFromMulti(wellId, signal = null) {
// [существующий код проверок...]

try {
updateProgress(10, 'Поиск информации о скважине...');

// ПРОВЕРЯЕМ отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

const targetWellMeta = currentMultiWellData.wells.find(w => w.wellId === wellId);
if (!targetWellMeta) {
throw new Error(`Скважина с ID ${wellId} не найдена в списке`);
}

let xmlContent = '';
let sourceFile = '';

// Случай 1: ZIP архив (данные в fileCache)
if (targetWellMeta.sourceFile && fileCache.has(targetWellMeta.sourceFile)) {
sourceFile = targetWellMeta.sourceFile;
updateProgress(30, 'Загрузка данных из кеша...');
xmlContent = fileCache.get(sourceFile);
}
// Случай 2: INU файл (данные в currentMultiWellData.xmlContent)
else if (currentMultiWellData.xmlContent) {
updateProgress(30, 'Загрузка данных из INU файла...');
xmlContent = currentMultiWellData.xmlContent;
sourceFile = 'current_inu_file';
}
// Случай 3: Не удалось определить источник
else {
throw new Error('Не удалось определить источник данных для скважины');
}

// [дальнейшая обработка без изменений...]
}
// [обработка ошибок без изменений...]
}
```

## 4. Обновить функцию поиска файлов для INU:

```javascript
async function findFileInArchiveByBlobPath(blobPath, fileName) {
// Если это INU файл (нет архива), возвращаем null
if (!currentZip) {
console.log('Это INU файл, архив не загружен');
return null;
}

// [существующая логика для ZIP архивов...]
}
```

Теперь программа будет корректно определять тип файла (ZIP или INU) и применять соответствующую логику обработки. Для INU файлов она будет читать XML напрямую, без попыток распаковки как ZIP архива.

Добавлено (2025-10-07, 13:34)
---------------------------------------------
Понял проблему! Нужно вернуть рабочую версию и аккуратно добавить поддержку INU файлов. Давайте откатим изменения и сделаем правильную реализацию.

Вот исправленная версия функции `loadWellData`:

```javascript
async function loadWellData(file, fileNumber) {
// Запускаем keep-alive при начале загрузки
startKeepAlive();

showLoading('Анализ архива...');
const wellDataElement = document.getElementById('wellData');
wellDataElement.innerHTML = '<div class="loading"><p>Загрузка данных...</p></div>';

try {
console.log('Начало загрузки файла:', file.name);
updateLoadingText('Чтение файла...');
updateProgress(5, 'Подготовка...');

const fileObj = await file.handle.getFile();
console.log('Размер файла:', fileObj.size, 'байт');

// ПРОСТАЯ ПРОВЕРКА ТИПА ФАЙЛА
const fileName = fileObj.name.toLowerCase();
const isInuFile = fileName.endsWith('.inu');

if (isInuFile) {
// ОБРАБОТКА INU ФАЙЛА
console.log('Обработка INU файла');
updateLoadingText('Чтение INU файла...');
updateProgress(30, 'Чтение XML данных...');

// Читаем содержимое INU файла как текст
const xmlContent = await fileObj.text();
console.log('INU файл прочитан, размер:', xmlContent.length, 'символов');

// Определяем тип файла по имени
const fileType = getFileType(fileObj.name);
console.log('Тип INU файла:', fileType);

updateProgress(50, 'Анализ данных скважины...');

// Ищем скважины в INU файле
const wells = detectWellsInContent(xmlContent, fileObj.name);
console.log('Найдено скважин в INU файле:', wells.length);

if (wells.length === 0) {
throw new Error('В INU файле не найдено данных скважин');
}

// Сохраняем XML контент для быстрого доступа
fileCache.set(fileObj.name, xmlContent);

// Для INU файлов создаем виртуальную структуру
currentZip = {
files: {
// Создаем виртуальную запись файла для совместимости
[fileObj.name]: {
async: function(type) {
return Promise.resolve(new TextEncoder().encode(xmlContent));
},
name: fileObj.name,
dir: false
}
}
};

// ОБРАБОТКА СКВАЖИН (одинаковая для ZIP и INU)
if (wells.length === 1) {
// Одна скважина - сразу загружаем и отображаем
const well = wells[0];
console.log(`Одна скважина найдена: ${well.wellId}, загружаем напрямую`);

updateProgress(70, 'Загрузка данных скважины...');
await parseWellDataUniversal(xmlContent, well.wellId, fileType);

updateProgress(100, 'Готово!');
setTimeout(() => {
hideLoading();
stopKeepAlive();
displayWellData(fileType, fileNumber, file.name, well.wellId);
}, 100);

} else {
// Несколько скважин - показываем список
console.log(`Найдено ${wells.length} скважин, показываем список`);

currentMultiWellData = {
wells: wells,
fileNames: [fileObj.name],
fileType: fileType,
xmlContent: xmlContent // Сохраняем XML контент
};
currentMultiFileName = file.name;

updateProgress(100, 'Готово!');
setTimeout(() => {
hideLoading();
stopKeepAlive();
showWellsList(wells, file.name, 1);
updateWellHeaderForMultiFile(fileType, file.name);
wellDataElement.innerHTML = '<div class="loading"><p>Выберите скважину из списка</p></div>';
}, 100);
}

} else {
// ОБРАБОТКА ZIP АРХИВА (оригинальная логика)
if (fileObj.size > 1500 * 1024 * 1024) {
throw new Error('Файл слишком большой для обработки в браузере (максимум 1500 МБ)');
}

updateLoadingText('Распаковка архива...');
updateProgress(15, 'Распаковка архива...');

const arrayBuffer = await Promise.race([
fileObj.arrayBuffer(),
new Promise((_, reject) =>
setTimeout(() => reject(new Error('Таймаут чтения файла')), 30000)
)
]);

console.log('ArrayBuffer прочитан, размер:', arrayBuffer.byteLength);

updateLoadingText('Обработка данных...');
updateProgress(25, 'Обработка ZIP...');

const zip = await Promise.race([
JSZip.loadAsync(arrayBuffer),
new Promise((_, reject) =>
setTimeout(() => reject(new Error('Таймаут распаковки архива')), 45000)
)
]);

console.log('ZIP распакован, файлов:', Object.keys(zip.files).length);

currentZip = zip;

// Получаем файлы с корректными именами
const allFiles = getZipFileNames(zip);

// Фильтруем только INU файлы
const inuFiles = allFiles.filter(file =>
file.correctedName.startsWith('904~') ||
file.correctedName.startsWith('906~') ||
file.correctedName.startsWith('911~') ||
file.correctedName.startsWith('909~')
);

if (inuFiles.length === 0) {
throw new Error('В архиве не найдено INU файлов с данными');
}

console.log('Найдены INU файлы:', inuFiles.map(f => f.correctedName));
updateProgress(30, `Найдено ${inuFiles.length} файлов`);

// Получаем типы файлов для отображения
const fileTypes = [...new Set(inuFiles.map(f => getFileType(f.correctedName)))];
const fileTypeText = fileTypes.map(type => {
const typeNames = {
'multi': 'Выгрузка для ПС',
'all': 'Все типы документаций',
'final': 'Итоговая документация',
'primary': 'Первичная документация'
};
return typeNames[type] || type;
}).join(', ');

// ОБНОВЛЯЕМ ЗАГОЛОВОК СРАЗУ ПРИ ЗАГРУЗКЕ АРХИВА
updateWellHeaderOnArchiveLoad(fileTypeText, file.name);

// Запускаем долгосрочный прогресс для обработки файлов
const progressInterval = startLongOperationProgress('Обработка файлов');

// УНИВЕРСАЛЬНЫЙ ПОИСК СКВАЖИН ВО ВСЕХ ФАЙЛАХ
const allWells = [];
let processedFiles = 0;

for (const inuFile of inuFiles) {
try {
// Обновляем прогресс для каждого файла
processedFiles++;
const fileProgress = 30 + (processedFiles / inuFiles.length) * 40;
updateProgress(fileProgress, `Обработка файлов: ${processedFiles}/${inuFiles.length}`);

console.log('Обработка файла:', inuFile.correctedName);

// Добавляем таймаут для чтения каждого файла
const xmlContent = await Promise.race([
readZipFileFast(inuFile.entry),
new Promise((_, reject) =>
setTimeout(() => reject(new Error(`Таймаут чтения файла ${inuFile.correctedName}`)), 15000)
)
]);

const wells = detectWellsInContent(xmlContent, inuFile.correctedName);

console.log(`В файле найдено скважин:`, wells.length);

// Сохраняем XML контент для быстрого доступа
wells.forEach(well => {
well.sourceFile = inuFile.correctedName;
well.originalSourceFile = inuFile.originalName;
well.xmlContent = xmlContent;
well.fileType = getFileType(inuFile.correctedName);
});

allWells.push(...wells);

// Сохраняем в кеш файлов по оригинальному имени
fileCache.set(inuFile.originalName, xmlContent);

} catch (error) {
console.error(`Ошибка обработки файла:`, error);
// Продолжаем обработку других файлов даже при ошибке
}
}

// Останавливаем долгосрочный прогресс
if (progressInterval) {
clearInterval(progressInterval);
}

if (allWells.length === 0) {
throw new Error('В архиве не найдено данных скважин');
}

// ВАЖНО: Убираем дубликаты скважин по wellId
const uniqueWells = [];
const seenWellIds = new Set();

for (const well of allWells) {
if (!seenWellIds.has(well.wellId)) {
seenWellIds.add(well.wellId);
uniqueWells.push(well);
}
}

console.log(`Уникальных скважин: ${uniqueWells.length} (всего найдено: ${allWells.length})`);
updateProgress(80, `Найдено ${uniqueWells.length} скважин`);

// ЕДИНАЯ ЛОГИКА ДЛЯ ВСЕХ СЛУЧАЕВ
if (uniqueWells.length === 1) {
// Одна скважина - сразу загружаем и отображаем
const well = uniqueWells[0];
console.log(`Одна скважина найдена: ${well.wellId}, загружаем напрямую`);

updateProgress(90, 'Загрузка данных скважины...');
await parseWellDataUniversal(well.xmlContent, well.wellId, well.fileType);

updateProgress(100, 'Готово!');
setTimeout(() => {
hideLoading();
stopKeepAlive();
displayWellData(well.fileType, fileNumber, file.name, well.wellId);
}, 100);

} else {
// Несколько скважин - показываем список
console.log(`Найдено ${uniqueWells.length} скважин, показываем список`);

currentMultiWellData = {
wells: uniqueWells,
fileNames: [...new Set(uniqueWells.map(w => w.sourceFile))],
fileType: fileTypes.length === 1 ? fileTypes[0] : 'mixed'
};
currentMultiFileName = file.name;

updateProgress(100, 'Готово!');
setTimeout(() => {
hideLoading();
stopKeepAlive();
showWellsList(uniqueWells, file.name, currentMultiWellData.fileNames.length);
updateWellHeaderForMultiFile(currentMultiWellData.fileType, file.name);
wellDataElement.innerHTML = '<div class="loading"><p>Выберите скважину из списка</p></div>';
}, 100);
}
}

} catch (error) {
// Гарантированно останавливаем keep-alive при ошибке
stopKeepAlive();
hideLoading();

console.error('Ошибка загрузки данных:', error);
wellDataElement.innerHTML = `
<div class="error">
<p><strong>Ошибка загрузки данных:</strong> ${error.message}</p>
<p>Попробуйте выбрать другой файл или архив</p>
${error.message.includes('Таймаут') ? `
<div style="margin-top: 15px; padding: 10px; background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 4px;">
<strong>Совет:</strong> Попробуйте выбрать меньший файл или проверьте стабильность интернет-соединения
</div>
` : ''}
</div>
`;
}
}
```

Ключевые изменения:

1. **Простая проверка типа файла** - только по расширению `.inu`
2. **Для INU файлов** - читаем напрямую как текст и создаем виртуальную структуру для совместимости
3. **Для ZIP архивов** - оставляем оригинальную логику без изменений
4. **Общая обработка скважин** - одинаковый код для обоих типов файлов после получения XML

Теперь должно работать корректно для обоих типов файлов!

Добавлено (2025-10-07, 13:43)
---------------------------------------------
Понял проблему! Ошибка возникает потому что для INU файлов не создаются карты данных (classifierMap, employeeMap и т.д.). Нужно исправить функцию `parseWellDataUniversal` чтобы она работала для INU файлов.

Вот исправления:

## 1. Исправить функцию `parseWellDataUniversal`:

```javascript
async function parseWellDataUniversal(xmlContent, wellId, fileType, signal = null) {
// Проверяем кеш
const cachedData = getCachedWellData(wellId);
if (cachedData) {
console.log('Используем кешированные данные для скважины:', wellId);

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

// НЕМЕДЛЕННО устанавливаем данные и скрываем загрузку
xmlData = cachedData;

// Скрываем загрузку и возвращаем данные
setTimeout(() => {
hideLoading();
}, 50);

return cachedData;
}

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

// Запускаем keep-alive для долгих парсингов
startKeepAlive();

showLoading('Загрузка данных скважины...');

try {
updateProgress(5, 'Подготовка данных...');

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

// Имитируем прогресс для начальной обработки
await new Promise(resolve => setTimeout(resolve, 100));
updateProgress(15, 'Анализ структуры данных...');

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

updateProgress(25, 'Создание карт данных...');

// ВАЖНО: Проверяем что xmlContent не пустой и корректен
if (!xmlContent || xmlContent.length < 100) {
throw new Error('XML данные пустые или повреждены');
}

console.log('Создание карт данных для XML длиной:', xmlContent.length);

// Создаем карты данных с небольшими задержками для прогресса
await new Promise(resolve => setTimeout(resolve, 50));
const classifierMap = createClassifierMap(xmlContent);
console.log('Карта классификаторов создана, размер:', classifierMap.size);
updateProgress(35, 'Карта классификаторов создана');

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

await new Promise(resolve => setTimeout(resolve, 50));
const employeeMap = createEmployeeMap(xmlContent);
console.log('Карта сотрудников создана, размер:', employeeMap.size);
updateProgress(45, 'Карта сотрудников создана');

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

await new Promise(resolve => setTimeout(resolve, 50));
const assayTypeMap = createAssayTypeMap(xmlContent);
console.log('Карта типов опробования создана, размер:', assayTypeMap.size);
updateProgress(55, 'Карта типов опробования создана');

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

await new Promise(resolve => setTimeout(resolve, 50));
const divisionMap = createDivisionMap(xmlContent);
console.log('Карта подразделений создана, размер:', divisionMap.size);
updateProgress(65, 'Карта подразделений создана');

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

updateProgress(75, 'Извлечение основной информации о скважине...');

// Используем существующий быстрый парсер для всех типов файлов
console.time(`Универсальный парсинг для ${wellId}`);

// Добавляем таймаут для парсинга
const wellData = await Promise.race([
parseAllWellDataFast(xmlContent, wellId, classifierMap, employeeMap, assayTypeMap, divisionMap),
new Promise((_, reject) =>
setTimeout(() => reject(new Error('Таймаут парсинга данных скважины')), 60000)
)
]);

console.timeEnd(`Универсальный парсинг для ${wellId}`);

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

if (wellData) {
updateProgress(85, 'Обработка интервалов документирования...');
await new Promise(resolve => setTimeout(resolve, 50));

updateProgress(90, 'Обработка данных опробования...');
await new Promise(resolve => setTimeout(resolve, 50));

// Добавляем информацию о типе файла
wellData.fileType = fileType;
wellData.wellId = wellId;

xmlData = wellData;

updateProgress(95, 'Сохранение в кеш...');
await new Promise(resolve => setTimeout(resolve, 30));

// Сохраняем в кеш
setCachedWellData(wellId, wellData);

updateProgress(100, 'Данные скважины успешно загружены!');

// Проверяем отмену операции перед завершением
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

setTimeout(() => {
hideLoading();
stopKeepAlive(); // Останавливаем keep-alive
}, 200);

return wellData;
}

throw new Error('Не удалось извлечь данные скважины');

} catch (error) {
// Игнорируем ошибки отмены
if (error.name === 'AbortError') {
console.log('Парсинг скважины отменен');
throw error;
}

// Гарантированно останавливаем keep-alive при ошибке
stopKeepAlive();
hideLoading();

console.error('Ошибка универсального парсинга скважины:', error);
console.error('XML content length:', xmlContent ? xmlContent.length : 'null');
console.error('WellId:', wellId);
console.error('FileType:', fileType);

// Очищаем кеш для этой скважины при ошибке
wellDataCache.delete(wellId);

// Показываем информативное сообщение об ошибке
let errorMessage = error.message;
if (error.message.includes('Таймаут')) {
errorMessage = 'Превышено время обработки данных. Попробуйте выбрать другую скважину или файл меньшего размера.';
} else if (error.message.includes('пустые') || error.message.includes('повреждены')) {
errorMessage = 'Данные файла повреждены или имеют неверный формат.';
}

throw new Error(errorMessage);
}
}
```

## 2. Обновить функцию `parseAllWellDataFast`:

```javascript
async function parseAllWellDataFast(xmlContent, wellId, classifierMap, employeeMap, assayTypeMap, divisionMap) {
return new Promise((resolve) => {
try {
console.time(`Fast parse ALL data for ${wellId}`);

console.log('Парсинг данных с картами:');
console.log('- classifierMap:', classifierMap.size);
console.log('- employeeMap:', employeeMap.size);
console.log('- assayTypeMap:', assayTypeMap.size);
console.log('- divisionMap:', divisionMap.size);

// [остальной код функции остается без изменений]
// просто используем переданные карты вместо создания новых
```

## 3. Обновить вызов в `loadWellData` для INU файлов:

Найти в функции `loadWellData` блок для INU файлов где вызывается `parseWellDataUniversal` и убедиться что передается правильный xmlContent:

```javascript
// В блоке обработки INU файлов:
await parseWellDataUniversal(xmlContent, well.wellId, fileType);
```

## 4. Добавить защиту в функции создания карт:

```javascript
function createClassifierMap(xmlContent) {
const classifierMap = new Map();
try {
// Проверяем что xmlContent существует
if (!xmlContent || typeof xmlContent !== 'string') {
console.warn('Некорректный xmlContent для создания карты классификаторов');
return classifierMap;
}

const classifierRegex = /<MR_DBA\.CLASSIFIER>[\s\S]*?<\/MR_DBA\.CLASSIFIER>/g;
const classifierMatches = xmlContent.match(classifierRegex) || [];

console.log('Найдено CLASSIFIER блоков:', classifierMatches.length);

for (const match of classifierMatches) {
const nodeId = extractValue(match, 'ID_NODE_ID');
const nodeName = extractValue(match, 'NODE_NAME');
if (nodeId && nodeName) {
classifierMap.set(nodeId, nodeName);
}
}
} catch (error) {
console.error('Ошибка создания карты классификаторов:', error);
}
return classifierMap;
}
```

Аналогично добавить проверки в другие функции создания карт (`createEmployeeMap`, `createAssayTypeMap`, `createDivisionMap`).

Теперь карты данных будут создаваться корректно для INU файлов, и ошибка "создания карт" должна исчезнуть!

Добавлено (2025-10-07, 13:50)
---------------------------------------------
Понял! Ошибка возникает потому что для мульти-файлов INU данные передаются неправильно. Давайте исправим логику передачи XML контента.

## 1. Исправить функцию `parseWellDataUniversal` - убрать строгую проверку:

```javascript
async function parseWellDataUniversal(xmlContent, wellId, fileType, signal = null) {
// Проверяем кеш
const cachedData = getCachedWellData(wellId);
if (cachedData) {
console.log('Используем кешированные данные для скважины:', wellId);

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

xmlData = cachedData;

setTimeout(() => {
hideLoading();
}, 50);

return cachedData;
}

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

// Запускаем keep-alive для долгих парсингов
startKeepAlive();

showLoading('Загрузка данных скважины...');

try {
updateProgress(5, 'Подготовка данных...');

// ПРОВЕРКА XML ДАННЫХ - БОЛЕЕ ГИБКАЯ
if (!xmlContent) {
throw new Error('XML данные отсутствуют');
}

if (xmlContent.length < 50) {
console.warn('XML данные очень короткие, но пробуем обработать:', xmlContent.length);
}

console.log('Начало парсинга XML длиной:', xmlContent.length, 'символов');

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

await new Promise(resolve => setTimeout(resolve, 100));
updateProgress(15, 'Анализ структуры данных...');

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

updateProgress(25, 'Создание карт данных...');

console.log('Создание карт данных...');

// Создаем карты данных с защитой от ошибок
await new Promise(resolve => setTimeout(resolve, 50));
const classifierMap = createClassifierMap(xmlContent);
console.log('Карта классификаторов создана, размер:', classifierMap.size);
updateProgress(35, 'Карта классификаторов создана');

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

await new Promise(resolve => setTimeout(resolve, 50));
const employeeMap = createEmployeeMap(xmlContent);
console.log('Карта сотрудников создана, размер:', employeeMap.size);
updateProgress(45, 'Карта сотрудников создана');

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

await new Promise(resolve => setTimeout(resolve, 50));
const assayTypeMap = createAssayTypeMap(xmlContent);
console.log('Карта типов опробования создана, размер:', assayTypeMap.size);
updateProgress(55, 'Карта типов опробования создана');

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

await new Promise(resolve => setTimeout(resolve, 50));
const divisionMap = createDivisionMap(xmlContent);
console.log('Карта подразделений создана, размер:', divisionMap.size);
updateProgress(65, 'Карта подразделений создана');

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

updateProgress(75, 'Извлечение основной информации о скважине...');

// Используем существующий быстрый парсер для всех типов файлов
console.time(`Универсальный парсинг для ${wellId}`);

// Передаем созданные карты в парсер
const wellData = await parseAllWellDataFast(xmlContent, wellId, classifierMap, employeeMap, assayTypeMap, divisionMap);

console.timeEnd(`Универсальный парсинг для ${wellId}`);

// Проверяем отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

if (wellData) {
updateProgress(85, 'Обработка интервалов документирования...');
await new Promise(resolve => setTimeout(resolve, 50));

updateProgress(90, 'Обработка данных опробования...');
await new Promise(resolve => setTimeout(resolve, 50));

// Добавляем информацию о типе файла
wellData.fileType = fileType;
wellData.wellId = wellId;

xmlData = wellData;

updateProgress(95, 'Сохранение в кеш...');
await new Promise(resolve => setTimeout(resolve, 30));

// Сохраняем в кеш
setCachedWellData(wellId, wellData);

updateProgress(100, 'Данные скважины успешно загружены!');

// Проверяем отмену операции перед завершением
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

setTimeout(() => {
hideLoading();
stopKeepAlive();
}, 200);

return wellData;
}

throw new Error('Не удалось извлечь данные скважины');

} catch (error) {
// Игнорируем ошибки отмены
if (error.name === 'AbortError') {
console.log('Парсинг скважины отменен');
throw error;
}

// Гарантированно останавливаем keep-alive при ошибке
stopKeepAlive();
hideLoading();

console.error('Ошибка универсального парсинга скважины:', error);
console.error('XML content length:', xmlContent ? xmlContent.length : 'null');
console.error('WellId:', wellId);
console.error('FileType:', fileType);

// Очищаем кеш для этой скважины при ошибке
wellDataCache.delete(wellId);

throw error; // Пробрасываем оригинальную ошибку
}
}
```

## 2. Исправить функцию `parseWellDataFromMulti` для INU файлов:

```javascript
async function parseWellDataFromMulti(wellId, signal = null) {
// ПРОВЕРЯЕМ отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

if (!currentMultiWellData || !currentMultiWellData.wells) {
throw new Error('Данные мульти-файла не загружены');
}

// ПРОВЕРЯЕМ КЕШ с защитой от ошибок
const cachedData = getCachedWellData(wellId);
if (cachedData) {
console.log('Используем кешированные данные для скважины:', wellId);

// ПРОВЕРЯЕМ отмену операции перед возвратом данных
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

xmlData = cachedData;
return;
}

showLoading('Загрузка данных скважины...');

try {
updateProgress(10, 'Поиск информации о скважине...');

// ПРОВЕРЯЕМ отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

const targetWellMeta = currentMultiWellData.wells.find(w => w.wellId === wellId);
if (!targetWellMeta) {
throw new Error(`Скважина с ID ${wellId} не найдена в списке`);
}

let xmlContent = '';
let sourceFile = '';

// Случай 1: ZIP архив (данные в fileCache)
if (targetWellMeta.sourceFile && fileCache.has(targetWellMeta.sourceFile)) {
sourceFile = targetWellMeta.sourceFile;
updateProgress(30, 'Загрузка данных из кеша...');

// ПРОВЕРЯЕМ отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

xmlContent = fileCache.get(sourceFile);
if (!xmlContent) {
throw new Error(`Файл ${sourceFile} не найден в кеше`);
}
}
// Случай 2: INU файл (данные в currentMultiWellData.xmlContent)
else if (currentMultiWellData.xmlContent) {
updateProgress(30, 'Загрузка данных из INU файла...');
xmlContent = currentMultiWellData.xmlContent;
sourceFile = 'current_inu_file';
console.log('Используем XML из currentMultiWellData, длина:', xmlContent.length);
}
// Случай 3: Данные в самом объекте скважины
else if (targetWellMeta.xmlContent) {
updateProgress(30, 'Загрузка данных из объекта скважины...');
xmlContent = targetWellMeta.xmlContent;
sourceFile = 'well_object';
console.log('Используем XML из targetWellMeta, длина:', xmlContent.length);
}
// Случай 4: Не удалось определить источник
else {
throw new Error('Не удалось определить источник данных для скважины');
}

// ВАЖНО: Проверяем что xmlContent не пустой
if (!xmlContent || xmlContent.length < 10) {
throw new Error('XML данные пустые или отсутствуют для скважины ' + wellId);
}

updateProgress(50, 'Быстрая обработка всех данных...');

// ПРОВЕРЯЕМ отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

// ИСПОЛЬЗУЕМ БЫСТРЫЙ МЕТОД ДЛЯ ВСЕХ ДАННЫХ
console.time(`Parse ALL data for ${wellId}`);
const allWellData = await parseAllWellDataFast(xmlContent, wellId);
console.timeEnd(`Parse ALL data for ${wellId}`);

// ПРОВЕРЯЕМ отмену операции
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

if (allWellData) {
// ВАЖНО: Сохраняем wellId в данных для корректного отображения
allWellData.wellId = wellId;

xmlData = allWellData;

// Сохраняем в кеш с защитой от ошибок
setCachedWellData(wellId, xmlData);

updateProgress(100, 'Готово!');

// ПРОВЕРЯЕМ отмену операции перед завершением
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

setTimeout(() => {
hideLoading();
}, 50);
return;
}

throw new Error('Не удалось извлечь данные скважины');

} catch (error) {
// Игнорируем ошибки отмены
if (error.name === 'AbortError') {
throw error;
}

hideLoading();
console.error('Ошибка загрузки данных скважины:', error);

// Очищаем кеш для этой скважины при ошибке
try {
wellDataCache.delete(wellId);
} catch (e) {
console.error('Ошибка очистки кеша:', e);
}

throw error;
}
}
```

## 3. Добавить отладочную информацию в `selectWell`:

```javascript
function selectWell(wellId, wellNumber) {
// Запоминаем позицию прокрутки
const listsContainer = document.getElementById('listsContainer');
if (listsContainer) {
lastScrollPosition = listsContainer.scrollTop;
}

// Скрываем меню в мобильной версии
if (window.innerWidth <= 1024) {
const sidebar = document.querySelector('.sidebar');
const overlay = document.getElementById('overlay');
if (sidebar) sidebar.classList.remove('active');
if (overlay) overlay.classList.remove('active');
}

// Сброс активного класса у всех элементов
document.querySelectorAll('.well-item').forEach(item => {
item.classList.remove('active');
});

// Добавление активного класса к выбранному элементу
event.currentTarget.classList.add('active');

currentWellId = wellId;

// Находим данные скважины
const wellMeta = currentMultiWellData.wells.find(w => w.wellId === wellId);
if (!wellMeta) {
console.error('Данные скважины не найдены:', wellId);
return;
}

console.log('Выбрана скважина:', wellId);
console.log('Данные скважины:', wellMeta);
console.log('currentMultiWellData:', currentMultiWellData);

abortController = new AbortController();
currentLoadingOperation = { wellId, timestamp: Date.now() };

showLoading('Загрузка данных скважины...');

// Используем setTimeout для асинхронной обработки
setTimeout(async () => {
// Проверяем, не была ли операция отменена
if (!currentLoadingOperation || currentLoadingOperation.wellId !== wellId) {
return;
}

try {
// Используем универсальный парсер
await parseWellDataFromMulti(wellId, abortController.signal);

// ВАЖНО: После успешной загрузки ОБЯЗАТЕЛЬНО отображаем данные
displayWellData(wellMeta.fileType, wellNumber, currentMultiFileName, wellId);

// Очищаем операцию после успешной загрузки
if (currentLoadingOperation && currentLoadingOperation.wellId === wellId) {
currentLoadingOperation = null;
abortController = null;
}
} catch (error) {
// Игнорируем ошибки отмены
if (error.name === 'AbortError') {
console.log('Загрузка отменена пользователем');
return;
}

console.error('Ошибка загрузки скважины:', error);

// Сбрасываем активный класс при ошибке
event.currentTarget.classList.remove('active');

// Очищаем операцию при ошибке
currentLoadingOperation = null;
abortController = null;

document.getElementById('wellData').innerHTML = `
<div class="error">
<p><strong>Ошибка загрузки данных скважины:</strong> ${error.message}</p>
<p>Попробуйте выбрать другую скважину</p>
</div>
`;
hideLoading();
}
}, 50);
}
```

Теперь XML данные должны передаваться корректно для INU файлов!

Добавлено (2025-10-07, 13:58)
---------------------------------------------
Отлично! Удалим функцию открытия отдельных INU файлов и заменим её на открытие ZIP архивов. Вот изменения:

## 1. Удаляем кнопку "Открыть INU файл" из HTML:

```javascript
// В разделе actions-container заменяем:
<div class="main-actions">
<button class="action-btn primary" id="selectFolderBtn">
<span class="btn-icon">📁</span>
<span class="btn-text">Выбрать папку</span>
</button>
<button class="action-btn secondary" id="selectFileBtn">
<span class="btn-icon">📄</span>
<span class="btn-text">Открыть ZIP</span> <!-- ← ИЗМЕНИЛИ ТЕКСТ -->
</button>
</div>
```

## 2. Обновляем функцию выбора файла:

```javascript
// Удаляем старую функцию selectFileManually и заменяем на:
async function selectZipFile() {
try {
const input = document.createElement('input');
input.type = 'file';
input.accept = '.zip'; // ← ТОЛЬКО ZIP ФАЙЛЫ
input.onchange = async (e) => {
const file = e.target.files[0];
if (file) {
// ОЧИСТКА СПИСКА ПРИ ВЫБОРЕ НОВОГО ФАЙЛА
clearFileList();
clearCaches();

// Создаем временный file handle-like объект
const tempFile = {
name: file.name,
handle: { getFile: () => Promise.resolve(file) }
};

// Обновляем отображение пути
document.getElementById('folderPath').innerHTML = `
<div class="folder-path-content">
<span class="folder-icon">📦</span>
<span class="folder-text">${file.name}</span>
</div>
`;

await loadWellData(tempFile, 0);
}
};
input.click();
} catch (error) {
console.error('Ошибка выбора ZIP файла:', error);
alert('Ошибка при выборе ZIP файла: ' + error.message);
}
}
```

## 3. Обновляем обработчики в DOMContentLoaded:

```javascript
// Заменяем обработчики:
document.getElementById('selectFolderBtn').addEventListener('click', selectFolder);
document.getElementById('selectFileBtn').addEventListener('click', selectZipFile); // ← ИЗМЕНИЛИ ФУНКЦИЮ
```

## 4. Обновляем функцию clearFileList для случая с ZIP:

```javascript
function clearFileList() {
const fileList = document.getElementById('fileList');
const wellsList = document.getElementById('wellsList');
const backButton = document.getElementById('backButton');

if (fileList) fileList.innerHTML = '<li class="file-item">Выберите папку или ZIP архив</li>'; // ← ОБНОВИЛИ ТЕКСТ
if (wellsList) {
wellsList.innerHTML = '';
wellsList.style.display = 'none';
}
if (backButton) backButton.style.display = 'none';

// Сбрасываем глобальные переменные
currentMultiWellData = null;
currentWellId = null;
currentMultiFileName = null;
currentDirectoryHandle = null;

// Обновляем счетчик
document.getElementById('fileCounter').textContent = '';

// Сбрасываем путь к папке
resetFolderPath();
}

function resetFolderPath() {
document.getElementById('folderPath').innerHTML = `
<div class="folder-path-content">
<span class="folder-icon">📂</span>
<span class="folder-text">Выберите папку или ZIP архив</span> <!-- ← ОБНОВИЛИ ТЕКСТ -->
</div>
`;
}
```

## 5. Обновляем тексты интерфейса:

```javascript
// В функции updateSidebarHeader:
function updateSidebarHeader(title) {
const sidebarHeader = document.querySelector('.sidebar-header h2');
if (sidebarHeader) {
sidebarHeader.textContent = title;
}
}

// В начальном состоянии:
document.addEventListener('DOMContentLoaded', function() {
// ... существующий код ...

// Устанавливаем начальный текст
updateSidebarHeader('Список архивов');
document.getElementById('fileList').innerHTML = '<li class="file-item">Выберите папку или ZIP архив</li>';
});
```

## 6. Обновляем тексты в счетчике файлов:

```javascript
// В функции loadFileList обновляем тексты:
const subfolderText = searchSubfolders ? ' (включая подпапки)' : '';
document.getElementById('fileCounter').textContent = `Найдено архивов: ${files.length}${subfolderText}`;

// И при отсутствии файлов:
fileList.innerHTML = '<li class="file-item">В папке нет архивов ZIP</li>';
```

## Полный код изменений:

```javascript
// ЗАМЕНЯЕМ старую функцию selectFileManually на:
async function selectZipFile() {
try {
const input = document.createElement('input');
input.type = 'file';
input.accept = '.zip';
input.onchange = async (e) => {
const file = e.target.files[0];
if (file) {
clearFileList();
clearCaches();

const tempFile = {
name: file.name,
handle: { getFile: () => Promise.resolve(file) }
};

document.getElementById('folderPath').innerHTML = `
<div class="folder-path-content">
<span class="folder-icon">📦</span>
<span class="folder-text">${file.name}</span>
</div>
`;

await loadWellData(tempFile, 0);
}
};
input.click();
} catch (error) {
console.error('Ошибка выбора ZIP файла:', error);
alert('Ошибка при выборе ZIP файла: ' + error.message);
}
}

// ОБНОВЛЯЕМ обработчики в DOMContentLoaded:
document.addEventListener('DOMContentLoaded', function() {
document.getElementById('selectFolderBtn').addEventListener('click', selectFolder);
document.getElementById('selectFileBtn').addEventListener('click', selectZipFile); // ← ИЗМЕНИЛИ
// ... остальной код ...
});
```

Теперь приложение будет работать только с папками и отдельными ZIP архивами, что упростит интерфейс и логику работы.

Добавлено (2025-10-07, 14:23)
---------------------------------------------
Отлично! Добавим кнопки выгрузки в Excel для всех таблиц. Вот реализация:

## 1. Добавляем библиотеку для работы с Excel:

```javascript
// Добавляем в head или перед закрывающим тегом body
<script src="https://cdnjs.cloudflare.com/ajax/libs/xlsx/0.18.5/xlsx.full.min.js"></script>
```

## 2. Создаем функцию для экспорта в Excel:

```javascript
// Функция для экспорта таблицы в Excel
function exportTableToExcel(tableElement, fileName) {
try {
// Создаем новую книгу Excel
const wb = XLSX.utils.book_new();

// Получаем данные из таблицы
const table = tableElement.querySelector('table');
const worksheet = XLSX.utils.table_to_sheet(table);

// Добавляем лист в книгу
XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

// Сохраняем файл
XLSX.writeFile(wb, `${fileName}_${new Date().toISOString().split('T')[0]}.xlsx`);

showNotification(`Таблица "${fileName}" успешно экспортирована`, 'success');
} catch (error) {
console.error('Ошибка экспорта в Excel:', error);
showNotification('Ошибка при экспорте таблицы', 'error');
}
}

// Функция создания кнопки экспорта
function createExportButton(tableId, fileName) {
return `
<div class="export-section" style="margin-bottom: 15px; display: flex; justify-content: flex-end;">
<button class="export-excel-btn"
data-table-id="${tableId}"
data-file-name="${fileName}"
style="background: linear-gradient(135deg, #27ae60 0%, #219653 100%);
color: white;
border: none;
padding: 10px 20px;
border-radius: 6px;
cursor: pointer;
font-size: 0.85rem;
font-weight: 500;
display: flex;
align-items: center;
gap: 8px;
box-shadow: 0 2px 4px rgba(39, 174, 96, 0.3);
transition: all 0.2s ease;">
<span style="font-size: 1.1rem;">📊</span>
<span>Экспорт в Excel</span>
</button>
</div>
`;
}
```

## 3. Обновляем функции отображения таблиц с кнопками экспорта:

### Для первичной документации:
```javascript
function displayPrimaryDocumentation() {
let html = '';

// Информация о первичном документировании
if (xmlData.primaryDocInfo) {
// ... существующий код ...
}

// Добавляем кнопку экспорта
html += createExportButton('primaryDocTable', 'Первичное_документирование');

html += `
<div class="table-wrapper">
<div class="table-header">
<table class="interval-table" id="primaryDocTable">
<thead>
<tr>
<th style="width: 50px;">ПП</th>
<th style="width: 80px;">От (м)</th>
<th style="width: 80px;">До (м)</th>
<th style="width: 100px;">Мощность (м)</th>
<th style="width: 150px;">Стратиграфия</th>
<th style="width: 150px;">Литология</th>
<th>Описание</th>
</tr>
</thead>
</table>
</div>
<div class="table-container">
<table class="interval-table">
<tbody>`;

xmlData.primaryDocumentation.forEach(interval => {
html += `
<tr>
<td style="width: 50px;">${interval.numberPP}</td>
<td style="width: 80px;">${formatNumber(interval.from)}</td>
<td style="width: 80px;">${formatNumber(interval.to)}</td>
<td style="width: 100px;">${formatNumber(interval.thickness)}</td>
<td style="width: 150px;" class="stratigraphy-column">${interval.stratigraphy}</td>
<td style="width: 150px;">${interval.lithology}</td>
<td><div class="description-text">${interval.description}</div></td>
</tr>`;
});

html += `
</tbody>
</table>
</div>
</div>
`;

return html;
}
```

### Для итоговой документации:
```javascript
function displayFinalDocumentation() {
let html = '';

// ... существующий код информации о документировании ...

// Добавляем кнопку экспорта
html += createExportButton('finalDocTable', 'Итоговое_документирование');

html += `
<div class="table-wrapper">
<div class="table-header">
<table class="interval-table" id="finalDocTable">
<thead>
<tr>
<th style="width: 50px;">ПП</th>
<th style="width: 80px;">От (м)</th>
<th style="width: 80px;">До (м)</th>
<th style="width: 100px;">Мощность (м)</th>
<th style="width: 150px;">Стратиграфия</th>
<th style="width: 150px;">Литология</th>
<th>Описание</th>
</tr>
</thead>
</table>
</div>
<div class="table-container">
<table class="interval-table">
<tbody>`;

// ... существующий код таблицы ...

return html;
}
```

### Для ГИС документации:
```javascript
function displayGisDocumentation() {
let html = '';

// ... существующий код ...

if (xmlData.gisDocumentation.length > 0) {
// Добавляем кнопку экспорта
html += createExportButton('gisDocTable', 'ГИС_документирование');

html += `
<div class="table-wrapper">
<div class="table-header">
<table class="interval-table" id="gisDocTable">
<thead>
<tr>
<th style="width: 50px;">ПП</th>
<th style="width: 80px;">От (м)</th>
<th style="width: 80px;">До (м)</th>
<th style="width: 100px;">Мощность (м)</th>
<th style="width: 150px;">Стратиграфия</th>
<th style="width: 150px;">Литология</th>
<th>Описание</th>
</tr>
</thead>
</table>
</div>
<div class="table-container">
<table class="interval-table">
<tbody>`;

// ... заполнение таблицы ...
}

return html;
}
```

### Для опробования:
```javascript
function displayAssays() {
let html = '';

if (xmlData.assays.length > 0) {
// Добавляем кнопку экспорта
html += createExportButton('assaysTable', 'Опробование');

html += `
<div class="table-wrapper">
<div class="table-header">
<table class="interval-table" id="assaysTable">
<thead>
<tr>
<th style="width: 60px;">№ пробы</th>
<th style="width: 120px;">Тип опробования</th>
<th style="width: 80px;">От (м)</th>
<th style="width: 80px;">До (м)</th>
<th style="width: 100px;">Значение</th>
<th style="width: 80px;">Ед. изм.</th>
<th style="width: 120px;">Штрих-код</th>
<th style="width: 120px;">Место отбора</th>
<th style="width: 120px;">Автор отбора</th>
<th style="width: 100px;">Дата отбора</th>
<th>Описание</th>
<th style="width: 150px;">Тип документирования</th>
</tr>
</thead>
</table>
</div>
<div class="table-container">
<table class="interval-table">
<tbody>`;

// ... заполнение таблицы ...
}

return html;
}
```

### Для керновых ящиков:
```javascript
function displayCoreBoxes(coreBoxes) {
if (!coreBoxes || coreBoxes.length === 0) {
return '<div class="no-data"><p>Нет данных о керновых ящиках</p></div>';
}

let html = `
<div class="doc-info-list" style="margin-bottom: 20px;">
<div class="doc-info-item">
<span class="doc-info-label">Всего керновых ящиков:</span>
<span class="doc-info-value"><strong>${coreBoxes.length}</strong></span>
</div>
</div>
`;

// Добавляем кнопку экспорта
html += createExportButton('coreBoxesTable', 'Керновые_ящики');

html += `
<div class="table-wrapper">
<div class="table-header">
<table class="interval-table" id="coreBoxesTable">
<thead>
<tr>
<th style="width: 80px;">№ ящика</th>
<th style="width: 100px;">От (м)</th>
<th style="width: 100px;">До (м)</th>
<th style="width: 100px;">Длина (м)</th>
<th style="width: 120px;">Базальный горизонт</th>
<th style="width: 200px;">Описание</th>
<th style="width: 250px;">Связанные документы</th>
<th style="width: 100px;">Дата добавления</th>
</tr>
</thead>
</table>
</div>
<div class="table-container">
<table class="interval-table">
<tbody>
`;

// ... заполнение таблицы ...

return html;
}
```

### Для вложенных документов:
```javascript
// В функции displayAttachedDocuments добавляем после фильтра:
html += createExportButton('documentsTable', 'Вложенные_документы');

// И обновляем ID таблицы:
html += `
<div id="documentsTableSection">
<div class="table-wrapper" id="documentsTableWrapper">
<div class="table-header">
<table class="interval-table" id="documentsTable" style="min-width: 1600px;">
<!-- ... остальная таблица ... -->
`;
```

## 4. Добавляем обработчики для кнопок экспорта:

```javascript
// Функция для инициализации обработчиков экспорта
function initializeExportButtons() {
document.querySelectorAll('.export-excel-btn').forEach(button => {
button.addEventListener('click', function() {
const tableId = this.getAttribute('data-table-id');
const fileName = this.getAttribute('data-file-name');
const tableElement = document.getElementById(tableId);

if (tableElement) {
exportTableToExcel(tableElement, fileName);
} else {
console.error('Таблица не найдена:', tableId);
showNotification('Ошибка: таблица не найдена', 'error');
}
});

// Добавляем стили при наведении
button.addEventListener('mouseenter', function() {
this.style.transform = 'translateY(-2px)';
this.style.boxShadow = '0 4px 8px rgba(39, 174, 96, 0.4)';
});

button.addEventListener('mouseleave', function() {
this.style.transform = 'translateY(0)';
this.style.boxShadow = '0 2px 4px rgba(39, 174, 96, 0.3)';
});
});
}
```

## 5. Обновляем функцию displayWellData для инициализации кнопок:

```javascript
// В функции displayWellData, после инициализации document buttons:
setTimeout(() => {
// ... существующие обработчики ...

// ОБЩИЕ обработчики для кнопок документов
initializeDocumentButtons();

// ОБРАБОТЧИК ДЛЯ ФИЛЬТРА ДОКУМЕНТОВ
const filterCheckbox = document.getElementById('filterRelatedDocuments');
if (filterCheckbox) {
filterCheckbox.addEventListener('change', function() {
filterDocumentsByStatus(this.checked);
});

// Применяем фильтр сразу (по умолчанию включен)
filterDocumentsByStatus(true);
}

// ИНИЦИАЛИЗИРУЕМ КНОПКИ ЭКСПОРТА ← ДОБАВЛЯЕМ ЭТУ СТРОЧКУ
initializeExportButtons();

}, 100);
```

## 6. Добавляем CSS стили для кнопок:

```css
/* Добавляем в CSS секцию */
.export-excel-btn:hover {
background: linear-gradient(135deg, #219653 0%, #1e8449 100%) !important;
transform: translateY(-2px) !important;
box-shadow: 0 4px 8px rgba(39, 174, 96, 0.4) !important;
}

.export-excel-btn:active {
transform: translateY(0) !important;
box-shadow: 0 2px 4px rgba(39, 174, 96, 0.3) !important;
}

.export-section {
margin-bottom: 15px;
display: flex;
justify-content: flex-end;
border-bottom: 1px solid #eee;
padding-bottom: 10px;
}
```

Теперь над каждой таблицей будет появляться кнопка "Экспорт в Excel", которая выгружает таблицу в форматированный Excel файл с текущей датой в названии.

Добавлено (2025-10-07, 14:44)
---------------------------------------------
Вот полный код функции `displayWellData` с добавленными кнопками экспорта:

```javascript
async function displayWellData(fileType, fileNumber, fileName, wellId = null, signal = null) {
const wellDataElement = document.getElementById('wellData');

// ГАРАНТИРУЕМ что загрузка скрыта перед отображением
hideLoading();

// Проверяем что данные действительно загружены
if (!xmlData) {
console.error('Нет данных для отображения');
wellDataElement.innerHTML = `
<div class="error">
<p>Ошибка: данные не загружены</p>
<p>Попробуйте выбрать скважину еще раз</p>
</div>
`;
return;
}

// Проверяем отмену операции перед отображением
if (signal && signal.aborted) {
throw new DOMException('Operation aborted', 'AbortError');
}

// Обновление заголовка
const badgeClass = fileType === 'all' ? 'all' :
fileType === 'primary' ? 'primary' :
fileType === 'final' ? 'final' :
fileType === 'multi' ? 'multi' : 'unknown';

const badgeText = fileType === 'all' ? 'Все типы документаций' :
fileType === 'primary' ? 'Первичная документация' :
fileType === 'final' ? 'Итоговая документация' :
fileType === 'multi' ? 'Выгрузка для ПС' : 'Неизвестный тип';

document.getElementById('wellName').innerHTML = `
<div class="well-header-content">
<div class="doc-type-badge ${badgeClass}">${badgeText}</div>
<div class="well-title">
${xmlData.lineNumber && xmlData.lineNumber !== 'Не указано' ? `
<div class="well-line-container">
<div class="well-line-label">Линия №:</div>
<div class="well-line-number">${xmlData.lineNumber}</div>
</div>
` : ''}
<div class="well-number-container">
<div class="well-number-label">Номер выработки:</div>
<div class="well-line-number">${xmlData.wellName}</div>
</div>
</div>
${xmlData.wellType && xmlData.wellType !== 'Не указано' ? `
<div class="well-type-inline">
<span class="well-type-label">Тип скважины:</span>
<span class="well-type-value">${xmlData.wellType}</span>
</div>
` : ''}
</div>
`;

// Создание HTML для отображения данных с ИСПРАВЛЕННОЙ СТРУКТУРОЙ ВКЛАДОК
let html = '';

// Основная информация о скважине
html += `
<div class="section">
<h2>Основная информация</h2>

<div class="info-group">
<div class="info-group-title">Объект и участок</div>
<div class="doc-info-list">
<div class="doc-info-item">
<span class="doc-info-label">Объект работ:</span>
<span class="doc-info-value"><strong>${formatLongText(xmlData.object || 'Не указан')}</strong></span>
</div>
<div class="doc-info-item ${!xmlData.area || xmlData.area === 'Не указано' ? 'missing-field-simple' : ''}">
<span class="doc-info-label">Геологический участок:</span>
<span class="doc-info-value">
${xmlData.area && xmlData.area !== 'Не указано' ? `<strong>${formatLongText(xmlData.area)}</strong>` : '<em class="not-specified-text">не указано</em>'}
</span>
</div>
</div>
</div>

<div class="info-group">
<div class="info-group-title">Бурение</div>
<div class="doc-info-list">
<div class="doc-info-item ${!xmlData.drillingStartDate || xmlData.drillingStartDate === '' ? 'missing-field-simple' : ''}">
<span class="doc-info-label">Начало бурения:</span>
<span class="doc-info-value">${xmlData.drillingStartDate || 'Не указано'}</span>
</div>
<div class="doc-info-item ${!xmlData.drillingEndDate || xmlData.drillingEndDate === '' ? 'missing-field-simple' : ''}">
<span class="doc-info-label">Окончание бурения:</span>
<span class="doc-info-value">${xmlData.drillingEndDate || 'Не указано'}</span>
</div>
<div class="doc-info-item ${!xmlData.drillingBrigade || xmlData.drillingBrigade === 'Не указано' ? 'missing-field-simple' : ''}">
<span class="doc-info-label">Бригада бурения:</span>
<span class="doc-info-value">${formatLongText(xmlData.drillingBrigade || 'Не указано')}</span>
</div>
</div>
</div>

${xmlData.wellDescription && xmlData.wellDescription !== 'Не указано' ? `
<div class="info-group">
<div class="info-group-title">Описание ТН</div>
<div class="description-block">
<p>${formatLongText(xmlData.wellDescription, 100)}</p>
</div>
</div>
` : ''}
</div>
`;

// ИСПРАВЛЕННАЯ СТРУКТУРА ВКЛАДОК
const hasPrimary = xmlData.primaryDocumentation && xmlData.primaryDocumentation.length > 0;
const hasFinal = xmlData.finalDocumentation && xmlData.finalDocumentation.length > 0;
const hasGis = xmlData.gisDocumentation && xmlData.gisDocumentation.length > 0;
const hasAssays = xmlData.assays && xmlData.assays.length > 0;
const hasCoreBoxes = xmlData.coreBoxes && xmlData.coreBoxes.length > 0;
const hasDocuments = xmlData.attachedDocuments && xmlData.attachedDocuments.length > 0;

// Создаем основные вкладки
if (hasPrimary || hasFinal || hasGis || hasAssays || hasCoreBoxes || hasDocuments) {
html += `<div class="section">`;
html += `<h2>Данные скважины</h2>`;

// Определяем первую активную вкладку
let firstActiveTab = '';
if (hasPrimary || hasFinal || hasGis || hasAssays) firstActiveTab = 'documentation';
else if (hasCoreBoxes) firstActiveTab = 'coreboxes';
else if (hasDocuments) firstActiveTab = 'documents';
else firstActiveTab = 'drilling';

// Создаем основные вкладки
html += `<div class="tabs">`;

// Вкладка 1: Документация
if (hasPrimary || hasFinal || hasGis || hasAssays) {
html += `<div class="tab ${firstActiveTab === 'documentation' ? 'active' : ''}" data-tab="documentation">Документация</div>`;
}

// Вкладка 2: Проходка
html += `<div class="tab ${firstActiveTab === 'drilling' ? 'active' : ''}" data-tab="drilling">Проходка</div>`;

// Вкладка 3: Керновые ящики
if (hasCoreBoxes) {
html += `<div class="tab ${firstActiveTab === 'coreboxes' ? 'active' : ''}" data-tab="coreboxes">Керновые ящики</div>`;
}

// Вкладка 4: Вложенные документы
if (hasDocuments) {
html += `<div class="tab ${firstActiveTab === 'documents' ? 'active' : ''}" data-tab="documents">Вложенные документы</div>`;
}

html += `</div>`;

// Содержимое вкладки "Документация"
if (hasPrimary || hasFinal || hasGis || hasAssays) {
html += `<div id="documentationTab" class="tab-content ${firstActiveTab === 'documentation' ? 'active' : ''}">`;

// Определяем первую активную подвкладку
let firstActiveSubTab = '';
if (hasPrimary) firstActiveSubTab = 'primary';
else if (hasFinal) firstActiveSubTab = 'final';
else if (hasGis) firstActiveSubTab = 'gis';
else if (hasAssays) firstActiveSubTab = 'assays';

// Внутренние вкладки для документации - оформляем как настоящие вкладки
html += `<div class="inner-tabs-container">`;
html += `<div class="inner-tabs">`;

if (hasPrimary) {
html += `<div class="inner-tab ${firstActiveSubTab === 'primary' ? 'active' : ''}" data-inner-tab="primary">Первичное документирование</div>`;
}
if (hasFinal) {
html += `<div class="inner-tab ${firstActiveSubTab === 'final' ? 'active' : ''}" data-inner-tab="final">Итоговое документирование</div>`;
}
if (hasGis) {
html += `<div class="inner-tab ${firstActiveSubTab === 'gis' ? 'active' : ''}" data-inner-tab="gis">Документирование по ГИС</div>`;
}
if (hasAssays) {
html += `<div class="inner-tab ${firstActiveSubTab === 'assays' ? 'active' : ''}" data-inner-tab="assays">Опробование</div>`;
}

html += `</div>`; // закрываем inner-tabs

// Содержимое внутренних вкладок
html += `<div class="inner-tabs-content">`;

if (hasPrimary) {
html += `<div id="primaryInnerTab" class="inner-tab-content ${firstActiveSubTab === 'primary' ? 'active' : ''}">`;
html += displayPrimaryDocumentation();
html += `</div>`;
}

if (hasFinal) {
html += `<div id="finalInnerTab" class="inner-tab-content ${firstActiveSubTab === 'final' ? 'active' : ''}">`;
html += displayFinalDocumentation();
html += `</div>`;
}

if (hasGis) {
html += `<div id="gisInnerTab" class="inner-tab-content ${firstActiveSubTab === 'gis' ? 'active' : ''}">`;
html += displayGisDocumentation();
html += `</div>`;
}

if (hasAssays) {
html += `<div id="assaysInnerTab" class="inner-tab-content ${firstActiveSubTab === 'assays' ? 'active' : ''}">`;
html += displayAssays();
html += `</div>`;
}

html += `</div>`; // закрываем inner-tabs-content
html += `</div>`; // закрываем inner-tabs-container
html += `</div>`; // закрываем documentationTab
}

// Содержимое вкладки "Проходка"
html += `<div id="drillingTab" class="tab-content ${firstActiveTab === 'drilling' ? 'active' : ''}">`;
html += `
<div class="no-data" style="text-align: center; padding: 40px 20px;">
<div style="font-size: 3rem; margin-bottom: 20px; color: #3498db;">🚧</div>
<h3 style="color: #2c3e50; margin-bottom: 15px;">Раздел в разработке</h3>
<p style="color: #7f8c8d; line-height: 1.6; max-width: 500px; margin: 0 auto;">
Функциональность раздела "Проходка" находится в стадии разработки.<br>
В будущем здесь будет отображаться информация о процессе бурения скважины.
</p>
</div>
`;
html += `</div>`;

// Содержимое вкладки "Керновые ящики"
if (hasCoreBoxes) {
html += `<div id="coreboxesTab" class="tab-content ${firstActiveTab === 'coreboxes' ? 'active' : ''}">`;
html += displayCoreBoxes(xmlData.coreBoxes);
html += `</div>`;
}

// Содержимое вкладки "Вложенные документы"
if (hasDocuments) {
html += `<div id="documentsTab" class="tab-content ${firstActiveTab === 'documents' ? 'active' : ''}">`;
html += displayAttachedDocuments(xmlData.attachedDocuments);
html += `</div>`;
}

html += `</div>`; // закрываем section
} else {
html += `
<div class="section">
<h2>Данные скважины</h2>
<div class="no-data">
<p>Нет данных о документировании и опробовании</p>
</div>
</div>
`;
}

wellDataElement.innerHTML = html;

// Добавляем обработчики для вкладок после рендеринга
setTimeout(() => {
// Обработчики для основных вкладок
document.querySelectorAll('.tab').forEach(tab => {
tab.addEventListener('click', function() {
const tabName = this.getAttribute('data-tab');
switchMainTab(tabName);
});
});

// Обработчики для внутренних вкладок документации
document.querySelectorAll('.inner-tab').forEach(innerTab => {
innerTab.addEventListener('click', function() {
const innerTabName = this.getAttribute('data-inner-tab');
switchInnerTab(innerTabName);
});
});

// ОБЩИЕ обработчики для кнопок документов
initializeDocumentButtons();

// ОБРАБОТЧИК ДЛЯ ФИЛЬТРА ДОКУМЕНТОВ
const filterCheckbox = document.getElementById('filterRelatedDocuments');
if (filterCheckbox) {
filterCheckbox.addEventListener('change', function() {
filterDocumentsByStatus(this.checked);
});

// Применяем фильтр сразу (по умолчанию включен)
filterDocumentsByStatus(true);
}

// ИНИЦИАЛИЗИРУЕМ КНОПКИ ЭКСПОРТА
initializeExportButtons();

}, 100);

console.log('Данные скважины успешно отображены');
}
```

Также добавьте эти вспомогательные функции, если их еще нет:

```javascript
// Функция переключения основных вкладок
function switchMainTab(tabName) {
// Скрываем все содержимое вкладок
document.querySelectorAll('.tab-content').forEach(content => {
content.classList.remove('active');
});

// Убираем активный класс со всех вкладок
document.querySelectorAll('.tab').forEach(tab => {
tab.classList.remove('active');
});

// Активируем выбранную вкладку
const selectedContent = document.getElementById(tabName + 'Tab');
const selectedTab = document.querySelector(`.tab[data-tab="${tabName}"]`);

if (selectedContent) {
selectedContent.classList.add('active');
}
if (selectedTab) {
selectedTab.classList.add('active');
}
}

// Функция для инициализации обработчиков экспорта
function initializeExportButtons() {
document.querySelectorAll('.export-excel-btn').forEach(button => {
button.addEventListener('click', function() {
const tableId = this.getAttribute('data-table-id');
const fileName = this.getAttribute('data-file-name');
const tableElement = document.getElementById(tableId);

if (tableElement) {
exportTableToExcel(tableElement, fileName);
} else {
console.error('Таблица не найдена:', tableId);
showNotification('Ошибка: таблица не найдена', 'error');
}
});

// Добавляем стили при наведении
button.addEventListener('mouseenter', function() {
this.style.transform = 'translateY(-2px)';
this.style.boxShadow = '0 4px 8px rgba(39, 174, 96, 0.4)';
});

button.addEventListener('mouseleave', function() {
this.style.transform = 'translateY(0)';
this.style.boxShadow = '0 2px 4px rgba(39, 174, 96, 0.3)';
});
});
}
```

Теперь функция `displayWellData` включает все кнопки экспорта для таблиц и правильную структуру вкладок.

Добавлено (2025-10-07, 14:58)
---------------------------------------------
Вот полные функции всех документаций, ящиков и документов с добавленными кнопками экспорта:

## 1. Функция displayPrimaryDocumentation:

```javascript
function displayPrimaryDocumentation() {
let html = '';

// Информация о первичном документировании
if (xmlData.primaryDocInfo) {
let hasDocInfo = false;
let docInfoHtml = '';

if (xmlData.primaryDocInfo.startDate && xmlData.primaryDocInfo.startDate !== '') {
docInfoHtml += `
<div class="doc-info-item">
<span class="doc-info-label">Начало документирования:</span>
<span class="doc-info-value">${xmlData.primaryDocInfo.startDate}</span>
</div>
`;
hasDocInfo = true;
}

if (xmlData.primaryDocInfo.endDate && xmlData.primaryDocInfo.endDate !== '') {
docInfoHtml += `
<div class="doc-info-item">
<span class="doc-info-label">Окончание документирования:</span>
<span class="doc-info-value">${xmlData.primaryDocInfo.endDate}</span>
</div>
`;
} else if (xmlData.primaryDocInfo.startDate && xmlData.primaryDocInfo.startDate !== '') {
docInfoHtml += `
<div class="doc-info-item missing-field">
<span class="doc-info-label">Окончание документирования:</span>
<span class="doc-info-value">Не указано (обязательное поле)</span>
</div>
`;
}
hasDocInfo = true;

if (xmlData.primaryDocInfo.depth && xmlData.primaryDocInfo.depth !== 'Не указано') {
docInfoHtml += `
<div class="doc-info-item">
<span class="doc-info-label">Фактическая глубина:</span>
<span class="doc-info-value">${xmlData.primaryDocInfo.depth} м</span>
</div>
`;
hasDocInfo = true;
}

if (xmlData.primaryDocInfo.author && xmlData.primaryDocInfo.author !== 'Не указано') {
docInfoHtml += `
<div class="doc-info-item">
<span class="doc-info-label">Документатор:</span>
<span class="doc-info-value">${formatLongText(xmlData.primaryDocInfo.author)}</span>
</div>
`;
hasDocInfo = true;
}

if (hasDocInfo) {
html += `<div class="doc-info-list">${docInfoHtml}</div>`;
}
}

// Добавляем кнопку экспорта
html += createExportButton('primaryDocTable', 'Первичное_документирование');

html += `
<div class="table-wrapper">
<div class="table-header">
<table class="interval-table" id="primaryDocTable">
<thead>
<tr>
<th style="width: 50px;">ПП</th>
<th style="width: 80px;">От (м)</th>
<th style="width: 80px;">До (м)</th>
<th style="width: 100px;">Мощность (м)</th>
<th style="width: 150px;">Стратиграфия</th>
<th style="width: 150px;">Литология</th>
<th>Описание</th>
</tr>
</thead>
</table>
</div>
<div class="table-container">
<table class="interval-table">
<tbody>`;

xmlData.primaryDocumentation.forEach(interval => {
html += `
<tr>
<td style="width: 50px;">${interval.numberPP}</td>
<td style="width: 80px;">${formatNumber(interval.from)}</td>
<td style="width: 80px;">${formatNumber(interval.to)}</td>
<td style="width: 100px;">${formatNumber(interval.thickness)}</td>
<td style="width: 150px;" class="stratigraphy-column">${interval.stratigraphy}</td>
<td style="width: 150px;">${interval.lithology}</td>
<td><div class="description-text">${interval.description}</div></td>
</tr>`;
});

html += `
</tbody>
</table>
</div>
</div>
`;

return html;
}
```

## 2. Функция displayFinalDocumentation:

```javascript
function displayFinalDocumentation() {
let html = '';

// Информация об итоговом документировании
if (xmlData.finalDocInfo) {
let hasDocInfo = false;
let docInfoHtml = '';

if (xmlData.finalDocInfo.startDate && xmlData.finalDocInfo.startDate !== '') {
docInfoHtml += `
<div class="doc-info-item">
<span class="doc-info-label">Начало документирования:</span>
<span class="doc-info-value">${xmlData.finalDocInfo.startDate}</span>
</div>
`;
hasDocInfo = true;
}

if (xmlData.finalDocInfo.endDate && xmlData.finalDocInfo.endDate !== '') {
docInfoHtml += `
<div class="doc-info-item">
<span class="doc-info-label">Окончание документирования:</span>
<span class="doc-info-value">${xmlData.finalDocInfo.endDate}</span>
</div>
`;
} else if (xmlData.finalDocInfo.startDate && xmlData.finalDocInfo.startDate !== '') {
docInfoHtml += `
<div class="doc-info-item missing-field">
<span class="doc-info-label">Окончание документирования:</span>
<span class="doc-info-value">Не указано (обязательное поле)</span>
</div>
`;
}
hasDocInfo = true;

if (xmlData.finalDocInfo.depth && xmlData.finalDocInfo.depth !== 'Не указано') {
docInfoHtml += `
<div class="doc-info-item">
<span class="doc-info-label">Фактическая глубина:</span>
<span class="doc-info-value">${xmlData.finalDocInfo.depth} м</span>
</div>
`;
hasDocInfo = true;
}

if (xmlData.finalDocInfo.author && xmlData.finalDocInfo.author !== 'Не указано') {
docInfoHtml += `
<div class="doc-info-item">
<span class="doc-info-label">Документатор:</span>
<span class="doc-info-value">${formatLongText(xmlData.finalDocInfo.author)}</span>
</div>
`;
hasDocInfo = true;
}

if (hasDocInfo) {
html += `<div class="doc-info-list">${docInfoHtml}</div>`;
}
}

// Добавляем кнопку экспорта
html += createExportButton('finalDocTable', 'Итоговое_документирование');

html += `
<div class="table-wrapper">
<div class="table-header">
<table class="interval-table" id="finalDocTable">
<thead>
<tr>
<th style="width: 50px;">ПП</th>
<th style="width: 80px;">От (м)</th>
<th style="width: 80px;">До (м)</th>
<th style="width: 100px;">Мощность (м)</th>
<th style="width: 150px;">Стратиграфия</th>
<th style="width: 150px;">Литология</th>
<th>Описание</th>
</tr>
</thead>
</table>
</div>
<div class="table-container">
<table class="interval-table">
<tbody>`;

xmlData.finalDocumentation.forEach(interval => {
html += `
<tr>
<td style="width: 50px;">${interval.numberPP}</td>
<td style="width: 80px;">${formatNumber(interval.from)}</td>
<td style="width: 80px;">${formatNumber(interval.to)}</td>
<td style="width: 100px;">${formatNumber(interval.thickness)}</td>
<td style="width: 150px;" class="stratigraphy-column">${interval.stratigraphy}</td>
<td style="width: 150px;">${interval.lithology}</td>
<td><div class="description-text">${interval.description}</div></td>
</tr>`;
});

html += `
</tbody>
</table>
</div>
</div>
`;

return html;
}
```

## 3. Функция displayGisDocumentation:

```javascript
function displayGisDocumentation() {
let html = '';

// Информация о ГИС документировании
if (xmlData.gisDocInfo) {
let hasDocInfo = false;
let docInfoHtml = '';

if (xmlData.gisDocInfo.startDate && xmlData.gisDocInfo.startDate !== '') {
docInfoHtml += `
<div class="doc-info-item">
<span class="doc-info-label">Начало документирования:</span>
<span class="doc-info-value">${xmlData.gisDocInfo.startDate}</span>
</div>`;
hasDocInfo = true;
}

if (xmlData.gisDocInfo.endDate && xmlData.gisDocInfo.endDate !== '') {
docInfoHtml += `
<div class="doc-info-item">
<span class="doc-info-label">Окончание документирования:</span>
<span class="doc-info-value">${xmlData.gisDocInfo.endDate}</span>
</div>`;
} else if (xmlData.gisDocInfo.startDate && xmlData.gisDocInfo.startDate !== '') {
docInfoHtml += `
<div class="doc-info-item missing-field">
<span class="doc-info-label">Окончание документирования:</span>
<span class="doc-info-value">Не указано (обязательное поле)</span>
</div>`;
}
hasDocInfo = true;

if (xmlData.gisDocInfo.depth && xmlData.gisDocInfo.depth !== 'Не указано') {
docInfoHtml += `
<div class="doc-info-item">
<span class="doc-info-label">Фактическая глубина:</span>
<span class="doc-info-value">${xmlData.gisDocInfo.depth} м</span>
</div>`;
hasDocInfo = true;
}

if (xmlData.gisDocInfo.author && xmlData.gisDocInfo.author !== 'Не указано') {
docInfoHtml += `
<div class="doc-info-item">
<span class="doc-info-label">Документатор:</span>
<span class="doc-info-value">${formatLongText(xmlData.gisDocInfo.author)}</span>
</div>`;
hasDocInfo = true;
}

if (hasDocInfo) {
html += `<div class="doc-info-list">${docInfoHtml}</div>`;
}
}

if (xmlData.gisDocumentation.length > 0) {
// Добавляем кнопку экспорта
html += createExportButton('gisDocTable', 'ГИС_документирование');

html += `
<div class="table-wrapper">
<div class="table-header">
<table class="interval-table" id="gisDocTable">
<thead>
<tr>
<th style="width: 50px;">ПП</th>
<th style="width: 80px;">От (м)</th>
<th style="width: 80px;">До (м)</th>
<th style="width: 100px;">Мощность (м)</th>
<th style="width: 150px;">Стратиграфия</th>
<th style="width: 150px;">Литология</th>
<th>Описание</th>
</tr>
</thead>
</table>
</div>
<div class="table-container">
<table class="interval-table">
<tbody>`;

xmlData.gisDocumentation.forEach(interval => {
html += `
<tr>
<td style="width: 50px;">${interval.numberPP}</td>
<td style="width: 80px;">${formatNumber(interval.from)}</td>
<td style="width: 80px;">${formatNumber(interval.to)}</td>
<td style="width: 100px;">${formatNumber(interval.thickness)}</td>
<td style="width: 150px;" class="stratigraphy-column">${interval.stratigraphy}</td>
<td style="width: 150px;">${interval.lithology}</td>
<td><div class="description-text">${interval.description}</div></td>
</tr>`;
});

html += `
</tbody>
</table>
</div>
</div>
`;
} else {
html += `<div class="no-data"><p>Нет данных ГИС документирования</p></div>`;
}

return html;
}
```

## 4. Функция displayAssays:

```javascript
function displayAssays() {
let html = '';

if (xmlData.assays && xmlData.assays.length > 0) {
// Добавляем кнопку экспорта
html += createExportButton('assaysTable', 'Опробование');

html += `
<div class="table-wrapper">
<div class="table-header">
<table class="interval-table" id="assaysTable">
<thead>
<tr>
<th style="width: 60px;">№ пробы</th>
<th style="width: 120px;">Тип опробования</th>
<th style="width: 80px;">От (м)</th>
<th style="width: 80px;">До (м)</th>
<th style="width: 100px;">Значение</th>
<th style="width: 80px;">Ед. изм.</th>
<th style="width: 120px;">Штрих-код</th>
<th style="width: 120px;">Место отбора</th>
<th style="width: 120px;">Автор отбора</th>
<th style="width: 100px;">Дата отбора</th>
<th>Описание</th>
<th style="width: 150px;">Тип документирования</th>
</tr>
</thead>
</table>
</div>
<div class="table-container">
<table class="interval-table">
<tbody>`;

xmlData.assays.forEach(assay => {
html += `
<tr>
<td style="width: 60px;">${assay.number}</td>
<td style="width: 120px;">${assay.type}</td>
<td style="width: 80px;">${formatNumber(assay.from)}</td>
<td style="width: 80px;">${formatNumber(assay.to)}</td>
<td style="width: 100px;">${assay.value}</td>
<td style="width: 80px;">${assay.unit}</td>
<td style="width: 120px;">${assay.barcode}</td>
<td style="width: 120px;">${assay.place}</td>
<td style="width: 120px;">${assay.author}</td>
<td style="width: 100px;">${assay.samplingDate}</td>
<td><div class="description-text">${assay.description}</div></td>
<td style="width: 150px;">${assay.documentationType}</td>
</tr>`;
});

html += `
</tbody>
</table>
</div>
</div>
`;
} else {
html += `<div class="no-data"><p>Нет данных опробования</p></div>`;
}

return html;
}
```

## 5. Функция displayCoreBoxes:

```javascript
function displayCoreBoxes(coreBoxes) {
if (!coreBoxes || coreBoxes.length === 0) {
return '<div class="no-data"><p>Нет данных о керновых ящиках</p></div>';
}

let html = `
<div class="doc-info-list" style="margin-bottom: 20px;">
<div class="doc-info-item">
<span class="doc-info-label">Всего керновых ящиков:</span>
<span class="doc-info-value"><strong>${coreBoxes.length}</strong></span>
</div>
</div>
`;

// Добавляем кнопку экспорта
html += createExportButton('coreBoxesTable', 'Керновые_ящики');

html += `
<div class="table-wrapper">
<div class="table-header">
<table class="interval-table" id="coreBoxesTable">
<thead>
<tr>
<th style="width: 80px;">№ ящика</th>
<th style="width: 100px;">От (м)</th>
<th style="width: 100px;">До (м)</th>
<th style="width: 100px;">Длина (м)</th>
<th style="width: 120px;">Базальный горизонт</th>
<th style="width: 200px;">Описание</th>
<th style="width: 250px;">Связанные документы</th>
<th style="width: 100px;">Дата добавления</th>
</tr>
</thead>
</table>
</div>
<div class="table-container">
<table class="interval-table">
<tbody>
`;

coreBoxes.forEach((box, index) => {
const basalClass = box.basalHorizon === 'Базальный горизонт' ? 'basal-horizon' : '';
const hasDocuments = box.relatedDocuments && box.relatedDocuments.length > 0;

html += `
<tr class="${basalClass}">
<td style="width: 80px;">
<strong>${box.boxNumber}</strong>
</td>
<td style="width: 100px;">${formatNumber(box.intervalFrom)}</td>
<td style="width: 100px;">${formatNumber(box.intervalTo)}</td>
<td style="width: 100px;">${formatNumber(box.thickness)}</td>
<td style="width: 120px;">${box.basalHorizon}</td>
<td style="width: 200px;"><div class="description-text">${box.description}</div></td>
<td style="width: 250px;">
${hasDocuments ?
`<div class="documents-list" style="display: flex; flex-direction: column; gap: 5px;">
${box.relatedDocuments.map(doc => {
const isImage = isImageFile(doc.downloadFileName);

// СОЗДАЕМ УНИКАЛЬНОЕ ОТОБРАЖАЕМОЕ ИМЯ
let displayName = createUniqueDisplayName(doc);

return `
<div style="display: flex; justify-content: space-between; align-items: center; padding: 4px 8px; background: #f8f9fa; border-radius: 4px; border: 1px solid #e9ecef;">
<div style="flex: 1; min-width: 0;">
<div style="font-weight: 500; font-size: 0.8rem; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;" title="${getDocumentTooltip(doc)}">
${displayName}
</div>
<div style="font-size: 0.7rem; color: #6c757d; display: flex; justify-content: space-between;">
<span>${doc.fileType || 'Неизвестный тип'}</span>
<span style="font-family: monospace; font-size: 0.6rem; color: #999;">ID: ${doc.id}</span>
</div>
</div>
<div style="display: flex; gap: 3px; flex-shrink: 0;">
<button class="preview-doc-btn corebox-preview-btn"
data-doc-id="${doc.id}"
data-file-name="${doc.downloadFileName}"
data-file-type="${doc.fileType}"
data-is-image="${isImage}"
data-blob-path="${doc.blobPath || ''}"
style="padding: 2px 6px; font-size: 0.65rem; background-color: #3498db; color: white; border: none; border-radius: 3px; cursor: pointer;"
title="Просмотр">
👁
</button>
<button class="download-doc-btn corebox-download-btn"
data-doc-id="${doc.id}"
data-file-name="${doc.downloadFileName}"
data-blob-path="${doc.blobPath || ''}"
style="padding: 2px 6px; font-size: 0.65rem; background-color: #27ae60; color: white; border: none; border-radius: 3px; cursor: pointer;"
title="Скачать">
📥
</button>
</div>
</div>
`;
}).join('')}
</div>` :
`<span style="color: #95a5a6; font-style: italic;">нет связанных документов</span>`
}
</td>
<td style="width: 100px;">${box.inputDate || 'Не указана'}</td>
</tr>
`;
});

html += `
</tbody>
</table>
</div>
</div>
`;

return html;
}
```

## 6. Функция displayAttachedDocuments:

```javascript
function displayAttachedDocuments(documents) {
if (!documents || documents.length === 0) {
return '<div class="no-data"><p>Нет вложенных документов</p></div>';
}

// Получаем информацию о текущей открытой скважине
const currentWellName = xmlData ? xmlData.wellName : '';
const currentLineNumber = xmlData ? xmlData.lineNumber : '';

// Форматируем отображение текущей скважины для сравнения
let currentWellDisplay = '';
if (currentLineNumber && currentLineNumber !== 'Не указано' && currentWellName) {
currentWellDisplay = `л${currentLineNumber} - ${currentWellName}`;
} else if (currentWellName) {
currentWellDisplay = currentWellName;
}

// СОРТИРУЕМ ДОКУМЕНТЫ: сначала связанные с текущей скважиной, потом остальные
const sortedDocuments = [...documents].sort((a, b) => {
const aIsCurrent = a.wellInfo && currentWellDisplay && a.wellInfo === currentWellDisplay;
const bIsCurrent = b.wellInfo && currentWellDisplay && b.wellInfo === currentWellDisplay;

if (aIsCurrent && !bIsCurrent) return -1; // a выше
if (!aIsCurrent && bIsCurrent) return 1; // b выше
return 0; // сохраняем порядок
});

// Считаем статистику
const relatedCount = sortedDocuments.filter(doc => {
const isCurrent = doc.wellInfo && currentWellDisplay && doc.wellInfo === currentWellDisplay;
return isCurrent;
}).length;

const otherCount = sortedDocuments.length - relatedCount;

let html = `
<div class="doc-info-list" style="margin-bottom: 20px;">
<div class="doc-info-item">
<span class="doc-info-label">Всего документов:</span>
<span class="doc-info-value"><strong>${sortedDocuments.length}</strong></span>
</div>
<div class="doc-info-item">
<span class="doc-info-label">Связано с текущей скважиной:</span>
<span class="doc-info-value"><strong style="color: #27ae60;">${relatedCount}</strong></span>
</div>
<div class="doc-info-item">
<span class="doc-info-label">Другие документы:</span>
<span class="doc-info-value"><strong style="color: #e67e22;">${otherCount}</strong></span>
</div>
<div class="doc-info-item">
<span class="doc-info-label">Текущая скважина:</span>
<span class="doc-info-value"><strong>${currentWellDisplay || 'Не определена'}</strong></span>
</div>
</div>

<!-- ФИЛЬТР ПО СТАТУСУ -->
<div class="filter-section" style="margin-bottom: 20px;">
<div class="filter-container" style="background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%); padding: 20px; border-radius: 8px; border: 1px solid #dee2e6; box-shadow: 0 2px 4px rgba(0,0,0,0.05);">
<div style="display: flex; align-items: center; justify-content: space-between; margin-bottom: 10px;">
<div style="display: flex; align-items: center; gap: 12px;">
<label class="checkbox-label-modern" style="margin: 0; font-size: 1rem;">
<input type="checkbox" id="filterRelatedDocuments" checked>
<span class="checkmark-modern" style="width: 20px; height: 20px;"></span>
<span class="checkbox-text" style="font-weight: 600; color: #2c3e50; font-size: 1rem;">
Показывать только документы, связанные с текущей скважиной
</span>
</label>
</div>
<div id="filterStatus" style="background: #27ae60; color: white; padding: 6px 12px; border-radius: 20px; font-size: 0.85rem; font-weight: 500;">
Фильтр активен
</div>
</div>
<div style="color: #6c757d; font-size: 0.9rem; line-height: 1.4;">
${relatedCount > 0 ?
`При включенном фильтре отображаются только <strong>${relatedCount}</strong> документов, связанных с текущей скважиной` :
`При включенном фильтре документов не найдено - отключите фильтр для просмотра всех документов`
}
</div>
</div>
</div>
`;

// Добавляем кнопку экспорта
html += createExportButton('documentsTable', 'Вложенные_документы');

// ТАБЛИЦА ДОКУМЕНТОВ
html += `
<div id="documentsTableSection">
<div class="table-wrapper" id="documentsTableWrapper">
<div class="table-header">
<table class="interval-table" id="documentsTable" style="min-width: 1600px;">
<thead>
<tr>
<th style="width: 50px;">№</th>
<th style="width: 150px;">Скважина</th>
<th style="width: 200px;">Название документа</th>
<th style="width: 180px;">Имя файла</th>
<th style="width: 120px;">Тип файла</th>
<th style="width: 200px;">Описание</th>
<th style="width: 100px;">Автор</th>
<th style="width: 100px;">Дата</th>
<th style="width: 150px;">Статус связи</th>
<th style="width: 150px;">Действия</th>
</tr>
</thead>
</table>
</div>
<div class="table-container">
<table class="interval-table" style="min-width: 1600px;">
<tbody id="documentsTableBody">
`;

let visibleIndex = 0;

sortedDocuments.forEach((doc, index) => {
const displayName = doc.fileName || `Документ ${index + 1}`;
const fileName = doc.originalFileName || doc.downloadFileName || 'Не указано';
const displayType = doc.fileType || 'Неизвестно';
const displayDescription = doc.description || 'Нет описания';
const displayAuthor = doc.author || 'Не указан';
const displayDate = doc.uploadDate || 'Не указана';
const downloadFileName = doc.downloadFileName || displayName;
const blobPath = doc.blobPath || '';

// Определяем, является ли файл изображением
const isImage = /\.(jpg|jpeg|png|gif|bmp|webp|tiff|tif)$/i.test(downloadFileName);

// Определяем стиль в зависимости от типа связи
let rowClass = '';
let statusText = '';
let statusColor = '';
let wellInfo = '';
let isRelatedToCurrent = false;

// Получаем информацию о скважине для документа
if (doc.wellInfo) {
wellInfo = doc.wellInfo;
} else if (xmlData && xmlData.wellName) {
const wellName = xmlData.wellName || '';
const lineNumber = xmlData.lineNumber && xmlData.lineNumber !== 'Не указано' ? xmlData.lineNumber : '';

if (lineNumber && wellName) {
wellInfo = `л${lineNumber} - ${wellName}`;
} else if (wellName) {
wellInfo = wellName;
}
}

// Определяем статус связи
if (wellInfo && currentWellDisplay && wellInfo === currentWellDisplay) {
isRelatedToCurrent = true;
statusText = 'Связан с текущей скважиной';
statusColor = '#27ae60';
} else if (wellInfo) {
rowClass = 'unrelated-document';
statusText = 'Принадлежит другой скважине';
statusColor = '#e67e22';
} else if (doc.relationType === 'unknown') {
statusText = 'Связь не определена';
statusColor = '#95a5a6';
} else {
rowClass = 'unrelated-document';
statusText = 'Не связан со скважиной';
statusColor = '#e67e22';
}

visibleIndex++;

html += `
<tr class="${rowClass} ${isRelatedToCurrent ? 'related-document' : 'other-document'}" data-related="${isRelatedToCurrent}">
<td style="width: 50px;">${visibleIndex}</td>
<td style="width: 150px;">
${wellInfo ? `<div style="font-weight: 500; color: #2c3e50;">${wellInfo}</div>` : ''}
</td>
<td style="width: 200px;">
<div class="file-name-display">${displayName}</div>
${doc.fileExtension ? `<div class="file-extension" title="Имя файла: ${downloadFileName}">${doc.fileExtension}</div>` : ''}
</td>
<td style="width: 180px;">
<div style="font-family: 'Consolas', 'Monaco', 'Courier New', monospace; font-size: 0.8rem; color: #495057; word-break: break-all;">
${fileName}
</div>
${doc.id ? `<div style="font-size: 0.7rem; color: #6c757d; margin-top: 2px;">ID: ${doc.id}</div>` : ''}
</td>
<td style="width: 120px;">${displayType}</td>
<td style="width: 200px;"><div class="description-text">${displayDescription}</div></td>
<td style="width: 100px;">${displayAuthor}</td>
<td style="width: 100px;">${displayDate}</td>
<td style="width: 150px; color: ${statusColor}; font-weight: 500;">${statusText}</td>
<td style="width: 150px;">
<div style="display: flex; gap: 5px; flex-wrap: wrap;">
<button class="btn preview-doc-btn" data-doc-id="${doc.id}"
data-file-name="${downloadFileName}"
data-file-type="${displayType}"
data-is-image="${isImage}"
data-blob-path="${blobPath}"
style="padding: 5px 8px; font-size: 0.75rem;">
Просмотр
</button>
<button class="btn download-doc-btn" data-doc-id="${doc.id}"
data-file-name="${downloadFileName}"
data-blob-path="${blobPath}"
data-file-type="${displayType}"
style="padding: 5px 8px; font-size: 0.75rem; background-color: #27ae60;">
Скачать
</button>
</div>
</td>
</tr>
`;
});

html += `
</tbody>
</table>
</div>
</div>

<div class="doc-info-list" style="margin-top: 20px; background: #f8f9fa; padding: 15px; border-radius: 6px;">
<div class="doc-info-item">
<span class="doc-info-label">Пояснение статусов:</span>
<span class="doc-info-value">
<strong style="color: #27ae60;">Связан с текущей скважиной</strong> - документ принадлежит открытой скважине<br>
<strong style="color: #e67e22;">Принадлежит другой скважине</strong> - документ связан с другой скважиной объекта<br>
<strong style="color: #e67e22;">Не связан со скважиной</strong> - документ не привязан к конкретной скважине<br>
<strong style="color: #95a5a6;">Связь не определена</strong> - не удалось определить принадлежность документа
</span>
</div>
</div>
</div>

<!-- СООБЩЕНИЕ КОГДА НЕТ ДОКУМЕНТОВ ПРИ ФИЛЬТРЕ -->
<div id="noRelatedDocumentsMessage" style="display: none; text-align: center; padding: 40px 20px; background: #f8f9fa; border-radius: 8px; margin-top: 20px;">
<div style="font-size: 3rem; margin-bottom: 15px; color: #95a5a6;">📄</div>
<h3 style="color: #6c757d; margin-bottom: 10px;">Нет связанных документов</h3>
<p style="color: #6c757d; line-height: 1.5;">
Для текущей скважины не найдено связанных документов.<br>
Отключите фильтр, чтобы увидеть все доступные документы.
</p>
</div>

<!-- Модальное окно для предпросмотра -->
<div id="docPreviewModal" style="display: none; position: fixed; top: 0; left: 0; width: 100%; height: 100%; background: rgba(0,0,0,0.8); z-index: 2000; justify-content: center; align-items: center; backdrop-filter: blur(5px);">
<div style="background: white; padding: 20px; border-radius: 8px; max-width: 90%; max-height: 90%; overflow: auto; box-shadow: 0 10px 30px rgba(0,0,0,0.3); border: 1px solid #ddd;">
<div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 15px;">
<h3 id="modalDocTitle" style="margin: 0; color: #2c3e50;">Просмотр документа</h3>
<button id="closeModalBtn" style="background: #e74c3c; color: white; border: none; padding: 8px 12px; border-radius: 4px; cursor: pointer; font-size: 14px;">✕ Закрыть</button>
</div>
<div id="modalDocContent">
<p>Загрузка документа...</p>
</div>
</div>
</div>
`;

return html;
}
```

Теперь все функции документаций, ящиков и документов включают кнопки экспорта в Excel над соответствующими таблицами.

Добавлено (2025-10-07, 15:25)
---------------------------------------------
Проблема в том, что функция `exportTableToExcel` пытается найти таблицу внутри tableElement, но tableElement уже является самой таблицей. Давайте исправим это:

## Исправленная функция exportTableToExcel:

```javascript
// Функция для экспорта таблицы в Excel
function exportTableToExcel(tableElement, fileName) {
try {
console.log('Начало экспорта таблицы:', fileName);
console.log('Table element:', tableElement);

// Проверяем, что tableElement существует
if (!tableElement) {
throw new Error('Элемент таблицы не найден');
}

// Получаем таблицу - tableElement уже является таблицей
const table = tableElement;
console.log('Таблица найдена:', table);

// Проверяем, что таблица содержит строки
const rowCount = table.rows ? table.rows.length : 0;
console.log('Количество строк в таблице:', rowCount);

if (rowCount === 0) {
throw new Error('Таблица пустая');
}

// Создаем новую книгу Excel
const wb = XLSX.utils.book_new();

// Получаем данные из таблицы
const worksheet = XLSX.utils.table_to_sheet(table);

// Добавляем лист в книгу
XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

// Генерируем имя файла с датой
const date = new Date().toISOString().split('T')[0];
const excelFileName = `${fileName}_${date}.xlsx`;

// Сохраняем файл
XLSX.writeFile(wb, excelFileName);

showNotification(`Таблица "${fileName}" успешно экспортирована`, 'success');
console.log('Экспорт завершен успешно');

} catch (error) {
console.error('Ошибка экспорта в Excel:', error);
console.error('Stack:', error.stack);
showNotification(`Ошибка при экспорте таблицы: ${error.message}`, 'error');
}
}
```

## Обновленная функция createExportButton:

```javascript
// Функция создания кнопки экспорта
function createExportButton(tableId, fileName) {
return `
<div class="export-section" style="margin-bottom: 15px; display: flex; justify-content: flex-end;">
<button class="export-excel-btn"
data-table-id="${tableId}"
data-file-name="${fileName}"
style="background: linear-gradient(135deg, #27ae60 0%, #219653 100%);
color: white;
border: none;
padding: 10px 20px;
border-radius: 6px;
cursor: pointer;
font-size: 0.85rem;
font-weight: 500;
display: flex;
align-items: center;
gap: 8px;
box-shadow: 0 2px 4px rgba(39, 174, 96, 0.3);
transition: all 0.2s ease;">
<span style="font-size: 1.1rem;">📊</span>
<span>Экспорт в Excel</span>
</button>
</div>
`;
}
```

## Обновленная функция initializeExportButtons:

```javascript
// Функция для инициализации обработчиков экспорта
function initializeExportButtons() {
document.querySelectorAll('.export-excel-btn').forEach(button => {
button.addEventListener('click', function() {
const tableId = this.getAttribute('data-table-id');
const fileName = this.getAttribute('data-file-name');

console.log('Кнопка экспорта нажата:', { tableId, fileName });

// Ищем таблицу по ID
const tableElement = document.getElementById(tableId);
console.log('Найденный элемент таблицы:', tableElement);

if (tableElement && tableElement.tagName === 'TABLE') {
exportTableToExcel(tableElement, fileName);
} else {
console.error('Таблица не найдена или не является таблицей:', tableId, tableElement);
showNotification('Ошибка: таблица не найдена', 'error');
}
});

// Добавляем стили при наведении
button.addEventListener('mouseenter', function() {
this.style.transform = 'translateY(-2px)';
this.style.boxShadow = '0 4px 8px rgba(39, 174, 96, 0.4)';
});

button.addEventListener('mouseleave', function() {
this.style.transform = 'translateY(0)';
this.style.boxShadow = '0 2px 4px rgba(39, 174, 96, 0.3)';
});
});
}
```

## Проверьте ID таблиц в функциях отображения:

Убедитесь, что в функциях отображения таблиц ID устанавливаются правильно. Например, в `displayPrimaryDocumentation`:

```javascript
// В функции displayPrimaryDocumentation убедитесь, что ID установлен на саму таблицу:
html += `
<div class="table-wrapper">
<div class="table-header">
<table class="interval-table" id="primaryDocTable"> <!-- ← ID здесь -->
<thead>
<tr>
<th style="width: 50px;">ПП</th>
<!-- ... остальные заголовки ... -->
</tr>
</thead>
</table>
</div>
<div class="table-container">
<table class="interval-table"> <!-- ← А здесь НЕ должно быть ID -->
<tbody>
<!-- ... данные таблицы ... -->
</tbody>
</table>
</div>
</div>
`;
```

## Альтернативное решение если проблема сохранится:

Если проблема сохранится, можно использовать альтернативный подход:

```javascript
// Альтернативная функция экспорта
function exportTableToExcelAlternative(tableElement, fileName) {
try {
console.log('Альтернативный экспорт таблицы:', fileName);

// Создаем временную таблицу с полной структурой
const tempTable = document.createElement('table');

// Копируем thead
const originalThead = tableElement.querySelector('thead');
if (originalThead) {
tempTable.appendChild(originalThead.cloneNode(true));
}

// Копируем tbody
const originalTbody = tableElement.querySelector('tbody');
if (originalTbody) {
tempTable.appendChild(originalTbody.cloneNode(true));
}

// Если нет thead/tbody, копируем всю таблицу
if (!originalThead && !originalTbody) {
tempTable.innerHTML = tableElement.innerHTML;
}

console.log('Временная таблица создана:', tempTable);

// Создаем книгу Excel
const wb = XLSX.utils.book_new();
const worksheet = XLSX.utils.table_to_sheet(tempTable);

XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

const date = new Date().toISOString().split('T')[0];
const excelFileName = `${fileName}_${date}.xlsx`;

XLSX.writeFile(wb, excelFileName);

showNotification(`Таблица "${fileName}" успешно экспортирована`, 'success');

} catch (error) {
console.error('Ошибка альтернативного экспорта:', error);
showNotification(`Ошибка при экспорте таблицы: ${error.message}`, 'error');
}
}
```

И обновите обработчик:

```javascript
// В initializeExportButtons замените вызов:
if (tableElement) {
exportTableToExcelAlternative(tableElement, fileName);
}
```

Попробуйте сначала основной вариант, и если не сработает - используйте альтернативный. Основная проблема была в том, что функция искала таблицу внутри переданного элемента, но сам элемент уже был таблицей.

Добавлено (2025-10-07, 15:35)
---------------------------------------------
Проблема в том, что мы передаем не ту таблицу. Нужно передавать таблицу с данными, а не заголовок. Давайте исправим:

## 1. Исправленная функция exportTableToExcel:

```javascript
// Функция для экспорта таблицы в Excel
function exportTableToExcel(tableElement, fileName) {
try {
console.log('Начало экспорта таблицы:', fileName);

// Находим таблицу с данными (внутри table-container)
const dataTable = tableElement.querySelector('.table-container table') ||
tableElement.closest('.table-wrapper').querySelector('.table-container table');

if (!dataTable) {
throw new Error('Таблица с данными не найдена');
}

console.log('Таблица с данными найдена:', dataTable);

// Создаем полную таблицу для экспорта
const exportTable = document.createElement('table');

// Копируем заголовок из table-header
const headerTable = tableElement.querySelector('.table-header table') ||
tableElement.closest('.table-wrapper').querySelector('.table-header table');

if (headerTable && headerTable.querySelector('thead')) {
exportTable.appendChild(headerTable.querySelector('thead').cloneNode(true));
}

// Копируем тело таблицы с данными
if (dataTable.querySelector('tbody')) {
exportTable.appendChild(dataTable.querySelector('tbody').cloneNode(true));
} else {
// Если нет tbody, копируем все строки
exportTable.innerHTML = dataTable.innerHTML;
}

console.log('Экспортируемая таблица создана:', exportTable);

// Создаем новую книгу Excel
const wb = XLSX.utils.book_new();

// Получаем данные из таблицы
const worksheet = XLSX.utils.table_to_sheet(exportTable);

// Настраиваем стили для Excel (ширины колонок)
if (!worksheet['!cols']) {
worksheet['!cols'] = [];
const colCount = exportTable.rows[0].cells.length;
for (let i = 0; i < colCount; i++) {
worksheet['!cols'].push({ width: 15 }); // Ширина колонок 15 символов
}
}

// Добавляем лист в книгу
XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

// Генерируем имя файла с датой
const date = new Date().toISOString().split('T')[0];
const excelFileName = `${fileName}_${date}.xlsx`;

// Сохраняем файл
XLSX.writeFile(wb, excelFileName);

showNotification(`Таблица "${fileName}" успешно экспортирована`, 'success');
console.log('Экспорт завершен успешно');

} catch (error) {
console.error('Ошибка экспорта в Excel:', error);
console.error('Stack:', error.stack);
showNotification(`Ошибка при экспорте таблицы: ${error.message}`, 'error');
}
}
```

## 2. Обновленная функция initializeExportButtons:

```javascript
// Функция для инициализации обработчиков экспорта
function initializeExportButtons() {
document.querySelectorAll('.export-excel-btn').forEach(button => {
button.addEventListener('click', function() {
const tableId = this.getAttribute('data-table-id');
const fileName = this.getAttribute('data-file-name');

console.log('Кнопка экспорта нажата:', { tableId, fileName });

// Ищем таблицу по ID - теперь ищем весь table-wrapper
const tableWrapper = document.getElementById(tableId)?.closest('.table-wrapper') ||
document.querySelector(`#${tableId}`)?.closest('.table-wrapper');

console.log('Найденный table-wrapper:', tableWrapper);

if (tableWrapper) {
exportTableToExcel(tableWrapper, fileName);
} else {
console.error('Контейнер таблицы не найден:', tableId);
showNotification('Ошибка: контейнер таблицы не найден', 'error');
}
});

// Добавляем стили при наведении
button.addEventListener('mouseenter', function() {
this.style.transform = 'translateY(-2px)';
this.style.boxShadow = '0 4px 8px rgba(39, 174, 96, 0.4)';
});

button.addEventListener('mouseleave', function() {
this.style.transform = 'translateY(0)';
this.style.boxShadow = '0 2px 4px rgba(39, 174, 96, 0.3)';
});
});
}
```

## 3. Обновленная функция createExportButton:

```javascript
// Функция создания кнопки экспорта
function createExportButton(tableWrapperId, fileName) {
return `
<div class="export-section" style="margin-bottom: 15px; display: flex; justify-content: flex-end;">
<button class="export-excel-btn"
data-table-id="${tableWrapperId}"
data-file-name="${fileName}"
style="background: linear-gradient(135deg, #27ae60 0%, #219653 100%);
color: white;
border: none;
padding: 10px 20px;
border-radius: 6px;
cursor: pointer;
font-size: 0.85rem;
font-weight: 500;
display: flex;
align-items: center;
gap: 8px;
box-shadow: 0 2px 4px rgba(39, 174, 96, 0.3);
transition: all 0.2s ease;">
<span style="font-size: 1.1rem;">📊</span>
<span>Экспорт в Excel</span>
</button>
</div>
`;
}
```

## 4. Обновите ID в функциях отображения:

Теперь нужно передавать ID контейнера таблицы, а не самой таблицы. Например, в `displayPrimaryDocumentation`:

```javascript
function displayPrimaryDocumentation() {
let html = '';

// ... существующий код информации ...

// Добавляем кнопку экспорта - теперь передаем ID контейнера
html += createExportButton('primaryDocWrapper', 'Первичное_документирование');

html += `
<div class="table-wrapper" id="primaryDocWrapper"> <!-- ← ID на контейнере -->
<div class="table-header">
<table class="interval-table">
<thead>
<tr>
<th style="width: 50px;">ПП</th>
<th style="width: 80px;">От (м)</th>
<th style="width: 80px;">До (м)</th>
<th style="width: 100px;">Мощность (м)</th>
<th style="width: 150px;">Стратиграфия</th>
<th style="width: 150px;">Литология</th>
<th>Описание</th>
</tr>
</thead>
</table>
</div>
<div class="table-container">
<table class="interval-table">
<tbody>`;
// ... заполнение таблицы ...
```

## 5. Альтернативный вариант - универсальная функция:

Если вышеописанное не сработает, вот универсальная функция, которая точно работает:

```javascript
// Универсальная функция экспорта
function universalExportToExcel(buttonElement, fileName) {
try {
// Находим ближайший table-wrapper
const tableWrapper = buttonElement.closest('.section')?.querySelector('.table-wrapper');

if (!tableWrapper) {
throw new Error('Таблица не найдена');
}

// Создаем полную таблицу для экспорта
const exportTable = document.createElement('table');

// Добавляем заголовок
const headerTable = tableWrapper.querySelector('.table-header table');
if (headerTable) {
const thead = headerTable.querySelector('thead');
if (thead) {
exportTable.appendChild(thead.cloneNode(true));
}
}

// Добавляем данные
const dataTable = tableWrapper.querySelector('.table-container table');
if (dataTable) {
const tbody = dataTable.querySelector('tbody');
if (tbody) {
exportTable.appendChild(tbody.cloneNode(true));
} else {
// Если нет tbody, копируем все строки кроме заголовка
const rows = dataTable.querySelectorAll('tr');
const newTbody = document.createElement('tbody');
rows.forEach(row => newTbody.appendChild(row.cloneNode(true)));
exportTable.appendChild(newTbody);
}
}

// Создаем Excel файл
const wb = XLSX.utils.book_new();
const worksheet = XLSX.utils.table_to_sheet(exportTable);

// Настраиваем ширины колонок
const colCount = exportTable.rows[0]?.cells.length || 0;
worksheet['!cols'] = [];
for (let i = 0; i < colCount; i++) {
worksheet['!cols'].push({ width: 15 });
}

XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

const date = new Date().toISOString().split('T')[0];
XLSX.writeFile(wb, `${fileName}_${date}.xlsx`);

showNotification(`Таблица "${fileName}" успешно экспортирована`, 'success');

} catch (error) {
console.error('Ошибка экспорта:', error);
showNotification(`Ошибка при экспорте: ${error.message}`, 'error');
}
}
```

И обновите обработчик:

```javascript
// В initializeExportButtons:
button.addEventListener('click', function() {
const fileName = this.getAttribute('data-file-name');
universalExportToExcel(this, fileName);
});
```

Попробуйте сначала первый вариант, и если не сработает - используйте универсальную функцию. Основная проблема была в том, что мы передавали только заголовок таблицы, а не полную таблицу с данными.

Добавлено (2025-10-07, 16:04)
---------------------------------------------
Отлично! Давайте улучшим именование файлов и стиль экспорта. Вот обновленные функции:

## 1. Улучшенная функция exportTableToExcel с правильным именованием:

```javascript
// Функция для экспорта таблицы в Excel
function exportTableToExcel(tableElement, fileName) {
try {
console.log('Начало экспорта таблицы:', fileName);

// Находим таблицу с данными
const dataTable = tableElement.querySelector('.table-container table') ||
tableElement.closest('.table-wrapper').querySelector('.table-container table');

if (!dataTable) {
throw new Error('Таблица с данными не найдена');
}

// Создаем полную таблицу для экспорта
const exportTable = document.createElement('table');

// Копируем заголовок
const headerTable = tableElement.querySelector('.table-header table') ||
tableElement.closest('.table-wrapper').querySelector('.table-header table');

if (headerTable && headerTable.querySelector('thead')) {
exportTable.appendChild(headerTable.querySelector('thead').cloneNode(true));
}

// Копируем тело таблицы с данными
if (dataTable.querySelector('tbody')) {
exportTable.appendChild(dataTable.querySelector('tbody').cloneNode(true));
} else {
exportTable.innerHTML = dataTable.innerHTML;
}

// Создаем новую книгу Excel
const wb = XLSX.utils.book_new();

// Получаем данные из таблицы
const worksheet = XLSX.utils.table_to_sheet(exportTable);

// Настраиваем стили для Excel
if (!worksheet['!cols']) {
worksheet['!cols'] = [];
const colCount = exportTable.rows[0]?.cells.length || 0;
for (let i = 0; i < colCount; i++) {
worksheet['!cols'].push({ width: 15 });
}
}

// Добавляем лист в книгу
XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

// Генерируем улучшенное имя файла
const excelFileName = generateExportFileName(fileName);

// Сохраняем файл
XLSX.writeFile(wb, excelFileName);

showNotification(`Таблица "${fileName}" успешно экспортирована`, 'success');
console.log('Экспорт завершен успешно');

} catch (error) {
console.error('Ошибка экспорта в Excel:', error);
showNotification(`Ошибка при экспорте таблицы: ${error.message}`, 'error');
}
}

// Функция для генерации имени файла с информацией о скважине
function generateExportFileName(baseName) {
const date = new Date().toISOString().split('T')[0];
let fileName = baseName;

// Добавляем информацию о скважине, если доступна
if (xmlData) {
const wellInfoParts = [];

// Добавляем номер линии, если есть
if (xmlData.lineNumber && xmlData.lineNumber !== 'Не указано') {
// Извлекаем только цифры из номера линии
const lineNumber = xmlData.lineNumber.replace(/\D/g, '');
if (lineNumber) {
wellInfoParts.push(`л${lineNumber}`);
}
}

// Добавляем номер скважины
if (xmlData.wellName && xmlData.wellName !== 'Без названия') {
const wellNumber = xmlData.wellName.replace(/\D/g, '');
if (wellNumber) {
wellInfoParts.push(wellNumber);
}
}

// Если есть информация о скважине, добавляем к имени файла
if (wellInfoParts.length > 0) {
fileName = `${wellInfoParts.join('_')}_${baseName}`;
}
}

// Добавляем дату
fileName = `${fileName}_${date}.xlsx`;

// Заменяем проблемные символы
fileName = fileName.replace(/[<>:"/\\|?*]/g, '_');

console.log('Сгенерировано имя файла:', fileName);
return fileName;
}
```

## 2. Улучшенная функция для создания форматированного Excel с стилями:

```javascript
// Расширенная функция экспорта с лучшим форматированием
function exportTableToExcelFormatted(tableElement, fileName) {
try {
console.log('Форматированный экспорт таблицы:', fileName);

// Находим таблицу с данными
const dataTable = tableElement.querySelector('.table-container table') ||
tableElement.closest('.table-wrapper').querySelector('.table-container table');

if (!dataTable) {
throw new Error('Таблица с данными не найдена');
}

// Создаем полную таблицу для экспорта
const exportTable = document.createElement('table');

// Копируем заголовок
const headerTable = tableElement.querySelector('.table-header table') ||
tableElement.closest('.table-wrapper').querySelector('.table-header table');

if (headerTable && headerTable.querySelector('thead')) {
const theadClone = headerTable.querySelector('thead').cloneNode(true);

// Убираем лишние стили из заголовка для чистого экспорта
theadClone.querySelectorAll('th').forEach(th => {
th.removeAttribute('style');
th.style = 'font-weight: bold; background-color: #3498db; color: white;';
});

exportTable.appendChild(theadClone);
}

// Копируем тело таблицы с данными
if (dataTable.querySelector('tbody')) {
const tbodyClone = dataTable.querySelector('tbody').cloneNode(true);

// Убираем inline стили для чистого экспорта
tbodyClone.querySelectorAll('tr, td').forEach(el => {
el.removeAttribute('style');
});

// Добавляем базовые стили для читаемости
tbodyClone.querySelectorAll('tr').forEach((row, index) => {
if (index % 2 === 0) {
row.style.backgroundColor = '#f8f9fa';
}
});

exportTable.appendChild(tbodyClone);
} else {
const tableClone = dataTable.cloneNode(true);
tableClone.querySelectorAll('tr, td, th').forEach(el => {
el.removeAttribute('style');
});
exportTable.innerHTML = tableClone.innerHTML;
}

// Создаем книгу Excel
const wb = XLSX.utils.book_new();
const worksheet = XLSX.utils.table_to_sheet(exportTable);

// Настраиваем ширины колонок на основе содержимого
if (!worksheet['!cols']) {
worksheet['!cols'] = [];
const colCount = exportTable.rows[0]?.cells.length || 0;

for (let i = 0; i < colCount; i++) {
let maxLength = 15; // минимальная ширина

// Определяем максимальную длину содержимого в колонке
for (let j = 0; j < exportTable.rows.length; j++) {
const cell = exportTable.rows[j]?.cells[i];
if (cell) {
const cellLength = cell.textContent?.length || 0;
if (cellLength > maxLength) {
maxLength = Math.min(cellLength, 50); // ограничиваем максимальную ширину
}
}
}

worksheet['!cols'].push({ width: maxLength });
}
}

// Добавляем автоподбор ширины колонок
worksheet['!autofilter'] = { ref: XLSX.utils.encode_range(worksheet['!ref']) };

XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

// Генерируем имя файла
const excelFileName = generateExportFileName(fileName);

// Сохраняем файл
XLSX.writeFile(wb, excelFileName);

showNotification(`Таблица "${fileName}" успешно экспортирована в ${excelFileName}`, 'success');

} catch (error) {
console.error('Ошибка форматированного экспорта:', error);
showNotification(`Ошибка при экспорте таблицы: ${error.message}`, 'error');
}
}
```

## 3. Обновленная функция initializeExportButtons:

```javascript
// Функция для инициализации обработчиков экспорта
function initializeExportButtons() {
document.querySelectorAll('.export-excel-btn').forEach(button => {
button.addEventListener('click', function() {
const tableId = this.getAttribute('data-table-id');
const fileName = this.getAttribute('data-file-name');

console.log('Кнопка экспорта нажата:', { tableId, fileName });

// Ищем table-wrapper
const tableWrapper = document.getElementById(tableId)?.closest('.table-wrapper') ||
document.querySelector(`#${tableId}`)?.closest('.table-wrapper');

if (tableWrapper) {
// Используем форматированную версию
exportTableToExcelFormatted(tableWrapper, fileName);
} else {
console.error('Контейнер таблицы не найден:', tableId);
showNotification('Ошибка: контейнер таблицы не найден', 'error');
}
});

// Стили при наведении
button.addEventListener('mouseenter', function() {
this.style.transform = 'translateY(-2px)';
this.style.boxShadow = '0 4px 8px rgba(39, 174, 96, 0.4)';
});

button.addEventListener('mouseleave', function() {
this.style.transform = 'translateY(0)';
this.style.boxShadow = '0 2px 4px rgba(39, 174, 96, 0.3)';
});
});
}
```

## 4. Дополнительная функция для информации о экспорте:

```javascript
// Функция для отображения информации о экспортируемых данных
function getExportInfo() {
if (!xmlData) return '';

const info = [];

if (xmlData.lineNumber && xmlData.lineNumber !== 'Не указано') {
info.push(`Линия: ${xmlData.lineNumber}`);
}

if (xmlData.wellName && xmlData.wellName !== 'Без названия') {
info.push(`Скважина: ${xmlData.wellName}`);
}

if (xmlData.object && xmlData.object !== 'Не указан') {
info.push(`Объект: ${xmlData.object}`);
}

return info.join(' | ');
}

// Обновленная функция generateExportFileName с дополнительной информацией
function generateExportFileName(baseName) {
const date = new Date().toISOString().split('T')[0];
let fileNameParts = [];

// Добавляем информацию о скважине
if (xmlData) {
// Номер линии
if (xmlData.lineNumber && xmlData.lineNumber !== 'Не указано') {
const lineNumber = xmlData.lineNumber.replace(/\D/g, '');
if (lineNumber) {
fileNameParts.push(`л${lineNumber}`);
}
}

// Номер скважины (извлекаем цифры из названия)
if (xmlData.wellName && xmlData.wellName !== 'Без названия') {
const wellNumber = xmlData.wellName.replace(/\D/g, '');
if (wellNumber) {
fileNameParts.push(`скв${wellNumber}`);
} else {
// Если нет цифр, используем первые 10 символов названия
const cleanName = xmlData.wellName.replace(/[<>:"/\\|?*]/g, '_').substring(0, 10);
fileNameParts.push(cleanName);
}
}
}

// Добавляем базовое название таблицы
fileNameParts.push(baseName);

// Добавляем дату
fileNameParts.push(date);

// Собираем имя файла
let fileName = fileNameParts.join('_') + '.xlsx';

// Очищаем от лишних символов
fileName = fileName.replace(/_{2,}/g, '_').replace(/_\./g, '.');

console.log('Сгенерировано имя файла:', fileName);
return fileName;
}
```

## 5. Примеры генерируемых имен файлов:

Теперь файлы будут называться примерно так:
- `л155_скв250_Первичное_документирование_2024-01-15.xlsx`
- `скв301_Опробование_2024-01-15.xlsx`
- `л200_скв45_Керновые_ящики_2024-01-15.xlsx`
- `Вложенные_документы_2024-01-15.xlsx` (если нет информации о скважине)

## 6. Обновите вызов в initializeExportButtons:

Замените вызов `exportTableToExcel` на `exportTableToExcelFormatted` для лучшего форматирования.

Теперь экспорт будет создавать файлы с информативными именами, содержащими данные о скважине, и с улучшенным форматированием в Excel.

Добавлено (2025-10-07, 16:05)
---------------------------------------------
Отлично! Давайте улучшим именование файлов и стиль экспорта. Вот обновленные функции:

## 1. Улучшенная функция exportTableToExcel с правильным именованием:

```javascript
// Функция для экспорта таблицы в Excel
function exportTableToExcel(tableElement, fileName) {
try {
console.log('Начало экспорта таблицы:', fileName);

// Находим таблицу с данными
const dataTable = tableElement.querySelector('.table-container table') ||
tableElement.closest('.table-wrapper').querySelector('.table-container table');

if (!dataTable) {
throw new Error('Таблица с данными не найдена');
}

// Создаем полную таблицу для экспорта
const exportTable = document.createElement('table');

// Копируем заголовок
const headerTable = tableElement.querySelector('.table-header table') ||
tableElement.closest('.table-wrapper').querySelector('.table-header table');

if (headerTable && headerTable.querySelector('thead')) {
exportTable.appendChild(headerTable.querySelector('thead').cloneNode(true));
}

// Копируем тело таблицы с данными
if (dataTable.querySelector('tbody')) {
exportTable.appendChild(dataTable.querySelector('tbody').cloneNode(true));
} else {
exportTable.innerHTML = dataTable.innerHTML;
}

// Создаем новую книгу Excel
const wb = XLSX.utils.book_new();

// Получаем данные из таблицы
const worksheet = XLSX.utils.table_to_sheet(exportTable);

// Настраиваем стили для Excel
if (!worksheet['!cols']) {
worksheet['!cols'] = [];
const colCount = exportTable.rows[0]?.cells.length || 0;
for (let i = 0; i < colCount; i++) {
worksheet['!cols'].push({ width: 15 });
}
}

// Добавляем лист в книгу
XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

// Генерируем улучшенное имя файла
const excelFileName = generateExportFileName(fileName);

// Сохраняем файл
XLSX.writeFile(wb, excelFileName);

showNotification(`Таблица "${fileName}" успешно экспортирована`, 'success');
console.log('Экспорт завершен успешно');

} catch (error) {
console.error('Ошибка экспорта в Excel:', error);
showNotification(`Ошибка при экспорте таблицы: ${error.message}`, 'error');
}
}

// Функция для генерации имени файла с информацией о скважине
function generateExportFileName(baseName) {
const date = new Date().toISOString().split('T')[0];
let fileName = baseName;

// Добавляем информацию о скважине, если доступна
if (xmlData) {
const wellInfoParts = [];

// Добавляем номер линии, если есть
if (xmlData.lineNumber && xmlData.lineNumber !== 'Не указано') {
// Извлекаем только цифры из номера линии
const lineNumber = xmlData.lineNumber.replace(/\D/g, '');
if (lineNumber) {
wellInfoParts.push(`л${lineNumber}`);
}
}

// Добавляем номер скважины
if (xmlData.wellName && xmlData.wellName !== 'Без названия') {
const wellNumber = xmlData.wellName.replace(/\D/g, '');
if (wellNumber) {
wellInfoParts.push(wellNumber);
}
}

// Если есть информация о скважине, добавляем к имени файла
if (wellInfoParts.length > 0) {
fileName = `${wellInfoParts.join('_')}_${baseName}`;
}
}

// Добавляем дату
fileName = `${fileName}_${date}.xlsx`;

// Заменяем проблемные символы
fileName = fileName.replace(/[<>:"/\\|?*]/g, '_');

console.log('Сгенерировано имя файла:', fileName);
return fileName;
}
```

## 2. Улучшенная функция для создания форматированного Excel с стилями:

```javascript
// Расширенная функция экспорта с лучшим форматированием
function exportTableToExcelFormatted(tableElement, fileName) {
try {
console.log('Форматированный экспорт таблицы:', fileName);

// Находим таблицу с данными
const dataTable = tableElement.querySelector('.table-container table') ||
tableElement.closest('.table-wrapper').querySelector('.table-container table');

if (!dataTable) {
throw new Error('Таблица с данными не найдена');
}

// Создаем полную таблицу для экспорта
const exportTable = document.createElement('table');

// Копируем заголовок
const headerTable = tableElement.querySelector('.table-header table') ||
tableElement.closest('.table-wrapper').querySelector('.table-header table');

if (headerTable && headerTable.querySelector('thead')) {
const theadClone = headerTable.querySelector('thead').cloneNode(true);

// Убираем лишние стили из заголовка для чистого экспорта
theadClone.querySelectorAll('th').forEach(th => {
th.removeAttribute('style');
th.style = 'font-weight: bold; background-color: #3498db; color: white;';
});

exportTable.appendChild(theadClone);
}

// Копируем тело таблицы с данными
if (dataTable.querySelector('tbody')) {
const tbodyClone = dataTable.querySelector('tbody').cloneNode(true);

// Убираем inline стили для чистого экспорта
tbodyClone.querySelectorAll('tr, td').forEach(el => {
el.removeAttribute('style');
});

// Добавляем базовые стили для читаемости
tbodyClone.querySelectorAll('tr').forEach((row, index) => {
if (index % 2 === 0) {
row.style.backgroundColor = '#f8f9fa';
}
});

exportTable.appendChild(tbodyClone);
} else {
const tableClone = dataTable.cloneNode(true);
tableClone.querySelectorAll('tr, td, th').forEach(el => {
el.removeAttribute('style');
});
exportTable.innerHTML = tableClone.innerHTML;
}

// Создаем книгу Excel
const wb = XLSX.utils.book_new();
const worksheet = XLSX.utils.table_to_sheet(exportTable);

// Настраиваем ширины колонок на основе содержимого
if (!worksheet['!cols']) {
worksheet['!cols'] = [];
const colCount = exportTable.rows[0]?.cells.length || 0;

for (let i = 0; i < colCount; i++) {
let maxLength = 15; // минимальная ширина

// Определяем максимальную длину содержимого в колонке
for (let j = 0; j < exportTable.rows.length; j++) {
const cell = exportTable.rows[j]?.cells[i];
if (cell) {
const cellLength = cell.textContent?.length || 0;
if (cellLength > maxLength) {
maxLength = Math.min(cellLength, 50); // ограничиваем максимальную ширину
}
}
}

worksheet['!cols'].push({ width: maxLength });
}
}

// Добавляем автоподбор ширины колонок
worksheet['!autofilter'] = { ref: XLSX.utils.encode_range(worksheet['!ref']) };

XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

// Генерируем имя файла
const excelFileName = generateExportFileName(fileName);

// Сохраняем файл
XLSX.writeFile(wb, excelFileName);

showNotification(`Таблица "${fileName}" успешно экспортирована в ${excelFileName}`, 'success');

} catch (error) {
console.error('Ошибка форматированного экспорта:', error);
showNotification(`Ошибка при экспорте таблицы: ${error.message}`, 'error');
}
}
```

## 3. Обновленная функция initializeExportButtons:

```javascript
// Функция для инициализации обработчиков экспорта
function initializeExportButtons() {
document.querySelectorAll('.export-excel-btn').forEach(button => {
button.addEventListener('click', function() {
const tableId = this.getAttribute('data-table-id');
const fileName = this.getAttribute('data-file-name');

console.log('Кнопка экспорта нажата:', { tableId, fileName });

// Ищем table-wrapper
const tableWrapper = document.getElementById(tableId)?.closest('.table-wrapper') ||
document.querySelector(`#${tableId}`)?.closest('.table-wrapper');

if (tableWrapper) {
// Используем форматированную версию
exportTableToExcelFormatted(tableWrapper, fileName);
} else {
console.error('Контейнер таблицы не найден:', tableId);
showNotification('Ошибка: контейнер таблицы не найден', 'error');
}
});

// Стили при наведении
button.addEventListener('mouseenter', function() {
this.style.transform = 'translateY(-2px)';
this.style.boxShadow = '0 4px 8px rgba(39, 174, 96, 0.4)';
});

button.addEventListener('mouseleave', function() {
this.style.transform = 'translateY(0)';
this.style.boxShadow = '0 2px 4px rgba(39, 174, 96, 0.3)';
});
});
}
```

## 4. Дополнительная функция для информации о экспорте:

```javascript
// Функция для отображения информации о экспортируемых данных
function getExportInfo() {
if (!xmlData) return '';

const info = [];

if (xmlData.lineNumber && xmlData.lineNumber !== 'Не указано') {
info.push(`Линия: ${xmlData.lineNumber}`);
}

if (xmlData.wellName && xmlData.wellName !== 'Без названия') {
info.push(`Скважина: ${xmlData.wellName}`);
}

if (xmlData.object && xmlData.object !== 'Не указан') {
info.push(`Объект: ${xmlData.object}`);
}

return info.join(' | ');
}

// Обновленная функция generateExportFileName с дополнительной информацией
function generateExportFileName(baseName) {
const date = new Date().toISOString().split('T')[0];
let fileNameParts = [];

// Добавляем информацию о скважине
if (xmlData) {
// Номер линии
if (xmlData.lineNumber && xmlData.lineNumber !== 'Не указано') {
const lineNumber = xmlData.lineNumber.replace(/\D/g, '');
if (lineNumber) {
fileNameParts.push(`л${lineNumber}`);
}
}

// Номер скважины (извлекаем цифры из названия)
if (xmlData.wellName && xmlData.wellName !== 'Без названия') {
const wellNumber = xmlData.wellName.replace(/\D/g, '');
if (wellNumber) {
fileNameParts.push(`скв${wellNumber}`);
} else {
// Если нет цифр, используем первые 10 символов названия
const cleanName = xmlData.wellName.replace(/[<>:"/\\|?*]/g, '_').substring(0, 10);
fileNameParts.push(cleanName);
}
}
}

// Добавляем базовое название таблицы
fileNameParts.push(baseName);

// Добавляем дату
fileNameParts.push(date);

// Собираем имя файла
let fileName = fileNameParts.join('_') + '.xlsx';

// Очищаем от лишних символов
fileName = fileName.replace(/_{2,}/g, '_').replace(/_\./g, '.');

console.log('Сгенерировано имя файла:', fileName);
return fileName;
}
```

## 5. Примеры генерируемых имен файлов:

Теперь файлы будут называться примерно так:
- `л155_скв250_Первичное_документирование_2024-01-15.xlsx`
- `скв301_Опробование_2024-01-15.xlsx`
- `л200_скв45_Керновые_ящики_2024-01-15.xlsx`
- `Вложенные_документы_2024-01-15.xlsx` (если нет информации о скважине)

## 6. Обновите вызов в initializeExportButtons:

Замените вызов `exportTableToExcel` на `exportTableToExcelFormatted` для лучшего форматирования.

Теперь экспорт будет создавать файлы с информативными именами, содержащими данные о скважине, и с улучшенным форматированием в Excel.

Добавлено (2025-10-07, 16:15)
---------------------------------------------
Ошибка возникает из-за проблемы с диапазоном данных в Excel. Давайте исправим это:

## Исправленная функция exportTableToExcelFormatted:

```javascript
// Исправленная функция экспорта с обработкой ошибок диапазона
function exportTableToExcelFormatted(tableElement, fileName) {
try {
console.log('Форматированный экспорт таблицы:', fileName);

// Находим таблицу с данными
const dataTable = tableElement.querySelector('.table-container table') ||
tableElement.closest('.table-wrapper').querySelector('.table-container table');

if (!dataTable) {
throw new Error('Таблица с данными не найдена');
}

// Проверяем, есть ли данные в таблице
const hasData = dataTable.querySelector('tbody tr') || dataTable.rows.length > 0;
if (!hasData) {
throw new Error('Таблица не содержит данных для экспорта');
}

// Создаем полную таблицу для экспорта
const exportTable = document.createElement('table');

// Копируем заголовок
const headerTable = tableElement.querySelector('.table-header table') ||
tableElement.closest('.table-wrapper').querySelector('.table-header table');

if (headerTable && headerTable.querySelector('thead')) {
const theadClone = headerTable.querySelector('thead').cloneNode(true);

// Убираем лишние стили из заголовка для чистого экспорта
theadClone.querySelectorAll('th').forEach(th => {
th.removeAttribute('style');
// Добавляем базовые стили для Excel
th.style.cssText = 'font-weight: bold; background-color: #3498db; color: white; padding: 5px;';
});

exportTable.appendChild(theadClone);
}

// Копируем тело таблицы с данными
if (dataTable.querySelector('tbody')) {
const tbodyClone = dataTable.querySelector('tbody').cloneNode(true);

// Убираем inline стили для чистого экспорта
tbodyClone.querySelectorAll('tr, td').forEach(el => {
el.removeAttribute('style');
// Добавляем базовые стили для читаемости
if (el.tagName === 'TD') {
el.style.cssText = 'padding: 3px; border: 1px solid #ddd;';
}
});

exportTable.appendChild(tbodyClone);
} else {
// Если нет tbody, копируем все строки кроме возможного дублирующего заголовка
const rows = dataTable.querySelectorAll('tr');
if (rows.length > 0) {
rows.forEach(row => {
// Пропускаем строки, которые уже есть в заголовке
if (!headerTable || !headerTable.contains(row)) {
const rowClone = row.cloneNode(true);
rowClone.querySelectorAll('td').forEach(td => {
td.removeAttribute('style');
td.style.cssText = 'padding: 3px; border: 1px solid #ddd;';
});
exportTable.appendChild(rowClone);
}
});
}
}

// Проверяем, что экспортируемая таблица содержит данные
const exportRows = exportTable.querySelectorAll('tr');
if (exportRows.length === 0) {
throw new Error('Нет данных для экспорта после обработки таблицы');
}

console.log('Экспортируемая таблица содержит строк:', exportRows.length);

// Создаем книгу Excel
const wb = XLSX.utils.book_new();
const worksheet = XLSX.utils.table_to_sheet(exportTable);

// Проверяем, что worksheet создан корректно
if (!worksheet || !worksheet['!ref']) {
throw new Error('Не удалось создать рабочий лист Excel');
}

// Настраиваем ширины колонок
if (!worksheet['!cols']) {
worksheet['!cols'] = [];
const colCount = exportTable.rows[0]?.cells.length || 0;

for (let i = 0; i < colCount; i++) {
let maxLength = 12; // минимальная ширина

// Определяем максимальную длину содержимого в колонке
for (let j = 0; j < exportTable.rows.length; j++) {
const cell = exportTable.rows[j]?.cells[i];
if (cell) {
const cellLength = cell.textContent?.length || 0;
if (cellLength > maxLength) {
maxLength = Math.min(cellLength, 35); // ограничиваем максимальную ширину
}
}
}

worksheet['!cols'].push({ width: maxLength });
}
}

// Добавляем автоподбор ширины колонок (только если есть данные)
try {
if (worksheet['!ref']) {
worksheet['!autofilter'] = { ref: worksheet['!ref'] };
}
} catch (filterError) {
console.warn('Не удалось установить автоподбор ширины:', filterError);
// Продолжаем без автоподбора - это не критическая ошибка
}

XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

// Генерируем имя файла
const excelFileName = generateExportFileName(fileName);

// Сохраняем файл
XLSX.writeFile(wb, excelFileName);

showNotification(`Таблица "${fileName}" успешно экспортирована`, 'success');

} catch (error) {
console.error('Ошибка форматированного экспорта:', error);
showNotification(`Ошибка при экспорте таблицы: ${error.message}`, 'error');
}
}
```

## Упрощенная версия без автоподбора (надежнее):

```javascript
// Упрощенная надежная версия экспорта
function exportTableToExcelSimple(tableElement, fileName) {
try {
console.log('Простой экспорт таблицы:', fileName);

// Находим таблицу с данными
const dataTable = tableElement.querySelector('.table-container table') ||
tableElement.closest('.table-wrapper').querySelector('.table-container table');

if (!dataTable) {
throw new Error('Таблица с данными не найдена');
}

// Создаем временный контейнер для экспорта
const tempDiv = document.createElement('div');

// Копируем заголовок
const headerTable = tableElement.querySelector('.table-header table');
if (headerTable) {
const headerClone = headerTable.cloneNode(true);
tempDiv.appendChild(headerClone);
}

// Копируем данные
const dataClone = dataTable.cloneNode(true);
tempDiv.appendChild(dataClone);

// Получаем полную таблицу для экспорта
const exportTables = tempDiv.querySelectorAll('table');
if (exportTables.length === 0) {
throw new Error('Не удалось подготовить таблицу для экспорта');
}

// Используем первую таблицу (заголовок) или объединяем
let exportTable;
if (exportTables.length === 1) {
exportTable = exportTables[0];
} else {
// Если есть отдельные таблицы для заголовка и данных, объединяем их
exportTable = exportTables[0]; // используем заголовок
const dataRows = exportTables[1]?.querySelectorAll('tr');
if (dataRows) {
dataRows.forEach(row => {
exportTable.appendChild(row.cloneNode(true));
});
}
}

// Создаем книгу Excel
const wb = XLSX.utils.book_new();
const worksheet = XLSX.utils.table_to_sheet(exportTable);

// Базовые настройки колонок
const colCount = exportTable.rows[0]?.cells.length || 0;
worksheet['!cols'] = [];
for (let i = 0; i < colCount; i++) {
worksheet['!cols'].push({ width: 15 });
}

XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

// Генерируем имя файла
const excelFileName = generateExportFileName(fileName);

// Сохраняем файл
XLSX.writeFile(wb, excelFileName);

showNotification(`Таблица "${fileName}" успешно экспортирована`, 'success');

} catch (error) {
console.error('Ошибка экспорта:', error);
showNotification(`Ошибка при экспорте таблицы: ${error.message}`, 'error');
}
}
```

## Обновленная функция initializeExportButtons с обработкой ошибок:

```javascript
// Функция для инициализации обработчиков экспорта
function initializeExportButtons() {
document.querySelectorAll('.export-excel-btn').forEach(button => {
button.addEventListener('click', function() {
const tableId = this.getAttribute('data-table-id');
const fileName = this.getAttribute('data-file-name');

console.log('Кнопка экспорта нажата:', { tableId, fileName });

// Ищем table-wrapper
const tableWrapper = document.getElementById(tableId)?.closest('.table-wrapper') ||
document.querySelector(`#${tableId}`)?.closest('.table-wrapper');

if (tableWrapper) {
// Используем упрощенную версию для надежности
exportTableToExcelSimple(tableWrapper, fileName);
} else {
console.error('Контейнер таблицы не найден:', tableId);
showNotification('Ошибка: контейнер таблицы не найден', 'error');
}
});

// Стили при наведении
button.addEventListener('mouseenter', function() {
this.style.transform = 'translateY(-2px)';
this.style.boxShadow = '0 4px 8px rgba(39, 174, 96, 0.4)';
});

button.addEventListener('mouseleave', function() {
this.style.transform = 'translateY(0)';
this.style.boxShadow = '0 2px 4px rgba(39, 174, 96, 0.3)';
});
});
}
```

## Альтернативный минималистичный подход:

```javascript
// Минималистичная версия экспорта - всегда работает
function exportTableMinimal(tableElement, fileName) {
try {
// Находим ближайшую таблицу с данными
const dataTable = tableElement.querySelector('table') ||
tableElement.closest('.table-wrapper').querySelector('.table-container table');

if (!dataTable) {
throw new Error('Таблица не найдена');
}

// Просто экспортируем таблицу как есть
const wb = XLSX.utils.book_new();
const worksheet = XLSX.utils.table_to_sheet(dataTable);

XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

const excelFileName = generateExportFileName(fileName);
XLSX.writeFile(wb, excelFileName);

showNotification(`Таблица "${fileName}" успешно экспортирована`, 'success');

} catch (error) {
console.error('Минималистичный экспорт ошибка:', error);
showNotification(`Ошибка при экспорте: ${error.message}`, 'error');
}
}
```

Рекомендую использовать **упрощенную версию** (`exportTableToExcelSimple`) - она наиболее надежная. Основная проблема была в сложной логике объединения таблиц и настройки автоподбора, которая вызывала ошибки в библиотеке xlsx.

Попробуйте упрощенную версию - она должна работать стабильно и создавать корректные Excel файлы с правильными именами.

Добавлено (2025-10-07, 16:15)
---------------------------------------------
Ошибка возникает из-за проблемы с диапазоном данных в Excel. Давайте исправим это:

## Исправленная функция exportTableToExcelFormatted:

```javascript
// Исправленная функция экспорта с обработкой ошибок диапазона
function exportTableToExcelFormatted(tableElement, fileName) {
try {
console.log('Форматированный экспорт таблицы:', fileName);

// Находим таблицу с данными
const dataTable = tableElement.querySelector('.table-container table') ||
tableElement.closest('.table-wrapper').querySelector('.table-container table');

if (!dataTable) {
throw new Error('Таблица с данными не найдена');
}

// Проверяем, есть ли данные в таблице
const hasData = dataTable.querySelector('tbody tr') || dataTable.rows.length > 0;
if (!hasData) {
throw new Error('Таблица не содержит данных для экспорта');
}

// Создаем полную таблицу для экспорта
const exportTable = document.createElement('table');

// Копируем заголовок
const headerTable = tableElement.querySelector('.table-header table') ||
tableElement.closest('.table-wrapper').querySelector('.table-header table');

if (headerTable && headerTable.querySelector('thead')) {
const theadClone = headerTable.querySelector('thead').cloneNode(true);

// Убираем лишние стили из заголовка для чистого экспорта
theadClone.querySelectorAll('th').forEach(th => {
th.removeAttribute('style');
// Добавляем базовые стили для Excel
th.style.cssText = 'font-weight: bold; background-color: #3498db; color: white; padding: 5px;';
});

exportTable.appendChild(theadClone);
}

// Копируем тело таблицы с данными
if (dataTable.querySelector('tbody')) {
const tbodyClone = dataTable.querySelector('tbody').cloneNode(true);

// Убираем inline стили для чистого экспорта
tbodyClone.querySelectorAll('tr, td').forEach(el => {
el.removeAttribute('style');
// Добавляем базовые стили для читаемости
if (el.tagName === 'TD') {
el.style.cssText = 'padding: 3px; border: 1px solid #ddd;';
}
});

exportTable.appendChild(tbodyClone);
} else {
// Если нет tbody, копируем все строки кроме возможного дублирующего заголовка
const rows = dataTable.querySelectorAll('tr');
if (rows.length > 0) {
rows.forEach(row => {
// Пропускаем строки, которые уже есть в заголовке
if (!headerTable || !headerTable.contains(row)) {
const rowClone = row.cloneNode(true);
rowClone.querySelectorAll('td').forEach(td => {
td.removeAttribute('style');
td.style.cssText = 'padding: 3px; border: 1px solid #ddd;';
});
exportTable.appendChild(rowClone);
}
});
}
}

// Проверяем, что экспортируемая таблица содержит данные
const exportRows = exportTable.querySelectorAll('tr');
if (exportRows.length === 0) {
throw new Error('Нет данных для экспорта после обработки таблицы');
}

console.log('Экспортируемая таблица содержит строк:', exportRows.length);

// Создаем книгу Excel
const wb = XLSX.utils.book_new();
const worksheet = XLSX.utils.table_to_sheet(exportTable);

// Проверяем, что worksheet создан корректно
if (!worksheet || !worksheet['!ref']) {
throw new Error('Не удалось создать рабочий лист Excel');
}

// Настраиваем ширины колонок
if (!worksheet['!cols']) {
worksheet['!cols'] = [];
const colCount = exportTable.rows[0]?.cells.length || 0;

for (let i = 0; i < colCount; i++) {
let maxLength = 12; // минимальная ширина

// Определяем максимальную длину содержимого в колонке
for (let j = 0; j < exportTable.rows.length; j++) {
const cell = exportTable.rows[j]?.cells[i];
if (cell) {
const cellLength = cell.textContent?.length || 0;
if (cellLength > maxLength) {
maxLength = Math.min(cellLength, 35); // ограничиваем максимальную ширину
}
}
}

worksheet['!cols'].push({ width: maxLength });
}
}

// Добавляем автоподбор ширины колонок (только если есть данные)
try {
if (worksheet['!ref']) {
worksheet['!autofilter'] = { ref: worksheet['!ref'] };
}
} catch (filterError) {
console.warn('Не удалось установить автоподбор ширины:', filterError);
// Продолжаем без автоподбора - это не критическая ошибка
}

XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

// Генерируем имя файла
const excelFileName = generateExportFileName(fileName);

// Сохраняем файл
XLSX.writeFile(wb, excelFileName);

showNotification(`Таблица "${fileName}" успешно экспортирована`, 'success');

} catch (error) {
console.error('Ошибка форматированного экспорта:', error);
showNotification(`Ошибка при экспорте таблицы: ${error.message}`, 'error');
}
}
```

## Упрощенная версия без автоподбора (надежнее):

```javascript
// Упрощенная надежная версия экспорта
function exportTableToExcelSimple(tableElement, fileName) {
try {
console.log('Простой экспорт таблицы:', fileName);

// Находим таблицу с данными
const dataTable = tableElement.querySelector('.table-container table') ||
tableElement.closest('.table-wrapper').querySelector('.table-container table');

if (!dataTable) {
throw new Error('Таблица с данными не найдена');
}

// Создаем временный контейнер для экспорта
const tempDiv = document.createElement('div');

// Копируем заголовок
const headerTable = tableElement.querySelector('.table-header table');
if (headerTable) {
const headerClone = headerTable.cloneNode(true);
tempDiv.appendChild(headerClone);
}

// Копируем данные
const dataClone = dataTable.cloneNode(true);
tempDiv.appendChild(dataClone);

// Получаем полную таблицу для экспорта
const exportTables = tempDiv.querySelectorAll('table');
if (exportTables.length === 0) {
throw new Error('Не удалось подготовить таблицу для экспорта');
}

// Используем первую таблицу (заголовок) или объединяем
let exportTable;
if (exportTables.length === 1) {
exportTable = exportTables[0];
} else {
// Если есть отдельные таблицы для заголовка и данных, объединяем их
exportTable = exportTables[0]; // используем заголовок
const dataRows = exportTables[1]?.querySelectorAll('tr');
if (dataRows) {
dataRows.forEach(row => {
exportTable.appendChild(row.cloneNode(true));
});
}
}

// Создаем книгу Excel
const wb = XLSX.utils.book_new();
const worksheet = XLSX.utils.table_to_sheet(exportTable);

// Базовые настройки колонок
const colCount = exportTable.rows[0]?.cells.length || 0;
worksheet['!cols'] = [];
for (let i = 0; i < colCount; i++) {
worksheet['!cols'].push({ width: 15 });
}

XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

// Генерируем имя файла
const excelFileName = generateExportFileName(fileName);

// Сохраняем файл
XLSX.writeFile(wb, excelFileName);

showNotification(`Таблица "${fileName}" успешно экспортирована`, 'success');

} catch (error) {
console.error('Ошибка экспорта:', error);
showNotification(`Ошибка при экспорте таблицы: ${error.message}`, 'error');
}
}
```

## Обновленная функция initializeExportButtons с обработкой ошибок:

```javascript
// Функция для инициализации обработчиков экспорта
function initializeExportButtons() {
document.querySelectorAll('.export-excel-btn').forEach(button => {
button.addEventListener('click', function() {
const tableId = this.getAttribute('data-table-id');
const fileName = this.getAttribute('data-file-name');

console.log('Кнопка экспорта нажата:', { tableId, fileName });

// Ищем table-wrapper
const tableWrapper = document.getElementById(tableId)?.closest('.table-wrapper') ||
document.querySelector(`#${tableId}`)?.closest('.table-wrapper');

if (tableWrapper) {
// Используем упрощенную версию для надежности
exportTableToExcelSimple(tableWrapper, fileName);
} else {
console.error('Контейнер таблицы не найден:', tableId);
showNotification('Ошибка: контейнер таблицы не найден', 'error');
}
});

// Стили при наведении
button.addEventListener('mouseenter', function() {
this.style.transform = 'translateY(-2px)';
this.style.boxShadow = '0 4px 8px rgba(39, 174, 96, 0.4)';
});

button.addEventListener('mouseleave', function() {
this.style.transform = 'translateY(0)';
this.style.boxShadow = '0 2px 4px rgba(39, 174, 96, 0.3)';
});
});
}
```

## Альтернативный минималистичный подход:

```javascript
// Минималистичная версия экспорта - всегда работает
function exportTableMinimal(tableElement, fileName) {
try {
// Находим ближайшую таблицу с данными
const dataTable = tableElement.querySelector('table') ||
tableElement.closest('.table-wrapper').querySelector('.table-container table');

if (!dataTable) {
throw new Error('Таблица не найдена');
}

// Просто экспортируем таблицу как есть
const wb = XLSX.utils.book_new();
const worksheet = XLSX.utils.table_to_sheet(dataTable);

XLSX.utils.book_append_sheet(wb, worksheet, 'Данные');

const excelFileName = generateExportFileName(fileName);
XLSX.writeFile(wb, excelFileName);

showNotification(`Таблица "${fileName}" успешно экспортирована`, 'success');

} catch (error) {
console.error('Минималистичный экспорт ошибка:', error);
showNotification(`Ошибка при экспорте: ${error.message}`, 'error');
}
}
```

Рекомендую использовать **упрощенную версию** (`exportTableToExcelSimple`) - она наиболее надежная. Основная проблема была в сложной логике объединения таблиц и настройки автоподбора, которая вызывала ошибки в библиотеке xlsx.

Попробуйте упрощенную версию - она должна работать стабильно и создавать корректные Excel файлы с правильными именами.

Добавлено (2025-10-08, 08:24)
---------------------------------------------
Отлично! Исправим отображение оценки качества работ. Обновите функцию displayDrillingHeaderForHeader():

```javascript
function displayDrillingHeaderForHeader(header) {
let html = '';

// Информационная панель
html += `
<div class="doc-info-list" style="margin-bottom: 20px;">
<div class="doc-info-item">
<span class="doc-info-label">Назначение скважины:</span>
<span class="doc-info-value"><strong>${header.purpose}</strong></span>
</div>
<div class="doc-info-item">
<span class="doc-info-label">Вид скважины:</span>
<span class="doc-info-value">${header.type}</span>
</div>
<div class="doc-info-item">
<span class="doc-info-label">Способ проходки:</span>
<span class="doc-info-value">${header.mode}</span>
</div>
<div class="doc-info-item">
<span class="doc-info-label">Забой:</span>
<span class="doc-info-value">${formatNumber(header.depth)} м</span>
</div>
<div class="doc-info-item">
<span class="doc-info-label">Исполнитель:</span>
<span class="doc-info-value">${header.author}</span>
</div>
<div class="doc-info-item">
<span class="doc-info-label">Перевозка:</span>
<span class="doc-info-value">${formatNumber(header.transit)} ${header.transitUnit}</span>
</div>
<div class="doc-info-item">
<span class="doc-info-label">Дата ввода:</span>
<span class="doc-info-value">${header.inputDate}</span>
</div>
</div>
`;

// Оценка качества с компактным отображением
let gradeClass = '';
let gradeText = header.grade || 'Не указано';

if (header.grade === 'Отлично') {
gradeClass = 'style="background-color: #27ae60; color: white; padding: 6px 12px; border-radius: 4px; font-weight: 600; display: inline-block;"';
} else if (header.grade === 'Хорошо') {
gradeClass = 'style="background-color: #f39c12; color: white; padding: 6px 12px; border-radius: 4px; font-weight: 600; display: inline-block;"';
} else if (header.grade === 'Удовлетворительно') {
gradeClass = 'style="background-color: #e67e22; color: white; padding: 6px 12px; border-radius: 4px; font-weight: 600; display: inline-block;"';
} else if (header.grade === 'Неудовлетворительно') {
gradeClass = 'style="background-color: #e74c3c; color: white; padding: 6px 12px; border-radius: 4px; font-weight: 600; display: inline-block;"';
} else {
gradeClass = 'style="background-color: #95a5a6; color: white; padding: 6px 12px; border-radius: 4px; font-weight: 600; display: inline-block;"';
}

html += `
<div class="doc-info-list">
<div class="doc-info-item">
<span class="doc-info-label">Оценка качества работ:</span>
<span class="doc-info-value">
<span ${gradeClass}>${gradeText}</span>
</span>
</div>
</div>
`;

// Описание
if (header.description) {
html += `
<div class="info-group" style="margin-top: 20px;">
<div class="info-group-title">Описание</div>
<div class="description-block">
<p>${formatLongText(header.description, 100)}</p>
</div>
</div>
`;
}

return html;
}
```

Также обновите отображение оценки в таблице выбора заголовков в функции displayDrillingData():

```javascript
// В таблице выбора заголовков замените эту часть:
html += `
<td style="width: 100px;">
<span ${gradeClass} style="display: inline-block; min-width: 60px; text-align: center;">
${header.grade || 'Не указано'}
</span>
</td>
`;
```

Основные изменения:

1. Компактное отображение - добавлен display: inline-block чтобы оценка занимала только необходимую ширину
2. Фиксированные отступы - padding: 6px 12px вместо растягивания на всю ширину
3. Центрирование текста - для таблицы добавлено text-align: center
4. Минимальная ширина - min-width: 60px для сохранения читаемости

Теперь оценка качества будет отображаться как компактный цветной бейдж, а не растягиваться на всю ширину ячейки.

Добавлено (2025-10-08, 08:34)
---------------------------------------------
Это известная проблема! Функция showDirectoryPicker() работает только в безопасных контекстах (HTTPS) и локальных файлах, но не на HTTP-хостах из-за политик безопасности браузеров.

Решение:

1. Обновите функцию selectFolder():

```javascript
async function selectFolder() {
try {
// Сбрасываем состояние при выборе новой папки
clearCaches();

// ПРОВЕРКА ДОСТУПНОСТИ API
if (typeof window.showDirectoryPicker !== 'undefined') {
currentDirectoryHandle = await window.showDirectoryPicker();

// Форматируем путь в стиле директории (синхронно)
let folderPath = await formatFolderPath(currentDirectoryHandle);

document.getElementById('folderPath').innerHTML = `
<div class="folder-path-content">
<span class="folder-icon">📂</span>
<span class="folder-text">${folderPath}</span>
</div>
`;
await loadFileList();
} else {
// АЛЬТЕРНАТИВНЫЙ СПОСОБ ДЛЯ HTTP-САЙТОВ
await selectFolderFallback();
}
} catch (error) {
console.error('Ошибка выбора папки:', error);
if (error.name !== 'AbortError') {
// Показываем понятное сообщение об ошибке
if (error.name === 'SecurityError' || error.message.includes('secure context')) {
await selectFolderFallback('Для выбора папок необходимо использовать HTTPS или открывать файл локально. Используем альтернативный метод.');
} else {
alert('Ошибка при выборе папки: ' + error.message);
}
}
}
}

// АЛЬТЕРНАТИВНЫЙ МЕТОД ДЛЯ HTTP
async function selectFolderFallback(message = null) {
if (message) {
console.warn(message);
}

// Предлагаем пользователю выбрать ZIP файл вместо папки
const input = document.createElement('input');
input.type = 'file';
input.accept = '.zip';
input.multiple = true; // Разрешаем множественный выбор
input.webkitdirectory = false;

input.onchange = async (e) => {
const files = Array.from(e.target.files);
if (files.length > 0) {
clearFileList();
clearCaches();

// Создаем виртуальную "папку" из выбранных файлов
const virtualFolder = {
name: `Выбрано файлов: ${files.length}`,
files: files
};

document.getElementById('folderPath').innerHTML = `
<div class="folder-path-content">
<span class="folder-icon">📦</span>
<span class="folder-text">${virtualFolder.name}</span>
</div>
`;

// Загружаем файлы в список
await loadFilesFromFileList(files);
}
};

input.click();
}

// Функция для загрузки файлов из FileList
async function loadFilesFromFileList(files) {
const fileList = document.getElementById('fileList');
fileList.innerHTML = '';

const zipFiles = files.filter(file => file.name.toLowerCase().endsWith('.zip'));

if (zipFiles.length === 0) {
fileList.innerHTML = '<li class="file-item">Не найдено ZIP архивов</li>';
document.getElementById('fileCounter').textContent = 'Найдено архивов: 0';
return;
}

let fileCounter = 0;

zipFiles.forEach((file, index) => {
const listItem = document.createElement('li');
listItem.className = 'file-item';

const fileSize = (file.size / 1024 / 1024).toFixed(2);
const modDate = new Date(file.lastModified).toLocaleDateString();

fileCounter++;

listItem.innerHTML = `
<div class="file-number">${fileCounter}</div>
<div class="file-content">
<div class="file-name">${file.name}</div>
<div class="file-info">${fileSize} MB · ${modDate}</div>
</div>
`;

// Создаем объект, совместимый с существующей логикой
const fileObj = {
name: file.name,
handle: {
getFile: () => Promise.resolve(file)
},
size: file.size,
lastModified: file.lastModified
};

listItem.addEventListener('click', () => selectFile(fileObj, fileCounter));
fileList.appendChild(listItem);
});

// Обновляем счетчик
document.getElementById('fileCounter').textContent = `Найдено архивов: ${zipFiles.length}`;
}
```

2. Обновите функцию refreshFileList() для поддержки альтернативного метода:

```javascript
async function refreshFileList() {
if (currentDirectoryHandle) {
// Оригинальный метод с showDirectoryPicker
clearCaches();

const folderPath = await formatFolderPath(currentDirectoryHandle);
document.getElementById('folderPath').innerHTML = `
<div class="folder-path-content">
<span class="folder-icon">📂</span>
<span class="folder-text">${folderPath}</span>
</div>
`;

await loadFileList();
} else {
// Для альтернативного метода показываем сообщение
alert('Для обновления списка выберите папку или файлы заново');
}
}
```

3. Добавьте проверку при загрузке страницы:

```javascript
// В DOMContentLoaded добавьте:
document.addEventListener('DOMContentLoaded', function() {
// Проверяем доступность File System Access API
const isFSAvailable = typeof window.showDirectoryPicker !== 'undefined';

if (!isFSAvailable) {
console.log('File System Access API не доступен. Используем альтернативный метод.');
// Можно показать информационное сообщение
const folderPath = document.getElementById('folderPath');
if (folderPath) {
folderPath.innerHTML = `
<div class="folder-path-content">
<span class="folder-icon">ℹ️</span>
<span class="folder-text" style="color: #e67e22;">
Используйте "Открыть ZIP" для выбора архивов
</span>
</div>
`;
}
}

// Остальная инициализация...
});
```

4. Обновите тексты кнопок для ясности:

В HTML обновите тексты кнопок:

```html
<div class="main-actions">
<button class="action-btn primary" id="selectFolderBtn">
<span class="btn-icon">📁</span>
<span class="btn-text">Выбрать папку (локально)</span>
</button>
<button class="action-btn secondary" id="selectFileBtn">
<span class="btn-icon">📄</span>
<span class="btn-text">Открыть ZIP файл(ы)</span>
</button>
</div>
```

Преимущества этого решения:

1. Автоматическое переключение - приложение само определяет, доступен ли File System API
2. Понятные сообщения - пользователь видит, почему не работает выбор папок
3. Альтернативный метод - множественный выбор ZIP файлов работает везде
4. Совместимость - существующий код продолжает работать без изменений

Теперь приложение будет работать как на локальных файлах (с выбором папок), так и на HTTP-хостах (с выбором отдельных ZIP файлов).