@coopenomics/desktop 2.2.10 → 2025.5.2

package/src/features/FreeDecision/GenerateDecision/model/index.ts

@@ -0,0 +1,36 @@
+import { client } from 'src/shared/api/client'
+import { Mutations } from '@coopenomics/sdk'
+import { useSystemStore } from 'src/entities/System/model'
+
+export type IGenerateFreeDecisionData = Mutations.FreeDecisions.GenerateFreeDecision.IInput['data']
+export type IGenerateFreeDecisionResult = Mutations.FreeDecisions.GenerateFreeDecision.IOutput[typeof Mutations.FreeDecisions.GenerateFreeDecision.name]
+
+export function useGenerateFreeDecision() {
+  const { info } = useSystemStore()
+
+  /**
+   * Генерирует документ для свободного решения
+   */
+  async function generateFreeDecision(data: Omit<IGenerateFreeDecisionData, 'coopname'>): Promise<IGenerateFreeDecisionResult> {
+    const { [Mutations.FreeDecisions.GenerateFreeDecision.name]: result } = await client.Mutation(
+      Mutations.FreeDecisions.GenerateFreeDecision.mutation,
+      {
+        variables: {
+          data: {
+            coopname: info.coopname,
+            ...data
+          },
+          options: {
+            lang: 'ru'
+          }
+        }
+      }
+    )
+
+    return result
+  }
+
+  return {
+    generateFreeDecision
+  }
+}

package/src/features/FreeDecision/index.ts

@@ -0,0 +1,2 @@
+export * from './CreateProject'
+export * from './GenerateDecision'

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

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

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

@@ -0,0 +1,92 @@
+import { client } from 'src/shared/api/client'
+import { useSignDocument } from 'src/shared/lib/document/model/entity'
+import { Mutations } from '@coopenomics/sdk'
+
+export type ISignBySecretaryResult = Mutations.Meet.SignBySecretaryOnAnnualGeneralMeet.IOutput[typeof Mutations.Meet.SignBySecretaryOnAnnualGeneralMeet.name]
+export type ISignByPresiderResult = Mutations.Meet.SignByPresiderOnAnnualGeneralMeet.IOutput[typeof Mutations.Meet.SignByPresiderOnAnnualGeneralMeet.name]
+
+interface ICloseMeetWithDecisionInput {
+  coopname: string
+  hash: string
+  username: string
+}
+
+
+export async function signBySecretaryOnAnnualGeneralMeetWithDecision(data: ICloseMeetWithDecisionInput): Promise<ISignBySecretaryResult> {
+  const { signDocument } = useSignDocument()
+  
+  const variables: Mutations.Meet.GenerateAnnualGeneralMeetDecisionDocument.IInput = {
+    data: {    
+      coopname: data.coopname,
+      username: data.username,
+    }
+  }
+  
+  // Генерируем документ решения
+  const { [Mutations.Meet.GenerateAnnualGeneralMeetDecisionDocument.name]: generatedDocument } = await client.Mutation(
+    Mutations.Meet.GenerateAnnualGeneralMeetDecisionDocument.mutation,
+    {
+      variables
+    }
+  )
+  
+  // Подписываем документ
+  const signedDocument = await signDocument(generatedDocument)
+
+  const variables2: Mutations.Meet.SignBySecretaryOnAnnualGeneralMeet.IInput = {
+    data: {
+      coopname: data.coopname,
+      hash: data.hash,
+      username: data.username,
+      secretary_decision: signedDocument
+    }
+  }
+  // Закрываем собрание с подписанным решением секретаря
+  const { [Mutations.Meet.SignBySecretaryOnAnnualGeneralMeet.name]: result } = await client.Mutation(
+    Mutations.Meet.SignBySecretaryOnAnnualGeneralMeet.mutation,
+    {
+      variables: variables2
+    }
+  )
+  
+  return result
+}
+
+export async function signByPresiderOnAnnualGeneralMeetWithDecision(data: ICloseMeetWithDecisionInput): Promise<ISignByPresiderResult> {
+  const { signDocument } = useSignDocument()
+  
+  const variables: Mutations.Meet.GenerateAnnualGeneralMeetDecisionDocument.IInput = {
+    data: {    
+      coopname: data.coopname,
+      username: data.username,
+    }
+  }
+  // Генерируем документ решения
+  const { [Mutations.Meet.GenerateAnnualGeneralMeetDecisionDocument.name]: generatedDocument } = await client.Mutation(
+    Mutations.Meet.GenerateAnnualGeneralMeetDecisionDocument.mutation,
+    {
+      variables
+    }
+  )
+  
+  // Подписываем документ
+  const signedDocument = await signDocument(generatedDocument)
+  
+  const variables2: Mutations.Meet.SignByPresiderOnAnnualGeneralMeet.IInput = {
+    data: {
+      coopname: data.coopname,
+      hash: data.hash,
+      username: data.username,
+      presider_decision: signedDocument 
+    }
+  }
+  // Закрываем собрание с подписанным решением председателя
+  const { [Mutations.Meet.SignByPresiderOnAnnualGeneralMeet.name]: result } = await client.Mutation(
+    Mutations.Meet.SignByPresiderOnAnnualGeneralMeet.mutation,
+    {
+      variables: variables2
+    }
+  )
+  
+  return result
+}

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

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

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

@@ -0,0 +1,65 @@
+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'
+
+export type ICreateMeetInput = Mutations.Meet.CreateAnnualGeneralMeet.IInput['data']
+export type ICreateMeetResult = Mutations.Meet.CreateAnnualGeneralMeet.IOutput[typeof Mutations.Meet.CreateAnnualGeneralMeet.name]
+
+export interface ICreateMeetWithAgendaInput {
+  coopname: string
+  initiator: string
+  presider: string
+  secretary: string
+  open_at: string
+  close_at: string
+  username: string
+  agenda_points: {
+    title: string
+    context: string
+    decision: string
+  }[]
+}
+
+export async function createMeet(data: ICreateMeetInput): Promise<ICreateMeetResult> {
+  const { [Mutations.Meet.CreateAnnualGeneralMeet.name]: result } = await client.Mutation(
+    Mutations.Meet.CreateAnnualGeneralMeet.mutation,
+    {
+      variables: {
+        data
+      }
+    }
+  );
+
+  return result;
+}
+
+export async function createMeetWithAgenda(data: ICreateMeetWithAgendaInput): Promise<ICreateMeetResult> {
+  const { signDocument } = useSignDocument()
+  // Генерируем документ повестки
+  const generatedDocument = await generateAgenda({
+    coopname: data.coopname,
+    username: data.username
+  })
+  // Подписываем документ
+  const signedDocument = await signDocument(generatedDocument)
+
+  // Создаем собрание
+  const result = await createMeet({
+    coopname: data.coopname,
+    agenda: data.agenda_points,
+    initiator: data.initiator,
+    presider: data.presider,
+    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

@@ -0,0 +1,34 @@
+<template lang="pug">
+div
+  q-btn(
+    color="primary"
+    label="Создать общее собрание"
+    @click="showCreateMeetDialog = true"
+  )
+  CreateMeetForm(
+    v-model="showCreateMeetDialog"
+    :loading="isCreating"
+    @create="handleCreate"
+  )
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue'
+import { CreateMeetForm } from './index'
+
+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)
+  } finally {
+    isCreating.value = false
+  }
+}
+</script> 

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

@@ -0,0 +1,136 @@
+<template lang="pug">
+q-dialog(:model-value="modelValue" @update:model-value="$emit('update:modelValue', $event)" persistent)
+  q-card(style="min-width: 500px")
+    q-card-section.row.items-center
+      div.text-h6 Создать общее собрание
+      q-space
+      q-btn(icon="close" flat round dense v-close-popup @click="$emit('update:modelValue', false)")
+
+    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="Председатель"
+          :rules="[val => !!val || 'Обязательное поле']"
+          dense
+        )
+        q-input(
+          v-model="formData.secretary"
+          label="Секретарь"
+          :rules="[val => !!val || 'Обязательное поле']"
+          dense
+        )
+        q-input(
+          v-model="formData.open_at"
+          label="Дата и время открытия, UTC"
+          type="datetime-local"
+          :rules="[val => !!val || 'Обязательное поле']"
+          dense
+        )
+        q-input(
+          v-model="formData.close_at"
+          label="Дата и время закрытия, UTC"
+          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
+              )
+            div.col-auto
+              q-btn(flat icon="delete" @click="removeAgendaPoint(index)")
+
+        div.text-center.q-mb-md
+          q-btn(outline label="Добавить пункт повестки" @click="addAgendaPoint")
+
+    q-card-section.q-pt-none
+      div.text-caption.text-grey При создании собрания будет сгенерирован документ повестки.
+
+    q-card-actions(align="right")
+      q-btn(flat label="Отмена" v-close-popup @click="$emit('update:modelValue', false)" :disable="loading")
+      q-btn(color="primary" label="Создать" type="submit" @click="handleSubmit" :loading="loading" )
+</template>
+
+<script setup lang="ts">
+import { reactive } from 'vue'
+import { useAgendaPoints } from 'src/shared/hooks/useAgendaPoints'
+
+defineProps<{
+  modelValue: boolean,
+  loading?: boolean
+}>()
+
+const emit = defineEmits<{
+  (e: 'update:modelValue', value: boolean): void
+  (e: 'create', data: any): void
+}>()
+
+// Форма для создания собрания
+
+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: ''
+//   }
+// ]
+// }
+)
+
+const { addAgendaPoint, removeAgendaPoint } = useAgendaPoints(formData.agenda_points)
+
+const handleSubmit = () => {
+  emit('create', formData)
+}
+</script>

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

@@ -0,0 +1,2 @@
+export { default as CreateMeetForm } from './CreateMeetForm.vue' 
+export { default as CreateMeet } from './CreateMeet.vue'

package/src/features/Meet/GenerateAgenda/index.ts

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

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

@@ -0,0 +1,18 @@
+import { client } from 'src/shared/api/client';
+import { Mutations } from '@coopenomics/sdk';
+
+export type IGenerateAgendaInput = Mutations.Meet.GenerateAnnualGeneralMeetAgendaDocument.IInput['data'];
+export type IGenerateAgendaResult = Mutations.Meet.GenerateAnnualGeneralMeetAgendaDocument.IOutput[typeof Mutations.Meet.GenerateAnnualGeneralMeetAgendaDocument.name];
+
+export async function generateAgenda(data: IGenerateAgendaInput): Promise<IGenerateAgendaResult> {
+  const { [Mutations.Meet.GenerateAnnualGeneralMeetAgendaDocument.name]: generatedDocument } = await client.Mutation(
+    Mutations.Meet.GenerateAnnualGeneralMeetAgendaDocument.mutation,
+    {
+      variables: {
+        data
+      }
+    }
+  );
+
+  return generatedDocument;
+}

package/src/features/Meet/GenerateBallot/index.ts

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

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

@@ -0,0 +1,18 @@
+import { client } from 'src/shared/api/client';
+import { Mutations } from '@coopenomics/sdk';
+
+export type IGenerateBallotInput = Mutations.Meet.GenerateBallotForAnnualGeneralMeetDocument.IInput['data'];
+export type IGenerateBallotResult = Mutations.Meet.GenerateBallotForAnnualGeneralMeetDocument.IOutput[typeof Mutations.Meet.GenerateBallotForAnnualGeneralMeetDocument.name];
+
+export async function generateBallot(data: IGenerateBallotInput): Promise<IGenerateBallotResult> {
+  const { [Mutations.Meet.GenerateBallotForAnnualGeneralMeetDocument.name]: result } = await client.Mutation(
+    Mutations.Meet.GenerateBallotForAnnualGeneralMeetDocument.mutation,
+    {
+      variables: {
+        data
+      }
+    }
+  );
+
+  return result;
+}

package/src/features/Meet/GenerateNotification/index.ts

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

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

@@ -0,0 +1,18 @@
+import { client } from 'src/shared/api/client'
+import { Mutations } from '@coopenomics/sdk'
+
+export type IGenerateNotificationInput = Mutations.Meet.GenerateAnnualGeneralMeetNotificationDocument.IInput['data']
+export type IGenerateNotificationResult = Mutations.Meet.GenerateAnnualGeneralMeetNotificationDocument.IOutput[typeof Mutations.Meet.GenerateAnnualGeneralMeetNotificationDocument.name]
+
+export async function generateNotification(data: IGenerateNotificationInput): Promise<IGenerateNotificationResult> {
+  const { [Mutations.Meet.GenerateAnnualGeneralMeetNotificationDocument.name]: result } = await client.Mutation(
+    Mutations.Meet.GenerateAnnualGeneralMeetNotificationDocument.mutation,
+    {
+      variables: {
+        data
+      }
+    }
+  )
+
+  return result
+} 

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

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

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

@@ -0,0 +1,48 @@
+import { client } from 'src/shared/api/client';
+import { Mutations } from '@coopenomics/sdk';
+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(
+    Mutations.Meet.GenerateSovietDecisionOnAnnualMeetDocument.mutation,
+    {
+      variables: {
+        data
+      }
+    }
+  );
+
+  return result;
+}
+
+export function useGenerateSovietDecisionOnAnnualMeet() {
+  const { info } = useSystemStore()
+
+  /**
+   * Генерирует документ для решения о проведении общего собрания
+   */
+  async function generateSovietDecisionOnAnnualMeet(
+    data: Omit<IGenerateSovietDecisionInput, 'coopname'>
+  ): Promise<IGenerateSovietDecisionResult> {
+    const { [Mutations.Meet.GenerateSovietDecisionOnAnnualMeetDocument.name]: result } = await client.Mutation(
+      Mutations.Meet.GenerateSovietDecisionOnAnnualMeetDocument.mutation,
+      {
+        variables: {
+          data: {
+            coopname: info.coopname,
+            ...data
+          }
+        }
+      }
+    )
+
+    return result
+  }
+
+  return {
+    generateSovietDecisionOnAnnualMeet
+  }
+}

package/src/features/Meet/MeetDetailsManagement/index.ts

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

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

@@ -0,0 +1,121 @@
+import { computed, type Ref } from 'vue'
+import type { IMeet } from 'src/entities/Meet'
+import { useMeetStore } from 'src/entities/Meet'
+import { useSessionStore } from 'src/entities/Session'
+import { FailAlert, SuccessAlert } from 'src/shared/api'
+import { signByPresiderOnAnnualGeneralMeetWithDecision } from 'src/features/Meet/CloseMeetWithDecision/model'
+import { restartMeetWithProposal } from 'src/features/Meet/RestartMeet/model'
+import moment from 'moment-with-locales-es6'
+
+moment.locale('ru')
+
+export const useMeetDetailsManagement = (
+  meet: IMeet,
+  coopname: string,
+  meetHash: string,
+  isProcessing: Ref<boolean>
+) => {
+  const meetStore = useMeetStore()
+  const sessionStore = useSessionStore()
+
+  const canManageMeet = computed(() => true) // Здесь можно добавить проверку ролей
+
+  const canCloseBySecretary = computed(() => {
+    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.meet.status === 'authorized'
+    
+    return isAfterCloseDate && isQuorumPassed && isAuthorized
+  })
+
+  const canCloseByPresider = computed(() => {
+    if (!meet?.processing?.meet) return false
+    return meet.processing.meet.status === 'preclose'
+  })
+
+  const canRestartMeet = computed(() => {
+    if (!meet?.processing?.meet) return false
+    
+    const now = moment()
+    const closeAt = moment(meet.processing.meet.close_at)
+    
+    const isAfterCloseDate = now.isAfter(closeAt)
+    const isQuorumNotPassed = meet.processing.meet.quorum_passed !== true
+    
+    return isAfterCloseDate && isQuorumNotPassed && meet.processing.meet.status === 'authorized'
+  })
+
+  const closeMeetBySecretary = async () => {
+    isProcessing.value = true
+    try {
+      await signByPresiderOnAnnualGeneralMeetWithDecision({
+        coopname,
+        hash: meetHash,
+        username: sessionStore.username,
+      })
+
+      await meetStore.loadMeet({ coopname, hash: meetHash })
+      SuccessAlert('Собрание успешно закрыто')
+    } catch (error: any) {
+      FailAlert(error)
+    } finally {
+      isProcessing.value = false
+    }
+  }
+
+  const closeMeetByPresider = async () => {
+    isProcessing.value = true
+    try {
+      await signByPresiderOnAnnualGeneralMeetWithDecision({
+        coopname,
+        hash: meetHash,
+        username: sessionStore.username,
+      })
+
+      await meetStore.loadMeet({ coopname, hash: meetHash })
+      SuccessAlert('Собрание успешно закрыто')
+    } catch (error: any) {
+      FailAlert(error)
+    } finally {
+      isProcessing.value = false
+    }
+  }
+
+  const handleRestartMeet = async (data: any) => {
+    isProcessing.value = true
+    try {
+      await restartMeetWithProposal({
+        coopname,
+        hash: meetHash,
+        username: sessionStore.username,
+        new_open_at: data.new_open_at,
+        new_close_at: data.new_close_at,
+        agenda_points: data.agenda_points
+      })
+
+      await meetStore.loadMeet({ coopname, hash: meetHash })
+      SuccessAlert('Собрание успешно перезапущено')
+      return true
+    } catch (error: any) {
+      FailAlert(error)
+      return false
+    } finally {
+      isProcessing.value = false
+    }
+  }
+
+  return {
+    canManageMeet,
+    canCloseBySecretary,
+    canCloseByPresider,
+    canRestartMeet,
+    closeMeetBySecretary,
+    closeMeetByPresider,
+    handleRestartMeet
+  }
+} 

package/src/features/Meet/RestartMeet/index.ts

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

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

@@ -0,0 +1,54 @@
+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'
+
+export type IRestartMeetInput = Mutations.Meet.RestartAnnualGeneralMeet.IInput['data'];
+export type IRestartMeetResult = Mutations.Meet.RestartAnnualGeneralMeet.IOutput[typeof Mutations.Meet.RestartAnnualGeneralMeet.name];
+
+export interface IRestartMeetWithProposalInput {
+  coopname: string
+  hash: string
+  username: string
+  new_open_at: string
+  new_close_at: string
+  agenda_points: {
+    title: string
+    context: string
+    decision: string
+  }[]
+}
+
+export async function restartMeet(data: IRestartMeetInput): Promise<IRestartMeetResult> {
+  const { [Mutations.Meet.RestartAnnualGeneralMeet.name]: result } = await client.Mutation(
+    Mutations.Meet.RestartAnnualGeneralMeet.mutation,
+    {
+      variables: {
+        data
+      }
+    }
+  );
+
+  return result;
+}
+
+export async function restartMeetWithProposal(data: IRestartMeetWithProposalInput): Promise<IRestartMeetResult> {
+  const { signDocument } = useSignDocument()
+  // Генерируем документ повестки
+  const generatedDocument = await generateAgenda({
+    coopname: data.coopname,
+    username: data.username
+  })
+  // Подписываем документ
+  const signedDocument = await signDocument(generatedDocument)
+
+  // Перезапускаем собрание
+  const result = await restartMeet({
+    coopname: data.coopname,
+    hash: data.hash,
+    new_open_at: data.new_open_at,
+    new_close_at: data.new_close_at,
+    newproposal: signedDocument
+  })
+  return result
+}