@coopenomics/desktop 2025.7.3 → 2025.11.8-alpha-2

package/src/shared/hooks/useRightDrawer.ts

@@ -0,0 +1,81 @@
+import { ref, onBeforeUnmount, type Component, markRaw } from 'vue';
+
+export interface RightDrawerAction {
+  id: string;
+  component: Component;
+  props?: Record<string, any>;
+  order?: number;
+}
+
+const rightDrawerActions = ref<RightDrawerAction[]>([]);
+
+export const useRightDrawer = () => {
+  const registeredActions = ref<string[]>([]);
+
+  const registerAction = (action: RightDrawerAction) => {
+    // Проверяем, не зарегистрирован ли уже такой ID
+    const existingIndex = rightDrawerActions.value.findIndex(
+      (a) => a.id === action.id,
+    );
+
+    // Создаем действие с markRaw для компонента
+    const actionWithMarkRaw = {
+      ...action,
+      component: markRaw(action.component),
+    };
+
+    if (existingIndex > -1) {
+      // Обновляем существующий
+      rightDrawerActions.value[existingIndex] = actionWithMarkRaw;
+    } else {
+      // Добавляем новый
+      rightDrawerActions.value.push(actionWithMarkRaw);
+    }
+
+    // Сортируем по порядку
+    rightDrawerActions.value.sort((a, b) => (a.order || 0) - (b.order || 0));
+
+    // Запоминаем что мы зарегистрировали
+    if (!registeredActions.value.includes(action.id)) {
+      registeredActions.value.push(action.id);
+    }
+  };
+
+  const unregisterAction = (actionId: string) => {
+    const index = rightDrawerActions.value.findIndex((a) => a.id === actionId);
+    if (index > -1) {
+      rightDrawerActions.value.splice(index, 1);
+    }
+
+    const registeredIndex = registeredActions.value.indexOf(actionId);
+    if (registeredIndex > -1) {
+      registeredActions.value.splice(registeredIndex, 1);
+    }
+  };
+
+  const clearActions = () => {
+    // Очищаем только те действия, которые зарегистрировал этот компонент
+    registeredActions.value.forEach((actionId) => {
+      unregisterAction(actionId);
+    });
+    registeredActions.value = [];
+  };
+
+  // Автоматически очищаем при размонтировании компонента
+  onBeforeUnmount(() => {
+    clearActions();
+  });
+
+  return {
+    registerAction,
+    unregisterAction,
+    clearActions,
+  };
+};
+
+// Отдельный composable для чтения состояния (для default.vue)
+export const useRightDrawerReader = () => {
+  return {
+    rightDrawerActions,
+  };
+};

package/src/shared/lib/composables/index.ts

@@ -1 +1,3 @@
-export { useMeetStatus } from './useMeetStatus'
+export { useMeetStatus } from './useMeetStatus';
+export { useExpandableState } from './useExpandableState';
+export { useDataPoller } from './useDataPoller';

package/src/shared/lib/composables/useDataPoller.ts

@@ -0,0 +1,132 @@
+import { ref, Ref, watch, onUnmounted } from 'vue';
+
+/**
+ * Опции для composable useDataPoller
+ */
+export interface UseDataPollerOptions {
+  /** Интервал обновления в миллисекундах (по умолчанию 20000 = 20 сек) */
+  interval?: number;
+  /** Запускать poll сразу при создании (по умолчанию true) */
+  immediate?: boolean;
+  /** Включение/выключение poll (реактивное) */
+  enabled?: Ref<boolean>;
+}
+
+/**
+ * Composable для периодического обновления данных с поддержкой паузы при неактивной вкладке
+ *
+ * @param fetchFn - Функция для загрузки данных
+ * @param options - Опции конфигурации
+ * @returns Объект с методами управления poll
+ */
+export function useDataPoller<T>(
+  fetchFn: () => Promise<T>,
+  options: UseDataPollerOptions = {}
+) {
+  const {
+    interval = 20000,
+    immediate = true,
+    enabled = ref(true),
+  } = options;
+
+  // Состояние polling
+  const isPolling = ref(false);
+  const intervalId = ref<any>(null);
+
+  // Состояние видимости страницы
+  const isPageVisible = ref(!document.hidden);
+
+  /**
+   * Обработчик изменения видимости страницы
+   */
+  const handleVisibilityChange = () => {
+    isPageVisible.value = !document.hidden;
+
+    if (isPageVisible.value && enabled.value && !isPolling.value) {
+      // Возобновляем poll при возвращении на страницу
+      startPolling();
+    } else if (!isPageVisible.value && isPolling.value) {
+      // Останавливаем poll при уходе со страницы
+      stopPolling();
+    }
+  };
+
+  /**
+   * Запуск периодического обновления
+   */
+  const startPolling = () => {
+    if (isPolling.value || !enabled.value || !isPageVisible.value) {
+      return;
+    }
+
+    isPolling.value = true;
+
+    // Немедленно выполняем первый запрос
+    fetchFn().catch((error) => {
+      console.warn('Poll fetch error:', error);
+      // Не прерываем poll при ошибке
+    });
+
+    // Запускаем интервал
+    intervalId.value = setInterval(async () => {
+      if (!enabled.value || !isPageVisible.value) {
+        stopPolling();
+        return;
+      }
+
+      try {
+        await fetchFn();
+      } catch (error) {
+        console.warn('Poll fetch error:', error);
+        // Продолжаем poll несмотря на ошибку
+      }
+    }, interval);
+  };
+
+  /**
+   * Остановка периодического обновления
+   */
+  const stopPolling = () => {
+    if (intervalId.value) {
+      clearInterval(intervalId.value);
+      intervalId.value = null;
+    }
+    isPolling.value = false;
+  };
+
+  // Отслеживаем изменение enabled
+  watch(enabled, (newEnabled) => {
+    if (newEnabled && isPageVisible.value && !isPolling.value) {
+      startPolling();
+    } else if (!newEnabled && isPolling.value) {
+      stopPolling();
+    }
+  });
+
+  // Подписываемся на события видимости страницы
+  // if (typeof document !== 'undefined') {
+  //   document.addEventListener('visibilitychange', handleVisibilityChange);
+  // }
+
+  // Запускаем poll при создании, если immediate = true
+  if (immediate && enabled.value && isPageVisible.value) {
+    startPolling();
+  }
+
+  // Очистка при уничтожении компонента
+  onUnmounted(() => {
+    stopPolling();
+    if (typeof document !== 'undefined') {
+      document.removeEventListener('visibilitychange', handleVisibilityChange);
+    }
+  });
+
+  return {
+    /** Запуск polling */
+    start: startPolling,
+    /** Остановка polling */
+    stop: stopPolling,
+    /** Состояние polling (реактивное) */
+    isPolling,
+  };
+}

package/src/shared/lib/composables/useEditableData.ts

@@ -15,7 +15,7 @@ export function useEditableData<T extends Record<string, any>>(
   const validateForm = async () => {
     if (formRef?.value) {
       const valid = await formRef.value.validate();
-      isDisabled.value = !valid; // Блокируем действия, если форма невалидна
+      isDisabled.value = valid === false; // Блокируем действия, только если форма невалидна
     }
   };
 

package/src/shared/lib/composables/useExpandableState.ts

@@ -0,0 +1,131 @@
+import { ref } from 'vue';
+import { LocalStorage } from 'quasar';
+
+/**
+ * Композабл для управления состоянием развернутости элементов с сохранением в LocalStorage
+ * @param storageKey - Ключ для сохранения состояния в LocalStorage
+ * @param itemsGetter - Функция, возвращающая массив текущих элементов для очистки устаревших записей
+ * @param itemKeyGetter - Функция, извлекающая ключ из элемента
+ * @returns Объект с состоянием expanded и методами для работы с ним
+ */
+export function useExpandableState<T>(
+  storageKey: string,
+  itemsGetter?: () => T[] | undefined,
+  itemKeyGetter?: (item: T) => string,
+) {
+  // Состояние развернутости элементов
+  const expanded = ref<Record<string, boolean>>({});
+
+  /**
+   * Загружает сохраненное состояние из LocalStorage
+   */
+  const loadExpandedState = () => {
+    const saved = LocalStorage.getItem(storageKey);
+    if (saved && typeof saved === 'object') {
+      Object.entries(saved).forEach(([key, value]) => {
+        if (typeof value === 'boolean') {
+          expanded.value[key] = value;
+        }
+      });
+    }
+  };
+
+  /**
+   * Сохраняет текущее состояние в LocalStorage
+   */
+  const saveExpandedState = () => {
+    LocalStorage.set(storageKey, { ...expanded.value });
+  };
+
+  /**
+   * Очищает устаревшие записи из expanded состояния
+   * Удаляет записи для элементов, которых больше нет в текущем списке
+   */
+  const cleanupExpandedState = () => {
+    // Работает только если переданы itemsGetter и itemKeyGetter
+    if (!itemsGetter || !itemKeyGetter) return;
+
+    const currentItems = itemsGetter();
+    if (!currentItems) return;
+
+    const currentItemKeys = new Set(currentItems.map(itemKeyGetter));
+    const expandedKeys = Object.keys(expanded.value);
+
+    // Удаляем из expanded элементы, которых больше нет в списке
+    expandedKeys.forEach((key) => {
+      if (!currentItemKeys.has(key)) {
+        delete expanded.value[key];
+      }
+    });
+
+    // Сохраняем очищенное состояние
+    saveExpandedState();
+  };
+
+  /**
+   * Переключает состояние развернутости для указанного элемента
+   * @param itemKey - Ключ элемента
+   */
+  const toggleExpanded = (itemKey: string) => {
+    expanded.value[itemKey] = !(expanded.value[itemKey] || false);
+    saveExpandedState();
+  };
+
+  /**
+   * Устанавливает состояние развернутости для указанного элемента
+   * @param itemKey - Ключ элемента
+   * @param isExpanded - Новое состояние
+   */
+  const setExpanded = (itemKey: string, isExpanded: boolean) => {
+    expanded.value[itemKey] = isExpanded;
+    saveExpandedState();
+  };
+
+  /**
+   * Получает состояние развернутости для указанного элемента
+   * @param itemKey - Ключ элемента
+   * @returns true если элемент развернут, false в противном случае
+   */
+  const isExpanded = (itemKey: string): boolean => {
+    return expanded.value[itemKey] || false;
+  };
+
+  /**
+   * Очищает устаревшие записи из expanded состояния по массиву актуальных ключей
+   * Удаляет записи для элементов, которых нет в переданном массиве
+   */
+  const cleanupExpandedByKeys = (currentKeys: string[]) => {
+    const currentKeysSet = new Set(currentKeys);
+    const expandedKeys = Object.keys(expanded.value);
+
+    // Удаляем из expanded элементы, которых больше нет в списке
+    expandedKeys.forEach((key) => {
+      if (!currentKeysSet.has(key)) {
+        delete expanded.value[key];
+      }
+    });
+
+    // Сохраняем очищенное состояние
+    saveExpandedState();
+  };
+
+  /**
+   * Очищает все состояния развернутости
+   */
+  const clearAllExpanded = () => {
+    Object.keys(expanded.value).forEach(key => delete expanded.value[key]);
+    LocalStorage.remove(storageKey);
+  };
+
+  return {
+    expanded,
+    loadExpandedState,
+    saveExpandedState,
+    cleanupExpandedState,
+    cleanupExpandedByKeys,
+    toggleExpanded,
+    setExpanded,
+    isExpanded,
+    clearAllExpanded,
+  };
+}

package/src/shared/lib/composables/usePWAThemeColor.ts

@@ -0,0 +1,26 @@
+import { computed, watch } from 'vue';
+import { useQuasar } from 'quasar';
+import { updatePWAThemeColor } from '../utils/theme';
+
+/**
+ * Composable для автоматического обновления PWA theme-color
+ * при изменении темы Quasar
+ */
+export function usePWAThemeColor() {
+  const $q = useQuasar();
+  const isDark = computed(() => $q.dark.isActive);
+
+  // Обновляем theme-color при изменении темы
+  watch(
+    isDark,
+    (newIsDark) => {
+      updatePWAThemeColor(newIsDark);
+    },
+    { immediate: true },
+  );
+
+  return {
+    isDark,
+    updatePWAThemeColor,
+  };
+}

package/src/shared/lib/consts/index.ts

@@ -1 +1,2 @@
 export * from './meet-statuses'
+export * from './poll'

package/src/shared/lib/consts/poll.ts

@@ -0,0 +1,27 @@
+/**
+ * Константы интервалов для периодического обновления данных (poll)
+ * Все интервалы указаны в миллисекундах
+ */
+
+// Быстрое обновление для динамичных данных (списки, голосования)
+export const POLL_INTERVAL_FAST = 10000; // 10 секунд
+
+// Среднее обновление для основных страниц
+export const POLL_INTERVAL_MEDIUM = 20000; // 20 секунд
+
+// Медленное обновление для статичных страниц
+export const POLL_INTERVAL_SLOW = 30000; // 30 секунд
+
+// Типы страниц для poll интервалов
+export const POLL_INTERVALS = {
+  // Быстрое обновление
+  FAST: POLL_INTERVAL_FAST,
+
+  // Среднее обновление
+  MEDIUM: POLL_INTERVAL_MEDIUM,
+
+  // Медленное обновление
+  SLOW: POLL_INTERVAL_SLOW,
+} as const;
+
+export type PollIntervalType = keyof typeof POLL_INTERVALS;

package/src/shared/lib/decision-factory/index.ts

@@ -0,0 +1,82 @@
+import type { DecisionHandlersRegistry, IDecisionHandler, IGenerateDecisionData } from '../types/decision-factory'
+
+/**
+ * Фабрика обработчиков решений
+ * Позволяет расширениям регистрировать свои обработчики для различных типов решений
+ */
+class DecisionFactory {
+  private handlers: DecisionHandlersRegistry = {}
+
+  /**
+   * Регистрирует обработчик для типа решения
+   * @param decisionType - тип решения (ключ из decisionsRegistry)
+   * @param handler - обработчик решения
+   */
+  registerHandler(decisionType: string, handler: IDecisionHandler): void {
+    this.handlers[decisionType] = handler
+  }
+
+  /**
+   * Получает обработчик для типа решения
+   * @param decisionType - тип решения
+   * @returns обработчик или undefined если не найден
+   */
+  getHandler(decisionType: string): IDecisionHandler | undefined {
+    return this.handlers[decisionType]
+  }
+
+  /**
+   * Проверяет, зарегистрирован ли обработчик для типа решения
+   * @param decisionType - тип решения
+   * @returns true если обработчик зарегистрирован
+   */
+  hasHandler(decisionType: string): boolean {
+    return decisionType in this.handlers
+  }
+
+  /**
+   * Генерирует документ решения используя зарегистрированный обработчик
+   * @param decisionType - тип решения
+   * @param data - данные для генерации
+   * @returns сгенерированный документ
+   * @throws Error если обработчик не найден или произошла ошибка генерации
+   */
+  async generateDocument(decisionType: string, data: IGenerateDecisionData): Promise<any> {
+    const handler = this.getHandler(decisionType)
+
+    if (!handler) {
+      throw new Error(`Не найден обработчик для типа решения: ${decisionType}`)
+    }
+
+    try {
+      return await handler.generateHandler(data)
+    } catch (error) {
+      console.error(`Ошибка при генерации документа решения типа ${decisionType}:`, error)
+      throw new Error(`Ошибка при генерации документа решения: ${error instanceof Error ? error.message : 'Неизвестная ошибка'}`)
+    }
+  }
+
+  /**
+   * Получает компонент дополнительной информации для типа решения
+   * @param decisionType - тип решения
+   * @returns компонент или undefined если не задан
+   */
+  getInfoComponent(decisionType: string): IDecisionHandler['infoComponent'] {
+    const handler = this.getHandler(decisionType)
+    return handler?.infoComponent
+  }
+
+  /**
+   * Получает список всех зарегистрированных типов решений
+   * @returns массив типов решений
+   */
+  getRegisteredTypes(): string[] {
+    return Object.keys(this.handlers)
+  }
+}
+
+// Глобальный экземпляр фабрики
+export const decisionFactory = new DecisionFactory()
+
+export { DecisionFactory }
+export type { DecisionHandlersRegistry, IDecisionHandler, IGenerateDecisionData }

package/src/shared/lib/navigation/useBackButton.ts

@@ -1,5 +1,5 @@
 import { onMounted, onUnmounted } from 'vue'
-import { useRouter } from 'vue-router'
+import { useRouter, useRoute } from 'vue-router'
 import { useDesktopStore } from 'src/entities/Desktop/model'
 import type { IBackNavigationButton } from 'src/entities/Desktop/model/types'
 
@@ -19,16 +19,21 @@ interface BackButtonOptions {
  */
 export function useBackButton(options: BackButtonOptions) {
   const router = useRouter()
+  const route = useRoute()
   const desktopStore = useDesktopStore()
-  
+
   // Устанавливаем кнопку навигации назад
   function setBackButton() {
+    // Проверяем, есть ли флаг принудительного использования router.back()
+    const forceHistoryBack = route.query._useHistoryBack === 'true'
+
     // Формируем данные для кнопки
     const button: IBackNavigationButton = {
       text: options.text,
       componentId: options.componentId,
       onClick: options.onClick || (() => {
-        if (options.routeName) {
+        // Приоритет: явно заданный routeName (если нет флага принудительного history back) > router.back()
+        if (options.routeName && !forceHistoryBack) {
           router.push({
             name: options.routeName,
             params: options.params || {}
@@ -38,26 +43,26 @@ export function useBackButton(options: BackButtonOptions) {
         }
       })
     }
-    
+
     desktopStore.setBackNavigationButton(button)
   }
-  
+
   // Удаляем кнопку навигации назад
   function removeBackButton() {
     desktopStore.removeBackNavigationButton(options.componentId)
   }
-  
+
   // Автоматически устанавливаем и удаляем кнопку
   onMounted(() => {
     setBackButton()
   })
-  
+
   onUnmounted(() => {
     removeBackButton()
   })
-  
+
   return {
     setBackButton,
     removeBackButton
   }
-} 
+}

package/src/shared/lib/types/decision-factory.ts

@@ -0,0 +1,36 @@
+import type { Component } from 'vue'
+import type { IAgenda } from 'src/entities/Agenda/model'
+
+/**
+ * Интерфейс данных для генерации документа решения
+ */
+export interface IGenerateDecisionData {
+  decision_id: number
+  username: string
+  row: IAgenda
+}
+
+/**
+ * Функция генерации документа решения
+ */
+export type GenerateDecisionHandler = (data: IGenerateDecisionData) => Promise<any>
+
+/**
+ * Компонент для отображения дополнительной информации по решению
+ */
+export type DecisionInfoComponent = Component<{ agenda: IAgenda }>
+
+/**
+ * Описание обработчика решения
+ */
+export interface IDecisionHandler {
+  /** Функция генерации документа */
+  generateHandler: GenerateDecisionHandler
+  /** Компонент для дополнительной информации (опционально) */
+  infoComponent?: DecisionInfoComponent
+}
+
+/**
+ * Реестр обработчиков решений
+ */
+export type DecisionHandlersRegistry = Record<string, IDecisionHandler>

package/src/shared/lib/types/document/index.ts

@@ -11,3 +11,6 @@ export type IDocument<T = any> = Omit<Zeus.ModelTypes['SignedDigitalDocumentInpu
 }
 // Для обратной совместимости
 export type IObjectedDocument = IDocument;
+export type IGenerateDocumentInput = Zeus.ModelTypes['GenerateDocumentInput'];
+export type IGenerateDocumentOptionsInput = Zeus.ModelTypes['GenerateDocumentOptionsInput'];
+export type IGeneratedDocumentOutput = Zeus.ModelTypes['GeneratedDocument'];

package/src/shared/lib/types/user/IUserData.ts

@@ -5,23 +5,29 @@ export type IEntrepreneurData = Cooperative.Users.IEntrepreneurData;
 export type IIndividualData = Cooperative.Users.IIndividualData;
 export type IOrganizationData = Cooperative.Users.IOrganizationData;
 
-type OmitUsername<T> = Omit<T, 'username'>;
-
-export type ICreateEntrepreneurData = OmitUsername<Cooperative.Users.IEntrepreneurData>;
-export type ICreateIndividualData = OmitUsername<Cooperative.Users.IIndividualData>;
-export type ICreateOrganizationData = OmitUsername<Cooperative.Users.IOrganizationData>;
+type OmitUsernameAndEmail<T> = Omit<T, 'username' | 'email'>;
 
+export type ICreateEntrepreneurData =
+  OmitUsernameAndEmail<Cooperative.Users.IEntrepreneurData>;
+export type ICreateIndividualData =
+  OmitUsernameAndEmail<Cooperative.Users.IIndividualData>;
+export type ICreateOrganizationData =
+  OmitUsernameAndEmail<Cooperative.Users.IOrganizationData>;
 
 export interface IUserData {
-  type: 'individual' | 'entrepreneur' | 'organization';
-  entrepreneur_data?: ICreateEntrepreneurData & {bank_account: Cooperative.Payments.IBankAccount};
+  type: 'individual' | 'entrepreneur' | 'organization' | null;
+  entrepreneur_data?: ICreateEntrepreneurData & {
+    bank_account: Cooperative.Payments.IBankAccount;
+  };
   individual_data?: ICreateIndividualData;
-  organization_data?: ICreateOrganizationData & {bank_account: Cooperative.Payments.IBankAccount};
+  organization_data?: ICreateOrganizationData & {
+    bank_account: Cooperative.Payments.IBankAccount;
+  };
+  email?: string;
+  username?: string;
 }
 
-
-
-export type IRegisterAccount = Mutations.Accounts.RegisterAccount.IInput['data'];
-export type IRegisteredAccountResult = Mutations.Accounts.RegisterAccount.IOutput[typeof Mutations.Accounts.RegisterAccount.name];
-
-
+export type IRegisterAccount =
+  Mutations.Accounts.RegisterAccount.IInput['data'];
+export type IRegisteredAccountResult =
+  Mutations.Accounts.RegisterAccount.IOutput[typeof Mutations.Accounts.RegisterAccount.name];

package/src/shared/lib/types/workspace.ts

@@ -17,8 +17,10 @@ export interface IWorkspaceRoute {
 }
 
 export interface IWorkspaceConfig {
-  workspace: string
-  title?: string
+  workspace: string // Уникальное имя workspace (например: 'soviet', 'chairman')
+  extension_name: string // Имя расширения, которому принадлежит этот workspace
+  title?: string // Отображаемое название workspace
+  icon?: string // Иконка для меню
   defaultRoute?: string // Имя маршрута для перехода по умолчанию
   routes: IWorkspaceRoute[]
 }