@opendash/plugin-parse/dist/admin/hooks.js

Parse Server Plugin for open.DASH

var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
import React from "react";
import { CopyOutlined, EditOutlined, LockOutlined } from "@ant-design/icons";
import { Tooltip } from "antd";
import { Parse } from "parse-hooks";
import { useParams } from "react-router-dom";
import { useTranslation } from "opendash";
import { AdminContext } from "./AdminContext";
import AdminTableFilter from "./AdminTableFilter";
import { AdminTableCell } from "./AdminTableCell";
export function useConfig() {
    var config_key = useParams().config_key;
    var _a = React.useContext(AdminContext), configs = _a[0], schemas = _a[1];
    var config = configs.find(function (c) { return c.key === config_key; });
    var schema = schemas.find(function (s) { var _a; return s.className === ((_a = config) === null || _a === void 0 ? void 0 : _a.className); });
    return [configs, config, schemas, schema];
}
export function useFetchSchema() {
    var _a = React.useState(undefined), state = _a[0], setState = _a[1];
    React.useEffect(function () {
        Parse.Cloud.run("getSchemaForAdmin").then(setState, console.error);
    }, []);
    return state;
}
export function useCreateColumns(_a) {
    var setEditElement = _a.setEditElement, setCreateElement = _a.setCreateElement, setEditPermission = _a.setEditPermission;
    var t = useTranslation(["parse", "parse-custom", "opendash"])[0];
    var _b = useConfig(), configs = _b[0], config = _b[1], schemas = _b[2], schema = _b[3];
    return React.useMemo(function () {
        var columnsOut = [];
        var _loop_1 = function (col) {
            var type = schema.fields[col] ? schema.fields[col].type : undefined;
            var column = {
                title: t("parse-custom:classes." + config.key + ".fields." + col, col),
                key: col,
                dataIndex: ["attributes", col],
                sorter: undefined,
                // filterDropdown: undefined,
                render: function (v, row) { return (React.createElement(AdminTableCell, { type: type, field: col, row: row })); },
            };
            if (["String", "Number", "Date"].includes(type)) {
                column.sorter = true;
            }
            if (["String"].includes(type)) {
                column.filterDropdown = function (props) { return (React.createElement(AdminTableFilter, __assign({ type: type }, props))); };
            }
            columnsOut.push(column);
        };
        for (var _i = 0, _a = config.columns; _i < _a.length; _i++) {
            var col = _a[_i];
            _loop_1(col);
        }
        columnsOut.push({
            title: t("parse-custom:classes." + config.key + ".fields.id", ""),
            dataIndex: "id",
            key: "default-id",
            render: function (id, row) { return (React.createElement("span", null,
                React.createElement("pre", { children: id, style: { display: "inline", fontSize: ".8em" } }),
                React.createElement(Tooltip, { title: t("parse:admin.edit_role_permission") },
                    React.createElement(LockOutlined, { style: { marginLeft: 10, cursor: "pointer" }, onClick: function (e) { return setEditPermission(id); } })),
                React.createElement(Tooltip, { title: t("parse:admin.edit.tooltip") },
                    React.createElement(EditOutlined, { style: { marginLeft: 10, cursor: "pointer" }, onClick: function (e) { return setEditElement(row); } })),
                React.createElement(Tooltip, { title: t("parse:admin.copy.tooltip") },
                    React.createElement(CopyOutlined, { style: { marginLeft: 10, cursor: "pointer" }, onClick: function (e) { return setCreateElement(row); } })))); },
        });
        return columnsOut;
    }, [config]);
}
export function useCreateParseQuery(objectClass, settings) {
    var queryRef = React.useRef(undefined);
    return React.useMemo(function () {
        var q = new Parse.Query(objectClass);
        q.limit(settings.pageSize);
        if (settings.page) {
            q.skip((settings.page - 1) * settings.pageSize);
        }
        if (settings.sortKey && settings.sortOrder) {
            if (settings.sortOrder === "ascend") {
                q.ascending(settings.sortKey);
            }
            if (settings.sortOrder === "descend") {
                q.descending(settings.sortKey);
            }
        }
        if (settings.filter) {
            Object.entries(settings.filter).forEach(function (_a) {
                var field = _a[0], _b = _a[1], filterType = _b[0], filterValue = _b[1];
                if (filterType === "equals" && filterValue) {
                    q.equalTo(field, filterValue);
                }
                if (filterType === "equals_not" && filterValue) {
                    q.notEqualTo(field, filterValue);
                }
                if (filterType === "starts_with" && filterValue) {
                    q.startsWith(field, filterValue);
                }
                if (filterType === "ends_with" && filterValue) {
                    q.endsWith(field, filterValue);
                }
                if (filterType === "contains" && filterValue) {
                    q.contains(field, filterValue);
                }
                if (filterType === "exists") {
                    q.exists(field);
                }
                if (filterType === "exists_not") {
                    q.doesNotExist(field);
                }
            });
        }
        return q;
    }, [objectClass, JSON.stringify(settings)]);
}
//# sourceMappingURL=hooks.js.map