@gisce/react-ooui 1.2.0-rc.7 → 1.2.0-rc.71

package/src/helpers/one2manyHelper.ts

@@ -1,18 +1,33 @@
 import { One2manyItem } from "@/widgets/base/one2many/One2manyInput";
 import ConnectionProvider from "@/ConnectionProvider";
+import { TreeView, View, ViewType } from "@/types";
+import { getColorMap, getTree } from "./treeHelper";
 
 type ReadObjectValuesOptions = {
   items: One2manyItem[];
   model: string;
-  treeFields: any;
-  formFields: any;
   context?: any;
+  currentView: ViewType;
+  formView: {
+    fields: any;
+  };
+  treeView: {
+    arch?: string;
+    fields: any;
+  };
 };
 
 const readObjectValues = async (
   options: ReadObjectValuesOptions
-): Promise<One2manyItem[]> => {
-  const { items, model, formFields, treeFields, context = {} } = options;
+): Promise<[One2manyItem[], any]> => {
+  const {
+    items,
+    model,
+    formView,
+    treeView,
+    context,
+    currentView = {},
+  } = options;
 
   const temporalItems: One2manyItem = items.filter(
     (item) => item.operation !== "original"
@@ -23,50 +38,72 @@ const readObjectValues = async (
     .filter((item) => item.operation === "original")
     .map((item) => item.id) as number[];
 
-  const values = await ConnectionProvider.getHandler().readObjects({
-    model,
-    ids: idsToFetch,
-    fields: { ...formFields, ...treeFields },
-    context,
-  });
+  const fieldsToRetrieve: { [key: string]: any } = {
+    form: formView.fields,
+    tree: treeView.fields,
+  };
+
+  let values = [],
+    evaluatedColorsForTree;
+
+  if (currentView === "tree" && treeView?.arch) {
+    const colors = getTree(treeView as TreeView)?.colors;
+    const results = await ConnectionProvider.getHandler().readEvalUiObjects({
+      model,
+      ids: idsToFetch,
+      arch: treeView?.arch!,
+      fields: treeView!.fields,
+      context,
+      attrs: colors && {
+        colors,
+      },
+    });
+    values = results[0];
+    evaluatedColorsForTree = getColorMap(results[1]);
+  } else {
+    values = await ConnectionProvider.getHandler().readObjects({
+      model,
+      ids: idsToFetch,
+      fields: fieldsToRetrieve[currentView as string],
+      context,
+    });
+  }
 
-  const formValues = values.map((result: any) => {
+  const filteredValues = values.map((result: any) => {
     const resultFormValues: any = {};
     Object.keys(result).forEach((key) => {
-      if (formFields.hasOwnProperty(key) || key === "id") {
+      if (
+        fieldsToRetrieve[currentView as string].hasOwnProperty(key) ||
+        key === "id"
+      ) {
         resultFormValues[key] = result[key];
       }
     });
     return resultFormValues;
   });
 
-  const treeValues = values.map((result: any) => {
-    const resultTreeValues: any = {};
-    Object.keys(result).forEach((key) => {
-      if (treeFields.hasOwnProperty(key) || key === "id") {
-        resultTreeValues[key] = result[key];
-      }
-    });
-    return resultTreeValues;
-  });
-
   // We fill the values property of the One2manyItem with the retrieved values from the API
   const originalItemsWithFetchedValues: One2manyItem[] = items.map((item) => {
-    const fetchedFormItemValues = formValues.find(
-      (itemValues: any) => itemValues.id === item.id
-    );
-    const fetchedTreeItemValues = treeValues.find(
+    const fetchedItemValues = filteredValues.find(
       (itemValues: any) => itemValues.id === item.id
     );
 
-    return {
+    const itemWithFetchedValues = {
       ...item,
-      values: fetchedFormItemValues,
-      treeValues: fetchedTreeItemValues,
     };
+
+    if (currentView === "form") {
+      itemWithFetchedValues["values"] = fetchedItemValues;
+    } else if (currentView === "tree") {
+      itemWithFetchedValues["treeValues"] = fetchedItemValues;
+    }
+    return itemWithFetchedValues;
   });
 
-  return originalItemsWithFetchedValues.concat(temporalItems);
+  return [
+    originalItemsWithFetchedValues.concat(temporalItems),
+    evaluatedColorsForTree,
+  ];
 };
 
 type RemoveItemOptions = {
@@ -79,14 +116,8 @@ type RemoveItemOptions = {
 };
 
 const removeItems = async (options: RemoveItemOptions) => {
-  const {
-    model,
-    activeId,
-    fieldName,
-    idsToRemove,
-    fields,
-    isMany2many,
-  } = options;
+  const { model, activeId, fieldName, idsToRemove, fields, isMany2many } =
+    options;
 
   const values: any = {};
   values[fieldName] = [];
@@ -136,4 +167,28 @@ const getNextPendingId = (items: One2manyItem[]) => {
   }
 };
 
-export { readObjectValues, removeItems, linkItem, getNextPendingId };
+const convertToPlain2ManyValues = (values: any, fields: any) => {
+  const result: any = {};
+  Object.keys(values).forEach((key) => {
+    if (
+      fields.hasOwnProperty(key) &&
+      (fields[key].type === "one2many" || fields[key].type === "many2many") &&
+      values[key] &&
+      values[key]?.items
+    ) {
+      result[key] = values[key].items.filter(
+        (item: One2manyItem) => item.operation !== "pendingRemove"
+      );
+    } else {
+      result[key] = values[key];
+    }
+  });
+  return result;
+};
+export {
+  readObjectValues,
+  removeItems,
+  linkItem,
+  getNextPendingId,
+  convertToPlain2ManyValues,
+};

package/src/helpers/searchHelper.ts

@@ -5,14 +5,14 @@ const convertBooleanParamIfNeeded = (value: any) => {
   return value;
 };
 
-export const getParamsForFields = (values: any, fields: any) => {
+export const getParamsForFields = (values: any, widgetContainer: any) => {
   const filteredValues = removeUndefinedFields(values);
   const groupedDateTime = groupDateTimeValuesIfNeeded(filteredValues);
-  const groupedValues = ungroupDateValuesIfNeeded(groupedDateTime, fields);
+  const groupedValues = ungroupDateValuesIfNeeded(groupedDateTime, widgetContainer);
 
   const params = [
     ...Object.keys(groupedValues).map((key) => {
-      return getParamForField(key, groupedValues[key], fields);
+      return getParamForField(key, groupedValues[key], widgetContainer);
     }),
   ];
 
@@ -27,9 +27,9 @@ export const getParamsForFields = (values: any, fields: any) => {
   return paramsForFields;
 };
 
-const getParamForField = (key: string, value: any, fields: any) => {
+const getParamForField = (key: string, value: any, widgetContainer: any) => {
   const filteredKey = key.split("#")[0];
-  const type = fields[filteredKey].type;
+  const type = widgetContainer.findById(filteredKey)?.type;
 
   if (
     type === "char" ||
@@ -127,9 +127,10 @@ export const groupDateTimeValuesIfNeeded = (values: any) => {
   return newValues;
 };
 
-const ungroupDateValuesIfNeeded = (values: any, fields: any) => {
+const ungroupDateValuesIfNeeded = (values: any, widgetContainer: any) => {
   const dateFields = Object.keys(values).filter((key) => {
-    return fields[key] && fields[key].type === "date";
+    const widget = widgetContainer.findById(key);
+    return widget && widget.type === "date";
   });
 
   let newValues: any = { ...values };

package/src/helpers/treeHelper.ts

@@ -1,4 +1,10 @@
-import { Tree as TreeOoui, Selection, Many2one, Boolean } from "@gisce/ooui";
+import {
+  Tree as TreeOoui,
+  Selection,
+  Many2one,
+  Boolean,
+  Reference,
+} from "@gisce/ooui";
 import { TreeView, Column } from "@/types";
 
 const getTree = (treeView: TreeView): TreeOoui => {
@@ -9,7 +15,11 @@ const getTree = (treeView: TreeView): TreeOoui => {
   return tree;
 };
 
-const getTableColumns = (tree: TreeOoui, components: any): Array<Column> => {
+const getTableColumns = (
+  tree: TreeOoui,
+  components: any,
+  context: any
+): Array<Column> => {
   const tableColumns = tree.columns.map((column) => {
     const type = column.type;
     const key = column.id;
@@ -18,7 +28,7 @@ const getTableColumns = (tree: TreeOoui, components: any): Array<Column> => {
 
     if (component) {
       render = (item: any) => {
-        return component(item);
+        return component(item, key, column, context);
       };
     }
 
@@ -54,9 +64,11 @@ const getTableItems = (treeOoui: TreeOoui, results: Array<any>): Array<any> => {
       } else {
         const widget = treeOoui.findById(key);
 
-        if (widget instanceof Selection) {
+        if (widget instanceof Reference) {
+          parsedItem[key] = item[key];
+        } else if (widget instanceof Selection) {
           const selection = widget;
-          parsedItem[key] = selection.selectionValues.get(item[key]);
+          parsedItem[key] = item[key];
         } else if (widget instanceof Many2one) {
           parsedItem[key] = item[key] &&
             Array.isArray(item[key]) &&

package/src/hooks/useExport.ts

@@ -0,0 +1,439 @@
+import {
+  ExportField,
+  ExportOptions,
+  PredefinedExport,
+  PredefinedExportField,
+} from "@gisce/react-formiga-components";
+import { useCallback, useRef } from "react";
+import { ConnectionProvider } from "..";
+import showInfo from "@/ui/InfoDialog";
+import { tForLang } from "@/context/LocaleContext";
+import { getMimeType, openBase64InNewTab } from "@/helpers/filesHelper";
+
+export const useExport = ({
+  model,
+  context,
+  locale,
+  selectedRegistersToExport,
+  domain,
+  limit,
+  onClose,
+}: {
+  model: string;
+  context: any;
+  locale: string;
+  selectedRegistersToExport?: any[];
+  domain: any[];
+  limit?: number;
+  onClose: () => void;
+}) => {
+  const fields = useRef<any>({});
+  const exportModelFields = useRef<Map<string, any>>(new Map<string, any>());
+
+  const onExport = useCallback(
+    async (options: ExportOptions) => {
+      if (
+        options.selectedKeys === undefined ||
+        options.selectedKeys.length === 0
+      ) {
+        showInfo(tForLang("selectAtLeastOneField", locale));
+        return;
+      }
+
+      let exportDomain = domain;
+
+      if (
+        options.registersAmount === "selected" &&
+        selectedRegistersToExport?.length !== 0
+      ) {
+        exportDomain = [
+          ["id", "in", selectedRegistersToExport?.map((r) => r.id)],
+        ];
+      }
+
+      const { datas } = await ConnectionProvider.getHandler().exportData({
+        model,
+        fields: addIdToRelationFields({
+          keys: options.selectedKeys,
+          fields: fields.current,
+        }),
+        domain: exportDomain,
+        limit: options.registersAmount === "all" ? 0 : limit,
+        context,
+        format: options.exportType,
+      });
+
+      onClose();
+
+      await new Promise((resolve) => setTimeout(resolve, 200));
+
+      const fileType: any = await getMimeType(datas);
+      openBase64InNewTab(datas, fileType.mime);
+    },
+    [locale, model, domain, limit, context, onClose]
+  );
+
+  const onGetFields = useCallback(async () => {
+    const viewData = await ConnectionProvider.getHandler().getFields({
+      model,
+      context,
+      fields: [],
+    });
+    fields.current["/"] = viewData;
+    return convertToExportFields({ fields: viewData });
+  }, [model, context, fields]);
+
+  const onGetFieldChilds = useCallback(
+    async (key: string) => {
+      const fieldDefinition = getFieldDefinition(key, fields.current);
+      const optsForField = fieldDefinition[getChildKey(key)];
+      const relation = optsForField.relation;
+      const viewData = await ConnectionProvider.getHandler().getFields({
+        model: relation,
+        context,
+        fields: [],
+      });
+
+      // We must iterate over each key of viewData in order to replace the string value
+      for (const [key, value] of Object.entries(viewData)) {
+        viewData[key].string = getTitle({
+          parentTitle: optsForField.string,
+          title: (value as any).string,
+        });
+      }
+
+      fields.current[key] = viewData;
+
+      return convertToExportFields({
+        fields: viewData,
+        parentKey: key,
+      });
+    },
+    [fields.current, model, context]
+  );
+
+  const onGetPredefinedExports = useCallback(async () => {
+    const predefinedExports = await listPredefinedExports({ model, context });
+
+    const keysWithChilds = await retrieveKeyFieldsForPredefinedExports({
+      predefinedExports,
+      fields: fields.current,
+      onGetFieldChilds,
+    });
+
+    // Then we reformat predefined exports to get the title
+    const predefinedExportsAdjusted = predefinedExports.map((pExport) => {
+      return {
+        ...pExport,
+        fields: pExport.fields.map((field: PredefinedExportField) => {
+          const childKey = getChildKey(field.key);
+          const fieldDefinition = getFieldDefinition(field.key, fields.current);
+          const optsForField = fieldDefinition[childKey];
+          return {
+            key: field.key,
+            title: optsForField.string,
+          };
+        }),
+      };
+    });
+
+    return {
+      predefinedExports: predefinedExportsAdjusted,
+      keysWithChilds,
+    };
+  }, [fields.current]);
+
+  const onSavePredefinedExport = useCallback(
+    async (pExport: PredefinedExport) => {
+      const fieldsForExport = await getModelFields("ir.exports");
+      const fieldsForExportLine = await getModelFields("ir.exports.line");
+
+      // First we must create the parent object
+      const exportId = await ConnectionProvider.getHandler().create({
+        model: "ir.exports",
+        values: {
+          name: pExport.name,
+          resource: model,
+        },
+        fields: fieldsForExport,
+        context,
+      });
+
+      // We create the lines
+      await Promise.all(
+        pExport.fields.map(async (field: any) => {
+          return await ConnectionProvider.getHandler().create({
+            model: "ir.exports.line",
+            values: {
+              name: field.key,
+              export_id: exportId,
+            },
+            fields: fieldsForExportLine,
+            context,
+          });
+        })
+      );
+
+      return { ...pExport, id: exportId };
+    },
+    []
+  );
+
+  const onRemovePredefinedExport = useCallback(
+    async (pExport: PredefinedExport) => {
+      await ConnectionProvider.getHandler().delete({
+        model: "ir.exports",
+        ids: [pExport.id!],
+      });
+    },
+    []
+  );
+
+  const getModelFields = useCallback(
+    async (model: string) => {
+      if (exportModelFields.current.has(model)) {
+        return exportModelFields.current.get(model);
+      }
+
+      const fieldsForModel = ConnectionProvider.getHandler().getFields({
+        model,
+        context,
+        fields: [],
+      });
+
+      exportModelFields.current.set(model, fieldsForModel);
+    },
+    [exportModelFields, context]
+  );
+
+  return {
+    onGetFields,
+    onGetFieldChilds,
+    onExport,
+    onGetPredefinedExports,
+    onSavePredefinedExport,
+    onRemovePredefinedExport,
+  };
+};
+
+const convertToExportFields = ({
+  fields,
+  parentKey,
+}: {
+  fields: any;
+  parentKey?: string;
+}) => {
+  const exportFields = [];
+
+  for (const key of Object.keys(fields)) {
+    const valuesForField = fields[key];
+
+    if (valuesForField.relation && valuesForField.is_function === true) {
+      continue;
+    }
+
+    const relationField = isRelationField(valuesForField);
+
+    exportFields.push({
+      key: compoundId({ key, parentKey }),
+      title: valuesForField.string,
+      tooltip: valuesForField.help,
+      required: valuesForField.required,
+      isLeaf: !relationField,
+    });
+  }
+  return exportFields;
+};
+
+const isRelationField = (fieldDefinition: any) => {
+  return (
+    fieldDefinition.type === "many2one" ||
+    fieldDefinition.type === "one2many" ||
+    fieldDefinition.type === "many2many"
+  );
+};
+
+const compoundId = ({
+  parentKey,
+  key,
+}: {
+  parentKey?: string;
+  key: string;
+}) => {
+  return `${parentKey ? parentKey + "/" : ""}${key}`;
+};
+
+const getParentKey = (key: string) => {
+  if (key.indexOf("/") === -1) {
+    return key;
+  }
+  const items = key.split("/");
+  return items.slice(0, -1).join("/");
+};
+
+const getChildKey = (key: string) => {
+  if (key.indexOf("/") === -1) {
+    return key;
+  }
+  const items = key.split("/");
+  return items[items.length - 1];
+};
+
+const getFieldDefinition = (key: string, fields: any) => {
+  if (key.indexOf("/") === -1) {
+    return fields["/"];
+  } else {
+    return fields[getParentKey(key)];
+  }
+};
+
+const getTitle = ({
+  title,
+  parentTitle,
+}: {
+  title: string;
+  parentTitle?: string;
+}) => {
+  return `${parentTitle ? parentTitle + " → " : ""}${title}`;
+};
+
+const listPredefinedExports = async ({
+  model,
+  context,
+}: {
+  model: string;
+  context: any;
+}) => {
+  const pExports = await ConnectionProvider.getHandler().search({
+    model: "ir.exports",
+    params: [["resource", "=", model]],
+    context,
+  });
+
+  const exportLinesIds = pExports.flatMap((exp: any) => exp.export_fields);
+
+  // Now we must read each id of the export lines
+  const exportLinesObjects = await ConnectionProvider.getHandler().readObjects({
+    model: "ir.exports.line",
+    ids: exportLinesIds,
+    context,
+  });
+
+  return pExports.map((pExport) => ({
+    id: pExport.id,
+    name: pExport.name,
+    fields: pExport.export_fields.map((id: number) => {
+      const exportLine = exportLinesObjects.find((e: any) => e.id === id);
+      return {
+        key: exportLine.name,
+      };
+    }),
+  }));
+};
+
+const getKeysWithoutChildsInFields = ({
+  fields,
+  keys,
+}: {
+  fields: any;
+  keys: string[];
+}) => {
+  return splitAndSortKeys([
+    ...new Set(
+      keys
+        .filter((key) => {
+          if (key.indexOf("/") === -1) {
+            return !fields["/"]?.[key];
+          } else {
+            const parentKey = getParentKey(key);
+            console.log({ key, parentKey, fields });
+            const exists = fields?.[getParentKey(key)]?.[key];
+            console.log({ exists });
+            return !fields?.[getParentKey(key)]?.[key];
+          }
+        })
+        .map((key) => getParentKey(key))
+    ),
+  ]);
+};
+
+const retrieveKeyFieldsForPredefinedExports = async ({
+  predefinedExports,
+  fields,
+  onGetFieldChilds,
+}: {
+  predefinedExports: PredefinedExport[];
+  fields: any;
+  onGetFieldChilds: (key: string) => Promise<ExportField[]>;
+}) => {
+  const allPredefinedExportKeys = predefinedExports.flatMap(
+    (exp: PredefinedExport) =>
+      exp.fields.map((field: any) => field.key)
+  );
+
+  const keysWithoutChildsInFields = getKeysWithoutChildsInFields({
+    fields,
+    keys: allPredefinedExportKeys,
+  });
+
+  const keysWithChilds = [];
+
+  // We must load the fields info for each key if not loaded yet in fields and store them in an array to pass them to the formiga component
+  for (const key of keysWithoutChildsInFields) {
+    keysWithChilds.push({ key, childs: await onGetFieldChilds(key) });
+  }
+
+  return keysWithChilds;
+};
+
+const addIdToRelationFields = ({
+  keys,
+  fields,
+}: {
+  keys: string[];
+  fields: any;
+}) =>
+  keys.map((key) => {
+    const childKey = getChildKey(key);
+    const fieldDefinition = getFieldDefinition(key, fields);
+    const optsForField = fieldDefinition[childKey];
+    const relationField = isRelationField(optsForField);
+    return relationField ? `${key}/id` : key;
+  });
+
+const splitAndSortKeys = (keys: string[]): string[] => {
+  // We must split the keys that have more than one level (character / ocurrences in the string > 1)
+  // Into an array of keys with only one level
+  // For example: "partner_id/country_id/name" => ["partner_id", "partner_id/country_id", "partner_id/country_id/name"]
+  // We must do this because we must load the fields info for each key if not loaded yet in fields
+  // And we must load the fields info for the parent key first
+  //
+  // We must also sort the keys by the number of levels they have
+  // For example: ["partner_id", "partner_id/country_id", "partner_id/country_id/name"]
+
+  const keysMap: Map<string, boolean> = new Map();
+  const result: string[] = [];
+
+  // Split keys with more than one level
+  for (const key of keys) {
+    const subKeys = key.split("/");
+    let parentKey = "";
+    for (const subKey of subKeys) {
+      const currentKey = parentKey ? `${parentKey}/${subKey}` : subKey;
+      if (!keysMap.has(currentKey)) {
+        result.push(currentKey);
+        keysMap.set(currentKey, true);
+      }
+      parentKey = currentKey;
+    }
+  }
+
+  // Sort keys by number of levels
+  result.sort((a, b) => {
+    const aLevels = a.split("/").length;
+    const bLevels = b.split("/").length;
+    return aLevels - bLevels;
+  });
+
+  return result;
+};