完善总成绩汇总

src/main/java/com/sztzjy/trade/config/security/AuthenticationFilter.java

@@ -93,7 +93,7 @@ public class AuthenticationFilter extends OncePerRequestFilter {
 
             if (!Token.equals(token)) {
                 // 如果 Redis 中存在不同的 Token，说明该用户已在其他地方登录
-                response.setStatus(HttpStatus.UNAUTHORIZED.value());
+                response.setStatus(HttpStatus.CONFLICT.value());
                 response.setCharacterEncoding("UTF-8");
                 response.setContentType("text/html;charset=UTF-8");
                 response.getWriter().print("登录失败：您的账户在其他地方已登录。如果您没有进行此操作，请立即更改密码以保护账户安全。");

src/main/java/com/sztzjy/trade/entity/StuUser.java

@@ -56,15 +56,54 @@ public class StuUser {
     @ApiModelProperty(notes = "更新时间")
     private Date updateTime;
 
-    @ApiModelProperty(notes = "考勤成绩")
+    @ApiModelProperty(notes = "（总）考勤成绩")
     private BigDecimal attendanceScore;
 
-    @ApiModelProperty(notes = "作业考试成绩")
+    @ApiModelProperty(notes = "（总）作业考试成绩")
     private BigDecimal examResultsForHomeworkAssignments;
 
-    @ApiModelProperty(notes = "理实案例成绩")
+    @ApiModelProperty(notes = "（总）理实案例成绩")
     private BigDecimal resultsOfPracticalCaseStudies;
 
+    @ApiModelProperty(notes = "数字贸易概论成绩")
+    private BigDecimal introductionDigitalTrade;
+
+    @ApiModelProperty(notes = "数字贸易标准和规则成绩")
+    private BigDecimal digitalTradeStandardsRules;
+
+    @ApiModelProperty(notes = "数字贸易法律法规成绩")
+    private BigDecimal digitalTradeLawsRegulations;
+
+    @ApiModelProperty(notes = "数字知识产权保护成绩")
+    private BigDecimal protectionDigitalIntellectualProperty;
+
+    @ApiModelProperty(notes = "数字贸易技术成绩")
+    private BigDecimal digitalTradeTechnology;
+
+    @ApiModelProperty(notes = "数字贸易物流成绩")
+    private BigDecimal digitalTradeLogistics;
+
+    @ApiModelProperty(notes = "数字贸易金融成绩")
+    private BigDecimal digitalTradeFinance;
+
+    @ApiModelProperty(notes = "数字产品贸易成绩")
+    private BigDecimal digitalProductTrade;
+
+    @ApiModelProperty(notes = "数字技术贸易成绩")
+    private BigDecimal digitalTechnologyTrade;
+
+    @ApiModelProperty(notes = "数字服务贸易成绩")
+    private BigDecimal digitalServiceTrade;
+
+    @ApiModelProperty(notes = "数据贸易成绩")
+    private BigDecimal dataTrade;
+
+    @ApiModelProperty(notes = "数字贸易营销成绩")
+    private BigDecimal digitalTradeMarketing;
+
+    @ApiModelProperty(notes = "aigc数字运营")
+    private BigDecimal aigcDigitalOperations;
+
     public String getUserId() {
         return userId;
     }
@@ -208,4 +247,108 @@ public class StuUser {
     public void setResultsOfPracticalCaseStudies(BigDecimal resultsOfPracticalCaseStudies) {
         this.resultsOfPracticalCaseStudies = resultsOfPracticalCaseStudies;
     }
+
+    public BigDecimal getIntroductionDigitalTrade() {
+        return introductionDigitalTrade;
+    }
+
+    public void setIntroductionDigitalTrade(BigDecimal introductionDigitalTrade) {
+        this.introductionDigitalTrade = introductionDigitalTrade;
+    }
+
+    public BigDecimal getDigitalTradeStandardsRules() {
+        return digitalTradeStandardsRules;
+    }
+
+    public void setDigitalTradeStandardsRules(BigDecimal digitalTradeStandardsRules) {
+        this.digitalTradeStandardsRules = digitalTradeStandardsRules;
+    }
+
+    public BigDecimal getDigitalTradeLawsRegulations() {
+        return digitalTradeLawsRegulations;
+    }
+
+    public void setDigitalTradeLawsRegulations(BigDecimal digitalTradeLawsRegulations) {
+        this.digitalTradeLawsRegulations = digitalTradeLawsRegulations;
+    }
+
+    public BigDecimal getProtectionDigitalIntellectualProperty() {
+        return protectionDigitalIntellectualProperty;
+    }
+
+    public void setProtectionDigitalIntellectualProperty(BigDecimal protectionDigitalIntellectualProperty) {
+        this.protectionDigitalIntellectualProperty = protectionDigitalIntellectualProperty;
+    }
+
+    public BigDecimal getDigitalTradeTechnology() {
+        return digitalTradeTechnology;
+    }
+
+    public void setDigitalTradeTechnology(BigDecimal digitalTradeTechnology) {
+        this.digitalTradeTechnology = digitalTradeTechnology;
+    }
+
+    public BigDecimal getDigitalTradeLogistics() {
+        return digitalTradeLogistics;
+    }
+
+    public void setDigitalTradeLogistics(BigDecimal digitalTradeLogistics) {
+        this.digitalTradeLogistics = digitalTradeLogistics;
+    }
+
+    public BigDecimal getDigitalTradeFinance() {
+        return digitalTradeFinance;
+    }
+
+    public void setDigitalTradeFinance(BigDecimal digitalTradeFinance) {
+        this.digitalTradeFinance = digitalTradeFinance;
+    }
+
+    public BigDecimal getDigitalProductTrade() {
+        return digitalProductTrade;
+    }
+
+    public void setDigitalProductTrade(BigDecimal digitalProductTrade) {
+        this.digitalProductTrade = digitalProductTrade;
+    }
+
+    public BigDecimal getDigitalTechnologyTrade() {
+        return digitalTechnologyTrade;
+    }
+
+    public void setDigitalTechnologyTrade(BigDecimal digitalTechnologyTrade) {
+        this.digitalTechnologyTrade = digitalTechnologyTrade;
+    }
+
+    public BigDecimal getDigitalServiceTrade() {
+        return digitalServiceTrade;
+    }
+
+    public void setDigitalServiceTrade(BigDecimal digitalServiceTrade) {
+        this.digitalServiceTrade = digitalServiceTrade;
+    }
+
+    public BigDecimal getDataTrade() {
+        return dataTrade;
+    }
+
+    public void setDataTrade(BigDecimal dataTrade) {
+        this.dataTrade = dataTrade;
+    }
+
+    public BigDecimal getDigitalTradeMarketing() {
+        return digitalTradeMarketing;
+    }
+
+    public void setDigitalTradeMarketing(BigDecimal digitalTradeMarketing) {
+        this.digitalTradeMarketing = digitalTradeMarketing;
+    }
+
+    public BigDecimal getAigcDigitalOperations() {
+        return aigcDigitalOperations;
+    }
+
+    public void setAigcDigitalOperations(BigDecimal aigcDigitalOperations) {
+        this.aigcDigitalOperations = aigcDigitalOperations;
+    }
 }

src/main/java/com/sztzjy/trade/entity/StuUserExample.java

@@ -1275,6 +1275,786 @@ public class StuUserExample {
             addCriterion("results_of_practical_case_studies not between", value1, value2, "resultsOfPracticalCaseStudies");
             return (Criteria) this;
         }
+
+        public Criteria andIntroductionDigitalTradeIsNull() {
+            addCriterion("introduction_digital_trade is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIntroductionDigitalTradeIsNotNull() {
+            addCriterion("introduction_digital_trade is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIntroductionDigitalTradeEqualTo(BigDecimal value) {
+            addCriterion("introduction_digital_trade =", value, "introductionDigitalTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andIntroductionDigitalTradeNotEqualTo(BigDecimal value) {
+            addCriterion("introduction_digital_trade <>", value, "introductionDigitalTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andIntroductionDigitalTradeGreaterThan(BigDecimal value) {
+            addCriterion("introduction_digital_trade >", value, "introductionDigitalTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andIntroductionDigitalTradeGreaterThanOrEqualTo(BigDecimal value) {
+            addCriterion("introduction_digital_trade >=", value, "introductionDigitalTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andIntroductionDigitalTradeLessThan(BigDecimal value) {
+            addCriterion("introduction_digital_trade <", value, "introductionDigitalTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andIntroductionDigitalTradeLessThanOrEqualTo(BigDecimal value) {
+            addCriterion("introduction_digital_trade <=", value, "introductionDigitalTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andIntroductionDigitalTradeIn(List<BigDecimal> values) {
+            addCriterion("introduction_digital_trade in", values, "introductionDigitalTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andIntroductionDigitalTradeNotIn(List<BigDecimal> values) {
+            addCriterion("introduction_digital_trade not in", values, "introductionDigitalTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andIntroductionDigitalTradeBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("introduction_digital_trade between", value1, value2, "introductionDigitalTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andIntroductionDigitalTradeNotBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("introduction_digital_trade not between", value1, value2, "introductionDigitalTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeStandardsRulesIsNull() {
+            addCriterion("digital_trade_standards_rules is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeStandardsRulesIsNotNull() {
+            addCriterion("digital_trade_standards_rules is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeStandardsRulesEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_standards_rules =", value, "digitalTradeStandardsRules");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeStandardsRulesNotEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_standards_rules <>", value, "digitalTradeStandardsRules");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeStandardsRulesGreaterThan(BigDecimal value) {
+            addCriterion("digital_trade_standards_rules >", value, "digitalTradeStandardsRules");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeStandardsRulesGreaterThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_standards_rules >=", value, "digitalTradeStandardsRules");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeStandardsRulesLessThan(BigDecimal value) {
+            addCriterion("digital_trade_standards_rules <", value, "digitalTradeStandardsRules");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeStandardsRulesLessThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_standards_rules <=", value, "digitalTradeStandardsRules");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeStandardsRulesIn(List<BigDecimal> values) {
+            addCriterion("digital_trade_standards_rules in", values, "digitalTradeStandardsRules");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeStandardsRulesNotIn(List<BigDecimal> values) {
+            addCriterion("digital_trade_standards_rules not in", values, "digitalTradeStandardsRules");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeStandardsRulesBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_trade_standards_rules between", value1, value2, "digitalTradeStandardsRules");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeStandardsRulesNotBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_trade_standards_rules not between", value1, value2, "digitalTradeStandardsRules");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLawsRegulationsIsNull() {
+            addCriterion("digital_trade_laws_regulations is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLawsRegulationsIsNotNull() {
+            addCriterion("digital_trade_laws_regulations is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLawsRegulationsEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_laws_regulations =", value, "digitalTradeLawsRegulations");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLawsRegulationsNotEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_laws_regulations <>", value, "digitalTradeLawsRegulations");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLawsRegulationsGreaterThan(BigDecimal value) {
+            addCriterion("digital_trade_laws_regulations >", value, "digitalTradeLawsRegulations");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLawsRegulationsGreaterThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_laws_regulations >=", value, "digitalTradeLawsRegulations");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLawsRegulationsLessThan(BigDecimal value) {
+            addCriterion("digital_trade_laws_regulations <", value, "digitalTradeLawsRegulations");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLawsRegulationsLessThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_laws_regulations <=", value, "digitalTradeLawsRegulations");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLawsRegulationsIn(List<BigDecimal> values) {
+            addCriterion("digital_trade_laws_regulations in", values, "digitalTradeLawsRegulations");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLawsRegulationsNotIn(List<BigDecimal> values) {
+            addCriterion("digital_trade_laws_regulations not in", values, "digitalTradeLawsRegulations");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLawsRegulationsBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_trade_laws_regulations between", value1, value2, "digitalTradeLawsRegulations");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLawsRegulationsNotBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_trade_laws_regulations not between", value1, value2, "digitalTradeLawsRegulations");
+            return (Criteria) this;
+        }
+
+        public Criteria andProtectionDigitalIntellectualPropertyIsNull() {
+            addCriterion("protection_digital_intellectual_property is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andProtectionDigitalIntellectualPropertyIsNotNull() {
+            addCriterion("protection_digital_intellectual_property is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andProtectionDigitalIntellectualPropertyEqualTo(BigDecimal value) {
+            addCriterion("protection_digital_intellectual_property =", value, "protectionDigitalIntellectualProperty");
+            return (Criteria) this;
+        }
+
+        public Criteria andProtectionDigitalIntellectualPropertyNotEqualTo(BigDecimal value) {
+            addCriterion("protection_digital_intellectual_property <>", value, "protectionDigitalIntellectualProperty");
+            return (Criteria) this;
+        }
+
+        public Criteria andProtectionDigitalIntellectualPropertyGreaterThan(BigDecimal value) {
+            addCriterion("protection_digital_intellectual_property >", value, "protectionDigitalIntellectualProperty");
+            return (Criteria) this;
+        }
+
+        public Criteria andProtectionDigitalIntellectualPropertyGreaterThanOrEqualTo(BigDecimal value) {
+            addCriterion("protection_digital_intellectual_property >=", value, "protectionDigitalIntellectualProperty");
+            return (Criteria) this;
+        }
+
+        public Criteria andProtectionDigitalIntellectualPropertyLessThan(BigDecimal value) {
+            addCriterion("protection_digital_intellectual_property <", value, "protectionDigitalIntellectualProperty");
+            return (Criteria) this;
+        }
+
+        public Criteria andProtectionDigitalIntellectualPropertyLessThanOrEqualTo(BigDecimal value) {
+            addCriterion("protection_digital_intellectual_property <=", value, "protectionDigitalIntellectualProperty");
+            return (Criteria) this;
+        }
+
+        public Criteria andProtectionDigitalIntellectualPropertyIn(List<BigDecimal> values) {
+            addCriterion("protection_digital_intellectual_property in", values, "protectionDigitalIntellectualProperty");
+            return (Criteria) this;
+        }
+
+        public Criteria andProtectionDigitalIntellectualPropertyNotIn(List<BigDecimal> values) {
+            addCriterion("protection_digital_intellectual_property not in", values, "protectionDigitalIntellectualProperty");
+            return (Criteria) this;
+        }
+
+        public Criteria andProtectionDigitalIntellectualPropertyBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("protection_digital_intellectual_property between", value1, value2, "protectionDigitalIntellectualProperty");
+            return (Criteria) this;
+        }
+
+        public Criteria andProtectionDigitalIntellectualPropertyNotBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("protection_digital_intellectual_property not between", value1, value2, "protectionDigitalIntellectualProperty");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeTechnologyIsNull() {
+            addCriterion("digital_trade_technology is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeTechnologyIsNotNull() {
+            addCriterion("digital_trade_technology is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeTechnologyEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_technology =", value, "digitalTradeTechnology");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeTechnologyNotEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_technology <>", value, "digitalTradeTechnology");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeTechnologyGreaterThan(BigDecimal value) {
+            addCriterion("digital_trade_technology >", value, "digitalTradeTechnology");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeTechnologyGreaterThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_technology >=", value, "digitalTradeTechnology");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeTechnologyLessThan(BigDecimal value) {
+            addCriterion("digital_trade_technology <", value, "digitalTradeTechnology");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeTechnologyLessThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_technology <=", value, "digitalTradeTechnology");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeTechnologyIn(List<BigDecimal> values) {
+            addCriterion("digital_trade_technology in", values, "digitalTradeTechnology");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeTechnologyNotIn(List<BigDecimal> values) {
+            addCriterion("digital_trade_technology not in", values, "digitalTradeTechnology");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeTechnologyBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_trade_technology between", value1, value2, "digitalTradeTechnology");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeTechnologyNotBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_trade_technology not between", value1, value2, "digitalTradeTechnology");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLogisticsIsNull() {
+            addCriterion("digital_trade_logistics is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLogisticsIsNotNull() {
+            addCriterion("digital_trade_logistics is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLogisticsEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_logistics =", value, "digitalTradeLogistics");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLogisticsNotEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_logistics <>", value, "digitalTradeLogistics");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLogisticsGreaterThan(BigDecimal value) {
+            addCriterion("digital_trade_logistics >", value, "digitalTradeLogistics");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLogisticsGreaterThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_logistics >=", value, "digitalTradeLogistics");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLogisticsLessThan(BigDecimal value) {
+            addCriterion("digital_trade_logistics <", value, "digitalTradeLogistics");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLogisticsLessThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_logistics <=", value, "digitalTradeLogistics");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLogisticsIn(List<BigDecimal> values) {
+            addCriterion("digital_trade_logistics in", values, "digitalTradeLogistics");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLogisticsNotIn(List<BigDecimal> values) {
+            addCriterion("digital_trade_logistics not in", values, "digitalTradeLogistics");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLogisticsBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_trade_logistics between", value1, value2, "digitalTradeLogistics");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeLogisticsNotBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_trade_logistics not between", value1, value2, "digitalTradeLogistics");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeFinanceIsNull() {
+            addCriterion("digital_trade_finance is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeFinanceIsNotNull() {
+            addCriterion("digital_trade_finance is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeFinanceEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_finance =", value, "digitalTradeFinance");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeFinanceNotEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_finance <>", value, "digitalTradeFinance");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeFinanceGreaterThan(BigDecimal value) {
+            addCriterion("digital_trade_finance >", value, "digitalTradeFinance");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeFinanceGreaterThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_finance >=", value, "digitalTradeFinance");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeFinanceLessThan(BigDecimal value) {
+            addCriterion("digital_trade_finance <", value, "digitalTradeFinance");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeFinanceLessThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_finance <=", value, "digitalTradeFinance");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeFinanceIn(List<BigDecimal> values) {
+            addCriterion("digital_trade_finance in", values, "digitalTradeFinance");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeFinanceNotIn(List<BigDecimal> values) {
+            addCriterion("digital_trade_finance not in", values, "digitalTradeFinance");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeFinanceBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_trade_finance between", value1, value2, "digitalTradeFinance");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeFinanceNotBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_trade_finance not between", value1, value2, "digitalTradeFinance");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalProductTradeIsNull() {
+            addCriterion("digital_product_trade is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalProductTradeIsNotNull() {
+            addCriterion("digital_product_trade is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalProductTradeEqualTo(BigDecimal value) {
+            addCriterion("digital_product_trade =", value, "digitalProductTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalProductTradeNotEqualTo(BigDecimal value) {
+            addCriterion("digital_product_trade <>", value, "digitalProductTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalProductTradeGreaterThan(BigDecimal value) {
+            addCriterion("digital_product_trade >", value, "digitalProductTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalProductTradeGreaterThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_product_trade >=", value, "digitalProductTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalProductTradeLessThan(BigDecimal value) {
+            addCriterion("digital_product_trade <", value, "digitalProductTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalProductTradeLessThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_product_trade <=", value, "digitalProductTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalProductTradeIn(List<BigDecimal> values) {
+            addCriterion("digital_product_trade in", values, "digitalProductTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalProductTradeNotIn(List<BigDecimal> values) {
+            addCriterion("digital_product_trade not in", values, "digitalProductTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalProductTradeBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_product_trade between", value1, value2, "digitalProductTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalProductTradeNotBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_product_trade not between", value1, value2, "digitalProductTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTechnologyTradeIsNull() {
+            addCriterion("digital_technology_trade is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTechnologyTradeIsNotNull() {
+            addCriterion("digital_technology_trade is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTechnologyTradeEqualTo(BigDecimal value) {
+            addCriterion("digital_technology_trade =", value, "digitalTechnologyTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTechnologyTradeNotEqualTo(BigDecimal value) {
+            addCriterion("digital_technology_trade <>", value, "digitalTechnologyTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTechnologyTradeGreaterThan(BigDecimal value) {
+            addCriterion("digital_technology_trade >", value, "digitalTechnologyTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTechnologyTradeGreaterThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_technology_trade >=", value, "digitalTechnologyTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTechnologyTradeLessThan(BigDecimal value) {
+            addCriterion("digital_technology_trade <", value, "digitalTechnologyTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTechnologyTradeLessThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_technology_trade <=", value, "digitalTechnologyTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTechnologyTradeIn(List<BigDecimal> values) {
+            addCriterion("digital_technology_trade in", values, "digitalTechnologyTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTechnologyTradeNotIn(List<BigDecimal> values) {
+            addCriterion("digital_technology_trade not in", values, "digitalTechnologyTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTechnologyTradeBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_technology_trade between", value1, value2, "digitalTechnologyTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTechnologyTradeNotBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_technology_trade not between", value1, value2, "digitalTechnologyTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalServiceTradeIsNull() {
+            addCriterion("digital_service_trade is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalServiceTradeIsNotNull() {
+            addCriterion("digital_service_trade is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalServiceTradeEqualTo(BigDecimal value) {
+            addCriterion("digital_service_trade =", value, "digitalServiceTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalServiceTradeNotEqualTo(BigDecimal value) {
+            addCriterion("digital_service_trade <>", value, "digitalServiceTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalServiceTradeGreaterThan(BigDecimal value) {
+            addCriterion("digital_service_trade >", value, "digitalServiceTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalServiceTradeGreaterThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_service_trade >=", value, "digitalServiceTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalServiceTradeLessThan(BigDecimal value) {
+            addCriterion("digital_service_trade <", value, "digitalServiceTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalServiceTradeLessThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_service_trade <=", value, "digitalServiceTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalServiceTradeIn(List<BigDecimal> values) {
+            addCriterion("digital_service_trade in", values, "digitalServiceTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalServiceTradeNotIn(List<BigDecimal> values) {
+            addCriterion("digital_service_trade not in", values, "digitalServiceTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalServiceTradeBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_service_trade between", value1, value2, "digitalServiceTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalServiceTradeNotBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_service_trade not between", value1, value2, "digitalServiceTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDataTradeIsNull() {
+            addCriterion("data_trade is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDataTradeIsNotNull() {
+            addCriterion("data_trade is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDataTradeEqualTo(BigDecimal value) {
+            addCriterion("data_trade =", value, "dataTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDataTradeNotEqualTo(BigDecimal value) {
+            addCriterion("data_trade <>", value, "dataTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDataTradeGreaterThan(BigDecimal value) {
+            addCriterion("data_trade >", value, "dataTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDataTradeGreaterThanOrEqualTo(BigDecimal value) {
+            addCriterion("data_trade >=", value, "dataTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDataTradeLessThan(BigDecimal value) {
+            addCriterion("data_trade <", value, "dataTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDataTradeLessThanOrEqualTo(BigDecimal value) {
+            addCriterion("data_trade <=", value, "dataTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDataTradeIn(List<BigDecimal> values) {
+            addCriterion("data_trade in", values, "dataTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDataTradeNotIn(List<BigDecimal> values) {
+            addCriterion("data_trade not in", values, "dataTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDataTradeBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("data_trade between", value1, value2, "dataTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDataTradeNotBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("data_trade not between", value1, value2, "dataTrade");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeMarketingIsNull() {
+            addCriterion("digital_trade_marketing is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeMarketingIsNotNull() {
+            addCriterion("digital_trade_marketing is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeMarketingEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_marketing =", value, "digitalTradeMarketing");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeMarketingNotEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_marketing <>", value, "digitalTradeMarketing");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeMarketingGreaterThan(BigDecimal value) {
+            addCriterion("digital_trade_marketing >", value, "digitalTradeMarketing");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeMarketingGreaterThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_marketing >=", value, "digitalTradeMarketing");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeMarketingLessThan(BigDecimal value) {
+            addCriterion("digital_trade_marketing <", value, "digitalTradeMarketing");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeMarketingLessThanOrEqualTo(BigDecimal value) {
+            addCriterion("digital_trade_marketing <=", value, "digitalTradeMarketing");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeMarketingIn(List<BigDecimal> values) {
+            addCriterion("digital_trade_marketing in", values, "digitalTradeMarketing");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeMarketingNotIn(List<BigDecimal> values) {
+            addCriterion("digital_trade_marketing not in", values, "digitalTradeMarketing");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeMarketingBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_trade_marketing between", value1, value2, "digitalTradeMarketing");
+            return (Criteria) this;
+        }
+
+        public Criteria andDigitalTradeMarketingNotBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("digital_trade_marketing not between", value1, value2, "digitalTradeMarketing");
+            return (Criteria) this;
+        }
+
+        public Criteria andAigcDigitalOperationsIsNull() {
+            addCriterion("aigc_digital_operations is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andAigcDigitalOperationsIsNotNull() {
+            addCriterion("aigc_digital_operations is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andAigcDigitalOperationsEqualTo(BigDecimal value) {
+            addCriterion("aigc_digital_operations =", value, "aigcDigitalOperations");
+            return (Criteria) this;
+        }
+
+        public Criteria andAigcDigitalOperationsNotEqualTo(BigDecimal value) {
+            addCriterion("aigc_digital_operations <>", value, "aigcDigitalOperations");
+            return (Criteria) this;
+        }
+
+        public Criteria andAigcDigitalOperationsGreaterThan(BigDecimal value) {
+            addCriterion("aigc_digital_operations >", value, "aigcDigitalOperations");
+            return (Criteria) this;
+        }
+
+        public Criteria andAigcDigitalOperationsGreaterThanOrEqualTo(BigDecimal value) {
+            addCriterion("aigc_digital_operations >=", value, "aigcDigitalOperations");
+            return (Criteria) this;
+        }
+
+        public Criteria andAigcDigitalOperationsLessThan(BigDecimal value) {
+            addCriterion("aigc_digital_operations <", value, "aigcDigitalOperations");
+            return (Criteria) this;
+        }
+
+        public Criteria andAigcDigitalOperationsLessThanOrEqualTo(BigDecimal value) {
+            addCriterion("aigc_digital_operations <=", value, "aigcDigitalOperations");
+            return (Criteria) this;
+        }
+
+        public Criteria andAigcDigitalOperationsIn(List<BigDecimal> values) {
+            addCriterion("aigc_digital_operations in", values, "aigcDigitalOperations");
+            return (Criteria) this;
+        }
+
+        public Criteria andAigcDigitalOperationsNotIn(List<BigDecimal> values) {
+            addCriterion("aigc_digital_operations not in", values, "aigcDigitalOperations");
+            return (Criteria) this;
+        }
+
+        public Criteria andAigcDigitalOperationsBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("aigc_digital_operations between", value1, value2, "aigcDigitalOperations");
+            return (Criteria) this;
+        }
+
+        public Criteria andAigcDigitalOperationsNotBetween(BigDecimal value1, BigDecimal value2) {
+            addCriterion("aigc_digital_operations not between", value1, value2, "aigcDigitalOperations");
+            return (Criteria) this;
+        }
     }
 
     public static class Criteria extends GeneratedCriteria {

src/main/java/com/sztzjy/trade/mapper/StuUserMapper.java

@@ -5,10 +5,9 @@ import com.sztzjy.trade.entity.StuUserExample;
 import java.util.List;
 import java.util.Map;
 
-import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 import org.apache.ibatis.annotations.Select;
-@Mapper
+
 public interface StuUserMapper {
     long countByExample(StuUserExample example);
 

src/main/java/com/sztzjy/trade/service/impl/StuExpermentTrainingServiceImpl.java

@@ -19,6 +19,7 @@ import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.http.HttpStatus;
+import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.CollectionUtils;
@@ -581,11 +582,8 @@ public class StuExpermentTrainingServiceImpl implements StuExpermentTrainingServ
 
     @Override
     public List<StuScoreDetails> getAcademicRecord(String userId, String module) {
-        StuUserExample stuUserExample = new StuUserExample();
+        StuUser stuUser = stuUserMapper.selectByPrimaryKey(userId);
-        stuUserExample.createCriteria().andUserIdEqualTo(userId);
+        TchDigitalTradeWeight tchConceptualTechnologyWeights = getWeight(stuUser.getSchoolId());
-        List<StuUser> stuUsers = stuUserMapper.selectByExample(stuUserExample);
-        String schoolId = stuUsers.get(0).getSchoolId();
-        TchDigitalTradeWeight tchConceptualTechnologyWeights = getWeight(schoolId);
 //        if(tchConceptualTechnologyWeights.size()==0){
 //            TchConceptualTechnologyWeight tchConceptualTechnologyWeight = new TchConceptualTechnologyWeight(schoolId,module);
 //            tchConceptualTechnologyWeightMapper.insert(tchConceptualTechnologyWeight);
@@ -786,7 +784,7 @@ public class StuExpermentTrainingServiceImpl implements StuExpermentTrainingServ
             scoreDetailsList.add(stuScoreDetails);
         }
         //将成绩添加到学生信息
-        this.personalScoreEntry(userId,module);
+        this.personalScoreEntry(stuUser,module,tchConceptualTechnologyWeights);
         return scoreDetailsList;
     }
     @Resource
@@ -799,10 +797,8 @@ public class StuExpermentTrainingServiceImpl implements StuExpermentTrainingServ
      */
     @Override
     public void hashReadingScore(StuScoreDetailsDTO stuScoreDetailsDTO) {
-        StuUserExample stuUserExample = new StuUserExample();
+
-        stuUserExample.createCriteria().andUserIdEqualTo(stuScoreDetailsDTO.getUserId());
+        StuUser stuUser = stuUserMapper.selectByPrimaryKey(stuScoreDetailsDTO.getUserId());
-        List<StuUser> stuUsers = stuUserMapper.selectByExample(stuUserExample);
-        StuUser stuUser = stuUsers.get(0);
 
         TchDigitalTradeWeight weight = getWeight(stuUser.getSchoolId());
 
@@ -822,7 +818,6 @@ public class StuExpermentTrainingServiceImpl implements StuExpermentTrainingServ
         stuScoreDetailsDTO.setScoreWeight(Double.parseDouble(String.valueOf(weight.getWeightStudyTime())));
         StuScoreDetails stuScoreDetails = convertUtil.DTOToEntity(stuScoreDetailsDTO, StuScoreDetails.class);
         stuScoreDetails.setScoreProject(stuKnowledgeSummaryScoring);
-        floor = floor >= 1 ? 1 : floor;
         stuScoreDetails.setCompletionStatus(String.valueOf(floor));
         stuScoreDetails.setSerialNumber(1);
         stuScoreDetails.setLearningProjects("知识概要");
@@ -860,9 +855,13 @@ public class StuExpermentTrainingServiceImpl implements StuExpermentTrainingServ
 
 
             stuScoreDetailsMapper.updateByExampleSelective(stuScoreDetails, example1);
+
+
         }
+
+
         //将分数统计到学生表中
-       this.personalScoreEntry(stuScoreDetailsDTO.getUserId(),stuScoreDetailsDTO.getModule());
+       this.personalScoreEntry(stuUser,stuScoreDetailsDTO.getModule(), weight);
     }
 
 
@@ -874,10 +873,7 @@ public class StuExpermentTrainingServiceImpl implements StuExpermentTrainingServ
      */
     @Override
     public void hashWatchScore(StuScoreDetailsDTO stuScoreDetailsDTO) {
-        StuUserExample stuUserExample = new StuUserExample();
+        StuUser stuUser  = stuUserMapper.selectByPrimaryKey(stuScoreDetailsDTO.getUserId());
-        stuUserExample.createCriteria().andUserIdEqualTo(stuScoreDetailsDTO.getUserId());
-        List<StuUser> stuUsers = stuUserMapper.selectByExample(stuUserExample);
-        StuUser stuUser = stuUsers.get(0);
         TchDigitalTradeWeight weight = getWeight(stuUser.getSchoolId());
 
         //时间转换成分钟
@@ -894,6 +890,7 @@ public class StuExpermentTrainingServiceImpl implements StuExpermentTrainingServ
         stuScoreDetails.setSerialNumber(2);
         stuScoreDetails.setLearningProjects("资源学习");
         stuScoreDetails.setAssessmentItems("观看资源");
+        stuScoreDetails.setProject(stuScoreDetailsDTO.getModule());
 
         //判断数据是否存在
         StuScoreDetailsExample example1 = new StuScoreDetailsExample();
@@ -926,60 +923,23 @@ public class StuExpermentTrainingServiceImpl implements StuExpermentTrainingServ
 
 
         //将分数统计到学生表中
-        this.personalScoreEntry(stuScoreDetailsDTO.getUserId(),stuScoreDetailsDTO.getModule());
+        this.personalScoreEntry(stuUser,stuScoreDetailsDTO.getModule(),weight);
-    }
+    }
-
+
-
-
-    public void personalScoreEntry(String userId,String module){
-//        StuUserExample stuUserExample=new StuUserExample();
-//        stuUserExample.createCriteria().andUserIdEqualTo(userId);
-//        List<StuUser> stuUsers = stuUserMapper.selectByExample(stuUserExample);
-//        String schoolId = stuUsers.get(0).getSchoolId();
-//        TchDigitalTradeWeight weight = getWeight(schoolId);
-//        //取到知识概要计分标准和权重
-//        BigDecimal knowledgeScore = weight.getScoringCriteriaForLearningDuration();
-//        BigDecimal summaryOfKnowledgeWeight = weight.getWeightStudyTime();
-//        //取到资源学习计分标准和权重
-//        BigDecimal resourceLearningScore = weight.getScoringCriteriaForStudyResource();
-//        BigDecimal resourceLearningWeight = weight.getWeightStudyResource();
-//        //取到学习测评计分标准和权重
-//        BigDecimal learningAssessmentScore = weight.getScoringCriteriaForStudyEvaluation();
-//        BigDecimal learningAssessmentWeight = weight.getWeightStudyEvaluation();
-//        //取到实验实训计分标准和权重
-//        BigDecimal experimentalTrainingScore = weight.getScoringCriteriaForExperimentalTraining();
-//        BigDecimal experimentalTrainingWeight = weight.getWeightExperimentalTraining();
-//        //取到实验报告权重
-//        BigDecimal reportWeight = weight.getWeightExperimentalReport();
 
+
+    @Async
+    public void personalScoreEntry(StuUser stuUser,String module,TchDigitalTradeWeight weight){
+
+        //每次都重新计算分数   累加写入总成绩字段    只有创建字段
         StuScoreDetailsExample stuScoreDetailsExample=new StuScoreDetailsExample();
-        stuScoreDetailsExample.createCriteria().andUserIdEqualTo(userId).andProjectEqualTo(module);
+        stuScoreDetailsExample.createCriteria().andUserIdEqualTo(stuUser.getUserId()).andProjectEqualTo(module);
         stuScoreDetailsExample.setOrderByClause("serial_number ASC");
         List<StuScoreDetails> scoreDetailsList = stuScoreDetailsMapper.selectByExample(stuScoreDetailsExample);
         double score=0;
-        for (int i = 0; i < scoreDetailsList.size(); i++) {
-//            StuScoreDetails stuScoreDetails = scoreDetailsList.get(i);
-//            if(stuScoreDetails.getLearningProjects().equals(Constant.ZSGY_TCHMODULE)){
-//                stuScoreDetails.setScoringCriteria(String.valueOf(knowledgeScore));
-//                stuScoreDetails.setScoreWeight(Double.parseDouble(String.valueOf(summaryOfKnowledgeWeight)));
-//            }
-//            if(stuScoreDetails.getLearningProjects().equals(Constant.ZYXX_TCHMODULE)){
-//                stuScoreDetails.setScoringCriteria(String.valueOf(resourceLearningScore));
-//                stuScoreDetails.setScoreWeight(Double.parseDouble(String.valueOf(resourceLearningWeight)));
-//            }
-//            if(stuScoreDetails.getLearningProjects().equals(Constant.XXCP_TCHMODULE)){
-//                stuScoreDetails.setScoringCriteria(String.valueOf(learningAssessmentScore));
-//                stuScoreDetails.setScoreWeight(Double.parseDouble(String.valueOf(learningAssessmentWeight)));
-//            }
-//            if(stuScoreDetails.getLearningProjects().equals(Constant.SYSX_TCHMODULE)){
-//                stuScoreDetails.setScoringCriteria(String.valueOf(experimentalTrainingScore));
-//                stuScoreDetails.setScoreWeight(Double.parseDouble(String.valueOf(experimentalTrainingWeight)));
-//            }
-//            if(stuScoreDetails.getLearningProjects().equals(Constant.SYBG_TCHMODULE)){
-//                stuScoreDetails.setScoreWeight(Double.parseDouble(String.valueOf(reportWeight)));
-//            }
-//            stuScoreDetailsMapper.updateByPrimaryKey(stuScoreDetails);
 
+        //不能直接计算所有分数
+        for (int i = 0; i < scoreDetailsList.size(); i++) {
             Double scoreProject = scoreDetailsList.get(i).getScoreProject();
             if (scoreProject==null)
             {
@@ -990,77 +950,119 @@ public class StuExpermentTrainingServiceImpl implements StuExpermentTrainingServ
             score+=mul;
         }
 
+        if (score>100){
+            score=100.0;
+        }else if (score<0){
+            score=0.0;
+        }
+
         //将所属模块总成绩添加到学生表
-        StuUser stuUser = stuUserMapper.selectByPrimaryKey(userId);
+
-//        if (module.equals(Constant.five_G)) {
+        if (module.equals("数字贸易概论")) {
-//            stuUser.setFiveScore(BigDecimal.valueOf(score));
+            stuUser.setIntroductionDigitalTrade(BigDecimal.valueOf(score));
-//        }
+        }
-//        if (module.equals(Constant.ARTIFICIAL_INTELLIGENCE)) {
+        if (module.equals("数字贸易标准和规则")) {
-//            stuUser.setArtificialIntelligenceScore(BigDecimal.valueOf(score));
+            stuUser.setDigitalTradeStandardsRules(BigDecimal.valueOf(score));
-//        }
-//        if (module.equals(Constant.BIG_DATA)) {
-//            stuUser.setBigDataScore(BigDecimal.valueOf(score));
-//        }
-//        if (module.equals(Constant.CLOUD_COMPUTING)) {
-//            stuUser.setCloudComputeScore(BigDecimal.valueOf(score));
-//        }
-//        if (module.equals(Constant.INTERNET_OF_THINGS)) {
-//            stuUser.setInternetOfThingsSocre(BigDecimal.valueOf(score));
-//        }
-//        if (module.equals(Constant.VIRTUAL_REALITY)) {
-//            stuUser.setVirtualRealitySocre(BigDecimal.valueOf(score));
-//        }
-//        if (module.equals(Constant.INDUSTRIAL_INTERNET)) {
-//            stuUser.setIndustrialInternetSocre(BigDecimal.valueOf(score));
-//        }
-//        if (module.equals(Constant.DIGITAL_TRADE)) {
-//            stuUser.setDigitalTradeScore(BigDecimal.valueOf(score));
-//        }
-//        if (module.equals(Constant.DIGITAL_FINANCE)) {
-//            stuUser.setDigitalFinanceScore(BigDecimal.valueOf(score));
-//        }
-//        if (module.equals("碳金融")) {
-//            stuUser.setDigitalGoverSocre(BigDecimal.valueOf(score));
-//        }
-        if (score!=0) {
-            stuUser.setResultsOfPracticalCaseStudies(BigDecimal.valueOf(score));
         }
+        if (module.equals("数字贸易法律法规")) {
+            stuUser.setDigitalTradeLawsRegulations(BigDecimal.valueOf(score));
+        }
+        if (module.equals("数字知识产权保护")) {
+            stuUser.setProtectionDigitalIntellectualProperty(BigDecimal.valueOf(score));
+        }
+        if (module.equals("数字贸易技术")) {
+            stuUser.setDigitalTradeTechnology(BigDecimal.valueOf(score));
+        }
+        if (module.equals("数字贸易物流")) {
+            stuUser.setDigitalTradeLogistics(BigDecimal.valueOf(score));
+        }
+        if (module.equals("数字贸易金融")) {
+            stuUser.setDigitalTradeFinance(BigDecimal.valueOf(score));
+        }
+        if (module.equals("数字产品贸易")) {
+            stuUser.setDigitalProductTrade(BigDecimal.valueOf(score));
+        }
+        if (module.equals("数字技术贸易")) {
+            stuUser.setDigitalTechnologyTrade(BigDecimal.valueOf(score));
+        }
+        if (module.equals("数字服务贸易")) {
+            stuUser.setDigitalServiceTrade(BigDecimal.valueOf(score));
+        }
+        if (module.equals("数据贸易")) {
+            stuUser.setDataTrade(BigDecimal.valueOf(score));
+        }
+        if (module.equals("数字贸易营销")) {
+            stuUser.setDigitalTradeMarketing(BigDecimal.valueOf(score));
+        }
+        if (module.equals("aigc数字运营")) {
+            stuUser.setAigcDigitalOperations(BigDecimal.valueOf(score));
+        }
+
         stuUserMapper.updateByPrimaryKey(stuUser);
-//        //更新数据价值化和数字产业化成绩和产业数字化和数字治理化成绩
+
-//        Double mul;
+        //计算总分
-//        StuUser stuUser1 = stuUserMapper.selectByPrimaryKey(userId);
+        caculateTotalScore(stuUser,weight);
-//        if(module.equals(Constant.DIGITAL_TRADE)||module.equals(Constant.DIGITAL_FINANCE)){
+
-//            BigDecimal digitalTradeScore = stuUser1.getDigitalTradeScore();
+    }
-//            BigDecimal digitalFinanceScore = stuUser1.getDigitalFinanceScore();
+
-//
+
-//            String mul1 = bigDecimalUtils.mul(String.valueOf(digitalTradeScore),String.valueOf(0.5),2);
+    void caculateTotalScore(StuUser stuUser,TchDigitalTradeWeight weight) {
-//            String mul2 = bigDecimalUtils.mul(String.valueOf(digitalFinanceScore), String.valueOf(0.5),2);
+
-//            mul=Double.parseDouble(mul1)+Double.parseDouble(mul2);
+        List<BigDecimal> scores = new ArrayList<>(20);
-//            stuUser1.setIndustryDigitalScore(BigDecimal.valueOf(mul));
+        List<BigDecimal> weights = new ArrayList<>(20);
-//
+
-//        }
+        // 将成绩和权重添加到列表中
-//        if(module.equals(Constant.five_G)||module.equals(Constant.ARTIFICIAL_INTELLIGENCE)||module.equals(Constant.BIG_DATA)||
+        scores.add(stuUser.getIntroductionDigitalTrade());
-//                module.equals(Constant.CLOUD_COMPUTING)|| module.equals(Constant.INTERNET_OF_THINGS)||
+        weights.add(weight.getWeightOne());
-//                module.equals(Constant.VIRTUAL_REALITY)||module.equals(Constant.INDUSTRIAL_INTERNET)) {
+        scores.add(stuUser.getDigitalTradeStandardsRules());
-//            BigDecimal fiveScore = stuUser1.getFiveScore();
+        weights.add(weight.getWeightTwo());
-//            BigDecimal artificialIntelligenceScore = stuUser1.getArtificialIntelligenceScore();
+        scores.add(stuUser.getDigitalTradeLawsRegulations());
-//            BigDecimal bigDataScore = stuUser1.getBigDataScore();
+        weights.add(weight.getWeightThree());
-//            BigDecimal cloudComputeScore = stuUser1.getCloudComputeScore();
+        scores.add(stuUser.getProtectionDigitalIntellectualProperty());
-//            BigDecimal internetOfThingsSocre = stuUser1.getInternetOfThingsSocre();
+        weights.add(weight.getWeightFour());
-//            BigDecimal virtualRealitySocre = stuUser1.getVirtualRealitySocre();
+        scores.add(stuUser.getDigitalTradeTechnology());
-//            BigDecimal industrialInternetSocre = stuUser1.getIndustrialInternetSocre();
+        weights.add(weight.getWeightFive());
-//            String mul1 = bigDecimalUtils.mul(String.valueOf(fiveScore),String.valueOf(0.1),2);
+        scores.add(stuUser.getDigitalTradeLogistics());
-//            String mul2 = bigDecimalUtils.mul(String.valueOf(artificialIntelligenceScore), String.valueOf(0.3),2);
+        weights.add(weight.getWeightSix());
-//            String mul3 = bigDecimalUtils.mul(String.valueOf(bigDataScore),String.valueOf(0.2),2);
+        scores.add(stuUser.getDigitalTradeFinance());
-//            String mul4 = bigDecimalUtils.mul(String.valueOf(cloudComputeScore), String.valueOf(0.1),2);
+        weights.add(weight.getWeightSven());
-//            String mul5 = bigDecimalUtils.mul(String.valueOf(internetOfThingsSocre),String.valueOf(0.1),2);
+        scores.add(stuUser.getDigitalProductTrade());
-//            String mul6 = bigDecimalUtils.mul(String.valueOf(virtualRealitySocre),String.valueOf(0.1),2);
+        weights.add(weight.getWeightEight());
-//            String mul7 = bigDecimalUtils.mul(String.valueOf(industrialInternetSocre),String.valueOf(0.1),2);
+        scores.add(stuUser.getDigitalTechnologyTrade());
-//            mul=Double.parseDouble(mul1)+Double.parseDouble(mul2)+Double.parseDouble(mul3)+Double.parseDouble(mul4)+
+        weights.add(weight.getWeightNine());
-//                    Double.parseDouble(mul5)+Double.parseDouble(mul6)+Double.parseDouble(mul7);
+        scores.add(stuUser.getDigitalServiceTrade());
-//            stuUser1.setDigitalIndustryScore(BigDecimal.valueOf(mul));
+        weights.add(weight.getWeightTen());
-//        }
+        scores.add(stuUser.getDataTrade());
-//        stuUserMapper.updateByPrimaryKey(stuUser1);
+        weights.add(weight.getWeightEleven());
+        scores.add(stuUser.getDigitalTradeMarketing());
+        weights.add(weight.getWeightTwelve());
+        scores.add(stuUser.getAigcDigitalOperations());
+        weights.add(weight.getWeightThirteen());
+
+        // 创建总成绩的变量并初始化为 BigDecimal.ZERO
+        BigDecimal totalScore = BigDecimal.ZERO;
+
+        // 循环计算总成绩
+        for (int i = 0; i < scores.size(); i++) {
+
+            if (scores.get(i)==null)
+            {
+                scores.set(i,BigDecimal.ZERO);
+            }
+
+            BigDecimal score = scores.get(i).multiply(weights.get(i)).setScale(2, BigDecimal.ROUND_HALF_UP);
+            totalScore = totalScore.add(score);
+        }
+
+
+        if (totalScore.compareTo(BigDecimal.valueOf(100)) > 0) {
+            totalScore = BigDecimal.valueOf(100);
+        }
+
+
+        stuUser.setResultsOfPracticalCaseStudies(totalScore);
+        stuUserMapper.updateByPrimaryKey(stuUser);
+
     }
 
 }

src/main/resources/mappers/StuUserMapper.xml

@@ -20,6 +20,19 @@
     <result column="attendance_score" jdbcType="DECIMAL" property="attendanceScore" />
     <result column="exam_results_for_homework_assignments" jdbcType="DECIMAL" property="examResultsForHomeworkAssignments" />
     <result column="results_of_practical_case_studies" jdbcType="DECIMAL" property="resultsOfPracticalCaseStudies" />
+    <result column="introduction_digital_trade" jdbcType="DECIMAL" property="introductionDigitalTrade" />
+    <result column="digital_trade_standards_rules" jdbcType="DECIMAL" property="digitalTradeStandardsRules" />
+    <result column="digital_trade_laws_regulations" jdbcType="DECIMAL" property="digitalTradeLawsRegulations" />
+    <result column="protection_digital_intellectual_property" jdbcType="DECIMAL" property="protectionDigitalIntellectualProperty" />
+    <result column="digital_trade_technology" jdbcType="DECIMAL" property="digitalTradeTechnology" />
+    <result column="digital_trade_logistics" jdbcType="DECIMAL" property="digitalTradeLogistics" />
+    <result column="digital_trade_finance" jdbcType="DECIMAL" property="digitalTradeFinance" />
+    <result column="digital_product_trade" jdbcType="DECIMAL" property="digitalProductTrade" />
+    <result column="digital_technology_trade" jdbcType="DECIMAL" property="digitalTechnologyTrade" />
+    <result column="digital_service_trade" jdbcType="DECIMAL" property="digitalServiceTrade" />
+    <result column="data_trade" jdbcType="DECIMAL" property="dataTrade" />
+    <result column="digital_trade_marketing" jdbcType="DECIMAL" property="digitalTradeMarketing" />
+    <result column="aigc_digital_operations" jdbcType="DECIMAL" property="aigcDigitalOperations" />
   </resultMap>
   <sql id="Example_Where_Clause">
     <where>
@@ -82,7 +95,11 @@
   <sql id="Base_Column_List">
     user_id, student_id, name, password, role_id, class_id, class_name, major, school_id, 
     school_name, total_rank, total_score, create_time, del_state, update_time, attendance_score, 
-    exam_results_for_homework_assignments, results_of_practical_case_studies
+    exam_results_for_homework_assignments, results_of_practical_case_studies, introduction_digital_trade, 
+    digital_trade_standards_rules, digital_trade_laws_regulations, protection_digital_intellectual_property, 
+    digital_trade_technology, digital_trade_logistics, digital_trade_finance, digital_product_trade, 
+    digital_technology_trade, digital_service_trade, data_trade, digital_trade_marketing, 
+    aigc_digital_operations
   </sql>
   <select id="selectByExample" parameterType="com.sztzjy.trade.entity.StuUserExample" resultMap="BaseResultMap">
     select
@@ -121,17 +138,29 @@
       school_name, total_rank, total_score, 
       create_time, del_state, update_time, 
       attendance_score, exam_results_for_homework_assignments, 
-      results_of_practical_case_studies)
+      results_of_practical_case_studies, introduction_digital_trade, 
+      digital_trade_standards_rules, digital_trade_laws_regulations, 
+      protection_digital_intellectual_property, digital_trade_technology, 
+      digital_trade_logistics, digital_trade_finance, 
+      digital_product_trade, digital_technology_trade, 
+      digital_service_trade, data_trade, digital_trade_marketing, 
+      aigc_digital_operations)
     values (#{userId,jdbcType=VARCHAR}, #{studentId,jdbcType=VARCHAR}, #{name,jdbcType=VARCHAR}, 
       #{password,jdbcType=VARCHAR}, #{roleId,jdbcType=INTEGER}, #{classId,jdbcType=VARCHAR}, 
       #{className,jdbcType=VARCHAR}, #{major,jdbcType=VARCHAR}, #{schoolId,jdbcType=VARCHAR}, 
       #{schoolName,jdbcType=VARCHAR}, #{totalRank,jdbcType=INTEGER}, #{totalScore,jdbcType=DECIMAL}, 
       #{createTime,jdbcType=TIMESTAMP}, #{delState,jdbcType=INTEGER}, #{updateTime,jdbcType=TIMESTAMP}, 
       #{attendanceScore,jdbcType=DECIMAL}, #{examResultsForHomeworkAssignments,jdbcType=DECIMAL}, 
-      #{resultsOfPracticalCaseStudies,jdbcType=DECIMAL})
+      #{resultsOfPracticalCaseStudies,jdbcType=DECIMAL}, #{introductionDigitalTrade,jdbcType=DECIMAL}, 
+      #{digitalTradeStandardsRules,jdbcType=DECIMAL}, #{digitalTradeLawsRegulations,jdbcType=DECIMAL}, 
+      #{protectionDigitalIntellectualProperty,jdbcType=DECIMAL}, #{digitalTradeTechnology,jdbcType=DECIMAL}, 
+      #{digitalTradeLogistics,jdbcType=DECIMAL}, #{digitalTradeFinance,jdbcType=DECIMAL}, 
+      #{digitalProductTrade,jdbcType=DECIMAL}, #{digitalTechnologyTrade,jdbcType=DECIMAL}, 
+      #{digitalServiceTrade,jdbcType=DECIMAL}, #{dataTrade,jdbcType=DECIMAL}, #{digitalTradeMarketing,jdbcType=DECIMAL}, 
+      #{aigcDigitalOperations,jdbcType=DECIMAL})
   </insert>
   <insert id="insertSelective" parameterType="com.sztzjy.trade.entity.StuUser">
-    insert IGNORE  into stu_user
+    insert into stu_user
     <trim prefix="(" suffix=")" suffixOverrides=",">
       <if test="userId != null">
         user_id,
@@ -187,6 +216,45 @@
       <if test="resultsOfPracticalCaseStudies != null">
         results_of_practical_case_studies,
       </if>
+      <if test="introductionDigitalTrade != null">
+        introduction_digital_trade,
+      </if>
+      <if test="digitalTradeStandardsRules != null">
+        digital_trade_standards_rules,
+      </if>
+      <if test="digitalTradeLawsRegulations != null">
+        digital_trade_laws_regulations,
+      </if>
+      <if test="protectionDigitalIntellectualProperty != null">
+        protection_digital_intellectual_property,
+      </if>
+      <if test="digitalTradeTechnology != null">
+        digital_trade_technology,
+      </if>
+      <if test="digitalTradeLogistics != null">
+        digital_trade_logistics,
+      </if>
+      <if test="digitalTradeFinance != null">
+        digital_trade_finance,
+      </if>
+      <if test="digitalProductTrade != null">
+        digital_product_trade,
+      </if>
+      <if test="digitalTechnologyTrade != null">
+        digital_technology_trade,
+      </if>
+      <if test="digitalServiceTrade != null">
+        digital_service_trade,
+      </if>
+      <if test="dataTrade != null">
+        data_trade,
+      </if>
+      <if test="digitalTradeMarketing != null">
+        digital_trade_marketing,
+      </if>
+      <if test="aigcDigitalOperations != null">
+        aigc_digital_operations,
+      </if>
     </trim>
     <trim prefix="values (" suffix=")" suffixOverrides=",">
       <if test="userId != null">
@@ -243,6 +311,45 @@
       <if test="resultsOfPracticalCaseStudies != null">
         #{resultsOfPracticalCaseStudies,jdbcType=DECIMAL},
       </if>
+      <if test="introductionDigitalTrade != null">
+        #{introductionDigitalTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTradeStandardsRules != null">
+        #{digitalTradeStandardsRules,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTradeLawsRegulations != null">
+        #{digitalTradeLawsRegulations,jdbcType=DECIMAL},
+      </if>
+      <if test="protectionDigitalIntellectualProperty != null">
+        #{protectionDigitalIntellectualProperty,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTradeTechnology != null">
+        #{digitalTradeTechnology,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTradeLogistics != null">
+        #{digitalTradeLogistics,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTradeFinance != null">
+        #{digitalTradeFinance,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalProductTrade != null">
+        #{digitalProductTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTechnologyTrade != null">
+        #{digitalTechnologyTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalServiceTrade != null">
+        #{digitalServiceTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="dataTrade != null">
+        #{dataTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTradeMarketing != null">
+        #{digitalTradeMarketing,jdbcType=DECIMAL},
+      </if>
+      <if test="aigcDigitalOperations != null">
+        #{aigcDigitalOperations,jdbcType=DECIMAL},
+      </if>
     </trim>
   </insert>
   <select id="countByExample" parameterType="com.sztzjy.trade.entity.StuUserExample" resultType="java.lang.Long">
@@ -308,6 +415,45 @@
       <if test="record.resultsOfPracticalCaseStudies != null">
         results_of_practical_case_studies = #{record.resultsOfPracticalCaseStudies,jdbcType=DECIMAL},
       </if>
+      <if test="record.introductionDigitalTrade != null">
+        introduction_digital_trade = #{record.introductionDigitalTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="record.digitalTradeStandardsRules != null">
+        digital_trade_standards_rules = #{record.digitalTradeStandardsRules,jdbcType=DECIMAL},
+      </if>
+      <if test="record.digitalTradeLawsRegulations != null">
+        digital_trade_laws_regulations = #{record.digitalTradeLawsRegulations,jdbcType=DECIMAL},
+      </if>
+      <if test="record.protectionDigitalIntellectualProperty != null">
+        protection_digital_intellectual_property = #{record.protectionDigitalIntellectualProperty,jdbcType=DECIMAL},
+      </if>
+      <if test="record.digitalTradeTechnology != null">
+        digital_trade_technology = #{record.digitalTradeTechnology,jdbcType=DECIMAL},
+      </if>
+      <if test="record.digitalTradeLogistics != null">
+        digital_trade_logistics = #{record.digitalTradeLogistics,jdbcType=DECIMAL},
+      </if>
+      <if test="record.digitalTradeFinance != null">
+        digital_trade_finance = #{record.digitalTradeFinance,jdbcType=DECIMAL},
+      </if>
+      <if test="record.digitalProductTrade != null">
+        digital_product_trade = #{record.digitalProductTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="record.digitalTechnologyTrade != null">
+        digital_technology_trade = #{record.digitalTechnologyTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="record.digitalServiceTrade != null">
+        digital_service_trade = #{record.digitalServiceTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="record.dataTrade != null">
+        data_trade = #{record.dataTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="record.digitalTradeMarketing != null">
+        digital_trade_marketing = #{record.digitalTradeMarketing,jdbcType=DECIMAL},
+      </if>
+      <if test="record.aigcDigitalOperations != null">
+        aigc_digital_operations = #{record.aigcDigitalOperations,jdbcType=DECIMAL},
+      </if>
     </set>
     <if test="_parameter != null">
       <include refid="Update_By_Example_Where_Clause" />
@@ -332,7 +478,20 @@
       update_time = #{record.updateTime,jdbcType=TIMESTAMP},
       attendance_score = #{record.attendanceScore,jdbcType=DECIMAL},
       exam_results_for_homework_assignments = #{record.examResultsForHomeworkAssignments,jdbcType=DECIMAL},
-      results_of_practical_case_studies = #{record.resultsOfPracticalCaseStudies,jdbcType=DECIMAL}
+      results_of_practical_case_studies = #{record.resultsOfPracticalCaseStudies,jdbcType=DECIMAL},
+      introduction_digital_trade = #{record.introductionDigitalTrade,jdbcType=DECIMAL},
+      digital_trade_standards_rules = #{record.digitalTradeStandardsRules,jdbcType=DECIMAL},
+      digital_trade_laws_regulations = #{record.digitalTradeLawsRegulations,jdbcType=DECIMAL},
+      protection_digital_intellectual_property = #{record.protectionDigitalIntellectualProperty,jdbcType=DECIMAL},
+      digital_trade_technology = #{record.digitalTradeTechnology,jdbcType=DECIMAL},
+      digital_trade_logistics = #{record.digitalTradeLogistics,jdbcType=DECIMAL},
+      digital_trade_finance = #{record.digitalTradeFinance,jdbcType=DECIMAL},
+      digital_product_trade = #{record.digitalProductTrade,jdbcType=DECIMAL},
+      digital_technology_trade = #{record.digitalTechnologyTrade,jdbcType=DECIMAL},
+      digital_service_trade = #{record.digitalServiceTrade,jdbcType=DECIMAL},
+      data_trade = #{record.dataTrade,jdbcType=DECIMAL},
+      digital_trade_marketing = #{record.digitalTradeMarketing,jdbcType=DECIMAL},
+      aigc_digital_operations = #{record.aigcDigitalOperations,jdbcType=DECIMAL}
     <if test="_parameter != null">
       <include refid="Update_By_Example_Where_Clause" />
     </if>
@@ -391,6 +550,45 @@
       <if test="resultsOfPracticalCaseStudies != null">
         results_of_practical_case_studies = #{resultsOfPracticalCaseStudies,jdbcType=DECIMAL},
       </if>
+      <if test="introductionDigitalTrade != null">
+        introduction_digital_trade = #{introductionDigitalTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTradeStandardsRules != null">
+        digital_trade_standards_rules = #{digitalTradeStandardsRules,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTradeLawsRegulations != null">
+        digital_trade_laws_regulations = #{digitalTradeLawsRegulations,jdbcType=DECIMAL},
+      </if>
+      <if test="protectionDigitalIntellectualProperty != null">
+        protection_digital_intellectual_property = #{protectionDigitalIntellectualProperty,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTradeTechnology != null">
+        digital_trade_technology = #{digitalTradeTechnology,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTradeLogistics != null">
+        digital_trade_logistics = #{digitalTradeLogistics,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTradeFinance != null">
+        digital_trade_finance = #{digitalTradeFinance,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalProductTrade != null">
+        digital_product_trade = #{digitalProductTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTechnologyTrade != null">
+        digital_technology_trade = #{digitalTechnologyTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalServiceTrade != null">
+        digital_service_trade = #{digitalServiceTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="dataTrade != null">
+        data_trade = #{dataTrade,jdbcType=DECIMAL},
+      </if>
+      <if test="digitalTradeMarketing != null">
+        digital_trade_marketing = #{digitalTradeMarketing,jdbcType=DECIMAL},
+      </if>
+      <if test="aigcDigitalOperations != null">
+        aigc_digital_operations = #{aigcDigitalOperations,jdbcType=DECIMAL},
+      </if>
     </set>
     where user_id = #{userId,jdbcType=VARCHAR}
   </update>
@@ -412,7 +610,20 @@
       update_time = #{updateTime,jdbcType=TIMESTAMP},
       attendance_score = #{attendanceScore,jdbcType=DECIMAL},
       exam_results_for_homework_assignments = #{examResultsForHomeworkAssignments,jdbcType=DECIMAL},
-      results_of_practical_case_studies = #{resultsOfPracticalCaseStudies,jdbcType=DECIMAL}
+      results_of_practical_case_studies = #{resultsOfPracticalCaseStudies,jdbcType=DECIMAL},
+      introduction_digital_trade = #{introductionDigitalTrade,jdbcType=DECIMAL},
+      digital_trade_standards_rules = #{digitalTradeStandardsRules,jdbcType=DECIMAL},
+      digital_trade_laws_regulations = #{digitalTradeLawsRegulations,jdbcType=DECIMAL},
+      protection_digital_intellectual_property = #{protectionDigitalIntellectualProperty,jdbcType=DECIMAL},
+      digital_trade_technology = #{digitalTradeTechnology,jdbcType=DECIMAL},
+      digital_trade_logistics = #{digitalTradeLogistics,jdbcType=DECIMAL},
+      digital_trade_finance = #{digitalTradeFinance,jdbcType=DECIMAL},
+      digital_product_trade = #{digitalProductTrade,jdbcType=DECIMAL},
+      digital_technology_trade = #{digitalTechnologyTrade,jdbcType=DECIMAL},
+      digital_service_trade = #{digitalServiceTrade,jdbcType=DECIMAL},
+      data_trade = #{dataTrade,jdbcType=DECIMAL},
+      digital_trade_marketing = #{digitalTradeMarketing,jdbcType=DECIMAL},
+      aigc_digital_operations = #{aigcDigitalOperations,jdbcType=DECIMAL}
     where user_id = #{userId,jdbcType=VARCHAR}
   </update>
 
@@ -450,5 +661,4 @@
       </foreach>
     </where>
   </select>
-
 </mapper>