drf-react-by-schema 0.28.8 → 0.28.9

package/dist/components/DataGridBySchemaEditable/hooks/usePreparedColumns.js

@@ -0,0 +1,73 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePreparedColumns = void 0;
+const react_1 = require("react");
+const columnFactory_1 = require("../utils/columnFactory");
+const DRFReactBySchemaContext_1 = require("../../../context/DRFReactBySchemaContext");
+const utils_1 = require("../../../utils");
+const usePreparedColumns = ({ apiRef, schema, columns, isEditable, actions, LinkComponent, stateToLink, validationErrors, optionsAC, onEditModel, customFieldFormLayouts, setDialog, indexField, indexFieldMinWidth, minWidth, customColumnOperations, customLinkDestination, indexFieldBasePath, }) => {
+    const { serverEndPoint } = (0, DRFReactBySchemaContext_1.useDRFReactBySchema)();
+    const [preparedColumns, setPreparedColumns] = (0, react_1.useState)(null);
+    const conditionalVisible = (0, react_1.useMemo)(() => (0, utils_1.buildConditionalVisibleBySchema)(schema), [schema]);
+    (0, react_1.useEffect)(() => {
+        const updateColumns = () => __awaiter(void 0, void 0, void 0, function* () {
+            if (serverEndPoint) {
+                const cols = yield (0, columnFactory_1.buildPreparedColumns)({
+                    apiRef,
+                    schema,
+                    columns,
+                    isEditable,
+                    actions,
+                    LinkComponent,
+                    stateToLink,
+                    validationErrors,
+                    optionsAC,
+                    onEditModel,
+                    customFieldFormLayouts,
+                    setDialog,
+                    indexField,
+                    indexFieldMinWidth,
+                    minWidth,
+                    customColumnOperations,
+                    customLinkDestination,
+                    indexFieldBasePath,
+                    conditionalVisible,
+                    serverEndPoint,
+                });
+                setPreparedColumns(cols);
+            }
+        });
+        updateColumns();
+    }, [
+        schema,
+        columns,
+        isEditable,
+        actions,
+        LinkComponent,
+        stateToLink,
+        validationErrors,
+        optionsAC,
+        // onEditModel,
+        customFieldFormLayouts,
+        // setDialog,
+        indexField,
+        indexFieldMinWidth,
+        minWidth,
+        customColumnOperations,
+        customLinkDestination,
+        indexFieldBasePath,
+        conditionalVisible,
+        serverEndPoint,
+    ]);
+    return { preparedColumns, setPreparedColumns };
+};
+exports.usePreparedColumns = usePreparedColumns;

package/dist/components/DataGridBySchemaEditable/hooks/useProcessRowUpdate.d.ts

@@ -0,0 +1,30 @@
+import { AnySchema } from 'yup';
+import { GridRowId } from '@mui/x-data-grid';
+import { GridApiCommunity } from '@mui/x-data-grid/models/api/gridApiCommunity';
+import { RefObject } from 'react';
+import { Item, SchemaType, Id, ExtraValidators, OnEditModelType, GridEnrichedBySchemaColDef, FieldKey, TField } from '../../../@types';
+interface UseProcessRowUpdateProps<T extends TField = void> {
+    preparedColumns: GridEnrichedBySchemaColDef<T>[] | null;
+    yupValidationSchema: AnySchema | null;
+    setDataGridLoading: (value: boolean) => void;
+    indexField: FieldKey<T>;
+    processingRow: React.RefObject<number | string | null>;
+    setValidationErrors: React.Dispatch<React.SetStateAction<Record<GridRowId, Record<string, string>>>>;
+    modelParent?: string;
+    modelParentId?: Id;
+    model: string;
+    schema: SchemaType<T>;
+    addExistingModel?: string;
+    updateOptionsAC: () => Promise<void>;
+    apiRef: RefObject<GridApiCommunity>;
+    setDataGridRows: (value: React.SetStateAction<Item<T>[]>) => void;
+    onProcessRow?: (p?: Item<T>) => void;
+    handleStopEditing: () => void;
+    extraValidators?: ExtraValidators<T>;
+    onEditModel?: (p: OnEditModelType<T>) => void;
+}
+export declare const useProcessRowUpdate: <T extends TField = void>({ preparedColumns, yupValidationSchema, setDataGridLoading, indexField, processingRow, setValidationErrors, modelParent, modelParentId, model, schema, addExistingModel, updateOptionsAC, apiRef, setDataGridRows, onProcessRow, handleStopEditing, }: UseProcessRowUpdateProps<T>) => {
+    processRowUpdate: (editedRow: Item<T>, originalRow: Item<T>) => Promise<Item<T>>;
+};
+export {};
+//# sourceMappingURL=useProcessRowUpdate.d.ts.map

package/dist/components/DataGridBySchemaEditable/hooks/useProcessRowUpdate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useProcessRowUpdate.d.ts","sourceRoot":"","sources":["../../../../src/components/DataGridBySchemaEditable/hooks/useProcessRowUpdate.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAmB,MAAM,KAAK,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AAChF,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAElC,OAAO,EACL,IAAI,EACJ,UAAU,EACV,EAAE,EACF,eAAe,EACf,eAAe,EACf,0BAA0B,EAC1B,QAAQ,EACR,MAAM,EACP,MAAM,iBAAiB,CAAC;AAUzB,UAAU,wBAAwB,CAAC,CAAC,SAAS,MAAM,GAAG,IAAI;IACxD,eAAe,EAAE,0BAA0B,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC;IACxD,mBAAmB,EAAE,SAAS,GAAG,IAAI,CAAC;IACtC,kBAAkB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IACxB,aAAa,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC,CAAC;IACvD,mBAAmB,EAAE,KAAK,CAAC,QAAQ,CACjC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAChE,CAAC;IACF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACrC,MAAM,EAAE,SAAS,CAAC,gBAAgB,CAAC,CAAC;IACpC,eAAe,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,CAAC;IAClE,YAAY,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IACrC,iBAAiB,EAAE,MAAM,IAAI,CAAC;IAC9B,eAAe,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC;IACrC,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;CAC/C;AAED,eAAO,MAAM,mBAAmB,GAAI,CAAC,SAAS,MAAM,GAAG,IAAI,EAAE,uPAkB1D,wBAAwB,CAAC,CAAC,CAAC;kCAEe,IAAI,CAAC,CAAC,CAAC,eAAe,IAAI,CAAC,CAAC,CAAC;CAoMzE,CAAC"}

package/dist/components/DataGridBySchemaEditable/hooks/useProcessRowUpdate.js

@@ -0,0 +1,199 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useProcessRowUpdate = void 0;
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("../../../utils");
+const APIWrapperContext_1 = require("../../../context/APIWrapperContext");
+const utils_2 = require("../utils");
+// import { buildEditPath } from '../utils'; // TODO: Check Why it is missing here
+function isYupValidationError(err) {
+    return err instanceof Error && err.name === 'ValidationError';
+}
+const useProcessRowUpdate = ({ preparedColumns, yupValidationSchema, setDataGridLoading, indexField, processingRow, setValidationErrors, modelParent, modelParentId, model, schema, addExistingModel, updateOptionsAC, apiRef, setDataGridRows, onProcessRow, handleStopEditing,
+// extraValidators, // TODO: Check why this is missing
+ }) => {
+    const { onEditRelatedModelSave, onEditModelDataGridSave } = (0, APIWrapperContext_1.useAPIWrapper)();
+    function processRowUpdate(editedRow, originalRow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            // const originalRow = dataGrid.data.find((r) => r.id === editedRow.id);
+            if (originalRow && JSON.stringify(originalRow) === JSON.stringify(editedRow)) {
+                console.log('No changes detected, skipping save.');
+                handleStopEditing();
+                if ((0, utils_1.isTmpId)(editedRow.id)) {
+                    (0, utils_2.deleteRow)({ id: editedRow.id, apiRef, setDataGridRows });
+                    throw new Error('CANCEL_TMP_ROW');
+                }
+                return editedRow;
+            }
+            if (!preparedColumns || !yupValidationSchema) {
+                return originalRow;
+            }
+            setDataGridLoading(true);
+            const indexCol = preparedColumns.find((col) => col.field === indexField);
+            processingRow.current = editedRow.id;
+            try {
+                yield yupValidationSchema.validate(editedRow, { abortEarly: false });
+            }
+            catch (err) {
+                if (isYupValidationError(err)) {
+                    const rowErrors = {};
+                    err.inner.forEach((e) => {
+                        if (e.path) {
+                            rowErrors[e.path] = e.message;
+                        }
+                        else {
+                            rowErrors['campo desconhecido'] = e.message;
+                        }
+                    });
+                    setValidationErrors((prev) => (Object.assign(Object.assign({}, prev), { [editedRow.id]: rowErrors })));
+                    err.message = Object.entries(rowErrors)
+                        .map(([field, message]) => `${field}: ${message}`)
+                        .join('; ');
+                }
+                setDataGridLoading(false);
+                throw err;
+            }
+            const indexValue = indexField ? editedRow[indexField] : undefined;
+            const onlyAddExisting = (0, utils_1.isTmpId)(editedRow.id) &&
+                indexValue &&
+                !(0, utils_1.isTmpId)(indexValue.id) &&
+                (!indexCol || !indexCol.valueFormatter);
+            const createNewItem = indexField && (0, utils_1.isTmpId)(editedRow.id) && indexValue && (0, utils_1.isTmpId)(indexValue.id);
+            if (onlyAddExisting) {
+                const row = {};
+                row.id_to_add = indexValue.id;
+                for (const [key, value] of Object.entries(indexValue)) {
+                    if (key === 'id') {
+                        row[key] = editedRow.id;
+                        continue;
+                    }
+                    row[key] = value;
+                }
+                editedRow = Object.assign({}, row);
+            }
+            if (createNewItem && indexValue) {
+                if (indexValue.inputValue) {
+                    editedRow[indexField] = indexValue.inputValue;
+                }
+                if (addExistingModel) {
+                    editedRow[indexField] = indexValue.label;
+                }
+            }
+            if (modelParent && modelParentId && onEditRelatedModelSave) {
+                const response = yield onEditRelatedModelSave({
+                    model: modelParent,
+                    id: modelParentId,
+                    relatedModel: model,
+                    relatedModelId: editedRow.id,
+                    newRow: editedRow,
+                    schema,
+                    onlyAddExisting,
+                });
+                if (axios_1.default.isAxiosError(response)) {
+                    let errorMessage = 'Erro desconhecido no servidor';
+                    if (((_a = response.response) === null || _a === void 0 ? void 0 : _a.data) &&
+                        typeof response.response.data === 'object' &&
+                        !Array.isArray(response.response.data)) {
+                        const backendErrors = response.response.data;
+                        const rowErrors = {};
+                        Object.keys(backendErrors).forEach((field) => {
+                            const msgs = backendErrors[field];
+                            if (Array.isArray(msgs)) {
+                                rowErrors[field] = msgs.join(', ');
+                            }
+                            else if (typeof msgs === 'string') {
+                                rowErrors[field] = msgs;
+                            }
+                        });
+                        setValidationErrors((prev) => (Object.assign(Object.assign({}, prev), { [editedRow.id]: rowErrors })));
+                        errorMessage = Object.entries(rowErrors)
+                            .map(([field, message]) => `${field}: ${message}`)
+                            .join('; ');
+                    }
+                    setDataGridLoading(false);
+                    throw new Error(errorMessage);
+                }
+                if (onlyAddExisting || createNewItem || !onlyAddExisting) {
+                    setValidationErrors((prev) => {
+                        const newState = Object.assign({}, prev);
+                        delete newState[editedRow.id];
+                        return newState;
+                    });
+                    updateOptionsAC();
+                    const newRow = (0, utils_1.enrichChoices)('data' in response && 'schema' in response ? response.data : response, schema);
+                    if (onProcessRow) {
+                        onProcessRow(newRow);
+                    }
+                    (0, utils_2.updateRow)({
+                        newRow: newRow,
+                        apiRef,
+                        originalId: editedRow.id,
+                        setDataGridRows,
+                    });
+                    setDataGridLoading(false);
+                    handleStopEditing();
+                    return newRow;
+                }
+            }
+            const response = yield onEditModelDataGridSave({
+                model,
+                id: editedRow.id,
+                newRow: editedRow,
+                schema,
+            });
+            if (axios_1.default.isAxiosError(response)) {
+                // Map DRF field validation errors (e.g. raised in a serializer's
+                // `validate()`) onto the corresponding cells of the edited row, so they
+                // show the message under each field, just like a yup error. Only keys
+                // present in the schema are mapped (they match the grid columns).
+                const fieldErrors = (0, utils_1.getFieldErrorsFromResponse)((_b = response.response) === null || _b === void 0 ? void 0 : _b.data, schema);
+                const rowErrors = {};
+                Object.entries(fieldErrors).forEach(([field, { message }]) => {
+                    rowErrors[field] = message;
+                });
+                if (Object.keys(rowErrors).length > 0) {
+                    setValidationErrors((prev) => (Object.assign(Object.assign({}, prev), { [editedRow.id]: rowErrors })));
+                }
+                const errorMessage = Object.entries(rowErrors)
+                    .map(([field, message]) => `${field}: ${message}`)
+                    .join('; ');
+                setDataGridLoading(false);
+                throw new Error(errorMessage || 'Erro desconhecido no servidor');
+            }
+            setValidationErrors((prev) => {
+                const newState = Object.assign({}, prev);
+                delete newState[editedRow.id];
+                return newState;
+            });
+            updateOptionsAC();
+            const newRow = (0, utils_1.enrichChoices)('data' in response && 'schema' in response ? response.data : response, schema);
+            (0, utils_2.updateRow)({
+                newRow,
+                originalId: editedRow.id,
+                apiRef,
+                setDataGridRows,
+            });
+            if (onProcessRow) {
+                onProcessRow(newRow);
+            }
+            setDataGridLoading(false);
+            handleStopEditing();
+            return newRow;
+        });
+    }
+    return { processRowUpdate };
+};
+exports.useProcessRowUpdate = useProcessRowUpdate;

package/dist/components/DataGridBySchemaEditable/utils/columnFactory.d.ts

@@ -0,0 +1,33 @@
+import { RefObject } from 'react';
+import { GridRowId, GridRenderCellParams } from '@mui/x-data-grid';
+import { GridApiCommunity } from '@mui/x-data-grid/internals';
+import { SchemaType, GridEnrichedBySchemaColDef, OptionsAC, OnEditModelType, CustomAction, LinkComponentType, CustomFormFieldLayouts, FieldKey, CustomColumnOperations, RowAction, TField, ConditionalVisible } from '../../../@types';
+import { DialogType } from '../../../context/APIWrapperContext';
+import { ServerEndPoint } from '../../../context/DRFReactBySchemaContext';
+export interface BuildPreparedColumnsProps<T extends TField = void> {
+    apiRef: RefObject<GridApiCommunity>;
+    schema: SchemaType<T>;
+    columns: GridEnrichedBySchemaColDef<T>[];
+    isEditable: boolean;
+    actions: RowAction<T>[];
+    customActions?: CustomAction[];
+    LinkComponent?: LinkComponentType;
+    indexFieldBasePath: string;
+    conditionalVisible: ConditionalVisible[];
+    indexFieldViewBasePath?: string;
+    stateToLink: object;
+    validationErrors: Record<GridRowId, Record<string, string>>;
+    optionsAC: OptionsAC<T>;
+    onEditModel?: (p: OnEditModelType<T>) => void;
+    customFieldFormLayouts?: CustomFormFieldLayouts<T>;
+    setDialog: (newState: Partial<DialogType> | null) => void;
+    indexField: FieldKey<T>;
+    addExistingModel?: string;
+    indexFieldMinWidth: number;
+    minWidth: number;
+    customColumnOperations?: CustomColumnOperations<T>;
+    customLinkDestination?: (p: GridRenderCellParams) => string;
+    serverEndPoint: ServerEndPoint;
+}
+export declare function buildPreparedColumns<T extends TField = void>({ apiRef, schema, columns, isEditable, actions, LinkComponent, stateToLink, validationErrors, optionsAC, onEditModel, customFieldFormLayouts, setDialog, indexField, indexFieldMinWidth, minWidth, customColumnOperations, customLinkDestination, indexFieldBasePath, conditionalVisible, serverEndPoint, }: BuildPreparedColumnsProps<T>): Promise<GridEnrichedBySchemaColDef<T>[]>;
+//# sourceMappingURL=columnFactory.d.ts.map

package/dist/components/DataGridBySchemaEditable/utils/columnFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columnFactory.d.ts","sourceRoot":"","sources":["../../../../src/components/DataGridBySchemaEditable/utils/columnFactory.tsx"],"names":[],"mappings":"AAAA,OAAc,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAKzC,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAA4B,MAAM,kBAAkB,CAAC;AAC7F,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAE9D,OAAO,EACL,UAAU,EACV,0BAA0B,EAC1B,SAAS,EACT,eAAe,EAEf,YAAY,EACZ,iBAAiB,EACjB,sBAAsB,EACtB,QAAQ,EACR,sBAAsB,EACtB,SAAS,EACT,MAAM,EACN,kBAAkB,EACnB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAC;AAmB1E,MAAM,WAAW,yBAAyB,CAAC,CAAC,SAAS,MAAM,GAAG,IAAI;IAChE,MAAM,EAAE,SAAS,CAAC,gBAAgB,CAAC,CAAC;IACpC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IACtB,OAAO,EAAE,0BAA0B,CAAC,CAAC,CAAC,EAAE,CAAC;IACzC,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;IACxB,aAAa,CAAC,EAAE,YAAY,EAAE,CAAC;IAC/B,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kBAAkB,EAAE,kBAAkB,EAAE,CAAC;IACzC,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC5D,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACxB,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IAC9C,sBAAsB,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC,CAAC;IACnD,SAAS,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,KAAK,IAAI,CAAC;IAC1D,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,sBAAsB,CAAC,EAAE,sBAAsB,CAAC,CAAC,CAAC,CAAC;IACnD,qBAAqB,CAAC,EAAE,CAAC,CAAC,EAAE,oBAAoB,KAAK,MAAM,CAAC;IAC5D,cAAc,EAAE,cAAc,CAAC;CAChC;AA4BD,wBAAsB,oBAAoB,CAAC,CAAC,SAAS,MAAM,GAAG,IAAI,EAAE,EAClE,MAAM,EACN,MAAM,EACN,OAAO,EACP,UAAU,EACV,OAAO,EACP,aAAa,EACb,WAAW,EACX,gBAAgB,EAChB,SAAS,EACT,WAAW,EACX,sBAAsB,EACtB,SAAS,EACT,UAAU,EACV,kBAAkB,EAClB,QAAQ,EACR,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EAClB,cAAc,GACf,EAAE,yBAAyB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC,CAAC,EAAE,CAAC,CA2WzE"}

package/dist/components/DataGridBySchemaEditable/utils/columnFactory.js

@@ -0,0 +1,270 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPreparedColumns = buildPreparedColumns;
+const react_1 = __importDefault(require("react"));
+const dayjs_1 = __importDefault(require("dayjs"));
+const string_mask_1 = __importDefault(require("string-mask"));
+const Typography_1 = __importDefault(require("@mui/material/Typography"));
+const Stack_1 = __importDefault(require("@mui/material/Stack"));
+const utils_1 = require("../../../utils");
+const utils_2 = require("../utils");
+const geoConstants_1 = require("../geoConstants");
+const SelectEditInputCell_1 = __importDefault(require("../SelectEditInputCell"));
+const GridDateInput_1 = __importDefault(require("../GridDateInput"));
+const GridDateTimeInput_1 = __importDefault(require("../GridDateTimeInput"));
+const GridDecimalInput_1 = __importDefault(require("../GridDecimalInput"));
+const BooleanInputCell_1 = __importDefault(require("../BooleanInputCell"));
+const FileInputCell_1 = __importDefault(require("../FileInputCell"));
+const GridGenericInput_1 = __importDefault(require("../GridGenericInput"));
+const GridPatternInput_1 = __importDefault(require("../GridPatternInput"));
+const GeoThumbCell_1 = __importDefault(require("../GeoThumbCell"));
+const GeoEditCell_1 = __importDefault(require("../GeoEditCell"));
+const FileTypeIcon_1 = __importDefault(require("../../FileTypeIcon"));
+const ConditionalEditWrapper_1 = __importDefault(require("../ConditionalEditWrapper"));
+/**
+ * Applies a `pattern_format` mask to a column, merging with any existing valueFormatter.
+ */
+const applyPatternFormatToColumn = (column, patternFormat) => {
+    column.patternFormat = patternFormat;
+    const existingValueFormatter = column.valueFormatter;
+    column.valueFormatter = (value, row, colDef, apiRef) => {
+        const formatted = existingValueFormatter
+            ? existingValueFormatter(value, row, colDef, apiRef)
+            : value;
+        if (typeof formatted !== 'string' || !formatted) {
+            return formatted;
+        }
+        return new string_mask_1.default(patternFormat, {}).apply(formatted);
+    };
+    return column;
+};
+function buildPreparedColumns(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ apiRef, schema, columns, isEditable, actions, LinkComponent, stateToLink, validationErrors, optionsAC, onEditModel, customFieldFormLayouts, setDialog, indexField, indexFieldMinWidth, minWidth, customColumnOperations, customLinkDestination, indexFieldBasePath, conditionalVisible, serverEndPoint, }) {
+        const promises = columns.map((col) => __awaiter(this, void 0, void 0, function* () {
+            const fieldSchema = schema[col.field];
+            if (!fieldSchema) {
+                return col;
+            }
+            const fieldType = fieldSchema.type;
+            const isIndexField = indexField !== '' && col.field === indexField;
+            let column = Object.assign({}, col);
+            column.editable =
+                isEditable &&
+                    !col.disabled &&
+                    (!fieldSchema.read_only || ['field', 'nested object'].includes(fieldType));
+            switch (fieldType) {
+                case 'date':
+                    column.type = 'date';
+                    if (!column.minWidth) {
+                        column.minWidth = 150;
+                    }
+                    const df = (0, utils_1.buildDateFormatBySchema)(fieldSchema.date_views);
+                    column.valueFormatter = (value) => (value ? (0, dayjs_1.default)(value).format(df) : '');
+                    column.filterOperators = (0, utils_2.quantityOnlyOperators)({ type: 'date' });
+                    if (isEditable && !col.disabled) {
+                        column.renderEditCell = (p) => {
+                            var _a;
+                            const err = (_a = validationErrors[p.id]) === null || _a === void 0 ? void 0 : _a[p.field];
+                            const inputCell = (react_1.default.createElement(GridDateInput_1.default, Object.assign({}, p, { column: column, dateViews: fieldSchema.date_views, error: Boolean(err), helperText: err })));
+                            if (conditionalVisible.filter(({ target }) => target === p.field).length > 0) {
+                                return (react_1.default.createElement(ConditionalEditWrapper_1.default, Object.assign({}, p, { conditionalVisible: conditionalVisible, apiRef: apiRef }), inputCell));
+                            }
+                            return inputCell;
+                        };
+                    }
+                    break;
+                case 'datetime':
+                    column.type = 'dateTime';
+                    if (!column.minWidth) {
+                        column.minWidth = 200;
+                    }
+                    column.valueFormatter = (value) => value ? (0, dayjs_1.default)(value).format('DD/MM/YYYY HH:mm') : '';
+                    if (isEditable && !col.disabled) {
+                        column.renderEditCell = (p) => {
+                            var _a;
+                            const err = (_a = validationErrors[p.id]) === null || _a === void 0 ? void 0 : _a[p.field];
+                            const inputCell = (react_1.default.createElement(GridDateTimeInput_1.default, Object.assign({}, p, { column: column, error: Boolean(err), helperText: err })));
+                            if (conditionalVisible.filter(({ target }) => target === p.field).length > 0) {
+                                return (react_1.default.createElement(ConditionalEditWrapper_1.default, Object.assign({}, p, { conditionalVisible: conditionalVisible, apiRef: apiRef }), inputCell));
+                            }
+                            return inputCell;
+                        };
+                    }
+                    break;
+                case 'nested object':
+                case 'field':
+                case 'choice':
+                case 'list':
+                    column.minWidth = 150;
+                    // Values are already option objects ({value, display_name} or {id,
+                    // label}); single = one object, multiple = an array of objects.
+                    const formatChoiceValue = (value) => {
+                        if (Array.isArray(value)) {
+                            return value.map((v) => (v === null || v === void 0 ? void 0 : v.label) || (v === null || v === void 0 ? void 0 : v.display_name) || '').join(', ');
+                        }
+                        return (value === null || value === void 0 ? void 0 : value.label) || (value === null || value === void 0 ? void 0 : value.display_name) || '';
+                    };
+                    if (isEditable && !col.disabled) {
+                        column.valueFormatter = formatChoiceValue;
+                        column.renderEditCell = (p) => {
+                            var _a;
+                            const err = (_a = validationErrors[p.id]) === null || _a === void 0 ? void 0 : _a[p.field];
+                            const inputCell = (react_1.default.createElement(SelectEditInputCell_1.default, Object.assign({}, p, { column: column, type: fieldType, options: optionsAC[col.field] || [], isIndexField: isIndexField, onEditModel: onEditModel, fieldsLayout: customFieldFormLayouts === null || customFieldFormLayouts === void 0 ? void 0 : customFieldFormLayouts[col.field], setDialog: setDialog, multiple: fieldType === 'list' || fieldSchema.many, error: Boolean(err), helperText: err })));
+                            if (conditionalVisible.filter(({ target }) => target === p.field).length > 0) {
+                                return (react_1.default.createElement(ConditionalEditWrapper_1.default, Object.assign({}, p, { conditionalVisible: conditionalVisible, apiRef: apiRef }), inputCell));
+                            }
+                            return inputCell;
+                        };
+                    }
+                    else {
+                        column.valueGetter = formatChoiceValue;
+                    }
+                    break;
+                case 'boolean':
+                    column.valueFormatter = (value) => (value ? 'Sim' : 'Não');
+                    if (isEditable && !col.disabled) {
+                        column.renderEditCell = (p) => {
+                            var _a;
+                            const err = (_a = validationErrors[p.id]) === null || _a === void 0 ? void 0 : _a[p.field];
+                            const inputCell = (react_1.default.createElement(BooleanInputCell_1.default, Object.assign({}, p, { column: column, error: Boolean(err), helperText: err })));
+                            if (conditionalVisible.filter(({ target }) => target === p.field).length > 0) {
+                                return (react_1.default.createElement(ConditionalEditWrapper_1.default, Object.assign({}, p, { conditionalVisible: conditionalVisible, apiRef: apiRef }), inputCell));
+                            }
+                            return inputCell;
+                        };
+                    }
+                    break;
+                case 'decimal':
+                case 'float':
+                case 'number':
+                case 'integer':
+                    const ds = fieldSchema.decimal_places || (fieldType === 'integer' ? 0 : 2);
+                    column.type = 'number';
+                    column.valueFormatter = (value) => {
+                        if (value === null || value === undefined)
+                            return '';
+                        return parseFloat(value).toLocaleString('pt-BR', {
+                            minimumFractionDigits: ds,
+                            maximumFractionDigits: ds,
+                        });
+                    };
+                    column.filterOperators = (0, utils_2.quantityOnlyOperators)({
+                        type: fieldType === 'decimal' ? 'float' : 'number',
+                    });
+                    if (isEditable && !col.disabled) {
+                        column.renderEditCell = (p) => {
+                            var _a;
+                            const err = (_a = validationErrors[p.id]) === null || _a === void 0 ? void 0 : _a[p.field];
+                            const inputCell = (react_1.default.createElement(GridDecimalInput_1.default, Object.assign({}, p, { decimalPlaces: ds, isCurrency: fieldSchema.is_currency, prefix: fieldSchema.prefix || '', suffix: fieldSchema.suffix || '', column: column, error: Boolean(err), helperText: err })));
+                            if (conditionalVisible.filter(({ target }) => target === p.field).length > 0) {
+                                return (react_1.default.createElement(ConditionalEditWrapper_1.default, Object.assign({}, p, { conditionalVisible: conditionalVisible, apiRef: apiRef }), inputCell));
+                            }
+                            return inputCell;
+                        };
+                    }
+                    break;
+                case 'image upload':
+                case 'file upload':
+                case 'image':
+                case 'file':
+                    column.minWidth = 200;
+                    column.renderCell = (p) => {
+                        var _a, _b;
+                        return (react_1.default.createElement(react_1.default.Fragment, null, ((_a = p.value) === null || _a === void 0 ? void 0 : _a.name) &&
+                            (((_b = p.value) === null || _b === void 0 ? void 0 : _b.url) && (fieldType === 'image upload' || fieldType === 'image') ? (react_1.default.createElement("img", { src: `${serverEndPoint === null || serverEndPoint === void 0 ? void 0 : serverEndPoint.url}${p.value.url}`, alt: p.value.name, style: { width: '100%', maxHeight: '100px', objectFit: 'cover' } })) : (react_1.default.createElement(Stack_1.default, { direction: "row", spacing: 0.5, alignItems: "center" },
+                                react_1.default.createElement(FileTypeIcon_1.default, { name: p.value.name }),
+                                react_1.default.createElement(Typography_1.default, { variant: "body2" }, p.value.name.split('/').pop()))))));
+                    };
+                    if (isEditable && !col.disabled) {
+                        column.renderEditCell = (p) => {
+                            var _a;
+                            const err = (_a = validationErrors[p.id]) === null || _a === void 0 ? void 0 : _a[p.field];
+                            const acc = fieldSchema.allowed_mime_types
+                                ? fieldSchema.allowed_mime_types.join(', ')
+                                : fieldType.includes('image')
+                                    ? 'image/*'
+                                    : '*';
+                            const inputCell = (react_1.default.createElement(FileInputCell_1.default, Object.assign({ accept: acc, fileType: fieldType, column: column, required: (0, utils_1.isFieldRequired)(fieldSchema) }, p, { error: Boolean(err), helperText: err })));
+                            if (conditionalVisible.filter(({ target }) => target === p.field).length > 0) {
+                                return (react_1.default.createElement(ConditionalEditWrapper_1.default, Object.assign({}, p, { conditionalVisible: conditionalVisible, apiRef: apiRef }), inputCell));
+                            }
+                            return inputCell;
+                        };
+                    }
+                    break;
+                case 'point':
+                case 'polygon':
+                case 'multipoint':
+                case 'multipolygon':
+                case 'geometrycollection':
+                    column.minWidth = geoConstants_1.GIS_THUMB_SIZE.w + 24;
+                    column.renderCell = (p) => (react_1.default.createElement(GeoThumbCell_1.default, { geometry: fieldType, value: p.value }));
+                    if (isEditable && !col.disabled) {
+                        column.renderEditCell = (p) => (react_1.default.createElement(GeoEditCell_1.default, Object.assign({}, p, { geometry: fieldType })));
+                    }
+                    break;
+                case 'string':
+                    if (isEditable && !col.disabled && (fieldSchema.pattern_format || col.patternFormat)) {
+                        column.renderEditCell = (p) => {
+                            var _a;
+                            const err = (_a = validationErrors[p.id]) === null || _a === void 0 ? void 0 : _a[p.field];
+                            const inputCell = (react_1.default.createElement(GridPatternInput_1.default, Object.assign({}, p, { patternFormat: fieldSchema.pattern_format || col.patternFormat || '', error: Boolean(err), helperText: err })));
+                            if (conditionalVisible.filter(({ target }) => target === p.field).length > 0) {
+                                return (react_1.default.createElement(ConditionalEditWrapper_1.default, Object.assign({}, p, { conditionalVisible: conditionalVisible, apiRef: apiRef }), inputCell));
+                            }
+                            return inputCell;
+                        };
+                    }
+                    break;
+            }
+            // Apply pattern_format (mask) for display:
+            const patternFormat = fieldSchema.pattern_format || col.patternFormat;
+            if (patternFormat && fieldType !== 'decimal' && fieldType !== 'float') {
+                column = applyPatternFormatToColumn(column, patternFormat);
+            }
+            if (indexFieldMinWidth && !column.minWidth)
+                column.minWidth = col.field === indexField ? indexFieldMinWidth : minWidth;
+            if (indexField && col.field === indexField) {
+                column.flex = 1;
+                column.renderCell = (p) => {
+                    if (LinkComponent &&
+                        (customLinkDestination || indexFieldBasePath !== '') &&
+                        !actions.includes('edit')) {
+                        const to = customLinkDestination
+                            ? customLinkDestination(p)
+                            : (0, utils_2.buildEditPath)(indexFieldBasePath, p.id);
+                        return (react_1.default.createElement(LinkComponent, { to: `${to}`, state: stateToLink }, p.formattedValue));
+                    }
+                    return react_1.default.createElement(react_1.default.Fragment, null, p.formattedValue);
+                };
+            }
+            if (!column.renderEditCell) {
+                column.renderEditCell = (p) => {
+                    var _a;
+                    const err = (_a = validationErrors[p.id]) === null || _a === void 0 ? void 0 : _a[p.field];
+                    const inputCell = react_1.default.createElement(GridGenericInput_1.default, Object.assign({}, p, { error: Boolean(err), helperText: err }));
+                    if (conditionalVisible.filter(({ target }) => target === p.field).length > 0) {
+                        return (react_1.default.createElement(ConditionalEditWrapper_1.default, Object.assign({}, p, { conditionalVisible: conditionalVisible, apiRef: apiRef }), inputCell));
+                    }
+                    return inputCell;
+                };
+            }
+            if (customColumnOperations)
+                column = yield customColumnOperations(column);
+            return column;
+        }));
+        return Promise.all(promises);
+    });
+}