@sarafapp/iron_core 1.0.62 → 1.0.64

package/src/BaseModel.ts

@@ -0,0 +1,127 @@
+import { JsonObject, JsonProperty } from "json2typescript";
+import { Formatter, DateFormat } from "./lib";
+
+@JsonObject("Amount")
+export class Amount {
+  @JsonProperty("value", String, true)
+  value: string = "";
+
+  @JsonProperty("symbol", String)
+  symbol: string = "";
+
+  public get tradeValueInNumber() {
+    return Number(this.value);
+  }
+
+  public get truncatedValue() {
+    return this.tradeValueInNumber.toLocaleString("en-US", {
+      maximumFractionDigits: 8,
+    });
+  }
+}
+
+@JsonObject("BaseModel")
+export class BaseModel {
+  @JsonProperty("id", Object)
+  public id!: number | string;
+
+  protected getTable<Table>() {
+    const table = Object.getPrototypeOf(this)._table;
+    if (!table) {
+      throw new Error(
+        "No Table found for the model. are you sure decorated the model with @Table() ?",
+      );
+    }
+    return table as Table;
+  }
+}
+
+@JsonObject("MinifiedSymbolModel")
+export class MinifiedSymbolModel extends BaseModel {
+  @JsonProperty("symbol", String)
+  public symbol!: string;
+  @JsonProperty("enName", String)
+  public enName!: string;
+  @JsonProperty("faName", String)
+  public faName!: string;
+  @JsonProperty("image", String)
+  public image!: string;
+}
+
+export class TradeDate {
+  public requestedDate: number;
+  public executedDate: number;
+
+  constructor(requestedDate: number, executedDate: number) {
+    this.requestedDate = requestedDate;
+    this.executedDate = executedDate;
+  }
+
+  public get requestedDateInJalali() {
+    return Formatter.mapUnixToDate(this.requestedDate, DateFormat.SimpleDate);
+  }
+  public get requestedTime() {
+    return Formatter.mapUnixToDate(this.requestedDate, DateFormat.JustHour);
+  }
+
+  public get executedDateInJalali() {
+    return Formatter.mapUnixToDate(this.executedDate, DateFormat.SimpleDate);
+  }
+  public get executedDateTime() {
+    return Formatter.mapUnixToDate(this.executedDate, DateFormat.JustHour);
+  }
+}
+
+export class TradeAmount {
+  public requestedAmount: Amount;
+  public executedAmount: Amount;
+
+  constructor(requestedAmount: Amount, executedAmount: Amount) {
+    this.requestedAmount = requestedAmount;
+    this.executedAmount = executedAmount;
+  }
+}
+
+export class SymbolPriceInTrade {
+  public symobl: string;
+  public symbolPrice: number;
+  public USDTPrice: number;
+  public symbolImage: string;
+  public USDTImage: string;
+
+  constructor(
+    symbolPrice: number,
+    USDTPrice: number,
+    symbol: string,
+    symbolImage: string,
+    USDTImage: string,
+  ) {
+    this.symbolPrice = symbolPrice;
+    this.USDTPrice = USDTPrice;
+    this.symobl = symbol;
+    this.symbolImage = symbolImage;
+    this.USDTImage = USDTImage;
+  }
+
+  public get truncatedSymbolPrice() {
+    return this.symbolPrice.toLocaleString("en-US", {
+      maximumFractionDigits: 8,
+    });
+  }
+
+  public get truncatedUSDTPrice() {
+    return this.USDTPrice.toLocaleString("en-US", {
+      maximumFractionDigits: 8,
+    });
+  }
+}
+
+export class SymbolInTrade {
+  public soldSymbol: MinifiedSymbolModel;
+  public buySymbol: MinifiedSymbolModel;
+
+  constructor(soldSymbol: MinifiedSymbolModel, buySymbol: MinifiedSymbolModel) {
+    this.soldSymbol = soldSymbol;
+    this.buySymbol = buySymbol;
+  }
+}

package/src/Utils.ts

@@ -0,0 +1,16 @@
+export function isOnlyOneItem(total: number): boolean {
+  return total === 1;
+}
+
+export function isLastItem(total: number, index: number): boolean {
+  return total - 1 === index;
+}
+
+export function isEmpty(value: unknown): boolean {
+  return String(value).length === 0 || value === null || value === undefined;
+}
+
+export function setupStore(initializer: () => void) {
+  initializer();
+}
+

package/src/accessHandling/AccessControl.ts

@@ -0,0 +1,33 @@
+import type { DirectiveBinding } from "vue";
+import type { MountedDirective, UpdateDirective } from "../baseDirective";
+import { AccessLevel } from "./AccessLevel";
+
+export abstract class AccessControl
+  implements MountedDirective, UpdateDirective
+{
+  protected accessService;
+
+  constructor() {
+    this.accessService = AccessLevel.GetInstance();
+  }
+
+  public mounted = (
+    element: HTMLElement,
+    binding: DirectiveBinding<string[]>,
+  ) => {
+    this.checkAccess(element, binding.value);
+  };
+
+  public updated = (
+    element: HTMLElement,
+    binding: DirectiveBinding<string[]>,
+  ) => {
+    this.checkAccess(element, binding.value);
+  };
+
+  private checkAccess = (element: HTMLElement, accessLevels: string[]) => {
+    if (!this.hasAccess(accessLevels)) element.remove();
+  };
+
+  protected abstract hasAccess(accessLevels: string[]): boolean;
+}

package/src/accessHandling/AccessLevel.ts

@@ -0,0 +1,52 @@
+import { StorageKeys } from '../constants'
+import type { Initializer } from '../initializer/Initializer'
+import type { Nullable } from '../types'
+
+export class AccessLevel implements Initializer {
+  private static Instance: Nullable<AccessLevel> = null
+  private availableAccesses: Set<string> = new Set<string>()
+
+  private constructor() {}
+
+  public setAvailableAccesses(accessToAdd: string[]) {
+    this.setAccessListToStorage(accessToAdd)
+    for (const access of accessToAdd) {
+      this.availableAccesses.add(access)
+    }
+  }
+
+  private setAccessListToStorage(accessesToAdd: string[]) {
+    localStorage.setItem(StorageKeys.AccessList, JSON.stringify(accessesToAdd))
+  }
+
+  public everyAccess(accessesToCheck: string[]) {
+    return accessesToCheck.every((access) => {
+      return this.availableAccesses.has(access)
+    })
+  }
+
+  public someAccess(accessesToCheck: string[]) {
+    return accessesToCheck.some((access) => {
+      return this.availableAccesses.has(access)
+    })
+  }
+
+  public clearAvailableAccesses() {
+    this.availableAccesses.clear()
+    localStorage.removeItem(StorageKeys.AccessList)
+  }
+
+  public initialize(): void {
+    const AccessesInStorage = localStorage.getItem(StorageKeys.AccessList)
+    if (AccessesInStorage !== null) {
+      this.setAvailableAccesses(JSON.parse(AccessesInStorage))
+    }
+  }
+
+  public static GetInstance() {
+    if (!AccessLevel.Instance) {
+      AccessLevel.Instance = new AccessLevel()
+    }
+    return AccessLevel.Instance as AccessLevel
+  }
+}

package/src/accessHandling/Accessible.ts

@@ -0,0 +1,3 @@
+export interface Accessible {
+  hasAccess(): boolean;
+}

package/src/accessHandling/EveryDirectiveAccess.ts

@@ -0,0 +1,7 @@
+import { AccessControl } from "./AccessControl";
+
+export class EveryAccess extends AccessControl {
+  protected hasAccess(accessLevels: string[]): boolean {
+    return this.accessService.everyAccess(accessLevels);
+  }
+}

package/src/accessHandling/SSO/AuthorizationDirective.ts

@@ -0,0 +1,65 @@
+import {
+  type MountedDirective,
+  type UpdateDirective,
+} from "../../baseDirective";
+import { AuthorizationService } from "./AuthorizationService";
+
+export abstract class AuthorizationDirective
+  implements MountedDirective, UpdateDirective
+{
+  protected _authorizationService: AuthorizationService =
+    AuthorizationService.GetInstance();
+
+  constructor() {
+    this.mounted = this.mounted.bind(this);
+    this.updated = this.updated.bind(this);
+    this.hasAccess = this.hasAccess.bind(this);
+    this.manageElement = this.manageElement.bind(this);
+  }
+
+  public mounted(
+    element: HTMLElement,
+    binding: { arg: string; modifiers: Record<PropertyKey, boolean> },
+    _vnode: unknown,
+  ): void {
+    this.manageElement(element, binding.arg, binding.modifiers);
+  }
+
+  public updated(
+    element: HTMLElement,
+    binding: { arg: string; modifiers: Record<PropertyKey, boolean> },
+    _vnode: unknown,
+  ): void {
+    this.manageElement(element, binding.arg, binding.modifiers);
+  }
+
+  private manageElement(
+    element: HTMLElement,
+    scope: string,
+    levels: Record<PropertyKey, boolean>,
+  ) {
+    if (!this._authorizationService.hasScope(scope)) {
+      element.remove();
+      return;
+    }
+    const accessLevels = this.getAccessLevels(scope, levels);
+    if (this.hasAccess(scope, accessLevels)) return;
+    element.remove();
+  }
+
+  private getAccessLevels(
+    scope: string,
+    accessLevels: Record<PropertyKey, boolean>,
+  ) {
+    let directiveAccessLevels = Object.keys(accessLevels);
+    if (!directiveAccessLevels.length) {
+      directiveAccessLevels = Array.from(
+        this._authorizationService.getAccessLevelsOfScope(scope)?.values() ??
+          [],
+      );
+    }
+    return directiveAccessLevels;
+  }
+
+  protected abstract hasAccess(scope: string, levels: string[]): boolean;
+}

package/src/accessHandling/SSO/AuthorizationService.ts

@@ -0,0 +1,74 @@
+import { StorageKeys } from "../../constants";
+import { type Initializer } from "../../initializer/Initializer";
+import { type Nullable } from "../../types/Global";
+
+export class AuthorizationService implements Initializer {
+  private static _instance: Nullable<AuthorizationService> = null;
+  private _accessLevels: Map<string, Set<string>> = new Map();
+
+  private constructor() {}
+
+  public initialize(): void {
+    this.setAccessLevelFromStorage();
+  }
+
+  public setAccessLevels(levels: Record<PropertyKey, string[]>) {
+    for (const key in levels) {
+      this._accessLevels.set(key, new Set(levels[key]));
+    }
+    this.setAccessLevelsToStorage(levels);
+  }
+
+  private setAccessLevelsToStorage(levels: Record<PropertyKey, string[]>) {
+    localStorage.setItem(StorageKeys.SSO_ACCESS_LIST, JSON.stringify(levels));
+  }
+
+  private getAccessLevelsFromStorage() {
+    let levelsInStorage = localStorage.getItem(StorageKeys.SSO_ACCESS_LIST);
+    if (levelsInStorage !== null) {
+      return JSON.parse(levelsInStorage);
+    }
+    return levelsInStorage;
+  }
+
+  public getAccessLevelsOfScope(scope: string) {
+    if (this._accessLevels.has(scope)) {
+      return this._accessLevels.get(scope);
+    }
+    throw new Error(`The scope is not exists ${scope}`);
+  }
+
+  private setAccessLevelFromStorage() {
+    const accessLevelInStorage = this.getAccessLevelsFromStorage();
+    if (!accessLevelInStorage) return;
+    this.setAccessLevels(accessLevelInStorage);
+  }
+
+  public everyAccess(scope: string, levels: string[]) {
+    const levelsInScope = this.getAccessLevelsOfScope(scope);
+    if (!levelsInScope) return false;
+    return levels.every((level) => levelsInScope.has(level));
+  }
+
+  public someAccess(scope: string, levels: string[]) {
+    const levelInScope = this.getAccessLevelsOfScope(scope);
+    if (!levelInScope) return false;
+    return levels.some((level) => levelInScope.has(level));
+  }
+
+  public hasScope(scope: string) {
+    return this._accessLevels.has(scope);
+  }
+
+  public clear() {
+    localStorage.removeItem(StorageKeys.SSO_ACCESS_LIST);
+    this._accessLevels = new Map<string, Set<string>>();
+  }
+
+  public static GetInstance() {
+    if (!AuthorizationService._instance) {
+      AuthorizationService._instance = new AuthorizationService();
+    }
+    return AuthorizationService._instance;
+  }
+}

package/src/accessHandling/SSO/EveryLevelAuthorizationDirective.ts

@@ -0,0 +1,7 @@
+import { AuthorizationDirective } from "./AuthorizationDirective";
+
+export class EveryLevelAuthorizationDirective extends AuthorizationDirective {
+  protected hasAccess(scope: string, levels: string[]): boolean {
+    return this._authorizationService.everyAccess(scope, levels);
+  }
+}

package/src/accessHandling/SSO/SomeLevelsAuthorizationDirective.ts

@@ -0,0 +1,7 @@
+import { AuthorizationDirective } from "./AuthorizationDirective";
+
+export class SomeLevelsAuthorizationDirective extends AuthorizationDirective {
+  protected hasAccess(scope: string, levels: string[]): boolean {
+    return this._authorizationService.someAccess(scope, levels);
+  }
+}

package/src/accessHandling/SomeDirectiveAccess.ts

@@ -0,0 +1,7 @@
+import { AccessControl } from "./AccessControl";
+
+export class SomeAccess extends AccessControl {
+  protected hasAccess(accessLevels: string[]): boolean {
+    return this.accessService.someAccess(accessLevels);
+  }
+}

package/src/accessHandling/index.ts

@@ -0,0 +1,9 @@
+export { AccessLevel } from "./AccessLevel";
+export { AccessControl } from "./AccessControl";
+export type { Accessible } from "./Accessible";
+export { EveryAccess } from "./EveryDirectiveAccess";
+export { SomeAccess } from "./SomeDirectiveAccess";
+export * from './SSO/AuthorizationDirective';
+export * from './SSO/AuthorizationService';
+export * from './SSO/EveryLevelAuthorizationDirective';
+export * from './SSO/SomeLevelsAuthorizationDirective';

package/src/baseDirective/BeforeMountDirective.ts

@@ -0,0 +1,3 @@
+export interface BeforeMountDirective {
+  beforeMount(el: unknown, binding: unknown, vnode: unknown): void;
+}

package/src/baseDirective/BeforeUnMountDirective.ts

@@ -0,0 +1,3 @@
+export interface BeforeUnMountDirective {
+  beforeUnMount(element: unknown, binding: unknown, vnode: unknown): void;
+}

package/src/baseDirective/BeforeUpdateDirective.ts

@@ -0,0 +1,3 @@
+export interface BeforeUpdateDirective {
+  beforeUpdate(element: unknown, binding: unknown, vnode: unknown): void;
+}

package/src/baseDirective/CreatedDirective.ts

@@ -0,0 +1,3 @@
+export interface CreatedDirective {
+  created(element: unknown, binding: unknown, vnode: unknown): void;
+}

package/src/baseDirective/MountedDirective.ts

@@ -0,0 +1,3 @@
+export interface MountedDirective {
+  mounted(element: unknown, binding: unknown, vnode: unknown): void;
+}

package/src/baseDirective/UnMountedDirective.ts

@@ -0,0 +1,3 @@
+export interface UnMountedDirective {
+  unMounted(element: unknown, binding: unknown, vnode: unknown): void;
+}

package/src/baseDirective/UpdateDirective.ts

@@ -0,0 +1,3 @@
+export interface UpdateDirective {
+  updated(element: unknown, binding: unknown, vnode: unknown): void;
+}

package/src/baseDirective/index.ts

@@ -0,0 +1,7 @@
+export type { BeforeMountDirective } from "./BeforeMountDirective";
+export type { BeforeUnMountDirective } from "./BeforeUnMountDirective";
+export type { BeforeUpdateDirective } from "./BeforeUpdateDirective";
+export type { CreatedDirective } from "./CreatedDirective";
+export type { MountedDirective } from "./MountedDirective";
+export type { UnMountedDirective } from "./UnMountedDirective";
+export type { UpdateDirective } from "./UpdateDirective";

package/src/baseForm/BaseRequestBodyFilter.ts

@@ -0,0 +1,7 @@
+import { RequestBodyFilter } from "./RequestBodyFilter";
+
+export class BaseRequestBodyFilter implements RequestBodyFilter<unknown> {
+  public shouldBeInRequestBody(_value: unknown): boolean {
+    return true;
+  }
+}

package/src/baseForm/FormManager.ts

@@ -0,0 +1,95 @@
+import { InputControl } from "./InputControl";
+import { BaseRequestBodyFilter } from "./BaseRequestBodyFilter";
+
+export class FormManager {
+  private _inputControls = new Map<string, InputControl<unknown>>();
+  private _isValid: boolean = false;
+  private _id: number = Math.random();
+
+  public getInputControlsAsArray(): InputControl<unknown>[] {
+    return Array.from(this._inputControls.values());
+  }
+
+  public async runValidation(shouldValidateInputControls?: boolean) {
+    let isValid = true;
+
+    for (const inputControl of this.getInputControlsAsArray()) {
+      if (shouldValidateInputControls) {
+        await inputControl.runValidation(true);
+      }
+      const isInputValid = inputControl.getIsValid();
+      if (!isInputValid) {
+        isValid = false;
+        if (!shouldValidateInputControls) {
+          this._isValid = false;
+          return;
+        }
+      }
+    }
+    this._isValid = isValid;
+  }
+
+  public addInputControls(inputControls: InputControl<unknown>[]) {
+    for (const inputControl of inputControls) {
+      this._inputControls.set(inputControl.getName(), inputControl);
+    }
+  }
+
+  public getInputControl<T>(inputControlName: string) {
+    const inputControl = this._inputControls.get(inputControlName);
+    if (!inputControl) {
+      throw new Error(
+        `The provided input name (${inputControlName}}) has no controls.`,
+      );
+    }
+    return inputControl as InputControl<T>;
+  }
+
+  public resetControls(inputControlNames: string[]) {
+    for (const inputName of inputControlNames) {
+      const inputToReset = this._inputControls.get(inputName);
+      if (inputToReset) {
+        inputToReset.reset();
+      } else {
+        console.warn(
+          `Provided input name ${inputName} has no controllers in this form`,
+        );
+      }
+    }
+  }
+
+  public resetAll() {
+    for (const inputControl of this.getInputControlsAsArray()) {
+      inputControl.reset();
+    }
+  }
+
+  public createRequestBody<T>(requestBodyFilter = new BaseRequestBodyFilter()) {
+    const requestBody: Record<string, unknown> = {};
+
+    for (const inputControl of this.getInputControlsAsArray()) {
+      if (
+        inputControl.getIsIncludeInRequestBody() &&
+        requestBodyFilter.shouldBeInRequestBody(inputControl.value)
+      ) {
+        requestBody[inputControl.getName()] = inputControl.value;
+      }
+    }
+
+    return requestBody as T;
+  }
+
+  public setIsValid(isValid: boolean): void {
+    this._isValid = isValid;
+  }
+  public getIsValid() {
+    return this._isValid;
+  }
+
+  public setId(id: number) {
+    this._id = id;
+  }
+  public getId() {
+    return this._id;
+  }
+}