lims_adapter/service/access/access_path.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/gtime"
	"github.com/gogf/gf/util/gvalid"
)

type AccessPathService struct {
	Dao      *dao.AccessPathDao
	LockDao  *dao.DeviceLockRelateDao
	Tenant   string
	userInfo request.UserInfo
}

func NewAccessPathService(ctx context.Context) (*AccessPathService, 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 &AccessPathService{
		Dao:      dao.NewAccessPathDao(tenant),
		LockDao:  dao.NewDeviceLockRelateDao(tenant),
		Tenant:   tenant,
		userInfo: userInfo,
	}, nil
}

func (s AccessPathService) List(ctx context.Context, req *model.AccessPathListReq) (int, []*model.ObjLock, error) {
	dao := &s.Dao.AccessPathDao
	if req.ObjName != "" {
		likestr := fmt.Sprintf("%%%s%%", req.ObjName)
		dao = dao.Where("ObjName like ?", likestr)
	}
	if req.ObjType != nil {
		dao = dao.Where("ObjType = ?", req.ObjType)
	}
	if req.LockId != "" {
		dao = dao.Where("LockId = ?", req.LockId)
	}
	dao = dao.Group("ObjId, ObjType")

	total, err := dao.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 = "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.ObjLock{}
	err = dao.Fields("ObjId, ObjType, ObjName").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 access_path where ObjId = ? and ObjType = ?)", ents[i].ObjId, ents[i].ObjType).Structs(&locks)
		if err != nil && err != sql.ErrNoRows {
			return 0, nil, err
		}
		ents[i].Lock = locks
	}
	return total, ents, err
}

func (s AccessPathService) Get(ctx context.Context, req *model.AccessPathGetReq) (*model.ObjLock, error) {
	ent := model.ObjLock{}
	err := s.Dao.Where("ObjId = ?", req.ObjId).
		Where("ObjType = ?", req.ObjType).
		Fields("ObjId, ObjType, ObjName").Struct(&ent)
	if err != nil {
		return nil, err
	}

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

func (s AccessPathService) Add(ctx context.Context, req *model.AccessPathAddReq) (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.Dao.Where("ObjId = ?", req.ObjId).
		Where("ObjType = ?", req.ObjType).Count()
	if err != nil {
		return 0, err
	}
	if exist != 0 {
		return 0, myerrors.NewMsgError(nil, "仪器设备已添加")
	}

	ent := []model.AccessPath{}
	for _, lid := range req.LockId {
		ent = append(ent, model.AccessPath{
			ObjId:       req.ObjId,
			ObjName:     req.ObjName,
			ObjType:     req.ObjType,
			LockId:      lid,
			CreatedById: int(s.userInfo.Id),
			CreatedBy:   s.userInfo.RealName,
			CreatedAt:   gtime.Now(),
		})
	}
	_, err = s.Dao.Insert(ent)
	return 0, err
}

func (s AccessPathService) Update(ctx context.Context, req *model.AccessPathUpdateReq) error {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return myerrors.NewMsgError(nil, validErr.Current().Error())
	}

	_, err := s.Dao.Where("ObjId = ?", req.ObjId).
		Where("ObjType = ?", req.ObjType).Delete()
	if err != nil {
		return err
	}
	ent := []model.AccessPath{}
	for _, lid := range req.LockId {
		ent = append(ent, model.AccessPath{
			ObjId:       req.ObjId,
			ObjName:     req.ObjName,
			ObjType:     req.ObjType,
			LockId:      lid,
			CreatedById: int(s.userInfo.Id),
			CreatedBy:   s.userInfo.RealName,
			CreatedAt:   gtime.Now(),
		})
	}
	if len(ent) == 0 {
		return nil
	}
	_, err = s.Dao.Insert(ent)
	return err
}

func (s AccessPathService) Delete(ctx context.Context, req *model.AccessPathDeleteReq) error {
	for _, i := range *req {
		_, err := s.Dao.Where("ObjId = ?", i.ObjId).
			Where("ObjType = ?", i.ObjType).Delete()
		if err != nil {
			return err
		}
	}
	return nil

}