1737 lines
81 KiB
TypeScript
1737 lines
81 KiB
TypeScript
import { useState, useMemo, useCallback, useEffect, useRef } from 'react';
|
||
import { Steps, Card, message, Row, Col, Space, Spin } from 'antd';
|
||
import Step1Phone from '../components/form/Step1Phone';
|
||
import StepDescription from '../components/form/StepDescription';
|
||
// Step1Policy убран - старый ERV флоу
|
||
import StepDraftSelection from '../components/form/StepDraftSelection';
|
||
import StepWizardPlan from '../components/form/StepWizardPlan';
|
||
import StepClaimConfirmation from '../components/form/StepClaimConfirmation';
|
||
// Step2EventType, StepDocumentUpload убраны - старый ERV флоу
|
||
// Step3Payment убран - не используется
|
||
import DebugPanel from '../components/DebugPanel';
|
||
// getDocumentsForEventType убран - старый ERV флоу
|
||
import './ClaimForm.css';
|
||
|
||
// Используем относительные пути - Vite proxy перенаправит на backend
|
||
|
||
const { Step } = Steps;
|
||
|
||
/**
|
||
* Генерация UUID v4
|
||
* Формат: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|
||
*/
|
||
function generateUUIDv4(): string {
|
||
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
|
||
const r = (Math.random() * 16) | 0;
|
||
const v = c === 'x' ? r : (r & 0x3) | 0x8;
|
||
return v.toString(16);
|
||
});
|
||
}
|
||
|
||
interface FormData {
|
||
// Шаг 1: Phone
|
||
phone?: string;
|
||
contact_id?: string;
|
||
unified_id?: string; // ✅ Unified ID пользователя из PostgreSQL
|
||
is_new_contact?: boolean;
|
||
smsCode?: string;
|
||
clientIp?: string;
|
||
smsDebugCode?: string;
|
||
|
||
// Шаг 2: Policy
|
||
voucher: string;
|
||
claim_id?: string;
|
||
session_id?: string;
|
||
project_id?: string; // ✅ ID проекта в vTiger (полис)
|
||
is_new_project?: boolean; // ✅ Флаг: создан новый проект
|
||
problemDescription?: string;
|
||
wizardPlan?: any;
|
||
wizardPlanStatus?: 'pending' | 'ready' | 'answered';
|
||
wizardAnswers?: Record<string, any>;
|
||
wizardPrefill?: Record<string, any>;
|
||
wizardPrefillArray?: Array<{ name: string; value: any }>;
|
||
wizardCoverageReport?: any;
|
||
wizardUploads?: Record<string, any>;
|
||
wizardSkippedDocuments?: string[];
|
||
|
||
// Подтверждение заявления (после получения данных из claim:plan)
|
||
showClaimConfirmation?: boolean;
|
||
claimPlanData?: any; // Данные заявления от n8n из канала claim:plan
|
||
|
||
// Шаг 3: Event Type
|
||
eventType?: string;
|
||
ticket_id?: string; // ✅ ID заявки в vTiger (HelpDesk)
|
||
ticket_number?: string; // ✅ Номер заявки (HD001234)
|
||
|
||
// Шаги 4+: Documents
|
||
documents?: Record<string, {
|
||
uploaded: boolean;
|
||
data: any;
|
||
file_type: string;
|
||
skipped?: boolean;
|
||
}>;
|
||
|
||
// Последний шаг: Payment
|
||
fullName?: string;
|
||
email?: string;
|
||
paymentMethod?: string;
|
||
bankId?: string; // ID банка из NSPK API
|
||
bankName?: string; // Название банка для отображения
|
||
cardNumber?: string;
|
||
accountNumber?: string;
|
||
}
|
||
|
||
export default function ClaimForm() {
|
||
// ✅ claim_id будет создан n8n в Step1Phone после SMS верификации
|
||
// Не генерируем его локально!
|
||
|
||
// session_id будет получен от n8n при создании контакта
|
||
// Используем useRef чтобы sessionId не вызывал перерендер и был стабильным
|
||
const sessionIdRef = useRef(`sess-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
|
||
const claimPlanEventSourceRef = useRef<EventSource | null>(null);
|
||
const claimPlanTimeoutRef = useRef<NodeJS.Timeout | null>(null);
|
||
|
||
const [currentStep, setCurrentStep] = useState(0);
|
||
const [sessionRestored, setSessionRestored] = useState(false); // Флаг: пытались восстановить сессию
|
||
const [formData, setFormData] = useState<FormData>({
|
||
voucher: '',
|
||
claim_id: undefined, // ✅ Будет заполнен n8n в Step1Phone
|
||
session_id: sessionIdRef.current,
|
||
paymentMethod: 'sbp',
|
||
});
|
||
const [isPhoneVerified, setIsPhoneVerified] = useState(false);
|
||
const [debugEvents, setDebugEvents] = useState<any[]>([]);
|
||
const [isSubmitted, setIsSubmitted] = useState(false);
|
||
const [showDraftSelection, setShowDraftSelection] = useState(false);
|
||
const [selectedDraftId, setSelectedDraftId] = useState<string | null>(null);
|
||
const [hasDrafts, setHasDrafts] = useState(false);
|
||
const [telegramAuthChecked, setTelegramAuthChecked] = useState(false);
|
||
/** Статус Telegram auth — показываем на странице, т.к. консоль Mini App отдельная */
|
||
const [tgDebug, setTgDebug] = useState<string>('');
|
||
/** Дефолт = веб. Скин TG подставляется только при заходе через Telegram Mini App. */
|
||
const [isTelegramMiniApp, setIsTelegramMiniApp] = useState(false);
|
||
/** Заход через MAX Mini App. */
|
||
const [isMaxMiniApp, setIsMaxMiniApp] = useState(false);
|
||
|
||
useEffect(() => {
|
||
// 🔥 VERSION CHECK: Если видишь это в консоли - фронт обновился!
|
||
console.log('🔥 ClaimForm v3.9 - 2025-12-29 - Auto redirect to drafts after success');
|
||
}, []);
|
||
|
||
// Определение: зашли с веба или из Telegram Mini App. Дефолт — веб; при TG вешаем класс для отдельного скина.
|
||
// Загружаем telegram-web-app.js только если есть признаки Telegram (чтобы не мусорить в консоли).
|
||
useEffect(() => {
|
||
const isTelegramContext = () => {
|
||
// Проверяем URL, referrer и user agent на признаки Telegram
|
||
const url = window.location.href;
|
||
const ref = document.referrer;
|
||
const ua = navigator.userAgent;
|
||
return (
|
||
url.includes('tgWebAppData') ||
|
||
url.includes('tgWebAppVersion') ||
|
||
ref.includes('telegram') ||
|
||
ua.includes('Telegram')
|
||
);
|
||
};
|
||
|
||
if (isTelegramContext()) {
|
||
// Загружаем скрипт Telegram SDK динамически
|
||
const script = document.createElement('script');
|
||
script.src = 'https://telegram.org/js/telegram-web-app.js';
|
||
script.async = true;
|
||
script.onload = () => {
|
||
setTimeout(() => {
|
||
const tg = (window as any).Telegram;
|
||
const webApp = tg?.WebApp;
|
||
const hasInitData = webApp?.initData && webApp.initData.length > 0;
|
||
if (webApp && hasInitData) {
|
||
setIsTelegramMiniApp(true);
|
||
try {
|
||
webApp.ready?.();
|
||
webApp.expand?.();
|
||
} catch (_) {}
|
||
}
|
||
}, 100);
|
||
};
|
||
document.head.appendChild(script);
|
||
}
|
||
}, []);
|
||
|
||
// ✅ Telegram Mini App: попытка авторизоваться через initData при первом заходе
|
||
useEffect(() => {
|
||
const tryTelegramAuth = async () => {
|
||
try {
|
||
// Только window: parent недоступен из-за cross-origin (iframe Telegram)
|
||
const getTg = () => (window as any).Telegram;
|
||
|
||
// Ждём появления initData: скрипт Telegram может подгрузиться с задержкой
|
||
const maxWaitMs = 2500;
|
||
const intervalMs = 150;
|
||
let webApp: TelegramWebApp | null = null;
|
||
let attempts = 0;
|
||
|
||
while (attempts * intervalMs < maxWaitMs) {
|
||
const tg = getTg();
|
||
webApp = tg?.WebApp ?? null;
|
||
if (webApp?.initData) {
|
||
console.log('[TG] initData появился через', attempts * intervalMs, 'ms, длина=', webApp.initData.length);
|
||
break;
|
||
}
|
||
attempts++;
|
||
await new Promise((r) => setTimeout(r, intervalMs));
|
||
}
|
||
|
||
if (!webApp?.initData) {
|
||
const tg = getTg();
|
||
console.log('[TG] После ожидания', maxWaitMs, 'ms: Telegram=', !!tg, 'WebApp=', !!tg?.WebApp, 'initData=', !!tg?.WebApp?.initData, '→ пропускаем tg/auth');
|
||
// Если Telegram не найден — пробуем MAX Mini App (window.WebApp от MAX Bridge)
|
||
let maxWebApp = (window as any).WebApp;
|
||
const maxWait = 4000;
|
||
for (let t = 0; t < maxWait; t += 200) {
|
||
await new Promise((r) => setTimeout(r, 200));
|
||
maxWebApp = (window as any).WebApp;
|
||
if (maxWebApp?.initData && maxWebApp.initData.length > 0) break;
|
||
}
|
||
if (maxWebApp?.initData && typeof maxWebApp.initData === 'string' && maxWebApp.initData.length > 0) {
|
||
const hasHash = maxWebApp.initData.includes('hash=');
|
||
console.log('[MAX] Обнаружен MAX WebApp, initData длина=', maxWebApp.initData.length, ', есть hash=', hasHash);
|
||
setIsMaxMiniApp(true);
|
||
try { maxWebApp.ready?.(); } catch (_) {}
|
||
const existingToken = localStorage.getItem('session_token');
|
||
if (existingToken) {
|
||
console.log('[MAX] session_token уже есть → max/auth не вызываем');
|
||
setTelegramAuthChecked(true);
|
||
return;
|
||
}
|
||
setTgDebug('MAX: POST /api/v1/max/auth...');
|
||
try {
|
||
const maxRes = await fetch('/api/v1/max/auth', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ init_data: maxWebApp.initData }),
|
||
});
|
||
const maxData = await maxRes.json();
|
||
if (maxData.need_contact) {
|
||
setTgDebug('MAX: Нужен контакт — закрываем приложение');
|
||
try { maxWebApp.close?.(); } catch (_) {}
|
||
setTelegramAuthChecked(true);
|
||
return;
|
||
}
|
||
if (maxRes.ok && maxData.success) {
|
||
if (maxData.session_token) {
|
||
localStorage.setItem('session_token', maxData.session_token);
|
||
sessionIdRef.current = maxData.session_token;
|
||
}
|
||
setFormData((prev) => ({
|
||
...prev,
|
||
unified_id: maxData.unified_id,
|
||
phone: maxData.phone,
|
||
contact_id: maxData.contact_id,
|
||
session_id: maxData.session_token,
|
||
}));
|
||
setIsPhoneVerified(true);
|
||
if (maxData.has_drafts) {
|
||
setShowDraftSelection(true);
|
||
setHasDrafts(true);
|
||
setCurrentStep(0);
|
||
} else {
|
||
setCurrentStep(1);
|
||
}
|
||
} else {
|
||
console.error('[MAX] max/auth ответ', maxRes.status, maxData);
|
||
}
|
||
} catch (e) {
|
||
console.error('[MAX] Ошибка max/auth:', e);
|
||
}
|
||
setTelegramAuthChecked(true);
|
||
return;
|
||
}
|
||
setTelegramAuthChecked(true);
|
||
return;
|
||
}
|
||
|
||
// Логирование для отладки
|
||
if (webApp.initDataUnsafe?.user) {
|
||
const u = webApp.initDataUnsafe.user;
|
||
console.log('[TG] initDataUnsafe.user:', { id: u.id, username: u.username, first_name: u.first_name });
|
||
}
|
||
|
||
// Если сессия уже есть в localStorage — ничего не делаем, дальше сработает обычное restoreSession
|
||
const existingToken = localStorage.getItem('session_token');
|
||
if (existingToken) {
|
||
setTgDebug('TG: session_token уже есть → tg/auth не вызываем');
|
||
console.log('[TG] session_token уже в localStorage → tg/auth не вызываем');
|
||
setTelegramAuthChecked(true);
|
||
return;
|
||
}
|
||
|
||
setTgDebug('TG: POST /api/v1/tg/auth...');
|
||
console.log('[TG] Вызываем POST /api/v1/tg/auth, initData длина=', webApp.initData.length);
|
||
|
||
const response = await fetch('/api/v1/tg/auth', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({
|
||
init_data: webApp.initData,
|
||
}),
|
||
});
|
||
|
||
const data = await response.json();
|
||
console.log('[TG] /api/v1/tg/auth ответ: status=', response.status, 'ok=', response.ok, 'data=', data);
|
||
|
||
if (!response.ok || !data.success) {
|
||
console.warn('[TG] Telegram auth не успешен → показываем экран телефона/SMS. detail=', data.detail || data);
|
||
setTelegramAuthChecked(true);
|
||
return;
|
||
}
|
||
|
||
const sessionToken = data.session_token;
|
||
|
||
// Сохраняем session_token так же, как после SMS-логина
|
||
if (sessionToken) {
|
||
localStorage.setItem('session_token', sessionToken);
|
||
sessionIdRef.current = sessionToken;
|
||
}
|
||
|
||
// Сохраняем базовые данные пользователя (phone может быть пустым)
|
||
setFormData((prev) => ({
|
||
...prev,
|
||
unified_id: data.unified_id,
|
||
phone: data.phone,
|
||
contact_id: data.contact_id,
|
||
session_id: sessionToken,
|
||
}));
|
||
|
||
// Помечаем телефон как уже "подтверждённый" для Telegram-флоу
|
||
setIsPhoneVerified(true);
|
||
|
||
// Если n8n сразу сообщил о наличии черновиков — показываем экран выбора
|
||
if (data.has_drafts) {
|
||
console.log('🤖 Telegram auth: has_drafts=true, переходим на экран черновиков');
|
||
setShowDraftSelection(true);
|
||
setHasDrafts(true);
|
||
setCurrentStep(0);
|
||
} else {
|
||
// Иначе переходим сразу к описанию проблемы
|
||
console.log('🤖 Telegram auth: черновиков нет, переходим к описанию проблемы');
|
||
setCurrentStep(1);
|
||
}
|
||
} catch (error) {
|
||
const msg = error instanceof Error ? error.message : String(error);
|
||
setTgDebug(`TG: ошибка: ${msg}`);
|
||
console.error('[TG] Ошибка при tg/auth (сеть или парсинг):', error);
|
||
} finally {
|
||
setTelegramAuthChecked(true);
|
||
}
|
||
};
|
||
|
||
tryTelegramAuth();
|
||
}, []);
|
||
|
||
// ✅ Восстановление сессии при загрузке страницы (после попытки Telegram auth)
|
||
useEffect(() => {
|
||
if (!telegramAuthChecked) {
|
||
// Ждём, пока не закончим попытку Telegram-авторизации,
|
||
// чтобы не гонять два параллельных restoreSession.
|
||
return;
|
||
}
|
||
|
||
const restoreSession = async () => {
|
||
console.log('🔑 🔑 🔑 НАЧАЛО ВОССТАНОВЛЕНИЯ СЕССИИ 🔑 🔑 🔑');
|
||
console.log('🔑 Все ключи в localStorage:', Object.keys(localStorage));
|
||
console.log('🔑 Значения всех ключей:', JSON.stringify(localStorage));
|
||
|
||
const savedSessionToken = localStorage.getItem('session_token');
|
||
|
||
if (!savedSessionToken) {
|
||
console.log('❌ Session token NOT found in localStorage');
|
||
setSessionRestored(true);
|
||
return;
|
||
}
|
||
|
||
console.log('✅ Found session_token in localStorage, verifying:', savedSessionToken);
|
||
addDebugEvent('session', 'info', '🔑 Проверка сохранённой сессии');
|
||
|
||
try {
|
||
const response = await fetch('/api/v1/session/verify', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ session_token: savedSessionToken })
|
||
});
|
||
|
||
if (!response.ok) {
|
||
throw new Error(`HTTP ${response.status}`);
|
||
}
|
||
|
||
const data = await response.json();
|
||
console.log('🔑 Session verify response:', data);
|
||
|
||
if (data.success && data.valid) {
|
||
// Сессия валидна! Восстанавливаем состояние
|
||
console.log('✅ Session valid! Restoring user data:', {
|
||
unified_id: data.unified_id,
|
||
phone: data.phone,
|
||
expires_in: data.expires_in_seconds
|
||
});
|
||
|
||
// Обновляем formData с данными сессии
|
||
updateFormData({
|
||
unified_id: data.unified_id,
|
||
phone: data.phone,
|
||
contact_id: data.contact_id,
|
||
session_id: savedSessionToken
|
||
});
|
||
|
||
// Устанавливаем session_id в ref
|
||
sessionIdRef.current = savedSessionToken;
|
||
|
||
// Помечаем телефон как верифицированный
|
||
setIsPhoneVerified(true);
|
||
|
||
// Проверяем черновики
|
||
const hasDraftsResult = await checkDrafts(data.unified_id, data.phone, savedSessionToken);
|
||
|
||
if (hasDraftsResult) {
|
||
// Есть черновики - показываем список
|
||
setShowDraftSelection(true);
|
||
setHasDrafts(true);
|
||
|
||
// Переходим к шагу выбора черновика
|
||
requestAnimationFrame(() => {
|
||
requestAnimationFrame(() => {
|
||
setCurrentStep(0);
|
||
});
|
||
});
|
||
|
||
message.success('Добро пожаловать!');
|
||
addDebugEvent('session', 'success', '✅ Сессия восстановлена, найдены черновики');
|
||
} else {
|
||
// Нет черновиков - переходим к описанию
|
||
setCurrentStep(1);
|
||
message.success('Добро пожаловать!');
|
||
addDebugEvent('session', 'success', '✅ Сессия восстановлена');
|
||
}
|
||
} else {
|
||
// Сессия невалидна - удаляем из localStorage
|
||
console.log('❌ Session invalid or expired, removing from localStorage');
|
||
localStorage.removeItem('session_token');
|
||
addDebugEvent('session', 'warning', '⚠️ Сессия истекла');
|
||
}
|
||
} catch (error) {
|
||
console.error('❌ Error verifying session:', error);
|
||
localStorage.removeItem('session_token');
|
||
addDebugEvent('session', 'error', '❌ Ошибка проверки сессии');
|
||
} finally {
|
||
setSessionRestored(true);
|
||
}
|
||
};
|
||
|
||
restoreSession();
|
||
}, [telegramAuthChecked]); // Запускаем только один раз, после попытки Telegram auth
|
||
|
||
// Получаем IP клиента один раз при монтировании
|
||
useEffect(() => {
|
||
const fetchClientIp = async () => {
|
||
try {
|
||
const response = await fetch('/api/v1/utils/client-ip');
|
||
if (!response.ok) return;
|
||
const data = await response.json();
|
||
if (data?.ip) {
|
||
setFormData((prev) => ({ ...prev, clientIp: data.ip }));
|
||
}
|
||
} catch {
|
||
// Тихо игнорируем, IP всегда можно взять на бэке из request
|
||
}
|
||
};
|
||
fetchClientIp();
|
||
}, []);
|
||
|
||
// Автоматический переход к шагу подтверждения, когда данные готовы
|
||
useEffect(() => {
|
||
if (formData.showClaimConfirmation && formData.claimPlanData) {
|
||
// Вычисляем индекс шага подтверждения динамически
|
||
// Шаг подтверждения добавляется после StepWizardPlan
|
||
// После выбора черновика showDraftSelection = false, поэтому:
|
||
// - Шаг 0 = Step1Phone
|
||
// - Шаг 1 = StepDescription
|
||
// - Шаг 2 = StepWizardPlan
|
||
// - Шаг 3 = StepClaimConfirmation (если showClaimConfirmation=true)
|
||
const confirmationStepIndex = 3; // Фиксированный индекс для шага подтверждения
|
||
|
||
console.log('✅ Данные заявления готовы, переходим к шагу подтверждения:', confirmationStepIndex);
|
||
setTimeout(() => {
|
||
setCurrentStep(confirmationStepIndex);
|
||
}, 100);
|
||
}
|
||
}, [formData.showClaimConfirmation, formData.claimPlanData]);
|
||
|
||
|
||
// Старый ERV флоу убран - documentConfigs больше не нужен
|
||
|
||
const addDebugEvent = (type: string, status: string, message: string, data?: any) => {
|
||
const event = {
|
||
timestamp: new Date().toLocaleTimeString('ru-RU'),
|
||
type,
|
||
status,
|
||
message,
|
||
data: {
|
||
...data,
|
||
claim_id: formData.claim_id // ✅ Используем claim_id из formData (от n8n)
|
||
}
|
||
};
|
||
setDebugEvents(prev => [event, ...prev]);
|
||
};
|
||
|
||
// ✅ claim_id будет залогирован в Step1Phone после получения от n8n
|
||
|
||
const updateFormData = useCallback((data: Partial<FormData>) => {
|
||
setFormData((prev) => ({ ...prev, ...data }));
|
||
}, []);
|
||
|
||
const nextStep = useCallback(() => {
|
||
console.log('⏩ nextStep called');
|
||
setCurrentStep((prev) => {
|
||
console.log('📍 Current step:', prev, '→ Next:', prev + 1);
|
||
return prev + 1;
|
||
});
|
||
}, []);
|
||
|
||
const prevStep = useCallback(() => {
|
||
console.log('⏪ prevStep called');
|
||
setCurrentStep((prev) => {
|
||
console.log('📍 Current step:', prev, '→ Prev:', prev - 1);
|
||
|
||
// ✅ Если возвращаемся к шагу 0 и есть черновики - показываем список
|
||
if (prev - 1 === 0 && formData.unified_id && hasDrafts) {
|
||
console.log('📍 Возврат к списку черновиков');
|
||
setShowDraftSelection(true);
|
||
setSelectedDraftId(null);
|
||
}
|
||
|
||
return prev - 1;
|
||
});
|
||
}, [formData.unified_id, hasDrafts]);
|
||
|
||
// ✅ Возврат к списку черновиков напрямую (без промежуточных шагов)
|
||
const backToDraftsList = useCallback(() => {
|
||
console.log('📋 Возврат к списку черновиков');
|
||
setShowDraftSelection(true);
|
||
setSelectedDraftId(null);
|
||
setCurrentStep(0);
|
||
}, []);
|
||
|
||
// Преобразование данных черновика в формат propertyName для формы подтверждения
|
||
const transformDraftToClaimPlanFormat = useCallback((data: {
|
||
claim: any;
|
||
payload: any;
|
||
body: any;
|
||
isTelegramFormat: boolean;
|
||
finalClaimId: string;
|
||
actualSessionId: string;
|
||
currentFormData: FormData;
|
||
}) => {
|
||
const { claim, payload, body, finalClaimId, actualSessionId, currentFormData } = data;
|
||
|
||
console.log('🔄 transformDraftToClaimPlanFormat: входные данные:', {
|
||
claimId: finalClaimId,
|
||
claimUnifiedId: claim.unified_id,
|
||
formDataUnifiedId: currentFormData.unified_id,
|
||
claimKeys: Object.keys(claim),
|
||
});
|
||
|
||
console.log('🔄 Данные из БД:', {
|
||
hasApplicantData: !!(body.applicant || payload.applicant),
|
||
hasCaseData: !!(body.case || payload.case),
|
||
hasContractData: !!(body.contract_or_service || payload.contract_or_service),
|
||
hasWizardAnswers: !!(body.answers || payload.answers || body.wizard_answers || payload.wizard_answers),
|
||
hasSendToFormApprove: !!(payload.send_to_form_approve && payload.send_to_form_approve.draft),
|
||
payloadKeys: Object.keys(payload),
|
||
bodyKeys: Object.keys(body),
|
||
});
|
||
|
||
// ✅ ПРИОРИТЕТ 1: Если есть данные в payload.send_to_form_approve.draft - используем их напрямую!
|
||
const sendToFormApproveDraft = payload.send_to_form_approve?.draft;
|
||
if (sendToFormApproveDraft) {
|
||
console.log('✅ Найдены данные в payload.send_to_form_approve.draft, используем их напрямую!');
|
||
console.log('✅ send_to_form_approve.draft:', sendToFormApproveDraft);
|
||
|
||
// Используем данные из send_to_form_approve.draft напрямую
|
||
const draftData = sendToFormApproveDraft;
|
||
|
||
// Формируем propertyName из draft данных
|
||
const propertyName = {
|
||
applicant: draftData.applicant || {},
|
||
case: draftData.case || {},
|
||
contract_or_service: draftData.contract_or_service || {},
|
||
offenders: draftData.offenders || [],
|
||
claim: draftData.claim || {},
|
||
meta: {
|
||
...(draftData.meta || {}),
|
||
claim_id: finalClaimId,
|
||
unified_id: draftData.meta?.unified_id || claim.unified_id || currentFormData.unified_id || null,
|
||
},
|
||
attachments: draftData.attachments || [],
|
||
attachments_count: draftData.attachments_count || 0,
|
||
attachments_names: draftData.attachments_names || [],
|
||
};
|
||
|
||
// Возвращаем данные в формате объекта (для компонента StepClaimConfirmation)
|
||
const result = {
|
||
propertyName: propertyName,
|
||
session_token: actualSessionId,
|
||
prefix: '',
|
||
telegram_id: null,
|
||
claim_id: finalClaimId,
|
||
unified_id: propertyName.meta.unified_id,
|
||
user_id: propertyName.meta.user_id || null,
|
||
};
|
||
|
||
console.log('🔄 transformDraftToClaimPlanFormat: результат из send_to_form_approve:', {
|
||
claim_id: result.claim_id,
|
||
unified_id: result.unified_id,
|
||
hasPropertyName: !!result.propertyName,
|
||
hasMeta: !!result.propertyName?.meta,
|
||
});
|
||
|
||
return result;
|
||
}
|
||
|
||
// ✅ ПРИОРИТЕТ 2: Если данных нет в send_to_form_approve, извлекаем из body/payload
|
||
// Извлекаем данные из body (telegram) или напрямую из payload (web_form)
|
||
const applicantData = body.applicant || payload.applicant || {};
|
||
const caseData = body.case || payload.case || {};
|
||
const contractData = body.contract_or_service || payload.contract_or_service || {};
|
||
const offendersData = body.offenders || payload.offenders || [];
|
||
const claimData = body.claim || payload.claim || {};
|
||
const metaData = body.meta || payload.meta || {};
|
||
const documentsMeta = body.documents_meta || payload.documents_meta || [];
|
||
|
||
// Извлекаем ответы на вопросы из wizard_answers
|
||
const wizardAnswers = body.answers || payload.answers || body.wizard_answers || payload.wizard_answers || {};
|
||
let answersParsed = wizardAnswers;
|
||
if (typeof wizardAnswers === 'string') {
|
||
try {
|
||
answersParsed = JSON.parse(wizardAnswers);
|
||
} catch (e) {
|
||
console.warn('⚠️ Не удалось распарсить answers:', e);
|
||
answersParsed = {};
|
||
}
|
||
}
|
||
|
||
console.log('🔄 wizard_answers parsed:', answersParsed);
|
||
|
||
// Преобразуем wizard_answers в формат propertyName, если данных нет в propertyName формате
|
||
// Маппинг полей из wizard_answers в propertyName структуру
|
||
const hasPropertyNameData = !!(applicantData.first_name || applicantData.last_name || caseData.category || contractData.subject);
|
||
|
||
if (!hasPropertyNameData && answersParsed && Object.keys(answersParsed).length > 0) {
|
||
console.log('🔄 Преобразуем wizard_answers в propertyName формат');
|
||
console.log('🔄 wizard_answers keys:', Object.keys(answersParsed));
|
||
|
||
// Маппинг полей из wizard_answers в contract_or_service
|
||
if (answersParsed.item && !contractData.subject) {
|
||
contractData.subject = answersParsed.item;
|
||
}
|
||
if (answersParsed.price && !contractData.amount_paid) {
|
||
// Нормализуем цену (убираем "рублей", пробелы и т.д.)
|
||
const priceStr = String(answersParsed.price).replace(/\s+/g, '').replace(/руб(лей|ль|\.)?/gi, '').replace(/₽|р\.|р$/gi, '');
|
||
contractData.amount_paid = priceStr;
|
||
contractData.amount_paid_fmt = priceStr;
|
||
}
|
||
if (answersParsed.place_date && !contractData.agreement_date) {
|
||
contractData.agreement_date = answersParsed.place_date;
|
||
contractData.agreement_date_fmt = answersParsed.place_date;
|
||
}
|
||
if (answersParsed.cancel_date && !contractData.period_start) {
|
||
contractData.period_start = answersParsed.cancel_date;
|
||
contractData.period_start_fmt = answersParsed.cancel_date;
|
||
}
|
||
|
||
// Маппинг полей из wizard_answers в claim
|
||
if (answersParsed.steps_taken && !claimData.description) {
|
||
claimData.description = answersParsed.steps_taken;
|
||
}
|
||
if (answersParsed.expectation && !claimData.reason) {
|
||
// expectation может быть "refund", "replacement", "compensation", "other"
|
||
claimData.reason = answersParsed.expectation === 'refund' ? 'consumer' : 'consumer';
|
||
}
|
||
|
||
// Маппинг в case
|
||
if (!caseData.category) {
|
||
caseData.category = 'consumer'; // По умолчанию consumer
|
||
}
|
||
if (!caseData.direction) {
|
||
caseData.direction = 'web_form';
|
||
}
|
||
|
||
// Если есть problem_description, используем его для claim.description
|
||
const problemDesc = payload.problem_description || body.problem_description;
|
||
if (problemDesc && !claimData.description) {
|
||
claimData.description = problemDesc;
|
||
}
|
||
if (problemDesc && !contractData.subject) {
|
||
contractData.subject = problemDesc;
|
||
}
|
||
}
|
||
|
||
// Данные заявителя берутся из других источников (phone, email из claim или formData)
|
||
// ФИО, дата рождения, ИНН будут заполняться в форме подтверждения
|
||
const applicantPhone = claim.phone || payload.phone || body.phone || currentFormData.phone || null;
|
||
const applicantEmail = claim.email || payload.email || body.email || currentFormData.email || null;
|
||
|
||
// Если есть данные заявителя в applicantData, используем их
|
||
if (!applicantData.phone && applicantPhone) {
|
||
applicantData.phone = applicantPhone;
|
||
}
|
||
if (!applicantData.email && applicantEmail) {
|
||
applicantData.email = applicantEmail;
|
||
}
|
||
|
||
// Формируем attachments_names из documents_meta
|
||
const attachmentsNames = documentsMeta.map((doc: any) => {
|
||
return doc.original_file_name || doc.file_name || doc.field_name || 'Документ';
|
||
});
|
||
|
||
// Формируем attachments с полной информацией
|
||
const attachments = documentsMeta.map((doc: any) => ({
|
||
label: doc.field_label || doc.original_file_name || doc.file_name || doc.field_name || 'Документ', // ✅ Используем field_label
|
||
field_label: doc.field_label || doc.field_name || doc.original_file_name || doc.file_name || 'Документ', // ✅ Добавляем field_label отдельно
|
||
url: doc.file_id ? `https://s3.twcstorage.ru${doc.file_id}` : '',
|
||
file_id: doc.file_id || '',
|
||
stored_file_name: doc.file_name || '',
|
||
original_file_name: doc.original_file_name || doc.file_name || '',
|
||
field_name: doc.field_name || '',
|
||
uploaded_at: doc.uploaded_at || new Date().toISOString(),
|
||
}));
|
||
|
||
// Формируем propertyName в нужном формате
|
||
const propertyName = {
|
||
applicant: {
|
||
first_name: applicantData.first_name || null,
|
||
middle_name: applicantData.middle_name || null,
|
||
last_name: applicantData.last_name || null,
|
||
full_name: applicantData.full_name || null,
|
||
birth_date: applicantData.birth_date || null,
|
||
birth_date_fmt: applicantData.birth_date_fmt || null,
|
||
birth_place: applicantData.birth_place || null,
|
||
inn: applicantData.inn || null,
|
||
address: applicantData.address || null,
|
||
phone: claim.phone || payload.phone || body.phone || currentFormData.phone || null,
|
||
email: claim.email || payload.email || body.email || currentFormData.email || null,
|
||
},
|
||
case: {
|
||
category: caseData.category || payload.case_type || 'consumer',
|
||
direction: caseData.direction || 'web_form',
|
||
country: caseData.country || null,
|
||
},
|
||
contract_or_service: {
|
||
agreement_date: contractData.agreement_date || null,
|
||
agreement_date_fmt: contractData.agreement_date_fmt || null,
|
||
amount_paid: contractData.amount_paid || null,
|
||
amount_paid_fmt: contractData.amount_paid_fmt || null,
|
||
subject: contractData.subject || payload.problem_description || body.problem_description || null,
|
||
period_start: contractData.period_start || null,
|
||
period_start_fmt: contractData.period_start_fmt || null,
|
||
period_end: contractData.period_end || null,
|
||
period_end_fmt: contractData.period_end_fmt || null,
|
||
period_text: contractData.period_text || null,
|
||
},
|
||
offenders: offendersData.length > 0 ? offendersData : [],
|
||
claim: {
|
||
reason: claimData.reason || caseData.category || 'consumer',
|
||
description: claimData.description || payload.problem_description || body.problem_description || null,
|
||
},
|
||
meta: {
|
||
claim_id: finalClaimId,
|
||
unified_id: claim.unified_id || currentFormData.unified_id || null,
|
||
status: claim.status_code || 'draft',
|
||
created_at: claim.created_at || new Date().toISOString(),
|
||
updated_at: claim.updated_at || new Date().toISOString(),
|
||
user_id: metaData.user_id || null,
|
||
},
|
||
attachments: attachments,
|
||
attachments_count: attachments.length,
|
||
attachments_names: attachmentsNames,
|
||
};
|
||
|
||
// Возвращаем данные в формате объекта (для компонента StepClaimConfirmation)
|
||
const result = {
|
||
propertyName: propertyName,
|
||
session_token: actualSessionId,
|
||
prefix: '',
|
||
telegram_id: null,
|
||
claim_id: finalClaimId,
|
||
unified_id: claim.unified_id || currentFormData.unified_id || null,
|
||
user_id: metaData.user_id || null,
|
||
};
|
||
|
||
console.log('🔄 transformDraftToClaimPlanFormat: результат:', {
|
||
claim_id: result.claim_id,
|
||
unified_id: result.unified_id,
|
||
hasPropertyName: !!result.propertyName,
|
||
hasMeta: !!result.propertyName?.meta,
|
||
});
|
||
|
||
return result;
|
||
}, []);
|
||
|
||
// Загрузка черновика
|
||
const loadDraft = useCallback(async (claimId: string) => {
|
||
try {
|
||
console.log('🔍 Загрузка черновика с ID:', claimId);
|
||
const url = `/api/v1/claims/drafts/${claimId}`;
|
||
console.log('🔍 URL запроса:', url);
|
||
|
||
const response = await fetch(url);
|
||
console.log('🔍 Статус ответа:', response.status, response.statusText);
|
||
|
||
if (!response.ok) {
|
||
const errorText = await response.text();
|
||
console.error('❌ Ошибка загрузки черновика:', response.status, errorText);
|
||
throw new Error(`Не удалось загрузить черновик: ${response.status} ${errorText}`);
|
||
}
|
||
|
||
const data = await response.json();
|
||
console.log('🔍 Данные черновика загружены:', data);
|
||
const claim = data.claim;
|
||
const payload = claim.payload || {};
|
||
|
||
// ✅ Сохраняем флаги подтверждения данных контакта
|
||
const contact_data_confirmed = data.contact_data_confirmed || false;
|
||
const contact_data_can_edit = data.contact_data_can_edit !== false; // По умолчанию true
|
||
const contact_data_confirmed_at = data.contact_data_confirmed_at || null;
|
||
const contact_data_from_crm = data.contact_data_from_crm || null;
|
||
|
||
console.log('🔒 Статус данных контакта:', {
|
||
contact_data_confirmed,
|
||
contact_data_can_edit,
|
||
contact_data_confirmed_at,
|
||
has_crm_data: !!contact_data_from_crm
|
||
});
|
||
|
||
// ✅ Для telegram черновиков данные могут быть в payload.body
|
||
const body = payload.body || {};
|
||
const isTelegramFormat = !!payload.body;
|
||
|
||
console.log('🔍 Claim объект:', claim);
|
||
console.log('🔍 claim.claim_id:', claim.claim_id);
|
||
console.log('🔍 claim.id:', claim.id);
|
||
console.log('🔍 claim.unified_id:', claim.unified_id);
|
||
console.log('🔍 Payload черновика:', payload);
|
||
console.log('🔍 payload.body:', body);
|
||
console.log('🔍 Формат:', isTelegramFormat ? 'telegram (body)' : 'web_form (прямой)');
|
||
|
||
// ✅ Извлекаем данные из body (telegram) или напрямую из payload (web_form)
|
||
const wizardPlanRaw = body.wizard_plan || payload.wizard_plan;
|
||
const answersRaw = body.answers || payload.answers;
|
||
// Ищем problem_description в разных местах (может быть в разных форматах)
|
||
const problemDescription =
|
||
body.problem_description ||
|
||
payload.problem_description ||
|
||
body.description ||
|
||
payload.description ||
|
||
payload.body?.problem_description || // Для вложенных структур
|
||
payload.body?.description ||
|
||
null;
|
||
const documentsMeta = body.documents_meta || payload.documents_meta || [];
|
||
|
||
// ✅ Парсим wizard_plan и answers, если они строки (JSON)
|
||
let wizardPlan = wizardPlanRaw;
|
||
if (typeof wizardPlanRaw === 'string') {
|
||
try {
|
||
wizardPlan = JSON.parse(wizardPlanRaw);
|
||
} catch (e) {
|
||
console.warn('⚠️ Не удалось распарсить wizard_plan:', e);
|
||
}
|
||
}
|
||
|
||
let answers = answersRaw;
|
||
if (typeof answersRaw === 'string') {
|
||
try {
|
||
answers = JSON.parse(answersRaw);
|
||
} catch (e) {
|
||
console.warn('⚠️ Не удалось распарсить answers:', e);
|
||
}
|
||
}
|
||
|
||
// ✅ Проверяем, заполнены ли все шаги
|
||
// Для problem_description: если его нет в payload, но есть wizard_plan и answers,
|
||
// значит описание уже было введено ранее (wizard_plan генерируется на основе описания)
|
||
const hasDescription = !!problemDescription || (!!wizardPlan && !!answers); // Если есть план и ответы - описание было
|
||
const hasWizardPlan = !!wizardPlan;
|
||
const hasAnswers = !!answers && Object.keys(answers).length > 0;
|
||
const hasDocuments = Array.isArray(documentsMeta) && documentsMeta.length > 0;
|
||
const isDraft = claim.status_code === 'draft';
|
||
|
||
// ✅ Запрещаем редактирование заявок "В работе"
|
||
if (claim.status_code === 'in_work') {
|
||
message.warning('Эта заявка уже в работе и не может быть изменена');
|
||
console.log('⚠️ Попытка открыть заявку "В работе" для редактирования - запрещено');
|
||
return;
|
||
}
|
||
|
||
// ✅ НОВОЕ: Проверяем наличие form_draft (собранные данные из RAG)
|
||
const formDraft = payload.form_draft;
|
||
const hasFormDraft = !!(formDraft && formDraft.user && formDraft.offenders);
|
||
const isDraftDocsComplete = claim.status_code === 'draft_docs_complete';
|
||
|
||
const allStepsFilled = hasDescription && hasWizardPlan && hasAnswers && hasDocuments;
|
||
const isReadyForConfirmation = (allStepsFilled && isDraft) || (hasFormDraft && isDraftDocsComplete);
|
||
|
||
console.log('🔍 Проверка полноты черновика:', {
|
||
hasDescription,
|
||
hasWizardPlan,
|
||
hasAnswers,
|
||
hasDocuments,
|
||
isDraft,
|
||
hasFormDraft,
|
||
isDraftDocsComplete,
|
||
allStepsFilled,
|
||
isReadyForConfirmation,
|
||
problemDescriptionFound: !!problemDescription,
|
||
inferredFromPlan: !problemDescription && !!wizardPlan && !!answers,
|
||
});
|
||
|
||
console.log('🔍 problem_description:', problemDescription ? 'есть' : (wizardPlan && answers ? 'выведено из наличия плана и ответов' : 'нет'));
|
||
console.log('🔍 wizard_plan:', wizardPlan ? 'есть' : 'нет');
|
||
console.log('🔍 answers:', answers ? 'есть' : 'нет');
|
||
console.log('🔍 documents_meta:', documentsMeta.length, 'документов');
|
||
console.log('🔍 Все ключи payload:', Object.keys(payload));
|
||
if (isTelegramFormat) {
|
||
console.log('🔍 Все ключи body:', Object.keys(body));
|
||
}
|
||
|
||
// ✅ Извлекаем claim_id из разных возможных мест
|
||
const finalClaimId = claim.claim_id || payload.claim_id || body.claim_id || claim.id || formData.claim_id || claimId;
|
||
console.log('🔍 Извлечённый claim_id:', finalClaimId);
|
||
|
||
// Восстанавливаем данные формы из черновика
|
||
console.log('🔄 Загрузка черновика: session_id из черновика:', claim.session_token);
|
||
console.log('🔄 Загрузка черновика: текущий sessionIdRef.current:', sessionIdRef.current);
|
||
console.log('🔄 Загрузка черновика: текущий formData.session_id:', formData.session_id);
|
||
|
||
// ✅ При загрузке черновика используем session_id из черновика (для продолжения работы с той же жалобой)
|
||
// Если session_id из черновика есть - используем его, иначе текущий
|
||
const actualSessionId = claim.session_token || sessionIdRef.current || formData.session_id;
|
||
console.log('🔄 Загрузка черновика: ИСПОЛЬЗУЕМ session_id:', actualSessionId);
|
||
|
||
// ✅ Обновляем sessionIdRef на сессию из черновика (если есть)
|
||
if (claim.session_token && claim.session_token !== sessionIdRef.current) {
|
||
sessionIdRef.current = claim.session_token;
|
||
console.log('🔄 Обновляем sessionIdRef на сессию из черновика:', claim.session_token);
|
||
}
|
||
|
||
// ✅ НОВЫЙ ФЛОУ: Извлекаем documents_required из payload
|
||
const documentsRequired = body.documents_required || payload.documents_required || [];
|
||
const documentsUploaded = body.documents_uploaded || payload.documents_uploaded || [];
|
||
const documentsSkipped = body.documents_skipped || payload.documents_skipped || [];
|
||
const currentDocIndex = body.current_doc_index ?? payload.current_doc_index ?? 0;
|
||
|
||
console.log('📋 Загрузка черновика - documents_required:', documentsRequired.length, 'шт.');
|
||
console.log('📋 Загрузка черновика - body.documents_required:', body.documents_required);
|
||
console.log('📋 Загрузка черновика - payload.documents_required:', payload.documents_required);
|
||
console.log('📋 Загрузка черновика - status_code:', claim.status_code);
|
||
console.log('📋 Загрузка черновика - все ключи payload:', Object.keys(payload));
|
||
|
||
updateFormData({
|
||
claim_id: finalClaimId, // ✅ Используем извлечённый claim_id
|
||
session_id: actualSessionId, // ✅ Используем session_id из черновика (если есть) или текущий
|
||
phone: body.phone || payload.phone || formData.phone,
|
||
email: body.email || payload.email || formData.email,
|
||
problemDescription: problemDescription || formData.problemDescription,
|
||
wizardPlan: wizardPlan || formData.wizardPlan,
|
||
wizardPlanStatus: wizardPlan ? (answers ? 'answered' : 'ready') : 'pending', // ✅ Устанавливаем статус
|
||
wizardAnswers: answers || formData.wizardAnswers,
|
||
wizardPrefill: (body.answers_prefill || payload.answers_prefill) ?
|
||
(body.answers_prefill || payload.answers_prefill).reduce((acc: any, item: any) => {
|
||
acc[item.name] = item.value;
|
||
return acc;
|
||
}, {}) : formData.wizardPrefill,
|
||
wizardPrefillArray: body.answers_prefill || payload.answers_prefill || formData.wizardPrefillArray,
|
||
wizardCoverageReport: body.coverage_report || payload.coverage_report || formData.wizardCoverageReport,
|
||
wizardUploads: {
|
||
documents: (body.documents_meta || payload.documents_meta) ? {} : formData.wizardUploads?.documents,
|
||
custom: formData.wizardUploads?.custom || [],
|
||
},
|
||
wizardSkippedDocuments: body.wizard_skipped_documents || payload.wizard_skipped_documents || formData.wizardSkippedDocuments,
|
||
eventType: body.event_type || payload.event_type || formData.eventType,
|
||
contact_id: body.contact_id || payload.contact_id || formData.contact_id,
|
||
project_id: body.project_id || payload.project_id || formData.project_id,
|
||
unified_id: formData.unified_id, // ✅ Сохраняем unified_id
|
||
// ✅ НОВЫЙ ФЛОУ: Документы
|
||
documents_required: documentsRequired,
|
||
documents_uploaded: documentsUploaded,
|
||
documents_skipped: documentsSkipped,
|
||
current_doc_index: currentDocIndex,
|
||
});
|
||
|
||
setSelectedDraftId(finalClaimId);
|
||
setShowDraftSelection(false);
|
||
|
||
// ✅ Если все шаги заполнены и статус = draft → переходим к форме подтверждения
|
||
if (isReadyForConfirmation) {
|
||
console.log('✅ Все шаги заполнены, преобразуем данные для формы подтверждения');
|
||
console.log('✅ hasFormDraft:', hasFormDraft, 'isDraftDocsComplete:', isDraftDocsComplete);
|
||
|
||
setIsPhoneVerified(true);
|
||
|
||
let claimPlanData;
|
||
|
||
// ✅ НОВОЕ: Если есть form_draft — используем его!
|
||
if (hasFormDraft && formDraft) {
|
||
console.log('✅ Используем form_draft из БД:', formDraft);
|
||
console.log('✅ project.description:', formDraft.project?.description);
|
||
console.log('✅ offenders:', formDraft.offenders);
|
||
console.log('✅ documentsMeta:', documentsMeta);
|
||
console.log('✅ documentsMeta[0]?.field_label:', documentsMeta[0]?.field_label);
|
||
|
||
const user = formDraft.user || {};
|
||
const project = formDraft.project || {};
|
||
|
||
// Преобразуем form_draft в формат propertyName (с правильными именами полей!)
|
||
claimPlanData = {
|
||
propertyName: {
|
||
applicant: {
|
||
// Маппинг полей user → applicant
|
||
first_name: user.firstname || '',
|
||
middle_name: user.secondname || '',
|
||
last_name: user.lastname || '',
|
||
phone: user.mobile || '',
|
||
email: user.email || '',
|
||
birth_date: user.birthday || '',
|
||
birth_place: user.birthplace || '',
|
||
address: user.mailingstreet || '',
|
||
inn: user.inn || '',
|
||
},
|
||
case: {
|
||
category: project.category || '',
|
||
direction: project.direction || '',
|
||
},
|
||
contract_or_service: {
|
||
subject: project.subject || '',
|
||
amount_paid: project.agrprice || '',
|
||
agreement_date: project.agrdate || '',
|
||
period_start: project.startdate || '',
|
||
period_end: project.finishdate || '',
|
||
country: project.country || '',
|
||
hotel: project.hotel || '',
|
||
},
|
||
offenders: (formDraft.offenders || []).map((o: any) => ({
|
||
name: o.accountname || '', // ✅ Форма ожидает 'name', а не 'accountname'
|
||
accountname: o.accountname || '', // Дублируем для совместимости
|
||
address: o.address || '',
|
||
email: o.email || '',
|
||
website: o.website || '',
|
||
phone: o.phone || '',
|
||
inn: o.inn || '',
|
||
ogrn: o.ogrn || '',
|
||
role: o.role || '',
|
||
})),
|
||
claim: {
|
||
description: project.description || problemDescription || '', // ✅ Описание проблемы
|
||
reason: project.category || '', // ✅ Причина обращения
|
||
},
|
||
meta: {
|
||
claim_id: finalClaimId,
|
||
unified_id: formData.unified_id || '',
|
||
session_token: actualSessionId,
|
||
},
|
||
// ✅ Используем field_label (человекочитаемые названия) вместо имён файлов
|
||
attachments_names: documentsMeta.map((d: any) => d.field_label || d.original_file_name || d.file_name || 'Документ'),
|
||
},
|
||
session_token: actualSessionId,
|
||
claim_id: finalClaimId,
|
||
prefix: 'clpr_',
|
||
};
|
||
|
||
console.log('✅ claimPlanData сформирован:', claimPlanData);
|
||
console.log('✅ claimPlanData.propertyName.claim.description:', claimPlanData.propertyName.claim.description);
|
||
console.log('✅ claimPlanData.propertyName.offenders:', claimPlanData.propertyName.offenders);
|
||
} else {
|
||
// Старый способ: преобразуем данные из БД
|
||
claimPlanData = transformDraftToClaimPlanFormat({
|
||
claim,
|
||
payload,
|
||
body,
|
||
isTelegramFormat,
|
||
finalClaimId,
|
||
actualSessionId,
|
||
currentFormData: formData,
|
||
});
|
||
}
|
||
|
||
console.log('✅ claimPlanData для формы подтверждения:', claimPlanData);
|
||
|
||
// ✅ Если данные подтверждены и есть данные из CRM - используем их
|
||
if (contact_data_confirmed && contact_data_from_crm) {
|
||
// Обновляем applicant данные из CRM
|
||
if (claimPlanData?.propertyName?.applicant) {
|
||
claimPlanData.propertyName.applicant = {
|
||
...claimPlanData.propertyName.applicant,
|
||
first_name: contact_data_from_crm.firstname || claimPlanData.propertyName.applicant.first_name,
|
||
last_name: contact_data_from_crm.lastname || claimPlanData.propertyName.applicant.last_name,
|
||
middle_name: contact_data_from_crm.cf_1157 || claimPlanData.propertyName.applicant.middle_name,
|
||
inn: contact_data_from_crm.cf_1257 || claimPlanData.propertyName.applicant.inn,
|
||
birth_date: contact_data_from_crm.birthday || claimPlanData.propertyName.applicant.birth_date,
|
||
birth_place: contact_data_from_crm.cf_1263 || claimPlanData.propertyName.applicant.birth_place,
|
||
address: contact_data_from_crm.mailingstreet || claimPlanData.propertyName.applicant.address,
|
||
email: contact_data_from_crm.email || claimPlanData.propertyName.applicant.email,
|
||
phone: contact_data_from_crm.mobile || claimPlanData.propertyName.applicant.phone,
|
||
};
|
||
}
|
||
}
|
||
|
||
// Сохраняем данные заявления в formData
|
||
updateFormData({
|
||
claimPlanData: claimPlanData,
|
||
showClaimConfirmation: true,
|
||
// ✅ Флаги подтверждения данных
|
||
contact_data_confirmed: contact_data_confirmed,
|
||
contact_data_can_edit: contact_data_can_edit,
|
||
contact_data_confirmed_at: contact_data_confirmed_at,
|
||
});
|
||
|
||
// Переход к шагу подтверждения произойдёт автоматически через useEffect
|
||
setCurrentStep(2); // StepWizardPlan (временно, useEffect переключит на подтверждение)
|
||
return;
|
||
}
|
||
|
||
// ✅ Определяем шаг для перехода на основе данных черновика
|
||
// Приоритет: если есть wizard_plan → переходим к визарду (даже если нет problem_description)
|
||
// После выбора черновика showDraftSelection = false, поэтому:
|
||
// - Шаг 0 = Step1Phone (но мы его пропускаем, т.к. телефон уже верифицирован)
|
||
// - Шаг 1 = StepDescription
|
||
// - Шаг 2 = StepWizardPlan
|
||
|
||
let targetStep = 1; // По умолчанию - описание (шаг 1)
|
||
|
||
// ✅ НОВЫЙ ФЛОУ: Если есть documents_required, показываем загрузку документов
|
||
if (documentsRequired.length > 0) {
|
||
targetStep = 2;
|
||
console.log('✅ Переходим к StepWizardPlan (шаг 2) - НОВЫЙ ФЛОУ: есть documents_required, показываем загрузку документов');
|
||
console.log('✅ documents_required:', documentsRequired.length, 'документов');
|
||
} else if (wizardPlan) {
|
||
// ✅ СТАРЫЙ ФЛОУ: Если есть wizard_plan - переходим к визарду (шаг 2)
|
||
// Пользователь уже описывал проблему, и есть план вопросов
|
||
targetStep = 2;
|
||
console.log('✅ Переходим к StepWizardPlan (шаг 2) - СТАРЫЙ ФЛОУ: есть wizard_plan');
|
||
console.log('✅ answers в черновике:', answers ? 'есть (показываем заполненную форму)' : 'нет (показываем пустую форму)');
|
||
} else if (problemDescription) {
|
||
// Если есть описание, но нет плана - переходим к визарду (шаг 2), чтобы получить план
|
||
targetStep = 2;
|
||
console.log('✅ Переходим к StepWizardPlan (шаг 2) - есть описание, план будет получен через SSE');
|
||
} else {
|
||
// Если нет ничего - переходим к описанию (шаг 1)
|
||
targetStep = 1;
|
||
console.log('✅ Переходим к StepDescription (шаг 1) - нет описания и плана');
|
||
}
|
||
|
||
console.log('🔍 Устанавливаем currentStep:', targetStep);
|
||
// ✅ Устанавливаем isPhoneVerified = true, чтобы пропустить шаг телефона
|
||
setIsPhoneVerified(true);
|
||
setCurrentStep(targetStep);
|
||
} catch (error) {
|
||
console.error('Ошибка загрузки черновика:', error);
|
||
message.error('Не удалось загрузить черновик');
|
||
}
|
||
}, [formData, updateFormData]);
|
||
|
||
// Обработчик выбора черновика
|
||
const handleSelectDraft = useCallback((claimId: string) => {
|
||
loadDraft(claimId);
|
||
}, [loadDraft]);
|
||
|
||
// Проверка наличия черновиков
|
||
const checkDrafts = useCallback(async (unified_id?: string, phone?: string, sessionId?: string) => {
|
||
try {
|
||
console.log('🔍 ========== checkDrafts вызван ==========');
|
||
console.log('🔍 Параметры:', { unified_id, phone, sessionId });
|
||
|
||
const params = new URLSearchParams();
|
||
// Приоритет: unified_id > phone > session_id
|
||
if (unified_id) {
|
||
params.append('unified_id', unified_id);
|
||
console.log('🔍 Используем unified_id:', unified_id);
|
||
} else if (phone) {
|
||
params.append('phone', phone);
|
||
console.log('🔍 Используем phone:', phone);
|
||
} else if (sessionId) {
|
||
params.append('session_id', sessionId);
|
||
console.log('🔍 Используем session_id:', sessionId);
|
||
} else {
|
||
console.warn('⚠️ Нет параметров для поиска черновиков');
|
||
return false;
|
||
}
|
||
|
||
const url = `/api/v1/claims/drafts/list?${params.toString()}`;
|
||
console.log('🔍 Запрос черновиков:', url);
|
||
|
||
const response = await fetch(url);
|
||
console.log('🔍 Статус ответа:', response.status, response.statusText);
|
||
|
||
if (!response.ok) {
|
||
const errorText = await response.text();
|
||
console.error('❌ Ошибка запроса черновиков:', response.status, response.statusText, errorText);
|
||
return false;
|
||
}
|
||
|
||
const data = await response.json();
|
||
console.log('🔍 Полный ответ API черновиков:', JSON.stringify(data, null, 2));
|
||
console.log('🔍 Debug info от backend:', data.debug_info || data.debug);
|
||
const count = data.count || 0;
|
||
console.log('🔍 Количество черновиков:', count);
|
||
console.log('🔍 Список черновиков:', data.drafts);
|
||
|
||
setHasDrafts(count > 0);
|
||
setShowDraftSelection(count > 0);
|
||
console.log('🔍 Установлены флаги: hasDrafts=', count > 0, 'showDraftSelection=', count > 0);
|
||
console.log('🔍 ========== checkDrafts завершён ==========');
|
||
return count > 0;
|
||
} catch (error) {
|
||
console.error('❌ Ошибка проверки черновиков:', error);
|
||
console.error('❌ Stack trace:', (error as Error).stack);
|
||
return false;
|
||
}
|
||
}, []);
|
||
|
||
// Обработчик создания новой заявки
|
||
const handleNewClaim = useCallback(() => {
|
||
console.log('🆕 Начинаем новое обращение');
|
||
console.log('🆕 Текущий currentStep:', currentStep);
|
||
console.log('🆕 isPhoneVerified:', isPhoneVerified);
|
||
|
||
// ✅ Генерируем НОВУЮ сессию для новой жалобы
|
||
const newSessionId = 'sess_' + generateUUIDv4();
|
||
console.log('🆕 Генерируем новую сессию для жалобы:', newSessionId);
|
||
console.log('🆕 Старая сессия:', sessionIdRef.current);
|
||
|
||
// ✅ Обновляем sessionIdRef на новую сессию
|
||
sessionIdRef.current = newSessionId;
|
||
|
||
// ✅ session_token в localStorage остаётся ПРЕЖНИМ (авторизация сохраняется)
|
||
const savedSessionToken = localStorage.getItem('session_token');
|
||
console.log('🆕 session_token в localStorage (авторизация):', savedSessionToken || '(не сохранён)');
|
||
console.log('🆕 Авторизация сохранена: unified_id=', formData.unified_id, 'phone=', formData.phone);
|
||
|
||
setShowDraftSelection(false);
|
||
setSelectedDraftId(null);
|
||
setHasDrafts(false); // ✅ Сбрасываем флаг наличия черновиков
|
||
|
||
// ✅ Очищаем данные формы и устанавливаем НОВЫЙ session_id
|
||
// unified_id, phone, contact_id остаются прежними - авторизация сохранена!
|
||
updateFormData({
|
||
session_id: newSessionId, // ✅ Новая сессия для новой жалобы
|
||
claim_id: undefined,
|
||
problemDescription: undefined,
|
||
wizardPlan: undefined,
|
||
wizardAnswers: undefined,
|
||
wizardPrefill: undefined,
|
||
wizardPrefillArray: undefined,
|
||
wizardCoverageReport: undefined,
|
||
wizardUploads: undefined,
|
||
wizardSkippedDocuments: undefined,
|
||
eventType: undefined,
|
||
// ✅ unified_id, phone, contact_id НЕ очищаем - авторизация сохраняется!
|
||
});
|
||
|
||
console.log('🆕 Переходим к шагу описания проблемы (пропускаем Phone и DraftSelection)');
|
||
|
||
// ✅ Переходим к шагу описания проблемы
|
||
// После сброса флагов черновиков, steps будут:
|
||
// Шаг 0 - Phone (уже верифицирован, но в массиве есть)
|
||
// Шаг 1 - Description (сюда переходим)
|
||
// Шаг 2 - WizardPlan
|
||
setCurrentStep(1); // ✅ Переходим к описанию (индекс 1)
|
||
}, [updateFormData, currentStep, isPhoneVerified, formData.unified_id, formData.phone]);
|
||
|
||
// ✅ Автоматический редирект на экран черновиков после успешной отправки
|
||
useEffect(() => {
|
||
if (isSubmitted) {
|
||
console.log('✅ Обращение успешно отправлено, ждём 2.5 секунды перед редиректом на черновики...');
|
||
|
||
const redirectTimer = setTimeout(async () => {
|
||
console.log('🔄 Выполняем редирект на экран черновиков');
|
||
|
||
// Проверяем наличие черновиков
|
||
const hasDraftsResult = await checkDrafts(
|
||
formData.unified_id,
|
||
formData.phone,
|
||
sessionIdRef.current
|
||
);
|
||
|
||
console.log('🔍 Результат проверки черновиков:', hasDraftsResult);
|
||
|
||
// Переходим на экран черновиков
|
||
setShowDraftSelection(true);
|
||
setHasDrafts(hasDraftsResult);
|
||
setIsSubmitted(false); // Сбрасываем флаг отправки
|
||
setSelectedDraftId(null); // Сбрасываем выбранный черновик
|
||
|
||
// Переходим на шаг 0 (черновики)
|
||
setTimeout(() => {
|
||
setCurrentStep(0);
|
||
console.log('✅ Переход на экран черновиков выполнен');
|
||
}, 100);
|
||
}, 2500); // Задержка 2.5 секунды
|
||
|
||
return () => {
|
||
clearTimeout(redirectTimer);
|
||
};
|
||
}
|
||
}, [isSubmitted, formData.unified_id, formData.phone, checkDrafts]);
|
||
|
||
const handleSubmit = useCallback(async () => {
|
||
try {
|
||
addDebugEvent('form', 'info', '📤 Отправка заявки в n8n через backend');
|
||
|
||
const payload = {
|
||
stage: 'final',
|
||
form_id: 'ticket_form',
|
||
session_id: formData.session_id ?? sessionIdRef.current,
|
||
client_ip: formData.clientIp,
|
||
sms_code: formData.smsCode,
|
||
|
||
// Базовые идентификаторы
|
||
claim_id: formData.claim_id,
|
||
contact_id: formData.contact_id,
|
||
project_id: formData.project_id,
|
||
ticket_id: formData.ticket_id,
|
||
is_new_contact: formData.is_new_contact,
|
||
is_new_project: formData.is_new_project,
|
||
|
||
// Основные поля формы (для удобства в n8n)
|
||
voucher: formData.voucher,
|
||
phone: formData.phone,
|
||
email: formData.email,
|
||
event_type: formData.eventType,
|
||
payment_method: formData.paymentMethod,
|
||
bank_id: formData.bankId, // ID банка из NSPK API
|
||
bank_name: formData.bankName, // Название банка для отображения
|
||
card_number: formData.cardNumber,
|
||
account_number: formData.accountNumber,
|
||
|
||
// Старый блок документов + новые загрузки визарда (пока как есть)
|
||
documents: formData.documents || {},
|
||
wizard_uploads: formData.wizardUploads || {},
|
||
|
||
// Всё состояние формы целиком — на всякий случай
|
||
form: formData,
|
||
};
|
||
|
||
const response = await fetch('/api/v1/claims/create', {
|
||
method: 'POST',
|
||
headers: {
|
||
'Content-Type': 'application/json',
|
||
},
|
||
body: JSON.stringify(payload),
|
||
});
|
||
|
||
const text = await response.text();
|
||
let parsed: any = null;
|
||
try {
|
||
parsed = text ? JSON.parse(text) : null;
|
||
} catch {
|
||
parsed = null;
|
||
}
|
||
|
||
if (!response.ok) {
|
||
message.error('Ошибка при создании заявки (n8n)');
|
||
addDebugEvent('form', 'error', '❌ Ошибка создания заявки в n8n', {
|
||
status: response.status,
|
||
body: text,
|
||
});
|
||
return;
|
||
}
|
||
|
||
addDebugEvent('form', 'success', '✅ Финальный webhook в n8n отработал', {
|
||
response: parsed ?? text,
|
||
});
|
||
// Помечаем, что заявка отправлена, и показываем заглушку.
|
||
setIsSubmitted(true);
|
||
message.success('Поздравляем! Ваше обращение направлено в Клиентправ.');
|
||
} catch (error) {
|
||
message.error('Ошибка соединения с сервером');
|
||
addDebugEvent('form', 'error', '❌ Ошибка соединения', { error: String(error) });
|
||
console.error(error);
|
||
}
|
||
}, [formData, addDebugEvent]);
|
||
|
||
// Динамически генерируем шаги на основе выбранного eventType
|
||
const steps = useMemo(() => {
|
||
const stepsArray: any[] = [];
|
||
|
||
// Шаг 0: Выбор черновика (показывается только если есть черновики)
|
||
// ✅ unified_id уже означает, что телефон верифицирован
|
||
// Показываем шаг, если showDraftSelection=true ИЛИ если есть unified_id и hasDrafts
|
||
if ((showDraftSelection || (formData.unified_id && hasDrafts)) && !selectedDraftId) {
|
||
stepsArray.push({
|
||
title: 'Черновики',
|
||
description: 'Выбор заявки',
|
||
content: (
|
||
<StepDraftSelection
|
||
phone={formData.phone || ''}
|
||
session_id={sessionIdRef.current}
|
||
unified_id={formData.unified_id} // ✅ Передаём unified_id
|
||
isTelegramMiniApp={isTelegramMiniApp} // ✅ Передаём флаг Telegram
|
||
onSelectDraft={handleSelectDraft}
|
||
onNewClaim={handleNewClaim}
|
||
/>
|
||
),
|
||
});
|
||
}
|
||
|
||
// Шаг 1: Phone (телефон + SMS верификация)
|
||
stepsArray.push({
|
||
title: 'Вход',
|
||
description: 'Подтверждение телефона',
|
||
content: (
|
||
<Step1Phone
|
||
formData={{ ...formData, session_id: formData.session_id || sessionIdRef.current }} // ✅ Используем session_id из formData (от n8n) или временный
|
||
updateFormData={(data: any) => {
|
||
updateFormData(data);
|
||
// ✅ Если n8n вернул session_id, обновляем ref
|
||
if (data.session_id && data.session_id !== sessionIdRef.current) {
|
||
console.log('🔄 Обновляем sessionIdRef на значение от n8n:', data.session_id);
|
||
sessionIdRef.current = data.session_id;
|
||
}
|
||
// ❌ Убрано: проверка черновиков здесь избыточна, т.к. она уже есть в onNext
|
||
}}
|
||
onNext={async (unified_id?: string) => {
|
||
console.log('🔥 onNext вызван с unified_id:', unified_id);
|
||
console.log('🔥 formData.unified_id:', formData.unified_id);
|
||
console.log('🔥 isPhoneVerified:', isPhoneVerified);
|
||
console.log('🔥 selectedDraftId:', selectedDraftId);
|
||
|
||
// После верификации проверяем черновики
|
||
// Используем unified_id из параметра (если передан) или из formData
|
||
const finalUnifiedId = unified_id || formData.unified_id;
|
||
console.log('🔥 finalUnifiedId:', finalUnifiedId);
|
||
|
||
// ✅ Если передан unified_id, значит телефон уже верифицирован (даже если isPhoneVerified ещё false)
|
||
// Проверяем черновики, если есть unified_id или телефон верифицирован
|
||
const shouldCheckDrafts = finalUnifiedId || (formData.phone && isPhoneVerified);
|
||
|
||
if (shouldCheckDrafts && !selectedDraftId) {
|
||
console.log('🔍 Проверка черновиков с unified_id:', finalUnifiedId, 'phone:', formData.phone, 'sessionId:', sessionIdRef.current);
|
||
const hasDraftsResult = await checkDrafts(finalUnifiedId, formData.phone, sessionIdRef.current);
|
||
console.log('🔍 Результат checkDrafts:', hasDraftsResult);
|
||
console.log('🔍 Текущие флаги после checkDrafts: hasDrafts=', hasDrafts, 'showDraftSelection=', showDraftSelection);
|
||
|
||
if (hasDraftsResult) {
|
||
console.log('✅ Есть черновики, переходим к шагу 0');
|
||
// ✅ ВАЖНО: Сначала устанавливаем флаги, потом переходим на шаг 0
|
||
setShowDraftSelection(true);
|
||
setHasDrafts(true);
|
||
// ✅ Используем setTimeout для гарантии, что React обновил состояние
|
||
setTimeout(() => {
|
||
console.log('🔄 Переходим на шаг 0 после установки флагов');
|
||
setCurrentStep(0); // Переходим к шагу выбора черновика
|
||
}, 100);
|
||
console.log('🛑 Остановка выполнения onNext - есть черновики');
|
||
return; // ✅ ВАЖНО: Не идём дальше, если есть черновики
|
||
} else {
|
||
console.log('❌ Нет черновиков, идем дальше к описанию проблемы');
|
||
// Нет черновиков - идём дальше
|
||
nextStep();
|
||
return;
|
||
}
|
||
} else {
|
||
console.log('⚠️ Условие не выполнено для проверки черновиков:', {
|
||
shouldCheckDrafts,
|
||
selectedDraftId,
|
||
finalUnifiedId,
|
||
phone: formData.phone,
|
||
isPhoneVerified
|
||
});
|
||
// Условие не выполнено - идём дальше
|
||
nextStep();
|
||
return;
|
||
}
|
||
|
||
// ❌ ЭТОТ КОД НЕ ДОЛЖЕН ВЫПОЛНЯТЬСЯ, если есть return выше
|
||
console.error('❌❌❌ КРИТИЧЕСКАЯ ОШИБКА: nextStep() вызван после return!');
|
||
nextStep();
|
||
}}
|
||
onPrev={prevStep}
|
||
isPhoneVerified={isPhoneVerified}
|
||
setIsPhoneVerified={(verified: boolean) => {
|
||
setIsPhoneVerified(verified);
|
||
// ❌ Убрано: проверка черновиков делается только в onNext
|
||
// onNext вызывается после успешной верификации и содержит unified_id
|
||
}}
|
||
addDebugEvent={addDebugEvent}
|
||
/>
|
||
),
|
||
});
|
||
|
||
// Шаг 2: свободное описание
|
||
stepsArray.push({
|
||
title: 'Обращение',
|
||
description: 'Опишите ситуацию',
|
||
content: (
|
||
<StepDescription
|
||
formData={formData}
|
||
updateFormData={updateFormData}
|
||
onPrev={prevStep}
|
||
onNext={nextStep}
|
||
/>
|
||
),
|
||
});
|
||
|
||
// Шаг 3: AI Рекомендации
|
||
stepsArray.push({
|
||
title: 'Документы',
|
||
description: 'Загрузка файлов',
|
||
content: (
|
||
<StepWizardPlan
|
||
formData={formData}
|
||
updateFormData={updateFormData}
|
||
onPrev={prevStep}
|
||
onNext={nextStep}
|
||
backToDraftsList={backToDraftsList}
|
||
addDebugEvent={addDebugEvent}
|
||
/>
|
||
),
|
||
});
|
||
|
||
// Шаг подтверждения заявления (показывается после получения данных из claim:plan)
|
||
// ✅ НОВЫЙ ФЛОУ: StepClaimConfirmation с SMS подтверждением
|
||
if (formData.showClaimConfirmation && formData.claimPlanData) {
|
||
stepsArray.push({
|
||
title: 'Подтверждение',
|
||
description: 'Проверка данных',
|
||
content: (
|
||
<StepClaimConfirmation
|
||
claimPlanData={formData.claimPlanData}
|
||
contact_data_confirmed={formData.contact_data_confirmed}
|
||
onPrev={prevStep}
|
||
onNext={nextStep}
|
||
onSubmitted={() => setIsSubmitted(true)}
|
||
/>
|
||
),
|
||
});
|
||
}
|
||
// Step3Payment убран - не используется
|
||
|
||
return stepsArray;
|
||
}, [formData, isPhoneVerified, nextStep, prevStep, backToDraftsList, updateFormData, handleSubmit, setIsPhoneVerified, addDebugEvent, showDraftSelection, selectedDraftId, hasDrafts, handleSelectDraft, handleNewClaim, checkDrafts]);
|
||
|
||
const handleReset = () => {
|
||
console.log('🔄 Начать заново - возврат к списку черновиков');
|
||
|
||
// ✅ Генерируем новую сессию для новой заявки (но сохраняем авторизацию)
|
||
const newSessionId = 'sess_' + generateUUIDv4();
|
||
sessionIdRef.current = newSessionId;
|
||
|
||
setIsSubmitted(false);
|
||
setShowDraftSelection(false);
|
||
setSelectedDraftId(null);
|
||
|
||
// ✅ Очищаем данные формы, НО сохраняем авторизацию (unified_id, phone, contact_id, isPhoneVerified)
|
||
updateFormData({
|
||
session_id: newSessionId,
|
||
claim_id: undefined,
|
||
voucher: '',
|
||
paymentMethod: 'sbp',
|
||
problemDescription: undefined,
|
||
wizardPlan: undefined,
|
||
wizardAnswers: undefined,
|
||
wizardPrefill: undefined,
|
||
wizardPrefillArray: undefined,
|
||
wizardCoverageReport: undefined,
|
||
wizardUploads: undefined,
|
||
wizardSkippedDocuments: undefined,
|
||
eventType: undefined,
|
||
// ✅ unified_id, phone, contact_id, isPhoneVerified НЕ очищаем
|
||
});
|
||
|
||
// ✅ Проверяем черновики и возвращаемся к списку
|
||
if (formData.unified_id && hasDrafts) {
|
||
console.log('🔄 Есть черновики - показываем список');
|
||
setShowDraftSelection(true);
|
||
setCurrentStep(0);
|
||
} else {
|
||
console.log('🔄 Нет черновиков - переходим к новой заявке');
|
||
setCurrentStep(1); // StepDescription
|
||
}
|
||
|
||
message.info('Форма сброшена');
|
||
addDebugEvent('system', 'info', '🔄 Форма сброшена');
|
||
};
|
||
|
||
// Обработчик кнопки "Выход"
|
||
const handleExitToList = useCallback(async () => {
|
||
console.log('🚪 Выход из системы');
|
||
addDebugEvent('system', 'info', '🚪 Выход из системы');
|
||
|
||
// ✅ В Telegram Mini App — просто закрываем приложение
|
||
if (isTelegramMiniApp) {
|
||
try {
|
||
const tg = (window as any).Telegram;
|
||
const webApp = tg?.WebApp;
|
||
if (webApp && typeof webApp.close === 'function') {
|
||
webApp.close();
|
||
}
|
||
} catch (error) {
|
||
console.warn('⚠️ Ошибка при закрытии Telegram Mini App:', error);
|
||
}
|
||
return;
|
||
}
|
||
|
||
// ✅ В обычном веб — полный сброс сессии и возврат к Step1Phone
|
||
// Получаем session_token из localStorage
|
||
const sessionToken = localStorage.getItem('session_token') || formData.session_id;
|
||
|
||
if (sessionToken) {
|
||
try {
|
||
// Вызываем API logout для удаления сессии из Redis
|
||
const response = await fetch('/api/v1/session/logout', {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ session_token: sessionToken })
|
||
});
|
||
|
||
if (response.ok) {
|
||
console.log('✅ Сессия удалена из Redis');
|
||
addDebugEvent('session', 'success', '✅ Сессия завершена');
|
||
}
|
||
} catch (error) {
|
||
console.warn('⚠️ Ошибка при завершении сессии:', error);
|
||
}
|
||
}
|
||
|
||
// Удаляем session_token из localStorage
|
||
localStorage.removeItem('session_token');
|
||
|
||
// Полный сброс: очищаем все данные авторизации и черновиков
|
||
setIsSubmitted(false);
|
||
setShowDraftSelection(false);
|
||
setHasDrafts(false);
|
||
setSelectedDraftId(null);
|
||
|
||
// Генерируем новую сессию для нового пользователя
|
||
const newSessionId = `sess-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
|
||
sessionIdRef.current = newSessionId;
|
||
|
||
// Полностью очищаем formData, включая unified_id и phone
|
||
setFormData({
|
||
voucher: '',
|
||
claim_id: undefined,
|
||
session_id: newSessionId,
|
||
paymentMethod: 'sbp',
|
||
unified_id: undefined,
|
||
phone: undefined,
|
||
contact_id: undefined,
|
||
is_new_contact: undefined,
|
||
isPhoneVerified: false,
|
||
});
|
||
|
||
// Сбрасываем флаг верификации телефона
|
||
setIsPhoneVerified(false);
|
||
|
||
// Переходим на экран входа (Step1Phone)
|
||
setCurrentStep(0);
|
||
|
||
message.info('Сессия завершена. До свидания!');
|
||
addDebugEvent('system', 'info', '🔄 Форма сброшена');
|
||
}, [formData.session_id, addDebugEvent, isTelegramMiniApp]);
|
||
|
||
// ✅ Показываем loader пока идёт проверка Telegram auth и восстановление сессии
|
||
if (!telegramAuthChecked || !sessionRestored) {
|
||
return (
|
||
<div className={`claim-form-container ${isTelegramMiniApp ? 'telegram-mini-app' : ''}`} style={{ padding: '20px', background: '#ffffff', display: 'flex', justifyContent: 'center', alignItems: 'center', minHeight: '100vh' }}>
|
||
<Spin size="large" tip="Загрузка..." />
|
||
</div>
|
||
);
|
||
}
|
||
|
||
return (
|
||
<div className={`claim-form-container ${isTelegramMiniApp ? 'telegram-mini-app' : ''}`} style={{ padding: '20px', background: '#ffffff' }}>
|
||
<Row gutter={16}>
|
||
{/* Левая часть - Форма (в проде на всю ширину, в деве 14 из 24) */}
|
||
<Col xs={24} lg={process.env.NODE_ENV === 'development' ? 14 : 24}>
|
||
<Card
|
||
title="Подать обращение о защите прав потребителя"
|
||
className="claim-form-card"
|
||
extra={
|
||
!isSubmitted && (
|
||
<Space>
|
||
{/* Кнопка "Выход" - показываем если телефон верифицирован */}
|
||
{isPhoneVerified && (
|
||
<button
|
||
onClick={handleExitToList}
|
||
style={{
|
||
padding: '4px 12px',
|
||
background: '#fff',
|
||
border: '1px solid #ff4d4f',
|
||
borderRadius: '4px',
|
||
cursor: 'pointer',
|
||
fontSize: '14px',
|
||
color: '#ff4d4f'
|
||
}}
|
||
>
|
||
🚪 Выход
|
||
</button>
|
||
)}
|
||
{/* Кнопка "Начать заново" - показываем только после шага телефона */}
|
||
{currentStep > 0 && (
|
||
<button
|
||
onClick={handleReset}
|
||
style={{
|
||
padding: '4px 12px',
|
||
background: '#fff',
|
||
border: '1px solid #d9d9d9',
|
||
borderRadius: '4px',
|
||
cursor: 'pointer',
|
||
fontSize: '14px'
|
||
}}
|
||
>
|
||
🔄 Начать заново
|
||
</button>
|
||
)}
|
||
</Space>
|
||
)
|
||
}
|
||
>
|
||
{isSubmitted ? (
|
||
<div style={{ padding: '40px 0', textAlign: 'center' }}>
|
||
<h3 style={{ fontSize: 22, marginBottom: 8 }}>Поздравляем! Ваше обращение направлено в Клиентправ.</h3>
|
||
<p style={{ color: '#666666', maxWidth: 480, margin: '0 auto 24px' }}>
|
||
В ближайшее время на указанную Вами электронную почту поступит письмо, подтверждающее регистрацию вашего обращения.
|
||
</p>
|
||
</div>
|
||
) : (
|
||
<>
|
||
<Steps current={currentStep} className="steps">
|
||
{steps.map((item, index) => (
|
||
<Step
|
||
key={`step-${index}`}
|
||
title={item.title}
|
||
description={item.description}
|
||
/>
|
||
))}
|
||
</Steps>
|
||
<div className="steps-content">
|
||
{steps[currentStep] ? steps[currentStep].content : (
|
||
<div style={{ padding: '40px 0', textAlign: 'center' }}>
|
||
<p>Загрузка шага...</p>
|
||
</div>
|
||
)}
|
||
</div>
|
||
</>
|
||
)}
|
||
</Card>
|
||
</Col>
|
||
|
||
{/* Правая часть - Debug консоль (только в dev режиме) */}
|
||
{process.env.NODE_ENV === 'development' && (
|
||
<Col xs={24} lg={10}>
|
||
<DebugPanel events={debugEvents} formData={formData} />
|
||
</Col>
|
||
)}
|
||
</Row>
|
||
</div>
|
||
);
|
||
}
|
||
|