@coopenomics/desktop 2.2.2

package/src/entities/Cooperative/index.ts

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

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

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

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

@@ -0,0 +1,123 @@
+import { defineStore } from 'pinia';
+import { Ref, ref, ComputedRef, computed } from 'vue';
+import { api } from '../api';
+import {
+  IAddressesData,
+  ICoopProgramData,
+  ILoadCoopPrograms,
+  ILoadCooperativeAddresses,
+  IAdministratorData,
+} from './types';
+import { Cooperative, FundContract, RegistratorContract } from 'cooptypes';
+
+const namespace = 'cooperative';
+
+interface ICooperativeStore {
+  // методы
+  loadFunds: (coopname: string) => Promise<void>;
+  loadAddresses: (params: ILoadCooperativeAddresses) => Promise<void>;
+  loadPrograms: (params: ILoadCoopPrograms) => Promise<void>;
+  loadPrivateCooperativeData: () => Promise<void>;
+  loadContacts: () => Promise<void>;
+  loadPublicCooperativeData: (coopname: string) => Promise<void>;
+  loadAdmins: (coopname: string) => Promise<void>;
+
+  // данные
+  admins: Ref<IAdministratorData[]>;
+  programs: Ref<ICoopProgramData[]>;
+  addresses: Ref<IAddressesData[]>;
+  contacts: Ref<Cooperative.Model.IContacts | undefined>
+  publicCooperativeData: Ref<RegistratorContract.Tables.Cooperatives.ICooperative | undefined>;
+  privateCooperativeData: Ref<Cooperative.Model.ICooperativeData | undefined>;
+
+  coopWallet: Ref<FundContract.Tables.CoopWallet.ICoopWallet | undefined>
+  accumulationFunds: Ref<FundContract.Tables.AccumulatedFunds.IAccumulatedFund[]>
+  expenseFunds: Ref<FundContract.Tables.ExpensedFunds.IExpensedFund[]>
+
+  governSymbol: ComputedRef<string>
+}
+
+export const useCooperativeStore = defineStore(
+  namespace,
+  (): ICooperativeStore => {
+    const programs = ref([] as ICoopProgramData[]);
+    const addresses = ref([] as IAddressesData[]);
+    const admins = ref([] as IAdministratorData[]);
+    const publicCooperativeData = ref<RegistratorContract.Tables.Cooperatives.ICooperative>();
+    const privateCooperativeData = ref<Cooperative.Model.ICooperativeData>()
+    const coopWallet = ref<FundContract.Tables.CoopWallet.ICoopWallet>()
+    const accumulationFunds = ref<FundContract.Tables.AccumulatedFunds.IAccumulatedFund[]>([])
+    const expenseFunds = ref<FundContract.Tables.ExpensedFunds.IExpensedFund[]>([])
+
+    const governSymbol = computed(() => {
+      if (publicCooperativeData.value) {
+        const [, symbol] = publicCooperativeData.value.initial.split(' ')
+        return symbol
+      } else return ''
+    })
+
+    const contacts = ref<Cooperative.Model.IContacts>()
+
+    const loadFunds = async(coopname: string) : Promise<void> => {
+      coopWallet.value = await api.loadCoopWallet(coopname)
+      accumulationFunds.value = (await api.loadAccumulationFunds(coopname)).map(el => ({
+        ...el,
+        percent: Number(el.percent) / 10000
+      }));
+
+      expenseFunds.value = await api.loadExpenseFunds(coopname)
+    }
+
+    const loadContacts = async(): Promise<void> => {
+      contacts.value = await api.loadContacts()
+    }
+
+    const loadPrivateCooperativeData = async(): Promise<void> => {
+      privateCooperativeData.value = await api.loadPrivateCooperativeData()
+    }
+
+    const loadPublicCooperativeData = async (
+      coopname: string
+    ): Promise<void> => {
+      publicCooperativeData.value = await api.loadPublicCooperativeData(
+        coopname
+      );
+    };
+
+    const loadPrograms = async (
+      params: ILoadCoopPrograms
+    ): Promise<void> => {
+      programs.value = await api.loadPrograms(params);
+    };
+
+    const loadAddresses = async (
+      params: ILoadCooperativeAddresses
+    ): Promise<void> => {
+      addresses.value = await api.loadCooperativeAddresses(params);
+    };
+
+    const loadAdmins = async (coopname: string): Promise<void> => {
+      admins.value = await api.loadAdmins(coopname);
+    };
+
+    return {
+      loadFunds,
+      loadPrograms,
+      loadAddresses,
+      loadContacts,
+      loadPublicCooperativeData,
+      loadPrivateCooperativeData,
+      programs,
+      addresses,
+      contacts,
+      privateCooperativeData,
+      publicCooperativeData,
+      loadAdmins,
+      admins,
+      governSymbol,
+      coopWallet,
+      accumulationFunds,
+      expenseFunds
+    };
+  }
+);

package/src/entities/Cooperative/model/types.ts

@@ -0,0 +1,19 @@
+import { SovietContract } from 'cooptypes';
+import { IUser } from 'src/shared/lib/types/user';
+
+export type ICoopProgramData =
+  SovietContract.Tables.Programs.IProgram;
+export type IAddressesData = SovietContract.Tables.Addresses.IAddress;
+
+export interface ILoadCoopPrograms {
+  coopname: string;
+}
+
+export interface ILoadCooperativeAddresses {
+  coopname: string;
+}
+
+export interface IAdministratorData
+  extends SovietContract.Tables.Admins.IAdmins {
+  user: IUser;
+}

package/src/entities/Decision/index.ts

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

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

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

package/src/entities/Decision/model/types.ts

@@ -0,0 +1,4 @@
+import type { Mutations } from '@coopenomics/sdk';
+
+export type ICreatedProjectDecisionData = Mutations.FreeDecisions.CreateProjectOfFreeDecision.IOutput[typeof Mutations.FreeDecisions.CreateProjectOfFreeDecision.name]
+export type IGeneratedProjectDecisionDocument = Mutations.FreeDecisions.GenerateProjectOfFreeDecision.IOutput[typeof Mutations.FreeDecisions.GenerateProjectOfFreeDecision.name]

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

@@ -0,0 +1,10 @@
+import type { IHealthResponse } from '@coopenomics/controller';
+import { sendGET } from 'src/shared/api';
+
+async function healthCheck(): Promise<IHealthResponse> {
+  return (await sendGET('/v1/system/health', {}, true)) as IHealthResponse;
+}
+
+export const api ={
+  healthCheck
+}

package/src/entities/Desktop/index.ts

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

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

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

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

@@ -0,0 +1,135 @@
+import { defineStore } from 'pinia'
+import * as Desktops from 'src/desktops'
+import { computed, ComputedRef, ref, Ref } from 'vue'
+import { FailAlert } from 'src/shared/api'
+import { RouteRecordRaw, type RouteLocationNormalized} from 'vue-router'
+import { IDesktop, IRoute, IBlockchainDesktops, IHealthResponse } from './types'
+import { api } from '../api'
+
+const desktopHashMap = {
+  'hash1': Desktops.UserDesktopModel.manifest, //User
+  'hash2': Desktops.ChairmanDesktopModel.manifest, //'Chairman',
+  'hash3': Desktops.MemberDesktopModel.manifest, //'Member',
+  'hash4': Desktops.SetupDesktopModel.manifest, //Setup
+}
+
+const namespace = 'desktops';
+
+interface IDesktopStore {
+  online: Ref<boolean | undefined>
+  health: Ref<IHealthResponse | undefined>
+  currentDesktop: Ref<IDesktop | undefined>
+  availableDesktops: Ref<IDesktop[]>
+  defaultDesktopHash: Ref<string | undefined>
+  healthCheck: () => Promise<void>;
+  setActiveDesktop: (hash: string | undefined) => void;
+  loadDesktops: () => Promise<void>;
+  getSecondLevel: (currentRoute: RouteLocationNormalized) => RouteRecordRaw[]
+  firstLevel: ComputedRef<IRoute[]>;
+}
+
+
+function getNestedRoutes(route: RouteRecordRaw):RouteRecordRaw[]  {
+  if (!route.children) {
+    return [];
+  }
+
+  let nestedRoutes: RouteRecordRaw[] = [];
+
+  for (const child of route.children) {
+    nestedRoutes.push(child);
+    nestedRoutes = nestedRoutes.concat(getNestedRoutes(child));
+  }
+
+  return nestedRoutes;
+}
+
+export const useDesktopStore = defineStore(namespace, (): IDesktopStore => {
+  const currentDesktop = ref<IDesktop>()
+  const availableDesktops = ref<IDesktop[]>([])
+  const defaultDesktopHash = ref<string>()
+  const health = ref<IHealthResponse | undefined>()
+  const online = ref<boolean | undefined>()
+
+
+
+  async function healthCheck(): Promise<void> {
+    try {
+
+      health.value = await api.healthCheck()
+
+      if (health.value.status != 'maintenance'){
+        if (online.value === false){
+          online.value = true
+        }
+      } else {
+        online.value = false
+        setTimeout(healthCheck, 10000)
+      }
+
+    } catch (e) {
+      online.value = false
+      setTimeout(healthCheck, 10000)
+    }
+  }
+
+  const firstLevel = computed(() => {
+    if (currentDesktop.value)
+      return currentDesktop.value.routes
+    else return []
+  });
+
+
+  const getSecondLevel = (currentRoute: RouteLocationNormalized): RouteRecordRaw[] => {
+    if (currentRoute.matched && currentDesktop.value && currentRoute) {
+
+      const matchingRootRoute = currentRoute.matched[1]
+
+      if (matchingRootRoute) {
+        return getNestedRoutes(matchingRootRoute)
+      }
+    }
+    return [];
+  }
+
+
+  const setActiveDesktop = (hash: string | undefined) => {
+    const desktop = availableDesktops.value.find(d => d.hash === hash)
+    if (desktop)
+      currentDesktop.value = desktop
+    else {
+      FailAlert('Рабочий стол не найден')
+    }
+  }
+
+  const loadAvailableDesktops = async(): Promise<IBlockchainDesktops> => {
+    return { //load it from bc later
+      defaultHash: 'hash1',
+      availableHashes: ['hash1','hash2', 'hash3']
+    }
+  }
+
+
+  const loadDesktops = async () => {
+    const {defaultHash, availableHashes} = await loadAvailableDesktops()
+    availableDesktops.value = []
+    defaultDesktopHash.value = defaultHash
+
+    availableHashes.map(hash => availableDesktops.value.push(
+      desktopHashMap[hash as any]
+    ))
+  }
+
+  return {
+    online,
+    health,
+    defaultDesktopHash, //перезапишем через локал-сторадж для пользовательского управления стартовой страницей
+    currentDesktop,
+    availableDesktops,
+    setActiveDesktop,
+    loadDesktops,
+    getSecondLevel,
+    firstLevel,
+    healthCheck
+  }
+})

package/src/entities/Desktop/model/types.ts

@@ -0,0 +1,29 @@
+export interface IDesktop {
+  name: string;
+  hash: string;
+  authorizedHome: string;
+  nonAuthorizedHome: string;
+  routes: IRoute[];
+  config: object;
+}
+
+export interface IBlockchainDesktops {
+  defaultHash: string; //hash
+  availableHashes: string[]; //hashes
+}
+
+interface RouteMeta {
+  title: string;
+  icon: string;
+  roles: string[];
+}
+
+export interface IRoute {
+  path: string;
+  name: string;
+  component?: any;
+  children?: IRoute[];
+  meta: RouteMeta;
+}
+
+export type { IHealthResponse } from '@coopenomics/controller'

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

@@ -0,0 +1,19 @@
+import { client } from 'src/shared/api/client';
+import { Queries } from '@coopenomics/sdk';
+import type { ZExtension } from '../model';
+
+async function loadExtensions(data?: Queries.Extensions.GetExtensions.IInput['data']): Promise<ZExtension[]> {
+  const { [Queries.Extensions.GetExtensions.name]: output } = await client.Query(
+    Queries.Extensions.GetExtensions.query,
+    {
+      variables: {
+        data
+      }
+    }
+  );
+  return output;
+}
+
+export const api ={
+  loadExtensions
+}

package/src/entities/Extension/index.ts

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

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

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

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

@@ -0,0 +1,71 @@
+import { defineStore } from 'pinia'
+import { ref, Ref } from 'vue'
+import { api } from '../api'
+import type { IExtension } from './types';
+import { Queries } from '@coopenomics/sdk';
+
+const namespace = 'extensionStore';
+
+export type ILoadExtensions = Queries.Extensions.GetExtensions.IInput['data'];
+
+interface IExtensionStore {
+  extensions: Ref<IExtension[]>
+  loadExtensions: (data?: ILoadExtensions) => void;
+}
+
+const parseDescriptionsRecursively = (obj: any): any => {
+  if (typeof obj !== 'object' || obj === null) {
+    return obj; // Если obj не объект, просто возвращаем его
+  }
+
+  return Object.fromEntries(
+    Object.entries(obj).map(([key, value]) => {
+      if (key === 'description' && typeof value === 'string') {
+        try {
+          return [key, JSON.parse(value)];
+        } catch (error) {
+          console.error(`Failed to parse description for key ${key}:`, error);
+          return [key, value]; // Оставляем строку, если парсинг не удался
+        }
+      } else if (typeof value === 'object') {
+        // Рекурсивно обрабатываем вложенные объекты
+        return [key, parseDescriptionsRecursively(value)];
+      } else {
+        return [key, value];
+      }
+    })
+  );
+};
+
+
+
+export const useExtensionStore = defineStore(namespace, (): IExtensionStore => {
+  const extensions = ref<IExtension[]>([])
+
+  const loadExtensions = async (data?: ILoadExtensions) => {
+    const loadedData = await api.loadExtensions(data);
+
+    const transformedData = loadedData.map((value) => {
+      const schema = value.schema as IExtension['schema'] | undefined; // schema может быть undefined
+
+      return {
+        ...value,
+        schema: schema
+          ? {
+              ...schema,
+              properties: schema.properties
+                ? parseDescriptionsRecursively(schema.properties)
+                : {}, // если properties отсутствует, возвращаем пустой объект
+            }
+          : undefined, // если schema отсутствует, возвращаем undefined
+      };
+    });
+
+    extensions.value = transformedData; // сохраняем преобразованные данные
+  };
+
+  return {
+    extensions,
+    loadExtensions
+  }
+})

package/src/entities/Extension/model/types.ts

@@ -0,0 +1,28 @@
+import type { Types, Queries, Zeus } from '@coopenomics/sdk';
+
+export type ZExtension = Queries.Extensions.GetExtensions.IOutput[typeof Queries.Extensions.GetExtensions.name][number]
+
+export type ISchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+
+export type ISchemaProperty = {
+  type?: ISchemaType;
+  description?: Types.DeserializedDescriptionOfExtension
+  default?: any;
+  required?: string[];
+  properties?: ISchemaProperty;
+  items?: ISchemaProperty; // для массивов
+  enum?: any[]; // если поле использует перечисления
+  additionalProperties?: boolean;
+};
+
+export type IExtensionConfigSchema = {
+  properties: ISchemaProperty;
+  required?: string[];
+  additionalProperties?: boolean;
+  type: ISchemaType;
+}
+
+
+export type IExtension = Omit<Zeus.ModelTypes['Extension'], 'schema'> & {
+  schema?: IExtensionConfigSchema;
+};

package/src/entities/Installer/index.ts

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

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

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

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

@@ -0,0 +1,36 @@
+import { defineStore } from 'pinia';
+import { IIndividualData } from 'src/shared/lib/types/user/IUserData';
+import { Ref, ref } from 'vue';
+
+interface data {
+  id: number,
+  role: 'chairman' | 'member',
+  type: 'individual',
+  individual_data: IIndividualData
+}
+
+interface IInstallCooperative {
+  wif: Ref<string | undefined>
+  is_finish: Ref<boolean>
+  soviet: Ref<data[]>
+}
+
+const namespace = 'install';
+
+export const useInstallCooperativeStore = defineStore(
+  namespace,
+  (): IInstallCooperative => {
+
+    const soviet = ref([])
+    const is_finish = ref(false)
+    const wif = ref()
+
+    return {
+      soviet,
+      is_finish,
+      wif
+    }
+  }, {
+    persist: true,
+  })
+

package/src/entities/Menu/index.ts

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

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

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

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

@@ -0,0 +1,69 @@
+import { defineStore } from 'pinia';
+import { ComputedRef, Ref, ref, computed } from 'vue';
+import { RouteRecordRaw } from 'vue-router';
+import { IMenu } from './types';
+
+interface IMenuStore {
+  //методы
+  setRoutes: (routes: RouteRecordRaw[]) => void;
+  //данные
+  routes: Ref<RouteRecordRaw[]>;
+  getUserDesktopMenu: (role: string | undefined) => IMenu[];
+  adminDesktopMenu: ComputedRef<IMenu[]>;
+}
+
+const namespace = 'buttonmenu';
+export const useMenuStore = defineStore(namespace, (): IMenuStore => {
+  const routes: Ref<RouteRecordRaw[]> = ref([]);
+
+  function setRoutes(newRoutes: RouteRecordRaw[]) {
+    routes.value = newRoutes;
+  }
+
+  function flattenRoutes(
+    routes: RouteRecordRaw[],
+    menuType: 'is_desktop_menu' | 'is_mobile_menu',
+    role: string
+  ): IMenu[] {
+    let flatRoutes: IMenu[] = [];
+    routes.forEach((route) => {
+      const { path, name, meta } = route;
+      if (meta && meta[menuType]) {
+        const { title, icon, roles = [] } = meta;
+
+        if (title && icon && (roles.includes(role) || roles.length == 0)) {
+          flatRoutes.push({
+            path,
+            name: name as string,
+            meta: {
+              is_desktop_menu: menuType === 'is_desktop_menu',
+              is_mobile_menu: menuType === 'is_mobile_menu',
+              title: title as string,
+              icon: icon as string,
+              roles: roles as string[],
+            },
+          });
+        }
+      }
+      // Рекурсивно обрабатываем дочерние маршруты
+      if (route.children) {
+        flatRoutes = flatRoutes.concat(
+          flattenRoutes(route.children, menuType, role)
+        );
+      }
+    });
+    return flatRoutes;
+  }
+  const getUserDesktopMenu = (role: string | undefined) => {
+    if (role == undefined) role = '';
+
+    return flattenRoutes(routes.value, 'is_desktop_menu', role);
+  };
+
+  const adminDesktopMenu = computed(() => {
+    if (!routes.value) return [];
+    return flattenRoutes(routes.value, 'is_desktop_menu', 'admin');
+  });
+
+  return { routes, setRoutes, adminDesktopMenu, getUserDesktopMenu };
+});

package/src/entities/Menu/model/types.ts

@@ -0,0 +1,11 @@
+export interface IMenu {
+  path: string
+  name: string
+  meta: {
+    is_desktop_menu: boolean
+    is_mobile_menu: boolean
+    title: string
+    icon: string
+    roles: string[]
+  }
+}

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

@@ -0,0 +1 @@
+export default {}

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

@@ -0,0 +1,14 @@
+import type { IGetCoopOrders, IGetResponse, IOrderResponse } from '@coopenomics/controller'
+import { sendGET } from 'src/shared/api'
+
+const loadCoopOrders = async(params: IGetCoopOrders): Promise<IGetResponse<IOrderResponse>> => {
+  console.log('params: ', params)
+  return await sendGET('/v1/orders/all', params) as IGetResponse<IOrderResponse>
+}
+
+const loadMyOrders = async(username?: string, page?: number, limit?: number): Promise<IGetResponse<IOrderResponse>> => {
+  return await sendGET(`/v1/orders/${username}`, {page, limit}) as IGetResponse<IOrderResponse>
+}
+
+
+export const api = {loadCoopOrders, loadMyOrders}

package/src/entities/Order/index.ts

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

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

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