// pages/bookServices/detail/index.js
|
import Toast from "tdesign-miniprogram/toast";
|
import tool from "../../../../assets/js/toolClass";
|
import moment from 'moment'
|
import {
|
loginInfo
|
} from "../../../../assets/js/login";
|
import FormData from '../../../../utils/formdata/index.js';
|
const app = getApp();
|
var pastData = require('../../psychologyAnswer/testdata/index')
|
Page({
|
/**
|
* 页面的初始数据
|
*/
|
data: {
|
// 进页面默认切换 展开的id
|
// defaultactiveTeachid 教学资源
|
// defaultactiveLearnid 云学习
|
bookId: "",
|
barHeight: "",
|
navBarHeight: "",
|
options: {
|
id: "",
|
name: "",
|
storeInfo: '',
|
},
|
bookDetail: {},
|
bookClass: [],
|
bookItemDetail: {},
|
link: {
|
jd: "",
|
tamll: "",
|
dang: "",
|
micro: "",
|
},
|
tabValue: "brief",
|
cmsDatas: [], // 资源refCode列表
|
ids: [1],
|
list: [],
|
teachResources: [],
|
teach: [],
|
learn: [],
|
test: [],
|
jslx: true,
|
openTeachids: [],
|
openLearnids: [],
|
openTestids: [],
|
isGoBuyResource: true,
|
learnPath: '',
|
applyResourceState: false, // 申请教学资源按钮防抖
|
resourceClassList: [], // 资源所属分类
|
applyState: "", // 教学资源申请状态
|
deadline: "", // 教学资源申请有效日期,
|
isShowBuyCloundBtn: false,
|
isshowDrawBtn: true, // 云学习领取查看按钮是否显示
|
isShowBuyCloundMenu: false, // 云学习全部购买按钮是否显示
|
isCloundHaveSaleMethod: false, // 云学习是否有销售方式
|
cloundMenuIsBuy: false,
|
learnTaskData: {},
|
rejectCause: "", // 下载拒绝原因
|
buyIdList: [],
|
shoppingCartGetId: [], // 已购买id列表
|
shoppingList: [],
|
loading: false,
|
isShowTeachDownload: false, // 提示PC下载弹窗状态
|
confirmBtn: {
|
content: "我知道了",
|
variant: "base",
|
},
|
mockData: {
|
id: 0, // 销售id
|
price: 0, // 售价
|
count: 0, // 组卷已购买次数
|
useCount: 0, // 组件已使用次数
|
residue: 0, // 组卷剩余次数
|
mockList: [], // 用户组卷提交信息
|
},
|
isBuyBank: false, // 题库是否购买
|
isShoppingBank: false, // 题库是否加入购物车
|
bankSaleData: null,
|
relatedBookLoading: false,
|
noRelatedBookData: false,
|
relatedBookPath: "", // 相关图书path
|
relatedBookData: [], // 相关图书列表
|
flag: true,
|
noResources: false,
|
selectedIds: "", //商品或子商品销售方式
|
bookBuy: false, //商品或子商品是否购买
|
expire: false, //商品或子商品销售方式是否过期
|
noFile: false, //商品或子商有无电子书文件
|
num: 0, //样书申请单数量
|
alreadyPaperBookList: [], //已申请纸质样书
|
alreadyElectronicBookList: [], //已申请电子样书
|
paperBookList: [], //样书单纸质书
|
electronicBookList: [], //样书单电子书
|
paperBookCount: 0, //纸质书剩余次数
|
ebookCount: 0, //电子书剩余次数
|
resourceCodeList: [], // 资源refcode列表
|
userInfo: {},
|
pageLoading: true,
|
fileInfo: {
|
bookName: "",
|
fileType: "",
|
md5: "",
|
freePage: "",
|
}, //阅读器数据
|
buyResourceData: {
|
productLinkPath: "",
|
refCode: "",
|
},
|
briefIcon: {
|
name: "/static/images/bookService/detail/tushujianjie-g.png",
|
},
|
briefIconClick: {
|
name: "/static/images/bookService/detail/tushujianjie-click.png",
|
},
|
eBookIcon: {
|
name: "/static/images/bookService/detail/ebook-g.png",
|
},
|
eBookClickIcon: {
|
name: "/static/images/bookService/detail/ebook-click.png",
|
},
|
teachResourcesIcon: {
|
name: "/static/images/bookService/detail/jiaoxueziyuan.png",
|
},
|
teachResourcesClickIcon: {
|
name: "/static/images/bookService/detail/jiaoxueziyuan-click.png",
|
},
|
learnResourceIcon: {
|
name: "/static/images/bookService/detail/yunxuexi.png",
|
},
|
learnResourceClickIcon: {
|
name: "/static/images/bookService/detail/yunxuexi-click.png",
|
},
|
testResourceIocn: {
|
name: "/static/images/bookService/detail/test-icon-g.png",
|
},
|
testResourceClickIocn: {
|
name: "/static/images/bookService/detail/test-click-icon.png",
|
},
|
noteIcon: {
|
name: "/static/images/bookService/detail/biji-icon-g.png",
|
},
|
noteClickIcon: {
|
name: "/static/images/bookService/detail/biji-click-icon.png",
|
},
|
linkIcon: {
|
name: "/static/images/bookService/detail/link.png",
|
},
|
linkClickIcon: {
|
name: "/static/images/bookService/detail/link-click.png",
|
},
|
icon1: {
|
name: "/static/images/bookService/detail/dangdang.png",
|
},
|
rowCol: [{
|
width: '50%',
|
},
|
{
|
width: '100%'
|
},
|
{
|
width: '80%'
|
},
|
{
|
width: '100%'
|
}, {
|
width: '100%'
|
},
|
],
|
showIndex: '',
|
successOrderNumber: '',
|
applicationState: '', // 电子样书申请状态
|
dialogBox: false,
|
resourceInfo: {
|
resourceName: '',
|
fileType: '',
|
description: '',
|
agree: false
|
},
|
resourceVisible: false,
|
resourceValue: [],
|
fileTypeList: [{
|
label: '音频',
|
value: '音频'
|
},
|
{
|
label: '视频',
|
value: '视频'
|
},
|
{
|
label: '图片',
|
value: '图片'
|
},
|
{
|
label: 'PDF',
|
value: 'PDF'
|
},
|
{
|
label: '资源包',
|
value: '资源包'
|
},
|
{
|
label: '文档',
|
value: '文档'
|
},
|
{
|
label: '其他',
|
value: '其他'
|
}
|
],
|
fileList: [],
|
isShowUp: true,
|
protocolShow: false,
|
protocolTxt: '',
|
learnMenu: null,
|
md5List: []
|
},
|
|
resetTree: function (e) {
|
this.setData({
|
currentCheck: e.detail.checkedItem,
|
list: e.detail.changeList,
|
});
|
},
|
/**
|
* 生命周期函数--监听页面加载
|
*/
|
onLoad(options) {
|
const systInfo = wx.getSystemInfoSync();
|
const menu = wx.getMenuButtonBoundingClientRect(); // 胶囊信息
|
const navBarHeight =
|
(menu.top - systInfo.statusBarHeight) * 2 + menu.height; // 导航栏高度
|
this.setData({
|
bookId: options.id + "",
|
barHeight: systInfo.statusBarHeight,
|
navBarHeight: navBarHeight,
|
options: {
|
id: options.id,
|
name: decodeURI(options.name),
|
storeInfo: options.storeInfo,
|
},
|
});
|
wx.setNavigationBarTitle({
|
title: decodeURI(options.name),
|
})
|
let token = wx.getStorageSync(app.config.tokenKey)
|
if (!token) {
|
loginInfo(app, (data) => {
|
if (data) {} else {}
|
})
|
}
|
this.getBookInfo(options.id);
|
// this.getResourceClass(); // 获取资源所属分类
|
token = wx.getStorageSync(app.config.tokenKey)
|
if (token) {
|
this.getShoppingCartProductGet();
|
this.getApplyInfo(options.id);
|
this.getAlreadyPBookList();
|
this.getAlreadyEBookList();
|
}
|
if (wx.getStorageSync(app.config.userInfoKey)) {
|
this.setData({
|
userInfo: JSON.parse(wx.getStorageSync(app.config.userInfoKey)),
|
});
|
// 获取申请次数
|
this.getSelectPaperBookCount();
|
this.getSelectBookCount();
|
}
|
if (options.tabValue) {
|
this.setData({
|
tabValue: options.tabValue,
|
});
|
|
|
}
|
},
|
|
/**
|
* 生命周期函数--监听页面显示
|
*/
|
onShow(options) {
|
if (wx.getStorageSync("paperBookList")) {
|
this.setData({
|
paperBookList: JSON.parse(wx.getStorageSync("paperBookList")),
|
});
|
}
|
if (wx.getStorageSync("electronicBookList")) {
|
this.setData({
|
electronicBookList: JSON.parse(wx.getStorageSync("electronicBookList")),
|
});
|
}
|
this.setData({
|
num: Number(this.data.paperBookList.length) + Number(this.data.electronicBookList.length),
|
});
|
if (this.data.bookDetail) {
|
this.getBookInfo(this.data.bookDetail.id)
|
}
|
},
|
|
/**
|
* 页面上拉触底事件的处理函数
|
*/
|
onReachBottom() {
|
if (this.data.tabValue == "jsek_note") {
|
const child = this.selectComponent("#note");
|
if (!child.data.noList) child.onReachBottom();
|
}
|
},
|
|
// 格式化日期
|
formatDate(dateString) {
|
if (!dateString) {
|
return "";
|
}
|
const match = dateString.match(
|
/^(\d{4})\/(\d{1,2})\/(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})$/
|
);
|
if (!match) {
|
throw new Error("Invalid date format");
|
}
|
|
const [, year, month, day, hours, minutes, seconds] = match;
|
const date = new Date(
|
parseInt(year, 10),
|
parseInt(month, 10) - 1,
|
parseInt(day, 10),
|
parseInt(hours, 10),
|
parseInt(minutes, 10),
|
parseInt(seconds, 10)
|
);
|
|
if (isNaN(date.getTime())) {
|
throw new Error("Invalid date");
|
}
|
|
// 由于小程序环境可能不支持 Intl.DateTimeFormat，我们使用简化的格式化方法
|
const formatted = `${year}年${this.formatMonth(month)}`;
|
return formatted;
|
},
|
// 简化的月份格式化函数，返回月份的中文表达
|
formatMonth(month) {
|
const months = [
|
"1月",
|
"2月",
|
"3月",
|
"4月",
|
"5月",
|
"6月",
|
"7月",
|
"8月",
|
"9月",
|
"10月",
|
"11月",
|
"12月",
|
];
|
return months[parseInt(month, 10) - 1];
|
},
|
// 金额显示.00格式
|
numFormat(value) {
|
if (!value) return "0.00";
|
value = Number(value).toFixed(2);
|
var intPart = Math.trunc(value); // 获取整数部分
|
var intPartFormat = intPart
|
.toString()
|
.replace(/(\d)(?=(?:\d{3})+$)/g, "$1,"); // 将整数部分逢三一断
|
var floatPart = ".00"; // 预定义小数部分
|
var value2Array = value.split(".");
|
// =2表示数据有小数位
|
if (value2Array.length === 2) {
|
floatPart = value2Array[1].toString(); // 拿到小数部分
|
if (floatPart.length === 1) {
|
return `${intPartFormat}.${floatPart}0`;
|
}
|
return `${intPartFormat}.${floatPart}`;
|
}
|
return intPartFormat + floatPart;
|
},
|
// 返回
|
goBack() {
|
let bookPathList = wx.getStorageSync("bookPathList");
|
if (bookPathList && JSON.parse(bookPathList).length) {
|
bookPathList = JSON.parse(bookPathList);
|
this.setData({
|
pageLoading: true,
|
tabValue: "brief",
|
});
|
this.onLoad(bookPathList[bookPathList.length - 1]);
|
bookPathList.pop();
|
wx.setStorageSync("bookPathList", JSON.stringify(bookPathList));
|
} else {
|
wx.navigateBack();
|
}
|
},
|
// 获取图书详情
|
getBookInfo(id) {
|
this.setData({
|
"mockData'.id": 0,
|
"mockData.price": 0,
|
"mockData.count": 0,
|
});
|
const query = {
|
storeInfo: this.data.options.storeInfo,
|
path: "*",
|
queryType: "*",
|
productId: id,
|
favoriteTypes: "FavoriteBookCity",
|
itemFields: {
|
"SysType=": "CmsFolder",
|
},
|
coverSize: {
|
height: 300,
|
},
|
fields: {
|
seriesName: [],
|
author: [],
|
isbn: [],
|
publicationDate: [],
|
bookClassification: [],
|
paperPrice: [],
|
JDLink: [],
|
tmallLink: [],
|
dangdangLink: [],
|
weidianLink: [],
|
content: [],
|
catalogue: [],
|
authorIntroduction: [],
|
// isApplyPaperBook: [],
|
// isApplyEBook: [],
|
isApplyBook: [],
|
isSell: [],
|
pdf: [],
|
protectedEpub: [],
|
probationPage: [], //pdf试读页数
|
freeEpubPage: [], //epub试读百分比
|
},
|
};
|
app.MG.store.getProductDetail(query).then(async (res) => {
|
this.getResourceCode(id, res.datas.rootCmsItemId)
|
console.log(res.datas, "res.datas")
|
this.setData({
|
bookDetail: res.datas,
|
buyIdList: res.datas.purchasedSaleMethodIdList,
|
pageLoading: false
|
});
|
if (res.datas.cmsDatas && res.datas.cmsDatas.length) {
|
this.setData({
|
cmsDatas: res.datas.cmsDatas[0].datas,
|
})
|
}
|
if (res.datas.datas.ProductLinkInfo) {
|
if (JSON.parse(res.datas.datas.ProductLinkInfo).length) this.setData({
|
relatedBookPath: JSON.parse(res.datas.datas.ProductLinkInfo)[0]
|
.LinkPath,
|
})
|
}
|
this.getSubTtem();
|
// 获取图书分类
|
if (res.datas.bookClassification) {
|
let classData = []
|
const bookClassification = JSON.parse(res.datas.bookClassification);
|
if (Array.isArray(bookClassification) && bookClassification.length) {
|
for (let index = 0; index < bookClassification.length; index++) {
|
const element = bookClassification[index];
|
const iconType = element[0];
|
const classType = element[1];
|
classData.push({
|
iconType,
|
classType
|
})
|
}
|
await this.getBookClass(classData);
|
}
|
}
|
if (this.data.tabValue == 'questionBank' || this.data.tabValue == 'jsek_cloudLearning' || this.data.tabValue == 'jsek_teachingResources') {
|
const checkData = this.data.cmsDatas.find(
|
(item) => item.refCode == this.data.tabValue
|
);
|
if (this.data.tabValue == "questionBank") {
|
this.getResourceData(checkData)
|
} else {
|
this.getResourceDataList(checkData)
|
}
|
}
|
|
// 获取组卷销售id
|
if (res.datas.saleMethod && res.datas.saleMethod.length) {
|
res.datas.saleMethod.forEach((item) => {
|
if (item.SaleType == "combinationTestPaper") {
|
this.setData({
|
"mockData.id": item.Id,
|
"mockData.price": item.Price,
|
});
|
}
|
});
|
}
|
// 获取组卷已购买次数
|
if (
|
res.datas.purchasedSaleMethodIdList &&
|
res.datas.purchasedSaleMethodIdList.length
|
) {
|
if (this.data.mockData.id) {
|
let count = res.datas.purchasedSaleMethodIdList.filter(
|
(item) => item == this.data.mockData.id
|
).length;
|
this.setData({
|
"mockData.count": count,
|
});
|
}
|
}
|
this.setData({
|
"bookDetail.publicationDate": this.data.bookDetail.publicationDate ? moment(this.data.bookDetail.publicationDate).format("YYYY年MM月") : '',
|
"bookDetail.price": this.numFormat(this.data.bookDetail.price),
|
"bookDetail.oldPrice": this.numFormat(this.data.bookDetail.oldPrice),
|
"bookDetail.paperPrice": this.numFormat(
|
this.data.bookDetail.paperPrice
|
),
|
|
});
|
});
|
},
|
getResourceCode(bookId, cmsId) {
|
let query = {
|
path: '*',
|
queryType: '*',
|
productId: bookId,
|
cmsPath: cmsId,
|
itemFields: {
|
SysType: 'Cms'
|
},
|
pading: {
|
start: 99,
|
size: 0
|
}
|
}
|
app.MG.store.getProductDetail(query).then((res) => {
|
let isBuyBank = true
|
let isShoppingBank = true
|
let bankSaleData = null
|
// 判断题库是否整体购买
|
const bank = res.datas.cmsDatas[0].datas.find((item) => item.refCode == 'questionBank')
|
if (bank) {
|
if (bank.saleMethod.length) {
|
bankSaleData = bank.saleMethod.find((item) => item.SaleType == 'Normal')
|
if (bankSaleData) {
|
isBuyBank = this.data.buyIdList.includes(bankSaleData.Id)
|
isShoppingBank = this.data.buyIdList.includes(bankSaleData.Id) ? true : this.data.shoppingCartGetId.includes(bankSaleData.Id)
|
}
|
}
|
}
|
this.setData({
|
resourceCodeList: res.datas.cmsDatas[0].datas,
|
learnTaskData: res.datas.cmsDatas[0].datas.filter((item) => item.refCode == 'jsek_learningTasks')[0],
|
isBuyBank,
|
isShoppingBank,
|
bankSaleData
|
})
|
if (res.datas.cmsDatas[0].datas.length) this.setData({
|
learnMenu: res.datas.cmsDatas[0].datas.find(item => item.refCode == 'jsek_cloudLearning')
|
})
|
})
|
},
|
//请求子商品的文件
|
getSubTtem() {
|
const obj = {
|
path: "*",
|
queryType: "SubProduct",
|
sort: {
|
type: "Desc",
|
field: "CreateDate",
|
},
|
paging: {
|
start: 0,
|
size: 6,
|
},
|
mainProductId: this.data.bookDetail.id,
|
fields: {
|
author: [],
|
bookshelf_pdf: [],
|
bookshelf_protectedEpub: [],
|
bookshelf_freeEpub: [], //epub试读百分比
|
bookshelf_probationPage: [], //pdf试读页数
|
},
|
};
|
app.MG.store.getProductList(obj).then((res) => {
|
if (res.datas && res.datas.length > 0) {
|
this.setData({
|
bookItemDetail: res.datas[0],
|
selectedIds: res.datas[0].defaultSaleMethod.id,
|
bookBuy: res.datas[0].purchasedSaleMethodIdList.indexOf(
|
res.datas[0].defaultSaleMethodId
|
) > -1,
|
"bookDetail.price": this.numFormat(res.datas[0].price),
|
});
|
let times = new Date(res.datas[0].defaultSaleMethod.endDate).getTime();
|
let startTime = new Date(
|
res.datas[0].defaultSaleMethod.beginDate
|
).getTime();
|
|
if (times < new Date().getTime() || new Date().getTime() < startTime) {
|
this.setData({
|
expire: true,
|
});
|
} else {
|
this.setData({
|
expire: false,
|
});
|
}
|
if (
|
res.datas[0].bookshelf_pdf ||
|
res.datas[0].bookshelf_protectedEpub
|
) {
|
this.setData({
|
noFile: true,
|
});
|
if (res.datas[0].bookshelf_pdf) {
|
this.setData({
|
"fileInfo.bookName": this.data.bookDetail.name,
|
"fileInfo.fileType": "pdf",
|
"fileInfo.md5": res.datas[0].bookshelf_pdf,
|
"fileInfo.freePage": res.datas[0].bookshelf_probationPage ? res.datas[0].bookshelf_probationPage : 30,
|
});
|
} else if (res.datas[0].bookshelf_protectedEpub) {
|
this.setData({
|
"fileInfo.bookName": this.data.bookDetail.name,
|
"fileInfo.fileType": "epub",
|
"fileInfo.md5": res.datas[0].bookshelf_protectedEpub,
|
"fileInfo.freePage": res.datas[0].bookshelf_freeEpub ? res.datas[0].bookshelf_freeEpub : 30,
|
});
|
}
|
}
|
} else {
|
if (this.data.bookDetail.pdf || this.data.bookDetail.protectedEpub) {
|
this.setData({
|
noFile: true,
|
});
|
if (this.data.bookDetail.pdf) {
|
this.setData({
|
"fileInfo.bookName": this.data.bookDetail.name,
|
"fileInfo.fileType": "pdf",
|
"fileInfo.md5": this.data.bookDetail.pdf,
|
"fileInfo.freePage": this.data.bookDetail.probationPage ? this.data.bookDetail.probationPage : 30,
|
});
|
} else if (this.data.bookDetail.protectedEpub) {
|
|
this.setData({
|
"fileInfo.bookName": this.data.bookDetail.name,
|
"fileInfo.fileType": "epub",
|
"fileInfo.md5": this.data.bookDetail.protectedEpub,
|
"fileInfo.freePage": this.data.bookDetail.freeEpubPage ? this.data.bookDetail.freeEpubPage : 30,
|
});
|
}
|
}
|
this.setData({
|
selectedIds: this.data.bookDetail.defaultSaleMethodId,
|
bookBuy: this.data.bookDetail.purchasedSaleMethodIdList.indexOf(
|
this.data.bookDetail.defaultSaleMethodId
|
) > -1,
|
});
|
let times = new Date(
|
this.data.bookDetail.defaultSaleMethod.endDate
|
).getTime();
|
let startTime = new Date(
|
this.data.bookDetail.defaultSaleMethod.beginDate
|
).getTime();
|
if (times < new Date().getTime() || new Date().getTime() < startTime) {
|
this.setData({
|
expire: true,
|
});
|
} else {
|
this.setData({
|
expire: false,
|
});
|
}
|
}
|
});
|
},
|
// 获取图书分类
|
async getBookClass(list) {
|
let name = "";
|
const query = {
|
refCodes: ["bookClassification"],
|
};
|
await app.MG.store.getProductTypeField(query).then((res) => {
|
for (let aindex = 0; aindex < list.length; aindex++) {
|
const aitem = list[aindex];
|
const iconType = aitem.iconType
|
const classType = aitem.classType
|
JSON.parse(res[0].config).option.forEach((item) => {
|
if (item.value == iconType) {
|
if (item.child && item.child.length) {
|
item.child.forEach((citem) => {
|
if (citem.value == classType) {
|
const flag = this.data.bookClass.findIndex((ditem) => ditem == citem.name)
|
if (flag == -1) {
|
let list = this.data.bookClass
|
list.push(citem.name)
|
this.setData({
|
bookClass: list
|
})
|
}
|
}
|
});
|
}
|
|
}
|
});
|
}
|
|
});
|
},
|
// 收藏
|
setCollect() {
|
const token = wx.getStorageSync(app.config.tokenKey);
|
if (!token) {
|
// 检查登录状态
|
loginInfo(app, (data) => {
|
// 如果不是第一次登录，会执行回调
|
if (data) {
|
// 登录成功，自动记录token和用户信息，并返回true
|
this.getBookInfo(this.data.bookId);
|
} else {
|
// 出现错误，返回false
|
}
|
});
|
} else {
|
if (this.data.bookDetail.isFavourite) {
|
app.MG.store
|
.delProductLink({
|
productIds: [this.data.bookDetail.id],
|
linkType: "FavoriteBookCity",
|
})
|
.then(() => {
|
this.setData({
|
"bookDetail.isFavourite": false,
|
});
|
});
|
} else {
|
const params = {
|
productIds: [this.data.bookDetail.id],
|
linkType: "FavoriteBookCity",
|
};
|
app.MG.store.addProductLink(params).then((res) => {
|
this.setData({
|
"bookDetail.isFavourite": true,
|
});
|
});
|
}
|
}
|
},
|
// 我要建议
|
suggestBtn() {
|
// 检查登录状态
|
const token = wx.getStorageSync(app.config.tokenKey);
|
const child = this.selectComponent("#suggest-component");
|
if (token)
|
// child.showDialog();
|
this.setData({
|
showIndex: '1'
|
})
|
},
|
// 跳转网店
|
goShop(e) {
|
const {
|
link
|
} = e.currentTarget.dataset;
|
wx.navigateTo({
|
url: `/packageBookService/pages/bookServices/linkPage/index?path=${link}`,
|
});
|
},
|
// tag切换
|
onTabsChange(e) {
|
const token = wx.getStorageSync(app.config.tokenKey);
|
this.setData({
|
tabValue: e.detail.value,
|
noResources: false,
|
});
|
if (
|
e.detail.label == "教学资源" ||
|
e.detail.label == "云学习" ||
|
e.detail.label == "云测试"
|
) {
|
const checkData = this.data.cmsDatas.find(
|
(item) => item.refCode == this.data.tabValue
|
);
|
if (!this.data.resourceClassList.length) this.getResourceClass()
|
if (checkData) {
|
if (e.detail.value == "jsek_cloudLearning") {
|
this.setData({
|
"buyResourceData.productLinkPath": checkData.productLinkPath,
|
"buyResourceData.refCode": checkData.refCode,
|
});
|
}
|
// if (
|
// (e.detail.value == "jsek_teachingResources" &&
|
// !this.data.teach.length) ||
|
// (e.detail.value == "jsek_cloudLearning" && !this.data.learn.length) ||
|
// (e.detail.value == "questionBank" && !this.data.test.length)
|
// ) {
|
// if (e.detail.value == "jsek_teachingResources") {
|
// wx.setStorageSync('teachResourcesPath', checkData.productLinkPath)
|
// }
|
// this.getResourceData(checkData);
|
// }
|
if ((e.detail.value == "jsek_teachingResources" && !this.data.teach.length) || (e.detail.value == "jsek_cloudLearning" && !this.data.learn.length)) {
|
wx.setStorageSync('teachResourcesPath', checkData.productLinkPath)
|
this.getResourceDataList(checkData)
|
} else if (e.detail.value == "questionBank" && !this.data.test.length) {
|
this.getResourceData(checkData);
|
}
|
if (e.detail.value == "questionBank" && token) this.getMockData();
|
} else {
|
this.setData({
|
noResources: true,
|
});
|
}
|
} else if (e.detail.label == "云笔记") {
|
const token = wx.getStorageSync(app.config.tokenKey);
|
const child = this.selectComponent("#note");
|
child.handleSubmitTitle();
|
if (token) {
|
child.changeLoading();
|
child.getNoteList();
|
} else {
|
child.changeNoList();
|
}
|
} else if (e.detail.label == "电子书") {
|
const child = this.selectComponent("#eBook");
|
if (child) {
|
child.getProgress();
|
}
|
} else if (e.detail.label == "相关图书") {
|
this.getAboutBook(this.data.relatedBookPath);
|
}
|
},
|
// 获取资源所属分类
|
getResourceClass() {
|
let query = {
|
refCodes: ["resourcesClassification"],
|
};
|
app.MG.store.getProductTypeField(query).then((res) => {
|
this.setData({
|
resourceClassList: JSON.parse(res[0].config).option,
|
});
|
});
|
},
|
|
// 获取所有子项数量
|
getChildrenItem(data) {
|
let num = 0
|
|
function getNum(data) {
|
for (let index = 0; index < data.length; index++) {
|
const item = data[index];
|
if (item.sysType == 'CmsItem') {
|
num += 1
|
} else if (item.sysType == 'CmsFolder') {
|
if (item.children && item.children.length)
|
getNum(item.children)
|
}
|
}
|
}
|
getNum(data)
|
return num
|
},
|
|
// 给目录添加子项数量
|
changeResourceChildren(list) {
|
const changeList = (list) => {
|
for (let index = 0; index < list.length; index++) {
|
const item = list[index];
|
if (item.sysType == 'CmsFolder' && item.children && item.children.length) {
|
item.childrenItem = this.getChildrenItem([item])
|
changeList(item.children)
|
} else if (item.sysType == 'CmsFolder' && item.children && !item.children.length) {
|
item.childrenItem = 0
|
} else if (item.sysType == 'CmsFolder' && !item.children) {
|
item.childrenItem = 0
|
}
|
}
|
}
|
changeList(list)
|
return list
|
},
|
|
// 扁平化数据转换tree
|
getTreeList(rootList, newArr, path) {
|
for (const item of rootList) {
|
if (path == item.productLinkPath.replace('\\' + item.id, '')) {
|
if (item.sysType == 'CmsItem') {
|
if (item.selectType == 'webpage') {
|
item.disabled = true
|
} else {
|
if (item.isDownload != 1) {
|
item.disabled = true
|
}
|
}
|
if (item.file && item.fileMap && item.fileMap[item.file]) {
|
if (item.fileMap[item.file].protectType == 'Private') item.disabled = true
|
}
|
}
|
// newArr.push(item)
|
// 在插入过程中对数据进行排序
|
newArr = this.insertAndSortObjectsById(newArr, item)
|
// 插进数组后 从原数据中删除
|
rootList = rootList.filter(nitem => nitem.id != item.id)
|
}
|
}
|
//给数组里面再添加一个children的空数组
|
for (const i of newArr) {
|
i.children = []
|
this.getTreeList(rootList, i.children, i.productLinkPath)
|
if (i.children.length == 0) {
|
delete i.children
|
}
|
}
|
return newArr
|
},
|
|
// 去除树结构多余项
|
ensureTreeConsistency(tree) {
|
for (let index = 0; index < tree.length; index++) {
|
const item = tree[index];
|
if (item.children && item.children.length) {
|
const isFloder = item.children.findIndex(citem => citem.sysType == 'CmsFolder')
|
const isItem = item.children.findIndex(citem => citem.sysType == 'CmsItem')
|
if (isFloder > -1 && isItem > -1) {
|
item.children = item.children.filter(ditem => ditem.sysType == 'CmsItem')
|
}
|
this.ensureTreeConsistency(item.children)
|
}
|
}
|
return tree
|
},
|
|
// 排序数组 按照id
|
insertAndSortObjectsById(array, newObj) {
|
// 查找新对象应该插入的位置
|
let insertIndex = array.findIndex(obj => newObj.id < obj.id);
|
// 如果没有找到合适的位置，则放在数组末尾
|
if (insertIndex === -1) {
|
insertIndex = array.length;
|
}
|
// 插入新对象到数组
|
array.splice(insertIndex, 0, newObj);
|
// 对数组进行排序
|
array.sort((a, b) => {
|
if (a.id < b.id) return -1;
|
if (a.id > b.id) return 1;
|
return 0;
|
});
|
// 返回更新后的数组
|
return array;
|
},
|
// 递归树结构，如果父级有销售方式(有效期)，去掉所有子集的销售方式
|
clearTreeSealmethod(clearSaleMethod, tree) {
|
for (let item of tree) {
|
const saleData = item.saleMethod &&
|
item.saleMethod.length ?
|
item.saleMethod.find((citem) => citem.SaleType == 'Normal') : null
|
if (
|
((saleData && new Date(saleData.EndDate).getTime() >= new Date().getTime() && new Date(saleData.BeginDate).getTime() <= new Date().getTime()) ||
|
clearSaleMethod) && item.children && item.children.length
|
) {
|
item.children.forEach((ditem) => (ditem.saleMethod = []))
|
}
|
if (item.children && item.children.length)
|
this.clearTreeSealmethod(
|
saleData && new Date(saleData.EndDate).getTime() >= new Date().getTime() && new Date(saleData.BeginDate).getTime() <= new Date().getTime(),
|
item.children
|
)
|
}
|
return tree
|
},
|
// 教学资源 云学习 获取
|
getResourceDataList(type) {
|
this.setData({
|
loading: true,
|
noResources: false,
|
});
|
let query = {
|
path: '*',
|
queryType: '*',
|
productId: this.data.bookDetail.id,
|
cmsPath: type.productLinkPath,
|
cmsType: '*',
|
itemFields: {
|
SysType: 'CmsFolder',
|
// 资源类型，试读文件，是否允许下载等参数
|
selectType: [],
|
learnSelectType: [],
|
freeFile: [],
|
file: [],
|
protectedFile: [],
|
resourcesClassification: [],
|
// isDownload: [],
|
jsek_resourceBrief: [],
|
jsek_link: [],
|
},
|
pading: {
|
start: 0,
|
size: 999
|
},
|
}
|
app.MG.store.getProductDetailNoChildren(query).then((res) => {
|
if (!res.datas.cmsDatas[0].datas.length || res.datas.cmsDatas[0].datas.length == 0) {
|
return this.setData({
|
noResources: true,
|
loading: false,
|
});
|
}
|
|
let list = []
|
// 判断云学习有无销售方式和有效期
|
const cloundSaleMethod =
|
type.saleMethod && type.saleMethod.length ?
|
type.saleMethod.find((citem) => citem.SaleType == 'Normal') :
|
null
|
let flags =
|
type.refCode == 'jsek_cloudLearning' &&
|
cloundSaleMethod &&
|
new Date().getTime() <= new Date(cloundSaleMethod.EndDate).getTime() &&
|
new Date().getTime() >= new Date(cloundSaleMethod.BeginDate).getTime()
|
let md5s = []
|
res.datas.cmsDatas[0].datas.forEach((item) => {
|
// 云学习上有销售方式，去掉云学习下所有销售方式
|
if (this.data.tabValue == "jsek_teachingResources") {
|
|
if (item.file || item.freeFile) {
|
let md5 = item.file ? item.file : item.freeFile
|
md5s.push(md5)
|
}
|
this.setData({
|
md5List: md5s,
|
});
|
}
|
if (flags) item.saleMethod = []
|
item.checked = false;
|
if (item.sysType == 'CmsItem') {
|
// 教学资源 类型名称赋值
|
this.data.resourceClassList.forEach((type) => {
|
if (type.value == item.resourcesClassification)
|
item.resourceClass = type.name;
|
});
|
// if (this.data.tabValue == "jsek_teachingResources") {} else if (this.data.tabValue == "jsek_cloudLearning") {
|
// item.isbuy = this.isShowNeedBuy(item);
|
// item.isShopCar = this.isShoppingCart(item);
|
// }
|
}
|
});
|
// 判断处理资源
|
if (res.datas.cmsDatas[0].datas.some((item) => item.sysType == 'CmsFolder')) {
|
if (!res.datas.cmsDatas[0].datas.some((item) => item.sysType == 'CmsItem')) {
|
// 1.只有目录，没有资源
|
list = res.datas.cmsDatas[0].datas
|
} else {
|
this.getTreeList(res.datas.cmsDatas[0].datas, list, query.cmsPath)
|
list = this.ensureTreeConsistency(list)
|
list = this.changeResourceChildren(list)
|
}
|
} else {
|
// 3.只有资源，没有目录
|
list = res.datas.cmsDatas[0].datas
|
}
|
let result = [];
|
if (type.refCode == "jsek_teachingResources") {
|
this.findChildIds(list, result);
|
this.setData({
|
openTeachids: result,
|
loading: false,
|
teach: list,
|
});
|
} else if (type.refCode == "jsek_cloudLearning") {
|
// 云学习上无销售方式，走目录 资源 销售方式去除方法
|
if (!flags) list = this.clearTreeSealmethod(false, list)
|
// 判断领取查看是否显示(云学习，或资源目录，有售价为0)
|
let isshowDrawBtn = res.datas.cmsDatas[0].datas.some(
|
(item) =>
|
item.saleMethod.length &&
|
item.saleMethod.find((citem) => citem.SaleType == 'Normal').Price == 0 &&
|
new Date(item.saleMethod.find((citem) => citem.SaleType == 'Normal').EndDate).getTime() >= new Date().getTime() &&
|
new Date(item.saleMethod.find((citem) => citem.SaleType == 'Normal').BeginDate).getTime() <= new Date().getTime()
|
) || (flags && cloundSaleMethod.Price == 0)
|
// 判断云学习全部购买按钮是否显示
|
let isShowBuyCloundMenu = flags && cloundSaleMethod.Price >= 0 && !this.data.buyIdList.includes(cloundSaleMethod.Id)
|
// 判断资源购买按钮是否显示
|
let isShowBuyCloundBtn = !flags && res.datas.cmsDatas[0].datas.some(citem => citem.saleMethod.length != 0)
|
// 判断购物车按钮和锁按钮是否显示
|
this.handleTreeData(list).forEach(item => {
|
item.isbuy = this.resourceIsBuy(item);
|
item.isShopCar = this.isShoppingCart(item);
|
})
|
this.findChildIds(list, result);
|
this.setData({
|
isshowDrawBtn,
|
isShowBuyCloundMenu,
|
isShowBuyCloundBtn,
|
isCloundHaveSaleMethod: flags,
|
learn: list,
|
loading: false,
|
openLearnids: result,
|
learnPath: type.productLinkPath
|
});
|
}
|
})
|
},
|
// 获取 云测试
|
getResourceData(type) {
|
var that = this
|
that.setData({
|
loading: true,
|
noResources: false,
|
});
|
let query = {
|
path: "*",
|
queryType: "*",
|
storeInfo: that.data.options.storeInfo,
|
productId: that.data.bookDetail.id,
|
cmsPath: type.productLinkPath,
|
cmsType: '*',
|
itemFields: {
|
SysType: "CmsFolder",
|
// 资源类型，试读文件，是否允许下载等参数
|
selectType: [],
|
freeFile: [],
|
file: [],
|
resourcesClassification: [],
|
isDownload: [],
|
jsek_resourceBrief: [],
|
jsek_link: [],
|
jsek_questionBank: [],
|
},
|
pading: {
|
start: 0,
|
size: 999,
|
},
|
};
|
app.MG.store
|
.getProductDetail(query)
|
.then(async (res) => {
|
// 云测试，递归请求里层数据
|
if (type.refCode == "questionBank") {
|
let data = []
|
let result = [];
|
const isTSFW = res.datas.cmsDatas[0].datas.filter(
|
(item) =>
|
item.type == 'questionBankFolder' &&
|
(item.name == '填空题' ||
|
item.name == '判断题' ||
|
item.name == '单选题' ||
|
item.name == '多选题' ||
|
item.name == '简答题')
|
)
|
if (that.data.options.storeInfo == 'jsek_jslx') {
|
data = res.datas.cmsDatas[0].datas.filter((item) => item.type == 'questionBankFolder');
|
if (data.length > 0) {
|
that.setData({
|
test: data,
|
loading: false,
|
openTeachids: result,
|
});
|
} else {
|
that.setData({
|
noResources: true,
|
loading: false,
|
});
|
}
|
} else {
|
|
if (isTSFW.length > 0) {
|
data = res.datas.cmsDatas[0].datas.filter((item) => item.type == 'questionBankFolder' && (item.childrenFolderCount > 0 || item.childrenCount > 0) && (item.name !== '填空题' &&
|
item.name !== '判断题' &&
|
item.name !== '多选题' &&
|
item.name !== '简答题') && item.name !== '单选题')
|
that.setData({
|
jslx: false,
|
});
|
} else {
|
data = res.datas.cmsDatas[0].datas.filter((item) => item.type == 'questionBankFolder' && item.refCode != 'jsek_interaction')
|
// && item.refCode != 'jsek_interaction'
|
that.setData({
|
jslx: true,
|
});
|
}
|
if (data.length > 0) {
|
console.log('data', data);
|
let list = []
|
that.getTreeList(data, list, query.cmsPath)
|
list = that.ensureTreeConsistency(list)
|
that.findChildIds(list[0].children, result);
|
that.setData({
|
test: list.length == 1 && list[0].name == '题库' ? list[0].children : list,
|
loading: false,
|
openTeachids: result,
|
});
|
//Json赋值
|
// const bookId = that.data.bookId
|
// if (bookId == 6619) {
|
// const jsonData = {}
|
// jsonData.name = "心理测评"
|
// jsonData.children = [...pastData.postData.list]
|
// var test = that.data.test;
|
// test.push(jsonData);
|
// that.setData({
|
// test: test,
|
// });
|
// console.log(that.data.test, "教学互动");
|
// }
|
|
} else {
|
that.setData({
|
noResources: true,
|
loading: false,
|
});
|
}
|
}
|
}
|
})
|
.catch((e) => {
|
console.log(e);
|
});
|
},
|
|
// 获取展开项
|
findChildIds(data, result) {
|
let index = 0
|
if (data)
|
for (let i = 0; i < data.length; i++) {
|
if (index < 3) {
|
const item = data[i]
|
if (item.children && item.children.length > 0) {
|
result.push(item.id)
|
if (item.children) {
|
for (let j = 0; j < item.children.length; j++) {
|
if (index < 3) {
|
const childrenItme = item.children[j]
|
if (item.childrenCount > 0) {
|
result.push(childrenItme.id)
|
index += 1
|
}
|
} else {
|
break
|
}
|
}
|
}
|
} else if (item.childrenCount > 0) {
|
result.push(item.id)
|
index += 1
|
}
|
} else {
|
break
|
}
|
}
|
},
|
|
// 图书添加购物车
|
async addBookShopcCar() {
|
if (!this.data.expire) {
|
const shoppingCartGetId = [];
|
let query = {
|
start: 0,
|
size: 9999,
|
filterList: [],
|
searchList: [],
|
};
|
const res = await app.MG.store.getShoppingCartProductList(query);
|
res.datas.forEach((item) => {
|
shoppingCartGetId.push(item.saleMethod.id);
|
});
|
const determine = shoppingCartGetId.some(
|
(item) => item == this.data.selectedIds
|
);
|
if (!determine) {
|
let query = {
|
requests: [{
|
saleMethodId: this.data.selectedIds,
|
storeEventId: null,
|
agentCode: "电子书",
|
}, ],
|
};
|
const addRes = app.MG.store.addShoppingCart(query);
|
this.showSuccessToast();
|
} else {
|
Toast({
|
context: this,
|
selector: "#t-toast",
|
message: "该书已在购物车，请勿重复添加",
|
theme: "warning",
|
direction: "column",
|
});
|
}
|
} else {
|
wx.showToast({
|
title: "商品不在有效期",
|
icon: "none",
|
duration: 1000,
|
});
|
}
|
},
|
|
showSuccessToast() {
|
Toast({
|
context: this,
|
selector: "#t-toast",
|
message: "添加成功",
|
theme: "success",
|
direction: "column",
|
});
|
},
|
|
async buyBook() {
|
if (!this.data.expire) {
|
let bookOrdersId = "";
|
let query = {
|
remarks: "电子书",
|
requests: [{
|
saleMethodId: this.data.bookItemDetail.defaultSaleMethodId ?
|
this.data.bookItemDetail.defaultSaleMethodId : this.data.bookDetail.defaultSaleMethodId,
|
count: 1,
|
}, ],
|
};
|
// 发起订单初始化请求并等待结果
|
const res = await app.MG.store.initOrder(query);
|
// 获取订单号并赋值给 orderNumber.value
|
bookOrdersId = res.orderNumber;
|
// 检查订单号是否存在
|
if (bookOrdersId) {
|
if (this.data.bookDetail.price == "0.00") {
|
app.MG.store
|
.confirmOrder({
|
orderNum: bookOrdersId,
|
})
|
.then((res) => {
|
if (res) {
|
wx.showToast({
|
title: "领取成功",
|
icon: "none",
|
duration: 1000,
|
});
|
this.getBookInfo(this.data.bookDetail.id);
|
}
|
});
|
} else {
|
const url = "/pages/cart/paymentPage/index?orderNumber=" + bookOrdersId + '&onNorderSaleMethod=' + res.saleMethodLinks[0].orderSaleMethod.id;
|
wx.navigateTo({
|
url,
|
});
|
}
|
} else {}
|
} else {
|
wx.showToast({
|
title: "商品不在有效期",
|
icon: "none",
|
duration: 1000,
|
});
|
}
|
},
|
|
// 获取教学资源下载是否申请通过
|
async getApplyInfo(id) {
|
// 获取当前时间
|
const currentDate = new Date();
|
let query = {
|
sort: {
|
type: "Desc",
|
field: "CreateDate",
|
},
|
start: 0,
|
size: 99999,
|
appRefCode: app.config.appRefCode,
|
topicIdOrRefCode: "productDownLoad",
|
};
|
await app.MG.ugc.getTopicMessageList(query).then((res) => {
|
const applyResource = res.datas.find((item) => {
|
let content = [];
|
try {
|
content = JSON.parse(item.content);
|
} catch (error) {
|
content = [];
|
}
|
if (Array.isArray(content))
|
return content.find((citem) => citem.id == id);
|
return false;
|
});
|
// 有申请记录
|
if (applyResource) {
|
if (applyResource.state == "Reject") {
|
this.setData({
|
rejectCause: JSON.parse(applyResource.feedBack).reason,
|
applyState: "Reject",
|
});
|
} else if (applyResource.state == "Normal") {
|
const endDate = JSON.parse(applyResource.feedBack).endDate;
|
// const endDate = new Date(JSON.parse(applyResource.feedBack).endDate + ' 23:59:59').getTime()
|
if (endDate == "永久") {
|
this.setData({
|
applyState: "Normal",
|
deadline: "永久",
|
});
|
} else {
|
let endTime = new Date(endDate + " 23:59:59").getTime();
|
this.setData({
|
deadline: endDate + " 23:59:59",
|
});
|
if (currentDate.getTime() < endTime) {
|
// 未超时
|
this.setData({
|
applyState: "Normal",
|
});
|
} else {
|
this.setData({
|
applyState: "none",
|
});
|
}
|
}
|
} else {
|
this.setData({
|
applyState: applyResource.state,
|
});
|
}
|
} else {
|
this.setData({
|
applyState: "none",
|
});
|
}
|
});
|
this.setData({
|
applyResourceState: false,
|
});
|
wx.hideLoading();
|
},
|
// 申请教学资源
|
applyResource() {
|
// if (this.data.applyResourceState) {
|
// return wx.showToast({
|
// icon: "error",
|
// title: "请勿重复点击",
|
// });
|
// }
|
this.setData({
|
applyResourceState: true,
|
});
|
let role = JSON.parse(wx.getStorageSync(app.config.userInfoKey)).role;
|
if (role) {
|
if (role == "Teacher") {
|
wx.showLoading({
|
title: "加载中",
|
});
|
// 申请教学资源
|
let query = {
|
topicIdOrRefCode: "productDownLoad",
|
type: "applyForDownload",
|
state: "WaitAudit",
|
cmsTypeRefCode: "",
|
newDataListRequest: [],
|
name: this.data.bookDetail.name, // name为申请的书本名称
|
content: JSON.stringify([{
|
name: this.data.bookDetail.name,
|
id: this.data.bookDetail.id,
|
// defaultSaleMethodId: bookData.value.defaultSaleMethodId,
|
icon: this.data.bookDetail.icon,
|
}, ]),
|
};
|
app.MG.ugc.newTopicMessage(query).then(async (res) => {
|
if (res) {
|
wx.showToast({
|
title: "申请已提交",
|
duration: 2000,
|
});
|
}
|
await this.getApplyInfo(this.data.bookDetail.id);
|
});
|
} else {
|
wx.showModal({
|
title: "尊敬的用户，您好！",
|
content: "请先进行教师认证！",
|
confirmColor: "#ff6c00",
|
cancelColor: "#949494",
|
complete: (res) => {
|
if (res.cancel) {}
|
if (res.confirm) {
|
wx.navigateTo({
|
url: "/packageDomain/pages/teacherCertification/index",
|
});
|
}
|
},
|
});
|
}
|
} else {
|
wx.showModal({
|
title: "尊敬的用户，您好！",
|
content: "请先进行教师认证！",
|
confirmColor: "#ff6c00",
|
cancelColor: "#949494",
|
complete: (res) => {
|
if (res.cancel) {}
|
if (res.confirm) {
|
wx.navigateTo({
|
url: "/packageDomain/pages/teacherCertification/index",
|
});
|
}
|
},
|
});
|
}
|
},
|
// 教学资源下载前往PC提示Diialog
|
closeTeachDownload() {
|
this.setData({
|
isShowTeachDownload: false,
|
});
|
},
|
// 下载功能
|
downloadTeach(e) {
|
let role = JSON.parse(wx.getStorageSync(app.config.userInfoKey)).role;
|
if (role && role == "Teacher") {
|
this.setData({
|
isShowTeachDownload: true,
|
});
|
} else {
|
wx.showModal({
|
title: "尊敬的用户，您好！",
|
content: "请先进行教师认证！",
|
confirmColor: "#ff6c00",
|
cancelColor: "#949494",
|
complete: (res) => {
|
if (res.cancel) {}
|
if (res.confirm) {
|
wx.navigateTo({
|
url: "/packageDomain/pages/teacherCertification/index",
|
});
|
}
|
},
|
});
|
}
|
// const data = e.detail.value
|
// // const data
|
// // let role = userStore.userInfo ? userStore.userInfo.role : null
|
// // if (role) {
|
// // if (role == 'Teacher') {
|
// if (this.properties.applyState == 'Normal' || this.properties.applyState == 'none') {
|
// // 是否允许下载
|
// if (data.isDownload == 1) {
|
// // 申请通过
|
// let url = app.config.requestCtx + '/file/api/ApiDownloadForAuthorize?md5='
|
// if (data.file) {
|
// // 判断是否私有
|
// if (data.fileMap[data.file].protectType == 'Private')
|
// return Message.error({
|
// context: this,
|
// offset: ['20rpx', '32rpx'],
|
// duration: 5000,
|
// content: '该文件无法下载'
|
// })
|
// url = url + data.file + '&token=' + wx.getStorageSync('jsek-token')
|
// } else if (data.freeFile) {
|
// url = url + data.freeFile + '&token=' + wx.getStorageSync('jsek-token')
|
// } else {
|
// Message.error({
|
// context: this,
|
// offset: ['20rpx', '32rpx'],
|
// duration: 5000,
|
// content: '暂无资源',
|
// })
|
// }
|
// this.downloadFile(url)
|
// } else {
|
// Message.error({
|
// context: this,
|
// offset: ['20rpx', '32rpx'],
|
// duration: 5000,
|
// content: '该资源无法下载',
|
// })
|
// }
|
// } else if (this.properties.applyState == 'WaitAudit') {
|
// // ElMessageBox.confirm('请先申请下载！', '尊敬的用户，您好！', {
|
// // confirmButtonText: '申请',
|
// // cancelButtonText: '取消',
|
// // type: 'warning'
|
// // })
|
// // .then(() => applyBookInfo())
|
// // .catch()
|
// Message.error({
|
// context: this,
|
// offset: ['20rpx', '32rpx'],
|
// duration: 5000,
|
// content: '该资源下载申请审核中',
|
// })
|
// } else if (this.properties.applyState == 'Reject') {
|
// Message.error({
|
// context: this,
|
// offset: ['20rpx', '32rpx'],
|
// duration: 5000,
|
// content: '资源下载申请未通过'
|
// })
|
|
// } else {
|
// // Message.error({
|
// // context: this,
|
// // offset: ['20rpx', '32rpx'],
|
// // duration: 5000,
|
// // content: '请先申请下载'
|
// // })
|
// console.log('请先申请下载');
|
// }
|
// // } else {
|
// // ElMessageBox.confirm('请先进行教师认证！', '尊敬的用户，您好！', {
|
// // confirmButtonText: '去认证',
|
// // cancelButtonText: '取消',
|
// // type: 'warning'
|
// // })
|
// // .then(() => {
|
// // isShow.value = true
|
// // })
|
// // .catch(() => { })
|
// // }
|
// // } else {
|
// // logIn()
|
// // }
|
},
|
downloadFile(url) {
|
wx.downloadFile({
|
url: url,
|
success: function (res) {
|
// 下载成功后，调用saveImageToPhotosAlbum函数保存图片到本地
|
wx.saveFile({
|
tempFilePath: res.tempFilePath,
|
success: function (res) {
|
wx.showToast({
|
title: "下载成功",
|
icon: "success",
|
});
|
},
|
fail: function (res) {
|
wx.showToast({
|
title: "下载失败",
|
icon: "none",
|
});
|
},
|
});
|
},
|
fail: function (res) {
|
wx.showToast({
|
title: "下载失败",
|
icon: "none",
|
});
|
},
|
});
|
},
|
// 判断资源是否购买
|
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.data.buyIdList.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;
|
}
|
},
|
// 云学习资源是否显示锁图标（未购买，且资源售价大于零）
|
isShowNeedBuy(data) {
|
if (data.saleMethod && data.saleMethod.length) {
|
const isSHow = this.data.buyIdList.some(
|
(item) => item == data.saleMethod[0].Id
|
);
|
if (isSHow) {
|
return false;
|
} else {
|
return data.saleMethod[0].Price > 0 ? true : false;
|
}
|
return !isSHow;
|
} else {
|
return false;
|
}
|
},
|
// 获取已购买商品
|
getShoppingCartProductGet() {
|
let query = {
|
start: 0,
|
size: 999,
|
filterList: [],
|
searchList: [],
|
};
|
app.MG.store.getShoppingCartProductList(query).then((res) => {
|
const list = [];
|
res.datas.forEach((item) => {
|
list.push(item.saleMethod.id);
|
});
|
this.setData({
|
shoppingList: res.datas,
|
shoppingCartGetId: list,
|
});
|
});
|
},
|
// 判断资源加入购物车按钮是否显示
|
isShoppingCart(data) {
|
if (data.saleMethod && data.saleMethod.length) {
|
const saleData = data.saleMethod.find((item) => item.SaleType == 'Normal')
|
// 先判断是否免费
|
if (saleData.Price <= 0) return false
|
// 再判断是否购买
|
const isBuy = this.data.buyIdList.some((item) => item == saleData.Id)
|
if (isBuy) {
|
// 购买了
|
return false
|
} else {
|
// 判断是否加入购物车
|
const isShow = this.data.shoppingCartGetId.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;
|
}
|
},
|
|
updateShoppingCartHidden() {
|
const isSHow = this.data.shoppingCartGetId.some(
|
(item) => item == data.saleMethod[0].Id
|
);
|
return !isSHow;
|
},
|
//刷新购物车图标
|
updateCloudLearning() {
|
this.getBookInfo()
|
this.getShoppingCartProductGet()
|
const checkData = this.data.cmsDatas.find(
|
(item) => item.refCode == "jsek_cloudLearning"
|
);
|
this.getResourceDataList(checkData);
|
},
|
// 遍历树结构转换为数组方法
|
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;
|
},
|
// 云学习一键领取
|
async getFreeResource() {
|
const child = this.selectComponent("#learn-resource");
|
const token = wx.getStorageSync(app.config.tokenKey);
|
if (!token) {
|
loginInfo(app, (data) => {
|
// 如果不是第一次登录，会执行回调
|
if (data) {
|
// 登录成功，自动记录token和用户信息，并返回true
|
} else {
|
// 出现错误，返回false
|
}
|
});
|
}
|
// 领取查看 ，先看云学习上的 再看资源上的
|
const cloundMenu = this.data.resourceCodeList.find((item) => item.refCode == 'jsek_cloudLearning')
|
const cloundMenuSaleMethod =
|
cloundMenu.saleMethod && cloundMenu.saleMethod.length ?
|
cloundMenu.saleMethod.find((ditem) => ditem.SaleType == 'Normal') :
|
undefined
|
let query = {}
|
if (this.data.isCloundHaveSaleMethod && !cloundMenuSaleMethod.Price) {
|
// 云学习上有销售方式，且为0元，直接领取云学习
|
query = {
|
remarks: '云学习',
|
requests: [{
|
saleMethodId: cloundMenuSaleMethod.Id,
|
count: 1
|
}]
|
}
|
} else {
|
// 领取资源
|
let arr = this.handleTreeData(this.data.learn).filter(item => this.resourceIsBuy(item))
|
let freeIds = arr.filter((item) => {
|
return item.saleMethod.find((citem) => citem.SaleType == 'Normal').Price == 0
|
})
|
if (!freeIds.length)
|
return wx.showToast({
|
icon: "error",
|
title: "暂无免费资源",
|
});
|
let requests = [];
|
freeIds.forEach((item, index) => {
|
if (this.resourceIsBuy(item)) {
|
requests.push({
|
saleMethodId: item.saleMethod[0].Id,
|
count: 1,
|
});
|
}
|
});
|
query = {
|
remarks: "云学习",
|
requests,
|
};
|
}
|
child.changeReceive(true);
|
try {
|
const initOrderRes = await app.MG.store.initOrder(query);
|
let parameter = {
|
orderNum: initOrderRes.orderNumber,
|
};
|
// 确认订单
|
const confirmOrderRes = await app.MG.store.confirmOrder(parameter);
|
if (confirmOrderRes.orderNumber) {
|
child.changeReceive(false);
|
wx.showToast({
|
title: "领取成功",
|
});
|
this.getBookInfo(this.data.bookId);
|
this.getResourceDataList({
|
refCode: 'jsek_cloudLearning',
|
productLinkPath: this.data.learnPath
|
})
|
this.setData({
|
successOrderNumber: confirmOrderRes.orderNumber
|
})
|
}
|
} catch (error) {
|
console.log(error);
|
}
|
},
|
// 云学习一键购买
|
async allAddShoppiingCar() {
|
const child = this.selectComponent("#learn-resource");
|
const token = wx.getStorageSync("jsek-token");
|
if (!token) {
|
return wx.getUserProfile({
|
desc: "用户登录",
|
success: (res) => {
|
console.log(res);
|
},
|
});
|
}
|
let shopList = this.handleTreeData(this.data.learn).filter(item => item.cmsType == 'cmsItem')
|
shopList = shopList.filter((item) =>
|
this.resourceIsBuy(item)
|
);
|
this.getShoppingCartProductGet();
|
if (!shopList.length)
|
return wx.showToast({
|
icon: "error",
|
title: "已全部购买",
|
});
|
child.changeBuy(true);
|
let requests = [];
|
shopList.forEach((item) => {
|
requests.push({
|
saleMethodId: item.saleMethod[0].Id,
|
count: 1,
|
});
|
});
|
let query = {
|
remarks: "云学习",
|
requests,
|
};
|
const initOrderRes = await app.MG.store.initOrder(query);
|
child.changeBuy(false);
|
// 检查订单号是否存在
|
if (initOrderRes.orderNumber) {
|
// bookService: orderNumber.value, 少传这个 ，暂时不知道有什么用
|
wx.navigateTo({
|
url: `/pages/cart/paymentPage/index?&bookId=${this.data.bookDetail.id}&bookName=${this.data.bookDetail.name}&orderNumber=${initOrderRes.orderNumber}`,
|
});
|
} else {
|
// 订单号不存在，显示警告消息
|
wx.showToast({
|
icon: "error",
|
title: "请重试",
|
});
|
}
|
},
|
// 云学习全部购买
|
async buyCloudLearnClass() {
|
const cloundMenu = this.data.resourceCodeList.find((item) => item.refCode == 'jsek_cloudLearning')
|
debugger
|
let query = {
|
remarks: '云学习',
|
requests: [{
|
saleMethodId: cloundMenu.saleMethod.find((eitem) => eitem.SaleType == 'Normal').Id,
|
count: 1
|
}]
|
}
|
const initOrderRes = await app.MG.store.initOrder(query)
|
// 检查订单号是否存在
|
if (initOrderRes.orderNumber) {
|
// bookService: orderNumber.value, 少传这个 ，暂时不知道有什么用
|
wx.navigateTo({
|
url: `/pages/cart/paymentPage/index?&bookId=${this.data.bookDetail.id}&bookName=${this.data.bookDetail.name}&orderNumber=${initOrderRes.orderNumber}`,
|
});
|
} else {
|
// 订单号不存在，显示警告消息
|
wx.showToast({
|
icon: "error",
|
title: "请重试",
|
});
|
}
|
},
|
// 云学习字段购买
|
async buyCloundMenu() {
|
const cloundData = this.data.resourceCodeList.find(item => item.refCode == 'jsek_cloudLearning')
|
|
},
|
// 变为所有check true
|
findAndUpdateItemsByIds(tree, ids) {
|
function findAndUpdate(node) {
|
if (ids.includes(node.id)) {
|
node.checked = true; // 将目标项的 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; // 返回修改后的完整数组
|
},
|
handleTrue() {
|
// findAndUpdateItemsByIds(this.date.)
|
},
|
|
// 题库购买
|
async buyBank() {
|
let query = {
|
remarks: '云测试',
|
requests: [{
|
saleMethodId: this.data.bankSaleData.Id,
|
count: 1
|
}]
|
}
|
const initOrderRes = await app.MG.store.initOrder(query)
|
if (this.data.bankSaleData.Price) {
|
// 购买
|
const url = "/pages/cart/paymentPage/index?orderNumber=" + initOrderRes.orderNumber + '&onNorderSaleMethod=' + initOrderRes.saleMethodLinks[0].orderSaleMethod.id;
|
wx.navigateTo({
|
url,
|
});
|
} else {
|
// 免费领取
|
app.MG.store
|
.confirmOrder({
|
orderNum: initOrderRes.orderNumber,
|
})
|
.then((res) => {
|
if (res) {
|
wx.showToast({
|
title: "领取成功",
|
icon: "none",
|
duration: 1000,
|
});
|
this.getBookInfo(this.data.bookDetail.id);
|
}
|
});
|
}
|
},
|
// 题库加入购物车
|
handleShoppingBank() {
|
let query = {
|
requests: [{
|
saleMethodId: this.data.bankSaleData.Id,
|
storeEventId: null,
|
agentCode: "电子书",
|
}, ],
|
};
|
app.MG.store.addShoppingCart(query).then(res => {
|
wx.showToast({
|
icon: 'success',
|
title: '加入成功',
|
})
|
this.getShoppingCartProductGet();
|
this.getBookInfo(this.data.bookDetail.id)
|
})
|
},
|
// 组卷格式化日期显示
|
DateFormat(date, fmt) {
|
if (date && fmt) {
|
let _date = new Date(date);
|
var o = {
|
"M+": _date.getMonth() + 1, //月份
|
"d+": _date.getDate(), //日
|
"h+": _date.getHours(), //小时
|
"m+": _date.getMinutes(), //分
|
"s+": _date.getSeconds(), //秒
|
"q+": Math.floor((_date.getMonth() + 3) / 3), //季度
|
S: _date.getMilliseconds(), //毫秒
|
};
|
if (/(y+)/.test(fmt)) {
|
fmt = fmt.replace(
|
RegExp.$1,
|
(_date.getFullYear() + "").substr(4 - RegExp.$1.length)
|
);
|
}
|
for (var k in o) {
|
if (new RegExp("(" + k + ")").test(fmt)) {
|
fmt = fmt.replace(
|
RegExp.$1,
|
RegExp.$1.length == 1 ?
|
o[k] :
|
("00" + o[k]).substr(("" + o[k]).length)
|
);
|
}
|
}
|
return fmt;
|
} else {
|
return "";
|
}
|
},
|
// 获取组卷答题数据
|
getMockData() {
|
// const child = this.selectComponent("#test-resource");
|
// if (child) child.changeTestLoaidng(true);
|
this.setData({
|
"mockData.useCount": 0,
|
"mockData.mockList": [],
|
});
|
app.MG.identity
|
.getUserKey({
|
domain: "mockData",
|
keys: [this.data.bookId],
|
})
|
.then((res) => {
|
if (res && res.length) {
|
const mock = JSON.parse(res[0].value);
|
mock.forEach((item) => {
|
item.createDate = this.DateFormat(item.createDate, "yyyy-MM-dd");
|
});
|
this.setData({
|
"mockData.mockList": mock,
|
});
|
// 组卷已使用次数
|
res.forEach((item) => {
|
// 已经有答题分数等数据，证明组卷已经使用完毕
|
if (item.resultData) {
|
this.setData({
|
"mockData.useCount": this.data.mockData.useCount + 1,
|
});
|
}
|
});
|
}
|
});
|
},
|
// 购买组卷
|
async buyMock() {
|
let res;
|
if (!this.data.mockData.id)
|
return wx.showToast({
|
icon: "error",
|
title: "暂无组卷",
|
mask: true,
|
});
|
// 构建订单查询对象
|
try {
|
let query = {
|
remarks: "组卷",
|
requests: [{
|
saleMethodId: this.data.mockData.id,
|
count: 1,
|
}, ],
|
};
|
if (this.data.flag) {
|
this.setData({
|
flag: false,
|
});
|
res = await app.MG.store.initOrder(query);
|
}
|
if (res.orderNumber && this.data.mockData.price) {
|
wx.navigateTo({
|
url: `/pages/cart/paymentPage/index?orderNumber=${res.orderNumber}`,
|
});
|
} else {
|
// 0元直接领取
|
// 确认订单
|
const confirmOrderRes = await app.MG.store.confirmOrder({
|
orderNum: res.orderNumber,
|
});
|
if (confirmOrderRes) {
|
wx.showToast({
|
icon: "success",
|
title: "领取成功",
|
});
|
this.setData({
|
flag: true,
|
});
|
await this.recordBuyMock(); // 记录购买时间
|
}
|
}
|
} catch (error) {
|
console.log(error);
|
}
|
},
|
// 记录购买组卷时间
|
recordBuyMock() {
|
const num = this.data.mockData.mockList.length;
|
const id = tool.uuid(8);
|
const createDate = this.DateFormat(new Date().getTime(), "yyyy-MM-dd");
|
const mockList = this.data.mockData.mockList;
|
mockList.push({
|
id,
|
createDate,
|
name: `第${num + 1}套试卷`,
|
state: "0",
|
});
|
this.setData({
|
"mockData.mockList": mockList,
|
});
|
// 记录购买时间，并设状态state为1，表示刚购买完成组卷
|
app.MG.identity.setUserKey({
|
setKeyRequests: [{
|
domain: "mockData",
|
key: this.data.bookDetail.id + "",
|
value: JSON.stringify(this.data.mockData.mockList),
|
}, ],
|
});
|
},
|
// 获取相关图书
|
getAboutBook(path) {
|
this.setData({
|
relatedBookLoading: true,
|
noRelatedBookData: false,
|
});
|
let query = {
|
path,
|
queryType: "*",
|
coverSize: {
|
height: 243,
|
},
|
paging: {
|
start: 0,
|
size: 99,
|
},
|
fields: {
|
author: [],
|
publicationDate: [],
|
},
|
};
|
app.MG.store.getProductList(query).then((res) => {
|
const Arr = res.datas.filter(
|
(item) => item.id != this.data.bookDetail.id
|
);
|
let bookArr = [];
|
if (Arr.length > 9) {
|
for (var i = 0; i < 9; i++) {
|
var _num = Math.floor(Math.random() * Arr.length);
|
var mm = Arr[_num];
|
Arr.splice(_num, 1);
|
bookArr.push(mm);
|
}
|
} else {
|
bookArr = Arr;
|
}
|
this.setData({
|
relatedBookData: bookArr,
|
relatedBookLoading: false,
|
});
|
if (!this.data.relatedBookData.length)
|
this.setData({
|
noRelatedBookData: true,
|
});
|
});
|
},
|
goBookDetails(e) {
|
this.setData({
|
tabValue: "brief",
|
pageLoading: true,
|
});
|
let bookPathList = wx.getStorageSync("bookPathList");
|
const bookPath = {
|
id: this.data.bookDetail.id,
|
name: this.data.bookDetail.name,
|
};
|
if (bookPathList) {
|
bookPathList = JSON.parse(bookPathList);
|
if (bookPathList.length > 8) bookPathList.shift();
|
bookPathList.push(bookPath);
|
} else {
|
bookPathList = [bookPath];
|
}
|
|
wx.setStorageSync("bookPathList", JSON.stringify(bookPathList));
|
this.setData({
|
learn: [],
|
teach: []
|
})
|
this.onLoad({
|
id: e.detail.id,
|
name: e.detail.name,
|
});
|
},
|
// 底部购买按钮
|
buyBtn() {
|
if (this.data.tabValue == "brief" && !this.data.bookBuy) {
|
this.buyBook();
|
} else if (this.data.tabValue == "jsek_cloudLearning") {
|
const tree = this.selectComponent("#tree");
|
tree.onCloudShoppingCart();
|
} else {
|
console.log(this.data.tabValue);
|
}
|
},
|
|
goRead() {
|
if (!this.data.noFile) {
|
wx.showToast({
|
title: "暂无阅读文件",
|
icon: "none",
|
duration: 2000,
|
});
|
return false;
|
}
|
wx.navigateTo({
|
url: "/packageBookService/pages/components/webView/index?md5=" +
|
this.data.fileInfo.md5 +
|
"&fileName=" +
|
this.data.fileInfo.bookName +
|
"&fileType=" +
|
this.data.fileInfo.fileType +
|
"&freePage=" +
|
this.data.fileInfo.freePage +
|
"&bookBuy=" +
|
this.data.bookBuy +
|
"&bookId=" +
|
this.data.bookDetail.id,
|
|
});
|
},
|
|
//样书申请
|
//获取已申请纸质样书
|
getAlreadyPBookList() {
|
const data = {
|
start: 0,
|
size: 9999,
|
topicIdOrRefCode: "applyEntityBook",
|
appRefCode: app.config.appRefCode,
|
sort: {
|
type: "Desc",
|
field: "CreateDate",
|
},
|
};
|
app.MG.ugc.getTopicMessageList(data).then((res) => {
|
let list = [];
|
res.datas.map((item) => {
|
if (item.content) {
|
item.content = JSON.parse(item.content);
|
}
|
list.push(item);
|
});
|
this.setData({
|
alreadyPaperBookList: list,
|
});
|
});
|
},
|
//获取已申请电子样书
|
getAlreadyEBookList() {
|
const data = {
|
start: 0,
|
size: 9999,
|
topicIdOrRefCode: "applyBook",
|
appRefCode: app.config.appRefCode,
|
sort: {
|
type: "Desc",
|
field: "CreateDate",
|
},
|
};
|
app.MG.ugc.getTopicMessageList(data).then((res) => {
|
let list = [];
|
if (res.datas.length > 0) {
|
res.datas.map((item) => {
|
if (item.feedBack) {
|
item.feedBack = JSON.parse(item.feedBack);
|
if (item.feedBack.endDate) {
|
let times = new Date(
|
item.feedBack.endDate + " 23:59:59"
|
).getTime();
|
let currentDate = new Date().getTime();
|
if (times < currentDate) {
|
item.isExpiry = true;
|
}
|
}
|
}
|
if (item.content) {
|
item.content = JSON.parse(item.content);
|
}
|
if (item.state != "Reject") {
|
list.push(item);
|
}
|
});
|
const smBook = list.find(item => item.content[0].id == this.data.bookDetail.id)
|
if (smBook && smBook.state == 'Normal') {
|
const flag = new Date(smBook.feedBack.endDate + ' 23:59:59').getTime() > new Date().getTime()
|
if (flag) {
|
this.setData({
|
applicationState: 'Normal'
|
})
|
} else {
|
this.setData({
|
applicationState: 'overdue'
|
})
|
}
|
}
|
this.setData({
|
alreadyElectronicBookList: list,
|
});
|
}
|
});
|
},
|
|
//获取当前已申请次数（纸质）
|
getSelectPaperBookCount() {
|
app.MG.app
|
.getTicketResult({
|
ticketRefCodeOrGuid: "paperSampleBookapplyNum",
|
roleId: this.data.userInfo.roleId,
|
})
|
.then((res) => {
|
this.setData({
|
paperBookCount: res.totalCount - res.usedCount,
|
});
|
});
|
},
|
//获取当前已申请次数（电子）
|
getSelectBookCount() {
|
app.MG.app
|
.getTicketResult({
|
ticketRefCodeOrGuid: "electronicSampleBookapplyNum",
|
roleId: this.data.userInfo.roleId,
|
})
|
.then((res) => {
|
this.setData({
|
ebookCount: res.totalCount - res.usedCount,
|
});
|
});
|
},
|
|
//申请电子样书
|
appplyElectronicBook() {
|
// 先判断下教师认证，未对原有逻辑修改
|
let role = this.data.userInfo != null ? this.data.userInfo.role : null;
|
if (role && role == "Teacher") {} else {
|
return wx.showModal({
|
title: "尊敬的用户，您好！", //提示的标题
|
content: "请先进行教师认证？", //提示的内容
|
confirmColor: "#ff6c00",
|
cancelColor: "#949494",
|
success: function (res) {
|
if (res.confirm) {
|
wx.navigateTo({
|
url: "/packageDomain/pages/teacherCertification/index",
|
});
|
} else if (res.cancel) {}
|
},
|
});
|
}
|
if (
|
this.data.bookDetail.isApplyBook == 2 ||
|
this.data.bookDetail.isApplyBook == 4
|
) {
|
let role = this.data.userInfo != null ? this.data.userInfo.role : null;
|
if (role && role == "Teacher") {
|
if (!this.data.noFile) {
|
wx.showToast({
|
title: "暂无电子书文件,请联系管理员!",
|
icon: "none",
|
duration: 1000,
|
});
|
return;
|
}
|
if (this.data.ebookCount == 0) {
|
wx.showToast({
|
title: "您的电子样书申请次数已用尽，若要继续，请联系管理员！",
|
icon: "none",
|
duration: 1000,
|
});
|
return false;
|
}
|
|
let isHas = this.data.electronicBookList.find(
|
(eitem) => eitem.id == this.data.bookDetail.id
|
);
|
if (isHas) {
|
wx.showToast({
|
title: "该书已在清单列表中",
|
icon: "none",
|
duration: 1000,
|
});
|
return false;
|
}
|
let isApply = this.data.alreadyElectronicBookList.find(
|
(eitem) => eitem.content[0].id == this.data.bookDetail.id
|
);
|
if (isApply) {
|
if (isApply.state == 'WaitAudit') {
|
wx.showToast({
|
title: "该书已申请！",
|
icon: "none",
|
duration: 1000,
|
});
|
return false;
|
} else if (isApply.state == 'Normal') {
|
const flag = new Date(isApply.feedBack.endDate + ' 23:59:59').getTime() > new Date().getTime()
|
if (flag) {
|
wx.showToast({
|
title: "该书已申请！",
|
icon: "none",
|
duration: 1000,
|
});
|
return false;
|
}
|
}
|
}
|
if (this.data.electronicBookList.length >= 2) {
|
wx.showToast({
|
title: "每次最多只可申请2本样书",
|
icon: "none",
|
duration: 1000,
|
});
|
return false;
|
}
|
this.addBookFun(this.data.bookDetail, "eBook");
|
} else {
|
wx.showModal({
|
title: "尊敬的用户，您好！", //提示的标题
|
content: "请先进行教师认证？", //提示的内容
|
confirmColor: "#ff6c00",
|
cancelColor: "#949494",
|
success: function (res) {
|
if (res.confirm) {
|
wx.navigateTo({
|
url: "/packageDomain/pages/teacherCertification/index",
|
});
|
} else if (res.cancel) {}
|
},
|
});
|
}
|
} else {
|
wx.showToast({
|
title: "该书不能申请电子样书",
|
icon: "none",
|
duration: 1000,
|
});
|
}
|
},
|
//申请纸质样书
|
appplyPaperBook() {
|
let role = this.data.userInfo != null ? this.data.userInfo.role : null;
|
if (role && role == "Teacher") {} else {
|
return wx.showModal({
|
title: "尊敬的用户，您好！", //提示的标题
|
content: "请先进行教师认证？", //提示的内容
|
confirmColor: "#ff6c00",
|
cancelColor: "#949494",
|
success: function (res) {
|
if (res.confirm) {
|
wx.navigateTo({
|
url: "/packageDomain/pages/teacherCertification/index",
|
});
|
} else if (res.cancel) {}
|
},
|
});
|
}
|
if (
|
this.data.bookDetail.isApplyBook == 3 ||
|
this.data.bookDetail.isApplyBook == 4
|
) {
|
let role = this.data.userInfo != null ? this.data.userInfo.role : null;
|
if (role && role == "Teacher") {
|
// 点击选中
|
if (this.data.paperBookCount == 0) {
|
wx.showToast({
|
title: "您的纸质样书申请次数已用尽，若要继续，请联系管理员！",
|
icon: "none",
|
duration: 1000,
|
});
|
return false;
|
}
|
let isApply = this.data.alreadyPaperBookList.find(
|
(pitem) => pitem.content[0].id == this.data.bookDetail.id
|
);
|
if (isApply) {
|
wx.showToast({
|
title: "该书已申请！",
|
icon: "none",
|
duration: 1000,
|
});
|
return false;
|
}
|
|
let isHas = this.data.paperBookList.find(
|
(pitem) => pitem.id == this.data.bookDetail.id
|
);
|
if (isHas) {
|
wx.showToast({
|
title: "该书已在清单列表中",
|
icon: "none",
|
duration: 1000,
|
});
|
return false;
|
}
|
if (this.data.paperBookList.length >= 2) {
|
wx.showToast({
|
title: "每次最多只可申请2本样书",
|
icon: "none",
|
duration: 1000,
|
});
|
return false;
|
}
|
this.addBookFun(this.data.bookDetail, "pBook");
|
} else {
|
wx.showModal({
|
title: "尊敬的用户，您好！", //提示的标题
|
content: "请先进行教师认证？", //提示的内容
|
confirmColor: "#ff6c00",
|
cancelColor: "#949494",
|
success: function (res) {
|
if (res.confirm) {
|
wx.navigateTo({
|
url: "/packageDomain/pages/teacherCertification/index",
|
});
|
} else if (res.cancel) {}
|
},
|
});
|
}
|
} else {
|
wx.showToast({
|
title: "该书不能申请纸质样书",
|
icon: "none",
|
duration: 1000,
|
});
|
}
|
},
|
// 添加样书
|
addBookFun(item, type) {
|
let itemAttr = null;
|
const eList = this.data.electronicBookList;
|
const pList = this.data.paperBookList;
|
itemAttr = {
|
id: item.id,
|
title: item.name || "-",
|
icon: item.icon,
|
checked: false,
|
defaultSaleMethodId: item.defaultSaleMethodId,
|
md5: item.datas.Icon,
|
author: item.author || "-",
|
price: item.price || "-",
|
isbn: item.isbn || "-",
|
publicationDate: item.publicationDate,
|
};
|
if (type == "eBook") {
|
eList.push(itemAttr);
|
this.setData({
|
electronicBookList: eList,
|
});
|
wx.setStorageSync("electronicBookList", JSON.stringify(eList));
|
} else {
|
pList.push(itemAttr);
|
this.setData({
|
paperBookList: pList,
|
});
|
wx.setStorageSync("paperBookList", JSON.stringify(pList));
|
}
|
this.setData({
|
num: this.data.num + 1,
|
});
|
wx.showToast({
|
title: "添加成功，在样书申请单等您哦~",
|
icon: "none",
|
duration: 1000,
|
});
|
},
|
|
//去样书申请单
|
goApply() {
|
wx.navigateTo({
|
url: "/packageDomain/pages/sampleBookList/applicationForm/index",
|
});
|
},
|
handleTree() {
|
// const child = this.selectComponent('#teach-tree')
|
let tree;
|
// let openIds = child.data.openIds
|
if (this.data.tabValue == "jsek_teachingResources") {
|
tree = this.data.teach;
|
} else {
|
tree = this.data.learn;
|
}
|
for (let index = 0; index < tree.length; index++) {
|
const item = tree[index];
|
if (item.children && item.children.length > 0) {
|
const num = this.data.openTeachids.findIndex(
|
(citem) => item.id == citem
|
);
|
if (num >= 0) {
|
item.open = true;
|
} else {
|
item.open = false;
|
}
|
this.handleTree(item.children);
|
}
|
}
|
this.setData({
|
teach: tree,
|
});
|
},
|
|
// 剔除树结构多余，只保留初始需要展开的
|
// 第一步：保留树结构前两层，并将展开项加入数组
|
deleteTreeData(list, openids) {
|
let resultList = []
|
for (let index = 0; index < list.length; index++) {
|
const item = list[index];
|
if (item.children.length > 0) {
|
for (let cindex = 0; cindex < item.children.length; cindex++) {
|
const citem = item.children[cindex];
|
citem.children = []
|
}
|
}
|
resultList.push(item)
|
}
|
for (let index = 0; index < openids.length; index++) {
|
const id = openids[index];
|
// 展开项加入数组
|
this.increaseTreeData(list, resultList, id)
|
}
|
return resultList
|
},
|
// 传递ids，将需要展开的id的children 赋值
|
increaseTreeData(treeList, list, openid) {
|
let num = 0;
|
// let useData = treeList.find(item => item.id == openid)
|
for (let index = 0; index < treeList.length; index++) {
|
const item = treeList[index];
|
if (item.id == openid && num >= 3) {
|
let useArr = item.children ? item.children : []
|
this.changeList(list, openid, useArr)
|
} else {
|
num += 1
|
this.increaseTreeData(item.children, list, openid)
|
}
|
}
|
|
},
|
// 递归前两层，找出需要展开的
|
changeList(isList, id, childrenList) {
|
for (let dindex = 0; dindex < isList.length; dindex++) {
|
const ditem = isList[dindex];
|
if (ditem.id == id) {
|
ditem.children = childrenList
|
return true
|
} else {
|
this.changeList(ditem.children, id, childrenList)
|
}
|
}
|
return childrenList
|
},
|
uploadFile(e) {
|
const userInfo = JSON.parse(wx.getStorageSync(app.config.userInfoKey))
|
if (userInfo.role != 'Teacher') return wx.showToast({
|
icon: 'error',
|
title: '请先进行教师认证',
|
})
|
this.setData({
|
dialogBox: true,
|
isShowUp: true
|
});
|
},
|
closeDialog() {
|
this.setData({
|
dialogBox: false,
|
resourceInfo: {
|
resourceName: '',
|
fileType: '',
|
description: '',
|
agree: false
|
},
|
});
|
},
|
onCloseProtocol() {
|
this.setData({
|
protocolShow: false,
|
});
|
},
|
onVisibleChange(e) {
|
this.setData({
|
protocolShow: e.detail.visible,
|
});
|
},
|
//查看协议
|
getAgreement() {
|
let query = {
|
path: 'jsek_protocol',
|
fields: {
|
content: [],
|
}
|
}
|
app.MG.resource.getItem(query).then((res) => {
|
try {
|
|
const data = res.datas.find((e) => e.refCode == 'jsek_authorizationAndConsentLetter')
|
this.setData({
|
protocolTxt: data && data.content ? data.content : '暂无协议',
|
protocolShow: true
|
});
|
} catch (error) {
|
this.setData({
|
protocolTxt: '暂无协议',
|
protocolShow: true,
|
});
|
}
|
})
|
|
},
|
onNameInput(e) {
|
this.setData({
|
'resourceInfo.resourceName': e.detail.value,
|
});
|
},
|
onResourcePicker(e) {
|
this.setData({
|
resourceValue: [this.data.resourceInfo.fileType],
|
resourceVisible: true,
|
});
|
},
|
onPickerChange(e) {
|
const {
|
value
|
} = e.detail;
|
this.setData({
|
resourceVisible: false,
|
resourceValue: value,
|
'resourceInfo.fileType': value.join(' '),
|
});
|
},
|
onPickerCancel(e) {
|
this.setData({
|
resourceVisible: false,
|
});
|
},
|
textareaChange(e) {
|
this.setData({
|
'resourceInfo.description': e.detail.value,
|
});
|
},
|
onChange() {
|
if (this.data.resourceInfo.agree) {
|
this.setData({
|
'resourceInfo.agree': false,
|
});
|
} else {
|
this.setData({
|
'resourceInfo.agree': true,
|
});
|
}
|
},
|
uploadPicture() {
|
var that = this;
|
wx.chooseMessageFile({
|
count: 1,
|
type: 'file',
|
success(res) {
|
const isLt2M = res.tempFiles[0].size / 1024 / 1024 < 50
|
if (!isLt2M) {
|
return wx.showToast({
|
title: "上传文件大小不能超过 50MB!",
|
icon: "none",
|
duration: 1000,
|
});
|
}
|
const FileName = res.tempFiles[0].name.split('.')[0]
|
const Extension = res.tempFiles[0].name.split('.')[1]
|
var medioType = ''
|
const audioData = ['mp3', 'mp3']
|
const videoData = ['mp4', 'avi']
|
const pdfData = ['pdf']
|
const Compression = ['rar', 'zip']
|
const pictureData = ['jpg', 'png']
|
const documentData = ['doc', 'docx', 'xls', 'xlsx', "ppt", "pptx"]
|
if (audioData.indexOf(Extension) > -1) {
|
medioType = '音频'
|
} else if (videoData.indexOf(Extension) > -1) {
|
medioType = '视频'
|
} else if (pdfData.indexOf(Extension) > -1) {
|
medioType = 'PDF'
|
} else if (Compression.indexOf(Extension) > -1) {
|
medioType = '资源包'
|
} else if (pictureData.indexOf(Extension) > -1) {
|
medioType = '图片'
|
} else if (documentData.indexOf(Extension) > -1) {
|
medioType = '文档'
|
} else {
|
medioType = '其他'
|
}
|
wx.getFileSystemManager().getFileInfo({
|
filePath: res.tempFiles[0].path, //选择图片返回的相对路径
|
// encoding: 'binary', //编码格式
|
success: ress => {
|
//成功的回调
|
let md5 = ress.digest;
|
let formData = new FormData();
|
formData.append('Md5', md5);
|
formData.append('FileName', FileName);
|
formData.append('FileType', res.tempFiles[0].type);
|
formData.appendFile("file", res.tempFiles[0].path);
|
const data = formData.getData();
|
let _token = wx.getStorageSync(app.config.tokenKey);
|
let header = {};
|
if (_token == null) {
|
header["Authorization"] = `Basic ${Base64.encode(website.clientId + ":" + website.clientSecret)}`;
|
} else {
|
header["Authorization"] = `Bearer ` + _token;
|
}
|
new Promise((resolve, reject) => {
|
wx.request({
|
url: app.config.requestCtx + '/file/api/ApiUpload',
|
method: 'POST',
|
header: {
|
'content-type': data.contentType,
|
...header
|
},
|
data: data.buffer,
|
success(res1) {
|
resolve(res1.data);
|
if (res1.data) {
|
let file = [{
|
name: res.tempFiles[0].name,
|
md5: md5,
|
type: medioType,
|
FileType: Extension
|
}]
|
that.setData({
|
"resourceInfo.resourceName": FileName,
|
"resourceInfo.fileType": medioType,
|
|
fileList: file,
|
isShowUp: false
|
})
|
}
|
}
|
})
|
})
|
}
|
})
|
}
|
})
|
|
},
|
handleRemove(e) {
|
this.setData({
|
isShowUp: true,
|
fileList: []
|
});
|
},
|
confirmM() {
|
if (this.data.resourceInfo.resourceName == '') {
|
return wx.showToast({
|
icon: "error",
|
title: "请填写资源名称",
|
});
|
}
|
if (this.data.resourceInfo.fileType == '') {
|
return wx.showToast({
|
icon: "error",
|
title: "请选择资源类型",
|
});
|
}
|
|
if (!this.data.fileList.length) {
|
return wx.showToast({
|
icon: "error",
|
title: "请上传资源文件",
|
});
|
}
|
if (!this.data.resourceInfo.agree) {
|
return wx.showToast({
|
icon: "none",
|
title: "请同意《授权同意书》！",
|
});
|
}
|
let query = {
|
topicIdOrRefCode: "uploadFiles",
|
name: this.data.bookDetail.name,
|
content: JSON.stringify(JSON.parse(JSON.stringify(this.data.fileList))),
|
type: 'UserSubmit',
|
description: this.data.resourceInfo.description,
|
cmsTypeRefCode: '',
|
newDataListRequest: []
|
}
|
app.MG.ugc.newTopicMessage(query).then((res) => {
|
wx.showToast({
|
icon: "success",
|
title: "上传成功",
|
});
|
this.closeDialog()
|
})
|
},
|
getCloundIsBuy() {
|
let flag = false
|
if (!this.data.isCloundHaveSaleMethod) flag = false
|
const cloundData = this.data.resourceCodeList.find(item => item.refCode == 'jsek_cloudLearning')
|
const saleData = cloundData.saleMethod.find(item => item.SaleType == "Normal")
|
if (!saleData) flag = false
|
flag = this.data.buyIdList.some(item => item == saleData.Id)
|
this.setData({
|
cloundMenuIsBuy: flag
|
})
|
},
|
/**
|
* 用户点击右上角分享
|
*/
|
onShareAppMessage() {},
|
onShareTimeline() {}
|
})
|
