@sarafapp/iron_core 1.0.63 → 1.0.64

package/src/baseForm/InputControl.ts

@@ -0,0 +1,182 @@
+import { toRaw } from "vue";
+import type { Nullable } from "../types";
+import { InputControlData } from "./InputControlData";
+import { isEmpty } from "../Utils";
+import { type Validator } from "../validators";
+
+export class InputControl<T> {
+  private initialData: Nullable<InputControlData<T>> = null;
+  private data = new InputControlData<T>();
+  private _validators: Validator<T>[] = [];
+  private _id = Math.random();
+
+  constructor(name: string, value: Nullable<T>) {
+    this.data.value = value;
+    this.data.name = name;
+    if (this.shouldRunValidation()) {
+      this.runValidation(true);
+    }
+  }
+
+  private shouldRunValidation(): boolean {
+    if (this.data.hasCustomValidationCheck) return false;
+    if (this.data.isRequired) return true;
+    return !isEmpty(this.data.value);
+  }
+
+  public async runValidation(isBlur: boolean = false) {
+    for (const validator of this._validators) {
+      const validationMessage = await validator.validate(this.data.value);
+      if (validationMessage) {
+        this.setFormToInvalidState(isBlur, validationMessage);
+        return;
+      }
+    }
+    this.setFormToValidState();
+  }
+
+  private setFormToInvalidState(
+    isBlur: boolean,
+    validationMessage: string,
+  ) {
+    this.data.isValid = false;
+    if (this.data.isChangeSensitive || isBlur) {
+      this.setNotValidMessage(validationMessage);
+    }
+  }
+
+  private setFormToValidState() {
+    this.data.isValid = true;
+    this.setNotValidMessage('');
+  }
+
+  public reset() {
+    if (this.initialData) {
+      this.data = structuredClone(toRaw(this.initialData));
+    } else {
+      console.warn(
+        "The " +
+          this.data.name +
+          `input control has no initial data,
+          the initial data will be available after calling the [markAsInitial] method on this instance`,
+      );
+    }
+  }
+
+  public markAsInitial() {
+    this.initialData = structuredClone(toRaw(this.data));
+  }
+
+  public setValidators(validators: Validator<T>[]) {
+    this._validators = validators;
+  }
+
+  public getChangeSensitive() {
+    return this.data.isChangeSensitive;
+  }
+
+  public setChangeSensitive(isChangeSensitive: boolean) {
+    if (isChangeSensitive && this.data.shouldRemoveValidationMessageOnInteract) {
+        throw new Error("Input control " + this.getName() + " can not be both change sensitive and remove validation meessage on interact");
+    }
+
+    this.data.isChangeSensitive = isChangeSensitive;
+  }
+
+  public getIsBlurSensitive(): boolean {
+    return this.data.isBlurSensitive;
+  }
+
+  public setIsBlurSensitive(isBlurSensitive: boolean) {
+    this.data.isBlurSensitive = isBlurSensitive;
+  }
+
+  public getIsRequired(): boolean {
+    return this.data.isRequired;
+  }
+
+  public setIsRequired(isRequired: boolean) {
+    this.data.isRequired = isRequired;
+  }
+
+  public getIsValid() {
+    return this.data.isValid;
+  }
+
+  public setIsValid(isValid: boolean) {
+    this.data.isValid = isValid;
+  }
+
+  public getIsIncludeInRequestBody(): boolean {
+    return this.data.isIncludeInRequestBody;
+  }
+
+  public setIsIncludeInRequestBody(isIncludeInRequestBody: boolean) {
+    this.data.isIncludeInRequestBody = isIncludeInRequestBody;
+  }
+
+  public getNotValidMessage() {
+    return this.data.notValidMessage;
+  }
+
+  public setNotValidMessage(notValidMessage: string) {
+    this.data.notValidMessage = notValidMessage;
+  }
+
+  public getName() {
+    return this.data.name;
+  }
+
+  public setName(name: string) {
+    this.data.name = name;
+  }
+
+  public setId(id: number) {
+    this._id = id;
+  }
+
+  public getId(): number {
+    return this._id;
+  }
+
+  public getIsEmptySensitive(): boolean {
+    return this.data.isEmptySensitive;
+  }
+
+  public setIsEmptySensitive(value: boolean) {
+    this.data.isEmptySensitive = value;
+  }
+
+  public setHasCustomValidationCheck(hasCustomCheck: boolean) {
+    this.data.hasCustomValidationCheck = hasCustomCheck;
+  }
+
+  public setShouldRemoveValidationOnInteract(value: boolean) {
+    if (value && this.data.isChangeSensitive) {
+      throw new Error("Input control " + this.getName() + " can not be both change sensitive and remove validation meessage on interact");
+    }
+    this.data.shouldRemoveValidationMessageOnInteract = value;
+  }
+
+  public getShouldRemoveValidationOnInteract() {
+    return this.data.shouldRemoveValidationMessageOnInteract;
+  }
+
+  public hasCustomValidationCheck() {
+    return this.data.hasCustomValidationCheck;
+  }
+
+  public set value(value: Nullable<T>) {
+    this.data.value = value;
+    if (this.shouldRunValidation()) {
+      this.runValidation();
+    }
+    if (this.getShouldRemoveValidationOnInteract()) {
+      this.setNotValidMessage("");
+    }
+  }
+
+  public get value() {
+    return this.data.value;
+  }
+}

package/src/baseForm/InputControlBuilder.ts

@@ -0,0 +1,59 @@
+import { InputControl } from "./InputControl";
+import type { Validator } from "../validators";
+
+export class InputControlBuilder<T> {
+  private _inputControl: InputControl<T>;
+
+  constructor(inputControl: InputControl<T>) {
+    this._inputControl = inputControl;
+  }
+
+  public setValidators(validators: Validator<T>[]) {
+    this._inputControl.setValidators(validators);
+    return this;
+  }
+
+  public setChangeSensitive() {
+    this._inputControl.setChangeSensitive(true);
+    return this;
+  }
+
+  public setRequired() {
+    this._inputControl.setIsRequired(true);
+    return this;
+  }
+
+  public setValid() {
+    this._inputControl.setIsValid(true);
+    return this;
+  }
+
+  public setBlurSensitive() {
+    this._inputControl.setIsBlurSensitive(true);
+    return this;
+  }
+
+  public setId(id: number) {
+    this._inputControl.setId(id);
+    return this;
+  }
+
+  public removeEmptySensitive() {
+    this._inputControl.setIsEmptySensitive(false);
+    return this;
+  }
+
+  public setHasCustomValidationCheck() {
+    this._inputControl.setHasCustomValidationCheck(true);
+    return this;
+  }
+
+  public removeErrorOnInteract() {
+    this._inputControl.setShouldRemoveValidationOnInteract(true);
+    return this;
+  }
+
+  public build(): InputControl<T> {
+    return this._inputControl;
+  }
+}

package/src/baseForm/InputControlData.ts

@@ -0,0 +1,16 @@
+import type { Nullable } from '../types'
+
+export class InputControlData<T> {
+  public value: Nullable<T> = null
+  public initialValue: Nullable<T> = null
+  public name: string = ''
+  public isValid: boolean = false
+  public isBlurSensitive: boolean = false
+  public isRequired: boolean = false
+  public isIncludeInRequestBody: boolean = true
+  public isChangeSensitive: boolean = false
+  public notValidMessage: string = ''
+  public isEmptySensitive: boolean = true;
+  public hasCustomValidationCheck: boolean = false;
+  public shouldRemoveValidationMessageOnInteract = false;
+}

package/src/baseForm/RequestBodyFilter.ts

@@ -0,0 +1,3 @@
+export interface RequestBodyFilter<T> {
+    shouldBeInRequestBody(value: T): boolean
+}

package/src/baseForm/TouchSensitiveForm.ts

@@ -0,0 +1,47 @@
+import type { DirectiveBinding } from "vue";
+import type { MountedDirective } from "../baseDirective";
+import type { BeforeUnMountDirective } from "../baseDirective";
+import { InputControl } from "./InputControl";
+
+export class TouchSensitiveControl
+    implements MountedDirective, BeforeUnMountDirective
+{
+
+  public mounted = (
+      element: HTMLInputElement,
+      binding: DirectiveBinding<InputControl<unknown>>,
+  ) => {
+    if (!binding.value) return;
+
+    if (!binding.value.getIsBlurSensitive()) return;
+
+    element.addEventListener('click', this.handleFocus.bind(this, binding.value))
+
+    element.addEventListener(
+        "blur",
+        this.handleBlur.bind(this, binding.value),
+        true,
+    );
+  };
+
+  public beforeUnMount = (
+      element: HTMLInputElement,
+      binding: DirectiveBinding<InputControl<unknown>>,
+  ) => {
+    element!.removeEventListener(
+        "blur",
+        this.handleBlur.bind(this, binding.value),
+    );
+    element!.removeEventListener('click', this.handleFocus.bind(this, binding.value))
+  };
+
+  private handleBlur(inputControl: InputControl<unknown>) {
+    inputControl!.runValidation(true);
+  }
+
+  private handleFocus(inputControl: InputControl<unknown>) {
+    if (inputControl.value || inputControl.getIsEmptySensitive()) return;
+
+    inputControl.setNotValidMessage('');
+  }
+}

package/src/baseForm/UseForm.ts

@@ -0,0 +1,32 @@
+import { reactive, ref, watch } from "vue";
+import { FormManager } from "./FormManager";
+import { FormValidationStatus } from "../constants";
+
+export function useForm(form: FormManager, hasCustomValidation = false) {
+  const reactiveForm = reactive<FormManager>(form);
+  const validationStatus = ref<FormValidationStatus>(
+    FormValidationStatus.Invalid,
+  );
+
+  watch(
+    () => reactiveForm.getInputControlsAsArray(),
+    () => {
+      if (hasCustomValidation) return;
+      reactiveForm.runValidation();
+      if (reactiveForm.getIsValid()) {
+        validationStatus.value = FormValidationStatus.Valid;
+      } else {
+        validationStatus.value = FormValidationStatus.Invalid;
+      }
+    },
+    {
+      immediate: true,
+      deep: true,
+    },
+  );
+
+  return {
+    reactiveForm,
+    validationStatus,
+  };
+}

package/src/baseForm/index.ts

@@ -0,0 +1,8 @@
+export { InputControl } from "./InputControl";
+export { InputControlBuilder } from "./InputControlBuilder";
+export { InputControlData } from "./InputControlData";
+export { TouchSensitiveControl } from "./TouchSensitiveForm";
+export { FormManager } from "./FormManager";
+export { useForm } from "./UseForm";
+export { BaseRequestBodyFilter } from "./BaseRequestBodyFilter"
+export { type RequestBodyFilter } from "./RequestBodyFilter"

package/src/baseSchedule/Schedule.ts

@@ -0,0 +1,3 @@
+export interface Schedule {
+  runAction: () => Promise<unknown>
+}

package/src/baseSchedule/Scheduler.ts

@@ -0,0 +1,29 @@
+import type { Nullable } from '../types'
+import type { Schedule } from './Schedule'
+
+export class Scheduler {
+  private timerId: Nullable<ReturnType<typeof setTimeout>> = null
+  private readonly schedule: Schedule;
+
+  constructor(scheduler: Schedule) {
+    this.setupInterval = this.setupInterval.bind(this);
+    this.schedule = scheduler;
+  }
+
+  public setupInterval(intervalInMilliseconds: number) {
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const thisReference = this;
+    this.timerId = setTimeout(async function autoRefresh() {
+      await thisReference.schedule.runAction()
+      thisReference.timerId = setTimeout(() => {
+        autoRefresh()
+      }, intervalInMilliseconds);
+    }, intervalInMilliseconds);
+  }
+
+  public clearInterval() {
+    if (this.timerId) {
+      clearInterval(this.timerId);
+    }
+  }
+}

package/src/baseSchedule/index.ts

@@ -0,0 +1,2 @@
+export { type Schedule } from './Schedule'
+export { Scheduler } from './Scheduler'

package/src/baseTable/BaseTable.ts

@@ -0,0 +1,162 @@
+import { SortDetail } from "../sort";
+import { BaseModel } from "../BaseModel";
+import { LoadingStatus, SortOrder, TableConstants } from "../constants";
+import { type Accessible, AccessLevel } from "../accessHandling";
+import type { TableHeaderSchema } from "./TableHeaderSchema";
+import type { TableService } from "./TableService";
+import type { TableAction } from "./TableAction";
+import type { Nullable } from "../types";
+import type { TableSummarySchema } from "./TableSummarySchema.ts";
+
+export abstract class BaseTable<Model extends BaseModel> {
+  protected service: TableService<Model>;
+  private accessService: AccessLevel;
+  protected currentPage: number = 1;
+  protected currentPageSize: number = 20;
+  private currentSortDetail: SortDetail<Model> = new SortDetail(
+    "id",
+    SortOrder.DESC,
+  );
+  protected loadedRows: Model[] = [];
+  public headerSchema: TableHeaderSchema<Model>[] = [];
+
+  protected constructor(service: TableService<Model>) {
+    this.service = service;
+    this.accessService = AccessLevel.GetInstance();
+  }
+
+  public addHeader(schema: TableHeaderSchema<Model>) {
+    this.headerSchema.push(schema);
+  }
+
+  public async load() {
+    this.headerSchema = this.filterItemsBaseOnAccessLevel(
+      await this.loadHeader(),
+    );
+    await this.loadRows();
+  }
+
+  protected filterItemsBaseOnAccessLevel<T>(items: Accessible[]): T[] {
+    return items.filter((item) => {
+      if (item.hasAccess) {
+        return item.hasAccess();
+      }
+      return true;
+    }) as T[];
+  }
+
+  public async sort(sortDetail: SortDetail<Model>) {
+    if (!this.shouldSendSortRequest(sortDetail)) return;
+    this.currentSortDetail = sortDetail;
+    this.loadedRows = (await this.handleSort(this.currentSortDetail)).items;
+  }
+
+  private shouldSendSortRequest(sortDetail: SortDetail<Model>): boolean {
+    return (
+      sortDetail.key !== this.currentSortDetail.key ||
+      sortDetail.order !== this.currentSortDetail.order
+    );
+  }
+
+  public async paginate(nextPage: number, pageSize: number) {
+    if (!this.shouldSendPaginationRequest(nextPage, pageSize)) return;
+    this.currentPage = nextPage;
+    this.currentPageSize = pageSize;
+    this.loadedRows = (
+      await this.handlePagination(this.currentPage, this.currentPageSize)
+    ).items;
+  }
+
+  private shouldSendPaginationRequest(
+    nextPage: number,
+    pageSize: number,
+  ): boolean {
+    return this.currentPage !== nextPage || this.currentPageSize !== pageSize;
+  }
+
+  protected async loadRows() {
+    this.loadedRows = (await this.service.fetchRows()).items;
+    return this.loadedRows;
+  }
+
+  public getData() {
+    return this.service.getData();
+  }
+
+  protected async handleSort(sortDetail: SortDetail<Model>) {
+    return await this.service.sort(sortDetail);
+  }
+
+  protected async handlePagination(nextPage: number, pageSize: number) {
+    return await this.service.paginate(nextPage, pageSize);
+  }
+
+  public getItemCountPerPage(): number {
+    return TableConstants.DEFAULT_ITEM_COUNT_PER_PAGE;
+  }
+
+  public isLoading() {
+    const loadingStatuses = this.getLoadingStatuses();
+    return (
+      loadingStatuses.has(LoadingStatus.Search) ||
+      loadingStatuses.has(LoadingStatus.FetchList) ||
+      loadingStatuses.has(LoadingStatus.Sort) ||
+      loadingStatuses.has(LoadingStatus.FetchLastItems) ||
+      loadingStatuses.has(LoadingStatus.FetchPreviousItems)
+    );
+  }
+
+  protected getLoadingStatuses() {
+    return this.getData().loadingStatus;
+  }
+
+  public hasAnyAction() {
+    for (const row of this.loadedRows) {
+      if (this.getAccessedActions(row).length) return true;
+    }
+    return false;
+  }
+
+  public getAccessedActions(row: Model): TableAction<Model>[] {
+    return this.filterItemsBaseOnAccessLevel(this.getActions(row));
+  }
+
+  protected getActions(row: Model): TableAction<Model>[] {
+    return [];
+  }
+
+  public getScrollDetail(): Nullable<boolean | { x?: number; y?: number }> {
+    return null;
+  }
+
+  public isExpandable() {
+    return false;
+  }
+
+  public async handleClick(row: Model) {
+    return;
+  }
+
+  public async handleMetaClick(row: Model) {
+    return;
+  }
+
+  public async handleDoubleClick(row: Model) {
+    return;
+  }
+
+  public async onDestroy() {
+    return;
+  }
+
+  public async loadHeader(): Promise<TableHeaderSchema<Model>[]> {
+    throw new Error("No header provided for the table.");
+  }
+
+  public loadSummarySchema(): TableSummarySchema {
+    return {
+      summaryTitle: "",
+      summaryItems: [],
+    };
+  }
+}

package/src/baseTable/Constants.ts

@@ -0,0 +1,26 @@
+import type { TableHeaderSchema } from "./TableHeaderSchema";
+import { BaseModel } from "../BaseModel";
+import { CellType, HeaderType, TableHeaderAlign } from "../constants";
+
+export const TABLE_COLUMN_DEFAULT_WIDTH = "150px";
+export const TABLE_COLUMN_DEFAULT_COLSPAN = 2;
+
+export const TABLE_ACTION_COLUMN: TableHeaderSchema<BaseModel> = {
+  path: "id",
+  key: "id",
+  title: "عملیات",
+  colspan: TABLE_COLUMN_DEFAULT_COLSPAN,
+  width: TABLE_COLUMN_DEFAULT_WIDTH,
+  cellType: CellType.ACTION,
+  align: TableHeaderAlign.Center,
+  headerType: HeaderType.Text,
+  accessLevel: null,
+};
+
+export const TABLE_COLUMN_DEFAULT_VALUES = {
+  width: TABLE_COLUMN_DEFAULT_WIDTH,
+  align: TableHeaderAlign.Center,
+  headerType: HeaderType.Text,
+  cellType: CellType.Text,
+  colspan: TABLE_COLUMN_DEFAULT_COLSPAN,
+};

package/src/baseTable/OnDestory.ts

@@ -0,0 +1,3 @@
+export interface Destroy {
+  onDestroy(): Promise<void>;
+}

package/src/baseTable/RowActionSource.ts

@@ -0,0 +1,5 @@
+import type { TableAction } from "./TableAction";
+
+export interface RowActionSource<Model, A> {
+  getActions(): TableAction<Model, A>[];
+}

package/src/baseTable/RowClick.ts

@@ -0,0 +1,3 @@
+export interface RowClick<Model> {
+  handleClick(row: Model): Promise<void>;
+}

package/src/baseTable/RowDoubleClick.ts

@@ -0,0 +1,3 @@
+export interface RowDoubleClick<Model> {
+  handleDoubleClick(row: Model): Promise<void>;
+}

package/src/baseTable/RowMetaClick.ts

@@ -0,0 +1,3 @@
+export interface RowMetaClick<Model> {
+  handleMetaClick(row: Model): Promise<void>;
+}

package/src/baseTable/SelectableTable.ts

@@ -0,0 +1,86 @@
+import { BaseTable } from './BaseTable'
+import { BehaviorSubject } from '../observables/BehaviorSubject'
+import { type SortDetail } from '../sort'
+import type { BaseModel } from '../BaseModel'
+import type { TableService } from './TableService'
+
+export abstract class SelectableTable<
+  Model extends BaseModel,
+> extends BaseTable<Model> {
+  public selectedRows: BehaviorSubject<Map<number, Model>> =
+    new BehaviorSubject(new Map<number, Model>());
+
+  constructor(service: TableService<Model>) {
+    super(service);
+    this.rowSelect = this.rowSelect.bind(this);
+    this.selectAll = this.selectAll.bind(this);
+    this.isEveryRowSelected = this.isEveryRowSelected.bind(this);
+    this.handlePagination = this.handlePagination.bind(this);
+    this.clearAllSelectedItems = this.clearAllSelectedItems.bind(this);
+    this.getSelectedRows = this.getSelectedRows.bind(this);
+    this.getSelectedRowsAsArray = this.getSelectedRowsAsArray.bind(this);
+    this.getSelectedRowIds = this.getSelectedRowIds.bind(this);
+  }
+
+  public rowSelect(row: Model) {
+    if (this.getSelectedRowsValue().has(row.id)) {
+      this.getSelectedRowsValue().delete(row.id);
+      this.selectedRows.next(this.selectedRows.getValue());
+    } else {
+      this.selectedRows.getValue().set(row.id, row);
+      this.selectedRows.next(this.selectedRows.getValue());
+    }
+  }
+
+  public selectAll() {
+    if (this.isEveryRowSelected()) {
+      this.clearAllSelectedItems();
+    } else {
+      for (const row of this.loadedRows) {
+        this.selectedRows.getValue().set(row.id, row);
+        this.selectedRows.next(this.selectedRows.getValue());
+      }
+    }
+  }
+
+  private isEveryRowSelected() {
+    return (
+      this.getSelectedRowsValue().size === this.currentPageSize ||
+      this.loadedRows.length === this.getSelectedRowsValue().size
+    );
+  }
+
+  protected override async handlePagination(
+    nextPage: number,
+    pageSize: number,
+  ) {
+    this.clearAllSelectedItems();
+    return await super.handlePagination(nextPage, pageSize);
+  }
+
+  protected override async handleSort(sortDetail: SortDetail<Model>) {
+    this.clearAllSelectedItems();
+    return await super.handleSort(sortDetail);
+  }
+
+  public clearAllSelectedItems() {
+    this.selectedRows.getValue().clear();
+    this.selectedRows.next(this.selectedRows.getValue());
+  }
+
+  public getSelectedRows() {
+    return this.selectedRows;
+  }
+
+  public getSelectedRowsAsArray() {
+    return Array.from(this.selectedRows.getValue().values());
+  }
+
+  public getSelectedRowIds() {
+    return Array.from(this.selectedRows.getValue().keys());
+  }
+
+  public getSelectedRowsValue() {
+    return this.selectedRows.getValue();
+  }
+}