lims_adapter/service/learning/material.go

package learning

import (
	"context"
	"fmt"
	"lims_adapter/dao/learning"
	"lims_adapter/model"
	"lims_adapter/model/learning"

	"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 LearningMaterialService struct {
	Dao               *dao.LearningMaterialDao
	FileDao           *dao.LearningMaterialFileDao
	PublishRecordDao  *dao.LearningMaterialPublishRecordDao
	LearningRecordDao *dao.LearningLearningRecordDao
	LearningRecordSrv *LearningLearningRecordService
	Tenant            string
	userInfo          request.UserInfo
}

func NewLearningMaterialService(ctx context.Context) (*LearningMaterialService, 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())
	}
	lrSrv, err := NewLearningLearningRecordService(ctx)
	if err != nil {
		return nil, err
	}
	return &LearningMaterialService{
		Dao:               dao.NewLearningMaterialDao(tenant),
		FileDao:           dao.NewLearningMaterialFileDao(tenant),
		PublishRecordDao:  dao.NewLearningMaterialPublishRecordDao(tenant),
		LearningRecordDao: dao.NewLearningLearningRecordDao(tenant),
		LearningRecordSrv: lrSrv,
		Tenant:            tenant,
		userInfo:          userInfo,
	}, nil
}

func (s LearningMaterialService) Get(ctx context.Context, req *learning.LearningMaterialGetReq) (ent *learning.LearningMaterialGetRsp, err error) {
	var m *learning.LearningMaterial
	if req.Id != 0 {
		m, err = s.Dao.Where("Id = ?", req.Id).One()
		if err != nil {
			return
		}
	}
	if req.Name != "" {
		m, err = s.Dao.Where("Name = ?", req.Name).One()
		if err != nil {
			return
		}
	}
	if m == nil {
		return nil, myerrors.NewMsgError(nil, "培训材料不存在")
	}
	file, err := s.FileDao.Where("MaterialId = ?", m.Id).All()
	if err != nil {
		return nil, err
	}
	_, record, err := s.LearningRecordSrv.List(ctx, &learning.LearningLearningRecordListReq{MaterialId: req.Id})
	if err != nil {
		return nil, err
	}

	return &learning.LearningMaterialGetRsp{
		LearningMaterial: *m,
		File:             file,
		LearningRecord:   record,
	}, nil
}

func (s LearningMaterialService) List(ctx context.Context, req *learning.LearningMaterialListReq) (int, []*learning.LearningMaterial, error) {
	dao := &s.Dao.LearningMaterialDao
	if req.Name != "" {
		dao = dao.Where("Name LIKE ?", fmt.Sprintf("%%%s%%", req.Name))
	}
	if req.SkillId != 0 {
		dao = dao.Where("SkillId = ?", req.SkillId)
	}
	if req.Type != 0 {
		dao = dao.Where("Type = ?", req.Type)
	}
	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 = &model.OrderBy{
			Value: "SortNo",
		}
	}
	order := "asc"
	if req.OrderBy.Type == "desc" {
		order = "desc"
	}
	dao = dao.Order(req.OrderBy.Value, order)
	ent, err := dao.All()
	return total, ent, err
}

func (s LearningMaterialService) ListMy(ctx context.Context, req *learning.LearningMaterialListMyReq) ([]*learning.LearningMaterialListMy, error) {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return nil, myerrors.NewMsgError(nil, validErr.Current().Error())
	}
	dao := s.Dao.Where("SkillId = ?", req.SkillId)
	if req.Type != 0 {
		dao = dao.Where("Type = ?", req.Type)
	}
	ent, err := dao.Order("SortNo").All()
	if err != nil {
		return nil, err
	}
	list := []*learning.LearningMaterialListMy{}
	for _, m := range ent {
		lr, err := s.LearningRecordDao.Where("MaterialId = ?", m.Id).One()
		if err != nil {
			return nil, err
		}
		learnt := true
		if lr == nil {
			learnt = false
		}
		list = append(list, &learning.LearningMaterialListMy{
			LearningMaterial: *m,
			Learnt:           learnt,
		})
	}
	return list, nil
}

func (s LearningMaterialService) Add(ctx context.Context, req *learning.LearningMaterialAddReq) (int, error) {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return 0, myerrors.NewMsgError(nil, validErr.Current().Error())
	}
	r, err := s.Dao.DB.Table("learning_skill").Where("Id", req.SkillId).One()
	if err != nil {
		return 0, err
	}
	if r.IsEmpty() {
		return 0, myerrors.NewMsgError(nil, fmt.Sprintf("技能不存在: %d", req.SkillId))
	}

	m, err := s.Dao.Where("Name = ?", req.Name).One()
	if err != nil {
		return 0, err
	}
	if m != nil {
		return 0, myerrors.NewMsgError(nil, fmt.Sprintf("资料已存在: %s", req.Name))
	}

	id, err := s.Dao.InsertAndGetId(learning.LearningMaterial{
		SkillId:   req.SkillId,
		Name:      req.Name,
		Type:      req.Type,
		SortNo:    req.SortNo,
		Enable:    req.Enable,
		Content:   req.Content,
		OperateBy: s.userInfo.RealName,
		CreatedAt: gtime.Now(),
		UpdatedAt: gtime.Now(),
	})
	if err != nil {
		return 0, err
	}
	_, err = s.PublishRecordDao.Insert(learning.LearningMaterialPublishRecord{
		MaterialId: int(id),
		OperateBy:  s.userInfo.RealName,
		CreatedAt:  gtime.Now(),
		UpdatedAt:  gtime.Now(),
	})
	if err != nil {
		return 0, err
	}

	if len(req.File) == 0 {
		return int(id), err
	}

	files := []learning.LearningMaterialFile{}
	for _, f := range req.File {
		files = append(files, learning.LearningMaterialFile{
			MaterialId: int(id),
			Name:       f.Name,
			Url:        f.Url,
			Size:       f.Size,
			Extend:     f.Extend,
			OperateBy:  s.userInfo.RealName,
			CreatedAt:  gtime.Now(),
			UpdatedAt:  gtime.Now(),
		})
	}
	_, err = s.FileDao.Insert(files)
	return int(id), err
}

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

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

	if req.SkillId != 0 {
		r, err := s.Dao.DB.Table("learning_skill").Where("Id", req.SkillId).One()
		if err != nil {
			return err
		}
		if r.IsEmpty() {
			return myerrors.NewMsgError(nil, fmt.Sprintf("技能不存在: %d", req.SkillId))
		}
	}

	if req.Name != "" {
		existM, err := s.Dao.Where("Name = ?", req.Name).One()
		if err != nil {
			return err
		}
		if existM != nil && existM.Id != m.Id {
			return myerrors.NewMsgError(nil, fmt.Sprintf("资料已存在: %s", req.Name))
		}
	}

	dao := &s.Dao.LearningMaterialDao
	toupdate := map[string]interface{}{}
	if req.SkillId != 0 {
		toupdate["SkillId"] = req.SkillId
	}
	if req.Name != "" {
		toupdate["Name"] = req.Name
	}
	if req.Type != nil {
		toupdate["Type"] = req.Type
	}
	if req.SortNo != nil {
		toupdate["SortNo"] = req.SortNo
	}
	if req.Enable != nil {
		toupdate["Enable"] = req.Enable
	}
	if req.Content != "" {
		toupdate["Content"] = req.Content
	}
	if len(toupdate) != 0 {
		toupdate["OperateBy"] = s.userInfo.RealName
		_, err = dao.Where("Id", req.Id).Data(toupdate).Update()
		if err != nil {
			return err
		}
	}

	if req.File == nil {
		return nil
	}
	_, err = s.FileDao.Where("MaterialId = ?", req.Id).Delete()
	if err != nil {
		return err
	}
	if len(req.File) == 0 {
		return nil
	}

	files := []learning.LearningMaterialFile{}
	for _, f := range req.File {
		files = append(files, learning.LearningMaterialFile{
			MaterialId: m.Id,
			Name:       f.Name,
			Url:        f.Url,
			Size:       f.Size,
			Extend:     f.Extend,
			OperateBy:  s.userInfo.RealName,
			CreatedAt:  gtime.Now(),
			UpdatedAt:  gtime.Now(),
		})
	}
	_, err = s.FileDao.Insert(files)
	return err
}

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

func (s LearningMaterialService) MaterialIds(ctx context.Context, skillId int) ([]int, error) {
	_, materials, err := s.List(ctx, &learning.LearningMaterialListReq{
		SkillId: skillId,
	})
	if err != nil {
		return nil, err
	}
	materialIds := []int{}
	for _, m := range materials {
		materialIds = append(materialIds, m.Id)
	}
	return materialIds, err
}