@coopenomics/desktop 2025.7.2 → 2025.11.8-alpha-1

package/src/processes/init-wallet/index.ts

@@ -3,18 +3,29 @@ import { useSessionStore } from 'src/entities/Session';
 import { useWalletStore } from 'src/entities/Wallet';
 import { useSystemStore } from 'src/entities/System/model';
 import { useAccountStore } from 'src/entities/Account/model';
+import { useDesktopStore } from 'src/entities/Desktop/model';
+import { extractGraphQLErrorMessages } from 'src/shared/api/errors';
 
 export function useInitWalletProcess() {
   const session = useSessionStore();
   const wallet = useWalletStore();
   const { info } = useSystemStore();
   const account = useAccountStore();
+  const desktops = useDesktopStore();
 
-  const run = async () => {
+  const run = async (forceReload = false) => {
     await session.init();
 
     if (!session.isAuth) return;
 
+    // Запоминаем, была ли уже загрузка завершена
+    const wasLoadComplete = session.loadComplete;
+
+    // При принудительной перезагрузке временно сбрасываем loadComplete
+    if (forceReload) {
+      session.loadComplete = false;
+    }
+
     try {
       const userAccount = await account.getAccount(session.username);
 
@@ -29,12 +40,47 @@ export function useInitWalletProcess() {
       });
 
       session.loadComplete = true;
-    } catch (e) {
-      console.error(e);
+
+      // Выключаем лоадер только при первой инициализации после входа
+      if (!wasLoadComplete) {
+        desktops.setWorkspaceChanging(false);
+      }
+    } catch (e: any) {
+      console.error('Ошибка при инициализации кошелька:', e);
+
+      // Используем тот же подход для извлечения сообщений об ошибках, что и в alerts.ts
+      const errorMessage = extractGraphQLErrorMessages(e);
+
+      // Проверяем на ошибку недействительного JWT токена
+      if (errorMessage.includes('Пользователь с указанным JWT не найден') ||
+          errorMessage.includes('jwt') ||
+          errorMessage.includes('token') ||
+          errorMessage.includes('авторизац')) {
+
+        console.warn('Обнаружена ошибка авторизации при инициализации, выполняем автоматический logout');
+
+        // Выполняем logout
+        session.close();
+        await desktops.setWorkspaceChanging(false);
+
+        // Обновляем страницу для полной очистки состояния
+        setTimeout(() => {
+          window.location.reload();
+        }, 100);
+
+        return;
+      }
+
+      // Выключаем лоадер при ошибке, но только если это была первая инициализация
+      if (!wasLoadComplete) {
+        desktops.setWorkspaceChanging(false);
+      }
     }
 
-    // фоновая проверка каждые 10 сек
-    setTimeout(run, 10_000);
+    // фоновая проверка каждые 10 сек (только если это не принудительная перезагрузка)
+    if (!forceReload) {
+      setTimeout(run, 10_000);
+    }
   };
 
   return { run };

package/src/processes/navigation-guard-setup/index.ts

@@ -4,6 +4,7 @@ import { useCurrentUser } from 'src/entities/Session';
 import { useDesktopStore } from 'src/entities/Desktop/model';
 import { useSystemStore } from 'src/entities/System/model';
 import { LocalStorage } from 'quasar';
+import { Zeus } from '@coopenomics/sdk';
 
 function hasAccess(to, userRole) {
   if (!to.meta?.roles || to.meta?.roles.length === 0) return true;
@@ -21,11 +22,34 @@ function getRedirectUrl(router: Router, to: any): string {
 export function setupNavigationGuard(router: Router) {
   const desktops = useDesktopStore();
   const session = useSessionStore();
-  const currentUser = useCurrentUser();
-  const { info } = useSystemStore();
+  const systemStore = useSystemStore();
 
   router.beforeEach(async (to, from, next) => {
-    await desktops.healthCheck();
+    const currentUser = useCurrentUser();
+    // если требуется установка
+    const allowedRoutesDuringInstall = ['install', 'invite'];
+    if ((systemStore.info.system_status === Zeus.SystemStatus.install || systemStore.info.system_status === Zeus.SystemStatus.initialized) && !allowedRoutesDuringInstall.includes(to.name as string)) {
+      next({ name: 'install', params: { coopname: systemStore.info.coopname } });
+      return;
+    }
+    // Если пользователь авторизован, но данные еще не загружены полностью
+    if (session.isAuth && !session.loadComplete) {
+      console.log('Waiting for user data to load...');
+
+      // Ждем завершения загрузки данных пользователя
+      let attempts = 0;
+      const maxAttempts = 50; // 5 секунд максимум
+
+      while (!session.loadComplete && attempts < maxAttempts) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        attempts++;
+      }
+
+      if (attempts >= maxAttempts) {
+        session.loadComplete = true;
+        console.warn('User data loading timeout');
+      }
+    }
 
     // Определяем роль пользователя при каждом запросе
     let userRole: string | null = null;
@@ -39,12 +63,6 @@ export function setupNavigationGuard(router: Router) {
       }
     }
 
-    // если требуется установка
-    if (desktops.health?.status === 'install' && to.name !== 'install') {
-      next({ name: 'install', params: { coopname: info.coopname } });
-      return;
-    }
-
     // редирект с index
     if (to.name === 'index') {
       // Убеждаемся, что правильный рабочий стол выбран
@@ -54,15 +72,24 @@ export function setupNavigationGuard(router: Router) {
           desktops.selectDefaultWorkspace();
         }
 
-        // Переходим на маршрут по умолчанию для выбранного рабочего стола
-        next();
-        desktops.goToDefaultPage(router);
-
+        // Получаем данные маршрута по умолчанию для выбранного рабочего стола
+        const defaultPageRoute = desktops.getDefaultPageRoute();
+        if (defaultPageRoute) {
+          next(defaultPageRoute);
+        } else {
+          // Если не удалось определить маршрут, используем fallback
+          next({ name: 'somethingBad' });
+        }
         return;
       } else {
-        // Если пользователь не авторизован, используем nonAuthorizedHome
-        const homePage = desktops.currentDesktop?.nonAuthorizedHome;
-        next({ name: homePage, params: { coopname: info.coopname } });
+        // Если пользователь не авторизован, выбираем рабочий стол и переходим на страницу по умолчанию
+        desktops.selectDefaultWorkspace();
+        const defaultRoute = desktops.getDefaultPageRoute();
+        if (defaultRoute) {
+          next(defaultRoute);
+        } else {
+          next({ name: 'signup', params: { coopname: systemStore.info.coopname } });
+        }
         return;
       }
     }
@@ -72,11 +99,12 @@ export function setupNavigationGuard(router: Router) {
       // Сохраняем целевой URL для редиректа после входа
       if (process.env.CLIENT) {
         // Получаем URL для редиректа
+        console.log('требуем аудентификацию ', to)
         const redirectUrl = getRedirectUrl(router, to);
         LocalStorage.set('redirectAfterLogin', redirectUrl);
       }
       // Перенаправляем на страницу входа
-      next({ name: 'login-redirect', params: { coopname: info.coopname } });
+      next({ name: 'login-redirect', params: { coopname: systemStore.info.coopname } });
       return;
     }
 

package/src/processes/process-decisions/handlers/index.ts

@@ -0,0 +1,103 @@
+import { Cooperative } from 'cooptypes';
+import { decisionFactory } from 'src/shared/lib/decision-factory';
+import { useGenerateFreeDecision } from 'src/features/FreeDecision/GenerateDecision';
+import { useGenerateParticipantApplicationDecision } from 'src/features/Decision/ParticipantApplication';
+import { useGenerateSovietDecisionOnAnnualMeet } from 'src/features/Meet/GenerateSovietDecision/model';
+import { useGenerateReturnByMoneyDecision } from 'src/features/Wallet/GenerateReturnByMoneyDecision';
+
+/**
+ * Регистрация обработчиков базовых решений
+ * Этот файл содержит регистрацию всех встроенных обработчиков решений
+ */
+export function registerBaseDecisionHandlers() {
+  // Обработчик для FreeDecision (свободное решение)
+  decisionFactory.registerHandler('freedecision', {
+    generateHandler: async ({ decision_id, username, row }) => {
+      if (!row.table?.statement?.meta) {
+        throw new Error('Отсутствуют метаданные заявления для решения freedecision');
+      }
+
+      const parsedDocumentMeta = JSON.parse(
+        row.table.statement.meta,
+      ) as Cooperative.Registry.FreeDecision.Action;
+
+      if (!parsedDocumentMeta.project_id) {
+        throw new Error('Отсутствует project_id в метаданных заявления');
+      }
+
+      const { generateFreeDecision } = useGenerateFreeDecision();
+      return await generateFreeDecision({
+        username,
+        decision_id,
+        project_id: parsedDocumentMeta.project_id,
+      });
+    },
+  });
+
+  // Обработчик для DecisionOfParticipantApplication (решение о приеме участника)
+  decisionFactory.registerHandler('joincoop', {
+    generateHandler: async ({ decision_id, username }) => {
+      const { generateParticipantApplicationDecision } =
+        useGenerateParticipantApplicationDecision();
+      return await generateParticipantApplicationDecision({
+        username,
+        decision_id,
+      });
+    },
+  });
+
+  // Обработчик для AnnualGeneralMeetingSovietDecision (решение совета о годовом собрании)
+  decisionFactory.registerHandler('creategm', {
+    generateHandler: async ({ decision_id, username, row }) => {
+      if (!row.table?.statement?.meta) {
+        throw new Error('Отсутствуют метаданные заявления для решения creategm');
+      }
+
+      if (!row.table?.hash) {
+        throw new Error('Отсутствует hash для решения creategm');
+      }
+
+      const { generateSovietDecisionOnAnnualMeet } =
+        useGenerateSovietDecisionOnAnnualMeet();
+      const parsedDocumentMeta = JSON.parse(
+        row.table.statement.meta,
+      ) as Cooperative.Registry.AnnualGeneralMeetingAgenda.Action;
+      const is_repeated = parsedDocumentMeta.is_repeated || false;
+
+      return await generateSovietDecisionOnAnnualMeet({
+        username,
+        decision_id,
+        meet_hash: row.table.hash,
+        is_repeated,
+      });
+    },
+  });
+
+  // Обработчик для ReturnByMoneyDecision (решение о возврате денег)
+  decisionFactory.registerHandler('createwthd', {
+    generateHandler: async ({ decision_id, username, row }) => {
+      if (!row.table?.statement?.meta) {
+        throw new Error('Отсутствуют метаданные заявления для решения createwthd');
+      }
+
+      const { generateReturnByMoneyDecision } =
+        useGenerateReturnByMoneyDecision();
+
+      const parsedDocumentMeta = JSON.parse(
+        row.table.statement.meta,
+      ) as Cooperative.Registry.ReturnByMoney.Action;
+
+      if (!parsedDocumentMeta.payment_hash || !parsedDocumentMeta.quantity || !parsedDocumentMeta.currency) {
+        throw new Error('Некорректные метаданные заявления для решения createwthd');
+      }
+
+      return await generateReturnByMoneyDecision({
+        username,
+        decision_id,
+        payment_hash: parsedDocumentMeta.payment_hash,
+        quantity: parsedDocumentMeta.quantity,
+        currency: parsedDocumentMeta.currency,
+      });
+    },
+  });
+}

package/src/processes/process-decisions/index.ts

@@ -1,8 +1,4 @@
-import { Cooperative, SovietContract } from 'cooptypes';
-import { useGenerateFreeDecision } from 'src/features/FreeDecision/GenerateDecision';
-import { useGenerateParticipantApplicationDecision } from 'src/features/Decision/ParticipantApplication';
-import { useGenerateSovietDecisionOnAnnualMeet } from 'src/features/Meet/GenerateSovietDecision/model';
-import { useGenerateReturnByMoneyDecision } from 'src/features/Wallet/GenerateReturnByMoneyDecision';
+import { SovietContract } from 'cooptypes';
 import { useSystemStore } from 'src/entities/System/model';
 import { useSessionStore } from 'src/entities/Session';
 import { useGlobalStore } from 'src/shared/store';
@@ -14,12 +10,17 @@ import type { IAgenda } from 'src/entities/Agenda/model';
 import { DigitalDocument } from 'src/shared/lib/document';
 import type { IUserCertificateUnion } from 'src/shared/lib/types/certificate';
 import { getNameFromCertificate } from 'src/shared/lib/utils/getNameFromCertificate';
+import { decisionFactory } from 'src/shared/lib/decision-factory';
+import { registerBaseDecisionHandlers } from './handlers';
 
 /**
  * Процесс обработки решений
  * Координирует работу различных фич для генерации и обработки решений различных типов
  */
 export function useDecisionProcessor() {
+  // Регистрируем базовые обработчики решений при первом использовании
+  registerBaseDecisionHandlers();
+
   const { info } = useSystemStore();
   const session = useSessionStore();
   const agendaStore = useAgendaStore();
@@ -106,79 +107,28 @@ export function useDecisionProcessor() {
    * Генерирует документ решения в зависимости от его типа
    */
   async function generateDecisionDocument(row: IAgenda) {
-    if (!row.table?.id || !row.table?.username || !row.table?.type) {
-      throw new Error('Некорректные данные решения');
+    if (!row.table) {
+      throw new Error('Отсутствует таблица решения');
+    }
+
+    if (!row.table.id || !row.table.username || !row.table.type) {
+      throw new Error('Некорректные данные решения: отсутствуют id, username или type');
     }
 
     const decision_id = Number(row.table.id);
+    if (isNaN(decision_id)) {
+      throw new Error('Некорректный ID решения');
+    }
+
     const username = row.table.username;
     const type = row.table.type;
-    console.log('type: ', type, Cooperative.Document.decisionsRegistry);
-    const registry_id = Cooperative.Document.decisionsRegistry[type];
-
-    // Генерация документа в зависимости от типа решения
-    let document;
-
-    if (registry_id === Cooperative.Registry.FreeDecision.registry_id) {
-      const parsedDocumentMeta = JSON.parse(
-        row.table.statement.meta,
-      ) as Cooperative.Registry.FreeDecision.Action;
-      const project_id = parsedDocumentMeta.project_id;
-
-      const { generateFreeDecision } = useGenerateFreeDecision();
-      document = await generateFreeDecision({
-        username: username,
-        decision_id: decision_id,
-        project_id: project_id,
-      });
-    } else if (
-      registry_id ===
-      Cooperative.Registry.DecisionOfParticipantApplication.registry_id
-    ) {
-      const { generateParticipantApplicationDecision } =
-        useGenerateParticipantApplicationDecision();
-      document = await generateParticipantApplicationDecision({
-        username: username,
-        decision_id: decision_id,
-      });
-    } else if (
-      registry_id ===
-      Cooperative.Registry.AnnualGeneralMeetingSovietDecision.registry_id
-    ) {
-      const { generateSovietDecisionOnAnnualMeet } =
-        useGenerateSovietDecisionOnAnnualMeet();
-      const parsedDocumentMeta = JSON.parse(
-        row.table.statement.meta,
-      ) as Cooperative.Registry.AnnualGeneralMeetingAgenda.Action;
-      const is_repeated = parsedDocumentMeta.is_repeated || false;
-
-      document = await generateSovietDecisionOnAnnualMeet({
-        username: username,
-        decision_id: decision_id,
-        meet_hash: row.table.hash as string,
-        is_repeated,
-      });
-    } else if (
-      registry_id === Cooperative.Registry.ReturnByMoneyDecision.registry_id
-    ) {
-      const { generateReturnByMoneyDecision } =
-        useGenerateReturnByMoneyDecision();
-
-      const parsedDocumentMeta = JSON.parse(
-        row.table.statement.meta,
-      ) as Cooperative.Registry.ReturnByMoney.Action;
-      console.log('row.table.statement.meta', parsedDocumentMeta.payment_hash);
-      document = await generateReturnByMoneyDecision({
-        username: username,
-        decision_id: decision_id,
-        payment_hash: parsedDocumentMeta.payment_hash,
-        quantity: parsedDocumentMeta.quantity,
-        currency: parsedDocumentMeta.currency,
-      });
-    } else {
-      console.log('Неизвестный тип решения', registry_id);
-      throw new Error('Неизвестный тип решения');
-    }
+
+    // Используем фабрику для генерации документа решения
+    const document = await decisionFactory.generateDocument(type, {
+      decision_id,
+      username,
+      row,
+    });
 
     if (!document) {
       throw new Error('Ошибка при генерации документа решения');
@@ -191,11 +141,18 @@ export function useDecisionProcessor() {
    * Авторизует и выполняет решение
    */
   async function authorizeAndExecuteDecision(row: IAgenda) {
-    if (!row.table?.id) {
-      throw new Error('Некорректные данные решения');
+    if (!row.table) {
+      throw new Error('Отсутствует таблица решения');
+    }
+
+    if (!row.table.id) {
+      throw new Error('Отсутствует ID решения');
     }
 
     const decision_id = Number(row.table.id);
+    if (isNaN(decision_id)) {
+      throw new Error('Некорректный ID решения');
+    }
 
     // Генерируем документ решения
     const document = await generateDecisionDocument(row);
@@ -255,11 +212,19 @@ export function useDecisionProcessor() {
    * Голосовать "за" решение
    */
   async function voteForDecision(row: IAgenda) {
-    if (!row.table?.id) {
+    if (!row.table) {
+      throw new Error('Отсутствует таблица решения');
+    }
+
+    if (!row.table.id) {
       throw new Error('Не удалось получить ID решения');
     }
 
     const decision_id = Number(row.table.id);
+    if (isNaN(decision_id)) {
+      throw new Error('Некорректный ID решения');
+    }
+
     const { voteForDecision: vote } = useVoteForDecision();
     await vote(decision_id);
     return true;
@@ -269,11 +234,19 @@ export function useDecisionProcessor() {
    * Голосовать "против" решения
    */
   async function voteAgainstDecision(row: IAgenda) {
-    if (!row.table?.id) {
+    if (!row.table) {
+      throw new Error('Отсутствует таблица решения');
+    }
+
+    if (!row.table.id) {
       throw new Error('Не удалось получить ID решения');
     }
 
     const decision_id = Number(row.table.id);
+    if (isNaN(decision_id)) {
+      throw new Error('Некорректный ID решения');
+    }
+
     const { voteAgainstDecision } = useVoteAgainstDecision();
     await voteAgainstDecision(decision_id);
     return true;
@@ -300,6 +273,15 @@ export function useDecisionProcessor() {
     return isVotedAgainst(decision) || isVotedFor(decision);
   }
 
+  /**
+   * Получает компонент дополнительной информации для типа решения
+   * @param decisionType - тип решения
+   * @returns компонент или undefined если не задан
+   */
+  function getDecisionInfoComponent(decisionType: string) {
+    return decisionFactory.getInfoComponent(decisionType);
+  }
+
   return {
     decisions,
     loading,
@@ -314,5 +296,6 @@ export function useDecisionProcessor() {
     formatDecisionTitle,
     getDocumentTitle,
     getDocumentHash,
+    getDecisionInfoComponent,
   };
 }

package/src/processes/watch-desktop-health/index.ts

@@ -1,33 +1,75 @@
 // processes/watch-desktop-health/index.ts
-import { watch } from 'vue'
-import { QSpinnerGears, useQuasar } from 'quasar'
-import { useDesktopStore } from 'src/entities/Desktop/model'
+import { watch, computed } from 'vue';
+import { QSpinnerGears, useQuasar } from 'quasar';
+import { useSystemStore } from 'src/entities/System/model';
+import { Zeus } from '@coopenomics/sdk';
 
 export function useDesktopHealthWatcherProcess() {
-  const $q = useQuasar()
-  const desktop = useDesktopStore()
+  const $q = useQuasar();
+  const systemStore = useSystemStore();
+
+
+  // Создаем computed для лучшей реактивности
+  const systemStatus = computed(() => systemStore.info.system_status);
 
   const enableLoading = () => {
     $q.loading.show({
       spinner: QSpinnerGears,
       message: 'Техническое обслуживание..',
       spinnerSize: 50,
-    })
-  }
+    });
+  };
 
   const disableLoading = () => {
-    $q.loading.hide()
-  }
+    $q.loading.hide();
+  };
 
   const check = () => {
-    if (desktop.online === false) {
-      enableLoading()
+    if (systemStatus.value === 'maintenance') {
+      enableLoading();
     } else {
-      disableLoading()
+      disableLoading();
     }
-  }
+  };
+
+  // Первоначальная проверка
+  check();
+
+  watch(
+    systemStatus,
+    (newSystemStatus, oldSystemStatus) => {
+
+      // Если состояние изменилось с maintenance на active (выход из технического обслуживания)
+      if (
+        oldSystemStatus === Zeus.SystemStatus.maintenance &&
+        (newSystemStatus === Zeus.SystemStatus.active ||
+          newSystemStatus === Zeus.SystemStatus.install)
+      ) {
+        // Перезагружаем страницу
+        if (process.env.CLIENT) {
+          window.location.reload();
+        }
+        return;
+      }
+
+      // Обычная логика проверки
+      check();
+    },
+    {
+      flush: 'sync', // Синхронное срабатывание для немедленной реакции
+    },
+  );
 
-  check()
+  // Дополнительная проверка через небольшую задержку на случай если статус изменился ДО регистрации watch
+  setTimeout(() => {
+    check();
+  }, 100);
 
-  watch(() => desktop.online, check)
+  // Следим за счетчиком maintenance для принудительной проверки
+  watch(
+    () => systemStore.maintenanceCounter,
+    () => {
+      check();
+    },
+  );
 }

package/src/shared/api/alerts.ts

@@ -1,23 +1,83 @@
-import { Notify } from 'quasar'
-import { extractGraphQLErrorMessages } from './errors'
+import { Notify } from 'quasar';
+import { extractGraphQLErrorMessages } from './errors';
+
+export function SuccessAlert(
+  message: string,
+  action?: {
+    text?: string;
+    icon?: string;
+    handler: () => void;
+  }
+): void {
+  const actions = action ? [{
+    ...(action.text ? { label: action.text } : { icon: action.icon || 'launch' }),
+    color: 'white',
+    size: 'sm',
+    flat: true,
+    handler: action.handler,
+  }] : [{
+    icon: 'close',
+    color: 'white',
+    round: true,
+    size: 'sm',
+    flat: true,
+    handler: () => {
+      /* ... */
+    },
+  }];
 
-export function SuccessAlert(message: string): void {
   Notify.create({
     message,
     color: 'primary',
-    actions: [
-      { icon: 'close', color: 'white', round: true, size:'sm', flat: true, handler: () => { /* ... */ } }
-    ]
-  })
+    position: 'top-right',
+    actions,
+  });
 }
 
-export function FailAlert(error: any): void{
-  const message = extractGraphQLErrorMessages(error)
+export function FailAlert(error: any, text?: string): void {
+  let message = extractGraphQLErrorMessages(error);
+  message = message.replace('assertion failure with message: ', '');
+
   Notify.create({
-    message,
+    message: text ? text+': '+message : message,
     type: 'negative',
+    position: 'top-right',
+    actions: [
+      {
+        icon: 'close',
+        color: 'white',
+        round: true,
+        size: 'sm',
+        flat: true,
+        handler: () => {
+          /* ... */
+        },
+      },
+    ],
+  });
+}
+
+export function NotifyAlert(
+  title: string,
+  body?: string,
+  avatar?: string,
+): void {
+  Notify.create({
+    message: title,
+    caption: body,
+    avatar: avatar,
+    position: 'top-right',
+    timeout: 8000,
     actions: [
-      { icon: 'close', color: 'white', round: true, size:'sm', flat: true, handler: () => { /* ... */ } }
-    ]
-  })
+      {
+        icon: 'close',
+        round: true,
+        size: 'sm',
+        flat: true,
+        handler: () => {
+          /* ... */
+        },
+      },
+    ],
+  });
 }