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

package service

import (
	"dy-admin/internal/pcmserver/bus/cabinet_pkg"
	"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"
	systemService "dy-admin/internal/pcmserver/sys/service"
	"dy-admin/internal/pcmserver/utils"
	"dy-admin/pkg/log"
	"fmt"
	"go.uber.org/zap"
	"gorm.io/gorm"
	"strconv"
	"time"

	"dy-admin/pkg/rescode"
)

type LeaveLogService struct {
}

func (lls *LeaveLogService) initLeaveLogCronTab() {
	var list []model.LeaveLog
	err := global.DB.Where("status in (?)", []string{model.StatusWaiting, model.StatusExecuting}).Find(&list).Error
	if err != nil {
		panic(err)
	}
	for _, leaveLog := range list {
		err = parseLeaveCronTab(global.DB, leaveLog)
		if err != nil {
			panic(err)
		}
	}
}

func (lls *LeaveLogService) CreateLeaveLog(leaveLog model.LeaveLog) (err error) {

	// 查询人员所在的柜子
	var staff model.Staff
	err = global.DB.Where("id = ?", leaveLog.StaffID).First(&staff).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	// 查询柜子当前的状态
	memInfo := cabinet_pkg.GetCabinet(staff.CabinetID)
	if !memInfo.IsConnect {
		return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrCabinetNotConnectCode])
	}

	// 时间转换
	startTime, err := utils.ParseMinuteTime(leaveLog.StartTimeStr)
	if err != nil {
		return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrLeaveParseTimeCode])
	}

	endTime, err := utils.ParseMinuteTime(leaveLog.EndTimeStr)
	if err != nil {
		return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrLeaveParseTimeCode])
	}

	if startTime.After(*endTime) {
		return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrLeaveStartGTEndCode])
	}

	leaveLog.StartTime = startTime
	leaveLog.EndTime = endTime
	leaveLog.Status = model.StatusWaiting

	// 找到人员等待执行或者执行中的请假单
	var staffLeaveLogs []model.LeaveLog
	err = global.DB.Where("staff_id = ?", leaveLog.StaffID).Where("status in (?)", []string{model.StatusWaiting, model.StatusExecuting}).Find(&staffLeaveLogs).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	for _, staffLeaveLog := range staffLeaveLogs {
		if staffLeaveLog.EndTime.After(*leaveLog.StartTime) {
			return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrLeaveRepeatCode])
		}
	}

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

	err = tx.Create(&leaveLog).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	return parseLeaveCronTab(tx, leaveLog)

}

func (lls *LeaveLogService) UpdateLeaveLog(leaveLog model.LeaveLog) (err error) {

	// 查询人员所在的柜子
	var staff model.Staff
	err = global.DB.Where("id = ?", leaveLog.StaffID).First(&staff).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	// 查询柜子当前的状态
	memInfo := cabinet_pkg.GetCabinet(staff.CabinetID)
	if !memInfo.IsConnect {
		return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrCabinetNotConnectCode])
	}

	// 时间转换
	startTime, err := utils.ParseMinuteTime(leaveLog.StartTimeStr)
	if err != nil {
		return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrLeaveParseTimeCode])
	}

	endTime, err := utils.ParseMinuteTime(leaveLog.EndTimeStr)
	if err != nil {
		return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrLeaveParseTimeCode])
	}

	if startTime.After(*endTime) {
		return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrLeaveStartGTEndCode])
	}

	leaveLog.StartTime = startTime
	leaveLog.EndTime = endTime
	leaveLog.Status = model.StatusWaiting

	// 找到人员等待执行或者执行中的请假单
	//var staffLeaveLogs []model.LeaveLog
	//err = global.DB.Where("staff_id = ?", leaveLog.StaffID).Where("status in (?)", []string{model.StatusWaiting, model.StatusExecuting}).Find(&staffLeaveLogs).Error
	//if err != nil {
	//	return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	//}
	//for _, staffLeaveLog := range staffLeaveLogs {
	//	if staffLeaveLog.EndTime.After(*leaveLog.StartTime) {
	//		return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrLeaveRepeatCode])
	//	}
	//}

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

	err = tx.Updates(&leaveLog).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	return parseLeaveCronTab(tx, leaveLog)

}

func (lls *LeaveLogService) updateLeaveLogStatus(leaveLogId int, status string) (err error) {
	err = global.DB.Model(&model.LeaveLog{}).Where("id = ?", leaveLogId).Update("status", status).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	return
}

func (lls *LeaveLogService) DeleteLeaveLogByIds(ids common.IdsReq) (err error) {
	var count int64
	err = global.DB.Model(&model.LeaveLog{}).Where("status = ?", model.StatusExecuting).Where("id in (?)", ids.IDs).Count(&count).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	if count != 0 {
		return rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrLeaveDeleteExecutingCode])
	}

	var levelLogs []model.LeaveLog
	err = global.DB.Where("status in (?)", []string{model.StatusWaiting, model.StatusFinish}).Where("id in (?)", ids.IDs).Find(&levelLogs).Error
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	for _, levelLog := range levelLogs {
		leaveJobName := strconv.Itoa(levelLog.ID) + "-" + strconv.Itoa(int(LeaveJob))
		resetLeaveJobName := strconv.Itoa(levelLog.ID) + "-" + strconv.Itoa(int(ResetLeaveJob))
		err = crontab.GetCron("leave").RemoveJob(leaveJobName)
		if err != nil {
			return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrLeaveRemoveCornTabCode])
		}
		err = crontab.GetCron("leave").RemoveJob(resetLeaveJobName)
		if err != nil {
			return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrLeaveRemoveCornTabCode])
		}
	}

	if err = global.DB.Delete(&[]model.LeaveLog{}, "id in (?)", ids.IDs).Error; err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}

	return
}

func (lls *LeaveLogService) GetLeaveLog(id int) (*model.LeaveLog, error) {
	var record model.LeaveLog
	err := global.DB.Where("id = ?", id).First(&record).Error
	if err != nil {
		if err != gorm.ErrRecordNotFound {
			return nil, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
		} else {
			return nil, nil
		}
	}
	return &record, nil
}

func (lls *LeaveLogService) GetLeaveLogList(info request.LeaveLogRecordSearch, dataPermission *BusPermission) (levelLogs []model.LeaveLog, total int64, err error) {
	var limit, offset int
	if info.Page == 0 || info.PageSize == 0 {
		limit = -1
		offset = -1
	} else {
		limit = info.PageSize
		offset = info.PageSize * (info.Page - 1)
	}

	var (
		startTime, endTime *time.Time
	)

	if info.StartTimeStr != "" {
		startTime, err = utils.ParseMinuteTime(info.StartTimeStr)
		if err != nil {
			return levelLogs, total, rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrLeaveParseTimeCode])
		}
	}

	if info.EndTimeStr != "" {
		endTime, err = utils.ParseMinuteTime(info.EndTimeStr)
		if err != nil {
			return levelLogs, total, rescode.RegisterErrorWithCause(nil, code.ErrCodeMap[code.ErrLeaveParseTimeCode])
		}
	}
	var leaveModel model.LeaveLog
	db := global.DB.Model(&leaveModel).Scopes(Permission(leaveModel.TableName(), dataPermission))

	if info.Status != "" {
		db = db.Where("status = ?", info.Status)
	}
	if info.StaffName != "" {
		db = db.Where("staff_name LIKE ?", "%"+info.StaffName+"%")
	}
	if info.Type != "" {
		db = db.Where("type = ?", info.Type)
	}

	if info.DeptID != 0 {
		deptIds, err := systemService.ServicesGroupApp.DeptService.GetSonDeptIds(info.DeptID)
		if err != nil {
			log.Warn("get son deptIds err", zap.Error(err))
		} else {
			db = db.Where("department_id in (?)", deptIds)
		}

	}
	if startTime != nil && endTime == nil {
		db = db.Where("start_time > ?", startTime).Where("end_time < ?", time.Now())
	}
	if endTime != nil && startTime == nil {
		db = db.Where("start_time > ?", time.Now()).Where("end_time < ?", endTime)
	}
	if startTime != nil && endTime != nil {
		db = db.Where("start_time > ?", startTime).Where("end_time < ?", endTime)
	}

	err = db.Count(&total).Error
	if err != nil {
		return
	}
	if err = db.Order("id desc").Limit(limit).Offset(offset).Find(&levelLogs).Error; err != nil {
		return levelLogs, total, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
	}
	return
}

func (lls *LeaveLogService) getLeaveByStaffID(staffId int) (leaveLog *model.LeaveLog, err error) {
	var record model.LeaveLog
	err = global.DB.Where("staff_id = ?", staffId).Where("status = ?", model.StatusExecuting).First(&record).Error
	if err != nil {
		if err != gorm.ErrRecordNotFound {
			return nil, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrDatabaseCode])
		} else {
			return nil, nil
		}
	}
	return &record, nil
}

func parseLeaveCronTab(db *gorm.DB, leaveLog model.LeaveLog) error {
	// 删除原来的定时任务
	leaveJobName := strconv.Itoa(leaveLog.ID) + "-" + strconv.Itoa(int(LeaveJob))
	resetLeaveJobName := strconv.Itoa(leaveLog.ID) + "-" + strconv.Itoa(int(ResetLeaveJob))
	err := crontab.GetCron("leave").RemoveJob(leaveJobName)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrLeaveRemoveCornTabCode])
	}
	err = crontab.GetCron("leave").RemoveJob(resetLeaveJobName)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrLeaveRemoveCornTabCode])
	}
	// 增加两个定时任务 更新人员请假状态。
	if leaveLog.StartTime.After(time.Now()) {
		if err := setLeaveCornTab(leaveLog.ID, leaveLog.StaffID, leaveLog.StartTime, LeaveJob); err != nil {
			return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrLeaveStartCornTabCode])
		}
	} else {
		// 更行请假单状态
		leaveLog.Status = model.StatusExecuting
		err := db.Updates(leaveLog).Error
		if err != nil {
			return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrLeaveStartCornTabCode])
		}

		// 更新用户状态
		err = ServicesGroupApp.StaffService.updateStaffLeaveStatus(leaveLog.StaffID, LeaveJob)
		if err != nil {
			log.Error("updateStaffLeaveStatus err", zap.Error(err))
		}
	}

	if leaveLog.EndTime.After(time.Now()) {
		// 启动定时任务
		if err := setLeaveCornTab(leaveLog.ID, leaveLog.StaffID, leaveLog.EndTime, ResetLeaveJob); err != nil {
			return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrLeaveStartCornTabCode])
		}
	} else {
		leaveLog.Status = model.StatusFinish
		err := db.Updates(leaveLog).Error
		if err != nil {
			return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrLeaveStartCornTabCode])
		}
		// 更新人员请假状态
		err = ServicesGroupApp.StaffService.updateStaffLeaveStatus(leaveLog.StaffID, ResetLeaveJob)
		if err != nil {
			log.Error("updateStaffLeaveStatus err", zap.Error(err))
		}
	}
	return nil
}

func setLeaveCornTab(leaveLogId, staffId int, cornTime *time.Time, action uint8) error {
	jobName := strconv.Itoa(leaveLogId) + "-" + strconv.Itoa(int(action))

	job := &LeaveCronJob{
		LeaveLogID: leaveLogId,
		JobName:    jobName,
		StaffID:    staffId,
		Action:     action,
	}

	secondStr := strconv.Itoa(cornTime.Second())
	minuteStr := strconv.Itoa(cornTime.Minute())
	hourStr := strconv.Itoa(cornTime.Hour())
	month := cornTime.Format("01")
	day := strconv.Itoa(cornTime.Day())

	spec := fmt.Sprintf("%s %s %s %s %s %s", secondStr, minuteStr, hourStr, day, month, "*")
	err := crontab.GetCron("leave").AddJobWithParams(jobName, spec, job)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrLeaveCornTabCode])
	}
	return nil
}