crm-app-vue3/utils/util.js

import Map from '@/js_sdk/fx-openMap/openMap.js'
import permision from "@/js_sdk/wa-permission/permission.js"
export function mapRoutePlan(data) {
	//既有起点也有终点
	var options = {
		destination: { //导航终点点坐标和名称
			latitude: data.point.latitude,
			longitude: data.point.longitude,
			name: data.address
		},
		mode: "drive", //导航方式 公交：bus驾车：drive（默认）,步行：walk,骑行：bike
		mapId: "map" //map 组件的 id (微信小程序端必传)
	}
	Map.routePlan(options, "gcj02")
}


// 在需要的页面中写方法，判断是否在微信浏览器中
export function is_weixin() {
	let flag = false;
	// #ifdef H5
	flag = String(navigator.userAgent.toLowerCase().match(/MicroMessenger/i)) === "micromessenger";
	// #endif

	// #ifdef  APP-PLUS
	flag = false;
	// #endif
	return flag;
}

// 格式化手机号码，移除国际区号
export function formatPhoneNumber(phoneNumber) {
	if (!phoneNumber) return '';

	// 移除非数字字符
	let cleaned = phoneNumber.replace(/\D/g, '');

	// 如果是中国手机号（+86 或 86 开头）
	if (cleaned.startsWith('86') && cleaned.length === 13) {
		// 移除中国区号 86
		cleaned = cleaned.substring(2);
	} else if (cleaned.startsWith('1') && cleaned.length === 11) {
		// 如果是11位数字，可能是中国手机号
		cleaned = cleaned;
	} else if (cleaned.startsWith('1') && cleaned.length === 12 && phoneNumber.includes('+86')) {
		// 如果是+86开头的完整号码
		cleaned = cleaned.substring(2);
	}

	return cleaned;
};


/**
 * 获取Androoid设备mac地址
 * */
export function getMacAddress() {
	if (window) {
		return "D1:D1:D1:D1:D1:D1"
	}
	var net = plus.android.importClass("java.net.NetworkInterface")
	var wl0 = net.getByName('wlan0')
	var macByte = wl0.getHardwareAddress()
	var str = ''
	for (var i = 0; i < macByte.length; i++) {
		var tmp = "";
		var num = macByte[i];
		if (num < 0) {
			tmp = (255 + num + 1).toString(16);
		} else {
			tmp = num.toString(16);
		}
		if (tmp.length == 1) {
			tmp = "0" + tmp;
		}
		if (i == macByte.length - 1) {
			str += tmp;
		} else {
			str = str + tmp + ":";
		}
	}
	return str.toUpperCase()
}


/**
 * 判断传入的值是否为空
 * @param {*} val 
 * @returns 
 */
export function isNull(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 function isDef(val) {
	return val !== undefined && val !== null;
}

// 是否是一个数字
export function isNumeric(val) {
	return /^\d+(\.\d+)?$/.test(val);
}

// 是一个对象
export function isObject(val) {
	return Object.prototype.toString.call(val) === "[object Object]"
}

// 是一个字符串
export function isString(val) {
	return Object.prototype.toString.call(val) === "[object String]"
}




// 添加单位
export function addUnit(value) {
	if (!isDef(value)) {
		return undefined;
	}

	value = String(value);
	return isNumeric(value) ? `${value}px` : value;
}

// 获得角度
export function getAngle(angx, angy) {
	return Math.atan2(angy, angx) * 180 / Math.PI;
};

// 根据起点终点返回方向 1向上 2向下 3向左 4向右 0未滑动
export function getDirection(startx, starty, endx, endy) {
	var angx = endx - startx;
	var angy = endy - starty;
	var result = 0;

	// 如果滑动距离太短
	if (Math.abs(angx) < 5 && Math.abs(angy) < 5) {
		return result;
	}

	var angle = getAngle(angx, angy);
	if (angle >= -160 && angle <= -20) {
		result = 1;
	} else if (angle > 20 && angle < 160) {
		result = 2;
	} else if ((angle >= 160 && angle <= 180) || (angle >= -180 && angle < -160)) {
		result = 3;
	} else if (angle >= -20 && angle <= 20) {
		result = 4;
	}

	return result;
}

// 回显数据字典
export function selectDictLabel(datas, value) {
	if (!datas) return value
	var actions = [];
	Object.keys(datas).some((key) => {
		if (datas[key].dictValue == ('' + value)) {
			actions.push(datas[key].dictLabel);
			return true;
		}
	})
	return actions.join('') || value
}


/**
 * 处理后台返回的数据
 * 去除无 children 且 isUser为false 的项目
 */
export function filterCustomerManager(list) {
	const newList = list.filter((item) => {
		if (item.children) {
			item.name = item.label;
			item.children = filterCustomerManager(item.children)
			return item.children.length > 0
		} else {
			item.name = item.label;
			item.id = item.id.toString()
			return item.isUser == true
		}
	})
	return newList
}


/**
 * 简单实现防抖方法
 *
 * 防抖(debounce)函数在第一次触发给定的函数时，不立即执行函数，而是给出一个期限值(delay)，比如100ms。
 * 如果100ms内再次执行函数，就重新开始计时，直到计时结束后再真正执行函数。
 * 这样做的好处是如果短时间内大量触发同一事件，只会执行一次函数。
 *
 * @param fn 要防抖的函数
 * @param delay 防抖的毫秒数
 * @returns {Function}
 */
export function simpleDebounce(fn, delay = 100) {
	let timer = null
	return function() {
		let args = arguments
		if (timer) {
			clearTimeout(timer)
		}
		timer = setTimeout(() => {
			fn.apply(this, args)
		}, delay)
	}
}


/**
 * 节流
 *
 * @param delay 时间
 * @param fn 执行的函数
 */
export function throttle(delay, fn) {
	let valid = true;
	return function() {
		if (!valid) {
			return false
		}
		valid = false;
		fn()
		setTimeout(() => {
			valid = true;
		}, delay)
	}
}


// 获取位置
export function getLocation(option = {}) {
	return new Promise((resolve, reject) => {
		permision.requestAndroidPermission("android.permission.ACCESS_FINE_LOCATION").then((
			result) => {
			if (result == 1) {
				uni.getLocation({
					type: 'gcj02', // gcj02 wgs84
					...option,
					success: function(res) {
						resolve(res);
						// console.log('当前位置的经度：' + res.longitude);
						// console.log('当前位置的纬度：' + res.latitude);
					},
					fail() {
						uni.$u.toast("获取定位失败");
						reject(true);
					}
				});
			} else if (result == 0) {
				uni.$u.toast("未获得位置授权");
				reject();
			} else {
				uni.$u.toast("位置授权被永久拒绝,请手动打开");
				reject();
			}
		});
	});
}

export const pullDownRefreshEnableSwitch = (enable) => {
	const pages = getCurrentPages()
	const page = pages[pages.length - 1]
	// #ifdef APP-PLUS
	const currentWebview = page.$getAppWebview()
	currentWebview.setStyle({
		pullToRefresh: {
			support: enable,
			style: plus.os.name === 'Android' ? 'circle' : 'default',
		},
	})
	// #endif

	// #ifdef WEB || H5
	let el = document.querySelector('.uni-page-refresh')
	if (el) {
		el.style.display = enable ? 'block' : 'none'
	} else {
		let time = 0
		setTimeout(() => {
			time++
			el = document.querySelector('.uni-page-refresh')
			if (time < 20 && !el) {
				pullDownRefreshEnableSwitch(enable)
			}
		}, 100)
	}
	// #endif
}

// 定时器的toast
export function toast(option = {}) {
	let time = null;
	time = setTimeout(() => {
		clearTimeout(time);
		uni.showToast({
			icon: "none",
			...option
		});
	}, 500);
}


//判断中文
export function isChinese(param) {
	var regExp = /^[u4e00-u9fa5]*$/;
	if (regExp.test(param))
		return false;
	return true;
}

// 计算两个经纬度之间的距离
export function getDistanceFromLatLonInM(lat1, lon1, lat2, lon2) {
	var R = 6371; // 地球半径，单位为千米
	var dLat = deg2rad(lat2 - lat1);
	var dLon = deg2rad(lon2 - lon1);
	var a =
		Math.sin(dLat / 2) * Math.sin(dLat / 2) +
		Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2)) *
		Math.sin(dLon / 2) * Math.sin(dLon / 2);
	var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
	var distance = R * c * 1000; // 转换为米
	return distance;
}

function deg2rad(deg) {
	return deg * (Math.PI / 180);
}


/**
 * 构造树型结构数据
 * @param {*} data 数据源
 * @param {*} id id字段 默认 'id'
 * @param {*} parentId 父节点字段 默认 'parentId'
 * @param {*} children 孩子节点字段 默认 'children'
 * @param {*} rootId 根Id 默认 0
 */
export function handleTree(data, id, parentId, children, rootId) {
	id = id || 'id'
	parentId = parentId || 'parentId'
	children = children || 'children'
	if (id === 'deptId' || id === "id") {
		if (data[0] && !data[0].ancestors) return rootId = 0
		let maxLength = 99999999
		data.forEach(item => {
			const length = item.ancestors.split(",").length
			if (maxLength > length) {
				maxLength = length
				rootId = item.parentId
			}
		})
	} else {
		rootId = rootId || Math.min.apply(Math, data.map(item => {
			return item[parentId]
		})) || 0
	}
	//对源数据深度克隆
	const cloneData = JSON.parse(JSON.stringify(data))
	//循环所有项
	const treeData = cloneData.filter(father => {
		let branchArr = cloneData.filter(child => {
			//返回每一项的子级数组
			return father[id] === child[parentId]
		});
		branchArr.length > 0 ? father.children = branchArr : '';
		//返回第一层
		return father[parentId] === rootId;
	});
	return treeData != '' ? treeData : data;
}