const util = require("./components/util"); // 引入封装过的加载提示
|
import {
|
loginInfo
|
} from "../../../../../../assets/js/login";
|
const app = getApp();
|
Component({
|
properties: {
|
treeList: {
|
type: Array,
|
value: [],
|
},
|
learnList: {
|
type: Array,
|
value: [],
|
},
|
bookInfo: {
|
type: Object,
|
value: {},
|
},
|
buyIds: {
|
type: Array,
|
value: [],
|
},
|
tab: {
|
type: String,
|
value: "",
|
},
|
applyState: {
|
type: String,
|
value: "",
|
},
|
openIds: {
|
type: Array,
|
value: [],
|
},
|
isShowCheck: {
|
type: Boolean,
|
value: false,
|
},
|
paymentPage: {
|
type: Boolean,
|
value: false,
|
},
|
superior: {
|
type: Boolean,
|
value: false,
|
},
|
checkAllState: {
|
type: Boolean,
|
},
|
deadline: {
|
type: String,
|
},
|
cloundMenuIsBuy: {
|
type: Boolean
|
}
|
},
|
data: {
|
activeValues: [1, 2],
|
webpageSrc: "",
|
cloudShoppingCart: [],
|
shoppingCart: true,
|
stop: false,
|
cart: true,
|
canExecute: true,
|
purchaseList: []
|
},
|
ready() {},
|
onLoad() {},
|
observers: {
|
treeList: function (newValue) {
|
const list = [];
|
let checked = "";
|
this.properties.treeList.forEach((item) => {
|
if (item.children && item.children.length > 0) {
|
list.push(...this.flattenTree([item]));
|
}
|
});
|
const flag = list.findIndex((item) => item.checked == true);
|
},
|
},
|
|
methods: {
|
handleList(tree) {
|
for (let index = 0; index < tree.length; index++) {
|
const item = tree[index];
|
if (item.sysType == "CmsItem" && !item.checked) {}
|
if (item.children && item.children.length > 0) {
|
this.handleList(item.children);
|
}
|
}
|
},
|
// 遍历树结构转换为数组方法
|
handleTreeData(array) {
|
const flattenedArray = [];
|
array.forEach((node) => {
|
// 将当前节点添加到展开的数组中
|
flattenedArray.push(node);
|
// 递归处理子节点
|
if (node.children && node.children.length > 0) {
|
const childrenArray = this.handleTreeData(node.children);
|
flattenedArray.push(...childrenArray);
|
}
|
});
|
return flattenedArray;
|
},
|
// 节点展开
|
handleChange(e) {
|
this.setData({
|
openIds: e.detail.value,
|
});
|
},
|
handleCheck(data) {
|
for (let index = 0; index < data.length; index++) {
|
const element = data[index];
|
element.checked = true;
|
if (element.childrenCount && element.type == "productFolder") {
|
handleCheck(element.children);
|
}
|
}
|
},
|
downloadTeach(e) {
|
const value = e.currentTarget.dataset.value;
|
var myEventDetail = {
|
value,
|
}; // detail对象，提供给事件监听函数
|
var myEventOption = {
|
bubbles: true,
|
composed: true,
|
}; // 触发事件的选项
|
this.triggerEvent("downloadTeach", myEventDetail, myEventOption);
|
},
|
// 判断资源是否购买
|
resourceIsBuy(data) {
|
if (data.saleMethod && data.saleMethod.length) {
|
const saleData = data.saleMethod.find((item) => item.SaleType == 'Normal')
|
if (saleData.State == 'Disable') return false
|
const isSHow = this.properties.buyIds.some(
|
(item) => item == saleData.Id
|
);
|
// 已经购买
|
if (isShow) return false
|
// 未购买，查看销售方式是否过期
|
if (!isShow) {
|
const flag = new Date(saleData.EndDate).getTime() >= new Date().getTime() &&
|
new Date(saleData.BeginDate).getTime() <= new Date().getTime()
|
if (flag) {
|
// 为过期 ，需要购买
|
return true
|
} else {
|
// 已过期 无需购买
|
return false
|
}
|
}
|
} else {
|
return false;
|
}
|
},
|
// 跳转音视频播放器
|
goPlayer(e) {
|
// 检查登录状态
|
const token = wx.getStorageSync(app.config.tokenKey);
|
if (!token) return false
|
const item = e.currentTarget.dataset.item;
|
const parent = e.currentTarget.dataset.parent;
|
const parentProductLinkPath = parent ?
|
parent.productLinkPath :
|
wx.getStorageSync("teachResourcesPath");
|
const parentName = parent ? parent.name : "教学资源";
|
// 资源购买页面(只展示未购买资源) 点击不跳转
|
if (this.properties.isShowCheck) return false;
|
if (item.selectType == "webpage") {
|
// 网页类型跳转到网址复制页，因为url传参不能传 带参数的网络地址，所以此处要把网络地址里的传参摘出来，放到url里
|
let urlData = ''
|
const flags = item.jsek_link.indexOf("?")
|
if (flags > -1) {
|
urlData = item.jsek_link.slice(flags + 1, item.jsek_link.length)
|
}
|
url = '/packageBookService/pages/bookServices/linkPage/index'
|
return wx.navigateTo({
|
url: urlData ? url + `?path=${item.jsek_link.slice(0,flags)}` + '&' + urlData : url + `?path=${item.jsek_link}`
|
})
|
}
|
if (!item.file && !item.freeFile && !item.protectedFile) {
|
return wx.showToast({
|
icon: 'error',
|
title: '暂无资源',
|
})
|
}
|
if (item.selectType == 'zip') {
|
if (this.properties.applyState == 'Normal') {
|
return wx.showToast({
|
icon: 'error',
|
title: '请前往PC端下载',
|
})
|
} else {
|
return wx.showToast({
|
icon: 'error',
|
title: '请先申请下载',
|
})
|
}
|
}
|
if (this.properties.tab == "jsek_teachingResources" && (item.file || item.freeFile)) {
|
let file = item.fileMap[item.file] ? item.fileMap[item.file] : item.fileMap[item.freeFile]
|
if (file && file.protectType !== "Public") {
|
return wx.showToast({
|
icon: "error",
|
title: "资源不可用，请联系管理员",
|
});
|
}
|
}
|
if (this.properties.tab == "jsek_cloudLearning") {
|
// 判断父级或自身是否购买
|
var myEventOption = {
|
bubbles: true,
|
composed: true,
|
};
|
// 出发判断云学习是否购买判断
|
this.triggerEvent("getCloundIsBuy", {}, myEventOption)
|
if (!this.properties.cloundMenuIsBuy) {
|
// 云学习未购买，查找以购买的目录和资源本身
|
const learn = this.handleTreeData(this.properties.treeList).filter(
|
(citem) => citem.saleMethod &&
|
citem.saleMethod.find((ditem) => ditem.SaleType == 'Normal') &&
|
new Date(citem.saleMethod.find((ditem) => ditem.SaleType == 'Normal').EndDate).getTime() >= new Date().getTime() &&
|
new Date(citem.saleMethod.find((ditem) => ditem.SaleType == 'Normal').BeginDate).getTime() <= new Date().getTime() &&
|
item.productLinkPath.includes(citem.productLinkPath)
|
)
|
// 资源和父级目录都无销售方式
|
// if (!learn.length) return wx.showToast({
|
// icon: 'error',
|
// title: '暂未开售',
|
// })
|
const buyList = learn.filter((citem) => this.properties.buyIds.includes(citem.saleMethod.find((ditem) => ditem.SaleType == 'Normal').Id))
|
if (!buyList.length && learn.length) {
|
// 资源和本身都未购买 且 父级或本身有销售方式
|
const itemSaleMethod = item.saleMethod && item.saleMethod.length ? item.saleMethod.find(citem => citem.SaleType == 'Normal') : undefined
|
return wx.showToast({
|
icon: 'error',
|
title: itemSaleMethod && itemSaleMethod.Price == 0 ? '请先领取资源' : '请先购买资源',
|
})
|
}
|
}
|
}
|
let url;
|
if (item.selectType == "video" || item.learnSelectType == "video") {
|
url = "/packageDomain/pages/resourceDetails/myVideo/index";
|
}
|
if (
|
item.selectType == "audio" ||
|
item.learnSelectType == "audio"
|
) {
|
url = "/packageDomain/pages/resourceDetails/myAudio/index";
|
}
|
if (item.selectType == "picture" || item.selectType == 'document') {
|
url = "/packageDomain/pages/resourceDetails/document/index";
|
}
|
wx.navigateTo({
|
url: `${url}?productLinkPath=${item.productLinkPath}&parentProductLinkPath=${parentProductLinkPath}&parentName=${parentName}&activeId=${item.id}&bookId=${this.properties.bookInfo.id}&bookName=${this.properties.bookInfo.name}&cmsId=${this.properties.bookInfo.rootCmsItemId}&formPath=${this.properties.tab}&applyState=${this.properties.applyState}&deadline=${this.properties.deadline}`,
|
});
|
},
|
|
// 拿到所有项
|
getAllChildren(id) {
|
let result = [];
|
|
function findChildren(item) {
|
if (item.id === id) {
|
if (item.children && item.children.length > 0) {
|
item.children.forEach((child) => {
|
findChildren(child);
|
});
|
}
|
} else {
|
if (item.children && item.children.length > 0) {
|
item.children.forEach((child) => {
|
findChildren(child);
|
});
|
}
|
}
|
if (item.children && item.children.length > 0) {
|
result.push(...item.children);
|
}
|
}
|
this.properties.treeList.forEach((item) => {
|
findChildren(item);
|
});
|
return result;
|
},
|
// 拿到当前项子项
|
flattenTree(tree) {
|
let result = [];
|
|
function flatten(node) {
|
result.push(node);
|
if (node.children && node.children.length > 0) {
|
node.children.forEach((child) => {
|
flatten(child);
|
});
|
}
|
}
|
tree.forEach((node) => {
|
flatten(node);
|
});
|
return result;
|
},
|
|
// 变为true
|
findAndUpdateItemsByIds(tree, ids, state) {
|
function findAndUpdate(node) {
|
if (ids.includes(node.id)) {
|
node.checked = state; // 将目标项的 check 属性设置为 true
|
}
|
if (node.children && node.children.length > 0) {
|
for (let child of node.children) {
|
findAndUpdate(child); // 递归处理子节点
|
}
|
}
|
}
|
for (let node of tree) {
|
findAndUpdate(node); // 对每个顶层节点执行查找和更新操作
|
}
|
return tree; // 返回修改后的完整数组
|
},
|
|
// 全选
|
checkAll() {
|
wx.showLoading()
|
const ids = [];
|
let list = [];
|
let checked = "";
|
this.properties.treeList.forEach((item) => {
|
if (item.children && item.children.length > 0) {
|
list.push(...this.flattenTree([item]));
|
}
|
});
|
list = list.filter(item => !item.disabled)
|
list.forEach((item) => {
|
ids.push(item.id);
|
checked = item.checked;
|
});
|
const flag = this.properties.checkAllState;
|
var myEventDetail = {
|
ids,
|
flag,
|
};
|
var myEventOption = {
|
bubbles: true,
|
composed: true,
|
};
|
this.triggerEvent("changeListChecked", myEventDetail, myEventOption);
|
var myEventDetail = {
|
value: !flag,
|
}; // detail对象，提供给事件监听函数
|
var myEventOption = {
|
bubbles: true,
|
composed: true,
|
}; // 触发事件的选项
|
this.triggerEvent("changeCheckAll", myEventDetail, myEventOption);
|
wx.hideLoading()
|
},
|
|
// 章节勾选
|
checkResourceTitle(e) {
|
wx.showLoading()
|
const flag = e.detail.checked;
|
// 这个时候checked的值是fals
|
const item = e.currentTarget.dataset.item;
|
const parent = this.findParentById(this.properties.learnList, item.id);
|
let childrenList = [];
|
let flagNum;
|
if (parent)
|
childrenList = parent.children.filter((citem) => citem.id !== item.id);
|
flagNum = childrenList.findIndex((item) => item.checked == false);
|
let list = this.flattenTree([item]);
|
list = list.filter(item => !item.disabled)
|
let ids = [];
|
list.forEach((item) => {
|
ids.push(item.id)
|
});
|
var myEventDetail = {
|
ids,
|
flag,
|
}; // detail对象，提供给事件监听函数
|
var myEventOption = {
|
bubbles: true,
|
composed: true,
|
}; // 触发事件的选项
|
// 去勾选点击目录的子项
|
this.triggerEvent("changeListChecked", myEventDetail, myEventOption);
|
// 去勾选点击目录的父项
|
if (flagNum == -1 && parent && !parent.disabled) {
|
let checkedState;
|
var myEventDetail = {
|
ids: [parent.id],
|
flag,
|
};
|
var myEventOption = {
|
bubbles: true,
|
composed: true,
|
};
|
this.triggerEvent("changeListChecked", myEventDetail, myEventOption);
|
}
|
list.forEach((items) => {
|
if (!items.checked) {
|
this.setData({
|
cloudShoppingCart: items,
|
});
|
}
|
});
|
this.setData({
|
openIds: this.data.openIds,
|
});
|
},
|
// 子项勾选
|
checkResource(e) {
|
wx.showLoading()
|
const citem = e.currentTarget.dataset.item;
|
const parent = e.currentTarget.dataset.parent;
|
let outermost;
|
if (parent)
|
outermost = this.findParentById(this.properties.learnList, parent.id);
|
const childrenList = parent.children.filter(
|
(item) => item.id !== citem.id && item.saleMethod.length
|
);
|
const flag = childrenList.findIndex((item) => item.checked == false);
|
// 改变该项checked
|
var myEventDetail = {
|
id: citem.id,
|
};
|
var myEventOption = {
|
bubbles: true,
|
composed: true,
|
};
|
this.triggerEvent("changeResourceChecked", myEventDetail, myEventOption);
|
// 通过判断,联通父级checked
|
if (flag == -1 && !parent.disabled) {
|
let checkedState;
|
citem.checked == false ? (checkedState = true) : (checkedState = false);
|
var myEventDetail = {
|
ids: [parent.id],
|
flag: checkedState,
|
};
|
var myEventOption = {
|
bubbles: true,
|
composed: true,
|
};
|
this.triggerEvent("changeListChecked", myEventDetail, myEventOption);
|
}
|
// 联通最外层级checked ,如果有一个取消勾选,且当前最外层勾选,则取消最外层的勾选
|
if (citem.checked && outermost && outermost.checked) {
|
var myEventDetail = {
|
ids: [outermost.id],
|
flag: false,
|
};
|
var myEventOption = {
|
bubbles: true,
|
composed: true,
|
};
|
this.triggerEvent("changeListChecked", myEventDetail, myEventOption);
|
}
|
// 联通最外层级checked, 如果所有子项勾选, 且当前最外层未勾选, 则加上最外层的勾选
|
if (!citem.checked && outermost && !outermost.disabled) {
|
let allchildren = this.flattenTree([outermost]);
|
allchildren = allchildren.filter(
|
(item) =>
|
item.sysType == "CmsItem" &&
|
item.id !== citem.id &&
|
item.saleMethod.length
|
);
|
const satate = allchildren.findIndex((item) => item.checked == false);
|
if (satate == -1) {
|
var myEventDetail = {
|
ids: [outermost.id],
|
flag: true,
|
};
|
var myEventOption = {
|
bubbles: true,
|
composed: true,
|
};
|
this.triggerEvent("changeListChecked", myEventDetail, myEventOption);
|
}
|
}
|
},
|
// 加入购物车
|
async onCloudShoppingCart(e) {
|
let shoppingCartGetId = [];
|
const item = e.currentTarget.dataset.item;
|
const saleMethodId = e.currentTarget.dataset.item.saleMethod[0].Id;
|
let query = {
|
start: 0,
|
size: 999,
|
filterList: [],
|
searchList: [],
|
};
|
const res = await app.MG.store.getShoppingCartProductList(query);
|
res.datas.forEach((item) => {
|
shoppingCartGetId.push(item.saleMethod.id);
|
});
|
if (shoppingCartGetId.includes(saleMethodId)) {
|
wx.showToast({
|
icon: "error",
|
title: "已添加",
|
});
|
this.setData({
|
shoppingCart: false,
|
});
|
} else {
|
let query = {
|
requests: [{
|
saleMethodId: saleMethodId,
|
storeEventId: null,
|
// agentCode: '电子书'
|
}, ],
|
};
|
const addRes = await app.MG.store.addShoppingCart(query);
|
if (addRes) {
|
wx.showToast({
|
icon: "success",
|
title: "添加成功",
|
});
|
item.isShopCar = false;
|
var myEventDetail = {
|
id: item.id,
|
};
|
var myEventOption = {
|
bubbles: true,
|
composed: true,
|
};
|
this.triggerEvent("updateCloudLearning", myEventDetail, myEventOption);
|
}
|
}
|
},
|
sadd() {
|
this.triggerEvent("updateShoppingCartHidden");
|
this.triggerEvent("updateCloudLearning");
|
},
|
findParentById(arr, id) {
|
for (let i = 0; i < arr.length; i++) {
|
const item = arr[i];
|
// 检查当前项是否匹配（即它是不是我们要找的项）
|
if (item.id === id) {
|
// 如果当前项就是我们要找的项，则它没有父级，返回 null
|
return null;
|
}
|
// 递归查找当前项的子项
|
const child = this.findChildById(item.children, id);
|
if (child) {
|
// 如果在子项中找到匹配的项，返回当前项作为父级
|
return item;
|
}
|
}
|
// 如果没有找到匹配的父项，返回 null
|
return null;
|
},
|
// 辅助函数，用于递归查找子项
|
findChildById(children, id) {
|
if (!children) {
|
return null;
|
}
|
for (let i = 0; i < children.length; i++) {
|
const child = children[i];
|
if (child.id === id) {
|
// 如果找到匹配的项，返回它
|
return child;
|
}
|
// 递归检查子项的子项
|
const subChild = this.findChildById(child.children, id);
|
if (subChild) {
|
return subChild;
|
}
|
}
|
// 如果没有找到匹配的项，返回 null
|
return null;
|
},
|
},
|
});
|
