dbd-meeting-wx-small/miniprogram/pages/reportRepair/report/report.js

let app = getApp();

import Notify from '@vant/weapp/notify/notify';

import {
    selfFormatTimeYMDHMS,
    repairAttachUpload,
    uploadVoice
} from "../../../utils/util.js"

import {
    deviceTypeListRq,
    deviceListRq,
    selectAddressListRq,
    selectRoomListRq,
    repairSaveRq,
} from "../../../api/repair/repair.js"


Page({

    /**
     * 页面的初始数据
     */
    data: {
        IMG_NAME: app.IMG_NAME,
        id: null,
        title: null,
        userDetail: {},
        recorderManager: null, // 录音对象
        voiceObj: {}, // 录音文件对象
        innerAudioContext: null, // 音频对象
        innerAudioContextIsPlay: false, // 音频对象-是否播放
        faultLevelShow: false,
        faultLevelList: [{
            name: '一级',
        }, {
            name: '二级',
        }, {
            name: '三级',
        }, ],
        repairTimeVisible: false, // 故障时间show
        repairTime: new Date().getTime(), // 故障时间-当前
        typeVisible: false,
        typeColumns: [{
                values: [],
                className: 'column1',
            },
            {
                values: [],
                className: 'column2',
            },
        ],
        addressVisible: false,
        addressColumns: [{
                values: [],
                className: 'column1',
            },
            {
                values: [],
                className: 'column2',
            },
        ],
        fileList: [], // 上传文件
        detail: {
            "repairName": "", //维修名称
            "repairLevel": "", //维修等级
            "repairTime": null, //故障时间
            "typeId": null, //故障类型
            "typeName": "", //故障名称
            "deviceId": null, //设备
            "deviceName": "", //设备名称
            "name": "", //用户名
            "phone": "", //手机号码
            "addressId": null, // 地点id
            "address": null, // 地点
            "floorId": null, // 楼层id
            "floor": null, // 楼层id
            "room": "", // 门牌号
            "explain": "", // 描述
        },
    },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options) {
        console.log('onLoad', options)
        let _this = this;
        let userDetail = wx.getStorageSync('user')
        //
        let detail = _this.data.detail;
        detail.phone = userDetail.mobile
        _this.setData({
            ...options,
            userDetail,
            detail
        })
        // 页面初始化 options为页面跳转所带来的参数
        wx.setNavigationBarTitle({
            title: options.title
        })

        // 初始化录音
        _this.initRecording()

        // 查询设备类型
        _this.queryDeviceType()

        // 查询地点
        _this.queryAddress()
    },



    // 显示-故障等级
    showFaultLevel() {
        let _this = this;
        _this.setData({
            faultLevelShow: true
        })
    },

    // 选择-故障等级
    selectFaultLevel(e) {
        console.log('selectFaultLevel', e);
        let _this = this;
        let detail = _this.data.detail;
        detail.repairLevel = e.detail.name;
        _this.setData({
            faultLevelShow: false,
            detail
        })
    },

    // 关闭-故障等级
    closeFaultLevel() {
        let _this = this;
        _this.setData({
            faultLevelShow: false
        })
    },

    // 显示-故障时间
    showRepairTime() {
        let _this = this;
        _this.setData({
            repairTimeVisible: true
        })
    },

    // 关闭-故障时间
    hideRepairTime() {
        let _this = this;
        _this.setData({
            repairTimeVisible: false
        })
    },

    // 确认-故障时间
    confirmRepairTime(e) {
        console.log('confirmRepairTime', e);
        let _this = this;
        let detail = _this.data.detail;
        detail.repairTime = selfFormatTimeYMDHMS(e.detail);
        _this.setData({
            repairTimeVisible: false,
            repairTime: e.detail,
            detail
        })
    },

    showType() {
        this.setData({
            typeVisible: true,
        })
    },

    hideType() {
        this.setData({
            typeVisible: false,
        })
    },

    // 查询设备类型
    queryDeviceType() {
        let _this = this
        deviceTypeListRq().then(res => {
            console.log('deviceTypeListRq', res);
            let list = res.rows.map(item => {
                return {
                    id: item.id,
                    text: item.name
                }
            })
            let typeColumns = _this.data.typeColumns
            typeColumns[0].values = list
            _this.setData({
                typeColumns
            })
            // 查询设备
            _this.queryDevice(list[0].id)
        })
    },

    // 查询设备
    queryDevice(id) {
        let _this = this

        deviceListRq({
            typeId: id
        }).then(res => {
            console.log('deviceListRq', res);
            let list = res.rows.map(item => {
                return {
                    id: item.id,
                    text: item.name
                }
            })
            let typeColumns = _this.data.typeColumns
            typeColumns[1].values = list
            _this.setData({
                typeColumns
            })
        })
    },

    // 选择设备类型
    typeColumnsChange(e) {
        console.log('typeColumnsChange', e.detail);
        let _this = this
        const {
            picker,
            value,
            index
        } = e.detail;
        if (index == 0) { // 选择类型
            let obj = value[index]
            _this.queryDevice(obj.id)

        } else if (index == 1) { // 选择设备
            let obj = value[index]
        }
    },

    // 确认设备
    typeColumnsConfirm(e) {
        console.log('typeColumnsConfirm', e.detail);
        let _this = this
        const {
            picker,
            value,
            index
        } = e.detail;
        let detail = _this.data.detail
        detail.typeId = value[0].id
        detail.typeName = value[0].text
        detail.deviceId = value[1].id
        detail.deviceName = value[1].text
        _this.setData({
            detail,
            typeVisible: false
        })
    },


    showAddress() {
        this.setData({
            addressVisible: true,
        })
    },

    hideAddress() {
        this.setData({
            addressVisible: false,
        })
    },

    // 查询地点
    queryAddress() {
        let _this = this
        selectAddressListRq().then(res => {
            console.log('selectAddressListRq', res);
            let list = res.rows.map(item => {
                return {
                    id: item.id,
                    text: item.name
                }
            })
            let addressColumns = _this.data.addressColumns
            addressColumns[0].values = list
            _this.setData({
                addressColumns
            })
            // 查询楼层
            _this.queryRoom(list[0].id)
        })
    },

    // 查询楼层
    queryRoom(id) {
        let _this = this

        selectRoomListRq({
            addressId: id
        }).then(res => {
            console.log('selectRoomListRq', res);
            let list = res.rows.map(item => {
                return {
                    id: item.id,
                    text: item.name
                }
            })
            let addressColumns = _this.data.addressColumns
            addressColumns[1].values = list
            _this.setData({
                addressColumns
            })
        })
    },

    // 选择地点
    addressColumnsChange(e) {
        console.log('addressColumnsChange', e.detail);
        let _this = this
        const {
            picker,
            value,
            index
        } = e.detail;
        if (index == 0) { // 选择地点
            let obj = value[index]
            _this.queryRoom(obj.id)

        } else if (index == 1) { // 选择楼层
            let obj = value[index]
        }
    },

    // 确认地点
    addressColumnsConfirm(e) {
        console.log('addressColumnsConfirm', e.detail);
        let _this = this
        const {
            picker,
            value,
            index
        } = e.detail;
        let detail = _this.data.detail
        detail.addressId = value[0].id
        detail.address = value[0].text
        detail.floorId = value[1].id
        detail.floor = value[1].text
        _this.setData({
            detail,
            addressVisible: false
        })
    },

    initRecording() {
        let _this = this
        let recorderManager = wx.getRecorderManager()
        recorderManager.onStart(() => {
            console.log('recorder start')
        })
        recorderManager.onStop((res) => {
            console.log('recorder stop', res)
            res.duration = parseInt(parseInt(res.duration) / 10) / 100
            _this.setData({
                voiceObj: res,
                innerAudioContext: null, // 音频对象
                innerAudioContextIsPlay: false, // 音频对象-是否播放
            })
        })
        _this.setData({
            recorderManager
        })
    },
    // 开始录音
    startRecording() {
        this.data.recorderManager.start({
            duration: 60000,
            sampleRate: 16000, //采样率，有效值 8000/16000/44100
            numberOfChannels: 1, //录音通道数，有效值 1/2
            encodeBitRate: 96000, //编码码率
            format: 'wav', //音频格式，wav 支持ios、android
            // frameSize: 50, //指定帧大小
            // audioSource: 'auto' //指定录音的音频输入源，可通过 wx.getAvailableAudioSources() 获取
        })
    },

    // 停止录音
    stopRecording() {
        this.data.recorderManager.stop()
    },

    // 播放语音
    startAudio() {
        console.log('startAudio');
        let _this = this
        // 获取innerAudioContext实例
        let innerAudioContext = _this.data.innerAudioContext
        let innerAudioContextIsPlay = _this.data.innerAudioContextIsPlay
        if (!innerAudioContext) {
            // 全局设置播放声音
            wx.setInnerAudioOption({
                obeyMuteSwitch: false
            });
            innerAudioContext = wx.createInnerAudioContext()
            // 设置音频文件的路径
            innerAudioContext.src = _this.data.voiceObj.tempFilePath
            innerAudioContextIsPlay = false
            innerAudioContext.onEnded(() => {
                _this.setData({
                    innerAudioContextIsPlay: false
                })
            })
        }
        if (innerAudioContextIsPlay) { // 播放中
            innerAudioContext.stop()
            innerAudioContextIsPlay = false
        } else { // 未播放
            innerAudioContext.play()
            innerAudioContextIsPlay = true
        }
        //
        _this.setData({
            innerAudioContext,
            innerAudioContextIsPlay
        })
    },

    // 停止语音
    stopAudio() {
        _this.data.innerAudioContext.stop()
    },

    // 清楚语音
    clearAudio() {
        this.setData({
            innerAudioContext: null, // 音频对象
            innerAudioContextIsPlay: false, // 音频对象-是否播放
            voiceObj: {}, // 录音文件对象
        })
    },

    // 图片-上传前校验
    beforeRead(event) {
        // const {
        //     file,
        //     callback
        // } = event.detail;
        // callback(file.type === 'image');
    },

    // 文件-上传后
    async fileAfterRead(event) {
        let _this = this;
        console.log('fileAfterRead', event);
        // 上传完成需要更新 fileList
        let fileList = _this.data.fileList;
        //
        const {
            file
        } = event.detail;
        // 当设置 mutiple 为 true 时, file 为数组格式，否则为对象格式
        for (let i = 0; i < file.length; i++) {
            let url = file[i].url;
            await repairAttachUpload({
                url,
                operate: 'repair'
            }).then(res => {
                console.log('upload file ', res);
                fileList.push({
                    id: res.id,
                    relativeUrl: res.url,
                    url: app.IMG_NAME + res.url,
                    deletable: true,
                })
            })
        }
        _this.setData({
            fileList
        })
    },


    // 删除图片
    deleteImg(event) {
        console.log('deleteImg', event);
        let _this = this;
        let fileList = _this.data.fileList;
        fileList.splice(event.detail.index, 1);
        _this.setData({
            fileList
        })
    },

    // input输入内容监听
    fieldInput(e) {
        console.log('fieldInput', e);
        let _this = this;
        let detail = _this.data.detail;
        detail[e.currentTarget.dataset.name] = e.detail
        _this.setData({
            detail
        })
    },

    // 提交数据
    async submitData() {
        let _this = this;
        // 上传文件列表
        let fileList = _this.data.fileList;
        // 音频
        let voiceObj = _this.data.voiceObj;
        // 数据
        let detail = _this.data.detail;
        //
        //
        // 校验数据
        //
        // 报修名称
        if (!detail.repairName) {
            app.vantNotifyErr(Notify, '输入报修名称!')
            return;
        }
        // 故障等级
        if (!detail.repairLevel) {
            app.vantNotifyErr(Notify, '请选择故障等级!')
            return;
        }
        // 故障时间
        if (!detail.repairTime) {
            app.vantNotifyErr(Notify, '请选择故障时间!')
            return;
        }
        // 故障类型
        if (!detail.typeId) {
            app.vantNotifyErr(Notify, '请选择故障类型!')
            return;
        }
        // 故障地点
        if (!detail.addressId) {
            app.vantNotifyErr(Notify, '请选择故障地点!')
            return;
        }
        // 门牌号
        if (!detail.room) {
            app.vantNotifyErr(Notify, '请输入门牌号!')
            return;
        }
        // 联系电话
        if (detail.phone) {
            if (detail.phone.length != 11) {
                app.vantNotifyErr(Notify, '请输入11位联系电话!')
                return;
            }
        } else {
            app.vantNotifyErr(Notify, '请输入联系电话!')
            return;
        }
        // 报修人姓名
        if (!detail.name) {
            app.vantNotifyErr(Notify, '请输入报修人姓名!')
            return;
        }
        // 故障描述
        if (!detail.explain) {
            app.vantNotifyErr(Notify, '请输入故障描述!')
            return;
        }
        //
        let fileIdList = []
        // 图片上传
        if (fileList && fileList.length > 0) {
            fileIdList = fileList.map(item => item.id)
        }
        // 音频
        if (voiceObj && voiceObj.tempFilePath) {
            await uploadVoice(voiceObj.tempFilePath).then(res => {
                console.log('uploadVoice', res);
                fileIdList.push(res.id)
            })
        }
        //
        // 添加数据
        repairSaveRq({
            repair: detail,
            files: fileIdList
        }).then(res => {
            console.log('visitorPersonRq', res);
            // 
            if (res.code == 0) {
                app.vantNotifySuccess(Notify, res.msg)
                wx.navigateBack()
            } else {
                app.vantNotifyErr(Notify, res.msg)
            }
        })
    },


    // 显示错误消息
    showErrMsg(msg) {
        Notify({
            type: 'danger',
            message: msg
        });
    },

    /**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady: function () {

    },

    /**
     * 生命周期函数--监听页面显示
     */
    onShow: function () {

    },

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

    },

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

    },

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

    },

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

    },

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

    }
})