@gisce/react-ooui 2.0.0-rc.8 → 2.0.0

package/src/widgets/modals/TranslationModal.tsx

@@ -1,202 +0,0 @@
-import React, { useContext, useEffect, useRef, useState } from "react";
-import { Modal, Button, Divider, Row, Space, Spin, Col } from "antd";
-import {
-  CheckOutlined,
-  CloseOutlined,
-  LoadingOutlined,
-} from "@ant-design/icons";
-import useWindowDimensions from "@/hooks/useWindowDimensions";
-import { LocaleContext, LocaleContextType } from "@/context/LocaleContext";
-import ConnectionProvider from "@/ConnectionProvider";
-import TextArea from "antd/lib/input/TextArea";
-import showErrorDialog from "@/ui/ActionErrorDialog";
-
-type TranslationModalProps = {
-  visible: boolean;
-  model: string;
-  id: number;
-  field: string;
-  onCloseModal: () => void;
-  onSubmitSucceed: () => void;
-};
-
-type Lang = {
-  code: string;
-  name: string;
-};
-
-type ValuesForLangs = {
-  [key: string]: string;
-};
-
-export const TranslationModal = (props: TranslationModalProps) => {
-  const { visible, onCloseModal, model, id, field, onSubmitSucceed } = props;
-
-  const { modalWidth } = useWindowDimensions();
-  const { t } = useContext(LocaleContext) as LocaleContextType;
-  const [langs, setLangs] = useState<Lang[]>([]);
-  const [isLoading, setIsLoading] = useState(false);
-  const [submitLoading, setSubmitLoading] = useState(false);
-  const [valuesForLangs, setValuesForLangs] = useState<ValuesForLangs>({});
-
-  const originalValuesForLangs = useRef<ValuesForLangs>();
-
-  useEffect(() => {
-    if (visible) {
-      fetchData();
-    } else {
-      setValuesForLangs({});
-    }
-  }, [visible]);
-
-  async function fetchData() {
-    setIsLoading(true);
-
-    try {
-      const langs = await getLangs();
-      await getValuesForLangs(langs);
-    } catch (err) {
-      showErrorDialog(err as any);
-    }
-
-    setIsLoading(false);
-  }
-
-  async function getLangs() {
-    const results: any[] = (await ConnectionProvider.getHandler().search({
-      params: [["translatable", "=", "1"]],
-      fields: ["code", "name"],
-      model: "res.lang",
-    })) as any;
-
-    const langs = results.map((item: any) => {
-      return {
-        code: item.code,
-        name: item.name,
-      };
-    });
-
-    setLangs?.(langs);
-    return langs;
-  }
-
-  async function getValuesForLangs(langs: Lang[]) {
-    const retrievedValuesForLang: ValuesForLangs = {};
-
-    for (const lang of langs) {
-      const retrievedValue = (
-        await ConnectionProvider.getHandler().readObjects({
-          model,
-          ids: [id],
-          fieldsToRetrieve: [field],
-          context: { lang: lang.code },
-        })
-      )[0];
-      retrievedValuesForLang[lang.code] = retrievedValue[field] || "";
-    }
-
-    originalValuesForLangs.current = retrievedValuesForLang;
-    setValuesForLangs(retrievedValuesForLang);
-  }
-
-  function getInputsForLangs() {
-    return langs.map((lang: Lang, i: number) => {
-      return (
-        <Row key={i} style={{ paddingBottom: 20 }}>
-          <Col flex="8rem" style={{ paddingRight: 10 }}>
-            {lang.name}
-          </Col>
-          <Col flex="auto">
-            <TextArea
-              rows={4}
-              value={valuesForLangs[lang.code] || ""}
-              onChange={(event: any) => {
-                setValuesForLangs({
-                  ...valuesForLangs,
-                  [lang.code]: event.target.value,
-                });
-              }}
-              disabled={submitLoading}
-            />
-          </Col>
-        </Row>
-      );
-    });
-  }
-
-  async function onSubmit() {
-    setSubmitLoading(true);
-
-    try {
-      for (const langCode of Object.keys(valuesForLangs)) {
-        if (
-          valuesForLangs[langCode] !== originalValuesForLangs.current![langCode]
-        ) {
-          await ConnectionProvider.getHandler().update({
-            model,
-            id,
-            values: { [field]: valuesForLangs[langCode] },
-            context: {
-              lang: langCode,
-            },
-            fields: {},
-          });
-        }
-      }
-    } catch (err) {
-      showErrorDialog(err as any);
-    }
-
-    setSubmitLoading(false);
-    onSubmitSucceed();
-  }
-
-  function content() {
-    if (isLoading) {
-      return <Spin />;
-    }
-
-    return (
-      <>
-        {getInputsForLangs()}
-        <Divider />
-        <Row justify="end">
-          <Space>
-            <Button
-              icon={<CloseOutlined />}
-              onClick={onCloseModal}
-              disabled={submitLoading}
-            >
-              {t("cancel")}
-            </Button>
-            <Button
-              icon={submitLoading ? <LoadingOutlined /> : <CheckOutlined />}
-              disabled={submitLoading}
-              onClick={onSubmit}
-              style={{ marginLeft: 15 }}
-              type="primary"
-            >
-              {t("ok")}
-            </Button>
-          </Space>
-        </Row>
-      </>
-    );
-  }
-
-  return (
-    (<Modal
-      title={t("translate")}
-      centered
-      width={modalWidth}
-      open={visible}
-      closable={true}
-      onCancel={onCloseModal}
-      footer={null}
-      destroyOnClose
-      maskClosable={false}
-    >
-      {content()}
-    </Modal>)
-  );
-};

package/src/widgets/views/Dashboard/Dashboard.tsx

@@ -1,381 +0,0 @@
-import React, {
-  forwardRef,
-  useContext,
-  useEffect,
-  useImperativeHandle,
-  useRef,
-  useState,
-} from "react";
-import ActionView from "@/views/ActionView";
-import { fetchAction } from "./dashboardHelper";
-import "react-resizable/css/styles.css";
-import "react-grid-layout/css/styles.css";
-import { Graph } from "../Graph/Graph";
-import { DashboardGrid, DashboardGridItem } from "../DashboardGrid";
-import ConnectionProvider from "@/ConnectionProvider";
-import { DashboardProps, FormView } from "@/types";
-import { One2manyItem } from "@/index";
-import { readObjectValues } from "@/helpers/one2manyHelper";
-import { LoadingOutlined } from "@ant-design/icons";
-import { Alert } from "antd";
-import {
-  DashboardActionContext,
-  DashboardActionContextType,
-} from "@/context/DashboardActionContext";
-import { ShortcutApi } from "@/ui/FavouriteButton";
-import DashboardTree from "./DashboardTree";
-import { DashboardForm } from "./DashboardForm";
-
-const itemsField = "line_ids";
-
-function Dashboard(props: DashboardProps, ref: any) {
-  const { model, context = {}, id, configAction } = props;
-  const [dashboardItems, setDashboardItems] = useState<any[]>([]);
-  const [isLoading, setIsLoading] = useState<boolean>(false);
-  const [error, setError] = useState<string>();
-  const {
-    setIsLoading: setActionBarLoading,
-    openAction,
-    moveItemsEnabled,
-  } = useContext(DashboardActionContext) as DashboardActionContextType;
-
-  const itemsFields = useRef<any>();
-  const boardFields = useRef<any>();
-
-  useEffect(() => {
-    fetchData();
-  }, [model, id, context]);
-
-  useImperativeHandle(ref, () => ({
-    refresh: () => {
-      fetchData();
-    },
-    configDashboard: openConfigDashboard,
-  }));
-
-  async function fetchData() {
-    setIsLoading(true);
-    setActionBarLoading(true);
-    setError(undefined);
-
-    try {
-      const view: FormView = (await fetchView()) as FormView;
-      const values = await fetchValues(view);
-      const model = view.fields[itemsField].relation;
-      const items: One2manyItem[] = values[itemsField].items;
-      boardFields.current = view.fields;
-
-      const originalItems: One2manyItem[] = await fetchDashboardItems({
-        items,
-        model,
-        context,
-      });
-
-      const itemsWithActions = await getItemsWithActions(originalItems);
-      setDashboardItems(itemsWithActions);
-      setIsLoading(false);
-      setActionBarLoading(false);
-    } catch (err) {
-      setError(JSON.stringify(err));
-    }
-  }
-
-  async function fetchView() {
-    return await ConnectionProvider.getHandler().getView({
-      model,
-      type: "form",
-      context,
-    });
-  }
-
-  async function fetchDashboardItems({
-    items,
-    model,
-    context,
-  }: {
-    items: One2manyItem[];
-    model: string;
-    context: any;
-  }) {
-    itemsFields.current = (
-      (await ConnectionProvider.getHandler().getView({
-        model,
-        type: "form",
-        context,
-      })) as FormView
-    ).fields;
-
-    const [results] = await readObjectValues({
-      treeView: {
-        fields: itemsFields.current,
-      },
-      formView: {
-        fields: itemsFields.current,
-      },
-      model,
-      items,
-      context,
-      currentView: "form",
-    });
-    return results;
-  }
-
-  async function fetchValues(view: FormView) {
-    return (
-      await ConnectionProvider.getHandler().readObjects({
-        model,
-        ids: [id],
-        fields: view.fields,
-        context,
-      })
-    )[0];
-  }
-
-  async function getItemsWithActions(items: One2manyItem[]) {
-    const itemsWithActions = [];
-
-    for (const dashboardItem of items) {
-      const { values } = dashboardItem;
-      if (values.action_id && values.action_id.length > 0) {
-        const actionId = parseInt(values.action_id[0], 10);
-        const actionData = await fetchAction({
-          actionId,
-          rootContext: context,
-        });
-        itemsWithActions.push({ ...dashboardItem, actionData });
-      }
-    }
-
-    return itemsWithActions;
-  }
-
-  async function onPositionItemsChanged(itemPositions: any[]) {
-    if (!moveItemsEnabled) {
-      return;
-    }
-
-    const differences = itemPositions.filter((itemPosition) => {
-      const dashboardItem = dashboardItems.find(
-        (dashboardItem) => dashboardItem.id === itemPosition.id
-      );
-      if (!dashboardItem) {
-        return false;
-      }
-
-      if (!dashboardItem.position) {
-        return true;
-      }
-
-      const remotePosition = {
-        ...JSON.parse(dashboardItem.position.replace(/'/g, '"')),
-        id: dashboardItem.id,
-      };
-
-      return JSON.stringify(itemPosition) !== JSON.stringify(remotePosition);
-    });
-
-    if (differences.length === 0) {
-      return;
-    }
-
-    const itemsToUpdate = dashboardItems.filter((dashboardItem) => {
-      return differences.map((diff) => diff.id).includes(dashboardItem.id);
-    });
-
-    const itemsToUpdateWithUpdatedPos = itemsToUpdate.map((dashboardItem) => {
-      const diffItem = {
-        ...differences.find((diffItem) => diffItem.id === dashboardItem.id),
-      };
-      delete diffItem.id;
-
-      const item = { ...dashboardItem };
-      delete item.actionData;
-
-      return {
-        ...dashboardItem,
-        operation: "pendingUpdate",
-        values: {
-          ...dashboardItem.values,
-          position: JSON.stringify(diffItem).replace(/"/g, "'"),
-        },
-      };
-    });
-
-    const valueToUpdate = {
-      fields: itemsFields.current,
-      items: itemsToUpdateWithUpdatedPos,
-    };
-
-    await ConnectionProvider.getHandler().update({
-      model,
-      id,
-      values: { [itemsField]: valueToUpdate },
-      fields: boardFields.current,
-      context,
-    });
-  }
-
-  async function openConfigDashboard() {
-    openAction(configAction);
-  }
-
-  if (error) {
-    console.log(error);
-    return (
-      <Alert className="mt-10 mb-20" message={error} type="error" banner />
-    );
-  }
-
-  if (isLoading) {
-    return <LoadingOutlined />;
-  }
-
-  return (
-    <DashboardGrid onPositionItemsChanged={onPositionItemsChanged}>
-      {dashboardItems.map((item, idx) => {
-        const { actionData, values } = item;
-        const { position, id } = values;
-
-        const {
-          actionId,
-          actionType,
-          key,
-          title,
-          views,
-          model,
-          context,
-          domain,
-          initialView,
-          limit,
-        } = actionData as any;
-
-        let parmsParsed = {};
-
-        try {
-          parmsParsed = JSON.parse(position.replace(/'/g, '"'));
-        } catch (err) {
-          // console.error(`Error parsing parms: ${action.position}`);
-          parmsParsed = { x: idx * 2, y: 0, w: 2, h: 3 };
-        }
-
-        let childContent = null;
-
-        if (initialView?.type === "graph") {
-          childContent = (
-            <Graph
-              view_id={
-                views.filter(
-                  (view: [number, string]) => view[1] === "graph"
-                )[0][0]
-              }
-              model={model}
-              context={context}
-              domain={domain}
-              limit={limit}
-            />
-          );
-        } else if (initialView?.type === "form") {
-          childContent = <DashboardForm model={model} actionDomain={domain} />;
-        } else if (initialView?.type === "tree") {
-          childContent = (
-            <DashboardTree
-              model={model}
-              domain={domain}
-              view_id={
-                views.filter(
-                  (view: [number, string]) => view[1] === "tree"
-                )[0][0]
-              }
-              onRowClicked={(record) => {
-                const formView = views.find((view: any[]) => {
-                  const [, type] = view;
-                  return type === "form";
-                });
-                if (formView) {
-                  const [id, type] = formView;
-                  const {
-                    actionId: action_id,
-                    actionType: action_type,
-                    title: name,
-                    model: res_model,
-                  } = actionData;
-
-                  const action: ShortcutApi = {
-                    action_id,
-                    action_type,
-                    name,
-                    res_id: record.id,
-                    res_model,
-                    view_id: id,
-                    view_type: type,
-                  };
-                  openAction(action);
-                }
-              }}
-            />
-          );
-        } else if (initialView !== undefined) {
-          const formattedInitialView =
-            initialView && Array.isArray(initialView.id)
-              ? { ...initialView, id: initialView.id[0] }
-              : initialView;
-          childContent = (
-            <ActionView
-              action_id={actionId}
-              action_type={actionType}
-              tabKey={key}
-              title={title}
-              views={views}
-              model={model}
-              context={context}
-              domain={domain}
-              setCanWeClose={() => {}}
-              initialView={formattedInitialView}
-              limit={limit}
-            />
-          );
-        }
-
-        let action: ShortcutApi;
-        const treeView = views.find((view: any[]) => {
-          const [, type] = view;
-          return type === "tree";
-        });
-        if (treeView) {
-          const [id, type] = treeView;
-          const {
-            actionId: action_id,
-            actionType: action_type,
-            title: name,
-            model: res_model,
-          } = actionData;
-
-          action = {
-            action_id,
-            action_type,
-            name,
-            res_id: false,
-            res_model,
-            view_id: id,
-            view_type: type,
-          };
-        }
-
-        return (
-          <DashboardGridItem
-            key={id}
-            id={id}
-            title={title}
-            parms={parmsParsed}
-            action={action!}
-            openAction={openAction}
-          >
-            {childContent}
-          </DashboardGridItem>
-        );
-      })}
-    </DashboardGrid>
-  );
-}
-
-export default forwardRef(Dashboard);

package/src/widgets/views/Dashboard/DashboardForm.tsx

@@ -1,30 +0,0 @@
-import ConnectionProvider from "@/ConnectionProvider";
-import React, { useEffect, useState } from "react";
-import Form, { FormProps } from "../Form";
-
-export const DashboardForm = (props: FormProps) => {
-  const { model } = props;
-  const [firstId, setFirstId] = useState<number>();
-
-  useEffect(() => {
-    fetchData();
-  }, [model]);
-
-  async function fetchData() {
-    const results: any[] = (await ConnectionProvider.getHandler().search({
-      params: [],
-      model,
-      limit: 1,
-    })) as any;
-
-    if (results.length > 0) {
-      setFirstId(results[0].id);
-    }
-  }
-
-  return (
-    <div style={{ padding: "0.5rem", overflowY: "scroll" }}>
-      <Form {...props} model={model} id={firstId} readOnly />
-    </div>
-  );
-};