@beinformed/ui 1.65.13 → 1.65.15

package/src/redux/_modularui/ModularUIActions.js

@@ -1,227 +0,0 @@
-// @flow
-import { HTTP_METHODS, MODULARUI_STATUS } from "../../constants/Constants";
-import Href from "../../models/href/Href";
-import ErrorResponse from "../../models/error/ErrorResponse";
-import { finishProgress, startProgress } from "../actions/ProgressIndicator";
-import { handleError } from "../actions/Error";
-
-import type { ModularUIModel } from "../../models/types";
-import type { Dispatch, ThunkAction } from "../types";
-import type {
-  ModularUIAction,
-  SetModelAction,
-  InitModelAction,
-  UpdateModelAction,
-  UpdateFormAction,
-  RemoveModelByKeyAction,
-  ResetModularUIAction,
-  UpdateStatusAction,
-} from "./types";
-import type {
-  RequestModularUIOptions,
-  UpdateHandler,
-} from "../../utils/fetch/types";
-
-/**
- */
-export const setModel = (
-  key: string,
-  model: ModularUIModel,
-): SetModelAction => {
-  // set key on model for later reference
-  model.connectKey = key;
-  return {
-    type: "MODULARUI/SET",
-    payload: {
-      key,
-      model,
-    },
-  };
-};
-
-/**
- */
-export const initModels = (
-  models: Array<{ key: string, model: ModularUIModel }>,
-): InitModelAction => ({
-  type: "MODULARUI/INIT",
-  payload: models,
-});
-
-/**
- */
-export const updateModel = (model: ModularUIModel): UpdateModelAction => ({
-  type: "MODULARUI/UPDATE",
-  payload: model,
-});
-
-/**
- */
-export const updateForm = (model: ModularUIModel): UpdateFormAction => ({
-  type: "MODULARUI/UPDATE_FORM",
-  payload: model,
-});
-
-/**
- */
-export const removeModelByKey = (key: string): RemoveModelByKeyAction => ({
-  type: "MODULARUI/REMOVE_KEY",
-  payload: key,
-});
-
-/**
- * Removes all models except the application model from the modular ui reducer
- */
-export const resetModularUI = (): ResetModularUIAction => ({
-  type: "MODULARUI/RESET",
-});
-
-/**
- */
-export const updateStatus = (
-  key: string,
-  status: $Keys<typeof MODULARUI_STATUS>,
-  requestOptions: any,
-): UpdateStatusAction => ({
-  type: "MODULARUI/STATUS",
-  payload: { key, status, requestOptions },
-});
-
-/**
- */
-const loadModelSuccessAction = (
-  key: string,
-  model: ModularUIModel,
-  updateHandler: UpdateHandler | void,
-): UpdateModelAction | SetModelAction => {
-  if (updateHandler) {
-    return updateModel(updateHandler(model));
-  }
-  return setModel(key, model);
-};
-
-/**
- * Retrieve the preferred language for this request, falls back to the browser language or english
- */
-const getRequestLocale = (optionLocale: ?string): string => {
-  if (optionLocale) {
-    return optionLocale;
-  }
-
-  if (typeof navigator !== "undefined" && navigator?.language) {
-    return navigator.language.split("-")[0] || "en";
-  }
-
-  return "en";
-};
-
-/**
- * This action is handled by the modularui middleware
- */
-export const loadModel = (
-  key: string,
-  href: Href | string,
-  options?: RequestModularUIOptions,
-): ModularUIAction => ({
-  type: "MODULARUI/FETCH",
-  payload: {
-    key,
-    origin: options?.origin,
-    contextPath: options?.contextPath,
-    href:
-      href instanceof Href
-        ? href
-        : new Href(href, "", {
-            origin: options?.origin,
-            contextPath: options?.contextPath,
-          }),
-    method: options?.method ?? HTTP_METHODS.GET,
-    params: options?.params,
-    data: options?.data,
-    timeout: options?.timeout,
-    headers: options?.headers,
-    events: options?.events,
-    onProgress: options?.onProgress,
-    locale: getRequestLocale(options?.locale),
-    childmodels: options?.childmodels,
-    targetModel: options?.targetModel,
-    forceTargetModel: options?.forceTargetModel,
-    cache: options?.cache,
-    isReload: options?.isReload,
-    withCredentials: options?.withCredentials,
-    /**
-     */
-    successAction: (model) =>
-      loadModelSuccessAction(key, model, options?.updateHandler),
-    /**
-     */
-    errorAction: (error) => {
-      const errorResponse = new ErrorResponse(error, key, {
-        origin: options?.origin,
-        contextPath: options?.contextPath,
-      });
-      if (
-        errorResponse.isChangePassword ||
-        errorResponse.isResourceNotFoundAfterReload
-      ) {
-        return removeModelByKey(key);
-      }
-      return updateStatus(key, MODULARUI_STATUS.ERROR);
-    },
-  },
-});
-
-/**
- */
-export const loadModularUI =
-  (
-    key: string,
-    href: Href | string,
-    options?: RequestModularUIOptions,
-    retryCount: number = 3,
-    retryDelay: number = 200,
-  ): ThunkAction =>
-  (dispatch: Dispatch, getState) => {
-    const modularuiStore = getState()?.modularui;
-    const currentRequest = modularuiStore?.[key];
-
-    const isLoading = currentRequest?.status === MODULARUI_STATUS.LOADING;
-
-    if (isLoading) {
-      const isDifferentRequest =
-        currentRequest.requestOptions?.href?.toString() !== href.toString();
-      if (isDifferentRequest && retryCount > 0) {
-        return new Promise((resolve) => {
-          setTimeout(() => {
-            resolve(
-              dispatch(
-                loadModularUI(key, href, options, retryCount - 1, retryDelay),
-              ),
-            );
-          }, retryDelay);
-        });
-      }
-
-      // Same request is already loading — do nothing
-      return Promise.resolve();
-    }
-
-    dispatch(startProgress());
-
-    const loadModelPromise = dispatch(loadModel(key, href, options));
-
-    return Promise.resolve(loadModelPromise)
-      .then(() => dispatch(finishProgress()))
-      .catch((error) => dispatch(handleError(error)));
-  };
-
-/**
- */
-export const reloadModel = (
-  model: ModularUIModel,
-  options?: RequestModularUIOptions,
-): ThunkAction =>
-  loadModularUI(model.connectKey, model.selfhref, {
-    ...options,
-    isReload: true,
-  });

package/src/redux/_modularui/ModularUIConnector.js

@@ -1,157 +0,0 @@
-// @flow
-import { useEffect } from "react";
-import { useDispatch } from "react-redux";
-import { useLocation } from "react-router";
-
-import {
-  loadModularUI,
-  reloadModel,
-  removeModelByKey,
-} from "./ModularUIActions";
-
-import Href from "../../models/href/Href";
-import { getDisplayName } from "../../react/utils";
-
-import { useUrl, useReload } from "./ModularUIUtils";
-import { useModularUI } from "../../hooks/useModularUI";
-import { useLocale } from "../../hooks/useI18n";
-
-import type { ComponentType, Node } from "react";
-import type { Location } from "react-router";
-import type { ModularUIModel } from "../../models/types";
-import type { ModularUIOptions } from "./types";
-import FormModel from "../../models/form/FormModel";
-
-export type InjectedProps = {
-  +modelKey: string,
-  +location: Location,
-  +status: string | null,
-  +lastModification: number | null,
-  +hasModel: boolean,
-  +locale: string,
-  +fetchModularUI: (href: string | Href, fetchOptions: Object) => void,
-  +reloadModel: (model: ModularUIModel, options: Object) => void,
-  +data?: ?ModularUIModel,
-};
-
-const patchUpdateModelOption = (oldOptions: Object) => {
-  if (
-    "updateModel" in oldOptions &&
-    oldOptions.updateModel instanceof FormModel
-  ) {
-    return {
-      ...oldOptions,
-      updateHandler: (newModel: ModularUIModel): ModularUIModel => {
-        if (newModel instanceof FormModel) {
-          // $FLowFixMe
-          const clonedModel: FormModel = oldOptions.updateModel.clone();
-          clonedModel.update(newModel);
-          return clonedModel;
-        }
-        return newModel;
-      },
-    };
-  }
-
-  return oldOptions;
-};
-
-/**
- */
-const modularUIConnector = (
-  name: string,
-  resource: string | Function,
-  options: ModularUIOptions = { propName: "data", removeOnUnmount: false },
-): ((Component: ComponentType<any>) => (props: any) => Node) => {
-  const {
-    propName = "data",
-    removeOnUnmount = false,
-    ...otherOptions
-  } = options;
-
-  return (Component: ComponentType<any>) => {
-    const WrappedComponent = (props: any) => {
-      // explicit property for removeOnMount overwrite the setting
-      const finalRemoveOnUnmount = props.removeOnUnmount ?? removeOnUnmount;
-
-      const dispatch = useDispatch();
-      const location = useLocation();
-
-      const url = useUrl(resource, { location, ...props });
-      const displayName = getDisplayName(Component, name, props.contextId);
-
-      // Load the model through the useModUI hook
-      const modelEntry = useModularUI(displayName, url, {
-        ...otherOptions,
-        removeOnUnmount: finalRemoveOnUnmount,
-      });
-      const modelKey = modelEntry?.model?.connectKey;
-
-      // handle manual reload of model
-      const handleManualReload = (
-        model: ModularUIModel,
-        reloadOptions?: Object,
-      ) => {
-        dispatch(reloadModel(model, reloadOptions));
-      };
-
-      // Provide connected models with a fetchModularUI method to be able
-      // to run the loadModularUI action from a handler / callback in the component
-      const handleFetch = (href: string | Href, fetchOptions: Object) => {
-        dispatch(
-          loadModularUI(modelKey, href, patchUpdateModelOption(fetchOptions)),
-        );
-      };
-
-      // Check if current model needs a reload
-      const reload = location?.state?.reload ?? 0;
-      const doReload = useReload(modelEntry, reload);
-      useEffect(() => {
-        if (doReload) {
-          dispatch(
-            loadModularUI(modelKey, url, {
-              ...patchUpdateModelOption(otherOptions),
-              isReload: true,
-            }),
-          );
-        }
-      }, [dispatch, doReload, url, modelKey]);
-
-      // Remove model when hoc unloads
-      useEffect(
-        // prettier-ignore
-        () => () => { //NOSONAR
-          if (finalRemoveOnUnmount) {
-            dispatch(removeModelByKey(modelKey));
-          }
-        },
-        [dispatch, modelKey, finalRemoveOnUnmount],
-      );
-
-      // Create new properties object to inject modularui properties to own props
-      const locale = useLocale();
-      const newProps: InjectedProps = {
-        modelKey,
-        [propName]: modelEntry?.model ?? null,
-        location,
-        status: modelEntry?.status ?? null,
-        lastModification: modelEntry?.lastModification ?? null,
-        hasModel: Boolean(modelEntry),
-        locale,
-        fetchModularUI: handleFetch,
-        reloadModel: handleManualReload,
-      };
-
-      return <Component {...props} {...newProps} />;
-    };
-
-    WrappedComponent.displayName = `BI.modularui(${getDisplayName(
-      WrappedComponent,
-      name,
-    )}`;
-
-    return WrappedComponent;
-  };
-};
-
-export default modularUIConnector;

package/src/redux/_modularui/ModularUIMiddleware.js

@@ -1,182 +0,0 @@
-// @flow
-import ModularUIRequest from "../../modularui/ModularUIRequest";
-import { HTTP_METHODS, MODULARUI_STATUS } from "../../constants/Constants";
-
-import { startProgress, finishProgress } from "../actions/ProgressIndicator";
-import { handleError } from "../actions/Error";
-
-import { updateStatus } from "./ModularUIActions";
-
-import type { Middleware, MiddlewareAPI } from "redux";
-import type {
-  ReduxAction,
-  ReduxState,
-  Dispatch,
-  PossibleAction,
-} from "../types";
-import type { ModularUIModel } from "../../models/types";
-import type Href from "../../models/href/Href";
-import type { ModularUIAction, SuccessAction, ErrorAction } from "./types";
-import type { TargetModel } from "../../modularui/types";
-
-type RequestOptions = {
-  origin?: string,
-  contextPath?: string,
-  href: Href,
-  method?: $Keys<typeof HTTP_METHODS>,
-  params?: string,
-  data?: any,
-  timeout?: number,
-  locale: string,
-  childmodels?: boolean,
-  targetModel?: TargetModel,
-  forceTargetModel?: boolean,
-  isReload?: boolean,
-  cache?: boolean,
-  headers?: {
-    [headerName: string]: string,
-    Accept?: string,
-    "Accept-Language"?: string,
-    "Content-Type"?: string,
-    "x-filename"?: string,
-    "x-filesize"?: string,
-  },
-  events?: { [eventName: string]: () => void },
-  onProgress?: ProgressEventHandler,
-  withCredentials?: boolean,
-};
-
-/**
- * Symbol key that carries API call info interpreted by this Redux middleware.
- */
-const createRequest = (modularui: RequestOptions): ModularUIRequest => {
-  const request = new ModularUIRequest(modularui.href, {
-    method: modularui.method || HTTP_METHODS.GET,
-    params: modularui.params || "",
-    data: modularui.data || {},
-    locale: modularui.locale,
-    childmodels: modularui.childmodels ?? true,
-    isReload: modularui.isReload,
-    cache: modularui.cache,
-    headers: modularui.headers,
-    events: modularui.events,
-    onProgress: modularui.onProgress,
-  });
-
-  if (modularui.origin) {
-    request.origin = modularui.origin;
-  }
-
-  if (modularui.contextPath) {
-    request.contextPath = modularui.contextPath;
-  }
-
-  if (modularui.targetModel) {
-    request.targetModel = modularui.targetModel;
-    request.forceTargetModel = modularui.forceTargetModel ?? false;
-  }
-
-  return request;
-};
-
-/**
- */
-const responseHandler = (
-  next: Dispatch,
-  dispatch: Dispatch,
-  successAction: SuccessAction,
-  model: ModularUIModel,
-) => {
-  if (successAction) {
-    const successResult = successAction(model);
-
-    if (successResult instanceof Promise) {
-      successResult
-        .then((result) => {
-          dispatch(result);
-        })
-        .catch((error) => {
-          next(handleError(error));
-        });
-    } else {
-      try {
-        dispatch(successResult);
-      } catch (error) {
-        throw new Error(
-          `Result of successResult is not a valid redux action: ${error}`,
-        );
-      }
-    }
-  }
-
-  return next(finishProgress());
-};
-
-/**
- */
-const errorHandler = (
-  next: Dispatch,
-  dispatch: Dispatch,
-  errorAction: ?ErrorAction,
-  err: any,
-) => {
-  dispatch(finishProgress());
-
-  if (errorAction) {
-    const errorResult = errorAction(err);
-
-    if (errorResult instanceof Promise) {
-      errorResult.then((result) => dispatch(result));
-    } else {
-      dispatch(errorResult);
-    }
-  }
-
-  return next(handleError(err));
-};
-
-/**
- */
-const handleFetch = (
-  action: ModularUIAction,
-  locale: string,
-  dispatch: Dispatch,
-  next: Dispatch,
-) => {
-  dispatch(startProgress());
-
-  const { key, successAction, errorAction, ...requestOptions } = action.payload;
-  requestOptions.locale = locale;
-
-  const modularuiRequest = createRequest(requestOptions);
-
-  dispatch(updateStatus(key, MODULARUI_STATUS.LOADING, requestOptions));
-
-  return modularuiRequest
-    .fetch()
-    .then((model) => responseHandler(next, dispatch, successAction, model))
-    .catch((error) => errorHandler(next, dispatch, errorAction, error));
-};
-
-/**
- */
-export const modularUIMiddleware: Middleware<
-  ReduxState,
-  ReduxAction,
-  Dispatch,
-> =
-  (api: MiddlewareAPI<ReduxState, ReduxAction, Dispatch>) =>
-  (next: Dispatch) =>
-  (action: PossibleAction) => {
-    if (action.type === "MODULARUI/FETCH") {
-      return handleFetch(
-        // $FlowExpectedError[incompatible-exact]
-        action,
-        api.getState().i18n.locale,
-        api.dispatch,
-        next,
-      );
-    }
-
-    return next(action);
-  };