@coopenomics/desktop 2.2.2

package/src/features/User/AddUser/ui/AddUserDialog/AddUserDialog.vue

@@ -0,0 +1,232 @@
+<template lang="pug">
+div
+  q-btn(size="sm" @click="showAdd = true" color="primary")
+    q-icon(name="add")
+    span добавить пайщика
+  q-dialog(v-model="showAdd" persistent :maximized="false" )
+    q-card
+      div()
+        q-bar.bg-gradient-dark.text-white
+          span Добавить пайщика
+          q-space
+          q-btn(v-close-popup dense flat icon="close")
+            q-tooltip Закрыть
+
+        div.q-pa-sm.row.justify-center
+          div.q-pa-md
+            div.q-pb-md
+              span Внимание! Вы собираетесь добавить действующего пайщика в реестр цифрового кооператива. Пайщик получит приглашение на электронную почту и сможет сразу использовать систему без заполнения заявления на вступление и оплаты вступительного взноса, т.к. он сделал это ранее вне цифровой системы.
+
+            UserDataForm(v-model:userData="state.userData")
+              template(#top)
+                q-input(@change="changeEmail" v-model="state.email" standout="bg-teal text-white" label="Электронная почта" :rules='[validateEmail, validateExists]').q-mb-md
+
+              template(#bottom="{userDataForm}")
+
+                q-input(
+                  standout="bg-teal text-white"
+                  v-model="addUserState.created_at"
+                  mask="datetime"
+                  label="Дата и время подписания заявления"
+                  placeholder="год/месяц/день часы:минуты"
+                  :rules="[val => notEmpty(val)]"
+                  autocomplete="off"
+                  hint="когда пайщик был принят в кооператив"
+                ).q-mt-md
+
+                q-input(
+                  standout="bg-teal text-white"
+                  v-model="initial"
+                  type="number"
+                  :min="0"
+                  label="Размер вступительного взноса"
+                  :rules="[val => moreThenZero(val)]"
+                  hint="был оплачен пайщиком при вступлении"
+                  ).q-mt-md
+                  template(#append)
+                    span.text-overline {{ coop.governSymbol }}
+                    q-btn(icon="sync" flat dense @click="refresh('initial')")
+
+                q-input(standout="bg-teal text-white" v-model="minimum" hint="был оплачен пайщиком при вступлении" type="number" label="Размер минимального паевого взноса" :rules="[val => moreThenZero(val)]").q-mt-md
+                  template(#append)
+                    span.text-overline {{ coop.governSymbol }}
+                    q-btn(icon="sync" flat dense @click="refresh('minimum')")
+
+                q-card(flat).q-mt-md
+
+                  q-item(tag="label" v-ripple)
+                    q-item-section(avatar)
+                      q-checkbox(v-model="addUserState.spread_initial")
+
+                    q-item-section
+                      q-item-label Начислить вступительный взнос
+                      q-item-label(caption) Вступительный взнос будет зачислен на счёт кошелька кооператива и станет доступен для списания по фонду хозяйственной деятельности.
+
+
+                q-card(flat).q-mt-md
+
+                  q-item(tag="label" v-ripple)
+                    q-item-section(avatar)
+                      q-checkbox(v-model="spread_minimum" disable )
+
+                    q-item-section
+                      q-item-label Начислить минимальный паевый взнос
+                      q-item-label(caption) Минимальный паевый взнос будет зачислен на оборотный счет кооператива и учитываться в процессе возврата при выходе пайщика из кооператива.
+
+
+
+                div.q-mt-lg
+                  q-btn(flat @click="showAdd = false") Отмена
+                  q-btn(color="primary" @click="addUserNow(userDataForm)" :loading="loading") Добавить
+
+
+</template>
+<script setup lang="ts">
+/**
+ * 1. При первой загрузке показываем системные параметры взносов.
+ * 2. Если параметр изменяется вручную, сохраняем его локально для организации или физлица/ип отдельно.
+ * 3. Кнопка сброса возвращает системные параметры взносов.
+ */
+import { computed, onMounted, ref, watch } from 'vue';
+import { UserDataForm } from 'src/shared/ui/UserDataForm/UserDataForm';
+import { useAddUser } from '../../model';
+import { useCooperativeStore } from 'src/entities/Cooperative';
+
+import { useRegistratorStore } from 'src/entities/Registrator';
+import { FailAlert, SuccessAlert } from 'src/shared/api';
+import { useCreateUser } from 'src/features/User/CreateUser';
+import { COOPNAME } from 'src/shared/config';
+import { notEmpty } from 'src/shared/lib/utils';
+
+const { state, addUserState, clearUserData } = useRegistratorStore()
+const spread_minimum = ref(true) //TODO REPLACE IT!
+const minimum = ref(0)
+const initial = ref(0)
+
+watch(initial, (newValue) => {
+  if (state.userData.type === 'organization')
+    addUserState.org_initial = Number(newValue)
+  else addUserState.initial = Number(newValue)
+})
+
+watch(minimum, (newValue) => {
+  if (state.userData.type === 'organization')
+    addUserState.org_minimum = Number(newValue)
+  else addUserState.minimum = Number(newValue)
+})
+
+const { addUser } = useAddUser()
+const api = useCreateUser()
+
+const coop = useCooperativeStore()
+
+onMounted(async () => {
+
+  await coop.loadPublicCooperativeData(COOPNAME)
+
+  if (coop.publicCooperativeData) {
+
+    if (addUserState.initial == 0)
+      addUserState.initial = parseFloat(coop.publicCooperativeData.initial)
+
+    if (addUserState.minimum == 0)
+      addUserState.minimum = parseFloat(coop.publicCooperativeData.minimum)
+
+    if (addUserState.org_initial == 0)
+      addUserState.org_initial = parseFloat(coop.publicCooperativeData.org_initial)
+
+    if (addUserState.org_minimum == 0)
+      addUserState.org_minimum = parseFloat(coop.publicCooperativeData.org_minimum)
+
+    updateLocalVars()
+  }
+
+})
+
+const updateLocalVars = () => {
+  if (state.userData.type === 'organization') {
+    initial.value = addUserState.org_initial
+    minimum.value = addUserState.org_minimum
+  } else {
+    initial.value = addUserState.initial
+    minimum.value = addUserState.minimum
+  }
+}
+
+watch(() => state.userData.type, () => {
+  updateLocalVars()
+})
+
+const refresh = (what: string) => {
+  if (coop.publicCooperativeData)
+    if (state.userData.type === 'organization') {
+      if (what === 'initial')
+        addUserState.org_initial = parseFloat(coop.publicCooperativeData.org_initial)
+      else
+        addUserState.org_minimum = parseFloat(coop.publicCooperativeData.org_minimum)
+    } else {
+      if (what === 'initial')
+        addUserState.initial = parseFloat(coop.publicCooperativeData.initial)
+      else
+        addUserState.minimum = parseFloat(coop.publicCooperativeData.minimum)
+    }
+
+  updateLocalVars()
+}
+
+const isValidEmail = computed(() => api.emailIsValid(state.email))
+
+const isEmailExist = ref(false)
+
+const validateEmail = () => {
+  return isValidEmail.value || 'Введите корректный email'
+}
+
+const validateExists = () => {
+  return !isEmailExist.value || 'Пользователь с таким email уже существует. Войдите.'
+}
+
+const changeEmail = () => {
+  if (state.userData.individual_data)
+    state.userData.individual_data.email = state.email
+  if (state.userData.organization_data)
+    state.userData.organization_data.email = state.email
+  if (state.userData.entrepreneur_data)
+    state.userData.entrepreneur_data.email = state.email
+}
+
+const showAdd = ref(false)
+const loading = ref(false)
+
+const addUserNow = (userDataForm: any) => {
+  userDataForm.validate().then(async (success: boolean) => {
+    if (success) {
+      try {
+        loading.value = true
+        await addUser()
+        SuccessAlert('Пайщик добавлен в реестр, а приглашение отправлено на его email');
+        showAdd.value = false
+        addUserState.created_at = ''
+        clearUserData()
+        loading.value = false
+      } catch (e: any) {
+        loading.value = false
+        FailAlert(`Возникла ошибка: ${e.message}`)
+      }
+
+    } else {
+      const firstInvalid = document.querySelector('.q-field--error .q-field__native');
+      if (firstInvalid) {
+        firstInvalid.scrollIntoView({ behavior: 'smooth', block: 'center' });
+      }
+      return;
+    }
+  })
+
+}
+
+const moreThenZero = (val: number) => {
+  return val > 0 || 'Взнос должен быть положительным'
+}
+
+</script>

package/src/features/User/AddUser/ui/AddUserDialog/index.ts

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

package/src/features/User/AddUser/ui/index.ts

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

package/src/features/User/CreateUser/api/index.ts

@@ -0,0 +1,65 @@
+import { PrivateKey } from '@wharfkit/antelope';
+import {
+  ICreatedUser,
+  IKeyPair,
+  ISendStatement,
+} from 'src/shared/lib/types/user';
+import { sendPOST } from 'src/shared/api';
+import { ICreateUser } from '../model';
+import type { ICreatedPayment } from '@coopenomics/controller';
+
+async function createUser(data: ICreateUser): Promise<ICreatedUser> {
+  const response = await sendPOST('/v1/users', data, true);
+
+  return response;
+}
+
+async function sendStatement(data: ISendStatement): Promise<void> {
+  await sendPOST('/v1/participants/join-cooperative', data);
+}
+
+async function emailIsExist(email: string): Promise<boolean> {
+  //TODO verify email exists on backend
+  console.log('check email before: ', email);
+  return false;
+}
+
+function generateKeys(): IKeyPair {
+  const private_key_data = PrivateKey.generate('K1');
+  const public_key = private_key_data.toPublic().toString();
+  const private_key = private_key_data.toWif();
+
+  return {
+    private_key,
+    public_key,
+  } as IKeyPair;
+}
+
+const generateUsername = (): string => {
+  let result = '';
+
+  const possible = 'abcdefghijklmnopqrstuvwxyz';
+  for (let i = 0; i < 12; i++)
+    result += possible.charAt(Math.floor(Math.random() * possible.length));
+
+  //TODO check for not exist in blockchain
+
+  return result;
+};
+
+
+async function createInitialPaymentOrder(
+): Promise<ICreatedPayment> {
+  const response = await sendPOST('/v1/orders/initial', {});
+  return response;
+}
+
+
+export const api = {
+  createUser,
+  emailIsExist,
+  generateUsername,
+  generateKeys,
+  sendStatement,
+  createInitialPaymentOrder
+};

package/src/features/User/CreateUser/index.ts

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

package/src/features/User/CreateUser/model/index.ts

@@ -0,0 +1,237 @@
+import { api } from '../api';
+import emailRegex from 'email-regex';
+const emailValidator = emailRegex({ exact: true });
+
+import { IGeneratedAccount, ISendStatement } from 'src/shared/lib/types/user';
+
+import { useSessionStore } from 'src/entities/Session';
+import { useGlobalStore } from 'src/shared/store';
+import { COOPNAME } from 'src/shared/config';
+import { DigitalDocument } from 'src/shared/lib/document';
+import { IObjectedDocument } from 'src/shared/lib/types/document';
+import {
+  ICreatedPayment,
+} from 'src/shared/lib/types/payments';
+import {
+  useCurrentUserStore,
+} from 'src/entities/User';
+import { useRegistratorStore } from 'src/entities/Registrator'
+import { IEntrepreneurData, IIndividualData, IOrganizationData, IUserData } from 'src/shared/lib/types/user/IUserData';
+import { Cooperative } from 'cooptypes';
+
+export interface ICreateUser {
+  email: string;
+  entrepreneur_data?: IEntrepreneurData;
+  individual_data?: IIndividualData;
+  organization_data?: IOrganizationData;
+  public_key: string;
+  referer?: string;
+  role: 'user';
+  type: 'individual' | 'entrepreneur' | 'organization';
+  username: string;
+}
+
+export function useCreateUser() {
+  const store = useRegistratorStore().state
+
+  async function createInitialPayment(): Promise<ICreatedPayment> {
+    const result = await api.createInitialPaymentOrder();
+    store.payment = result;
+
+    return result;
+  }
+
+  async function sendStatementAndAgreements(): Promise<void> {
+    const data: ISendStatement = {
+      username: store.account.username,
+      statement: store.statement,
+      wallet_agreement: store.walletAgreement,
+      privacy_agreement: store.privacyAgreement,
+      signature_agreement: store.signatureAgreement,
+      user_agreement: store.userAgreement
+    };
+
+    await api.sendStatement(data);
+  }
+
+
+  async function signStatement(): Promise<IObjectedDocument> {
+    const data: Cooperative.Registry.ParticipantApplication.Action = {
+      registry_id: Cooperative.Registry.ParticipantApplication.registry_id,
+      signature: store.signature,
+      skip_save: false,
+      coopname: COOPNAME,
+      username: store.account.username,
+      braname: store.selectedBranch,
+      links: [store.walletAgreement.hash, store.privacyAgreement.hash, store.signatureAgreement.hash, store.userAgreement.hash]
+    }
+
+    const document = await new DigitalDocument().generate<Cooperative.Registry.ParticipantApplication.Action>(data);
+    const globalStore = useGlobalStore();
+    const digital_signature = await globalStore.signDigest(document.hash);
+
+    store.statement = {
+      hash: document.hash,
+      meta: document.meta,
+      public_key: digital_signature.public_key,
+      signature: digital_signature.signature,
+    } as IObjectedDocument;
+
+    return store.statement;
+  }
+
+  async function signPrivacyAgreement(): Promise<IObjectedDocument> {
+    const data: Cooperative.Registry.PrivacyPolicy.Action= {
+      registry_id: Cooperative.Registry.PrivacyPolicy.registry_id,
+      coopname: COOPNAME,
+      username: store.account.username,
+    };
+
+    const document = new DigitalDocument();
+    await document.generate(data);
+    await document.sign();
+
+    store.privacyAgreement = document.signedDocument as IObjectedDocument;
+
+    return store.privacyAgreement;
+  }
+
+  async function signSignatureAgreement(): Promise<IObjectedDocument> {
+    const data: Cooperative.Registry.RegulationElectronicSignature.Action= {
+      registry_id: Cooperative.Registry.RegulationElectronicSignature.registry_id,
+      coopname: COOPNAME,
+      username: store.account.username,
+    };
+
+    const document = new DigitalDocument();
+    await document.generate(data);
+    await document.sign();
+
+    store.signatureAgreement = document.signedDocument as IObjectedDocument;
+
+    return store.signatureAgreement;
+  }
+
+
+  async function signUserAgreement(): Promise<IObjectedDocument> {
+    const data: Cooperative.Registry.UserAgreement.Action= {
+      registry_id: Cooperative.Registry.UserAgreement.registry_id,
+      coopname: COOPNAME,
+      username: store.account.username,
+    };
+
+    const document = new DigitalDocument();
+    await document.generate(data);
+    await document.sign();
+
+    store.userAgreement = document.signedDocument as IObjectedDocument;
+
+    return store.userAgreement;
+  }
+
+
+
+
+  async function signWalletAgreement(): Promise<IObjectedDocument> {
+    const data: Cooperative.Registry.WalletAgreement.Action= {
+      registry_id: Cooperative.Registry.WalletAgreement.registry_id,
+      coopname: COOPNAME,
+      username: store.account.username,
+    };
+
+    const document = new DigitalDocument();
+    await document.generate(data);
+    await document.sign();
+
+    store.walletAgreement = document.signedDocument as IObjectedDocument;
+
+    console.log('walletAgreement: ', store.walletAgreement)
+
+    return store.walletAgreement;
+  }
+
+
+  async function generateStatementWithoutSignature() {
+
+    const document = await new DigitalDocument().generate<Cooperative.Registry.ParticipantApplication.Action>({
+      signature: '',
+      skip_save: true,
+      coopname: COOPNAME,
+      username: store.account.username,
+      braname: store.selectedBranch,
+      registry_id: Cooperative.Registry.ParticipantApplication.registry_id
+  });
+
+    return document;
+  }
+
+  async function createUser(
+    email: string,
+    userData: IUserData,
+    account: IGeneratedAccount
+  ): Promise<void> {
+
+    const synthData = { type: userData.type } as any;
+
+    if (synthData.type === 'individual') {
+      synthData.individual_data = userData.individual_data;
+    } else if (synthData.type === 'organization') {
+      synthData.organization_data = userData.organization_data;
+    } else if (synthData.type === 'entrepreneur') {
+      synthData.entrepreneur_data = userData.entrepreneur_data;
+    }
+    const data: ICreateUser = {
+      ...synthData,
+      role: 'user',
+      email,
+      username: account.username,
+      public_key: account.public_key,
+    };
+
+    const { user, tokens } = await api.createUser(data);
+
+    const globalStore = useGlobalStore();
+    const sessionStore = useSessionStore();
+
+    await globalStore.setTokens(tokens);
+    await globalStore.setWif(user.username, account.private_key);
+
+    await sessionStore.init();
+
+    const currentUser = useCurrentUserStore();
+    await currentUser.loadProfile(user.username, COOPNAME);
+  }
+
+  function emailIsValid(email: string): boolean {
+    return emailValidator.test(email);
+  }
+
+  async function emailIsExist(email: string): Promise<boolean> {
+    return await api.emailIsExist(email);
+  }
+
+  function generateAccount(): IGeneratedAccount {
+    const keyPair = api.generateKeys();
+    const username = api.generateUsername();
+
+    return {
+      username,
+      ...keyPair,
+    };
+  }
+
+  return {
+    emailIsValid,
+    emailIsExist,
+    generateAccount,
+    createUser,
+    generateStatementWithoutSignature,
+    signStatement,
+    sendStatementAndAgreements,
+    createInitialPayment,
+    signWalletAgreement,
+    signPrivacyAgreement,
+    signUserAgreement,
+    signSignatureAgreement
+  };
+}

package/src/features/User/LoginUser/api/index.ts

@@ -0,0 +1,20 @@
+import { Bytes, Checksum256, PrivateKey } from '@wharfkit/session';
+import { getBlockchainInfo, sendPOST } from 'src/shared/api';
+import { ICreatedUser } from 'src/shared/lib/types/user';
+
+
+async function loginUser(email: string, wif: string): Promise<ICreatedUser> {
+  const now = (await getBlockchainInfo()).head_block_time.toString()
+
+  const privateKey = PrivateKey.fromString(wif)
+  const bytes = Bytes.fromString(now, 'utf8')
+  const checksum = Checksum256.hash(bytes)
+  const signature = privateKey.signDigest(checksum)
+  const response = await sendPOST('/v1/auth/login', {email, now, signature}, true);
+;
+  return response;
+}
+
+export const api = {
+  loginUser,
+};

package/src/features/User/LoginUser/index.ts

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

package/src/features/User/LoginUser/model/index.ts

@@ -0,0 +1,69 @@
+import { useSessionStore } from 'src/entities/Session'
+import { useGlobalStore } from 'src/shared/store'
+import { api } from '../api'
+import {client} from 'src/shared/api/client'
+import { useCurrentUserStore } from 'src/entities/User'
+import { useSystemStore } from 'src/entities/System/model'
+import { useRegistratorStore } from 'src/entities/Registrator'
+
+export function useLoginUser() {
+  const globalStore = useGlobalStore()
+  const currentUser = useCurrentUserStore()
+  const system = useSystemStore()
+
+  async function login(email: string, wif: string): Promise<void> {
+    const auth = await api.loginUser(email, wif)
+
+    await globalStore.setWif(auth.user.username, wif)
+    await globalStore.setTokens(auth.tokens)
+
+    const session = useSessionStore()
+    await session.init()
+    client.setToken(auth.tokens.access.token)
+
+    await currentUser.loadProfile(globalStore.username, system.info.coopname)
+
+    if (!currentUser.isRegistrationComplete){
+      const {state, steps} = useRegistratorStore()
+      state.userData.type = currentUser.userAccount?.type as 'individual' | 'entrepreneur' | 'organization'
+      const privateData = currentUser.userAccount?.private_data || {};
+
+      // Для каждого типа пользователя берём нужное поле и, если оно существует, переносим совпадающие ключи
+      const dataMap: Record<string, any> = {
+        individual: state.userData.individual_data,
+        organization: state.userData.organization_data,
+        entrepreneur: state.userData.entrepreneur_data
+      };
+
+      const data = dataMap[state.userData.type];
+      if (data) {
+        for (const key of Object.keys(privateData)) {
+          if (key in data) {
+            data[key] = privateData[key];
+          }
+        }
+      }
+
+      //continue registration process here
+      state.account.username = currentUser.userAccount?.username as string
+      state.account.private_key = wif
+      state.account.public_key = currentUser.userAccount?.public_key as string
+
+      state.email = currentUser.userAccount?.email as string
+
+      if (currentUser.userAccount?.status === 'created')
+        state.step = steps.ReadStatement
+      else if (currentUser.userAccount?.status === 'joined')
+        state.step = steps.PayInitial
+      else if (currentUser.userAccount?.status === 'payed')
+        state.step = steps.WaitingRegistration
+      else if (currentUser.userAccount?.status === 'registered')
+        state.step = steps.Welcome
+    }
+
+  }
+
+  return {
+    login,
+  }
+}