private CSchema InferSchema(CProtoService cProtoService) { var schemaName = cProtoService.ServiceName; if (schemaName.EndsWith("Service")) { schemaName = schemaName.Substring(0, schemaName.LastIndexOf("Service")).ToLower(); } return(new CSchema { SchemaName = schemaName }); }
/* * private KProtoFile FindKProtoFile(KGrpcProject grpcKProject, CMethod method) * { * KProtoFile kProtoFile = null; * * foreach (var mPf in grpcKProject.ProtoFile) * { * foreach (var mRpc in mPf.Rpc) * if (mRpc.RpcName.ToLower() == method.MethodName.ToLower()) * { * kProtoFile = mPf; * break; * } * if (kProtoFile != null) * break; * } * * if (kProtoFile == null) * { * kProtoFile = grpcKProject.ProtoFile.FirstOrDefault(); * if (kProtoFile == null) * { * kProtoFile = new KProtoFile {ProtoFileName = grpcKProject.ProjectName}; * grpcKProject.ProtoFile.Add(kProtoFile); * } * } * if (kProtoFile.GeneratedProtoFile == null) * { * var protoNamespace = kProtoFile.CSharpNamespace; // * if (string.IsNullOrEmpty(protoNamespace)) * protoNamespace = * $@"{grpcKProject.CompanyName}.{grpcKProject.ProjectName}{grpcKProject.NamespaceSuffix}.{ * grpcKProject.ProjectSuffix * }.Proto.Types"; * kProtoFile.GeneratedProtoFile = BuildProtoFile(grpcKProject, kProtoFile, protoNamespace); * } * * * return kProtoFile; * }*/ private CProtoFile BuildProtoFile(KGrpcProject grpcKProject, KProtoFile kProtoFile, string protoNamespace) { var protoFile = new CProtoFile(); protoFile.Import.Add("google/protobuf/timestamp.proto"); protoFile.Import.Add("google/protobuf/duration.proto"); protoFile.Import.Add("google/protobuf/descriptor.proto"); protoFile.CSharpNamespace = protoNamespace; protoFile.Option.Add($@"csharp_namespace = ""{protoNamespace}"";"); protoFile.Option.Add($@"(version) = ""1.0.0"";"); var protoService = new CProtoService(protoFile) { ServiceName = $@"{kProtoFile.ProtoFileName}Service" }; protoFile.ProtoService.Add(protoService); return(protoFile); }
private KProtoFile GetProtoFile(string solutionName) { _sl.SelectWorksheet("Proto"); var colSolutionName = GetColumnIndex("SolutionName"); var colCSharpNamespace = GetColumnIndex("CSharpNamespace"); var colServiceName = GetColumnIndex("ServiceName"); var colRpcName = GetColumnIndex("RpcName"); var colRequestMessageName = GetColumnIndex("RequestMessageName"); var colResponseMessageName = GetColumnIndex("ResponseMessageName"); var currentRow = 2; var protoFile = new CProtoFile(); while (!string.IsNullOrEmpty(_sl.GetCellValueAsString(currentRow, colSolutionName))) { if (_sl.GetCellValueAsString(currentRow, colSolutionName) != solutionName) { currentRow++; continue; } protoFile.CSharpNamespace = _sl.GetCellValueAsString(currentRow, colCSharpNamespace); var protoService = new CProtoService(protoFile) { ServiceName = _sl.GetCellValueAsString(currentRow, colServiceName) }; protoFile.ProtoService.Add(protoService); var rpc = new CProtoRpc(protoService) { RpcName = _sl.GetCellValueAsString(currentRow, colRpcName) }; rpc.Request = new CProtoMessage(rpc) { MessageName = _sl.GetCellValueAsString(currentRow, colRequestMessageName) }; rpc.Response = new CProtoMessage(rpc) { MessageName = _sl.GetCellValueAsString(currentRow, colResponseMessageName) }; protoService.Rpc.Add(rpc); /* * while (_sl.GetCellValueAsString(currentRow, colServiceName) == view.ViewName) * { * var column = new SColumn(view) * { * ColumnName = _sl.GetCellValueAsString(currentRow, colColumnName), * ColumnTypeRaw = _sl.GetCellValueAsString(currentRow, colColumnSqlDbType), * }; * view.Column.Add(column); * currentRow++; * } */ currentRow++; } return(new KProtoFile { GeneratedProtoFile = protoFile }); }
private CClass BuildTestClass(CProtoService protoService) { var testClass = new CClass($"{protoService.ServiceName}Tests") { Namespace = new CNamespace { NamespaceName = $"{_grpcMServiceUnitTestProject.CompanyName}.{_grpcMServiceUnitTestProject.ProjectName}{_grpcMServiceUnitTestProject.NamespaceSuffix}.{_grpcMServiceUnitTestProject.ProjectSuffix}" } }; testClass.ClassAttribute.Add(new CClassAttribute { AttributeName = "TestClass" }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "System.Threading.Tasks" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Moq" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Grpc.Core" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Google.Protobuf.WellKnownTypes" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Microsoft.VisualStudio.TestTools.UnitTesting" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Company.GrpcCommon.Infrastructure" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = $"{protoService.ProtoFile.CSharpNamespace}" } }); testClass.Field.Add(new CField { AccessModifier = CAccessModifier.Private, FieldType = "Mock<IMediatorExecutor>", FieldName = "_mediatrMock" }); testClass.Field.Add(new CField { AccessModifier = CAccessModifier.Private, FieldType = "Server", FieldName = "_server" }); testClass.Field.Add(new CField { AccessModifier = CAccessModifier.Private, FieldType = "Channel", FieldName = "_channel" }); testClass.Method.Add(BuildInitializeMethod()); testClass.Method.Add(BuildDisposeMethod()); foreach (var rpc in protoService.Rpc) { var method = GetTestMethod(rpc); testClass.Method.Add(method); } return(testClass); }
public CProtoFile Convert(List <CStoredProcedure> storedProcedures, bool addCRUD = false, bool addBulkRpc = true) { var protoFile = new CProtoFile(); protoFile.Import.Add("google/protobuf/timestamp.proto"); protoFile.Import.Add("google/protobuf/descriptor.proto"); //protoFile.Import.Add("google/protobuf/duration.proto"); protoFile.CSharpNamespace = NamespaceName; protoFile.Option.Add($@"csharp_namespace = ""{NamespaceName}"";"); var messagesToAddToBulkRpc = new List <CProtoMessage>(); var protoService = new CProtoService(protoFile) { ServiceName = ServiceName }; protoFile.ProtoService.Add(protoService); foreach (var storedProcedure in storedProcedures) { if (!addCRUD) { if (storedProcedure.DataOperationIs.HasFlag(COperationIs.CRUD)) { continue; } } var rpc = new CProtoRpc(protoService) { RpcName = storedProcedure.StoredProcedureName, RpcDescription = storedProcedure.StoredProcedureDescription, //DomainModelName = storedProcedure.ResultSetName, DerivedFrom = storedProcedure }; rpc.Request = new CProtoMessage(rpc) { IsRequest = true, MessageName = $"{storedProcedure.StoredProcedureName}Request" }; rpc.Response = new CProtoMessage(rpc) { IsResponse = true, MessageName = $"{storedProcedure.StoredProcedureName}Response" }; var requestMessage = rpc.Request; if (!string.IsNullOrEmpty(storedProcedure.ParameterSetName)) { rpc.Request.ProtoField.Add(new CProtoMessageField(storedProcedure) { IsScalar = false, MessageType = storedProcedure.ParameterSetName, FieldName = storedProcedure.ParameterSetName }); requestMessage = new CProtoMessage(rpc) { IsRequest = true, MessageName = storedProcedure.ParameterSetName }; if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == requestMessage.MessageName)) { protoFile.ProtoMessage.Add(requestMessage); if (addBulkRpc) { messagesToAddToBulkRpc.Add(requestMessage); } } } foreach (var parameter in storedProcedure.Parameter) { var sqlType = SqlDbType.VarChar; if (!parameter.ParameterTypeIsUserDefined) { sqlType = SqlMapper.ParseValueAsSqlDbType(parameter.ParameterTypeRaw); } var field = new CProtoMessageField(parameter) { FieldName = parameter.ParameterName, //.SourceColumn.ColumnName, FieldType = SqlMapper.SqlDbTypeToGrpcType(sqlType) }; if (parameter.ParameterTypeIsUserDefined) { field.Repeated = true; } requestMessage.ProtoField.Add(field); } var responseMessage = rpc.Response; if (!string.IsNullOrEmpty(storedProcedure.ResultSetName)) { rpc.Response.ProtoField.Add(new CProtoMessageField(null) { IsScalar = false, Repeated = true, MessageType = storedProcedure.ResultSetName, FieldName = storedProcedure.ResultSetName }); responseMessage = new CProtoMessage(rpc) { IsResponse = true, MessageName = storedProcedure.ResultSetName }; if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == responseMessage.MessageName)) { protoFile.ProtoMessage.Add(responseMessage); } } foreach (var resultColumn in storedProcedure.ResultSet) { var field = new CProtoMessageField(resultColumn) { FieldName = resultColumn.ColumnName, FieldType = SqlMapper.SqlDbTypeToGrpcType(resultColumn.ColumnSqlDbType) }; responseMessage.ProtoField.Add(field); } protoService.Rpc.Add(rpc); } /* * if (addBulkRpc) * { * var rpc = new SProtoRpc(protoService) * { * RpcName = $"{BulkStoreRpcName}", * OperationIs = SOperationIs.Bulk | SOperationIs.Add | SOperationIs.Update * }; * * var request = new SProtoMessage * { * IsRequest = true, * MessageName = $"{rpc.RpcName}Request" * * }; * * rpc.Request = request; * foreach (var message in messagesToAddToBulkRpc) * { * request.ProtoField.Add(new SProtoMessageField (null) { IsScalar = false, Repeated = true, MessageType = message.MessageName, FieldName = $"{message.MessageName}" }); * } * * var response = new SProtoMessage * { * IsResponse = true, * MessageName = $"{rpc.RpcName}Response" * }; * rpc.Response = response; * * * protoService.Rpc.Add(rpc); * }*/ return(protoFile); }
private CClass BuildTestClass(CProtoService protoService) { var testClass = new CClass($"{protoService.ServiceName}Tests") { Namespace = new CNamespace { NamespaceName = $"{_grpcMServiceIntegrationTestProject.CompanyName}.{_grpcMServiceIntegrationTestProject.ProjectName}{_grpcMServiceIntegrationTestProject.NamespaceSuffix}.{_grpcMServiceIntegrationTestProject.ProjectSuffix}" } }; testClass.ClassAttribute.Add(new CClassAttribute { AttributeName = "TestClass" }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "System.Threading.Tasks" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Moq" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Grpc.Core" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Google.Protobuf.WellKnownTypes" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Microsoft.VisualStudio.TestTools.IntegrationTesting" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = $"{protoService.ProtoFile.CSharpNamespace}" } }); // private Mock<IMediatorExecutor> _mediatrMock; //private Server _server; //private Channel _channel; testClass.Field.Add(new CField { AccessModifier = CAccessModifier.Private, FieldType = "Mock<IMediatorExecutor>", FieldName = "_mediatrMock" }); testClass.Field.Add(new CField { AccessModifier = CAccessModifier.Private, FieldType = "Server", FieldName = "_server" }); testClass.Field.Add(new CField { AccessModifier = CAccessModifier.Private, FieldType = "Channel", FieldName = "_channel" }); testClass.Method.Add(BuildSetupMethod()); testClass.Method.Add(BuildDisposeMethod()); //todo: finish implementing /* * foreach (var rpc in protoService.Rpc) * { * var method = GetTestMethod(rpc); * @testClass.Method.Add(method); * * }*/ return(testClass); }
private CClass BuildTestClass(CProtoService protoService) { var testClass = new CClass($"{protoService.ServiceName}Tests") { Namespace = new CNamespace { NamespaceName = $"{_grpcMServiceClientTestProject.CompanyName}.{_grpcMServiceClientTestProject.ProjectName}{_grpcMServiceClientTestProject.NamespaceSuffix}.{_grpcMServiceClientTestProject.ProjectSuffix}" }, DerivedFrom = protoService }; testClass.ClassAttribute.Add(new CClassAttribute { AttributeName = "TestClass" }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "System.Threading.Tasks" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Moq" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Grpc.Core" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Google.Protobuf.WellKnownTypes" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Microsoft.VisualStudio.TestTools.UnitTesting" } }); testClass.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = $"{protoService.ProtoFile.CSharpNamespace}" } }); // private Mock<IMediatorExecutor> _mediatrMock; //private Server _server; //private Channel _channel; //testClass.Field.Add(new SField { AccessModifier = SAccessModifier.Private, FieldType = "Mock<IMediatorExecutor>", FieldName = "_mediatrMock" }); // testClass.Field.Add(new SField { AccessModifier = SAccessModifier.Private, FieldType = "Server", FieldName = "_server" }); // testClass.Field.Add(new SField { AccessModifier = SAccessModifier.Private, FieldType = "Channel", FieldName = "_channel" }); //testClass.Method.Add(BuildSetupMethod()); //testClass.Method.Add(BuildDisposeMethod()); testClass.Field.Add(new CField { IsReadonly = true, AccessModifier = CAccessModifier.Private, FieldType = "int", FieldName = "_currentDbIdentityValue", DefaultValue = "1000" }); testClass.Constructor.Add(new CConstructor { ConstructorName = testClass.ClassName, AccessModifier = CAccessModifier.Public, Parameter = new List <CParameter> { new CParameter { Type = "int", ParameterName = "currentDbIdentityValue" } }, CodeSnippet = "_currentDbIdentityValue = currentDbIdentityValue;" }); foreach (var rpc in protoService.Rpc) { if (rpc.DerivedFrom is CStoredProcedure && (rpc.DerivedFrom as CStoredProcedure).DataOperationIs.HasFlag(COperationIs.Add) && (rpc.DerivedFrom as CStoredProcedure).DataOperationIs.HasFlag(COperationIs.Update) ) { var methodAdd = GetTestMethod(rpc, COperationIs.Add); if (methodAdd == null) { continue; } testClass.Method.Add(methodAdd); var methodUpdate = GetTestMethod(rpc, COperationIs.Update); if (methodUpdate == null) { continue; } testClass.Method.Add(methodUpdate); } else if (rpc.DerivedFrom is CStoredProcedure && (rpc.DerivedFrom as CStoredProcedure).DataOperationIs.HasFlag(COperationIs.Delete)) { var methodDelete = GetTestMethod(rpc, COperationIs.Delete); if (methodDelete == null) { continue; } testClass.Method.Add(methodDelete); } else { var method = GetTestMethod(rpc, COperationIs.Undefined); if (method == null) { continue; } testClass.Method.Add(method); } } return(testClass); }
private CProtoRpc BuildRpcFromStoredProc(CProtoFile protoFile, CProtoService protoService, CMethod method, CStoredProcedure storedProcedure) { var rpc = new CProtoRpc(protoService) { RpcName = storedProcedure.StoredProcedureName, RpcDescription = storedProcedure.StoredProcedureDescription, //DomainModelName = storedProcedure.ResultSetName, DerivedFrom = storedProcedure }; rpc.Request = new CProtoMessage(rpc) { IsRequest = true, MessageName = $"{storedProcedure.StoredProcedureName}Request" }; rpc.Response = new CProtoMessage(rpc) { IsResponse = true, MessageName = $"{storedProcedure.StoredProcedureName}Response" }; var requestMessage = rpc.Request; if (!string.IsNullOrEmpty(storedProcedure.ParameterSetName)) { rpc.Request.ProtoField.Add(new CProtoMessageField(storedProcedure) { IsScalar = false, MessageType = storedProcedure.ParameterSetName, FieldName = storedProcedure.ParameterSetName }); requestMessage = new CProtoMessage(rpc) { IsRequest = true, MessageName = storedProcedure.ParameterSetName }; if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == requestMessage.MessageName)) { protoFile.ProtoMessage.Add(requestMessage); } } foreach (var parameter in storedProcedure.Parameter) { var field = new CProtoMessageField(parameter) { FieldName = parameter.ParameterName //.SourceColumn.ColumnName, }; if (!parameter.ParameterTypeIsUserDefined) { var sqlType = SqlMapper.ParseValueAsSqlDbType(parameter.ParameterTypeRaw); field.FieldType = SqlMapper.SqlDbTypeToGrpcType(sqlType); } else { //todo: property handle user defined sql types (tables) //lookup table type //for now, use the data type of the first column, assumes single column table var tableType = FindTableType(parameter.ParameterTypeRaw); var converter = new CTableTypeToCClassConverter(); var @class = converter.Convert(tableType.GeneratedTableType); field.FieldType = GrpcType.__string; field.IsScalar = false; field.Repeated = true; field.MessageType = $@"{@class.ClassName}"; if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == field.MessageType)) { //create a message var tableTypeDerivedMessage = new CProtoMessage(rpc) { MessageName = field.MessageType }; foreach (var property in @class.Property) { var field2 = new CProtoMessageField(property) { FieldName = property.PropertyName, FieldType = SqlMapper.ClrTypeToGrpcType(SqlMapper.ClrTypeAliasToClrType(property.Type)) }; tableTypeDerivedMessage.ProtoField.Add(field2); } protoFile.ProtoMessage.Add(tableTypeDerivedMessage); } } requestMessage.ProtoField.Add(field); } var responseMessage = rpc.Response; if (!string.IsNullOrEmpty(storedProcedure.ResultSetName)) { rpc.Response.ProtoField.Add(new CProtoMessageField(null) { IsScalar = false, Repeated = true, MessageType = storedProcedure.ResultSetName, FieldName = storedProcedure.ResultSetName }); responseMessage = new CProtoMessage(rpc) { IsResponse = true, MessageName = storedProcedure.ResultSetName }; if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == responseMessage.MessageName)) { protoFile.ProtoMessage.Add(responseMessage); } } foreach (var resultColumn in storedProcedure.ResultSet) { var field = new CProtoMessageField(resultColumn) { FieldName = resultColumn.ColumnName, FieldType = SqlMapper.SqlDbTypeToGrpcType(resultColumn.ColumnSqlDbType) }; responseMessage.ProtoField.Add(field); } return(rpc); }
private CProtoRpc BuildBulkRpcFromStoredProcList(CProtoFile protoFile, CProtoService protoService, CMethod method, CStoredProcList storedProcedureList) { var rpc = new CProtoRpc(protoService) { RpcName = method.MethodName, //DomainModelName = "Junk", // storedProcedure.ResultSetName,, DerivedFrom = storedProcedureList }; rpc.Request = new CProtoMessage(rpc) { IsRequest = true, MessageName = $"{method.MethodName}Request" }; rpc.Response = new CProtoMessage(rpc) { IsResponse = true, MessageName = $"{method.MethodName}Response" }; var requestMessage = rpc.Request; foreach (var storedProcedure in storedProcedureList.List) { if (!string.IsNullOrEmpty(storedProcedure.ParameterSetName)) { rpc.Request.ProtoField.Add(new CProtoMessageField(storedProcedure) { IsScalar = false, MessageType = storedProcedure.ParameterSetName, FieldName = storedProcedure.ParameterSetName, Repeated = true }); requestMessage = new CProtoMessage(rpc) { IsRequest = true, MessageName = storedProcedure.ParameterSetName }; if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == requestMessage.MessageName)) { protoFile.ProtoMessage.Add(requestMessage); } } foreach (var parameter in storedProcedure.Parameter) { var sqlType = SqlDbType.VarChar; if (!parameter.ParameterTypeIsUserDefined) { sqlType = SqlMapper.ParseValueAsSqlDbType(parameter.ParameterTypeRaw); } var field = new CProtoMessageField(parameter) { FieldName = parameter.ParameterName, //.SourceColumn.ColumnName, FieldType = SqlMapper.SqlDbTypeToGrpcType(sqlType) }; if (parameter.ParameterTypeIsUserDefined) { field.Repeated = true; } requestMessage.ProtoField.Add(field); } /* * var responseMessage = rpc.Response; * if (!string.IsNullOrEmpty(storedProcedure.ResultSetName)) * { * rpc.Response.ProtoField.Add(new SProtoMessageField(null) * { * IsScalar = false, * Repeated = true, * MessageType = storedProcedure.ResultSetName, * FieldName = storedProcedure.ResultSetName * }); * * responseMessage = new SProtoMessage * { * IsResponse = true, * MessageName = storedProcedure.ResultSetName * }; * if (!protoFile.ProtoMessage.Exists(pm => pm.MessageName == responseMessage.MessageName)) * { * protoFile.ProtoMessage.Add(responseMessage); * * } * * } * foreach (var resultColumn in storedProcedure.ResultSet) * { * var field = new SProtoMessageField(resultColumn) * { * FieldName = resultColumn.ColumnName, * FieldType = SqlMapper.SqlDbTypeToGrpcType(resultColumn.ColumnSqlDbType) * }; * * responseMessage.ProtoField.Add(field); * }*/ } return(rpc); }
public CClass BuildServiceImplClass(KGrpcProject grpcKProject, CProtoService protoService, string protoTypesNamespace, bool useToEntity = true, bool useToProto = true) { var @class = new CClass($"{protoService.ServiceName}Impl") { Namespace = new CNamespace { NamespaceName = $"{grpcKProject.CompanyName}.{grpcKProject.ProjectName}{grpcKProject.NamespaceSuffix}.{grpcKProject.ProjectSuffix}" }, InheritsFrom = new CClass($"{protoService.ServiceName}.{protoService.ServiceName}Base") }; //todo: add only if needed @class.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "System.Linq" } }); @class.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "System.Threading.Tasks" } }); @class.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Grpc.Core" } }); @class.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "Company.GrpcCommon.Infrastructure" } }); @class.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = protoTypesNamespace } }); @class.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = $"{@class.Namespace}.Query" } }); @class.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = $"{@class.Namespace.NamespaceName}.Config" } }); @class.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = $"{@class.Namespace.NamespaceName}.Auth" } }); @class.Field.Add(new CField { AccessModifier = CAccessModifier.Private, IsReadonly = true, FieldType = "IMediatorExecutor", FieldName = "_executor" }); @class.Field.Add(new CField { AccessModifier = CAccessModifier.Private, IsReadonly = true, FieldType = "AuthenticationSettings", FieldName = "_authSettings" }); @class.Constructor.Add(new CConstructor { AccessModifier = CAccessModifier.Public, ConstructorName = @class.ClassName, Parameter = new List <CParameter> { new CParameter { Type = "IMediatorExecutor", ParameterName = "executor" }, new CParameter { Type = "AuthenticationSettings", ParameterName = "authSettings" } }, CodeSnippet = @"_executor = executor; _authSettings = authSettings;" }); foreach (var rpc in protoService.Rpc) { var rpcMethod = new CMethod { AccessModifier = CAccessModifier.Public, IsOverride = true, IsAsync = true, ReturnType = $"Task<{rpc.Response.MessageName}>", MethodName = rpc.RpcName }; rpcMethod.Parameter.Add(new CParameter { Type = $"{rpc.Request.MessageName}", ParameterName = "request" }); rpcMethod.Parameter.Add(new CParameter { Type = "ServerCallContext", ParameterName = "context" }); var codeWriter = new CodeWriter(); codeWriter.WriteLine("context.CheckAuthenticated(_authSettings);"); codeWriter.WriteLine(); codeWriter.Indent(); codeWriter.Indent(); codeWriter.Indent(); codeWriter.WriteLine($"var result = await _executor.ExecuteAsync(new {rpc.RpcName}Query"); codeWriter.WriteLine("{"); codeWriter.Indent(); var first = true; foreach (var pf in rpc.Request.ProtoField) { if (!first) { codeWriter.WriteLine(","); } first = false; codeWriter.Write($"{pf.FieldName} = request.{pf.FieldName}"); if (pf.FieldType == GrpcType.__google_protobuf_Timestamp) { codeWriter.Write(".ToDateTime()"); } if (useToEntity && !pf.IsScalar) { if (pf.Repeated) { codeWriter.Write(".Select(p => p.ToModel())"); } else { codeWriter.Write(".ToModel()"); } } } codeWriter.WriteLine(string.Empty); codeWriter.Unindent(); codeWriter.WriteLine("}).ConfigureAwait(false);"); codeWriter.WriteLine(""); if (rpc.Response.HasFields) { //codeWriter.WriteLine("var query = result.FirstOrDefault();"); codeWriter.WriteLine(); codeWriter.WriteLine($"var response = new {rpc.Response.MessageName}();"); codeWriter.WriteLine(); codeWriter.WriteLine("if (result != null)"); codeWriter.WriteLine("{"); codeWriter.Indent(); if (rpc.ResponseIsList()) { codeWriter.WriteLine("foreach (var r in result)"); codeWriter.WriteLine("{"); codeWriter.Indent(); codeWriter.Write($"response.{rpc.Response.ProtoField.First().FieldName}.Add(r"); if (useToProto) { codeWriter.Write(".ToProto()"); } codeWriter.WriteLine("); "); codeWriter.Unindent(); codeWriter.WriteLine("}"); } else { foreach (var field in rpc.Response.ProtoField) { if (field.Repeated) { if (field.IsScalar) { codeWriter.WriteLine($"response.{field.FieldName}.Add(result.{field.FieldName});"); } else { codeWriter.WriteLine( $"response.{field.FieldName}.Add(result.{field.FieldName}.ToProto());"); } } else { if (field.IsScalar) { codeWriter.WriteLine($"response.{field.FieldName} = result.{field.FieldName};"); } else { codeWriter.WriteLine( $"response.{field.FieldName} = result.{field.FieldName}.ToProto();"); } } } } codeWriter.Unindent(); codeWriter.WriteLine("}"); codeWriter.WriteLine("return response;"); } else { codeWriter.WriteLine(""); codeWriter.WriteLine($"var response = new {rpc.Response.MessageName}"); codeWriter.WriteLine("{ "); codeWriter.WriteLine("};"); codeWriter.WriteLine(""); codeWriter.WriteLine("return response;"); } rpcMethod.CodeSnippet = codeWriter.ToString(); @class.Method.Add(rpcMethod); } return(@class); }
public KProtoFile Convert(string protoFileName, string protoFileContent) { //1. save file to temp folder //2. run protoc compiler, convert to C# class //3. Compile the code in memory //4. Read the .Descriptor //5. Converto SProtoFile var codePath = GenerateCodeFromProto(protoFileContent); var code = GetGeneratedCode(codePath); var assembly = CompileCodeToAssembly(code); var descriptors = GetFileDescriptorsFromAssembly(assembly); var messagesAdded = new List <CProtoMessage>(); var protoFile = new CProtoFile(); protoFile.SourceProtoText = protoFileContent; foreach (var descriptorPair in descriptors) { var descriptor = descriptorPair.Value; protoFile.CSharpNamespace = descriptorPair.Key; protoFile.Import.Add("google/protobuf/timestamp.proto"); protoFile.Import.Add("google/protobuf/duration.proto"); protoFile.Import.Add("google/protobuf/descriptor.proto"); protoFile.Option.Add($@"csharp_namespace = ""{protoFile.CSharpNamespace}"";"); protoFile.Option.Add($@"(version) = ""1.0.0"";"); foreach (var service in descriptor.Services) { var protoService = new CProtoService(protoFile) { ServiceName = service.Name }; foreach (var method in service.Methods) { var protoServiceMethod = new CProtoRpc(protoService) { RpcName = method.Name }; protoService.Rpc.Add(protoServiceMethod); protoServiceMethod.Request = new CProtoMessage(protoServiceMethod) { MessageName = method.InputType.Name }; messagesAdded.Add(protoServiceMethod.Request); foreach (var field in method.InputType.Fields.InFieldNumberOrder()) { //protoServiceMethod.Request.ProtoField.Add(BuildProtoMessageField(field)); ProcessField(field, descriptor, protoServiceMethod.Request, messagesAdded); } protoServiceMethod.Response = new CProtoMessage(protoServiceMethod) { MessageName = method.OutputType.Name }; messagesAdded.Add(protoServiceMethod.Response); foreach (var field in method.OutputType.Fields.InFieldNumberOrder()) { //protoServiceMethod.Response.ProtoField.Add(BuildProtoMessageField(field)); ProcessField(field, descriptor, protoServiceMethod.Response, messagesAdded); } } protoFile.ProtoService.Add(protoService); } foreach (var enumType in descriptor.EnumTypes) { if (protoFile.ProtoEnum.Exists(pe => pe.EnumName == enumType.Name)) { continue; } var protoEnum = new CProtoEnum { EnumName = enumType.Name }; foreach (var enumTypeItem in enumType.Values) { var enumValue = new CProtoEnumValue { EnumValueName = enumTypeItem.Name, EnumValueNumber = enumTypeItem.Number }; protoEnum.EnumValue.Add(enumValue); } protoFile.ProtoEnum.Add(protoEnum); } foreach (var message in descriptor.MessageTypes) { if (messagesAdded.Exists(pm => pm.MessageName == message.Name)) { continue; } var protoMessage = new CProtoMessage(null) { MessageName = message.Name }; foreach (var field in message.Fields.InFieldNumberOrder()) { ProcessField(field, descriptor, protoMessage, messagesAdded); } protoFile.ProtoMessage.Add(protoMessage); messagesAdded.Add(protoMessage); } foreach (var dependency in descriptor.Dependencies) { foreach (var message in dependency.MessageTypes) { if (messagesAdded.Exists(pm => pm.MessageName == message.Name)) { continue; } var protoMessage = new CProtoMessage(null) { MessageName = message.Name, IsExternal = true }; protoFile.ProtoMessage.Add(protoMessage); messagesAdded.Add(protoMessage); } } } return(new KProtoFile { ProtoFileFile = protoFileName, GeneratedProtoFile = protoFile }); }