@coopenomics/desktop 2025.5.14 → 2025.6.14

package/src/features/Meet/CloseMeetWithDecision/model/index.ts

@@ -1,6 +1,14 @@
 import { client } from 'src/shared/api/client'
 import { useSignDocument } from 'src/shared/lib/document/model/entity'
-import { Mutations } from '@coopenomics/sdk'
+import { Mutations, Zeus } from '@coopenomics/sdk'
+import { computed, ref, type Ref } from 'vue'
+import { useMeetStore } from 'src/entities/Meet'
+import { useSessionStore } from 'src/entities/Session'
+import { FailAlert, SuccessAlert } from 'src/shared/api'
+import moment from 'moment-with-locales-es6'
+import { useSystemStore } from 'src/entities/System/model'
+
+moment.locale('ru')
 
 export type ISignBySecretaryResult = Mutations.Meet.SignBySecretaryOnAnnualGeneralMeet.IOutput[typeof Mutations.Meet.SignBySecretaryOnAnnualGeneralMeet.name]
 export type ISignByPresiderResult = Mutations.Meet.SignByPresiderOnAnnualGeneralMeet.IOutput[typeof Mutations.Meet.SignByPresiderOnAnnualGeneralMeet.name]
@@ -11,7 +19,7 @@ interface ICloseMeetWithDecisionInput {
   username: string
 }
 
-
+// Базовые функции API для работы с бэкендом
 export async function signBySecretaryOnAnnualGeneralMeetWithDecision(data: ICloseMeetWithDecisionInput): Promise<ISignBySecretaryResult> {
   const { signDocument } = useSignDocument()
 
@@ -19,6 +27,7 @@ export async function signBySecretaryOnAnnualGeneralMeetWithDecision(data: IClos
     data: {
       coopname: data.coopname,
       username: data.username,
+      meet_hash: data.hash
     }
   }
 
@@ -30,7 +39,7 @@ export async function signBySecretaryOnAnnualGeneralMeetWithDecision(data: IClos
     }
   )
 
-  // Подписываем документ
+  // Подписываем документ первой подписью секретаря (signatureId = 1 по умолчанию)
   const signedDocument = await signDocument(generatedDocument, data.username)
 
   const variables2: Mutations.Meet.SignBySecretaryOnAnnualGeneralMeet.IInput = {
@@ -54,23 +63,35 @@ export async function signBySecretaryOnAnnualGeneralMeetWithDecision(data: IClos
 
 export async function signByPresiderOnAnnualGeneralMeetWithDecision(data: ICloseMeetWithDecisionInput): Promise<ISignByPresiderResult> {
   const { signDocument } = useSignDocument()
+  const meetStore = useMeetStore()
 
-  const variables: Mutations.Meet.GenerateAnnualGeneralMeetDecisionDocument.IInput = {
-    data: {
-      coopname: data.coopname,
-      username: data.username,
-    }
+  // Получаем текущее собрание из store
+  const currentMeet = meetStore.currentMeet
+  if (!currentMeet?.processing?.meet) {
+    throw new Error('Собрание не найдено в store')
   }
-  // Генерируем документ решения
-  const { [Mutations.Meet.GenerateAnnualGeneralMeetDecisionDocument.name]: generatedDocument } = await client.Mutation(
-    Mutations.Meet.GenerateAnnualGeneralMeetDecisionDocument.mutation,
-    {
-      variables
-    }
-  )
 
-  // Подписываем документ
-  const signedDocument = await signDocument(generatedDocument, data.username)
+  if (!currentMeet.processing.meet.decision1) {
+    throw new Error('Документ решения секретаря (decision1) не найден')
+  }
+
+  if (!currentMeet.processing.meet.decision1.rawDocument) {
+    throw new Error('Сырой документ решения секретаря (rawDocument) не найден')
+  }
+
+  if (!currentMeet.processing.meet.decision1.document) {
+    throw new Error('Подписанный документ решения секретаря (document) не найден')
+  }
+
+  // Используем существующий rawDocument из decision1 (созданный секретарем)
+  // и объединяем подпись секретаря с новой подписью председателя (signatureId = 2)
+  // В результате получается единый документ с обеими подписями
+  const signedDocument = await signDocument(
+    currentMeet.processing.meet.decision1.rawDocument,
+    data.username,
+    2,
+    [currentMeet.processing.meet.decision1.document]
+  )
 
   const variables2: Mutations.Meet.SignByPresiderOnAnnualGeneralMeet.IInput = {
     data: {
@@ -80,6 +101,7 @@ export async function signByPresiderOnAnnualGeneralMeetWithDecision(data: IClose
       presider_decision: signedDocument
     }
   }
+
   // Закрываем собрание с подписанным решением председателя
   const { [Mutations.Meet.SignByPresiderOnAnnualGeneralMeet.name]: result } = await client.Mutation(
     Mutations.Meet.SignByPresiderOnAnnualGeneralMeet.mutation,
@@ -90,3 +112,83 @@ export async function signByPresiderOnAnnualGeneralMeetWithDecision(data: IClose
 
   return result
 }
+
+// Композабл для использования в компонентах
+export const useCloseMeet = (
+  isProcessing?: Ref<boolean>
+) => {
+  const { info } = useSystemStore()
+
+  const localIsProcessing = ref(false)
+  const processingRef = isProcessing || localIsProcessing
+
+  const meetStore = useMeetStore()
+  const sessionStore = useSessionStore()
+
+  const canCloseBySecretary = computed(() => {
+    const meet = meetStore.currentMeet
+    if (!meet?.processing?.meet) return false
+
+    const now = moment()
+    const closeAt = moment(meet.processing.meet.close_at)
+
+    const isAfterCloseDate = now.isAfter(closeAt)
+    const isQuorumPassed = meet.processing.meet.quorum_passed === true
+    const isAuthorized = meet.processing.extendedStatus === Zeus.ExtendedMeetStatus.VOTING_COMPLETED
+    const isSecretary = meet.processing.meet.secretary === sessionStore.username
+
+    return isAfterCloseDate && isQuorumPassed && isAuthorized && isSecretary
+  })
+
+  const canCloseByPresider = computed(() => {
+    const meet = meetStore.currentMeet
+    if (!meet?.processing?.meet) return false
+    const isPresider = meet.processing.meet.presider === sessionStore.username
+    return meet.processing.extendedStatus === Zeus.ExtendedMeetStatus.PRECLOSED && isPresider
+  })
+
+  const closeMeetBySecretary = async () => {
+    if (!meetStore.currentMeet) return
+    processingRef.value = true
+    try {
+      await signBySecretaryOnAnnualGeneralMeetWithDecision({
+        coopname: info.coopname,
+        hash: meetStore.currentMeet.hash,
+        username: sessionStore.username,
+      })
+
+      await meetStore.loadMeet({ coopname: info.coopname, hash: meetStore.currentMeet.hash })
+      SuccessAlert('Собрание успешно закрыто')
+    } catch (error: any) {
+      FailAlert(error)
+    } finally {
+      processingRef.value = false
+    }
+  }
+
+  const closeMeetByPresider = async () => {
+    if (!meetStore.currentMeet) return
+    processingRef.value = true
+    try {
+      await signByPresiderOnAnnualGeneralMeetWithDecision({
+        coopname: info.coopname,
+        hash: meetStore.currentMeet.hash,
+        username: sessionStore.username,
+      })
+
+      await meetStore.loadMeet({ coopname: info.coopname, hash: meetStore.currentMeet.hash })
+      SuccessAlert('Собрание успешно закрыто')
+    } catch (error: any) {
+      FailAlert(error)
+    } finally {
+      processingRef.value = false
+    }
+  }
+
+  return {
+    canCloseBySecretary,
+    canCloseByPresider,
+    closeMeetBySecretary,
+    closeMeetByPresider
+  }
+}

package/src/features/Meet/CreateMeet/model/index.ts

@@ -1,12 +1,15 @@
 import { client } from 'src/shared/api/client'
 import { Mutations } from '@coopenomics/sdk'
-import { generateAgenda } from 'src/features/Meet/GenerateAgenda/model'
 import { useSignDocument } from 'src/shared/lib/document/model/entity'
-import { hashSHA256 } from 'src/shared/api/crypto'
+import { getTimezone } from 'src/shared/lib/utils/dates/timezone'
+import moment from 'moment-timezone'
 
 export type ICreateMeetInput = Mutations.Meet.CreateAnnualGeneralMeet.IInput['data']
 export type ICreateMeetResult = Mutations.Meet.CreateAnnualGeneralMeet.IOutput[typeof Mutations.Meet.CreateAnnualGeneralMeet.name]
 
+export type IGenerateAgendaInput = Mutations.Meet.GenerateAnnualGeneralMeetAgendaDocument.IInput['data']
+export type IGenerateAgendaResult = Mutations.Meet.GenerateAnnualGeneralMeetAgendaDocument.IOutput[typeof Mutations.Meet.GenerateAnnualGeneralMeetAgendaDocument.name]
+
 export interface ICreateMeetWithAgendaInput {
   coopname: string
   initiator: string
@@ -22,6 +25,24 @@ export interface ICreateMeetWithAgendaInput {
   }[]
 }
 
+/**
+ * Генерирует документ повестки собрания
+ * @private Внутренняя функция, не экспортируется
+ */
+async function generateAgenda(data: IGenerateAgendaInput, options?: any): Promise<IGenerateAgendaResult> {
+  const { [Mutations.Meet.GenerateAnnualGeneralMeetAgendaDocument.name]: generatedDocument } = await client.Mutation(
+    Mutations.Meet.GenerateAnnualGeneralMeetAgendaDocument.mutation,
+    {
+      variables: {
+        data,
+        options
+      }
+    }
+  );
+
+  return generatedDocument;
+}
+
 export async function createMeet(data: ICreateMeetInput): Promise<ICreateMeetResult> {
   const { [Mutations.Meet.CreateAnnualGeneralMeet.name]: result } = await client.Mutation(
     Mutations.Meet.CreateAnnualGeneralMeet.mutation,
@@ -36,12 +57,38 @@ export async function createMeet(data: ICreateMeetInput): Promise<ICreateMeetRes
 }
 
 export async function createMeetWithAgenda(data: ICreateMeetWithAgendaInput): Promise<ICreateMeetResult> {
+
   const { signDocument } = useSignDocument()
-  // Генерируем документ повестки
+
+  // Получаем московский часовой пояс для форматирования
+  const timezone = getTimezone()
+
+  // Преобразуем формат даты для документа, явно указывая московский часовой пояс
+  // Добавляем маркер '(Мск)' к датам, так как в шаблоне документа этот маркер не добавляется автоматически
+  const openAtFormatted = `${moment(data.open_at).tz(timezone).format('DD.MM.YYYY HH:mm')} (Мск)`
+  const closeAtFormatted = `${moment(data.close_at).tz(timezone).format('DD.MM.YYYY HH:mm')} (Мск)`
+
+  // Формируем вопросы повестки в требуемом формате
+  const questions = data.agenda_points.map((point, index) => ({
+    number: String(index + 1),
+    title: point.title,
+    decision: point.decision,
+    context: point.context || ''
+  }))
+
+  // Генерируем документ повестки с правильными параметрами согласно DTO
   const generatedDocument = await generateAgenda({
     coopname: data.coopname,
-    username: data.username
+    username: data.username,
+    meet: {
+      type: 'regular', // По умолчанию очередное собрание
+      open_at_datetime: openAtFormatted,
+      close_at_datetime: closeAtFormatted
+    },
+    questions: questions
   })
+
+
   // Подписываем документ
   const signedDocument = await signDocument(generatedDocument, data.username)
 
@@ -54,11 +101,6 @@ export async function createMeetWithAgenda(data: ICreateMeetWithAgendaInput): Pr
     secretary: data.secretary,
     open_at: data.open_at,
     close_at: data.close_at,
-    hash: await hashSHA256(JSON.stringify({
-      coopname: data.coopname,
-      initiator: data.initiator,
-      timestamp: Date.now()
-    })),
     proposal: signedDocument
   })
   return result

package/src/features/Meet/CreateMeet/ui/CreateMeet.vue

@@ -15,20 +15,51 @@ div
 <script setup lang="ts">
 import { ref } from 'vue'
 import { CreateMeetForm } from './index'
+import { createMeetWithAgenda } from '../model'
+import { useSessionStore } from 'src/entities/Session'
+import { useMeetStore } from 'src/entities/Meet'
+import { useRoute } from 'vue-router'
+import { Notify } from 'quasar'
+import { FailAlert } from 'src/shared/api'
+
+const route = useRoute()
+const sessionStore = useSessionStore()
+const meetStore = useMeetStore()
 
 const showCreateMeetDialog = ref(false)
 const isCreating = ref(false)
 
-const emit = defineEmits<{
-  (e: 'create', formData: any): void
-}>()
-
 const handleCreate = async (formData: any) => {
   isCreating.value = true
   try {
-    emit('create', formData)
+    await createMeetWithAgenda({
+      coopname: route.params.coopname as string,
+      initiator: formData.initiator,
+      presider: formData.presider,
+      secretary: formData.secretary,
+      open_at: formData.open_at,
+      close_at: formData.close_at,
+      username: sessionStore.username,
+      agenda_points: formData.agenda_points
+    })
+
+    Notify.create({
+      message: 'Собрание успешно создано',
+      type: 'positive',
+    })
+
+    // Закрываем диалог
+    showCreateMeetDialog.value = false
+
+    // Обновляем список собраний через стор
+    await meetStore.loadMeets({ coopname: route.params.coopname as string })
+
+    return true
+  } catch (e: any) {
+    FailAlert(e)
+    return false
   } finally {
     isCreating.value = false
   }
 }
-</script> 
+</script>

package/src/features/Meet/CreateMeet/ui/CreateMeetForm.vue

@@ -8,66 +8,73 @@ q-dialog(:model-value="modelValue" @update:model-value="$emit('update:modelValue
 
     q-card-section
       q-form(@submit="handleSubmit")
-        q-input(
-          v-model="formData.initiator"
-          label="Инициатор"
-          :rules="[val => !!val || 'Обязательное поле']"
-          dense
-        )
         q-input(
           v-model="formData.presider"
-          label="Председатель"
+          label="Имя аккаунта председателя собрания"
           :rules="[val => !!val || 'Обязательное поле']"
           dense
         )
         q-input(
           v-model="formData.secretary"
-          label="Секретарь"
+          label="Имя аккаунта секретаря собрания"
           :rules="[val => !!val || 'Обязательное поле']"
           dense
         )
         q-input(
           v-model="formData.open_at"
-          label="Дата и время открытия, UTC"
+          :label="env.NODE_ENV === 'development' ? `Дата и время открытия (мин. через 1 минуту, ${timezoneLabel})` : `Дата и время открытия (мин. через 15 дней, ${timezoneLabel})`"
           type="datetime-local"
           :rules="[val => !!val || 'Обязательное поле']"
           dense
         )
         q-input(
           v-model="formData.close_at"
-          label="Дата и время закрытия, UTC"
+          :label="`Дата и время закрытия (${timezoneLabel})`"
           type="datetime-local"
           :rules="[val => !!val || 'Обязательное поле']"
           dense
         )
 
+
         div.text-h6.q-mt-md Повестка собрания
 
-        div(v-for="(point, index) in formData.agenda_points" :key="index")
-          div.row.q-mb-sm
-            div.col
-              q-input(
-                v-model="point.title"
-                label="Заголовок"
-                :rules="[val => !!val || 'Обязательное поле']"
-                dense
-              )
-            div.col
-              q-input(
-                v-model="point.context"
-                label="Описание"
-                :rules="[val => !!val || 'Обязательное поле']"
-                dense
-              )
-            div.col
-              q-input(
-                v-model="point.decision"
-                label="Решение"
-                :rules="[val => !!val || 'Обязательное поле']"
-                dense
-              )
+        q-card(flat bordered v-for="(point, index) in formData.agenda_points" :key="index").q-mb-lg.q-pa-sm
+          div.row.items-center.q-mb-sm
+            div.text-subtitle1.q-mr-md № {{ index + 1 }}
             div.col-auto
-              q-btn(flat icon="delete" @click="removeAgendaPoint(index)")
+              q-btn(flat icon="delete" size="sm" color="grey" @click="removeAgendaPoint(index)")
+
+          div.q-mb-sm
+            q-input(
+              v-model="point.title"
+              label="Вопрос"
+              :rules="[val => !!val || 'Обязательное поле']"
+              dense
+              type="textarea"
+              autogrow
+            )
+
+          div.q-mb-sm
+            q-input(
+              v-model="point.decision"
+              label="Проект Решения"
+              :rules="[val => !!val || 'Обязательное поле']"
+              dense
+              type="textarea"
+              autogrow
+            )
+
+          div.q-mb-sm
+            q-input(
+              v-model="point.context"
+              label="Приложения"
+              :rules="[val => !!val || 'Обязательное поле']"
+              dense
+              type="textarea"
+              autogrow
+            )
+
+          q-separator(v-if="index < formData.agenda_points.length - 1")
 
         div.text-center.q-mb-md
           q-btn(outline label="Добавить пункт повестки" @click="addAgendaPoint")
@@ -83,6 +90,10 @@ q-dialog(:model-value="modelValue" @update:model-value="$emit('update:modelValue
 <script setup lang="ts">
 import { reactive } from 'vue'
 import { useAgendaPoints } from 'src/shared/hooks/useAgendaPoints'
+import { getCurrentLocalDateForForm, convertLocalDateToUTC, getTimezoneLabel, getFutureDateForForm } from 'src/shared/lib/utils/dates/timezone'
+import { env } from 'src/shared/config/Environment'
+import { useSessionStore } from 'src/entities/Session';
+import { useSystemStore } from 'src/entities/System/model';
 
 defineProps<{
   modelValue: boolean,
@@ -94,43 +105,54 @@ const emit = defineEmits<{
   (e: 'create', data: any): void
 }>()
 
-// Форма для создания собрания
+// Название часового пояса для отображения в лейблах
+const timezoneLabel = getTimezoneLabel()
+const session = useSessionStore()
+const system = useSystemStore()
 
+// Форма для создания собрания
 const formData = reactive(
-  {
-    'coopname': 'voskhod',
-    'initiator': 'ant',
-    'presider': 'ant',
-    'secretary': 'ant',
-    'open_at': new Date(Date.now() + 10000).toISOString().slice(0, 16),
-    'close_at': new Date(Date.now() + 120000).toISOString().slice(0, 16),
-    'username': 'ant',
-    'agenda_points': [
-        {
-            'title': 'test',
-            'context': 'testt',
-            'decision': 'testtt'
-        }
-    ]
-}
-// {
-//   initiator: '',
-//   presider: '',
-//   secretary: '',
-//   open_at: '',
-//   close_at: '',
-//   agenda_points: [{
-//     title: '',
-//     context: '',
-//     decision: ''
-//   }
-// ]
-// }
+  env.NODE_ENV === 'development'
+    ? {
+        coopname: system.info.coopname,
+        initiator: session.username,
+        presider: session.username,
+        secretary: session.username,
+        open_at: getCurrentLocalDateForForm(0.17), // ~10 секунд от текущего времени
+        close_at: getCurrentLocalDateForForm(2), // 2 минуты от текущего времени
+        username: session.username,
+        agenda_points: [
+          {
+            title: 'Тестовый вопрос',
+            context: 'Тут приложения к вопросу',
+            decision: 'Тут проект решения по вопросу',
+          },
+        ],
+      }
+    : {
+        coopname: system.info.coopname,
+        initiator: session.username,
+        presider: '',
+        secretary: '',
+        open_at: getFutureDateForForm(15, 6, 0), // через 15 дней, 6:00
+        close_at: getFutureDateForForm(18, 12, 0), // через 18 дней, 12:00
+        username: session.username,
+        agenda_points: [
+          // пустой массив, либо можно добавить пустой объект для вёрстки
+        ],
+      }
 )
 
 const { addAgendaPoint, removeAgendaPoint } = useAgendaPoints(formData.agenda_points)
 
 const handleSubmit = () => {
-  emit('create', formData)
+  // Конвертируем локальные даты в UTC для отправки в блокчейн
+  const dataToSend = {
+    ...formData,
+    open_at: convertLocalDateToUTC(formData.open_at),
+    close_at: convertLocalDateToUTC(formData.close_at)
+  }
+
+  emit('create', dataToSend)
 }
 </script>

package/src/features/Meet/GenerateSovietDecision/model/index.ts

@@ -5,17 +5,18 @@ import { useSystemStore } from 'src/entities/System/model'
 export type IGenerateSovietDecisionInput = Mutations.Meet.GenerateSovietDecisionOnAnnualMeetDocument.IInput['data'];
 export type IGenerateSovietDecisionResult = Mutations.Meet.GenerateSovietDecisionOnAnnualMeetDocument.IOutput[typeof Mutations.Meet.GenerateSovietDecisionOnAnnualMeetDocument.name];
 
-export async function generateSovietDecision(data: IGenerateSovietDecisionInput): Promise<IGenerateSovietDecisionResult> {
-  const { [Mutations.Meet.GenerateSovietDecisionOnAnnualMeetDocument.name]: result } = await client.Mutation(
+export async function generateSovietDecision(data: IGenerateSovietDecisionInput, options?: any): Promise<IGenerateSovietDecisionResult> {
+  const { [Mutations.Meet.GenerateSovietDecisionOnAnnualMeetDocument.name]: generatedDocument } = await client.Mutation(
     Mutations.Meet.GenerateSovietDecisionOnAnnualMeetDocument.mutation,
     {
       variables: {
-        data
+        data,
+        options
       }
     }
   );
 
-  return result;
+  return generatedDocument;
 }
 
 export function useGenerateSovietDecisionOnAnnualMeet() {
@@ -27,6 +28,15 @@ export function useGenerateSovietDecisionOnAnnualMeet() {
   async function generateSovietDecisionOnAnnualMeet(
     data: Omit<IGenerateSovietDecisionInput, 'coopname'>
   ): Promise<IGenerateSovietDecisionResult> {
+    // Здесь необходимо убедиться, что переданы все обязательные параметры согласно DTO
+    if (!data.decision_id) {
+      throw new Error('Необходимо указать ID решения совета (decision_id)')
+    }
+
+    if (!data.meet_hash) {
+      throw new Error('Необходимо указать хеш собрания (meet_hash)')
+    }
+
     const { [Mutations.Meet.GenerateSovietDecisionOnAnnualMeetDocument.name]: result } = await client.Mutation(
       Mutations.Meet.GenerateSovietDecisionOnAnnualMeetDocument.mutation,
       {