@coopenomics/desktop 2025.7.3 → 2025.11.8-alpha-2

package/extensions/capital/entities/Project/model/store.ts

@@ -0,0 +1,125 @@
+import { defineStore } from 'pinia';
+import { ref, Ref } from 'vue';
+import { api } from '../api';
+import type {
+  IGetProjectOutput,
+  IProjectsPagination,
+  IProjectWithRelations,
+  IProject,
+  IGetProjectInput,
+  IGetProjectsInput,
+  IGetProjectWithRelationsInput,
+} from './types';
+
+const namespace = 'projectStore';
+
+interface IProjectStore {
+  projects: Ref<IProjectsPagination>;
+  loadProjects: (data: IGetProjectsInput) => Promise<IProjectsPagination>;
+  addProjectToList: (projectData: IProject) => void;
+  loadProject: (data: IGetProjectInput) => Promise<IGetProjectOutput>;
+  projectWithRelations: Ref<IProjectWithRelations | null>;
+  loadProjectWithRelations: (
+    data: IGetProjectWithRelationsInput,
+  ) => Promise<IProjectWithRelations>;
+  isMaster: (project_hash: string, username: string) => Promise<boolean>;
+}
+
+export const useProjectStore = defineStore(namespace, (): IProjectStore => {
+  const projects = ref<IProjectsPagination>({
+    items: [],
+    totalCount: 0,
+    totalPages: 1,
+    currentPage: 1,
+  });
+  const projectWithRelations = ref<IProjectWithRelations | null>(null);
+
+  const loadProjects = async (data: IGetProjectsInput): Promise<IProjectsPagination> => {
+    const loadedData = await api.loadProjects(data);
+    projects.value = loadedData;
+
+    return loadedData;
+  };
+
+  const addProjectToList = (projectData: IProject) => {
+    // Ищем существующий проект по _id
+    const existingIndex = projects.value.items.findIndex(
+      (project) => project._id === projectData._id,
+    );
+
+    if (existingIndex !== -1) {
+      // Заменяем существующий проект
+      projects.value.items[existingIndex] = projectData;
+    } else {
+      // Добавляем новый проект в начало списка
+      projects.value.items = [
+        projectData as IProject,
+        ...projects.value.items,
+      ];
+      // Увеличиваем общее количество
+      projects.value.totalCount += 1;
+    }
+  };
+
+  const loadProject = async (data: IGetProjectInput): Promise<IGetProjectOutput> => {
+    const loadedData = await api.loadProject(data);
+    if (!loadedData) return;
+
+    // Обновляем проект в списке projects
+    const existingIndex = projects.value.items.findIndex(
+      (project) => project.project_hash === loadedData.project_hash,
+    );
+
+    if (existingIndex !== -1) {
+      // Заменяем существующий проект
+      projects.value.items[existingIndex] = loadedData as IProject;
+    } else {
+      // Добавляем новый проект в начало списка
+      projects.value.items = [
+        loadedData as IProject,
+        ...projects.value.items,
+      ];
+      // Увеличиваем общее количество
+      projects.value.totalCount += 1;
+    }
+
+    return loadedData;
+  };
+
+  const loadProjectWithRelations = async (
+    data: IGetProjectWithRelationsInput,
+  ): Promise<IProjectWithRelations> => {
+    const loadedData = await api.loadProjectWithRelations(data);
+    projectWithRelations.value = loadedData;
+    return loadedData;
+  };
+
+  const isMaster = async (project_hash: string, username: string): Promise<boolean> => {
+    // Ищем проект в локальном списке
+    let project = projects.value.items.find(
+      (project) => project.project_hash === project_hash,
+    );
+
+    // Если проект не найден, загружаем его
+    if (!project) {
+      const loadedProject = await loadProject({ hash: project_hash });
+      if (!loadedProject) {
+        return false;
+      }
+      project = loadedProject;
+    }
+
+    // Проверяем, является ли пользователь мастером
+    return project.master === username;
+  };
+
+  return {
+    projects,
+    projectWithRelations,
+    loadProjects,
+    addProjectToList,
+    loadProject,
+    loadProjectWithRelations,
+    isMaster,
+  };
+});

package/extensions/capital/entities/Project/model/types.ts

@@ -0,0 +1,27 @@
+import type { Queries, Mutations, Zeus } from '@coopenomics/sdk';
+
+// Тип проекта-компонента (без вложенных компонентов)
+export type IProjectComponent = Zeus.ModelTypes['CapitalProjectComponent'];
+
+// Тип полного проекта (с компонентами)
+export type IProject = Zeus.ModelTypes['CapitalProject'];
+
+// Тип разрешений для проекта
+export type IProjectPermissions = Zeus.ModelTypes['CapitalProjectPermissions'];
+
+export type IGetProjectOutput =
+  Queries.Capital.GetProject.IOutput[typeof Queries.Capital.GetProject.name];
+
+export type IProjectsPagination =
+  Queries.Capital.GetProjects.IOutput[typeof Queries.Capital.GetProjects.name];
+export type IProjectWithRelations =
+  Queries.Capital.GetProjectWithRelations.IOutput[typeof Queries.Capital.GetProjectWithRelations.name];
+
+export type IGetProjectInput = Queries.Capital.GetProject.IInput['data'];
+export type IGetProjectsInput = Queries.Capital.GetProjects.IInput;
+export type IGetProjectWithRelationsInput =
+  Queries.Capital.GetProjectWithRelations.IInput['data'];
+export type ICreateProjectInput =
+  Mutations.Capital.CreateProject.IInput['data'];
+export type ICreateProjectOutput =
+  Mutations.Capital.CreateProject.IOutput[typeof Mutations.Capital.CreateProject.name];

package/extensions/capital/entities/Result/api/index.ts

@@ -0,0 +1,37 @@
+import { client } from 'src/shared/api/client';
+import { Queries } from '@coopenomics/sdk';
+import type {
+  IResult,
+  IResultsPagination,
+  IGetResultInput,
+  IGetResultsInput,
+} from '../model';
+
+async function loadResults(
+  data: IGetResultsInput,
+): Promise<IResultsPagination> {
+  const { [Queries.Capital.GetResults.name]: output } = await client.Query(
+    Queries.Capital.GetResults.query,
+    {
+      variables: data,
+    },
+  );
+  return output;
+}
+
+async function loadResult(data: IGetResultInput): Promise<IResult> {
+  const { [Queries.Capital.GetResult.name]: output } = await client.Query(
+    Queries.Capital.GetResult.query,
+    {
+      variables: {
+        data,
+      },
+    },
+  );
+  return output;
+}
+
+export const api = {
+  loadResults,
+  loadResult,
+};

package/extensions/capital/entities/Result/index.ts

@@ -0,0 +1,2 @@
+export * as ResultModel from './model';
+export * from './api';

package/extensions/capital/entities/Result/model/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './store';

package/extensions/capital/entities/Result/model/store.ts

@@ -0,0 +1,40 @@
+import { defineStore } from 'pinia';
+import { ref, Ref } from 'vue';
+import { api } from '../api';
+import type {
+  IResult,
+  IResultsPagination,
+  IGetResultInput,
+  IGetResultsInput,
+} from './types';
+
+const namespace = 'resultStore';
+
+interface IResultStore {
+  results: Ref<IResultsPagination | null>;
+  loadResults: (data: IGetResultsInput) => Promise<void>;
+  result: Ref<IResult | null>;
+  loadResult: (data: IGetResultInput) => Promise<void>;
+}
+
+export const useResultStore = defineStore(namespace, (): IResultStore => {
+  const results = ref<IResultsPagination | null>(null);
+  const result = ref<IResult | null>(null);
+
+  const loadResults = async (data: IGetResultsInput): Promise<void> => {
+    const loadedData = await api.loadResults(data);
+    results.value = loadedData;
+  };
+
+  const loadResult = async (data: IGetResultInput): Promise<void> => {
+    const loadedData = await api.loadResult(data);
+    result.value = loadedData;
+  };
+
+  return {
+    results,
+    result,
+    loadResults,
+    loadResult,
+  };
+});

package/extensions/capital/entities/Result/model/types.ts

@@ -0,0 +1,12 @@
+import type { Queries, Mutations } from '@coopenomics/sdk';
+
+export type IResult =
+  Queries.Capital.GetResult.IOutput[typeof Queries.Capital.GetResult.name];
+export type IResultsPagination =
+  Queries.Capital.GetResults.IOutput[typeof Queries.Capital.GetResults.name];
+
+export type IGetResultInput = Queries.Capital.GetResult.IInput['data'];
+export type IGetResultsInput = Queries.Capital.GetResults.IInput;
+export type IPushResultInput = Mutations.Capital.PushResult.IInput['data'];
+export type IPushResultOutput =
+  Mutations.Capital.PushResult.IOutput[typeof Mutations.Capital.PushResult.name];

package/extensions/capital/entities/Segment/api/index.ts

@@ -0,0 +1,33 @@
+import { client } from 'src/shared/api/client';
+import { Queries } from '@coopenomics/sdk';
+import type { ISegmentsPagination, IGetSegmentsInput, ISegment, IGetSegmentInput } from '../model';
+
+async function loadSegments(data: IGetSegmentsInput): Promise<ISegmentsPagination> {
+  const { [Queries.Capital.GetSegments.name]: output } = await client.Query(
+    Queries.Capital.GetSegments.query,
+    {
+      variables: data,
+    },
+  );
+  return output;
+}
+
+async function loadSegment(data: IGetSegmentInput): Promise<ISegment> {
+  const { [Queries.Capital.GetSegment.name]: output } = await client.Query(
+    Queries.Capital.GetSegment.query,
+    {
+      variables: data,
+    },
+  );
+
+  if (!output) {
+    throw new Error('Segment not found');
+  }
+
+  return output;
+}
+
+export const api = {
+  loadSegments,
+  loadSegment,
+};

package/extensions/capital/entities/Segment/index.ts

@@ -0,0 +1,2 @@
+export * as SegmentModel from './model';
+export * from './api';

package/extensions/capital/entities/Segment/model/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './store';

package/extensions/capital/entities/Segment/model/store.ts

@@ -0,0 +1,62 @@
+import { defineStore } from 'pinia';
+import { ref, Ref } from 'vue';
+import { api } from '../api';
+import type { ISegmentsPagination, IGetSegmentsInput, ISegment, IGetSegmentInput } from './types';
+
+const namespace = 'segmentStore';
+
+interface ISegmentStore {
+  // Реактивные состояния
+  segments: Ref<ISegmentsPagination | null>;
+
+  // Методы загрузки данных (только запросы!)
+  loadSegments: (data: IGetSegmentsInput) => Promise<ISegmentsPagination>;
+  loadAndUpdateSegment: (data: IGetSegmentInput) => Promise<ISegment>;
+  addSegmentToList: (segmentData: ISegment) => void;
+}
+
+export const useSegmentStore = defineStore(namespace, (): ISegmentStore => {
+  // Реактивные ref'ы
+  const segments = ref<ISegmentsPagination | null>(null);
+
+  // Методы загрузки (только чтение!)
+  const loadSegments = async (data: IGetSegmentsInput): Promise<ISegmentsPagination> => {
+    const loadedData = await api.loadSegments(data);
+    segments.value = loadedData;
+    return loadedData;
+  };
+
+  // Загружает один сегмент и обновляет его в списке segments
+  const loadAndUpdateSegment = async (data: IGetSegmentInput): Promise<ISegment> => {
+    const loadedSegment = await api.loadSegment(data);
+
+    // Обновляем сегмент в списке через addSegmentToList
+    addSegmentToList(loadedSegment);
+
+    return loadedSegment;
+  };
+
+  // Добавляет или обновляет сегмент в списке без загрузки с сервера
+  const addSegmentToList = (segmentData: ISegment) => {
+    // Ищем существующий сегмент по username
+    const existingIndex = segments.value?.items.findIndex(
+      (segment) => segment.username === segmentData.username,
+    );
+
+    if (existingIndex !== undefined && existingIndex !== -1 && segments.value?.items) {
+      // Заменяем существующий сегмент
+      segments.value.items[existingIndex] = segmentData as any;
+    } else if (segments.value?.items) {
+      // Добавляем новый сегмент в список
+      segments.value.items.push(segmentData as any);
+      segments.value.totalCount += 1;
+    }
+  };
+
+  return {
+    segments,
+    loadSegments,
+    loadAndUpdateSegment,
+    addSegmentToList,
+  };
+});

package/extensions/capital/entities/Segment/model/types.ts

@@ -0,0 +1,14 @@
+import type { Queries, Zeus } from '@coopenomics/sdk';
+
+// Тип сегмента
+export type ISegment = Zeus.ModelTypes['CapitalSegment'];
+
+// Тип пагинированного списка сегментов
+export type ISegmentsPagination =
+  Queries.Capital.GetSegments.IOutput[typeof Queries.Capital.GetSegments.name];
+
+// Тип входных параметров для получения сегментов
+export type IGetSegmentsInput = Queries.Capital.GetSegments.IInput;
+
+// Тип входных параметров для получения одного сегмента
+export type IGetSegmentInput = Queries.Capital.GetSegment.IInput;

package/extensions/capital/entities/Story/api/index.ts

@@ -0,0 +1,37 @@
+import { client } from 'src/shared/api/client';
+import { Queries } from '@coopenomics/sdk';
+import type {
+  IGetStoriesInput,
+  IStoriesPagination,
+  IGetStoryInput,
+  IGetStoryOutput,
+} from '../model';
+
+async function loadStories(
+  data: IGetStoriesInput,
+): Promise<IStoriesPagination> {
+  const { [Queries.Capital.GetStories.name]: output } = await client.Query(
+    Queries.Capital.GetStories.query,
+    {
+      variables: data,
+    },
+  );
+  return output;
+}
+
+async function loadStory(data: IGetStoryInput): Promise<IGetStoryOutput> {
+  const { [Queries.Capital.GetStory.name]: output } = await client.Query(
+    Queries.Capital.GetStory.query,
+    {
+      variables: {
+        data,
+      },
+    },
+  );
+  return output;
+}
+
+export const api = {
+  loadStories,
+  loadStory,
+};

package/extensions/capital/entities/Story/index.ts

@@ -0,0 +1,2 @@
+export * as StoryModel from './model';
+export * from './api';

package/extensions/capital/entities/Story/model/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './store';

package/extensions/capital/entities/Story/model/store.ts

@@ -0,0 +1,80 @@
+import { defineStore } from 'pinia';
+import { ref, Ref } from 'vue';
+import { api } from '../api';
+import type { IStoriesPagination, IGetStoriesInput, IStory } from './types';
+
+const namespace = 'storyStore';
+
+interface IStoryStore {
+  stories: Ref<IStoriesPagination | null>;
+  loadStories: (data: IGetStoriesInput) => Promise<void>;
+  addStoryToList: (storyData: IStory) => void;
+  removeStoryFromList: (storyHash: string) => void;
+  updateStoryInPlace: (storyData: IStory) => void;
+}
+
+export const useStoryStore = defineStore(namespace, (): IStoryStore => {
+  const stories = ref<IStoriesPagination | null>(null);
+
+  const loadStories = async (data: IGetStoriesInput): Promise<void> => {
+    const loadedData = await api.loadStories(data);
+    stories.value = loadedData;
+  };
+
+  const addStoryToList = (storyData: IStory) => {
+    if (stories.value) {
+      // Ищем существующую историю по _id
+      const existingIndex = stories.value.items.findIndex(
+        (story) => story._id === storyData._id,
+      );
+
+      if (existingIndex !== -1) {
+        // Заменяем существующую историю
+        stories.value.items[existingIndex] = storyData;
+      } else {
+        // Добавляем новую историю в начало списка
+        stories.value.items = [storyData, ...stories.value.items];
+        // Увеличиваем общее количество
+        stories.value.totalCount += 1;
+      }
+    }
+  };
+
+  const updateStoryInPlace = (storyData: IStory) => {
+    if (stories.value) {
+      // Ищем историю по _id и заменяем её на месте
+      const existingIndex = stories.value.items.findIndex(
+        (story) => story._id === storyData._id,
+      );
+
+      if (existingIndex !== -1) {
+        // Заменяем объект на месте, без пересортировки
+        stories.value.items[existingIndex] = storyData;
+      }
+    }
+  };
+
+  const removeStoryFromList = (storyHash: string) => {
+    if (stories.value) {
+      // Ищем историю по story_hash
+      const storyIndex = stories.value.items.findIndex(
+        (story) => story.story_hash === storyHash,
+      );
+
+      if (storyIndex !== -1) {
+        // Удаляем историю из списка
+        stories.value.items.splice(storyIndex, 1);
+        // Уменьшаем общее количество
+        stories.value.totalCount -= 1;
+      }
+    }
+  };
+
+  return {
+    stories,
+    loadStories,
+    addStoryToList,
+    updateStoryInPlace,
+    removeStoryFromList,
+  };
+});

package/extensions/capital/entities/Story/model/types.ts

@@ -0,0 +1,22 @@
+import type { Queries, Mutations } from '@coopenomics/sdk';
+
+export type IStoriesPagination =
+  Queries.Capital.GetStories.IOutput[typeof Queries.Capital.GetStories.name];
+
+export type IStory = IStoriesPagination['items'][0];
+
+export type IGetStoriesInput = Queries.Capital.GetStories.IInput;
+export type IGetStoryInput = Queries.Capital.GetStory.IInput['data'];
+export type IGetStoryOutput =
+  Queries.Capital.GetStory.IOutput[typeof Queries.Capital.GetStory.name];
+export type ICreateStoryInput = Mutations.Capital.CreateStory.IInput['data'];
+export type ICreateStoryOutput =
+  Mutations.Capital.CreateStory.IOutput[typeof Mutations.Capital.CreateStory.name];
+
+export type IUpdateStoryInput = Mutations.Capital.UpdateStory.IInput['data'];
+export type IUpdateStoryOutput =
+  Mutations.Capital.UpdateStory.IOutput[typeof Mutations.Capital.UpdateStory.name];
+
+export type IDeleteStoryInput = Mutations.Capital.DeleteStory.IInput['data'];
+export type IDeleteStoryOutput =
+  Mutations.Capital.DeleteStory.IOutput[typeof Mutations.Capital.DeleteStory.name];

package/extensions/capital/entities/TimeEntries/api/index.ts

@@ -0,0 +1,22 @@
+import { client } from 'src/shared/api/client';
+import { Queries } from '@coopenomics/sdk';
+import type {
+  IGetTimeEntriesInput,
+  ITimeEntriesPagination,
+} from '../model/types';
+
+async function loadTimeEntries(
+  data: IGetTimeEntriesInput,
+): Promise<ITimeEntriesPagination> {
+  const { [Queries.Capital.GetTimeEntries.name]: output } = await client.Query(
+    Queries.Capital.GetTimeEntries.query,
+    {
+      variables: data,
+    },
+  );
+  return output;
+}
+
+export const api = {
+  loadTimeEntries,
+};

package/extensions/capital/entities/TimeEntries/index.ts

@@ -0,0 +1,2 @@
+export * as TimeEntriesModel from './model';
+export * from './api';

package/extensions/capital/entities/TimeEntries/model/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './store';

package/extensions/capital/entities/TimeEntries/model/store.ts

@@ -0,0 +1,20 @@
+import { defineStore } from 'pinia';
+import { api } from '../api';
+import type { ITimeEntriesPagination, IGetTimeEntriesInput } from './types';
+
+const namespace = 'timeEntriesStore';
+
+interface ITimeEntriesStore {
+  loadTimeEntries: (data: IGetTimeEntriesInput) => Promise<ITimeEntriesPagination>;
+}
+
+export const useTimeEntriesStore = defineStore(namespace, (): ITimeEntriesStore => {
+  const loadTimeEntries = async (data: IGetTimeEntriesInput): Promise<ITimeEntriesPagination> => {
+    const loadedData = await api.loadTimeEntries(data);
+    return loadedData;
+  };
+
+  return {
+    loadTimeEntries,
+  };
+});

package/extensions/capital/entities/TimeEntries/model/types.ts

@@ -0,0 +1,8 @@
+import type { Queries } from '@coopenomics/sdk';
+
+export type ITimeEntriesPagination =
+  Queries.Capital.GetTimeEntries.IOutput[typeof Queries.Capital.GetTimeEntries.name];
+
+export type ITimeEntry = Queries.Capital.GetTimeEntries.IOutput[typeof Queries.Capital.GetTimeEntries.name]['items'][0];
+
+export type IGetTimeEntriesInput = Queries.Capital.GetTimeEntries.IInput;

package/extensions/capital/entities/TimeIssues/api/index.ts

@@ -0,0 +1,22 @@
+import { client } from 'src/shared/api/client';
+import { Queries } from '@coopenomics/sdk';
+import type {
+  IGetTimeIssuesInput,
+  ITimeIssuesPagination,
+} from '../model/types';
+
+async function loadTimeIssues(
+  data: IGetTimeIssuesInput,
+): Promise<ITimeIssuesPagination> {
+  const { [Queries.Capital.GetTimeEntriesByIssues.name]: output } = await client.Query(
+    Queries.Capital.GetTimeEntriesByIssues.query,
+    {
+      variables: data,
+    },
+  );
+  return output;
+}
+
+export const api = {
+  loadTimeIssues,
+};

package/extensions/capital/entities/TimeIssues/index.ts

@@ -0,0 +1,2 @@
+export * as TimeIssuesModel from './model';
+export * from './api';

package/extensions/capital/entities/TimeIssues/model/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './store';

package/extensions/capital/entities/TimeIssues/model/store.ts

@@ -0,0 +1,26 @@
+import { defineStore } from 'pinia';
+import { ref, Ref } from 'vue';
+import { api } from '../api';
+import type { ITimeIssuesPagination, IGetTimeIssuesInput } from './types';
+
+const namespace = 'timeIssuesStore';
+
+interface ITimeIssuesStore {
+  timeIssues: Ref<ITimeIssuesPagination | null>;
+  loadTimeIssues: (data: IGetTimeIssuesInput) => Promise<ITimeIssuesPagination>;
+}
+
+export const useTimeIssuesStore = defineStore(namespace, (): ITimeIssuesStore => {
+  const timeIssues = ref<ITimeIssuesPagination | null>(null);
+
+  const loadTimeIssues = async (data: IGetTimeIssuesInput): Promise<ITimeIssuesPagination> => {
+    const loadedData = await api.loadTimeIssues(data);
+    timeIssues.value = loadedData;
+    return loadedData;
+  };
+
+  return {
+    timeIssues,
+    loadTimeIssues,
+  };
+});

package/extensions/capital/entities/TimeIssues/model/types.ts

@@ -0,0 +1,8 @@
+import type { Queries } from '@coopenomics/sdk';
+
+export type ITimeIssuesPagination =
+  Queries.Capital.GetTimeEntriesByIssues.IOutput[typeof Queries.Capital.GetTimeEntriesByIssues.name];
+
+export type ITimeIssue = Queries.Capital.GetTimeEntriesByIssues.IOutput[typeof Queries.Capital.GetTimeEntriesByIssues.name]['items'][0];
+
+export type IGetTimeIssuesInput = Queries.Capital.GetTimeEntriesByIssues.IInput;