fonchain-fiee/pkg/service/exam/exam_task.go

package exam

import (
	"context"

	"fmt"

	"time"

	"dubbo.apache.org/dubbo-go/v3/common/logger"
	"github.com/fonchain_enterprise/fonchain-main/api/account"
	"github.com/fonchain_enterprise/fonchain-main/api/exam"
	"github.com/fonchain_enterprise/fonchain-main/pkg/e"
	"github.com/fonchain_enterprise/fonchain-main/pkg/model/login"
	"github.com/fonchain_enterprise/fonchain-main/pkg/serializer"
	"github.com/fonchain_enterprise/fonchain-main/pkg/service"
	"github.com/gin-gonic/gin"
)

func SaveExamTask(c *gin.Context) {
	req := new(exam.ExamTaskInfo)
	if err := c.ShouldBind(req); err != nil {
		logger.Errorf("SaveExamTask ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	userInfo := login.GetUserInfoFromC(c)
	logger.Info("-------------------------------")
	logger.Info("userInfo:", userInfo)
	req.CreaterName = userInfo.NickName
	req.CreaterID = int32(userInfo.ID)

	res, err := service.GrpcExamClientImpl.SaveExamTask(context.Background(), req)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func UpdateExamTask(c *gin.Context) {
	req := new(exam.ExamTaskInfo)
	if err := c.ShouldBind(req); err != nil {
		logger.Errorf("UpdateExamTask ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	res, err := service.GrpcExamClientImpl.UpdateExamTask(context.Background(), req)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func DeleteExamTask(c *gin.Context) {
	req := new(exam.ExamTaskInfo)
	if err := c.ShouldBind(req); err != nil {
		logger.Errorf("DeleteExamTask ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	res, err := service.GrpcExamClientImpl.DeleteExamTask(context.Background(), req)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func GetExamTasks(c *gin.Context) {
	req := new(exam.ExamTaskPageRequest)
	if err := c.ShouldBind(req); err != nil {
		logger.Errorf("GetExamTasks ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	res, err := service.GrpcExamClientImpl.GetExamTasks(context.Background(), req)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	if res != nil && len(res.ExamTaskInfo) > 0 {
		for _, examTaskInfo := range res.ExamTaskInfo {
			positionIds := make([]uint32, 0)
			if examTaskInfo.Examinee != nil {
				for _, value := range examTaskInfo.Examinee {
					if value.PositionId != 0 {
						positionIds = append(positionIds, uint32(value.PositionId))
					}
				}
			}
			// 查询部门下人数
			accountReq := account.ListV2Request{
				Page:        1,
				PageSize:    9999,
				PositionIds: positionIds,
			}
			fmt.Println("========== 部门下请求：", accountReq.PositionIds)
			timer := time.Now() // 记录开始时间
			accountRes, accountErr := service.AccountProvider.ListV2(context.Background(), &accountReq)
			if accountErr != nil {
				service.Error(c, e.Error, accountErr)
				return
			}
			elapsed := time.Since(timer) // 计算自开始时间以来经过的时间
			fmt.Printf("ListV2 耗时 %v milliseconds\n", elapsed.Milliseconds())

			examTaskInfo.TotalNum = int32(accountRes.Count)
			examTaskInfo.UnexamNum = examTaskInfo.TotalNum - examTaskInfo.PassNum - examTaskInfo.FailNum

			updateNumInfo := exam.ExamTaskInfo{
				ID:        examTaskInfo.ID,
				TotalNum:  examTaskInfo.TotalNum,
				PassNum:   examTaskInfo.PassNum,
				FailNum:   examTaskInfo.FailNum,
				UnexamNum: examTaskInfo.UnexamNum,
			}
			_, updateErr := service.GrpcExamClientImpl.UpdateExamTaskNum(context.Background(), &updateNumInfo)
			if updateErr != nil {
				service.Error(c, e.Error, updateErr)
				return
			}
		}
	}

	service.Success(c, res)
}

func DetailExamTask(c *gin.Context) {
	req := new(exam.ExamTaskIdRequest)
	if err := c.ShouldBind(req); err != nil {
		logger.Errorf("DetailExamTask ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	res, err := service.GrpcExamClientImpl.DetailExamTask(context.Background(), req)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func CheckExamTask(c *gin.Context) {
	req := new(exam.ExamTaskCheckPageRequest)
	if err := c.ShouldBind(req); err != nil {
		logger.Errorf("CheckExamTask ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	res, err := service.GrpcExamClientImpl.CheckExamTask(context.Background(), req)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func PublishExamTask(c *gin.Context) {
	req := new(exam.ExamTaskPublishRequest)
	if err := c.ShouldBind(req); err != nil {
		logger.Errorf("PublishExamTask ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	res, err := service.GrpcExamClientImpl.PublishExamTask(context.Background(), req)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}

func UpdateExamTaskRange(c *gin.Context) {
	req := new(exam.UpdateExamTaskRangeRequest)
	if err := c.ShouldBind(req); err != nil {
		logger.Errorf("UpdateExamTaskRange ShouldBind err", err)
		service.ResponseMsg(c, e.SUCCESS, serializer.Response{
			Msg:    err.Error(),
			Status: e.Failed,
		})
		return
	}

	userInfo := login.GetUserInfoFromC(c)
	logger.Info("-------------------------------")
	logger.Info("userInfo:", userInfo)
	req.UpdaterName = userInfo.NickName
	req.UpdaterID = int32(userInfo.ID)

	res, err := service.GrpcExamClientImpl.UpdateExamTaskRange(context.Background(), req)

	if err != nil {
		service.Error(c, e.Error, err)
		return
	}

	service.Success(c, res)
}