@coopenomics/desktop 2.2.10 → 2025.5.2

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

@@ -1,135 +1,141 @@
 import { defineStore } from 'pinia'
-import * as Desktops from 'src/desktops'
-import { computed, ComputedRef, ref, Ref } from 'vue'
-import { FailAlert } from 'src/shared/api'
-import { RouteRecordRaw, type RouteLocationNormalized} from 'vue-router'
-import { IDesktop, IRoute, IBlockchainDesktops, IHealthResponse } from './types'
+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'
 
-const desktopHashMap = {
-  'hash1': Desktops.UserDesktopModel.manifest, //User
-  'hash2': Desktops.ChairmanDesktopModel.manifest, //'Chairman',
-  'hash3': Desktops.MemberDesktopModel.manifest, //'Member',
-  'hash4': Desktops.SetupDesktopModel.manifest, //Setup
+interface WorkspaceMenuItem {
+  workspaceName: string
+  title: string
+  icon: string
+  mainRoute: RouteRecordRaw | null
+  meta: RouteMeta
 }
 
-const namespace = 'desktops';
-
-interface IDesktopStore {
-  online: Ref<boolean | undefined>
-  health: Ref<IHealthResponse | undefined>
-  currentDesktop: Ref<IDesktop | undefined>
-  availableDesktops: Ref<IDesktop[]>
-  defaultDesktopHash: Ref<string | undefined>
-  healthCheck: () => Promise<void>;
-  setActiveDesktop: (hash: string | undefined) => void;
-  loadDesktops: () => Promise<void>;
-  getSecondLevel: (currentRoute: RouteLocationNormalized) => RouteRecordRaw[]
-  firstLevel: ComputedRef<IRoute[]>;
-}
-
-
-function getNestedRoutes(route: RouteRecordRaw):RouteRecordRaw[]  {
-  if (!route.children) {
-    return [];
-  }
-
-  let nestedRoutes: RouteRecordRaw[] = [];
-
-  for (const child of route.children) {
-    nestedRoutes.push(child);
-    nestedRoutes = nestedRoutes.concat(getNestedRoutes(child));
+const namespace = 'desktops'
+
+export const useDesktopStore = defineStore(namespace, () => {
+  const currentDesktop = ref<IDesktopWithNavigation>()
+  const health = ref<IHealthResponse>()
+  const online = ref<boolean>()
+
+  async function loadDesktop(): Promise<void> {
+    const newDesktop = await api.getDesktop();
+    // Если уже есть расширения, мерджим маршруты
+    if (currentDesktop.value && currentDesktop.value.workspaces) {
+      newDesktop.workspaces.forEach(newWs => {
+        const oldWs = currentDesktop.value?.workspaces.find(ws => ws.name === newWs.name);
+        if (oldWs && (oldWs as any).routes) {
+          (newWs as any).routes = (oldWs as any).routes;
+        }
+      });
+    }
+    // Добавляем поле backNavigationButton если оно отсутствует
+    currentDesktop.value = {
+      ...newDesktop,
+      backNavigationButton: currentDesktop.value?.backNavigationButton || null
+    };
   }
 
-  return nestedRoutes;
-}
-
-export const useDesktopStore = defineStore(namespace, (): IDesktopStore => {
-  const currentDesktop = ref<IDesktop>()
-  const availableDesktops = ref<IDesktop[]>([])
-  const defaultDesktopHash = ref<string>()
-  const health = ref<IHealthResponse | undefined>()
-  const online = ref<boolean | undefined>()
-
-
-
   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);
+    }
+  }
 
-      health.value = await api.healthCheck()
-
-      if (health.value.status != 'maintenance'){
-        if (online.value === false){
-          online.value = true
-        }
-      } else {
-        online.value = false
-        setTimeout(healthCheck, 10000)
-      }
-
-    } catch (e) {
-      online.value = false
-      setTimeout(healthCheck, 10000)
+  function setRoutes(workspaceName: string, routes: RouteRecordRaw[]): void {
+    if (!currentDesktop.value) return;
+    const ws = currentDesktop.value.workspaces.find(w => w.name === workspaceName);
+    if (ws) {
+      (ws as any).routes = routes;
     }
   }
 
-  const firstLevel = computed(() => {
-    if (currentDesktop.value)
-      return currentDesktop.value.routes
-    else return []
+  const workspaceMenus = computed<WorkspaceMenuItem[]>(() => {
+    if (!currentDesktop.value) return [];
+    return currentDesktop.value.workspaces.map(ws => {
+      const routes: RouteRecordRaw[] = (ws as any).routes || [];
+      const meta: RouteMeta = routes.length > 0 && routes[0].meta
+        ? routes[0].meta as RouteMeta
+        : { title: ws.title, icon: '', roles: [] };
+      return {
+        workspaceName: ws.name,
+        title: ws.title,
+        icon: meta.icon,
+        mainRoute: routes.length > 0 ? routes[0] : null,
+        meta
+      };
+    });
   });
 
-
-  const getSecondLevel = (currentRoute: RouteLocationNormalized): RouteRecordRaw[] => {
-    if (currentRoute.matched && currentDesktop.value && currentRoute) {
-
-      const matchingRootRoute = currentRoute.matched[1]
-
-      if (matchingRootRoute) {
-        return getNestedRoutes(matchingRootRoute)
-      }
-    }
-    return [];
+  // Храним название активного workspace
+  const activeWorkspaceName = ref<string | null>(null);
+  function selectWorkspace(name: string) {
+    activeWorkspaceName.value = name;
   }
 
+  const activeSecondLevelRoutes = computed((): RouteRecordRaw[] => {
+    if (!activeWorkspaceName.value) return [];
+    const ws = workspaceMenus.value.find(menu => menu.workspaceName === activeWorkspaceName.value);
+    return ws && ws.mainRoute && ws.mainRoute.children
+      ? ws.mainRoute.children as RouteRecordRaw[]
+      : [];
+  });
 
-  const setActiveDesktop = (hash: string | undefined) => {
-    const desktop = availableDesktops.value.find(d => d.hash === hash)
-    if (desktop)
-      currentDesktop.value = desktop
-    else {
-      FailAlert('Рабочий стол не найден')
+  function registerWorkspaceMenus(router: Router): void {
+    const baseRoute = router.getRoutes().find(r => r.name === 'base');
+    if (baseRoute) {
+      workspaceMenus.value.forEach(menu => {
+        if (menu.mainRoute) {
+          router.addRoute('base', menu.mainRoute as RouteRecordRaw);
+        }
+      });
     }
   }
 
-  const loadAvailableDesktops = async(): Promise<IBlockchainDesktops> => {
-    return { //load it from bc later
-      defaultHash: 'hash1',
-      availableHashes: ['hash1','hash2', 'hash3']
+  // Новый метод: удаляет workspace (расширение) из currentDesktop.workspaces по имени
+  function removeWorkspace(workspaceName: string): void {
+    if (currentDesktop.value && currentDesktop.value.workspaces) {
+      currentDesktop.value.workspaces = currentDesktop.value.workspaces.filter(ws => ws.name !== workspaceName);
     }
   }
 
+  // Методы для управления навигацией
+  function setBackNavigationButton(button: IBackNavigationButton) {
+    if (!currentDesktop.value) return
+    currentDesktop.value.backNavigationButton = button
+  }
 
-  const loadDesktops = async () => {
-    const {defaultHash, availableHashes} = await loadAvailableDesktops()
-    availableDesktops.value = []
-    defaultDesktopHash.value = defaultHash
-
-    availableHashes.map(hash => availableDesktops.value.push(
-      desktopHashMap[hash as any]
-    ))
+  function removeBackNavigationButton(componentId: string) {
+    if (!currentDesktop.value) return
+    if (currentDesktop.value.backNavigationButton?.componentId === componentId) {
+      currentDesktop.value.backNavigationButton = null
+    }
   }
 
+  const backNavigationButton = computed(() => currentDesktop.value?.backNavigationButton)
+
   return {
-    online,
-    health,
-    defaultDesktopHash, //перезапишем через локал-сторадж для пользовательского управления стартовой страницей
     currentDesktop,
-    availableDesktops,
-    setActiveDesktop,
-    loadDesktops,
-    getSecondLevel,
-    firstLevel,
-    healthCheck
-  }
-})
+    health,
+    online,
+    loadDesktop,
+    healthCheck,
+    setRoutes,
+    workspaceMenus,
+    activeWorkspaceName,
+    selectWorkspace,
+    activeSecondLevelRoutes,
+    registerWorkspaceMenus,
+    removeWorkspace,
+    // Новые методы
+    setBackNavigationButton,
+    removeBackNavigationButton,
+    backNavigationButton
+  };
+});

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

@@ -1,4 +1,7 @@
-export interface IDesktop {
+import type { Queries } from '@coopenomics/sdk';
+
+export type IDesktop = Queries.Desktop.GetDesktop.IOutput[typeof Queries.Desktop.GetDesktop.name]
+export interface ILegacyDesktop {
   name: string;
   hash: string;
   authorizedHome: string;
@@ -28,3 +31,13 @@ export interface IRoute {
 }
 
 export type { IHealthResponse } from '@coopenomics/controller'
+
+export interface IBackNavigationButton {
+  text: string
+  onClick: () => void
+  componentId: string
+}
+
+export interface IDesktopWithNavigation extends IDesktop {
+  backNavigationButton: IBackNavigationButton | null
+}

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

@@ -0,0 +1,24 @@
+import { client } from 'src/shared/api/client';
+import { Queries } from '@coopenomics/sdk';
+import type { IGetDocuments, ZGetDocumentsResult } from '../model/types';
+
+/**
+ * Загрузка документов с сервера
+ * @param data параметры запроса документов
+ * @returns результат запроса с пагинацией и документами
+ */
+async function loadDocuments(data: IGetDocuments): Promise<ZGetDocumentsResult> {
+  const { getDocuments: output } = await client.Query(
+    Queries.Documents.GetDocuments.query,
+    {
+      variables: {
+        data
+      }
+    }
+  );
+  return output;
+}
+
+export const api = {
+  loadDocuments
+}

package/src/entities/Document/index.ts

@@ -0,0 +1,2 @@
+export * as DocumentModel from './model'
+export * from './api'

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

@@ -0,0 +1,117 @@
+import { defineStore } from 'pinia'
+import { ref, type Ref } from 'vue'
+import { api } from '../api'
+import type { DocumentType, IGetDocuments, IPagination, IDocumentPackageAggregate } from './types'
+import { FailAlert } from 'src/shared/api'
+
+const namespace = 'documentStore'
+
+interface IDocumentStore {
+  documents: Ref<IDocumentPackageAggregate[]>
+  loading: Ref<boolean>
+  documentType: Ref<DocumentType>
+  pagination: Ref<IPagination>
+  changePage: (page: number, username: string, filter: Record<string, any>, hidden?: boolean) => Promise<IDocumentPackageAggregate[]>
+  changeDocumentType: (type: DocumentType, username: string, filter: Record<string, any>) => Promise<void>
+  resetDocuments: () => void
+}
+/**
+ * Хранилище для работы с документами
+ */
+export const useDocumentStore = defineStore(namespace, (): IDocumentStore => {
+  const documents = ref<IDocumentPackageAggregate[]>([])
+  const loading = ref(false)
+  const documentType = ref<DocumentType>('newsubmitted')
+
+  // Информация о пагинации
+  const pagination = ref<IPagination>({
+    totalCount: 0,
+    totalPages: 0,
+    currentPage: 1
+  })
+
+  /**
+   * Сброс состояния документов
+   */
+  const resetDocuments = () => {
+    documents.value = []
+    pagination.value = {
+      totalCount: 0,
+      totalPages: 0,
+      currentPage: 1
+    }
+  }
+
+  /**
+   * Изменяет страницу для пагинации и загружает данные
+   * @param page номер страницы
+   * @param username имя пользователя или кооператива
+   * @param filter параметры фильтрации
+   * @param hidden флаг скрытой загрузки (без индикатора)
+   * @returns массив документов
+   */
+  const changePage = async (
+    page: number,
+    username: string,
+    filter: Record<string, any>,
+    hidden = false
+  ): Promise<IDocumentPackageAggregate[]> => {
+    try {
+      loading.value = hidden ? false : true
+
+      pagination.value.currentPage = page
+
+      const data: IGetDocuments = {
+        username,
+        filter,
+        type: documentType.value,
+        page: page,
+        limit: 10
+      }
+
+      const result = await api.loadDocuments(data)
+
+      // Если это первая страница, заменяем документы
+      // Иначе добавляем новые документы к существующим
+      if (page === 1) {
+        documents.value = result.items
+      } else {
+        documents.value = [...documents.value, ...result.items]
+      }
+
+      // Обновляем информацию о пагинации
+      pagination.value = {
+        totalCount: result.totalCount,
+        totalPages: result.totalPages,
+        currentPage: result.currentPage
+      }
+
+      loading.value = false
+      return documents.value
+    } catch (error: any) {
+      loading.value = false
+      console.error('Error loading documents:', error)
+      FailAlert(error)
+      return []
+    }
+  }
+
+  /**
+   * Изменяет тип документов для отображения
+   */
+  const changeDocumentType = async (type: DocumentType, username: string, filter: Record<string, any>) => {
+    documentType.value = type
+    // Сбрасываем текущую страницу при смене типа и загружаем документы
+    await changePage(1, username, filter)
+  }
+
+  return {
+    documents,
+    loading,
+    documentType,
+    pagination,
+    changePage,
+    changeDocumentType,
+    resetDocuments
+  }
+})

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

@@ -0,0 +1,18 @@
+import type { Queries, Zeus } from '@coopenomics/sdk';
+
+export type IDocumentPackageAggregate = Zeus.ModelTypes['DocumentPackageAggregate'];
+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 interface IPagination {
+  totalCount: number;
+  totalPages: number;
+  currentPage: number;
+}
+
+// Типы документов в системе
+export type DocumentType = 'newsubmitted' | 'newresolved';
+
+

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

@@ -0,0 +1,58 @@
+import { client } from 'src/shared/api/client';
+import { Queries, Mutations } from '@coopenomics/sdk';
+import type { IGetMeetsInput, IGetMeetInput, ICloseMeetInput, IRestartMeetInput } from '../types';
+
+async function loadMeets(data: IGetMeetsInput) {
+  const { [Queries.Meet.GetMeets.name]: output } = await client.Query(
+    Queries.Meet.GetMeets.query,
+    {
+      variables: {
+        data
+      }
+    }
+  );
+  return output;
+}
+
+async function loadMeet(data: IGetMeetInput) {
+  const { [Queries.Meet.GetMeet.name]: output } = await client.Query(
+    Queries.Meet.GetMeet.query,
+    {
+      variables: {
+        data
+      }
+    }
+  );
+  return output;
+}
+
+async function closeMeet(data: ICloseMeetInput) {
+  const { [Mutations.Meet.SignByPresiderOnAnnualGeneralMeet.name]: output } = await client.Mutation(
+    Mutations.Meet.SignByPresiderOnAnnualGeneralMeet.mutation,
+    {
+      variables: {
+        data
+      }
+    }
+  );
+  return output;
+}
+
+async function restartMeet(data: IRestartMeetInput) {
+  const { [Mutations.Meet.RestartAnnualGeneralMeet.name]: output } = await client.Mutation(
+    Mutations.Meet.RestartAnnualGeneralMeet.mutation,
+    {
+      variables: {
+        data
+      }
+    }
+  );
+  return output;
+}
+
+export const api = {
+  loadMeets,
+  loadMeet,
+  closeMeet,
+  restartMeet
+}

package/src/entities/Meet/index.ts

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

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

@@ -0,0 +1,72 @@
+import { defineStore } from 'pinia'
+import { ref, Ref } from 'vue'
+import { api } from '../api'
+import type { IMeet, IGetMeetsInput, IGetMeetInput, ICloseMeetInput, IRestartMeetInput } from '../types';
+
+const namespace = 'meetStore';
+
+interface IMeetStore {
+  meets: Ref<IMeet[]>
+  currentMeet: Ref<IMeet | null>
+  loading: Ref<boolean>
+  loadMeets: (data: IGetMeetsInput) => Promise<IMeet[]>;
+  loadMeet: (data: IGetMeetInput) => Promise<IMeet>;
+  closeMeet: (data: ICloseMeetInput) => Promise<IMeet>;
+  restartMeet: (data: IRestartMeetInput) => Promise<IMeet>;
+}
+
+export const useMeetStore = defineStore(namespace, (): IMeetStore => {
+  const meets = ref<IMeet[]>([])
+  const currentMeet = ref<IMeet | null>(null)
+  const loading = ref<boolean>(false)
+
+  const loadMeets = async (data: IGetMeetsInput) => {
+    loading.value = true
+    try {
+      const result = await api.loadMeets(data);
+      meets.value = result;
+      return result;
+    } finally {
+      loading.value = false
+    }
+  };
+
+  const loadMeet = async (data: IGetMeetInput) => {
+    loading.value = true
+    try {
+      const result = await api.loadMeet(data);
+      currentMeet.value = result;
+      return result;
+    } finally {
+      loading.value = false
+    }
+  };
+
+  const closeMeet = async (data: ICloseMeetInput) => {
+    loading.value = true
+    try {
+      return await api.closeMeet(data);
+    } finally {
+      loading.value = false
+    }
+  };
+
+  const restartMeet = async (data: IRestartMeetInput) => {
+    loading.value = true
+    try {
+      return await api.restartMeet(data);
+    } finally {
+      loading.value = false
+    }
+  };
+
+  return {
+    meets,
+    currentMeet,
+    loading,
+    loadMeets,
+    loadMeet,
+    closeMeet,
+    restartMeet
+  }
+})

package/src/entities/Meet/types/index.ts

@@ -0,0 +1,7 @@
+import type { Queries, Mutations } from '@coopenomics/sdk';
+
+export type IMeet = Queries.Meet.GetMeet.IOutput[typeof Queries.Meet.GetMeet.name]
+export type IGetMeetsInput = Queries.Meet.GetMeets.IInput['data']
+export type IGetMeetInput = Queries.Meet.GetMeet.IInput['data']
+export type ICloseMeetInput = Mutations.Meet.SignByPresiderOnAnnualGeneralMeet.IInput['data']
+export type IRestartMeetInput = Mutations.Meet.RestartAnnualGeneralMeet.IInput['data']

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

@@ -0,0 +1,20 @@
+import { client } from 'src/shared/api/client';
+import { Queries } from '@coopenomics/sdk';
+import type { IGetPaymentsInputData, IGetPaymentsInputOptions, IPaymentPaginationResult } from '../model/types';
+
+/**
+ * Загружает список платежей с использованием GraphQL API
+ */
+async function loadPayments(data?: IGetPaymentsInputData, options?: IGetPaymentsInputOptions): Promise<IPaymentPaginationResult> {
+  const variables: Queries.Payments.GetPayments.IInput = {data, options}
+
+  const { [Queries.Payments.GetPayments.name]: output } = await client.Query(
+    Queries.Payments.GetPayments.query,
+    {
+      variables
+    }
+  );
+  return output;
+}
+
+export const api = { loadPayments };

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

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

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

@@ -0,0 +1,62 @@
+import { defineStore } from 'pinia';
+import { Ref, ref } from 'vue';
+import { api } from '../api';
+import type { IGetPaymentsInputData, IGetPaymentsInputOptions, IPayment, IPaymentPaginationResult } from './types';
+
+interface IPaymentStore {
+  payments: Ref<IPaymentPaginationResult | undefined>;
+  loadPayments: (data?: IGetPaymentsInputData, options?: IGetPaymentsInputOptions) => Promise<void>;
+  updatePayments: (data?: IGetPaymentsInputData, options?: IGetPaymentsInputOptions) => Promise<void>;
+  clear: () => void;
+}
+
+const namespace = 'payments';
+
+export const usePaymentStore = defineStore(namespace, (): IPaymentStore => {
+  const payments: Ref<IPaymentPaginationResult | undefined> = ref();
+
+  const clear = () => {
+    payments.value = undefined;
+  };
+
+  // Функция для слияния массивов платежей по id
+  const mergePayments = (existingPayments: IPayment[], newPayments: IPayment[]) => {
+    const mergedPaymentsMap = new Map(existingPayments.map(payment => [payment.id, payment]));
+
+    newPayments.forEach(payment => {
+      mergedPaymentsMap.set(payment.id, payment); // Обновляем или добавляем новый платеж
+    });
+
+    return Array.from(mergedPaymentsMap.values()); // Возвращаем массив объединённых платежей
+  };
+
+  const updatePayments = async(data?: IGetPaymentsInputData, options?: IGetPaymentsInputOptions): Promise<void> => {
+    const newPaymentsResponse = await api.loadPayments(data, options);
+
+    if (payments.value) {
+      payments.value.items = mergePayments(payments.value.items, newPaymentsResponse.items);
+    } else {
+      payments.value = newPaymentsResponse;
+    }
+  };
+
+  // Функция для загрузки платежей
+  const loadPayments = async (data?: IGetPaymentsInputData, options?: IGetPaymentsInputOptions): Promise<void> => {
+    const newPaymentsResponse = await api.loadPayments(data, options);
+
+    if (payments.value) {
+      // Обновляем все свойства объекта payments
+      payments.value = {
+        ...payments.value,
+        items: mergePayments(payments.value.items, newPaymentsResponse.items),
+        currentPage: newPaymentsResponse.currentPage,
+        totalPages: newPaymentsResponse.totalPages,
+        totalCount: newPaymentsResponse.totalCount
+      };
+    } else {
+      payments.value = newPaymentsResponse;
+    }
+  };
+
+  return { payments, loadPayments, updatePayments, clear };
+});

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

@@ -0,0 +1,7 @@
+import type { Queries } from '@coopenomics/sdk';
+
+export type IPaymentPaginationResult = Queries.Payments.GetPayments.IOutput[typeof Queries.Payments.GetPayments.name]
+export type IPayment = IPaymentPaginationResult['items'][number]
+
+export type IGetPaymentsInputData = Queries.Payments.GetPayments.IInput['data']
+export type IGetPaymentsInputOptions = Queries.Payments.GetPayments.IInput['options']