jsek-applet.git

// packageBookService/pages/bookServices/detail/buyResource/index.js
const app = getApp();
Page({
  /**
   * 页面的初始数据
   */
  data: {
    barHeight: "",
    navBarHeight: "",
    learn: [],
    openLearnids: [],
    bookId: "",
    loading: true,
    shoppingList: [],
    shoppingCartGetId: [],
    methodId: [],
    paymentPage: false,
    superior: false,
    checkAllState: true,
    productLinkPath: '',
    refCode: '',
    naData: false,
    bookRefCode: []
  },
 
  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    this.getBookInfo(options.bookId);
    const systInfo = wx.getSystemInfoSync();
    const menu = wx.getMenuButtonBoundingClientRect(); // 胶囊信息
    const navBarHeight =
      (menu.top - systInfo.statusBarHeight) * 2 + menu.height; // 导航栏高度
    this.setData({
      barHeight: systInfo.statusBarHeight,
      navBarHeight: navBarHeight,
      bookId: options.bookId,
      productLinkPath: options.productLinkPath,
      refCode: options.refCode
    });
    this.getShoppingCartProductGet();
  },
 
  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {},
 
  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {},
 
  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {},
 
  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {},
 
  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {},
 
  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {},
 
  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {},
  onShareTimeline() {},
  changeCheckAll(e) {
    this.setData({
      checkAllState: e.detail.value,
    });
  },
  goBack() {
    wx.navigateBack();
  },
 
  // 获取所有子项数量
  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 = this.insertAndSortObjectsByProductLinkPath(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
  },
 
  // 排序数组 按照productLinkPath
  insertAndSortObjectsByProductLinkPath(array, newObj) {
    // 查找新对象应该插入的位置  
    let insertIndex = array.findIndex(obj => newObj.id < obj.id);
    // 如果没有找到合适的位置，则放在数组末尾  
    if (insertIndex === -1) {
      insertIndex = array.length;
    }
    // 插入新对象到数组  
    array.splice(insertIndex, 0, newObj);
    // 测试6 正式5
    // 对数组进行排序  
    array.sort((a, b) => {
      if (a.id < b.id) return -1;
      if (a.id > b.id) return 1;
      return 0;
    });
    // 返回更新后的数组  
    return array;
  },
 
  // 遍历树结构转换为数组方法
  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;
  },
  // 递归树结构，如果父级有销售方式(有效期)，去掉所有子集的销售方式
  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
  },
  // 勾选禁用
  handleTreeCheck(tree) {
    for (const item of tree) {
      const saleData = item.saleMethod &&
        item.saleMethod.length ?
        item.saleMethod.find((citem) => citem.SaleType == 'Normal') : undefined
      if (saleData && new Date(saleData.EndDate).getTime() >= new Date().getTime() && new Date(saleData.BeginDate).getTime() <= new Date().getTime()) {
        item.disabled = false
      } else {
        item.disabled = true
      }
      if (item.children && item.children.length) this.handleTreeCheck(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',
        // 资源类型，试读文件，是否允许下载等参数
        learnSelectType: [],
        // freeFile: [],
        // file: [],
        // protectedFile: [],
        // resourcesClassification: [],
        // isDownload: [],
        // jsek_resourceBrief: [],
        // jsek_link: [],
        // jsek_questionBank: []
      },
      pading: {
        start: 0,
        size: 999
      },
    }
    app.MG.store.getProductDetailNoChildren(query).then((res) => {
      if (!res.datas.cmsDatas[0].datas.length) {
        return this.setData({
          noResources: true,
          loading: false,
        });
      }
      let list = []
      res.datas.cmsDatas[0].datas.forEach((item) => {
        item.checked = false;
        // if (item.sysType == 'CmsItem') {
        //   item.isbuy = this.resourceIsBuy(item);
        //   item.isShopCar = this.isShoppingCart(item);
        // }
      });
      // 显示 需要购买的和需要免费领取的
      this.getTreeList(res.datas.cmsDatas[0].datas, list, query.cmsPath)
      list = this.ensureTreeConsistency(list)
      list = this.changeResourceChildren(list)
      list = this.clearTreeSealmethod(false, list)
      list = this.handleTreeCheck(list)
      this.handleTreeData(list).forEach(item => {
        item.isbuy = this.resourceIsBuy(item);
        item.isShopCar = this.isShoppingCart(item);
      })
      console.log('修改后云', list);
      let result = [];
      let arr = res.datas.cmsDatas[0].datas.filter(
        (item) => item.saleMethod[0]
      );
      let freeIds = arr.filter((item) => {
        return item.saleMethod[0].Price == 0;
      });
      if (!freeIds.length)
        this.setData({
          isshowDrawBtn: false,
        });
      this.findChildIds(list, result);
      this.setData({
        learn: list,
        loading: false,
        openLearnids: result,
      });
    })
  },
 
  async getBookInfo(id) {
    const query = {
      path: "*",
      queryType: "*",
      productId: id,
      favoriteTypes: "FavoriteBookCity",
      itemFields: {
        "SysType=": "CmsFolder",
      },
      coverSize: {
        height: 300,
      },
      fields: {
        seriesName: [],
        author: [],
        isbn: [],
        publicationDate: [],
        bookClassification: [],
        paperPrice: [],
        JDLink: [],
        tmallLink: [],
        dangdangLink: [],
        weidianLink: [],
        content: [],
        authorIntroduction: [],
        isApplyBook: [],
        isSell: [],
        pdf: [],
        protectedEpub: [],
        probationPage: [], //pdf试读页数
        freeEpubPage: [], //epub试读百分比
      },
    };
    await app.MG.store.getProductDetail(query).then(async (res) => {
      this.setData({
        bookDetail: res.datas,
        buyIdList: res.datas.purchasedSaleMethodIdList,
      });
      this.getResourceDataList({
        productLinkPath: this.data.productLinkPath,
        refCode: this.data.refCode,
      })
    });
 
  },
  // 获取已购买商品
  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,
      });
    });
  },
  // 判断资源是否购买
  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;
    }
  },
 
  // 判断资源加入购物车按钮是否显示
  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
          }
        }
      }
      // if (data.saleMethod[0].Price <= 0) return false;
      // // 再判断是否购买
      // const isBuy = this.data.buyIdList.some(
      //   (item) => item == data.saleMethod[0].Id
      // );
      // if (isBuy) {
      //   // 购买了
      //   return false;
      // } else {
      //   // 判断是否加入购物车
      //   const isSHow = this.data.shoppingCartGetId.some(
      //     (item) => item == data.saleMethod[0].Id
      //   );
      //   return !isSHow;
      // }
    } else {
      return false;
    }
  },
  // 获取展开项
  findChildIds(data, result) {
    let index = 0;
    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);
          for (let j = 0; j < item.children.length; j++) {
            if (index < 3) {
              const childrenItme = item.children[j];
              if (item.children && item.children.length > 0) {
                result.push(childrenItme.id);
                index += 1;
              }
            } else {
              break;
            }
          }
        } else if (item.children && item.children.length > 0) {
          result.push(item.id);
          index += 1;
        }
      } else {
        break;
      }
    }
  },
  checkAll() {
    const child = this.selectComponent("#tree");
    child.checkAll();
  },
  //购买按钮
  batchPurchase() {
    if (!this.data.learn.length) {
      return wx.showToast({
        icon: "error",
        title: '暂无数据',
      })
    }
    // 修改后方法
    const checkData = this.handleTreeData(this.data.learn).filter(item => item.checked == true)
    console.log('选中', checkData);
    if (!checkData.length) return wx.showToast({
      icon: 'error',
      title: '请勾选资源',
    })
    let saleMethodIds = [];
    checkData.forEach((items) => {
      if (items.saleMethod.length) {
        saleMethodIds.push(items.saleMethod.find(citem => citem.SaleType == 'Normal').Id);
      }
    });
    app.MG.store
      .initOrder({
        requests: saleMethodIds.map((id) => ({
          saleMethodId: id,
          count: 1,
        })),
      })
      .then((res) => {
        if (res) {
          wx.navigateTo({
            url: "/pages/cart/paymentPage/index?orderNumber=" + res.orderNumber,
          });
        }
      });
  },
 
  // 章节勾选方法
  findAndUpdateItemsByIds(tree, ids, state) {
    function findAndUpdate(node) {
      if (ids.includes(node.id)) {
        // console.log(node, 'node');
        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); // 对每个顶层节点执行查找和更新操作
    }
    // console.log(tree, 'tree345');
    return tree; // 返回修改后的完整数组
  },
  // 单个勾选方法
  checkResoucrceInfo(tree, id) {
    function findAndUpdate(node) {
      if (node.sysType == "CmsFolder" && node.children.length > 0) {
        for (let index = 0; index < node.children.length; index++) {
          const element = node.children[index];
          findAndUpdate(element);
        }
      } else if (id == node.id && node.sysType == "CmsItem") {
        node.checked = !node.checked; // 将目标项的 check 属性设置为 true
      }
    }
    for (let node of tree) {
      findAndUpdate(node); // 对每个顶层节点执行查找和更新操作
    }
    return tree; // 返回修改后的完整数组
  },
  // 章节勾选事件
  changeListChecked(e) {
    const ids = e.detail.ids
    const state = e.detail.flag
    const updated = this.findAndUpdateItemsByIds(this.data.learn, ids, state)
    this.setData({
      learn: updated
    }, () => {
      wx.hideLoading()
    })
  },
  // 单个勾选事件
  changeResourceChecked(e) {
    const id = e.detail.id
    const updated = this.checkResoucrceInfo(this.data.learn, id)
    this.setData({
      learn: updated
    }, () => {
      wx.hideLoading()
    })
  },
  upDateShopCar(id, tree) {
    for (let item of tree) {
      if (item.id == id) {
        item.isShopCar = false
      } else {
        if (item.children && item.children.length) this.upDateShopCar(id, item.children)
      }
    }
    return tree
  },
  // 更新购物车图标
  updateCloudLearning(e) {
    const {
      id
    } = e.detail
    console.log(id);
    const list = this.upDateShopCar(id, this.data.learn)
    this.setData({
      learn: list
    })
  }
});