Losita/smartmate
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Version: 0.2.0.dev.260210

Browse Source 
feat: 🗑️ 新增删除单个课程与解除安排日程接口

- 逻辑复杂，初版接口写完后才发现需求需要传切片
- 针对需求修改，通过大 for 循环和事务处理来解决问题 🔄

refactor: 🔧 移除部分冗余的用户 ID 验证逻辑

- sv/schedule.go 中，进来的 ID 已通过 redis 黑名单与 JWT 保护验证
- 去除重复的数据库查验，优化了代码流程 🛠️

refactor: 🔄 重构 API 层业务错误判断逻辑

- 抛弃了原有的手动比对方式，封装进 `respond` 包，简化判断流程
- 未来不再手动遍历数据链路，提升了开发效率 🧹

undo: ⚠️ 修复任务块添加到日程的接口问题（待修复）

- 接口允许直接修改已经安排的任务时间，且重复执行时未被禁止
- 此逻辑存在问题，计划在下个版本修复 🔧

undo: ⚠️ 重测接口的幂等性与其他特性

- 当前接口幂等性等特性尚未专门测试，后续计划重测所有接口
- 测试不充分，待进一步完善 🔄

undo: ⚠️ 修复刷新 token 接口错误处理问题

- 当前接口将 token 本身的错误以 500 错误返回，需修复此问题 🛠️
This commit is contained in:
LoveLosita
2026-02-10 19:51:05 +08:00
parent 6d857d16c2
commit d07234e183
13 changed files with 334 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
backend/api/course.go
View File

@@ -58,15 +58,10 @@ func (sa *CourseHandler) AddUserCourses(c *gin.Context) {
defer cancel() // 记得释放资源
conflicts, err := sa.service.AddUserCourses(ctx, req, userIDInterface)
if err != nil {
switch {
case errors.Is(err, respond.WrongParamType), errors.Is(err, respond.WrongCourseInfo),
errors.Is(err, respond.InsertCourseTwice):
c.JSON(http.StatusBadRequest, err)
case errors.Is(err, respond.ScheduleConflict):
if errors.Is(err, respond.ScheduleConflict) {
c.JSON(http.StatusConflict, respond.RespWithData(respond.ScheduleConflict, conflicts))
default:
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
}
respond.DealWithError(c, err)
return
}
//4.返回成功响应

43
backend/api/schedule.go
View File

@@ -2,11 +2,11 @@ package api
import (
"context"
"errors"
"net/http"
"strconv"
"time"
"github.com/LoveLosita/smartflow/backend/model"
"github.com/LoveLosita/smartflow/backend/respond"
"github.com/LoveLosita/smartflow/backend/service"
"github.com/gin-gonic/gin"
@@ -31,14 +31,8 @@ func (s *ScheduleAPI) GetUserTodaySchedule(c *gin.Context) {
defer cancel() // 记得释放资源
todaySchedules, err := s.scheduleService.GetUserTodaySchedule(ctx, userID)
if err != nil {
switch {
case errors.Is(err, respond.WrongUserID):
c.JSON(http.StatusBadRequest, respond.WrongUserID)
return
default:
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
return
}
respond.DealWithError(c, err)
return
}
//3.返回日程安排数据给前端
c.JSON(http.StatusOK, respond.RespWithData(respond.Ok, todaySchedules))
@@ -58,15 +52,30 @@ func (s *ScheduleAPI) GetUserWeeklySchedule(c *gin.Context) {
defer cancel() // 记得释放资源
weeklySchedules, err := s.scheduleService.GetUserWeeklySchedule(ctx, userID, week)
if err != nil {
switch {
case errors.Is(err, respond.WrongUserID), errors.Is(err, respond.WeekOutOfRange):
c.JSON(http.StatusBadRequest, err)
return
default:
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
return
}
respond.DealWithError(c, err)
return
}
//4.返回日程安排数据给前端
c.JSON(http.StatusOK, respond.RespWithData(respond.Ok, weeklySchedules))
}
func (s *ScheduleAPI) DeleteScheduleEvent(c *gin.Context) {
// 1. 从请求上下文中获取用户ID
userID := c.GetInt("user_id")
// 2. 从请求体中获取要删除的日程事件信息
var req []model.UserDeleteScheduleEvent
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, respond.WrongParamType)
return
}
//3.调用服务层方法删除指定的日程事件
ctx, cancel := context.WithTimeout(c.Request.Context(), 1*time.Second)
defer cancel() // 记得释放资源
err := s.scheduleService.DeleteScheduleEvent(ctx, req, userID)
if err != nil {
respond.DealWithError(c, err)
return
}
//4.返回删除成功的响应给前端
c.JSON(http.StatusOK, respond.Ok)
}

32
backend/api/task-class.go
View File

@@ -2,7 +2,6 @@ package api
import (
"context"
"errors"
"net/http"
"strconv"
"time"
@@ -11,7 +10,6 @@ import (
"github.com/LoveLosita/smartflow/backend/respond"
"github.com/LoveLosita/smartflow/backend/service"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
type TaskClassHandler struct {
@@ -43,11 +41,8 @@ func (api *TaskClassHandler) UserAddTaskClass(c *gin.Context) {
defer cancel() // 记得释放资源
err = api.svc.AddOrUpdateTaskClass(ctx, &req, userIDInterface, create, 0)
if err != nil {
if errors.Is(err, respond.WrongParamType) {
c.JSON(http.StatusBadRequest, respond.WrongParamType)
return
}
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
respond.DealWithError(c, err)
return
}
c.JSON(http.StatusOK, respond.Ok)
}
@@ -59,7 +54,7 @@ func (api *TaskClassHandler) UserGetTaskClassInfos(c *gin.Context) {
defer cancel() // 记得释放资源
resp, err := api.svc.GetUserTaskClassInfos(ctx, userIDInterface)
if err != nil {
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
respond.DealWithError(c, err)
return
}
c.JSON(http.StatusOK, respond.RespWithData(respond.Ok, resp))
@@ -83,11 +78,7 @@ func (api *TaskClassHandler) UserGetCompleteTaskClass(c *gin.Context) {
defer cancel() // 记得释放资源
resp, err := api.svc.GetUserCompleteTaskClass(ctx, userIDInterface, intTaskClassID)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
c.JSON(http.StatusNotFound, respond.UserTaskClassNotFound)
return
}
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
respond.DealWithError(c, err)
return
}
c.JSON(http.StatusOK, respond.RespWithData(respond.Ok, resp))
@@ -109,11 +100,8 @@ func (api *TaskClassHandler) UserUpdateTaskClass(c *gin.Context) {
defer cancel() // 记得释放资源
err = api.svc.AddOrUpdateTaskClass(ctx, &req, userIDInterface, update, intTaskClassID)
if err != nil {
if errors.Is(err, respond.WrongParamType) || errors.Is(err, respond.UserTaskClassForbidden) {
c.JSON(http.StatusBadRequest, err)
return
}
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
respond.DealWithError(c, err)
return
}
c.JSON(http.StatusOK, respond.Ok)
}
@@ -138,13 +126,7 @@ func (api *TaskClassHandler) UserAddTaskClassItemIntoSchedule(c *gin.Context) {
defer cancel() // 记得释放资源
err = api.svc.AddTaskClassItemIntoSchedule(ctx, &req, userIDInterface, intTaskID)
if err != nil {
if errors.Is(err, respond.TaskClassItemNotBelongToUser) || errors.Is(err, respond.CourseNotBelongToUser) ||
errors.Is(err, respond.CourseAlreadyEmbeddedByOtherTaskBlock) || errors.Is(err, respond.CourseTimeNotMatch) ||
errors.Is(err, respond.ScheduleConflict) || errors.Is(err, respond.WrongCourseID) {
c.JSON(http.StatusBadRequest, err)
return
}
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
respond.DealWithError(c, err)
return
}
c.JSON(http.StatusOK, respond.Ok)

20
backend/api/task.go
View File

@@ -2,7 +2,6 @@ package api
import (
"context"
"errors"
"fmt"
"net/http"
"time"
@@ -41,13 +40,8 @@ func (th *TaskHandler) AddTask(c *gin.Context) {
defer cancel() // 记得释放资源
resp, err := th.svc.AddTask(ctx, &req, userID)
if err != nil {
switch {
case errors.Is(err, respond.InvalidPriority): //如果是无效刷新令牌或者无效claims或者无效签名方法
c.JSON(http.StatusBadRequest, err)
return
default:
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
}
respond.DealWithError(c, err)
return
}
//3. 返回响应
c.JSON(http.StatusOK, respond.RespWithData(respond.Ok, resp))
@@ -62,14 +56,8 @@ func (th *TaskHandler) GetUserTasks(c *gin.Context) {
defer cancel() // 记得释放资源
resp, err := th.svc.GetUserTasks(ctx, userID)
if err != nil {
switch {
case errors.Is(err, respond.UserTasksEmpty): //如果任务列表为空
c.JSON(http.StatusOK, respond.RespWithData(respond.UserTasksEmpty, []model.Task{})) //确实没错误，但是任务列表为空，返回自定义响应
return
default:
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
return
}
respond.DealWithError(c, err)
return
}
//3. 返回响应
c.JSON(http.StatusOK, respond.RespWithData(respond.Ok, resp))

34
backend/api/user.go
View File

@@ -4,7 +4,6 @@ package api
import (
"context"
"errors"
"net/http"
"time"
@@ -40,15 +39,8 @@ func (api *UserHandler) UserRegister(c *gin.Context) {
defer cancel() // 记得释放资源
retUser, err := api.svc.UserRegister(ctx, user)
if err != nil {
switch {
case errors.Is(err, respond.InvalidName), errors.Is(err, respond.MissingParam),
errors.Is(err, respond.ParamTooLong): //如果是无效ID或者缺少参数的错误
c.JSON(http.StatusBadRequest, err)
return
default:
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
return
}
respond.DealWithError(c, err)
return
}
c.JSON(http.StatusOK, respond.RespWithData(respond.Ok, retUser))
@@ -66,14 +58,8 @@ func (api *UserHandler) UserLogin(c *gin.Context) {
defer cancel() // 记得释放资源
tokens, err := api.svc.UserLogin(ctx, &req)
if err != nil {
switch {
case errors.Is(err, respond.WrongName), errors.Is(err, respond.WrongPwd): //如果是无效ID或者缺少参数的错误
c.JSON(http.StatusBadRequest, err)
return
default:
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
return
}
respond.DealWithError(c, err)
return
}
c.JSON(http.StatusOK, respond.RespWithData(respond.Ok, tokens))
}
@@ -94,14 +80,8 @@ func (api *UserHandler) RefreshTokenHandler(c *gin.Context) {
defer cancel() // 记得释放资源
tokens, err := api.svc.RefreshTokenHandler(ctx, requestBody.RefreshToken)
if err != nil {
switch {
case errors.Is(err, respond.InvalidRefreshToken), errors.Is(err, respond.InvalidClaims),
errors.Is(err, respond.InvalidTokenSingingMethod), errors.Is(err, respond.UserLoggedOut): //如果是无效刷新令牌或者无效claims或者无效签名方法
c.JSON(http.StatusBadRequest, err)
return
default:
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
}
respond.DealWithError(c, err)
return
}
c.JSON(http.StatusOK, respond.RespWithData(respond.Ok, tokens))
}
@@ -116,7 +96,7 @@ func (api *UserHandler) UserLogout(c *gin.Context) {
defer cancel() // 记得释放资源
err := api.svc.UserLogout(ctx, cl.Jti, cl.ExpiresAt.Time)
if err != nil {
c.JSON(http.StatusInternalServerError, respond.InternalError(err))
respond.DealWithError(c, err)
return
}
c.JSON(http.StatusOK, respond.Ok)

2
backend/auth/jwt_handler.go
View File

@@ -111,7 +111,7 @@ func ValidateRefreshToken(tokenString string, cache *dao.CacheDAO) (*jwt.Token,
isBlack, err := cache.IsBlacklisted(claims.Jti)
if err != nil {
// Redis 出错时的处理逻辑，建议报错以防“漏网之鱼”
return nil, respond.InternalError(errors.New("无法验证令牌状态"))
return nil, errors.New("无法验证令牌状态")
}
if isBlack {
return nil, respond.UserLoggedOut // 返回你定义的“用户已登出”错误

2
backend/cmd/start.go
View File

@@ -52,7 +52,7 @@ func Start() {
taskSv := service.NewTaskService(taskRepo)
courseService := service.NewCourseService(courseRepo, scheduleRepo)
taskClassService := service.NewTaskClassService(taskClassRepo, cacheRepo, scheduleRepo, manager)
scheduleService := service.NewScheduleService(scheduleRepo, userRepo)
scheduleService := service.NewScheduleService(scheduleRepo, userRepo, taskClassRepo, manager)
//api 层
userApi := api.NewUserHandler(userService)
taskApi := api.NewTaskHandler(taskSv)

96
backend/dao/schedule.go
View File

@@ -301,3 +301,99 @@ func (d *ScheduleDAO) GetUserWeeklySchedule(ctx context.Context, userID, week in
return schedules, nil
}
func (d *ScheduleDAO) DeleteScheduleEventAndSchedule(ctx context.Context, eventID int, userID int) error {
//级联删除：先删 schedules，自动删 schedule_events
res := d.db.WithContext(ctx).Where("id=? AND user_id=?", eventID, userID).Delete(&model.ScheduleEvent{})
if res.Error != nil {
return res.Error
}
if res.RowsAffected == 0 {
return respond.WrongScheduleEventID // 事件不存在或不属于该用户，统一返回错误
}
return nil
}
func (d *ScheduleDAO) GetScheduleTypeByEventID(ctx context.Context, eventID, userID int) (string, error) {
type row struct {
Type *string `gorm:"column:type"`
}
var r row
err := d.db.WithContext(ctx).
Table("schedule_events").
Select("type").
Where("id = ? AND user_id=?", eventID, userID).
First(&r).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return "", respond.WrongScheduleEventID // 事件不存在或不属于该用户，统一返回错误
}
return "", err
}
if r.Type == nil {
return "", respond.WrongScheduleEventID
}
return *r.Type, nil
}
func (d *ScheduleDAO) GetScheduleEmbeddedTaskID(ctx context.Context, eventID int) (int, error) {
// embedded_task_id 存在于 schedules 表中（按 event_id 聚合取一个非空值）
// 若该事件没有任何嵌入任务，则返回 0, nil
type row struct {
EmbeddedTaskID *int `gorm:"column:embedded_task_id"`
}
var r row
err := d.db.WithContext(ctx).
Table("schedules").
Select("embedded_task_id").
Where("event_id = ?", eventID).
Where("embedded_task_id IS NOT NULL AND embedded_task_id <> 0").
Order("id ASC").
Limit(1).
Scan(&r).Error
if err != nil {
return 0, err
}
if r.EmbeddedTaskID == nil { // 没有任何嵌入任务
return 0, nil
}
return *r.EmbeddedTaskID, nil
}
func (d *ScheduleDAO) IfScheduleEventIDExists(ctx context.Context, eventID int) (bool, error) {
var count int64
err := d.db.WithContext(ctx).
Table("schedule_events").
Where("id = ?", eventID).
Count(&count).Error
if err != nil {
return false, err
}
return count > 0, nil
}
func (d *ScheduleDAO) SetScheduleEmbeddedTaskIDToNull(ctx context.Context, eventID int) (int, error) {
// 先取出该事件当前嵌入的任务 id（若没有嵌入则返回对应业务错误）
embeddedTaskID, err := d.GetScheduleEmbeddedTaskID(ctx, eventID)
if err != nil {
return 0, err
}
if embeddedTaskID == 0 {
return 0, respond.TargetScheduleNotHaveEmbeddedTask
}
// 将 schedules 表中指定 event_id 的 embedded_task_id 字段置空（用于解除嵌入关系）
res := d.db.WithContext(ctx).
Table("schedules").
Where("event_id = ?", eventID).
Where("embedded_task_id IS NOT NULL AND embedded_task_id <> 0").
Update("embedded_task_id", nil)
if res.Error != nil {
return 0, res.Error
}
if res.RowsAffected == 0 {
return 0, respond.TargetScheduleNotHaveEmbeddedTask
}
return embeddedTaskID, nil
}

8
backend/dao/task-class.go
View File

@@ -187,3 +187,11 @@ func (dao *TaskClassDAO) UpdateTaskClassItemEmbeddedTime(ctx context.Context, ta
Update("embedded_time", embeddedTime).Error
return err
}
func (dao *TaskClassDAO) DeleteTaskClassItemEmbeddedTime(ctx context.Context, taskID int) error {
err := dao.db.WithContext(ctx).
Model(&model.TaskClassItem{}).
Where("id = ?", taskID).
Update("embedded_time", nil).Error
return err
}

6
backend/model/schedule.go
View File

@@ -86,6 +86,12 @@ type WeeklyEventBrief struct {
EmbeddedTaskInfo TaskBrief `json:"embedded_task_info,omitempty"`
}
type UserDeleteScheduleEvent struct {
ID int `json:"id"` // 这个 ID 是 ScheduleEvent 的 ID，不是 Schedule 的 ID
DeleteCourse bool `json:"delete_course"`
DeleteEmbeddedTask bool `json:"delete_embedded_task"`
}
func (ScheduleEvent) TableName() string { return "schedule_events" }
func (Schedule) TableName() string { return "schedules" }

30
backend/respond/respond.go
View File

@@ -2,6 +2,13 @@
// 统一API响应格式和处理逻辑
package respond
import (
"errors"
"net/http"
"github.com/gin-gonic/gin"
)
type Response struct { //响应结构体
Status string `json:"status"`
Info string `json:"info"`
@@ -13,7 +20,6 @@ type FinalResponse struct { //最终响应结构体
Data interface{} `json:"data"`
}
// 实现error接口
func (r Response) Error() string { // 实现 error 接口
return r.Info
}
@@ -26,6 +32,18 @@ func RespWithData(response Response, data interface{}) FinalResponse { //传入
return finalResponse
}
func DealWithError(c *gin.Context, err error) { //处理错误，返回对应的响应结构体
if err == nil {
return
}
var resp Response
if errors.As(err, &resp) {
c.JSON(http.StatusBadRequest, resp)
return
}
c.JSON(http.StatusInternalServerError, InternalError(err))
}
func InternalError(err error) Response { //服务器错误
return Response{
Status: "500",
@@ -193,4 +211,14 @@ var ( //请求相关的响应
Status: "40030",
Info: "week out of range",
}
WrongScheduleEventID = Response{ //日程ID错误
Status: "40031",
Info: "wrong schedule_event id",
}
TargetScheduleNotHaveEmbeddedTask = Response{ //目标日程没有嵌入任务
Status: "40032",
Info: "target schedule does not have embedded task",
}
)

3
backend/routers/routers.go
View File

@@ -37,7 +37,7 @@ func RegisterRouters(handlers *api.ApiHandlers, cache *dao.CacheDAO) *gin.Engine
apiGroup.GET("/health", func(c *gin.Context) {
c.JSON(200, gin.H{
"status": "ok",
"version": "1.0.0",
"version": "0.2.0.dev.260210",
})
})
@@ -74,6 +74,7 @@ func RegisterRouters(handlers *api.ApiHandlers, cache *dao.CacheDAO) *gin.Engine
scheduleGroup.Use(middleware.JWTTokenAuth(cache))
scheduleGroup.GET("/today", handlers.ScheduleHandler.GetUserTodaySchedule)
scheduleGroup.GET("/week", handlers.ScheduleHandler.GetUserWeeklySchedule)
scheduleGroup.DELETE("/delete", handlers.ScheduleHandler.DeleteScheduleEvent)
}
}
// 初始化Gin引擎

158
backend/service/schedule.go
View File

@@ -2,7 +2,6 @@ package service
import (
"context"
"errors"
"fmt"
"time"
@@ -10,30 +9,33 @@ import (
"github.com/LoveLosita/smartflow/backend/dao"
"github.com/LoveLosita/smartflow/backend/model"
"github.com/LoveLosita/smartflow/backend/respond"
"gorm.io/gorm"
)
type ScheduleService struct {
scheduleDAO *dao.ScheduleDAO
userDAO *dao.UserDAO
scheduleDAO *dao.ScheduleDAO
userDAO *dao.UserDAO
taskClassDAO *dao.TaskClassDAO
repoManager *dao.RepoManager // 统一管理多个 DAO 的事务
}
func NewScheduleService(scheduleDAO *dao.ScheduleDAO, userDAO *dao.UserDAO) *ScheduleService {
func NewScheduleService(scheduleDAO *dao.ScheduleDAO, userDAO *dao.UserDAO, taskClassDAO *dao.TaskClassDAO, repoManager *dao.RepoManager) *ScheduleService {
return &ScheduleService{
scheduleDAO: scheduleDAO,
userDAO: userDAO,
scheduleDAO: scheduleDAO,
userDAO: userDAO,
taskClassDAO: taskClassDAO,
repoManager: repoManager,
}
}
func (ss *ScheduleService) GetUserTodaySchedule(ctx context.Context, userID int) ([]model.UserTodaySchedule, error) {
//1.先检查用户id是否存在
_, err := ss.userDAO.GetUserByID(userID)
//1.先检查用户id是否存在(考虑移除)
/*_, err := ss.userDAO.GetUserByID(userID)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, respond.WrongUserID
}
return nil, err
}
}*/
//2.获取当前日期
curTime := time.Now().Format("2006-01-02")
/*curTime := "2026-03-02" //测试数据*/
@@ -57,14 +59,14 @@ func (ss *ScheduleService) GetUserWeeklySchedule(ctx context.Context, userID, we
if week < 0 || week > 25 {
return nil, respond.WeekOutOfRange
}
//2.先检查用户id是否存在
_, err := ss.userDAO.GetUserByID(userID)
//2.先检查用户id是否存在(考虑移除)
/*_, err := ss.userDAO.GetUserByID(userID)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, respond.WrongUserID
}
return nil, err
}
}*/
//2.查询用户每周的日程安排
//如果没有传入 week 参数，则默认查询当前周的日程安排
if week == 0 {
@@ -83,3 +85,133 @@ func (ss *ScheduleService) GetUserWeeklySchedule(ctx context.Context, userID, we
weeklySchedules := conv.SchedulesToUserWeeklySchedule(schedules)
return weeklySchedules, nil
}
func (ss *ScheduleService) DeleteScheduleEvent(ctx context.Context, requests []model.UserDeleteScheduleEvent, userID int) error {
err := ss.repoManager.Transaction(ctx, func(txM *dao.RepoManager) error {
for _, req := range requests {
//1.如果要删课程和嵌入的事件
if req.DeleteEmbeddedTask && req.DeleteCourse {
//通过schedule表的embedded_task_id字段找到对应的task_id
taskID, err := txM.Schedule.GetScheduleEmbeddedTaskID(ctx, req.ID)
if err != nil {
return err
}
//再将task_items表中对应的embedded_time字段设置为null
if taskID != 0 {
err = txM.TaskClass.DeleteTaskClassItemEmbeddedTime(ctx, taskID)
if err != nil {
return err
}
}
//再删除课程事件和嵌入的事件（通过级联删除实现）
err = txM.Schedule.DeleteScheduleEventAndSchedule(ctx, req.ID, userID)
if err != nil {
return err
}
continue
}
//2.只删课程事件
if req.DeleteCourse {
//2.1.检查课程是否有嵌入的任务事件
exists, err := txM.Schedule.IfScheduleEventIDExists(ctx, req.ID)
if err != nil {
return err
}
if !exists {
return respond.WrongScheduleEventID
}
embeddedTaskID, err := txM.Schedule.GetScheduleEmbeddedTaskID(ctx, req.ID)
if err != nil {
return err
}
//2.2.如果有，则需另外为其创建新的scheduleEvent（type=task）
//课程事件先删除后再创建任务事件
if embeddedTaskID != 0 {
//2.2.1.先通过id取出taskClassItem详情
taskClassItem, err := txM.TaskClass.GetTaskClassItemByID(ctx, embeddedTaskID)
if err != nil {
return err
}
//下方开启事务，删除课程事件并创建新的任务事件
//2.2.2.删除课程事件
txErr := txM.Schedule.DeleteScheduleEventAndSchedule(ctx, req.ID, userID)
if txErr != nil {
return txErr
}
//2.2.3.再复用代码创建新的scheduleEvent，下方代码改编自AddTaskClassItemIntoSchedule函数
//直接构造Schedule模型
sections := make([]int, 0, taskClassItem.EmbeddedTime.SectionTo-taskClassItem.EmbeddedTime.SectionFrom+1)
// 这里的 req 主要是为了传递 Week 和 DayOfWeek，其他字段不需要了
schedules, scheduleEvent := conv.UserInsertTaskItemRequestToModel(
&model.UserInsertTaskClassItemToScheduleRequest{
Week: taskClassItem.EmbeddedTime.Week,
DayOfWeek: taskClassItem.EmbeddedTime.DayOfWeek},
taskClassItem, nil, userID, taskClassItem.EmbeddedTime.SectionFrom, taskClassItem.EmbeddedTime.SectionTo)
//将节次区间转换为节次切片，方便后续检查冲突
for section := taskClassItem.EmbeddedTime.SectionFrom; section <= taskClassItem.EmbeddedTime.SectionTo; section++ {
sections = append(sections, section)
}
//单用户不存在删除时这个格子被占用的情况，所以不检查冲突了
/*//4.1 统一检查冲突（避免逐条查库）
conflict, err := ss.scheduleDAO.HasUserScheduleConflict(ctx, userID, req.Week, req.DayOfWeek, sections)
if err != nil {
return err
}
if conflict {
return respond.ScheduleConflict
}*/
// 5. 写入数据库（通过 RepoManager 统一管理事务）
// 这里的 sv.daoManager 是你在初始化 Service 时注入的全局 RepoManager 实例
// 5.1 使用事务中的 ScheduleRepo 插入 Event
// 💡 这里的 txM.Schedule 已经注入了事务句柄
eventID, txErr := txM.Schedule.AddScheduleEvent(scheduleEvent)
if txErr != nil {
return txErr // 触发回滚
}
// 5.2 关联 ID（纯内存操作，无需 tx）
for i := range schedules {
schedules[i].EventID = eventID
}
// 5.3 使用事务中的 ScheduleRepo 批量插入原子槽位
// 💡 如果这里因为外键或唯一索引报错，5.1 的 Event 也会被撤回
if _, txErr = txM.Schedule.AddSchedules(schedules); txErr != nil {
return txErr // 触发回滚
}
// 5.4 使用事务中的 TaskRepo 更新任务状态
// 💡 这里的 txM.Task 取代了你原来的 txDAO
if txErr = txM.TaskClass.UpdateTaskClassItemEmbeddedTime(ctx, embeddedTaskID, taskClassItem.EmbeddedTime); txErr != nil {
return txErr // 触发回滚
}
continue
}
//2.3.如果没有嵌入的事件，就直接删除课程事件
err = txM.Schedule.DeleteScheduleEventAndSchedule(ctx, req.ID, userID)
if err != nil {
return err
}
continue
}
//3.只删嵌入的事件
if req.DeleteEmbeddedTask {
//下面先设置schedule表的embedded_task_id字段为null，再设置task_items表的embedded_time字段为null，实现删除嵌入事件的效果
//3.1.先将schedule表的embedded_task_id字段设置为null
taskID, txErr := txM.Schedule.SetScheduleEmbeddedTaskIDToNull(ctx, req.ID)
if txErr != nil {
return txErr
}
//3.2.再将task_items表的embedded_time字段设置为null
txErr = txM.TaskClass.DeleteTaskClassItemEmbeddedTime(ctx, taskID)
if txErr != nil {
return txErr
}
continue
}
}
return nil
})
if err != nil {
return err
}
return nil
}