DRProtocolServer/service/protocol.go

package service

import (
	"context"
	"errors"
	"log/slog"
)

import (
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/structpb"
	"gorm.io/gorm"
)

import (
	"protocol-server/common"
	"protocol-server/models"
	pb "protocol-server/rpc_idl/dr_protocol_pb"
)

var nilStruct *structpb.Struct

func init() {
	var err error
	nilStruct, err = structpb.NewStruct(map[string]any{})
	if err != nil {
		panic(err)
	}
}

type ProtocolServer struct {
	pb.UnimplementedProtocolServer
}

func (s *ProtocolServer) GetPatientTypeList(ctx context.Context, in *pb.PatientTypeRequest) (*pb.PatientTypeReply, error) {
	res := pb.PatientTypeReply{}
	product, _, _, err := common.GetHeader(ctx)
	if err != nil {
		return &res, err
	}
	err = models.DB.Model(&models.PatientType{}).Scopes(
		models.String("product = ?", product.ToString()),
		models.Bool("is_enabled = ?", in.IsEnabled),
	).Order("sort").Find(&res.PatientTypeList).Error
	if err != nil {
		return nil, status.Errorf(codes.Internal, "patient_type find err %v", err)
	}
	for _, pt := range res.GetPatientTypeList() {
		pt.PatientTypeNameLocal = pt.PatientTypeName
	}
	return &res, nil
}

func (s *ProtocolServer) GetBodyPartList(ctx context.Context, in *pb.BodyPartRequest) (*pb.BodyPartReply, error) {
	res := pb.BodyPartReply{}
	product, _, _, err := common.GetHeader(ctx)
	if err != nil {
		return &res, err
	}
	err = models.DB.Model(&models.BodyPart{}).Scopes(
		models.String("patient_type = ?", in.GetPatientType()),
		models.String("modality = ?", in.GetModality()),
		models.String("product = ?", product.ToString()),
		models.Bool("is_enabled = ?", in.IsEnabled),
	).Order("sort").Find(&res.BodyPartList).Error
	if err != nil {
		return nil, status.Errorf(codes.Internal, "body_part find err %v", err)
	}
	for _, pt := range res.GetBodyPartList() {
		pt.BodyPartNameLocal = pt.BodyPartName
	}
	return &res, nil
}

func (s *ProtocolServer) GetProcedureList(ctx context.Context, in *pb.ProcedureRequest) (*pb.ProcedureReply, error) {
	res := pb.ProcedureReply{}
	product, _, _, err := common.GetHeader(ctx)
	if err != nil {
		return &res, err
	}
	err = models.DB.Model(&models.Procedure{}).Scopes(
		models.String("patient_type = ?", in.GetPatientType()),
		models.String("body_part_id = ?", in.GetBodyPartId()),
		models.String("product = ?", product.ToString()),
		models.Bool("is_enabled = ?", in.IsEnabled),
		models.Bool("is_pre_install = ?", in.IsPreInstall),
	).Order("sort").Find(&res.ProcedureList).Error
	if err != nil {
		return nil, status.Errorf(codes.Internal, "procedure find err %v", err)
	}
	for _, pt := range res.GetProcedureList() {
		pt.ProcedureNameLocal = pt.ProcedureName
		pt.ProcedureDescriptionLocal = pt.ProcedureDescription
	}
	return &res, nil
}

func (s *ProtocolServer) GetProcedure(ctx context.Context, in *pb.IDRequest) (*pb.Procedure, error) {
	slog.Info("[rpc]GetProcedure...", "instance_id", *in.InstanceId)
	res := pb.Procedure{}
	product, _, _, err := common.GetHeader(ctx)
	if err != nil {
		return &res, err
	}
	err = models.DB.Model(&models.Procedure{}).Scopes(
		models.String("internal_id = ?", in.GetInstanceId()),
		models.String("product = ?", product.ToString()),
	).Order("sort").Find(&res).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, status.Errorf(codes.NotFound, "procedure %s not found", in.GetInstanceId())
		}
		return nil, status.Errorf(codes.Internal, "procedure find err %v", err)
	}
	res.ProcedureNameLocal = res.ProcedureName
	res.ProcedureDescriptionLocal = res.ProcedureDescription
	return &res, nil
}

func (s *ProtocolServer) GetViewList(ctx context.Context, in *pb.ViewRequest) (*pb.ViewReply, error) {
	procedure := models.Procedure{}
	res := pb.ViewReply{}
	product, _, _, err := common.GetHeader(ctx)
	if err != nil {
		return &res, err
	}
	if in.GetProcedureId() == "" {
		err := models.DB.Model(&models.View{}).Scopes(
			models.String("patient_type = ?", in.GetPatientType()),
			models.String("body_part_id = ?", in.GetBodyPartId()),
			models.String("product = ?", product.ToString()),
			models.Bool("is_enabled = ?", in.IsEnabled),
			models.Bool("is_pre_install = ?", in.IsPreInstall),
		).Order("sort").Find(&procedure.Views).Error
		if err != nil {
			return nil, status.Errorf(codes.Internal, "view find err %v", err)
		}
	} else {
		err := models.DB.Model(&models.Procedure{}).Preload("Views").Scopes(
			models.String("procedure_id = ?", in.GetProcedureId()),
			models.String("product = ?", product.ToString()),
			models.Bool("is_enabled = ?", in.IsEnabled),
			models.Bool("is_pre_install = ?", in.IsPreInstall),
		).Order("sort").First(&procedure).Error
		if err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return nil, status.Errorf(codes.NotFound, "procedure %s not found", in.GetProcedureId())
			}
			return nil, status.Errorf(codes.Internal, "procedure find err %v", err)
		}
	}
	for i := range procedure.Views {
		res.ViewList = append(res.ViewList, view2pb(procedure.Views[i]))
	}
	return &res, nil
}

func (s *ProtocolServer) GetView(ctx context.Context, in *pb.IDRequest) (*pb.View, error) {
	slog.Info("[rpc]GetView...", "instance_id", *in.InstanceId)
	product, _, _, err := common.GetHeader(ctx)
	if err != nil {
		slog.Info("[rpc]GetView err:", err)
		return &pb.View{}, err
	}
	var view models.View
	err = models.DB.Scopes(
		models.String("internal_id = ?", in.GetInstanceId()),
		models.String("product = ?", product.ToString()),
	).Order("sort").First(&view).Error
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, status.Errorf(codes.NotFound, "view %s not found", in.GetInstanceId())
		}
		return nil, status.Errorf(codes.Internal, "view find err %v", err)
	}
	return view2pb(&view), nil
}