cooleshow/cooleshow-user/user-biz/src/main/resources/config/mybatis/CourseScheduleMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yonge.cooleshow.biz.dal.dao.CourseScheduleDao">
    <resultMap id="BaseResultMap" type="com.yonge.cooleshow.biz.dal.entity.CourseSchedule">
        <id column="id_" jdbcType="INTEGER" property="id"/>
        <result column="course_group_id_" jdbcType="INTEGER" property="courseGroupId"/>
        <result column="type_" jdbcType="VARCHAR" property="type"/>
        <result column="status_" jdbcType="VARCHAR" property="status"/>
        <result column="class_num_" jdbcType="INTEGER" property="classNum"/>
        <result column="teacher_id_" jdbcType="INTEGER" property="teacherId"/>
        <result column="class_date_" jdbcType="TIMESTAMP" property="classDate"/>
        <result column="start_time_" jdbcType="TIMESTAMP" property="startTime"/>
        <result column="end_time_" jdbcType="TIMESTAMP" property="endTime"/>
        <result column="lock_" jdbcType="INTEGER" property="lock"/>
        <result column="lock_time_" jdbcType="TIMESTAMP" property="lockTime"/>
        <result column="ex_student_num_" jdbcType="INTEGER" property="exStudentNum"/>
        <result column="created_by_" jdbcType="INTEGER" property="createdBy"/>
        <result column="created_time_" jdbcType="TIMESTAMP" property="createdTime"/>
        <result column="updated_by_" jdbcType="INTEGER" property="updatedBy"/>
        <result column="updated_time_" jdbcType="TIMESTAMP" property="updatedTime"/>
    </resultMap>

    <sql id="Base_Column_List">
        id_
        , course_group_id_, type_, status_,class_num_, teacher_id_, class_date_, start_time_, end_time_, lock_, lock_time_, ex_student_num_, created_by_, created_time_, updated_by_, updated_time_
    </sql>

    <insert id="insertBatch" keyColumn="id_" keyProperty="id" useGeneratedKeys="true"
            parameterType="com.yonge.cooleshow.biz.dal.entity.CourseSchedule">
        insert into course_schedule(course_group_id_, type_, status_,class_num_, teacher_id_, class_date_, start_time_,
        end_time_, lock_, lock_time_, ex_student_num_, created_by_, created_time_, updated_by_,
        updated_time_)
        values
        <foreach collection="entities" item="entity" separator=",">
            (#{entity.courseGroupId}, #{entity.type}, #{entity.status},#{entity.classNum}, #{entity.teacherId}, #{entity.classDate},
            #{entity.startTime}, #{entity.endTime}, #{entity.lock}, #{entity.lockTime},
            #{entity.exStudentNum}, #{entity.createdBy}, #{entity.createdTime}, #{entity.updatedBy},
            #{entity.updatedTime})
        </foreach>
    </insert>

    <select id="queryTeacherTotal" resultType="com.yonge.cooleshow.biz.dal.vo.TeacherTotalVo">
        select a.*,b.starGrade from (
            <!-- 统计查询已上课时数,未上课时数 -->
            select
                a.teacher_id_ as userId,
                sum(if(a.end_time_ &lt;= now(),1,0)) as expTime,
                sum(if(a.end_time_ &gt; now(),1,0)) as unExpTime
            from course_schedule a
            where a.lock_ = 0 and a.type_ = 'PRACTICE'
            group by a.teacher_id_
        ) a
        left join (
            <!-- 统计老师星级评分 -->
            select
                a.teacher_id_ as userId,
                avg (b.score_) as starGrade
            from course_schedule a
            join course_schedule_replied b on a.id_ = b.course_schedule_id_
            where a.lock_ = 0 and type_ = 'PRACTICE' and b.score_ is not null
            group by a.teacher_id_
        ) b on a.userId = b.userId
    </select>
    <select id="queryStudentTotal" resultType="com.yonge.cooleshow.biz.dal.vo.StudentTotalVo">
        select
            b.user_id_ as userId,
            sum(if(a.end_time_ &lt;= now(),1,0)) as finshHours,
            sum(if(a.end_time_ &gt; now(),1,0)) as unfinshHours
        from course_schedule a
        join course_schedule_student_payment b on a.id_ = b.course_id_
        where a.lock_ = 0 and a.type_ = 'PRACTICE'
        group by b.user_id_
    </select>

    <select id="queryStudentCourse" resultMap="BaseResultMap">
        select b.id_,
               b.course_group_id_,
               b.type_,
               b.class_num_,
               b.teacher_id_,
               b.class_date_,
               b.start_time_,
               b.end_time_,
               b.lock_,
               b.lock_time_,
               b.ex_student_num_,
               b.status_,
               b.created_by_,
               b.created_time_,
               b.updated_by_,
               b.updated_time_
        from course_schedule_student_payment as a
                 left join course_schedule as b on a.course_id_ = b.id_
        <where>
            a.user_id_ = #{param.studentId}
            <if test="param.greaterDate != null">
                AND <![CDATA[ b.start_time_ > #{param.greaterDate} ]]>
            </if>
            <if test="param.startClassDate != null">
                AND <![CDATA[ b.class_date_  >= #{param.startClassDate} ]]>
            </if>
            <if test="param.endClassDate != null">
                AND <![CDATA[ b.class_date_  <= #{param.endClassDate} ]]>
            </if>
            <if test="param.classDate != null">
                AND b.class_date_ = #{param.classDate}
            </if>
            <if test="param.status != null">
                AND b.status_ = #{param.status}
            </if>
            <if test="param.statusList != null">
                AND b.status_ IN
                <foreach collection="param.statusList" item="item" open="(" separator="," close=")">
                    #{item}
                </foreach>
            </if>
        </where>
        order by b.start_time_ desc
    </select>

    <select id="queryLiveTeacherCourse" resultType="com.yonge.cooleshow.biz.dal.vo.TeacherLiveCourseInfoVo">
        select
        b.id_ as courseGroupId,
        b.name_ as courseGroupName,
        s.name_ as subjectName,
        a.start_time_ as startTime,
        a.end_time_ as endTime,
        a.status_ as `status`,
        b.pre_student_num_ as studentCount,
        b.background_pic_ as backgroundPic,
        b.im_group_id_  as imGroupId
        from course_schedule as a
        left join course_group as b on a.course_group_id_ = b.id_
        left join subject as s on b.subject_id_ = s.id_
        where b.teacher_id_ = #{param.teacherId}
        AND a.lock_ = 0
        AND a.type_ = #{param.type}
        <![CDATA[ AND a.class_date_  >= #{param.startDate} ]]>
        <![CDATA[ AND a.class_date_  <= #{param.endDate} ]]>
        <if test="param.status !=null and param.status !=''">
            AND a.status_ = #{param.status}
        </if>
        <if test="param.subjectId != null">
            AND b.subject_id_ = #{param.subjectId}
        </if>
    </select>

    <select id="queryTeacherPracticeCourse" resultType="com.yonge.cooleshow.biz.dal.vo.MyCourseVo">
        SELECT
            u.id_ AS userId,
            u.username_ AS userName,
            u.real_name_ AS realName,
            u.avatar_ AS avatar,
            cs.class_date_ AS classDate,
            cs.start_time_ AS startTime,
            cs.end_time_ AS endTime,
            cs.status_ AS `status`,
            g.subject_id_ AS subjectId,
            sb.name_ AS subjectName,
            p.course_id_ AS courseId,
            p.course_group_id_ AS courseGoupId
        FROM course_schedule_student_payment p
        LEFT JOIN sys_user u ON p.user_id_ =u.id_
        LEFT JOIN course_schedule cs ON p.course_id_=cs.id_
        LEFT JOIN course_group g ON p.course_group_id_ = g.id_
        LEFT JOIN `subject` sb ON g.subject_id_=sb.id_
        WHERE p.course_id_ IN
        (SELECT s.id_ FROM course_schedule s WHERE s.type_='PRACTICE' AND s.teacher_id_=#{param.teacherId})
        <if test="param.status !=null and param.status !=''">
            AND cs.status_ = #{param.status}
        </if>
        <if test="param.subjectId !=null">
            AND g.subject_id_ = #{param.subjectId}
        </if>
        <if test="param.classDate !=null and param.classDate !=''">
            AND cs.class_date_ = #{param.classDate}
        </if>
        <if test="param.startDate !=null and param.startDate !=''">
            <![CDATA[ AND cs.class_date_  >= #{param.startDate} ]]>
        </if>
        <if test="param.endDate !=null and param.endDate !=''">
            <![CDATA[ AND cs.class_date_  <= #{param.endDate} ]]>
        </if>
        <if test="param.repliedIds !=null">
            AND p.user_id_ IN
            <foreach collection="param.repliedIds" item="repliedIds" open="(" close=")" separator=",">
                #{repliedIds}
            </foreach>
        </if>
        <if test="param.studentName !=null and param.studentName !=''">
            AND u.username_ LIKE CONCAT('%', #{param.studentName}, '%')
        </if>
    </select>

    <select id="countTeacherNoDecorateHomework" resultType="java.lang.Integer">

        select count(1)
        from course_schedule cs
        left join course_homework ch on ch.course_schedule_id_ = cs.id_
        <where>
            <!-- 没有布置作业记录 -->
            <if test="param.decorate != null">
                <if test="param.decorate.code == 0">
                    and ch.id_ is null
                </if>
                <if test="param.decorate.code == 1">
                    and ch.id_ is not null
                </if>
            </if>
            <if test="param.courseStatus != null">
                and cs.type_ = #{param.courseType}
            </if>
            <if test="param.courseType != null">
                and cs.status_ = #{param.courseStatus}
            </if>
            <if test="param.teacherId != null">
                and cs.teacher_id_ = #{param.teacherId}
            </if>
            <if test="param.courseScheduleId != null ">
                and cs.id_ = #{param.courseScheduleId}
            </if>
        </where>
    </select>

    <select id="queryCourseSchedule" resultType="java.lang.String"
            parameterType="com.yonge.cooleshow.biz.dal.dto.search.MyCourseSearch">
        SELECT s.class_date_
        FROM course_schedule_student_payment p
        LEFT JOIN course_schedule s ON p.course_id_ = s.id_
        WHERE s.teacher_id_=#{teacherId}
        <![CDATA[ AND s.class_date_  >= #{startDate} ]]>
        <![CDATA[ AND s.class_date_  <= #{endDate} ]]>
    </select>

    <select id="queryStudentPracticeCourse" resultType="com.yonge.cooleshow.biz.dal.vo.MyCourseVo">
        SELECT
            s.id_ AS courseId,
            s.course_group_id_ AS courseGoupId,
            s.class_date_ AS classDate,
            s.start_time_ AS startTime,
            s.end_time_ AS endTime,
            s.status_ AS `status`,
            s.teacher_id_ AS teacherId,
            u.id_ AS userId,
            u.username_ AS userName,
            u.real_name_ AS realName,
            u.avatar_ AS avatar,
            g.subject_id_ AS subjectId,
            b.name_ AS subjectName
        FROM course_schedule s
        LEFT JOIN sys_user u ON s.teacher_id_ = u.id_
        LEFT JOIN course_group g ON s.course_group_id_ = g.id_
        LEFT JOIN `subject` b ON g.subject_id_ = b.id_
        WHERE s.id_ IN
        (SELECT course_id_ FROM course_schedule_student_payment WHERE user_id_ = #{param.studentId} AND course_type_ = 'PRACTICE')
        <if test="param.status !=null and param.status !=''">
            AND s.status_ = #{param.status}
        </if>
        <if test="param.subjectId !=null">
            AND g.subject_id_ = #{param.subjectId}
        </if>
        <if test="param.classDate !=null and param.classDate !=''">
            AND s.class_date_ = #{param.classDate}
        </if>
        <if test="param.startDate !=null and param.startDate !=''">
            <![CDATA[ AND s.class_date_  >= #{param.startDate} ]]>
        </if>
        <if test="param.endDate !=null and param.endDate !=''">
            <![CDATA[ AND s.class_date_  <= #{param.endDate} ]]>
        </if>
    </select>

    <select id="queryCourseUser" resultType="com.yonge.cooleshow.biz.dal.vo.CourseStudent">
        SELECT
            cs.id_ AS courseId,
            cs.course_group_id_ AS courseGoupId,
            cs.class_date_ AS classDate,
            cs.start_time_ AS startTime,
            cs.end_time_ AS endTime,
            cs.status_ AS `status`,
            cs.type_ AS courseType,
            NULL AS userId,
            CONCAT(g.name_,'-第',cs.class_num_,'课') AS name,
            NULL AS realName,
            p.payCount AS payCount,
            g.background_pic_ AS cover,
            g.subject_id_ AS subjectId,
            sb.name_ AS subjectName
        FROM course_schedule cs
        LEFT JOIN course_group g ON cs.course_group_id_ = g.id_
        LEFT JOIN (SELECT course_id_ AS pid,count(*) AS payCount FROM course_schedule_student_payment GROUP BY course_id_ ) p ON cs.id_=p.pid
        LEFT JOIN `subject` sb ON g.subject_id_=sb.id_
        WHERE cs.type_='LIVE'
        AND cs.teacher_id_=#{param.teacherId}
        AND cs.class_date_=#{param.classDate}
        AND cs.id_ IN(
            SELECT c.id_
            FROM course_schedule_student_payment p,course_schedule c
            WHERE p.course_id_=c.id_
            AND p.course_group_id_ = c.course_group_id_
            AND c.teacher_id_=#{param.teacherId}
            AND c.class_date_=#{param.classDate}
            AND c.type_='LIVE')
        UNION
        SELECT
            p.course_id_ AS courseId,
            p.course_group_id_ AS courseGoupId,
            cs.class_date_ AS classDate,
            cs.start_time_ AS startTime,
            cs.end_time_ AS endTime,
            cs.status_ AS `status`,
            cs.type_ AS courseType,
            u.id_ AS userId,
            u.username_ AS name,
            u.real_name_ AS realName,
            NULL AS payCount,
            u.avatar_ AS cover,
            g.subject_id_ AS subjectId,
            sb.name_ AS subjectName
        FROM course_schedule_student_payment p
        LEFT JOIN sys_user u ON p.user_id_ =u.id_
        LEFT JOIN course_schedule cs ON p.course_id_=cs.id_
        LEFT JOIN course_group g ON p.course_group_id_ = g.id_
        LEFT JOIN `subject` sb ON g.subject_id_=sb.id_
        WHERE p.course_id_ IN (SELECT s.id_ FROM course_schedule s WHERE s.type_='PRACTICE' AND s.teacher_id_=#{param.teacherId})
        AND cs.class_date_=#{param.classDate}
        ORDER BY startTime
    </select>

    <select id="queryCourseScheduleStudent" resultType="java.lang.String"
            parameterType="com.yonge.cooleshow.biz.dal.dto.search.MyCourseSearch">
        SELECT class_date_ FROM course_schedule
        WHERE id_ IN (SELECT course_id_ FROM course_schedule_student_payment WHERE user_id_ = #{studentId} AND course_type_ = 'PRACTICE')
        <![CDATA[ AND class_date_  >= #{startDate} ]]>
        <![CDATA[ AND class_date_  <= #{endDate} ]]>
    </select>

    <select id="teacherList" resultType="com.yonge.cooleshow.biz.dal.vo.PracticeTeacherVo">
        SELECT
        t.user_id_ AS teacherId,
        u.username_ AS userName,
        u.real_name_ AS realName,
        u.avatar_ AS avatar,

        tt.star_grade_ AS starGrade,
        tt.exp_time_ AS expTime,
        t.graduate_school_ AS school,
        t.subject_ AS schoolSubject,

        (SELECT group_concat(p.subject_name_) FROM teacher_subject_price p WHERE find_in_set(t.user_id_,p.teacher_id_)) AS configSubject,
        sp.subjectId AS subjectId,
        sp.subjectName AS subjectName,
        sp.subjectPrice AS subjectPrice,
        sp.courseMinutes AS courseMinutes

        FROM teacher t
        LEFT JOIN sys_user u ON t.user_id_ = u.id_
        LEFT JOIN teacher_total tt ON t.user_id_=tt.user_id_
        LEFT JOIN (SELECT
        f.teacher_id_ AS teacherId,
        p.subject_id_ AS subjectId,
        p.subject_name_ AS subjectName,
        p.subject_price_ AS subjectPrice,
        p.course_minutes_ AS courseMinutes
        FROM teacher_free_time f
        LEFT JOIN teacher_subject_price p ON f.id_=p.teacher_free_time_id
        WHERE f.default_flag_=1
        AND p.subject_id_=#{param.subjectId}) sp ON t.user_id_=sp.teacherId

        WHERE t.user_id_ IN (SELECT teacher_id_ FROM teacher_free_time GROUP BY teacher_id_)
        <if test="param.subjectId !=null">
            AND sp.subjectId=#{param.subjectId}
        </if>
        <if test="param.search !=null and param.search !=''">
            AND u.username_ LIKE CONCAT('%', #{param.search}, '%')
        </if>
        <choose>
            <when test="param.sort !=null and param.sort !=''">
                ORDER BY ${param.sort}
            </when>
        </choose>
    </select>

    <select id="queryCourseTeacher" resultType="com.yonge.cooleshow.biz.dal.vo.CourseStudent"
            parameterType="com.yonge.cooleshow.biz.dal.dto.search.MyCourseSearch">
        SELECT
            s.id_ AS courseId,
            s.course_group_id_ AS courseGoupId,
            s.class_date_ AS classDate,
            s.start_time_ AS startTime,
            s.end_time_ AS endTime,
            s.type_ AS courseType,
            s.status_ AS `status`,
            u.id_ AS userId,
            u.username_ AS name,
            u.real_name_ AS realName,
            u.avatar_ AS cover,
            g.subject_id_ AS subjectId,
            b.name_ AS subjectName
        FROM course_schedule s
        LEFT JOIN sys_user u ON s.teacher_id_ = u.id_
        LEFT JOIN course_group g ON s.course_group_id_ = g.id_
        LEFT JOIN `subject` b ON g.subject_id_ = b.id_
        WHERE s.id_ IN
        (SELECT course_id_ FROM course_schedule_student_payment WHERE user_id_ = #{param.studentId} AND course_type_ = 'PRACTICE')
        AND s.class_date_ = #{param.classDate}
        UNION
        SELECT
            s.id_ AS courseId,
            s.course_group_id_ AS courseGoupId,
            s.class_date_ AS classDate,
            s.start_time_ AS startTime,
            s.end_time_ AS endTime,
            s.type_ AS courseType,
            s.status_ AS `status`,
            NULL AS userId,
            CONCAT(g.name_,'-第',s.class_num_,'课') AS name,
            NULL AS realName,
            g.background_pic_ AS cover,
            g.subject_id_ AS subjectId,
            sb.name_ AS subjectName
        FROM course_schedule s
        LEFT JOIN course_group g ON s.course_group_id_ = g.id_
        LEFT JOIN `subject` sb ON g.subject_id_=sb.id_
        WHERE s.id_ IN
        (SELECT course_id_ FROM course_schedule_student_payment WHERE user_id_ = #{param.studentId} AND course_type_ = 'LIVE')
        AND s.class_date_ = #{param.classDate}
        ORDER BY startTime
    </select>

    <select id="queryStudentLiveCourse" parameterType="map" resultType="com.yonge.cooleshow.biz.dal.vo.CourseStudent">
        SELECT distinct
        cs.id_ AS courseId,
        cs.course_group_id_ AS courseGoupId,
        cs.class_date_ AS classDate,
        cs.start_time_ AS startTime,
        cs.end_time_ AS endTime,
        cs.status_ AS `status`,
        cs.type_ AS courseType,
        su.username_ AS userId,
        CONCAT(g.name_,'-第',cs.class_num_,'课') AS name,
        IFNULL(g.pre_student_num_, 0) AS payCount,
        g.background_pic_ AS cover,
        g.subject_id_ AS subjectId,
        sb.name_ AS subjectName,
        su.avatar_ AS avatar,
        g.im_group_id_  as imGroupId
        FROM
        course_schedule_student_payment as a
        LEFT JOIN course_schedule cs on a.course_id_ = cs.id_
        LEFT JOIN course_group g ON cs.course_group_id_ = g.id_
        LEFT JOIN `subject` sb ON g.subject_id_=sb.id_
        LEFT JOIN sys_user su on g.teacher_id_ = su.id_
        LEFT JOIN user_order o on a.order_no_  = o.order_no_
        WHERE cs.type_=#{param.type}
        AND a.user_id_ = #{param.studentId}
        <![CDATA[ AND class_date_  >= #{param.startDate} ]]>
        <![CDATA[ AND class_date_  <= #{param.endDate} ]]>
        <if test="param.orderState != null">
            AND o.status_ = #{param.orderState}
        </if>
        <if test="param.subjectId != null">
            AND g.subject_id_ = #{param.subjectId}
        </if>
        <if test="param.courseState != null">
            and cs.status_ = #{param.courseState}
        </if>
    </select>

    <insert id="addCourseGroup" parameterType="com.yonge.cooleshow.biz.dal.dto.PracticeScheduleDto" useGeneratedKeys="true" keyProperty="groupId">
        Insert INTO course_group(teacher_id_,type_,name_,subject_id_,single_course_minutes_,course_num_,course_introduce_,
        course_price_,status_,created_by_,mix_student_num_,course_start_time_,pre_student_num_)
        VALUES (#{teacherId},#{type},#{courseGroupName},#{subjectId},#{singleCourseMinutes},#{courseNum},#{courseIntroduce},
        #{coursePrice},#{status},#{studentId},#{mixStudentNum},#{courseStartTime},1)
    </insert>

    <update id="updateLock" parameterType="java.util.List">
        UPDATE course_schedule SET lock_ = 0 WHERE id_ IN
        <foreach collection="list" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
    </update>
    <update id="courseAdjust" parameterType="com.yonge.cooleshow.biz.dal.vo.CourseAdjustVo">
        UPDATE course_schedule
        SET class_date_=#{classDate},start_time_=#{startTime},end_time_=#{endTime}
        WHERE id_ = #{courseId}
    </update>
    <select id="selectLive" resultType="com.yonge.cooleshow.biz.dal.vo.StudentHomePage$Live">
        SELECT
            u.id_ AS teacherId,
            u.username_ AS teacherName,
            u.real_name_ AS realName,
            u.avatar_ AS avatar,
            g.id_ AS courseGroupId,
            g.name_ AS courseGroupName,
            g.course_price_ AS courseGroupPrice,
            g.course_start_time_ AS courseStartTime,
            g.background_pic_ AS backgroundPic,
            g.course_num_ AS courseNum,
            g.pre_student_num_ AS buyCount,
            g.subject_id_ AS subjectId,
            s.name_ AS subjectName
        FROM course_group g
        LEFT JOIN sys_user u ON g.teacher_id_=u.id_
        LEFT JOIN subject s ON g.subject_id_=s.id_
        WHERE type_='LIVE' and g.status_ = 'APPLY' and #{appAuditVersion} = g.audit_version_
        ORDER BY courseStartTime DESC LIMIT 4
    </select>
    <select id="selectVideo" resultType="com.yonge.cooleshow.biz.dal.vo.StudentHomePage$Video">
        SELECT
            u.id_ AS teacherId,
            u.username_ AS teacherName,
            u.real_name_ AS realName,
            u.avatar_ AS avatar,
            g.id_ AS videoGroupId,
            g.lesson_name_ AS videoGroupName,
            g.lesson_price_ AS lessonPrice,
            g.create_time_ AS createTime,
            g.lesson_cover_url_ AS lessonCoverUrl,
            g.lesson_count_ AS lessonCount,
            g.lesson_subject_ AS subjectId,
            s.name_ AS subjectName,
            IFNULL(r.count_,0) AS buyCount
        FROM video_lesson_group g
        LEFT JOIN sys_user u ON g.teacher_id_=u.id_
        LEFT JOIN `subject` s ON g.lesson_subject_=s.id_
        LEFT JOIN (SELECT video_lesson_group_id_ ,COUNT(1) AS count_ FROM video_lesson_purchase_record WHERE order_status_='PAID' GROUP BY video_lesson_group_id_) r ON g.id_= r.video_lesson_group_id_
        WHERE g.audit_status_='PASS' and #{appAuditVersion} = g.audit_version_
        ORDER BY g.create_time_ DESC LIMIT 4
    </select>
    <select id="selectRecentCourses" resultType="com.yonge.cooleshow.biz.dal.vo.StudentHomePage$RecentCourses">
        SELECT
            u.id_ AS teacherId,
            u.username_ AS teacherName,
            u.real_name_ AS realName,
            u.avatar_ AS avatar,
            p.course_group_id_ AS courseGroupId,
            p.course_id_ AS courseId,
            g.name_ AS courseGroupName,
            p.course_type_ AS courseType,
            s.status_ AS `status`,
            s.start_time_ AS courseStartTime
        FROM course_schedule_student_payment p
        LEFT JOIN course_schedule s ON p.course_id_=s.id_
        LEFT JOIN sys_user u ON s.teacher_id_=u.id_
        LEFT JOIN course_group g ON p.course_group_id_=g.id_
        WHERE p.user_id_=#{studentId}
        AND s.status_ IN ('NOT_START','ING')
        ORDER BY ABS(NOW() - s.start_time_) ASC
        limit 1
    </select>
    <select id="selectRecentCoursesTeacher" resultType="com.yonge.cooleshow.biz.dal.vo.StudentHomePage$RecentCourses">
        SELECT
            u.id_ AS teacherId,
            u.username_ AS teacherName,
            u.real_name_ AS realName,
            u.avatar_ AS avatar,
            s.course_group_id_ AS courseGroupId,
            s.id_ AS courseId,
            g.name_ AS courseGroupName,
            s.type_ AS courseType,
            s.status_ AS `status`,
            s.start_time_ AS courseStartTime
        FROM course_schedule s
        LEFT JOIN sys_user u ON s.teacher_id_=u.id_
        LEFT JOIN course_group g ON s.course_group_id_=g.id_
        WHERE s.teacher_id_=#{teacherId}
        AND s.status_ = 'NOT_START'
        ORDER BY ABS(NOW() - s.start_time_) ASC
        limit 1
    </select>
    <select id="selectWeekNotStartCourseSchedule" resultType="java.lang.Integer">
        select count(1)
        from course_schedule cs
        where cs.teacher_id_ = #{userId} and cs.status_ = 'NOT_START'
        and YEARWEEK(date_format(cs.class_date_,'%Y-%m-%d'),7) = YEARWEEK(now(),7)
    </select>

    <select id="selectHomeworkNotDecorate" resultType="java.lang.Integer">
        select count(1)
        from course_schedule cs
        left join course_homework ch on cs.id_ = ch.course_schedule_id_
        where cs.teacher_id_ = #{userId} and cs.status_ = 'COMPLETE' and cs.type_ = 'PRACTICE'
        and YEARWEEK(date_format(cs.class_date_,'%Y-%m-%d'),7) = YEARWEEK(now(),7)
        and ch.id_ is null
    </select>

    <select id="selectNotRepliedCourseSchedule" resultType="java.lang.Integer">
        select count(1)
        from course_schedule cs
        left join course_schedule_replied csr on cs.id_ = csr.course_schedule_id_
        where cs.teacher_id_ = #{userId} and cs.status_ = 'COMPLETE' and cs.type_ = 'PRACTICE'
        and csr.teacher_replied_ is null
    </select>

    <select id="selectWeekStudentRepliedCourseSchedule" resultType="java.lang.Integer">
        select count(1)
        from course_schedule cs
        left join course_schedule_replied csr on cs.id_ = csr.course_schedule_id_
        where cs.teacher_id_ = #{userId} and cs.status_ = 'COMPLETE' and cs.type_ = 'PRACTICE'
        and csr.student_replied_ is not null
    </select>
    <select id="selectStartTime" resultType="java.lang.String" parameterType="java.lang.String">
        SELECT s.start_time_
        FROM course_schedule_student_payment p
        LEFT JOIN course_schedule s ON p.course_id_=s.id_
        WHERE p.order_no_=#{orderNo}
    </select>
    <select id="selectTeacher" resultType="com.yonge.cooleshow.auth.api.entity.SysUser"
            parameterType="java.lang.String">
        SELECT s.teacher_id_ AS id,u.phone_ AS phone
        FROM course_schedule s
        LEFT JOIN sys_user u ON s.teacher_id_=u.id_
        WHERE class_date_=#{tomorrow} AND lock_=0
        GROUP BY s.teacher_id_
    </select>
    <select id="selectTypeCount" resultType="com.yonge.cooleshow.biz.dal.vo.CountVo">
        SELECT type_ AS type, COUNT(1) AS count
        FROM course_schedule
        WHERE class_date_=#{tomorrow}
        AND teacher_id_=#{teacherId} AND lock_=0
        GROUP BY type_
    </select>


    <select id="selectTodayNotRepliedAndNotDecorateHomework"
            resultType="com.yonge.cooleshow.biz.dal.vo.TodayNotRepliedAndNotDecorateHomeworkVo">

        select sum(if(ch.id_ is null,1,0)) as decorateNum,
            sum(if(csr.teacher_replied_ is null,1,0)) as repliedNum,
            su.id_ as teacherId,
            su.phone_ as phone
        from course_schedule cs
        left join course_schedule_replied csr on cs.id_ = csr.course_schedule_id_
        left join course_homework ch on cs.id_ = ch.course_schedule_id_
        left join sys_user su on cs.teacher_id_ = su.id_
        where cs.status_ = 'COMPLETE' and date_format(cs.class_date_,'%Y-%m-%d') = date_format(now(),'%Y-%m-%d')
        and cs.type_ = 'PRACTICE'
        group by  su.id_,su.phone_
    </select>

    <select id="countAllReplie" resultType="com.yonge.cooleshow.biz.dal.vo.RepliedCountVo"
            parameterType="java.lang.String">
        SELECT
            p.user_id_ AS userId,
            u.phone_ AS phone,
            COUNT(1) AS count
        FROM course_schedule_student_payment p
        LEFT JOIN sys_user u ON p.user_id_=u.id_
        WHERE p.course_id_ IN (SELECT id_ FROM course_schedule  WHERE class_date_=#{today} AND lock_=0 AND type_='PRACTICE')
        GROUP BY p.user_id_;
    </select>
    <select id="countReplies" resultType="java.lang.Integer" parameterType="java.lang.Integer">
        SELECT COUNT(1)
        FROM course_schedule_replied
        WHERE student_id_=#{studentId}
    </select>
</mapper>