@coopenomics/desktop 2.2.9 → 2025.4.29

package/src/processes/init-installed-extensions/index.ts

@@ -0,0 +1,25 @@
+import type { Router } from 'vue-router'
+import { useDesktopStore } from 'src/entities/Desktop/model'
+
+export async function useInitExtensionsProcess(router: Router) {
+  const store = useDesktopStore()
+  // Загружаем все модули расширений
+  const modules = import.meta.glob('../../../extensions/**/install.{ts,js}')
+
+  for (const path in modules) {
+    const mod = await modules[path]()
+    if (mod?.default) {
+      // Ожидаем, что расширение возвращает объект { workspace, routes }
+      const result = await mod.default()
+      if (result?.workspace && result?.routes?.length) {
+        // Записываем маршруты в соответствующий workspace
+        store.setRoutes(result.workspace, result.routes)
+        // Регистрируем маршруты в router, добавляя их в базовый родительский маршрут (например, "base")
+        const baseRoute = router.getRoutes().find(r => r.name === 'base')
+        if (baseRoute) {
+          result.routes.forEach((r: any) => router.addRoute('base', r))
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,40 @@
+// processes/init-wallet/index.ts
+import { useSessionStore } from 'src/entities/Session'
+import { useCurrentUserStore } from 'src/entities/User'
+import { useWalletStore } from 'src/entities/Wallet'
+import { useSystemStore } from 'src/entities/System/model'
+import { useAccountStore } from 'src/entities/Account/model'
+
+export function useInitWalletProcess() {
+  const session = useSessionStore()
+  const user = useCurrentUserStore()
+  const wallet = useWalletStore()
+  const { info } = useSystemStore()
+  const account = useAccountStore()
+
+  const run = async () => {
+    await session.init()
+
+    if (!session.isAuth) return
+
+    try {
+      await account.getAccount(session.username)
+
+      await user.loadProfile(session.username, info.coopname)
+
+      await wallet.loadUserWallet({
+        coopname: info.coopname,
+        username: session.username,
+      })
+
+      session.loadComplete = true
+    } catch (e) {
+      console.error(e)
+    }
+
+    // фоновая проверка каждые 10 сек
+    setTimeout(run, 10_000)
+  }
+
+  return { run }
+}

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

@@ -0,0 +1,45 @@
+import { Router } from 'vue-router'
+import { useSessionStore } from 'src/entities/Session'
+import { useCurrentUserStore } from 'src/entities/User'
+import { useDesktopStore } from 'src/entities/Desktop/model'
+import { useSystemStore } from 'src/entities/System/model'
+
+function hasAccess(to, userAccount) {
+  if (!to.meta?.roles || to.meta?.roles.length === 0) return true
+  return userAccount && to.meta?.roles.includes(userAccount.role)
+}
+
+export function setupNavigationGuard(router: Router) {
+  const desktops = useDesktopStore()
+  const session = useSessionStore()
+  const currentUser = useCurrentUserStore()
+  const { info } = useSystemStore()
+
+  router.beforeEach(async (to, from, next) => {
+    await desktops.healthCheck()
+
+    // если требуется установка
+    if (desktops.health?.status === 'install' && to.name !== 'install') {
+      next({ name: 'install', params: { coopname: info.coopname } })
+      return
+    }
+
+    // редирект с index
+    if (to.name === 'index') {
+      const homePage =
+        session.isAuth && currentUser.isRegistrationComplete
+          ? desktops.currentDesktop?.authorizedHome
+          : desktops.currentDesktop?.nonAuthorizedHome
+
+      next({ name: homePage, params: { coopname: info.coopname } })
+      return
+    }
+
+    // проверка по ролям
+    if (hasAccess(to, currentUser.userAccount)) {
+      next()
+    } else {
+      next({ name: 'permissionDenied' })
+    }
+  })
+}

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

@@ -0,0 +1,275 @@
+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 { useSystemStore } from 'src/entities/System/model'
+import { useSessionStore } from 'src/entities/Session'
+import { useGlobalStore } from 'src/shared/store'
+import { useVoteForDecision } from 'src/features/Decision/VoteForDecision'
+import { useVoteAgainstDecision } from 'src/features/Decision/VoteAgainstDecision'
+import { computed } from 'vue'
+import { useAgendaStore } from 'src/entities/Agenda/model'
+import type { IAgenda } from 'src/entities/Agenda/model'
+
+/**
+ * Процесс обработки решений
+ * Координирует работу различных фич для генерации и обработки решений различных типов
+ */
+export function useDecisionProcessor() {
+  const { info } = useSystemStore()
+  const session = useSessionStore()
+  const agendaStore = useAgendaStore()
+  
+  // Данные повестки и состояние загрузки
+  const decisions = computed(() => agendaStore.agenda)
+  const loading = computed(() => agendaStore.loading)
+
+  /**
+   * Форматирует заголовок вопроса
+   */
+  function formatDecisionTitle(title: string, user: any) {
+    let result = 'Вопрос на голосование'
+
+    if (user.first_name) {
+      result = `${title} от ${user.last_name} ${user.first_name} ${user.middle_name}`
+    } else {
+      result = `${title} от ${user.short_name}`
+    }
+
+    return result
+  }
+
+  /**
+   * Получает заголовок документа из агрегата
+   */
+  function getDocumentTitle(row: IAgenda) {
+    // Используем только агрегаты документов
+    if (row.documents?.statement?.documentAggregate?.rawDocument?.full_title) {
+      return row.documents.statement.documentAggregate.rawDocument.full_title
+    }
+    
+    if (row.documents?.decision?.documentAggregate?.rawDocument?.full_title) {
+      return row.documents.decision.documentAggregate.rawDocument.full_title
+    }
+    
+    // Поддержка исходного формата для таблицы
+    if (row.table?.statement?.meta && typeof row.table.statement.meta === 'string') {
+      try {
+        const meta = JSON.parse(row.table.statement.meta)
+        if (meta.title) return meta.title
+      } catch (e) {
+        // Игнорируем ошибку парсинга JSON
+      }
+    }
+    
+    return 'Вопрос без заголовка'
+  }
+
+  /**
+   * Загружает список вопросов на повестке
+   */
+  async function loadDecisions(coopname: string, hidden = false) {
+    try {
+      const result = await agendaStore.loadAgenda({ coopname }, hidden)
+      return result
+    } catch (error) {
+      throw error
+    }
+  }
+
+  /**
+   * Получает хеш документа из агрегата
+   */
+  function getDocumentHash(row: IAgenda) {
+    // Используем только агрегаты документов
+    if (row.documents?.statement?.documentAggregate?.rawDocument?.hash) {
+      return row.documents.statement.documentAggregate.rawDocument.hash
+    }
+    
+    if (row.documents?.decision?.documentAggregate?.rawDocument?.hash) {
+      return row.documents.decision.documentAggregate.rawDocument.hash
+    }
+    
+    // Поддержка исходного формата для таблицы
+    if (row.table?.statement?.hash) {
+      return row.table.statement.hash
+    }
+    
+    return null
+  }
+
+  /**
+   * Генерирует документ решения в зависимости от его типа
+   */
+  async function generateDecisionDocument(row: IAgenda) {
+    if (!row.table?.id || !row.table?.username || !row.table?.type) {
+      throw new Error('Некорректные данные решения')
+    }
+    
+    const decision_id = Number(row.table.id)
+    const username = row.table.username
+    const type = row.table.type
+    const registry_id = Cooperative.Document.decisionsRegistry[type]
+
+    // Генерация документа в зависимости от типа решения
+    let document
+
+    if (registry_id === Cooperative.Registry.FreeDecision.registry_id) {
+      const unparsedDocumentMeta = row.table.statement.meta == '' ? '{}' : row.table.statement.meta
+      const parsedDocumentMeta = JSON.parse(unparsedDocumentMeta) 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()
+      document = await generateSovietDecisionOnAnnualMeet({
+        username: username,
+      })
+    }
+    else {
+      throw new Error('Неизвестный тип решения')
+    }
+
+    if (!document) {
+      throw new Error('Ошибка при генерации документа решения')
+    }
+
+    return document
+  }
+
+  /**
+   * Авторизует и выполняет решение
+   */
+  async function authorizeAndExecuteDecision(row: IAgenda) {
+    if (!row.table?.id) {
+      throw new Error('Некорректные данные решения')
+    }
+    
+    const decision_id = Number(row.table.id)
+
+    // Генерируем документ решения
+    const document = await generateDecisionDocument(row)
+
+    // Подписываем документ
+    const signed_hash_of_document = useGlobalStore().signDigest(document.hash)
+    const chainDocument: Cooperative.Document.IChainDocument = {
+      hash: document.hash,
+      meta: JSON.stringify(document.meta),
+      signature: signed_hash_of_document.signature,
+      public_key: signed_hash_of_document.public_key,
+    }
+
+    // Подготавливаем данные для транзакций
+    const authorizeData: SovietContract.Actions.Decisions.Authorize.IAuthorize = {
+      coopname: info.coopname,
+      chairman: session.username,
+      decision_id,
+      document: chainDocument,
+    }
+
+    const execData: SovietContract.Actions.Decisions.Exec.IExec = {
+      executer: session.username,
+      coopname: info.coopname,
+      decision_id: decision_id,
+    }
+
+    // Выполняем транзакции
+    await useGlobalStore().transact([
+      {
+        account: SovietContract.contractName.production,
+        name: SovietContract.Actions.Decisions.Authorize.actionName,
+        authorization: [
+          {
+            actor: session.username,
+            permission: 'active',
+          },
+        ],
+        data: authorizeData,
+      },
+      {
+        account: SovietContract.contractName.production,
+        name: SovietContract.Actions.Decisions.Exec.actionName,
+        authorization: [
+          {
+            actor: session.username,
+            permission: 'active',
+          },
+        ],
+        data: execData,
+      },
+    ])
+
+    return true
+  }
+
+  /**
+   * Голосовать "за" решение
+   */
+  async function voteForDecision(decision_id: number) {
+    const { voteForDecision: vote } = useVoteForDecision()
+    await vote(decision_id)
+    return true
+  }
+
+  /**
+   * Голосовать "против" решения
+   */
+  async function voteAgainstDecision(decision_id: number) {
+    await useVoteAgainstDecision().voteAgainstDecision({
+      coopname: info.coopname,
+      member: session.username,
+      decision_id,
+    })
+    return true
+  }
+
+  /**
+   * Проверяет, проголосовал ли текущий пользователь "за" решение
+   */
+  function isVotedFor(decision: SovietContract.Tables.Decisions.IDecision) {
+    return decision.votes_for.includes(session.username)
+  }
+
+  /**
+   * Проверяет, проголосовал ли текущий пользователь "против" решения
+   */
+  function isVotedAgainst(decision: SovietContract.Tables.Decisions.IDecision) {
+    return decision.votes_against.includes(session.username)
+  }
+
+  /**
+   * Проверяет, проголосовал ли текущий пользователь за решение каким-либо образом
+   */
+  function isVotedAny(decision: SovietContract.Tables.Decisions.IDecision) {
+    return isVotedAgainst(decision) || isVotedFor(decision)
+  }
+
+  return {
+    decisions,
+    loading,
+    loadDecisions,
+    generateDecisionDocument,
+    authorizeAndExecuteDecision,
+    voteForDecision,
+    voteAgainstDecision,
+    isVotedFor,
+    isVotedAgainst,
+    isVotedAny,
+    formatDecisionTitle,
+    getDocumentTitle,
+    getDocumentHash
+  }
+}

package/src/processes/select-branch/index.ts

@@ -0,0 +1,80 @@
+import { computed, ref } from 'vue'
+import { useSelectBranch } from 'src/features/Branch/SelectBranch'
+import { useSystemStore } from 'src/entities/System/model'
+import { useSessionStore } from 'src/entities/Session'
+import { useBranchStore } from 'src/entities/Branch/model'
+import { DigitalDocument } from 'src/shared/lib/document'
+import { SuccessAlert, FailAlert } from 'src/shared/api'
+import { Cooperative } from 'cooptypes'
+
+export function useSelectBranchProcess() {
+  const title = ref('Выберите кооперативный участок')
+  const step = ref(1)
+  const isSubmitting = ref(false)
+  const isLoading = ref(false)
+  const selectedBranch = ref('')
+  const document = ref()
+
+  const digitalDocument = new DigitalDocument()
+
+  const system = useSystemStore()
+  const session = useSessionStore()
+  const branchStore = useBranchStore()
+  const { selectBranch } = useSelectBranch()
+
+  const branches = computed(() => branchStore.publicBranches)
+
+  if (session.isAuth) {
+    branchStore.loadPublicBranches({ coopname: system.info.coopname })
+  }
+
+  const next = async () => {
+    isLoading.value = true
+    document.value = await digitalDocument.generate<Cooperative.Registry.SelectBranchStatement.Action>({
+      registry_id: Cooperative.Registry.SelectBranchStatement.registry_id,
+      coopname: system.info.coopname,
+      username: session.username,
+      braname: selectedBranch.value,
+    })
+    isLoading.value = false
+    step.value++
+  }
+
+  const back = () => {
+    step.value--
+  }
+
+  const sign = async () => {
+    try {
+      isSubmitting.value = true
+      const doc = await digitalDocument.sign()
+
+      await selectBranch({
+        braname: selectedBranch.value,
+        coopname: system.info.coopname,
+        document: doc,
+        username: session.username,
+      })
+
+      useSelectBranch().isVisible.value = false
+      SuccessAlert('Кооперативный участок выбран')
+    } catch (e: any) {
+      FailAlert(e)
+    } finally {
+      isSubmitting.value = false
+    }
+  }
+
+  return {
+    title,
+    step,
+    selectedBranch,
+    branches,
+    document,
+    isSubmitting,
+    isLoading,
+    next,
+    back,
+    sign,
+  }
+}

package/src/processes/watch-branch-overlay/index.ts

@@ -0,0 +1,38 @@
+import { watch } from 'vue'
+import { useAccountStore } from 'src/entities/Account/model'
+import { useSessionStore } from 'src/entities/Session'
+import { useSystemStore } from 'src/entities/System/model'
+import { useSelectBranch } from 'src/features/Branch/SelectBranch/model'
+
+export function useBranchOverlayProcess() {
+  const session = useSessionStore()
+  const system = useSystemStore()
+  const account = useAccountStore()
+  const { isVisible } = useSelectBranch()
+
+  const checkConditions = () => {
+    const branched = system.info?.cooperator_account?.is_branched
+    const participant = account?.account?.participant_account
+    const noBraname = participant?.braname === ''
+
+    // показываем оверлей выбора КУ, если
+    // пользователь - авторизован,
+    // кооператив - в мажоритарном режиме (branched),
+    // пользователь - это пайщик,
+    // и у пользователя не выбран КУ
+    isVisible.value = !!(
+      session.isAuth &&
+      branched &&
+      participant &&
+      noBraname
+    )
+  }
+
+  checkConditions()
+
+  watch(
+    [() => session.isAuth, () => system.info, () => account.account],
+    checkConditions,
+    { deep: true }
+  )
+}

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

@@ -0,0 +1,33 @@
+// processes/watch-desktop-health/index.ts
+import { watch } from 'vue'
+import { QSpinnerGears, useQuasar } from 'quasar'
+import { useDesktopStore } from 'src/entities/Desktop/model'
+
+export function useDesktopHealthWatcherProcess() {
+  const $q = useQuasar()
+  const desktop = useDesktopStore()
+
+  const enableLoading = () => {
+    $q.loading.show({
+      spinner: QSpinnerGears,
+      message: 'Техническое обслуживание..',
+      spinnerSize: 50,
+    })
+  }
+
+  const disableLoading = () => {
+    $q.loading.hide()
+  }
+
+  const check = () => {
+    if (desktop.online === false) {
+      enableLoading()
+    } else {
+      disableLoading()
+    }
+  }
+
+  check()
+
+  watch(() => desktop.online, check)
+}

package/src/shared/api/alerts.ts

@@ -11,7 +11,8 @@ export function SuccessAlert(message: string): void {
   })
 }
 
-export function FailAlert(message: string): void {
+export function FailAlert(error: any): void{
+  const message = extractGraphQLErrorMessages(error)
   Notify.create({
     message,
     type: 'negative',
@@ -20,8 +21,3 @@ export function FailAlert(message: string): void {
     ]
   })
 }
-
-export function failAlert(error: any): void{
-  const message = extractGraphQLErrorMessages(error)
-  FailAlert(message)
-}

package/src/shared/api/axios.ts

@@ -1,5 +1,4 @@
 import axios from 'axios';
-import { BACKEND_URL } from '../config';
 import { useGlobalStore } from '../store';
 
 export async function sendGET(
@@ -14,7 +13,7 @@ export async function sendGET(
       // if (!tokens || !tokens.access || !tokens.access.token)
       //   throw new Error('Ошибка авторизации: токен доступа не найден');
 
-      const response = await axios.get(BACKEND_URL + url, {
+      const response = await axios.get(process.env.BACKEND_URL + url, {
         params,
         headers: {
           Authorization: `Bearer ${tokens?.access?.token}`,
@@ -22,7 +21,7 @@ export async function sendGET(
       });
       return response.data;
     } else {
-      const response = await axios.get(BACKEND_URL + url, {
+      const response = await axios.get(process.env.BACKEND_URL + url, {
         params,
       });
       return response.data;
@@ -50,14 +49,14 @@ export async function sendPOST(
       // if (!tokens || !tokens.access || !tokens.access.token)
       //   throw new Error('Ошибка авторизации: токен доступа не найден');
 
-      const response = await axios.post(BACKEND_URL + url, data, {
+      const response = await axios.post(process.env.BACKEND_URL + url, data, {
         headers: {
           Authorization: `Bearer ${tokens?.access?.token}`,
         },
       });
       return response.data;
     } else {
-      const response = await axios.post(BACKEND_URL + url, data);
+      const response = await axios.post(process.env.BACKEND_URL + url, data);
       return response.data;
     }
   } catch (e: any) {

package/src/shared/api/client.ts

@@ -1,13 +1,12 @@
 import { Client } from '@coopenomics/sdk'
-import { BACKEND_URL, CHAIN_ID, CHAIN_URL } from '../config'
 
 // Создаем и экспортируем экземпляр API-клиента
 export const client = Client.create({
-  api_url: BACKEND_URL + '/v1/graphql',
+  api_url: process.env.BACKEND_URL + '/v1/graphql',
   headers: {
     'Content-Type': 'application/json',
   },
-  chain_url: CHAIN_URL,
-  chain_id: CHAIN_ID,
+  chain_url: process.env.CHAIN_URL as string,
+  chain_id: process.env.CHAIN_ID as string,
 })
 

package/src/shared/api/eosio.ts

@@ -1,12 +1,11 @@
 import { TransactResult } from '@wharfkit/session';
 import { APIClient, PrivateKey } from '@wharfkit/antelope';
 import { ContractKit } from '@wharfkit/contract';
-import { CHAIN_URL } from '../config/Env';
 import { useGlobalStore } from '../store';
 import { Account } from '@wharfkit/account'
 
 export const readBlockchain = new APIClient({
-  url: CHAIN_URL,
+  url: process.env.CHAIN_URL,
 });
 
 export const contractKit = new ContractKit({

package/src/shared/api/utils.ts

@@ -1,9 +1,7 @@
-import { STORAGE_URL } from '../config';
-
 export function constructImageSrc(name: string): string {
   if (name.startsWith('https://')) {
     return name;
   } else {
-    return STORAGE_URL + name;
+    return process.env.STORAGE_URL + name;
   }
 }

package/src/shared/config/index.ts

@@ -3,4 +3,3 @@ export * from './TablesList';
 export * from './LimitsList';
 export * from './SecondaryIndexesNumbersList';
 export * from './SecondaryIndexesTypesList';
-export * from './Env'

package/src/shared/hooks/index.ts

@@ -0,0 +1,2 @@
+export { useWindowSize } from './useWindowSize'
+export { useAgendaPoints } from './useAgendaPoints'

package/src/shared/hooks/useAgendaPoints.ts

@@ -0,0 +1,24 @@
+import type { Mutations } from '@coopenomics/sdk'
+
+export type AgendaPoint = Mutations.Meet.CreateAnnualGeneralMeet.IInput['data']['agenda'][number]
+
+export function useAgendaPoints(points: AgendaPoint[]) {
+  const addAgendaPoint = () => {
+    points.push({
+      title: '',
+      context: '',
+      decision: ''
+    })
+  }
+
+  const removeAgendaPoint = (index: number) => {
+    if (points.length > 1) {
+      points.splice(index, 1)
+    }
+  }
+
+  return {
+    addAgendaPoint,
+    removeAgendaPoint
+  }
+}