@coopenomics/desktop 2.2.10 → 2025.4.29

package/src/pages/User/ProfilePage/ui/ProfilePage.vue

@@ -0,0 +1,114 @@
+<template lang="pug">
+div.q-pa-md
+  div.row
+    div.col-md-12.col-xs-12
+      q-card(flat class="card-container q-pa-md")
+        div.row
+          div.col-12.col-md-3.flex.justify-center.align-start
+            AutoAvatar(class="profile-avatar" :username="currentUser.userAccount?.username || 'user'")
+
+          div.col-12.col-md-9
+            div.row
+              div.col-12.info-card
+                div.row.q-mb-md
+                  div.col-12
+                    div.text-h4.q-mb-xs
+                      span(v-if="isIP").q-mr-sm ИП
+                      | {{displayName}}
+                    q-badge(color="primary" class="user-role") {{role}}
+
+
+
+                CopyableInput(
+                  label="Имя аккаунта"
+                  standout="bg-teal text-white"
+                  dense
+                  :model-value="currentUser.userAccount?.username || ''"
+                  input-class="q-mt-md"
+                ).q-mb-md
+
+                EditableIndividualCard(
+                  v-if="userType === 'individual' && individualProfile"
+                  :participantData="individualProfile"
+                  :readonly="true"
+                )
+                EditableEntrepreneurCard(
+                  v-if="userType === 'entrepreneur' && entrepreneurProfile"
+                  :participantData="entrepreneurProfile"
+                  :readonly="true"
+                )
+                EditableOrganizationCard(
+                  v-if="userType === 'organization' && organizationProfile"
+                  :participantData="organizationProfile"
+                  :readonly="true"
+                )
+</template>
+
+<script lang="ts" setup>
+import { AutoAvatar } from 'src/shared/ui/AutoAvatar';
+import { useCurrentUserStore } from 'src/entities/User';
+import type { IEntrepreneurData, IIndividualData, IOrganizationData } from 'src/shared/lib/types/user/IUserData';
+import { computed } from 'vue';
+import { EditableIndividualCard } from 'src/shared/ui/EditableIndividualCard';
+import { EditableEntrepreneurCard } from 'src/shared/ui/EditableEntrepreneurCard';
+import { EditableOrganizationCard } from 'src/shared/ui/EditableOrganizationCard';
+import { useDisplayName } from 'src/shared/lib/composables/useDisplayName';
+import { CopyableInput } from 'src/shared/ui/CopyableInput';
+import 'src/shared/ui/CardStyles/index.scss';
+
+const currentUser = useCurrentUserStore();
+
+const userType = computed(() => currentUser.userAccount?.type);
+
+const userProfile = computed(() => {
+  return currentUser.userAccount?.private_data as IEntrepreneurData | IIndividualData | IOrganizationData | null;
+});
+
+const individualProfile = computed(() => {
+  if (userType.value === 'individual') {
+    return userProfile.value as IIndividualData;
+  }
+  return null;
+});
+
+const entrepreneurProfile = computed(() => {
+  if (userType.value === 'entrepreneur') {
+    return userProfile.value as IEntrepreneurData;
+  }
+  return null;
+});
+
+const organizationProfile = computed(() => {
+  if (userType.value === 'organization') {
+    return userProfile.value as IOrganizationData;
+  }
+  return null;
+});
+
+const { displayName, isIP } = useDisplayName(userProfile.value);
+
+const role = computed(() => {
+  if (currentUser.userAccount?.role === 'user')
+    return 'Пайщик';
+  else if (currentUser.userAccount?.role === 'member')
+    return 'Член совета';
+  else if (currentUser.userAccount?.role === 'chairman')
+    return 'Председатель совета';
+  else return '';
+});
+
+</script>
+
+<style lang="scss" scoped>
+.profile-avatar {
+  width: 180px;
+  height: 180px;
+  border-radius: 50%;
+  object-fit: cover;
+}
+
+.user-role {
+  font-size: 14px;
+  padding: 4px 8px;
+}
+</style>

package/src/pages/User/ProfilePage/ui/index.ts

@@ -0,0 +1 @@
+export { default as ProfilePage } from './ProfilePage.vue';

package/src/pages/User/SettingsPage/ui/index.ts

@@ -1 +1 @@
-export {default as UserSettingsPage} from './UserSettingsPage.vue'
+export { default as UserSettingsPage } from './UserSettingsPage.vue'

package/src/pages/User/WalletPage/index.ts

@@ -0,0 +1 @@
+export * from './ui';

package/src/pages/User/WalletPage/ui/WalletPage.vue

@@ -0,0 +1,72 @@
+<template lang="pug">
+div.q-pa-md
+  div.row
+    div.col-md-12.col-xs-12
+      q-card(flat class="card-container q-pa-md")
+        div.row.items-center.q-mb-md
+          div.col-12
+            div.text-h4.q-mb-xs Кошелёк
+            q-badge(color="primary" class="user-role") {{ role }}
+
+        div.row.q-mb-md
+          div.col-12
+            div.info-card
+              div.card-title Неснижаемый остаток
+              div.card-label Заблокировано
+              div.card-value {{ currentUser.participantAccount?.minimum_amount || '0' }}
+
+        div.row
+          div.col-12
+            div.text-h6.q-mb-sm Целевые Программы
+
+        div.row
+          div.col-6.q-pr-sm
+            DepositButton.full-width.card-action-btn
+          div.col-6.q-pl-sm
+            WithdrawButton.full-width.card-action-btn
+
+        div.row.q-mb-md
+          div.col-12
+            div
+              div.info-card.hover(v-for="program_wallet of walletStore.program_wallets" :key="program_wallet.id")
+                div.card-title {{ program_wallet.program_details.title }}
+                div.row
+                  div.col-6
+                    div.card-label Доступно
+                    div.card-value {{program_wallet.available || '0'}}
+                  div.col-6
+                    div.card-label Заблокировано
+                    div.card-value {{program_wallet.blocked || '0'}}
+
+</template>
+
+<script lang="ts" setup>
+import { DepositButton } from 'src/features/Wallet/DepositToWallet';
+import { WithdrawButton } from 'src/features/Wallet/WithdrawFromWallet';
+import { useWalletStore } from 'src/entities/Wallet';
+import { useCurrentUserStore } from 'src/entities/User';
+import { computed } from 'vue';
+import 'src/shared/ui/CardStyles/index.scss';
+
+const walletStore = useWalletStore();
+const currentUser = useCurrentUserStore();
+
+
+
+const role = computed(() => {
+  if (currentUser.userAccount?.role === 'user')
+    return 'Пайщик';
+  else if (currentUser.userAccount?.role === 'member')
+    return 'Член совета';
+  else if (currentUser.userAccount?.role === 'chairman')
+    return 'Председатель совета';
+  else return '';
+});
+</script>
+
+<style lang="scss" scoped>
+.user-role {
+  font-size: 14px;
+  padding: 4px 8px;
+}
+</style>

package/src/pages/User/WalletPage/ui/index.ts

@@ -0,0 +1 @@
+export { default as WalletPage } from './WalletPage.vue';

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

@@ -0,0 +1,28 @@
+import { useDesktopStore } from 'src/entities/Desktop/model'
+import { useSystemStore } from 'src/entities/System/model'
+import { useInitWalletProcess } from 'src/processes/init-wallet'
+import type { Router } from 'vue-router'
+import { useBranchOverlayProcess } from '../watch-branch-overlay'
+import { setupNavigationGuard } from '../navigation-guard-setup'
+import { useInitExtensionsProcess } from 'src/processes/init-installed-extensions'
+
+export async function useInitAppProcess(router: Router) {
+  const system = useSystemStore()
+  await system.loadSystemInfo()
+
+  const desktops = useDesktopStore()
+  await desktops.healthCheck()
+  await desktops.loadDesktop()
+
+  // Выбираем активный рабочий стол (например, participant)
+  desktops.selectWorkspace('participant')
+
+  useBranchOverlayProcess()
+  await useInitWalletProcess().run()
+
+  // Регистрируем маршруты рабочего стола
+  desktops.registerWorkspaceMenus(router)
+  setupNavigationGuard(router)
+
+  await useInitExtensionsProcess(router)
+}

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