@coopenomics/desktop 2.2.2

package/src/entities/Order/model/store.ts

@@ -0,0 +1,87 @@
+import { defineStore } from 'pinia';
+import { Ref, ref } from 'vue';
+import type { IGetResponse, IOrderResponse } from '@coopenomics/controller';
+import { api } from '../api';
+import type { IGetCoopOrders, IGetMyOrders } from '@coopenomics/controller';
+
+
+interface IOrderStore {
+  username: Ref<string | undefined>;
+  orders: Ref<IGetResponse<IOrderResponse> | undefined>;
+  loadCoopOrders: (params: IGetCoopOrders) => Promise<void>
+  updateCoopOrders: (params: IGetCoopOrders) => Promise<void>
+  loadMyOrders: (username: string, params: IGetMyOrders) => Promise<void>
+  clear: () => void
+}
+
+const namespace = 'orders';
+
+export const useOrderStore = defineStore(namespace, (): IOrderStore => {
+  const orders: Ref<IGetResponse<IOrderResponse> | undefined> = ref();
+  const username: Ref<string | undefined> = ref();
+
+  const clear = () => {
+    orders.value = undefined
+  }
+  // Функция для слияния массивов ордеров по id
+  const mergeOrders = (existingOrders: IOrderResponse[], newOrders: IOrderResponse[]) => {
+    const mergedOrdersMap = new Map(existingOrders.map(order => [order.id, order]));
+
+    newOrders.forEach(order => {
+      mergedOrdersMap.set(order.id, order); // Обновляем или добавляем новый ордер
+    });
+
+    return Array.from(mergedOrdersMap.values()); // Возвращаем массив объединённых ордеров
+  };
+
+  const updateCoopOrders = async(params: IGetCoopOrders): Promise<void> => {
+    const newOrdersResponse = await api.loadCoopOrders(params);
+
+    if (orders.value)
+      orders.value.results = mergeOrders(orders.value.results, newOrdersResponse.results) // Мерджим старые и новые результаты
+    else orders.value = newOrdersResponse
+
+  }
+
+  // Функция для загрузки всех ордеров
+  const loadCoopOrders = async (params: IGetCoopOrders): Promise<void> => {
+    username.value = params.username;
+
+    const newOrdersResponse = await api.loadCoopOrders(params);
+
+    if (orders.value) {
+      // Обновляем все свойства объекта orders
+      orders.value = {
+        ...orders.value, // Сохраняем старые значения limit, totalPages, totalResults и т.д.
+        results: mergeOrders(orders.value.results, newOrdersResponse.results), // Мерджим старые и новые результаты
+        page: newOrdersResponse.page, // Обновляем текущую страницу
+        totalPages: newOrdersResponse.totalPages, // Обновляем общее количество страниц
+        totalResults: newOrdersResponse.totalResults, // Обновляем общее количество результатов
+      };
+    } else {
+      orders.value = newOrdersResponse; // Если это первая страница, просто присваиваем новый объект
+    }
+  };
+
+  // Функция для загрузки собственных ордеров (по аналогии с loadAllOrders)
+  const loadMyOrders = async (target: string, params: IGetMyOrders): Promise<void> => {
+    username.value = target;
+    const newOrdersResponse = await api.loadMyOrders(username.value, params.page, params.limit);
+
+    if (orders.value) {
+      // Обновляем все свойства объекта orders
+      orders.value = {
+        ...orders.value,
+        results: mergeOrders(orders.value.results, newOrdersResponse.results),
+        page: newOrdersResponse.page,
+        totalPages: newOrdersResponse.totalPages,
+        totalResults: newOrdersResponse.totalResults,
+      };
+    } else {
+      orders.value = newOrdersResponse;
+    }
+    loadMyOrders
+  };
+
+  return { username, orders, loadCoopOrders, updateCoopOrders, loadMyOrders, clear};
+});

package/src/entities/Registrator/index.ts

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

package/src/entities/Registrator/model/index.ts

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

package/src/entities/Registrator/model/store.ts

@@ -0,0 +1,237 @@
+import { defineStore } from 'pinia';
+import { computed, reactive } from 'vue';
+import { IGeneratedAccount } from 'src/shared/lib/types/user';
+import { type ICreateUserData } from 'src/shared/lib/types/user/IUserData';
+import type { Cooperative } from 'cooptypes';
+import { useSystemStore } from 'src/entities/System/model';
+
+const namespace = 'registrator';
+
+// Начальное состояние для account
+const initialAccountState: IGeneratedAccount = {
+  username: '',
+  private_key: '',
+  public_key: ''
+};
+
+// Начальное состояние для userData
+const initialUserDataState: ICreateUserData = {
+  type: 'individual',
+  individual_data: {
+    first_name: '',
+    last_name: '',
+    middle_name: '',
+    birthdate: '',
+    full_address: '',
+    phone: '',
+    email: '',
+  },
+  organization_data: {
+    type: 'coop',
+    short_name: '',
+    full_name: '',
+    represented_by: {
+      first_name: '',
+      last_name: '',
+      middle_name: '',
+      position: '',
+      based_on: '',
+    },
+    country: 'Russia',
+    city: '',
+    full_address: '',
+    fact_address: '',
+    phone: '',
+    email: '',
+    details: {
+      kpp: '',
+      inn: '',
+      ogrn: '',
+    },
+    bank_account: {
+      currency: 'RUB',
+      card_number: undefined,
+      bank_name: '',
+      account_number: '',
+      details: {
+        bik: '',
+        corr: '',
+        kpp: '',
+      },
+    },
+  },
+  entrepreneur_data: {
+    first_name: '',
+    last_name: '',
+    middle_name: '',
+    birthdate: '',
+    phone: '',
+    email: '',
+    country: 'Russia',
+    city: '',
+    full_address: '',
+    details: {
+      inn: '',
+      ogrn: '',
+    },
+    bank_account: {
+      currency: 'RUB',
+      card_number: undefined,
+      bank_name: '',
+      account_number: '',
+      details: {
+        bik: '',
+        corr: '',
+        kpp: '',
+      },
+    },
+  },
+};
+
+// Начальное состояние для любого документа
+const initialDocumentState = {
+  hash: '',
+  meta: {} as Cooperative.Document.IMetaDocument,
+  public_key: '',
+  signature: '',
+};
+
+// Начальное состояние для payment
+const initialPaymentState = {
+  provider: '',
+  details: {
+    data: '',
+  },
+};
+
+// Начальное состояние для agreements
+const initialAgreementsState = {
+  condidential: false,
+  digital_signature: false,
+  wallet: false,
+  ustav: false,
+  user: false,
+  self_paid: false,
+};
+export const useRegistratorStore = defineStore(
+  namespace,
+  () => {
+    const state = reactive({
+      step: 1,
+      role: 'user',
+      email: '',
+      selectedBranch: '',
+      account: structuredClone(initialAccountState),
+      userData: structuredClone(initialUserDataState),
+      signature: '',
+      inLoading: false,
+      agreements: structuredClone(initialAgreementsState),
+      statement: structuredClone(initialDocumentState),
+      walletAgreement: structuredClone(initialDocumentState),
+      privacyAgreement: structuredClone(initialDocumentState),
+      signatureAgreement: structuredClone(initialDocumentState),
+      userAgreement: structuredClone(initialDocumentState),
+      payment: structuredClone(initialPaymentState),
+      is_paid: false,
+    });
+
+    const stepNames = [
+      'EmailInput',
+      'SetUserData',
+      'GenerateAccount',
+      'SelectBranch',
+      'ReadStatement',
+      'SignStatement',
+      'PayInitial',
+      'WaitingRegistration',
+      'Welcome',
+    ] as const;
+
+    type StepName = (typeof stepNames)[number];
+
+    const steps = stepNames.reduce((acc, step, index) => {
+      acc[step] = index + 1; // Индексы начинаются с 1
+      return acc;
+    }, {} as Record<StepName, number>);
+
+    const system = useSystemStore();
+    const isBranched = computed(() => system.info?.cooperator_account.is_branched);
+
+    const filteredSteps = computed(() =>
+      stepNames.filter(step => step !== 'SelectBranch' || isBranched.value)
+    );
+
+    const isStepDone = (stepName: StepName) => {
+      const stepIndex = steps[stepName];
+      return stepIndex < state.step;
+    };
+
+    const isStep = (stepName: StepName) => {
+      const stepIndex = steps[stepName];
+      return stepIndex === state.step;
+    };
+
+    const next = () => {
+      if (state.step < filteredSteps.value.length) {
+        state.step += 1;
+      }
+    };
+
+    const prev = () => {
+      if (state.step > 1) {
+        state.step -= 1;
+      }
+    };
+
+    const goTo = (targetStep: StepName) => {
+      const targetIndex = steps[targetStep];
+      if (targetIndex > 0) {
+        state.step = targetIndex;
+      }
+    };
+
+    const clearAddUserState = () => reactive({
+      spread_initial: false,
+      created_at: '',
+      initial: 0,
+      minimum: 0,
+      org_initial: 0,
+      org_minimum: 0,
+    });
+
+    const addUserState = clearAddUserState();
+
+    const clearUserData = () => {
+      state.step = 1;
+      state.selectedBranch = ''
+      state.email = '';
+      state.account = structuredClone(initialAccountState);
+      state.agreements = structuredClone(initialAgreementsState);
+      state.userData = structuredClone(initialUserDataState);
+      state.payment = structuredClone(initialPaymentState);
+      state.is_paid = false;
+      state.statement = structuredClone(initialDocumentState);
+      state.walletAgreement = structuredClone(initialDocumentState);
+      state.privacyAgreement = structuredClone(initialDocumentState);
+      state.signatureAgreement = structuredClone(initialDocumentState);
+      state.userAgreement = structuredClone(initialDocumentState);
+    };
+
+    return {
+      state,
+      steps,
+      filteredSteps,
+      next,
+      prev,
+      goTo,
+      isStepDone,
+      isStep,
+      clearUserData,
+      addUserState,
+      isBranched,
+    };
+  },
+  {
+    persist: true,
+  }
+);

package/src/entities/Registrator/ui/index.ts

@@ -0,0 +1 @@
+export * from '../../../shared/ui/UserDataForm/UserDataForm'

package/src/entities/Request/api/index.ts

@@ -0,0 +1,192 @@
+import { fetchTable } from '../../../shared/api';
+import {
+  ContractsList,
+  LimitsList,
+  SecondaryIndexesNumbers,
+  TablesList,
+} from '../../../shared/config';
+import { ILoadAllRequests, IUpdateOneRequest } from '../model';
+import type {
+  IRequestData,
+  IRequestObjectData,
+  ILoadAllParentOffers,
+  ILoadUserParentOffers,
+  ILoadUserChildOrders,
+} from '../model';
+
+function parseRequestObjectData(data: string): IRequestObjectData {
+  try {
+    return JSON.parse(data) as IRequestObjectData;
+  } catch (e) {
+    console.error(e); // Логирование ошибки может быть полезным
+    return {} as IRequestObjectData;
+  }
+}
+
+async function loadAllRequests(
+  params: ILoadAllRequests
+): Promise<IRequestData[]> {
+  const requests = (await fetchTable(
+    ContractsList.Marketplace,
+    params.coopname,
+    TablesList.CoopMarketRequests
+  )) as any[];
+
+  requests.map((el) => (el.data = parseRequestObjectData(el.data)));
+
+  return requests as IRequestData[];
+}
+
+async function loadOneRequest(
+  params: IUpdateOneRequest
+): Promise<IRequestData> {
+  const request = (
+    await fetchTable(
+      ContractsList.Marketplace,
+      params.coopname,
+      TablesList.CoopMarketRequests,
+      params.request_id,
+      params.request_id,
+      1
+    )
+  )[0] as any;
+
+  // если есть родительская заявка, то получаем данные из неё, потому что в дочернией заявке data не множится
+  if (request.parent_id !== 0) {
+    const parent_request = (
+      (await fetchTable(
+        ContractsList.Marketplace,
+        params.coopname,
+        TablesList.CoopMarketRequests,
+        request.parent_id,
+        request.parent_id,
+        1
+      )) as any
+    )[0];
+    request.data = parseRequestObjectData(parent_request.data);
+  } else {
+    request.data = parseRequestObjectData(request.data);
+  }
+
+  return request as IRequestData;
+}
+
+async function loadAllParentOffers(
+  params: ILoadAllParentOffers
+): Promise<IRequestData[]> {
+  const requests = (await fetchTable(
+    ContractsList.Marketplace,
+    params.coopname,
+    TablesList.CoopMarketRequests,
+    0,
+    0,
+    LimitsList.None,
+    SecondaryIndexesNumbers.Six
+  )) as any[];
+
+  requests.map((el) => (el.data = parseRequestObjectData(el.data)));
+
+  return requests as IRequestData[];
+}
+
+async function loadAllChildOrders(
+  params: ILoadAllParentOffers
+): Promise<IRequestData[]> {
+  const child_requests = (
+    (await fetchTable(
+      ContractsList.Marketplace,
+      params.coopname,
+      TablesList.CoopMarketRequests,
+      1,
+      -1,
+      LimitsList.None,
+      SecondaryIndexesNumbers.Six
+    )) as any[]
+  ).filter((el) => el.type === 'order'); //фильтр возможно избыточный
+
+  for (const child_request of child_requests) {
+    const parent_request = await loadOneRequest({
+      coopname: child_request.coopname,
+      request_id: child_request.id,
+    } as IUpdateOneRequest);
+    child_request.data = parent_request.data;
+  }
+  return child_requests as IRequestData[];
+}
+
+async function loadUserParentOffers(
+  params: ILoadUserParentOffers
+): Promise<IRequestData[]> {
+  const requests = (
+    (await fetchTable(
+      ContractsList.Marketplace,
+      params.coopname,
+      TablesList.CoopMarketRequests,
+      params.username,
+      params.username,
+      LimitsList.None,
+      SecondaryIndexesNumbers.Seven
+    )) as any[]
+  ).filter((el) => el.parent_id == 0);
+
+  requests.map((el) => (el.data = parseRequestObjectData(el.data)));
+
+  return requests as IRequestData[];
+}
+
+async function loadUserChildOrders(
+  params: ILoadUserChildOrders
+): Promise<IRequestData[]> {
+  let result = [] as any[];
+  //получаем входящие заявки на открытые заявки пользователя
+  //  получаем встречные заявки, в которых пользователь - родитель
+  const user_incoming_requests = (
+    (await fetchTable(
+      ContractsList.Marketplace,
+      params.coopname,
+      TablesList.CoopMarketRequests,
+      params.username,
+      params.username,
+      LimitsList.None,
+      SecondaryIndexesNumbers.Eight
+    )) as any[]
+  ).filter((el) => el.parent_id > 0); //возможно фильтр лишний
+
+  //TODO получить родительские заявки самого пользователя как происходит ниже
+  result = result.concat(user_incoming_requests);
+
+  //получаем исходящие заявки пользователя
+  const user_outcoming_requests = (
+    (await fetchTable(
+      ContractsList.Marketplace,
+      params.coopname,
+      TablesList.CoopMarketRequests,
+      params.username,
+      params.username,
+      LimitsList.None,
+      SecondaryIndexesNumbers.Seven
+    )) as any[]
+  ).filter((el) => el.parent_id > 0); //возможно фильтр лишний
+
+  result = result.concat(user_outcoming_requests);
+
+  //получаем данные о содержании заявки из родителя для всех ранее полученных встречных заявок
+  //нам это нужно потому что во встречных заявках не содержится текст объявления - он только в открытых
+  for (const child_request of result) {
+    const parent_request = await loadOneRequest({
+      coopname: child_request.coopname,
+      request_id: child_request.id,
+    } as IUpdateOneRequest);
+    child_request.data = parent_request.data;
+  }
+  return result as IRequestData[];
+}
+
+export const api = {
+  loadAllRequests,
+  loadOneRequest,
+  loadAllParentOffers,
+  loadAllChildOrders,
+  loadUserParentOffers,
+  loadUserChildOrders,
+};

package/src/entities/Request/index.ts

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

package/src/entities/Request/model/index.ts

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

package/src/entities/Request/model/stores.ts

@@ -0,0 +1,123 @@
+import { defineStore } from 'pinia'
+import {
+  ILoadAllParentOffers,
+  ILoadAllRequests,
+  ILoadUserChildOrders,
+  ILoadUserParentOffers,
+  IClearRequests,
+  IUpdateOneRequest,
+  IRequestData,
+  ILoadAllChildOrders,
+} from './types'
+import { Ref, ref } from 'vue'
+import { api } from '../api'
+
+const namespace = 'requests'
+
+interface IRequestsStore {
+  //методы
+  loadAllRequests: (params: ILoadAllRequests) => Promise<void>
+  updateOneRequest: (params: IUpdateOneRequest) => Promise<void>
+  loadAllParentOffers: (params: ILoadAllParentOffers) => Promise<void>
+  loadAllChildOrders: (params: ILoadAllChildOrders) => Promise<void>
+  loadUserParentOffers: (params: ILoadUserParentOffers) => Promise<void>
+  loadUserChildOrders: (params: ILoadUserChildOrders) => Promise<void>
+  clear: (params: IClearRequests) => void //* очищаем хранилище
+  //геттеры
+  getAllPublishedParentOffers: () => IRequestData[]
+  //данные
+  allRequests: Ref<IRequestData[]>
+  allParentOffers: Ref<IRequestData[]>
+  allChildOrders: Ref<IRequestData[]>
+  userParentOffers: Ref<IRequestData[]>
+  userChildOrders: Ref<IRequestData[]>
+  //userParentOrders - пока не реализуем
+  //userChildOffers - пока не реализуем
+}
+
+export const useRequestStore = defineStore(namespace, (): IRequestsStore => {
+  const allRequests = ref([] as IRequestData[])
+  const allParentOffers = ref([] as IRequestData[])
+  const allChildOrders = ref([] as IRequestData[])
+  const userParentOffers = ref([] as IRequestData[])
+  const userChildOrders = ref([] as IRequestData[])
+
+  const clear = (params: IClearRequests): void => {
+    if (params.target === 'allRequests') allRequests.value = []
+    else if (params.target === 'allParentOffers') allParentOffers.value = []
+    else if (params.target === 'allChildOrders') allChildOrders.value = []
+    else if (params.target === 'userParentOffers') userParentOffers.value = []
+    else if (params.target === 'userChildOrders') userChildOrders.value = []
+  }
+
+  const loadAllRequests = async (params: ILoadAllRequests): Promise<void> => {
+    allRequests.value = (await api.loadAllRequests(params)).sort(
+      (a, b) => Number(b.id) - Number(a.id)
+    )
+  }
+
+  const updateOneRequest = async (params: IUpdateOneRequest): Promise<void> => {
+    const request = (await api.loadOneRequest(params)) as IRequestData
+    console.log('on update request: ', request)
+
+    //ищем и обновляем объект по всему хранилищу
+    allRequests.value = allRequests.value.map((req) => (req.id === request.id ? request : req))
+
+    allParentOffers.value = allParentOffers.value.map((req) =>
+      req.id === request.id ? request : req
+    )
+    allChildOrders.value = allChildOrders.value.map((req) =>
+      req.id === request.id ? request : req
+    )
+    userParentOffers.value = userParentOffers.value.map((req) =>
+      req.id === request.id ? request : req
+    )
+    userChildOrders.value = userChildOrders.value.map((req) =>
+      req.id === request.id ? request : req
+    )
+  }
+
+  const loadAllParentOffers = async (params: ILoadAllParentOffers): Promise<void> => {
+    allParentOffers.value = (await api.loadAllParentOffers(params)).sort(
+      (a, b) => Number(b.id) - Number(a.id)
+    )
+  }
+
+  const loadAllChildOrders = async (params: ILoadAllChildOrders): Promise<void> => {
+    allChildOrders.value = (await api.loadAllChildOrders(params)).sort(
+      (a, b) => Number(b.id) - Number(a.id)
+    )
+  }
+
+  const loadUserParentOffers = async (params: ILoadUserParentOffers): Promise<void> => {
+    userParentOffers.value = (await api.loadUserParentOffers(params)).sort(
+      (a, b) => Number(b.id) - Number(a.id)
+    )
+  }
+
+  const loadUserChildOrders = async (params: ILoadUserChildOrders): Promise<void> => {
+    userChildOrders.value = (await api.loadUserChildOrders(params)).sort(
+      (a, b) => Number(b.id) - Number(a.id)
+    )
+  }
+
+  const getAllPublishedParentOffers = (): IRequestData[] => {
+    return allParentOffers.value.filter((el) => el.status == 'published')
+  }
+
+  return {
+    loadAllRequests,
+    updateOneRequest,
+    loadAllParentOffers,
+    loadAllChildOrders,
+    loadUserParentOffers,
+    loadUserChildOrders,
+    clear,
+    getAllPublishedParentOffers,
+    allRequests,
+    allParentOffers,
+    allChildOrders,
+    userParentOffers,
+    userChildOrders,
+  }
+})