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

package/src/helpers/searchHelper.ts

@@ -1,196 +0,0 @@
-const convertBooleanParamIfNeeded = (value: any) => {
-  if ((typeof value === "string" && value === "true") || value === "false") {
-    return value === "true";
-  }
-  return value;
-};
-
-export const getParamsForFields = (values: any, widgetContainer: any) => {
-  const filteredValues = removeUndefinedFields(values);
-  const groupedDateTime = groupDateTimeValuesIfNeeded(filteredValues);
-  const groupedValues = ungroupDateValuesIfNeeded(
-    groupedDateTime,
-    widgetContainer,
-  );
-
-  const params = [
-    ...Object.keys(groupedValues).map((key) => {
-      return getParamForField(key, groupedValues[key], widgetContainer);
-    }),
-  ];
-
-  // This is needed because in case of datetime we receive an array of arrays
-  const paramsForFields = params.reduce((acc, curVal) => {
-    if (Array.isArray(curVal[0])) {
-      return acc.concat(curVal);
-    }
-    return [...acc, curVal];
-  }, []);
-
-  return paramsForFields;
-};
-
-const getParamForField = (key: string, value: any, widgetContainer: any) => {
-  const filteredKey = key.split("#")[0];
-  const type = widgetContainer.findById(filteredKey)?.type;
-
-  if (
-    type === "char" ||
-    type === "text" ||
-    type === "many2one" ||
-    type === "many2many" ||
-    type === "one2many"
-  ) {
-    return [key, "ilike", value];
-  } else if (
-    type === "float" ||
-    type === "integer" ||
-    type === "float_time" ||
-    type === "progressbar"
-  ) {
-    const operator = key.indexOf("#from") !== -1 ? ">=" : "<=";
-    return [filteredKey, operator, value];
-  } else if (type === "date") {
-    const operator = key.indexOf("#from") !== -1 ? ">=" : "<=";
-    return [filteredKey, operator, value.format("YYYY-MM-DD")];
-  } else if (type === "datetime") {
-    const filteredValues = [];
-    if (value[0]) {
-      filteredValues.push([filteredKey, ">=", value[0]]);
-    }
-    if (value[1]) {
-      filteredValues.push([filteredKey, "<=", value[1]]);
-    }
-    return filteredValues;
-  } else if (type === "selection") {
-    return [
-      key,
-      "in",
-      value.map((valueEntry: string) =>
-        convertBooleanParamIfNeeded(valueEntry),
-      ),
-    ];
-  } else {
-    return [key, "=", convertBooleanParamIfNeeded(value)];
-  }
-};
-
-const getDatetimeDateFields = (values: any) => {
-  return Object.keys(values).filter((key) => {
-    return key.indexOf("#date") !== -1;
-  });
-};
-
-const removeDateTimeSingleFields = (values: any) => {
-  const newValues = { ...values };
-  Object.keys(newValues).forEach(
-    (key) =>
-      (key.indexOf("#time") !== -1 || key.indexOf("#date") !== -1) &&
-      delete newValues[key],
-  );
-  return newValues;
-};
-
-export const groupDateTimeValuesIfNeeded = (values: any) => {
-  const newValues: any = { ...removeDateTimeSingleFields(values) };
-
-  const datetimeDateFields = getDatetimeDateFields(values);
-
-  datetimeDateFields.forEach((field) => {
-    const datePair = values[field];
-    const baseKey = field.split("#")[0];
-    const timeKey = baseKey + "#time";
-    const timePair = values[timeKey];
-
-    let from, to;
-
-    if (datePair[0] !== null) {
-      const dateValueFrom = datePair[0].format("YYYY-MM-DD");
-      from = dateValueFrom;
-
-      if (timePair && timePair[0] !== null) {
-        const timeValueFrom = timePair[0].format("HH:mm:ss");
-        from = from + " " + timeValueFrom;
-      }
-    }
-
-    if (datePair[1] !== null) {
-      const dateValueTo = datePair[1].format("YYYY-MM-DD");
-      to = dateValueTo;
-
-      if (timePair && timePair[1] !== null) {
-        const timeValueTo = timePair[1].format("HH:mm:ss");
-        to = to + " " + timeValueTo;
-      }
-    }
-
-    newValues[baseKey + "#datetime"] = [from, to];
-  });
-
-  return newValues;
-};
-
-const ungroupDateValuesIfNeeded = (values: any, widgetContainer: any) => {
-  const dateFields = Object.keys(values).filter((key) => {
-    const widget = widgetContainer.findById(key);
-    return widget && widget.type === "date";
-  });
-
-  const newValues: any = { ...values };
-
-  dateFields.forEach((key) => {
-    delete newValues[key];
-    if (values[key][0] !== null) {
-      newValues[key + "#from"] = values[key][0];
-    }
-
-    if (values[key][1] !== null) {
-      newValues[key + "#to"] = values[key][1];
-    }
-  });
-
-  return newValues;
-};
-
-export const removeUndefinedFields = (values: any) => {
-  const newValues = { ...values };
-  Object.keys(newValues).forEach(
-    (key) =>
-      (newValues[key] === undefined ||
-        newValues[key] === null ||
-        newValues[key] === "") &&
-      delete newValues[key],
-  );
-  return newValues;
-};
-
-export const getUniqueFieldsForParams = (params: any[]) => {
-  const uniqueFields: any = {};
-
-  params.forEach((param) => {
-    if (Array.isArray(param) && param[0]) {
-      uniqueFields[param[0]] = true;
-    } else {
-      uniqueFields[param] = true;
-    }
-  });
-
-  return Object.keys(uniqueFields);
-};
-
-export const mergeParams = (searchParams: any[], domainParams: any[]) => {
-  const finalParams = [...searchParams];
-  const uniqueParams = getUniqueFieldsForParams(searchParams);
-
-  domainParams.forEach((element) => {
-    if (Array.isArray(element) && element[0]) {
-      if (!uniqueParams.includes(element[0])) {
-        finalParams.push(element);
-      }
-    } else if (!uniqueParams.includes(element)) {
-      finalParams.push(element);
-    }
-  });
-
-  return finalParams;
-};

package/src/helpers/timeHelper.ts

@@ -1,58 +0,0 @@
-function parseStringToFloat(text?: string) {
-  if (!text) {
-    return undefined;
-  }
-
-  try {
-    if (text.includes(":")) {
-      const splitted = text.trim().split(":");
-      return (
-        Math.round(
-          (parseInt(splitted[0]) + parseInt(splitted[1]) / 60.0) * 10000,
-        ) / 10000
-      );
-    } else {
-      return parseFloat(text.trim());
-    }
-  } catch (err) {
-    return 0;
-  }
-}
-
-function parseFloatToString(num?: number) {
-  if (num === undefined) {
-    return undefined;
-  }
-
-  let finalString;
-  let hours = Math.floor(Math.abs(num));
-  let mins = Math.round((Math.abs(num) % 1) * 100) / 100;
-
-  if (mins >= 1) {
-    hours = hours + 1;
-    mins = 0.0;
-  } else {
-    mins = mins * 60;
-  }
-
-  const hoursString = hours.toLocaleString("en-US", {
-    minimumIntegerDigits: 2,
-    maximumFractionDigits: 0,
-    useGrouping: false,
-  });
-  const minsStrings = mins.toLocaleString("en-US", {
-    minimumIntegerDigits: 2,
-    maximumFractionDigits: 0,
-    useGrouping: false,
-  });
-
-  finalString = `${hoursString}:${minsStrings}`;
-
-  if (num < 0) {
-    finalString = "-" + finalString;
-  }
-
-  return finalString;
-}
-
-export { parseStringToFloat, parseFloatToString };

package/src/helpers/treeHelper.tsx

@@ -1,226 +0,0 @@
-import {
-  Tree as TreeOoui,
-  Selection,
-  Many2one,
-  Boolean,
-  Reference,
-} from "@gisce/ooui";
-import { TreeView, Column } from "@/types";
-
-const getTree = (treeView: TreeView): TreeOoui => {
-  const xml = treeView.arch;
-  const fields = treeView.fields;
-  const tree = new TreeOoui(fields);
-  tree.parse(xml);
-  return tree;
-};
-
-function canRenderValue(value: any): boolean {
-  return (
-    typeof value === "number" ||
-    typeof value === "string" ||
-    typeof value === "boolean" ||
-    value === null ||
-    value === undefined
-  );
-}
-
-const getTableColumns = (
-  tree: TreeOoui,
-  components: any,
-  context: any,
-): Column[] => {
-  const tableColumns = tree.columns.map((column) => {
-    const type = column.type;
-    const key = column.id;
-    const component = components?.[type];
-    let render;
-
-    if (component) {
-      render = (value: any) => {
-        return component({ value, key, ooui: column, context });
-      };
-    } else {
-      render = (value: any) => {
-        return canRenderValue(value) ? (
-          value
-        ) : (
-          <p style={{ color: "red" }}>
-            Unsupported widget type for a Tree cell:
-            <pre>
-              <strong>{type}:</strong>
-            </pre>
-          </p>
-        );
-      };
-    }
-
-    return {
-      key,
-      dataIndex: key,
-      title: column.label,
-      render,
-      sorter: (a: any, b: any) => {
-        let aItem = a[key] || "";
-        let bItem = b[key] || "";
-
-        if (type === "many2one") {
-          aItem = a[key]?.value || "";
-          bItem = b[key]?.value || "";
-        }
-
-        if (aItem < bItem) return -1;
-        if (aItem > bItem) return 1;
-        return 0;
-      },
-    };
-  });
-  return tableColumns;
-};
-
-const getTableItems = (treeOoui: TreeOoui, results: any[]): any[] => {
-  const tableItems = results.map((item: any) => {
-    const parsedItem: any = {};
-    Object.keys(item).forEach((key) => {
-      if (key === "id") {
-        parsedItem[key] = item[key];
-      } else {
-        const widget = treeOoui.findById(key);
-
-        if (widget instanceof Reference) {
-          parsedItem[key] = item[key];
-        } else if (widget instanceof Selection) {
-          parsedItem[key] = item[key];
-        } else if (widget instanceof Many2one) {
-          parsedItem[key] = item[key] &&
-            Array.isArray(item[key]) &&
-            item[key].length === 2 && {
-              model: widget.relation,
-              id: item[key][0],
-              value: item[key][1],
-            };
-        } else if (widget instanceof Boolean) {
-          parsedItem[key] = item[key];
-        } else if (widget) {
-          parsedItem[key] = item[key] === false ? "" : item[key];
-        } else {
-          parsedItem[key] = item[key];
-        }
-      }
-    });
-    return parsedItem;
-  });
-
-  return tableItems;
-};
-
-function itemHasBooleans({ values, fields }: { values: any; fields: any }) {
-  if (!fields) {
-    return false;
-  }
-  return Object.keys(values).some((key) => {
-    return fields[key] !== undefined && fields[key].type === "boolean";
-  });
-}
-
-function convertBooleansToNumeric({
-  values,
-  fields,
-}: {
-  values: any;
-  fields: any;
-}) {
-  if (!fields) {
-    return values;
-  }
-  const filteredValues: any = {};
-  Object.keys(values).forEach((key) => {
-    if (fields[key] !== undefined && fields[key].type === "boolean") {
-      filteredValues[key] = values[key] === true ? 1 : 0;
-    }
-  });
-  return { ...values, ...filteredValues };
-}
-
-function getColorMap(colorsValue: any) {
-  return getItemsAttributes(colorsValue, "colors");
-}
-
-function getStatusMap(values: any) {
-  return getItemsAttributes(values, "status");
-}
-
-function getItemsAttributes(attributes: object[], attribute: string) {
-  if (!attributes) {
-    return undefined;
-  }
-  const map: any = {};
-  attributes.forEach((entry: any) => {
-    map[entry.id] = entry[attribute];
-  });
-  return map;
-}
-
-function sortResults({
-  resultsToSort,
-  sorter,
-  fields,
-}: {
-  resultsToSort: any[];
-  sorter: any;
-  fields: any;
-}) {
-  if (!sorter) {
-    return resultsToSort;
-  }
-
-  const { id: field, desc } = sorter;
-  const order = desc === false ? "ascend" : "descend";
-
-  const type = fields[field].type;
-
-  const sortFn = (a: any, b: any) => {
-    let aItem = a[field] || "";
-    let bItem = b[field] || "";
-
-    if (type === "many2one") {
-      aItem = a[field]?.[1] || "";
-      bItem = b[field]?.[1] || "";
-    }
-
-    if (aItem === bItem) {
-      return 0;
-    }
-
-    if (order === "ascend") {
-      return aItem > bItem ? 1 : -1;
-    }
-
-    return aItem < bItem ? 1 : -1;
-  };
-
-  return resultsToSort.sort(sortFn);
-}
-
-function hasActualValues(obj: Record<string, any>): boolean {
-  for (const key in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, key)) {
-      if (obj[key] !== undefined) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-export {
-  getTableColumns,
-  getTableItems,
-  getTree,
-  convertBooleansToNumeric,
-  itemHasBooleans,
-  getColorMap,
-  getStatusMap,
-  sortResults,
-  hasActualValues,
-};

package/src/helpers/viewHelper.ts

@@ -1,23 +0,0 @@
-import { ViewTuple, ViewType } from "@/types";
-
-export async function resolveViewInfoPromises(
-  viewsToRetrieve: Array<{ viewTuple: ViewTuple; promise?: Promise<any> }>,
-) {
-  const results = await Promise.all(
-    viewsToRetrieve.map(async (item) => {
-      try {
-        return await item.promise;
-      } catch (error) {
-        console.error(`Error for ${item.viewTuple}:`, error);
-        return null;
-      }
-    }),
-  );
-
-  const updatedViews = viewsToRetrieve.map((item, index) => ({
-    ...item,
-    info: results[index],
-  }));
-
-  return updatedViews.filter((item) => item.info !== null);
-}

package/src/hooks/useEffectDebugger.ts

@@ -1,43 +0,0 @@
-import { useRef, useEffect } from "react";
-
-const usePrevious = (value: any, initialValue: any) => {
-  const ref = useRef(initialValue);
-  useEffect(() => {
-    ref.current = value;
-  });
-  return ref.current;
-};
-
-const useEffectDebugger = (
-  effectHook: any,
-  dependencies: any,
-  dependencyNames = [],
-) => {
-  const previousDeps = usePrevious(dependencies, []);
-
-  const changedDeps = dependencies.reduce(
-    (accum: any, dependency: any, index: any) => {
-      if (dependency !== previousDeps[index]) {
-        const keyName = dependencyNames[index] || index;
-        return {
-          ...accum,
-          [keyName]: {
-            before: previousDeps[index],
-            after: dependency,
-          },
-        };
-      }
-
-      return accum;
-    },
-    {},
-  );
-
-  if (Object.keys(changedDeps).length) {
-    console.log("[use-effect-debugger] ", changedDeps);
-  }
-
-  useEffect(effectHook, dependencies);
-};
-
-export { useEffectDebugger };