lims_adapter/service/feedback/feedback.go

package feedback

import (
	"context"
	"database/sql"
	"fmt"
	dao "lims_adapter/dao/feedback"
	"lims_adapter/model/feedback"

	"dashoo.cn/common_definition/admin/permission_def"
	"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"
)

const PermissionFeedbackProcess = "feedback:process"

type FeedbackService struct {
	Dao       *dao.FeedbackDao
	DaoFlow   *dao.FeedbackFlowDao
	DaoResult *dao.FeedbackResultDao
	Tenant    string
	userInfo  request.UserInfo
}

func NewFeedbackService(ctx context.Context) (*FeedbackService, 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 &FeedbackService{
		Dao:       dao.NewFeedbackDao(tenant),
		DaoFlow:   dao.NewFeedbackFlowDao(tenant),
		DaoResult: dao.NewFeedbackResultDao(tenant),
		Tenant:    tenant,
		userInfo:  userInfo,
	}, nil
}

func (s FeedbackService) Get(ctx context.Context, req *feedback.FeedbackGetReq) (*feedback.FeedbackGetRsp, error) {
	f, err := s.Dao.Where("Id = ?", req.Id).One()
	if err != nil {
		return nil, err
	}
	if f == nil {
		return nil, myerrors.NewMsgError(nil, "反馈不存在")
	}
	flow, err := s.DaoFlow.Where("FeedbackId = ?", f.Id).All()
	if err != nil {
		return nil, err
	}
	result, err := s.DaoResult.Where("FeedbackId = ?", f.Id).All()
	if err != nil {
		return nil, err
	}

	return &feedback.FeedbackGetRsp{
		Feedback: *f,
		Flow:     flow,
		Result:   result,
	}, nil
}

func (s FeedbackService) List(ctx context.Context, req *feedback.FeedbackListReq) (int, []*feedback.Feedback, error) {
	dao := &s.Dao.FeedbackDao
	if req.Status != 0 {
		dao = dao.Where("Status = ?", req.Status)
	}
	if req.Type != "" {
		dao = dao.Where("Type = ?", req.Type)
	}
	if req.CreatedByName != "" {
		dao = dao.Where("CreatedByName LIKE ?", fmt.Sprintf("%%%s%%", req.CreatedByName))
	}
	if req.CreatedAtStart != nil {
		dao = dao.Where("CreatedAt > ?", req.CreatedAtStart)
	}
	if req.CreatedAtEnd != nil {
		dao = dao.Where("CreatedAt < ?", req.CreatedAtEnd)
	}

	allow, err := Allow(s.Tenant, s.userInfo.Uuid, PermissionFeedbackProcess)
	if err != nil {
		return 0, nil, err
	}
	if !allow {
		dao = dao.Where("CreatedById = ?", s.userInfo.Id)
	}

	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)
	}

	dao = dao.Order("CreatedAt", "desc")
	ent, err := dao.All()
	return total, ent, err
}

type organize struct {
	Id       int
	FullName string
}

func (s FeedbackService) Add(ctx context.Context, req *feedback.FeedbackAddReq) (int, error) {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return 0, myerrors.NewMsgError(nil, validErr.Current().Error())
	}
	dept := &organize{}
	err := s.Dao.DB.Table("base_organize").Where("Id", s.userInfo.DeptId).Struct(dept)
	if err == sql.ErrNoRows {
		return 0, myerrors.NewMsgError(err, fmt.Sprintf("部门不存在 %s", s.userInfo.DeptId))
	}
	if err != nil {
		return 0, err
	}

	id, err := s.Dao.InsertAndGetId(feedback.Feedback{
		Type:               req.Type,
		Status:             1,
		Content:            req.Content,
		CurrentProcessorId: 0,
		CreatedById:        int(s.userInfo.Id),
		CreatedByName:      s.userInfo.RealName,
		CreatedByMobile:    req.Mobile,
		CreatedByEmail:     req.Email,
		CreatedByDeptId:    dept.Id,
		CreatedByDeptName:  dept.FullName,
		CreatedAt:          gtime.New(),
		UpdatedAt:          gtime.New(),
	})
	if err != nil {
		return 0, err
	}

	_, err = s.DaoFlow.Insert(feedback.FeedbackFlow{
		FeedbackId:    int(id),
		Type:          1,
		Status:        1,
		ProcessById:   int(s.userInfo.Id),
		ProcessByName: s.userInfo.RealName,
		Note:          "",
		CreatedAt:     gtime.New(),
		UpdatedAt:     gtime.New(),
	})
	return int(id), err
}

type user struct {
	Id       int
	Realname string
}

func (s FeedbackService) Trans(ctx context.Context, req *feedback.FeedbackTransReq) error {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return myerrors.NewMsgError(nil, validErr.Current().Error())
	}
	trnasTo := user{}
	err := s.Dao.DB.Table("base_user").Where("Id", req.UserId).Struct(&trnasTo)
	if err == sql.ErrNoRows {
		return myerrors.NewMsgError(nil, fmt.Sprintf("转交人不存在: %d", req.UserId))
	}
	if err != nil {
		return err
	}

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

	_, err = s.Dao.Where("Id = ?", req.Id).Data(
		map[string]interface{}{
			"CurrentProcessorId":   req.UserId,
			"CurrentProcessorName": trnasTo.Realname,
		}).Update()
	if err != nil {
		return err
	}
	_, err = s.DaoFlow.Insert(feedback.FeedbackFlow{
		FeedbackId:    req.Id,
		Type:          2,
		Status:        1,
		ProcessById:   int(s.userInfo.Id),
		ProcessByName: s.userInfo.RealName,
		Note:          req.Note,
		CreatedAt:     gtime.New(),
		UpdatedAt:     gtime.New(),
	})
	return err
}

func (s FeedbackService) Process(ctx context.Context, req *feedback.FeedbackProcessReq) error {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return myerrors.NewMsgError(nil, validErr.Current().Error())
	}
	f, err := s.Dao.Where("Id = ?", req.Id).One()
	if err != nil {
		return err
	}
	if f == nil {
		return myerrors.NewMsgError(nil, fmt.Sprintf("反馈不存在: %d", req.Id))
	}

	_, err = s.Dao.Where("Id = ?", req.Id).Data(
		map[string]interface{}{
			"CurrentProcessorId":   s.userInfo.Id,
			"CurrentProcessorName": s.userInfo.RealName,
			"ProcessedAt":          gtime.Now(),
			"Status":               2,
		}).Update()
	if err != nil {
		return err
	}
	_, err = s.DaoFlow.Insert(feedback.FeedbackFlow{
		FeedbackId:    req.Id,
		Type:          3,
		Status:        1,
		ProcessById:   int(s.userInfo.Id),
		ProcessByName: s.userInfo.RealName,
		Note:          "",
		CreatedAt:     gtime.New(),
		UpdatedAt:     gtime.New(),
	})
	if err != nil {
		return err
	}
	_, err = s.DaoResult.Insert(feedback.FeedbackResult{
		FeedbackId:    req.Id,
		ProcessById:   int(s.userInfo.Id),
		ProcessByName: s.userInfo.RealName,
		ProcessType:   req.Type,
		ProcessNote:   req.Note,
		CreatedAt:     gtime.New(),
		UpdatedAt:     gtime.New(),
	})
	return err
}

func (s FeedbackService) Reactivate(ctx context.Context, req *feedback.FeedbackReactivateReq) error {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return myerrors.NewMsgError(nil, validErr.Current().Error())
	}
	f, err := s.Dao.Where("Id = ?", req.Id).One()
	if err != nil {
		return err
	}
	if f == nil {
		return myerrors.NewMsgError(nil, fmt.Sprintf("反馈不存在: %d", req.Id))
	}

	_, err = s.Dao.Where("Id = ?", req.Id).Data(
		map[string]interface{}{
			"Status":               1,
			"CurrentProcessorId":   0,
			"CurrentProcessorName": nil,
			"ProcessedAt":          nil,
		}).Update()
	if err != nil {
		return err
	}
	_, err = s.DaoFlow.Insert(feedback.FeedbackFlow{
		FeedbackId:    req.Id,
		Type:          4,
		Status:        1,
		ProcessById:   int(s.userInfo.Id),
		ProcessByName: s.userInfo.RealName,
		Note:          req.Note,
		CreatedAt:     gtime.New(),
		UpdatedAt:     gtime.New(),
	})
	return err
}

type id struct {
	Id int
}

func (s FeedbackService) Processor(ctx context.Context) ([]feedback.FeedbackProcessorRsp, error) {
	rsp := []feedback.FeedbackProcessorRsp{}
	menu := &id{}
	err := s.Dao.DB.Table("base_menu").
		Where("Permission = ?", PermissionFeedbackProcess).
		Fields("Id").Struct(menu)
	if err == sql.ErrNoRows {
		return nil, myerrors.NewMsgError(err,
			fmt.Sprintf("未配置权限: %s", PermissionFeedbackProcess))
	}
	if err != nil {
		return nil, err
	}

	roles := []id{}
	err = s.Dao.DB.Table("base_role_menu").
		Where("find_in_set(?, `MenuIds`)", menu.Id).
		Fields("RoleId as Id").Structs(&roles)
	if err == sql.ErrNoRows {
		return rsp, nil
	}
	if err != nil {
		return nil, err
	}
	if len(roles) == 0 {
		return rsp, nil
	}

	dao := s.Dao.DB.Table("base_user a").LeftJoin("base_user_role b", "b.UserId=a.Id")
	orsql := ""
	for i, r := range roles {
		if i != 0 {
			orsql += " OR "
		}
		orsql += fmt.Sprintf("find_in_set(%d, `RoleIds`)", r.Id)
	}
	dao = dao.Where("a.Enabled = 1").Where(fmt.Sprintf("(%s)", orsql))
	err = dao.Fields("a.Id, a.Realname").Structs(&rsp)
	if err == sql.ErrNoRows {
		return rsp, nil
	}
	return rsp, err
}

func Allow(tenant, uuid, permission string) (bool, error) {
	permissionSrv := micro_srv.InitMicroSrvClient("Permission", "micro_srv.admin")
	defer permissionSrv.Close()
	rsp := &permission_def.PermissionResp{}
	err := permissionSrv.Call(context.TODO(), "GetAllPermissionByUser", &permission_def.UuidReq{
		Tenant: tenant,
		Uuid:   uuid,
	}, rsp)
	if err != nil {
		return false, fmt.Errorf("获取权限失败 %s", err.Error())
	}
	for _, p := range rsp.UserPermissions {
		if p == permission {
			return true, nil
		}
	}
	return false, nil
}