lims_adapter/service/feedback/feedback.go

package feedback

import (
	"context"
	"database/sql"
	"fmt"
	dao "lims_adapter/dao/feedback"
	"lims_adapter/model"
	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 PermissionFeeedbackProcess = "feeedback: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("FeebackId = ?", f.Id).All()
	if err != nil {
		return nil, err
	}
	result, err := s.DaoResult.Where("FeebackId = ?", 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.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, PermissionFeeedbackProcess)
	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) error {
	validErr := gvalid.CheckStruct(ctx, req, nil)
	if validErr != nil {
		return 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 myerrors.NewMsgError(err, fmt.Sprintf("部门不存在 %s", s.userInfo.DeptId))
	}
	if err != nil {
		return 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 err
	}

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

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())
	}
	r, err := s.Dao.DB.Table("base_user").Where("Id", req.UserId).One()
	if err != nil {
		return err
	}
	if r.IsEmpty() {
		return myerrors.NewMsgError(nil, fmt.Sprintf("转交人不存在: %d", req.UserId))
	}

	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("CurrentProcessorId", req.UserId).Update()
	if err != nil {
		return err
	}
	_, err = s.DaoFlow.Insert(feedback.FeedbackFlow{
		FeebackId:     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("Status", 2).Update()
	if err != nil {
		return err
	}
	_, err = s.DaoFlow.Insert(feedback.FeedbackFlow{
		FeebackId:     req.Id,
		Type:          3,
		Status:        1,
		ProcessById:   int(s.userInfo.Id),
		ProcessByName: s.userInfo.RealName,
		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,
		}).Update()
	if err != nil {
		return err
	}
	_, err = s.DaoFlow.Insert(feedback.FeedbackFlow{
		FeebackId:     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, req *model.EmptyArgs) ([]feedback.FeedbackProcessorRsp, error) {
	menu := &id{}
	err := s.Dao.DB.Table("base_menu").
		Where("Permission = ?", PermissionFeeedbackProcess).
		Fields("Id").Struct(menu)
	if err == sql.ErrNoRows {
		return nil, myerrors.NewMsgError(err,
			fmt.Sprintf("未配置权限: %s", PermissionFeeedbackProcess))
	}
	if err != nil {
		return nil, err
	}

	roles := []id{}
	err = s.Dao.DB.Table("base_role_menu").
		Where("MenuIds LIKE ?", fmt.Sprintf("%%%d%%", menu.Id)).
		Fields("Id").Structs(&roles)
	if err == sql.ErrNoRows {
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	if len(roles) == 0 {
		return nil, nil
	}

	rsp := []feedback.FeedbackProcessorRsp{}
	dao := s.Dao.DB.Table("base_user_role a").LeftJoin("base_user b", "a.UserId=b.Id")
	for _, r := range roles {
		dao.Or("find_in_set(?, `a.RoleIds`)", r.Id)
	}
	err = dao.Fields("b.Id, b.Realname").Structs(&rsp)
	if err == sql.ErrNoRows {
		return nil, nil
	}
	return rsp, nil
}

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
}