zhywpt-sp/utils/utils.ts

import config from '@/config/index.js'
import { getItem, StorageKeys } from "./storage";
import { OrderStatus, OrderTypes } from "@/datas/enum.ts";
import { envs, ocrDo } from "@/utils/network/api.js";
import { agentId } from "@/utils/network/difference";
import {
	requestNew
} from "@/utils/network/request.js";
export const msg = (title : string = "", param : any = {}) => {
	if (!title) return;
	uni.showToast({
		title,
		duration: param.duration || 1500,
		mask: param.mask || false,
		icon: param.icon || "none",
	});
};

// tab页面,用于区分不同跳转方法
const tabBarPages = ["pages/index/index", "pages/service/service", "pages/user/user"]

//确认弹窗
export const confirm = (content : string, callback : Function, title : string = "", showCancel ?: boolean, confimTxt = '确定') => {
	uni.showModal({
		title: title,
		content: content,
		showCancel: showCancel ? showCancel : true,
		confirmText: confimTxt,
		success: function (res) {
			if (res.confirm) {
				callback()
			} else if (res.cancel) {
				//console.log('用户点击取消');
			}
		}
	});
};

/**
 * 判断是否登录
 */
export const hasLogin = () => {
	const token = getItem(StorageKeys.Token);
	const openId = getItem(StorageKeys.OpenId);
	return !isBlank(token) && !isBlank(openId);
}

/**
 * 跳转页面
 * url：页面路径
 * login：是否需要判断有没有登录
 */
export const navTo = (url : string = "", login : boolean = false) => {
	if (!url) {
		return;
	}
	if (login && !hasLogin()) {
		confirm('您需要登录过后才能使用此功能', () => {
			uni.navigateTo({
				url: '/login/login',
			});
		}, '温馨提示', true, '去登录');
	} else {
		let pages = getCurrentPages();
		// 获取页面栈总页数
		// this.pagesCount = pages.length;
		// 如果页面栈总数大于10
		console.log("pages.length", pages.length)
		if (pages.length >= 10) {
			// 使用重定向跳转页面
			uni.redirectTo({
				url
			})
		} else {
			// 如果页面栈总数小于10，则打开新页面
			if (isTabarPages(url)) {
				uni.switchTab({
					url: url
				})
			} else {
				uni.navigateTo({
					url,
				});
			}
		}
	}
};

/**
 * 是否是tabar页面
 * url：页面路径
 */
const isTabarPages = (url : string) => {
	let isNot = false
	
	for (let i = 0; i < tabBarPages.length; i++) {
		let item = tabBarPages[i]
		if (url.includes(item)) {
			isNot = true
			break
		}
		
	}
	
	return isNot
}

/**
 * 校验格式数据格式
 * @param 要校验的数据
 * @param 什么类型格式
 */
export const checkStr = (str : string, type : string) => {
	switch (type) {
		case 'mobile': //手机号码
			return /^1[3|4|5|6|7|8|9][0-9]{9}$/.test(str);
		case 'tel': //座机
			return /^(0\d{2,3}-\d{7,8})(-\d{1,4})?$/.test(str);
		case 'card': //身份证
			return /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/.test(str);
		case 'mobileCode': //6位数字验证码
			return /^[0-9]{6}$/.test(str)
		case 'pwd': //密码以字母开头，长度在8~99之间，只能包含字母、数字和下划线
			return /^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{8,99}$/.test(str)
		case 'payPwd': //支付密码 6位纯数字
			return /^[0-9]{6}$/.test(str)
		case 'postal': //邮政编码
			return /[1-9]\d{5}(?!\d)/.test(str);
		case 'QQ': //QQ号
			return /^[1-9][0-9]{4,9}$/.test(str);
		case 'weixin': //微信号
			return /^[a-zA-Z][a-zA-Z\d_-]{5,19}$/.test(str);
		case 'email': //邮箱
			return /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(str);
		case 'money': //金额(小数点2位)
			return /^\d*(?:\.\d{0,2})?$/.test(str);
		case 'URL': //网址
			return /(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?/.test(str)
		case 'IP': //IP
			return /((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))/.test(str);
		case 'date': //日期时间
			return /^(\d{4})\-(\d{2})\-(\d{2}) (\d{2})(?:\:\d{2}|:(\d{2}):(\d{2}))$/.test(str) || /^(\d{4})\-(\d{2})\-(\d{2})$/
				.test(str)
		case 'number': //数字
			return /^[0-9]$/.test(str);
		case 'english': //英文
			return /^[a-zA-Z]+$/.test(str);
		case 'chinese': //中文
			return /^[\\u4E00-\\u9FA5]+$/.test(str);
		case 'lower': //小写
			return /^[a-z]+$/.test(str);
		case 'upper': //大写
			return /^[A-Z]+$/.test(str);
		case 'HTML': //HTML标记
			return /<("[^"]*"|'[^']*'|[^'">])*>/.test(str);
		default:
			return true;
	}
}

/**
 * 检查是否为空
 * val 数组、对象、字符串
 */
export function isBlank(val) {
	if (typeof val == 'boolean') {
		return false;
	}
	if (typeof val == 'number') {
		return false;
	}
	if (val instanceof Array) {
		if (val.length == 0) return true;
	} else if (val instanceof Object) {
		if (JSON.stringify(val) === '{}') return true;
	} else {
		if (val == 'null' || val == null || val == 'undefined' || val == undefined || val == '') return true;
		return false;
	}
	return false;
};

//根据订单状态获取订单状态文字
export const getOrderStatusName = (status) => {
	switch (Number(status)) {
		case Number(OrderStatus.完成填写基本信息):
			return '申请中';
			break;
		case Number(OrderStatus["完成个人/单位信息上传"]):
			return '申请中';
			break;
		case Number(OrderStatus.完成车辆信息上传):
			return '申请中';
			break;
		case Number(OrderStatus.待支付):
			return '待支付';
			break;
		case Number(OrderStatus.待支付3):
			return '申请中';
			break;
		case Number(OrderStatus.待支付2):
			return '待支付';
			break;
		case Number(OrderStatus.完成签约):
			return '完成签约';
			break;
		case Number(OrderStatus.待审核):
			return '待审核';
			break;
		case Number(OrderStatus.审核不通过):
			return '审核不通过';
			break;
		case Number(OrderStatus.待发货):
			return '待发货';
			break;
		case Number(OrderStatus.待收货):
			return '待收货';
			break;
		case Number(OrderStatus.待激活):
			return '待激活';
			break;
		case Number(OrderStatus.已完成):
			return '已完成';
			break;
		case Number(OrderStatus["已申请-换货"]):
			return '换货中';
			break;
		case Number(OrderStatus["已申请-退货"]):
			return '退货中';
			break;
		case Number(OrderStatus.已结束):
			return '已结束';
			break;
		case Number(OrderStatus.退款中):
			return '退款中';
			break;
		case Number(OrderStatus.退款成功):
			return '退款成功';
			break;
		case Number(OrderStatus.退货成功):
			return '退货成功';
			break;
		case Number(OrderStatus["换货-设备已回收"]):
			return '换货成功';
			break;
		case Number(OrderStatus.待加购权益):
			return '代加购权益';
			break;
		case Number(OrderStatus["完成车辆信息上传/待支付"]):
			return '待支付';
			break;
		case Number(OrderStatus["已支付/待签约"]):
			return '待签约';
			break;
		default:
			break;
	}
}
//根据订单状态获取订单状态文字
export const getOrderStatusNameNew = (status) => {
	switch (status) {
		case OrderStatus.完成填写基本信息:
			return 'shenqingzhong';
			break;
		case OrderStatus["完成个人/单位信息上传"]:
			return 'shenqingzhong';
			break;
		case OrderStatus.完成车辆信息上传:
			return 'shenqingzhong';
			break;
		case OrderStatus.待支付:
			return 'daizhifu';
			break;
		case OrderStatus.待支付3:
			return 'shenqingzhong';
			break;
		case OrderStatus.待支付2:
			return 'daizhifu';
			break;
		case OrderStatus.完成签约:
			return 'finishqianyue';
			break;
		case OrderStatus.待审核:
			return 'daishenhe';
			break;
		case OrderStatus.审核不通过:
			return 'nopass';
			break;
		case OrderStatus.待发货:
			return 'daifanhuo';
			break;
		case OrderStatus.待收货:
			return 'daishouhuo';
			break;
		case OrderStatus.待激活:
			return 'dajihuo';
			break;
		case OrderStatus.已完成:
			return 'yiwancheng';
			break;
		case OrderStatus["已申请-换货"]:
			return 'huanhuozhong';
			break;
		case OrderStatus["已申请-退货"]:
			return 'tuihuozhong';
			break;
		case OrderStatus.已结束:
			return 'yijieshu';
			break;
		case OrderStatus.退款中:
			return 'tuikuanzhong';
			break;
		case OrderStatus.退款成功:
			return 'tuikuanchenggong';
			break;
		case OrderStatus.退货成功:
			return 'tuihuosuccess';
			break;
		case OrderStatus["换货-设备已回收"]:
			return 'huanhuochenggong';
			break;
		case OrderStatus["完成车辆信息上传/待支付"]:
			return 'daizhifu';
			break;
		case OrderStatus["已支付/待签约"]:
			return 'daiqianyue';
			break;
		default:	
			break;
	}
}
//根据订单类型获取订单类型文字
export const getOrderTypeName = (orderType) => {
	return OrderTypes[orderType];
}
//根据订单类型获取订单类型文字
export const getOrderTypeNameNew = (orderType) => {
	return OrderTypesNew[orderType];
}
//根据车辆类型获取车辆名称
export const getCarTypeName = (carType : any) => {
	switch (carType) {
		case 1:
			return '客车';
			break;
		case 2:
			return '货车';
			break;
		default:
			break;
	}
}

//根据ETC卡状态获取ETC卡状态文字
export const getETCStatusName = (cardStatus) => {
	switch (cardStatus) {
		case 0:
			return '申请';
			break;
		case 1:
			return '正常';
			break;
		case 2:
			return '有卡挂起';
			break;
		case 3:
			return '无卡挂起';
			break;
		case 4:
			return '有卡注销';
			break;
		case 5:
			return '无卡注销';
			break;
		case 6:
			return '卡挂失';
			break;
		case 9:
			return '预注销';
			break;
		case 99:
			return '已删除';
			break;
		default:
			break;
	}
}

//根据OBU状态获取OBU状态文字
export const getOBUStatusName = (obuStatus) => {
	switch (obuStatus) {
		case 0:
			return '未安装';
			break;
		case 1:
			return '正常';
			break;
		case 2:
			return '有签挂起';
			break;
		case 3:
			return '无签挂起';
			break;
		case 4:
			return '有签注销';
			break;
		case 5:
			return '无签注销';
			break;
		case 6:
			return '标签挂失';
			break;
		case 7:
			return '已过户';
			break;
		case 8:
			return '维修中';
			break;
		case 9:
			return '发行申请';
			break;
		case 10:
			return '车型不符';
			break;
		case 11:
			return '已发行';
			break;
		case 99:
			return '已删除';
			break;
		default:
			break;
	}
}

//获取订单时间
export const getOrderTime = (time) => {
	if (!time) return '';
	return getFormatDate(new Date(time));
}
//替换图片路径
export const strReplace = (str : string) => {
	// let imgUrl = str.replace("http://192.168.101.145:9000", envs[process.env.NODE_ENV].baseUrl);
	// imgUrl = imgUrl.replace("http://100.64.2.113:9000", envs[process.env.NODE_ENV].baseUrl);
	// return envs[process.env.NODE_ENV].baseUrl + imgUrl;
	return str;
}

//增加图片路径
export const imgPathMontage = (str : string) => {
	// let imgUrl = `${envs[process.env.NODE_ENV].baseUrl}/${str}`;
	let imgUrl = `${str}`;
	return imgUrl;
}

// 获取文件完整路径
export const getFullImageUrl = (str : string) => {
	return `${envs[process.env.NODE_ENV].baseUrl}/${str}`
}

// 获取文件完整路径
export const replaceBaseImageUrl = (str : string) => {
	return str.replace(envs[process.env.NODE_ENV].baseUrl, "")
}

// 身份证号脱敏
export const desensitization = (val) => {
	if (val) {
		return val.replace(/^\d{14}/, '**************');
	}
}
// 银行卡脱敏
/**
 * 对银行卡号进行脱敏处理
 * @param {string} cardNumber - 银行卡号字符串
 * @returns {string} 脱敏后的卡号，格式为：前6位 + 星号 + 后4位
 */
export const maskBankCard = (cardNumber: string): string => {
    if (!cardNumber || typeof cardNumber !== 'string') {
        return cardNumber;
    }
    
    // 移除所有非数字字符
    const digitsOnly = cardNumber.replace(/\D/g, '');
    const length = digitsOnly.length;
    
    // 卡号长度验证（常见长度：15, 16, 19位）
    if (length < 10) {
        // 长度不足，无法按规则脱敏，返回原值或抛出错误
        return digitsOnly;
    }
    
    // 计算需要隐藏的位数：总长度 - 前6位 - 后4位
    const starsCount = length - 10;
    const firstSix = digitsOnly.substring(0, 6);
    const lastFour = digitsOnly.substring(length - 4);
    
    // 生成星号部分
    const stars = '*'.repeat(starsCount);
    
    return firstSix + stars + lastFour;
}
//查看大图
export const checkBigImg = (current, urls) => {
	uni.previewImage({
		current: current,
		urls: urls,
	});
}

//日期格式化
export function getFormatDate(date, fmt ?: string) {
	if (date == undefined) {
		date = new Date()
	}
	date = typeof date == 'number' ? new Date(date) : date;
	fmt = fmt || 'yyyy-MM-dd HH:mm:ss';
	var obj = {
		'y': date.getFullYear(), // 年份，注意必须用getFullYear
		'M': date.getMonth() + 1, // 月份，注意是从0-11
		'd': date.getDate(), // 日期
		'q': Math.floor((date.getMonth() + 3) / 3), // 季度
		'w': date.getDay(), // 星期，注意是0-6
		'H': date.getHours(), // 24小时制
		'h': date.getHours() % 12 == 0 ? 12 : date.getHours() % 12, // 12小时制
		'm': date.getMinutes(), // 分钟
		's': date.getSeconds(), // 秒
		'S': date.getMilliseconds() // 毫秒
	};
	var week = ['天', '一', '二', '三', '四', '五', '六'];
	for (var i in obj) {
		fmt = fmt.replace(new RegExp(i + '+', 'g'), function (m) {
			var val = obj[i] + '';
			if (i == 'w') return (m.length > 2 ? '星期' : '周') + week[val];
			for (var j = 0, len = val.length; j < m.length - len; j++) val = '0' + val;
			return m.length == 1 ? val : val.substring(val.length - m.length);
		});
	}
	return fmt;
};

//时间格式化
export function formatTime(date : any) {
	const year = date.getFullYear()
	const month = date.getMonth() + 1
	const day = date.getDate()
	const hour = date.getHours()
	const minute = date.getMinutes()
	const second = date.getSeconds()

	return `${[year, month, day].map(formatNumber).join('-')}T${[hour, minute, second].map(formatNumber).join(':')}`
}
export function formatTime2(date : any) {
	const year = date.getFullYear() + 10
	const month = date.getMonth() + 1
	const day = date.getDate()
	const hour = date.getHours()
	const minute = date.getMinutes()
	const second = date.getSeconds()

	return `${[year, month, day].map(formatNumber).join('-')}T${[hour, minute, second].map(formatNumber).join(':')}`
}

//有效期时间格式化
export function expireDate(date : any) {
	const year = date.getFullYear() + 10
	const month = date.getMonth() + 1
	const day = date.getDate()

	return `${[year, month, day].map(formatNumber).join('-')}`
}

export function expireDate2(date : any) {
	const year = date.getFullYear() + 10
	const month = date.getMonth() + 1
	const day = date.getDate()

	return `${[year, month, day].map(formatNumber).join('')}`
}
//当前时间时间格式化
export function nowDate(date : any) {
	const year = date.getFullYear()
	const month = date.getMonth() + 1
	const day = date.getDate()
	return `${[year, month, day].map(formatNumber).join('-')}`
}

function formatNumber(n : any) {
	n = n.toString()
	return n[1] ? n : `0${n}`
}
export const uploadFile = (tempImagePath, imageType: number | string = 100) => {
	console.log("tempImagePath", tempImagePath, tempImagePath.size,imageType)
	return new Promise((resolve, reject) => {
		let url = `${envs[process.env.NODE_ENV].baseUrl}${config.prefix}/minIo/upload`
		
		uni.uploadFile({
			url: url,
			filePath: tempImagePath,
			name: 'file',
			formData: {
				'busCode': 'iaw',
			},
			success: (uploadFileRes) => {
				console.log("uploadFileRes", uploadFileRes, JSON.parse(uploadFileRes.data).data.ossFilePath)
				if (!imageType || parseInt(imageType) >= 99) {
					resolve({ imageUrl: JSON.parse(uploadFileRes.data).data.ossFilePath })
					return
				}

				const options = {
					type: 2,
					data: {
						type: imageType,
						imagePath: JSON.parse(uploadFileRes.data).data.ossFilePath,
					},
					method: "POST",
					showLoading: true,
				};
				requestNew(ocrDo, options).then((res) => {
					const data = { ...res, imageUrl: JSON.parse(uploadFileRes.data).data.ossFilePath,imageName: res.imageUrl };
					resolve(data)
				});

			},
			fail: () => {
				uni.showModal({
					title: '提示',
					content: '图片上传失败,请联系管理人员',
					success: function (res) {
						if (res.confirm) {
							console.log('用户点击确定');
						} else if (res.cancel) {
							console.log('用户点击取消');
						}
					}
				});

			}
		});
	})
}
/**
 *  获取距离当前时间的 (天数/小时数/分钟数)
 * @param {*} timesData  '2018-05-17 16:58:00'
 * @returns 
 */
export function timesDiff(timesData : any) {
	var dateBegin = new Date();//获取当前时间
	var dateEnd = new Date(timesData.replace(/-/g, "/"));//将-转化为/，使用new Date
	var dateDiff = dateEnd.getTime() - dateBegin.getTime();//时间差的毫秒数
	var days = Math.floor(dateDiff / (24 * 3600 * 1000));//计算出相差天数
	var leave1 = dateDiff % (24 * 3600 * 1000)    //计算天数后剩余的毫秒数
	var hours = Math.floor(leave1 / (3600 * 1000))//计算出小时数
	var leave2 = leave1 % (3600 * 1000)    //计算小时数后剩余的毫秒数
	var minutes = Math.floor(leave2 / (60 * 1000))//计算相差分钟数
	var diffObj = {
		days: 0,
		hours: 0,
		minutes: 0,
	};

	if (days != 0) {
		diffObj.days = Math.abs(days);
	} else if (days == 0 && hours != 0) {
		diffObj.hours = hours;
	} else if (days == 0 && hours == 0) {
		diffObj.minutes = minutes;
	}

	return diffObj
}
// 订阅消息
export function subscribeMessages() {
	uni.requestSubscribeMessage({
		tmplIds: ['aNr4T2JEtaLtR9dihM2w3NAznz4bFMkutVZCbaSTjxg'],
		success(res) {
			console.log("订阅消息", res)
		}
	})
}
// 通知用户消息订阅
export const noticeUser = (callback : Function) => {

	// #ifdef MP-WEIXIN
	uni.requestSubscribeMessage({
		tmplIds: ['u7u0yO2dkYBISpox815e1S_fcUyl9B9qyxAK7aBjuho'],
		complete(res) {
			console.log("通知用户消息订阅", res)
			callback()
		}
	})
	// #endif
	// #ifdef MP-ALIPAY
	my.requestSubscribeMessage({
		entityIds: [
			'f1f2d14d608e48dca5c4f4775d3d2424'
		],
		complete(res) {
			console.log("通知用户消息订阅", res)
			callback()
		}
	})
	// #endif
}
// 压缩图片
export const compressImage = (tempFilePaths : any, scall, callback : Function) => {
	uni.compressImage({
		src: tempFilePaths, // 图片路径
		quality: 80, // 压缩质量，范围为0 - 100，100为不压缩
		success: function (res) {
			console.log('压缩后的图片路径：' + res.tempFilePath, res)
			callback(res)
		},
		fail: function (err) {
			console.error('压缩失败：' + err)
		}
	})
}
export const chooseImageCompress = (callback : Function) => {
	uni.chooseImage({
		count: 1, //只能选取一张照片
		sizeType: ["original", "compressed"], //可以指定是原图还是压缩图，默认二者都有
		sourceType: ["album"], //从相册选择
		success: function (res) {
			let scall = res.tempFiles[0].size / 1024 / 1024 / 2
			console.log("scall", scall)
			console.log("res.tempFiles[0].size", res.tempFilePaths[0], res.tempFiles[0].size / 1024 / 1024)
			// if(scall>1){
			// 		console.log("压缩")
			// 		let quality=100
			// 		if(scall<2){
			// 			quality=80
			// 		}else if(scall>=3 && scall<4){
			// 			quality=75
			// 		}else if(scall>=4 && scall<5){
			// 			quality=60
			// 		}else if(scall>=5 && scall<6){
			// 			quality=1
			// 		}else{
			// 			quality=0
			// 		}
			// 		uni.compressImage({
			// 			src: res.tempFilePaths[0], // 图片路径
			// 			quality: quality, // 压缩质量，范围为0 - 100，100为不压缩
			// 			success: function (res) {
			// 				console.log('压缩后的图片路径：' + res.tempFilePath,res)
			// 				callback(res)
			// 			},
			// 			fail: function (err) {
			// 				console.error('压缩失败：' + err)
			// 			}
			// 		})
			// }else{
			callback(res)
			// }
		},
	})
}
// 身份证有效期是否过期
export function compareDates(specifiedDateString) {
	const newTime = specifiedDateString.substring(0, 4) + "-" + specifiedDateString.substring(4, 6) + "-" + specifiedDateString.substring(6, 8)
	console.log("newTime", newTime)
	const currentDate = new Date();
	const specifiedDate = new Date(newTime);

	if (currentDate > specifiedDate) {
		console.log("当前日期晚于指定日期")
		msg("身份证过期请重新上传", {
			'duration': 2000
		})
		return "当前日期晚于指定日期";
	} else if (currentDate < specifiedDate) {
		console.log("当前日期早于指定日期")
		return "当前日期早于指定日期";
	} else {
		console.log("当前日期等于指定日期")
		return "当前日期等于指定日期";
	}
}

// 示例使用
// const dateComparison = compareDates('2023-12-31');
// console.log(dateComparison);

// 跳转运维小程序
export function jumpOldMini() {
	uni.navigateToMiniProgram({
		appId: "wx008c60533388527a",
		path: `pages/main/serve/serve`,
		envVersion: "release",
		success(res) {
			console.log('成功', res);
		},
		fail(res) {
			console.log('失败' + res);
		},
	});
}
// 图片转base64
export const getFileBase64 = (path) => {
	console.log("进来", path)
	return new Promise((resolve, reject) => {
		uni.getFileSystemManager().readFile({
			filePath: path, //参数path:图片相对路径
			encoding: 'base64',
			success: (res) => {
				console.log("进来1", res)
				resolve(res.data);
			},
			fail: (err) => {
				console.log(err);
			}
		});
	});
};

// 获取路径中的params 参数
export const getUrlParameters = (url: string) => {
   
  const params = {};
  
  const queryString = url.split('?')[1];

  if (queryString) {
   
    const paramPairs = queryString.split('&');

    for (let i = 0; i < paramPairs.length; i++) {
   
      const pair = paramPairs[i].split('=');
      const key = decodeURIComponent(pair[0]);
      const value = decodeURIComponent(pair[1] || '');

      if (params[key]) {
   
        if (Array.isArray(params[key])) {
   
          params[key].push(value);
        } else {
   
          params[key] = [params[key], value];
        }
      } else {
   
        params[key] = value;
      }
    }
  }

  return params;
}

// 将对象转化为url中的params
export const objectToQueryString = (obj: object) => {
	// 对空值无值的属性做个过滤
	const filteredObj = Object.fromEntries(Object.entries(obj).filter(([key, value]) => value !== undefined && value !== null && value !== ""));
	return Object.keys(filteredObj).map(key => 
		key + '=' + filteredObj[key]
	).join('&');
}

// 获取月初第一天
export const getFirstDayOfMonth = () => {
	const today = new Date(); // 获取当前日期
	const firstDay = new Date(today.getFullYear(), today.getMonth(), 1); // 设置日期为当前月份的第一天
	return `${getFormatDate(firstDay, 'yyyy-MM-dd')}`;
}

// 获取月份最后一天
export const getLastDayOfMonth = () => {
    const today = new Date(); // 获取当前日期
	let lastDay = new Date(today.getFullYear(), today.getMonth() + 1, 0); // 设置日期为下个月的第一天的前一天，即当前月的最后一天
	return `${getFormatDate(lastDay, 'yyyy-MM-dd')}`;
}