drf-react-by-schema 0.28.8 → 0.28.9

package/dist/api.js

@@ -0,0 +1,1118 @@
+"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.exportExcelData = exports.getAllModels = exports.changePassword = exports.confirmPasswordReset = exports.requestPasswordReset = exports.signUp = exports.getSignUpOptions = exports.isLoggedIn = exports.setAuthToken = exports.hasJWT = exports.clearJWT = exports.loginByPayload = exports.dispatchAuthExpired = exports.AUTH_EXPIRED_EVENT = void 0;
+exports.getRawData = getRawData;
+exports.getData = getData;
+exports.updateData = updateData;
+exports.partialUpdateData = partialUpdateData;
+exports.createData = createData;
+exports.deleteData = deleteData;
+exports.createOrUpdateData = createOrUpdateData;
+exports.prepareDataBySchema = prepareDataBySchema;
+exports.updateDataBySchema = updateDataBySchema;
+exports.addExistingRelatedModel = addExistingRelatedModel;
+exports.getAutoComplete = getAutoComplete;
+exports.getGenericModelList = getGenericModelList;
+exports.getGenericModel = getGenericModel;
+const axios_1 = __importDefault(require("axios"));
+const dayjs_1 = __importDefault(require("dayjs"));
+const utils_1 = require("./utils");
+const expiredTokenMessage = 'Token expired! System must login again';
+const noServerEndPointMessage = 'There is not API definition (serverEndPoint)!';
+const unknownError = 'Unknown error!';
+/**
+ * Global event dispatched whenever the session is definitively expired (i.e. a
+ * 401 happened AND refreshing the token failed). Host apps can listen to this
+ * to immediately sign out and redirect to the login page.
+ */
+exports.AUTH_EXPIRED_EVENT = 'drf-react-by-schema:auth-expired';
+const dispatchAuthExpired = () => {
+    if (typeof window !== 'undefined') {
+        window.dispatchEvent(new CustomEvent(exports.AUTH_EXPIRED_EVENT));
+    }
+};
+exports.dispatchAuthExpired = dispatchAuthExpired;
+function getOptions(path, serverEndPoint, schemas) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (schemas) {
+            const pathParts = path.split('/');
+            const model = pathParts[0];
+            const relatedModel = pathParts.length > 2 ? pathParts[2] : null;
+            const schemaKey = relatedModel
+                ? (0, utils_1.slugToCamelCase)(`${model}_related_${relatedModel}_schema`, true)
+                : (0, utils_1.slugToCamelCase)(`${model}_schema`, true);
+            if (schemas[schemaKey]) {
+                const foundSchema = schemas[schemaKey];
+                if (typeof foundSchema === 'function') {
+                    try {
+                        const loaded = yield foundSchema();
+                        return loaded.default || loaded;
+                    }
+                    catch (e) {
+                        console.error(`Failed to load schema for ${schemaKey}`, e);
+                    }
+                }
+                else {
+                    return foundSchema;
+                }
+            }
+        }
+        if (!serverEndPoint) {
+            return {
+                message: noServerEndPointMessage,
+                isAxiosError: true,
+            };
+        }
+        const url = `${serverEndPoint.api}/${path}`;
+        try {
+            const { data } = yield axios_1.default.options(url);
+            return {
+                schema: data.actions.POST,
+                verbose_name: data.verbose_name,
+                verbose_name_plural: data.verbose_name_plural,
+            };
+        }
+        catch (e) {
+            if (axios_1.default.isAxiosError(e)) {
+                const err = e;
+                const message = `Error fetching options from ${url}`;
+                if (((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                    const isRefreshed = yield refreshToken(serverEndPoint);
+                    if (!isRefreshed) {
+                        console.log(expiredTokenMessage);
+                        return {
+                            message: expiredTokenMessage,
+                            isAxiosError: true,
+                        };
+                    }
+                    try {
+                        const { data } = yield axios_1.default.options(url);
+                        return {
+                            schema: data.actions.POST,
+                            verbose_name: data.verbose_name,
+                            verbose_name_plural: data.verbose_name_plural,
+                        };
+                    }
+                    catch (e) {
+                        console.log(message, e);
+                        return {
+                            message,
+                            isAxiosError: true,
+                        };
+                    }
+                }
+                console.log(message, e);
+                return {
+                    message,
+                    isAxiosError: true,
+                };
+            }
+            return {
+                message: unknownError,
+                isAxiosError: true,
+            };
+        }
+    });
+}
+function getSchema(path, serverEndPoint, schemas) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const options = yield getOptions(path, serverEndPoint, schemas);
+        if (axios_1.default.isAxiosError(options)) {
+            return options;
+        }
+        // Special default value of "currentUser":
+        let usuaria = false;
+        for (const [key, fieldRaw] of Object.entries(options.schema)) {
+            const field = fieldRaw;
+            if (field.model_default === '{currentUser}') {
+                if (!usuaria) {
+                    usuaria = yield (0, exports.isLoggedIn)(serverEndPoint);
+                }
+                if (usuaria) {
+                    options.schema[key].model_default = {
+                        id: usuaria.id,
+                        label: usuaria.first_name,
+                    };
+                }
+            }
+            if (field.model_default === '{dateNow}') {
+                field.model_default = (0, dayjs_1.default)().format('YYYY-MM-DD');
+            }
+            if (field.model_default === '{dateTimeNow}') {
+                field.model_default = (0, dayjs_1.default)().format('YYYY-MM-DDTHH:mm');
+            }
+            if (field.model_default && field.type === 'choice') {
+                if (field.choices) {
+                    const modelDefault = field.choices.filter((choice) => choice.value === field.model_default);
+                    options.schema[key].model_default =
+                        modelDefault.length === 1 ? modelDefault[0] : undefined;
+                }
+            }
+        }
+        const modelOptions = {
+            verbose_name: options.verbose_name,
+            verbose_name_plural: options.verbose_name_plural,
+        };
+        return { schema: options.schema, modelOptions };
+    });
+}
+function getRawData(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ path, serverEndPoint, }) {
+        var _b;
+        if (!serverEndPoint) {
+            return {
+                message: noServerEndPointMessage,
+                isAxiosError: true,
+            };
+        }
+        const url = `${serverEndPoint.api}/${path}`;
+        try {
+            const { data } = yield axios_1.default.get(url);
+            return data;
+        }
+        catch (e) {
+            const message = `Error fetching data from ${url}`;
+            if (axios_1.default.isAxiosError(e)) {
+                const err = e;
+                if (((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) === 401) {
+                    const isRefreshed = yield refreshToken(serverEndPoint);
+                    if (!isRefreshed) {
+                        console.log(expiredTokenMessage);
+                        return {
+                            message: expiredTokenMessage,
+                            isAxiosError: true,
+                        };
+                    }
+                    try {
+                        const { data } = yield axios_1.default.get(url);
+                        return data;
+                    }
+                    catch (e) {
+                        const message = `Error fetching data from ${url}`;
+                        console.log(message, e);
+                        return {
+                            message,
+                            isAxiosError: true,
+                        };
+                    }
+                }
+            }
+            console.log(message, e);
+            return {
+                message,
+                isAxiosError: true,
+            };
+        }
+    });
+}
+function getData(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ path, serverEndPoint, route = 'api', }) {
+        var _b;
+        if (!serverEndPoint) {
+            return {
+                message: noServerEndPointMessage,
+                isAxiosError: true,
+            };
+        }
+        const url = `${serverEndPoint[route]}/${path}`;
+        try {
+            const { data } = yield axios_1.default.get(url);
+            return data;
+        }
+        catch (e) {
+            if (axios_1.default.isAxiosError(e)) {
+                const err = e;
+                if (((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) === 401) {
+                    const isRefreshed = yield refreshToken(serverEndPoint);
+                    if (!isRefreshed) {
+                        console.log(expiredTokenMessage);
+                        return {
+                            message: expiredTokenMessage,
+                            isAxiosError: true,
+                        };
+                    }
+                    try {
+                        const { data } = yield axios_1.default.get(url);
+                        return data;
+                    }
+                    catch (e) {
+                        console.log(expiredTokenMessage, e);
+                        return {
+                            message: expiredTokenMessage,
+                            isAxiosError: true,
+                        };
+                    }
+                }
+            }
+            const message = `Error fetching data from ${url}`;
+            console.log(message, e);
+            return {
+                message,
+                isAxiosError: true,
+            };
+        }
+    });
+}
+/**
+ *
+ * @param options - params
+ * @returns updatedData when succesfully updated, axiosError otherwise
+ */
+function updateData(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ path, serverEndPoint, data, id, contentType = 'application/json', }) {
+        var _b, _c, _d;
+        if (!serverEndPoint) {
+            return {
+                message: noServerEndPointMessage,
+                isAxiosError: true,
+            };
+        }
+        const url = `${serverEndPoint.api}/${path}/${id}/`;
+        const config = { headers: { 'Content-Type': contentType } };
+        try {
+            const { data: updatedData } = yield axios_1.default.put(url, data, config);
+            return updatedData;
+        }
+        catch (e) {
+            if (axios_1.default.isAxiosError(e)) {
+                const err = e;
+                const message = `Error updating data at ${url}`;
+                if (((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) === 401) {
+                    const isRefreshed = yield refreshToken(serverEndPoint);
+                    if (!isRefreshed) {
+                        console.log(expiredTokenMessage);
+                        return {
+                            message: expiredTokenMessage,
+                            isAxiosError: true,
+                        };
+                    }
+                    try {
+                        const { data: updatedData } = yield axios_1.default.put(url, data, config);
+                        return updatedData;
+                    }
+                    catch (e) {
+                        console.log(message, data, (_c = err.response) === null || _c === void 0 ? void 0 : _c.data, e);
+                        return { message, isAxiosError: true };
+                    }
+                }
+                console.log(message, data, (_d = err.response) === null || _d === void 0 ? void 0 : _d.data);
+                return { message, isAxiosError: true, response: err.response };
+            }
+        }
+        return { message: unknownError, isAxiosError: true };
+    });
+}
+function partialUpdateData(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ path, serverEndPoint, data, id, }) {
+        var _b, _c;
+        if (!serverEndPoint) {
+            return {
+                message: noServerEndPointMessage,
+                isAxiosError: true,
+            };
+        }
+        const url = `${serverEndPoint.api}/${path}/${id}/`;
+        try {
+            const { data: updatedData } = yield axios_1.default.patch(url, data);
+            return updatedData;
+        }
+        catch (e) {
+            if (axios_1.default.isAxiosError(e)) {
+                const err = e;
+                const message = `Error partial updating data at ${url}`;
+                if (((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) === 401) {
+                    const isRefreshed = yield refreshToken(serverEndPoint);
+                    if (!isRefreshed) {
+                        console.log(expiredTokenMessage);
+                        return {
+                            message: expiredTokenMessage,
+                            isAxiosError: true,
+                        };
+                    }
+                    try {
+                        const { data: updatedData } = yield axios_1.default.patch(url, data);
+                        return updatedData;
+                    }
+                    catch (e) {
+                        console.log(message, data, e);
+                        return {
+                            message: err.response ? err.response.data : message,
+                            isAxiosError: true,
+                        };
+                    }
+                }
+                console.log(message, data, (_c = err.response) === null || _c === void 0 ? void 0 : _c.data);
+                return {
+                    message: err.response ? err.response.data : message,
+                    isAxiosError: true,
+                };
+            }
+        }
+        return { message: unknownError, isAxiosError: true };
+    });
+}
+function createData(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ path, serverEndPoint, data, contentType = 'application/json', }) {
+        var _b, _c;
+        if (!serverEndPoint) {
+            return {
+                message: noServerEndPointMessage,
+                isAxiosError: true,
+            };
+        }
+        const url = `${serverEndPoint.api}/${path}/`;
+        const config = { headers: { 'Content-Type': contentType } };
+        try {
+            const { data: createdData } = yield axios_1.default.post(url, data, config);
+            return createdData;
+        }
+        catch (err) {
+            if (axios_1.default.isAxiosError(err)) {
+                const message = `Error creating data at ${url}`;
+                if (((_b = err.response) === null || _b === void 0 ? void 0 : _b.status) === 401) {
+                    const isRefreshed = yield refreshToken(serverEndPoint);
+                    if (!isRefreshed) {
+                        console.log(expiredTokenMessage);
+                        return {
+                            message: expiredTokenMessage,
+                            isAxiosError: true,
+                        };
+                    }
+                    try {
+                        const { data: createdData } = yield axios_1.default.post(url, data);
+                        return createdData;
+                    }
+                    catch (e) {
+                        console.log(message, data, e);
+                        return {
+                            message: err.response ? err.response.data : message,
+                            isAxiosError: true,
+                            response: err.response,
+                        };
+                    }
+                }
+                console.log(message, data, (_c = err.response) === null || _c === void 0 ? void 0 : _c.data);
+                return {
+                    message: err.response ? err.response.data : message,
+                    isAxiosError: true,
+                    response: err.response,
+                };
+            }
+        }
+        return {
+            message: unknownError,
+            isAxiosError: true,
+        };
+    });
+}
+function deleteData(path, serverEndPoint, id) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (!serverEndPoint) {
+            return {
+                message: noServerEndPointMessage,
+                isAxiosError: true,
+            };
+        }
+        const url = `${serverEndPoint.api}/${path}/${id}`;
+        try {
+            yield axios_1.default.delete(url);
+            return true;
+        }
+        catch (e) {
+            if (axios_1.default.isAxiosError(e)) {
+                const err = e;
+                const message = `Error deleting data from ${url}`;
+                if (((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                    const isRefreshed = yield refreshToken(serverEndPoint);
+                    if (!isRefreshed) {
+                        console.log(expiredTokenMessage);
+                        return {
+                            message: expiredTokenMessage,
+                            isAxiosError: true,
+                        };
+                    }
+                    try {
+                        yield axios_1.default.delete(url);
+                        return true;
+                    }
+                    catch (e) {
+                        console.log(message, e);
+                        return {
+                            message: err.response ? err.response.data : message,
+                            isAxiosError: true,
+                        };
+                    }
+                }
+                console.log(message, e);
+                return {
+                    message: err.response ? err.response.data : message,
+                    isAxiosError: true,
+                };
+            }
+        }
+        return {
+            message: unknownError,
+            isAxiosError: true,
+        };
+    });
+}
+function createOrUpdateData(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ path, serverEndPoint, data, id, contentType = 'application/json', }) {
+        if ((0, utils_1.isTmpId)(id) || !id) {
+            const responseCreate = yield createData({ path, serverEndPoint, data, contentType });
+            return responseCreate;
+        }
+        const responseUpdate = yield updateData({ path, serverEndPoint, data, id, contentType });
+        return responseUpdate;
+    });
+}
+function prepareDataBySchemaRecursive({ data: typedData, schema, }) {
+    const data = typedData;
+    let requiresMultipart = false;
+    const dbData = {};
+    const conditionalVisible = (0, utils_1.buildConditionalVisibleBySchema)(schema);
+    for (const [key, field] of Object.entries(schema)) {
+        const value = data[key];
+        if (!(key in data) || (key === 'id' && (0, utils_1.isTmpId)(value))) {
+            continue;
+        }
+        // Clear hidden conditional_visible fields so their stale value isn't saved.
+        if (!(0, utils_1.showConditionalVisibleFieldObj)(key, conditionalVisible, data)) {
+            dbData[key] = (0, utils_1.emptyByType)(field, true);
+            continue;
+        }
+        if (typeof value !== 'boolean' && !value) {
+            dbData[key] = (0, utils_1.emptyByType)(field, true);
+            continue;
+        }
+        // Check for file upload fields
+        if (field && ['file upload', 'image upload'].includes(field.type)) {
+            requiresMultipart = true;
+            if ('file' in data[key]) {
+                dbData[key] = { file: value.file };
+            }
+            continue;
+        }
+        // OneToMany or ManyToMany relations:
+        if ((field === null || field === void 0 ? void 0 : field.type) === 'field' && field.child) {
+            const dataArr = value;
+            dbData[key] = dataArr.map((row) => {
+                var _a;
+                return ((_a = field.child) === null || _a === void 0 ? void 0 : _a.children)
+                    ? prepareDataBySchemaRecursive({
+                        data: row,
+                        schema: field.child.children,
+                    }).data
+                    : row;
+            });
+            continue;
+        }
+        // Nested Object:
+        if ((field === null || field === void 0 ? void 0 : field.type) === 'nested object' && field.children && typeof value === 'object') {
+            dbData[key] = (0, utils_1.isTmpId)(value === null || value === void 0 ? void 0 : value.id)
+                ? prepareDataBySchemaRecursive({
+                    data: value,
+                    schema: field.children,
+                }).data
+                : value.id;
+            continue;
+        }
+        // Choices:
+        if ((field === null || field === void 0 ? void 0 : field.type) === 'choice') {
+            dbData[key] = value.value;
+            continue;
+        }
+        // Multiple-choice lists: unwrap {value, display_name} objects to raw .value
+        // for the backend; raw values already present are passed through unchanged.
+        if ((field === null || field === void 0 ? void 0 : field.type) === 'list' || (field === null || field === void 0 ? void 0 : field.type) === 'multiple choice') {
+            dbData[key] = Array.isArray(value)
+                ? value.map((choice) => typeof choice === 'object' && choice !== null ? choice.value : choice)
+                : value;
+            continue;
+        }
+        // Date:
+        if ((field === null || field === void 0 ? void 0 : field.type) === 'date') {
+            dbData[key] = (0, dayjs_1.default)(value).format('YYYY-MM-DD');
+            continue;
+        }
+        // DateTime:
+        if ((field === null || field === void 0 ? void 0 : field.type) === 'datetime') {
+            dbData[key] = (0, dayjs_1.default)(value).format('YYYY-MM-DDTHH:mm');
+            continue;
+        }
+        // Default:
+        dbData[key] = value;
+    }
+    return {
+        data: dbData,
+        requiresMultipart,
+    };
+}
+function prepareDataBySchema({ data, schema, }) {
+    const { data: preparedData, requiresMultipart } = prepareDataBySchemaRecursive({
+        data,
+        schema,
+    });
+    return {
+        data: requiresMultipart ? (0, utils_1.convertToFormData)(preparedData) : preparedData,
+        contentType: requiresMultipart
+            ? 'multipart/form-data'
+            : 'application/json',
+    };
+}
+function updateDataBySchema(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ model, modelObjectId, serverEndPoint, data, schema, path = null, }) {
+        const { data: dbData, contentType } = prepareDataBySchema({ data, schema });
+        if (!path) {
+            path = model;
+        }
+        const response = yield createOrUpdateData({
+            path,
+            serverEndPoint,
+            data: dbData,
+            id: modelObjectId,
+            contentType,
+        });
+        return response;
+    });
+}
+function addExistingRelatedModel(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ model, serverEndPoint, id, data, }) {
+        const response = yield partialUpdateData({ path: model, serverEndPoint, data, id });
+        return response;
+    });
+}
+function getDataGridColumns(schema, columnFields, creatableFields, disabledFields) {
+    if (!schema) {
+        return false;
+    }
+    const finalColumnFields = !columnFields || columnFields.length === 0
+        ? Object.keys(schema)
+        : columnFields.filter((field) => {
+            return field in schema;
+        });
+    return finalColumnFields.map((field) => {
+        const fieldSchema = schema[field];
+        const column = {
+            field,
+            headerName: fieldSchema === null || fieldSchema === void 0 ? void 0 : fieldSchema.label,
+            creatable: creatableFields && creatableFields.includes(field)
+                ? true
+                : fieldSchema && 'related_editable' in fieldSchema
+                    ? fieldSchema.related_editable
+                    : false,
+            disabled: !!disabledFields && disabledFields.includes(field),
+            uiRequired: (fieldSchema === null || fieldSchema === void 0 ? void 0 : fieldSchema.ui_required) || false,
+            width: 100,
+        };
+        return column;
+    });
+}
+function getAutoComplete(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ model, queryParams, serverEndPoint, }) {
+        const data = yield getData({
+            path: `${model}/${queryParams && queryParams.length > 0 ? '?' + queryParams.join('&') : ''}`,
+            serverEndPoint,
+            route: 'autocomplete',
+        });
+        if (axios_1.default.isAxiosError(data)) {
+            return data;
+        }
+        const occurrences = {};
+        const sanitizedData = data.map((row) => {
+            const baseLabel = row.label;
+            occurrences[baseLabel] = (occurrences[baseLabel] || 0) + 1;
+            return Object.assign(Object.assign({}, row), { label: occurrences[baseLabel] > 1 ? `${baseLabel} (${occurrences[baseLabel]})` : baseLabel });
+        });
+        return sanitizedData;
+    });
+}
+const loginByPayload = (payload, serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!serverEndPoint) {
+        return {
+            message: noServerEndPointMessage,
+            isAxiosError: true,
+        };
+    }
+    const url = serverEndPoint.getToken;
+    if (!url) {
+        console.log('Erro no loginByPayload: faltou a configuração de url getToken!');
+        return false;
+    }
+    try {
+        const { data } = yield axios_1.default.post(url, payload);
+        localStorage.setItem('refreshToken', data.refresh);
+        (0, exports.setAuthToken)(data.access);
+        return true;
+    }
+    catch (e) {
+        console.log('Erro no loginByPayload!', e);
+        (0, exports.setAuthToken)(null);
+        return false;
+    }
+});
+exports.loginByPayload = loginByPayload;
+const clearJWT = () => {
+    localStorage.removeItem('token');
+    return false;
+};
+exports.clearJWT = clearJWT;
+const hasJWT = () => {
+    const token = localStorage.getItem('token');
+    if (token) {
+        return true;
+    }
+    return false;
+};
+exports.hasJWT = hasJWT;
+const setAuthToken = (token) => {
+    if (token) {
+        localStorage.setItem('token', token);
+        axios_1.default.defaults.headers.common.Authorization = `Bearer ${token}`;
+        return;
+    }
+    localStorage.removeItem('token');
+    localStorage.removeItem('refreshToken');
+    delete axios_1.default.defaults.headers.common.Authorization;
+};
+exports.setAuthToken = setAuthToken;
+const refreshToken = (serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!serverEndPoint) {
+        return {
+            message: noServerEndPointMessage,
+            isAxiosError: true,
+        };
+    }
+    const refreshToken = localStorage.getItem('refreshToken');
+    (0, exports.setAuthToken)(null);
+    if (!refreshToken) {
+        (0, exports.dispatchAuthExpired)();
+        return false;
+    }
+    try {
+        const { data } = yield axios_1.default.post(`${serverEndPoint.refreshToken}`, {
+            refresh: refreshToken,
+        });
+        (0, exports.setAuthToken)(data.access);
+        return true;
+    }
+    catch (e) {
+        console.log('Failed refreshing token', e);
+        (0, exports.dispatchAuthExpired)();
+        return false;
+    }
+});
+const isLoggedIn = (serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    const token = localStorage.getItem('token');
+    (0, exports.setAuthToken)(token);
+    if (!token) {
+        return false;
+    }
+    const usuaria = yield getData({ path: 'my_account/', serverEndPoint });
+    if (axios_1.default.isAxiosError(usuaria)) {
+        console.log('Erro ao recuperar dados de usuária!');
+        return false;
+    }
+    return usuaria;
+});
+exports.isLoggedIn = isLoggedIn;
+const getSignUpOptions = (serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!serverEndPoint || !serverEndPoint.signUp) {
+        return {
+            message: noServerEndPointMessage,
+            isAxiosError: true,
+        };
+    }
+    const url = serverEndPoint.signUp;
+    try {
+        const { data } = yield axios_1.default.options(url);
+        return data.action.POST;
+    }
+    catch (e) {
+        const message = `Error fetching options from ${url}`;
+        console.log(message, e);
+        return {
+            message,
+            isAxiosError: true,
+        };
+    }
+});
+exports.getSignUpOptions = getSignUpOptions;
+const signUp = (data, serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    if (!serverEndPoint || !serverEndPoint.signUp) {
+        return {
+            message: noServerEndPointMessage,
+            isAxiosError: true,
+        };
+    }
+    const url = serverEndPoint.signUp;
+    try {
+        const { data: responseData } = yield axios_1.default.post(url, data);
+        return responseData;
+    }
+    catch (e) {
+        if (axios_1.default.isAxiosError(e)) {
+            const err = e;
+            const message = `Error trying signUp at ${url}`;
+            if (((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                const isRefreshed = yield refreshToken(serverEndPoint);
+                if (!isRefreshed) {
+                    console.log(expiredTokenMessage);
+                    return {
+                        message: expiredTokenMessage,
+                        isAxiosError: true,
+                    };
+                }
+                try {
+                    const { data: responseData } = yield axios_1.default.post(url, data);
+                    return responseData;
+                }
+                catch (e) {
+                    console.log(message, data, e);
+                    return {
+                        message,
+                        isAxiosError: true,
+                    };
+                }
+            }
+            console.log(message, data, e);
+            return {
+                message,
+                isAxiosError: true,
+            };
+        }
+    }
+    console.log(unknownError, data);
+    return {
+        message: unknownError,
+        isAxiosError: true,
+    };
+});
+exports.signUp = signUp;
+const requestPasswordReset = (email, serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!serverEndPoint || !serverEndPoint.requestPasswordReset) {
+        return {
+            message: noServerEndPointMessage,
+            isAxiosError: true,
+        };
+    }
+    const url = serverEndPoint.requestPasswordReset;
+    try {
+        const { data } = yield axios_1.default.post(url, { email });
+        return data;
+    }
+    catch (e) {
+        if (axios_1.default.isAxiosError(e)) {
+            return e;
+        }
+    }
+    return { message: unknownError, isAxiosError: true };
+});
+exports.requestPasswordReset = requestPasswordReset;
+const confirmPasswordReset = (data, serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!serverEndPoint || !serverEndPoint.confirmPasswordReset) {
+        return {
+            message: noServerEndPointMessage,
+            isAxiosError: true,
+        };
+    }
+    const url = serverEndPoint.confirmPasswordReset;
+    try {
+        const { data: responseData } = yield axios_1.default.post(url, data);
+        return responseData;
+    }
+    catch (e) {
+        if (axios_1.default.isAxiosError(e)) {
+            return e;
+        }
+    }
+    return { message: unknownError, isAxiosError: true };
+});
+exports.confirmPasswordReset = confirmPasswordReset;
+const changePassword = (data, serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!serverEndPoint || !serverEndPoint.changePassword) {
+        return {
+            message: noServerEndPointMessage,
+            isAxiosError: true,
+        };
+    }
+    const url = serverEndPoint.changePassword;
+    try {
+        const { data: responseData } = yield axios_1.default.post(url, data);
+        return responseData;
+    }
+    catch (e) {
+        if (axios_1.default.isAxiosError(e)) {
+            return e;
+        }
+    }
+    return { message: unknownError, isAxiosError: true };
+});
+exports.changePassword = changePassword;
+function getGenericModelList(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ model, serverEndPoint, id = '', relatedModel = '', relatedModelId = '', columnFields, creatableFields, disabledFields, isInBatches = false, loadedSchema, loadedModelOptions, page, filter, queryParams = [], sort, sumRows, schemas, }) {
+        const newQueryParams = [...queryParams];
+        let path = `${model}/${id}`;
+        let schemaPath = `${model}/`;
+        let schema = loadedSchema;
+        let modelOptions = loadedModelOptions;
+        let columns = [];
+        if (!(0, utils_1.isTmpId)(id) && relatedModel) {
+            path += `/${relatedModel}/`;
+            if (relatedModelId) {
+                path += `${relatedModelId}/`;
+            }
+            schemaPath += `${id}/${relatedModel}/`;
+        }
+        // SERVER-SIDE TOTALS (sumRows):
+        if (sumRows) {
+            const sumRowsParams = sumRows.rows.map((row) => row.field).join(',');
+            newQueryParams.push(`sum_rows=${sumRowsParams}`);
+        }
+        // SERVER-SIDE FILTERING:
+        if (filter) {
+            if (filter.quickFilterValues &&
+                filter.quickFilterValues.length > 0 &&
+                filter.quickFilterValues[0]) {
+                newQueryParams.push(`search=${filter.quickFilterValues[0]}`);
+            }
+            for (const item of filter.items) {
+                if (!item.operator) {
+                    continue;
+                }
+                const queryParam = item.value
+                    ? `field=${item.field}&operator=${item.operator}&value=${item.value}`
+                    : `field=${item.field}&operator=${item.operator}`;
+                newQueryParams.push(queryParam);
+            }
+        }
+        // SERVER-SIDE SORTING:
+        if (sort) {
+            const sortParams = [];
+            for (const item of sort) {
+                sortParams.push(item.sort === 'desc' ? `-${item.field}` : item.field);
+            }
+            newQueryParams.push(`ordering=${sortParams.join(',')}`);
+        }
+        // SERVER-SIDE PAGINATION:
+        if (page) {
+            newQueryParams.push(`page=${page + 1}`);
+        }
+        // Only get schema and columns if not in batches or in first batch:
+        if (!schema) {
+            const options = yield getSchema(schemaPath, serverEndPoint, schemas);
+            if (!options || axios_1.default.isAxiosError(options)) {
+                return (options || { message: unknownError, isAxiosError: true });
+            }
+            schema = options.schema;
+            if (!schema) {
+                return { message: `Schema not found for ${model}`, isAxiosError: true };
+            }
+            modelOptions = options.modelOptions;
+            columns = getDataGridColumns(schema, columnFields, creatableFields, disabledFields);
+            if (!columns) {
+                return {
+                    message: `Columns could not be generated for ${model}`,
+                    isAxiosError: true,
+                };
+            }
+        }
+        let rowCount = 0;
+        let sumRowsTotals = null;
+        let data = [];
+        if (!id || (id && !relatedModelId)) {
+            if (isInBatches) {
+                newQueryParams.push(loadedSchema ? 'is_last_batch=1' : 'is_first_batch=1');
+            }
+            if (newQueryParams.length > 0) {
+                path += `?${newQueryParams.join('&')}`;
+            }
+            const ret = yield getData({ path, serverEndPoint });
+            if (ret && axios_1.default.isAxiosError(ret)) {
+                return ret;
+            }
+            const dataRaw = 'results' in ret ? ret.results : ret;
+            if ('results' in ret) {
+                rowCount = ret.count;
+                if (sumRows) {
+                    sumRowsTotals = ret.sum_rows;
+                }
+            }
+            if (!schema) {
+                return { message: `Schema not found for ${model}`, isAxiosError: true };
+            }
+            data = dataRaw.map((row) => {
+                const newRow = {};
+                for (const [key, field] of Object.entries(schema)) {
+                    if (!(key in row)) {
+                        continue;
+                    }
+                    if ((field === null || field === void 0 ? void 0 : field.type) === 'choice') {
+                        newRow[key] = row[key]
+                            ? {
+                                value: row[key],
+                                display_name: (0, utils_1.getChoiceByValue)(row[key], field.choices),
+                            }
+                            : (0, utils_1.emptyByType)(field);
+                        continue;
+                    }
+                    if ((field === null || field === void 0 ? void 0 : field.type) === 'list' || (field === null || field === void 0 ? void 0 : field.type) === 'multiple choice') {
+                        newRow[key] = Array.isArray(row[key])
+                            ? row[key].map((entry) => { var _a; return (0, utils_1.toChoiceItem)(entry, (_a = field.child) === null || _a === void 0 ? void 0 : _a.choices); })
+                            : (0, utils_1.emptyByType)(field);
+                        continue;
+                    }
+                    newRow[key] = row[key] ? row[key] : (0, utils_1.emptyByType)(field);
+                }
+                return newRow;
+            });
+        }
+        if (!schema || !columns) {
+            return {
+                message: `Schema or columns not found for ${model}`,
+                isAxiosError: true,
+            };
+        }
+        return { data, columns, schema, modelOptions, rowCount, sumRowsTotals };
+    });
+}
+function getGenericModel(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ model, serverEndPoint, id = '', relatedModel = '', relatedModelId = '', schemas, }) {
+        let path = `${model}/${id}`;
+        let schemaPath = `${model}/`;
+        if (!(0, utils_1.isTmpId)(id) && relatedModel) {
+            path += `/${relatedModel}/`;
+            if (relatedModelId) {
+                path += `${relatedModelId}/`;
+            }
+            schemaPath += `${id}/${relatedModel}/`;
+        }
+        else if (id) {
+            path += '/';
+        }
+        const options = yield getSchema(schemaPath, serverEndPoint, schemas);
+        if (!options || axios_1.default.isAxiosError(options)) {
+            return (options || { message: unknownError, isAxiosError: true });
+        }
+        const { schema, modelOptions } = options;
+        const columns = getDataGridColumns(schema);
+        if (!columns) {
+            return {
+                message: `Columns could not be generated for ${model}`,
+                isAxiosError: true,
+            };
+        }
+        let data = {};
+        if (!(0, utils_1.isTmpId)(id) && (!relatedModel || (relatedModel && relatedModelId))) {
+            const response = yield getData({ path, serverEndPoint });
+            if (!axios_1.default.isAxiosError(response)) {
+                data = response;
+            }
+            else {
+                return response;
+            }
+        }
+        return { schema, columns, modelOptions, data };
+    });
+}
+const getAllModels = (serverEndPoint) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!serverEndPoint) {
+        return {
+            message: noServerEndPointMessage,
+            isAxiosError: true,
+        };
+    }
+    const data = yield getData({ path: 'endpoints/', serverEndPoint });
+    return axios_1.default.isAxiosError(data) ? [] : data;
+});
+exports.getAllModels = getAllModels;
+const exportExcelData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ model, modelParent, modelParentId, paginationModel, serverEndPoint, }) {
+    var _b;
+    if (!serverEndPoint) {
+        return {
+            message: noServerEndPointMessage,
+            isAxiosError: true,
+        };
+    }
+    const filter = paginationModel.filter;
+    const sort = paginationModel.sort;
+    const newQueryParams = paginationModel.queryParams ? [...paginationModel.queryParams] : [];
+    try {
+        // SERVER-SIDE FILTERING:
+        if (filter) {
+            if (filter.quickFilterValues &&
+                filter.quickFilterValues.length > 0 &&
+                filter.quickFilterValues[0]) {
+                newQueryParams.push(`search=${filter.quickFilterValues[0]}`);
+            }
+            for (const item of filter.items) {
+                if (!item.operator) {
+                    continue;
+                }
+                const queryParam = item.value
+                    ? `field=${item.field}&operator=${item.operator}&value=${item.value}`
+                    : `field=${item.field}&operator=${item.operator}`;
+                newQueryParams.push(queryParam);
+            }
+        }
+        // SERVER-SIDE SORTING:
+        if (sort) {
+            const sortParams = [];
+            for (const item of sort) {
+                sortParams.push(item.sort === 'desc' ? `-${item.field}` : item.field);
+            }
+            newQueryParams.push(`ordering=${sortParams.join(',')}`);
+        }
+        let url = !modelParent || !modelParentId
+            ? `${serverEndPoint.api}/${model}/excel/`
+            : `${serverEndPoint.api}/${modelParent}/${modelParentId}/${model}/excel/`;
+        if (newQueryParams.length > 0) {
+            url += `?${newQueryParams.join('&')}`;
+        }
+        const response = yield axios_1.default.get(url, { responseType: 'blob' });
+        const downloadUrl = window.URL.createObjectURL(new Blob([response.data]));
+        const link = document.createElement('a');
+        link.href = downloadUrl;
+        // Try to get filename from content-disposition header if available, otherwise use model name
+        let filename = `${model}.xlsx`;
+        const disposition = response.headers['content-disposition'];
+        if (disposition && disposition.indexOf('attachment') !== -1) {
+            const filenameRegex = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/;
+            const matches = filenameRegex.exec(disposition);
+            if (matches != null && matches[1]) {
+                filename = matches[1].replace(/['"]/g, '');
+            }
+        }
+        link.setAttribute('download', filename);
+        document.body.appendChild(link);
+        link.click();
+        (_b = link.parentNode) === null || _b === void 0 ? void 0 : _b.removeChild(link);
+        return true;
+    }
+    catch (error) {
+        console.error('Error exporting to excel:', error);
+        if (axios_1.default.isAxiosError(error)) {
+            return error;
+        }
+        return {
+            message: 'Erro desconhecido ao exportar para Excel',
+            isAxiosError: true,
+        };
+    }
+});
+exports.exportExcelData = exportExcelData;