// pages/home/home.js
|
const storage = require('../../utils/storage.js');
|
const {
|
get,
|
post
|
} = require('../../api/request.js');
|
const config = require('../../api/config.js');
|
const {
|
PROJECT_CONFIG
|
} = require('../../utils/projectConfig.js');
|
const {
|
ENV
|
} = require('../../api/env.js');
|
|
Page({
|
|
/**
|
* 页面的初始数据
|
*/
|
data: {
|
sessionId: "",
|
showConfirm: false,
|
myItem: {},
|
waterIntakeName: "",
|
image: "/images/ic_head_bg.jpg",
|
userPhone: "",
|
userName: "请点击登录",
|
scrollViewHeight: 0,
|
listData: [],
|
isRefreshing: false,
|
isWXRefreshing: false,
|
errorData: '', //错误内容
|
showErrorDialog: false,
|
confirmBtn: {
|
content: '确认'
|
},
|
errorDialogTitle: "关阀错误",
|
showForceConfirm: false, //是否强制开阀
|
lastIntakeName: "",
|
showProjectDialog: false,
|
selectedProject: '',
|
avatarTapCount: 0,
|
isFromLogin: false,
|
showTipDialog: '',
|
projectConfig: PROJECT_CONFIG, // 添加项目配置到data中
|
showInfoDialog: false,
|
projectList: []
|
},
|
|
openValve: function (e) {
|
const app = getApp();
|
if (app.globalData.isLoggedIn) {
|
wx.navigateTo({
|
url: '/pages/waterIntake/waterIntake',
|
})
|
} else {
|
wx.showToast({
|
title: '请先登录',
|
icon: 'error'
|
})
|
}
|
},
|
// calculateScrollViewHeight: function () {
|
// wx.createSelectorQuery().selectAll('.list-item').boundingClientRect((rects) => {
|
// let totalHeight = rects.reduce((sum, rect) => sum + rect.height, 0);
|
// this.setData({
|
// scrollViewHeight: totalHeight,
|
// });
|
// }).exec();
|
// },
|
startPullDownRefresh() {
|
if (getApp().globalData.isLoggedIn) {
|
if (!this.data.isWXRefreshing) {
|
var self = this;
|
console.log(this.data.isRefreshing);
|
this.setData({
|
isRefreshing: true
|
});
|
this.getOpenList();
|
}
|
} else {
|
wx.showToast({
|
title: '请先登录',
|
icon: 'error'
|
})
|
}
|
|
|
},
|
|
|
|
/**
|
* 生命周期函数--监听页面加载
|
*/
|
onLoad(options) {
|
console.log('home页面onLoad开始，参数:', options);
|
|
// 初始化项目列表数据
|
this.initProjectList();
|
|
//当开阀成功后调用刷新
|
if (options.param === "1" || options.param === "2") {
|
this.setData({
|
options: options
|
})
|
}
|
// 检查是否从登录页面返回
|
let fromLogin = false;
|
|
// 检查URL参数
|
if (options && options.fromLogin === 'true') {
|
console.log('检测到URL参数fromLogin=true');
|
fromLogin = true;
|
}
|
|
console.log('home页面加载，fromLogin:', fromLogin, '参数:', options);
|
|
// 设置fromLogin标志
|
if (fromLogin) {
|
console.log('设置isFromLogin=true');
|
this.setData({
|
isFromLogin: true
|
});
|
}
|
|
// 延迟执行剩余的初始化过程，以确保临时标记和URL参数能被正确处理
|
setTimeout(() => {
|
this.initializePage(options, fromLogin);
|
}, 100);
|
},
|
|
// 初始化项目列表数据
|
initProjectList() {
|
// 将PROJECT_CONFIG对象转换为数组，方便在视图中遍历
|
const projectList = Object.entries(PROJECT_CONFIG).map(([key, config]) => ({
|
key: key, // 使用key作为项目标识(JYG、MQ等)
|
tag: config.tag, // 保留tag字段（原配置中已有的标识，如ym、mq等）
|
displayName: config.displayName, // 显示名称
|
...config // 其他配置属性
|
}));
|
|
// 获取当前已选择的项目，默认为JYG
|
let currentSelectedProject = 'JYG';
|
|
// 尝试从全局变量获取
|
const app = getApp();
|
if (app && app.globalData && app.globalData.selectedProject) {
|
currentSelectedProject = app.globalData.selectedProject;
|
} else {
|
// 尝试从本地存储获取
|
try {
|
const savedProject = wx.getStorageSync('selectedProject');
|
if (savedProject) {
|
currentSelectedProject = savedProject;
|
}
|
} catch (e) {
|
console.error('从本地存储获取项目失败:', e);
|
}
|
}
|
|
// 设置到页面数据中
|
this.setData({
|
projectList,
|
selectedProject: currentSelectedProject
|
});
|
|
console.log('项目列表已初始化:', projectList, '当前选中项目:', currentSelectedProject);
|
},
|
|
// 新增的初始化页面辅助函数，分离出onLoad中的逻辑以便延迟执行
|
initializePage(options, fromLogin) {
|
// 检查是否已选择项目
|
const {
|
PROJECT_URLS
|
} = require('../../api/config.js');
|
|
// 确保全局变量存在
|
getApp().globalData = getApp().globalData || {};
|
|
storage.getItemSafe('selectedProject')
|
.then((project) => {
|
if (project) {
|
this.setData({
|
selectedProject: project
|
});
|
|
// 设置 baseUrl
|
const serverUrl = PROJECT_CONFIG[project]?.serverUrl;
|
if (serverUrl) {
|
getApp().globalData.baseUrl = serverUrl;
|
getApp().globalData.selectedProject = project;
|
console.log('设置baseUrl:', serverUrl);
|
}
|
|
// 根据项目设置对应的tag
|
const projectConfig = PROJECT_CONFIG[project];
|
if (projectConfig) {
|
getApp().globalData.tag = projectConfig.tag;
|
|
// 根据项目是否需要登录，设置不同的userName
|
if (projectConfig.needLogin === false) {
|
// 不需要登录的项目，显示项目名称
|
this.setData({
|
userName: projectConfig.displayName
|
});
|
} else {
|
// 需要登录的项目，显示"请点击登录"
|
this.setData({
|
userName: "请点击登录"
|
});
|
}
|
}
|
|
// 根据项目设置对应的operator和clientId
|
if (projectConfig && projectConfig.operatorId) {
|
getApp().globalData.operator = projectConfig.operatorId;
|
getApp().globalData.clientId = projectConfig.operatorId;
|
getApp().globalData.isLoggedIn = true;
|
getApp().globalData.sessionId = projectConfig.operatorId;
|
|
// 如果有vcId，也设置
|
if (projectConfig.vcId) {
|
getApp().globalData.vcId = projectConfig.vcId;
|
}
|
|
// 持久化存储项目参数
|
const params = {
|
operator: projectConfig.operatorId,
|
clientId: projectConfig.operatorId,
|
isLoggedIn: true,
|
sessionId: projectConfig.operatorId
|
};
|
|
if (projectConfig.vcId) {
|
params.vcId = projectConfig.vcId;
|
}
|
|
storage.setItem(`${project}_params`, params);
|
}
|
|
// 继续初始化页面
|
this.continueInitPage(options);
|
} else {
|
// 首次进入，显示项目选择弹窗
|
this.setData({
|
showProjectDialog: true
|
});
|
return Promise.reject({
|
type: 'project_not_selected',
|
message: '未选择项目'
|
}); // 终止后续处理
|
}
|
})
|
.then(() => {
|
// 继续初始化页面
|
this.continueInitPage(options);
|
})
|
.catch(err => {
|
// 将错误对象规范化
|
const error = typeof err === 'object' ? err : {
|
type: 'unknown',
|
message: String(err)
|
};
|
console.log('获取存储数据中断:', error.message);
|
|
// 如果是从登录页返回或已登录，不再跳转
|
if (fromLogin) {
|
console.log('从登录页返回或已登录，继续初始化页面');
|
this.continueInitPage(options);
|
return;
|
}
|
|
// 处理未选择项目的情况
|
if (error.type === 'project_not_selected') {
|
console.log('未选择项目，显示项目选择弹窗');
|
this.setData({
|
showProjectDialog: true
|
});
|
return;
|
}
|
|
// 其他未知错误，尝试继续初始化页面
|
console.warn('未知错误，尝试继续初始化页面:', error);
|
this.continueInitPage(options);
|
});
|
},
|
|
/**
|
* 生命周期函数--监听页面初次渲染完成
|
*/
|
onReady() {
|
// 检查是否有options和param
|
if (this.data.options && this.data.options.param) {
|
if (this.data.options.param === "1" || this.data.options.param === "2") {
|
this.getOpenList();
|
}
|
}
|
},
|
|
/**
|
* 生命周期函数--监听页面显示
|
*/
|
onShow() {
|
console.log('home页面onShow开始');
|
|
// 获取当前页面的参数
|
const pages = getCurrentPages();
|
const currentPage = pages[pages.length - 1];
|
|
let fromLogin = false;
|
|
// 检查是否有fromLogin参数
|
if (currentPage && currentPage.options && currentPage.options.fromLogin === 'true') {
|
console.log('onShow: 检测到fromLogin参数，设置isFromLogin标记');
|
fromLogin = true;
|
this.setData({
|
isFromLogin: true
|
});
|
}
|
|
// 初始化处理
|
if (fromLogin || this.data.isFromLogin) {
|
console.log('onShow: 从登录页返回，不进行登录检查');
|
} else {
|
console.log('onShow: 正常显示页面');
|
// 延迟检查登录状态，确保能正确识别临时标记
|
setTimeout(() => {
|
this.checkLoginStatusIfNeeded();
|
}, 300);
|
}
|
},
|
|
// 检查登录状态（仅在需要时）
|
checkLoginStatusIfNeeded() {
|
// 再次确认是否从登录页返回
|
if (this.getFromLogin()) {
|
console.log('检测到从登录页返回的标记，不进行登录检查');
|
return;
|
}
|
|
console.log('执行登录状态检查');
|
this.checkLoginStatus();
|
},
|
|
/**
|
* 生命周期函数--监听页面隐藏
|
*/
|
onHide() {
|
// 页面隐藏时考虑清理临时标记
|
this.cleanupTempMarkers();
|
},
|
|
/**
|
* 生命周期函数--监听页面卸载
|
*/
|
onUnload() {
|
// 页面卸载时清理临时标记
|
this.cleanupTempMarkers();
|
},
|
|
/**
|
* 页面相关事件处理函数--监听用户下拉动作
|
*/
|
onPullDownRefresh() {
|
// 下拉刷新触发的逻辑，可以是请求数据等操作
|
// 例如，请求数据后更新页面内容
|
console.log(this.data.isRefreshing);
|
this.setData({
|
isWXRefreshing: true
|
});
|
console.log(this.data.isRefreshing);
|
// 数据请求完成后，停止下拉刷新的动画
|
this.getOpenList();
|
},
|
|
/**
|
* 页面上拉触底事件的处理函数
|
*/
|
onReachBottom() {
|
|
},
|
|
/**
|
* 用户点击右上角分享
|
*/
|
onShareAppMessage() {
|
|
},
|
recharge() {
|
// wx.navigateTo({
|
// url: '/pages/rechargeCard/rechargeCard',
|
// })
|
wx.showToast({
|
title: '暂未开放',
|
icon: 'none'
|
})
|
},
|
openValveList() {
|
const app = getApp();
|
if (app.globalData.isLoggedIn) {
|
wx.navigateTo({
|
url: '/pages/valveList/valveList',
|
})
|
} else {
|
wx.showToast({
|
title: '请先登录',
|
icon: 'error'
|
})
|
}
|
},
|
feedBack() {
|
wx.showToast({
|
title: '暂未开放',
|
icon: 'none'
|
})
|
},
|
//解绑用户
|
unbind() {
|
// 检查当前项目是否需要登录
|
const currentProject = getApp().globalData.selectedProject;
|
const projectConfig = PROJECT_CONFIG[currentProject];
|
|
// 如果当前项目配置为不需要登录，则提示用户并打开项目选择弹窗
|
if (projectConfig && !projectConfig.needLogin) {
|
wx.showModal({
|
title: '切换项目',
|
content: '是否确定解绑？',
|
confirmText: '确认',
|
cancelText: '取消',
|
success: (res) => {
|
if (res.confirm) {
|
// 显示项目选择弹窗
|
this.setData({
|
showProjectDialog: true
|
});
|
}
|
}
|
});
|
return;
|
}
|
|
// 如果已登录，显示解绑确认对话框
|
if (getApp().globalData.isLoggedIn) {
|
wx.showModal({
|
title: '解绑确认',
|
content: '确定要解绑当前账号吗？解绑后将无法使用相关功能，需重新绑定。',
|
confirmText: '确认解绑',
|
confirmColor: '#e34d59',
|
cancelText: '取消',
|
success: (res) => {
|
if (res.confirm) {
|
this.unBindPost();
|
}
|
}
|
});
|
} else {
|
wx.showToast({
|
title: '还未绑定',
|
icon: 'error'
|
});
|
}
|
},
|
//轮灌
|
irrigation() {
|
if (getApp().globalData.isLoggedIn) {
|
wx.navigateTo({
|
url: '/pages/irrigation/irrigation',
|
})
|
} else {
|
wx.showToast({
|
title: '请先登录',
|
icon: 'error'
|
})
|
}
|
},
|
handleChange(e) {
|
const item = e.currentTarget.dataset.item;
|
console.log(item);
|
this.setData({
|
showConfirm: true,
|
waterIntakeName: item.intakeNum,
|
myItem: item
|
});
|
},
|
closeDialog() {
|
console.log("closeDialog");
|
this.setData({
|
showConfirm: false,
|
showErrorDialog: false,
|
showForceConfirm: false
|
});
|
},
|
cancelDialog() {
|
this.setData({
|
showForceConfirm: false,
|
showConfirm: false
|
});
|
},
|
/**
|
* 关闭阀门
|
* @param {*} orderNo 订单号
|
* @param {*} rtuAddr 阀控器地址
|
* @param {*} vcNum 虚拟卡编号
|
*/
|
postCloseValaue(orderNo, rtuAddr, vcNum) {
|
wx.showLoading({
|
title: '正在关阀请稍候...', // 加载提示文字
|
mask: true // 是否显示透明蒙层，防止触摸穿透，默认为 false
|
});
|
const app = getApp();
|
const data = {
|
rtuAddr: rtuAddr,
|
vcNum: vcNum, //虚拟卡ID
|
orderNo: orderNo,
|
operator: app.globalData.clientId //操作员
|
};
|
console.log("postCloseValaue" + data);
|
post({
|
url: "wx/valve/close_wx",
|
data: data,
|
isShowLoding: false,
|
timeout: 185000
|
}).then(response => {
|
|
// 处理成功响应
|
console.log('请求成功:', response);
|
// 加载完成后隐藏加载动画
|
wx.hideLoading();
|
this.getOpenList();
|
wx.showToast({
|
title: '关阀成功',
|
icon: 'success',
|
duration: 3000
|
})
|
}).catch(error => {
|
wx.hideLoading();
|
// 处理错误响应
|
console.error('请求失败:', error);
|
if (error.code === "ECONNABORTED" || error.message?.includes('timeout')) {
|
// 处理超时错误
|
this.setData({
|
showErrorDialog: true,
|
errorData: "通信超时，请稍后再试",
|
errorDialogTitle: "关阀错误"
|
})
|
} else {
|
this.setData({
|
showErrorDialog: true,
|
errorData: error.msg,
|
errorDialogTitle: "关阀错误"
|
})
|
}
|
});
|
},
|
/**
|
* 获取为关阀记录
|
*/
|
getOpenList() {
|
const app = getApp();
|
if (!getApp().globalData.isLoggedIn) {
|
wx.showToast({
|
title: '请先登录',
|
icon: 'error'
|
})
|
this.setData({
|
isRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
|
isWXRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
|
});
|
return;
|
}
|
// 检查是否从登录页返回
|
const fromLogin = this.getFromLogin();
|
|
// 检查clientId是否存在
|
if (!app.globalData.clientId) {
|
console.log('getOpenList: clientId不存在，不执行API请求');
|
|
// 如果是从登录页返回，就显示空列表而不是错误提示
|
this.setData({
|
listData: [],
|
isRefreshing: false,
|
isWXRefreshing: false
|
});
|
|
// 如果不是从登录页返回且不处于刷新状态，考虑检查登录状态
|
if (!fromLogin && !this.data.isRefreshing && !this.data.isWXRefreshing) {
|
console.log('getOpenList: 非刷新状态下检测到无clientId，尝试自动登录');
|
// 延迟调用微信登录，尝试自动恢复会话
|
setTimeout(() => {
|
if (!getApp().globalData.clientId && !this.getFromLogin()) {
|
this.wxLogin();
|
}
|
}, 1000);
|
}
|
return;
|
}
|
|
console.log('getOpenList: 开始获取列表数据, clientId:', app.globalData.clientId);
|
|
const params = {
|
url: 'wx/valve/get',
|
data: {
|
operator: app.globalData.clientId
|
}
|
};
|
|
get(params).then(data => {
|
console.log('获取列表数据成功:', data);
|
this.setData({
|
listData: data.content,
|
isRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
|
isWXRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
|
});
|
this.updateDisplayText();
|
|
}).catch(err => {
|
console.error('获取列表数据失败:', err);
|
// 错误回调
|
this.setData({
|
isRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
|
isWXRefreshing: false, // 将triggered属性设置为false，表示下拉刷新已完成
|
});
|
|
// 检查错误类型
|
if (err && err.code === '0003') {
|
console.log('会话无效或过期，但不进行跳转');
|
|
// 如果不是从登录页返回，显示错误提示
|
if (!fromLogin) {
|
wx.showToast({
|
title: '登录已过期，请刷新重试',
|
icon: 'none',
|
duration: 3000
|
});
|
}
|
} else {
|
// 一般错误，显示错误信息
|
wx.showToast({
|
title: err.msg || '获取列表数据失败',
|
icon: 'none',
|
duration: 3000
|
});
|
}
|
});
|
},
|
/**
|
* 确认关闭回调
|
* @param {} item
|
*/
|
confirmDialog() {
|
this.setData({
|
showConfirm: false
|
});
|
this.postCloseValaue(this.data.myItem.orderNo, this.data.myItem.rtuAddr, this.data.myItem.vcNum);
|
},
|
//根据session获取农户信息
|
getUserDataBySession() {
|
// 先检查是否从登录页返回
|
if (this.getFromLogin()) {
|
console.log('getUserDataBySession: 检测到从登录页返回的标记，不执行API请求');
|
return;
|
}
|
|
const app = getApp();
|
|
// 检查是否有sessionId
|
if (!app.globalData.sessionId) {
|
console.log('getUserDataBySession: sessionId不存在，不执行API请求');
|
return;
|
}
|
|
console.log('getUserDataBySession: 开始获取用户数据, sessionId:', app.globalData.sessionId);
|
|
const params = {
|
url: 'wx/client/simple_info',
|
data: {
|
sessionId: app.globalData.sessionId
|
}
|
};
|
|
get(params).then(data => {
|
console.log('获取用户数据成功:', data);
|
this.setData({
|
userName: data.content.clientName,
|
userPhone: this.maskPhoneNumber(data.content.phone)
|
});
|
}).catch(err => {
|
console.error('获取用户数据失败:', err);
|
// 错误回调，但不进行页面跳转
|
|
// 检查错误类型
|
if (err && err.code === '0003') {
|
console.log('会话无效或过期，但不进行跳转');
|
// 不再直接跳转到登录页
|
|
// 清除会话信息
|
app.globalData.sessionId = '';
|
app.globalData.isLoggedIn = false;
|
|
// 如果不是从登录页返回，显示错误提示
|
if (!this.getFromLogin()) {
|
wx.showToast({
|
title: '登录已过期，请重新登录',
|
icon: 'none',
|
duration: 3000
|
});
|
}
|
}
|
});
|
},
|
maskPhoneNumber(phoneNumber) {
|
if (phoneNumber.length !== 11) {
|
throw new Error("Phone number must be 11 digits");
|
}
|
// 使用正则表达式替换中间四位数字为星号
|
const maskedPhoneNumber = phoneNumber.replace(/^(\d{3})\d{4}(\d{4})$/, "$1****$2");
|
return maskedPhoneNumber;
|
},
|
|
closeDialog() {
|
this.setData({
|
showErrorDialog: false
|
})
|
},
|
/**
|
* 扫码开阀
|
*/
|
scenCode() {
|
const that = this;
|
wx.scanCode({
|
success(res) {
|
console.log(res.result); // 当且仅当扫码为非微信二维码时，会返回result
|
if (res.result.startsWith("content://")) {
|
let jsonStr = res.result.replace("content://", "")
|
try {
|
|
that.saveData(jsonStr)
|
} catch (error) {
|
console.error('Error parsing JSON:', error);
|
}
|
|
} else {
|
that.postOppenValva(res.result)
|
}
|
|
},
|
fail(err) {
|
console.error(err);
|
}
|
})
|
},
|
confirmForceDialog() {
|
console.log("confirmForceDialog");
|
this.setData({
|
showForceConfirm: false
|
})
|
this.postOppenValva(this.data.lastIntakeName, true)
|
},
|
/**
|
*
|
* @param {*} intakeName
|
*/
|
postOppenValva(intakeName, isforce) {
|
const that = this;
|
wx.showLoading({
|
title: '正在开阀请稍候...', // 加载提示文字
|
mask: true // 是否显示透明蒙层，防止触摸穿透，默认为 false
|
});
|
const app = getApp();
|
that.setData({
|
lastIntakeName: intakeName
|
})
|
const data = {
|
intakeName: intakeName, //取水口ID
|
// vcId: vcId, //虚拟卡ID
|
operator: app.globalData.clientId, //操作员
|
forceOpen: !!isforce // 使用逻辑非操作符 !! 来确保 isForce 是布尔值
|
};
|
post({
|
url: "wx/valve/open_wx",
|
data: data,
|
timeout: 180000
|
}).then(response => {
|
|
// 处理成功响应
|
console.log('请求成功:', response);
|
// 加载完成后隐藏加载动画
|
wx.hideLoading();
|
//完成后回到首页
|
wx.reLaunch({
|
url: '/pages/home/home?param=true' // 首页的路径，根据实际情况填写
|
});
|
}).catch(error => {
|
// 加载完成后隐藏加载动画
|
wx.hideLoading();
|
// 处理错误响应
|
console.error('请求失败:', error);
|
if (error.code === "10005") {
|
that.setData({
|
showForceConfirm: true
|
})
|
} else {
|
that.setData({
|
showErrorDialog: true,
|
errorData: error.msg,
|
errorDialogTitle: "开阀错误"
|
})
|
}
|
});
|
},
|
/**
|
* 扫描后保存用户id和tag
|
*/
|
saveData(userData) {
|
storage.setItem("userData", userData).then(() => {
|
this.initData();
|
}).catch((error) => {});
|
|
},
|
//进入界面获取界面数据
|
initData() {
|
const app = getApp();
|
console.log("initData开始，tag:", app.globalData.tag);
|
|
// 首先检查是否从登录页返回
|
if (this.getFromLogin()) {
|
console.log('initData: 检测到从登录页返回的标记，仅获取基本数据');
|
|
// 即使从登录页返回，也尝试获取开阀列表以显示基本UI
|
// 但先检查是否有客户端ID可用
|
if (!app.globalData.clientId) {
|
console.log('initData: 从登录页返回且无clientId，尝试从存储恢复');
|
// 尝试从存储恢复clientId
|
storage.getItemSafe('clientId')
|
.then(clientId => {
|
if (clientId) {
|
console.log('initData: 从存储恢复clientId成功:', clientId);
|
app.globalData.clientId = clientId;
|
this.getOpenList();
|
} else {
|
console.log('initData: 无法恢复clientId，显示空列表');
|
this.setData({
|
listData: []
|
});
|
}
|
})
|
.catch(err => {
|
console.error('initData: 恢复clientId失败:', err);
|
this.setData({
|
listData: []
|
});
|
});
|
} else {
|
this.getOpenList();
|
}
|
return;
|
}
|
|
// 检查当前项目是否需要登录
|
const currentProject = app.globalData.selectedProject;
|
const projectConfig = PROJECT_CONFIG[currentProject];
|
const needLogin = projectConfig && projectConfig.needLogin;
|
|
// 根据项目是否需要登录，设置不同的userName
|
if (projectConfig && projectConfig.needLogin === false) {
|
// 不需要登录的项目，显示项目名称
|
this.setData({
|
userName: projectConfig.displayName
|
});
|
}
|
|
// 尝试获取用户数据和已开阀记录
|
try {
|
// 优先检查全局变量中是否有sessionId
|
if (app.globalData.sessionId) {
|
console.log('initData: 使用全局sessionId获取数据');
|
|
// 只有需要登录的项目才调用getUserDataBySession
|
if (needLogin) {
|
console.log('initData: 当前项目需要登录，获取用户数据');
|
this.getUserDataBySession();
|
} else {
|
console.log('initData: 当前项目不需要登录，跳过获取用户数据');
|
}
|
|
this.getOpenList();
|
return;
|
}
|
|
// 检查是否有存储的userData
|
const hasUserData = storage.isHasKeySync("userData");
|
console.log('initData: 是否存在userData:', hasUserData);
|
|
if (hasUserData) {
|
storage.getItemSafe('userData')
|
.then((data) => {
|
console.log('initData: 成功读取userData');
|
if (data) {
|
try {
|
let jsonObj = JSON.parse(data);
|
app.globalData.sessionId = jsonObj.sessionId;
|
app.globalData.tag = jsonObj.tag;
|
console.log("userData已加载:", data);
|
} catch (e) {
|
console.error('userData解析失败:', e);
|
}
|
}
|
|
// 只有需要登录的项目才调用getUserDataBySession
|
if (needLogin) {
|
console.log('initData: 当前项目需要登录，获取用户数据');
|
this.getUserDataBySession();
|
} else {
|
console.log('initData: 当前项目不需要登录，跳过获取用户数据');
|
}
|
|
this.getOpenList();
|
})
|
.catch((err) => {
|
console.error('加载userData失败:', err);
|
|
// 再次检查是否从登录页返回
|
if (this.getFromLogin()) {
|
console.log('initData:catch: 检测到从登录页返回的标记，只获取开阀列表');
|
this.getOpenList();
|
} else {
|
// 只有需要登录的项目才调用getUserDataBySession
|
if (needLogin) {
|
console.log('initData:catch: 当前项目需要登录，获取用户数据');
|
this.getUserDataBySession();
|
} else {
|
console.log('initData:catch: 当前项目不需要登录，跳过获取用户数据');
|
}
|
|
this.getOpenList();
|
}
|
});
|
} else {
|
console.log('未找到userData，直接获取数据');
|
|
// 再次检查是否从登录页返回
|
if (this.getFromLogin()) {
|
console.log('initData:else: 检测到从登录页返回的标记，只获取开阀列表');
|
this.getOpenList();
|
} else {
|
// 只有需要登录的项目才调用getUserDataBySession
|
if (needLogin) {
|
console.log('initData:else: 当前项目需要登录，获取用户数据');
|
this.getUserDataBySession();
|
} else {
|
console.log('initData:else: 当前项目不需要登录，跳过获取用户数据');
|
}
|
|
this.getOpenList();
|
}
|
}
|
} catch (e) {
|
console.error('initData执行出错:', e);
|
|
// 再次检查是否从登录页返回
|
if (this.getFromLogin()) {
|
console.log('initData:error: 检测到从登录页返回的标记，只获取开阀列表');
|
this.getOpenList();
|
} else {
|
// 只有需要登录的项目才调用getUserDataBySession
|
if (needLogin) {
|
console.log('initData:error: 当前项目需要登录，获取用户数据');
|
this.getUserDataBySession();
|
} else {
|
console.log('initData:error: 当前项目不需要登录，跳过获取用户数据');
|
}
|
|
this.getOpenList();
|
}
|
}
|
},
|
// 处理头像点击
|
handleAvatarTap() {
|
this.setData({
|
avatarTapCount: this.data.avatarTapCount + 1
|
});
|
|
if (this.data.avatarTapCount >= 5) {
|
this.setData({
|
showProjectDialog: true,
|
avatarTapCount: 0
|
});
|
}
|
},
|
|
// 处理弹窗可见性变化
|
onVisibleChange(e) {
|
// 如果尝试关闭弹窗且没有选择项目，则阻止关闭
|
if (!e.detail.visible && !this.data.selectedProject) {
|
return;
|
}
|
this.setData({
|
showProjectDialog: e.detail.visible
|
});
|
},
|
|
// 处理项目选择变化
|
onProjectChange(event) {
|
console.log('选择的项目：', event.detail.value);
|
this.setData({
|
selectedProject: event.detail.value
|
});
|
},
|
|
// 处理项目选择确认
|
handleProjectConfirm() {
|
console.log('开始处理项目选择确认', this.data.selectedProject, this.data.projectList);
|
|
if (!this.data.selectedProject) {
|
wx.showToast({
|
title: '请选择项目',
|
icon: 'none'
|
});
|
return;
|
}
|
|
// 获取当前已选项目和新选择的项目
|
const currentProject = getApp().globalData.selectedProject;
|
const newProject = this.data.selectedProject;
|
console.log('当前项目:', currentProject, '新选择项目:', newProject);
|
console.log('PROJECT_CONFIG 内容:', PROJECT_CONFIG);
|
|
const projectConfig = PROJECT_CONFIG[newProject];
|
console.log('选择的项目配置:', projectConfig);
|
|
if (!projectConfig) {
|
wx.showToast({
|
title: '项目配置错误',
|
icon: 'none'
|
});
|
return;
|
}
|
|
// 检查是否切换了项目（如果当前项目不同于新选择的项目）
|
const isProjectChanged = currentProject && currentProject !== newProject;
|
|
// 添加二次确认
|
const confirmText = isProjectChanged ?
|
`确定要将项目从"${PROJECT_CONFIG[currentProject]?.displayName || '当前项目'}"切换到"${projectConfig.displayName}"吗？` :
|
`确定选择"${projectConfig.displayName}"项目吗？`;
|
|
wx.showModal({
|
title: isProjectChanged ? '确认切换项目' : '确认选择项目',
|
content: confirmText,
|
confirmText: isProjectChanged ? '确认切换' : '确认',
|
cancelText: '取消',
|
success: (res) => {
|
if (res.confirm) {
|
// 用户确认选择，继续处理
|
this.processProjectSelection(currentProject, newProject, projectConfig, isProjectChanged);
|
} else {
|
// 用户取消，不进行任何操作
|
console.log('用户取消了项目选择');
|
}
|
}
|
});
|
},
|
|
// 处理项目选择的后续操作
|
processProjectSelection(currentProject, newProject, projectConfig, isProjectChanged) {
|
// 如果切换了项目，先清除登录状态
|
if (isProjectChanged) {
|
console.log(`正在从项目 ${currentProject} 切换到 ${newProject}，将清除登录状态`);
|
|
// 清除全局登录状态
|
getApp().globalData.sessionId = '';
|
getApp().globalData.clientId = '';
|
getApp().globalData.isLoggedIn = false;
|
getApp().globalData.userInfo = null;
|
getApp().globalData.vcId = '';
|
getApp().globalData.operator = '';
|
|
// 清除存储中的登录状态
|
try {
|
// 清除基本登录数据
|
wx.removeStorageSync('sessionId');
|
wx.removeStorageSync('clientId');
|
wx.removeStorageSync('userData');
|
wx.removeStorageSync('isLoggedIn');
|
|
// 清除之前项目的特定数据
|
if (currentProject) {
|
wx.removeStorageSync(`${currentProject}_params`);
|
}
|
|
// 清除其他可能的缓存数据
|
wx.removeStorageSync('_attempted_login_redirect');
|
|
console.log('已清除登录相关的存储数据');
|
} catch (e) {
|
console.error('清除存储数据失败:', e);
|
}
|
|
// 重置UI显示状态
|
if (projectConfig.needLogin === false) {
|
// 不需要登录的项目，显示项目名称作为userName
|
this.setData({
|
userName: projectConfig.displayName,
|
userPhone: "",
|
listData: []
|
});
|
} else {
|
// 需要登录的项目，显示"请点击登录"
|
this.setData({
|
userName: "请点击登录",
|
userPhone: "",
|
listData: []
|
});
|
}
|
}
|
|
// 保存项目选择到本地存储
|
storage.setItem('selectedProject', newProject).then(() => {
|
// 调用setBaseUrl来更新基础URL
|
try {
|
console.log('尝试设置基础URL，项目:', newProject);
|
const result = config.setBaseUrl(newProject);
|
console.log('设置基础URL结果:', result);
|
} catch (error) {
|
console.error('设置基础URL出错:', error);
|
// 继续执行，不中断流程
|
}
|
|
// 更新全局变量
|
getApp().globalData = getApp().globalData || {};
|
getApp().globalData.selectedProject = newProject;
|
getApp().globalData.baseUrl = projectConfig.serverUrl;
|
getApp().globalData.serverId = projectConfig.serverId;
|
|
// 通过配置对象统一设置项目参数
|
getApp().globalData.tag = projectConfig.tag;
|
|
// 对于不需要登录的项目，直接设置operator和clientId
|
if (!projectConfig.needLogin && projectConfig.operatorId) {
|
const operatorId = projectConfig.operatorId;
|
getApp().globalData.operator = operatorId;
|
getApp().globalData.clientId = operatorId;
|
getApp().globalData.isLoggedIn = true;
|
getApp().globalData.sessionId = operatorId;
|
|
// 如果有vcId，也设置
|
if (projectConfig.vcId) {
|
getApp().globalData.vcId = projectConfig.vcId;
|
}
|
|
// 持久化存储项目参数
|
const params = {
|
operator: operatorId,
|
clientId: operatorId,
|
isLoggedIn: true,
|
sessionId: operatorId
|
};
|
|
if (projectConfig.vcId) {
|
params.vcId = projectConfig.vcId;
|
}
|
|
storage.setItem(`${newProject}_params`, params);
|
}
|
|
console.log('已切换到项目:', projectConfig.displayName, '服务器:', projectConfig.serverId, 'tag:', getApp().globalData.tag);
|
|
this.setData({
|
showProjectDialog: false
|
});
|
|
// 显示切换成功提示
|
wx.showToast({
|
title: `已选择${projectConfig.displayName}`,
|
icon: 'success',
|
duration: 2000
|
});
|
setTimeout(() => {
|
console.log('项目已切换，正在初始化数据');
|
// 确保显示正确的用户名
|
if (!projectConfig.needLogin) {
|
this.setData({
|
userName: projectConfig.displayName
|
});
|
} else {
|
this.setData({
|
userName: "请点击登录"
|
});
|
}
|
this.initData();
|
}, 1000);
|
|
}).catch(err => {
|
console.error('保存项目选择失败：', err);
|
wx.showToast({
|
title: '保存失败，请重试',
|
icon: 'none',
|
duration: 2000
|
});
|
});
|
},
|
|
// 检查登录状态
|
checkLoginStatus() {
|
const app = getApp();
|
|
// 检查是否已登录
|
if (app.globalData.isLoggedIn && app.globalData.sessionId) {
|
console.log('已从全局变量检测到登录状态');
|
return;
|
}
|
|
// 检查本页面是否正在处理返回逻辑
|
const fromLogin = this.getFromLogin();
|
if (fromLogin) {
|
console.log('从登录页返回，不再重定向');
|
return;
|
}
|
|
// 检查当前项目是否需要登录
|
const currentProject = app.globalData.selectedProject;
|
if (currentProject && PROJECT_CONFIG[currentProject] && !PROJECT_CONFIG[currentProject].needLogin) {
|
console.log('当前项目不需要登录:', currentProject);
|
return;
|
}
|
|
// 获取当前页面路由和参数
|
const pages = getCurrentPages();
|
const currentPage = pages[pages.length - 1];
|
const currentRoute = currentPage ? currentPage.route : '';
|
const currentOptions = currentPage ? currentPage.options || {} : {};
|
|
console.log('当前页面路由:', currentRoute, '参数:', currentOptions);
|
|
// 检查URL参数中是否有fromLogin
|
if (currentOptions.fromLogin === 'true') {
|
console.log('URL参数中检测到fromLogin=true，不执行跳转');
|
this.setData({
|
isFromLogin: true
|
});
|
return;
|
}
|
|
// 如果当前已在登录页，不再跳转
|
if (currentRoute === 'pages/login/login') {
|
console.log('当前已在登录页，不再跳转');
|
return;
|
}
|
|
// Promise链处理存储检查
|
Promise.all([
|
storage.getItemSafe('sessionId'),
|
storage.getItemSafe('clientId'),
|
storage.getItemSafe('isLoggedIn')
|
])
|
.then(([sessionId, clientId, isLoggedIn]) => {
|
if (sessionId) {
|
// 从存储中恢复登录状态
|
app.globalData.sessionId = sessionId;
|
app.globalData.isLoggedIn = true;
|
|
if (clientId) {
|
app.globalData.clientId = clientId;
|
}
|
|
console.log('已从存储恢复登录状态');
|
// 已登录，刷新页面
|
wx.reLaunch({
|
url: '/pages/home/home'
|
});
|
} else {
|
// 标记当前页面正在处理返回逻辑
|
this.setData({
|
isFromLogin: true
|
});
|
|
// 未登录，可能需要跳转到登录页面
|
console.log('未检测到登录状态，可能需要跳转到登录页');
|
|
// 最后再检查一次是否已从登录页返回
|
const finalCheck = this.getFromLogin();
|
if (finalCheck) {
|
console.log('最终检查: 已从登录页返回，不再跳转');
|
return;
|
}
|
|
// 检查项目是否需要登录
|
if (currentProject && PROJECT_CONFIG[currentProject] && !PROJECT_CONFIG[currentProject].needLogin) {
|
console.log('最终检查: 当前项目不需要登录:', currentProject);
|
return;
|
}
|
|
console.log('确认需要跳转到登录页');
|
|
// 跳转前再次检查登录页面临时标记
|
try {
|
wx.setStorageSync('_attempted_login_redirect', 'true');
|
} catch (e) {}
|
|
// wx.navigateTo({
|
// url: `/pages/login/login?project=${this.data.selectedProject}`,
|
// success: () => console.log('成功跳转到登录页'),
|
// fail: (err) => console.error('跳转到登录页失败:', err)
|
// });
|
}
|
})
|
.catch(err => {
|
console.error('检查登录状态时出错:', err);
|
|
// 标记当前页面正在处理返回逻辑
|
this.setData({
|
isFromLogin: true
|
});
|
|
// 再次检查是否已从登录页返回
|
if (this.getFromLogin()) {
|
console.log('错误处理: 已从登录页返回，不再跳转');
|
return;
|
}
|
|
// 检查项目是否需要登录
|
if (currentProject && PROJECT_CONFIG[currentProject] && !PROJECT_CONFIG[currentProject].needLogin) {
|
console.log('错误处理: 当前项目不需要登录:', currentProject);
|
return;
|
}
|
|
// 出错时也跳转到登录页
|
// wx.navigateTo({
|
// url: `/pages/login/login?project=${this.data.selectedProject}`,
|
// success: () => console.log('错误后成功跳转到登录页'),
|
// fail: (err) => console.error('错误后跳转到登录页失败:', err)
|
// });
|
});
|
},
|
|
// 辅助函数：检查是否从登录页返回
|
getFromLogin() {
|
// 检查当前页面的options
|
const pages = getCurrentPages();
|
const currentPage = pages[pages.length - 1];
|
if (currentPage && currentPage.options && currentPage.options.fromLogin === 'true') {
|
console.log('getFromLogin: 检测到URL参数fromLogin=true');
|
// 设置标志，确保下次检查时能识别
|
this.setData({
|
isFromLogin: true
|
});
|
return true;
|
}
|
console.log('getFromLogin: 未检测到从登录页返回的标记');
|
return false;
|
},
|
|
// 继续初始化页面
|
continueInitPage(options) {
|
console.log('继续初始化页面，options:', options);
|
|
// 检查是否从登录页返回
|
let fromLogin = false;
|
|
// 从URL参数中检查
|
if (options && options.fromLogin === 'true') {
|
console.log('continueInitPage: 从URL参数检测到fromLogin=true');
|
fromLogin = true;
|
this.setData({
|
isFromLogin: true
|
});
|
}
|
|
// 从页面数据中检查
|
if (this.data.isFromLogin) {
|
console.log('continueInitPage: 从页面数据中检测到isFromLogin=true');
|
fromLogin = true;
|
}
|
// 当开阀成功后调用刷新
|
if (options && options.param) {
|
console.log("开阀成功参数:", options.param);
|
wx.showToast({
|
title: '开阀成功',
|
icon: 'success',
|
duration: 3000
|
});
|
this.getOpenList();
|
}
|
|
// 初始化数据
|
this.initData();
|
|
// 如果不是从登录页返回，则设置延迟检查登录状态
|
if (!fromLogin) {
|
console.log('不是从登录页返回，延迟检查登录状态');
|
setTimeout(() => {
|
// 仅在未登录且不是从登录页返回时检查登录状态
|
if (!getApp().globalData.isLoggedIn) {
|
console.log('延迟检查：未登录且不是从登录页返回，执行登录状态检查');
|
this.checkLoginStatus();
|
}
|
}, 500);
|
} else {
|
console.log('从登录页返回，不检查登录状态');
|
}
|
},
|
|
// 微信登录
|
wxLogin() {
|
// 检查当前项目是否需要登录
|
const currentProject = getApp().globalData.selectedProject;
|
if (currentProject && PROJECT_CONFIG[currentProject]) {
|
const projectConfig = PROJECT_CONFIG[currentProject];
|
|
if (!projectConfig.needLogin) {
|
console.log('wxLogin: 当前项目不需要登录:', currentProject);
|
// 不需要登录的项目，显示项目名称
|
this.setData({
|
userName: projectConfig.displayName
|
});
|
return;
|
}
|
}
|
|
if (!getApp().globalData.isLoggedIn) {
|
wx.showLoading({
|
title: '正在登录请稍候...',
|
mask: true
|
});
|
|
wx.login({
|
success: (res) => {
|
if (res.code) {
|
// 将code发送到服务器获取openid
|
post({
|
url: "wx/client/code_login",
|
data: {
|
code: res.code
|
}
|
}).then(response => {
|
wx.hideLoading();
|
if (response.code === "0001") {
|
if (response.content.client.clientId === "") {
|
// 未绑定账号，跳转到登录页面并传递当前项目信息
|
const projectInfo = PROJECT_CONFIG[this.data.selectedProject];
|
wx.navigateTo({
|
url: `/pages/login/login?project=${this.data.selectedProject}&projectName=${projectInfo.displayName}`
|
});
|
} else {
|
this.setData({
|
userName: response.content.client.clientName,
|
userPhone: response.content.client.userPhone
|
})
|
// 已有账号，保存数据并初始化
|
const sessionId = response.content.client.sessionId;
|
const clientId = response.content.client.clientId;
|
|
// 设置全局变量
|
getApp().globalData.sessionId = sessionId;
|
getApp().globalData.clientId = clientId;
|
getApp().globalData.isLoggedIn = true;
|
|
// 设置正确的项目tag
|
const projectConfig = PROJECT_CONFIG[this.data.selectedProject];
|
if (projectConfig) {
|
getApp().globalData.tag = projectConfig.tag;
|
}
|
|
// 保存到存储
|
storage.setItem("sessionId", sessionId);
|
storage.setItem("clientId", clientId);
|
storage.setItem("isLoggedIn", "true");
|
|
// 保存userData信息，包含sessionId和tag
|
const userData = JSON.stringify({
|
sessionId: sessionId,
|
tag: projectConfig ? projectConfig.tag : 'ym',
|
project: this.data.selectedProject,
|
userName: response.content.client.clientName,
|
userPhone: response.content.client.userPhone
|
});
|
storage.setItem("userData", userData)
|
.then(() => {
|
console.log('用户数据保存成功，包含项目信息:', this.data.selectedProject, 'tag:', projectConfig ? projectConfig.tag : 'ym');
|
this.initData();
|
})
|
.catch(err => {
|
console.warn('保存userData失败，但继续初始化:', err);
|
this.initData();
|
});
|
|
}
|
} else if (response.code === "1003") {
|
// 未绑定账号，跳转到登录页面并传递当前项目信息
|
const projectInfo = PROJECT_CONFIG[this.data.selectedProject];
|
wx.navigateTo({
|
url: `/pages/login/login?project=${this.data.selectedProject}&projectName=${projectInfo.displayName}`
|
});
|
} else {
|
wx.showToast({
|
title: '登录失败',
|
icon: 'error',
|
duration: 2000
|
});
|
}
|
}).catch(error => {
|
wx.hideLoading();
|
console.error('登录请求失败:', error);
|
if(error.code==="1003"){
|
// 未绑定账号，跳转到登录页面并传递当前项目信息
|
const projectInfo = PROJECT_CONFIG[this.data.selectedProject];
|
wx.navigateTo({
|
url: `/pages/login/login?project=${this.data.selectedProject}&projectName=${projectInfo.displayName}`
|
});
|
}else{
|
wx.showToast({
|
title: '登录失败，请重试',
|
icon: 'none'
|
});
|
}
|
});
|
} else {
|
wx.hideLoading();
|
console.log('登录失败！' + res.errMsg);
|
wx.showToast({
|
title: '微信登录失败',
|
icon: 'none'
|
});
|
}
|
},
|
fail: (err) => {
|
wx.hideLoading();
|
console.error('微信登录API调用失败:', err);
|
wx.showToast({
|
title: '登录失败，请重试',
|
icon: 'none'
|
});
|
}
|
});
|
}
|
},
|
|
// 辅助函数：清理临时标记
|
cleanupTempMarkers() {
|
// 只有在isFromLogin为true时才进行清理
|
if (this.data.isFromLogin) {
|
|
|
// 重设isFromLogin为false，但添加延迟，避免影响当前页面的返回逻辑
|
setTimeout(() => {
|
this.setData({
|
isFromLogin: false
|
});
|
console.log('重置isFromLogin=false');
|
}, 5000);
|
}
|
}, //确认解绑
|
unBindPost() {
|
this.setData({
|
showUnBind: false
|
})
|
wx.showLoading({
|
title: '正在解绑请稍候...', // 加载提示文字
|
mask: true // 是否显示透明蒙层，防止触摸穿透，默认为 false
|
});
|
const data = {
|
sessionId: getApp().globalData.sessionId //取水口ID
|
};
|
post({
|
url: 'wx/client/unbind',
|
data: data,
|
useParams: true
|
}).then(response => {
|
// 处理成功响应
|
console.log('请求成功:', response);
|
// 加载完成后隐藏加载动画
|
wx.hideLoading();
|
const app = getApp();
|
|
// 清除全局登录状态
|
app.globalData.sessionId = '';
|
app.globalData.clientId = '';
|
app.globalData.isLoggedIn = false;
|
app.globalData.userInfo = null;
|
|
// 清除存储中的登录状态
|
const storage = require('../../utils/storage.js');
|
storage.removeItem('sessionId')
|
.then(() => storage.removeItem('clientId'))
|
.then(() => storage.removeItem('userData'))
|
.then(() => storage.removeItem('isLoggedIn'))
|
.then(() => {
|
wx.showToast({
|
title: '解绑成功',
|
icon: 'success',
|
duration: 2000
|
});
|
|
// 重置UI显示状态
|
this.setData({
|
userName: "请点击登录",
|
userPhone: "",
|
listData: []
|
});
|
})
|
.catch(err => {
|
console.error('解绑过程中出错:', err);
|
wx.showToast({
|
title: '解绑失败，请重试',
|
icon: 'none',
|
duration: 2000
|
});
|
});
|
}).catch(error => {
|
// 加载完成后隐藏加载动画
|
wx.hideLoading();
|
// 处理错误响应
|
console.error('请求失败:', error);
|
wx.showToast({
|
title: '解绑失败',
|
icon: 'error',
|
duration: 3000
|
})
|
});
|
},
|
onShareAppMessage: function (options) {
|
// 设置分享内容
|
return {
|
title: '大禹灌溉助手', // 分享标题
|
path: '/pages/home/home', // 分享路径，该路径需要是当前小程序存在的页面路径
|
imageUrl: '/images/logo2.jpg', // 分享图标，可以是网络图片路径或本地图片路径
|
success: function (res) {
|
// 分享成功的回调函数
|
},
|
fail: function (res) {
|
// 分享失败的回调函数
|
}
|
};
|
},
|
//点击提示按钮
|
infoShow() {
|
this.setData({
|
showInfoDialog: true
|
})
|
},
|
//提示窗确认按钮
|
confirmBtnInfoDialog() {
|
this.setData({
|
showInfoDialog: false
|
})
|
},
|
//强制删除
|
onDelete(e) {
|
const item = e.currentTarget.dataset.item;
|
const that = this;
|
|
if (this.data.useTestData) {
|
// 测试数据模式下，模拟删除操作
|
wx.showLoading({
|
title: '正在强制删除请稍候...',
|
mask: true
|
});
|
|
// 模拟请求延迟
|
setTimeout(() => {
|
wx.hideLoading();
|
|
// 从列表中移除被删除的项
|
const updatedList = this.data.listData.filter(listItem =>
|
listItem.orderNo !== item.orderNo
|
);
|
|
this.setData({
|
listData: updatedList
|
});
|
|
wx.showToast({
|
title: '删除成功',
|
icon: 'success',
|
duration: 2000
|
});
|
}, 1500);
|
return;
|
}
|
|
wx.showLoading({
|
title: '正在强制删除请稍候...', // 加载提示文字
|
mask: true // 是否显示透明蒙层，防止触摸穿透，默认为 false
|
});
|
const data = {
|
vcNum: item.vcNum, //取水口ID
|
rtuAddr: item.rtuAddr, //阀控器地址
|
};
|
post({
|
url: "wx/valve/deleteUnclosed",
|
data: data,
|
timeout: 180000
|
}).then(response => {
|
// 处理成功响应
|
console.log('请求成功:', response);
|
// 加载完成后隐藏加载动画
|
wx.hideLoading();
|
//重新获取列表刷新数据
|
this.getOpenList();
|
}).catch(error => {
|
// 加载完成后隐藏加载动画
|
wx.hideLoading();
|
// 处理错误响应
|
console.error('请求失败:', error);
|
});
|
},
|
//修改按钮文字
|
updateDisplayText() {
|
const updatedList = this.data.listData.map(item => {
|
let displayText = '';
|
if (item.planned) {
|
displayText = '取消';
|
} else {
|
displayText = "关阀"
|
}
|
let deleteText = "删除"
|
let time;
|
if (!item.dt) {
|
time = "暂无"
|
} else {
|
time = this.extractTime(item.dt)
|
}
|
if (item.waterInstant === null) {
|
item.waterInstant = "暂无"
|
}
|
|
return {
|
...item,
|
displayText,
|
deleteText,
|
time
|
}; // 保留所有其他字段，并添加 displayText 字段
|
});
|
// 更新列表数据
|
this.setData({
|
listData: updatedList
|
});
|
},
|
//处理时间去掉年月日
|
extractTime(datetimeString) {
|
const formattedDate = datetimeString.replace(" ", "T");
|
const date = new Date(formattedDate);
|
// 获取小时、分钟和秒
|
const hours = date.getHours().toString().padStart(2, '0');
|
const minutes = date.getMinutes().toString().padStart(2, '0');
|
const seconds = date.getSeconds().toString().padStart(2, '0');
|
return `${hours}:${minutes}:${seconds}`;
|
},
|
|
// 切换项目
|
switchProject(e) {
|
const project = e.currentTarget.dataset.project;
|
|
if (config.setBaseUrl(project)) {
|
this.setData({
|
selectedProject: project
|
});
|
|
// 保存选择到本地存储
|
try {
|
wx.setStorageSync('selectedProject', project);
|
} catch (e) {
|
console.error('保存项目选择失败:', e);
|
}
|
|
// 更新全局变量
|
const app = getApp();
|
if (app && app.globalData) {
|
app.globalData.selectedProject = project;
|
|
// 根据项目配置设置相关参数
|
const projectConfig = PROJECT_CONFIG[project];
|
if (projectConfig) {
|
app.globalData.tag = projectConfig.tag;
|
if (!projectConfig.needLogin) {
|
app.globalData.operator = projectConfig.operatorId;
|
app.globalData.clientId = projectConfig.operatorId;
|
app.globalData.isLoggedIn = true;
|
app.globalData.sessionId = projectConfig.operatorId;
|
// 如果有vcId，也设置
|
if (projectConfig.vcId) {
|
app.globalData.vcId = projectConfig.vcId;
|
}
|
}
|
}
|
}
|
|
// 重新加载页面数据
|
this.initData();
|
} else {
|
wx.showToast({
|
title: '切换项目失败',
|
icon: 'none'
|
});
|
}
|
},
|
})
|
