kpt-pasture/module/backend/work.go

package backend

import (
	"context"
	"errors"
	"fmt"
	"kpt-pasture/model"
	"kpt-pasture/util"
	"net/http"
	"strings"
	"time"

	pasturePb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
	"gitee.com/xuyiping_admin/pkg/logger/zaplog"
	"gitee.com/xuyiping_admin/pkg/xerr"
	"go.uber.org/zap"
	"gorm.io/gorm"
)

func (s *StoreEntry) OrderList(ctx context.Context, req *pasturePb.SearchWorkOrderRequest, pagination *pasturePb.PaginationModel) (*pasturePb.SearchWorkOrderResponse, error) {
	workOrderList := make([]*model.WorkOrder, 0)
	var count int64 = 0

	pref := s.DB.Model(new(model.WorkOrder))
	if req.Name != "" {
		pref.Where("name like ?", fmt.Sprintf("%s%s%s", "%", req.Name, "%"))
	}

	if req.Frequency > 0 {
		pref.Where("frequency = ?", req.Frequency)
	}

	if req.Priority > 0 {
		pref.Where("priority = ?", req.Priority)
	}

	if req.IsShow > 0 {
		pref.Where("is_show = ?", req.IsShow)
	}

	if req.SubscribeUnit > 0 {
		pref.Where("subscribe_unit = ?", req.SubscribeUnit)
	}

	if req.CategoryId > 0 {
		pref.Where("category_id = ?", req.CategoryId)
	}

	if err := pref.Order("id desc").Count(&count).Limit(int(pagination.PageSize)).Offset(int(pagination.PageOffset)).
		Find(&workOrderList).Error; err != nil {
		return nil, xerr.WithStack(err)
	}

	priorityMap := s.WorkOrderPriorityMap()
	frequencyMap := s.WorkOrderFrequencyMap()
	subscribeUnitMap := s.WorkOrderSubUnitMap()
	weekMap := s.WeekMap()
	monthMap := s.MonthMap()
	return &pasturePb.SearchWorkOrderResponse{
		Code:    http.StatusOK,
		Message: "ok",
		Data: &pasturePb.SearchWorkOrderData{
			List:     model.WorkOrderSlice(workOrderList).ToPB(priorityMap, frequencyMap, subscribeUnitMap, weekMap, monthMap),
			Total:    int32(count),
			PageSize: pagination.PageSize,
			Page:     pagination.Page,
		},
	}, nil
}

func (s *StoreEntry) OrderCreateOrUpdate(ctx context.Context, req *pasturePb.WorkOrderList) error {
	currentUser, _ := s.GetCurrentSystemUser(ctx)
	workOrderCategoryMap := s.WorkOrderCategoryMap()
	systemUserList, _ := s.SystemUserList(ctx)
	deptList, _ := s.SystemDeptList(ctx)
	newWorkOrder := model.NewWorkOrder(req, currentUser, systemUserList, deptList, workOrderCategoryMap)
	if req.Id <= 0 {
		if err := s.DB.Create(newWorkOrder).Error; err != nil {
			return xerr.WithStack(err)
		}

		// 发送异步数据
		defer func() {
			s.SendAsynqWorkOrder(ctx, newWorkOrder)
		}()
	} else {
		if err := s.DB.Where("id = ?", req.Id).Updates(newWorkOrder).Error; err != nil {
			return xerr.WithStack(err)
		}
	}
	return nil
}

func (s *StoreEntry) OrderIsShow(ctx context.Context, id int64) error {
	workOrder := &model.WorkOrder{Id: id}
	if err := s.DB.First(workOrder).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return xerr.Custom("该工单不存在")
		}
		return xerr.WithStack(err)
	}

	// 开启发送消息任务,需要判断今天工单任务是否已经生成过了
	defer func() {
		s.SendAsynqWorkOrder(ctx, workOrder)
	}()

	isShow := pasturePb.IsShow_No
	if workOrder.IsShow == pasturePb.IsShow_No {
		isShow = pasturePb.IsShow_Ok
	}

	if err := s.DB.Model(workOrder).Update("is_show", isShow).Error; err != nil {
		return xerr.WithStack(err)
	}

	return nil
}

func (s *StoreEntry) SendAsynqWorkOrder(ctx context.Context, workOrder *model.WorkOrder) {
	if workOrder.IsShow == pasturePb.IsShow_No {
		return
	}

	timeUnix, _ := util.ConvertParseLocalUnix(workOrder.ExecTime)
	nowTime := time.Now()
	// 过滤掉10秒内要执行的任务
	if timeUnix <= nowTime.Unix()+10 {
		return
	}

	// 判断是否是周任务，并且当前周不在执行周期内，则不执行任务
	if workOrder.WeekMonthValue != "" {
		execWeekMonth := strings.Split(workOrder.WeekMonthValue, ",")
		currentWeekMonth := ""
		if workOrder.Frequency == pasturePb.WorkOrderFrequency_Weekly {
			currentWeekMonth = fmt.Sprintf("%d", nowTime.Weekday())
		}

		if workOrder.Frequency == pasturePb.WorkOrderFrequency_Monthly {
			currentWeekMonth = fmt.Sprintf("%d", nowTime.Day())
		}

		var info bool
		for _, weekMonth := range execWeekMonth {
			if currentWeekMonth == weekMonth {
				info = true
				break
			}
		}

		// 如果有，则不执行任务
		if info {
			return
		}
	}

	execTime := time.Now().Unix() - timeUnix
	if _, err := s.AsynqClient.CtxEnqueue(ctx, model.NewTaskWorkOrderPayload(workOrder.Id, time.Duration(execTime)*time.Second)); err != nil {
		zaplog.Error("PushMessage CtxEnqueue", zap.Any("Err", err))
	}
}