@coopenomics/desktop 2.2.2

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

@@ -0,0 +1,192 @@
+import { fetchTable, sendGET } from '../../../shared/api';
+
+import {
+  ContractsList,
+  TablesList,
+  LimitsList,
+  SecondaryIndexesNumbers,
+} from 'src/shared/config';
+
+import {
+  IWalletData,
+  IDepositData,
+  IWithdrawData,
+  IProgramWalletData,
+  ICoopProgramData,
+  ExtendedProgramWalletData,
+  IGetPaymentMethods,
+  IGetResponsePaymentMethodData,
+  IPaymentMethodData,
+} from '../model';
+
+import {
+  ILoadSingleUserWallet,
+  ILoadSingleUserDeposit,
+  ILoadSingleUserProgramWallet,
+  ILoadSingleUserWithdraw,
+  ILoadUserDeposits,
+  ILoadUserProgramWallets,
+  ILoadUserWithdraws,
+} from '../model';
+import { SovietContract } from 'cooptypes';
+
+async function loadSingleUserWalletData(
+  params: ILoadSingleUserWallet
+): Promise<IWalletData> {
+  return (
+    await fetchTable(
+      ContractsList.Soviet,
+      params.coopname,
+      TablesList.Wallets,
+      params.username,
+      params.username,
+      LimitsList.One
+    )
+  )[0] as IWalletData;
+}
+
+async function loadSingleUserDepositData(
+  params: ILoadSingleUserDeposit
+): Promise<IDepositData> {
+  return (
+    await fetchTable(
+      ContractsList.Gateway,
+      params.coopname,
+      TablesList.Deposits,
+      params.username,
+      params.username,
+      LimitsList.One
+    )
+  )[0] as IDepositData;
+}
+
+async function loadSingleUserProgramWalletData(
+  params: ILoadSingleUserProgramWallet
+): Promise<IProgramWalletData> {
+  return (
+    await fetchTable(
+      ContractsList.Soviet,
+      params.coopname,
+      TablesList.ProgramWallets,
+      params.wallet_id,
+      params.wallet_id,
+      LimitsList.One
+    )
+  )[0] as IProgramWalletData;
+}
+
+async function loadSingleUserWithdrawData(
+  params: ILoadSingleUserWithdraw
+): Promise<IWithdrawData> {
+  return (
+    await fetchTable(
+      ContractsList.Gateway,
+      params.coopname,
+      TablesList.Withdraws,
+      params.withdraw_id,
+      params.withdraw_id,
+      LimitsList.One
+    )
+  )[0] as IWithdrawData;
+}
+
+async function loadUserDepositsData(
+  params: ILoadUserDeposits
+): Promise<IDepositData[]> {
+  return (await fetchTable(
+    ContractsList.Gateway,
+    params.coopname,
+    TablesList.Deposits,
+    params.username,
+    params.username,
+    LimitsList.None,
+    SecondaryIndexesNumbers.Two
+  )) as IDepositData[];
+}
+
+async function loadUserWithdrawsData(
+  params: ILoadUserWithdraws
+): Promise<IWithdrawData[]> {
+  return (await fetchTable(
+    ContractsList.Gateway,
+    params.coopname,
+    TablesList.Withdraws,
+    params.username,
+    params.username,
+    LimitsList.None,
+    SecondaryIndexesNumbers.Two
+  )) as IWithdrawData[];
+}
+
+async function loadUserProgramWalletsData(
+  params: ILoadUserProgramWallets
+): Promise<ExtendedProgramWalletData[]> {
+  const programs = (await fetchTable(
+    SovietContract.contractName.production,
+    params.coopname,
+    SovietContract.Tables.Programs.tableName
+  )) as ICoopProgramData[];
+
+  const program_wallets = (await fetchTable(
+    SovietContract.contractName.production,
+    params.coopname,
+    SovietContract.Tables.ProgramWallets.tableName,
+    params.username,
+    params.username,
+    LimitsList.None,
+    SecondaryIndexesNumbers.Two
+  )) as IProgramWalletData[];
+
+  const extendedProgramWallets: ExtendedProgramWalletData[] =
+    program_wallets.map((wallet) => {
+      const programInfo = programs.find(
+        (program) => program.id === wallet.program_id
+      );
+
+      if (programInfo) {
+        return {
+          ...wallet,
+          program_details: programInfo,
+        } as ExtendedProgramWalletData;
+      }
+
+      return wallet as ExtendedProgramWalletData;
+    });
+
+  return extendedProgramWallets;
+}
+
+async function loadMethods(params: IGetPaymentMethods): Promise<IPaymentMethodData[]> {
+  const {username} = params
+  const methods = (await sendGET(`/v1/methods/${username}`)) as IGetResponsePaymentMethodData;
+
+  return methods.results;
+}
+
+async function loadUserAgreements(coopname: string, username: string): Promise<SovietContract.Tables.Agreements.IAgreement[]> {
+  return (
+    await fetchTable(
+      SovietContract.contractName.production,
+      coopname,
+      SovietContract.Tables.Agreements.tableName,
+      username,
+      username,
+      LimitsList.None,
+      'secondary'
+    )
+  ) as SovietContract.Tables.Agreements.IAgreement[];
+
+}
+
+
+export const api = {
+  loadSingleUserWalletData,
+  loadSingleUserDepositData,
+  loadSingleUserProgramWalletData,
+  loadSingleUserWithdrawData,
+  loadUserDepositsData,
+  loadUserWithdrawsData,
+  loadUserProgramWalletsData,
+  loadMethods,
+  loadUserAgreements
+};

package/src/entities/Wallet/index.ts

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

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

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

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

@@ -0,0 +1,108 @@
+import { defineStore } from 'pinia';
+import { api } from '../api';
+import {
+  IWalletData,
+  IDepositData,
+  IWithdrawData,
+  ExtendedProgramWalletData,
+  ICreateWithdraw,
+  IPaymentMethodData,
+} from './types';
+import { IPaymentOrder } from 'src/shared/lib/types/payments';
+import { ILoadUserWallet } from './types';
+import { ICreateDeposit } from 'src/shared/lib/types/payments';
+import { Ref, ref } from 'vue';
+import { sendPOST } from 'src/shared/api';
+import { CURRENCY } from 'src/shared/config';
+import type { SovietContract } from 'cooptypes';
+
+const namespace = 'wallet';
+
+interface IWalletStore {
+  /*  доменный интерфейс кошелька пользователя */
+  wallet: Ref<IWalletData>;
+  program_wallets: Ref<ExtendedProgramWalletData[]>;
+  deposits: Ref<IDepositData[]>;
+  withdraws: Ref<IWithdrawData[]>;
+  methods: Ref<IPaymentMethodData[]>;
+  agreements: Ref<SovietContract.Tables.Agreements.IAgreement[]>;
+
+  loadUserWalet: (params: ILoadUserWallet) => Promise<void>;
+
+  //TODO move to features
+  createDeposit: (params: ICreateDeposit) => Promise<IPaymentOrder>;
+  createWithdraw: (params: ICreateWithdraw) => Promise<void>;
+}
+
+export const useWalletStore = defineStore(namespace, (): IWalletStore => {
+  const wallet = ref<IWalletData>({
+    username: '',
+    coopname: '',
+    available: `0.0000 ${CURRENCY}`,
+    blocked: `0.0000 ${CURRENCY}`,
+    minimum: `0.0000 ${CURRENCY}`,
+    initial: `0.0000 ${CURRENCY}`,
+  });
+
+  const deposits = ref<IDepositData[]>([]);
+  const withdraws = ref<IWithdrawData[]>([]);
+  const program_wallets = ref<ExtendedProgramWalletData[]>([]);
+  const methods = ref<IPaymentMethodData[]>([]);
+  const agreements = ref<SovietContract.Tables.Agreements.IAgreement[]>([]);
+
+
+  const loadUserWalet = async (params: ILoadUserWallet) => {
+
+    const createEmptyWallet = (): IWalletData => ({
+      username: '',
+      coopname: '',
+      available: `0.0000 ${CURRENCY}`,
+      blocked: `0.0000 ${CURRENCY}`,
+      minimum: `0.0000 ${CURRENCY}`,
+      initial: `0.0000 ${CURRENCY}`,
+    });
+
+    try {
+      const data = await Promise.all([
+        api.loadSingleUserWalletData(params),
+        api.loadUserDepositsData(params),
+        api.loadUserWithdrawsData(params),
+        api.loadUserProgramWalletsData(params),
+        api.loadMethods(params),
+        api.loadUserAgreements(params.coopname, params.username)
+      ]);
+
+      wallet.value = data[0] ?? createEmptyWallet();
+      deposits.value = data[1] ?? [];
+      withdraws.value = data[2] ?? [];
+      program_wallets.value = data[3] ?? [];
+      methods.value = data[4] ?? [];
+      agreements.value = data[5] ?? [];
+
+    } catch (e: any) {
+      console.log(e);
+    }
+  };
+
+  const createDeposit = async (
+    params: ICreateDeposit
+  ): Promise<IPaymentOrder> => {
+    return sendPOST('/v1/orders/deposit', params);
+  };
+
+  const createWithdraw = async (params: ICreateWithdraw): Promise<void> => {
+    console.log('here', params)
+  };
+
+  return {
+    wallet,
+    program_wallets,
+    deposits,
+    withdraws,
+    methods,
+    agreements,
+    loadUserWalet,
+    createDeposit,
+    createWithdraw,
+  };
+});

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

@@ -0,0 +1,77 @@
+import { SovietContract, GatewayContract } from 'cooptypes';
+
+export type IProgramWalletData =
+  SovietContract.Tables.ProgramWallets.IProgramWallet;
+
+  export type ICoopProgramData =
+  SovietContract.Tables.Programs.IProgram;
+
+export type ExtendedProgramWalletData = IProgramWalletData & {
+  program_type: string;
+  program_details: ICoopProgramData; // | или другие типы будущих программ
+};
+
+export type IDepositData = GatewayContract.Tables.Deposits.IDeposits;
+export type IWithdrawData = GatewayContract.Tables.Withdraws.IWithdraws;
+export type IWalletData = SovietContract.Tables.Wallets.IWallets;
+
+export interface ILoadSingleUserWallet {
+  coopname: string;
+  username: string;
+}
+
+export interface ILoadSingleUserDeposit {
+  coopname: string;
+  username: string;
+  deposit_id: string | number;
+}
+
+export interface ILoadSingleUserWithdraw {
+  coopname: string;
+  username: string;
+  withdraw_id: string | number;
+}
+
+export interface ILoadSingleUserProgramWallet {
+  coopname: string;
+  username: string;
+  wallet_id: string | number;
+}
+
+export interface ILoadUserDeposits {
+  coopname: string;
+  username: string;
+}
+
+export interface ILoadUserWithdraws {
+  coopname: string;
+  username: string;
+}
+
+export interface ILoadUserProgramWallets {
+  coopname: string;
+  username: string;
+}
+
+export interface ILoadUserWallet {
+  coopname: string;
+  username: string;
+}
+
+export interface ICreateWithdraw {
+  quantity: string;
+}
+
+import { Cooperative } from 'cooptypes';
+
+export type IPaymentMethodData = Cooperative.Payments.IPaymentData
+export type IGetResponsePaymentMethodData = Cooperative.Document.IGetResponse<IPaymentMethodData>
+
+export interface IGetPaymentMethods {
+  username?: string
+}
+
+export interface IDeletePaymentMethod {
+  username: string;
+  method_id: number;
+}

package/src/entities/Wallet/ui/WalletBalance/WalletBalance.vue

@@ -0,0 +1,35 @@
+<script setup lang="ts">
+import { useWalletStore } from '../../model'
+const walletStore = useWalletStore()
+</script>
+
+<template lang="pug">
+q-list(flat).q-gutter-sm
+  q-item
+    q-item-section
+      q-item-label(caption) Имя аккаунта
+      q-item-label(style="font-size: 20px;").text-bold {{ walletStore.wallet.username }}
+
+  q-item
+    q-item-section
+      q-item-label(caption) Паевый счёт
+      q-item-label(style="font-size: 20px;").text-bold {{ walletStore.wallet.available }}
+
+  q-item
+    q-item-section
+      q-item-label(caption) Минимальный паевый счёт
+      q-item-label(style="font-size: 20px;").text-bold {{ walletStore.wallet.minimum }}
+
+  q-item
+    q-item-section
+      q-item-label(caption) Заблокировано в целевых программах
+      q-item-label(style="font-size: 20px;").text-bold {{ walletStore.wallet.blocked }}
+
+
+  q-item(v-for="program_wallet of walletStore.program_wallets" :key="program_wallet.id")
+    q-item-section
+      q-item-label(caption) {{ program_wallet.program_details.title }}
+
+      q-item-label(style="font-size: 20px;").text-bold {{program_wallet.available}}
+
+</template>

package/src/entities/Wallet/ui/WalletBalance/index.ts

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

package/src/entities/Wallet/ui/WalletProgramsList/WalletProgramsList.vue

@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import { useWalletStore } from '../../model'
+const walletStore = useWalletStore()
+</script>
+
+<template lang="pug">
+div.q-pa-md
+  q-list
+    q-item(v-for="program_wallet of walletStore.program_wallets" :key="program_wallet.id" v-ripple clickable)
+      q-item-section
+        q-item-label {{ program_wallet.program_details.title }}
+      q-item-section(side )
+        q-item-label(caption) {{program_wallet.available}}
+
+</template>

package/src/entities/Wallet/ui/WalletProgramsList/index.ts

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

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

@@ -0,0 +1,2 @@
+export * from './WalletBalance'
+export * from './WalletProgramsList'

package/src/env.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+
+declare namespace NodeJS {
+  interface ProcessEnv {
+    NODE_ENV: string;
+    VUE_ROUTER_MODE: 'hash' | 'history' | 'abstract' | undefined;
+    VUE_ROUTER_BASE: string | undefined;
+  }
+}
+
+declare global {
+  interface Window {
+    YooMoneyCheckoutWidget: any;
+    chatwootSDK: any;
+  }
+}
+
+import 'vue-router';
+
+declare module 'vue-router' {
+  // Расширяем интерфейс RouteMeta, добавляя новые свойства
+  interface RouteMeta {
+    roles?: string[];
+    agreements?: string[]
+    title: string
+    icon: string
+  }
+}

package/src/features/Agreementer/GenerateAgreement/index.ts

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

package/src/features/Agreementer/GenerateAgreement/model/index.ts

@@ -0,0 +1,24 @@
+import { useAgreementStore } from 'src/entities/Agreement'
+import { DigitalDocument } from 'src/shared/lib/document'
+
+export const useGenerateAgreement = () => {
+
+  const generateAgreement = async (coopname: string, username: string, registry_id: number) => {
+    const agreementStore = useAgreementStore()
+    const exist = agreementStore.generatedAgreements.find(agreement => agreement.meta.registry_id == registry_id)
+
+    if (!exist){
+      const agreement = await new DigitalDocument().generate({
+        registry_id,
+        coopname,
+        username
+      })
+
+      agreementStore.generatedAgreements.push(agreement)
+    }
+  }
+
+  return {
+    generateAgreement
+  }
+}

package/src/features/Agreementer/GenerateAgreement/ui/AgreementReader.vue

@@ -0,0 +1,37 @@
+<template lang="pug">
+div(v-if="agreement")
+  DocumentHtmlReader(:html="agreement.html")
+</template>
+
+<script setup lang="ts">
+  import { COOPNAME } from 'src/shared/config';
+  import { useGenerateAgreement } from '../model';
+  import { useSessionStore } from 'src/entities/Session';
+  import { computed, onMounted } from 'vue';
+  import { FailAlert } from 'src/shared/api';
+  import { DocumentHtmlReader } from 'src/shared/ui/DocumentHtmlReader';
+  import { useAgreementStore } from 'src/entities/Agreement';
+  import { SovietContract } from 'cooptypes';
+  const session = useSessionStore();
+
+  const { generateAgreement } = useGenerateAgreement();
+  const agreementer = useAgreementStore()
+
+  const agreement = computed(() => agreementer.generatedAgreements.find(el => el.meta.registry_id == props.agreement.draft_id))
+
+  const props = defineProps({
+    agreement: {
+      type: Object as () => SovietContract.Tables.CoopAgreements.ICoopAgreement,
+      required: true,
+    },
+  });
+
+  onMounted(async () => {
+    try {
+      await generateAgreement(COOPNAME, session.username, Number(props.agreement.draft_id));
+    } catch(e: any){
+      FailAlert(`Возникла ошибка при генерации соглашения, пожалуйста, обратитесь в поддержку с сообщением: ${e.message}`);
+    }
+
+  });
+  </script>

package/src/features/Agreementer/GenerateAgreement/ui/index.ts

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

package/src/features/Agreementer/ReadAgreementDialog/index.ts

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

package/src/features/Agreementer/ReadAgreementDialog/ui/ReadAgreementDialog.vue

@@ -0,0 +1,58 @@
+<template lang="pug">
+span(@click.stop='(event) => showDialog(event)' style="color: blue; text-decoration: underline;").q-ml-xs {{text}}
+  q-dialog(v-model="show" persistent :maximized="true" )
+    ModalBase(title="" :show_close="true")
+      div.row.justify-center
+        div(style="padding-bottom: 100px;").col-md-8.col-col-xs-12
+          Loader(v-if="isLoading" :text='`Загружаем документ...`')
+          Form(:handler-submit="ok" :is-submitting="isSubmitting" :showSubmit="!isLoading" :showCancel="!isLoading" button-cancel-text="Отменить" button-submit-txt="Подтвердить" @cancel="clear").q-pa-md
+            slot
+
+</template>
+<script setup lang="ts">
+import { computed, ref } from 'vue';
+import { ModalBase } from 'src/shared/ui/ModalBase';
+import { Loader } from 'src/shared/ui/Loader';
+import { Form } from 'src/shared/ui/Form';
+import { SovietContract } from 'cooptypes';
+import { useAgreementStore } from 'src/entities/Agreement';
+
+const isLoading = computed(() => agreementOnSign.value ? false : true)
+const agreementStore = useAgreementStore()
+const agreementOnSign = computed(() => agreementStore.generatedAgreements.find(el => el.meta.registry_id == props.agreement.draft_id))
+const emit = defineEmits(['update:agree'])
+
+const show = ref(false)
+const isSubmitting = ref(false)
+
+const ok = async() => {
+  emit('update:agree', true)
+  show.value = false
+}
+const clear = () => {
+  emit('update:agree', false)
+  show.value = false
+}
+
+const props = defineProps({
+  agreement: {
+    type: Object as () => SovietContract.Tables.CoopAgreements.ICoopAgreement,
+    required: true,
+  },
+  agree: {
+    type: Boolean,
+    required: true,
+  },
+  text: {
+    type: String,
+    required: true
+  }
+})
+
+const showDialog = (event) => {
+  event.stopPropagation()
+  console.log('props: ', props)
+  show.value = true
+}
+
+</script>

package/src/features/Agreementer/ReadAgreementDialog/ui/index.ts

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

package/src/features/Agreementer/SignAgreementDialog/api/index.ts

@@ -0,0 +1,26 @@
+import { TransactResult } from '@wharfkit/session';
+import { transact } from 'src/shared/api';
+import { SovietContract } from 'cooptypes';
+
+async function sendAgreement(
+  data: SovietContract.Actions.Agreements.SendAgreement.ISendAgreement
+): Promise<TransactResult | undefined> {
+
+  return await transact(
+    {
+      account: SovietContract.contractName.production,
+      name: SovietContract.Actions.Agreements.SendAgreement.actionName,
+      authorization: [
+        {
+          actor: data.username,
+          permission: 'active',
+        },
+      ],
+      data
+    },
+   );
+}
+
+export const api = {
+  sendAgreement,
+}

package/src/features/Agreementer/SignAgreementDialog/index.ts

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

package/src/features/Agreementer/SignAgreementDialog/model/index.ts

@@ -0,0 +1,27 @@
+import { DigitalDocument, type IGeneratedDocument } from 'src/shared/lib/document';
+import { api } from '../api';
+import { COOPNAME } from 'src/shared/config';
+
+export const useSignAgreement = () => {
+
+  const signAgreement = async(username: string, agreement_type: string, agreement: IGeneratedDocument) => {
+    const document = new DigitalDocument(agreement);
+    await document.sign();
+
+    if (!document.signedDocument)
+      throw new Error('Ошибка подписи документа')
+
+
+    await api.sendAgreement({
+      coopname: COOPNAME,
+      administrator: COOPNAME,
+      username,
+      agreement_type,
+      document: {...document.signedDocument, meta: JSON.stringify(document.signedDocument.meta)}
+    })
+  }
+
+  return {
+    signAgreement
+  }
+}