lims_adapter/service/access/user_lockaccess.go

package service

import (
	"context"
	"database/sql"
	"fmt"
	dao "lims_adapter/dao/access"
	m "lims_adapter/model"
	model "lims_adapter/model/access"

	"dashoo.cn/micro_libary/micro_srv"
	"dashoo.cn/micro_libary/myerrors"
	"dashoo.cn/micro_libary/request"
	"github.com/gogf/gf/os/glog"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gvalid"
)

type UserLockaccessService struct {
	Dao      *dao.UserLockaccessDao
	LockDao  *dao.DeviceLockRelateDao
	Tenant   string
	userInfo request.UserInfo
}

func NewUserLockaccessService(ctx context.Context) (*UserLockaccessService, error) {
	tenant, err := micro_srv.GetTenant(ctx)
	if err != nil {
		return nil, fmt.Errorf("获取组合码异常：%s", err.Error())
	}
	// 获取用户信息
	userInfo, err := micro_srv.GetUserInfo(ctx)
	if err != nil {
		return nil, fmt.Errorf("获取用户信息异常：%s", err.Error())
	}
	return &UserLockaccessService{
		Dao:      dao.NewUserLockaccessDao(tenant),
		LockDao:  dao.NewDeviceLockRelateDao(tenant),
		Tenant:   tenant,
		userInfo: userInfo,
	}, nil
}

func (s UserLockaccessService) List(ctx context.Context, req *model.UserLockaccessListReq) (int, []*model.UserLock, error) {
	dao := s.LockDao.DB.Table("user_lockaccess a").LeftJoin("base_user b", "a.UserId=b.Id")
	if req.UserId != 0 {
		dao = dao.Where("a.UserId = ?", req.UserId)
	}
	if req.UserName != "" {
		likestr := fmt.Sprintf("%%%s%%", req.UserName)
		dao = dao.Where("b.RealName like ?", likestr)
	}
	if req.LockId != "" {
		dao = dao.Where("a.LockId = ?", req.LockId)
	}

	total, err := dao.Fields("distinct(a.UserId)").Count()
	if err != nil {
		return 0, nil, err
	}

	if req.Page != nil {
		if req.Page.Current == 0 {
			req.Page.Current = 1
		}
		if req.Page.Size == 0 {
			req.Page.Size = 10
		}
		dao = dao.Page(req.Page.Current, req.Page.Size)
	}
	if req.OrderBy == nil {
		req.OrderBy = &m.OrderBy{}
	}
	if req.OrderBy.Value == "" {
		req.OrderBy.Value = "a.CreatedAt"
		req.OrderBy.Type = "desc"
	}
	if req.OrderBy != nil && req.OrderBy.Value != "" {
		order := "asc"
		if req.OrderBy.Type == "desc" {
			order = "desc"
		}
		dao = dao.Order(req.OrderBy.Value, order)
	}

	ents := []*model.UserLock{}
	err = dao.Fields("distinct(a.UserId), b.RealName as UserName").Structs(&ents)
	if err != nil && err != sql.ErrNoRows {
		return 0, nil, err
	}
	for i := range ents {
		locks := []*model.DeviceLockRelate{}
		err = s.LockDao.Where("LockId in (select LockId from user_lockaccess where UserId = ?)", ents[i].UserId).Structs(&locks)
		if err != nil && err != sql.ErrNoRows {
			return 0, nil, err
		}
		ents[i].Lock = locks
	}
	return total, ents, err
}

func (s UserLockaccessService) Get(ctx context.Context, req *model.UserLockaccessGetReq) (*model.UserLock, error) {
	ent := model.UserLock{}
	err := s.Dao.DB.Table("base_user").Where("Id = ?", req.UserId).
		Fields("Id as UserId, RealName as UserName").Struct(&ent)
	if err != nil {
		return nil, err
	}

	locks := []*model.DeviceLockRelate{}
	err = s.LockDao.Where("LockId in (select LockId from user_lockaccess where UserId = ?)", req.UserId).Structs(&locks)
	if err != nil && err != sql.ErrNoRows {
		return nil, err
	}
	ent.Lock = locks
	return &ent, nil
}

func (s UserLockaccessService) Add(ctx context.Context, req *model.UserLockaccessAddReq) (int, error) {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return 0, myerrors.NewMsgError(nil, validErr.Current().Error())
	}
	if len(req.LockId) == 0 {
		return 0, myerrors.NewMsgError(nil, "门禁ID 不能为空")
	}

	exist, err := s.LockDao.DB.Table("user_lockaccess").
		Where("UserId = ?", req.UserId).Count()
	if err != nil {
		return 0, err
	}
	if exist != 0 {
		return 0, myerrors.NewMsgError(nil, "用户已添加")
	}

	ent := []model.UserLockaccess{}
	add := []model.DeviceLockRelate{}
	for _, lid := range req.LockId {
		lock, err := s.LockDao.Where("LockId = ?", lid).One()
		if err != nil {
			return 0, err
		}
		if lock == nil {
			return 0, myerrors.NewMsgError(nil, fmt.Sprintf("门禁不存在 %s", lid))
		}
		add = append(add, *lock)
		ent = append(ent, model.UserLockaccess{
			LockId:      lid,
			UserId:      req.UserId,
			CreatedById: int(s.userInfo.Id),
			CreatedBy:   s.userInfo.RealName,
			CreatedAt:   gtime.Now(),
		})
	}
	_, err = s.Dao.Insert(ent)
	if err != nil {
		return 0, err
	}
	err = SendLockTaskPersonUpdate(s.Tenant, req.UserId, nil, add)
	if err != nil {
		glog.Error("发送通路设备锁更新任务失败，err:", err.Error())
	}
	return 0, err
}

func (s UserLockaccessService) Update(ctx context.Context, req *model.UserLockaccessUpdateReq) error {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return myerrors.NewMsgError(nil, validErr.Current().Error())
	}
	del := []model.DeviceLockRelate{}
	err := s.Dao.DB.Table("user_lockaccess a").
		LeftJoin("device_lock_relate b", "a.LockId = b.LockId").
		Where("a.UserId = ?", req.UserId).
		Fields("b.*").Structs(&del)
	if err != nil {
		return err
	}

	_, err = s.Dao.Where("UserId = ?", req.UserId).Delete()
	if err != nil {
		return err
	}
	ent := []model.UserLockaccess{}
	add := []model.DeviceLockRelate{}
	for _, lid := range req.LockId {
		lock, err := s.LockDao.Where("LockId = ?", lid).One()
		if err != nil {
			return err
		}
		if lock == nil {
			return myerrors.NewMsgError(nil, fmt.Sprintf("门禁不存在 %s", lid))
		}
		add = append(add, *lock)
		ent = append(ent, model.UserLockaccess{
			LockId:      lid,
			UserId:      req.UserId,
			CreatedById: int(s.userInfo.Id),
			CreatedBy:   s.userInfo.RealName,
			CreatedAt:   gtime.Now(),
		})
	}
	if len(ent) == 0 {
		return nil
	}
	_, err = s.Dao.Insert(ent)
	if err != nil {
		return err
	}
	err = SendLockTaskPersonUpdate(s.Tenant, req.UserId, del, add)
	if err != nil {
		glog.Error("发送通路设备锁更新任务失败，err:", err.Error())
	}
	return err
}

func (s UserLockaccessService) Delete(ctx context.Context, req *model.UserLockaccessDeleteReq) error {
	if len(req.UserId) == 0 {
		return nil
	}
	for _, uid := range req.UserId {
		del := []model.DeviceLockRelate{}
		err := s.Dao.DB.Table("user_lockaccess a").
			LeftJoin("device_lock_relate b", "a.LockId = b.LockId").
			Where("a.UserId = ?", uid).
			Fields("b.*").Structs(&del)
		if err != nil {
			return err
		}
		fmt.Println(del)
		err = SendLockTaskPersonUpdate(s.Tenant, uid, del, nil)
		if err != nil {
			glog.Error("发送通路设备锁更新任务失败，err:", err.Error())
			return err
		}
	}

	_, err := s.Dao.Where("UserId  IN (?)", req.UserId).Delete()
	return err
}