yizhizan-h5/common/queue.js

/**
 * 
 * @author maxd
 * @date 2019.8.1
 */
import configdata from './config'
import cache from './cache'
// #ifdef APP-PLUS 
import permision from "../js_sdk/wa-permission/permission.js"
// #endif

function getHost(name) {
	const webConfig = cache.get('web_config')
	if (webConfig && webConfig[name]) {
		return webConfig[name]
	}
	return configdata[name]
}

module.exports = {
	//微信的appId
	getWxAppid() {
		return 'wxd0bec3a917085e78'
	},
	//全局邀请码
	getInvitation() {
		return uni.getStorageSync("publicRelation")
	},
	//获取APP下载地址
	getAppDownUrl() {
		return uni.getStorageSync("appurl")
	},
	//全局域名 部分html中需要单独替换 需要修改config中的网络请求域名
	publicYuMing() {
		return configdata.h5Url
	},
	// 登录判断
	toLogin(type) {
		let url = '/pages/public/loginV2'
		switch (type) {
			case 'navigateTo':
				uni.navigateTo({
					url
				})
				break
			default:
				uni.reLaunch({
					url
				})
		}
	},
	logout() {
		this.remove("token");
		this.remove("userId");
		this.remove("mobile");
		this.remove("openid");
		this.remove("nickName");
		this.remove("relation");
		this.remove("image_url");
		this.remove("relation_id");
		this.remove("isInvitation");
		this.remove("userType");
		this.remove("member");
		this.remove('companyId')
		this.remove('avatar')
		this.remove('age')
		this.remove('companyName')
		this.remove('companyStatus')
		this.remove('isVip')
		this.remove('vipMsgNum')
		this.remove('vipMsgPrice')
		this.remove('vipDueTimes')
		this.remove('msgNum')
		this.remove('msgPrice')
		this.remove('invitationCode')
		this.remove('inviterCode')
		this.remove('hadShowPoster')
	},
	loginClear() {
		this.remove("token");
		this.remove("userId");
		this.remove("mobile");
		this.remove("nickName");
		this.remove("image_url");
		this.remove("relation_id");
		this.remove("isInvitation");
		this.remove("member");
	},
	showLoading(title) {
		uni.showLoading({
			title: title
		});
	},
	hideLoading() {
		uni.hideLoading();
	},
	showToast(title) {
		uni.showToast({
			title: title,
			mask: false,
			duration: 2000,
			icon: "none"
		});
	},
	getChatSearchKeys: function(key) {
		let list = uni.getStorageSync("chatSearchKeys");
		let keys = key.replace(/\s*/g, "")
		let over = false
		for (var i = 0; i < keys.length; i++) {
			// console.error(keys[i])
			if (list.indexOf(keys[i]) != -1) {
				over = true;
				// return over;
			}

		}
		return over;

	},
	setJson: function(key, value) {
		let jsonString = JSON.stringify(value);
		try {
			uni.setStorageSync(key, jsonString);
		} catch (e) {
			// error
		}
	},
	setData: function(key, value) {
		try {
			uni.setStorageSync(key, value);
		} catch (e) {
			// error
		}
	},
	getData: function(key) {
		try {
			const value = uni.getStorageSync(key);
			if (value) {
				return value;
			}
		} catch (e) {
			// error
		}

	},
	getJson: function(key) {
		try {
			const value = uni.getStorageSync(key);
			if (value) {
				return JSON.parse(value);
			}
		} catch (e) {
			// error
		}

	},
	clear: function() {
		uni.clearStorage();
	},
	get: function(key) { //获取队列里面全部的数据
		let data = this.getJson(key);
		if (data instanceof Array) {
			return data;
		}
		return [];
	},
	insert: function(param) { //队列插入数据
		param.capacityNum = param.capacityNum || 100; //队列容量 默认队列中超过100条数据，自动删除尾部
		let data = this.getJson(param.key);
		if (data instanceof Array) {
			if (data.length > param.capacityNum) {
				let total = data.length - param.capacityNum;
				for (let i = 0; i < total; i++) {
					data.pop();
				}
			}
			data.unshift(param.value);
		} else {
			data = [];
			data.push(param.value);
		}
		this.setJson(param.key, data);
	},
	removeItem: function(key, itemIds) { //提供itemIds数组 批量删除队列中的某项数据
		let data = this.getJson(key);
		if (data instanceof Array) {
			for (let i = 0; i < itemIds.length; i++) {
				for (let p = 0; p < data.length; p++) {
					if (itemIds[i] === data[p].itemid) {
						data.splice(p, 1);
						break;
					}
				}
			}
			this.setJson(key, data);
		}
	},
	isExist: function(key, itemId) { //检测某条数据在队列中是否存在
		let data = this.getJson(key);
		if (data instanceof Array) {
			for (let p = 0; p < data.length; p++) {
				if (itemId === data[p].itemid) {
					return true;
				}
			}
		}
		return false;
	},
	isExistPdd: function(key, itemId) { //检测某条数据在队列中是否存在
		let data = this.getJson(key);
		if (data instanceof Array) {
			for (let p = 0; p < data.length; p++) {
				if (itemId === data[p].goodsId) {
					return true;
				}
			}
		}
		return false;
	},
	isExistJd: function(key, itemId) { //检测某条数据在队列中是否存在
		let data = this.getJson(key);
		if (data instanceof Array) {
			for (let p = 0; p < data.length; p++) {
				if (itemId === data[p].skuId) {
					return true;
				}
			}
		}
		return false;
	},
	remove: function(key) { //删除某条队列
		try {
			uni.removeStorageSync(key);
			//localStorage.removeItem(key)
		} catch (e) {
			// error
		}
	},
	getCount: function(key) { //获取队列中全部数据数量

		let data = this.getJson(key);
		if (data instanceof Array) {
			return data.length;
		}
		return 0;
	},
	uploadFile: function(path, callback) {
		const host = getHost('APIHOST1')
		const uploadTask = uni.uploadFile({ // 上传接口
			url: host + '/alioss/upload', //真实的接口地址
			filePath: path,
			name: 'file',
			success: (uploadFileRes) => {
				let content = JSON.parse(uploadFileRes.data).data;
				uni.hideLoading();
				callback(content)
			},
			fail: (err) => {
				callback(false)
				console.log(err)
			}
		});
		uploadTask.onProgressUpdate((res) => {
			uni.showLoading({
				title: '上传进度' + res.progress + '%',
			})
			if (res.progress >= 100) {
				uni.hideLoading()
			}
		})
	},
	/**
	 * 上传文件
	 * @param {Object} params 参数
	 *  url：服务器地址
	 *  path：文件本地地址
	 *  name：文件名称
	 *  formData：上传参数
	 * @param {Object} callback
	 */
	uploadFiles: function(params, callback) {
		let url = params.url ? params.url : ''
		let filePath = params.path ? params.path : ''
		let name = params.name ? params.name : ''
		let formData = params.data ? params.data : {}
		const host = getHost('APIHOST')
		const uploadTask = uni.uploadFile({ // 上传接口
			url: `${host}${url}`, //真实的接口地址
			filePath,
			name,
			formData,
			header: {
				token: uni.getStorageSync('token')
			},
			timeout: params?.timeout ? params.timeout : 60000,
			success: (uploadFileRes) => {
				let content = JSON.parse(uploadFileRes.data)
				uni.hideLoading();
				callback(content)
			},
			fail: (err) => {
				callback(false)
				console.log(err)
			}
		});
		if (params?.hideUploadTask) {
			return
		}
		uploadTask.onProgressUpdate((res) => {
			uni.showLoading({
				title: '上传进度' + res.progress + '%',
			})
			if (res.progress >= 100) {
				uni.hideLoading()
			}
		})
	},
	array_column: function(arr, column_key, index_key = null) {
		if (index_key === null) {
			return arr.map(item => item[column_key]);
		}

		return arr.reduce((result, item) => {
			result[item[index_key]] = item[column_key];
			return result;
		}, {});
	},
	isCurrentMonth: function(date) {
		const now = new Date();
		return now.getFullYear() === date.getFullYear() &&
			now.getMonth() === date.getMonth();
	},
	getHighestEducation: function(educations) {
		// 定义学历等级映射（从低到高）
		const educationLevels = {
			'小学': 1,
			'初中': 2,
			'高中': 3,
			'中专': 4,
			'大专': 5,
			'本科': 6,
			'硕士': 7,
			'博士': 8,
			'博士后': 9
		};

		let highestEducation = null;
		let highestLevel = -1;

		educations.forEach(edu => {
			const level = educationLevels[edu.degree] || 0;
			if (level > highestLevel) {
				highestLevel = level;
				highestEducation = edu.degree;
			}
		});

		return highestEducation;
	},

	//职业状态
	resumesStatus() {

		return [{
				value: '0',
				text: '离职-随时到岗',
				recommended: true
			},
			{
				value: '1',
				text: '在职-月内到岗',
				recommended: true
			},
			{
				value: '2',
				text: '在职-考虑机会',
				recommended: false
			},
			{
				value: '3',
				text: '在职-暂不考虑',
				recommended: false
			},
			{
				value: '4',
				text: '实习',
				recommended: false
			}
		]
	},

	appConfirm: function(content = '请确认您的操作？', callback, title = '操作提示', button = ["继续", "取消"]) {
		// #ifndef APP-PLUS 
		uni.showModal({
			title: title,
			content: content,
			success: function(res) {
				if (res.confirm) {
					callback(true)
				} else
					callback(false)
			}
		});
		return
		//#endif
		// #ifdef APP-PLUS 
		plus.nativeUI.confirm(content, function(e) {
			if (e.index == 0)
				callback(true)
			else
				callback(false)
		}, title, button);
		//#endif
	},
	isDateExpired: function(targetDate) {
		const currentTimestamp = new Date().getTime();
		const targetTimestamp = new Date(targetDate).getTime();
		const rest = targetTimestamp < currentTimestamp
		if (rest)
			return [true, 0]
		// 计算毫秒差
		const diffInMs = targetTimestamp - currentTimestamp;

		// 转换为小时（向上取整确保显示完整小时）
		const hours = Math.ceil(diffInMs / (1000 * 60 * 60));

		return [rest, hours > 0 ? hours : 0]; // 返回非负值
	},
	convert12to24: function(time12h) {
		// 使用正则表达式匹配12小时制格式
		const regex = /^(0?[1-9]|1[0-2]):([0-5]\d)\s?(AM|PM)$/i;
		const match = time12h.match(regex);

		if (!match) {
			throw new Error('无效的时间格式，请使用如 "2:00 PM" 或 "02:00 PM" 的格式');
		}

		let hour = parseInt(match[1], 10);
		const minute = match[2];
		const period = match[3].toUpperCase();

		// 处理AM/PM转换逻辑
		if (period === 'PM' && hour !== 12) {
			hour += 12;
		} else if (period === 'AM' && hour === 12) {
			hour = 0;
		}

		// 格式化为两位数
		const hour24 = hour.toString().padStart(2, '0');

		return `${hour24}:${minute}`;
	},
	changeTabbar: function(res) {
		setTimeout(() => {
			if (res == 1) {
				uni.setTabBarItem({
					index: 0,
					text: '首页',
					iconPath: "/static/tabbar/Home.png",
					selectedIconPath: "/static/tabbar/Iconly_Bold_Home.png",
				})
				uni.setTabBarItem({
					index: 1,
					text: '急聘',
					pagePath: "/pages/index/game/gameList",
					iconPath: "/static/tabbar/jipin.png",
					selectedIconPath: "/static/tabbar/ACjipin.png",
				})
			} else {
				uni.setTabBarItem({
					index: 0,
					text: '牛人',
					iconPath: "/static/tabbar/niu.png",
					selectedIconPath: "/static/tabbar/niu2.png",
				})
				uni.setTabBarItem({
					index: 1,
					pagePath: "/pages/talentSearch/index",
					iconPath: "/static/tabbar/Hrsearch.png",
					selectedIconPath: "/static/tabbar/ACsearch.png",
					text: "搜索"
				})
			}
			// 可以在这里添加 tabbar 更新后的后续操作
			console.log('tabbar 更新完成');
		}, 100);
	},
	// 核心年龄计算函数
	calculateAgeFromBirthday: function(birthday) {
		const birthDate = new Date(birthday);
		const currentDate = new Date();

		// 验证日期有效性
		if (isNaN(birthDate.getTime())) {
			throw new Error('无效的生日日期');
		}

		if (birthDate > currentDate) {
			throw new Error('生日日期不能晚于当前日期');
		}

		let years = currentDate.getFullYear() - birthDate.getFullYear();
		let months = currentDate.getMonth() - birthDate.getMonth();
		let days = currentDate.getDate() - birthDate.getDate();

		// 处理天数负数情况
		if (days < 0) {
			months--;
			// 获取上个月的天数
			const lastMonth = new Date(currentDate.getFullYear(), currentDate.getMonth(), 0);
			days += lastMonth.getDate();
		}

		// 处理月份负数情况
		if (months < 0) {
			years--;
			months += 12;
		}

		return years;
	},
	// 筛选求职列表
	getFilterData: function(key = 'filter') {
		const condition = {
			education: '', //学历
			experience: '', //经验
			industry: '', //行业
			salaryRange: '', //薪资
			companyPeople: '' //公司规模
		}
		//获取选中的筛选条件
		if (uni.getStorageSync(key) && (uni.getStorageSync(key)).length > 0) {
			let filter = uni.getStorageSync(key)
			filter.map(item => {
				let arr = []
				item.list.map(ite => {
					if (ite.value != '不限') {
						arr.push(ite.value)
					}
				})
				switch (item.name) {
					case '学历要求':
						condition.education = arr.join(',')
						break;
					case '薪资范围（单选）':
						condition.salaryRange = arr.join(',')
						break;
					case '经验要求':
						condition.experience = arr.join(',')
						break;
					case '公司规模':
						condition.companyPeople = arr.join(',')
						break;
					case '行业':
						condition.industry = arr.join(',')
						break;
				}

			})
			// console.log(filter)
		}
		return condition
	},
	//APP获取手机权限鉴权
	// APP获取手机权限鉴权（优化版，兼容全权限+多系统）

	async checkPermission(permission, tip, that, perpop = 'permission') {
		// 权限映射配置
		let permisionID = '';
		let permisionIosID = '';

		return new Promise(async (resolve) => {
			// #ifdef H5
			resolve(true);
			return;
			// #endif

			const appAuthorizeSetting = uni.getAppAuthorizeSetting()
			if (permission == 'location') {
				permisionID = 'android.permission.ACCESS_FINE_LOCATION';
				permisionIosID = 'location';
				if (appAuthorizeSetting.locationAuthorized == 'authorized') {
					resolve(true);
					return
				}
			}
			if (permission == 'camera') {
				permisionID = 'android.permission.CAMERA,android.permission.READ_EXTERNAL_STORAGE';
				permisionIosID = 'camera,photoLibrary';
				if (appAuthorizeSetting.cameraAuthorized == 'authorized') {
					resolve(true);
					return
				}
			}
			if (permission == 'microphone') {
				permisionID = 'android.permission.RECORD_AUDIO';
				permisionIosID = 'record';
				if (appAuthorizeSetting.microphoneAuthorized == 'authorized') {
					resolve(true);
					return
				}
			}

			// 特殊处理：相机权限在非iOS平台显示自定义弹窗
			if (uni.getSystemInfoSync().platform != 'ios') {
				switch (perpop) {
					case 'permission':
						that.$refs.permission.open();
						break
					case 'microphonePermission':
						that.$refs.microphonePermission.open();
						break
					case 'locationPermission':
						that.$refs.locationPermission.open();
						break
					default:
						console.warn('未知权限类型:', perpop);
				}

			}
			// Android 平台处理
			if (uni.getSystemInfoSync().platform === 'android') {
				if (permisionID == '') {
					resolve(true);
					return;
				}

				try {
					const result = await permision.requestAndroidPermission(permisionID);
					console.log(result);
					switch (perpop) {
						case 'permission':
							that.$refs.permission.close();
							break
						case 'microphonePermission':
							that.$refs.microphonePermission.close();
							break
						case 'locationPermission':
							that.$refs.locationPermission.close();
							break
						default:
							console.warn('未知权限类型:', perpop);
					}
					if (result == 1) {
						console.log("已获得授权");
						resolve(true);
					} else if (result == 0) {
						console.log("未获得授权");
						resolve(false);
					} else {
						console.log("权限被拒绝");
						// 显示确认对话框
						this.appConfirm("权限被拒绝，" + tip, function(res) {
							if (res) {
								uni.openAppAuthorizeSetting();
							}
							resolve(false);
						});
					}
				} catch (error) {
					console.error("权限请求失败:", error);
					resolve(false);
				}
			}
			// iOS 平台处理
			else {
				if (permisionIosID == '') {
					resolve(true);
					return;
				}

				const iosPermissions = permisionIosID.split(',');
				let allGranted = 0;

				for (let i = 0; i < iosPermissions.length; i++) {
					const currentPermission = iosPermissions[i];
					allGranted = permision.judgeIosPermission(currentPermission);
					console.log('权限状态码：', allGranted)
				}
				if (allGranted == 0) {
					console.log('第一次授权')
					resolve(true);
				} else if (allGranted == 3) {
					console.log('已授权')
					resolve(true);
				} else {
					this.appConfirm("权限被拒绝，" + tip, function(res) {
						if (res) {
							uni.openAppAuthorizeSetting();
						}
						resolve(false);
					});
				}
			}
		});
	},
	appShare(scene, that) {
		uni.share({
			provider: "weixin", //分享服务提供商（即weixin|qq|sinaweibo）
			scene: scene, //场景，可取值参考下面说明。
			type: 0, //分享形式 0:图文 1:纯文字 2:纯图片 3:音乐 4:视频 5:小程序
			summary: '亿职赞APP新上线，欢迎前来体验',
			href: configdata.h5Url + '/pages/index/download',
			imageUrl: configdata.h5Url + '/40x40.png',
			success: function(res) {
				that.shows = false; //成功后关闭底部弹框
			},
			fail: (err) => {
				this.showToast('分享失败')
				that.shows = false;
			}
		});
	},
	connectSocket() {
		let that = this
		let userId = this.getData('userId');
		const wsHost = getHost('WSHOST1')
		if (!userId)
			return;
		uni.closeSocket()
		uni.connectSocket({
			url: wsHost + '' + userId,
			data() {
				return {
					msg: 'Hello'
				}
			},
			header: {
				'content-type': 'application/json'
			},
			method: 'GET',
			success(res) {
				// 这里是接口调用成功的回调，不是连接成功的回调，请注意
				console.log('连接成功', res)
				that.onSocketMsg();
			},
			fail(err) {
				console.log('连接失败', res)
				// 这里是接口调用失败的回调，不是连接失败的回调，请注意
			}
		})
	},
	onSocketMsg() {
		let that = this
		uni.onSocketMessage((res) => {
			if (res.data === 'HeartBeat') return // 忽略心跳包
			let msg
			try {
				msg = JSON.parse(res.data)
			} catch (e) {
				// console.log('消息不是JSON格式:', res.data)
				return
			}
			if (msg.type === 'kickOut') {
				uni.showModal({
					title: '提示',
					content: msg.content,
					showCancel: false,
					success() {
						that.logout();
						// #ifdef H5	
						uni.reLaunch({
							url: '/pages/public/loginphone?type=1'
						})
						// #endif
						// #ifndef H5
						uni.reLaunch({
							url: '/pages/public/loginV2'
						})
						// #endif
					}
				})
			}
		})
	},
	sendImMessage(userId, content, messageType, chatConversationId, recordId) {
		let data = {
			userId,
			content,
			messageType,
			chatConversationId
		}
		if (recordId) {
			data = {
				...data,
				recordId
			}
		}
		data = JSON.stringify(data);
		return new Promise(async (resolve, reject) => {
			uni.sendSocketMessage({
				data: data,
				success(res) {
					resolve(res)
				},
				fail(err) {
					reject(err);
				}
			})
		})
	},

	/**
	 * 深合并两个对象：将前一个对象的数据合并到后一个对象（支持嵌套对象）
	 * @param {Object} sourceObj - 源对象（提供数据的对象，前一个对象）
	 * @param {Object} targetObj - 目标对象（被合并的对象，后一个对象）
	 * @returns {Object} 合并后的目标对象
	 */
	deepMergeObject(sourceObj, targetObj) {
		// 1. 参数校验
		const isValidObj = (obj) => obj !== null && typeof obj === 'object' && !Array.isArray(obj);
		if (!isValidObj(sourceObj)) return isValidObj(targetObj) ? targetObj : {};
		if (!isValidObj(targetObj)) return JSON.parse(JSON.stringify(sourceObj)); // 简单深拷贝源对象

		// 2. 遍历源对象属性
		Object.keys(sourceObj).forEach((key) => {
			const sourceValue = sourceObj[key];
			const targetValue = targetObj[key];

			// 3. 处理嵌套对象（递归合并）
			if (isValidObj(sourceValue) && isValidObj(targetValue)) {
				deepMergeObject(sourceValue, targetValue); // 递归处理嵌套对象
				return; // 嵌套对象处理完毕，跳过后续逻辑
			}

			// 4. 非嵌套对象，按照原规则处理
			if (!(key in targetObj) || targetValue === null || targetValue === undefined) {
				targetObj[key] = sourceValue;
			}
		});

		return targetObj;
	}
};