更换t_paper_group为t_paper_class

sapi/src/main/resources/mapper/analyze/SchoolSummaryMapper.xml

         count(distinct case when pg.starttime<=#{sparams.timestamp} then ps.psid else null end)pstunum,
         count(distinct case when ps.psstate!=0 then ps.psid else null end)pcommitnum,
         count(distinct case when ps.psstate!=0 and ps.pschecked=1 then ps.psid else null end)pchecknum
-        from t_paper p left join t_paper_group pg on p.paperid=pg.paperid
+        from t_paper p left join t_paper_class pg on p.paperid=pg.paperid
         left join t_paper_student ps on ps.paperid=pg.paperid and ps.classid=pg.classid
         left join t_class c on pg.classid=c.classid
         where p.paperstate=22 and p.schoolid=#{sparams.schoolid}

sapi/src/main/resources/mapper/analyze/SchoolTaskMapper.xml

         count(distinct case when ps1.psstate!=0 then ps1.psid else null end) commitnum,
         count(distinct case when ps1.psstate!=0 and ps1.pschecked=1 then ps1.psid else null end) checknum
         FROM t_paper p LEFT JOIN t_subject s ON p.subjectid=s.subjectid
-        left join t_paper_group pg on p.paperid=pg.paperid
+        left join t_paper_class pg on p.paperid=pg.paperid
         LEFT JOIN t_paper_student ps1 ON p.paperid=ps1.paperid and ps1.classid=pg.classid
         LEFT JOIN t_class c ON pg.classid=c.classid
         LEFT JOIN T_USER U ON p.createid=u.userid
         count(distinct case when pg.starttime<=#{sparams.timestamp} then ps1.psid else null end)stunum,
         count(distinct case when ps1.psstate!=0 then ps1.psid else null end) commitnum,
         count(distinct case when ps1.psstate!=0 and ps1.pschecked=1 then ps1.psid else null end) checknum
-        from t_paper p left join t_paper_group pg on p.paperid=pg.paperid
+        from t_paper p left join t_paper_class pg on p.paperid=pg.paperid
         left join t_paper_student ps1 on ps1.paperid=pg.paperid and ps1.classid=pg.classid
         left join t_class c on c.classid=pg.classid
         where p.schoolid=#{sparams.schoolid} and p.paperstate=22 and c.gradeid=#{sparams.gradeid} and c.year=#{sparams.year}

sapi/src/main/resources/mapper/classreport/ClassReportMapper.xml

         ,sum(ps.userscore)uscore
         ,ifnull(truncate(sum(ps.userscore)*100/sum(case when pg.starttime<=#{type.createtime} then ps.paperscore else 0 end),2),0)zqrate
         ,from_unixtime(p.createtime,'%Y-%m-%d')begindate,count(distinct p.paperid)fbnum
-        from t_paper p left join t_paper_group pg on p.paperid=pg.paperid
+        from t_paper p left join t_paper_class pg on p.paperid=pg.paperid
         left join t_paper_student ps on ps.paperid=p.paperid and ps.classid=pg.classid
         left join t_class c on pg.classid=c.classid
         left join t_school s on p.schoolid=s.schoolid

sapi/src/main/resources/mapper/itemtool/StudentTodoMapper.xml

             <if test="todo.todotype=='paper'">
                 select 'paper' todotype,count(distinct p.paperid)num,#{todo.subjectid} subjectid
                 from t_paper_student s join t_paper p on p.paperid = s.paperid
-                left join t_paper_group pg on s.paperid = pg.paperid and s.classid=pg.classid
+                left join t_paper_class pg on s.paperid = pg.paperid and s.classid=pg.classid
                 where pg.starttime&lt;=#{timestamp} and s.studentid=#{todo.studentid} and s.psstate=0
                 <if test="todo.subjectid!=null and todo.subjectid!='0'.toString() and todo.subjectid!=''">
                     and p.subjectid=#{todo.subjectid}
             <if test="todo.todotype=='checkpaper'">
                 select 'checkpaper' todotype,count(distinct p.paperid)num,#{todo.subjectid} subjectid
                 from t_paper_student ps join t_paper p on p.paperid = ps.paperid
-                left join t_paper_group pg on ps.paperid = pg.paperid and ps.classid=pg.classid
+                left join t_paper_class pg on ps.paperid = pg.paperid and ps.classid=pg.classid
                 where ps.checkid=#{todo.studentid} and ps.psstate!=0 and ps.pschecked!=1
                 <if test="todo.showtime!=null and todo.showtime!=0">
                     and pg.starttime>=#{todo.showtime}

sapi/src/main/resources/mapper/region/RPaperAnalyzeMapper.xml

 
     <!--作业数量统计——作业数量-->
     <select id="getRegionPaperNumPaper" resultType="java.lang.Integer">
-      select count(DISTINCT pg.paperid) from t_paper_group pg left join t_paper p on pg.paperid=p.paperid
+      select count(DISTINCT pg.paperid) from t_paper_class pg left join t_paper p on pg.paperid=p.paperid
         LEFT JOIN t_school s on p.schoolid=s.schoolid
         left join t_class c on c.classid=pg.classid
         where s.schoollevel=#{param.level}
         count(case when ps.psstate!=0 then ps.psid else null end) commitnum,
         count(case when ps.psstate=1 then ps.psid else null end) commitasnum,
         count(case when ps.psstate!=0 and ps.pschecked=1 then ps.psid else null end) checknum
-        from t_paper p left join t_paper_group pg on p.paperid=pg.paperid
+        from t_paper p left join t_paper_class pg on p.paperid=pg.paperid
         left join t_paper_student ps on ps.paperid=p.paperid and ps.classid=pg.classid
         left join t_school s on p.schoolid=s.schoolid
         left join t_class c on c.classid=pg.classid

sapi/src/main/resources/mapper/region/RegionAnalyzeMapper.xml

         count(distinct ps.psid)stunum,
         count(distinct case when ps.psstate!=0 then ps.psid else null end)commitnum,
         count(distinct case when ps.psstate!=0 and ps.pschecked=1 then ps.psid else null end)checknum
-        from t_paper_group pg
+        from t_paper_class pg
         right join t_school s on pg.schoolid=s.schoolid and pg.pgstate=22
         and pg.starttime between #{param.begintime} and #{param.endtime}
         left join t_paper_student ps on ps.paperid=pg.paperid
     <!--布置作业统计_布置作业次数-->
     <select id="listPapernumMonth" resultType="com.xhkjedu.sapi.vo.region.WorkVo">
         select s.schoolid,s.schoolname,s.shortname,count(distinct pg.paperid) num
-        from t_paper_group pg left join t_class c on c.classid=pg.classid
+        from t_paper_class pg left join t_class c on c.classid=pg.classid
         right join t_school s on pg.schoolid=s.schoolid and pg.pgstate=22
         and pg.createtime between #{param.begintime} and #{param.endtime}
         where s.schoolstate=1

sapi/src/main/resources/mapper/region/SAnalyzeMapper.xml

     <select id="listPaperCommitMonth" resultType="com.xhkjedu.sapi.vo.region.SWorkVo">
         select c.gradeid,s.subjectname,count(distinct pg.paperid)num,s.subjectorder
         ,truncate(count(distinct case when ps.psstate!=0 then ps.psid else null end)*100/count(distinct ps.psid),2)numrate
-        from t_paper_group pg right join t_paper p on pg.paperid=p.paperid
+        from t_paper_class pg right join t_paper p on pg.paperid=p.paperid
         left join t_subject s on p.subjectid=s.subjectid
         left join t_class c on pg.classid=c.classid
         left join t_paper_student ps on ps.paperid=pg.paperid

sstudy/src/main/java/com/xhkjedu/sstudy/controller/paper/PaperAnalyzeController.java

 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
 import com.xhkjedu.sstudy.model.paper.TPaper;
-import com.xhkjedu.sstudy.model.paperstudent.TPaperGroup;
+import com.xhkjedu.sstudy.model.paperstudent.TPaperClass;
 import com.xhkjedu.sstudy.model.paperstudent.TPaperStudent;
 import com.xhkjedu.sstudy.model.paperstudent.TPaperStudentQuestion;
 import com.xhkjedu.sstudy.service.paper.PaperAnalyzeService;
     }
 
     @PostMapping("/paper_class_student")
-    public ResultVo paperClassStudent(@RequestBody TPaperGroup paper){
+    public ResultVo paperClassStudent(@RequestBody TPaperClass paper){
         Integer paperid = paper.getPaperid();
         Integer classid = paper.getClassid();
         N_Utils.validation(new Object[]{paperid,"作业id",1,classid,"班级id",1});

sstudy/src/main/java/com/xhkjedu/sstudy/controller/paper/PaperReportController.java

 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
 import com.xhkjedu.sstudy.model.paper.TPaper;
-import com.xhkjedu.sstudy.model.paperstudent.TPaperGroup;
+import com.xhkjedu.sstudy.model.paperstudent.TPaperClass;
 import com.xhkjedu.sstudy.service.paperreport.PaperReportService;
 import com.xhkjedu.utils.N_Utils;
 import com.xhkjedu.utils.PageUtil;
      * @return com.xhkjedu.vo.ResultVo
      **/
     @PostMapping("gpr")
-    public ResultVo generatePaperReport(@RequestBody TPaperGroup paper) {
+    public ResultVo generatePaperReport(@RequestBody TPaperClass paper) {
         Integer paperid = paper.getPaperid();
         N_Utils.validation(new Object[]{paperid, "作业id", 1});
         paperReportService.generatePaperReport(paperid);
      * @return com.xhkjedu.vo.ResultVo
      **/
     @PostMapping("po")
-    public ResultVo getPaperOverview(@RequestBody TPaperGroup paper) {
+    public ResultVo getPaperOverview(@RequestBody TPaperClass paper) {
         Integer paperid = paper.getPaperid();
         Integer classid = paper.getClassid();
         N_Utils.validation(new Object[]{paperid, "作业id", 1, classid, "班级id", 1});
      * @return com.xhkjedu.vo.ResultVo
      **/
     @PostMapping("pd")
-    public ResultVo getPaperDetail(@RequestBody TPaperGroup paper) {
+    public ResultVo getPaperDetail(@RequestBody TPaperClass paper) {
         Integer paperid = paper.getPaperid();
         Integer classid = paper.getClassid();
         N_Utils.validation(new Object[]{paperid, "作业id", 1, classid, "班级id", 1});
      * @return com.xhkjedu.vo.ResultVo
      **/
     @PostMapping("list_wtjstu")
-    public ResultVo listWtjStu(@RequestBody TPaperGroup paper) {
+    public ResultVo listWtjStu(@RequestBody TPaperClass paper) {
         Integer paperid = paper.getPaperid();
         Integer classid = paper.getClassid();
         N_Utils.validation(new Object[]{paperid, "作业id", 1, classid, "班级id", 1});
      * @return com.xhkjedu.vo.ResultVo
      **/
     @PostMapping("p")
-    public ResultVo getPaper(@RequestBody TPaperGroup paper) {
+    public ResultVo getPaper(@RequestBody TPaperClass paper) {
         Integer paperid = paper.getPaperid();
         N_Utils.validation(new Object[]{paperid, "作业id", 1});
         Map map = paperReportService.getPaper(paperid);

sstudy/src/main/java/com/xhkjedu/sstudy/controller/paper/PaperTeaAppController.java

 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
 import com.xhkjedu.sstudy.model.paper.TPaper;
-import com.xhkjedu.sstudy.model.paperstudent.TPaperGroup;
+import com.xhkjedu.sstudy.model.paperstudent.TPaperClass;
 import com.xhkjedu.sstudy.model.question.TQuestionClass;
 import com.xhkjedu.sstudy.service.paper.PaperTeaAppService;
 import com.xhkjedu.sstudy.vo.paper.PQuestionVo;
     }
 
     @PostMapping("/paper_detail")
-    public ResultVo paperDetail(@RequestBody TPaperGroup pg) {
+    public ResultVo paperDetail(@RequestBody TPaperClass pg) {
         Integer paperid = pg.getPaperid();
         Integer checkid = pg.getCheckid();
         Integer schoolid = pg.getSchoolid();

sstudy/src/main/java/com/xhkjedu/sstudy/controller/paperstudent/PaperGroupController.java → sstudy/src/main/java/com/xhkjedu/sstudy/controller/paperstudent/PaperClassController.java

 package com.xhkjedu.sstudy.controller.paperstudent;
 
-import com.xhkjedu.sstudy.model.paperstudent.TPaperGroup;
-import com.xhkjedu.sstudy.service.paperstudent.PaperGroupService;
+import com.xhkjedu.sstudy.model.paperstudent.TPaperClass;
+import com.xhkjedu.sstudy.service.paperstudent.PaperClassService;
 import com.xhkjedu.sstudy.vo.paperstudent.PaperGroupParam;
 import com.xhkjedu.sstudy.vo.paperstudent.PaperGroupVo;
 import com.xhkjedu.utils.N_Utils;
  **/
 @RestController
 @RequestMapping("/pg")
-public class PaperGroupController {
+public class PaperClassController {
     @Autowired
-    private PaperGroupService paperGroupService;
+    private PaperClassService paperClassService;
 
     /**
      *功能描述  发布作业
     @PostMapping("/save")
     public ResultVo save(@RequestBody PaperGroupParam paperGroupParam){
         N_Utils.validation(new Object[]{paperGroupParam.getPaperid(),"作业id",1,paperGroupParam.getShowtype(),"公布答案",1,paperGroupParam.getClasslst(),"班级",1});
-        return paperGroupService.savePaperGroup(paperGroupParam);
+        return paperClassService.savePaperGroup(paperGroupParam);
     }
 
     //发布作业（兼容靶向作业）
     @PostMapping("/save2")
     public ResultVo save2(@RequestBody PaperGroupParam paperGroupParam){
         N_Utils.validation(new Object[]{paperGroupParam.getPaperid(),"作业id",1,paperGroupParam.getShowtype(),"公布答案",1,paperGroupParam.getSelclass(),"班级",1});
-        return paperGroupService.savePaperClassStu(paperGroupParam);
+        return paperClassService.savePaperClassStu(paperGroupParam);
     }
 
 
     @PostMapping("/paper_student_list")
-    public ResultVo listPaperStudent(@RequestBody TPaperGroup group) {
+    public ResultVo listPaperStudent(@RequestBody TPaperClass group) {
         Integer paperid = group.getPaperid();
         N_Utils.validation(new Object[]{paperid, "作业id", 1});
-        List<PaperGroupVo> list = paperGroupService.listPaperStudent(paperid);
+        List<PaperGroupVo> list = paperClassService.listPaperStudent(paperid);
         return new ResultVo(0, "获取参与作业学生列表成功", list);
     }
 
     //作业发布对象
     @PostMapping("/list_object")
-    public ResultVo listObject(@RequestBody TPaperGroup group) {
+    public ResultVo listObject(@RequestBody TPaperClass group) {
         Integer paperid = group.getPaperid();
         Integer createid = group.getCreateid();
         Integer papertype = group.getPapertype();
         Integer schoolid = group.getSchoolid();
         N_Utils.validation(new Object[]{paperid, "试卷id", 1, createid, "发布人id", 1
                 , papertype, "作业类型", 1, schoolid, "学校id", 1});
-        Map list = paperGroupService.listObject(paperid, createid, papertype, schoolid);
+        Map list = paperClassService.listObject(paperid, createid, papertype, schoolid);
         return new ResultVo(0, "获取发布对象成功", list);
     }
 
      * @return com.xhkjedu.vo.ResultVo
      **/
     @PostMapping("/list_gs")
-    public ResultVo listGroupStudent(@RequestBody TPaperGroup group) {
+    public ResultVo listGroupStudent(@RequestBody TPaperClass group) {
         Integer paperid = group.getPaperid();
         Integer papertype = group.getPapertype();
         Integer groupid = group.getGroupid();
         N_Utils.validation(new Object[]{paperid, "试卷id", 1, papertype, "作业类型", 1
                 , groupid, "分组id", 1});
-        List<Map> list = paperGroupService.listGroupStudent(paperid, papertype, groupid);
+        List<Map> list = paperClassService.listGroupStudent(paperid, papertype, groupid);
         return new ResultVo(0, "获取发布对象成功", list);
     }
 }

sstudy/src/main/java/com/xhkjedu/sstudy/mapper/paper/PaperAnalyzeMapper.java

 import com.xhkjedu.base.TkMapper;
 import com.xhkjedu.sstudy.model.paper.TPaper;
 import com.xhkjedu.sstudy.model.paper.TPaperAnalyze;
-import com.xhkjedu.sstudy.model.paperstudent.TPaperGroup;
+import com.xhkjedu.sstudy.model.paperstudent.TPaperClass;
 import com.xhkjedu.sstudy.vo.gradeclass.CStudentVo;
 import com.xhkjedu.sstudy.vo.paper.AStudentPaperVo;
 import com.xhkjedu.sstudy.vo.paper.AnalyzeQuestionVo;
      * @Date 2020/9/24 10:05
      * @return java.util.List<com.xhkjedu.vo.gradeclass.CStudentVo>
      **/
-    List<CStudentVo> listPaperClassStudent(@Param("paper") TPaperGroup paper);
+    List<CStudentVo> listPaperClassStudent(@Param("paper") TPaperClass paper);
 
     //作业统计：年级下教师列表
     List<PaperGAnalyzeVo> listUser(@Param("paper") AnalyzeSearchVo paper);

sstudy/src/main/java/com/xhkjedu/sstudy/mapper/paperstudent/PaperGroupMapper.java → sstudy/src/main/java/com/xhkjedu/sstudy/mapper/paperstudent/PaperClassMapper.java

 package com.xhkjedu.sstudy.mapper.paperstudent;
 
 import com.xhkjedu.base.TkMapper;
-import com.xhkjedu.sstudy.model.paperstudent.TPaperGroup;
+import com.xhkjedu.sstudy.model.paperstudent.TPaperClass;
 import com.xhkjedu.sstudy.vo.paperstudent.PaperGroupVo;
 import com.xhkjedu.sstudy.vo.question.QuestionVo;
 import org.apache.ibatis.annotations.Param;
  * Date 2020/6/9 11:00
  **/
 @Repository
-public interface PaperGroupMapper extends TkMapper<TPaperGroup> {
+public interface PaperClassMapper extends TkMapper<TPaperClass> {
 
     /**
      * 根据作业、分组id获取作业班级详情
      * @Param [paperid, groupid]
      * @Author ywx
      * @Date 2020/6/11 10:09
-     * @return com.xhkjedu.model.paperstudent.TPaperGroup
+     * @return com.xhkjedu.model.paperstudent.TPaperClass
      **/
-    TPaperGroup selectByPaperAndClassId(Integer paperid, Integer classid);
+    TPaperClass selectByPaperAndClassId(Integer paperid, Integer classid);
 
     /**
      * 获取参与作业学生列表
      * @Author ywx
      * @Date 2020/10/14 11:04
      **/
-    Integer getWpyNum(@Param("pg") TPaperGroup pg);
+    Integer getWpyNum(@Param("pg") TPaperClass pg);
 
     //获取班级作业是否结束批阅
     Integer getPaperClassChecked(@Param("paperid") Long paperid, @Param("classid") Integer classid);

sstudy/src/main/java/com/xhkjedu/sstudy/model/paperstudent/TPaperGroup.java → sstudy/src/main/java/com/xhkjedu/sstudy/model/paperstudent/TPaperClass.java

 import java.util.ArrayList;
 import java.util.List;
 
-@Table(name = "t_paper_group")
+@Table(name = "t_paper_class")
 @Data
-public class TPaperGroup extends BaseBean {
+public class TPaperClass extends BaseBean {
     //作业班级表
     @Id
-    private Integer pgid;
+    private Integer pcid;
 
     //作业id
     private Integer paperid;
     //批改人
     private Integer checkid;
 
+    //是否分层0不分层1分层
+    private Integer hasfc;
+
     //创建人id
     private Integer createid;
 

sstudy/src/main/java/com/xhkjedu/sstudy/service/paper/PaperAnalyzeService.java

 import com.xhkjedu.sstudy.model.paper.TPaper;
 import com.xhkjedu.sstudy.model.paper.TPaperAnalyze;
 import com.xhkjedu.sstudy.model.paper.TPaperFile;
-import com.xhkjedu.sstudy.model.paperstudent.TPaperGroup;
+import com.xhkjedu.sstudy.model.paperstudent.TPaperClass;
 import com.xhkjedu.sstudy.utils.StudyUtil;
 import com.xhkjedu.sstudy.vo.gradeclass.CStudentVo;
 import com.xhkjedu.sstudy.vo.paper.*;
      * @Date 2020/9/24 10:10
      * @return java.util.Map
      **/
-    public Map listPaperClassStudent(TPaperGroup paper) {
+    public Map listPaperClassStudent(TPaperClass paper) {
         Map map = new HashMap();
         List<CStudentVo> list = paperAnalyzeMapper.listPaperClassStudent(paper);
         List<String> ytjstus = new ArrayList<>();

sstudy/src/main/java/com/xhkjedu/sstudy/service/paperreport/PaperReportService.java

 import com.xhkjedu.sstudy.mapper.paper.PaperMapper;
 import com.xhkjedu.sstudy.mapper.paper.PaperQtypeQuestionMapper;
 import com.xhkjedu.sstudy.mapper.paperreport.*;
-import com.xhkjedu.sstudy.mapper.paperstudent.PaperGroupMapper;
+import com.xhkjedu.sstudy.mapper.paperstudent.PaperClassMapper;
 import com.xhkjedu.sstudy.mapper.paperstudent.PaperStudentMapper;
 import com.xhkjedu.sstudy.mapper.paperstudent.PaperStudentQuestionMapper;
 import com.xhkjedu.sstudy.mapper.paperstudent.PaperStudentScantronMapper;
     @Resource
     private QuestionClassMapper questionClassMapper;
     @Resource
-    private PaperGroupMapper paperGroupMapper;
+    private PaperClassMapper paperClassMapper;
     @Resource
     private PaperReportMapper paperReportMapper;
 
             if (N_Utils.isListNotEmpty(list)) {
                 questionClassMapper.insertList(list);
             }
-            paperGroupMapper.updateChecked(pid, classid);
+            paperClassMapper.updateChecked(pid, classid);
         }
     }
 

sstudy/src/main/java/com/xhkjedu/sstudy/service/paperstudent/PaperGroupService.java → sstudy/src/main/java/com/xhkjedu/sstudy/service/paperstudent/PaperClassService.java

 import com.xhkjedu.sstudy.mapper.paper.PaperMapper;
 import com.xhkjedu.sstudy.mapper.paper.PaperQtypeQuestionMapper;
 import com.xhkjedu.sstudy.mapper.paper.PaperScantronMapper;
-import com.xhkjedu.sstudy.mapper.paperstudent.PaperGroupMapper;
+import com.xhkjedu.sstudy.mapper.paperstudent.PaperClassMapper;
 import com.xhkjedu.sstudy.mapper.paperstudent.PaperStudentMapper;
 import com.xhkjedu.sstudy.mapper.paperstudent.PaperStudentQuestionMapper;
 import com.xhkjedu.sstudy.model.paper.TPaper;
 import com.xhkjedu.sstudy.model.paper.TPaperQtypeQuestion;
-import com.xhkjedu.sstudy.model.paperstudent.TPaperGroup;
+import com.xhkjedu.sstudy.model.paperstudent.TPaperClass;
 import com.xhkjedu.sstudy.model.paperstudent.TPaperStudent;
 import com.xhkjedu.sstudy.model.paperstudent.TPaperStudentQuestion;
 import com.xhkjedu.sstudy.utils.ArithUtil;
  **/
 @Slf4j
 @Service
-public class PaperGroupService {
+public class PaperClassService {
     @Autowired
-    private PaperGroupMapper paperGroupMapper;
+    private PaperClassMapper paperClassMapper;
     @Autowired
     private ClassMapper classMapper;
     @Autowired
             TPaper paper = paperMapper.selectByPrimaryKey(paperGroupParam.getPaperid());
             if (paper.getPaperstate() == 22) return new ResultVo(0,"保存成功");
             //班级
-            List<TPaperGroup> classlst = paperGroupParam.getClasslst().stream().distinct().collect(Collectors.toList());
+            List<TPaperClass> classlst = paperGroupParam.getClasslst().stream().distinct().collect(Collectors.toList());
             List<Map> jtrclist = paperGroupParam.getJtrclist();
 
             if (N_Utils.isListEmpty(classlst) && N_Utils.isListEmpty(jtrclist)) {
         return resultVo;
     }
 
-    private ResultVo savePaperStudent(PaperGroupParam paperGroupParam, List<TPaperGroup> classlst, TPaper paper) {
-        List<TPaperGroup> savegroup = new ArrayList<>();//班级分组
+    private ResultVo savePaperStudent(PaperGroupParam paperGroupParam, List<TPaperClass> classlst, TPaper paper) {
+        List<TPaperClass> savegroup = new ArrayList<>();//班级分组
         List<TPaperStudent> saveps = new ArrayList<>();//班级分组学生
 
         Integer schoolid = paperGroupParam.getSchoolid();
         Integer createid = paperGroupParam.getCreateid();
         Integer papernum = paper.getPapernum();
         Double paperscore = paper.getPaperscore();
-        for (TPaperGroup pg : classlst) {
+        for (TPaperClass pg : classlst) {
             List<Integer> groups = pg.getGroups();
             Integer classid = pg.getClassid();
             //处理作业分组数据
 
         //批量保存作业班级，作业班级学生信息
         try {
-            paperGroupMapper.insertList(savegroup);
+            paperClassMapper.insertList(savegroup);
         } catch (Exception e) {
             if (e instanceof DuplicateKeyException) {
                 return new ResultVo(0, "保存成功");
     }
 
     //处理作业分组数据
-    private void setPaperGroup(List<TPaperGroup> savegroup, List<TPaperStudent> saveps
+    private void setPaperGroup(List<TPaperClass> savegroup, List<TPaperStudent> saveps
             , Integer schoolid, Integer paperid, Integer starttime, Integer stoptime
             , Integer showtype, Integer createid, Integer papernum, Double paperscore
             , Integer classid, List<Integer> groups) {
         if (N_Utils.isListNotEmpty(groups)) {
-            TPaperGroup pg = new TPaperGroup();
+            TPaperClass pg = new TPaperClass();
             pg.setClassid(classid);
             pg.setPaperid(paperid);
             pg.setPgstate(22);//布置作业
      * @Date 2020/7/24 14:52
      **/
     public List<PaperGroupVo> listPaperStudent(Integer paperid) {
-        return paperGroupMapper.listPaperStudent(paperid);
+        return paperClassMapper.listPaperStudent(paperid);
     }
 
     /**
      **/
     public Map listObject(Integer paperid, Integer createid, Integer papertype, Integer schoolid) {
         Map paper = new HashMap();
-        List<Map> groups = paperGroupMapper.listGroupByTeacherId(createid, schoolid);//教师权限分组
+        List<Map> groups = paperClassMapper.listGroupByTeacherId(createid, schoolid);//教师权限分组
         //20230217过滤无学生分组，出现groupnum大于0，但是实际关联表没有学生
         groups = groups.stream().filter(m -> m.get("studentid") != null).collect(Collectors.toList());
 
                 , LinkedHashMap::new, Collectors.toList()));
         List<Integer> studentids = groups.stream().map(m -> (Integer) m.get("studentid")).distinct().collect(Collectors.toList());
 
-        List<Map> users = paperGroupMapper.listUserByIds(studentids);
+        List<Map> users = paperClassMapper.listUserByIds(studentids);
         Map<Integer, Map> userMap = users.stream().collect(Collectors.toMap(m -> (Integer) m.get("userid"), m -> m));
         if (papertype == 3) {//靶向作业
-            List<QuestionVo> questions = paperGroupMapper.listPaperQuestions(paperid);
+            List<QuestionVo> questions = paperClassMapper.listPaperQuestions(paperid);
             for (QuestionVo question : questions) {
                 String qstemtxt = question.getQstemtxt();
                 if(N_Utils.isNotEmpty(qstemtxt)){
             }
             paper.put("questions", questions);
             List<String> questionids = questions.stream().map(QuestionVo::getQuestionid).collect(Collectors.toList());
-            List<Map> stuQuestions = paperGroupMapper.listStuQuestion(questionids, studentids);
+            List<Map> stuQuestions = paperClassMapper.listStuQuestion(questionids, studentids);
             for (Integer studentid : studentids) {
                 List<String> stuQuestionIds = new ArrayList<>();//学生未收到或未得满分的试题ids
                 Double paperscore = 0.0;//试卷总分
             , Integer papernum, Double paperscore, Integer classid, List<PaperStudentParam> students) {
         List<TPaperStudentQuestion> savestuque=new ArrayList<>();
         if (N_Utils.isListNotEmpty(students)) {
-            TPaperGroup pg = new TPaperGroup();
+            TPaperClass pg = new TPaperClass();
             pg.setPaperid(paperid);
             pg.setClassid(classid);
             pg.setPgstate(22);
             pg.setSchoolid(schoolid);
             pg.setCreatetime(timestamp);
             pg.setChecked(0);
-            paperGroupMapper.insertSelective(pg);
+            paperClassMapper.insertSelective(pg);
 
             //根据studentid集合去重
             List<PaperStudentParam> students2 = students.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(PaperStudentParam::getStudentid))), ArrayList::new));
 
     //伙伴学校作业发布对象
     public List<Map> listGroupStudent(Integer paperid, Integer papertype, Integer groupid) {
-        List<Map> students = paperGroupMapper.listGroupStudent(groupid);//教师权限集团校分组
+        List<Map> students = paperClassMapper.listGroupStudent(groupid);//教师权限集团校分组
         List<Integer> studentids = students.stream().map(m -> (Integer) m.get("studentid")).distinct().collect(Collectors.toList());
         if (papertype == 3) {//靶向作业
-            List<QuestionVo> questions = paperGroupMapper.listPaperPQuestions(paperid);//获取作业母题列表
+            List<QuestionVo> questions = paperClassMapper.listPaperPQuestions(paperid);//获取作业母题列表
             List<String> questionids = questions.stream().map(QuestionVo::getQuestionid).collect(Collectors.toList());
-            List<Map> stuQuestions = paperGroupMapper.listStuQuestion(questionids, studentids);
+            List<Map> stuQuestions = paperClassMapper.listStuQuestion(questionids, studentids);
             for (Map student : students) {
                 Object studentid = student.get("studentid");
                 List<String> stuQuestionIds = new ArrayList<>();//学生未收到或未得满分的试题ids

sstudy/src/main/java/com/xhkjedu/sstudy/service/paperstudent/PaperStudentService.java

 import com.xhkjedu.sstudy.mapper.paper.PaperAnalyzeMapper;
 import com.xhkjedu.sstudy.mapper.paper.PaperMapper;
 import com.xhkjedu.sstudy.mapper.paper.PaperScantronMapper;
-import com.xhkjedu.sstudy.mapper.paperstudent.PaperGroupMapper;
+import com.xhkjedu.sstudy.mapper.paperstudent.PaperClassMapper;
 import com.xhkjedu.sstudy.mapper.paperstudent.PaperStudentMapper;
 import com.xhkjedu.sstudy.mapper.paperstudent.PaperStudentQuestionMapper;
 import com.xhkjedu.sstudy.mapper.paperstudent.PaperStudentScantronMapper;
 import com.xhkjedu.sstudy.mapper.question.QuestionMapper;
 import com.xhkjedu.sstudy.model.paper.TPaper;
 import com.xhkjedu.sstudy.model.paper.TPaperScantron;
-import com.xhkjedu.sstudy.model.paperstudent.TPaperGroup;
+import com.xhkjedu.sstudy.model.paperstudent.TPaperClass;
 import com.xhkjedu.sstudy.model.paperstudent.TPaperStudent;
 import com.xhkjedu.sstudy.model.paperstudent.TPaperStudentQuestion;
 import com.xhkjedu.sstudy.model.paperstudent.TPaperStudentScantron;
     @Resource
     private QuestionClassService questionClassService;
     @Resource
-    private PaperGroupMapper paperGroupMapper;
+    private PaperClassMapper paperClassMapper;
 
     @Autowired
     private PaperStudentScantronService paperStudentScantronService;
             TPaperStudent paperStudentBean = new TPaperStudent();
             paperStudentBean.setPsid(psid);
             int nowTime = N_Utils.getSecondTimestamp();
-            TPaperGroup pg = paperGroupMapper.selectByPaperAndClassId(paperid, classid);
+            TPaperClass pg = paperClassMapper.selectByPaperAndClassId(paperid, classid);
             if (pg.getStoptime() < nowTime) paperStudentBean.setPsstate(2);
             else paperStudentBean.setPsstate(1);
 
      * @return java.lang.Integer
      **/
     @Transactional(rollbackFor = Exception.class)
-    public Integer updatePaper(Integer psid, TPaperStudent paperStudentBean, TPaperGroup pg) throws Exception {
+    public Integer updatePaper(Integer psid, TPaperStudent paperStudentBean, TPaperClass pg) throws Exception {
         Integer result = null;
         try {
             //把学生未做的题设置分值为0，状态为已批改
             TPaperStudent paperStudentBean = new TPaperStudent();
             paperStudentBean.setPsid(psid);
             int nowTime = N_Utils.getSecondTimestamp();
-            TPaperGroup pg = paperGroupMapper.selectByPaperAndClassId(paperid, classid);
+            TPaperClass pg = paperClassMapper.selectByPaperAndClassId(paperid, classid);
             if (pg.getStoptime() < nowTime) paperStudentBean.setPsstate(2);
             else paperStudentBean.setPsstate(1);
             paperStudentBean.setStoptime(nowTime);
      * @return java.lang.Integer
      **/
     @Transactional(rollbackFor = Exception.class)
-    public Integer updateSPaper(Integer psid, TPaperStudent paperStudentBean, TPaperGroup pg) throws Exception {
+    public Integer updateSPaper(Integer psid, TPaperStudent paperStudentBean, TPaperClass pg) throws Exception {
         Integer result = null;
         try {
             //把学生未做的题设置分值为0，状态为已批改
      * @return java.lang.Integer
      **/
     public Integer getCheckedByPsId(Integer psid){
-        return paperGroupMapper.getCheckedByPsId(psid);
+        return paperClassMapper.getCheckedByPsId(psid);
     }
 
     //学生作业退回

sstudy/src/main/java/com/xhkjedu/sstudy/service/paperstudent/PaperStudentWebService.java

 import com.xhkjedu.sstudy.mapper.paper.PaperMapper;
 import com.xhkjedu.sstudy.mapper.paper.PaperQtypeQuestionMapper;
 import com.xhkjedu.sstudy.mapper.paper.PaperScantronMapper;
-import com.xhkjedu.sstudy.mapper.paperstudent.PaperGroupMapper;
+import com.xhkjedu.sstudy.mapper.paperstudent.PaperClassMapper;
 import com.xhkjedu.sstudy.mapper.paperstudent.PaperStudentMapper;
 import com.xhkjedu.sstudy.mapper.paperstudent.PaperStudentQuestionMapper;
 import com.xhkjedu.sstudy.mapper.question.QuestionMapper;
 import com.xhkjedu.sstudy.model.paper.TPaperFile;
 import com.xhkjedu.sstudy.model.paper.TPaperScantron;
-import com.xhkjedu.sstudy.model.paperstudent.TPaperGroup;
+import com.xhkjedu.sstudy.model.paperstudent.TPaperClass;
 import com.xhkjedu.sstudy.model.paperstudent.TPaperStudent;
 import com.xhkjedu.sstudy.model.paperstudent.TPaperStudentQuestion;
 import com.xhkjedu.sstudy.model.paperstudent.TPaperStudentScantron;
     @Resource
     private QuestionClassService questionClassService;
     @Resource
-    private PaperGroupMapper paperGroupMapper;
+    private PaperClassMapper paperClassMapper;
 
     @Autowired
     private PaperStudentScantronService paperStudentScantronService;
             Integer paperid = psq.getPaperid();
             Integer classid = paper.getClassid();
             int nowTime = N_Utils.getSecondTimestamp();
-            TPaperGroup pg = paperGroupMapper.selectByPaperAndClassId(paperid, classid);
+            TPaperClass pg = paperClassMapper.selectByPaperAndClassId(paperid, classid);
             if (pg.getStoptime() < nowTime){
                 ps.setPsstate(2);
             } else {
             Integer paperid = pss.getPaperid();
             Integer classid = paper.getClassid();
             int nowTime = N_Utils.getSecondTimestamp();
-            TPaperGroup pg = paperGroupMapper.selectByPaperAndClassId(paperid, classid);
+            TPaperClass pg = paperClassMapper.selectByPaperAndClassId(paperid, classid);
             if (pg.getStoptime() < nowTime){
                 ps.setPsstate(2);
             } else {

sstudy/src/main/java/com/xhkjedu/sstudy/service/question/QuestionClassService.java

 import com.xhkjedu.sstudy.config.ConfigKey;
 import com.xhkjedu.sstudy.listener.MessageSender;
 import com.xhkjedu.sstudy.mapper.paper.PaperMapper;
-import com.xhkjedu.sstudy.mapper.paperstudent.PaperGroupMapper;
+import com.xhkjedu.sstudy.mapper.paperstudent.PaperClassMapper;
 import com.xhkjedu.sstudy.mapper.question.QuestionClassMapper;
 import com.xhkjedu.sstudy.mapper.question.QuestionExplainMapper;
 import com.xhkjedu.sstudy.mapper.question.QuestionMapper;
     @Resource
     private QuestionExplainMapper questionExplainMapper;
     @Resource
-    private PaperGroupMapper paperGroupMapper;
+    private PaperClassMapper paperClassMapper;
     @Resource
     private QuestionStudentService questionStudentService;
     @Resource

sstudy/src/main/java/com/xhkjedu/sstudy/vo/paperstudent/PaperGroupParam.java

 package com.xhkjedu.sstudy.vo.paperstudent;
 
-import com.xhkjedu.sstudy.model.paperstudent.TPaperGroup;
+import com.xhkjedu.sstudy.model.paperstudent.TPaperClass;
 import lombok.Data;
 
 import java.util.ArrayList;
     private Integer schoolid;
 
     //布置作业对象
-    private List<TPaperGroup> classlst = new ArrayList<>();
+    private List<TPaperClass> classlst = new ArrayList<>();
 
     private List<PaperClassParam> selclass = new ArrayList<>();//发布作业选中的班级集合
 

sstudy/src/main/resources/mapper/paper/PaperAnalyzeMapper.xml

         ,p.createtime,pg.starttime,pg.stoptime,pg.showtype
         ,(case when ps.psstate=0 then 0 when ps.pschecked=1 then 2 else 1 end)pschecked
         from t_paper p left join t_paper_student ps on p.paperid = ps.paperid
-        left join t_paper_group pg on pg.paperid=p.paperid and pg.classid=#{classid}
+        left join t_paper_class pg on pg.paperid=p.paperid and pg.classid=#{classid}
         where p.paperid=#{paperid} and ps.classid=#{classid}
     </select>
     <select id="getPeopleAnalyze" resultType="com.xhkjedu.sstudy.vo.paper.AnalyzeStudentVo">
     <select id="listClass" resultType="com.xhkjedu.sstudy.vo.paper.PaperClassVo">
         select count(*)classnum,c.classname,c.gradeid,pg.classid
         ,(select count(*) from t_paper_student ps where ps.paperid=pg.paperid and ps.classid=pg.classid and ps.psstate!=0)ytjnum
-        from t_paper_group pg left join t_paper_student ps on pg.paperid=ps.paperid and pg.classid=ps.classid
+        from t_paper_class pg left join t_paper_student ps on pg.paperid=ps.paperid and pg.classid=ps.classid
         left join t_class c on pg.classid=c.classid
         where pg.paperid=#{paperid} group by pg.classid order by c.gradeid,c.classtype,c.classorder
     </select>
     <select id="listCommitAnalyze" resultMap="commitAnalyze">
         select p.paperid,p.papername,pg.starttime
-        from t_paper p left join t_paper_group pg on p.paperid = pg.paperid
+        from t_paper p left join t_paper_class pg on p.paperid = pg.paperid
         where p.createid=#{createid}
         group by p.paperid order by pg.starttime desc limit #{papernum}
     </select>
     </resultMap>
     <select id="listPaperClass" resultMap="schoolMap">
         select pg.classid,c.classname,c.gradeid,pg.checked,s.schoolid,s.schoolname
-        from t_paper_group pg left join t_class c on pg.classid = c.classid
+        from t_paper_class pg left join t_class c on pg.classid = c.classid
         left join t_school s on c.schoolid = s.schoolid
         where pg.paperid=#{paperid}
         group by pg.classid order by c.schoolid <![CDATA[ <> ]]> #{schoolid},c.gradeid,c.classtype,c.classorder
         ,ps.psstate,ps.pschecked,count(distinct case when ps2.userscore>ps.userscore then ps2.psid else null end)+1 `rank`,count(distinct ps2.psid)stunum
         from t_paper_student ps left join t_paper p on ps.paperid = p.paperid
         left join t_paper_student ps2 on ps2.paperid=ps.paperid and ps2.classid=ps.classid
-        left join t_paper_group pg on pg.paperid=ps.paperid and pg.classid=ps.classid
+        left join t_paper_class pg on pg.paperid=ps.paperid and pg.classid=ps.classid
         left join t_user u on p.createid=u.userid
         where ps.psid=#{psid} limit 1
     </select>
         select p.createid as teacherid,count(distinct p.paperid)fbnum,count(distinct case when pg.starttime&lt;=#{paper.timestamp} then ps.psid else null end)ytjnum,
         count(distinct case when ps.psstate!=0 then ps.psid else null end)commitnum,
         count(distinct case when ps.psstate!=0 and ps.pschecked=1 then ps.psid else null end)checknum
-        from t_paper p left join t_paper_group pg on p.paperid=pg.paperid
+        from t_paper p left join t_paper_class pg on p.paperid=pg.paperid
         left join t_paper_student ps on ps.paperid=pg.paperid and ps.classid=pg.classid
         left join t_class c on pg.classid=c.classid
         where p.paperstate=22 and c.schoolid=#{paper.schoolid} and c.gradeid=#{paper.gradeid} and c.year=#{paper.year}
         </if>
         group by cs2.studentid)cs
         left join t_paper_student ps on ps.studentid=cs.studentid
-        left join t_paper_group pg on pg.paperid=ps.paperid and pg.classid=ps.classid
+        left join t_paper_class pg on pg.paperid=ps.paperid and pg.classid=ps.classid
         left join t_paper p on ps.paperid=p.paperid and p.paperstate=22
         <if test="paper.starttime!=null and paper.starttime!=0">
             and pg.starttime>=#{paper.starttime}
         ,count(distinct ps.psid)sdnum,count(distinct case when ps.psstate!=0 then ps.psid else null end)commitnum
         ,sum(ps.userscore)userscore,sum(ps.paperscore)paperscore
         from t_paper_student ps left join t_class c on ps.classid=c.classid
-        left join t_paper_group pg on pg.paperid=ps.paperid and pg.classid=ps.classid
+        left join t_paper_class pg on pg.paperid=ps.paperid and pg.classid=ps.classid
         left join t_paper p on ps.paperid=p.paperid
         left join t_subject s on p.subjectid=s.subjectid
         where ps.studentid=#{paper.studentid} and c.gradeid=#{paper.gradeid} and c.year=#{paper.year} and
     <select id="listPaperStuExport" resultType="com.xhkjedu.sstudy.vo.paper.AStudentPaperVo">
         select ps.studentid,p.subjectid,ps.psstate,ps.userscore,ps.paperscore
         from t_paper_student ps left join t_class c on ps.classid=c.classid
-        left join t_paper_group pg on pg.paperid=ps.paperid and pg.classid=ps.classid
+        left join t_paper_class pg on pg.paperid=ps.paperid and pg.classid=ps.classid
         left join t_paper p on ps.paperid=p.paperid
         where ps.studentid=#{paper.studentid} and c.gradeid=#{paper.gradeid} and c.year=#{paper.year} and p.paperstate=22
         <if test="paper.starttime!=null and paper.starttime!=0">
     <select id="listPaperAllClassStu" resultType="com.xhkjedu.sstudy.vo.paper.AStudentPaperVo">
         select ps.studentid,p.subjectid,ps.psstate,ps.userscore,ps.paperscore
         from t_paper_student ps left join t_class c on ps.classid=c.classid
-        left join t_paper_group pg on ps.paperid=pg.paperid and ps.classid=pg.classid
+        left join t_paper_class pg on ps.paperid=pg.paperid and ps.classid=pg.classid
         left join t_paper p on pg.paperid=p.paperid
         where c.schoolid=#{paper.schoolid} and c.gradeid=#{paper.gradeid} and c.year=#{paper.year} and p.paperstate=22
         <if test="paper.starttime!=null and paper.starttime!=0">

sstudy/src/main/resources/mapper/paper/PaperMapper.xml

     <select id="findById" resultType="com.xhkjedu.sstudy.vo.paper.PaperVo">
         select p.paperid,p.papername,p.papernum,p.paperscore,p.createtime,u.username createname,
         p.papertype,p.comm,p.paperclass,p.directorid,p.paperstate,p.hearfile
-        ,(select showtype from t_paper_group pg where pg.paperid=p.paperid limit 1)showtype
+        ,(select showtype from t_paper_class pg where pg.paperid=p.paperid limit 1)showtype
         from t_paper p left join t_user u on u.userid=p.createid
         where p.paperid=#{paperid} limit 1
     </select>
         <if test="checktype==1">
         ,pg.checkid,(select group_concat(distinct u.username) from t_user u where pg.checkid=u.userid)teachername
         </if>
-        from t_paper_group pg left join t_class c on pg.classid=c.classid
+        from t_paper_class pg left join t_class c on pg.classid=c.classid
         left join t_paper_student ps on ps.paperid=pg.paperid and ps.classid=pg.classid
         where pg.paperid=#{paperid}
         <if test="checkid!=null and checkid!=0 and checkid!=createid">
     <!--本校作业班级批阅人-->
     <select id="listPaperCheckStu" resultType="java.util.Map">
          <if test="checktype==1">
-           select pg.checkid userid,u.username,c.classid,c.classname,c.gradeid from t_paper_group pg
+           select pg.checkid userid,u.username,c.classid,c.classname,c.gradeid from t_paper_class pg
            left join t_user u on pg.checkid=u.userid
            left join t_class c on pg.classid=c.classid
            where pg.paperid=#{paperid} and pg.schoolid=#{logschoolid}
         select p.paperid,p.papername,p.papertype,p.paperclass,p.paperstate,p.checktype,p.createtime,p.schoolid,p.hasreport,
         #{paper.schoolid} logschoolid,u.username createname,pg.starttime,pg.stoptime,pg.showtype,p.papernum,p.createid,#{paper.createid} checkid
         from t_paper p left join t_user u on p.createid=u.userid
-        left join t_paper_group pg on p.paperid=pg.paperid
+        left join t_paper_class pg on p.paperid=pg.paperid
         where p.lsbid=#{paper.lsbid} and (p.createid=#{paper.createid} or pg.checkid=#{paper.createid} or
         (p.hashb=1 and pg.classid in (${paper.classids})) or
         (p.hashb=0 and pg.classid in (${paper.bxclassids})))
         select p.paperid,p.papername,p.papertype,p.paperclass,p.paperstate,p.checktype,p.createtime,p.createid,#{checkid} checkid,p.schoolid as logschoolid
         ,u.username createname,pg.starttime,pg.stoptime,p.papernum
         from t_paper p left join t_user u on p.createid=u.userid
-        left join t_paper_group pg on p.paperid=pg.paperid
+        left join t_paper_class pg on p.paperid=pg.paperid
         left join t_paper_student ps on p.paperid=ps.paperid and pg.classid=ps.classid
         where p.checktype=1 and ps.checkid=#{checkid} and ps.psstate!=0 and ps.pschecked!=1
         group by p.paperid order by p.createtime desc
         ,pg.starttime,pg.stoptime,p.papernum,p.createid,#{paper.teacherid} checkid,p.schoolid,#{paper.schoolid} logschoolid
         ,pg.showtype,p.hasreport
         ,(select u.username from t_user u where u.userid=p.createid)createname
-        from t_paper p left join t_paper_group pg on p.paperid=pg.paperid
+        from t_paper p left join t_paper_class pg on p.paperid=pg.paperid
         left join t_class c on pg.classid=c.classid
         where p.createid=#{paper.teacherid} and c.gradeid=#{paper.gradeid} and c.year=#{paper.year}
         <if test="paper.starttime!=null and paper.starttime!=0">
     </resultMap>
     <select id="listPaperClass" resultMap="schoolMap">
         select pg.classid,c.classname,c.gradeid,pg.checked,c.schoolid,s.schoolname
-        from t_paper_group pg left join t_class c on pg.classid = c.classid
+        from t_paper_class pg left join t_class c on pg.classid = c.classid
         left join t_paper_student ps on pg.paperid=ps.paperid and pg.classid=ps.classid
         left join t_school s on c.schoolid = s.schoolid
         where pg.paperid=#{paperid} and ps.psstate!=0
     <!--作业发布班级和学校-->
     <select id="listSchoolClassByPaperid" resultType="java.util.Map">
         select s.schoolid,s.schoolname,pg.classid,c.classname,c.gradeid,c.year,p.subjectid
-        from t_paper_group pg
+        from t_paper_class pg
         left join t_class c on pg.classid=c.classid
         left join t_school s on s.schoolid=c.schoolid
         left join t_paper p on pg.paperid=p.paperid
         left join t_teacher_powersb tp on ct.teacherid=tp.teacherid
         left join t_user u on u.userid=ct.teacherid
         left join t_class c on ct.classid=c.classid
-        left join t_paper_group pg on u.schoolid=pg.schoolid
+        left join t_paper_class pg on u.schoolid=pg.schoolid
         where tp.subjectid=#{param.subjectid} and u.userstate=1 and u.usertype=1 and pg.paperid=#{param.paperid}
         and c.classstate=1 and c.year=#{param.year} and c.classtype in (1,2) and c.gradeid=#{param.gradeid}
         group by ct.teacherid order by c.classtype,c.classorder, convert(u.username using gbk)
     <!--获取作业学生列表-->
     <select id="listPaperStudentsByPaperid" resultMap="paperStudentList">
         select u.schoolid,s.schoolname, pg.classid,c.classname,c.gradeid,c.classnum,cs.studentid,u.username studentname
-        from t_paper_group pg left join t_class c on pg.classid=c.classid
+        from t_paper_class pg left join t_class c on pg.classid=c.classid
         left join t_class_student cs on c.classid = cs.classid
         left join t_user u on cs.studentid=u.userid
         left join t_school s on s.schoolid=u.schoolid

sstudy/src/main/resources/mapper/paper/PaperTeaAppMapper.xml

         select p.paperid,p.papername,p.papernum,p.papertype,p.paperclass,p.paperstate,p.checktype,p.createid,#{paper.teacherid} checkid
         ,min(pg.starttime)starttime,min(pg.stoptime)stoptime,pg.checked,p.subjectid,p.paperscore,p.schoolid,#{paper.schoolid} logschoolid
         ,group_concat(pg.classid) classids
-        from t_paper p left join t_paper_group pg on p.paperid=pg.paperid
+        from t_paper p left join t_paper_class pg on p.paperid=pg.paperid
         where (p.createid=#{paper.teacherid} or pg.checkid=#{paper.teacherid} or
         (p.hashb=1 and pg.classid in (${paper.classids})) or
         (p.hashb=0 and pg.classid in (${paper.bxclassids})))
     <select id="getPaperDetail" resultMap="paperDetailResult">
         select pg.classid,c.classname,c.gradeid,pg.checked,pg.paperid,pg.schoolid gschoolid,#{schoolid} schoolid
         ,pg.checkid,u.username checkname
-        from t_paper_group pg left join t_class c on pg.classid=c.classid
+        from t_paper_class pg left join t_class c on pg.classid=c.classid
         left join t_user u on pg.checkid=u.userid
         where pg.paperid=#{paperid} and pg.classid in(${classids})
         <!--<if test="checkid!=null and checkid!=0">

sstudy/src/main/resources/mapper/paperreport/PaperReportMapper.xml

     <select id="getPaper" resultType="java.util.Map">
         select p.papername,p.papertype,p.paperclass,p.createtime
         ,pg.starttime,pg.stoptime,pg.showtype
-        from t_paper p left join t_paper_group pg on p.paperid = pg.paperid
+        from t_paper p left join t_paper_class pg on p.paperid = pg.paperid
         where p.paperid=#{paperid} limit 1
     </select>
 </mapper>

sstudy/src/main/resources/mapper/paperstudent/PaperGroupMapper.xml → sstudy/src/main/resources/mapper/paperstudent/PaperClassMapper.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.xhkjedu.sstudy.mapper.paperstudent.PaperGroupMapper">
+<mapper namespace="com.xhkjedu.sstudy.mapper.paperstudent.PaperClassMapper">
     <!--详情-->
-    <select id="selectByPaperAndClassId" resultType="com.xhkjedu.sstudy.model.paperstudent.TPaperGroup">
+    <select id="selectByPaperAndClassId" resultType="com.xhkjedu.sstudy.model.paperstudent.TPaperClass">
         select pg.paperid,pg.classid,pg.stoptime,pg.showtype
-        from t_paper_group pg
+        from t_paper_class pg
         where pg.paperid=#{paperid} and pg.classid=#{classid} limit 1
     </select>
     <resultMap id="groupClass" type="com.xhkjedu.sstudy.vo.paperstudent.PaperGroupVo">
     <!--获取参与作业学生列表-->
     <select id="listPaperStudent" resultMap="groupClass">
         select ps.classid,c.classname,c.gradeid,ps.studentid,u.username studentname,pg.starttime,pg.stoptime
-        from t_paper_group pg left join t_paper_student ps on ps.paperid = pg.paperid and pg.classid=ps.classid
+        from t_paper_class pg left join t_paper_student ps on ps.paperid = pg.paperid and pg.classid=ps.classid
         left join t_user u on ps.studentid=u.userid
         left join t_class c on ps.classid=c.classid
         where pg.paperid=#{paperid} order by c.gradeid,c.classtype,c.classorder,convert(u.username using gbk)
     </select>
     <!--批阅完成-->
     <update id="updateChecked">
-        update t_paper_group set checked=1 where paperid=#{paperid} and classid=#{classid}
+        update t_paper_class set checked=1 where paperid=#{paperid} and classid=#{classid}
     </update>
     <!--根据学生作业id获取作业是否完成批阅-->
     <select id="getCheckedByPsId" resultType="java.lang.Integer">
         select pg.checked from t_paper_student ps
-        left join t_paper_group pg on ps.paperid=pg.paperid and ps.classid=pg.classid
+        left join t_paper_class pg on ps.paperid=pg.paperid and ps.classid=pg.classid
         where ps.psid=#{psid}
     </select>
 
     </select>
     <!--获取班级作业是否结束批阅-->
     <select id="getPaperClassChecked" resultType="java.lang.Integer">
-        select pg.checked from t_paper_group pg where pg.paperid=#{paperid} and pg.classid=#{classid}
+        select pg.checked from t_paper_class pg where pg.paperid=#{paperid} and pg.classid=#{classid}
     </select>
     <!--教师权限分组-->
     <select id="listGroupByTeacherId" resultType="java.util.Map">

sstudy/src/main/resources/mapper/paperstudent/PaperStudentMapper.xml

         ,pg.starttime,pg.stoptime,pg.showtype,ps.showanswer,u.username createname,p.papertype,d.directorname
         from t_paper_student ps join t_paper p on p.paperid = ps.paperid
         left join t_director d on p.directorid=d.directorid
-        left join t_paper_group pg on ps.paperid = pg.paperid and ps.classid=pg.classid
+        left join t_paper_class pg on ps.paperid = pg.paperid and ps.classid=pg.classid
         left join t_user u on p.createid = u.userid
         where ps.studentid = #{ps.studentid} and pg.starttime<=#{ps.nowtime}
         <if test="ps.subjectid!=null and ps.subjectid!='0'.toString() and ps.subjectid!=''">
         select ps.psid,p.paperid,p.papername,p.paperclass,ps.psstate,ps.pschecked
         ,pg.starttime,pg.stoptime,u.username createname,s.subjectname,p.papertype,pg.checked
         from t_paper_student ps join t_paper p on p.paperid = ps.paperid
-        left join t_paper_group pg on ps.paperid = pg.paperid and ps.classid=pg.classid
+        left join t_paper_class pg on ps.paperid = pg.paperid and ps.classid=pg.classid
         left join t_user u on p.createid = u.userid
         left join t_subject s on p.subjectid = s.subjectid
         where ps.checkid=#{ps.checkid} and ps.psstate!=0 and ps.pschecked!=1
     <!--作业说明-->
     <select id="getPaperComm" resultType="com.xhkjedu.sstudy.vo.paperstudent.PaperCommVo">
         select ps.psid,p.papername,ps.papernum,ps.paperscore,p.paperclass,p.comm,pg.starttime,pg.stoptime,pg.showtype
-        from t_paper_student ps left join t_paper_group pg on ps.paperid=pg.paperid and ps.classid=pg.classid
+        from t_paper_student ps left join t_paper_class pg on ps.paperid=pg.paperid and ps.classid=pg.classid
         left join t_paper p on pg.paperid = p.paperid
         where ps.psid=#{psid}
     </select>
     <!--详情退回学生作业使用-->
     <select id="findById2" resultType="com.xhkjedu.sstudy.model.paperstudent.TPaperStudent">
         select s.psid,s.paperid,s.classid,s.studentid,s.psstate,s.pschecked,pg.checked
-        from t_paper_student s left join t_paper_group pg on s.paperid=pg.paperid and s.classid=pg.classid
+        from t_paper_student s left join t_paper_class pg on s.paperid=pg.paperid and s.classid=pg.classid
         where s.psid=#{psid} limit 1
     </select>
 
         update t_paper_student set checkid=#{checkid} where paperid=#{paperid}
     </update>
     <update id="updateCheckId2">
-        update t_paper_group pg left join t_paper_student ps on pg.paperid=ps.paperid and pg.classid=ps.classid
+        update t_paper_class pg left join t_paper_student ps on pg.paperid=ps.paperid and pg.classid=ps.classid
         <trim prefix="set" suffixOverrides=",">
             <trim prefix="pg.checkid = CASE " suffix="END,">
                 <foreach collection="params" index="index" item="item">
     </select>
 
     <update id="updateShowanswer">
-        update t_paper_student ps left join t_paper_group pg on ps.paperid=pg.paperid
+        update t_paper_student ps left join t_paper_class pg on ps.paperid=pg.paperid
         set ps.showanswer=1 where pg.pgstate=22 AND pg.showtype=1 and ps.showanswer=0 and pg.stoptime <![CDATA[ <= ]]> #{stoptime}
     </update>
 
         ,pg.starttime,pg.stoptime,ps.showanswer,u.username createname,p.papertype,s.subjectname
         from t_paper_student ps join t_paper p on p.paperid = ps.paperid
         left join t_subject s on p.subjectid=s.subjectid
-        left join t_paper_group pg on ps.paperid = pg.paperid and ps.classid=pg.classid
+        left join t_paper_class pg on ps.paperid = pg.paperid and ps.classid=pg.classid
         left join t_user u on p.createid = u.userid
         where ps.studentid = #{ps.studentid} and pg.starttime&lt;=#{ps.nowtime}
         <if test="ps.subjectid!=null and ps.subjectid!='0'.toString() and ps.subjectid!=''">

suser/src/main/resources/mapper/gradeclass/ClassTeacherMapper.xml

     <!--获取作业学生列表-->
     <select id="listPaperStudent" resultMap="teacherClass">
         select pg.classid,c.classname,c.gradeid,c.classnum,cs.studentid,u.username studentname,u.headpic
-        from t_paper_group pg left join t_class c on pg.classid=c.classid
+        from t_paper_class pg left join t_class c on pg.classid=c.classid
         left join t_class_student cs on c.classid = cs.classid
         left join t_user u on cs.studentid=u.userid
         where pg.paperid=#{paperid} order by c.gradeid,c.classtype,c.classorder,convert(u.username using gbk)
     </resultMap>
     <select id="listPaperTeacher" resultMap="paperTeacher">
         select pg.classid,c.classname,c.gradeid,ct.teacherid,u.username teachername
-        from t_paper_group pg left join t_class c on pg.classid=c.classid
+        from t_paper_class pg left join t_class c on pg.classid=c.classid
         left join t_class_teacher ct on c.classid=ct.classid
         right join t_teacher_powersb tp on tp.teacherid=ct.teacherid
         right join t_subject_book sb on sb.lsbid=tp.lsbid and sb.subjectid=#{subjectid}