iotlcm/internal/service/workorder/service.go

package workorder

import (
	"context"
	"time"

	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/os/gtime"

	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/dao"
	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model"
	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model/do"
	"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model/entity"
)

const (
	statusResolved = 3
	statusClosed   = 4
	operationClose = 4
)

type Service struct{}

func New() *Service {
	return &Service{}
}

func (s *Service) AutoCloseResolved(ctx context.Context, message model.WorkOrderAutoCloseMessage) error {
	if message.WoNo == "" {
		return nil
	}
	g.Log().Infof(ctx, "work order auto close received, woNo:%s", message.WoNo)
	return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		current := entity.TWoMain{}
		if err := tx.Ctx(ctx).Model(dao.TWoMain.Table()).
			Where(dao.TWoMain.Columns().WoNo, message.WoNo).
			Scan(&current); err != nil {
			return gerror.Wrap(err, "query work order failed")
		}
		if current.WoNo == "" || current.CurrentStatus != statusResolved {
			return nil
		}
		if current.ResolveTime == nil || current.ResolveTime.Add(72*time.Hour).After(gtime.Now()) {
			return nil
		}
		if message.ResolveTimeTs > 0 && (current.ResolveTime == nil || current.ResolveTime.Timestamp() != message.ResolveTimeTs) {
			g.Log().Infof(ctx, "work order auto close skipped, resolve time changed, woNo:%s, messageResolveTime:%d", message.WoNo, message.ResolveTimeTs)
			return nil
		}

		operatorID := int64(0)
		now := gtime.Now()
		result, err := tx.Ctx(ctx).Model(dao.TWoMain.Table()).
			Where(dao.TWoMain.Columns().Id, current.Id).
			Where(dao.TWoMain.Columns().TenantId, current.TenantId).
			Where(dao.TWoMain.Columns().ResolveTime, current.ResolveTime).
			Where(dao.TWoMain.Columns().CurrentStatus, statusResolved).
			Data(do.TWoMain{
				CurrentStatus: statusClosed,
				CloseTime:     now,
				UpdatedBy:     operatorID,
			}).Update()
		if err != nil {
			return gerror.Wrap(err, "auto close work order failed")
		}
		affected, err := result.RowsAffected()
		if err != nil || affected == 0 {
			return err
		}

		_, err = tx.Ctx(ctx).Model(dao.TWoRecord.Table()).Data(do.TWoRecord{
			WoNo:            message.WoNo,
			OperationType:   operationClose,
			OperationDeptId: current.HandlerDeptId,
			OperationUserId: operatorID,
			BeforeStatus:    statusResolved,
			AfterStatus:     statusClosed,
			TenantId:        current.TenantId,
			CreatedDept:     current.CreatedDept,
			CreatedBy:       operatorID,
		}).Insert()
		if err != nil {
			return gerror.Wrap(err, "保存自动完结记录失败")
		}
		return saveAutoCloseNotice(ctx, tx, &current)
	})
}

func (s *Service) CloseOverdue(ctx context.Context) error {
	var rows []*entity.TWoMain
	if err := dao.TWoMain.Ctx(ctx).Where(dao.TWoMain.Columns().CurrentStatus, statusResolved).WhereLTE(dao.TWoMain.Columns().ResolveTime, gtime.Now().Add(-72*time.Hour)).OrderAsc(dao.TWoMain.Columns().ResolveTime).Limit(100).Scan(&rows); err != nil {
		return gerror.Wrap(err, "查询到期工单失败")
	}
	for _, row := range rows {
		if row == nil || row.ResolveTime == nil {
			continue
		}
		if err := s.AutoCloseResolved(ctx, model.WorkOrderAutoCloseMessage{WoNo: row.WoNo, ResolveTimeTs: row.ResolveTime.Timestamp()}); err != nil {
			g.Log().Errorf(ctx, "工单补偿关闭失败 woNo:%s err:%v", row.WoNo, err)
		}
	}
	return nil
}