美食家大橙子 发表于 3 天前

从0到1：多医院陪诊小步调开辟笔记(上）

概要设计

医院陪诊预约小步调：随着移动互联网的遍及，越来越多的医院陪诊服务开始向线上转型, 传统的预约方式往往服从低下，用户需淹灭大量时间举行电话预约或现场排队，陪诊服务预约小步调集多种服务于一体，可以提高服务服从、提升用户体验。 用户可以浏览差异医院的位置、陪诊项目和陪诊时间，用户可以选择日期、时间段和人数，然后举行预约。
功能规划

本项如以后端完备代码包括公告关照，用户预约，签到核销， 管理者可以自定义预约要填写的内容，比如姓名、性别、年事、诊疗科室、手机号等，后台预约管理，后台预约名单管理和导出Excel，后台设置预约时段和人数上线，后台管理最新关照公告，后台用户管理，后台医院管理，医院管理员设定等功能。
https://i-blog.csdnimg.cn/direct/604ac6db5e9549a1b681b80f2d045336.png
数据库设计

MeetModel.DB_STRUCTURE = {
        _pid: 'string|true',
        MEET_ID: 'string|true',
        MEET_ADMIN_ID: 'string|true|comment=添加的管理员',
        MEET_TITLE: 'string|true|comment=标题',

        MEET_UNIT_ID: 'string|false',
        MEET_UNIT_NAME: 'string|false',

        MEET_JOIN_FORMS: 'array|true|default=[]|comment=表单字段设置',
        MEET_DAYS: 'array|true|default=[]|comment=最近一次修改保存的可用日期',

        MEET_CATE_ID: 'string|true|comment=分类编号',
        MEET_CATE_NAME: 'string|true|comment=分类冗余',

        MEET_FORMS: 'array|true|default=[]',
        MEET_OBJ: 'object|true|default={}',

        MEET_CANCEL_SET: 'int|true|default=1|comment=取消设置 0=不允,1=允许,2=仅开始前可取消',

        MEET_STATUS: 'int|true|default=1|comment=状态 0=未启用,1=使用中,9=停止预约,10=已关闭',
        MEET_ORDER: 'int|true|default=9999',
        MEET_VOUCH: 'int|true|default=0',

        MEET_QR: 'string|false',


        MEET_ADD_TIME: 'int|true',
        MEET_EDIT_TIME: 'int|true',
        MEET_ADD_IP: 'string|false',
        MEET_EDIT_IP: 'string|false',
};

JoinModel.DB_STRUCTURE = {
        _pid: 'string|true',
        JOIN_ID: 'string|true',

        JOIN_UNIT_ID: 'string|false',
        JOIN_UNIT_NAME: 'string|false',

        JOIN_EDIT_ADMIN_ID: 'string|false|comment=最近修改的管理员ID',
        JOIN_EDIT_ADMIN_NAME: 'string|false|comment=最近修改的管理员名',
        JOIN_EDIT_ADMIN_TIME: 'int|true|default=0|comment=管理员最近修改的时间',
        JOIN_EDIT_ADMIN_STATUS: 'int|false|comment=最近管理员修改为的状态 ',

        JOIN_IS_ADMIN: 'int|true|default=0|comment=是否管理员添加 0/1',

        JOIN_CODE: 'string|true|comment=核验码15位',
        JOIN_IS_CHECKIN: 'int|true|default=0|comment=是否核销 0/1 ',
        JOIN_CHECKIN_TIME: 'int|true|default=0',

        JOIN_USER_ID: 'string|true|comment=用户ID',
        JOIN_MEET_ID: 'string|true|comment=预约PK',
        JOIN_MEET_CATE_ID: 'string|true',
        JOIN_MEET_CATE_NAME: 'string|true',
        JOIN_MEET_TITLE: 'string|true|comment=项目',
        JOIN_MEET_DAY: 'string|true|comment=日期',
        JOIN_MEET_TIME_START: 'string|true|comment=时段开始',
        JOIN_MEET_TIME_END: 'string|true|comment=时段结束',
        JOIN_MEET_TIME_MARK: 'string|true|comment=时段标识',

        JOIN_COMPLETE_END_TIME: 'string|false|comment=完整结束时间',

        JOIN_START_TIME: 'int|true|comment=开始时间戳',

        JOIN_FORMS: 'array|true|default=[]|comment=表单',
        /* title:
           mark:
           type:
           val:
        */
        JOIN_OBJ: 'object|true|default={}',

        JOIN_STATUS: 'int|true|default=1|comment=状态 1=预约成功,10=已取消, 99=系统取消',

        JOIN_REASON: 'string|false|comment=审核拒绝或者取消理由',

        JOIN_ADD_TIME: 'int|true',
        JOIN_EDIT_TIME: 'int|true',
        JOIN_ADD_IP: 'string|false',
        JOIN_EDIT_IP: 'string|false',
};
焦点实现

class MeetService extends BaseProjectService {

        constructor() {
                super();
                this._log = new LogUtil(projectConfig.MEET_LOG_LEVEL);
        }

        /**
       * 抛出异常
       * @param {*} msg
       * @param {*} code
       */
        AppError(msg) {
                this._log.error(msg);
                super.AppError(msg);
        }

        _meetLog(meet, func = '', msg = '') {
                let str = '';
                str = `[${func}] ${msg}`;
                this._log.debug(str);
        }

        /** 统一获取Meet（某天) */
        async getMeetOneDay(meetId, day, where, fields = '*') {

                let meet = await MeetModel.getOne(where, fields);
                if (!meet) return meet;

                meet.MEET_DAYS_SET = await this.getDaysSet(meetId, day, day);
                return meet;
        }

        /** 获取日期设置 */
        async getDaysSet(meetId, startDay, endDay = null) {
                let where = {
                        DAY_MEET_ID: meetId
                }
                if (startDay && endDay && endDay == startDay)
                        where.day = startDay;
                else if (startDay && endDay)
                        where.day = ['between', startDay, endDay];
                else if (!startDay && endDay)
                        where.day = ['<=', endDay];
                else if (startDay && !endDay)
                        where.day = ['>=', startDay];

                let orderBy = {
                        'day': 'asc'
                }
                let list = await DayModel.getAllBig(where, 'day,dayDesc,times', orderBy, 1000);

                for (let k = 0; k < list.length; k++) {
                        delete list._id;
                }

                return list;
        }

        // 按时段统计某时段报名情况
        async statJoinCnt(meetId, timeMark) {
                let whereDay = {
                        DAY_MEET_ID: meetId,
                        day: this.getDayByTimeMark(timeMark)
                };
                let day = await DayModel.getOne(whereDay, 'times');
                if (!day) return;

                let whereJoin = {
                        JOIN_MEET_TIME_MARK: timeMark,
                        JOIN_MEET_ID: meetId
                };
                let ret = await JoinModel.groupCount(whereJoin, 'JOIN_STATUS');

                let stat = { //统计数据
                        succCnt: ret['JOIN_STATUS_1'] || 0, //1=预约成功,
                        cancelCnt: ret['JOIN_STATUS_10'] || 0, //10=已取消,
                        adminCancelCnt: ret['JOIN_STATUS_99'] || 0, //99=后台取消
                };

                let times = day.times;
                for (let j in times) {
                        if (times.mark === timeMark) {
                                let data = {
                                        ['times.' + j + '.stat']: stat
                                }
                                await DayModel.edit(whereDay, data);
                                return;
                        }
                }

        }


        // 预约前检测
        async beforeJoin(userId, meetId, timeMark) {
                await this.checkMeetRules(userId, meetId, timeMark);
        }


        // 根据日期获取其所在天设置
        getDaySetByDay(meet, day) {
                for (let k = 0; k < meet.MEET_DAYS_SET.length; k++) {
                        if (meet.MEET_DAYS_SET.day == day)
                                return dataUtil.deepClone(meet.MEET_DAYS_SET);
                }
                return null;
        }

        // 根据时段标识获取其所在天
        getDayByTimeMark(timeMark) {
                return timeMark.substr(1, 4) + '-' + timeMark.substr(5, 2) + '-' + timeMark.substr(7, 2);
        }

        // 根据时段标识获取其所在天设置
        getDaySetByTimeMark(meet, timeMark) {
                let day = this.getDayByTimeMark(timeMark);

                for (let k = 0; k < meet.MEET_DAYS_SET.length; k++) {
                        if (meet.MEET_DAYS_SET.day == day)
                                return dataUtil.deepClone(meet.MEET_DAYS_SET);
                }
                return null;
        }

        // 根据时段标识获取其所在时段设置
        getTimeSetByTimeMark(meet, timeMark) {
                let day = this.getDayByTimeMark(timeMark);

                for (let k = 0; k < meet.MEET_DAYS_SET.length; k++) {
                        if (meet.MEET_DAYS_SET.day != day) continue;

                        for (let j in meet.MEET_DAYS_SET.times) {
                                if (meet.MEET_DAYS_SET.times.mark == timeMark)
                                        return dataUtil.deepClone(meet.MEET_DAYS_SET.times);
                        }
                }
                return null;
        }

        // 预约时段人数和状态控制校验
        async checkMeetTimeControll(meet, timeMark, meetPeopleCnt = 1) {
                if (!meet) this.AppError('预约时段设置错误, 预约项目不存在');

                let daySet = this.getDaySetByTimeMark(meet, timeMark); // 当天设置
                let timeSet = this.getTimeSetByTimeMark(meet, timeMark); // 预约时段设置

                if (!daySet || !timeSet) this.AppError('预约时段设置错误day&time');

                let statusDesc = timeSet.status == 1 ? '开启' : '关闭';
                let limitDesc = '';
                if (timeSet.isLimit) {
                        limitDesc = '人数上限MAX=' + timeSet.limit;
                } else
                        limitDesc = '人数不限制NO';

                this._meetLog(meet, `------------------------------`);
                this._meetLog(meet, `#预约时段控制,预约日期=<${daySet.day}>`, `预约时段=[${timeSet.start}-${timeSet.end}],状态=${statusDesc}, ${limitDesc} 当前预约成功人数=${timeSet.stat.succCnt}`);

                if (timeSet.status == 0) this.AppError('该时段预约已经关闭，请选择其他');

                // 时段总人数限制
                if (timeSet.isLimit) {
                        if (timeSet.stat.succCnt >= timeSet.limit) {
                                this.AppError('该时段预约人员已满，请选择其他');
                        }

                        let maxCnt = timeSet.limit - timeSet.stat.succCnt;

                        if (maxCnt < meetPeopleCnt) {
                                this.AppError('本时段最多还可以预约' + (maxCnt) + '人，您当前提交了' + meetPeopleCnt + '人，请调整后再提交');
                        }
                }

        }


        /** 报名规则校验 */
        async checkMeetRules(userId, meetId, timeMark, formsList = null) {

                // 预约时段是否存在
                let meetWhere = {
                        _id: meetId
                };
                let day = this.getDayByTimeMark(timeMark);
                let meet = await this.getMeetOneDay(meetId, day, meetWhere);
                if (!meet) {
                        this.AppError('预约时段选择错误，请重新选择');
                }

                // 预约时段人数和状态控制校验
                let meetPeopleCnt = formsList ? formsList.length : 1;

                await this.checkMeetTimeControll(meet, timeMark, meetPeopleCnt);

                // 截止规则
                await this.checkMeetEndSet(meet, timeMark);


                // 针对用户的次数限制
                await this.checkMeetLimitSet(userId, meet, timeMark, meetPeopleCnt);

        }


        // 预约次数限制校验
        async checkMeetLimitSet(userId, meet, timeMark, nowCnt) {
                if (!meet) this.AppError('预约次数规则错误, 预约项目不存在');
                let meetId = meet._id;

                let daySet = this.getDaySetByTimeMark(meet, timeMark); // 当天设置
                let timeSet = this.getTimeSetByTimeMark(meet, timeMark); // 预约时段设置

                this._meetLog(meet, `------------------------------`);
                this._meetLog(meet, `#预约次数规则,预约日期=<${daySet.day}>`, `预约时段=[${timeSet.start}～${timeSet.end}]`);

                let where = {
                        JOIN_MEET_ID: meetId,
                        JOIN_MEET_TIME_MARK: timeMark,
                        JOIN_USER_ID: userId,
                        JOIN_STATUS: JoinModel.STATUS.SUCC
                }
                let cnt = await JoinModel.count(where);
                let maxCnt = projectConfig.MEET_MAX_JOIN_CNT;
                this._meetLog(meet, `预约次数规则,mode=本时段可预约${maxCnt}次`, `当前已预约=${cnt}次`);

                if (cnt >= maxCnt)
                        this.AppError(`您本时段已经预约，不能继续预约`);

        }



        // 预约截止设置校验
        async checkMeetEndSet(meet, timeMark) {
                if (!meet) this.AppError('预约截止规则错误, 预约项目不存在');


                this._meetLog(meet, `------------------------------`);
                let daySet = this.getDaySetByTimeMark(meet, timeMark); // 当天设置
                let timeSet = this.getTimeSetByTimeMark(meet, timeMark); // 预约时段设置

                this._meetLog(meet, `#预约截止规则,预约日期=<${daySet.day}>`, `预约时段=[${timeSet.start}-${timeSet.end}]`);

                let nowTime = timeUtil.time('Y-M-D h:m:s');

                /*
                let startTime = daySet.day + ' ' + timeSet.start + ':00';
                this._meetLog(meet, `预约开始规则,mode=<时段过期判定>`, `预约开始时段=${startTime},当前时段=${nowTime}`);
                if (nowTime > startTime) {
                        this.AppError('该时段已开始，无法预约，请选择其他');
                }*/

                let endTime = daySet.day + ' ' + timeSet.end + ':59';
                this._meetLog(meet, `预约开始规则,mode=<时段过期判定>`, `预约结束时段=${endTime},当前时段=${nowTime}`);
                if (nowTime > endTime) {
                        this.AppError('该时段已结束，无法预约，请选择其他');
                }

        }


        /**预约详情 */
        async viewMeet(meetId) {

                let fields = '*';

                let where = {
                        _id: meetId,
                        MEET_STATUS: ['in', ]
                }
                let meet = await MeetModel.getOne(where, fields);
                if (!meet) return null;


                let getDaysSet = [];
                meet.MEET_DAYS_SET = await this.getDaysSet(meetId, timeUtil.time('Y-M-D')); //今天及以后
                let daysSet = meet.MEET_DAYS_SET;

                let now = timeUtil.time('Y-M-D');
                for (let k = 0; k < daysSet.length; k++) {
                        let dayNode = daysSet;

                        if (dayNode.day < now) continue; // 排除过期

                        let getTimes = [];

                        for (let j in dayNode.times) {
                                let timeNode = dayNode.times;

                                // 排除状态关闭的时段
                                if (timeNode.status != 1) continue;

                                // 判断数量是否已满
                                if (timeNode.isLimit && timeNode.stat.succCnt >= timeNode.limit)
                                        timeNode.error = '预约已满';

                                // 截止规则
                                if (!timeNode.error) {
                                        try {
                                                await this.checkMeetEndSet(meet, timeNode.mark);
                                        } catch (ex) {
                                                if (ex.name == 'AppError')
                                                        timeNode.error = '预约结束';
                                                else
                                                        throw ex;
                                        }
                                }

                                getTimes.push(timeNode);
                        }
                        dayNode.times = getTimes;

                        getDaysSet.push(dayNode);
                }

                // 只返回需要的字段
                let ret = {};
                ret.MEET_DAYS_SET = getDaysSet;

                ret.MEET_QR = meet.MEET_QR;
                ret.MEET_TITLE = meet.MEET_TITLE;
                ret.MEET_CATE_NAME = meet.MEET_CATE_NAME;
                ret.MEET_OBJ = meet.MEET_OBJ;
                ret.MEET_UNIT_NAME = meet.MEET_UNIT_NAME;

                return ret;
        }


        /**预约前获取关键信息 */
        async detailForJoin(userId, meetId, timeMark) {

                let fields = 'MEET_DAYS_SET,MEET_JOIN_FORMS, MEET_TITLE';

                let where = {
                        _id: meetId,
                        MEET_STATUS: ['in', ]
                }
                let day = this.getDayByTimeMark(timeMark);
                let meet = await this.getMeetOneDay(meetId, day, where, fields);
                if (!meet) return null;

                let dayDesc = timeUtil.fmtDateCHN(this.getDaySetByTimeMark(meet, timeMark).day);

                let timeSet = this.getTimeSetByTimeMark(meet, timeMark);
                let timeDesc = timeSet.start + '～' + timeSet.end;
                meet.dayDesc = dayDesc + ' ' + timeDesc;

                // 取出本人最近一次本时段填写表单
                let whereMy = {
                        JOIN_USER_ID: userId,
                }
                let orderByMy = {
                        JOIN_ADD_TIME: 'desc'
                }
                let joinMy = await JoinModel.getOne(whereMy, 'JOIN_FORMS', orderByMy);


                if (joinMy)
                        meet.myForms = joinMy.JOIN_FORMS;
                else
                        meet.myForms = [];

                return meet;
        }

        /** 按天获取预约项目 */
        async getMeetListByDay(unit, day) {
                let where = {
                        'meet.MEET_STATUS': ['in', ],
                        'day': day,
                        DAY_UNIT_NAME: unit,
                };

                let orderBy = {
                        'MEET_ORDER': 'asc',
                        'MEET_ADD_TIME': 'desc'
                };

                let fields = 'meet.MEET_UNIT_NAME,meet.MEET_ORDER,meet.MEET_ADD_TIME,meet.MEET_TITLE,meet.MEET_DAYS_SET,meet.MEET_OBJ.cover, DAY_MEET_ID, day, times';

                let joinParams = {
                        from: MeetModel.CL,
                        localField: 'DAY_MEET_ID',
                        foreignField: '_id',
                        as: 'meet',
                };

                let list = await DayModel.getListJoin(joinParams, where, fields, orderBy, 1, 100, false);
                list = list.list;
                let retList = [];

                for (let k = 0; k < list.length; k++) {

                        let usefulTimes = [];

                        for (let j in list.times) {
                                if (list.times.status != 1) continue;
                                usefulTimes.push(list.times);
                        }

                        if (usefulTimes.length == 0) continue;

                        let node = {};
                        node.timeDesc = usefulTimes.length > 1 ? usefulTimes.length + '个时段' : usefulTimes.start;
                        node.title = list.meet.MEET_TITLE;
                        node.pic = list.meet.MEET_OBJ.cover;
                        node._id = list.DAY_MEET_ID;
                        retList.push(node);

                }
                return retList;
        }

        /** 获取从某天开始可预约的日期 */
        async getHasDaysFromDay(unit, day) {
                console.log(unit)
                let where = {
                        DAY_UNIT_NAME: unit,
                        day: ['>=', day],
                };

                let fields = 'DAY_UNIT_NAME,times,day';
                let list = await DayModel.getAllBig(where, fields);

                let retList = [];
                for (let k = 0; k < list.length; k++) {
                        for (let n in list.times) {
                                if (list.times.status == 1) {
                                        retList.push(list.day);
                                        break;
                                }
                        }
                } console.log(retList)
                return retList;
        }

        /** 取得预约分页列表 */
        async getMeetList({
                unit,
                search, // 搜索条件
                sortType, // 搜索菜单
                sortVal, // 搜索菜单
                orderBy, // 排序
                cateId, //分类查询条件
                page,
                size,
                isTotal = true,
                oldTotal
        }) {

                orderBy = orderBy || {
                        'MEET_ORDER': 'asc',
                        'MEET_ADD_TIME': 'desc'
                };
                let fields = 'MEET_UNIT_NAME,MEET_TITLE,MEET_OBJ,MEET_DAYS,MEET_CATE_NAME,MEET_CATE_ID';

                let where = {};
                where.and = {
                        MEET_UNIT_NAME: unit,
                        _pid: this.getProjectId() //复杂的查询在此处标注PID
                };

                if (cateId && cateId !== '0') where.and.MEET_CATE_ID = cateId;

                where.and.MEET_STATUS = ['in', ]; // 状态

                if (util.isDefined(search) && search) {
                        where.or = [
                                { MEET_TITLE: ['like', search] },
                        ];

                } else if (sortType && util.isDefined(sortVal)) {
                        // 搜索菜单
                        switch (sortType) {
                                case 'sort': {
                                        orderBy = this.fmtOrderBySort(sortVal, 'NEWS_ADD_TIME');
                                        break;
                                }
                                case 'cateId': {
                                        if (sortVal) where.and.MEET_CATE_ID = String(sortVal);
                                        break;
                                }
                        }
                }
                let result = await MeetModel.getList(where, fields, orderBy, page, size, isTotal, oldTotal);

                return result;
        }



        /** 取消我的预约 只有成功可以取消 */
        async cancelMyJoin(userId, joinId) {
                let where = {
                        JOIN_USER_ID: userId,
                        _id: joinId,
                        JOIN_IS_CHECKIN: 0, // 核销不能取消
                        JOIN_STATUS: JoinModel.STATUS.SUCC
                };
                let join = await JoinModel.getOne(where);

                if (!join) {
                        this.AppError('未找到可取消的预约记录');
                }

                // 取消规则判定
                let whereMeet = {
                        _id: join.JOIN_MEET_ID,
                        MEET_STATUS: ['in', ]
                }
                let meet = await this.getMeetOneDay(join.JOIN_MEET_ID, join.JOIN_MEET_DAY, whereMeet);
                if (!meet) this.AppError('预约项目不存在或者已关闭');

                let daySet = this.getDaySetByTimeMark(meet, join.JOIN_MEET_TIME_MARK);
                let timeSet = this.getTimeSetByTimeMark(meet, join.JOIN_MEET_TIME_MARK);
                if (!timeSet) this.AppError('被取消的时段不存在');


                if (meet.MEET_CANCEL_SET == 0)
                        this.AppError('该预约不能取消');


                let startT = daySet.day + ' ' + timeSet.start + ':00';
                let startTime = timeUtil.time2Timestamp(startT);
                let now = timeUtil.time();
                if (meet.MEET_CANCEL_SET == 2 && now > startTime)
                        this.AppError('该预约时段已经开始，无法取消');

                // TODO 已过期不能取消


                await JoinModel.del(where);


                // 统计
                this.statJoinCnt(join.JOIN_MEET_ID, join.JOIN_MEET_TIME_MARK);

        }

        /** 取得我的预约详情 */
        async getMyJoinDetail(userId, joinId) {

                let fields = 'JOIN_UNIT_NAME,JOIN_COMPLETE_END_TIME,JOIN_IS_CHECKIN,JOIN_CHECKIN_TIME,JOIN_REASON,JOIN_MEET_ID,JOIN_MEET_TITLE,JOIN_MEET_DAY,JOIN_MEET_TIME_START,JOIN_MEET_TIME_END,JOIN_STATUS,JOIN_ADD_TIME,JOIN_CODE,JOIN_FORMS';

                let where = {
                        _id: joinId,
                        JOIN_USER_ID: userId
                };
                return await JoinModel.getOne(where, fields);
        }

        /** 取得我的预约分页列表 */
        async getMyJoinList(userId, {
                search, // 搜索条件
                sortType, // 搜索菜单
                sortVal, // 搜索菜单
                orderBy, // 排序
                page,
                size,
                isTotal = true,
                oldTotal
        }) {
                orderBy = orderBy || {
                        //        'JOIN_MEET_DAY': 'desc',
                        //        'JOIN_MEET_TIME_START': 'desc',
                        'JOIN_ADD_TIME': 'desc'
                };
                let fields = 'JOIN_UNIT_NAME,JOIN_COMPLETE_END_TIME,JOIN_IS_CHECKIN,JOIN_REASON,JOIN_MEET_ID,JOIN_MEET_TITLE,JOIN_MEET_DAY,JOIN_MEET_TIME_START,JOIN_MEET_TIME_END,JOIN_STATUS,JOIN_ADD_TIME,JOIN_OBJ';

                let where = {
                        JOIN_USER_ID: userId
                };
                //where.MEET_STATUS = ['in', ]; // 状态

                if (util.isDefined(search) && search) {
                        where['JOIN_MEET_TITLE'] = {
                                $regex: '.*' + search,
                                $options: 'i'
                        };
                } else if (sortType) {
                        // 搜索菜单
                        switch (sortType) {

                                case 'cateId': {
                                        if (sortVal) where.JOIN_MEET_CATE_ID = String(sortVal);
                                        break;
                                }
                                case 'all': { //所有
                                        break;
                                }
                                case 'use': { //可用未过期
                                        where.JOIN_STATUS = JoinModel.STATUS.SUCC;
                                        where.JOIN_COMPLETE_END_TIME = ['>=', timeUtil.time('Y-M-D h:m')];
                                        break;
                                }
                                case 'check': { //已核销
                                        where.JOIN_STATUS = JoinModel.STATUS.SUCC;
                                        where.JOIN_IS_CHECKIN = 1;
                                        break;
                                }
                                case 'timeout': { //已过期未核销
                                        where.JOIN_STATUS = JoinModel.STATUS.SUCC;
                                        where.JOIN_IS_CHECKIN = 0;
                                        where.JOIN_COMPLETE_END_TIME = ['<', timeUtil.time('Y-M-D h:m')];
                                        break;
                                }
                                case 'succ': { //预约成功
                                        where.JOIN_STATUS = JoinModel.STATUS.SUCC;
                                        //where.JOIN_MEET_DAY = ['>=', timeUtil.time('Y-M-D h:m')];
                                        //where.JOIN_MEET_TIME_START = ['>=', timeUtil.time('h:m')];
                                        break;
                                }
                                case 'cancel': { //已取消
                                        where.JOIN_STATUS = ['in', ];
                                        break;
                                }
                        }
                }
                let result = await JoinModel.getList(where, fields, orderBy, page, size, isTotal, oldTotal);

                return result;
        }

        /** 取得我的某日预约列表 */
        async getMyJoinSomeday(userId, day) {

                let fields = 'JOIN_IS_CHECKIN,JOIN_MEET_ID,JOIN_MEET_TITLE,JOIN_MEET_DAY,JOIN_MEET_TIME_START,JOIN_MEET_TIME_END,JOIN_STATUS,JOIN_ADD_TIME';

                let where = {
                        JOIN_USER_ID: userId,
                        JOIN_MEET_DAY: day
                };
                //where.MEET_STATUS = ['in', ]; // 状态

                let orderBy = {
                        'JOIN_MEET_TIME_START': 'asc',
                        'JOIN_ADD_TIME': 'desc'
                }

                return await JoinModel.getAll(where, fields, orderBy);


        }
}
UI设计

https://i-blog.csdnimg.cn/direct/997f3e6b13284d3fb133d33e4376c6f4.png
https://i-blog.csdnimg.cn/direct/aa50592a542142b796926c817cce60b0.png
https://i-blog.csdnimg.cn/direct/d256223196b149bb945364bfad08acf1.png
https://i-blog.csdnimg.cn/direct/26b069eeae49489a84f84a930cd3ada0.png
https://i-blog.csdnimg.cn/direct/a184f87a85f44967ad239f6c2cb82c72.png
https://i-blog.csdnimg.cn/direct/a6ac8e73e9e44236b204d69bb7f199d2.png
后台管理体系设计

https://i-blog.csdnimg.cn/direct/25a7f7da8d4145a4b8207a77352ec4ee.png
https://i-blog.csdnimg.cn/direct/bee15c905a424fedacc74b0ba4462251.png
https://i-blog.csdnimg.cn/direct/d6c8f74a57ce49acbfe49f49a868f4b3.png
https://i-blog.csdnimg.cn/direct/5a1d90a77edb460784e64ed1754309ab.png
https://i-blog.csdnimg.cn/direct/d2194b88c5d14064a02993a8caacf2f5.png
https://i-blog.csdnimg.cn/direct/ebd73905d39349ab8a5ba13ab6c7dc15.png
https://i-blog.csdnimg.cn/direct/969bf57cd28d442eaf1c904dc01e96fe.png
git下载

github下载

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。
页: [1]
查看完整版本: 从0到1：多医院陪诊小步调开辟笔记(上）