@coopenomics/desktop 2.2.10 → 2025.4.29

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

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

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

@@ -0,0 +1,34 @@
+import { computed } from 'vue';
+import type { IEntrepreneurData, IIndividualData, IOrganizationData } from 'src/shared/lib/types/user/IUserData';
+
+export function useDisplayName(privateData: IEntrepreneurData | IIndividualData | IOrganizationData | null) {
+  const displayName = computed(() => {
+    if (!privateData) return '';
+
+    if ('short_name' in privateData) {
+      // Это организация
+      return privateData.short_name;
+    } else if ('first_name' in privateData && 'last_name' in privateData) {
+      // Это физлицо или ИП
+      return `${privateData.last_name} ${privateData.first_name} ${privateData.middle_name || ''}`.trim();
+    }
+
+    return '';
+  });
+
+  const isIP = computed(() => {
+    if (!privateData) return false;
+
+    // Проверка на предпринимателя - наличие полей details.inn и details.ogrn, но нет short_name
+    return !('short_name' in privateData) &&
+           'details' in privateData &&
+           privateData.details &&
+           'inn' in privateData.details &&
+           'ogrn' in privateData.details;
+  });
+
+  return {
+    displayName,
+    isIP
+  };
+}

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

@@ -0,0 +1,2 @@
+export * from './routeUtils'
+export * from './useBackButton'

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

@@ -0,0 +1,51 @@
+import { RouteLocationNormalizedLoaded } from 'vue-router'
+
+/**
+ * Получает глубину текущего маршрута
+ *
+ * @param route Текущий маршрут
+ * @returns Глубина маршрута (количество уровней вложенности)
+ */
+export function getRouteDepth(route: RouteLocationNormalizedLoaded): number {
+  return route.matched?.length || 0
+}
+
+/**
+ * Получает родительский маршрут для текущего маршрута
+ *
+ * @param route Текущий маршрут
+ * @returns Родительский маршрут или null, если его нет
+ */
+export function getParentRoute(route: RouteLocationNormalizedLoaded) {
+  const matched = route.matched || []
+  if (matched.length < 2) {
+    return null
+  }
+
+  return matched[matched.length - 2]
+}
+
+/**
+ * Проверяет, есть ли у маршрута родительский маршрут
+ *
+ * @param route Текущий маршрут
+ * @returns true, если у маршрута есть родитель, иначе false
+ */
+export function hasParentRoute(route: RouteLocationNormalizedLoaded): boolean {
+  return getParentRoute(route) !== null
+}
+
+/**
+ * Получает заголовок маршрута из его метаданных
+ *
+ * @param route Маршрут
+ * @param defaultTitle Заголовок по умолчанию, если в маршруте не указан
+ * @returns Заголовок маршрута
+ */
+export function getRouteTitle(route: RouteLocationNormalizedLoaded | null, defaultTitle = 'Назад'): string {
+  if (!route || !route.meta || !route.meta.title) {
+    return defaultTitle
+  }
+
+  return route.meta.title as string
+}

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

@@ -0,0 +1,63 @@
+import { onMounted, onUnmounted } from 'vue'
+import { useRouter } from 'vue-router'
+import { useDesktopStore } from 'src/entities/Desktop/model'
+import type { IBackNavigationButton } from 'src/entities/Desktop/model/types'
+
+interface BackButtonOptions {
+  text: string
+  routeName?: string
+  params?: Record<string, string>
+  componentId: string
+  onClick?: () => void
+}
+
+/**
+ * Хук для работы с кнопкой навигации "назад"
+ *
+ * @param options - объект с настройками кнопки
+ * @returns Функции для управления кнопкой
+ */
+export function useBackButton(options: BackButtonOptions) {
+  const router = useRouter()
+  const desktopStore = useDesktopStore()
+  
+  // Устанавливаем кнопку навигации назад
+  function setBackButton() {
+    // Формируем данные для кнопки
+    const button: IBackNavigationButton = {
+      text: options.text,
+      componentId: options.componentId,
+      onClick: options.onClick || (() => {
+        if (options.routeName) {
+          router.push({
+            name: options.routeName,
+            params: options.params || {}
+          })
+        } else {
+          router.back()
+        }
+      })
+    }
+    
+    desktopStore.setBackNavigationButton(button)
+  }
+  
+  // Удаляем кнопку навигации назад
+  function removeBackButton() {
+    desktopStore.removeBackNavigationButton(options.componentId)
+  }
+  
+  // Автоматически устанавливаем и удаляем кнопку
+  onMounted(() => {
+    setBackButton()
+  })
+  
+  onUnmounted(() => {
+    removeBackButton()
+  })
+  
+  return {
+    setBackButton,
+    removeBackButton
+  }
+} 

package/src/shared/lib/utils/dates/validateDateWithinRange.ts

@@ -0,0 +1,23 @@
+import moment from 'moment-with-locales-es6';
+
+export function validateDateWithinRange(yearsAgo, yearsAhead = 0) {
+  return (val) => {
+    const inputDate = moment(val, 'YYYY/MM/DD HH:mm', true); // указание формата для парсинга
+    const lowerLimit = moment().subtract(Math.abs(yearsAgo), 'years'); // Предел в прошлом
+    const upperLimit = moment().add(Math.abs(yearsAhead), 'years'); // Предел в будущем
+
+    if (!inputDate.isValid()) {
+      return 'Неверный формат даты';
+    }
+
+    if (inputDate.isBefore(lowerLimit)) {
+      return `Дата не может быть раньше ${lowerLimit.format('YYYY/MM/DD HH:mm')}`;
+    }
+
+    if (inputDate.isAfter(upperLimit)) {
+      return `Дата не может быть позже ${upperLimit.format('YYYY/MM/DD HH:mm')}`;
+    }
+
+    return true;
+  };
+}