DRProtocolServer/service/protocol.go

package service

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

import (
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/structpb"
	"gorm.io/datatypes"
	"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)
	}
}

func Json2Struct(o *datatypes.JSON) *structpb.Struct {
	var tempMap map[string]interface{}
	err := json.Unmarshal(*o, &tempMap)
	if err != nil {
		slog.Error("Error unmarshalling datatypes.JSON to map", "err", err)
		return nilStruct
	}
	protoStruct, err := structpb.NewStruct(tempMap)
	if err != nil {
		slog.Error("Error creating proto struct", "err", err)
		return nilStruct
	}
	return protoStruct
}

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.PatientTypeLocal = 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.BodyPartLocal = 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 view2pb(view models.View) *pb.View {
	return &pb.View{
		InternalId:      view.InternalID,
		ViewId:          view.ViewID,
		ViewName:        view.ViewName,
		ViewNameLocal:   view.ViewNameLocal,
		ViewOtherName:   view.ViewOtherName,
		ViewDescription: view.ViewDescription,
		ViewPosition:    view.ViewPosition,
		Application:     view.Application,
		AnatomicRegion:  view.AnatomicRegion,
		PatientType:     view.PatientType,
		BodyPartId:      view.BodyPartID,
		ViewIconName:    view.ViewIconName,
		ViewBigIconName: view.ViewBigIconName,
		ViewCoachName:   view.ViewCoachName,
		Modality:        view.Modality,
		ConfigObject:    Json2Struct(&view.ConfigObject),
		TechTemplate:    view.TechTemplate,
		ImgProcTemplate: view.ImgProcTemplate,
		Sort:            int32(view.Sort),
		IsEnabled:       view.IsEnabled,
		Product:         view.Product,
		IsPreInstall:    view.IsPreInstall,
	}
}

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, "procedure 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 _, view := range procedure.Views {
		res.ViewList = append(res.ViewList, view2pb(view))
	}
	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, "procedure %s not found", in.GetInstanceId())
		}
		return nil, status.Errorf(codes.Internal, "view find err %v", err)
	}
	return view2pb(view), nil
}