@bchr/bchr-front-lib 0.5.9 → 0.5.10

package/src/base/layout/RefInput.js

@@ -0,0 +1,148 @@
+import React, {Fragment} from "react";
+import InputRefAddonBtn from "./InputRefAddonBtn";
+import {Values} from "../utils";
+import Strings from "../utils/Strings";
+import lodash from "lodash";
+import {Input} from "antd";
+
+class RefInput extends React.Component {
+    constructor(props) {
+        super(props);
+        this.modalRef = React.createRef();
+    }
+
+    buildHiddenFieldNames = (field) => {
+        if (Values.isBlankString(field)) {
+            throw new Error("参照输入控件缺少【field】关键属性");
+        }
+
+        if (field.endsWith("_ext_name")) {
+            let index = field.indexOf("_ext_name");
+            let fieldPrefix = field.substring(0, index)
+            return [fieldPrefix + "_pk", fieldPrefix + "_ext_code"];
+        }
+        else if (field.endsWith("_name")) {
+            let index = field.indexOf("_name");
+            let fieldPrefix = field.substring(0, index)
+            return [fieldPrefix + "_pk", fieldPrefix + "_code"];
+        }
+        else {
+            throw new Error("参照输入控件缺少【field】关键属性的名称需要以【_ext_name】结尾");
+        }
+    }
+
+    onInputChange = (value) => {
+        const { data, field } = this.props;
+        if (data) {
+            let [field_pk, field_code] = this.buildHiddenFieldNames(field);
+            data[field] = value;
+            data[field_pk] = null;
+            data[field_code] = null;
+
+            this.forceUpdate();
+        }
+    }
+
+    onOk = (selectedData) => {
+        const {multiple, field, data, okCallback} = this.props;
+        if (data) {
+            let [field_pk, field_code] = this.buildHiddenFieldNames(field);
+
+            if (!multiple) {
+                data[field] = selectedData[0].name;
+                data[field_pk] = selectedData[0].pk;
+                data[field_code] = selectedData[0].code;
+            } else {
+                let fieldNameData = [];
+                let fieldPkData = [];
+                let fieldCodeData = [];
+
+                selectedData.forEach(item => {
+                    fieldNameData.push(item.name);
+                    fieldPkData.push(item.pk);
+                    fieldCodeData.push(item.code);
+                })
+
+                data[field] = fieldPkData.join(',');
+                data[field_pk] = fieldCodeData.join(',');
+                data[field_code] = fieldNameData.join(',');
+            }
+
+            this.forceUpdate();
+        }
+        if (okCallback && typeof okCallback === 'function') {
+            if (!multiple) {
+                okCallback(selectedData[0], data);
+            } else {
+                okCallback(selectedData, data);
+            }
+        }
+    }
+
+    onClear = () => {
+        const {field, data, clearCallback} = this.props;
+        let [field_pk, field_code] = this.buildHiddenFieldNames(field);
+
+        data[field_pk] = null;
+        data[field_code] = null;
+        data[field] = null;
+
+        this.forceUpdate();
+
+        if (clearCallback && typeof clearCallback === 'function') {
+            clearCallback(null);
+        }
+    }
+
+    render() {
+        let inputProps = {...this.props};
+        let {
+            disabled, refCode, refDialogWidth, refDialogHeight, field, data, multiple, rules, isNotData, customGridData, customRefUIConfig,
+            onBeforeClick, readonly
+        } = inputProps;
+
+        delete inputProps.addonAfter;
+        delete inputProps.refCode;
+        delete inputProps.refDialogWidth;
+        delete inputProps.refDialogHeight;
+        delete inputProps.formRef;
+        delete inputProps.multiple;
+        delete inputProps.rules;
+        delete inputProps.okCallback;
+        delete inputProps.isNotData;
+        delete inputProps.customGridData;
+        delete inputProps.customRefUIConfig;
+        delete inputProps.onBeforeClick;
+        delete inputProps.readonly;
+
+        if (lodash.isPlainObject(refCode) && Strings.isNotBlankString(refCode.dictCode)) {
+            refCode = refCode.dictCode
+        }
+
+        let [field_pk, field_code] = this.buildHiddenFieldNames(field);
+
+        return <Fragment>
+            {field_pk   && <input type={"hidden"} name={field_pk}></input>}
+            {field_code && <input type={"hidden"} name={field_code}></input>}
+            <Input {...inputProps} className={`ref-input ${inputProps.className || ''}`}
+                   value={data[field]}
+                   readonly={readonly === undefined || readonly}
+                   onClear={this.onClear}
+                   onChange={this.onInputChange}
+                   addonAfter={!disabled && <InputRefAddonBtn ref={this.modalRef}
+                                                              isNotData={isNotData}
+                                                              customGridData={customGridData}
+                                                              customRefUIConfig={customRefUIConfig}
+                                                              rules={rules}
+                                                              refCode={refCode}
+                                                              multiple={multiple}
+                                                              onOk={this.onOk}
+                                                              onBeforeClick={onBeforeClick}
+                                                              refDialogWidth={refDialogWidth}
+                                                              refDialogHeight={refDialogHeight}/>}/>
+        </Fragment>
+    }
+
+}
+
+export default RefInput;

package/src/base/utils/TableDataProcessors.js

@@ -0,0 +1,87 @@
+import Values from "./Values";
+
+const buildTableTreeDataSource = function(flatArrayData, recordIDFieldName, recordParentIDFieldName) {
+    if (typeof recordIDFieldName !== "string") {
+        throw new Error("Invalid parameter value: recordIDFieldName.");
+    }
+
+    if (typeof recordParentIDFieldName !== "string") {
+        throw new Error("Invalid parameter value: recordParentIDFieldName.");
+    }
+
+    if (!flatArrayData) {
+        return [];
+    }
+
+    if (!Array.isArray(flatArrayData)) {
+        throw new Error("The original data source is not array!");
+    }
+
+    if (flatArrayData.length === 0) {
+        return [];
+    }
+
+    let topRecords = [];
+    let recordPK2RecordVOMap = new Map();
+    for (let i = 0, len = flatArrayData.length; i < len; i++) {
+        let record = flatArrayData[i];
+        if (record) {
+            let recordIDValue = record[recordIDFieldName];
+            if (recordIDValue) {
+
+                if (!record[recordParentIDFieldName]) {
+                    topRecords.push(record);
+                }
+
+                recordPK2RecordVOMap.set(recordIDValue, record);
+            }
+        }
+    }
+
+    for (let i = 0, len = flatArrayData.length; i < len; i++) {
+        let record = flatArrayData[i];
+        if (record) {
+            let recordIDValue = record[recordIDFieldName];
+            if (recordIDValue) {
+                let recordParentIDValue = record[recordParentIDFieldName];
+                if (recordParentIDValue) {
+                    let parentRecord = recordPK2RecordVOMap.get(recordParentIDValue);
+                    if (parentRecord) {
+                        if (!parentRecord.children) {
+                            parentRecord.children = [];
+                        }
+
+                        parentRecord.children.push(record);
+                    }
+                }
+            }
+        }
+    }
+
+    return topRecords;
+}
+
+const buildQueryParameters = function (gridOperator) {
+    let param = {
+        pageIndex : (gridOperator.skip / gridOperator.take) + 1,
+        pageSize  : gridOperator.take,
+    }
+
+    let filters = gridOperator.filter?.filters || [];
+    if (Values.isNotEmptyArray(filters)) {
+        let filter = {};
+
+        for (let i = 0; i < filters.length; i++) {
+            filter[filters[i].field] = filters[i].value;
+        }
+
+        param.filter = filter;
+    }
+
+    return param;
+}
+
+export {
+    buildTableTreeDataSource,
+    buildQueryParameters
+}

package/src/services/KendoGridAPI.js

@@ -0,0 +1,298 @@
+import React from "react";
+import lodash from "lodash";
+import Values from "../base/utils/Values";
+import DateTimes from "../base/utils/DateTimes";
+import uuid from 'react-uuid';
+import {message} from "antd";
+
+class KendoGridAPI {
+    constructor(kendoGridRef, state, setState) {
+        this.gridTableRef = kendoGridRef;
+
+        if (state) {
+            if (Values.isNotEmpty(state)) {
+                this.state = state;
+                this.setState = setState;
+            }
+            else {
+                throw new Error("Invalid state for create KendoGridAPI");
+            }
+        }
+
+        this.defaultPagerGridModelObj = {
+            skip: 0,
+            take: 20,
+            filters: [],
+            pageable: {
+                pageSizes: [20, 50, 100, 200],
+                type: 'numeric'
+            },
+            total: 0,
+            filterable: true,
+            resizable: true,
+            sortable: {mode: 'multiple'},
+            data: []
+        }
+    }
+
+    static of(gridTableRef, state, setState) {
+        return new KendoGridAPI(gridTableRef, state, setState);
+    }
+
+    getTableRef() {
+        return this.gridTableRef;
+    }
+
+    buildPagerGridModel(modelOptions) {
+        let model = null;
+
+        if (lodash.isPlainObject(modelOptions)) {
+            model = Object.assign({...this.defaultPagerGridModelObj}, modelOptions);
+        } else {
+            model = {...this.defaultPagerGridModelObj};
+        }
+
+        this.setState({
+            refTableModel: {...model}
+        })
+
+        return this.state.refTableModel;
+    }
+
+    buildNotPagerGridModel(modelOptions) {
+        let model = null;
+
+        if (lodash.isPlainObject(modelOptions)) {
+            model = Object.assign({...this.defaultPagerGridModelObj, pageable: false}, modelOptions);
+        } else {
+            model = {...this.defaultPagerGridModelObj, pageable: false};
+        }
+
+        this.setState({
+            refTableModel: {...model}
+        })
+
+        return this.state.refTableModel;
+    }
+
+    setTableFilter(field, filterInfo) {
+        if (!this.state.refTableModel.filters) {
+            this.state.refTableModel.filters = [];
+        }
+        let filters = this.state.refTableModel?.filters;
+        let hasFieldIndex = filters?.findIndex(item => item.field === field);
+
+        if (Values.isNotEmpty(filterInfo)) {
+            if (hasFieldIndex !== -1) {
+                this.state.refTableModel.filters[hasFieldIndex] = filterInfo;
+            } else {
+                this.state.refTableModel.filters.unshift({...filterInfo, field});
+            }
+        } else {
+            this.state.refTableModel.filters = filters.filter(item => item.field !== field);
+        }
+
+        this.setState({
+            refTableModel: {...this.state.refTableModel}
+        })
+
+        return this.state.refTableModel;
+    }
+
+    setTableDataWithNoPageable(allData) {
+        let dataArray = allData || [];
+        if (lodash.isEmpty(this.state.refTableModel)) {
+            throw new Error("please create buildPagerTableModel first, then set table data.");
+        }
+        this.state.refTableModel.data = dataArray;
+
+        this.setState({
+            refTableModel: {...this.state.refTableModel}
+        })
+
+        return this.state.refTableModel;
+    }
+
+    setAllDataWithPage(allData) {
+        let dataArray = allData || [];
+        this.setOnePageData({
+            data: dataArray,
+            total: dataArray.length
+        }, this.getCurrentPageIndex(), this.getPageSize())
+    }
+
+    setOnePageData(onePageResultData, pageIndex, pageSize) {
+        if (lodash.isEmpty(this.state.refTableModel)) {
+            throw new Error("please create buildPagerTableModel first, then set table data.");
+        }
+
+        if (Values.isEmpty(onePageResultData)) {
+            throw new Error("please check pageData value.");
+        }
+
+        this.state.refTableModel.data = onePageResultData?.data;
+        this.state.refTableModel.skip = pageIndex;
+        this.state.refTableModel.take = pageSize
+        this.state.refTableModel.total = onePageResultData?.total;
+
+        this.setState({
+            refTableModel: {...this.state.refTableModel}
+        })
+
+        return this.state.refTableModel;
+    }
+
+    getRowData(row) {
+        if (row.uid) {
+            return this.state.refTableModel.data.filter(item => item.uid === row.uid)[0];
+        }
+        return this.state.refTableModel.data.filter(item => item.pk === row.pk)[0];
+    }
+
+    insertRow(row) {
+        let addItem = {
+            uid: uuid(),
+            inEditState: true,
+        }
+        if (lodash.isPlainObject(row)) {
+            addItem = {...addItem, ...row}
+        }
+        if (Values.isEmpty(this.state.refTableModel.data)) {
+            this.state.refTableModel.data = [];
+        }
+        this.state.refTableModel.data.push({...addItem});
+
+        this.setState({
+            refTableModel: {...this.state.refTableModel}
+        })
+
+        return this
+    }
+
+    insertOneRow(row) {
+        if (Values.isNotEmptyArray(this.state.refTableModel.data)) {
+            let findData = this.state.refTableModel.data.find(item => Values.isNotNull(item.uid) || item.inEditState);
+
+            if (Values.isNull(findData)) {
+                this.insertRow(row);
+            } else {
+                message.warning("有未保存的数据，请先保存或取消");
+            }
+        } else {
+            this.insertRow(row);
+        }
+    }
+
+    removeRow(row) {
+        let filterGridData = this.state.refTableModel.data.filter(item => item.pk ? item.pk !== row.pk : item.uid !== row.uid);
+        this.state.refTableModel.data = [...filterGridData];
+
+        this.setState({
+            refTableModel: {...this.state.refTableModel}
+        })
+    }
+
+    updateRow(row) {
+        let rowIndex = this.state.refTableModel.data.findIndex(item => item.pk === row.pk);
+
+        if (row.uid) {
+            rowIndex = this.state.refTableModel.data.findIndex(item => item.uid === row.uid);
+        }
+
+        if (rowIndex !== -1) {
+            let dataItem = this.state.refTableModel.data[rowIndex];
+            this.state.refTableModel.data[rowIndex] = {...dataItem, ...row};
+        }
+
+        this.setState({
+            refTableModel: {...this.state.refTableModel}
+        })
+
+        return this;
+    }
+
+    setRowInEditState(row, state = true) {
+        this.state.refTableModel.data?.forEach((item, index) => {
+            if (item.pk === row.pk) {
+                if (!state) {
+                    this.state.refTableModel.data[index] = {...row};
+                    this.state.refTableModel.data[index].inEditState = state;
+                } else {
+                    item.inEditState = state;
+                }
+            }
+        })
+
+        this.setState({
+            refTableModel: {...this.state.refTableModel}
+        })
+        return this;
+    }
+
+    setAllRowInEditState(state = true) {
+        this.state.refTableModel.data?.forEach(item => {
+            item.inEditState = state;
+        })
+
+        this.setState({
+            refTableModel: {...this.state.refTableModel}
+        })
+
+        return this;
+    }
+
+    renderBooleanColumnAsText(rowIndex, column) {
+        return this.state.refTableModel.data[rowIndex][column.dataIndex] ? "是" : "否";
+    }
+
+    renderDateColumnAsDate10Text(rowIndex, column) {
+        return DateTimes.strDateOfLen10(this.state.refTableModel.data[rowIndex][column.dataIndex]);
+    }
+
+    renderDateColumnAsDateTime19Text(rowIndex, column) {
+        return DateTimes.strDateTimeOfLen19(this.state.refTableModel.data[rowIndex][column.dataIndex]);
+    }
+
+    rowIndex(rowIndex) {
+        return (this.state.refTableModel.skip - 1) * this.state.refTableModel.take + rowIndex + 1;
+    }
+
+    showTotalRow() {
+        this.state.refTableModel.showTotal = true;
+        this.setState({
+            refTableModel: {...this.state.refTableModel}
+        })
+    }
+
+    hideTotalRow() {
+        this.state.refTableModel.showTotal = false;
+        this.setState({
+            refTableModel: {...this.state.refTableModel}
+        })
+    }
+
+    setPageSize(size) {
+        this.state.refTableModel.take = size;
+        this.setState({
+            refTableModel: {...this.state.refTableModel}
+        })
+    }
+
+    getPageSize() {
+        return this.state.refTableModel.take;
+    }
+
+    setCurrentPageIndex(index) {
+        this.state.refTableModel.skip = index;
+        this.setState({
+            refTableModel: {...this.state.refTableModel}
+        })
+    }
+
+    getCurrentPageIndex() {
+        return this.state.refTableModel.skip;
+    }
+
+}
+
+export default KendoGridAPI;