@gisce/react-ooui 2.0.0-alpha.62 → 2.0.0-alpha.64

package/src/context/ContentRootContext.tsx

@@ -1,461 +0,0 @@
-import { FormView, GenerateReportOptions, ViewType } from "@/types";
-import React, {
-  useContext,
-  useRef,
-  useState,
-  forwardRef,
-  useImperativeHandle,
-} from "react";
-import showErrorDialog from "@/ui/ActionErrorDialog";
-import { openBase64InNewTab, getMimeType } from "@/helpers/filesHelper";
-import { parseContext } from "@gisce/ooui";
-import ConnectionProvider from "@/ConnectionProvider";
-import { Modal, Spin } from "antd";
-import {
-  TabManagerContext,
-  TabManagerContextType,
-} from "@/context/TabManagerContext";
-import { FormModal } from "@/widgets/modals/FormModal";
-import { LocaleContext, LocaleContextType } from "@/context/LocaleContext";
-import { transformPlainMany2Ones, stringFormat } from "@/helpers/formHelper";
-
-export type ContentRootContextType = {
-  processAction: ({
-    actionData,
-    fields,
-    values,
-    context,
-  }: {
-    actionData: any;
-    fields: any;
-    values: any;
-    context?: any;
-    onRefreshParentValues?: () => void;
-  }) => Promise<any>;
-  globalValues?: any;
-};
-
-type ActionModalOpts = {
-  model?: string;
-  domain?: any;
-  context: any;
-  formView?: FormView;
-  actionData?: any;
-};
-
-export const ContentRootContext =
-  React.createContext<ContentRootContextType | null>(null);
-
-type ContentRootProviderProps = {
-  children: React.ReactNode;
-  globalValues?: any;
-};
-
-const callRefreshValues = async (fns: any[]) => {
-  for (let i = 0; i < fns.length; i++) {
-    await fns?.[i]?.();
-  }
-};
-
-const ContentRootProvider = (
-  props: ContentRootProviderProps,
-  ref: any,
-): any => {
-  const { children, globalValues = {} } = props;
-  const reportInProgressInterval = useRef<any>();
-  const waitingForReport = useRef<boolean>();
-  const [reportGenerating, setReportGenerating] = useState<boolean>(false);
-  const tabManagerContext = useContext(
-    TabManagerContext,
-  ) as TabManagerContextType;
-  const { openAction } = tabManagerContext || {};
-  const onRefreshParentValues = useRef<any>([]);
-  const { t } = useContext(LocaleContext) as LocaleContextType;
-
-  useImperativeHandle(ref, () => ({
-    openActionModal,
-  }));
-
-  // Action modal state
-  const [actionModalVisible, setActionModalVisible] = useState<boolean>(false);
-
-  const [actionModalOptions, setActionModalOptions] = useState<ActionModalOpts>(
-    {
-      context: {},
-    },
-  );
-
-  async function generateReport(options: GenerateReportOptions) {
-    const { reportData, fields, values, context = {} } = options;
-
-    const {
-      context: reportContext,
-      model,
-      datas = {},
-      report_name,
-      type,
-    } = reportData;
-
-    if (type !== "ir.actions.report.xml") {
-      showErrorDialog(`${type} action not supported`);
-      return;
-    }
-
-    const { ids } = datas || {};
-
-    const idsToExecute = ids || [];
-
-    const reportContextParsed =
-      typeof reportContext === "string"
-        ? parseContext({
-            context: reportContext,
-            fields,
-            values,
-          })
-        : reportContext;
-
-    try {
-      const newReportId = await ConnectionProvider.getHandler().createReport({
-        model,
-        name: report_name,
-        datas,
-        ids: idsToExecute,
-        context: { ...context, ...reportContextParsed },
-      });
-
-      setReportGenerating(true);
-
-      waitingForReport.current = true;
-      reportInProgressInterval.current = setInterval(() => {
-        evaluateReportStatus(newReportId);
-      }, 1000);
-    } catch (err) {
-      waitingForReport.current = false;
-      clearInterval(reportInProgressInterval.current);
-      showErrorDialog(err);
-      setReportGenerating(false);
-    }
-  }
-
-  async function evaluateReportStatus(id: any) {
-    let reportState;
-    try {
-      reportState = await ConnectionProvider.getHandler().getReport({
-        id,
-      });
-      if (reportState.state && waitingForReport.current === true) {
-        waitingForReport.current = false;
-        clearInterval(reportInProgressInterval.current);
-        setReportGenerating(false);
-        const fileType: any = await getMimeType(reportState.result);
-        openBase64InNewTab(reportState.result, fileType.mime);
-      }
-    } catch (error) {
-      waitingForReport.current = false;
-      clearInterval(reportInProgressInterval.current);
-      setReportGenerating(false);
-      showErrorDialog(error.exception || error);
-    }
-  }
-
-  async function processAction({
-    actionData,
-    fields,
-    values,
-    context,
-    onRefreshParentValues: onRefreshParentValuesFn,
-  }: {
-    actionData: any;
-    fields: any;
-    values: any;
-    context?: any;
-    onRefreshParentValues?: any;
-  }) {
-    const { type } = actionData;
-    onRefreshParentValues.current.push(onRefreshParentValuesFn);
-
-    if (type === "ir.actions.report.xml") {
-      return await generateReport({
-        reportData: actionData,
-        fields,
-        values,
-        context,
-      });
-    } else if (type === "ir.actions.act_window") {
-      return await runAction({ actionData, fields, values, context });
-    } else if (type === "ir.actions.act_url") {
-      window.open(
-        stringFormat(actionData.url, { ...values, context }),
-        "_blank",
-      );
-    } else {
-      showErrorDialog(`${type} action not supported`);
-      return {};
-    }
-  }
-
-  async function runAction({
-    actionData: _actionData,
-    fields = {},
-    values = {},
-    context = {},
-  }: {
-    actionData: any;
-    fields?: any;
-    values?: any;
-    context?: any;
-  }) {
-    let actionData = _actionData;
-
-    if (!_actionData.res_model) {
-      actionData = (
-        await ConnectionProvider.getHandler().readObjects({
-          model: "ir.actions.act_window",
-          ids: [parseInt(_actionData.id)],
-          context,
-        })
-      )[0];
-    }
-
-    const responseContext =
-      typeof actionData?.context === "string"
-        ? parseContext({
-            context: actionData.context,
-            fields,
-            values: { ...values, ...globalValues },
-          })
-        : actionData.context;
-
-    const mergedContext = {
-      ...context,
-      ...responseContext,
-    };
-
-    let parsedDomain = [];
-
-    if (actionData.domain) {
-      parsedDomain = await ConnectionProvider.getHandler().evalDomain({
-        domain: actionData.domain,
-        values: transformPlainMany2Ones({
-          fields,
-          values: { ...values, ...globalValues },
-        }),
-        fields,
-        context: mergedContext,
-      });
-    }
-
-    // -- Possible values for target property --
-    // * new ==> modal
-    // * current ==> new tab
-    // * undefined ==> new tab
-    if (actionData.target === "new") {
-      const formView = (await ConnectionProvider.getHandler().getView({
-        model: actionData.res_model,
-        type: "form",
-        id: actionData?.view_id?.[0] || undefined,
-        context: mergedContext,
-      })) as FormView;
-
-      openActionModal({
-        domain: parsedDomain,
-        model: actionData.res_model,
-        formView,
-        context: mergedContext,
-      });
-
-      return {};
-    } else {
-      const { initialView, views } = await getViewsAndInitialView({
-        model: actionData.res_model,
-        context: mergedContext,
-        view_mode: actionData.view_mode,
-        views: actionData.views,
-      });
-
-      openAction?.({
-        target: "current",
-        context: mergedContext,
-        domain: parsedDomain,
-        model: actionData.res_model,
-        views,
-        title: actionData.name,
-        initialView,
-        action_id: actionData.id,
-        action_type: actionData.type,
-      });
-
-      return { closeParent: true };
-    }
-  }
-
-  function openActionModal({
-    domain,
-    model,
-    formView,
-    context,
-    actionData,
-  }: {
-    domain: any;
-    model: string;
-    formView: FormView;
-    context: any;
-    actionData?: any;
-  }) {
-    if (actionModalVisible) {
-      openNewActionModal({ domain, model, formView, context, actionData });
-    } else {
-      setActionModalOptions({ domain, model, context, formView, actionData });
-      setActionModalVisible(true);
-    }
-  }
-
-  async function openNewActionModal({
-    domain,
-    model,
-    formView,
-    context,
-    actionData,
-  }: {
-    domain: any;
-    model: string;
-    formView: FormView;
-    context: any;
-    actionData?: any;
-  }) {
-    setActionModalOptions({
-      domain: undefined,
-      model: undefined,
-      context: {},
-      formView: undefined,
-      actionData: undefined,
-    });
-    setActionModalVisible(false);
-    await new Promise((resolve) => setTimeout(resolve, 300));
-    setActionModalOptions({ domain, model, context, formView, actionData });
-    setActionModalVisible(true);
-  }
-
-  async function onFormModalSucceed() {
-    callRefreshValues(onRefreshParentValues.current);
-    onRefreshParentValues.current = [];
-    setActionModalVisible(false);
-    setActionModalOptions({
-      domain: undefined,
-      model: undefined,
-      context: {},
-      formView: undefined,
-      actionData: undefined,
-    });
-  }
-
-  return (
-    <>
-      <ContentRootContext.Provider
-        value={{
-          processAction,
-          globalValues,
-        }}
-      >
-        <>
-          {children}
-          <Modal
-            title={t("generatingReport")}
-            open={reportGenerating}
-            footer={null}
-            closable={false}
-            centered
-            maskClosable={false}
-          >
-            <Spin />
-          </Modal>
-          <FormModal
-            buttonModal
-            parentContext={actionModalOptions.context}
-            model={actionModalOptions.model!}
-            formView={actionModalOptions.formView}
-            visible={actionModalVisible}
-            onSubmitSucceed={onFormModalSucceed}
-            onCancel={() => {
-              callRefreshValues(onRefreshParentValues.current);
-              onRefreshParentValues.current = [];
-              setActionModalVisible(false);
-              setActionModalOptions({
-                domain: undefined,
-                model: undefined,
-                context: {},
-                formView: undefined,
-                actionData: undefined,
-              });
-            }}
-            showFooter={false}
-            actionDomain={actionModalOptions.domain}
-            isMenuAction={actionModalOptions?.actionData !== undefined}
-            actionData={actionModalOptions?.actionData}
-          />
-        </>
-      </ContentRootContext.Provider>
-    </>
-  );
-};
-
-async function getViewsAndInitialView({
-  views,
-  view_mode,
-  model,
-  context,
-  view_id,
-}: {
-  views: any[];
-  view_mode: string;
-  model: string;
-  context: any;
-  view_id?: number;
-}) {
-  const retriedViewData = [];
-  let initialView;
-
-  if (views) {
-    for (const view of views) {
-      const viewData = await ConnectionProvider.getHandler().getView({
-        model,
-        type: view[1],
-        id: view[0],
-        context,
-      });
-      retriedViewData.push([viewData.view_id, view[1]]);
-    }
-  } else {
-    const viewTypes = view_mode.split(",");
-    for (const viewType of viewTypes) {
-      const viewData = await ConnectionProvider.getHandler().getView({
-        model,
-        type: viewType as ViewType,
-        context,
-      });
-      retriedViewData.push([viewData.view_id, viewType]);
-    }
-  }
-  if (views && views.length > 0) {
-    const [id, type] = views[0];
-    initialView = {
-      id,
-      type,
-    };
-  } else if (!view_id) {
-    const type = view_mode.split(",")[0];
-    const [retrievedViewId] = retriedViewData.find(
-      ([_, viewType]) => viewType === type,
-    )!;
-    initialView = { id: retrievedViewId, type };
-  } else {
-    initialView = {
-      id: view_id,
-      type: view_mode.split(",")[0],
-    };
-  }
-
-  return { views: retriedViewData, initialView };
-}
-
-export default forwardRef(ContentRootProvider);

package/src/context/DashboardActionContext.tsx

@@ -1,44 +0,0 @@
-import { ShortcutApi } from "@/ui/FavouriteButton";
-import React, { useState } from "react";
-
-export type DashboardActionContextType = {
-  isLoading: boolean;
-  setIsLoading: (value: boolean) => void;
-  dashboardRef: any;
-  openAction: (action?: ShortcutApi) => void;
-  moveItemsEnabled: boolean;
-  setMoveItemsEnabled: (value: boolean) => void;
-};
-
-export const DashboardActionContext =
-  React.createContext<DashboardActionContextType | null>(null);
-
-type DashboardActionProviderProps = {
-  children: React.ReactNode;
-  dashboardRef: any;
-  openAction: (action?: ShortcutApi) => void;
-};
-
-const DashboardActionProvider = (props: DashboardActionProviderProps): any => {
-  const [isLoading, setIsLoading] = useState<boolean>(false);
-  const [moveItemsEnabled, setMoveItemsEnabled] = useState<boolean>(false);
-
-  const { children, dashboardRef, openAction } = props;
-
-  return (
-    <DashboardActionContext.Provider
-      value={{
-        isLoading,
-        setIsLoading,
-        dashboardRef,
-        openAction,
-        moveItemsEnabled,
-        setMoveItemsEnabled,
-      }}
-    >
-      {children}
-    </DashboardActionContext.Provider>
-  );
-};
-
-export default DashboardActionProvider;

package/src/context/FormContext.tsx

@@ -1,79 +0,0 @@
-import React, { useRef, useState } from "react";
-
-export type FormContextType = {
-  activeId?: number;
-  activeModel: string;
-  setFieldValue: (field: string, value?: string) => void;
-  getFieldValue: (field: string) => string;
-  executeButtonAction: ({
-    type,
-    action,
-    context,
-  }: {
-    type: string;
-    action: string;
-    context?: any;
-  }) => Promise<void>;
-  getContext: () => Promise<any>;
-  getValues: () => Promise<any>;
-  getPlainValues: () => { [key: string]: any };
-  getFields: () => Promise<any>;
-  domain: any[];
-  submitForm?: (options?: {
-    callOnSubmitSucceed?: boolean;
-  }) => Promise<{ succeed: boolean; id: number }>;
-  fetchValues?: () => void;
-  formHasChanges?: () => boolean;
-  elementHasLostFocus?: () => void;
-};
-
-export const FormContext = React.createContext<FormContextType | null>(null);
-
-type FormProviderProps = FormContextType & {
-  children: React.ReactNode;
-};
-
-const FormProvider = (props: FormProviderProps): any => {
-  const {
-    children,
-    activeId,
-    activeModel,
-    setFieldValue,
-    getFieldValue,
-    executeButtonAction,
-    getContext,
-    getValues,
-    getPlainValues,
-    domain,
-    submitForm,
-    fetchValues,
-    formHasChanges,
-    elementHasLostFocus,
-    getFields,
-  } = props;
-
-  return (
-    <FormContext.Provider
-      value={{
-        domain,
-        getValues,
-        getPlainValues,
-        getFields,
-        activeId,
-        activeModel,
-        setFieldValue,
-        getFieldValue,
-        executeButtonAction,
-        getContext,
-        submitForm,
-        fetchValues,
-        formHasChanges,
-        elementHasLostFocus,
-      }}
-    >
-      {children}
-    </FormContext.Provider>
-  );
-};
-
-export default FormProvider;

package/src/context/FormModalContext.tsx

@@ -1,28 +0,0 @@
-import React from "react";
-
-export type FormModalContextType = {
-  setTitle?: (title: string) => void;
-};
-
-export const FormModalContext =
-  React.createContext<FormModalContextType | null>(null);
-
-type FormModalProviderProps = FormModalContextType & {
-  children: React.ReactNode;
-};
-
-const FormModalProvider = (props: FormModalProviderProps): any => {
-  const { children, setTitle } = props;
-
-  return (
-    <FormModalContext.Provider
-      value={{
-        setTitle,
-      }}
-    >
-      {children}
-    </FormModalContext.Provider>
-  );
-};
-
-export default FormModalProvider;

package/src/context/LocaleContext.tsx

@@ -1,50 +0,0 @@
-import React from "react";
-import ca_ES from "@/locales/ca_ES";
-import en_US from "@/locales/en_US";
-import es_ES from "@/locales/es_ES";
-
-const localeStrings: any = {
-  ca_ES,
-  en_US,
-  es_ES,
-};
-
-export type LocaleContextType = {
-  lang: string;
-  t: (key: string) => string;
-};
-
-export const LocaleContext = React.createContext<LocaleContextType | null>(
-  null,
-);
-
-type LocaleContextProps = {
-  children: React.ReactNode;
-  lang: string;
-};
-
-const LocaleContextProvider = (props: LocaleContextProps): any => {
-  const { children, lang } = props;
-
-  function t(key: string): string {
-    return tForLang(key, lang);
-  }
-
-  return (
-    <LocaleContext.Provider
-      value={{
-        lang,
-        t,
-      }}
-    >
-      {children}
-    </LocaleContext.Provider>
-  );
-};
-
-export const tForLang = (key: string, lang: string) => {
-  const translated = localeStrings[lang]?.[key];
-  return translated || key;
-};
-
-export default LocaleContextProvider;

package/src/context/One2manyContext.tsx

@@ -1,45 +0,0 @@
-import { ViewType } from "@/types";
-import React, { useState } from "react";
-
-export type One2manyContextType = {
-  currentView: ViewType;
-  setCurrentView: (view: ViewType) => void;
-  itemIndex: number;
-  setItemIndex: (value: number) => void;
-  manualTriggerChange: boolean;
-  setManualTriggerChange: (value: boolean) => void;
-};
-
-export const One2manyContext = React.createContext<One2manyContextType | null>(
-  null,
-);
-
-const One2manyProvider = ({
-  children,
-  initialView,
-}: {
-  children: React.ReactNode;
-  initialView: ViewType;
-}): any => {
-  const [currentView, setCurrentView] = useState<ViewType>(initialView);
-  const [itemIndex, setItemIndex] = useState<number>(0);
-  const [manualTriggerChange, setManualTriggerChange] =
-    useState<boolean>(false);
-
-  return (
-    <One2manyContext.Provider
-      value={{
-        currentView,
-        setCurrentView,
-        itemIndex,
-        setItemIndex,
-        manualTriggerChange,
-        setManualTriggerChange,
-      }}
-    >
-      {children}
-    </One2manyContext.Provider>
-  );
-};
-
-export default One2manyProvider;