workApp/common/common.js

export function pxToMm(value) {

    // var inch = value / getDPI()[0];
    let scale=1754/297;
    // var c_value = inch * 25.4;
    let result=value/scale;
    return parseFloat(result.toFixed(4));//保留四位小数

}

// /**
//  * 像素转换成毫米
//  * @param {number} px - 输入的像素值
//  * @returns {number} - 转换后的毫米值，保留四位小数
//  */
// export function pxToMm(px) {
//     if (px) {
//         const DPI = getDPI(); // 获取当前设备的 DPI
//         const MM_PER_INCH = 25.4; // 每英寸毫米数
//         const mmValue = (px * MM_PER_INCH) / DPI;
//         return parseFloat(mmValue.toFixed(4)); // 保留四位小数
//     } else {
//         console.log("px", px);
//         return 0;
//     }
// }

// 保留整数 小数 四舍五入
export function mmToPx(num) {
    if(num)
    {
        // console.log("num",num);
        // console.log("转换后",Math.round(1754/297*num));
        // let scale=1754/297;
        // let result=(scale*num).toFixed(4);
        // console.log("scale",scale,result);
        let scale=1754/297;
        return  parseFloat((scale*num).toFixed(4)); //高 150dpi 1754  96dpi:1120         1754*2480
        // return Math.round(1754/297*num)
    }
    else
    {
        console.log("num",num);
        return 0;
    }
}
//获取考试背景颜色值
export function getExamBackgroundColor(type){
    const examTypesColor = {
        "1": '#F56C6C',//期末
        "2": '#3ba272',//期中
        "3": '#ea7acb',//模拟
        "4": '#fac858',//月考
        "5": '#995fb3',//周测
        "6": '#72C0DD',//平时
    };
    const result = examTypesColor[type];
    return result;
}
// 获取分析报告成绩分析中默认的20个颜色
export function getScorePerformanceAnalysis() {
    return [
      "#5470C6",
      "#3BA272",
      "#EE6666",
      "#FAC858",
      "#995FB3",
      "#72C0DD",
      "#90CB75",
      "#EA7ACB",
      "#FC8451",
      "#65789B",
      "#178BD3",
      "#26A616",
      "#A6129E",
      "#D3A141",
      "#234098",
      "#047640",
      "#B43535",
      "#848BDC",
      "#D6AF83",
      "#84313D",
    ]
}
// 文本截断：超过指定长度显示省略号
export function truncateText(text, maxLength) {
    if (!text) return '';
    if (text.length > maxLength) {
        return text.substring(0, maxLength) + '...';
    }
    return text;
}

// 去掉小数点后面为0的 如果不为0 最多只保留2位小数
export function  getFormatNumber(numberStr) {
    // 尝试将字符串转为数字
    const num = parseFloat(numberStr);
      
    // 检查是否为NaN（非数字情况）
    if (isNaN(num)) {
        return numberStr;
    }
    
    // 检查是否为整数（小数点后全为0）
    if (num % 1 === 0) {
        return num.toString();
    }
    
    // 保留最多2位小数，并去除末尾的0
    let formatted = num.toFixed(2);
    
    // 如果小数点后都是0，则返回整数形式
    if (formatted.endsWith('.00')) {
        return formatted.split('.')[0];
    }
    
    // 去除末尾的0（如1.50 → 1.5）
    formatted = formatted.replace(/\.?0+$/, '');
    
    return formatted;
}
/**
 * 格式化时间，输出：xx月xx日 时:分，去除年份、秒
 * @param {string|number|null} time
 * @returns {string}
*/
export function formatToMonthDayHM(time) {
    if (time == null || time === '') {
        return ''
    }
    const str = String(time).trim().replace('T', ' ')
    const match = str.match(/^(\d{4})-(\d{2})-(\d{2})(?:\s+(\d{2}:\d{2}))?(?::\d{2})?/)
    if (!match) {
        return str
    }
    const month = match[2]
    const day = match[3]
    const hm = match[4]
    if (hm) {
        return `${month}-${day} ${hm}`
    }
    return `${month}-${day}`
}

/**
 * 去掉后端时间中的秒，页面只展示「年月日 时分」
 * 支持：2026-08-27 16:44:00、2026-08-27T16:44:59、2026-08-27
 */
export function formatTimeWithoutSeconds(time) {
    if (time == null || time === '') {
        return ''
    }
    const str = String(time).trim().replace('T', ' ')
    const match = str.match(/^(\d{4}-\d{2}-\d{2})(?:\s+(\d{2}:\d{2}))?(?::\d{2})?/)
    if (!match) {
        return str
    }
    if (match[2]) {
        return `${match[1]} ${match[2]}`
    }
    return match[1]
}

/**
 * 开始时间传给后端：补写死的 00 秒
 * 例：2026-08-27 16:44 → 2026-08-27 16:44:00
 */
export function toApiStartTime(time) {
    const base = formatTimeWithoutSeconds(time)
    if (!base) {
        return ''
    }
    if (/^\d{4}-\d{2}-\d{2}$/.test(base)) {
        return `${base} 00:00:00`
    }
    return `${base}:00`
}

/**
 * 结束时间传给后端：补写死的 59 秒
 * 例：2026-08-27 17:30 → 2026-08-27 17:30:59
 */
export function toApiEndTime(time) {
    const base = formatTimeWithoutSeconds(time)
    if (!base) {
        return ''
    }
    if (/^\d{4}-\d{2}-\d{2}$/.test(base)) {
        return `${base} 23:59:59`
    }
    return `${base}:59`
}
/**
 * 剩余时间：结束时间减去当前时间，精确到分钟。
 * 满一天显示「X天X小时X分」，不足一天显示「X小时X分」或「X分」。
 * 已过期返回 null。
 *
 * @param {string|Date} endTime - 结束时间
 * @returns {string|null}
 */
export function remainingDays(endTime) {
    if (!endTime) return null

    const end = new Date(typeof endTime === 'string' ? String(endTime).replace(/-/g, '/') : endTime)
    if (isNaN(end.getTime())) return null

    const diffMs = end.getTime() - Date.now()
    if (diffMs <= 0) return null

    const MS_PER_MINUTE = 60 * 1000
    const MS_PER_HOUR = 60 * MS_PER_MINUTE
    const MS_PER_DAY = 24 * MS_PER_HOUR

    const days = Math.floor(diffMs / MS_PER_DAY)
    const hours = Math.floor((diffMs % MS_PER_DAY) / MS_PER_HOUR)
    const minutes = Math.floor((diffMs % MS_PER_HOUR) / MS_PER_MINUTE)

    if (days > 0) {
        return `${days}天${hours}小时${minutes}分`
    }
    if (hours > 0) {
        return `${hours}小时${minutes}分`
    }
    if (minutes > 0) {
        return `${minutes}分`
    }
    return '不足1分'
}
//时间
export function unioformDateTransform(date, param = "time"){
    if(date){
        let strDate = new Date(date).toLocaleString('zh-CN')
        let days = strDate.split(" ")[0]
        let time = strDate.split(" ")[1]
        let year = days.split("/")[0]
        let month = days.split("/")[1]
        let day = days.split("/")[2]

        if(Number(month)<10){
            month = '0'+ month
        }
        if(Number(day)<10){
            day = '0'+day
        }
        days =  year+'-'+month+'-'+day

        switch(param){
            case "day":
                return days
            case "time":
                return days + " " + time
        }
    }else{
        return ''
    }
}
export const fileSizeConvert = (byte)=>{
    let kbSize = 0
    let mbSize = 0
    let gbSize = 0
    kbSize = (byte / 1024)
    if(kbSize > 1024){
        mbSize = kbSize / 1024
        if(mbSize > 1024){
            gbSize = mbSize / 1024
            return gbSize.toFixed(2) + 'GB'
        }else {
            return mbSize.toFixed(2) + 'MB'
        }
    }else{
        return kbSize.toFixed(2) + 'KB'
    }
}
// 计算文件大小方法，如果文件可以算出 MB，就返回 MB，否则返回 KB
export const getFileSize = (fileSize) => {
    if (!fileSize) return '0 KB'

    if (fileSize >= 1024 * 1024) {
        fileSize = Math.round(fileSize / (1024 * 1024))
        return `${fileSize} MB`
    } else {
        fileSize = Math.round(fileSize / 1024)
        return `${fileSize} KB`
    }
}
//部门及部门下的人
export const getDeptTreeData = (list) => {
    if (!list || list.length === 0) return []

    const arr = []

    list.forEach(one => {
        const { name, id, groupVOS } = one
        const objectOne = {
            label: name,
            id: id,
            children: []
        }
        arr.push(objectOne)

        if (groupVOS && groupVOS.length) {
            groupVOS.forEach(two => {
                const { groupId, groupName, groupUserVOS } = two
                const objectTwo = {
                    label: groupName,
                    id: groupId,
                    children: []
                }
                objectOne.children.push(objectTwo)

                if (groupUserVOS && groupUserVOS.length) {
                    groupUserVOS.forEach((three, threeIndex) => {
                        const { teacherName, teacherId, userAccount, canDel, selected } = three
                        objectTwo.children.push({
                            id: `${one.id}_${two.groupId}_${teacherId}_${threeIndex}`,
                            label: `${teacherName}(${userAccount})`,
                            targetType: 1,
                            targetName: teacherName,
                            targetId: teacherId,
                            studentCode: null,
                            roleCode: null,
                            roleName: null,
                            gradeCode: null,
                            gradeName: null,
                            subjectCode: null,
                            subjectName: null,
                            classIdCode: null,
                            className: null,
                            classType: null,
                            classTypeName: null,
                            departmentId: one.id,
                            departmentName: one.name,
                            departmentGroupId: two.groupId,
                            departmentGroupName: two.groupName,
                            disabled: !canDel,
                            selected,
							checked:selected==1?'checked':''
                        })
                    })
                }
            })
        }
    })

    return arr
}
export const subjectTreeData = (list) => {
    if (!list || list.length === 0) return []

    const arr = []

    list.forEach(one => {
        const { subjectName, subjectCode, gradePersonVos } = one
        const objectOne = {
            label: subjectName,
            id: subjectCode,
            children: []
        }
        arr.push(objectOne)

        if (gradePersonVos && gradePersonVos.length) {
            gradePersonVos.forEach(two => {
                const { gradeName, gradeCode, personVoList } = two
                const objectTwo = {
                    label: gradeName,
                    id: `${subjectCode}_${gradeCode}`,
                    children: []
                }
                objectOne.children.push(objectTwo)

                if (personVoList && personVoList.length) {
                    personVoList.forEach((three, threeIndex) => {
                        const {
                            showName,
                            teacherName,
                            teacherId,
                            userAccount,
                            roleCode,
                            roleName,
                            gradeCode,
                            gradeName,
                            classIdCode,
                            className,
                            canDel,
                            selected
                        } = three

                        objectTwo.children.push({
                            id: `${one.subjectCode}_${two.gradeCode}_${teacherId}_${threeIndex}`,
                            label: `${showName}(${userAccount})`,
                            targetType: 1,
                            targetName: teacherName,
                            targetId: teacherId,
                            studentCode: null,
                            roleCode,
                            roleName,
                            gradeCode,
                            gradeName,
                            subjectCode: one.subjectCode,
                            subjectName: one.subjectName,
                            classIdCode,
                            className,
                            classType: null,
                            classTypeName: null,
                            departmentId: null,
                            departmentName: null,
                            departmentGroupId: null,
                            departmentGroupName: null,
                            disabled: !canDel,
                            selected
                        })
                    })
                }
            })
        }
    })

    return arr
}

export const gradTreeData = (list) => {
    if (!list || list.length === 0) return []

    const arr = []

    list.forEach(one => {
        const { gradeName, gradeCode, classTypePersonVoList } = one
        const objectOne = {
            label: gradeName,
            id: gradeCode,
            children: []
        }
        arr.push(objectOne)

        if (classTypePersonVoList && classTypePersonVoList.length) {
            classTypePersonVoList.forEach(two => {
                const { classTypeName, classType, classInfoPersonVoList } = two
                const objectTwo = {
                    label: classTypeName,
                    id: `${gradeCode}_${classType}`,
                    children: []
                }
                objectOne.children.push(objectTwo)

                if (classInfoPersonVoList && classInfoPersonVoList.length) {
                    classInfoPersonVoList.forEach(three => {
                        const { className, classIdCode, personVoList } = three
                        const objectThree = {
                            label: className,
                            id: `${gradeCode}_${classType}_${classIdCode}`,
                            children: []
                        }
                        objectTwo.children.push(objectThree)

                        if (personVoList && personVoList.length) {
                            personVoList.forEach((four, fourIndex) => {
                                const {
                                    showName,
                                    teacherName,
                                    teacherId,
                                    userAccount,
                                    roleCode,
                                    roleName,
                                    courseCode,
                                    courseName,
                                    canDel,
                                    selected
                                } = four

                                objectThree.children.push({
                                    id: `${one.gradeCode}_${two.classType}_${three.classIdCode}_${teacherId}_${fourIndex}`,
                                    label: `${showName}(${userAccount})`,
                                    targetType: 1,
                                    targetName: teacherName,
                                    targetId: teacherId,
                                    studentCode: null,
                                    roleCode,
                                    roleName,
                                    gradeCode,
                                    gradeName,
                                    subjectCode: courseCode,
                                    subjectName: courseName,
                                    classIdCode: three.classIdCode,
                                    className: three.className,
                                    classType: two.classType,
                                    classTypeName: two.classTypeName,
                                    departmentId: null,
                                    departmentName: null,
                                    departmentGroupId: null,
                                    departmentGroupName: null,
                                    disabled: !canDel,
                                    selected
                                })
                            })
                        }
                    })
                }
            })
        }
    })

    return arr
}

export const permTreeData = (list) => {
    if (!list || list.length === 0) return []

    const arr = []

    list.forEach(one => {
        const { roleId, roleName, personVoList } = one
        const objectOne = {
            label: roleName,
            id: roleId,
            children: []
        }
        arr.push(objectOne)

        if (personVoList && personVoList.length) {
            personVoList.forEach((two, twoIndex) => {
                const {
                    showName,
                    teacherName,
                    teacherId,
                    userAccount,
                    roleCode,
                    roleName,
                    gradeCode,
                    gradeName,
                    courseCode,
                    courseName,
                    canDel,
                    selected
                } = two

                objectOne.children.push({
                    id: `${one.roleId}_${teacherId}_${twoIndex}`,
                    label: `${showName}(${userAccount})`,
                    targetType: 1,
                    targetName: teacherName,
                    targetId: teacherId,
                    studentCode: null,
                    roleCode,
                    roleName,
                    gradeCode,
                    gradeName,
                    subjectCode: courseCode,
                    subjectName: courseName,
                    classIdCode: null,
                    className: null,
                    classType: null,
                    classTypeName: null,
                    departmentId: null,
                    departmentName: null,
                    departmentGroupId: null,
                    departmentGroupName: null,
                    disabled: !canDel,
                    selected
                })
            })
        }
    })

    return arr
}
/**
 * 根据文件后缀获取文件类型
 * @param {string} fileType 文件后缀，如 "jpg"
 * @returns {'image'|'video'|'audio'|'document'|''}
 */
export const getFileTypeBySuffix = (fileType) => {
	// 图片后缀
	const IMAGE_EXTS = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'svg', 'ico', 'tiff'];
	// 视频后缀
	const VIDEO_EXTS = ['mp4', 'mov', 'avi', 'mkv', 'flv', 'wmv', 'rmvb', 'mpeg', 'mpg', 'webm'];
	// 音频后缀
	const AUDIO_EXTS = ['mp3', 'wav', 'flac', 'aac', 'ogg', 'm4a', 'wma'];
	// 文档后缀
	const DOC_EXTS = ['doc', 'docx'];
	const XLS_EXTS = ['xls', 'xlsx'];
	const PPT_EXTS = ['ppt', 'pptx'];
	const PDF_EXTS = ['pdf'];
	const TXT_EXTS = ['txt'];
	
	if (!fileType) return '';
	
	// 后缀，转小写
	const ext = fileType.toLowerCase();

	if(IMAGE_EXTS.includes(ext)){
		return 'image'
	}else if (VIDEO_EXTS.includes(ext)){
		return 'video'
	}else if (AUDIO_EXTS.includes(ext)){
		return 'audio'
	}else if (DOC_EXTS.includes(ext)){
		return 'word'
	}else if (XLS_EXTS.includes(ext)){
		return 'excel'
	}else if (PPT_EXTS.includes(ext)){
		return 'pptx'
	}else if (PDF_EXTS.includes(ext)){
		return 'pdf'
	}else if (TXT_EXTS.includes(ext)){
		return 'txt'
	}else{
		return ''
	}
}