nova-trip/nova-tourism/pages/homestay/room-order/index.js

let Parse = getApp().Parse
const company = getApp().globalData.company
import dataSource from '../../../service/data';
import dateServ from '../../../service/date';
const rechText = require('../../../../utils/rech-text')
Page({

    /**
     * 页面的初始数据
     */
    data: {
        roomId:null,
        room: {},
        note: {
            "title":'订房必读',
            "desc":'防疫期间,请您在下单前与房东确认接待政策,以免影响您的入住。(提示有效期2022/03/18起)',
            "arrowtext":'查看全部'
        },
        date: '',// 入住时间
        defaultDate: [],// 日历默认时间
        startTime: null,// 入住开始时间
        endTime: null,// 入住结束时间
        count: 1,// 入住几晚
        columns: [],// 入住人数可选数组
        peopleNum: 1,// 入住人数
        showNote: false,
        showDate: false,
        showNumPicker: false,
        showPayment: false,
        customers:[],// 住客信息
        priceInfoArr: [],// 房费详细信息
        formatter:null,// 日历格式化
        // checkedFormatter: null,// 日历相关数据处理
        CountArray: [], // 房型可选日期及已订数量数组 [{date: '',count: 0}]
        CountObj: [], // 房型可选日期及已订数量对象 {date: count}
    },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad: function (options) {
        let roomId = options.id
        this.initData(roomId)  
    },
        /**
     * 生命周期函数--监听页面显示
     */
    onShow: function () {
        this.setData({
            customers:this.data.customers
        })
        console.log(this.data.customers);
    },
    initData(roomId){
        dataSource.getRoomById(roomId).then(room =>{
            room.desc = room.tags.join(" ")// 标签
            this.data.note.detail = rechText.formatRichText((room.note || ''));// 订房必读
            let merber = room.merber;// 房间容纳人数
            let columns  = [...new Array(merber+1).keys()]// 入住人数可选数组
            columns.shift(0)
            console.log(columns); 
            // 日期相关数据初始化
            // let defaultDate = this.initDate()
            // 订单开始时间结束时间  默认下午两点 方便无房时间对比
            // let today = new Date();
            // let tommrrow = dateServ.getStrByTimeIncreaseDay(today,1)
            // let {startTime,endTime}=this.formatTimeArea(today,tommrrow)
            // console.log(startTime,endTime);
            // let priceInfoArr = dateServ.getDayAll(startTime,endTime)// 订单时间跨度数组
            // priceInfoArr.pop();// 最后一天为退房 不计入
            // console.log(priceInfoArr);
            // let count= priceInfoArr.length;
            this.setData({
                roomId,
                room,
                columns,
                // date:defaultDate,
                peopleNum:merber,
                // priceInfoArr,
                // count,
                // startTime,
                // endTime,
            })
            
            
        })
    },
    dayAddOne(time){
        time = new Date(time)
        let year = time.getFullYear()
        let month = time.getMonth() + 1
        let day = time.getDate()
        return new Date(`${year}-${month}-${day + 1} 14:00:00`);
    },
    formatTimeArea(start, end){
        start = new Date(start)
        end = new Date(end)
        console.log(start,end);
        let year = start.getFullYear()
        let month = start.getMonth() + 1
        let day = start.getDate()
        let year2 = end.getFullYear()
        let month2 = end.getMonth() + 1
        let day2 = end.getDate()
        console.log(year,month,day);
        let obj = {
            startTime: new Date(`${year}/${month}/${day} 14:00:00`),
            endTime: new Date(`${year2}/${month2}/${day2} 14:00:00`)
        }
        console.log(obj);
        return obj
    },
    navigate(event){
        console.log(event);
        let type = event.currentTarget.dataset.type;
        switch (type) {
            case 'room':
                wx.navigateTo({
                    url: `/nova-tourism/pages/homestay/room-detail/index?id=${this.data.roomId}`
                })  
                break;
                case 'customer':
                    wx.navigateTo({
                        url: `/nova-tourism/pages/homestay/customer/select-customer/index`
                    })  
                    break;
            default:
                break;
        }
        
    },
    // 显示订房必读
    showNotePop(){
        this.setData({
            showNote:true
        })
    },
    closeModal() {
        this.setData({ showNote: false });
    },

    // 日期
    initDate(){
        let month = new Date().getMonth()+1;
        let start = new Date().getDate();
        let end = new Date().getDate() + 1;
        return `${month}月${start} 日 - ${month}月${end} 日`;
    },
    checkDate(){
        this.initCalenderData()
        this.setData({
            showDate:true
        })
    },
    closeDate(){
        this.setData({
            showDate:false
        })
    },
    enterDate(event){
        const [start, end] = event.detail;
        console.log(11111,event.detail)
        let {startTime,endTime} = this.formatTimeArea(start, end)
        console.log(startTime,endTime);
        var dataAll = dateServ.getDayAll(startTime,endTime);
        dataAll.pop();// 最后一天为退房，不算在内
        console.log(dataAll);
        console.log(this.formatDate(startTime), this.formatDate(endTime))
        let dateStr = this.formatDate(startTime) + '-' + this.formatDate(endTime)
        console.log(dateStr)
        this.setData({
            showDate:false,
            date: `${this.formatDate(startTime)} - ${this.formatDate(endTime)}`,
            startTime: new Date(startTime),
            endTime: new Date(endTime),
            priceInfoArr:dataAll,
            count:dataAll.length

        })
        
        console.log(this.data.priceInfoArr);
    },
    formatDate(date) {
        date = new Date(date);
        return `${date.getMonth() + 1}/${date.getDate()}`;
    },
    
    /*****
     * 已知：用户选择房型、时间段，房型的可用数量
     * 查询：范围内是否有空房
     * 
     * 入住时间：当天占用房间
     * 离店时间：当天房间可用
     
     let CountArray = [
         {日期:20220419,数量:1},
         {date:20220419,count:1},
     ]

     function addOrdertoArray(currentDate){
        let currentIdx = CountArray.findIndex(item=>item.date == currentDate)

        if(currentIdx&&currentIdx>=0){
            CountArray[currentIdx].count += 1
        }else{
            CountArray.push({date:currentDate,count:1})
        }
     }
     function getDateByTime() // 同时获取14点校准时间


     RoomOrderList.forEach(order=>{
         let startDate = getDateByTime(order.get("startTime"));
         let endDate = getDateByTime(order.get("endTime"));
         let breakDate = 

         for(currentDate; currentDate + 1day; currentDate=breakDate){
            addOrdertoArray(currentDate);
         }
     })
     */
    
    


    /*** 日期组件初始化
     * 1、获取日历可选时间区间内 所有已生成订单  生成日期对应订单数量对象 {date:count}
     * 1、设置默认日期  （组件默认时间为当前时间及后一天 需修改为非无房状态日期）
     * 2、无房状态显示禁点
     * 3、已选择开始日期时，日期往后推 无房日期之后均为禁点
     */
    async initCalenderData(){
        // 获取日历可选时间区间内 所有已生成订单
        console.log(111)
        let orders = await this.getRoomOrdersByRoomId(this.data.roomId)
        orders.forEach(order =>{
            let startDate = dateServ.getDateStrByTime(order.get("startTime"));
            let endDate = dateServ.getDateStrByTime(order.get("endTime"));
            let breakDate = dateServ.getStrByTimeIncreaseDay(order.get("endTime"),-1);
            console.log(startDate,endDate,breakDate);
            // 遍历单个订单下已订时间 将订单覆盖时间推入CountObject
            let dateArr = dateServ.getDayAll(startDate,breakDate)
            console.log(dateArr)
            for (let index = 0; index < dateArr.length; index++) {
                let datastr = dateArr[index];
                this.addOrdertoArray(datastr)
            }
        })
        console.log(this.data.CountArray,this.data.CountObj);
        this.setData({
            orders,
            defaultDate:[],// 默认日期
            CountArray:this.data.CountArray,
            CountObj:this.data.CountObj
        })
        this.checkedFormatter('init')
                
    },
    selectDay(date,type){
        let day = {
            date,
            text:'20',
            type:'',
            bottomInfo:undefined
        }
        console.log('ddddddd',type);
        this.formatter(day,type)       
    },
    getOrderDate(date){
        console.log(this.data.CountObj[date] , this.data.room.total);
        if(!this.data.CountObj[date]){
            return date
        }
        if(this.data.CountObj[date] && this.data.CountObj[date] < this.data.room.total){
            return date
        }
        if(this.data.CountObj[date] && this.data.CountObj[date] >= this.data.room.total){
            return false
        }
        
    },
     addOrdertoArray(currentDate){
        // currentDate = new Date(currentDate)
        let currentIdx = this.data.CountArray.findIndex(item=>item.date == currentDate)
        if(currentIdx&&currentIdx>=0){
            this.data.CountArray[currentIdx].count += 1
        }else{
            this.data.CountArray.push({date:currentDate,count:1})// 日期，已订数量
        }

        this.data.CountObj[currentDate] ? this.data.CountObj[currentDate] += 1 : this.data.CountObj[currentDate] = 1;
        console.log(this.data.CountObj)
     },
    // 组件日期订单数量达到总数时，type设置为disabled 
    // 组件默认start为当前日期，end为当前日期后一天  当前日期无房情况下需将最近的非disabled日期设为start
    // 当start 后一天为 无房日期时，该日期type改为''   ,无房日期 不可为start
    type :null,
    start:null,
    end:null,
    disabled:null,
    // start后的第一个无房日期
    checkedFormatter(type){
        if(this.end){
            this.disabled = null;
        }
        let that = this;
        this.status = null;
        let formatter =  function (day,type) {//
            const month = day.date.getMonth() + 1;
            const date = day.date.getDate();
            if(month <7){
                if(date == 4 || date == 5 || date == 20 || date == 21 || date == 30){
                    // console.log(day,day.date,day.type);
                }
                let CountObj = that.data.CountObj
                  let datestr = dateServ.getDateStrByTime(day.date);
                  let endstr = null;
                  let disabledstr =null;
                  let startstr =null;
                  if(that.end){
                    endstr = dateServ.getDateStrByTime(that.end);
                  }
                  if(that.disabled){
                    disabledstr = dateServ.getDateStrByTime(that.disabled);
                  }
                  if(that.start){
                    startstr = dateServ.getDateStrByTime(that.start);
                  }
                
                // 1、该日期订单数量达到房间总量且非结束日期  显示无房 禁点
                if(CountObj[datestr] && CountObj[datestr]>= that.data.room.total &&endstr != datestr){
                    day.bottomInfo = '无房';
                    day.type = 'disabled';
                    // that.disabled = day.date;
                    // 4.1无房后日期禁点1 无离店日期时 入住日期后最近无房日期保存为disabled  
                    // console.log(startstr, datestr,that.disabled);
                    if(startstr < datestr && !that.end && (!that.disabled || disabledstr > datestr)){
                        // console.log(startstr, datestr,that.disabled);
                        that.disabled = day.date
                    }
                }
                // 已有end时，记录end 
                if(day.type == 'end'){
                    that.end = day.date;
                    that.disabled = null;
                }
                // 4.2无房后日期禁点2  已选入住日期 无离店日期 时，离入住日期最近无房日期后所有日期type 设为 disabled  
                // console.log(day.config,that.start,that.end,datestr,disabledstr,startstr);
                if(that.start && !that.end && (datestr > disabledstr)  && (startstr < datestr) ){
                    // console.log(datestr,disabledstr);
                    day.type = 'disabled'
                }
                // 2、设置默认入住日期：无start时，最近一天非disabled日期设为start  设为默认日期
                if(day.type != 'disabled' && !that.start ){//&& !that.data.defaultDate[0]
                    day.type = 'start'
                    that.start = day.date;
                    // that.data.defaultDate[0] = day.date.getTime()
                    // console.log(that.data.defaultDate);
                    // that.setData({
                    //     defaultDate:that.data.defaultDate
                    // })
                }
                // 已有start时，记录start 原无房日期type为start时，不存
                if(day.type == 'start'){
                    console.log(day,'start');
                    that.type = 'start';
                    that.start = day.date;
                    if(CountObj[datestr] && CountObj[datestr]>= that.data.room.total){
                        day.type = 'disabled';
                        that.start = null;
                        
                    }
                }
                // 3.1、有start无end时,后一天如果为disabled，type设为'' 
                if(that.start  && day.type =='disabled'  && month <6 ){
                    let leavSelect = dateServ.getStrByTimeIncreaseDay(that.start,1)
                    // 日历day 时间为00:00:00,需把时间转换为 00:00:00 进行对比
                    let isSame = dateServ.isSameDay(day.date,leavSelect)
                    // console.log(startstr,CountObj[startstr] , that.data.room.total , !CountObj[startstr] || CountObj[startstr] <that.data.room.total);
                    if(isSame && datestr != endstr && (!CountObj[startstr] || CountObj[startstr] < that.data.room.total)){
                        // console.log(datestr,endstr);
                        // console.log('ddddddddddddddddddddd');
                        // console.log(day,day.date,day.type);
                        day.type = ''
                    }
                }
                // 3.2、如果离店日期为无房日期，点击该日期 不修改入住和离店日期
                if(datestr == endstr ){
                    console.log(datestr,endstr);
                    if(CountObj[datestr] && CountObj[datestr]>= that.data.room.total){
                        day.type == 'end'
                    }
                }
                

                if (day.type === 'start') {
                    day.bottomInfo = '入住';
                  } else if (day.type === 'end') {
                    day.bottomInfo = '离店';
                }
            }
            return day;
        }
        // return formatter()
        // if(!this.defaultDate){
        //     this.setData({
        //         defaultDate:[this.start,this.end]
        //     })
        // }
        this.setData({
            checkedFormatter:formatter
        })
    },
    unselectDate(event){
        console.log(event);

    },
    selectDate(event){
        console.log(event);
        let dates = event.detail;
        this.start = dates[0]
        this.end = dates[1]
        if(this.end){
            this.disabled = null;
            console.log(this.disabled);
        }
       this.checkedFormatter()
    },
    formatter(day,type){
        const month = day.date.getMonth() + 1;
        if(month <6){
            console.log(day,type);
        }
        let CountObj = this.data.CountObj
        let datestr = dateServ.getDateStrByTime(day.date);
        // 该日期已有订单 且数量达到房间总量 显示无房 禁点
        if(CountObj[datestr] && CountObj[datestr]>= this.data.room.total){
            day.bottomInfo = '无房';
            day.type = 'disabled'
        }
        if (day.type === 'start') {
            day.bottomInfo = '入住';
        } else if (day.type === 'end') {
            day.bottomInfo = '离店';
        }
        if(type){
            day.type = type;
        }
        return day;
    },
    select:{
        start:null,
        end:null
    },
    // defaultDate(){
    //     // 已知： 有订单时间对象数组 this.CountObj this.CountArray   房间数量 this.room.total
    //     // 求： 最近订单数量小于房间数量时间
    //      let arr = this.getTimeArr()
    //      console.log(arr);
    //      return arr
    //     // format(day,type){
    //     //     if(type){
    //     //         day.type == type
    //     //     }
    // },
    getTimeArr(){
        let arr  = [...new Array(30).keys()]// 日期遍历以30天为周期遍历
        let date = new Date();
        for(let i=0;i<arr.length;i++){
            let startstr = new Date(dateServ.getStrByTimeIncreaseDay(date,0))
            let start = this.getOrderDate(startstr)
            date = new Date(dateServ.getStrByTimeIncreaseDay(date,1))
            if(start){// 最近可订的时间  
                console.log(start);
                this.selectDay(start,'start')
                console.log(start);
                let end = new Date(dateServ.getStrByTimeIncreaseDay(start,1))
                let endstr = dateServ.getStrByTimeIncreaseDay(start,1)
                let select = this.getOrderDate(endstr)
                console.log(select);
                if(!select){// 处于禁用状态
                    this.selectDay(end,'end')
                }
                return [start,end]
            }
            if(i+1 == arr.length){
                this.getTimeArr()
            }
        }
    },

    // formatter (day) {
    //     const month = day.date.getMonth() + 1;
    //     const date = day.date.getDate();
    //     // console.log(month,date);
    //     // if (month === 5) {
    //     //   if (date === 1) {
    //     //     day.topInfo = '劳动节';
    //     //   } else if (date === 4) {
    //     //     day.topInfo = '五四青年节';
    //     //   } else if (date === 11) {
    //     //     day.text = '今天';
    //     //   }
    //     // }
    //     if(month === 4){
    //         if(date === 18 || date === 19 || date === 20 || date === 21){
    //             console.log(day);
    //         }
    //         if(day.type == 'start'){
    //             console.log('start');
    //             this.type = 'start';
    //             // type = 'start';
    //         }
    //         if (day.type === 'start') {
    //             day.bottomInfo = '入住';
    //           } else if (day.type === 'end') {
    //             day.bottomInfo = '离店';
    //           }
    //           let CountObj = this.data.CountObj
    //           let datestr = dateServ.getDateStrByTime(day.date);
    //           if(CountObj[datestr] && CountObj[datestr]>= this.data.room.total){// 该日期已有订单 且数量达到房间总量 显示无房 禁点
    //               day.bottomInfo = '无房';
    //               day.type = 'disabled'
                  
    //           }
    //           if(date === 18 || date === 19 || date === 20 || date === 21){
    //             console.log(day);
    //         }
            
    //     }
    //     return day;
    // },
    // 入住人数选择
    checkNum(){
        this.setData({
            showNumPicker:true
        })
    },
    numPickerChange(event){
        // console.log(event,event.detail);
        // this.setData({
        //     peopleNum:event.detail
        // })
    },
    numPickerEnter(event) {
        const { picker, value, index } = event.detail;
        console.log(picker, value, index);
        console.log(`当前值：${value}, 当前索引：${index}`);
        this.setData({
            peopleNum:value,
            showNumPicker:false
        })
      },
    
      numPickerCancel() {
        console.log('取消');
        this.setData({
            showNumPicker:false
        })
      },
      async checkOrderCount(){
        //   start1  end1   现在选择
        //   start2  end2     已有订单时间
        //   start1 < start2              end1 < end2
        //   start1 > start2              end1 > end2
        //   start1 = start2              end1 = end2
          let now = dateServ.changeDateTime(new Date(),'14:00:00')
        let Order = new Parse.Query("RoomOrder")
        Order.equalTo("room",this.data.roomId)
        Order.equalTo("company",company)
        Order.exists("status") 
        Order.notEqualTo("status",100) 
        Order.notEqualTo("status",400) 
        Order.notEqualTo("status",601) 
        Order.notEqualTo("status",700) 
        Order.greaterThanOrEqualTo("startTime",this.data.endTime)  //20  23    21 22  
        Order.lessThanOrEqualTo("endTime",this.data.startTime)
        Order.select("startTime","endTime")
        let count = await Order.count()
        console.log(count);
        return count
      },
      async submit(){
        if(!this.data.startTime || !this.data.endTime){
            wx.showToast({
              title: '请选择入住时间',
              icon: 'none',
            })
            return 
        }
        if(this.data.customers.length == 0){
            wx.showToast({
              title: '请选择入住人',
              icon: 'none',
            })
            return 
        }
        let count = await this.checkOrderCount()
        if(count >=this.data.room.total){
            console.log(count);
            wx.showToast({
                title: '当前日期，已无剩余房间，请重新选择',
                icon: 'none',
              })
            return
        }
        let tradeNo = this.getTradeNo()
        let order = await this.setOrder(tradeNo)
        if(order){
            this.setData({
                activeOrder:order,
                tradeNo,
                showPayment:true,
            })
        }
      },
      async acceptResult(e) {
        let { activeOrder } = this.data
        let that = this
        let {
            params,
            no
        } = e.detail;
        that.setData({
            showPayment: false
        })
        try {
            if (params == "ok") {
                activeOrder.set("status", 100)
                activeOrder.set("isPay", true)
                await activeOrder.save()
                wx.showToast({
                    title: '支付成功',
                    icon: 'none',
                    duration: 1500,
                    mask: false,
                });
                wx.navigateBack({
                  delta: 1,
                })
            } else {
                wx.showToast({
                    title: '支付失败，取消订单',
                    icon: 'none',
                    duration: 1500,
                    mask: false,
                });
            }
        } catch (error) {
            console.log(error)
            wx.showToast({
                title: "支付失败",
                icon: "error",
                duration: 1500,
            });
            wx.hideLoading()
        }
    },
      //生成订单号
      getTradeNo(){
        let now = new Date()
        let tradeNo = "C" +
        String(now.getFullYear()) +
        (now.getMonth() + 1) +
        now.getDate() +
        now.getHours() +
        now.getMinutes() +
        now.getSeconds() +
        Math.random().toString().slice(-6); //生成六位随机数
        return tradeNo
      },
    //   创建待支付订单
      async setOrder(tradeNo){
        let currentUser = Parse.User.current()
        let Order = Parse.Object.extend("RoomOrder");
        let order = new Order()
        try {
        order.set("details",this.data.room.details);
        order.set("user",{
            __type: 'Pointer',
            className: '_User',
            objectId: currentUser.id
        });
        order.set("orderNum",tradeNo);
        order.set("room",{
            __type: 'Pointer',
            className: 'ShopRoom',
            objectId: this.data.roomId
        });
        console.log(this.data.startTime,this.data.endTime);
        order.set("startTime",this.data.startTime);
        order.set("endTime",this.data.endTime);
        order.set("price",this.data.count * this.data.room.price);
        order.set("shopStore",{
            __type: 'Pointer',
            className: 'ShopStore',
            objectId: this.data.room.shop.objectId
        });
        order.set("company", {
            __type: 'Pointer',
            className: 'Company',
            objectId: company
        })
        order.set("name",this.data.customers[0]['realname']);
        order.set("mobile",this.data.customers[0]['mobile']);
        order.set("merber",this.data.peopleNum);
        order = await order.save()
        } catch (error) {
            console.log(error);
            wx.showToast({
              title: error.errMsg,
              icon: 'none'
            })
        }
        return order
      },
    /**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady: function () {

    },
    async getRoomOrdersByRoomId(roomId){
        let time1 = dateServ.changeDateTime(new Date(),'00:00:00');
        let time2 = this.timeaddsix(dateServ.changeDateTime(new Date(),'23:59:59'));
        console.log("time1",time1, "time2", time2)
        let Order = new Parse.Query("RoomOrder")
        Order.equalTo("room",roomId)
        Order.equalTo("company",company)
        Order.exists("status")
        Order.greaterThanOrEqualTo("startTime",time1)
        Order.lessThanOrEqualTo("startTime",time2)
        Order.select("startTime","endTime")
        let orders = await Order.find()
        console.log(orders);
        return orders
        
    },
     timeaddsix(str){
        // 创建日期对象，并初始化，完成文本转日期
        var date = new Date(str);
        //日期转文本方式一：
        // str = date.format("yyyy-MM-dd");
        var year= date.getFullYear();//年
        var month= date.getMonth() + 7;//月 +6个月  因为js里month从0开始，所以要加1
        if (month>12){
            year++;
            month -= 12;
        }
        if(month<10){
            month="0"+month;
        }
        var date2=new Date(year,month,0);//新的年月
        var day1=date.getDate();
        var day2=date2.getDate();
        if(day1>day2){  //防止+6月后没有31天
            day1=day2;
        }
        str = year + '/'
            + month + '/'
            + day1;
        return str
    },

    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide: function () {

    },

    /**
     * 生命周期函数--监听页面卸载
     */
    onUnload: function () {

    },

    /**
     * 页面相关事件处理函数--监听用户下拉动作
     */
    onPullDownRefresh: function () {

    },

    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom: function () {

    },

    /**
     * 用户点击右上角分享
     */
    onShareAppMessage: function () {

    },
    // getRoom(){
    //     this.getRoom
    // }
})