WI/Web.Admin.V1.0.git

/**
 * 获取距离date的dayCount天数( 年月日)
 * @param {*} dayCount 距离date的天数
 * @param {*} date 日期
 * @returns 返回 yyyy-MM-dd
 */
export function getDay(dayCount, date) {
    var today = date ? new Date(date) : new Date();
    var targetday_milliseconds = today.getTime() + 1000 * 60 * 60 * 24 * dayCount;
    today.setTime(targetday_milliseconds); //注意，这行是关键代码
    var tYear = today.getFullYear();
    var tMonth = today.getMonth();
    var tDate = today.getDate();
    tMonth = doHandleMonth(tMonth + 1);
    tDate = doHandleMonth(tDate);
    return tYear + '-' + tMonth + '-' + tDate;
}
function doHandleMonth(month) {
    var m = month;
    if (month.toString().length == 1) {
        m = '0' + month;
    }
    return m;
}
 
// 格式化时间格式
/**
 * 格式化时间格式
 * @param {*} template  格式化模板
 * @param {*} date 格式化日期
 * @returns
 */
export function formatTime(template, date) {
    var today = date ? new Date(date) : new Date();
    var o = {
        'M+': today.getMonth() + 1, //月份
        'd+': today.getDate(), //日
        'h+': today.getHours(), //小时
        'm+': today.getMinutes(), //分
        's+': today.getSeconds(), //秒
        'q+': Math.floor((today.getMonth() + 3) / 3), //季度
        S: today.getMilliseconds(), //毫秒
    };
    var fmt = template;
    if (/(y+)/.test(fmt)) {
        fmt = fmt.replace(RegExp.$1, (today.getFullYear() + '').substr(4 - RegExp.$1.length));
    }
 
    for (var k in o) {
        if (new RegExp('(' + k + ')').test(fmt)) {
            fmt = fmt.replace(RegExp.$1, RegExp.$1.length == 1 ? o[k] : ('00' + o[k]).substr(('' + o[k]).length));
        }
    }
    return fmt;
}
 
/**
 * 数组去重
 * @param {*} arr  原始数组
 * @returns
 */
export function uniqueInArray(arr) {
    if (Array.hasOwnProperty('from')) {
        return Array.from(new Set(arr));
    } else {
        var n = {},
            r = [];
        for (var i = 0; i < arr.length; i++) {
            if (!n[arr[i]]) {
                n[arr[i]] = true;
                r.push(arr[i]);
            }
        }
        return r;
    }
}
 
/**
 * 计算echarts 的 max ，min ，interval
 * @param {*} max 最大值
 * @param {*} min 最小值
 * @param {*} splitNumber 分隔数
 * @returns '{ max: 0, min: 0, interval: 0 }'
 */
export function getChartMaxMinInterval(max, min, splitNumber) {
    function getMaxMinNumber(n, l) {
        var a1 = Math.floor(Math.log(n) / Math.LN10);
        var b;
        if (l) {
            a1 < 2
                ? (b =
                        n / Math.pow(10, a1) - parseInt(n / Math.pow(10, a1)) > 0.5
                            ? Math.round(n / Math.pow(10, a1)) * Math.pow(10, a1)
                            : (parseInt(n / Math.pow(10, a1)) + 0.5) * Math.pow(10, a1))
                : (b = Math.ceil(n / Math.pow(10, 1)) * Math.pow(10, 1));
        } else {
            a1 < 2
                ? (b =
                        n / Math.pow(10, a1) - parseInt(n / Math.pow(10, a1)) > 0.5
                            ? (parseInt(n / Math.pow(10, a1)) + 0.5) * Math.pow(10, a1)
                            : Math.floor(n / Math.pow(10, a1)) * Math.pow(10, a1))
                : (b = Math.floor(n / Math.pow(10, 1)) * Math.pow(10, 1));
        }
        return l ? (-20 <= a1 ? +b.toFixed(a1 < 0 ? -a1 + 1 : 0) : b) : b;
    }
    var interval = 0;
    if ((max - min) % splitNumber != 0) {
        interval = getMaxMinNumber((max - min) / splitNumber, 1);
        max = parseFloat((parseFloat((interval * splitNumber).toFixed(12)) + min).toFixed(12)); //解决小数精度一般问题，极端问题并不能解决。
        min = min;
    } else {
        interval = (max - min) / splitNumber;
        min = min;
        max = max;
    }
    return { max: max, min: min, interval: interval };
}
 
/**
 * 保留几位小数
 * @param {*} val  要保留小数的值
 * @param {*} n 保留的小数位数
 * @returns
 */
export function getToFixed(val, n) {
    let temp = parseFloat(val);
    n = n ? n : 0;
    if (typeof temp == NaN) {
        console.warn('传入的为非数字类型');
        return NaN;
    }
    temp = parseFloat(temp.toFixed(n));
    return temp;
}
 
/**
 * 根据扬程算流量
 * @param {*} curve 贝塞尔曲线
 * @param {*} y 扬程
 * @returns '{x: 0,y: 0,}'
 */
export function getSectPointFlowbyH(curve, y) {
    if (curve == null) return null;
    var iPtCount = curve.length;
    if (y > curve[0].Point0.Y) {
        return null;
    }
    if (y < curve[iPtCount - 1].Point3.Y) {
        return null;
    }
 
    for (var i = 0; i < iPtCount; i++) {
        if (y > curve[i].Point3.Y && y < curve[i].Point0.Y) {
            var ptBizer = curve[i];
            //
            try {
                var minDis = Math.abs(ptBizer.Point3.Y - ptBizer.Point0.Y);
                var sectY = 0;
                var sectX = 0;
                //console.log(minDis)
                for (var uu = 0; uu <= 1; uu = uu + 0.01) {
                    var y0 = ptBizer.Point0.Y * uu * uu * uu;
                    var y1 = 3 * ptBizer.Point1.Y * uu * uu * (1 - uu);
                    var y2 = 3 * ptBizer.Point2.Y * uu * (1 - uu) * (1 - uu);
                    var y3 = ptBizer.Point3.Y * (1 - uu) * (1 - uu) * (1 - uu);
 
                    var curveY = y0 + y1 + y2 + y3;
                    //console.log(curveY)
                    if (Math.abs(curveY - y) < minDis) {
                        var y0 = ptBizer.Point0.Y * uu * uu * uu;
                        var y1 = 3 * ptBizer.Point1.Y * uu * uu * (1 - uu);
                        var y2 = 3 * ptBizer.Point2.Y * uu * (1 - uu) * (1 - uu);
                        var y3 = ptBizer.Point3.Y * (1 - uu) * (1 - uu) * (1 - uu);
 
                        var x0 = ptBizer.Point0.X * uu * uu * uu;
                        var x1 = 3 * ptBizer.Point1.X * uu * uu * (1 - uu);
                        var x2 = 3 * ptBizer.Point2.X * uu * (1 - uu) * (1 - uu);
                        var x3 = ptBizer.Point3.X * (1 - uu) * (1 - uu) * (1 - uu);
 
                        minDis = Math.abs(curveY - y);
                        sectX = x0 + x1 + x2 + x3;
                        sectY = curveY;
                    }
                }
                return {
                    x: sectX,
                    y: sectY,
                };
            } catch (ex) {
                alert(ex.message);
            }
        }
    }
}
 
/**
 * 根据流量算扬程
 * @param {*} curve 贝塞尔曲线
 * @param {*} x 流量
 * @returns '{x: 0,y: 0,}'
 */
export function getSectPointHbyFlow(curve, x) {
    if (curve == null) return null;
    var iPtCount = curve.length;
    if (x < curve[0].Point0.X) {
        return null;
    }
    if (x > curve[iPtCount - 1].Point3.X) {
        return null;
    }
 
    for (var i = 0; i < iPtCount; i++) {
        if (x > curve[i].Point0.X && x < curve[i].Point3.X) {
            var ptBizer = curve[i];
            //
            try {
                //alert(i);
                var minDis = Math.abs(ptBizer.Point3.X - ptBizer.Point0.X);
                //alert(x + "   " + curve[i].Point0.X + "    " + curve[i].Point3.X);
                var sectY = 0;
                var sectX = 0;
                for (var uu = 0; uu <= 1; uu = uu + 0.01) {
                    var x0 = ptBizer.Point0.X * uu * uu * uu;
                    var x1 = 3 * ptBizer.Point1.X * uu * uu * (1 - uu);
                    var x2 = 3 * ptBizer.Point2.X * uu * (1 - uu) * (1 - uu);
                    var x3 = ptBizer.Point3.X * (1 - uu) * (1 - uu) * (1 - uu);
 
                    var curveX = x0 + x1 + x2 + x3;
                    if (Math.abs(curveX - x) < minDis) {
                        var y0 = ptBizer.Point0.Y * uu * uu * uu;
                        var y1 = 3 * ptBizer.Point1.Y * uu * uu * (1 - uu);
                        var y2 = 3 * ptBizer.Point2.Y * uu * (1 - uu) * (1 - uu);
                        var y3 = ptBizer.Point3.Y * (1 - uu) * (1 - uu) * (1 - uu);
                        minDis = Math.abs(curveX - x);
                        sectY = y0 + y1 + y2 + y3;
                        sectX = curveX;
                    }
                }
                return {
                    x: sectX,
                    y: sectY,
                };
            } catch (ex) {
                alert(ex.message);
            }
        }
    }
}
 
/**
 * 转成Bezier曲线模型
 * @param {*} pixelPoints
 * @returns
 */
export function transBezierCurveModel(pixelPoints) {
    if (pixelPoints == null || pixelPoints.length < 4) return null;
    //console.log(pixelPoints);
    var iPointCout = pixelPoints.length;
    var a = 0.09;
    var b = 0.09;
    var controlPoint = [];
 
    for (var i = 0; i < iPointCout - 1; i++) {
        var bezier = {};
        bezier.Point0 = { X: pixelPoints[i][0], Y: pixelPoints[i][1] };
 
        if (i == 0) {
            var x1 = pixelPoints[i][0] + a * (pixelPoints[i + 1][0] - pixelPoints[i][0]);
            var y1 = pixelPoints[i][1] + a * (pixelPoints[i + 1][1] - pixelPoints[i][1]);
            bezier.Point1 = {
                X: x1,
                Y: y1,
            };
        } else {
            var x1 = pixelPoints[i][0] + a * (pixelPoints[i + 1][0] - pixelPoints[i - 1][0]);
            var y1 = pixelPoints[i][1] + a * (pixelPoints[i + 1][1] - pixelPoints[i - 1][1]);
            bezier.Point1 = {
                X: x1,
                Y: y1,
            };
        }
 
        if (i == iPointCout - 2) {
            var x2 = pixelPoints[i + 1][0] - b * (pixelPoints[i + 1][0] - pixelPoints[i][0]);
            var y2 = pixelPoints[i + 1][1] - b * (pixelPoints[i + 1][1] - pixelPoints[i][1]);
            bezier.Point2 = {
                X: x2,
                Y: y2,
            };
        } else {
            var x2 = pixelPoints[i + 1][0] - b * (pixelPoints[i + 2][0] - pixelPoints[i][0]);
            var y2 = pixelPoints[i + 1][1] - b * (pixelPoints[i + 2][1] - pixelPoints[i][1]);
            bezier.Point2 = {
                X: x2,
                Y: y2,
            };
        }
        bezier.Point3 = { X: pixelPoints[i + 1][0], Y: pixelPoints[i + 1][1] };
        //bezier.Point3 = pixelPoints[i + 1];
        controlPoint.push(bezier);
    }
    //console.log(controlPoint);
    return controlPoint;
}
 
/**
 * 格式化值，根据值的大小选择保留几位小数
 * @param {*} value
 * @returns
 */
export function numberFormat4RecordValue(value) {
    if (value == null || value == undefined) return 0;
    value = parseFloat(value);
    if (value > 100) return parseFloat(value.toFixed(1));
    else if (value > 10) return parseFloat(value.toFixed(2));
    else return parseFloat(value.toFixed(4));
}
export function numberFormat(value) {
    if (value == null || value == undefined) return 0;
    var v = value.toString();
    var result = v;
    var decimalIndex = v.indexOf('.');
    if (decimalIndex != -1) {
        result = v.substring(decimalIndex + 1, v.length);
        if (result.length > 5) {
            v = parseFloat(value).toFixed('5');
        }
        if (result.substr(result.length - 4, 4) == '0000') {
            v = parseFloat(value).toFixed(result.length - 4);
        } else if (result.substr(result.length - 3, 3) == '000') {
            v = parseFloat(value).toFixed(result.length - 3);
        } else if (result.substr(result.length - 2, 2) == '00') {
            v = parseFloat(value).toFixed(result.length - 2);
        } else if (result.substr(result.length - 1, 1) == '0') {
            v = parseFloat(value).toFixed(result.length - 1);
        }
    }
    return v;
}
/**
 * 数组求和
 * @param {Array} arr
 * @returns  sum
 */
export function sumInArray(arr) {
    return arr.reduce((pre, cur) => {
        return pre + cur;
    });
}
 
/**
 * 计算数组最大值
 * @param {*} arr
 * @returns max
 */
export function maxInArray(arr) {
    return Math.max.apply(null, arr);
}
 
/**
 * 计算数组 最小值
 * @param {*} arr
 * @returns min
 */
export function minInArray(arr) {
    return Math.min.apply(null, arr);
}
 
/**
 * 深拷贝
 * @param {*} data
 * @returns data
 */
export const deepCopy = (data) => {
    return JSON.parse(JSON.stringify(data));
};
 
/**
 * list数据转成 tree使用格式
 * @param {*} data  list结构数组  父子关系是ParentIds数组
 * @returns tree
 */
export const treeCorprationDataFormat = (data) => {
    if (!Array.isArray(data)) {
        return data;
    }
    let tree = [];
    const listToTree = (list, tree, parentId, length) => {
        list.forEach((org) => {
            org.value = org.ID;
            // 判断是否为父级菜单
            if (length == 0) {
                if (org.ParentIds.length == 0) {
                    let child = org;
                    child.Children = [];
                    // 迭代 list， 找到当前菜单相符合的所有子菜单
                    listToTree(list, child.Children, org.ID, org.ParentIds.length + 1);
                    // 删掉不存在 children 值的属性
                    if (child.Children.length <= 0) {
                        delete child.Children;
                    }
                    // 加入到树中
                    tree.push(child);
                }
            } else {
                if (org.ParentIds.length == length && org.ParentIds.indexOf(parentId) != -1) {
                    let child = org;
                    child.Children = [];
                    // 迭代 list， 找到当前菜单相符合的所有子菜单
                    listToTree(list, child.Children, org.ID, org.ParentIds.length + 1);
                    // 删掉不存在 children 值的属性
                    if (child.Children.length <= 0) {
                        delete child.Children;
                    }
                    // 加入到树中
                    tree.push(child);
                }
            }
        });
    };
    listToTree(data, tree, 0, 0);
    return tree;
};
 
/**
 * 在版本管理，用于将左侧故障树中的 item 项汇入 Children 中，
 * 方便树形数据展示
 */
export const formatTreeList = (responseTreeData) => {
    return responseTreeData.map((node) => {
        let formatItems = [];
        if (node.Items) {
            formatItems = node.Items.map((item) => {
                item.wysType = 'fault';
                item.isFaultTree = true;
                return item;
            });
        }
        // 如果有 Children 属性，确定不是故障
        if (node.Children) {
            node.Children = [...formatTreeList([...node.Children]), ...formatItems];
            // 无 Items 属性，确定一定是故障，而不是故障组
        } else if (!node.Items) {
            node.wysType = 'fault';
            node.isFaultTree = true;
        }
        return node;
    });
};
 
/**
 * list数据转成 treeTable使用格式 用于客户管理页面表格展示
 * @param {*} data  list结构数组  父子关系是ParentIds数组
 * @returns tree
 */
export const listFormatTreeTableCorpration = (data, pid, l) => {
    if (!Array.isArray(data)) {
        return data;
    }
    let tree = [];
    const listToTree = (list, tree, parentId, length) => {
        list.forEach((org) => {
            // 判断是否为父级菜单
            org.value = org.ID;
            if (org.ParentIds.length == length && org.ParentIds.indexOf(parentId) != -1) {
                let child = org;
                child.children = [];
                // 迭代 list， 找到当前菜单相符合的所有子菜单
                listToTree(list, child.children, org.ID, org.ParentIds.length + 1);
                // 删掉不存在 children 值的属性
                if (child.children.length <= 0) {
                    delete child.children;
                }
                // 加入到树中
                tree.push(child);
            }
        });
    };
 
    listToTree(data, tree, pid, l);
    return tree;
};
 
/**
 * list数据转成 tree使用格式 用于左侧树结构显示登录客户及子客户
 * @param {*} data  list结构数组  父子关系是ParentIds数组
 * @returns tree
 */
export const listFormatTreeCorpration = (data, pid, l) => {
    if (!Array.isArray(data)) {
        return data;
    }
    let tree = [];
    const listToTree = (list, tree, parentId, length) => {
        list.forEach((org) => {
            org.value = org.ID;
            // 判断是否为父级菜单
            if (org.ParentIds.length == length && org.ID == parentId) {
                let child = org;
                child.Children = [];
                // 迭代 list， 找到当前菜单相符合的所有子菜单
                listToTree(list, child.Children, org.ID, org.ParentIds.length + 1);
                // 删掉不存在 Children 值的属性
                if (child.Children.length <= 0) {
                    delete child.Children;
                }
                // 加入到树中
                tree.push(child);
            } else if (org.ParentIds.length == length && org.ParentIds.indexOf(parentId) != -1) {
                let child = org;
                child.Children = [];
                // 迭代 list， 找到当前菜单相符合的所有子菜单
                listToTree(list, child.Children, org.ID, org.ParentIds.length + 1);
                // 删掉不存在 Children 值的属性
                if (child.Children.length <= 0) {
                    delete child.Children;
                }
                // 加入到树中
                tree.push(child);
            }
        });
    };
 
    listToTree(data, tree, pid, l);
    return tree;
};
 
/**
 * 根据id获取树id  用于获取默认选中高亮
 * @param {*} list 原始数组
 * @param {*} ID  选中id
 * @returns obj 原始数组中item
 */
export const getTreeIdById = (list, ID) => {
    let obj = [];
    if (list.length === 0) {
        return obj;
    }
    const getDtreeId = (obj, list, ID) => {
        if (ID) {
            for (var i = 0; i < list.length; i++) {
                var item = list[i];
                if (!item.Children) {
                    item.Children = [];
                }
                if (item.ID == ID) {
                    obj.push(item);
                    // break;
                }
                if (item.Children.length != 0) {
                    getDtreeId(obj, item.Children, ID);
                }
            }
        } else {
            if (!list[0].Children) {
                list[0].Children = [];
            }
            if (list[0].Children.length == 0) {
                obj.push(list[0]);
            }
            if (list[0].Children.length != 0) {
                getDtreeId(obj, list[0].Children, ID);
            }
        }
    };
    getDtreeId(obj, list, ID);
    return obj;
};
 
export const formatTreeDataToElementPlusTreeSelect = (list, idstr, childrenstr) => {
    const addValue = (list, idstr, childrenstr) => {
        list.forEach((x) => {
            x.value = x[idstr];
            if (x[childrenstr] && x[childrenstr].length > 0) {
                addValue(x[childrenstr], idstr, childrenstr);
            }
        });
    };
    if (list && list.length > 0) {
        addValue(list, idstr, childrenstr);
    }
};
 
export const $ = (name) => document.querySelector(name);
 
export const getContainerSize = (dom) => ({ width: dom.getBoundingClientRect().width, height: dom.getBoundingClientRect().height });