1. 导入时，校验总权重值 == 100%

2. 提交评估内容时，校验总权重优化

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"fmt"
 	"github.com/beego/beego/v2/core/validation"
 	"github.com/beego/beego/v2/core/validation"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
+	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils"
 )
 )
 
 
 type UpdateTemplateCommand struct {
 type UpdateTemplateCommand struct {
@@ -34,7 +35,8 @@ func (in *UpdateTemplateCommand) Valid(validation *validation.Validation) {
 					weightTotal += linkNode.NodeContents[i2].Weight
 					weightTotal += linkNode.NodeContents[i2].Weight
 				}
 				}
 				if weightTotal != 100 {
 				if weightTotal != 100 {
-					validation.SetError("linkNodes", fmt.Sprintf("权重错误，当前%s的总权重值为：%f（必须等于100）", linkNode.Name, weightTotal))
+					formatWeightTotal := utils.FormatFloatDecimal(weightTotal, 2)
+					validation.SetError("linkNodes", fmt.Sprintf("权重错误，当前%s的总权重值为：%s%%（必须等于100%%）", linkNode.Name, formatWeightTotal))
 					return
 					return
 				}
 				}
 			}
 			}

 package controllers
 package controllers
 
 
 import (
 import (
+	"fmt"
+	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils"
 	"strconv"
 	"strconv"
 	"strings"
 	"strings"
 
 
@@ -46,19 +48,22 @@ func (controller *ImportController) Import() {
 		if err != nil {
 		if err != nil {
 			controller.Response(nil, application.ThrowError(application.ARG_ERROR, err.Error()))
 			controller.Response(nil, application.ThrowError(application.ARG_ERROR, err.Error()))
 		}
 		}
-		list := controller.parseTemplateNodeContent(dimensions)
-		controller.Response(tool_funs.SimpleWrapGridMap(int64(len(list)), list), nil)
+		if err, list := controller.parseTemplateNodeContent(dimensions); err != nil {
+			controller.Response(nil, application.ThrowError(application.ARG_ERROR, err.Error()))
+		} else {
+			controller.Response(tool_funs.SimpleWrapGridMap(int64(len(list)), list), nil)
+		}
 	default:
 	default:
 		controller.Response(nil, application.ThrowError(application.ARG_ERROR, "请确认您导入的表单类型"))
 		controller.Response(nil, application.ThrowError(application.ARG_ERROR, "请确认您导入的表单类型"))
 	}
 	}
 }
 }
 
 
-func (controller *ImportController) parseTemplateNodeContent(data []*domain.PerformanceDimension) []*domain.NodeContent {
+func (controller *ImportController) parseTemplateNodeContent(data []*domain.PerformanceDimension) (error, []*domain.NodeContent) {
 	nodeContents := make([]*domain.NodeContent, 0)
 	nodeContents := make([]*domain.NodeContent, 0)
 
 
 	transactionContext, err := factory.StartTransaction()
 	transactionContext, err := factory.StartTransaction()
 	if err != nil {
 	if err != nil {
-		return nodeContents
+		return err, nodeContents
 	}
 	}
 	defer func() {
 	defer func() {
 		transactionContext.RollbackTransaction()
 		transactionContext.RollbackTransaction()
@@ -70,18 +75,18 @@ func (controller *ImportController) parseTemplateNodeContent(data []*domain.Perf
 	ruleRepository := factory.CreateEvaluationRuleRepository(map[string]interface{}{"transactionContext": transactionContext})
 	ruleRepository := factory.CreateEvaluationRuleRepository(map[string]interface{}{"transactionContext": transactionContext})
 	_, rules, err := ruleRepository.Find(map[string]interface{}{"companyId": ua.CompanyId, "sysType": domain.EvaluationSysTypeSystem, "limit": 1})
 	_, rules, err := ruleRepository.Find(map[string]interface{}{"companyId": ua.CompanyId, "sysType": domain.EvaluationSysTypeSystem, "limit": 1})
 	if err != nil {
 	if err != nil {
-		return nodeContents
+		return err, nodeContents
 	}
 	}
 	var ruleId = int64(0)
 	var ruleId = int64(0)
 	if len(rules) == 0 {
 	if len(rules) == 0 {
 		newRule := domain.GenerateSysRule(ua.CompanyId) // 生成一个系统默认规则
 		newRule := domain.GenerateSysRule(ua.CompanyId) // 生成一个系统默认规则
 		if rule, err := ruleRepository.Insert(newRule); err != nil {
 		if rule, err := ruleRepository.Insert(newRule); err != nil {
-			return nodeContents
+			return err, nodeContents
 		} else {
 		} else {
 			ruleId = rule.Id
 			ruleId = rule.Id
 		}
 		}
 		if err := transactionContext.CommitTransaction(); err != nil {
 		if err := transactionContext.CommitTransaction(); err != nil {
-			return nodeContents
+			return err, nodeContents
 		}
 		}
 	} else {
 	} else {
 		ruleId = rules[0].Id
 		ruleId = rules[0].Id
@@ -91,6 +96,7 @@ func (controller *ImportController) parseTemplateNodeContent(data []*domain.Perf
 	evaluatorNames := make([]string, 0)
 	evaluatorNames := make([]string, 0)
 	evaluatorMap := map[string]string{}
 	evaluatorMap := map[string]string{}
 
 
+	weightTotal := 0.0
 	for i := range data {
 	for i := range data {
 		dimension := data[i]
 		dimension := data[i]
 		for i2 := range dimension.PerformanceModule {
 		for i2 := range dimension.PerformanceModule {
@@ -107,6 +113,7 @@ func (controller *ImportController) parseTemplateNodeContent(data []*domain.Perf
 			} else {
 			} else {
 				nc.Weight = 0
 				nc.Weight = 0
 			}
 			}
+			weightTotal += nc.Weight                     // 总权重
 			nc.PromptTitle = ""                          // 提示项标题
 			nc.PromptTitle = ""                          // 提示项标题
 			nc.PromptText = module.Standard              // 提示项内容
 			nc.PromptText = module.Standard              // 提示项内容
 			nc.EntryItems = make([]*domain.EntryItem, 0) // 输入项
 			nc.EntryItems = make([]*domain.EntryItem, 0) // 输入项
@@ -132,7 +139,6 @@ func (controller *ImportController) parseTemplateNodeContent(data []*domain.Perf
 			if module.Evaluator == "HRBP" {
 			if module.Evaluator == "HRBP" {
 				nc.EvaluatorId = -1
 				nc.EvaluatorId = -1
 			} else {
 			} else {
-
 				if len(module.Evaluator) > 0 {
 				if len(module.Evaluator) > 0 {
 					evaluatorNames = append(evaluatorNames, module.Evaluator) // 项目评估人名称数组
 					evaluatorNames = append(evaluatorNames, module.Evaluator) // 项目评估人名称数组
 					evaluatorMap[nc.Category+nc.Name] = module.Evaluator      // k,v = (类别+名称, 项目评估人名称)
 					evaluatorMap[nc.Category+nc.Name] = module.Evaluator      // k,v = (类别+名称, 项目评估人名称)
@@ -143,11 +149,17 @@ func (controller *ImportController) parseTemplateNodeContent(data []*domain.Perf
 		}
 		}
 	}
 	}
 
 
+	// 权重总数不等于100%，提示报错
+	if weightTotal != 100 {
+		sprintf := fmt.Sprintf("当前导入的总权重值为：%s%%（必须等于100%%）", utils.FormatFloatDecimal(weightTotal, 2))
+		return application.ThrowError(application.INTERNAL_SERVER_ERROR, sprintf), nodeContents
+	}
+
 	if len(evaluatorNames) > 0 {
 	if len(evaluatorNames) > 0 {
 		userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
 		userRepository := factory.CreateUserRepository(map[string]interface{}{"transactionContext": transactionContext})
 		_, users, err := userRepository.Find(map[string]interface{}{"companyId": ua.CompanyId, "names": evaluatorNames})
 		_, users, err := userRepository.Find(map[string]interface{}{"companyId": ua.CompanyId, "names": evaluatorNames})
 		if err != nil {
 		if err != nil {
-			return nodeContents
+			return err, nodeContents
 		}
 		}
 		nameIdMap := map[string]int64{}
 		nameIdMap := map[string]int64{}
 		for i := range users {
 		for i := range users {
@@ -169,5 +181,5 @@ func (controller *ImportController) parseTemplateNodeContent(data []*domain.Perf
 		}
 		}
 	}
 	}
 
 
-	return nodeContents
+	return nil, nodeContents
 }
 }

@@ -7,6 +7,7 @@ import (
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
 	"math"
 	"math"
 	"reflect"
 	"reflect"
+	"strconv"
 	"strings"
 	"strings"
 	"time"
 	"time"
 )
 )
@@ -36,6 +37,16 @@ func ValidateCommand(commandType interface{}) error {
 	return nil
 	return nil
 }
 }
 
 
+// FormatFloatDecimal 格式化小数点位数
+func FormatFloatDecimal(num float64, decimal int) string {
+	d := float64(1)
+	if decimal > 0 {
+		d = math.Pow10(decimal) // 10的N次方
+	}
+	// math.trunc作用就是返回浮点数的整数部分
+	return strconv.FormatFloat(math.Trunc(num*d)/d, 'f', -1, 64)
+}
+
 // NextTime 0点时刻为标准计算
 // NextTime 0点时刻为标准计算
 func NextTime(now0 time.Time, start time.Time, kpiCycle int) time.Time {
 func NextTime(now0 time.Time, start time.Time, kpiCycle int) time.Time {
 	year, month, day := start.Date()
 	year, month, day := start.Date()