@sarafapp/iron_core 1.0.63 → 1.0.64

package/src/composables/UseLoadingStatus.ts

@@ -0,0 +1,65 @@
+import { computed, ref } from "vue";
+import { LoadingStatus } from "../constants";
+
+export function useLoadingStatus() {
+  const loadingStatus = ref<Set<LoadingStatus>>(new Set<LoadingStatus>());
+
+  const isFetchingList = computed(() => {
+    return loadingStatus.value.has(LoadingStatus.FetchList);
+  });
+
+  const isFetchingItem = computed(() => {
+    return loadingStatus.value.has(LoadingStatus.FetchItem);
+  });
+
+  const isFetchingLastItems = computed(() => {
+    return loadingStatus.value.has(LoadingStatus.FetchLastItems);
+  });
+
+  const isFetchingPreviousItems = computed(() => {
+    return loadingStatus.value.has(LoadingStatus.FetchPreviousItems);
+  });
+
+  const isCreating = computed(() => {
+    return loadingStatus.value.has(LoadingStatus.Create);
+  });
+
+  const isUpdating = computed(() => {
+    return loadingStatus.value.has(LoadingStatus.Update);
+  });
+
+  const isDeleting = computed(() => {
+    return loadingStatus.value.has(LoadingStatus.Delete);
+  });
+
+  const isSearching = computed(() => {
+    return loadingStatus.value.has(LoadingStatus.Search);
+  });
+
+  const isSorting = computed(() => {
+    return loadingStatus.value.has(LoadingStatus.Sort);
+  });
+
+  function setStatus(status: LoadingStatus) {
+    loadingStatus.value.add(status);
+  }
+
+  function removeStatus(status: LoadingStatus) {
+    loadingStatus.value.delete(status);
+  }
+
+  return {
+    loadingStatus,
+    isFetchingList,
+    isFetchingItem,
+    isFetchingLastItems,
+    isFetchingPreviousItems,
+    isCreating,
+    isUpdating,
+    isDeleting,
+    isSearching,
+    isSorting,
+    setStatus,
+    removeStatus,
+  };
+}

package/src/composables/UseParams.ts

@@ -0,0 +1,93 @@
+import { type Ref, ref } from "vue";
+import { SortDetail } from "../sort";
+import { BaseModel } from "../BaseModel";
+import { Params } from "../repository";
+
+const DEFAULT_PARAMS = new Params();
+
+export function useParams() {
+  const params: Ref<Params> = ref(structuredClone(DEFAULT_PARAMS));
+
+  function setNextPage() {
+    params.value.pageNumber = params.value.pageNumber + 1;
+  }
+
+  function setPreventPage() {
+    params.value.pageNumber = params.value.pageNumber - 1;
+  }
+
+  function setPageNumber(pageNumber: number) {
+    params.value.pageNumber = pageNumber;
+  }
+
+  function setItemCount(itemCount: number) {
+    params.value.itemCount = itemCount;
+  }
+
+  function setSortDetail(sortDetail: SortDetail<BaseModel>) {
+    params.value.sortDetail.key = sortDetail.key;
+    params.value.sortDetail.order = sortDetail.order;
+  }
+
+  function setFiltersBaseOnRequestBody(filters: Record<string, unknown>) {
+    for (const key in filters) {
+      setFilter(key, filters[key]);
+    }
+  }
+
+  function setFilter(key: string, value: unknown) {
+    const index = params.value.filters.findIndex(
+      (filter) => filter.key === key,
+    );
+    if (index > -1) params.value.filters[index].value = value;
+    else params.value.filters.push({ key, value });
+  }
+
+  function removeFilter(key: string) {
+    let currentParams = params.value.filters;
+    currentParams = currentParams.filter(iteratedParam => iteratedParam.key !== key)
+    params.value.filters = currentParams;
+  }
+
+  function getRequestParams() {
+    const requestParams: Record<string, unknown> = {
+      page: params.value.pageNumber,
+      count: params.value.itemCount,
+    };
+    if (params.value.sortDetail) {
+      requestParams.by = params.value.sortDetail.key;
+      requestParams.order = params.value.sortDetail.order;
+    }
+    for (const filter of params.value.filters) {
+      if (filter.value) {
+        if (typeof filter.value === 'string' || typeof filter.value === 'number') {
+          requestParams[filter.key] = filter.value;
+        } else {
+          const value = JSON.stringify(filter.value);
+          if (value !== "[]" && value !== "{}") {
+            requestParams[filter.key] = value;
+          }
+        }
+      }
+    }
+    return requestParams;
+  }
+
+  function clearParam() {
+    params.value = structuredClone(DEFAULT_PARAMS);
+  }
+
+  return {
+    params,
+    setNextPage,
+    setPreventPage,
+    setPageNumber,
+    setItemCount,
+    setSortDetail,
+    setFilter,
+    removeFilter,
+    getRequestParams,
+    clearParam,
+    setFiltersBaseOnRequestBody
+  };
+}

package/src/composables/UseRepository.ts

@@ -0,0 +1,207 @@
+import { computed, onBeforeUnmount } from "vue";
+import { useData } from "./UseData";
+import { useParams } from "./UseParams";
+import { useLoadingStatus } from "./UseLoadingStatus";
+import { type Repository, type SyncDetail } from "../repository";
+import { LoadingStatus } from "../constants";
+import { SortDetail } from "../sort";
+import { BaseModel } from "../BaseModel";
+import { Scheduler } from "../baseSchedule";
+import { type TableRenderingData, type TableService } from "../baseTable";
+
+export function useRepository<Model extends BaseModel>(
+  repository: Repository<Model>,
+) {
+  const dataManger = useData();
+  const paramsManager = useParams();
+  const loadingStatusManager = useLoadingStatus();
+
+  const scheduler = new Scheduler({
+    runAction: async () => fetchList(LoadingStatus.AutoRefresh),
+  });
+
+  const currentPageItems = computed<Model[]>(() => {
+    const pageNumber = paramsManager.params.value.pageNumber;
+    const pageSize = paramsManager.params.value.itemCount;
+    const startIndex = pageNumber * pageSize - pageSize;
+    const endIndex = pageNumber * pageSize - 1;
+    const items: Model[] = [];
+    for (let index = startIndex; index <= endIndex; index++) {
+      if (!dataManger.itemsAsArray.value[index]) break;
+      items.push(dataManger.itemsAsArray.value[index] as Model);
+    }
+    return items;
+  });
+
+  const tableRenderingData = computed<TableRenderingData<Model>>(() => {
+    return {
+      totalItems: dataManger.totalCount.value,
+      currentPage: paramsManager.params.value.pageNumber,
+      rows: dataManger.itemsAsArray.value,
+      loadingStatus: loadingStatusManager.loadingStatus.value,
+      currentPageItems: currentPageItems.value,
+    } as TableRenderingData<Model>;
+  });
+
+  const tableService = computed<TableService<Model>>(() => {
+    return {
+      getData: getTableRenderingData,
+      sort: sort,
+      paginate: fetchItemsByPageNumber,
+      fetchRows: fetchList,
+    };
+  });
+
+  const syncDetail = computed<SyncDetail>(() => {
+    return repository.getSyncDetail();
+  });
+
+  function getTableRenderingData(): TableRenderingData<Model> {
+    return tableRenderingData.value;
+  }
+
+  async function handleFetchList(query?: Record<string, unknown>) {
+    const result = await repository.fetchList(query);
+    dataManger.clearItems();
+    dataManger.addOrReplaceItems(result.items);
+    dataManger.setTotalCount(result.totalItems);
+    return result;
+  }
+
+  async function fetchList(
+    loadingStatus: LoadingStatus = LoadingStatus.FetchList,
+  ) {
+    loadingStatusManager.setStatus(loadingStatus);
+    const result = await handleFetchList(paramsManager.getRequestParams());
+    loadingStatusManager.removeStatus(loadingStatus);
+    return result;
+  }
+
+  async function fetchWithAutoRefresh() {
+    setupAutoRefresh();
+    await fetchList();
+  }
+
+  function setupAutoRefresh() {
+    if (!syncDetail.value.shouldKeepSync) {
+      throw new Error(`The provided repository does not support auto refresh`);
+    }
+    scheduler.setupInterval(syncDetail.value.intervalInMillisecond);
+  }
+
+  function stopAutoRefresh() {
+    scheduler.clearInterval();
+  }
+
+  async function fetchItemById(id: number, shouldRemoveItem = true) {
+    loadingStatusManager.setStatus(LoadingStatus.FetchItem);
+    if (shouldRemoveItem) {
+      dataManger.clearCurrentItem();
+    }
+    const result = await repository.fetchItemById(id);
+    dataManger.setCurrentItem(result);
+    loadingStatusManager.removeStatus(LoadingStatus.FetchItem);
+    return result;
+  }
+
+  async function createItem<Body>(body: Body) {
+    loadingStatusManager.setStatus(LoadingStatus.Create);
+    const result = await repository.createItem(body);
+    if (result) {
+      dataManger.addOrReplaceItems([result]);
+    }
+    loadingStatusManager.removeStatus(LoadingStatus.Create);
+    return result;
+  }
+
+  async function updateItem<Body>(id: number, body: Body) {
+    loadingStatusManager.setStatus(LoadingStatus.Update);
+    const result = await repository.updateItem(id, body);
+    if (result) {
+      dataManger.addOrReplaceItems([result]);
+    }
+    loadingStatusManager.removeStatus(LoadingStatus.Update);
+    return result;
+  }
+
+  async function deleteItem(id: number) {
+    loadingStatusManager.setStatus(LoadingStatus.Delete);
+    await repository.deleteItem(id);
+    loadingStatusManager.removeStatus(LoadingStatus.Delete);
+    return dataManger.removeById(id);
+  }
+
+  async function fetchLastItems() {
+    paramsManager.setNextPage();
+    loadingStatusManager.setStatus(LoadingStatus.FetchLastItems);
+    const result = await handleFetchList(paramsManager.getRequestParams());
+    loadingStatusManager.removeStatus(LoadingStatus.FetchLastItems);
+    return result;
+  }
+
+  async function fetchPreviousItems() {
+    paramsManager.setPreventPage();
+    loadingStatusManager.setStatus(LoadingStatus.FetchPreviousItems);
+    const result = await handleFetchList(paramsManager.getRequestParams());
+    loadingStatusManager.removeStatus(LoadingStatus.FetchPreviousItems);
+    return result;
+  }
+
+  async function fetchItemsByPageNumber(pageNumber: number) {
+    paramsManager.setPageNumber(pageNumber);
+    loadingStatusManager.setStatus(LoadingStatus.FetchList);
+    const result = await handleFetchList(paramsManager.getRequestParams());
+    loadingStatusManager.removeStatus(LoadingStatus.FetchList);
+    return result;
+  }
+
+  async function search(searchedValue: string) {
+    paramsManager.setFilter("search", searchedValue);
+    loadingStatusManager.setStatus(LoadingStatus.Search);
+    dataManger.clearItems();
+    const result = await handleFetchList(paramsManager.getRequestParams());
+    loadingStatusManager.removeStatus(LoadingStatus.Search);
+    return result;
+  }
+
+  async function sort(sortDetail: SortDetail<Model>) {
+    paramsManager.setSortDetail(sortDetail as SortDetail<BaseModel>);
+    loadingStatusManager.setStatus(LoadingStatus.Sort);
+    dataManger.clearItems();
+    const result = await handleFetchList(paramsManager.getRequestParams());
+    loadingStatusManager.removeStatus(LoadingStatus.Sort);
+    return result;
+  }
+
+  async function clearFilters() {
+    paramsManager.clearParam();
+    return await fetchList();
+  }
+
+  onBeforeUnmount(() => {
+    stopAutoRefresh();
+  });
+
+  return {
+    loadingStatusManager,
+    dataManger,
+    paramsManager,
+    tableRenderingData,
+    fetchList,
+    fetchWithAutoRefresh,
+    setupAutoRefresh,
+    stopAutoRefresh,
+    fetchItemById,
+    createItem,
+    updateItem,
+    deleteItem,
+    fetchLastItems,
+    fetchPreviousItems,
+    fetchItemsByPageNumber,
+    search,
+    sort,
+    clearFilters,
+    tableService,
+    currentPageItems,
+  };
+}

package/src/composables/UseState.ts

@@ -0,0 +1,30 @@
+import { computed, ref, type Ref } from "vue";
+
+export function useState<T>(initial: T, ttl: number = 300_000): Ref<T> {
+  const state = ref<T>(structuredClone(initial));
+  let timer: ReturnType<typeof setTimeout> | null = null;
+
+  function resetTimer() {
+    if (timer) clearTimeout(timer);
+    if (ttl > 0) {
+      timer = setTimeout(() => {
+        state.value = initial;
+      }, ttl);
+    }
+  }
+
+  const computedState = computed<T>({
+    get() {
+      resetTimer();
+      return state.value;
+    },
+    set(value: T) {
+      state.value = value;
+      resetTimer();
+    },
+  });
+
+  resetTimer();
+
+  return computedState;
+}

package/src/composables/UseStaticTableService.ts

@@ -0,0 +1,45 @@
+import { computed, ref } from 'vue'
+import { LoadingStatus } from '../constants'
+import { SortDetail } from '../sort'
+import type { TableRenderingData, TableService } from '../baseTable'
+
+export function useStaticTableService<Model>(initialRows: Model[]) {
+  const tableRows = ref<Model[]>(initialRows);
+
+  const staticTableService = computed<TableService<Model>>(() => {
+    return {
+      getData(): TableRenderingData<Model> {
+        return {
+          totalItems: tableRows.value.length,
+          currentPageItems: tableRows.value as Model[],
+          loadingStatus: new Set<LoadingStatus>(),
+          rows: tableRows.value as Model[],
+          currentPage: 1
+        }
+      },
+      async sort(_sortDetail: SortDetail<Model>) {
+        return {
+          totalItems: tableRows.value.length,
+          items: tableRows.value as Model[]
+        }
+      },
+      async fetchRows() {
+        return {
+          totalItems: tableRows.value.length,
+          items: tableRows.value as Model[]
+        }
+      },
+      async paginate(_nextPage: number, _pageSize: number) {
+        return {
+          totalItems: tableRows.value.length,
+          items: tableRows.value as Model[]
+        }
+      }
+    }
+  })
+
+  return {
+    tableRows,
+    staticTableService
+  }
+}

package/src/composables/index.ts

@@ -0,0 +1,7 @@
+export { useRepository } from "./UseRepository";
+export { useData } from "./UseData";
+export { useParams } from "./UseParams";
+export { useLoadingStatus } from "./UseLoadingStatus";
+export { useStaticTableService } from "./UseStaticTableService";
+export * from "./UseCrud";
+export * from "./UseState";

package/src/constants/Constants.ts

@@ -0,0 +1,126 @@
+export const enum LoadingStatus {
+  FetchList = "fetchList",
+  AutoRefresh = "autoRefresh",
+  FetchItem = "fetchItem",
+  FetchLastItems = "fetchLastItems",
+  FetchPreviousItems = "fetchPreviousItems",
+  Create = "CREATE",
+  Update = "UPDATE",
+  Delete = "DELETE",
+  Search = "SEARCH",
+  Sort = "SORT",
+  Success = "SUCCESS",
+  Error = "ERROR",
+  Idle = "IDLE",
+}
+
+export const enum DialogDimensions {
+  Width = "width",
+  Height = "height",
+  DefaultWidth = 500,
+  DefaultHeight = 350,
+  MinimalAvailableSize = 0,
+}
+
+export const enum SortOrder {
+  ASC = "ASC",
+  DESC = "DESC",
+}
+
+export const enum SortOrderTableHeader {
+  ASC = "ascend",
+  DESC = "descend",
+}
+
+export const enum TableHeaderAlign {
+  Left = "left",
+  Right = "right",
+  Center = "center",
+}
+
+export const enum HeaderType {
+  Text = "text",
+}
+
+export const enum CellType {
+  Text = "text",
+  ACTION = "action",
+  Tag = "tag",
+  Iban = "iban",
+  BankCard = "bankCard",
+  Symbol = "symbol",
+  TradeDetail = "tradeDetail",
+  SymbolPrice = "symbolPrice",
+  TradeSymbol = "tradeSymbol",
+  Price = "price",
+  DynamicCurrencyPrice = "dynamicCurrencyPrice",
+  TradeDate = "tradeDate",
+  RequestResponseIdentity = "requestResponseIdentity",
+  Image = 'image'
+}
+
+export const enum TableConstants {
+  MINIMAL_LOADABLE_HEADER_COUNT = 0,
+  DEFAULT_ITEM_COUNT_PER_PAGE = 20,
+  PAGINATION_POSITION = "bottomCenter",
+}
+
+export const enum ApplicationTheme {
+  FontFamily = "IRANSansX",
+}
+
+export const enum ApplicationDrawerStatus {
+  Open = "open",
+  Close = "close",
+}
+
+export const enum ToastType {
+  Success = "success",
+  Failure = "error",
+  Info = "info",
+  Warning = "warning",
+}
+
+export const enum ToastLocation {
+  BottomLeft = "bottomLeft",
+}
+
+export const enum StatusCode {
+  NotFound = 404,
+  Unauthorized = 401,
+  ServerError = 500,
+}
+
+export const enum FormValidationStatus {
+  Invalid,
+  Valid,
+}
+
+export const enum StorageKeys {
+  Theme = "theme",
+  AccessList = "accessList",
+  Token = 'token',
+  SSO_ACCESS_LIST = 'ssoAccessList'
+}
+
+export const enum ApplicationTheme {
+  Light = "light",
+  Dark = "dark",
+}
+
+export const enum ComponentSize {
+  Small = "small",
+  Medium = "medium",
+  Large = "large",
+}
+
+export const enum StoreNames {
+  Dialog = "dialog",
+  Drawer = "drawer",
+  Module = "module",
+  Toast = "toast",
+}
+
+export const enum Symbols {
+  USDT = "USDT",
+}

package/src/constants/index.ts

@@ -0,0 +1,19 @@
+export {
+  LoadingStatus,
+  DialogDimensions,
+  SortOrder,
+  SortOrderTableHeader,
+  TableHeaderAlign,
+  HeaderType,
+  CellType,
+  TableConstants,
+  ApplicationDrawerStatus,
+  ToastType,
+  ToastLocation,
+  StatusCode,
+  FormValidationStatus,
+  StorageKeys,
+  ApplicationTheme,
+  StoreNames,
+  Symbols,
+} from "./Constants";