lims_adapter/service/reservation/reservation.go

package reservation

import (
	"context"
	"dashoo.cn/common_definition/admin/user_def"
	"dashoo.cn/micro_libary/request"
	"errors"
	"fmt"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gconv"
	"lims_reservation/common"
	"lims_reservation/dao"
	"lims_reservation/model"
	"lims_reservation/service"
	"lims_reservation/service/meeting"
	"lims_reservation/service/srv"
	"time"
)

// Service ReservationService 预约
type Service struct {
	Dao    *dao.MeetingReservationDao
	Tenant string
}

// NewSrv 服务初始化
func NewSrv(tenant string) Service {
	return Service{Dao: dao.NewMeetingReservationDao(tenant), Tenant: tenant}
}

// List 预约列表
func (s Service) List(req model.ListReq) ([]model.List, int, error) {
	entityModel := s.Dao.M

	if req.Entity != nil {
		entity := new(model.ReservationReq)
		gconv.Struct(req.Entity, entity)
		if entity.Title != "" {
			entityModel = entityModel.WhereLike(s.Dao.Columns.Title, "%"+entity.Title+"%")
		}
		if entity.EntityId != 0 {
			entityModel = entityModel.Where(s.Dao.Columns.EntityId, entity.EntityId)
		}
		if entity.UserName != "" {
			entityModel = entityModel.WhereLike(s.Dao.Columns.UserName, "%"+entity.UserName+"%")
		}
		// 预约状态(1:预定   2:取消)
		if entity.Status != 0 {
			entityModel = entityModel.Where(s.Dao.Columns.Status, entity.Status)
		}
		// 预约时间
		if len(entity.TimeSplit) == 2 {
			entityModel = entityModel.WhereBetween(s.Dao.Columns.Status, entity.TimeSplit[0], entity.TimeSplit[1])
		}
	}
	total, err := entityModel.Count()
	if err != nil {
		return nil, 0, err
	}
	if total == 0 {
		return nil, 0, nil
	}
	if req.Value != "" {
		entityModel = entityModel.Order(req.Value, req.Type)
	}
	res, err := entityModel.Page(req.Current, req.Size).
		Fields("meeting_reservation.*", "meeting.Name", "base_user.DepartmentName").
		LeftJoin("meeting", "meeting.Id = meeting_reservation.EntityId").
		LeftJoin("base_user", "base_user.Id = meeting_reservation.UserId").
		FindAll()
	if err != nil {
		return nil, 0, err
	}
	if res.IsEmpty() {
		return nil, 0, nil
	}
	list := make([]model.List, 0)
	res.Structs(&list)
	return list, total, nil
}

// Add 添加预约
func (s Service) Add(userInfo request.UserInfo, req model.ReservationReq) error {
	entity := new(model.MeetingReservation)
	err := s.check(req)
	if err != nil {
		return err
	}
	gconv.Struct(req, entity)
	service.SetCreate(&userInfo, entity)
	entity.UserName = userInfo.RealName
	entity.UserId = int(userInfo.Id)
	entity.DepartmentId = gconv.Int(userInfo.DeptId)
	_, err = s.Dao.M.Insert(entity)
	if err != nil {
		return err
	}
	return nil
}

// Cancel 取消预约  预约状态(1:预定   2:取消)
func (s Service) Cancel(userInfo request.UserInfo, id int) error {
	// 判断当前用户是否是预约人
	entity, err := s.Dao.WherePri(id).FindOne()
	if err != nil {
		return err
	}
	if int32(entity.UserId) != userInfo.Id {
		return errors.New("当前预约只能由预约人取消")
	}
	updatedMap := service.SetUpdatedMap(&userInfo)
	updatedMap["Status"] = 2
	_, err = s.Dao.M.Data(updatedMap).WherePri(id).Update()
	if err != nil {
		return err
	}
	return nil
}

// OverviewList 预约概况
func (s Service) OverviewList(req model.OverviewReq) (g.Map, error) {
	dates := s.getCurrentWeekDay(req.Date)
	meetingList, err := meeting.NewSrv(s.Tenant).ShortList()
	if err != nil {
		return nil, err
	}
	reservationList, err := s.shortList(req.Date)
	if err != nil {
		return nil, err
	}
	return g.Map{
		"dates":       dates,
		"meeting":     meetingList,
		"reservation": reservationList,
	}, nil

}

// ReserveInfo 预约信息
func (s Service) ReserveInfo(ctx context.Context, req model.ReserveReq) (g.Map, error) {
	// 常规信息
	beginAt := g.Cfg().GetString("reservation.begin_at")
	endAt := g.Cfg().GetString("reservation.end_at")
	period := s.getCurrentPeriod(beginAt, endAt)
	dates := s.getCurrentWeekDay(req.Date)
	weekday := g.Cfg().GetString("reservation.weekday")
	// 预约信息
	list, err := s.getCurrentWeekReservation(ctx, req)
	if err != nil {
		return nil, err
	}
	return g.Map{
		"period":      period,
		"dates":       dates,
		"weekday":     weekday,
		"reservation": list,
	}, nil
}

// Check 预约校验
func (s Service) check(req model.ReservationReq) error {
	// 校验开始结束时间不能跨天
	if req.StartTime.Format("Y-m-d") != req.EndTime.Format("Y-m-d") {
		return errors.New("预约时间必须是同一天")
	}
	// 校验开始时间是否小于结束时间
	if req.EndTime.Sub(req.StartTime) <= 0 {
		return errors.New("预约结束时候必须大于开始时间")
	}
	// 时间间隔不能小于30分钟 todo:可以加到配置参数中
	if req.EndTime.Sub(req.StartTime).Minutes() < 30 {
		return errors.New("预约时间最小为30分钟")
	}
	// 校验是否是过期时间
	if req.StartTime.Sub(gtime.Now()) < 0 {
		return errors.New("当前预约时间已过期")
	}
	// 校验时间内是否有 预约
	exist, err := s.Dao.M.WhereBetween(s.Dao.Columns.StartTime, req.StartTime, req.EndTime).
		WhereBetween(s.Dao.Columns.EndTime, req.StartTime, req.EndTime).
		Where(s.Dao.Columns.Status, 1).Count()
	if err != nil {
		return err
	}
	if exist > 0 {
		return errors.New("当前时间段内已有预约记录,请刷新后重试")
	}
	// 校验会议室是否存在
	err = meeting.NewSrv(s.Tenant).Exists(req.EntityId)
	if err != nil {
		return err
	}
	return nil
}

// getCurrentWeekDay 返回当前日期的周信息
func (s Service) getCurrentWeekDay(current *gtime.Time) []model.CurrentDate {
	startOfWeek := common.GetCNStartOfWeek(current)
	dates := make([]model.CurrentDate, 0)
	for i := 0; i <= 6; i++ {
		times := startOfWeek.AddDate(0, 0, 1*i)
		dates = append(dates, model.CurrentDate{
			Date: times.Format("Y-m-d"),
			Day:  times.Day(),
		})
	}
	return dates
}

func (s Service) shortList(date *gtime.Time) ([]model.ShortList, error) {
	sTime := common.GetCNStartOfWeek(date)
	eTime := common.GetCNEndOfWeek(date)

	list := make([]model.ShortList, 0)
	res, err := s.Dao.M.WhereBetween(s.Dao.Columns.StartTime, sTime, eTime).FindAll()
	if err != nil {
		return nil, err
	}
	if res.IsEmpty() {
		return nil, nil
	}
	res.Structs(&list)
	return list, nil
}

// getCurrentDayTimeQuantum 获取当前的时间段
func (s Service) getCurrentPeriod(entityBeginAt, entityEndAt string) [][]string {
	now := gtime.Now()
	startTime, _ := gtime.StrToTime(entityBeginAt)
	endTime, _ := gtime.StrToTime(entityEndAt)
	startAtStr := fmt.Sprintf("%v-%.2v-%.2v %.2v:%.2v:%.2v",
		now.Year(), int(now.Month()), now.Day(),
		startTime.Hour(), startTime.Minute(), startTime.Second())
	startAt, _ := gtime.StrToTime(startAtStr)

	endAtStr := fmt.Sprintf("%v-%.2v-%.2v %.2v:%.2v:%.2v",
		now.Year(), int(now.Month()), now.Day(),
		endTime.Hour(), endTime.Minute(), endTime.Second())
	endAt, _ := gtime.StrToTime(endAtStr)

	timeLong := endAt.Sub(startAt).Hours()
	grids := int(timeLong * 2)
	var timeQuantum [][]string
	for i := 0; i < grids; i++ {
		times := make([]string, 0)
		timeSplit := g.Cfg().GetInt("reservation.time_split")
		// 开始时间
		startAt := startAt.Add(time.Duration(i*timeSplit) * time.Minute)
		startTime := startAt.Format("H:i")
		// 结束时间
		endAt := startAt.Add(time.Duration(timeSplit) * time.Minute).Format("H:i")
		times = append(times, startTime, endAt)
		timeQuantum = append(timeQuantum, times)
	}
	return timeQuantum
}

// getCurrentWeekReservation 返回本周预约信息
func (s Service) getCurrentWeekReservation(ctx context.Context, req model.ReserveReq) ([]model.ReservationList, error) {
	// 获取符合条件的预约信息
	list, err := s.Dao.Where(s.Dao.Columns.EntityId, req.EntityId).
		Where(s.Dao.Columns.Status, 1).
		Where(s.Dao.Columns.StartTime+">=", common.GetCNStartOfWeek(req.Date)).
		Where(s.Dao.Columns.StartTime+"<=", common.GetCNEndOfWeek(req.Date)).
		FindAll()
	if err != nil {
		return nil, err
	}
	if len(list) == 0 {
		return nil, nil
	}
	uIds := make([]int64, 0)
	uMap := make(map[int]struct{})
	for _, v := range list {
		if _, ok := uMap[v.UserId]; !ok {
			uIds = append(uIds, int64(v.UserId))
			uMap[v.UserId] = struct{}{}
		}
	}
	// 获取用户信息
	userList, err := srv.GetUserList(ctx, uIds, s.Tenant)
	usersMap := make(map[int]user_def.UserInfoList)
	for _, v := range userList {
		usersMap[v.Id] = v
	}
	resultList := make([]model.ReservationList, 0)
	for _, v := range list {
		timeLong := v.EndTime.Sub(v.StartTime).Hours()
		grids := int(timeLong * 2)
		for i := 0; i <= grids; i++ {
			startAt := v.StartTime.Add(time.Duration(i) * 30 * time.Minute)
			resultList = append(resultList, model.ReservationList{
				Day:       v.StartTime.Day(),
				Dept:      usersMap[v.UserId].DepartmentName,
				StartTime: fmt.Sprintf("%.2v:%.2v", startAt.Hour(), startAt.Minute()),
				Tel:       usersMap[v.UserId].Mobile,
				Uid:       v.UserId,
				Uname:     v.UserName,
				Week:      common.GetCNWeekday(v.StartTime),
			})
		}
	}
	return resultList, nil
}