@coopenomics/desktop 2025.7.3 → 2025.11.8-alpha-2

package/src/entities/Desktop/model/store.ts

@@ -2,18 +2,18 @@ import { defineStore } from 'pinia';
 import { computed, ref } from 'vue';
 import { RouteRecordRaw, type RouteMeta, type Router } from 'vue-router';
 import type {
-  IHealthResponse,
   IBackNavigationButton,
   IDesktopWithNavigation,
 } from './types';
 import { api } from '../api';
-import { useCurrentUser } from 'src/entities/Session';
 import { useSystemStore } from 'src/entities/System/model';
+import { useCurrentUser } from 'src/entities/Session';
 
 interface WorkspaceMenuItem {
   workspaceName: string;
   title: string;
   icon: string;
+  extensionName: string;
   mainRoute: RouteRecordRaw | null;
   meta: RouteMeta;
 }
@@ -21,11 +21,34 @@ interface WorkspaceMenuItem {
 const namespace = 'desktops';
 const STORAGE_KEY_WORKSPACE = 'monocoop-active-workspace';
 
+// Вспомогательные функции для безопасного доступа к localStorage (SSR-safe)
+function safeLocalStorageGetItem(key: string): string | null {
+  if (typeof window === 'undefined' || !window.localStorage) {
+    return null;
+  }
+  try {
+    return localStorage.getItem(key);
+  } catch (error) {
+    console.warn('Failed to read from localStorage:', error);
+    return null;
+  }
+}
+
+function safeLocalStorageSetItem(key: string, value: string): void {
+  if (typeof window === 'undefined' || !window.localStorage) {
+    return;
+  }
+  try {
+    localStorage.setItem(key, value);
+  } catch (error) {
+    console.warn('Failed to write to localStorage:', error);
+  }
+}
+
 export const useDesktopStore = defineStore(namespace, () => {
   const currentDesktop = ref<IDesktopWithNavigation>();
-  const health = ref<IHealthResponse>();
-  const online = ref<boolean>();
   const isWorkspaceChanging = ref<boolean>(false);
+  const leftDrawerOpen = ref<boolean>(true);
 
   async function loadDesktop(): Promise<void> {
     const newDesktop = await api.getDesktop();
@@ -49,16 +72,6 @@ export const useDesktopStore = defineStore(namespace, () => {
     isWorkspaceChanging.value = false;
   }
 
-  async function healthCheck(): Promise<void> {
-    try {
-      health.value = await api.healthCheck();
-      online.value = health.value.status !== 'maintenance';
-      if (!online.value) setTimeout(healthCheck, 10000);
-    } catch {
-      online.value = false;
-      setTimeout(healthCheck, 10000);
-    }
-  }
 
   function setRoutes(workspaceName: string, routes: RouteRecordRaw[]): void {
     if (!currentDesktop.value) return;
@@ -78,10 +91,15 @@ export const useDesktopStore = defineStore(namespace, () => {
         routes.length > 0 && routes[0].meta
           ? (routes[0].meta as RouteMeta)
           : { title: ws.title, icon: '', roles: [] };
+
+      // Приоритет иконки: 1) из workspace (с бэкенда), 2) из meta маршрута
+      const icon = (ws as any).icon || meta.icon || 'fa-solid fa-desktop';
+
       return {
         workspaceName: ws.name,
         title: ws.title,
-        icon: meta.icon,
+        icon,
+        extensionName: (ws as any).extension_name || 'unknown',
         mainRoute: routes.length > 0 ? routes[0] : null,
         meta,
       };
@@ -94,8 +112,8 @@ export const useDesktopStore = defineStore(namespace, () => {
   function selectWorkspace(name: string) {
     isWorkspaceChanging.value = true;
     activeWorkspaceName.value = name;
-    // Сохраняем выбранный рабочий стол в localStorage
-    localStorage.setItem(STORAGE_KEY_WORKSPACE, name);
+    // Сохраняем выбранный рабочий стол в localStorage (SSR-safe)
+    safeLocalStorageSetItem(STORAGE_KEY_WORKSPACE, name);
   }
 
   // Функция для определения и выбора дефолтного рабочего стола
@@ -103,37 +121,44 @@ export const useDesktopStore = defineStore(namespace, () => {
     // Сбрасываем состояние загрузки на случай если оно было установлено
     isWorkspaceChanging.value = false;
 
-    // Проверяем, был ли ранее сохранен рабочий стол
-    const savedWorkspace = localStorage.getItem(STORAGE_KEY_WORKSPACE);
+    // Проверяем, был ли ранее сохранен рабочий стол (SSR-safe)
+    const savedWorkspace = safeLocalStorageGetItem(STORAGE_KEY_WORKSPACE);
 
     if (
       savedWorkspace &&
       currentDesktop.value?.workspaces.some((ws) => ws.name === savedWorkspace)
     ) {
-      // Устанавливаем рабочий стол без включения состояния загрузки (это инициализация)
+      // Устанавливаем сохраненный рабочий стол без включения состояния загрузки (это инициализация)
       activeWorkspaceName.value = savedWorkspace;
-      localStorage.setItem(STORAGE_KEY_WORKSPACE, savedWorkspace);
       return;
     }
 
-    // Если нет сохраненного рабочего стола, определяем по правам пользователя
-    const userStore = useCurrentUser();
+    // Получаем настройки системы
+    const systemStore = useSystemStore();
+    const currentUser = useCurrentUser();
 
-    if (userStore.isMember || userStore.isChairman) {
-      // Для членов совета или председателя устанавливаем soviet
-      const hasSoviet = currentDesktop.value?.workspaces.some(
-        (ws) => ws.name === 'soviet',
-      );
-      if (hasSoviet) {
-        activeWorkspaceName.value = 'soviet';
-        localStorage.setItem(STORAGE_KEY_WORKSPACE, 'soviet');
-        return;
-      }
+    let defaultWorkspace = 'participant'; // дефолтное значение
+
+    // Определяем, какие настройки использовать (авторизованный или неавторизованный пользователь)
+    if (currentUser.isAuth) {
+      // Для авторизованных пользователей используем authorized_default_workspace
+      defaultWorkspace = systemStore.info?.settings?.authorized_default_workspace || 'participant';
+    } else {
+      // Для неавторизованных пользователей используем non_authorized_default_workspace
+      defaultWorkspace = systemStore.info?.settings?.non_authorized_default_workspace || 'participant';
     }
 
-    // В остальных случаях устанавливаем participant
+    // Проверяем, что выбранный рабочий стол доступен
+    const isWorkspaceAvailable = currentDesktop.value?.workspaces.some((ws) => ws.name === defaultWorkspace);
+
+    if (isWorkspaceAvailable) {
+      activeWorkspaceName.value = defaultWorkspace;
+      safeLocalStorageSetItem(STORAGE_KEY_WORKSPACE, defaultWorkspace);
+    } else {
+      // Если настроенный рабочий стол недоступен, используем participant
     activeWorkspaceName.value = 'participant';
-    localStorage.setItem(STORAGE_KEY_WORKSPACE, 'participant');
+    safeLocalStorageSetItem(STORAGE_KEY_WORKSPACE, 'participant');
+    }
   }
 
   const activeSecondLevelRoutes = computed((): RouteRecordRaw[] => {
@@ -190,13 +215,33 @@ export const useDesktopStore = defineStore(namespace, () => {
     isWorkspaceChanging.value = value;
   }
 
-  // Новый метод: перейти на маршрут по умолчанию для текущего рабочего стола
-  function goToDefaultPage(router: Router): void {
+  // Методы для управления левым drawer
+  function toggleLeftDrawer() {
+    leftDrawerOpen.value = !leftDrawerOpen.value;
+  }
+
+  function setLeftDrawerOpen(value: boolean) {
+    leftDrawerOpen.value = value;
+  }
+
+  function closeLeftDrawerOnMobile() {
+    // Проверяем, является ли устройство мобильным
+    const isMobile = window.innerWidth < 768;
+    if (isMobile) {
+      leftDrawerOpen.value = false;
+    }
+  }
+
+  // Новый метод: получить данные маршрута по умолчанию без выполнения перехода
+  function getDefaultPageRoute(): {
+    name: string;
+    params: Record<string, any>;
+  } | null {
     const { info } = useSystemStore();
-    console.log('on go. to default workspace');
+    const currentUser = useCurrentUser();
+
     if (!currentDesktop.value || !activeWorkspaceName.value) {
-      isWorkspaceChanging.value = false;
-      return;
+      return null;
     }
 
     // Найти текущий рабочий стол
@@ -205,22 +250,54 @@ export const useDesktopStore = defineStore(namespace, () => {
     );
 
     if (!currentWorkspace) {
-      isWorkspaceChanging.value = false;
-      return;
+      return null;
+    }
+
+    // Проверяем, есть ли настроенный маршрут для текущего рабочего стола
+    let configuredRoute: string | undefined;
+
+    if (currentUser.isAuth) {
+      // Для авторизованных пользователей используем authorized_default_route
+      configuredRoute = info?.settings?.authorized_default_route;
+    } else {
+      // Для неавторизованных пользователей используем non_authorized_default_route
+      configuredRoute = info?.settings?.non_authorized_default_route;
+    }
+
+    // Если настроенный маршрут существует, используем его
+    if (configuredRoute) {
+      // Глобальные маршруты (не принадлежащие конкретному workspace)
+      const globalRoutes = ['signin', 'signup', 'lostkey', 'resetkey', 'invite'];
+      if (globalRoutes.includes(configuredRoute)) {
+        return {
+          name: configuredRoute,
+          params: { coopname: info.coopname },
+        };
+      }
+
+      // Проверяем, что маршрут принадлежит текущему рабочему столу
+      const ws = workspaceMenus.value.find(
+        (menu) => menu.workspaceName === activeWorkspaceName.value,
+      );
+      if (
+        ws &&
+        ws.mainRoute &&
+        ws.mainRoute.children &&
+        ws.mainRoute.children.some((child: any) => child.name === configuredRoute)
+      ) {
+        return {
+          name: configuredRoute,
+          params: { coopname: info.coopname },
+        };
+      }
     }
 
-    // Проверяем наличие defaultRoute
+    // Если нет настроенного маршрута или он не найден, используем defaultRoute рабочего стола
     if ((currentWorkspace as any).defaultRoute) {
-      // Если есть defaultRoute, переходим на него
-      router.push({
+      return {
         name: (currentWorkspace as any).defaultRoute,
         params: { coopname: info.coopname },
-      });
-      // Устанавливаем небольшую задержку для плавного перехода
-      setTimeout(() => {
-        isWorkspaceChanging.value = false;
-      }, 500);
-      return;
+      };
     }
 
     // Если нет defaultRoute, ищем первый маршрут в детях основного маршрута
@@ -234,26 +311,38 @@ export const useDesktopStore = defineStore(namespace, () => {
       ws.mainRoute.children.length > 0
     ) {
       const firstChild = ws.mainRoute.children[0];
-      router.push({
+      return {
         name: firstChild.name as string,
         params: { coopname: info.coopname },
-      });
+      };
+    }
+
+    return null;
+  }
+
+  // Новый метод: перейти на маршрут по умолчанию для текущего рабочего стола
+  function goToDefaultPage(router: Router): void {
+    // Используем новую функцию для получения данных маршрута
+    const defaultPageRoute = getDefaultPageRoute();
+
+    if (defaultPageRoute) {
+      // Если маршрут найден, выполняем переход
+      router.push(defaultPageRoute);
       // Устанавливаем небольшую задержку для плавного перехода
       setTimeout(() => {
         isWorkspaceChanging.value = false;
       }, 500);
     } else {
+      // Если маршрут не найден, просто сбрасываем состояние загрузки
       isWorkspaceChanging.value = false;
     }
   }
 
   return {
     currentDesktop,
-    health,
-    online,
     isWorkspaceChanging,
+    leftDrawerOpen,
     loadDesktop,
-    healthCheck,
     setRoutes,
     workspaceMenus,
     activeWorkspaceName,
@@ -262,8 +351,12 @@ export const useDesktopStore = defineStore(namespace, () => {
     activeSecondLevelRoutes,
     registerWorkspaceMenus,
     removeWorkspace,
+    getDefaultPageRoute,
     goToDefaultPage,
     setWorkspaceChanging,
+    toggleLeftDrawer,
+    setLeftDrawerOpen,
+    closeLeftDrawerOnMobile,
     // Новые методы
     setBackNavigationButton,
     removeBackNavigationButton,

package/src/entities/Desktop/model/types.ts

@@ -1,22 +1,17 @@
-import type { Queries } from '@coopenomics/sdk';
+import type { Queries, Zeus } from '@coopenomics/sdk';
 
+//TODO: заменить здесь и на бэкенде на IExtension
 export type IDesktop = Queries.Desktop.GetDesktop.IOutput[typeof Queries.Desktop.GetDesktop.name]
 
+// Тип конфигурации рабочего стола из SDK
+export type IDesktopConfig = Zeus.ModelTypes['DesktopConfig']
+
 export interface IWorkspace {
   name: string;
   title: string;
   defaultRoute?: string; // Маршрут по умолчанию для этого рабочего стола
 }
 
-export interface ILegacyDesktop {
-  name: string;
-  hash: string;
-  authorizedHome: string;
-  nonAuthorizedHome: string;
-  routes: IRoute[];
-  config: object;
-}
-
 export interface IBlockchainDesktops {
   defaultHash: string; //hash
   availableHashes: string[]; //hashes
@@ -27,6 +22,7 @@ interface RouteMeta {
   icon: string;
   roles: string[];
   conditions: string;
+  hidden?: boolean;
 }
 
 export interface IRoute {
@@ -37,7 +33,6 @@ export interface IRoute {
   meta: RouteMeta;
 }
 
-export type { IHealthResponse } from '@coopenomics/controller'
 
 export interface IBackNavigationButton {
   text: string

package/src/entities/Document/model/types.ts

@@ -5,6 +5,8 @@ export type IDocumentAggregate = Zeus.ModelTypes['DocumentAggregate'];
 export type ZGetDocumentsResult = Queries.Documents.GetDocuments.IOutput[typeof Queries.Documents.GetDocuments.name];
 export type IGetDocuments = Queries.Documents.GetDocuments.IInput['data']
 export type ISignedDocument2 = Zeus.ModelTypes['SignedDigitalDocument']
+export type ISignedChainDocument = Zeus.ModelTypes['SignedBlockchainDocument']
+
 // Информация о пагинации
 export interface IPagination {
   totalCount: number;

package/src/entities/Installer/model/store.ts

@@ -1,5 +1,6 @@
 import { defineStore } from 'pinia';
 import { IIndividualData } from 'src/shared/lib/types/user/IUserData';
+import { ICreateOrganizationData } from 'src/shared/ui/UserDataForm/CreateOrganizationDataForm';
 import { Ref, ref } from 'vue';
 
 interface data {
@@ -9,10 +10,39 @@ interface data {
   individual_data: IIndividualData
 }
 
+interface IAgreementVar {
+  protocol_number: string;
+  protocol_day_month_year: string;
+}
+
+interface IVars {
+  coopname: string;
+  full_abbr: string;
+  full_abbr_genitive: string;
+  full_abbr_dative: string;
+  short_abbr: string;
+  website: string;
+  name: string;
+  confidential_link: string;
+  confidential_email: string;
+  contact_email: string;
+  passport_request: 'yes' | 'no';
+  wallet_agreement: IAgreementVar;
+  privacy_agreement: IAgreementVar;
+  signature_agreement: IAgreementVar;
+  user_agreement: IAgreementVar;
+  participant_application: IAgreementVar;
+  coopenomics_agreement?: IAgreementVar | null;
+}
+
 interface IInstallCooperative {
   wif: Ref<string | undefined>
   is_finish: Ref<boolean>
   soviet: Ref<data[]>
+  vars: Ref<IVars | undefined>
+  organization_data: Ref<ICreateOrganizationData | undefined>
+  current_step: Ref<'key' | 'init' | 'soviet' | 'vars'>
+  install_code: Ref<string | undefined>
 }
 
 const namespace = 'install';
@@ -24,11 +54,19 @@ export const useInstallCooperativeStore = defineStore(
     const soviet = ref([])
     const is_finish = ref(false)
     const wif = ref()
+    const vars = ref<IVars>()
+    const organization_data = ref<ICreateOrganizationData>()
+    const current_step = ref<'key' | 'init' | 'soviet' | 'vars'>('key')
+    const install_code = ref()
 
     return {
       soviet,
       is_finish,
-      wif
+      wif,
+      vars,
+      organization_data,
+      current_step,
+      install_code
     }
   }, {
     persist: true,

package/src/entities/LedgerAccount/api/index.ts

@@ -0,0 +1,43 @@
+import { client } from 'src/shared/api/client';
+import { Queries } from '@coopenomics/sdk';
+import type {
+  IGetLedgerInput,
+  ILedgerState,
+  IGetLedgerHistoryInput,
+  ILedgerHistoryResponse,
+} from '../types';
+
+async function getLedger(
+  data: IGetLedgerInput,
+): Promise<ILedgerState | undefined> {
+  const { [Queries.Ledger.GetLedger.name]: output } = await client.Query(
+    Queries.Ledger.GetLedger.query,
+    {
+      variables: {
+        data,
+      },
+    },
+  );
+
+  return output;
+}
+
+async function getLedgerHistory(
+  data: IGetLedgerHistoryInput,
+): Promise<ILedgerHistoryResponse | undefined> {
+  const { [Queries.Ledger.GetLedgerHistory.name]: output } = await client.Query(
+    Queries.Ledger.GetLedgerHistory.query,
+    {
+      variables: {
+        data,
+      },
+    },
+  );
+
+  return output;
+}
+
+export const api = {
+  getLedger,
+  getLedgerHistory,
+};

package/src/entities/LedgerAccount/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './model';

package/src/entities/LedgerAccount/model/index.ts

@@ -0,0 +1,2 @@
+export * from './store';
+export * from './useLocalLedgerHistory';

package/src/entities/LedgerAccount/model/store.ts

@@ -0,0 +1,30 @@
+import { defineStore } from 'pinia';
+import { ref, type Ref } from 'vue';
+import { api } from '../api';
+import type { IGetLedgerInput, ILedgerState } from '../types';
+
+const namespace = 'ledgerAccountStore';
+
+interface ILedgerAccountStore {
+  ledgerState: Ref<ILedgerState | undefined>;
+  getLedgerState: (data: IGetLedgerInput) => Promise<ILedgerState | undefined>;
+}
+
+export const useLedgerAccountStore = defineStore(
+  namespace,
+  (): ILedgerAccountStore => {
+    const ledgerState = ref<ILedgerState>();
+
+    const getLedgerState = async (
+      data: IGetLedgerInput,
+    ): Promise<ILedgerState | undefined> => {
+      ledgerState.value = await api.getLedger(data);
+      return ledgerState.value;
+    };
+
+    return {
+      ledgerState,
+      getLedgerState,
+    };
+  },
+);

package/src/entities/LedgerAccount/model/useLocalLedgerHistory.ts

@@ -0,0 +1,130 @@
+import { ref, type Ref } from 'vue';
+import { api } from '../api';
+import type {
+  ILedgerHistoryFilter,
+  ILedgerOperation,
+  ILedgerHistoryPagination,
+} from '../types';
+
+/**
+ * Композабл для локального состояния истории операций ledger
+ * Каждый виджет может использовать свой экземпляр для независимого состояния
+ */
+export function useLocalLedgerHistory() {
+  // Локальное состояние
+  const operations = ref<ILedgerOperation[]>([]);
+  const loading = ref(false);
+  const pagination = ref<ILedgerHistoryPagination>({
+    currentPage: 0,
+    totalPages: 0,
+    totalCount: 0,
+  });
+  const hasMore = ref(true);
+  const filter = ref<ILedgerHistoryFilter | null>(null);
+
+  /**
+   * Загрузка первой страницы истории операций
+   */
+  const loadHistory = async (
+    filterParams: ILedgerHistoryFilter,
+  ): Promise<void> => {
+    try {
+      loading.value = true;
+      filter.value = { ...filterParams, page: 1, limit: 20 };
+
+      const response = await api.getLedgerHistory(filter.value);
+
+      if (response) {
+        operations.value = response.items || [];
+        pagination.value = {
+          currentPage: response.currentPage || 1,
+          totalPages: response.totalPages || 1,
+          totalCount: response.totalCount || 0,
+        };
+        hasMore.value =
+          pagination.value.currentPage < pagination.value.totalPages;
+      }
+    } catch (error) {
+      console.error('Ошибка загрузки истории операций:', error);
+      throw error;
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  /**
+   * Загрузка следующей страницы для бесконечного скролла
+   */
+  const loadMoreHistory = async (): Promise<void> => {
+    if (!hasMore.value || loading.value || !filter.value) {
+      return;
+    }
+
+    try {
+      loading.value = true;
+      const nextPage = pagination.value.currentPage + 1;
+
+      const nextPageFilter = {
+        ...filter.value,
+        page: nextPage,
+      };
+
+      const response = await api.getLedgerHistory(nextPageFilter);
+
+      if (response && response.items) {
+        // Добавляем новые операции к существующим
+        operations.value.push(...response.items);
+        pagination.value = {
+          currentPage: response.currentPage || nextPage,
+          totalPages: response.totalPages || pagination.value.totalPages,
+          totalCount: response.totalCount || pagination.value.totalCount,
+        };
+        hasMore.value =
+          pagination.value.currentPage < pagination.value.totalPages;
+      }
+    } catch (error) {
+      console.error('Ошибка загрузки следующей страницы:', error);
+      throw error;
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  /**
+   * Сброс состояния
+   */
+  const resetHistory = (): void => {
+    operations.value = [];
+    pagination.value = {
+      currentPage: 0,
+      totalPages: 0,
+      totalCount: 0,
+    };
+    hasMore.value = true;
+    filter.value = null;
+  };
+
+  /**
+   * Изменение фильтров и перезагрузка данных
+   */
+  const changeFilter = async (
+    newFilter: ILedgerHistoryFilter,
+  ): Promise<void> => {
+    resetHistory();
+    await loadHistory(newFilter);
+  };
+
+  return {
+    // Состояние
+    operations: operations as Ref<ILedgerOperation[]>,
+    loading: loading as Ref<boolean>,
+    pagination: pagination as Ref<ILedgerHistoryPagination>,
+    hasMore: hasMore as Ref<boolean>,
+
+    // Методы
+    loadHistory,
+    loadMoreHistory,
+    resetHistory,
+    changeFilter,
+  };
+}

package/src/entities/LedgerAccount/types.ts

@@ -0,0 +1,28 @@
+import type { Queries, Zeus } from '@coopenomics/sdk';
+
+export type ILedgerState =
+  Queries.Ledger.GetLedger.IOutput[typeof Queries.Ledger.GetLedger.name];
+export type IGetLedgerInput = Queries.Ledger.GetLedger.IInput['data'];
+export type ILedgerAccount = Zeus.ModelTypes['ChartOfAccountsItem'];
+
+// Типы для истории операций ledger
+export type ILedgerHistoryResponse =
+  Queries.Ledger.GetLedgerHistory.IOutput[typeof Queries.Ledger.GetLedgerHistory.name];
+export type IGetLedgerHistoryInput =
+  Queries.Ledger.GetLedgerHistory.IInput['data'];
+export type ILedgerOperation = Zeus.ModelTypes['LedgerOperation'];
+
+// Интерфейс для пагинации истории операций
+export interface ILedgerHistoryPagination {
+  currentPage: number;
+  totalPages: number;
+  totalCount: number;
+}
+
+// Интерфейс для параметров фильтрации истории
+export interface ILedgerHistoryFilter {
+  coopname: string;
+  account_id?: number;
+  page?: number;
+  limit?: number;
+}