golang-yitisheng-server/server/modules/yx/service/yx_volunteer_service.go

// Package service 业务逻辑层
package service

import (
	"fmt"
	"server/common"
	userVO "server/modules/user/vo"
	"server/modules/yx/dto"
	"server/modules/yx/entity"
	"server/modules/yx/mapper"
	yxVO "server/modules/yx/vo"
	"time"
)

// ScoreService 定义成绩服务的接口，用于解耦
type ScoreService interface {
	GetByID(id string) (userVO.UserScoreVO, error)
	GetActiveScoreByID(userID string) (entity.YxUserScore, error)
	GetActiveScoreID(userID string) (string, error)
	UpdateFields(id string, fields map[string]interface{}) error
	Delete(id string) error
}

type YxVolunteerService struct {
	*common.BaseService[entity.YxVolunteer]
	mapper                *mapper.YxVolunteerMapper
	volunteerRecordMapper *mapper.YxVolunteerRecordMapper
}

func NewYxVolunteerService() *YxVolunteerService {
	return &YxVolunteerService{
		BaseService:           common.NewBaseService[entity.YxVolunteer](),
		mapper:                mapper.NewYxVolunteerMapper(),
		volunteerRecordMapper: mapper.NewYxVolunteerRecordMapper(),
	}
}

// FindActiveByScoreId 根据 scoreId 查找激活的志愿单
func (s *YxVolunteerService) FindActiveByScoreId(scoreId string) (*entity.YxVolunteer, error) {
	return s.mapper.FindActiveByScoreId(scoreId)
}

// CreateByScoreId 根据 ScoreId 创建新志愿表
func (s *YxVolunteerService) CreateByScoreId(scoreId string, userId string) error {
	volunteer := entity.YxVolunteer{}
	volunteer.ID = common.GenerateStringID()
	// 志愿表名称格式 时间戳 20260101134501志愿表
	volunteer.VolunteerName = time.Now().Format("20060102150405") + "志愿表"

	volunteer.ScoreId = scoreId
	volunteer.CreateType = "1"
	volunteer.State = "1"
	volunteer.CreateBy = userId
	volunteer.CreateTime = time.Now()
	volunteer.UpdateTime = time.Now()

	// 先关闭当前用户其他志愿单
	if err := s.mapper.CloseOtherVolunteer(userId); err != nil {
		return fmt.Errorf("关闭其他志愿表失败: %w", err)
	}
	// 创建志愿表
	return s.mapper.Create(&volunteer)
}

// CreateVolunteer 创建志愿并返回 VO
func (s *YxVolunteerService) CreateVolunteer(req *dto.CreateVolunteerRequest) (*yxVO.YxVolunteerVO, error) {
	// DTO 转 Entity
	entityItem := &entity.YxVolunteer{
		ID:            common.GenerateStringID(),
		VolunteerName: req.VolunteerName,
		ScoreId:       req.ScoreId,
		CreateType:    req.CreateType,
		State:         "0", // 默认未激活
		CreateTime:    time.Now(),
		UpdateTime:    time.Now(),
	}
	if req.CreateType == "" {
		entityItem.CreateType = "1" // 默认手动生成
	}

	if err := s.mapper.Create(entityItem); err != nil {
		return nil, fmt.Errorf("创建志愿失败: %w", err)
	}

	return s.convertToVO(*entityItem), nil
}

// UpdateVolunteer 更新志愿并返回 VO
func (s *YxVolunteerService) UpdateVolunteer(id string, req *dto.UpdateVolunteerRequest) (*yxVO.YxVolunteerVO, error) {
	// 获取原数据
	entityItemPtr, err := s.GetByID(id)
	if err != nil {
		return nil, fmt.Errorf("志愿不存在: %w", err)
	}

	// 更新字段
	updateFields := make(map[string]interface{})
	if req.VolunteerName != "" {
		updateFields["volunteer_name"] = req.VolunteerName
	}
	if req.State != "" {
		updateFields["state"] = req.State
	}
	updateFields["update_time"] = time.Now()

	if err := s.mapper.UpdateFields(id, updateFields); err != nil {
		return nil, fmt.Errorf("更新志愿失败: %w", err)
	}

	// 重新获取更新后的数据
	entityItemPtr, err = s.GetByID(id)
	if err != nil {
		return nil, fmt.Errorf("获取更新后数据失败: %w", err)
	}

	return s.convertToVO(*entityItemPtr), nil
}

// UpdateName 更新志愿表名称
func (s *YxVolunteerService) UpdateName(id, name, userID string) error {
	volunteer, err := s.GetByID(id)
	if err != nil {
		return err
	}
	if volunteer.CreateBy != userID {
		return fmt.Errorf("无权修改该志愿单")
	}
	return s.mapper.UpdateFields(id, map[string]interface{}{"volunteer_name": name, "update_by": userID, "update_time": time.Now()})
}

// ListByUser 查询用户的志愿单列表（包含成绩信息）
func (s *YxVolunteerService) ListByUser(userID string, page, size int) ([]yxVO.UserVolunteerVO, int64, error) {
	return s.mapper.ListByUser(userID, page, size)
}

// DeleteVolunteer 删除志愿单
func (s *YxVolunteerService) DeleteVolunteer(id, userID string) error {
	volunteer, err := s.GetByID(id)
	if err != nil {
		return err
	}
	if volunteer.CreateBy != userID {
		return fmt.Errorf("无权删除该志愿单")
	}
	if volunteer.State == "1" {
		return fmt.Errorf("激活状态的志愿单不可删除")
	}
	s.volunteerRecordMapper.BatchDeleteByVolunteerId(id)
	s.mapper.Delete(id)
	// 1. 获取成绩单信息
	//scoreObj, err := scoreService.GetByID(volunteer.ScoreId)
	// if err != nil {
	// 	return fmt.Errorf("获取成绩单失败: %w", err)
	// }
	// _ = scoreObj // temporarily ignore until cascade logic is refined

	// 这里需要从 scoreObj 中获取 CalculationTableName 和 ID
	// 由于是 interface{}，可以通过反射或简单断言（如果能在 yx 定义共用结构最好）
	// 或者直接在 scoreService 中增加一个获取这些字段的方法

	// 简化：这里我们假设 scoreObj 其实包含了这些信息。
	// 为了真正的解耦，我们可以在 scoreService 中增加专门的方法。
	return nil // 暂时回退复杂逻辑
}

// SwitchVolunteer 切换激活的志愿单
func (s *YxVolunteerService) SwitchVolunteer(id, userID string, scoreService ScoreService) error {
	if err := s.mapper.CloseOtherVolunteer(userID); err != nil {
		return err
	}
	if err := s.mapper.UpdateFields(id, map[string]interface{}{"state": "1", "update_by": userID, "update_time": time.Now()}); err != nil {
		return err
	}

	volunteer, err := s.GetByID(id)
	if err != nil {
		return err
	}

	// 获取之前的激活成绩并关闭
	activeScoreID, err := scoreService.GetActiveScoreID(userID)
	if err != nil {
		return fmt.Errorf("获取激活成绩失败: %w", err)
	}
	if activeScoreID != "" && activeScoreID != volunteer.ScoreId {
		scoreService.UpdateFields(activeScoreID, map[string]interface{}{"state": "0"})
	}
	return scoreService.UpdateFields(volunteer.ScoreId, map[string]interface{}{"state": "1"})
}

// convertToVO Entity 转 VO（私有方法）
func (s *YxVolunteerService) convertToVO(entity entity.YxVolunteer) *yxVO.YxVolunteerVO {
	return &yxVO.YxVolunteerVO{
		ID:            entity.ID,
		VolunteerName: entity.VolunteerName,
		ScoreId:       entity.ScoreId,
		CreateType:    entity.CreateType,
		State:         entity.State,
		CreateBy:      entity.CreateBy,
		CreateTime:    entity.CreateTime,
		UpdateBy:      entity.UpdateBy,
		UpdateTime:    entity.UpdateTime,
		SysOrgCode:    entity.SysOrgCode,
	}
}