@coopenomics/desktop 2025.7.3 → 2025.11.8-alpha-2

package/extensions/capital/features/Issue/SetCreator/ui/SetCreatorButton.vue

@@ -0,0 +1,174 @@
+<template lang="pug">
+div(style="max-width: 300px")
+  ContributorSelector(
+    v-model='selectedCreators'
+    :multi-select='true'
+    :dense='dense'
+    :disable='disable'
+    :loading='loading'
+    :project-hash='issue?.project_hash'
+    placeholder=''
+    class='creators-selector'
+    label='Исполнители'
+  )
+</template>
+
+<script setup lang="ts">
+import { ref, watch } from 'vue';
+import { useSetCreators } from '../model';
+import { useContributorStore } from '../../../../entities/Contributor/model';
+import { FailAlert } from 'src/shared/api/alerts';
+import { ContributorSelector } from '../../../../entities/Contributor';
+import type { IIssue } from '../../../../entities/Issue/model';
+import type { IContributor } from '../../../../entities/Contributor/model';
+
+interface Props {
+  issue: IIssue;
+  dense?: boolean;
+  disable?: boolean;
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  dense: false,
+  disable: false,
+});
+
+const emit = defineEmits<{
+  'creators-set': [creators: IContributor[]];
+}>();
+
+const { setCreators, setCreatorsInput } = useSetCreators();
+const contributorStore = useContributorStore();
+const loading = ref(false);
+const selectedCreators = ref<IContributor[]>([]);
+const currentCreators = ref<IContributor[]>([]);
+const isSaving = ref(false);
+
+// Загрузка контрибьюторов по их usernames
+const loadCreators = async (creatorUsernames: string[]) => {
+  if (!creatorUsernames || creatorUsernames.length === 0) {
+    currentCreators.value = [];
+    selectedCreators.value = [];
+    return;
+  }
+
+  try {
+    // Загружаем каждого контрибьютора отдельно
+    const creators = await Promise.all(
+      creatorUsernames.map(async (username) => {
+        try {
+          return await contributorStore.loadContributor({ username });
+        } catch (error) {
+          console.error(`Failed to load contributor ${username}:`, error);
+          return null;
+        }
+      })
+    );
+
+    // Фильтруем null значения и устанавливаем текущих создателей
+    currentCreators.value = creators.filter((creator): creator is IContributor => creator !== null);
+    selectedCreators.value = [...currentCreators.value];
+  } catch (error) {
+    console.error('Error loading creators:', error);
+    FailAlert('Не удалось загрузить создателей задачи');
+    currentCreators.value = [];
+    selectedCreators.value = [];
+  }
+};
+
+// Обновляем входные данные при изменении задачи
+watch(
+  () => props.issue,
+  async (newIssue) => {
+    if (newIssue) {
+      setCreatorsInput.value.issue_hash = newIssue.issue_hash;
+      // Загружаем контрибьюторов по их usernames
+      await loadCreators(newIssue.creators || []);
+    } else {
+      // Если задачи нет, очищаем создателей
+      await loadCreators([]);
+    }
+  },
+  { immediate: true },
+);
+
+// Автоматическое сохранение при изменении выбранных создателей
+watch(selectedCreators, async (newCreators, oldCreators) => {
+  // Игнорируем начальную установку
+  if (oldCreators === undefined) return;
+
+  // Предотвращаем повторное сохранение
+  if (isSaving.value) return;
+
+  // Проверяем, что newCreators не null и является массивом
+  if (!Array.isArray(newCreators)) {
+    console.warn('SetCreatorButton: newCreators is not an array', newCreators);
+    return;
+  }
+
+  // Проверяем, что у всех выбранных участников есть username
+  const invalidContributors = newCreators.filter(c => !c?.username);
+  if (invalidContributors.length > 0) {
+    console.error('SetCreatorButton: invalid contributors', invalidContributors);
+    FailAlert('У некоторых выбранных участников отсутствует имя пользователя');
+    return;
+  }
+
+  // Проверяем, изменились ли данные по сравнению с текущими создателями
+  const newUsernames = newCreators
+    .map(c => c?.username)
+    .filter(Boolean)
+    .sort();
+  const currentUsernames = currentCreators.value
+    .map(c => c?.username)
+    .filter(Boolean)
+    .sort();
+
+  const usernamesChanged = JSON.stringify(newUsernames) !== JSON.stringify(currentUsernames);
+
+  if (!usernamesChanged) {
+    // Данные не изменились, не сохраняем
+    return;
+  }
+
+  isSaving.value = true;
+  loading.value = true;
+
+  try {
+    // Создаем копию объекта для передачи в API
+    const inputData = {
+      issue_hash: setCreatorsInput.value.issue_hash,
+      creators: newCreators
+        .map((c: IContributor) => c?.username)
+        .filter((username): username is string => username !== undefined && username !== null),
+    };
+
+    await setCreators(inputData, props.issue);
+
+    // Обновляем currentCreators после успешного сохранения
+    currentCreators.value = [...newCreators];
+
+    emit('creators-set', newCreators);
+  } catch (error) {
+    console.error('SetCreatorButton: setCreators error', error);
+    FailAlert(error);
+
+    // При ошибке перезагружаем создателей из issue
+    if (props.issue) {
+      await loadCreators(props.issue.creators || []);
+    }
+  } finally {
+    loading.value = false;
+    isSaving.value = false;
+  }
+}, { deep: true });
+
+</script>
+
+<style lang="scss" scoped>
+.creators-selector {
+  :deep(.q-field) {
+    min-width: 250px;
+  }
+}
+</style>

package/extensions/capital/features/Issue/SetCreator/ui/index.ts

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

package/extensions/capital/features/Issue/UpdateIssue/api/index.ts

@@ -0,0 +1,23 @@
+import type {
+  IUpdateIssueInput,
+  IUpdateIssueOutput,
+} from 'app/extensions/capital/entities/Issue/model';
+import { client } from 'src/shared/api/client';
+import { Mutations } from '@coopenomics/sdk';
+
+async function updateIssue(
+  data: IUpdateIssueInput,
+): Promise<IUpdateIssueOutput> {
+  const { [Mutations.Capital.UpdateIssue.name]: result } =
+    await client.Mutation(Mutations.Capital.UpdateIssue.mutation, {
+      variables: {
+        data,
+      },
+    });
+
+  return result;
+}
+
+export const api = {
+  updateIssue,
+};

package/extensions/capital/features/Issue/UpdateIssue/index.ts

@@ -0,0 +1,4 @@
+export * from './model';
+export * from './ui/UpdateStatus';
+export * from './ui/UpdatePriority';
+export * from './ui/UpdateEstimate';

package/extensions/capital/features/Issue/UpdateIssue/model/index.ts

@@ -0,0 +1,111 @@
+import { ref, type Ref } from 'vue';
+import { type Mutations } from '@coopenomics/sdk';
+import { api } from '../api';
+import {
+  useIssueStore,
+  type IUpdateIssueOutput,
+} from 'app/extensions/capital/entities/Issue/model';
+import { FailAlert } from 'src/shared/api/alerts';
+
+export type IUpdateIssueInput = Mutations.Capital.UpdateIssue.IInput['data'];
+
+export function useUpdateIssue() {
+  const store = useIssueStore();
+
+  const initialUpdateIssueInput: Partial<IUpdateIssueInput> = {};
+
+  const updateIssueInput = ref<Partial<IUpdateIssueInput>>({
+    ...initialUpdateIssueInput,
+  });
+
+  // Состояния для авто-сохранения
+  const isAutoSaving = ref(false);
+  const autoSaveError = ref<string | null>(null);
+
+  // Таймер для debounce
+  let autoSaveTimeout: ReturnType<typeof setTimeout> | null = null;
+
+  // Функция debounce для отложенного сохранения
+  function debounceSave(data: IUpdateIssueInput, projectHash: string, delay = 2000) {
+    // Очищаем предыдущий таймер
+    if (autoSaveTimeout) {
+      clearTimeout(autoSaveTimeout);
+    }
+
+    // Возвращаем Promise, который разрешается/отклоняется после выполнения
+    return new Promise<void>((resolve, reject) => {
+      // Устанавливаем новый таймер
+      autoSaveTimeout = setTimeout(async () => {
+        try {
+          await performAutoSave(data, projectHash);
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      }, delay);
+    });
+  }
+
+  // Выполнение авто-сохранения
+  async function performAutoSave(data: IUpdateIssueInput, projectHash: string) {
+    if (isAutoSaving.value) return;
+
+    try {
+      isAutoSaving.value = true;
+      autoSaveError.value = null;
+
+      await updateIssue(data, projectHash);
+    } catch (error: any) {
+      console.error('Auto-save failed:', error);
+      autoSaveError.value = 'Ошибка авто-сохранения';
+      FailAlert(error);
+      throw error; // Выбрасываем ошибку дальше для отката в UI
+    } finally {
+      isAutoSaving.value = false;
+    }
+  }
+
+  // Функция для немедленного сохранения (отменяет debounce)
+  async function saveImmediately(data: IUpdateIssueInput, projectHash: string) {
+    // Очищаем таймер debounce
+    if (autoSaveTimeout) {
+      clearTimeout(autoSaveTimeout);
+      autoSaveTimeout = null;
+    }
+
+    return await performAutoSave(data, projectHash);
+  }
+
+  // Универсальная функция для сброса объекта к начальному состоянию
+  function resetInput(
+    input: Ref<Partial<IUpdateIssueInput>>,
+    initial: Partial<IUpdateIssueInput>,
+  ) {
+    Object.assign(input.value, initial);
+  }
+
+  async function updateIssue(
+    data: IUpdateIssueInput,
+    projectHash: string,
+  ): Promise<IUpdateIssueOutput> {
+    const transaction = await api.updateIssue(data);
+
+    // Добавляем/обновляем задачу в списке
+    store.addIssue(projectHash, transaction);
+
+    // Сбрасываем updateIssueInput после выполнения updateIssue
+    resetInput(updateIssueInput, initialUpdateIssueInput);
+
+    return transaction;
+  }
+
+  return {
+    updateIssue,
+    updateIssueInput,
+    // Авто-сохранение
+    debounceSave,
+    saveImmediately,
+    isAutoSaving,
+    autoSaveError,
+  };
+}

package/extensions/capital/features/Issue/UpdateIssue/ui/UpdateEstimate/UpdateEstimate.vue

@@ -0,0 +1,77 @@
+<template lang="pug">
+q-input(
+  v-model.number="selectedEstimate"
+  type="number"
+  :min="0"
+  step="0.5"
+  standout="bg-teal text-white"
+  :label="label"
+  :readonly="readonly"
+  @update:model-value="handleEstimateChange"
+  dense
+)
+</template>
+
+<script setup lang="ts">
+import { ref, watch, computed } from 'vue'
+import { useRoute } from 'vue-router'
+import { useUpdateIssue } from '../../model'
+
+interface Props {
+  modelValue: number
+  issueHash: string
+  label?: string
+  readonly?: boolean
+}
+
+interface Emits {
+  (e: 'update:modelValue', value: number): void
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  label: 'Оценка (часы)',
+  readonly: false
+})
+
+const emit = defineEmits<Emits>()
+
+const route = useRoute()
+const projectHash = computed(() => route.params.project_hash as string)
+
+// Используем composable для обновления задач
+const { debounceSave } = useUpdateIssue()
+
+// Текущая выбранная оценка
+const selectedEstimate = ref<number>(props.modelValue)
+
+// Обработчик изменения оценки
+const handleEstimateChange = async (newEstimate: string | number | null) => {
+  // Конвертируем в число, по умолчанию 0
+  const numericEstimate = typeof newEstimate === 'string' ? parseFloat(newEstimate) : (newEstimate || 0)
+
+  // Проверяем, что значение валидное и не отрицательное
+  const validEstimate = isNaN(numericEstimate) ? 0 : Math.max(0, numericEstimate)
+
+  if (validEstimate === props.modelValue) return
+
+  try {
+    const updateData = {
+      issue_hash: props.issueHash,
+      estimate: validEstimate,
+    }
+
+    // Автоматическое сохранение с задержкой
+    debounceSave(updateData, projectHash.value)
+
+    // Обновляем локальное значение
+    emit('update:modelValue', validEstimate)
+  } catch (error) {
+    console.error('Failed to update estimate:', error)
+  }
+}
+
+// Синхронизируем с внешним значением
+watch(() => props.modelValue, (newValue) => {
+  selectedEstimate.value = newValue
+})
+</script>

package/extensions/capital/features/Issue/UpdateIssue/ui/UpdateEstimate/index.ts

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

package/extensions/capital/features/Issue/UpdateIssue/ui/UpdatePriority/UpdatePriority.vue

@@ -0,0 +1,83 @@
+<template lang="pug">
+q-select(
+  v-model="selectedPriority"
+  :options="priorityOptions"
+  option-value="value"
+  option-label="label"
+  emit-value
+  map-options
+  filled
+  dense
+  :label="label"
+  :readonly="readonly"
+  @update:model-value="handlePriorityChange"
+)
+</template>
+
+<script setup lang="ts">
+import { ref, watch, computed } from 'vue'
+import { useRoute } from 'vue-router'
+import { Zeus } from '@coopenomics/sdk'
+import { getIssuePriorityLabel } from 'app/extensions/capital/shared/lib'
+import { useUpdateIssue } from '../../model'
+
+interface Props {
+  modelValue: Zeus.IssuePriority
+  issueHash: string
+  label?: string
+  readonly?: boolean
+}
+
+interface Emits {
+  (e: 'update:modelValue', value: Zeus.IssuePriority): void
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  label: 'Приоритет',
+  readonly: false
+})
+
+const emit = defineEmits<Emits>()
+
+const route = useRoute()
+const projectHash = computed(() => route.params.project_hash as string)
+
+// Используем composable для обновления задач
+const { debounceSave } = useUpdateIssue()
+
+// Текущий выбранный приоритет
+const selectedPriority = ref<Zeus.IssuePriority>(props.modelValue)
+
+// Опции для выбора приоритета
+const priorityOptions = [
+  { value: Zeus.IssuePriority.LOW, label: getIssuePriorityLabel(Zeus.IssuePriority.LOW) },
+  { value: Zeus.IssuePriority.MEDIUM, label: getIssuePriorityLabel(Zeus.IssuePriority.MEDIUM) },
+  { value: Zeus.IssuePriority.HIGH, label: getIssuePriorityLabel(Zeus.IssuePriority.HIGH) },
+  { value: Zeus.IssuePriority.URGENT, label: getIssuePriorityLabel(Zeus.IssuePriority.URGENT) },
+]
+
+// Обработчик изменения приоритета
+const handlePriorityChange = async (newPriority: Zeus.IssuePriority) => {
+  if (!newPriority || newPriority === props.modelValue) return
+
+  try {
+    const updateData = {
+      issue_hash: props.issueHash,
+      priority: newPriority,
+    }
+
+    // Автоматическое сохранение с задержкой
+    debounceSave(updateData, projectHash.value)
+
+    // Обновляем локальное значение
+    emit('update:modelValue', newPriority)
+  } catch (error) {
+    console.error('Failed to update priority:', error)
+  }
+}
+
+// Синхронизируем с внешним значением
+watch(() => props.modelValue, (newValue) => {
+  selectedPriority.value = newValue
+})
+</script>

package/extensions/capital/features/Issue/UpdateIssue/ui/UpdatePriority/index.ts

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

package/extensions/capital/features/Issue/UpdateIssue/ui/UpdateStatus/UpdateStatus.vue

@@ -0,0 +1,108 @@
+<template lang="pug">
+q-select(
+  tabIndex=100
+  ref="selectRef"
+  v-model="selectedStatus"
+  :options="statusOptions"
+  option-value="value"
+  option-label="label"
+  emit-value
+  map-options
+  dense
+  standout="bg-teal text-white"
+  :label="label"
+  :readonly="readonly"
+  @click="handleClick"
+  @update:model-value="handleStatusChange"
+  style="max-width: 150px"
+)
+</template>
+
+<script setup lang="ts">
+import { ref, watch, computed } from 'vue'
+import { useRoute } from 'vue-router'
+import { Zeus } from '@coopenomics/sdk'
+
+import { useUpdateIssue } from '../../model'
+import { getIssueStatusLabel } from 'app/extensions/capital/shared/lib'
+
+interface Props {
+  modelValue: Zeus.IssueStatus
+  issueHash: string
+  label?: string
+  readonly?: boolean
+}
+
+interface Emits {
+  (e: 'update:modelValue', value: Zeus.IssueStatus): void
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  label: 'Статус',
+  readonly: false
+})
+
+const emit = defineEmits<Emits>()
+
+const route = useRoute()
+const projectHash = computed(() => route.params.project_hash as string)
+
+// Ref для доступа к q-select компоненту
+const selectRef = ref()
+
+// Используем composable для обновления задач
+const { debounceSave } = useUpdateIssue()
+
+// Текущий выбранный статус
+const selectedStatus = ref<Zeus.IssueStatus>(props.modelValue)
+
+
+// Опции для выбора статуса
+const statusOptions = [
+  { value: Zeus.IssueStatus.BACKLOG, label: getIssueStatusLabel(Zeus.IssueStatus.BACKLOG) },
+  { value: Zeus.IssueStatus.TODO, label: getIssueStatusLabel(Zeus.IssueStatus.TODO) },
+  { value: Zeus.IssueStatus.IN_PROGRESS, label: getIssueStatusLabel(Zeus.IssueStatus.IN_PROGRESS) },
+  { value: Zeus.IssueStatus.ON_REVIEW, label: getIssueStatusLabel(Zeus.IssueStatus.ON_REVIEW) },
+  { value: Zeus.IssueStatus.DONE, label: getIssueStatusLabel(Zeus.IssueStatus.DONE) },
+  { value: Zeus.IssueStatus.CANCELED, label: getIssueStatusLabel(Zeus.IssueStatus.CANCELED) },
+]
+
+// Обработчик клика по селекту - переключает dropdown
+const handleClick = () => {
+  if (!props.readonly && selectRef.value) {
+    // selectRef.value.togglePopup() //TODO: не работает потому что не существует
+  }
+}
+
+// Обработчик изменения статуса
+const handleStatusChange = async (newStatus: Zeus.IssueStatus) => {
+  if (!newStatus || newStatus === props.modelValue) return
+
+  // Сохраняем предыдущее состояние для возможного отката
+  const previousStatus = props.modelValue
+
+  try {
+    const updateData = {
+      issue_hash: props.issueHash,
+      status: newStatus,
+    }
+
+    // Обновляем локальное значение оптимистично
+    emit('update:modelValue', newStatus)
+
+    // Автоматическое сохранение с задержкой
+    await debounceSave(updateData, projectHash.value)
+  } catch (error) {
+    console.error('Failed to update status:', error)
+
+    // Откатываем к предыдущему состоянию в случае ошибки
+    selectedStatus.value = previousStatus
+    emit('update:modelValue', previousStatus)
+  }
+}
+
+// Синхронизируем с внешним значением
+watch(() => props.modelValue, (newValue) => {
+  selectedStatus.value = newValue
+})
+</script>

package/extensions/capital/features/Issue/UpdateIssue/ui/UpdateStatus/index.ts

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

package/extensions/capital/features/Issue/index.ts

@@ -0,0 +1,4 @@
+export * as CreateIssue from './CreateIssue';
+export * as UpdateIssue from './UpdateIssue';
+export * as DeleteIssue from './DeleteIssue';
+export * as SetCreator from './SetCreator';

package/extensions/capital/features/ProgramInvest/CreateProgramInvest/api/index.ts

@@ -0,0 +1,23 @@
+import type {
+  ICreateProgramInvestOutput,
+  ICreateProgramInvestInput,
+} from 'app/extensions/capital/entities/ProgramInvest/model';
+import { client } from 'src/shared/api/client';
+import { Mutations } from '@coopenomics/sdk';
+
+async function createProgramInvest(
+  data: ICreateProgramInvestInput,
+): Promise<ICreateProgramInvestOutput> {
+  const { [Mutations.Capital.CreateProgramProperty.name]: result } =
+    await client.Mutation(Mutations.Capital.CreateProgramProperty.mutation, {
+      variables: {
+        data,
+      },
+    });
+
+  return result;
+}
+
+export const api = {
+  createProgramInvest,
+};

package/extensions/capital/features/ProgramInvest/CreateProgramInvest/index.ts

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