@coopenomics/desktop 2.2.10 → 2025.5.2

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,6 +1,6 @@
 import axios from 'axios';
-import { BACKEND_URL } from '../config';
 import { useGlobalStore } from '../store';
+import { env } from 'src/shared/config';
 
 export async function sendGET(
   url: string,
@@ -14,7 +14,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(env.BACKEND_URL + url, {
         params,
         headers: {
           Authorization: `Bearer ${tokens?.access?.token}`,
@@ -22,7 +22,7 @@ export async function sendGET(
       });
       return response.data;
     } else {
-      const response = await axios.get(BACKEND_URL + url, {
+      const response = await axios.get(env.BACKEND_URL + url, {
         params,
       });
       return response.data;
@@ -50,14 +50,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(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(env.BACKEND_URL + url, data);
       return response.data;
     }
   } catch (e: any) {

package/src/shared/api/client.ts

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

package/src/shared/api/eosio.ts

@@ -1,12 +1,12 @@
 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'
+import { env } from 'src/shared/config';
 
 export const readBlockchain = new APIClient({
-  url: CHAIN_URL,
+  url: env.CHAIN_URL,
 });
 
 export const contractKit = new ContractKit({

package/src/shared/api/indexDB.ts

@@ -1,6 +1,8 @@
 import { openDB } from 'idb';
+import { env } from '../config';
 
 async function openIndexedDB(dbName: string, storeName: string) {
+
   if (!process.env.CLIENT) {
     return;
   }
@@ -21,6 +23,7 @@ export async function getFromIndexedDB(dbName: string, storeName: string, key: s
     return;
   }
 
+
   const db = await openIndexedDB(dbName, storeName);
   if (db) {
     return db.get(storeName, key);

package/src/shared/api/utils.ts

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

package/src/shared/config/Environment.ts

@@ -0,0 +1,68 @@
+// Типы для переменных окружения
+export interface EnvVars {
+  NODE_ENV?: string;
+  BACKEND_URL?: string;
+  CHAIN_URL?: string;
+  CHAIN_ID?: string;
+  CURRENCY?: string;
+  COOP_SHORT_NAME?: string;
+  SITE_DESCRIPTION?: string;
+  SITE_IMAGE?: string;
+  STORAGE_URL?: string;
+  UPLOAD_URL?: string;
+  CLIENT?: boolean;
+  SERVER?: boolean;
+  VUE_ROUTER_MODE?: string;
+  VUE_ROUTER_BASE?: string;
+  [key: string]: string | boolean | undefined;
+}
+
+// Расширяем глобальный Window чтобы TypeScript понимал window.__ENV__
+declare global {
+  interface Window {
+    __ENV__?: EnvVars;
+  }
+}
+
+/**
+ * Определение переменных окружения для разных сред
+ * - На сервере (SSR): берем напрямую из process.env
+ * - На клиенте (SSR): используем window.__ENV__, инжектированные с сервера
+ * - В SPA режиме: переменные заменяются при сборке
+ */
+function getEnv(): EnvVars {
+  // SSR сервер или SPA сборка
+
+  if (typeof process !== 'undefined' && process.env) {
+    // Для SSR сервера - берем реальные переменные
+    // Для SPA - эти значения заменятся при сборке
+    return {
+      NODE_ENV: process.env.NODE_ENV,
+      BACKEND_URL: process.env.BACKEND_URL,
+      CHAIN_URL: process.env.CHAIN_URL,
+      CHAIN_ID: process.env.CHAIN_ID,
+      CURRENCY: process.env.CURRENCY,
+      COOP_SHORT_NAME: process.env.COOP_SHORT_NAME,
+      SITE_DESCRIPTION: process.env.SITE_DESCRIPTION,
+      SITE_IMAGE: process.env.SITE_IMAGE,
+      STORAGE_URL: process.env.STORAGE_URL,
+      UPLOAD_URL: process.env.UPLOAD_URL,
+      CLIENT: process.env.CLIENT as unknown as boolean,
+      SERVER: process.env.SERVER as unknown as boolean,
+      VUE_ROUTER_MODE: process.env.VUE_ROUTER_MODE,
+      VUE_ROUTER_BASE: process.env.VUE_ROUTER_BASE
+    };
+  }
+
+  // SSR клиент - берем из window.__ENV__
+  if (typeof window !== 'undefined' && window.__ENV__) {
+    return window.__ENV__;
+  }
+
+  // Запасной вариант, если ничего не сработало
+  console.warn('Не удалось получить переменные окружения!');
+  return {};
+}
+
+// Экспортируем переменные окружения
+export const env: EnvVars = getEnv();

package/src/shared/config/index.ts

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

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
+  }
+}

package/src/shared/hooks/useWindowSize.ts

@@ -0,0 +1,13 @@
+import { computed } from 'vue'
+import { useWindowSize as vueWindowSize } from 'vue-window-size'
+
+export const useWindowSize = () => {
+  const { width } = vueWindowSize()
+
+  const isMobile = computed(() => width.value < 768)
+
+  return {
+    width,
+    isMobile
+  }
+}