@steedos/filters 2.2.54-beta.3 → 2.2.54-beta.4

package/dist/steedos-filters.umd.js

@@ -0,0 +1,1286 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash'), require('moment')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'lodash', 'moment'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.SteedosFilters = {}, global._, global.moment));
+})(this, (function (exports, lodash, moment) {
+    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+    var moment__default = /*#__PURE__*/_interopDefaultLegacy(moment);
+
+    function leftPad(text, length) {
+        while(text.length < length) {
+            text = "0" + text;
+        }
+        return text;
+    }
+
+    var FORMAT_TYPES = {
+        "3": "abbreviated",
+        "4": "wide",
+        "5": "narrow"
+    };
+
+    var LDML_FORMATTERS = {
+        y: function(date, count, useUtc) {
+            var year = date[useUtc ? "getUTCFullYear" : "getFullYear"]();
+            if(count === 2) {
+                year = year % 100;
+            }
+            return leftPad(year.toString(), count);
+        },
+        M: function(date, count, useUtc, dateParts) {
+            var month = date[useUtc ? "getUTCMonth" : "getMonth"]();
+            var formatType = FORMAT_TYPES[count];
+            if(formatType) {
+                return dateParts.getMonthNames(formatType, "format")[month];
+            }
+            return leftPad((month + 1).toString(), Math.min(count, 2));
+        },
+        L: function(date, count, useUtc, dateParts) {
+            var month = date[useUtc ? "getUTCMonth" : "getMonth"]();
+            var formatType = FORMAT_TYPES[count];
+            if(formatType) {
+                return dateParts.getMonthNames(formatType, "standalone")[month];
+            }
+            return leftPad((month + 1).toString(), Math.min(count, 2));
+        },
+        Q: function(date, count, useUtc, dateParts) {
+            var month = date[useUtc ? "getUTCMonth" : "getMonth"]();
+            var quarter = Math.floor(month / 3);
+            var formatType = FORMAT_TYPES[count];
+            if(formatType) {
+                return dateParts.getQuarterNames(formatType)[quarter];
+            }
+            return leftPad((quarter + 1).toString(), Math.min(count, 2));
+        },
+        E: function(date, count, useUtc, dateParts) {
+            var day = date[useUtc ? "getUTCDay" : "getDay"]();
+            var formatType = FORMAT_TYPES[count < 3 ? 3 : count];
+            return dateParts.getDayNames(formatType)[day];
+        },
+        a: function(date, count, useUtc, dateParts) {
+            var hours = date[useUtc ? "getUTCHours" : "getHours"](),
+                period = hours < 12 ? 0 : 1,
+                formatType = FORMAT_TYPES[count];
+            return dateParts.getPeriodNames(formatType)[period];
+        },
+        d: function(date, count, useUtc) {
+            return leftPad(date[useUtc ? "getUTCDate" : "getDate"]().toString(), Math.min(count, 2));
+        },
+        H: function(date, count, useUtc) {
+            return leftPad(date[useUtc ? "getUTCHours" : "getHours"]().toString(), Math.min(count, 2));
+        },
+        h: function(date, count, useUtc) {
+            var hours = date[useUtc ? "getUTCHours" : "getHours"]();
+            return leftPad((hours % 12 || 12).toString(), Math.min(count, 2));
+        },
+        m: function(date, count, useUtc) {
+            return leftPad(date[useUtc ? "getUTCMinutes" : "getMinutes"]().toString(), Math.min(count, 2));
+        },
+        s: function(date, count, useUtc) {
+            return leftPad(date[useUtc ? "getUTCSeconds" : "getSeconds"]().toString(), Math.min(count, 2));
+        },
+        S: function(date, count, useUtc) {
+            return leftPad(date[useUtc ? "getUTCMilliseconds" : "getMilliseconds"]().toString(), 3).substr(0, count);
+        },
+        x: function(date, count, useUtc) {
+            var timezoneOffset = useUtc ? 0 : date.getTimezoneOffset(),
+                signPart = timezoneOffset > 0 ? "-" : "+",
+                timezoneOffsetAbs = Math.abs(timezoneOffset),
+                hours = Math.floor(timezoneOffsetAbs / 60),
+                minutes = timezoneOffsetAbs % 60,
+                hoursPart = leftPad(hours.toString(), 2),
+                minutesPart = leftPad(minutes.toString(), 2);
+
+            return signPart + hoursPart + (count >= 3 ? ":" : "") + (count > 1 || minutes ? minutesPart : "");
+        },
+        X: function(date, count, useUtc) {
+            if(useUtc || !date.getTimezoneOffset()) {
+                return "Z";
+            }
+            return LDML_FORMATTERS.x(date, count, useUtc);
+        },
+        Z: function(date, count, useUtc) {
+            return LDML_FORMATTERS.X(date, count >= 5 ? 3 : 2, useUtc);
+        }
+    };
+
+    var getFormatter = function(format, dateParts) {
+        return function(date) {
+            var charIndex,
+                formatter,
+                char,
+                charCount = 0,
+                separator = "'",
+                isEscaping = false,
+                isCurrentCharEqualsNext,
+                result = "";
+
+            if(!date) return null;
+
+            if(!format) return date;
+
+            var useUtc = format[format.length - 1] === "Z" || format.slice(-3) === "'Z'";
+
+            for(charIndex = 0; charIndex < format.length; charIndex++) {
+                char = format[charIndex];
+                formatter = LDML_FORMATTERS[char];
+                isCurrentCharEqualsNext = char === format[charIndex + 1];
+                charCount++;
+
+                if(!isCurrentCharEqualsNext) {
+                    if(formatter && !isEscaping) {
+                        result += formatter(date, charCount, useUtc, dateParts);
+                    }
+                    charCount = 0;
+                }
+
+                if(char === separator && !isCurrentCharEqualsNext) {
+                    isEscaping = !isEscaping;
+                } else if(isEscaping || !formatter) {
+                    result += char;
+                }
+                if(char === separator && isCurrentCharEqualsNext) {
+                    charIndex++;
+                }
+            }
+            return result;
+        };
+    };
+
+    const _getFormatter = getFormatter;
+
+    var MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
+        DAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+        PERIODS = ["AM", "PM"],
+        QUARTERS = ["Q1", "Q2", "Q3", "Q4"];
+
+    var cutCaptions = function(captions, format) {
+        var lengthByFormat = {
+            abbreviated: 3,
+            short: 2,
+            narrow: 1
+        };
+
+        return captions.map(function (caption) {
+            return caption.substr(0, lengthByFormat[format]);
+        });
+    };
+
+    function getMonthNames(format) {
+        return cutCaptions(MONTHS, format);
+    }
+    function getDayNames(format) {
+        return cutCaptions(DAYS, format);
+    }
+    function getQuarterNames(format) {
+        return QUARTERS;
+    }
+    function getPeriodNames(format) {
+        return PERIODS;
+    }
+
+    var defaultDateNames = {
+        getMonthNames,
+        getDayNames,
+        getQuarterNames,
+        getPeriodNames
+    };
+
+    // const DevExpress = require("devextreme/bundles/modules/core");
+    // const Guid = require("devextreme/core/guid");
+    // const EdmLiteral = require("devextreme/data/odata/utils").EdmLiteral;
+
+    const DevExpressData = {
+        utils: {
+            isConjunctiveOperator: function (condition) {
+                return /^(and|&&|&)$/i.test(condition);
+            },
+            normalizeBinaryCriterion: function (crit) {
+                return [
+                    crit[0],
+                    crit.length < 3 ? "=" : String(crit[1]).toLowerCase(),
+                    crit.length < 2 ? true : crit[crit.length - 1]
+                ];
+            },
+            isUnaryOperation: function (crit) {
+                return crit[0] === "!" && Array.isArray(crit[1]);
+            }
+        }
+    };
+
+    const DevExpressOData = {
+        pad(text, length, right) {
+            text = String(text);
+            while (text.length < length) {
+                text = right ? (text + "0") : ("0" + text);
+            }
+            return text;
+        },
+        padLeft2(text) {
+            return this.pad(text, 2);
+        },
+        serializePropName(propName) {
+            return propName.replace(/\./g, "/");
+        },
+        serializeValue(value, protocolVersion) {
+            if(value === undefined){
+                // 解决value为undefined的时候解析异常，需要返回null值
+                // 有可能serializeValueV4函数中if (value instanceof Guid)逻辑被注释掉造成的，放开应该就会自动返回null
+                return null;
+            }
+            switch (protocolVersion) {
+                case 2:
+                    return this.serializeValueV2(value);
+                case 3:
+                    return this.serializeValueV2(value);
+                case 4:
+                    return this.serializeValueV4(value);
+                default: 
+                    return this.serializeValueV4(value);
+            }
+        },
+        serializeValueV2(value) {
+            if (value instanceof Date) {
+                return this.serializeDate(value);
+            }
+            // if (value instanceof Guid) {
+            //     return "guid'" + value + "'";
+            // }
+            // if (value instanceof EdmLiteral) {
+            //     return value.valueOf();
+            // }
+            if (typeof value === "string") {
+                return this.serializeString(value);
+            }
+            return String(value);
+        },
+        serializeValueV4(value) {
+            if (value instanceof Date) {
+                return this.formatISO8601(value, false, false);
+            }
+            // if (value instanceof Guid) {
+            //     return value.valueOf();
+            // }
+            if (Array.isArray(value)) {
+                return "[" + value.map((item)=>{
+                    return this.serializeValueV4(item);
+                }).join(",") + "]";
+            }
+            return this.serializeValueV2(value);
+        }, 
+        serializeString(value) {
+            return "'" + value.replace(/'/g, "''") + "'";
+        },
+        serializeDate(value, serializationFormat) {
+            if (!serializationFormat) {
+                return value;
+            }
+
+            if (!(value instanceof Date)) {
+                return null;
+            }
+
+            if (serializationFormat === "number") {
+                return value && value.valueOf ? value.valueOf() : null;
+            }
+
+            return _getFormatter(serializationFormat, defaultDateNames)(value);
+        },
+        formatISO8601(date, skipZeroTime, skipTimezone) {
+            var bag = [];
+
+            var isZeroTime = function () {
+                return date.getUTCHours() + date.getUTCMinutes() + date.getUTCSeconds() + date.getUTCMilliseconds() < 1;
+            };
+
+            bag.push(date.getUTCFullYear());
+            bag.push("-");
+            bag.push(this.padLeft2(date.getUTCMonth() + 1));
+            bag.push("-");
+            bag.push(this.padLeft2(date.getUTCDate()));
+
+            if (!(skipZeroTime && isZeroTime())) {
+                bag.push("T");
+                bag.push(this.padLeft2(date.getUTCHours()));
+                bag.push(":");
+                bag.push(this.padLeft2(date.getUTCMinutes()));
+                bag.push(":");
+                bag.push(this.padLeft2(date.getUTCSeconds()));
+
+                if (date.getUTCMilliseconds()) {
+                    bag.push(".");
+                    bag.push(this.pad(date.getUTCMilliseconds(), 3));
+                }
+
+                if (!skipTimezone) {
+                    bag.push("Z");
+                }
+            }
+
+            return bag.join("");
+        }
+    };
+
+
+    class SteedosFilter {
+
+        constructor(filters, odataProtocolVersion = 4, forceLowerCase = true){
+            this.filters = filters || [];
+            this.protocolVersion = odataProtocolVersion;
+            this.forceLowerCase = forceLowerCase;
+            this.formatters = {
+                "=": this.createBinaryOperationFormatter("eq"),
+                "<>": this.createBinaryOperationFormatter("ne"),
+                ">": this.createBinaryOperationFormatter("gt"),
+                ">=": this.createBinaryOperationFormatter("ge"),
+                "<": this.createBinaryOperationFormatter("lt"),
+                "<=": this.createBinaryOperationFormatter("le"),
+                "startswith": this.createStringFuncFormatter("startswith"),
+                "endswith": this.createStringFuncFormatter("endswith")
+            };
+            this.formattersV2 = {...this.formatters, ...{
+                    "contains": this.createStringFuncFormatter("substringof", true),
+                    "notcontains": this.createStringFuncFormatter("not substringof", true)
+                }
+            };
+            this.formattersV4 = {
+                ...this.formatters, ...{
+                    "contains": this.createStringFuncFormatter("contains"),
+                    "notcontains": this.createStringFuncFormatter("not contains"),
+                    "notstartswith": this.createStringFuncFormatter("not startswith"),
+                    "notendswith": this.createStringFuncFormatter("not endswith"),
+                    "in": this.createBinaryOperationFormatter("in"),
+                    "notin": this.createBinaryOperationFormatter("notin")
+                }
+            };
+        }
+
+        createBinaryOperationFormatter(op) {
+            return (prop, val)=> {
+                return prop + " " + op + " " + val;
+            };
+        }
+
+        createStringFuncFormatter(op, reverse) {
+            return (prop, val)=> {
+                var bag = [op, "("];
+
+                if (this.forceLowerCase) {
+                    // prop = prop.indexOf("tolower(") === -1 ? "tolower(" + prop + ")" : prop;
+                    // forceLowerCase时不需要在prop外面增加tolower(..)，因为odata-v4-mongodb等包不支持
+                    val = val.toLowerCase();
+                }
+
+                if (reverse) {
+                    bag.push(val, ",", prop);
+                } else {
+                    bag.push(prop, ",", val);
+                }
+
+                bag.push(")");
+                return bag.join("");
+            };
+        }
+
+        compileUnary(criteria) {
+            var op = criteria[0],
+                crit = this.compileCore(criteria[1]);
+
+            if (op === "!") {
+                return "not (" + crit + ")";
+            }
+            throw new Error("E4003");
+        }
+
+        compileGroup(criteria) {
+            var bag = [],
+                groupOperator,
+                nextGroupOperator;
+
+            criteria.forEach((criterion) => {
+                if (Array.isArray(criterion)) {
+
+                    if (bag.length > 1 && groupOperator !== nextGroupOperator) {
+                        throw new Error("E4019");
+                    }
+
+                    bag.push("(" + this.compileCore(criterion) + ")");
+
+                    groupOperator = nextGroupOperator;
+                    nextGroupOperator = "and";
+                } else {
+                    nextGroupOperator = DevExpressData.utils.isConjunctiveOperator(criterion) ? "and" : "or";
+                }
+            });
+
+            return bag.join(" " + groupOperator + " ");
+        }
+
+        compileBinary(criteria){
+            criteria = DevExpressData.utils.normalizeBinaryCriterion(criteria);
+
+            var op = criteria[1],
+                formatters = this.protocolVersion === 4
+                    ? this.formattersV4
+                    : this.formattersV2,
+                formatter = formatters[op.toLowerCase()];
+
+            if (!formatter) {
+                throw new Error("E4003");
+            }
+
+            var fieldName = criteria[0],
+                value = criteria[2];
+
+            return formatter(
+                DevExpressOData.serializePropName(fieldName),
+                (op === 'in' || op === 'notin') ? value : DevExpressOData.serializeValue(value, this.protocolVersion)
+            );
+        }
+
+        compileCore(criteria) {
+            if (!criteria || criteria.length === 0){
+                return "";
+            }
+            if (Array.isArray(criteria[0])) {
+                return this.compileGroup(criteria);
+            }
+
+            if (DevExpressData.utils.isUnaryOperation(criteria)) {
+                return this.compileUnary(criteria);
+            }
+
+            return this.compileBinary(criteria);
+        }
+        
+        formatFiltersToODataQuery() {
+            // 转换filters为odata串
+            let filters = this.filters;
+            let query = this.compileCore(filters);
+            return query;
+        }
+    }
+
+    var filter = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        'default': SteedosFilter
+    });
+
+    let t = (key) => {
+        return key;
+    };
+
+    let getMonthDays = (year, month) => {
+        var days, endDate, millisecond, startDate;
+        if (month === 11) {
+            return 31;
+        }
+        millisecond = 1000 * 60 * 60 * 24;
+        startDate = new Date(year, month, 1);
+        endDate = new Date(year, month + 1, 1);
+        days = (endDate - startDate) / millisecond;
+        return days;
+    };
+
+    let getNextQuarterFirstDay = (year, month) => {
+        if (!year) {
+            year = new Date().getFullYear();
+        }
+        if (!month) {
+            month = new Date().getMonth();
+        }
+        if (month < 3) {
+            month = 3;
+        } else if (month < 6) {
+            month = 6;
+        } else if (month < 9) {
+            month = 9;
+        } else {
+            year++;
+            month = 0;
+        }
+        return new Date(year, month, 1);
+    };
+
+    let getLastMonthFirstDay = (year, month) => {
+        if (!year) {
+            year = new Date().getFullYear();
+        }
+        if (!month) {
+            month = new Date().getMonth();
+        }
+    	// 月份为0代表本年的第一月
+        if (month === 0) {
+            month = 11;
+            year--;
+            return new Date(year, month, 1);
+        }
+        // 否则,只减去月份
+        month--;
+        return new Date(year, month, 1);
+    };
+
+    let getQuarterStartMonth = (month) => {
+        if (!month) {
+            month = new Date().getMonth();
+        }
+        if (month < 3) {
+            return 0;
+        } else if (month < 6) {
+            return 3;
+        } else if (month < 9) {
+            return 6;
+        }
+        return 9;
+    };
+
+    let getLastQuarterFirstDay = (year, month) => {
+        if (!year) {
+            year = new Date().getFullYear();
+        }
+        if (!month) {
+            month = new Date().getMonth();
+        }
+        if (month < 3) {
+            year--;
+            month = 9;
+        } else if (month < 6) {
+            month = 0;
+        } else if (month < 9) {
+            month = 3;
+        } else {
+            month = 6;
+        }
+        return new Date(year, month, 1);
+    };
+
+    let getBetweenTimeBuiltinValueItem = (key, utcOffset) => {
+        // 过滤器between运算符，现算日期/日期时间类型字段的values值
+        var currentMonth, currentYear, endValue, firstDay, label, lastDay, lastMonday, lastMonthFinalDay, lastMonthFirstDay, lastQuarterEndDay, lastQuarterStartDay, lastSunday, last_120_days, last_30_days, last_60_days, last_7_days, last_90_days, millisecond, minusDay, monday, month, nextMonday, nextMonthFinalDay, nextMonthFirstDay, nextQuarterEndDay, nextQuarterStartDay, nextSunday, nextYear, next_120_days, next_30_days, next_60_days, next_7_days, next_90_days, now, previousYear, startValue, strEndDay, strFirstDay, strLastDay, strMonday, strStartDay, strSunday, strToday, strTomorrow, strYestday, sunday, thisQuarterEndDay, thisQuarterStartDay, tomorrow, values, week, year, yestday;
+        now = new Date();
+        // 一天的毫秒数
+        millisecond = 1000 * 60 * 60 * 24;
+        yestday = new Date(now.getTime() - millisecond);
+        tomorrow = new Date(now.getTime() + millisecond);
+        // 一周中的某一天
+        week = now.getDay();
+        // 减去的天数
+        minusDay = week !== 0 ? week - 1 : 6;
+        monday = new Date(now.getTime() - (minusDay * millisecond));
+        sunday = new Date(monday.getTime() + (6 * millisecond));
+        // 上周日
+        lastSunday = new Date(monday.getTime() - millisecond);
+        // 上周一
+        lastMonday = new Date(lastSunday.getTime() - (millisecond * 6));
+        // 下周一
+        nextMonday = new Date(sunday.getTime() + millisecond);
+        // 下周日
+        nextSunday = new Date(nextMonday.getTime() + (millisecond * 6));
+        currentYear = now.getFullYear();
+        previousYear = currentYear - 1;
+        nextYear = currentYear + 1;
+        // 当前月份
+        currentMonth = now.getMonth();
+        // 计数年、月
+        year = now.getFullYear();
+        month = now.getMonth();
+        // 本月第一天
+        firstDay = new Date(currentYear, currentMonth, 1);
+    	// 当为12月的时候年份需要加1
+    	// 月份需要更新为0 也就是下一年的第一个月
+        if (currentMonth === 11) {
+            year++;
+            month++;
+        } else {
+            month++;
+        }
+        nextMonthFirstDay = new Date(year, month, 1);
+        nextMonthFinalDay = new Date(year, month, getMonthDays(year, month));
+        lastDay = new Date(nextMonthFirstDay.getTime() - millisecond);
+        lastMonthFirstDay = getLastMonthFirstDay(currentYear, currentMonth);
+        lastMonthFinalDay = new Date(firstDay.getTime() - millisecond);
+        thisQuarterStartDay = new Date(currentYear, getQuarterStartMonth(currentMonth), 1);
+        thisQuarterEndDay = new Date(currentYear, getQuarterStartMonth(currentMonth) + 2, getMonthDays(currentYear, getQuarterStartMonth(currentMonth) + 2));
+        lastQuarterStartDay = getLastQuarterFirstDay(currentYear, currentMonth);
+        lastQuarterEndDay = new Date(lastQuarterStartDay.getFullYear(), lastQuarterStartDay.getMonth() + 2, getMonthDays(lastQuarterStartDay.getFullYear(), lastQuarterStartDay.getMonth() + 2));
+        nextQuarterStartDay = getNextQuarterFirstDay(currentYear, currentMonth);
+        nextQuarterEndDay = new Date(nextQuarterStartDay.getFullYear(), nextQuarterStartDay.getMonth() + 2, getMonthDays(nextQuarterStartDay.getFullYear(), nextQuarterStartDay.getMonth() + 2));
+        last_7_days = new Date(now.getTime() - (6 * millisecond));
+        last_30_days = new Date(now.getTime() - (29 * millisecond));
+        last_60_days = new Date(now.getTime() - (59 * millisecond));
+        last_90_days = new Date(now.getTime() - (89 * millisecond));
+        last_120_days = new Date(now.getTime() - (119 * millisecond));
+        next_7_days = new Date(now.getTime() + (6 * millisecond));
+        next_30_days = new Date(now.getTime() + (29 * millisecond));
+        next_60_days = new Date(now.getTime() + (59 * millisecond));
+        next_90_days = new Date(now.getTime() + (89 * millisecond));
+        next_120_days = new Date(now.getTime() + (119 * millisecond));
+        switch (key) {
+            case "last_year":
+                // 去年
+                label = t("creator_filter_operation_between_last_year");
+                startValue = new Date(previousYear + "-01-01T00:00:00Z");
+                endValue = new Date(previousYear + "-12-31T23:59:59Z");
+                break;
+            case "this_year":
+                // 今年
+                label = t("creator_filter_operation_between_this_year");
+                startValue = new Date(currentYear + "-01-01T00:00:00Z");
+                endValue = new Date(currentYear + "-12-31T23:59:59Z");
+                break;
+            case "next_year":
+                // 明年
+                label = t("creator_filter_operation_between_next_year");
+                startValue = new Date(nextYear + "-01-01T00:00:00Z");
+                endValue = new Date(nextYear + "-12-31T23:59:59Z");
+                break;
+            case "last_quarter":
+                // 上季度
+                strFirstDay = moment__default["default"](lastQuarterStartDay).format("YYYY-MM-DD");
+                strLastDay = moment__default["default"](lastQuarterEndDay).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_last_quarter");
+                startValue = new Date(strFirstDay + "T00:00:00Z");
+                endValue = new Date(strLastDay + "T23:59:59Z");
+                break;
+            case "this_quarter":
+                // 本季度
+                strFirstDay = moment__default["default"](thisQuarterStartDay).format("YYYY-MM-DD");
+                strLastDay = moment__default["default"](thisQuarterEndDay).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_this_quarter");
+                startValue = new Date(strFirstDay + "T00:00:00Z");
+                endValue = new Date(strLastDay + "T23:59:59Z");
+                break;
+            case "next_quarter":
+                // 下季度
+                strFirstDay = moment__default["default"](nextQuarterStartDay).format("YYYY-MM-DD");
+                strLastDay = moment__default["default"](nextQuarterEndDay).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_next_quarter");
+                startValue = new Date(strFirstDay + "T00:00:00Z");
+                endValue = new Date(strLastDay + "T23:59:59Z");
+                break;
+            case "last_month":
+                // 上月
+                strFirstDay = moment__default["default"](lastMonthFirstDay).format("YYYY-MM-DD");
+                strLastDay = moment__default["default"](lastMonthFinalDay).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_last_month");
+                startValue = new Date(strFirstDay + "T00:00:00Z");
+                endValue = new Date(strLastDay + "T23:59:59Z");
+                break;
+            case "this_month":
+                // 本月
+                strFirstDay = moment__default["default"](firstDay).format("YYYY-MM-DD");
+                strLastDay = moment__default["default"](lastDay).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_this_month");
+                startValue = new Date(strFirstDay + "T00:00:00Z");
+                endValue = new Date(strLastDay + "T23:59:59Z");
+                break;
+            case "next_month":
+                // 下月
+                strFirstDay = moment__default["default"](nextMonthFirstDay).format("YYYY-MM-DD");
+                strLastDay = moment__default["default"](nextMonthFinalDay).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_next_month");
+                startValue = new Date(strFirstDay + "T00:00:00Z");
+                endValue = new Date(strLastDay + "T23:59:59Z");
+                break;
+            case "last_week":
+                // 上周
+                strMonday = moment__default["default"](lastMonday).format("YYYY-MM-DD");
+                strSunday = moment__default["default"](lastSunday).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_last_week");
+                startValue = new Date(strMonday + "T00:00:00Z");
+                endValue = new Date(strSunday + "T23:59:59Z");
+                break;
+            case "this_week":
+                // 本周
+                strMonday = moment__default["default"](monday).format("YYYY-MM-DD");
+                strSunday = moment__default["default"](sunday).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_this_week");
+                startValue = new Date(strMonday + "T00:00:00Z");
+                endValue = new Date(strSunday + "T23:59:59Z");
+                break;
+            case "next_week":
+                // 下周
+                strMonday = moment__default["default"](nextMonday).format("YYYY-MM-DD");
+                strSunday = moment__default["default"](nextSunday).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_next_week");
+                startValue = new Date(strMonday + "T00:00:00Z");
+                endValue = new Date(strSunday + "T23:59:59Z");
+                break;
+            case "yestday":
+                // 昨天
+                strYestday = moment__default["default"](yestday).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_yestday");
+                startValue = new Date(strYestday + "T00:00:00Z");
+                endValue = new Date(strYestday + "T23:59:59Z");
+                break;
+            case "today":
+                // 今天
+                strToday = moment__default["default"](now).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_today");
+                startValue = new Date(strToday + "T00:00:00Z");
+                endValue = new Date(strToday + "T23:59:59Z");
+                break;
+            case "tomorrow":
+                // 明天
+                strTomorrow = moment__default["default"](tomorrow).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_tomorrow");
+                startValue = new Date(strTomorrow + "T00:00:00Z");
+                endValue = new Date(strTomorrow + "T23:59:59Z");
+                break;
+            case "last_7_days":
+                // 过去7天
+                strStartDay = moment__default["default"](last_7_days).format("YYYY-MM-DD");
+                strEndDay = moment__default["default"](now).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_last_7_days");
+                startValue = new Date(strStartDay + "T00:00:00Z");
+                endValue = new Date(strEndDay + "T23:59:59Z");
+                break;
+            case "last_30_days":
+                // 过去30天
+                strStartDay = moment__default["default"](last_30_days).format("YYYY-MM-DD");
+                strEndDay = moment__default["default"](now).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_last_30_days");
+                startValue = new Date(strStartDay + "T00:00:00Z");
+                endValue = new Date(strEndDay + "T23:59:59Z");
+                break;
+            case "last_60_days":
+                // 过去60天
+                strStartDay = moment__default["default"](last_60_days).format("YYYY-MM-DD");
+                strEndDay = moment__default["default"](now).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_last_60_days");
+                startValue = new Date(strStartDay + "T00:00:00Z");
+                endValue = new Date(strEndDay + "T23:59:59Z");
+                break;
+            case "last_90_days":
+                // 过去90天
+                strStartDay = moment__default["default"](last_90_days).format("YYYY-MM-DD");
+                strEndDay = moment__default["default"](now).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_last_90_days");
+                startValue = new Date(strStartDay + "T00:00:00Z");
+                endValue = new Date(strEndDay + "T23:59:59Z");
+                break;
+            case "last_120_days":
+                // 过去120天
+                strStartDay = moment__default["default"](last_120_days).format("YYYY-MM-DD");
+                strEndDay = moment__default["default"](now).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_last_120_days");
+                startValue = new Date(strStartDay + "T00:00:00Z");
+                endValue = new Date(strEndDay + "T23:59:59Z");
+                break;
+            case "next_7_days":
+                // 未来7天
+                strStartDay = moment__default["default"](now).format("YYYY-MM-DD");
+                strEndDay = moment__default["default"](next_7_days).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_next_7_days");
+                startValue = new Date(strStartDay + "T00:00:00Z");
+                endValue = new Date(strEndDay + "T23:59:59Z");
+                break;
+            case "next_30_days":
+                // 未来30天
+                strStartDay = moment__default["default"](now).format("YYYY-MM-DD");
+                strEndDay = moment__default["default"](next_30_days).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_next_30_days");
+                startValue = new Date(strStartDay + "T00:00:00Z");
+                endValue = new Date(strEndDay + "T23:59:59Z");
+                break;
+            case "next_60_days":
+                // 未来60天
+                strStartDay = moment__default["default"](now).format("YYYY-MM-DD");
+                strEndDay = moment__default["default"](next_60_days).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_next_60_days");
+                startValue = new Date(strStartDay + "T00:00:00Z");
+                endValue = new Date(strEndDay + "T23:59:59Z");
+                break;
+            case "next_90_days":
+                // 未来90天
+                strStartDay = moment__default["default"](now).format("YYYY-MM-DD");
+                strEndDay = moment__default["default"](next_90_days).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_next_90_days");
+                startValue = new Date(strStartDay + "T00:00:00Z");
+                endValue = new Date(strEndDay + "T23:59:59Z");
+                break;
+            case "next_120_days":
+                // 未来120天
+                strStartDay = moment__default["default"](now).format("YYYY-MM-DD");
+                strEndDay = moment__default["default"](next_120_days).format("YYYY-MM-DD");
+                label = t("creator_filter_operation_between_next_120_days");
+                startValue = new Date(strStartDay + "T00:00:00Z");
+                endValue = new Date(strEndDay + "T23:59:59Z");
+        }
+        values = [startValue, endValue];
+        // 时间类型字段，应该考虑偏移时区值，否则过滤数据存在偏差
+        // 日期类型字段，数据库本来就存的是UTC的0点；
+        // 日期类型字段，目前creator代码（2019年08月07号存的）存的是UTC的16点，见：https://github.com/steedos/creator/issues/1271；
+        // 比如用户想搜索2019-08-07的数据，请求会是：((created ge 2019-08-06T16:00:00Z) and (created le 2019-08-07T15:59:59Z)) ，
+        // 如果数据库中存储的是2019-08-07T16:00:00Z而不是2019-08-07T00:00:00Z，那么就搜索不到数据。
+        // 所以，日期类型字段，要求存储的是UTC的0点，而不可以是16点，否则可能搜索不到数据。
+        if (utcOffset) {
+            values = values.map(function (fv) {
+                if (fv) {
+                    // 注意这里取的值是moment().utcOffset() / 60得到的，不是new Date().getTimezoneOffset() / 60
+                    // 它们的值正好为正负关系，北京时间前者为 +8，后者为 -8
+                    fv = new Date(fv.getTime());// clone fv的值以防止原来的值被更改
+                    fv.setHours(fv.getHours() - utcOffset);
+                }
+                return fv;
+            });
+        }
+        return {
+            label: label,
+            key: key,
+            values: values
+        };
+    };
+
+    let getBetweenBuiltinValueItem = (key, utcOffset) => {
+        return getBetweenTimeBuiltinValueItem(key, utcOffset);
+    };
+
+    let isBetweenFilterOperation = (operation) => {
+        return operation === "between";
+    };
+
+    // "{userId}"或"{user.name}"格式
+    let checkFormula = (formula) => {
+        return typeof formula === "string" && /\{\w+(\.\w+)?\}/.test(formula);
+    };
+
+    // "{userId}"转换为"this['userId']","{user.name}"转换为"this['user'].['name']"
+    let prepareFormula = (formula, prefix = "this") => {
+        var reg, rev;
+        reg = /(\{[^{}]*\})/g;
+        rev = formula.replace(reg, function (m, $1) {
+            return prefix + $1.replace(/\{\s*/, "[\"").replace(/\s*\}/, "\"]").replace(/\s*\.\s*/g, "\"][\"");
+        });
+        return rev;
+    };
+
+    let evaluateFormula = (formula, context) => {
+        if (checkFormula(formula)) {
+            formula = prepareFormula(formula);
+            return function () {
+                return eval(formula);
+            }.call(context);
+        }
+        else {
+            return formula;
+        }
+    };
+
+    const _evaluateFormula = evaluateFormula;
+
+    // 正则包括encodeURIComponent函数编码的11个特殊符号;/?:@&=+$,#
+    // 还包括convertSpecialCharacter函数中转义的特殊符号^$()*+?.\|[]{}
+    // 注意encodeURIComponent("\\(")的结果是%5C(，需要特别处理
+    // 注意encodeURIComponent("\\.")的结果是%5C.，需要特别处理
+    // 注意encodeURIComponent("\\*")的结果是%5C*，因为不需要encodeURIComponent函数编码，所以不用加入REG_FOR_ENCORD变量
+    const REG_FOR_ENCORD = /\;|\/|\?|\:|\@|\&|\=|\+|\$|\,|\#|\^|(\\\()|(\\\))|(\\\.)|\\|\||\[|\]|\{|\}/;
+
+    /**
+        ^$()*+?.\|[]{}等特殊符号需要转义，否则有可能会报错且无法正确识别
+        encodeURIComponent函数并不能完全编码上述所有特殊符号
+        这里保持跟版本1.23一样的处理逻辑，只是额外判断了下避免重复转义或重复执行encodeURIComponent编码的可能
+     */
+    const convertSpecialCharacter = (str) => {
+        // if(str.indexOf("\\") > -1){
+        //     // 如果有转义符号就按已经执行过转义处理，否则重复转义会有问题
+        //     return str;
+        // }
+        // encodeURIComponent("\\(")的结果是%5C(,进一步转义的话会变成%5C\(，里面包括了符号\，会通过上面的正则REG_FOR_ENCORD，
+        // 从而造成重复执行encodeURIComponent，所以这个不可以进一步转义，否则会搜索不到正确结果
+        // 类似的有符号.*
+        if(str.indexOf("%5C(") > -1 || str.indexOf("%5C)") > -1){
+            return str;
+        }
+        if(str.indexOf("%5C.") > -1){
+            return str;
+        }
+        if(str.indexOf("%5C*") > -1){
+            return str;
+        }
+    	return str.replace(/([\^\$\(\)\*\+\?\.\\\|\[\]\{\}])/g, "\\$1");
+    };
+
+    let extendUserContext = (userContext, utcOffset) => {
+        if (!userContext.now) {
+            userContext.now = new Date();
+        }
+        return userContext;
+    };
+
+    let formatFiltersToDev = (filters, userContext = { userId: null, spaceId: null, user: { utcOffset: 0 } }) => {
+        if(lodash.isNull(filters) || lodash.isUndefined(filters)){
+            return;
+        }
+        let utcOffset = userContext.user ? userContext.user.utcOffset : 0;
+        userContext = extendUserContext(userContext);
+        // 2019-03-23T01:00:33.524Z、2019-03-23T01:00:33Z、2022-06-11T00:00:00.444+08:00这种格式
+        var regDate = /^\d{4}-\d{1,2}-\d{1,2}(T|\s)\d{1,2}\:\d{1,2}(\:\d{1,2}(\.\d{1,3})?)?(Z|((\+|\-)\d{1,2}\:\d{1,2}))?$/;
+        var filtersLooper, selector;
+        if (!lodash.isFunction(filters) && !filters.length) {
+            return;
+        }
+        selector = [];
+        filtersLooper = function (filters_loop) {
+            var builtinValue, field, i, isBetweenOperation, option, ref, sub_selector, tempFilters, tempLooperResult, value;
+            tempFilters = [];
+            tempLooperResult = null;
+            if (filters_loop === "!") {
+                return filters_loop;
+            }
+            if (lodash.isFunction(filters_loop)) {
+                filters_loop = filters_loop();
+            }
+            if (!lodash.isArray(filters_loop)) {
+                if (lodash.isObject(filters_loop)) {
+                    // 当filters不是[Array]类型而是[Object]类型时，进行格式转换
+                    if (filters_loop.operation) {
+                        filters_loop = [filters_loop.field, filters_loop.operation, filters_loop.value];
+                    } else {
+                        return null;
+                    }
+                } else {
+                    return null;
+                }
+            }
+            if (filters_loop.length === 1) {
+                // 只有一个元素，进一步解析其内容
+                tempLooperResult = filtersLooper(filters_loop[0]);
+                if (tempLooperResult) {
+                    tempFilters.push(tempLooperResult);
+                }
+            } else if (filters_loop.length === 2) {
+                // 只有两个元素，进一步解析其内容，省略"and"连接符，但是有"and"效果
+                filters_loop.forEach(function (n, i) {
+                    tempLooperResult = filtersLooper(n);
+                    if (tempLooperResult) {
+                        return tempFilters.push(tempLooperResult);
+                    }
+                });
+            } else if (filters_loop.length === 3) {
+                // 只有三个元素，可能中间是"or","and"连接符也可能是普通数组，区别对待解析
+                if (lodash.includes(["or", "and"], filters_loop[1])) {
+                    // 中间有"or","and"连接符，则循环filters_loop，依次用filtersLooper解析其过虑条件
+                    // 最后生成的结果格式：tempFilters = [filtersLooper(filters_loop[0]), filters_loop[1], filtersLooper(filters_loop[2]), ...]
+                    // 因要判断filtersLooper(filters_loop[0])及filtersLooper(filters_loop[2])是否为空
+                    // 所以不能直接写：tempFilters = [filtersLooper(filters_loop[0]), filters_loop[1], filtersLooper(filters_loop[2])]
+                    tempFilters = [];
+                    i = 0;
+                    while (i < filters_loop.length) {
+                        if (lodash.includes(["or", "and"], filters_loop[i])) {
+                            i++;
+                            continue;
+                        }
+                        tempLooperResult = filtersLooper(filters_loop[i]);
+                        if (!tempLooperResult) {
+                            i++;
+                            continue;
+                        }
+                        if (i > 0) {
+                            tempFilters.push(filters_loop[i - 1]);
+                        }
+                        tempFilters.push(tempLooperResult);
+                        i++;
+                    }
+                    if (lodash.includes(["or", "and"], tempFilters[0])) {
+                        tempFilters.shift();
+                    }
+                } else {
+                    if (lodash.isString(filters_loop[1])) {
+                        // 第二个元素为字符串，则认为是某一个具体的过虑条件
+                        field = filters_loop[0];
+                        option = filters_loop[1];
+                        value = filters_loop[2];
+                        if (lodash.isFunction(value)) {
+                            value = value();
+                        }
+                        if (option === "!=") {
+                            // 支持!=为不等于操作
+                            option = "<>";
+                        }
+                        value = _evaluateFormula(value, userContext);
+                        sub_selector = [];
+                        isBetweenOperation = isBetweenFilterOperation(option);
+                        if (isBetweenOperation && lodash.isString(value)) {
+                            // 如果是between运算符内置值，则取出对应values作为过滤值
+                            // 比如value为last_year，返回对应的时间值
+                            builtinValue = getBetweenBuiltinValueItem(value, utcOffset);
+                            if (builtinValue) {
+                                value = builtinValue.values;
+                            }
+                        }
+                        if (lodash.isArray(value)) {
+                            value = value.map(function (item) {
+                                if (typeof item === "string") {
+                                    if(["contains", "startswith", "endswith", "notcontains", "notstartswith", "notendswith"].indexOf(option) > -1){
+                                        item = convertSpecialCharacter(item);
+                                    }
+                                    if(regDate.test(item)){
+                                        // 如果item正好是regDate格式，则转换为Date类型
+                                        item = new Date(item);
+                                    }
+                                    else if(REG_FOR_ENCORD.test(item)){
+                                        item = encodeURIComponent(item);
+                                    }
+                                }
+                                return item;
+                            });
+                            if (["=", "in"].indexOf(option) > -1) {
+                                if(value.length){
+                                    sub_selector.push([field, "in", `(${JSON.stringify(value).replace(/\"/g, "'").slice(1).slice(0, -1)})`], "and");
+                                    // _.each(value, function (v) {
+                                    //     return sub_selector.push([field, "=", v], "or");
+                                    // });
+                                }
+                                else {
+                                    // 空数组返回空值
+                                    sub_selector.push([field, "=", "__badQueryForEmptyArray"], "and");
+                                }
+                            } else if (["<>", "notin"].indexOf(option) > -1) {
+                                sub_selector.push([field, "notin", `(${JSON.stringify(value).replace(/\"/g, "'").slice(1).slice(0, -1)})`], "and");
+                                // _.each(value, function (v) {
+                                //     return sub_selector.push([field, "<>", v], "and");
+                                // });
+                            } else if (["notcontains", "notstartswith", "notendswith"].indexOf(option) > -1) {
+                                lodash.each(value, function (v) {
+                                    return sub_selector.push([field, option, v], "and");
+                                });
+                            } else if (isBetweenOperation) {
+                                if(value.length > 0){
+                                    if ([null, undefined, ''].indexOf(value[0]) < 0 || [null, undefined, ''].indexOf(value[1]) < 0) {
+                                        if ([null, undefined, ''].indexOf(value[0]) < 0) {
+                                            sub_selector.push([field, ">=", value[0]], "and");
+                                        }
+                                        if ([null, undefined, ''].indexOf(value[1]) < 0) {
+                                            sub_selector.push([field, "<=", value[1]], "and");
+                                        }
+                                    }
+                                }
+                            } else {
+                                // contains、startswith、endswith等，如果value为空数组，不加任何条件，即查找所有数据
+                                lodash.each(value, function (v) {
+                                    return sub_selector.push([field, option, v], "or");
+                                });
+                            }
+                            if (sub_selector[sub_selector.length - 1] === "and" || sub_selector[sub_selector.length - 1] === "or") {
+                                sub_selector.pop();
+                            }
+                            if (sub_selector.length) {
+                                tempFilters = sub_selector;
+                            }
+                        } else if(value === false) {
+                            // boolean类型字段优化，选择否时，应该兼容undefined值的情况
+                            // 主要是为了落地版本，目前我们有的项目yml中一些字段是项目交付上线后再加的，
+                            // 就造成按false搜索时搜索不到老数据（因为老数据中该字段值为空）
+                            if(option === "="){
+                                tempFilters = [[field, "=", false], "or", [field, "=", null]];
+                            }
+                            else if(option === "<>"){
+                                tempFilters = [field, "=", true];
+                            }
+                        } else {
+                            if (isBetweenOperation && !lodash.isArray(value)) ;
+                            else {
+                                if (typeof value === "string") {
+                                    if(["contains", "startswith", "endswith", "notcontains", "notstartswith", "notendswith"].indexOf(option) > -1){
+                                        value = convertSpecialCharacter(value);
+                                    }
+                                    if(regDate.test(value)){
+                                        // 如果value正好是regDate格式，则转换为Date类型
+                                        value = new Date(value);
+                                    }
+                                    else if(REG_FOR_ENCORD.test(value)){
+                                        value = encodeURIComponent(value);
+                                    }
+                                }
+                                tempFilters = [field, option, value];
+                            }
+                        }
+                    } else {
+                        // 普通数组，当成完整过虑条件进一步循环解析每个条件
+                        filters_loop.forEach(function (n, i) {
+                            tempLooperResult = filtersLooper(n);
+                            if (tempLooperResult) {
+                                return tempFilters.push(tempLooperResult);
+                            }
+                        });
+                    }
+                }
+            } else {
+                // 超过3个元素的数组，可能中间是"or","and"连接符也可能是普通数组，区别对待解析
+                if ((ref = lodash.intersection(["or", "and"], filters_loop)) != null ? ref.length : void 0) {
+                    // 中间有"or","and"连接符，则循环filters_loop，依次用filtersLooper解析其过虑条件
+                    // 最后生成的结果格式：tempFilters = [filtersLooper(filters_loop[0]), filters_loop[1], filtersLooper(filters_loop[2]), ...]
+                    // 因要判断filtersLooper(filters_loop[0])及filtersLooper(filters_loop[2])是否为空
+                    // 所以不能直接写：tempFilters = [filtersLooper(filters_loop[0]), filters_loop[1], filtersLooper(filters_loop[2])]
+                    tempFilters = [];
+                    i = 0;
+                    while (i < filters_loop.length) {
+                        if (lodash.includes(["or", "and"], filters_loop[i])) {
+                            i++;
+                            continue;
+                        }
+                        tempLooperResult = filtersLooper(filters_loop[i]);
+                        if (!tempLooperResult) {
+                            i++;
+                            continue;
+                        }
+                        if (i > 0) {
+                            tempFilters.push(filters_loop[i - 1]);
+                        }
+                        tempFilters.push(tempLooperResult);
+                        i++;
+                    }
+                    if (lodash.includes(["or", "and"], tempFilters[0])) {
+                        tempFilters.shift();
+                    }
+                } else {
+                    // 普通过虑条件，当成完整过虑条件进一步循环解析每个条件
+                    filters_loop.forEach(function (n, i) {
+                        tempLooperResult = filtersLooper(n);
+                        if (tempLooperResult) {
+                            return tempFilters.push(tempLooperResult);
+                        }
+                    });
+                }
+            }
+            if (tempFilters.length) {
+                return tempFilters;
+            } else {
+                return null;
+            }
+        };
+        selector = filtersLooper(filters);
+        return selector;
+    };
+
+    let formatFiltersToODataQuery = (filters, userContext, odataProtocolVersion, forceLowerCase) => {
+        let devFilters = formatFiltersToDev(filters, userContext);
+        return new SteedosFilter(devFilters, odataProtocolVersion, forceLowerCase).formatFiltersToODataQuery();
+    };
+
+    const _formatFiltersToDev = formatFiltersToDev;
+    const _formatFiltersToODataQuery = formatFiltersToODataQuery;
+
+    // 把"a.b.c"这种字符fieldName转换为{"a":{"b":{"c":{}}}}这种json
+    let expandFieldName = (initial, fieldName) => {
+        lodash.reduce(fieldName.split("."),function(m, k){
+            if(!m[k]){
+                m[k] = {};
+            }
+            return m[k]
+        }, initial);
+        return initial;
+    };
+
+
+    // 把["a.b.c","x.y","x.z","m"]这种字符fieldName转换为{"a":{"b":{"c":{}}},"x":{"y":{},"z":{}},"m":{}}这种json对象格式
+    let expandFieldNames = (fieldNames) => {
+        let initial = {};
+        fieldNames.forEach((n) => {
+            expandFieldName(initial, n);
+        });
+        return initial;
+    };
+
+    let generateIndents = (count) =>{
+        return Array(count).fill("    ").join("");
+    };
+
+    /** 
+    把{"a":{"b":{"c":{}}}}这种json转换为字符格式：
+    {
+        a {
+            b {
+                c
+            }
+        }
+    }
+    */ 
+    let reduceGraphqlFieldsQuery = (fields, indentsCount) => {
+        if(!indentsCount){
+            indentsCount = 0;
+        }
+        let itemQuery;
+        return ` {
+${
+    lodash.map(fields, (fieldValue, fieldKey) => {
+        itemQuery = generateIndents(indentsCount) + generateIndents(1) + fieldKey;
+        if(lodash.isEmpty(fieldValue)){
+            itemQuery += "\n";
+        }
+        else {
+            indentsCount += 1;
+            itemQuery += reduceGraphqlFieldsQuery(fieldValue, indentsCount);
+            indentsCount -= 1;
+        }
+        return itemQuery;
+    }).join("")
+}${generateIndents(indentsCount)}}
+`;
+    };
+
+    let formatFieldsToGraphqlQuery = (fields) => {
+        if(lodash.isString(fields)){
+            fields = fields.split(",");
+        }
+        let expandedFields = expandFieldNames(fields);
+        return reduceGraphqlFieldsQuery(expandedFields, 3);
+    };
+
+    /**
+     * 
+     * 
+     * 把filters和fields转换为如下格式的graphql请求串
+      query {
+        contracts(filters:[
+          [
+            "create_date",
+            "between",
+            "this_year"
+          ]
+      ]) {
+          name
+          amount
+          contract_type {
+            name
+          }
+        }
+      }
+     * @param {*} filters ,请求的过滤条件
+     * @param {*} fields ,请求的字段，支持["a.b.c","m","n"]或"a.b.c,m,n"这种语法
+     */
+    let formatFiltersToGraphqlQuery = (objectName, filters, fields, userContext, odataProtocolVersion, forceLowerCase) => {
+        if(!lodash.isString(filters)){
+            filters = _formatFiltersToODataQuery(filters, userContext, odataProtocolVersion, forceLowerCase);
+        }
+        let filtersWrap  = filters ? `(filters:"${filters}")` : "";
+        let graphqlFields = formatFieldsToGraphqlQuery(fields);
+        let graphqlQuery = `
+        query {
+            ${objectName}${filtersWrap}${graphqlFields}
+        }
+    `;
+        return graphqlQuery;
+    };
+
+    const _formatFiltersToGraphqlQuery = formatFiltersToGraphqlQuery;
+
+    exports.SteedosFilter = filter;
+    exports.evaluateFormula = _evaluateFormula;
+    exports.formatFiltersToDev = _formatFiltersToDev;
+    exports.formatFiltersToGraphqlQuery = _formatFiltersToGraphqlQuery;
+    exports.formatFiltersToODataQuery = _formatFiltersToODataQuery;
+    exports.getBetweenBuiltinValueItem = getBetweenBuiltinValueItem;
+    exports.getBetweenTimeBuiltinValueItem = getBetweenTimeBuiltinValueItem;
+    exports.getLastMonthFirstDay = getLastMonthFirstDay;
+    exports.getLastQuarterFirstDay = getLastQuarterFirstDay;
+    exports.getMonthDays = getMonthDays;
+    exports.getNextQuarterFirstDay = getNextQuarterFirstDay;
+    exports.getQuarterStartMonth = getQuarterStartMonth;
+    exports.isBetweenFilterOperation = isBetweenFilterOperation;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));