633 lines
20 KiB
Go
633 lines
20 KiB
Go
package service
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"photowall/internal/model"
|
|
"photowall/pkg/sensitive"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
type ClassService struct {
|
|
db *gorm.DB
|
|
configSvc *ConfigService
|
|
}
|
|
|
|
func NewClassService(db *gorm.DB, configSvc *ConfigService) *ClassService {
|
|
return &ClassService{db: db, configSvc: configSvc}
|
|
}
|
|
|
|
// CreateClassReq 创建班级请求
|
|
type CreateClassReq struct {
|
|
SchoolID uint `json:"school_id" binding:"required"`
|
|
CollegeID uint `json:"college_id"`
|
|
Name string `json:"name" binding:"required"`
|
|
Grade string `json:"grade" binding:"required"` // 如"2018级"
|
|
ClassNo string `json:"class_no" binding:"required"`
|
|
GraduateYear int `json:"graduate_year" binding:"required"`
|
|
GraduationPhoto string `json:"graduation_photo"`
|
|
StudentNames []string `json:"student_names"`
|
|
TeacherNames []string `json:"teacher_names"`
|
|
}
|
|
|
|
// cleanNames 清洗名字：去空格、去空、去重，保持顺序
|
|
func cleanNames(names []string) []string {
|
|
seen := map[string]bool{}
|
|
result := []string{}
|
|
for _, n := range names {
|
|
n = strings.TrimSpace(n)
|
|
if n == "" {
|
|
continue
|
|
}
|
|
if seen[n] {
|
|
continue
|
|
}
|
|
seen[n] = true
|
|
result = append(result, n)
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Create 创建班级
|
|
func (s *ClassService) Create(userID uint, req *CreateClassReq) (*model.Class, error) {
|
|
// 0. 敏感词检测
|
|
if found, word := sensitive.Check(req.Name); found {
|
|
return nil, fmt.Errorf("班级名称包含敏感词：%s", word)
|
|
}
|
|
// 1. 校验用户有学习履历
|
|
var eduCount int64
|
|
s.db.Model(&model.EducationHistory{}).Where("user_id = ?", userID).Count(&eduCount)
|
|
if eduCount == 0 {
|
|
return nil, errors.New("请先完善个人学习履历，有学习履历的用户才能创建班级")
|
|
}
|
|
|
|
// 2. 校验学校
|
|
var school model.School
|
|
if err := s.db.First(&school, req.SchoolID).Error; err != nil {
|
|
return nil, errors.New("学校不存在")
|
|
}
|
|
|
|
// 3. 校验学院（如果传了）
|
|
if req.CollegeID > 0 {
|
|
if !school.SchoolType.HasCollege() {
|
|
return nil, errors.New("该学校类型不支持学院层级")
|
|
}
|
|
var college model.College
|
|
if err := s.db.Where("id = ? AND school_id = ?", req.CollegeID, req.SchoolID).First(&college).Error; err != nil {
|
|
return nil, errors.New("学院不存在或不属于该学校")
|
|
}
|
|
} else if school.SchoolType.HasCollege() {
|
|
// 大学/职业学校必须选学院
|
|
return nil, errors.New("该学校需要选择所属学院")
|
|
}
|
|
|
|
// 4. 唯一性校验
|
|
var existCount int64
|
|
q := s.db.Model(&model.Class{}).Where("school_id = ? AND grade = ? AND class_no = ? AND graduate_year = ? AND status != ?",
|
|
req.SchoolID, req.Grade, req.ClassNo, req.GraduateYear, model.ClassDeleted)
|
|
if req.CollegeID > 0 {
|
|
q = q.Where("college_id = ?", req.CollegeID)
|
|
} else {
|
|
q = q.Where("college_id = 0 OR college_id IS NULL")
|
|
}
|
|
q.Count(&existCount)
|
|
if existCount > 0 {
|
|
return nil, errors.New("该班级已存在，请勿重复创建")
|
|
}
|
|
|
|
// 5. 清洗名单
|
|
students := cleanNames(req.StudentNames)
|
|
teachers := cleanNames(req.TeacherNames)
|
|
|
|
// 6. 构建班级
|
|
graceDays := 30
|
|
if s.configSvc != nil {
|
|
graceDays = s.configSvc.GetInt("audit_grace_days", 30)
|
|
}
|
|
class := &model.Class{
|
|
SchoolID: req.SchoolID,
|
|
CollegeID: req.CollegeID,
|
|
Name: req.Name,
|
|
Grade: req.Grade,
|
|
ClassNo: req.ClassNo,
|
|
GraduateYear: req.GraduateYear,
|
|
AdminUserID: userID,
|
|
GraduationPhoto: req.GraduationPhoto,
|
|
AuditDeadline: time.Now().AddDate(0, 0, graceDays),
|
|
}
|
|
class.SetStudentNames(students)
|
|
class.SetTeacherNames(teachers)
|
|
|
|
// 7. 名字不足8个直接打回
|
|
if len(students) < model.MinStudentCount {
|
|
class.Status = model.ClassRejected
|
|
class.RejectReason = fmt.Sprintf("班级同学名单仅 %d 人，需至少录入 %d 人（毕业照上通常有全部同学姓名，请补齐后重新提交）", len(students), model.MinStudentCount)
|
|
} else {
|
|
class.Status = model.ClassPending
|
|
}
|
|
|
|
// 8. 事务：创建班级 + 创建者成为管理员成员 + 审核日志
|
|
err := s.db.Transaction(func(tx *gorm.DB) error {
|
|
if err := tx.Create(class).Error; err != nil {
|
|
return err
|
|
}
|
|
member := &model.ClassMember{
|
|
ClassID: class.ID,
|
|
UserID: userID,
|
|
Role: model.MemberRoleAdmin,
|
|
JoinMethod: model.JoinByInvite, // 创建者视同邀请
|
|
JoinedAt: time.Now(),
|
|
}
|
|
if err := tx.Create(member).Error; err != nil {
|
|
return err
|
|
}
|
|
log := &model.AuditLog{
|
|
ClassID: class.ID,
|
|
AuditorID: userID,
|
|
Action: model.AuditSubmit,
|
|
Reason: fmt.Sprintf("创建班级，录入同学 %d 人、老师 %d 人", len(students), len(teachers)),
|
|
}
|
|
return tx.Create(log).Error
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return class, nil
|
|
}
|
|
|
|
// ClassDetail 班级详情
|
|
type ClassDetail struct {
|
|
Class model.Class `json:"class"`
|
|
StudentNames []string `json:"student_names"`
|
|
TeacherNames []string `json:"teacher_names"`
|
|
School *model.School `json:"school,omitempty"`
|
|
College *model.College `json:"college,omitempty"`
|
|
Admin *model.User `json:"admin,omitempty"`
|
|
Members []ClassMemberInfo `json:"members"`
|
|
Photos []model.ClassPhoto `json:"photos"`
|
|
MyRole string `json:"my_role"` // 当前用户角色，未加入为空
|
|
IsMember bool `json:"is_member"`
|
|
CanViewSensitive bool `json:"can_view_sensitive"` // 是否可查看照片和联系方式（成员/管理员）
|
|
}
|
|
|
|
type ClassMemberInfo struct {
|
|
Member model.ClassMember `json:"member"`
|
|
User model.User `json:"user"`
|
|
Contacts []model.UserContact `json:"contacts,omitempty"`
|
|
}
|
|
|
|
func (s *ClassService) GetDetail(classID, currentUserID uint, isSuperAdmin bool) (*ClassDetail, error) {
|
|
var class model.Class
|
|
if err := s.db.First(&class, classID).Error; err != nil {
|
|
return nil, errors.New("班级不存在")
|
|
}
|
|
if class.Status == model.ClassDeleted {
|
|
return nil, errors.New("班级已删除")
|
|
}
|
|
|
|
// 数据隔离：只有班级成员或超级管理员可查看完整信息（照片+联系方式）
|
|
canViewSensitive := isSuperAdmin || (currentUserID > 0 && s.isMember(classID, currentUserID))
|
|
|
|
detail := &ClassDetail{
|
|
Class: class,
|
|
StudentNames: class.StudentNames(),
|
|
TeacherNames: class.TeacherNames(),
|
|
CanViewSensitive: canViewSensitive,
|
|
}
|
|
|
|
// 学校
|
|
var school model.School
|
|
if s.db.First(&school, class.SchoolID).Error == nil {
|
|
detail.School = &school
|
|
}
|
|
// 学院
|
|
if class.CollegeID > 0 {
|
|
var college model.College
|
|
if s.db.First(&college, class.CollegeID).Error == nil {
|
|
detail.College = &college
|
|
}
|
|
}
|
|
// 管理员
|
|
var admin model.User
|
|
if s.db.First(&admin, class.AdminUserID).Error == nil {
|
|
detail.Admin = &admin
|
|
}
|
|
|
|
// 成员列表
|
|
var members []model.ClassMember
|
|
s.db.Where("class_id = ?", classID).Order("role desc, joined_at").Find(&members)
|
|
for _, m := range members {
|
|
var u model.User
|
|
s.db.First(&u, m.UserID)
|
|
info := ClassMemberInfo{Member: m, User: u}
|
|
// 数据隔离：同班成员或超级管理员可查看联系方式
|
|
if canViewSensitive {
|
|
info.Contacts = s.getUserContacts(m.UserID)
|
|
}
|
|
detail.Members = append(detail.Members, info)
|
|
}
|
|
|
|
// 照片墙：数据隔离，只有成员或超级管理员可查看
|
|
if canViewSensitive {
|
|
var photos []model.ClassPhoto
|
|
s.db.Where("class_id = ?", classID).Order("user_id, id desc").Find(&photos)
|
|
detail.Photos = photos
|
|
} else {
|
|
detail.Photos = []model.ClassPhoto{}
|
|
}
|
|
|
|
// 当前用户角色
|
|
if currentUserID > 0 {
|
|
var myMember model.ClassMember
|
|
if s.db.Where("class_id = ? AND user_id = ?", classID, currentUserID).First(&myMember).Error == nil {
|
|
detail.MyRole = string(myMember.Role)
|
|
detail.IsMember = true
|
|
}
|
|
}
|
|
return detail, nil
|
|
}
|
|
|
|
func (s *ClassService) isMember(classID, userID uint) bool {
|
|
var count int64
|
|
s.db.Model(&model.ClassMember{}).Where("class_id = ? AND user_id = ?", classID, userID).Count(&count)
|
|
return count > 0
|
|
}
|
|
|
|
func (s *ClassService) getUserContacts(userID uint) []model.UserContact {
|
|
var list []model.UserContact
|
|
s.db.Where("user_id = ?", userID).Order("type, is_primary desc").Find(&list)
|
|
return list
|
|
}
|
|
|
|
// SearchClassReq 搜索班级
|
|
type SearchClassReq struct {
|
|
Keyword string `form:"keyword"`
|
|
SchoolID uint `form:"school_id"`
|
|
Grade string `form:"grade"`
|
|
GraduateYear int `form:"graduate_year"`
|
|
Page int `form:"page"`
|
|
PageSize int `form:"page_size"`
|
|
}
|
|
|
|
// Search 搜索可加入的班级（仅 active 状态）
|
|
func (s *ClassService) Search(req *SearchClassReq) (*SchoolListResp, error) {
|
|
if req.Page <= 0 {
|
|
req.Page = 1
|
|
}
|
|
if req.PageSize <= 0 || req.PageSize > 100 {
|
|
req.PageSize = 20
|
|
}
|
|
db := s.db.Model(&model.Class{}).Where("status = ?", model.ClassActive)
|
|
if req.SchoolID > 0 {
|
|
db = db.Where("school_id = ?", req.SchoolID)
|
|
}
|
|
if req.Grade != "" {
|
|
db = db.Where("grade = ?", req.Grade)
|
|
}
|
|
if req.GraduateYear > 0 {
|
|
db = db.Where("graduate_year = ?", req.GraduateYear)
|
|
}
|
|
if req.Keyword != "" {
|
|
db = db.Where("name LIKE ?", "%"+req.Keyword+"%")
|
|
}
|
|
var total int64
|
|
db.Count(&total)
|
|
var list []model.Class
|
|
err := db.Order("graduate_year desc, id desc").Offset((req.Page - 1) * req.PageSize).Limit(req.PageSize).Find(&list).Error
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &SchoolListResp{List: list, Total: total, Page: req.Page}, nil
|
|
}
|
|
|
|
// JoinBySearchReq 搜索加入验证
|
|
type JoinBySearchReq struct {
|
|
ClassID uint `json:"class_id" binding:"required"`
|
|
StudentNames []string `json:"student_names" binding:"required,min=8"`
|
|
}
|
|
|
|
// JoinBySearch 通过搜索+8人验证加入班级
|
|
func (s *ClassService) JoinBySearch(userID uint, req *JoinBySearchReq) error {
|
|
var class model.Class
|
|
if err := s.db.First(&class, req.ClassID).Error; err != nil {
|
|
return errors.New("班级不存在")
|
|
}
|
|
if class.Status != model.ClassActive {
|
|
return errors.New("该班级尚未通过审核，暂不能加入")
|
|
}
|
|
// 已加入？
|
|
if s.isMember(class.ID, userID) {
|
|
return errors.New("你已经是该班级成员")
|
|
}
|
|
// 验证8个名字
|
|
classStudents := class.StudentNames()
|
|
classSet := map[string]bool{}
|
|
for _, n := range classStudents {
|
|
classSet[strings.TrimSpace(n)] = true
|
|
}
|
|
input := cleanNames(req.StudentNames)
|
|
if len(input) < model.MinStudentCount {
|
|
return fmt.Errorf("请输入至少 %d 位同学的名字", model.MinStudentCount)
|
|
}
|
|
for _, n := range input {
|
|
if !classSet[n] {
|
|
return fmt.Errorf("同学「%s」不在该班级名单中，验证失败，请确认名字与毕业照一致", n)
|
|
}
|
|
}
|
|
// 全部匹配，加入
|
|
member := &model.ClassMember{
|
|
ClassID: class.ID,
|
|
UserID: userID,
|
|
Role: model.MemberRoleMember,
|
|
JoinMethod: model.JoinBySearch,
|
|
JoinedAt: time.Now(),
|
|
}
|
|
return s.db.Create(member).Error
|
|
}
|
|
|
|
// ---- 邀请码 ----
|
|
|
|
// CreateInvitation 管理员生成邀请码
|
|
func (s *ClassService) CreateInvitation(classID, userID uint, maxUses int, expireDays int) (*model.Invitation, error) {
|
|
if !s.isAdmin(classID, userID) {
|
|
return nil, errors.New("只有班级管理员可以生成邀请码")
|
|
}
|
|
var class model.Class
|
|
if err := s.db.First(&class, classID).Error; err != nil {
|
|
return nil, errors.New("班级不存在")
|
|
}
|
|
if class.Status == model.ClassDeleted {
|
|
return nil, errors.New("班级已删除")
|
|
}
|
|
if maxUses <= 0 {
|
|
maxUses = 50
|
|
}
|
|
if expireDays <= 0 {
|
|
expireDays = 30
|
|
}
|
|
inv := &model.Invitation{
|
|
ClassID: classID,
|
|
InviterID: userID,
|
|
Code: strings.ToUpper(strings.ReplaceAll(uuid.New().String()[:8], "-", "")),
|
|
MaxUses: maxUses,
|
|
ExpiresAt: time.Now().AddDate(0, 0, expireDays),
|
|
Status: "active",
|
|
}
|
|
if err := s.db.Create(inv).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return inv, nil
|
|
}
|
|
|
|
// ListInvitations 管理员查看邀请码列表
|
|
func (s *ClassService) ListInvitations(classID, userID uint) ([]model.Invitation, error) {
|
|
if !s.isAdmin(classID, userID) {
|
|
return nil, errors.New("只有班级管理员可以查看邀请码")
|
|
}
|
|
var list []model.Invitation
|
|
err := s.db.Where("class_id = ?", classID).Order("id desc").Find(&list).Error
|
|
return list, err
|
|
}
|
|
|
|
// JoinByInvitationReq 邀请码加入
|
|
type JoinByInvitationReq struct {
|
|
Code string `json:"code" binding:"required"`
|
|
}
|
|
|
|
// JoinByInvitation 通过邀请码加入
|
|
func (s *ClassService) JoinByInvitation(userID uint, req *JoinByInvitationReq) (*model.Class, error) {
|
|
code := strings.ToUpper(strings.TrimSpace(req.Code))
|
|
var inv model.Invitation
|
|
if err := s.db.Where("code = ?", code).First(&inv).Error; err != nil {
|
|
return nil, errors.New("邀请码无效")
|
|
}
|
|
if inv.Status != "active" {
|
|
return nil, errors.New("邀请码已失效")
|
|
}
|
|
if inv.UsedCount >= inv.MaxUses {
|
|
return nil, errors.New("邀请码使用次数已达上限")
|
|
}
|
|
if time.Now().After(inv.ExpiresAt) {
|
|
return nil, errors.New("邀请码已过期")
|
|
}
|
|
var class model.Class
|
|
if err := s.db.First(&class, inv.ClassID).Error; err != nil {
|
|
return nil, errors.New("班级不存在")
|
|
}
|
|
if class.Status == model.ClassDeleted {
|
|
return nil, errors.New("班级已删除")
|
|
}
|
|
if s.isMember(class.ID, userID) {
|
|
return nil, errors.New("你已经是该班级成员")
|
|
}
|
|
// 事务：加成员 + 邀请码使用数+1
|
|
err := s.db.Transaction(func(tx *gorm.DB) error {
|
|
member := &model.ClassMember{
|
|
ClassID: class.ID,
|
|
UserID: userID,
|
|
Role: model.MemberRoleMember,
|
|
JoinMethod: model.JoinByInvite,
|
|
JoinedAt: time.Now(),
|
|
}
|
|
if err := tx.Create(member).Error; err != nil {
|
|
return err
|
|
}
|
|
return tx.Model(&model.Invitation{}).Where("id = ?", inv.ID).
|
|
Update("used_count", gorm.Expr("used_count + 1")).Error
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &class, nil
|
|
}
|
|
|
|
// DisableInvitation 管理员禁用邀请码
|
|
func (s *ClassService) DisableInvitation(classID, invID, userID uint) error {
|
|
if !s.isAdmin(classID, userID) {
|
|
return errors.New("只有班级管理员可以操作")
|
|
}
|
|
res := s.db.Model(&model.Invitation{}).Where("id = ? AND class_id = ?", invID, classID).Update("status", "disabled")
|
|
if res.RowsAffected == 0 {
|
|
return errors.New("邀请码不存在")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// isAdmin 检查用户是否为班级管理员
|
|
func (s *ClassService) isAdmin(classID, userID uint) bool {
|
|
var count int64
|
|
s.db.Model(&model.ClassMember{}).Where("class_id = ? AND user_id = ? AND role = ?", classID, userID, model.MemberRoleAdmin).Count(&count)
|
|
return count > 0
|
|
}
|
|
|
|
// TransferAdmin 管理员转移
|
|
func (s *ClassService) TransferAdmin(classID, fromUserID, toUserID uint) error {
|
|
if !s.isAdmin(classID, fromUserID) {
|
|
return errors.New("只有班级管理员可以转移管理员身份")
|
|
}
|
|
if fromUserID == toUserID {
|
|
return errors.New("不能转移给自己")
|
|
}
|
|
// 目标必须是同班成员
|
|
var target model.ClassMember
|
|
if err := s.db.Where("class_id = ? AND user_id = ?", classID, toUserID).First(&target).Error; err != nil {
|
|
return errors.New("目标用户不是该班级成员")
|
|
}
|
|
err := s.db.Transaction(func(tx *gorm.DB) error {
|
|
// 原管理员降为成员
|
|
if err := tx.Model(&model.ClassMember{}).
|
|
Where("class_id = ? AND user_id = ?", classID, fromUserID).
|
|
Update("role", model.MemberRoleMember).Error; err != nil {
|
|
return err
|
|
}
|
|
// 目标升为管理员
|
|
if err := tx.Model(&model.ClassMember{}).
|
|
Where("class_id = ? AND user_id = ?", classID, toUserID).
|
|
Update("role", model.MemberRoleAdmin).Error; err != nil {
|
|
return err
|
|
}
|
|
// 更新班级 admin_user_id
|
|
return tx.Model(&model.Class{}).Where("id = ?", classID).Update("admin_user_id", toUserID).Error
|
|
})
|
|
return err
|
|
}
|
|
|
|
// RemoveMember 管理员移除成员（不能移除自己）
|
|
func (s *ClassService) RemoveMember(classID, adminID, targetUserID uint) error {
|
|
if !s.isAdmin(classID, adminID) {
|
|
return errors.New("只有班级管理员可以移除成员")
|
|
}
|
|
if adminID == targetUserID {
|
|
return errors.New("不能移除自己，请先转移管理员")
|
|
}
|
|
res := s.db.Where("class_id = ? AND user_id = ?", classID, targetUserID).Delete(&model.ClassMember{})
|
|
if res.RowsAffected == 0 {
|
|
return errors.New("成员不存在")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ---- 个人照片墙 ----
|
|
|
|
// UploadPhoto 上传个人当期照片（每人每班级最多10张）
|
|
func (s *ClassService) UploadPhoto(classID, userID uint, photoURL, caption string) (*model.ClassPhoto, error) {
|
|
if !s.isMember(classID, userID) {
|
|
return nil, errors.New("只有班级成员可以上传照片")
|
|
}
|
|
var class model.Class
|
|
if err := s.db.First(&class, classID).Error; err != nil {
|
|
return nil, errors.New("班级不存在")
|
|
}
|
|
if class.Status == model.ClassDeleted {
|
|
return nil, errors.New("班级已删除")
|
|
}
|
|
var count int64
|
|
s.db.Model(&model.ClassPhoto{}).Where("class_id = ? AND user_id = ?", classID, userID).Count(&count)
|
|
if count >= int64(model.MaxPhotosPerUserPerClass) {
|
|
return nil, fmt.Errorf("每人在每个班级最多上传 %d 张照片", model.MaxPhotosPerUserPerClass)
|
|
}
|
|
photo := &model.ClassPhoto{
|
|
ClassID: classID,
|
|
UserID: userID,
|
|
PhotoURL: photoURL,
|
|
Caption: caption,
|
|
}
|
|
if err := s.db.Create(photo).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return photo, nil
|
|
}
|
|
|
|
// DeletePhoto 删除照片（本人或班级管理员或超级管理员）
|
|
func (s *ClassService) DeletePhoto(classID, photoID, userID uint, isSuperAdmin bool) error {
|
|
var photo model.ClassPhoto
|
|
if err := s.db.Where("id = ? AND class_id = ?", photoID, classID).First(&photo).Error; err != nil {
|
|
return errors.New("照片不存在")
|
|
}
|
|
// 权限校验：本人、班级管理员、超级管理员
|
|
canDelete := isSuperAdmin || photo.UserID == userID || s.isAdmin(classID, userID)
|
|
if !canDelete {
|
|
return errors.New("无权删除此照片")
|
|
}
|
|
s.db.Delete(&photo)
|
|
return nil
|
|
}
|
|
|
|
// ListMyClasses 我的班级列表
|
|
func (s *ClassService) ListMyClasses(userID uint) ([]ClassDetail, error) {
|
|
var members []model.ClassMember
|
|
s.db.Where("user_id = ?", userID).Order("id desc").Find(&members)
|
|
result := []ClassDetail{}
|
|
for _, m := range members {
|
|
var class model.Class
|
|
if err := s.db.First(&class, m.ClassID).Error; err != nil {
|
|
continue
|
|
}
|
|
if class.Status == model.ClassDeleted {
|
|
continue
|
|
}
|
|
d := ClassDetail{
|
|
Class: class,
|
|
MyRole: string(m.Role),
|
|
IsMember: true,
|
|
}
|
|
var school model.School
|
|
if s.db.First(&school, class.SchoolID).Error == nil {
|
|
d.School = &school
|
|
}
|
|
result = append(result, d)
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
// ResubmitReq 重新提交审核（补齐名单/照片）
|
|
type ResubmitReq struct {
|
|
GraduationPhoto string `json:"graduation_photo"`
|
|
StudentNames []string `json:"student_names"`
|
|
TeacherNames []string `json:"teacher_names"`
|
|
}
|
|
|
|
// Resubmit 被打回后补齐重新提交
|
|
func (s *ClassService) Resubmit(classID, userID uint, req *ResubmitReq) error {
|
|
var class model.Class
|
|
if err := s.db.First(&class, classID).Error; err != nil {
|
|
return errors.New("班级不存在")
|
|
}
|
|
if class.AdminUserID != userID {
|
|
return errors.New("只有班级管理员可以重新提交审核")
|
|
}
|
|
if class.Status != model.ClassRejected && class.Status != model.ClassPending {
|
|
return errors.New("当前状态不支持重新提交")
|
|
}
|
|
students := cleanNames(req.StudentNames)
|
|
teachers := cleanNames(req.TeacherNames)
|
|
|
|
if len(students) < model.MinStudentCount {
|
|
return fmt.Errorf("同学名单至少需要 %d 人，当前仅 %d 人", model.MinStudentCount, len(students))
|
|
}
|
|
if req.GraduationPhoto != "" {
|
|
class.GraduationPhoto = req.GraduationPhoto
|
|
}
|
|
class.SetStudentNames(students)
|
|
class.SetTeacherNames(teachers)
|
|
class.Status = model.ClassPending
|
|
class.RejectReason = ""
|
|
// 重新提交后审核截止时间顺延？保持原截止时间，30天从创建算起
|
|
if err := s.db.Save(&class).Error; err != nil {
|
|
return err
|
|
}
|
|
// 审核日志
|
|
log := &model.AuditLog{
|
|
ClassID: class.ID,
|
|
AuditorID: userID,
|
|
Action: model.AuditSubmit,
|
|
Reason: fmt.Sprintf("重新提交，补齐同学 %d 人、老师 %d 人", len(students), len(teachers)),
|
|
}
|
|
s.db.Create(log)
|
|
return nil
|
|
}
|