lims_adapter/service/access/device_lock_relate.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 DeviceLockRelateService struct {
	Dao      *dao.DeviceLockRelateDao
	Tenant   string
	userInfo request.UserInfo
}

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

func (s DeviceLockRelateService) List(ctx context.Context, req *model.DeviceLockRelateListReq) (int, []*model.DeviceLockRelate, error) {
	dao := &s.Dao.DeviceLockRelateDao
	if req.DeviceId != "" {
		dao = dao.Where("DeviceId = ?", req.DeviceId)
	}
	if req.LockId != "" {
		dao = dao.Where("LockId = ?", req.LockId)
	}
	if req.LockName != "" {
		likestr := fmt.Sprintf("%%%s%%", req.LockName)
		dao = dao.Where("LockName LIKE ?", likestr)
	}
	if req.PlatformType != nil {
		dao = dao.Where("PlatformType = ?", *req.PlatformType)
	}
	if req.PlatformConfigId != "" {
		dao = dao.Where("PlatformConfigId = ?", req.PlatformConfigId)
	}

	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.DeviceLockRelate{}
	err = dao.Structs(&ents)
	if err != nil && err != sql.ErrNoRows {
		return 0, nil, err
	}
	return total, ents, err
}

func (s DeviceLockRelateService) Get(ctx context.Context, id int) (*model.DeviceLockRelate, error) {
	ent, err := s.Dao.Where("Id = ?", id).One()
	if err != nil {
		return nil, err
	}
	if ent == nil {
		return nil, myerrors.NewMsgError(nil, "门禁不存在")
	}
	return ent, nil
}

func (s DeviceLockRelateService) Add(ctx context.Context, req *model.DeviceLockRelateAddReq) (int, error) {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return 0, myerrors.NewMsgError(nil, validErr.Current().Error())
	}

	ent, err := s.Dao.Where("DeviceId = ?", req.DeviceId).One()
	if err != nil {
		return 0, err
	}
	if ent != nil {
		return 0, myerrors.NewMsgError(nil, fmt.Sprintf("锁设备ID:%s 已存在", req.DeviceId))
	}
	ent, err = s.Dao.Where("LockId = ?", req.LockId).One()
	if err != nil {
		return 0, err
	}
	if ent != nil {
		return 0, myerrors.NewMsgError(nil, fmt.Sprintf("门禁ID:%s 已存在", req.LockId))
	}
	ent, err = s.Dao.Where("LockName = ?", req.LockName).One()
	if err != nil {
		return 0, err
	}
	if ent != nil {
		return 0, myerrors.NewMsgError(nil, fmt.Sprintf("门禁名称:%s 已存在", req.LockName))
	}

	id, err := s.Dao.InsertAndGetId(model.DeviceLockRelate{
		DeviceId:         req.DeviceId,
		LockId:           req.LockId,
		LockName:         req.LockName,
		PlatformType:     req.PlatformType,
		PlatformConfigId: req.PlatformConfigId,
		LastTime:         nil,
		CreatedById:      int(s.userInfo.Id),
		UpdatedById:      int(s.userInfo.Id),
		CreatedBy:        s.userInfo.RealName,
		UpdatedBy:        s.userInfo.RealName,
		CreatedAt:        gtime.Now(),
		UpdatedAt:        gtime.Now(),
	})
	if err != nil {
		return 0, err
	}
	return int(id), err
}

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

	ent, err := s.Dao.Where("id = ?", req.Id).One()
	if err != nil {
		return err
	}
	if ent == nil {
		return myerrors.NewMsgError(nil, fmt.Sprintf("门禁不存在: %d", req.Id))
	}

	if req.LockName != "" {
		exist, err := s.Dao.Where("LockName = ?", req.LockName).One()
		if err != nil {
			return err
		}
		if exist != nil && exist.Id != req.Id {
			return myerrors.NewMsgError(nil, fmt.Sprintf("门禁名称: %s 已存在", req.LockName))
		}
	}

	dao := &s.Dao.DeviceLockRelateDao
	toupdate := map[string]interface{}{}
	if req.LockName != "" {
		toupdate["LockName"] = req.LockName
	}
	if len(toupdate) != 0 {
		toupdate["updatedById"] = int(s.userInfo.Id)
		toupdate["updatedBy"] = s.userInfo.RealName
		toupdate["updatedAt"] = gtime.Now()
		_, err = dao.Where("Id", req.Id).Data(toupdate).Update()
		if err != nil {
			return err
		}
	}
	return nil
}

func (s DeviceLockRelateService) Delete(ctx context.Context, id []int) error {
	if len(id) == 0 {
		return nil
	}
	_, err := s.Dao.Where("Id  IN (?)", id).Delete()
	return err
}