magic_admin/service/daytask/dt_task.go

package daytask

import (
	"fmt"
	"time"

	model "go_server/model/biz_modules/daytask"
	"go_server/model/common/response"
	"go_server/service/base"

	"github.com/gin-gonic/gin"
)

// DtTaskCategoryService 任务分类服务
type DtTaskCategoryService struct {
	base.BizCommonService
}

func (s *DtTaskCategoryService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskCategory()).Get(c, s.DB())
}

func (s *DtTaskCategoryService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id       *int64  `form:"id"`
		Name     *string `form:"name"`
		Platform *string `form:"platform"`
		Status   *int8   `form:"status"`
	}
	req := new(request[model.DtTaskCategory])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.Id != nil && *req.Id != 0 {
		db = db.Where("id", req.Id)
	}
	if req.Name != nil && *req.Name != "" {
		db = db.Where("name LIKE ?", "%"+*req.Name+"%")
	}
	if req.Platform != nil && *req.Platform != "" {
		db = db.Where("platform", req.Platform)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	db = db.Order("sort ASC")

	colInfo := s.GetColumnCommentFromStruct(model.DtTaskCategory{})
	resp, err := base.NewQueryBaseHandler(model.NewDtTaskCategory()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtTaskCategoryService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskCategory()).Create(c, s.DB())
}

func (s *DtTaskCategoryService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskCategory()).UpdateOne(c, s.DB())
}

func (s *DtTaskCategoryService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskCategory()).DeleteOne(c, s.DB())
}

// DtTaskService 任务服务
type DtTaskService struct {
	base.BizCommonService
}

func (s *DtTaskService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTask()).Get(c, s.DB())
}

func (s *DtTaskService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id         *int64  `form:"id"`
		TaskNo     *string `form:"taskNo"`
		CategoryId *int64  `form:"categoryId"`
		Title      *string `form:"title"`
		TaskType   *int8   `form:"taskType"`
		Status     *int8   `form:"status"`
		MinLevel   *int    `form:"minLevel"`
		BeginTime  *int64  `form:"beginTime"`
		EndTime    *int64  `form:"endTime"`
	}
	req := new(request[model.DtTask])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.Id != nil && *req.Id != 0 {
		db = db.Where("id", req.Id)
	}
	if req.TaskNo != nil && *req.TaskNo != "" {
		db = db.Where("task_no", req.TaskNo)
	}
	if req.CategoryId != nil && *req.CategoryId != 0 {
		db = db.Where("category_id", req.CategoryId)
	}
	if req.Title != nil && *req.Title != "" {
		db = db.Where("title LIKE ?", "%"+*req.Title+"%")
	}
	if req.TaskType != nil {
		db = db.Where("task_type", req.TaskType)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	if req.MinLevel != nil {
		db = db.Where("min_level >= ?", req.MinLevel)
	}
	if req.BeginTime != nil && *req.BeginTime > 0 && req.EndTime != nil && *req.EndTime > 0 {
		db = db.Where("created_at BETWEEN ? AND ?", *req.BeginTime, *req.EndTime)
	}

	colInfo := s.GetColumnCommentFromStruct(model.DtTask{})
	resp, err := base.NewQueryBaseHandler(model.NewDtTask()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtTaskService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTask()).Create(c, s.DB())
}

func (s *DtTaskService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTask()).UpdateOne(c, s.DB())
}

func (s *DtTaskService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTask()).DeleteOne(c, s.DB())
}

// DtTaskStepService 任务步骤服务
type DtTaskStepService struct {
	base.BizCommonService
}

func (s *DtTaskStepService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskStep()).Get(c, s.DB())
}

func (s *DtTaskStepService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		TaskId *int64 `form:"taskId"`
	}
	req := new(request[model.DtTaskStep])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.TaskId != nil && *req.TaskId != 0 {
		db = db.Where("task_id", req.TaskId)
	}
	db = db.Order("step_no ASC")

	colInfo := s.GetColumnCommentFromStruct(model.DtTaskStep{})
	resp, err := base.NewQueryBaseHandler(model.NewDtTaskStep()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtTaskStepService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskStep()).Create(c, s.DB())
}

func (s *DtTaskStepService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskStep()).UpdateOne(c, s.DB())
}

func (s *DtTaskStepService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskStep()).DeleteOne(c, s.DB())
}

// DtTaskExampleService 审核样例服务
type DtTaskExampleService struct {
	base.BizCommonService
}

func (s *DtTaskExampleService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskExample()).Get(c, s.DB())
}

func (s *DtTaskExampleService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		TaskId *int64 `form:"taskId"`
	}
	req := new(request[model.DtTaskExample])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.TaskId != nil && *req.TaskId != 0 {
		db = db.Where("task_id", req.TaskId)
	}
	db = db.Order("sort ASC, id ASC")

	colInfo := s.GetColumnCommentFromStruct(model.DtTaskExample{})
	resp, err := base.NewQueryBaseHandler(model.NewDtTaskExample()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtTaskExampleService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskExample()).Create(c, s.DB())
}

func (s *DtTaskExampleService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskExample()).UpdateOne(c, s.DB())
}

func (s *DtTaskExampleService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtTaskExample()).DeleteOne(c, s.DB())
}

// DtUserTaskService 用户任务记录服务
type DtUserTaskService struct {
	base.BizCommonService
}

func (s *DtUserTaskService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtUserTask()).Get(c, s.DB())
}

func (s *DtUserTaskService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id        *int64  `form:"id"`
		OrderNo   *string `form:"orderNo"`
		UserId    *int64  `form:"userId"`
		UserUid   *string `form:"userUid"`
		TaskId    *int64  `form:"taskId"`
		TaskNo    *string `form:"taskNo"`
		Status    *int8   `form:"status"`
		BeginTime *int64  `form:"beginTime"`
		EndTime   *int64  `form:"endTime"`
	}
	req := new(request[model.DtUserTask])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.Id != nil && *req.Id != 0 {
		db = db.Where("id", req.Id)
	}
	if req.OrderNo != nil && *req.OrderNo != "" {
		db = db.Where("order_no", req.OrderNo)
	}
	if req.UserId != nil && *req.UserId != 0 {
		db = db.Where("user_id", req.UserId)
	}
	if req.UserUid != nil && *req.UserUid != "" {
		db = db.Where("user_uid", req.UserUid)
	}
	if req.TaskId != nil && *req.TaskId != 0 {
		db = db.Where("task_id", req.TaskId)
	}
	if req.TaskNo != nil && *req.TaskNo != "" {
		db = db.Where("task_no", req.TaskNo)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	if req.BeginTime != nil && *req.BeginTime > 0 && req.EndTime != nil && *req.EndTime > 0 {
		db = db.Where("created_at BETWEEN ? AND ?", *req.BeginTime, *req.EndTime)
	}

	colInfo := s.GetColumnCommentFromStruct(model.DtUserTask{})
	resp, err := base.NewQueryBaseHandler(model.NewDtUserTask()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtUserTaskService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtUserTask()).Create(c, s.DB())
}

func (s *DtUserTaskService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtUserTask()).UpdateOne(c, s.DB())
}

func (s *DtUserTaskService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtUserTask()).DeleteOne(c, s.DB())
}

// Audit 审核任务
func (s *DtUserTaskService) Audit(c *gin.Context) {
	s.SetDbAlias("daytask")
	db := s.DB()
	now := time.Now().Unix()

	type request struct {
		Id           int64  `json:"id" binding:"required"`
		Status       int8   `json:"status" binding:"required"` // 2=通过 3=拒绝
		AuditRemark  string `json:"auditRemark"`
		RejectReason string `json:"rejectReason"`
	}
	var req request
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	if req.Status != 2 && req.Status != 3 {
		response.Resp(c, "状态值无效")
		return
	}

	// 查询用户任务记录
	var userTask model.DtUserTask
	if err := db.Where("id = ? AND status = 1", req.Id).First(&userTask).Error; err != nil {
		response.Resp(c, "任务记录不存在或状态不正确")
		return
	}

	// 开启事务
	tx := db.Begin()

	// 更新任务状态
	updates := map[string]interface{}{
		"status":       req.Status,
		"audit_remark": req.AuditRemark,
		"audit_time":   now,
	}
	if req.Status == 3 {
		updates["reject_reason"] = req.RejectReason
	}

	if err := tx.Model(&model.DtUserTask{}).Where("id = ?", req.Id).Updates(updates).Error; err != nil {
		tx.Rollback()
		response.Resp(c, err.Error())
		return
	}

	// 审核通过，发放奖励
	if req.Status == 2 {
		// 1. 查询用户信息
		var user model.DtUser
		if err := tx.Where("id = ?", userTask.UserId).First(&user).Error; err != nil {
			tx.Rollback()
			response.Resp(c, "用户不存在")
			return
		}

		// 2. 更新任务完成数量
		tx.Exec("UPDATE dt_task SET completed_count = completed_count + 1 WHERE id = ?", userTask.TaskId)

		// 3. 给用户发放任务奖励
		rewardAmount := userTask.RewardAmount
		newBalance := user.Balance + rewardAmount

		tx.Model(&model.DtUser{}).Where("id = ?", user.Id).Updates(map[string]interface{}{
			"balance":           newBalance,
			"total_task_income": user.TotalTaskIncome + rewardAmount,
			"total_task_count":  user.TotalTaskCount + 1,
		})

		// 4. 记录用户余额流水
		tx.Create(&model.DtBalanceLog{
			UserId:        user.Id,
			UserUid:       user.Uid,
			Type:          "task_reward",
			Amount:        rewardAmount,
			BalanceBefore: user.Balance,
			BalanceAfter:  newBalance,
			RelatedId:     userTask.Id,
			RelatedNo:     userTask.OrderNo,
			Title:         "任务奖励 - " + userTask.TaskTitle,
			Remark:        "完成任务获得奖励",
			CreatedAt:     now,
		})

		// 5. 处理一级上级返佣
		if user.ParentId > 0 {
			// 获取返佣比例配置
			var config model.DtConfig
			commissionRate := 0.1 // 默认10%
			if err := tx.Where("`group` = ? AND `key` = ?", "commission", "level1_rate").First(&config).Error; err == nil {
				if rate, err := parseFloat(config.Value); err == nil && rate > 0 {
					commissionRate = rate
				}
			}

			// 计算返佣金额
			commission := rewardAmount * commissionRate
			if commission > 0 {
				// 查询上级用户
				var parent model.DtUser
				if err := tx.Where("id = ?", user.ParentId).First(&parent).Error; err == nil {
					// 更新上级余额
					parentNewBalance := parent.Balance + commission
					tx.Model(&model.DtUser{}).Where("id = ?", parent.Id).Updates(map[string]interface{}{
						"balance":             parentNewBalance,
						"total_invite_income": parent.TotalInviteIncome + commission,
					})

					// 记录上级余额流水
					tx.Create(&model.DtBalanceLog{
						UserId:        parent.Id,
						UserUid:       parent.Uid,
						Type:          "invite_reward",
						Amount:        commission,
						BalanceBefore: parent.Balance,
						BalanceAfter:  parentNewBalance,
						RelatedId:     userTask.Id,
						RelatedNo:     userTask.OrderNo,
						Title:         "推广返佣 - " + user.Nickname,
						Remark:        "下级完成任务返佣",
						CreatedAt:     now,
					})
				}
			}
		}
	}

	tx.Commit()
	response.Resp(c, "操作成功")
}

// parseFloat 解析浮点数
func parseFloat(s string) (float64, error) {
	var f float64
	_, err := fmt.Sscanf(s, "%f", &f)
	return f, err
}