Merge branch 'master' of https://e.coding.net/chuanghaikeji/smartCampus/backend_code

src/main/java/com/template/api/SmartEvaluateStudentControlle2API.java

@@ -0,0 +1,46 @@
+package com.template.api;
+
+import com.alibaba.fastjson.JSONObject;
+import com.template.model.evaluate.student.SmartEvaluateStudent;
+import com.template.model.evaluate.student.SmartSubjectTemplate;
+import com.template.model.result.CommonResult;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+
+@RequestMapping("/api/smartEvaluateStudent2")
+@Api(tags = {"SmartEvaluateStudentController2API"}, value = "学生评测2")
+public interface SmartEvaluateStudentControlle2API {
+
+    @RequestMapping(value = "/addSmartSubjectTemplate")
+    @ApiOperation(value = "新增评分项", httpMethod = "POST")
+    public CommonResult addSmartSubjectTemplate(@Validated @RequestBody JSONObject jsonObject);
+
+    @RequestMapping(value = "/updateSmartSubjectTemplate")
+    @ApiOperation(value = "修改评分项", httpMethod = "POST")
+    public CommonResult updateSmartSubjectTemplate(@Validated @RequestBody JSONObject jsonObject);
+
+    @RequestMapping(value = "/delSmartSubjectTemplate")
+    @ApiOperation(value = "删除评分项", httpMethod = "POST")
+    public CommonResult delSmartSubjectTemplate(@RequestParam Integer id);
+
+    @RequestMapping(value = "/queryTemplatePage")
+    @ApiOperation(value = "查看评分项", httpMethod = "POST")
+    public CommonResult queryTemplatePage(Integer currentPage, Integer pageCount);
+
+    @RequestMapping(value = "/queryTemplateRulePage")
+    @ApiOperation(value = "查看评分规则", httpMethod = "POST")
+    public CommonResult queryTemplateRulePage(Integer id);
+
+    @RequestMapping(value = "/evaluateScore")
+    @ApiOperation(value = "学生评分", httpMethod = "POST")
+    public CommonResult evaluateScore(Integer id, String scoreComment);
+
+    @RequestMapping(value = "/queryEvaluateStudent")
+    @ApiOperation(value = "查看评价数据", httpMethod = "POST")
+    public CommonResult queryEvaluateStudent(@Validated @RequestBody SmartEvaluateStudent smartEvaluateStudent, Integer currentPage, Integer pageCount);
+
+}

src/main/java/com/template/controller/SmartEvaluateStudentController2.java

@@ -0,0 +1,296 @@
+package com.template.controller;
+
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.template.annotation.DESRespondSecret;
+import com.template.annotation.PassToken;
+import com.template.api.SmartEvaluateStudentControlle2API;
+import com.template.common.utils.UUIDUtil;
+import com.template.model.evaluate.student.*;
+import com.template.model.pojo.SmartExamtype;
+import com.template.model.pojo.SmartGrade;
+import com.template.model.pojo.SmartScore;
+import com.template.model.result.CommonResult;
+import com.template.model.result.PageUtils;
+import com.template.services.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+@RestController
+//返回参数加密注解
+@DESRespondSecret
+public class SmartEvaluateStudentController2 implements SmartEvaluateStudentControlle2API {
+
+    @Autowired
+    public SmartSubjectManageService smartSubjectManageService;
+    @Autowired
+    public SmartSubjectRuleService smartSubjectRuleService;
+    @Autowired
+    public SmartEvaluateStudentService smartEvaluateStudentService;
+    @Autowired
+    public SmartEvaluateSdetailService smartEvaluateSdetailService;
+    @Autowired
+    public SmartSubjectTemplateService smartSubjectTemplateService;
+    @Autowired
+    public SmartTemplateRuleService smartTemplateRuleService;
+    @Autowired
+    public SmartExamtypeService smartExamtypeService;
+    @Autowired
+    public SmartScoreService smartScoreService;
+    @Autowired
+    public SmartGradeService smartGradeService;
+
+    /** ==============================第二版============================ **/
+    @PassToken
+    public CommonResult addSmartSubjectTemplate(JSONObject jsonObject) {
+        SmartTemplateRuleList smartTemplateRuleList = null;
+        try {
+            smartTemplateRuleList = JSONObject.parseObject(jsonObject.toString(), SmartTemplateRuleList.class);
+        } catch (Exception e) {
+            return CommonResult.errorMsg("参数格式错误");
+        }
+        SmartSubjectTemplate smartSubjectTemplate = smartTemplateRuleList.getSmartSubjectTemplate();
+        QueryWrapper<SmartSubjectTemplate> queryWrapper1 = new QueryWrapper<>();
+        queryWrapper1.eq("deleted", 0);
+        queryWrapper1.eq("grade", smartSubjectTemplate.getGrade());
+        queryWrapper1.eq("term", smartSubjectTemplate.getTerm());
+        // queryWrapper1.eq("exam_type", smartSubjectTemplate.getExamType());
+        List<SmartSubjectTemplate> listc = smartSubjectTemplateService.list(queryWrapper1);
+        if (!listc.isEmpty()){
+            return CommonResult.fail("该评分项已存在");
+        }
+        smartSubjectTemplate.setId((int) UUIDUtil.generateID());
+        List<SmartTemplateRule> ruleList = smartTemplateRuleList.getRuleList();
+        List<String> levels = ruleList.stream().map(SmartTemplateRule::getLevel).collect(Collectors.toList());
+        Set<String> levelSet = new HashSet<>(levels);
+        if (levels.size() != levelSet.size()) {
+            return CommonResult.fail("存在重复等级");
+        }
+        for (int i = 0; i < ruleList.size(); i++) {
+            SmartTemplateRule rule = ruleList.get(i);
+            rule.setTemplateId(smartSubjectTemplate.getId());
+            rule.setDeleted(0);
+            if (rule.getId()==null){
+                rule.setId((int) UUIDUtil.generateID());
+            }
+            smartTemplateRuleService.insertSmartTemplateRule(rule);
+        }
+        smartSubjectTemplate.setDeleted(0);
+        smartSubjectTemplateService.insertSmartSubjectTemplate(smartSubjectTemplate);
+        return CommonResult.ok("操作成功");
+    }
+
+    @PassToken
+    public CommonResult updateSmartSubjectTemplate(JSONObject jsonObject) {
+        SmartTemplateRuleList smartTemplateRuleList = null;
+        try {
+            smartTemplateRuleList = JSONObject.parseObject(jsonObject.toString(), SmartTemplateRuleList.class);
+        } catch (Exception e) {
+            return CommonResult.errorMsg("参数格式错误");
+        }
+        SmartSubjectTemplate smartSubjectTemplate = smartTemplateRuleList.getSmartSubjectTemplate();
+        QueryWrapper<SmartSubjectTemplate> queryWrapper1 = new QueryWrapper<>();
+        queryWrapper1.eq("deleted", 0);
+        queryWrapper1.eq("grade", smartSubjectTemplate.getGrade());
+        queryWrapper1.eq("term", smartSubjectTemplate.getTerm());
+        // queryWrapper1.eq("exam_type", smartSubjectTemplate.getExamType());
+        List<SmartSubjectTemplate> listc = smartSubjectTemplateService.list(queryWrapper1);
+        if (!listc.isEmpty() && !Objects.equals(listc.get(0).getId(), smartSubjectTemplate.getId())){
+            return CommonResult.fail("该评分项已存在");
+        }
+        SmartSubjectTemplate st = smartSubjectTemplateService.getSmartSubjectTemplateById(smartSubjectTemplate.getId());
+        if (st==null){
+            return CommonResult.fail("未找到该评分项");
+        }
+        QueryWrapper<SmartEvaluateStudent> queryWrapper2 = new QueryWrapper<>();
+        queryWrapper2.eq("deleted", 0);
+        queryWrapper2.eq("grade_name", smartSubjectTemplate.getGrade());
+        queryWrapper2.eq("term", smartSubjectTemplate.getTerm());
+        // queryWrapper2.eq("exam_type", smartSubjectTemplate.getExamType());
+        queryWrapper2.isNotNull("score_level");
+        List<SmartEvaluateStudent> evaluateData = smartEvaluateStudentService.getSmartEvaluateStudentByKey(queryWrapper2);
+        if (!evaluateData.isEmpty()){
+            return CommonResult.fail("该评分项已评测，不可修改");
+        }
+        List<SmartTemplateRule> ruleList = smartTemplateRuleList.getRuleList();
+        List<String> levels = ruleList.stream().filter(e->e.getDeleted().equals(0)).map(SmartTemplateRule::getLevel).collect(Collectors.toList());
+        Set<String> levelSet = new HashSet<>(levels);
+        if (levels.size() != levelSet.size()) {
+            return CommonResult.fail("存在重复等级");
+        }
+        for (int i = 0; i < ruleList.size(); i++) {
+            SmartTemplateRule rule = ruleList.get(i);
+            if (rule.getId()==null){
+                rule.setId((int) UUIDUtil.generateID());
+            }
+            rule.setTemplateId(smartSubjectTemplate.getId());
+            SmartTemplateRule ruleListc = smartTemplateRuleService.getSmartTemplateRuleById(rule.getId());
+            if (ruleListc==null){
+                smartTemplateRuleService.insertSmartTemplateRule(rule);
+            } else {
+                smartTemplateRuleService.updateSmartTemplateRule(rule);
+            }
+        }
+        smartSubjectTemplate.setDeleted(0);
+        smartSubjectTemplateService.updateSmartSubjectTemplate(smartSubjectTemplate);
+        return CommonResult.ok("操作成功");
+    }
+
+    @PassToken
+    public CommonResult delSmartSubjectTemplate(Integer id) {
+        if (id==null){
+            return CommonResult.fail("请传入ID");
+        }
+        SmartSubjectTemplate smartSubjectTemplate = smartSubjectTemplateService.getSmartSubjectTemplateById(id);
+        if (smartSubjectTemplate==null){
+            return CommonResult.fail("该评分项不存在");
+        }
+        QueryWrapper<SmartEvaluateStudent> queryWrapper1 = new QueryWrapper<>();
+        queryWrapper1.eq("deleted", 0);
+        queryWrapper1.eq("grade_name", smartSubjectTemplate.getGrade());
+        queryWrapper1.eq("term", smartSubjectTemplate.getTerm());
+        // queryWrapper1.eq("exam_type", smartSubjectTemplate.getExamType());
+        queryWrapper1.isNotNull("score_level");
+        List<SmartEvaluateStudent> evaluateData = smartEvaluateStudentService.getSmartEvaluateStudentByKey(queryWrapper1);
+        if (!evaluateData.isEmpty()){
+            return CommonResult.fail("该评分项已评测，不可删除");
+        }
+        QueryWrapper<SmartTemplateRule> queryWrapper2 = new QueryWrapper<>();
+        queryWrapper2.eq("deleted", 0);
+        queryWrapper2.eq("template_id", smartSubjectTemplate.getId());
+        List<SmartTemplateRule> listc = smartTemplateRuleService.getSmartTemplateRuleByKey(queryWrapper2);
+        if (!listc.isEmpty()){
+            SmartTemplateRule sr = new SmartTemplateRule();
+            sr.setDeleted(1);
+            smartTemplateRuleService.update(sr, queryWrapper2);
+        }
+        smartSubjectTemplateService.deleteSmartSubjectTemplateById(id);
+        return CommonResult.ok("操作成功");
+    }
+
+    @PassToken
+    @DESRespondSecret(validated = false)
+    public CommonResult queryTemplatePage(Integer currentPage, Integer pageCount) {
+        QueryWrapper<SmartSubjectTemplate> queryWrapper1 = new QueryWrapper<>();
+        queryWrapper1.eq("deleted", 0);
+        queryWrapper1.orderByDesc("id");
+        PageUtils<SmartSubjectTemplate> list = smartSubjectTemplateService.queryPageSmartSubjectTemplate(currentPage, pageCount, queryWrapper1);
+        return CommonResult.ok(list);
+    }
+
+    @PassToken
+    @DESRespondSecret(validated = false)
+    public CommonResult queryTemplateRulePage(Integer id) {
+        QueryWrapper<SmartTemplateRule> queryWrapper1 = new QueryWrapper<>();
+        queryWrapper1.eq("deleted", 0);
+        queryWrapper1.eq("template_id", id);
+        queryWrapper1.orderByDesc("id");
+        List<SmartTemplateRule> list = smartTemplateRuleService.getSmartTemplateRuleByKey(queryWrapper1);
+        return CommonResult.ok(list);
+    }
+
+    @PassToken
+    public CommonResult evaluateScore(Integer id, String scoreComment) {
+        if (id==null) {
+            return CommonResult.fail("请传入ID");
+        }
+        SmartEvaluateStudent evaluateStudent = smartEvaluateStudentService.getSmartEvaluateStudentById(id);
+        if (evaluateStudent==null){
+            return CommonResult.fail("该条记录已删除");
+        }
+        QueryWrapper<SmartSubjectTemplate> queryWrapper1 = new QueryWrapper<>();
+        queryWrapper1.eq("deleted", 0);
+        queryWrapper1.eq("grade", evaluateStudent.getGradeName());
+        queryWrapper1.eq("term", evaluateStudent.getTerm());
+        List<SmartSubjectTemplate> templateList = smartSubjectTemplateService.getSmartSubjectTemplateByKey(queryWrapper1);
+        if (templateList.isEmpty()){
+            return CommonResult.fail("未查询到相关评价模板");
+        }
+        SmartSubjectTemplate template = templateList.get(0);
+        String[] examType = template.getExamType().split(",");
+        QueryWrapper<SmartGrade> queryWrapper2 = new QueryWrapper<>();
+        queryWrapper2.eq("deleted", 0);
+        queryWrapper2.eq("name", template.getGrade());
+        SmartGrade smartGrade = smartGradeService.getOne(queryWrapper2);
+        Double totalScore = 0.00;
+        int k = 0;
+        for (int i = 0; i < examType.length; i++) {
+            QueryWrapper<SmartExamtype> queryWrapper3 = new QueryWrapper<>();
+            queryWrapper3.eq("deleted", 0);
+            queryWrapper3.eq("grade_id",smartGrade.getId());
+            queryWrapper3.eq("name", examType[i]);
+            SmartExamtype smartExamtype = smartExamtypeService.getOne(queryWrapper3);
+            if (smartExamtype.getIsExam()==0){
+                return CommonResult.fail(smartGrade.getName()+"-"+smartExamtype.getName()+"不支持综评！");
+            }
+            QueryWrapper<SmartScore> queryWrapper4 = new QueryWrapper<>();
+            queryWrapper4.eq("deleted", 0);
+            queryWrapper4.eq("semester", template.getTerm());
+            queryWrapper4.eq("grade", template.getGrade());
+            queryWrapper4.eq("exam_type", smartExamtype.getId());
+            queryWrapper4.eq("card_no", evaluateStudent.getCardNo());
+            List<SmartScore> scoreList = smartScoreService.list(queryWrapper4);
+            if (scoreList.isEmpty()){
+                return CommonResult.fail("未查询到"+evaluateStudent.getName()+"-"+template.getTerm()+"-"+smartExamtype.getName()+"考试成绩");
+            }
+            for (int j = 0; j < scoreList.size(); j++) {
+                totalScore+=scoreList.get(j).getScore();
+                k++;
+            }
+        }
+        Double avgScore = totalScore/k;
+        QueryWrapper<SmartTemplateRule> queryWrapper5 = new QueryWrapper<>();
+        queryWrapper5.eq("deleted", 0);
+        queryWrapper5.eq("template_id", template.getId());
+        List<SmartTemplateRule> ruleList = smartTemplateRuleService.getSmartTemplateRuleByKey(queryWrapper5);
+        if (ruleList.isEmpty()){
+            return CommonResult.fail("未配置评分规则");
+        }
+        String scoreLevel = "";
+        for (int j = 0; j < ruleList.size(); j++) {
+            String[] range = ruleList.get(j).getScoreRange().split("-");
+            double min = Double.parseDouble(range[0]);
+            double max = Double.parseDouble(range[1]);
+            if (avgScore >= min && avgScore <= max) {
+                scoreLevel = ruleList.get(j).getLevel();
+                break;
+            }
+        }
+        evaluateStudent.setScoreNum(avgScore);
+        evaluateStudent.setScoreLevel(scoreLevel);
+        evaluateStudent.setScoreComment(scoreComment);
+        smartEvaluateStudentService.updateSmartEvaluateStudent(evaluateStudent);
+        return CommonResult.ok();
+    }
+
+    @PassToken
+    public CommonResult queryEvaluateStudent(SmartEvaluateStudent smartEvaluateStudent, Integer currentPage, Integer pageCount) {
+        QueryWrapper<SmartEvaluateStudent> queryWrapper1 = new QueryWrapper<>();
+        queryWrapper1.eq("deleted", 0);
+        if (smartEvaluateStudent.getName() != null && !smartEvaluateStudent.getName().trim().equals("")) {
+            queryWrapper1.and(qw -> qw.like("name", smartEvaluateStudent.getName()).or().like("card_no", smartEvaluateStudent.getName()));
+        }
+        if (smartEvaluateStudent.getTerm() != null && !smartEvaluateStudent.getTerm().trim().equals("")) {
+            queryWrapper1.like("term", smartEvaluateStudent.getTerm());
+        }
+        if (smartEvaluateStudent.getGradeName() != null && !smartEvaluateStudent.getGradeName().trim().equals("")) {
+            queryWrapper1.eq("grade_name", smartEvaluateStudent.getGradeName());
+        }
+        if (smartEvaluateStudent.getClassName() != null && !smartEvaluateStudent.getClassName().trim().equals("")) {
+            queryWrapper1.eq("class_name", smartEvaluateStudent.getClassName());
+        }
+        if (smartEvaluateStudent.getScoreLevel() != null && !smartEvaluateStudent.getScoreLevel().trim().equals("")) {
+            queryWrapper1.eq("score_level", smartEvaluateStudent.getClassName());
+        }
+        queryWrapper1.orderByDesc("id");
+        PageUtils<SmartEvaluateStudent> list = smartEvaluateStudentService.queryPageSmartEvaluateStudent(currentPage, pageCount, queryWrapper1);
+        return CommonResult.ok(list);
+    }
+
+}

src/main/java/com/template/mapper/SmartSubjectTemplateMapper.java

@@ -0,0 +1,16 @@
+package com.template.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.template.model.evaluate.student.SmartSubjectTemplate;
+
+/**
+ * <p>
+ * 平分项管理 Mapper 接口
+ * </p>
+ *
+ * @author ceshi
+ * @since 2024-03-14
+ */
+public interface SmartSubjectTemplateMapper extends BaseMapper<SmartSubjectTemplate> {
+
+}

src/main/java/com/template/mapper/SmartTemplateRuleMapper.java

@@ -0,0 +1,16 @@
+package com.template.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.template.model.evaluate.student.SmartTemplateRule;
+
+/**
+ * <p>
+ * 平分项管理 Mapper 接口
+ * </p>
+ *
+ * @author ceshi
+ * @since 2024-03-14
+ */
+public interface SmartTemplateRuleMapper extends BaseMapper<SmartTemplateRule> {
+
+}

src/main/java/com/template/model/evaluate/student/SmartSubjectTemplate.java

@@ -0,0 +1,66 @@
+package com.template.model.evaluate.student;
+
+import com.baomidou.mybatisplus.annotation.*;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+import javax.validation.constraints.NotBlank;
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * <p>
+ * 平分项管理
+ * </p>
+ *
+ * @author ceshi
+ * @since 2024-03-14
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Accessors(chain = true)
+@ApiModel(value="SmartSubjectTemplate对象", description="平分项管理")
+public class SmartSubjectTemplate implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @ApiModelProperty(value = "主键ID")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "年级")
+    @NotBlank(message = "年级不能为空")
+    private String grade;
+
+    @ApiModelProperty(value = "学期")
+    @NotBlank(message = "学期不能为空")
+    private String term;
+
+    @ApiModelProperty(value = "考试类型")
+    @NotBlank(message = "考试类型不能为空")
+    private String examType;
+
+    @ApiModelProperty(value = "创建时间")
+    @TableField(fill = FieldFill.INSERT)
+    private Date createTime;
+
+    @ApiModelProperty(value = "更新时间")
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private Date updateTime;
+
+    @ApiModelProperty(value = "创建人员")
+    @TableField(fill = FieldFill.INSERT)
+    private String createUser;
+
+    @ApiModelProperty(value = "更新人员")
+    @TableField(fill = FieldFill.INSERT_UPDATE)
+    private String updateUser;
+
+    @ApiModelProperty(value = "逻辑删除 未删除：0；删除：1")
+    private Integer deleted;
+
+
+}

src/main/java/com/template/model/evaluate/student/SmartTemplateRule.java

@@ -0,0 +1,49 @@
+package com.template.model.evaluate.student;
+
+import com.baomidou.mybatisplus.annotation.*;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+import javax.validation.constraints.NotBlank;
+import java.io.Serializable;
+
+/**
+ * <p>
+ * 平分项管理
+ * </p>
+ *
+ * @author ceshi
+ * @since 2024-03-14
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Accessors(chain = true)
+@ApiModel(value="SmartTemplateRule对象", description="平分项管理")
+public class SmartTemplateRule implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @ApiModelProperty(value = "主键ID")
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    @ApiModelProperty(value = "模板ID")
+    @NotBlank(message = "模板ID不能为空")
+    private Integer templateId;
+
+    @ApiModelProperty(value = "等级")
+    @NotBlank(message = "评分等级不能为空")
+    private String level;
+
+    @ApiModelProperty(value = "分值区间")
+    @NotBlank(message = "分数区间能为空")
+    private String scoreRange;
+
+    @ApiModelProperty(value = "逻辑删除 未删除：0；删除：1")
+    private Integer deleted;
+
+
+}

src/main/java/com/template/model/evaluate/student/SmartTemplateRuleList.java

@@ -0,0 +1,22 @@
+package com.template.model.evaluate.student;
+
+import io.swagger.annotations.ApiModel;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+import java.io.Serializable;
+import java.util.List;
+
+@Data
+@EqualsAndHashCode(callSuper = false)
+@Accessors(chain = true)
+@ApiModel(value="SmartTemplateRuleList对象", description="平分项列表")
+public class SmartTemplateRuleList implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    public SmartSubjectTemplate smartSubjectTemplate;
+
+    public List<SmartTemplateRule> ruleList;
+}

src/main/java/com/template/services/SmartSubjectTemplateService.java

@@ -0,0 +1,34 @@
+package com.template.services;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.template.model.evaluate.student.SmartSubjectTemplate;
+import com.template.model.result.PageUtils;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 平分项管理 服务类
+ * </p>
+ *
+ * @author ceshi
+ * @since 2024-03-14
+ */
+public interface SmartSubjectTemplateService extends IService<SmartSubjectTemplate> {
+
+    public int insertSmartSubjectTemplate(SmartSubjectTemplate sa);
+
+    public int updateSmartSubjectTemplate(SmartSubjectTemplate sa);
+
+    public PageUtils<SmartSubjectTemplate> queryPageSmartSubjectTemplate(int currentPage, int pageCount, QueryWrapper<SmartSubjectTemplate> queryWrapper);
+
+    public int deleteSmartSubjectTemplateById(int id);
+
+    public SmartSubjectTemplate getSmartSubjectTemplateById(int id);
+
+    public List<SmartSubjectTemplate> getSmartSubjectTemplateList();
+
+    public List<SmartSubjectTemplate> getSmartSubjectTemplateByKey(QueryWrapper<SmartSubjectTemplate> queryWrapper);
+
+}

src/main/java/com/template/services/SmartTemplateRuleService.java

@@ -0,0 +1,34 @@
+package com.template.services;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.template.model.evaluate.student.SmartTemplateRule;
+import com.template.model.result.PageUtils;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 平分项管理 服务类
+ * </p>
+ *
+ * @author ceshi
+ * @since 2024-03-14
+ */
+public interface SmartTemplateRuleService extends IService<SmartTemplateRule> {
+
+    public int insertSmartTemplateRule(SmartTemplateRule sa);
+
+    public int updateSmartTemplateRule(SmartTemplateRule sa);
+
+    public PageUtils<SmartTemplateRule> queryPageSmartTemplateRule(int currentPage, int pageCount, QueryWrapper<SmartTemplateRule> queryWrapper);
+
+    public int deleteSmartTemplateRuleById(int id);
+
+    public SmartTemplateRule getSmartTemplateRuleById(int id);
+
+    public List<SmartTemplateRule> getSmartTemplateRuleList();
+
+    public List<SmartTemplateRule> getSmartTemplateRuleByKey(QueryWrapper<SmartTemplateRule> queryWrapper);
+
+}

src/main/java/com/template/services/impl/SmartSubjectTemplateServiceImpl.java

@@ -0,0 +1,76 @@
+package com.template.services.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.template.mapper.SmartSubjectTemplateMapper;
+import com.template.model.evaluate.student.SmartSubjectTemplate;
+import com.template.model.evaluate.student.SmartSubjectTemplate;
+import com.template.model.result.PageUtils;
+import com.template.services.SmartSubjectTemplateService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 平分项管理 服务实现类
+ * </p>
+ *
+ * @author ceshi
+ * @since 2024-03-14
+ */
+@Service
+public class SmartSubjectTemplateServiceImpl extends ServiceImpl<SmartSubjectTemplateMapper, SmartSubjectTemplate> implements SmartSubjectTemplateService {
+
+    @Autowired
+    private SmartSubjectTemplateMapper smartSubjectTemplateMapper;
+
+    @Override
+    public int insertSmartSubjectTemplate(SmartSubjectTemplate sa) {
+        int result = smartSubjectTemplateMapper.insert(sa);
+        return result;
+    }
+
+    @Override
+    public int updateSmartSubjectTemplate(SmartSubjectTemplate sa) {
+        int result = smartSubjectTemplateMapper.updateById(sa);
+        return result;
+    }
+
+    @Override
+    public PageUtils<SmartSubjectTemplate> queryPageSmartSubjectTemplate(int currentPage, int pageCount, QueryWrapper<SmartSubjectTemplate> queryWrapper) {
+        Page<SmartSubjectTemplate> page = new Page<>(currentPage, pageCount);
+        IPage<SmartSubjectTemplate> result = smartSubjectTemplateMapper.selectPage(page,queryWrapper);
+        return new PageUtils<>(result);
+    }
+
+    @Override
+    public int deleteSmartSubjectTemplateById(int id) {
+        int result = smartSubjectTemplateMapper.deleteById(id);
+        return result;
+    }
+
+    @Override
+    public SmartSubjectTemplate getSmartSubjectTemplateById(int id) {
+        SmartSubjectTemplate result = smartSubjectTemplateMapper.selectById(id);
+        return result;
+    }
+
+    @Override
+    public List<SmartSubjectTemplate> getSmartSubjectTemplateList() {
+        QueryWrapper<SmartSubjectTemplate> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("deleted", 0);
+        List<SmartSubjectTemplate> result = smartSubjectTemplateMapper.selectList(queryWrapper);
+        return result;
+    }
+
+    @Override
+    public List<SmartSubjectTemplate> getSmartSubjectTemplateByKey(QueryWrapper<SmartSubjectTemplate> queryWrapper) {
+        List<SmartSubjectTemplate> result = smartSubjectTemplateMapper.selectList(queryWrapper);
+        return result;
+    }
+    
+}

src/main/java/com/template/services/impl/SmartTemplateRuleServiceImpl.java

@@ -0,0 +1,76 @@
+package com.template.services.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.template.mapper.SmartTemplateRuleMapper;
+import com.template.model.evaluate.student.SmartTemplateRule;
+import com.template.model.evaluate.student.SmartTemplateRule;
+import com.template.model.result.PageUtils;
+import com.template.services.SmartTemplateRuleService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 平分项管理 服务实现类
+ * </p>
+ *
+ * @author ceshi
+ * @since 2024-03-14
+ */
+@Service
+public class SmartTemplateRuleServiceImpl extends ServiceImpl<SmartTemplateRuleMapper, SmartTemplateRule> implements SmartTemplateRuleService {
+
+    @Autowired
+    private SmartTemplateRuleMapper smartTemplateRuleMapper;
+
+    @Override
+    public int insertSmartTemplateRule(SmartTemplateRule sa) {
+        int result = smartTemplateRuleMapper.insert(sa);
+        return result;
+    }
+
+    @Override
+    public int updateSmartTemplateRule(SmartTemplateRule sa) {
+        int result = smartTemplateRuleMapper.updateById(sa);
+        return result;
+    }
+
+    @Override
+    public PageUtils<SmartTemplateRule> queryPageSmartTemplateRule(int currentPage, int pageCount, QueryWrapper<SmartTemplateRule> queryWrapper) {
+        Page<SmartTemplateRule> page = new Page<>(currentPage, pageCount);
+        IPage<SmartTemplateRule> result = smartTemplateRuleMapper.selectPage(page,queryWrapper);
+        return new PageUtils<>(result);
+    }
+
+    @Override
+    public int deleteSmartTemplateRuleById(int id) {
+        int result = smartTemplateRuleMapper.deleteById(id);
+        return result;
+    }
+
+    @Override
+    public SmartTemplateRule getSmartTemplateRuleById(int id) {
+        SmartTemplateRule result = smartTemplateRuleMapper.selectById(id);
+        return result;
+    }
+
+    @Override
+    public List<SmartTemplateRule> getSmartTemplateRuleList() {
+        QueryWrapper<SmartTemplateRule> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("deleted", 0);
+        List<SmartTemplateRule> result = smartTemplateRuleMapper.selectList(queryWrapper);
+        return result;
+    }
+
+    @Override
+    public List<SmartTemplateRule> getSmartTemplateRuleByKey(QueryWrapper<SmartTemplateRule> queryWrapper) {
+        List<SmartTemplateRule> result = smartTemplateRuleMapper.selectList(queryWrapper);
+        return result;
+    }
+    
+}

src/main/resources/mapper/template/SmartSubjectTemplateMapper.xml

@@ -0,0 +1,5 @@
+<?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.template.mapper.SmartSubjectTemplateMapper">
+
+</mapper>

src/main/resources/mapper/template/SmartTemplateRuleMapper.xml

@@ -0,0 +1,5 @@
+<?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.template.mapper.SmartTemplateRuleMapper">
+
+</mapper>