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

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

func (s RecordHistoryService) List(ctx context.Context, req *model.RecordHistoryListReq) (int, []*model.RecordHistory, error) {
	dao := &s.Dao.RecordHistoryDao
	if req.ProjectSourse != "" {
		dao = dao.Where("ProjectSourse = ?", req.ProjectSourse)
	}
	if req.ProjectAccount != "" {
		dao = dao.Where("ProjectAccount = ?", req.ProjectAccount)
	}
	if req.ProjectAccountName != "" {
		dao = dao.Where("ProjectAccountName = ?", req.ProjectAccountName)
	}
	if req.SendTo != "" {
		dao = dao.Where("SendTo = ?", req.SendTo)
	}
	if req.DataItem != "" {
		dao = dao.Where("DataItem = ?", req.DataItem)
	}
	if req.IsSend != nil {
		dao = dao.Where("IsSend = ?", req.IsSend)
	}
	if req.DeviceId != "" {
		dao = dao.Where("DeviceId = ?", req.DeviceId)
	}
	if req.DeviceName != "" {
		likestr := fmt.Sprintf("%%%s%%", req.DeviceName)
		dao = dao.Where("DeviceName LIKE ?", likestr)
	}
	if req.ChannelCode != "" {
		dao = dao.Where("ChannelCode = ?", req.ChannelCode)
	}
	if req.ChannelName != "" {
		likestr := fmt.Sprintf("%%%s%%", req.ChannelName)
		dao = dao.Where("ChannelName LIKE ?", likestr)
	}
	if req.CreateOnStart != nil {
		dao = dao.Where("CreateOnStart >= ?", req.CreateOnStart)
	}
	if req.CreateOnEnd != nil {
		dao = dao.Where("CreateOnEnd <= ?", req.CreateOnEnd)
	}

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

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

	id, err := s.Dao.InsertAndGetId(model.RecordHistory{
		ProjectSourse:      req.ProjectSourse,
		ProjectAccount:     req.ProjectAccount,
		ProjectAccountName: req.ProjectAccountName,
		SendTo:             req.SendTo,
		DataItem:           req.DataItem,
		Message:            req.Message,
		IsSend:             req.IsSend,
		DeviceId:           req.DeviceId,
		DeviceName:         req.DeviceName,
		ChannelCode:        req.ChannelCode,
		ChannelName:        req.ChannelName,
		CreateOn:           req.CreateOn,
		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 RecordHistoryService) Delete(ctx context.Context, id []int) error {
	if len(id) == 0 {
		return nil
	}
	_, err := s.Dao.Where("Id  IN (?)", id).Delete()
	return err
}