dy-admin-temp/internal/pcmserver/bus/service/work_time_cron_job.go

package service

import (
	"dy-admin/internal/pcmserver/bus/cabinet_pkg"
	"dy-admin/internal/pcmserver/bus/model"
	"dy-admin/internal/pcmserver/global"
	"dy-admin/internal/pcmserver/utils"
	"dy-admin/pkg/log"
	"fmt"
	"go.uber.org/zap"
	"gorm.io/gorm"
	"time"
)

type WorkTimeCronJob struct {
}

func (job *WorkTimeCronJob) Run() {
	var err error
	var execRes = "定时任务已执行，执行信息： "
	now := time.Now()
	defer func() {
		// 记录执行日志
		err := global.DB.Create(&model.CronLog{
			ExecTime: now,
			CronName: "work_time",
			CronRes:  execRes,
		}).Error
		if err != nil {
			log.Error("create cron log err", zap.Error(err))
		}
	}()

	datetimeString := utils.FormatMinuteTime(&now)
	cond, _ := utils.ParseMinuteTime(datetimeString)
	timeString := utils.FormatTime(&now)
	chWeekDay := utils.ParseChWeekDay(&now)
	// 找到例外时间 例外时间   非工作日： 开始-可以开  结束-不允许开  工作日：相反
	specTime := &model.SpecialTime{}
	err = global.DB.Where("start_time <= ?", cond).Where("end_time >= ?", cond).First(specTime).Error
	if err != nil && err != gorm.ErrRecordNotFound {
		log.Error("find spec time err", zap.Error(err))
	}

	// 内存中拿到所有的柜子信息
	cabinets := cabinet_pkg.GetCabinets()
	workTimeCabinets := make([]int, 0, len(cabinets))
	for _, cabinet := range cabinets {
		// 1. 从柜子时间管理中找，如果有单独柜子时间管理。优先柜子时间管理的规则，此处不处理
		var cabinetTimeCount int64
		err = global.DB.Model(&model.CabinetTime{}).Where("cabinet_id = ?", cabinet.CabinetID).Where("use_rule = ?", "启用").Count(&cabinetTimeCount).Error
		if err != nil {
			log.Error("get cabinetTimeCount err", zap.Error(err))
			continue
		}

		if cabinetTimeCount > 0 {
			// 柜子单独的时间管理规则优先。
			log.Info("cabinetTimeCount > 0,top Level,do nothing", zap.Int("cabinetId", cabinet.CabinetID), zap.Int64("cabinetTimeCount", cabinetTimeCount))
			continue
		}
		workTimeCabinets = append(workTimeCabinets, cabinet.CabinetID)
	}

	if len(workTimeCabinets) != 0 {
		// 2. 如果当前时间在例外时间段内，根据例外时间的 工作日还是非工作日进行处理。优先级第二高
		if specTime.ID != 0 {
			execRes += processSpecTime(workTimeCabinets, specTime, datetimeString)

		} else {
			// 3. 如果当前时间不在例外时间段内。根据当前日期为星期几模糊匹配。如果点数相同，看是工作日还是非工作日。下发指令
			execRes += processWorkTime(workTimeCabinets, chWeekDay, timeString)
		}
	} else {
		execRes += "没有符合条件的柜子"
	}
}

func processSpecTime(cabinetIds []int, specTime *model.SpecialTime, nowDataTime string) string {
	var (
		isStart, isEnd, isWork bool
		errs                   []error
		execRes                string
	)
	// 例外时间的开始时间=当前时间
	if specTime.StartTimeStr == nowDataTime {
		isStart = true
	}

	if specTime.EndTimeStr == nowDataTime {
		isEnd = true
	}

	if specTime.WorkDay == "工作日" {
		isWork = true
	}

	if isStart {
		if isWork {
			// 开始时间 工作日 不允许开
			errs = DisableCabinets(cabinetIds)
		} else {
			// 开始时间 非工作日 允许开
			errs = EnableCabinets(cabinetIds)
		}
	}

	if isEnd {
		if isWork {
			// 结束时间 工作日 允许开
			errs = EnableCabinets(cabinetIds)
		} else {
			// 结束时间 非工作日 不允许开
			errs = DisableCabinets(cabinetIds)
		}
	}

	if len(errs) != 0 {

		for _, err := range errs {
			if err != nil {
				execRes = fmt.Sprintf("processSpecTime err.isStart:%t,isEnd:%t,isWork:%t,cabinetIds:%v,specTime.StartTimeStr:%s,nowDataTime:%s,specTime.WorkDay:%s,err:%s",
					isStart, isEnd, isWork, cabinetIds, specTime.StartTimeStr, nowDataTime, specTime.WorkDay, err.Error())
				log.Error(execRes)
			}
		}
		return execRes
	}

	if isStart || isEnd {
		execRes = fmt.Sprintf("processSpecTime success.isStart:%t,isEnd:%t,isWork:%t,cabinetIds:%v,specTime.StartTimeStr:%s,nowDataTime:%s,specTime.WorkDay:%s",
			isStart, isEnd, isWork, cabinetIds, specTime.StartTimeStr, nowDataTime, specTime.WorkDay)

		return execRes
	}

	execRes = fmt.Sprintf("processSpecTime do nothing.isStart:%t,isEnd:%t,isWork:%t,cabinetIds:%v,nowDataTime:%s", isStart, isEnd, isWork, cabinetIds, nowDataTime)

	return execRes
}

func processWorkTime(cabinetIds []int, weekDay string, timeStr string) string {
	// 模糊查询星期
	var workTimes []model.WorkTime
	var err error
	var errs []error
	var execRes string
	err = global.DB.Where("week_day like ?", weekDay+"%").Find(&workTimes).Error
	if err != nil {
		log.Error("find workTime err", zap.Error(err))
		return err.Error()
	}
	var (
		isStart, isEnd, isWork bool
	)
	for _, workTime := range workTimes {
		// 小时分钟是否相等
		if workTime.StartTimeStr == timeStr {
			isStart = true
		}
		if workTime.EndTimeStr == timeStr {
			isEnd = true
		}
		if workTime.WorkDay == "禁止开" {
			isWork = true
		}
	}

	if isEnd {
		if isWork {
			// 结束时间 工作日 允许开
			errs = EnableCabinets(cabinetIds)
		} else {
			// 结束时间 非工作日 不允许开
			errs = DisableCabinets(cabinetIds)
		}
	}

	if isStart {
		if isWork {
			// 开始时间 工作日 不允许开
			errs = DisableCabinets(cabinetIds)
		} else {
			// 开始时间 非工作日  允许开
			errs = EnableCabinets(cabinetIds)
		}

	}

	if len(errs) != 0 {
		for _, err := range errs {
			if err != nil {
				execRes = fmt.Sprintf("processWorkTime err.isStart:%t,isEnd:%t,isWork:%t,cabinetIds:%v,weekDay:%s,timeStr:%s,err:%s",
					isStart, isEnd, isWork, cabinetIds, weekDay, timeStr, err.Error())
				log.Error(execRes)
				return execRes
			}
		}
	}

	if isStart || isEnd {
		execRes = fmt.Sprintf("processWorkTime success.isStart:%t,isEnd:%t,isWork:%t,cabinetIds:%v,weekDay:%s,timeStr:%s",
			isStart, isEnd, isWork, cabinetIds, weekDay, timeStr)
		return execRes
	}
	execRes = fmt.Sprintf("processWorkTime do nothing.isStart:%t,isEnd:%t,isWork:%t,cabinetIds:%v,weekDay:%s,timeStr:%s",
		isStart, isEnd, isWork, cabinetIds, weekDay, timeStr)

	return execRes
}

func EnableCabinets(cabinetIds []int) (errs []error) {
	for _, cabinetId := range cabinetIds {
		err := ServicesGroupApp.CabinetService.ChangeCabinetStatus(cabinetId, "允许开启")
		if err != nil {
			errs = append(errs, err)
		}
	}
	return
}

func DisableCabinets(cabinetIds []int) (errs []error) {
	for _, cabinetId := range cabinetIds {
		err := ServicesGroupApp.CabinetService.ChangeCabinetStatus(cabinetId, "禁止开启")
		if err != nil {
			errs = append(errs, err)
		}
	}
	return
}