@coopenomics/desktop 2.2.2

package/src/desktops/User/model/index.ts

@@ -0,0 +1,325 @@
+import { ListOfOrdersPage } from 'src/pages/Cooperative/ListOfOrders';
+import { ListOfQuestionsWidget } from 'src/widgets/Cooperative/Agenda/ListOfQuestions';
+import { markRaw } from 'vue';
+import { ContactsPage } from 'src/pages/Cooperative/Contacts';
+import { ListOfParticipantsPage } from 'src/pages/Cooperative/ListOfParticipants';
+import { UnionPageListOfCooperatives } from 'src/pages/Union/ListOfCooperatives';
+import { agreementsBase } from 'src/shared/lib/consts/workspaces';
+import { ConnectionPage } from 'src/pages/Union/Connection';
+import { ListOfDocumentsPage } from 'src/pages/Documentor/ListOfDocuments';
+import { CoopCardPage } from 'src/pages/User/CardPage';
+
+export const manifest = {
+  'name': 'UserDesktop',
+  'hash': 'hash1',
+  'authorizedHome': 'coop-card',
+  'nonAuthorizedHome': 'signup',
+  'routes': [
+    {
+      meta: {
+        title: 'Централ',
+        icon: 'fa-solid fa-id-card',
+        roles: [],
+      },
+      path: '/:coopname/user',
+      name: 'home',
+      children: [
+        {
+          meta: {
+            title: 'Карта пайщика',
+            icon: '',
+            roles: [],
+            agreements: agreementsBase
+          },
+          path: 'coop-card',
+          name: 'coop-card',
+          component: markRaw(CoopCardPage),
+          children: [],
+        },
+        // {
+        // meta: {
+        //   title: 'Удостоверение',
+        //   icon: '',
+        //   roles: [],
+        //   agreements: agreementsBase
+        // },
+        // path: 'identity',
+        // name: 'user-identity',
+        // component: markRaw(UserIdentityPage),
+        // children: [],
+        // },{
+        //   meta: {
+        //     title: 'Кошелёк',
+        //     icon: '',
+        //     roles: [],
+        //   },
+        //   path: 'wallet',
+        //   name: 'user-wallet',
+        //   component: markRaw(UserWalletPage),
+        //   children: [],
+        // },
+        {
+          path: 'agenda',
+          name: 'agenda',
+          component: markRaw(ListOfQuestionsWidget),
+          meta: {
+            title: 'Повестка',
+            icon: 'fa-solid fa-check-to-slot',
+            roles: ['chairman', 'member'],
+          },
+        },
+        {
+          path: 'participants',
+          name: 'participants',
+          component: markRaw(ListOfParticipantsPage),
+          meta: {
+            title: 'Пайщики',
+            icon: 'fa-solid fa-users',
+            roles: ['chairman', 'member'],
+          },
+        },
+        // {
+        //   path: 'members',
+        //   name: 'settings-members',
+        //   component: markRaw(CooperativeMembers),
+        //   meta: {
+        //     title: 'Совет',
+        //     icon: 'fa-solid fa-users',
+        //     roles: ['chairman', 'member'],
+        //   },
+        // },
+        {
+          path: 'documents',
+          name: 'documents',
+          component: markRaw(ListOfDocumentsPage),
+          meta: {
+            title: 'Документы',
+            icon: 'fa-solid fa-file-invoice',
+            roles: ['chairman', 'member'],
+          },
+        },
+
+        {
+          path: 'orders/:username?',
+          name: 'orders',
+          component: markRaw(ListOfOrdersPage),
+          meta: {
+            title: 'Платежи',
+            icon: 'fa-solid fa-file-invoice',
+            roles: ['chairman', 'member'],
+          },
+        },
+        // {
+        //   path: 'details',
+        //   name: 'settings-details',
+        //   component: markRaw(CooperativeDetails),
+        //   meta: {
+        //     title: 'Реквизиты',
+        //     icon: 'fa-solid fa-check-to-slot',
+        //     roles: [],
+        //   },
+        // },
+
+        // {
+        //   path: 'contributions',
+        //   name: 'settings-contributions',
+        //   component: markRaw(ChangeCooperativeContributions),
+        //   meta: {
+        //     title: 'Взносы',
+        //     icon: 'fa-solid fa-file-invoice',
+        //     roles: ['chairman', 'member'],
+        //   },
+        // },
+        {
+          // meta: {
+            // title: 'Подключения',
+            // icon: 'fas fa-link',
+            // roles: ['chairman', 'member'],
+          // },
+          path: '/:coopname/connections',
+          name: 'connections',
+          component: markRaw(UnionPageListOfCooperatives),
+
+        },
+        {
+          // meta: {
+            // title: 'Подключения',
+            // icon: 'fas fa-link',
+            // roles: ['chairman', 'member'],
+          // },
+          path: '/:coopname/connect',
+          name: 'connect',
+          component: markRaw(ConnectionPage),
+
+        },
+        {
+          path: '/:coopname/contacts',
+          name: 'contacts',
+          component: markRaw(ContactsPage),
+          meta: {
+            title: 'Контакты',
+            icon: 'fa-solid fa-info',
+            roles: [],
+          },
+        },
+
+        // {
+        //   meta: {
+        //     title: 'Поддержка',
+        //     icon: '',
+        //     roles: [],
+        //   },
+        //   path: 'support',
+        //   name: 'support',
+        //   component: markRaw(SupportPage),
+        //   children: [],
+        // },
+      ],
+    },
+
+    // {
+    //   meta: {
+    //     title: 'Совет',
+    //     icon: 'fa-regular fa-circle',
+    //     roles: ['chairman', 'member'],
+    //   },
+    //   path: '/:coopname/soviet',
+    //   name: 'soviet',
+    //   children: [
+
+    //   ]
+    // },
+
+    //КООПЕРАТИВ
+    // {
+    //   meta: {
+    //     title: 'Кооператив',
+    //     icon: 'fa-solid fa-cog',
+    //     roles: ['chairman', 'member'],
+    //   },
+    //   path: '/:coopname/settings',
+    //   name: 'settings',
+    //   children: [
+
+    //   ]
+    // },
+
+
+
+      // {
+      //   meta: {
+      //     title: 'Маркетплейс',
+      //     icon: 'fa-solid fa-cog',
+      //     roles: [],
+      //   },
+      //   path: '/:coopname/marketplace',
+      //   name: 'marketplace',
+      //   component: markRaw(MainMarketplacePage),
+      //   children: [
+      //     {
+      //       path: 'moderation',
+      //       name: 'marketplace-moderation',
+      //       component: markRaw(ModerationPage),
+      //       meta: {
+      //         title: 'Модерация',
+      //         icon: '',
+      //         roles: ['member', 'chairman'],
+      //       },
+      //     },
+      //     {
+      //       path: 'create-offer',
+      //       name: 'marketplace-create-offer',
+      //       component: markRaw(CreateParentOfferPage),
+      //       meta: {
+      //         title: 'Создать объявление',
+      //         icon: '',
+      //         roles: [],
+      //       },
+      //     },
+      //     {
+      //       path: 'showcase',
+      //       name: 'marketplace-showcase',
+      //       component: markRaw(ShowcasePage),
+      //       children: [
+      //         {
+      //           path: ':id',
+      //           name: 'marketplace-showcase-id',
+      //           component: markRaw(ShowcasePage),
+      //         },
+      //       ],
+      //       meta: {
+      //         title: 'Витрина',
+      //         icon: '',
+      //         roles: [],
+      //       },
+      //     },
+      //     {
+      //       path: 'user-offers',
+      //       name: 'marketplace-user-offers',
+      //       component: markRaw(UserParentOffersPage),
+      //       children: [
+      //         {
+      //           path: ':id',
+      //           name: 'marketplace-user-offer-id',
+      //           component: markRaw(UserParentOffersPage),
+      //         },
+      //       ],
+      //       meta: {
+      //         title: 'Мои объявления',
+      //         icon: '',
+      //         roles: [],
+      //       },
+      //     },
+      //     {
+      //       path: 'supplies',
+      //       name: 'marketplace-supplies',
+      //       component: markRaw(SuppliesListPage),
+      //       meta: {
+      //         title: 'Все заказы',
+      //         icon: '',
+      //         roles: ['member', 'chairman'],
+      //       },
+      //     },
+      //     {
+      //       path: 'user-supplies',
+      //       name: 'marketplace-user-supplies',
+      //       component: markRaw(UserSuppliesListPage),
+      //       meta: {
+      //         title: 'Мои заказы',
+      //         icon: '',
+      //         roles: [],
+      //       },
+      //     },
+      //   ],
+      // },
+      //страница контактов
+      // {
+      //   path: ':coopname/contacts',
+      //   name: 'contacts',
+      //   component: markRaw(ContactsPage),
+      //   meta: {
+      //     title: 'Контакты',
+      //     icon: 'fa-solid fa-info',
+      //     roles: [],
+      //   },
+      // },
+      // {
+      //   path: ':coopname/commutator',
+      //   name: 'commutator',
+      //   component: markRaw(Commutator),
+      //   meta: {
+      //     title: 'Коммутатор',
+      //     icon: '',
+      //     roles: [],
+      //   },
+      // },
+  ],
+  'config': {
+    'layout': 'default',
+    'theme': 'light'
+  },
+  'schemas': {
+    'layout': 'avj schema here',
+    'theme': 'avj schema here'
+  }
+}

package/src/desktops/index.ts

@@ -0,0 +1,9 @@
+export * from './Chairman'
+export * from './Member'
+export * from './User'
+export * from './Setup'
+
+// export desktopsMap {
+//   Chairman: ChairmanDesktop,
+
+// }

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

@@ -0,0 +1,17 @@
+import { client } from 'src/shared/api/client';
+import { Queries } from '@coopenomics/sdk';
+import type { IAccount } from '../types';
+
+async function getAccount(username: string): Promise<IAccount | undefined> {
+  const { [Queries.Accounts.GetAccount.name]: output } = await client.Query(Queries.Accounts.GetAccount.query, {
+    variables: {
+      data: {username}
+    }
+  });
+
+  return output;
+}
+
+export const api ={
+  getAccount
+}

package/src/entities/Account/index.ts

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

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

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

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

@@ -0,0 +1,25 @@
+import { defineStore } from 'pinia'
+import { ref, Ref } from 'vue'
+import { api } from '../api'
+import type { IAccount } from '../types';
+
+const namespace = 'accountStore';
+
+interface ISystemStore {
+  account: Ref<IAccount | undefined>
+  getAccount: (username: string) => Promise<IAccount | undefined>;
+}
+
+export const useAccountStore = defineStore(namespace, (): ISystemStore => {
+  const account = ref<IAccount>()
+
+  const getAccount = async (username: string) => {
+    account.value = await api.getAccount(username);
+    return account.value
+  };
+
+  return {
+    account,
+    getAccount
+  }
+})

package/src/entities/Account/types/index.ts

@@ -0,0 +1,3 @@
+import { Queries } from '@coopenomics/sdk';
+
+export type IAccount = Queries.Accounts.GetAccount.IOutput[typeof Queries.Accounts.GetAccount.name]

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

@@ -0,0 +1,46 @@
+import { DraftContract, SovietContract } from 'cooptypes';
+import { fetchTable } from 'src/shared/api';
+
+async function loadCooperativeAgreements(coopname: string): Promise<SovietContract.Tables.CoopAgreements.ICoopAgreement[]> {
+  return (
+    await fetchTable(
+      SovietContract.contractName.production,
+      coopname,
+      SovietContract.Tables.CoopAgreements.tableName,
+    )
+  ) as SovietContract.Tables.CoopAgreements.ICoopAgreement[];
+}
+
+
+async function loadAgreementsOfAllParticipants(coopname: string): Promise<SovietContract.Tables.Agreements.IAgreement[]> {
+  return (
+    await fetchTable(
+      SovietContract.contractName.production,
+      coopname,
+      SovietContract.Tables.Agreements.tableName,
+    )
+  ) as SovietContract.Tables.Agreements.IAgreement[];
+
+}
+
+
+async function loadAgreementTemplates(coopname: string): Promise<DraftContract.Tables.Drafts.IDraft[]> {
+
+    const global = await fetchTable(
+      DraftContract.contractName.production,
+      DraftContract.contractName.production,
+      DraftContract.Tables.Drafts.tableName,
+    )
+
+    const coop = await fetchTable(
+      DraftContract.contractName.production,
+      coopname,
+      DraftContract.Tables.Drafts.tableName,
+    )
+
+    return [...global, ...coop] as DraftContract.Tables.Drafts.IDraft[];
+
+}
+
+
+export const api = {loadCooperativeAgreements, loadAgreementsOfAllParticipants, loadAgreementTemplates}

package/src/entities/Agreement/index.ts

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

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

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

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

@@ -0,0 +1,49 @@
+import { defineStore } from 'pinia';
+import { api } from '../api'
+import { Ref, ref } from 'vue';
+import type { DraftContract, SovietContract } from 'cooptypes';
+import type { IGeneratedDocument } from 'src/shared/lib/document';
+
+const namespace = 'agreementer';
+
+interface IAgreementStore {
+  /*  доменный интерфейс кошелька пользователя */
+  agreementsTemplates: Ref<DraftContract.Tables.Drafts.IDraft[]>
+  agreementsOfAllParticipants: Ref<SovietContract.Tables.Agreements.IAgreement[]>;
+  cooperativeAgreements: Ref<SovietContract.Tables.CoopAgreements.ICoopAgreement[]>;
+  generatedAgreements: Ref<IGeneratedDocument[]>
+  loadAgreementsOfAllParticipants: (coopname: string) => Promise<void>;
+  loadAgreementTemplates: (coopname: string) => Promise<void>;
+  loadCooperativeAgreements: (coopname: string) => Promise<void>;
+}
+
+export const useAgreementStore = defineStore(namespace, (): IAgreementStore => {
+  const agreementsTemplates = ref<DraftContract.Tables.Drafts.IDraft[]>([]);
+  const agreementsOfAllParticipants = ref<SovietContract.Tables.Agreements.IAgreement[]>([]);
+
+  const cooperativeAgreements = ref<SovietContract.Tables.CoopAgreements.ICoopAgreement[]>([]);
+
+  const generatedAgreements = ref<IGeneratedDocument[]>([])
+
+  const loadAgreementsOfAllParticipants = async (coopname: string) => {
+    agreementsOfAllParticipants.value = await api.loadAgreementsOfAllParticipants(coopname)
+  }
+
+  const loadAgreementTemplates = async (coopname: string) => {
+    agreementsTemplates.value = await api.loadAgreementTemplates(coopname)
+  }
+
+  const loadCooperativeAgreements = async (coopname: string) => {
+    cooperativeAgreements.value = await api.loadCooperativeAgreements(coopname)
+  }
+
+  return {
+    cooperativeAgreements,
+    agreementsTemplates,
+    agreementsOfAllParticipants,
+    loadAgreementsOfAllParticipants,
+    loadAgreementTemplates,
+    loadCooperativeAgreements,
+    generatedAgreements
+  };
+});

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

@@ -0,0 +1,34 @@
+import { client } from 'src/shared/api/client';
+import { Queries } from '@coopenomics/sdk';
+import type { IBranch, IGetBranchesInput, IPublicBranch } from '../model';
+
+async function loadBranches(data: IGetBranchesInput): Promise<IBranch[]> {
+  const { [Queries.Branches.GetBranches.name]: output } = await client.Query(
+    Queries.Branches.GetBranches.query,
+    {
+      variables: {
+        data
+      }
+    }
+  );
+  return output;
+}
+
+async function loadPublicBranches(data: IGetBranchesInput): Promise<IPublicBranch[]> {
+  const { [Queries.Branches.GetPublicBranches.name]: output } = await client.Query(
+    Queries.Branches.GetPublicBranches.query,
+    {
+      variables: {
+        data
+      }
+    }
+  );
+
+  return output;
+}
+
+
+export const api ={
+  loadBranches,
+  loadPublicBranches
+}

package/src/entities/Branch/index.ts

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

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

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

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

@@ -0,0 +1,36 @@
+import { defineStore } from 'pinia'
+import { ref, Ref } from 'vue'
+import { api } from '../api'
+import type { IBranch, IGetBranchesInput, IPublicBranch } from './types';
+
+const namespace = 'branchStore';
+
+interface IBranchStore {
+  branches: Ref<IBranch[]>
+  loadBranches: (data: IGetBranchesInput) => Promise<void>;
+  publicBranches: Ref<IPublicBranch[]>
+  loadPublicBranches: (data: IGetBranchesInput) => Promise<void>;
+}
+
+
+export const useBranchStore = defineStore(namespace, (): IBranchStore => {
+  const branches = ref<IBranch[]>([])
+  const publicBranches = ref<IPublicBranch[]>([])
+
+  const loadBranches = async (data: IGetBranchesInput) => {
+    const loadedData = await api.loadBranches(data);
+    branches.value = loadedData; // сохраняем преобразованные данные
+  };
+
+  const loadPublicBranches = async (data: IGetBranchesInput) => {
+    const loadedData = await api.loadPublicBranches(data);
+    publicBranches.value = loadedData; // сохраняем преобразованные данные
+  };
+
+  return {
+    branches,
+    publicBranches,
+    loadBranches,
+    loadPublicBranches
+  }
+})

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

@@ -0,0 +1,7 @@
+import type { Queries } from '@coopenomics/sdk';
+
+export type IBranch = Queries.Branches.GetBranches.IOutput[typeof Queries.Branches.GetBranches.name][number]
+export type IPublicBranch = Queries.Branches.GetPublicBranches.IOutput[typeof Queries.Branches.GetPublicBranches.name][number]
+
+export type IGetBranchesInput = Queries.Branches.GetBranches.IInput['data']
+

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

@@ -0,0 +1,106 @@
+import { fetchTable, sendGET } from 'src/shared/api';
+import { ContractsList, TablesList } from 'src/shared/config';
+import {
+  IAddressesData,
+  IAdministratorData,
+  ICoopProgramData,
+  ILoadCoopPrograms,
+  ILoadCooperativeAddresses,
+} from '../model';
+import {Cooperative, FundContract, RegistratorContract, SovietContract } from 'cooptypes';
+
+async function loadPrograms(
+  params: ILoadCoopPrograms
+): Promise<ICoopProgramData[]> {
+  return (await fetchTable(
+    SovietContract.contractName.production,
+    params.coopname,
+    SovietContract.Tables.Programs.tableName
+  )) as ICoopProgramData[];
+}
+
+async function loadAdmins(coopname: string): Promise<IAdministratorData[]> {
+  return (await sendGET('/v1/coop/staff', {
+    coopname: coopname,
+  })) as IAdministratorData[];
+}
+
+async function loadPrivateCooperativeData(): Promise<Cooperative.Model.ICooperativeData> {
+  return (await sendGET('/v1/coop/info', {}, false)) as Cooperative.Model.ICooperativeData;
+}
+
+async function loadContacts(): Promise<Cooperative.Model.IContacts> {
+  return (await sendGET('/v1/coop/contacts', {}, true)) as Cooperative.Model.IContacts;
+}
+
+async function loadCoopWallet(coopname: string): Promise<FundContract.Tables.CoopWallet.ICoopWallet>{
+  return (
+    await fetchTable(
+      FundContract.contractName.production,
+      coopname,
+      FundContract.Tables.CoopWallet.tableName,
+      0,
+      0,
+      1
+    )
+  )[0] as FundContract.Tables.CoopWallet.ICoopWallet;
+}
+
+async function loadAccumulationFunds(coopname: string): Promise<FundContract.Tables.AccumulatedFunds.IAccumulatedFund[]>{
+  return (
+    await fetchTable(
+      FundContract.contractName.production,
+      coopname,
+      FundContract.Tables.AccumulatedFunds.tableName,
+    )
+  )as FundContract.Tables.AccumulatedFunds.IAccumulatedFund[];
+}
+
+
+async function loadExpenseFunds(coopname: string): Promise<FundContract.Tables.ExpensedFunds.IExpensedFund[]>{
+  return (
+    await fetchTable(
+      FundContract.contractName.production,
+      coopname,
+      FundContract.Tables.ExpensedFunds.tableName,
+    )
+  )as FundContract.Tables.ExpensedFunds.IExpensedFund[];
+}
+
+
+async function loadPublicCooperativeData(
+  coopname: string
+): Promise<RegistratorContract.Tables.Cooperatives.ICooperative> {
+  return (
+    await fetchTable(
+      RegistratorContract.contractName.production,
+      RegistratorContract.contractName.production,
+      RegistratorContract.Tables.Cooperatives.tableName,
+      coopname,
+      coopname,
+      1
+    )
+  )[0] as RegistratorContract.Tables.Cooperatives.ICooperative;
+}
+
+async function loadCooperativeAddresses(
+  params: ILoadCooperativeAddresses
+): Promise<IAddressesData[]> {
+  return (await fetchTable(
+    ContractsList.Soviet,
+    params.coopname,
+    TablesList.CooperativeAddresses
+  )) as IAddressesData[];
+}
+
+export const api = {
+  loadPrograms,
+  loadCooperativeAddresses,
+  loadPublicCooperativeData,
+  loadAdmins,
+  loadPrivateCooperativeData,
+  loadContacts,
+  loadCoopWallet,
+  loadAccumulationFunds,
+  loadExpenseFunds
+};