updates

server/modules/yx/entity/yx_history_score_control_line.go

@@ -5,12 +5,12 @@ import "time"
 // YxHistoryScoreControlLine 历年各专业省控分数线实体
 type YxHistoryScoreControlLine struct {
 	ID                   string    `gorm:"column:id;primaryKey" json:"id"`
-	Year                 string    `gorm:"column:year" json:"year"`                                 // 年份
+	Year                 string    `gorm:"column:year" json:"year"`                                  // 年份
 	ProfessionalCategory string    `gorm:"column:professional_category" json:"professionalCategory"` // 专业类别
-	Category             string    `gorm:"column:category" json:"category"`                         // 文理科
+	Category             string    `gorm:"column:category" json:"category"`                          // 文理科
-	Batch                string    `gorm:"column:batch" json:"batch"`                               // 批次
+	Batch                string    `gorm:"column:batch" json:"batch"`                                // 批次
-	CulturalScore        float64   `gorm:"column:cultural_score" json:"culturalScore"`              // 文化分
+	CulturalScore        float64   `gorm:"column:cultural_score" json:"culturalScore"`               // 文化分
-	SpecialScore         float64   `gorm:"column:special_score" json:"specialScore"`                // 专业分
+	SpecialScore         float64   `gorm:"column:special_score" json:"specialScore"`                 // 专业分
 	CreateBy             string    `gorm:"column:create_by" json:"createBy"`
 	CreateTime           time.Time `gorm:"column:create_time" json:"createTime"`
 	UpdateBy             string    `gorm:"column:update_by" json:"updateBy"`
@@ -18,5 +18,5 @@ type YxHistoryScoreControlLine struct {
 }
 
 func (YxHistoryScoreControlLine) TableName() string {
-	return "yx_history_score_control_line"
+	return "yx_history_score_control_line_new"
 }

server/modules/yx/mapper/yx_calculation_major_mapper.go

@@ -81,6 +81,11 @@ func (m *YxCalculationMajorMapper) FindRecommendList(query dto.SchoolMajorQuery)
 		params = append(params, query.MainSubjects)
 	}
 
+	if query.Keyword != "" {
+		baseSQL += " AND cm.major_name like ?"
+		params = append(params, query.Keyword)
+	}
+
 	// 3. 优化后的总数量COUNT SQL
 	countSQL := fmt.Sprintf(`
 		SELECT COUNT(cm.id) FROM %s cm

server/modules/yx/mapper/yx_history_score_control_line_mapper.go

@@ -13,9 +13,21 @@ func NewYxHistoryScoreControlLineMapper() *YxHistoryScoreControlLineMapper {
 
 func (m *YxHistoryScoreControlLineMapper) SelectByYearAndCategory(year, professionalCategory, category string) ([]entity.YxHistoryScoreControlLine, error) {
 	var items []entity.YxHistoryScoreControlLine
+	// 判断是否为表演类，如果是则匹配多个类别
+	var categories []string
+	switch professionalCategory {
+	case "表演类":
+		categories = []string{"表演类-戏剧影视表演", "表演类-服装表演", "表演类-戏剧影视导演"}
+		// fallthrough  // 继续执行下面的case
+	case "音乐类":
+		categories = []string{"音乐类-音乐表演声乐", "音乐类-音乐表演器乐", "音乐类-音乐教育"}
+	default:
+		categories = []string{professionalCategory}
+	}
+
 	err := config.DB.Model(&entity.YxHistoryScoreControlLine{}).
 		Where("year = ?", year).
-		Where("professional_category = ?", professionalCategory).
+		Where("professional_category IN ?", categories).
 		Where("category = ?", category).
 		Order("batch desc").
 		Find(&items).Error

server/modules/yx/service/yx_calculation_major_service.go

@@ -27,7 +27,7 @@ type YxCalculationMajorService struct {
 func NewYxCalculationMajorService() *YxCalculationMajorService {
 	mapper := mapper.NewYxCalculationMajorMapper()
 	return &YxCalculationMajorService{
-		BaseService:                   common.NewBaseService[entity.YxCalculationMajor](),
+		BaseService:                    common.NewBaseService[entity.YxCalculationMajor](),
 		historyMajorEnrollService:      NewYxHistoryMajorEnrollService(),
 		mapper:                         mapper,
 		historyScoreControlLineService: NewYxHistoryScoreControlLineService(),
@@ -311,17 +311,268 @@ func (s *YxCalculationMajorService) UserMajorDTOGetHistory(userMajorDTOList *[]d
 func (s *YxCalculationMajorService) CheckEnrollProbability(schoolMajorDTOList *[]dto.SchoolMajorDTO, userScoreVO vo.UserScoreVO) error {
 	professionalCategory := userScoreVO.ProfessionalCategory
 	if "表演类" == professionalCategory {
-		// TODO: biaoyanService
+		s.BiaoYanRecommendMajorListSetEnrollProbability(schoolMajorDTOList, userScoreVO)
 	} else if "音乐类" == professionalCategory {
-		// TODO: musicService
+		s.YinYueRecommendMajorListSetEnrollProbability(schoolMajorDTOList, userScoreVO)
 	} else {
-		s.betaRecommendMajorListSetEnrollProbability(schoolMajorDTOList, userScoreVO)
+		s.BetaRecommendMajorListSetEnrollProbability(schoolMajorDTOList, userScoreVO)
 	}
 	return nil
 }
 
-// betaRecommendMajorListSetEnrollProbability 美术与设计类，书法类，体育类 获取录取率
+// BiaoYanRecommendMajorListSetEnrollProbability 表演类 获取录取率
-func (s *YxCalculationMajorService) betaRecommendMajorListSetEnrollProbability(recommendMajorList *[]dto.SchoolMajorDTO, userScoreVO vo.UserScoreVO) {
+func (s *YxCalculationMajorService) BiaoYanRecommendMajorListSetEnrollProbability(recommendMajorList *[]dto.SchoolMajorDTO, userScoreVO vo.UserScoreVO) {
+	if recommendMajorList == nil || len(*recommendMajorList) == 0 {
+		return
+	}
+	professionalCategory := userScoreVO.ProfessionalCategory
+	nowBatch := "本科"
+
+	// 获取省控线 Map
+	historyScoreControlLineMap, err := s.historyScoreControlLineService.MapsBatchByProfessionalCategoryOfYear(common.NowYear, professionalCategory, userScoreVO.CognitioPolyclinic)
+	if err != nil {
+		return
+	}
+
+	culturalScore := userScoreVO.CulturalScore
+	professionalScore := userScoreVO.ProfessionalScore
+
+	var nowMajorTypeChild string
+	var batchKey string
+	for i := range *recommendMajorList {
+		item := &(*recommendMajorList)[i]
+
+		rulesEnrollProbability := item.PrivateRulesEnrollProbability
+		probabilityOperator := item.PrivateProbabilityOperator
+
+		// 当前子类型
+		nowMajorTypeChild = item.MajorTypeChild
+		// 整合为 表演类-XXX子类型
+		batchKey = professionalCategory + "-" + nowMajorTypeChild + "_" + item.Batch
+
+		// 获取对应批次的省控线
+		controlLineData, ok := historyScoreControlLineMap[batchKey]
+		if !ok {
+			if val, okDefault := historyScoreControlLineMap["本科"]; okDefault {
+				controlLineData = val
+			} else {
+				continue
+			}
+		}
+
+		// 判断子类型，使用对应的成绩进行计算
+		professionalScore = userScoreVO.ProfessionalCategoryChildrenScore[item.MajorTypeChild]
+
+		culturalControlLine := controlLineData.CulturalScore
+		specialControlLine := controlLineData.SpecialScore
+
+		if rulesEnrollProbability == "" {
+			continue
+		}
+
+		// 补全 probabilityOperator 逻辑
+		if rulesEnrollProbability == "文过专排" && probabilityOperator == "" {
+			probabilityOperator = "文*0+专*1"
+		} else if rulesEnrollProbability == "专过文排" && probabilityOperator == "" {
+			probabilityOperator = "文*1+专*0"
+		}
+
+		if probabilityOperator == "" {
+			item.EnrollProbability = common.Number5
+			continue
+		}
+
+		// 判断其他录取要求
+		if !calc.OtherScoreJudge(professionalScore, userScoreVO, *item) {
+			item.EnrollProbability = common.Number0
+			continue
+		}
+
+		// 判断是否过省控线
+		if !calc.CrossingControlLine(rulesEnrollProbability, culturalScore, professionalScore, culturalControlLine, specialControlLine) {
+			item.EnrollProbability = common.Number0
+			continue
+		}
+
+		// 计算学生折合分
+		studentScore := calc.ConvertIntoScore(rulesEnrollProbability, culturalScore, professionalScore, probabilityOperator)
+		item.PrivateStudentScore = studentScore
+		item.StudentScore = studentScore
+
+		// 权限检查
+		if !calc.HasComputeEnrollProbabilityPermissions(nowBatch, item.Batch) {
+			item.EnrollProbability = common.Number0
+			continue
+		}
+
+		// 录取方式计算
+		if common.CulturalControlLineGuoMain == rulesEnrollProbability {
+			if len(item.HistoryMajorEnrollList) == 0 {
+				item.EnrollProbability = common.Number0
+				continue
+			}
+			item.EnrollProbability = (studentScore * item.HistoryMajorEnrollList[0].AdmissionLine) * common.Number0p75
+			if studentScore >= item.HistoryMajorEnrollList[0].AdmissionLine {
+				item.EnrollProbability *= common.Number0p5
+			}
+			continue
+		} else {
+			nowYearProvincialControlLine := calc.ConvertIntoScore(rulesEnrollProbability, culturalControlLine, specialControlLine, probabilityOperator)
+			if nowYearProvincialControlLine <= 0 {
+				item.EnrollProbability = common.Number0
+				continue
+			}
+
+			diffMap := calc.ComputeHistoryMajorEnrollScoreLineDifferenceWithRulesEnrollProbability(item.MajorType, rulesEnrollProbability, probabilityOperator, item.HistoryMajorEnrollMap)
+			historyThreeYearDiff := diffMap["scoreDifference"].(float64)
+
+			if historyThreeYearDiff == 0 {
+				item.EnrollProbability = common.Number0
+				continue
+			}
+
+			nowYearDiff := studentScore - nowYearProvincialControlLine
+
+			enrollProbability := calc.CommonCheckEnrollProbability(nowYearDiff, historyThreeYearDiff)
+			item.EnrollProbability = calc.CommonCheckEnrollProbabilityBeilv(enrollProbability)
+		}
+	}
+}
+
+// YinYueRecommendMajorListSetEnrollProbability 音乐类 获取录取率
+func (s *YxCalculationMajorService) YinYueRecommendMajorListSetEnrollProbability(recommendMajorList *[]dto.SchoolMajorDTO, userScoreVO vo.UserScoreVO) {
+	if recommendMajorList == nil || len(*recommendMajorList) == 0 {
+		return
+	}
+	professionalCategory := userScoreVO.ProfessionalCategory
+	nowBatch := "本科"
+
+	// 获取省控线 Map
+	historyScoreControlLineMap, err := s.historyScoreControlLineService.MapsBatchByProfessionalCategoryOfYear(common.NowYear, professionalCategory, userScoreVO.CognitioPolyclinic)
+	if err != nil {
+		return
+	}
+
+	culturalScore := userScoreVO.CulturalScore
+	professionalScore := userScoreVO.ProfessionalScore
+
+	var rulesEnrollProbability string
+	var probabilityOperator string
+	var nowMajorTypeChild string
+	var batchKey string
+	for i := range *recommendMajorList {
+		item := &(*recommendMajorList)[i]
+
+		rulesEnrollProbability = item.PrivateRulesEnrollProbability
+		probabilityOperator = item.PrivateProbabilityOperator
+
+		// 当前子类型
+		nowMajorTypeChild = item.MajorTypeChild
+
+		// 主考科目
+		if "音乐表演" == nowMajorTypeChild {
+			nowMajorTypeChild += item.MainSubjects
+		}
+
+		// 整合为 表演类-XXX子类型
+		if "高职高专" == item.Batch {
+			batchKey = professionalCategory + "-" + nowMajorTypeChild + "_" + item.Batch
+		} else {
+			batchKey = professionalCategory + "-" + nowMajorTypeChild + "_本科"
+		}
+
+		// 获取对应批次的省控线
+		controlLineData, ok := historyScoreControlLineMap[batchKey]
+		if !ok {
+			continue
+			// if val, okDefault := historyScoreControlLineMap["本科"]; okDefault {
+			// 	controlLineData = val
+			// } else {
+			// 	continue
+			// }
+		}
+
+		// 判断子类型，使用对应的成绩进行计算
+		professionalScore = userScoreVO.ProfessionalCategoryChildrenScore[nowMajorTypeChild]
+
+		culturalControlLine := controlLineData.CulturalScore
+		specialControlLine := controlLineData.SpecialScore
+
+		if rulesEnrollProbability == "" {
+			continue
+		}
+
+		// 补全 probabilityOperator 逻辑
+		if rulesEnrollProbability == "文过专排" && probabilityOperator == "" {
+			probabilityOperator = "文*0+专*1"
+		} else if rulesEnrollProbability == "专过文排" && probabilityOperator == "" {
+			probabilityOperator = "文*1+专*0"
+		}
+
+		if probabilityOperator == "" {
+			item.EnrollProbability = common.Number5
+			continue
+		}
+
+		// 判断其他录取要求
+		if !calc.OtherScoreJudge(professionalScore, userScoreVO, *item) {
+			item.EnrollProbability = common.Number0
+			continue
+		}
+
+		// 判断是否过省控线
+		if !calc.CrossingControlLine(rulesEnrollProbability, culturalScore, professionalScore, culturalControlLine, specialControlLine) {
+			item.EnrollProbability = common.Number0
+			continue
+		}
+
+		// 计算学生折合分
+		studentScore := calc.ConvertIntoScore(rulesEnrollProbability, culturalScore, professionalScore, probabilityOperator)
+		item.PrivateStudentScore = studentScore
+		item.StudentScore = studentScore
+
+		// 权限检查
+		if !calc.HasComputeEnrollProbabilityPermissions(nowBatch, item.Batch) {
+			item.EnrollProbability = common.Number0
+			continue
+		}
+
+		// 录取方式计算
+		if common.CulturalControlLineGuoMain == rulesEnrollProbability {
+			if len(item.HistoryMajorEnrollList) == 0 {
+				item.EnrollProbability = common.Number0
+				continue
+			}
+			item.EnrollProbability = (studentScore * item.HistoryMajorEnrollList[0].AdmissionLine) * common.Number0p75
+			if studentScore >= item.HistoryMajorEnrollList[0].AdmissionLine {
+				item.EnrollProbability *= common.Number0p5
+			}
+			continue
+		} else {
+			nowYearProvincialControlLine := calc.ConvertIntoScore(rulesEnrollProbability, culturalControlLine, specialControlLine, probabilityOperator)
+			if nowYearProvincialControlLine <= 0 {
+				item.EnrollProbability = common.Number0
+				continue
+			}
+
+			diffMap := calc.ComputeHistoryMajorEnrollScoreLineDifferenceWithRulesEnrollProbability(item.MajorType, rulesEnrollProbability, probabilityOperator, item.HistoryMajorEnrollMap)
+			historyThreeYearDiff := diffMap["scoreDifference"].(float64)
+
+			if historyThreeYearDiff == 0 {
+				item.EnrollProbability = common.Number0
+				continue
+			}
+
+			nowYearDiff := studentScore - nowYearProvincialControlLine
+
+			enrollProbability := calc.CommonCheckEnrollProbability(nowYearDiff, historyThreeYearDiff)
+			item.EnrollProbability = calc.CommonCheckEnrollProbabilityBeilv(enrollProbability)
+		}
+	}
+}
+
+// BetaRecommendMajorListSetEnrollProbability 美术与设计类，书法类，体育类 获取录取率
+func (s *YxCalculationMajorService) BetaRecommendMajorListSetEnrollProbability(recommendMajorList *[]dto.SchoolMajorDTO, userScoreVO vo.UserScoreVO) {
 	if recommendMajorList == nil || len(*recommendMajorList) == 0 {
 		return
 	}
@@ -474,28 +725,28 @@ func (s *YxCalculationMajorService) GetCalculationMajorByID(id string) (*yxVO.Yx
 func (s *YxCalculationMajorService) CreateCalculationMajor(req *yxDto.CreateCalculationMajorRequest) (*yxVO.YxCalculationMajorVO, error) {
 	// DTO 转 Entity - 只使用 Entity 中存在的字段
 	entityItem := &entity.YxCalculationMajor{
-		ID:                           uuid.New().String(),
+		ID:                       uuid.New().String(),
-		SchoolCode:                   req.SchoolCode,
+		SchoolCode:               req.SchoolCode,
-		MajorCode:                    req.MajorCode,
+		MajorCode:                req.MajorCode,
-		MajorName:                    req.MajorName,
+		MajorName:                req.MajorName,
-		MajorType:                    req.MajorType,
+		MajorType:                req.MajorType,
-		MajorTypeChild:               req.MajorTypeChild,
+		MajorTypeChild:           req.MajorTypeChild,
-		PlanNum:                      req.PlanNum,
+		PlanNum:                  req.PlanNum,
-		MainSubjects:                 req.MainSubjects,
+		MainSubjects:             req.MainSubjects,
-		Limitation:                   req.Limitation,
+		Limitation:               req.Limitation,
-		EnrollmentCode:               req.EnrollmentCode,
+		EnrollmentCode:           req.EnrollmentCode,
-		Tuition:                      req.Tuition,
+		Tuition:                  req.Tuition,
-		Detail:                       req.Detail,
+		Detail:                   req.Detail,
-		Category:                     req.Category,
+		Category:                 req.Category,
-		Batch:                        req.Batch,
+		Batch:                    req.Batch,
-		RulesEnrollProbability:       req.RulesEnrollProbability,
+		RulesEnrollProbability:   req.RulesEnrollProbability,
-		ProbabilityOperator:          req.ProbabilityOperator,
+		ProbabilityOperator:      req.ProbabilityOperator,
-		Kslx:                         req.Kslx,
+		Kslx:                     req.Kslx,
-		State:                        req.State,
+		State:                    req.State,
-		EnrollProbability:            req.EnrollProbability,
+		EnrollProbability:        req.EnrollProbability,
-		StudentConvertedScore:        req.StudentScore,
+		StudentConvertedScore:    req.StudentScore,
-		RulesEnrollProbabilitySx:     req.RulesEnrollProbability,
+		RulesEnrollProbabilitySx: req.RulesEnrollProbability,
-		CreateTime:                   time.Now(),
+		CreateTime:               time.Now(),
 	}
 
 	// 注意：分数限制字段存储在 OtherScoreLimitation 中，需要单独处理
@@ -516,7 +767,7 @@ func (s *YxCalculationMajorService) CreateCalculationMajor(req *yxDto.CreateCalc
 		entityItem.OtherScoreLimitation = strings.Join(otherLimitations, ",")
 	}
 
-// 保存到数据库
+	// 保存到数据库
 	if err := s.Create(entityItem); err != nil {
 		return nil, err
 	}
@@ -628,28 +879,28 @@ func (s *YxCalculationMajorService) BatchCreateCalculationMajors(reqs *[]yxDto.C
 	for _, req := range *reqs {
 		// DTO 转 Entity - 只使用 Entity 中存在的字段
 		entityItem := entity.YxCalculationMajor{
-			ID:                           uuid.New().String(),
+			ID:                       uuid.New().String(),
-			SchoolCode:                   req.SchoolCode,
+			SchoolCode:               req.SchoolCode,
-			MajorCode:                    req.MajorCode,
+			MajorCode:                req.MajorCode,
-			MajorName:                    req.MajorName,
+			MajorName:                req.MajorName,
-			MajorType:                    req.MajorType,
+			MajorType:                req.MajorType,
-			MajorTypeChild:               req.MajorTypeChild,
+			MajorTypeChild:           req.MajorTypeChild,
-			PlanNum:                      req.PlanNum,
+			PlanNum:                  req.PlanNum,
-			MainSubjects:                 req.MainSubjects,
+			MainSubjects:             req.MainSubjects,
-			Limitation:                   req.Limitation,
+			Limitation:               req.Limitation,
-			EnrollmentCode:               req.EnrollmentCode,
+			EnrollmentCode:           req.EnrollmentCode,
-			Tuition:                      req.Tuition,
+			Tuition:                  req.Tuition,
-			Detail:                       req.Detail,
+			Detail:                   req.Detail,
-			Category:                     req.Category,
+			Category:                 req.Category,
-			Batch:                        req.Batch,
+			Batch:                    req.Batch,
-			RulesEnrollProbability:       req.RulesEnrollProbability,
+			RulesEnrollProbability:   req.RulesEnrollProbability,
-			ProbabilityOperator:          req.ProbabilityOperator,
+			ProbabilityOperator:      req.ProbabilityOperator,
-			Kslx:                         req.Kslx,
+			Kslx:                     req.Kslx,
-			State:                        req.State,
+			State:                    req.State,
-			EnrollProbability:            req.EnrollProbability,
+			EnrollProbability:        req.EnrollProbability,
-			StudentConvertedScore:        req.StudentScore,
+			StudentConvertedScore:    req.StudentScore,
-			RulesEnrollProbabilitySx:     req.RulesEnrollProbability,
+			RulesEnrollProbabilitySx: req.RulesEnrollProbability,
-			CreateTime:                   now,
+			CreateTime:               now,
 		}
 
 		// 处理分数限制字段
@@ -679,30 +930,30 @@ func (s *YxCalculationMajorService) BatchCreateCalculationMajors(reqs *[]yxDto.C
 // convertToVO Entity 转 VO（私有方法）
 func (s *YxCalculationMajorService) convertToVO(entity entity.YxCalculationMajor) *yxVO.YxCalculationMajorVO {
 	vo := &yxVO.YxCalculationMajorVO{
-		ID:                           entity.ID,
+		ID:                     entity.ID,
-		SchoolCode:                   entity.SchoolCode,
+		SchoolCode:             entity.SchoolCode,
-		MajorCode:                    entity.MajorCode,
+		MajorCode:              entity.MajorCode,
-		MajorName:                    entity.MajorName,
+		MajorName:              entity.MajorName,
-		MajorType:                    entity.MajorType,
+		MajorType:              entity.MajorType,
-		MajorTypeChild:               entity.MajorTypeChild,
+		MajorTypeChild:         entity.MajorTypeChild,
-		PlanNum:                      entity.PlanNum,
+		PlanNum:                entity.PlanNum,
-		MainSubjects:                 entity.MainSubjects,
+		MainSubjects:           entity.MainSubjects,
-		Limitation:                   entity.Limitation,
+		Limitation:             entity.Limitation,
-		EnrollmentCode:               entity.EnrollmentCode,
+		EnrollmentCode:         entity.EnrollmentCode,
-		Tuition:                      entity.Tuition,
+		Tuition:                entity.Tuition,
-		Detail:                       entity.Detail,
+		Detail:                 entity.Detail,
-		Category:                     entity.Category,
+		Category:               entity.Category,
-		Batch:                        entity.Batch,
+		Batch:                  entity.Batch,
-		RulesEnrollProbability:       entity.RulesEnrollProbability,
+		RulesEnrollProbability: entity.RulesEnrollProbability,
-		ProbabilityOperator:          entity.ProbabilityOperator,
+		ProbabilityOperator:    entity.ProbabilityOperator,
-		Kslx:                         entity.Kslx,
+		Kslx:                   entity.Kslx,
-		State:                        entity.State,
+		State:                  entity.State,
-		EnrollProbability:            entity.EnrollProbability,
+		EnrollProbability:      entity.EnrollProbability,
-		StudentScore:                 entity.StudentConvertedScore,
+		StudentScore:           entity.StudentConvertedScore,
-		PrivateStudentScore:          entity.PrivateStudentConvertedScore,
+		PrivateStudentScore:    entity.PrivateStudentConvertedScore,
-		StudentConvertedScore:        entity.StudentConvertedScore,
+		StudentConvertedScore:  entity.StudentConvertedScore,
-		CreateTime:                   entity.CreateTime.Format("2006-01-02 15:04:05"),
+		CreateTime:             entity.CreateTime.Format("2006-01-02 15:04:05"),
-		UpdateTime:                   "",
+		UpdateTime:             "",
 	}
 	// 注意：SchoolName, ChineseScoreLimitation 等字段需要从关联表或其他来源获取
 	// 这里设置为空字符串

server/modules/yx/service/yx_history_score_control_line_service.go

@@ -23,14 +23,25 @@ func (s *YxHistoryScoreControlLineService) MapsBatchByProfessionalCategoryOfYear
 	}
 
 	result := make(map[string]entity.YxHistoryScoreControlLine)
-	for _, item := range list {
+
-		// 复制对象逻辑，处理"本科A段"映射为"提前批"
+	switch professionalCategory {
-		if item.Batch == "本科A段" {
+	case "表演类":
-			newItem := item
+		fallthrough
-			newItem.Batch = "提前批"
+	case "音乐类":
-			result[newItem.Batch] = newItem
+		for _, item := range list {
+			result[item.ProfessionalCategory+"_"+item.Batch] = item
+		}
+	default:
+		for _, item := range list {
+			// 复制对象逻辑，处理"本科A段"映射为"提前批"
+			if item.Batch == "本科A段" {
+				newItem := item
+				newItem.Batch = "提前批"
+				result[newItem.Batch] = newItem
+			}
+			result[item.Batch] = item
 		}
-		result[item.Batch] = item
 	}
+
 	return result, nil
 }