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

package service

import (
	"dy-admin/internal/pcmserver/bus/model"
	"dy-admin/internal/pcmserver/bus/model/request"
	"dy-admin/internal/pcmserver/common"
	"dy-admin/internal/pcmserver/global"
	"dy-admin/internal/pcmserver/pkg/code"
	"dy-admin/internal/pcmserver/pkg/crontab"
	"dy-admin/internal/pcmserver/utils"
	"dy-admin/pkg/rescode"
	"fmt"
	"sort"
	"strconv"
	"strings"
)

type CabinetTimeService struct {
}

func (s *CabinetTimeService) initCabinetTimeCronTab() {
	var list []model.CabinetTime
	err := global.DB.Order("id asc").Find(&list).Error
	if err != nil {
		panic(err)
	}
	for _, ct := range list {
		err = setCabinetTimeCronTab(ct)
		if err != nil {
			panic(err)
		}
	}
}

func (s *CabinetTimeService) CreateCabinetTime(ct model.CabinetTime) (err error) {
	actTime, err := utils.ParseTime(ct.ActTimeStr)
	if err != nil {
		return err
	}
	ct.ActTime = actTime
	repeatSlice := strings.Split(ct.Repeat, ",")
	for _, weekStr := range repeatSlice {
		week, err := strconv.Atoi(weekStr)
		if err != nil {
			return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetTimeInvalidCode])
		}
		if week < 0 || week > 6 {
			return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrCabinetTimeInvalidCode])
		}
	}
	tx := global.DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	err = tx.Create(&ct).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	// 启用定时任务
	err = setCabinetTimeCronTab(ct)
	if err != nil {
		return err
	}
	return
}

func (s *CabinetTimeService) DeleteCabinetTime(id int) (err error) {
	err = global.DB.Delete(&model.CabinetTime{Model: common.Model{ID: id}}).Error
	if err != nil {
		return
	}
	// 删除定时任务
	err = crontab.GetCron("cabinet_time").RemoveJob(strconv.Itoa(id))
	if err != nil {
		return
	}
	return
}

func (s *CabinetTimeService) ChangeUseStatus(id int, status string) (err error) {
	var cabinetTime model.CabinetTime
	err = global.DB.Where("id = ?", id).First(&cabinetTime).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	tx := global.DB.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()

	err = tx.Where("id = ?", id).Updates(&model.CabinetTime{UseRule: status}).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	if status == "启用" && cabinetTime.UseRule == "禁用" {
		// 开启定时器
		cabinetTime.UseRule = "启用"
		err = setCabinetTimeCronTab(cabinetTime)
		if err != nil {
			return
		}
	}

	if status == "禁用" && cabinetTime.UseRule == "启用" {
		err = crontab.GetCron("cabinet_time").RemoveJob(strconv.Itoa(id))
		if err != nil {
			return
		}
	}

	return
}

func (s *CabinetTimeService) GetCabinetTimeList(info request.CabinetTimeSearch) (list []model.CabinetTime, total int64, err error) {
	limit := info.PageSize
	offset := info.PageSize * (info.Page - 1)

	db := global.DB.Model(&model.CabinetTime{})
	err = db.Count(&total).Error
	if err != nil {
		return
	}
	if err = db.Order("id asc").Limit(limit).Offset(offset).Where("cabinet_id = ?", info.CabinetID).Find(&list).Error; err != nil {
		return list, total, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	return
}

func setCabinetTimeCronTab(ct model.CabinetTime) (err error) {
	if ct.UseRule != "启用" {
		return nil
	}
	jobName := strconv.Itoa(ct.ID)
	job := &CabinetTimeCronJob{CabinetID: ct.CabinetID, Action: ct.Act}

	secondStr := strconv.Itoa(ct.ActTime.Second())
	minuteStr := strconv.Itoa(ct.ActTime.Minute())
	hourStr := strconv.Itoa(ct.ActTime.Hour())

	spec := fmt.Sprintf("%s %s %s %s %s %s", secondStr, minuteStr, hourStr, "*", "*", parseRepeat(ct.Repeat))
	err = crontab.GetCron("cabinet_time").AddJobWithParams(jobName, spec, job)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetTimeCornTabCode])
	}
	return nil
}

type WeekDays []string

func (w WeekDays) Len() int {
	return len(w)
}

func (w WeekDays) Swap(i, j int) {
	w[i], w[j] = w[j], w[i]
}

func (w WeekDays) Less(i, j int) bool {
	return w[i] < w[j]
}

func parseRepeat(repeat string) string {
	repeatSlice := strings.Split(repeat, ",")
	// 去重
	weekdays := removeRepeatByMap(repeatSlice)
	// 排序
	sort.Sort(weekdays)

	res := strings.Join(weekdays, ",")

	return res
}

// removeRepeatByMap 切片去重,使用字典方式
func removeRepeatByMap(weekday []string) WeekDays {
	res := make([]string, 0)
	tmpMap := make(map[string]struct{})
	for _, wd := range weekday {
		if _, ok := tmpMap[wd]; !ok {
			tmpMap[wd] = struct{}{}
			res = append(res, wd)
		}
	}
	return res
}