@coopenomics/desktop 2.2.2

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

@@ -0,0 +1,57 @@
+import { MarketContract } from 'cooptypes';
+
+type Request = MarketContract.Tables.Requests.IRequest;
+
+export interface IRequestObjectData {
+  title: string;
+  description: string;
+  preview: string;
+  images: Array<string>;
+}
+
+export interface IRequestData
+  extends Omit<Request, 'data' | 'created_at' | 'expired_at'> {
+  data: IRequestObjectData;
+  created_at: Date;
+  expired_at: Date;
+}
+
+export interface IUpdateOneRequest {
+  coopname: string;
+  request_id: string | number;
+}
+
+export interface ILoadAllRequests {
+  coopname: string;
+}
+
+export interface ILoadAllParentOffers {
+  coopname: string;
+}
+
+export interface ILoadAllChildOrders {
+  coopname: string;
+}
+
+export interface ILoadUserParentOffers {
+  coopname: string;
+  username: string;
+}
+
+export interface ILoadUserChildOrders {
+  coopname: string;
+  username: string;
+}
+
+enum ClearList {
+  /** Список типов для очищения заявок в маркетплейсе */
+  allRequests = 'allRequests',
+  allParentOffers = 'allParentOffers',
+  allChildOrders = 'allChildOrders',
+  userParentOffers = 'userParentOffers',
+  userChildOrders = 'userChildOrders',
+}
+
+export interface IClearRequests {
+  target: ClearList;
+}

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

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

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

@@ -0,0 +1,21 @@
+import { sendPOST } from 'src/shared/api';
+import { ICreatedUser } from 'src/shared/lib/types/user';
+import { hashSHA256 } from 'src/shared/api/crypto';
+
+async function loginUser(username: string, wif: string): Promise<ICreatedUser> {
+  const password = await hashSHA256(wif);
+
+  const data = {
+    username,
+    password,
+  };
+
+  const response = await sendPOST('/v1/auth/login', data, true);
+
+  console.log('response: ', response);
+  return response;
+}
+
+export const api = {
+  loginUser,
+};

package/src/entities/Session/index.ts

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

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

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

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

@@ -0,0 +1,100 @@
+import { defineStore } from 'pinia';
+import { useGlobalStore } from 'src/shared/store';
+import { computed, ComputedRef, Ref, ref } from 'vue';
+import { Session } from '@wharfkit/session';
+import { WalletPluginPrivateKey } from '@wharfkit/wallet-plugin-privatekey';
+import { FailAlert, readBlockchain } from 'src/shared/api';
+import { CHAIN_ID, CHAIN_URL } from 'src/shared/config';
+import { PrivateKey, Serializer } from '@wharfkit/antelope';
+import { GetInfoResult } from 'eosjs/dist/eosjs-rpc-interfaces';
+
+interface ISessionStore {
+  isAuth: Ref<boolean>;
+  username: ComputedRef<string>;
+  init: () => Promise<void>;
+  //TODO add Blockchain Session here
+  session: Ref<Session | undefined>;
+  close: () => Promise<void>;
+  BCInfo: Ref<{
+    connected: boolean;
+    info: GetInfoResult | undefined;
+  }>;
+  getInfo: () => Promise<void>;
+  loadComplete: Ref<boolean>;
+}
+
+export const useSessionStore = defineStore('session', (): ISessionStore => {
+  const globalStore = useGlobalStore();
+  const isAuth = ref(false);
+  const loadComplete = ref(false);
+
+  const session = ref();
+  const BCInfo = ref<{
+    connected: boolean;
+    info: GetInfoResult | undefined;
+  }>({ connected: false, info: undefined });
+
+  const getInfo = async () => {
+    try {
+      const info = await readBlockchain.v1.chain.get_info();
+      if (info) {
+        BCInfo.value.info = Serializer.objectify(info);
+        BCInfo.value.connected = true;
+      }
+    } catch (e) {
+      BCInfo.value = { connected: false, info: undefined };
+    }
+  };
+
+  const close = async (): Promise<void> => {
+    isAuth.value = false;
+    session.value = undefined;
+  };
+
+  const init = async () => {
+    if (!globalStore.hasCreditials){
+
+      await globalStore.init();
+      isAuth.value = globalStore.hasCreditials;
+
+      //TODO добавить более детальную проверку авторизации
+
+      getInfo();
+
+      try {
+
+        if (globalStore.hasCreditials){
+
+          session.value = new Session({
+            actor: globalStore.username,
+            permission: 'active',
+            chain: {
+              id: CHAIN_ID,
+              url: CHAIN_URL,
+            },
+            walletPlugin: new WalletPluginPrivateKey(
+              globalStore.wif as PrivateKey
+            ),
+          });
+        }
+      } catch (e: any) {
+        console.error(e);
+        FailAlert(e.message);
+        //TODO logout
+      }
+    }
+  };
+
+  const username = computed(() => globalStore.username);
+
+  return {
+    isAuth,
+    init,
+    session,
+    BCInfo,
+    username,
+    close,
+    getInfo,
+    loadComplete
+  };
+});

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

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

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

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

package/src/entities/Settings/index.ts

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

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

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

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

@@ -0,0 +1,24 @@
+import { defineStore } from 'pinia';
+import { api } from '../api'
+import { ref, type Ref } from 'vue';
+import type { ISettings } from '@coopenomics/controller';
+
+const namespace = 'settings';
+
+interface ISettingsStore {
+  settings: Ref<ISettings | null>
+  loadSettings: () => Promise<void>;
+}
+
+export const useSettingsStore = defineStore(namespace, (): ISettingsStore => {
+  const settings = ref<ISettings | null>(null)
+
+  const loadSettings = async () => {
+    settings.value = await api.loadSettings()
+  }
+
+  return {
+    settings,
+    loadSettings
+  };
+});

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

@@ -0,0 +1,12 @@
+import { client } from 'src/shared/api/client';
+import { Queries } from '@coopenomics/sdk';
+import type { ISystemInfo } from '../types';
+
+async function loadSystemInfo(): Promise<ISystemInfo> {
+  const { [Queries.System.GetSystemInfo.name]: output } = await client.Query(Queries.System.GetSystemInfo.query);
+  return output;
+}
+
+export const api ={
+  loadSystemInfo
+}

package/src/entities/System/index.ts

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

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

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

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

@@ -0,0 +1,24 @@
+import { defineStore } from 'pinia'
+import { ref, Ref } from 'vue'
+import { api } from '../api'
+import type { ISystemInfo } from '../types';
+
+const namespace = 'systemStore';
+
+interface ISystemStore {
+  info: Ref<ISystemInfo>
+  loadSystemInfo: () => Promise<void>;
+}
+
+export const useSystemStore = defineStore(namespace, (): ISystemStore => {
+  const info = ref<ISystemInfo>({} as ISystemInfo)
+
+  const loadSystemInfo = async () => {
+    info.value = await api.loadSystemInfo();
+  };
+
+  return {
+    info,
+    loadSystemInfo
+  }
+})

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

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

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

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

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

@@ -0,0 +1,19 @@
+import { RegistratorContract } from 'cooptypes'
+import { defineStore } from 'pinia'
+
+const namespace = 'union'
+
+export const useUnionStore = defineStore(
+  namespace,
+  () => {
+
+    const coops = [] as RegistratorContract.Tables.Cooperatives.ICooperative[]
+
+    return {
+      coops
+    }
+  },
+  {
+    persist: false
+  }
+  )

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

@@ -0,0 +1,75 @@
+import { fetchTable, getAccountInfo, sendGET } from 'src/shared/api';
+import {
+  IBlockchainAccountResult,
+  ICopenomicsAccount,
+  IUserAccountData,
+} from '../model';
+import { RegistratorContract, SovietContract } from 'cooptypes';
+import { LimitsList } from 'src/shared/config';
+
+async function loadBlockchainAccount(
+  username: string
+): Promise<IBlockchainAccountResult> {
+  const account = (await getAccountInfo(username)) as IBlockchainAccountResult;
+  return account;
+}
+
+async function loadCopenomicsAccount(
+  username: string
+): Promise<ICopenomicsAccount> {
+  const organization = (
+    await fetchTable(
+      RegistratorContract.contractName.production,
+      RegistratorContract.contractName.production,
+      RegistratorContract.Tables.Cooperatives.tableName,
+      username,
+      username,
+      LimitsList.One
+    )
+  )[0] as RegistratorContract.Tables.Cooperatives.ICooperative;
+
+  const account = (
+    await fetchTable(
+      RegistratorContract.contractName.production,
+      RegistratorContract.contractName.production,
+      RegistratorContract.Tables.Accounts.tableName,
+      username,
+      username,
+      LimitsList.One
+    )
+  )[0] as RegistratorContract.Tables.Accounts.IAccount;
+
+  return {
+    ...organization,
+    ...account,
+  };
+}
+
+async function loadParticipantAccount(
+  username: string,
+  coopname: string
+): Promise<SovietContract.Tables.Participants.IParticipants> {
+  const participant = (
+    await fetchTable(
+      SovietContract.contractName.production,
+      coopname,
+      SovietContract.Tables.Participants.tableName,
+      username,
+      username,
+      LimitsList.One
+    )
+  )[0] as SovietContract.Tables.Participants.IParticipants;
+  return participant;
+}
+
+async function loadUserAccount(username: string): Promise<IUserAccountData> {
+  const user = (await sendGET('/v1/users/' + username, {})) as IUserAccountData;
+  return user;
+}
+
+export const api = {
+  loadBlockchainAccount,
+  loadCopenomicsAccount,
+  loadParticipantAccount,
+  loadUserAccount,
+};

package/src/entities/User/index.ts

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

package/src/entities/User/model/entity.ts

@@ -0,0 +1,47 @@
+// UserEntity.ts
+import {
+  IUserAccountData,
+  IBlockchainAccountResult,
+  ICopenomicsAccount,
+} from './types';
+import { Ref, ref } from 'vue';
+import { api } from '../api';
+import { SovietContract } from 'cooptypes';
+
+export class UserEntity {
+  username: Ref<string> = ref('');
+
+  blockchainAccount = ref<IBlockchainAccountResult | null>(null);
+  copenomicsAccount = ref<ICopenomicsAccount | null>(null);
+  participantAccount =
+    ref<SovietContract.Tables.Participants.IParticipants | null>(null);
+  userAccount = ref<IUserAccountData | null>(null);
+
+  async loadProfile(username: string, coopname: string): Promise<void> {
+    this.username.value = username;
+    await this.loadPrivateProfile(username);
+
+    if (this.userAccount.value?.is_registered)
+      await this.loadPublicProfile(username, coopname);
+  }
+
+  async loadPublicProfile(username: string, coopname: string): Promise<void> {
+    this.blockchainAccount.value = await api.loadBlockchainAccount(username);
+    this.copenomicsAccount.value = await api.loadCopenomicsAccount(username);
+    this.participantAccount.value = await api.loadParticipantAccount(
+      username,
+      coopname
+    );
+  }
+
+  async loadPrivateProfile(username: string): Promise<void> {
+    this.userAccount.value = await api.loadUserAccount(username);
+  }
+
+  clearAccount(): void {
+    this.blockchainAccount.value = null;
+    this.copenomicsAccount.value = null;
+    this.userAccount.value = null;
+    this.participantAccount.value = null;
+  }
+}

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

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

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

@@ -0,0 +1,49 @@
+// stores.ts
+import { SovietContract } from 'cooptypes';
+import { defineStore } from 'pinia';
+import { computed, ComputedRef, Ref } from 'vue';
+import { UserEntity } from './entity';
+import {
+  IBlockchainAccountResult,
+  ICopenomicsAccount,
+  IUserAccountData,
+} from './types';
+
+interface IUserStore {
+  //методы
+  loadProfile(username: string, coopname: string): Promise<void>;
+  clearAccount: () => void;
+  //данные
+  username: Ref<string>;
+  blockchainAccount: Ref<IBlockchainAccountResult | null>;
+  copenomicsAccount: Ref<ICopenomicsAccount | null>;
+  participantAccount: Ref<SovietContract.Tables.Participants.IParticipants | null>;
+  userAccount: Ref<IUserAccountData | null>;
+  isRegistrationComplete: ComputedRef<boolean>;
+  isChairman: ComputedRef<boolean>;
+}
+
+const namespaceCurrentUser = 'currentUser';
+export const useCurrentUserStore = defineStore(
+  namespaceCurrentUser,
+  (): IUserStore => {
+    const userEntity = new UserEntity();
+
+    return {
+      username: userEntity.username,
+      clearAccount: () => userEntity.clearAccount(),
+      loadProfile: (username: string, coopname: string) =>
+        userEntity.loadProfile(username, coopname),
+      blockchainAccount: userEntity.blockchainAccount,
+      copenomicsAccount: userEntity.copenomicsAccount,
+      userAccount: userEntity.userAccount,
+      participantAccount: userEntity.participantAccount,
+      isRegistrationComplete: computed(
+        () =>
+          (userEntity.userAccount.value || false) &&
+          userEntity.participantAccount.value != null
+      ),
+      isChairman: computed(() => userEntity.userAccount.value?.role === 'chairman')
+    };
+  }
+);

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

@@ -0,0 +1,36 @@
+import { RegistratorContract } from 'cooptypes';
+import { AccountResult } from 'eosjs/dist/eosjs-rpc-interfaces';
+import { IEntrepreneurData, IIndividualData, IOrganizationData } from 'src/shared/lib/types/user/IUserData';
+
+export interface ILoadPrivateProfile {
+  coopname: string;
+  username: string;
+}
+
+export interface ILoadPublicProfile {
+  coopname: string;
+  username: string;
+}
+
+export interface IPrivateProfile {
+  username: string;
+}
+
+export interface IUserAccountData {
+  username: string;
+  status: 'created' | 'joined' | 'payed' | 'registered' | 'active' | 'blocked' | 'failed';
+  is_registered: boolean;
+  type: 'individual' | 'entrepreneur' | 'organization';
+  public_key: string;
+  referer: string;
+  email: string;
+  role: string;
+  is_email_verified: boolean;
+  private_data: IIndividualData | IEntrepreneurData | IOrganizationData | null;
+}
+
+export interface ICopenomicsAccount
+  extends Partial<RegistratorContract.Tables.Accounts.IAccount>,
+    Partial<RegistratorContract.Tables.Cooperatives.ICooperative> {}
+
+export type IBlockchainAccountResult = AccountResult;

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

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