private void AddProtoFile(CProject project, CProtoFile protoFile)
{
project.ProjectContent.Add(new CProjectContent
{
Content = protoFile,
BuildAction = CBuildAction.None,
File = new CFile
{
Folder = $@"Proto",
FileName = $"{_mGrpcIntegrationBusinessTestProject.ProjectName}.proto"
}
});
}
private void AddProtoFile(CProject project, CProtoFile protoFile)
{
project.ProjectContent.Add(new CProjectContent
{
Content = protoFile,
BuildAction = CBuildAction.None,
File = new CFile
{
Folder = $@"Proto\ProtoRef\Proto",
FileName = $"{_grpcMServiceClientTestProject.ProjectName}.proto"
}
});
}
// public SProtoFile ProtoFile { get; set; }
public override void ConfigureMetaData()
{
/*
* if (ProtoFile.Count ==0)
* {
* ProtoFile.Add(new MProtoFile());
* return;
* }
*/
foreach (var mProtoFile in ProtoFile)
{
if (mProtoFile.GeneratedProtoFile != null)
{
continue;
}
mProtoFile.GeneratedProtoFile = CProtoFile.FromJson(mProtoFile.ProtoFileText);
}
}
private void AddProtoRpcRef(CProject project, CProtoFile protoFile)
{
foreach (var protoService in protoFile.ProtoService)
{
foreach (var rpc in protoService.Rpc)
{
var protoRpcRef = new CProtoRpcRef {
Direction = CProtoRpcRefDataDirection.Undefined, ProtoRpc = rpc
};
project.ProjectContent.Add(new CProjectContent
{
Content = protoRpcRef,
BuildAction = CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"Proto", FileName = $"{protoRpcRef.ProtoRpc.RpcName}.json"
}
});
}
}
}
/*
* 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
});
}
public void AddModelToProtoMethods(CClass extensionsClass, CProtoFile protoFile, CClass modelClass,
string protoNamespace)
{
var alias = "ProtoAlias";
extensionsClass.NamespaceRef.Add(new CNamespaceRef("System.Collections.Generic"));
extensionsClass.NamespaceRef.Add(new CNamespaceRef("System.Linq"));
extensionsClass.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
Alias = alias, NamespaceName = protoNamespace
}
});
foreach (var protoMessageIn in protoFile.ProtoMessage)
{
CClass convertFromModelClass = null;
//foreach (var modelClass in convertFromModelClasses)
{
var pm = modelClass?.DerivedFrom?.DerivedFrom as CProtoMessage;
if (pm != null && pm.MessageName == protoMessageIn.MessageName)
{
convertFromModelClass = modelClass;
break;
}
}
if (convertFromModelClass == null)
{
return;
}
var protoMessage = protoMessageIn; //protoFile.ProtoMessage.FirstOrDefault(m => m.MessageName == convertFromClass.ClassName);
// var protoMessage2 = convertFromModelClass?.DerivedFrom?.DerivedFrom as CProtoMessage;
//if (protoMessage2 == null)
// continue;
if (protoMessage.ProtoField.Count == 1 &&
protoMessage.ProtoField.First().FieldType == GrpcType.__message)
{
protoMessage = protoMessage.Rpc.ProtoService.ProtoFile.GetRepeatedMessagesUsedInAResponse()
.FirstOrDefault(m => m.MessageName == protoMessage.ProtoField.First().MessageType);
}
if (protoMessage == null)
{
return;
}
var toProtoMethod = new CMethod
{
IsStatic = true,
IsExtensionMethod = true,
ReturnType = $"{alias}.{protoMessage.MessageName}",
MethodName = "ToProto"
};
//todo: create method for fully qualified name
toProtoMethod.Parameter.Add(new CParameter
{
Type = $"{convertFromModelClass.Namespace.NamespaceName}.{convertFromModelClass.ClassName}",
ParameterName = "source"
});
var codeWriter = new CodeWriter();
codeWriter.WriteLine($"return new {alias}.{protoMessage.MessageName}");
codeWriter.WriteLine("{");
codeWriter.Indent();
var first = true;
foreach (var property in convertFromModelClass.Property)
{
//var protoField = protoMessage.ProtoField.FirstOrDefault(pf => pf.FieldName == property.PropertyName.Replace("@", ""));
var protoField = FindProtoMessageField(protoMessage, property);
if (!first)
{
codeWriter.WriteLine(",");
}
first = false;
if (protoField == null)
{
codeWriter.Write($"//<unknownProtoField> = source.{property.PropertyName}");
}
else if (property.Type.ToLower() == "char[]" && protoField.FieldType == GrpcType.__string)
{
codeWriter.Write($"{protoField.FieldName} = source.{property.PropertyName}");
//assume tostring is needed
codeWriter.Write(".ToString()");
}
else if (property.Type.ToLower() == "decimal" && protoField.FieldType == GrpcType.__string)
{
codeWriter.Write($"{protoField.FieldName} = source.{property.PropertyName}");
//assume tostring is needed
codeWriter.Write(".ToString()");
}
else if (property.Type.ToLower() == "decimal" &&
protoField.FieldType == GrpcType.__company_Decimal64Value)
{
codeWriter.Write($"{protoField.FieldName} = new Decimal64Value() ");
}
else if (property.Type.ToLower() == "byte" && protoField.FieldType == GrpcType.__int32)
{
codeWriter.Write($"{protoField.FieldName} = (int) source.{property.PropertyName}");
}
else if (property.Type.ToLower() == "datetime" &&
protoField.FieldType == GrpcType.__google_protobuf_Timestamp)
{
codeWriter.Write(
$"{protoField.FieldName} = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTime(DateTime.SpecifyKind(source.{property.PropertyName}, DateTimeKind.Utc))");
}
else if (property.Type.ToLower() == "datetimeoffset" &&
protoField.FieldType == GrpcType.__google_protobuf_Timestamp)
{
codeWriter.Write(
$"{protoField.FieldName} = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTime(DateTime.SpecifyKind(source.{property.PropertyName}.DateTime, DateTimeKind.Utc))");
}
else if (property.Type.ToLower() == "byte[]" && protoField.FieldType == GrpcType.__bytes)
{
codeWriter.Write(
$"{protoField.FieldName} = Google.Protobuf.ByteString.CopyFrom(source.{property.PropertyName})");
}
else
{
codeWriter.Write($"{protoField.FieldName} = source.{property.PropertyName}");
}
}
codeWriter.WriteLine(string.Empty);
codeWriter.Unindent();
codeWriter.WriteLine("};");
toProtoMethod.CodeSnippet = codeWriter.ToString();
extensionsClass.Method.Add(toProtoMethod);
var toProtoForListMethod = new CMethod
{
IsStatic = true,
IsExtensionMethod = true,
ReturnType = $"IEnumerable<{alias}.{protoMessage.MessageName}>",
MethodName = "ToProto"
};
//todo: create method for fully qualified name
var parameterType = string.Empty;
parameterType =
$"IEnumerable<{convertFromModelClass.Namespace.NamespaceName}.{convertFromModelClass.ClassName}>";
toProtoForListMethod.Parameter.Add(new CParameter {
Type = parameterType, ParameterName = "source"
});
var codeWriter3 = new CodeWriter();
codeWriter3.WriteLine($"return source.Select(s => s.ToProto()).ToList();");
toProtoForListMethod.CodeSnippet = codeWriter3.ToString();
extensionsClass.Method.Add(toProtoForListMethod);
}
}
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);
}
public void AddProtoToModelMethods(CClass extensionsClass, CProtoFile protoFile, CClass convertFromProtoClass,
string protoNamespace)
{
var alias = "ProtoAlias";
extensionsClass.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = "System.Collections.Generic"
}
});
extensionsClass.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = protoNamespace
}
});
//todo: should we use SProtoFile instead?
//foreach (var convertFromProtoClass in convertFromProtoClasses)
{
var protoMessage = protoFile.ProtoMessage.FirstOrDefault(m => m.MessageName == convertFromProtoClass.ClassName);
if (protoMessage == null)
{
return;
}
var toProtoMethod = new CMethod
{
IsStatic = true,
IsExtensionMethod = true,
ReturnType = convertFromProtoClass.ClassName,
MethodName = "ToModel"
};
//todo: create method for fully qualified name
toProtoMethod.Parameter.Add(new CParameter
{
Type = $"{convertFromProtoClass.Namespace.NamespaceName}.{convertFromProtoClass.ClassName}",
ParameterName = "source"
});
var codeWriter = new CodeWriter();
codeWriter.WriteLine($"return new {convertFromProtoClass.ClassName}");
codeWriter.WriteLine("{");
codeWriter.Indent();
var first = true;
foreach (var property in convertFromProtoClass.Property)
{
//var protoField = protoMessage.ProtoField.FirstOrDefault(pf => pf.FieldName == property.PropertyName.Replace("@", ""));
var protoField = FindProtoMessageField(protoMessage, property);
if (!first)
{
codeWriter.WriteLine(",");
}
first = false;
if (protoField == null)
{
codeWriter.Write($"//<unknownProtoField> = source.{property.PropertyName}");
}
else if (property.Type.ToLower() == "char[]" && protoField.FieldType == GrpcType.__string)
{
codeWriter.Write($"{protoField.FieldName} = source.{property.PropertyName}");
//assume tostring is needed
codeWriter.Write(".ToString()");
}
else if (property.Type.ToLower() == "decimal" && protoField.FieldType == GrpcType.__string)
{
codeWriter.Write($"{protoField.FieldName} = source.{property.PropertyName}");
//assume tostring is needed
codeWriter.Write(".ToString()");
}
else if (property.Type.ToLower() == "byte" && protoField.FieldType == GrpcType.__int32)
{
codeWriter.Write($"{protoField.FieldName} = (int) source.{property.PropertyName}");
}
else if (property.Type.ToLower() == "datetime" &&
protoField.FieldType == GrpcType.__google_protobuf_Timestamp)
{
codeWriter.Write(
$"{protoField.FieldName} = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTime(DateTime.SpecifyKind(source.{property.PropertyName}, DateTimeKind.Utc))");
}
else if (property.Type.ToLower() == "datetimeoffset" &&
protoField.FieldType == GrpcType.__google_protobuf_Timestamp)
{
codeWriter.Write(
$"{protoField.FieldName} = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTime(DateTime.SpecifyKind(source.{property.PropertyName}.DateTime, DateTimeKind.Utc))");
}
else if (property.Type.ToLower() == "byte[]" && protoField.FieldType == GrpcType.__bytes)
{
codeWriter.Write(
$"{protoField.FieldName} = Google.Protobuf.ByteString.CopyFrom(source.{property.PropertyName})");
}
else
{
codeWriter.Write($"{protoField.FieldName} = source.{property.PropertyName}");
}
}
codeWriter.WriteLine(string.Empty);
codeWriter.Unindent();
codeWriter.WriteLine("};");
toProtoMethod.CodeSnippet = codeWriter.ToString();
extensionsClass.Method.Add(toProtoMethod);
}
}
private CMethod GetTestMethod(CProtoFile protoFile, CProtoRpc rpc)
{
var codeWriter = new CodeWriter();
var methodName = $"{rpc.RpcName}_Success";
var method = new CMethod
{
ReturnType = "Task",
IsAsync = true,
IsStatic = false,
MethodName = methodName,
Parameter = new List <CParameter>
{
new CParameter
{
Type = $"{rpc.ProtoService.ServiceName}.{rpc.ProtoService.ServiceName}Client",
ParameterName = "client"
}
}
};
method.Attribute.Add(new CMethodAttribute {
AttributeName = "TestMethod"
});
codeWriter.WriteLine("//Arrange");
codeWriter.WriteLine();
codeWriter.WriteLine($"var request = new {rpc.Request.MessageName}();");
/*
* if (!rpc.OperationIs.HasFlag(SOperationIs.Bulk)) //ignore, for now
* {
* foreach (var field in rpc.Request.ProtoField)
* {
* if (!field.IsScalar)
* {
* var childMessage = protoFile.ProtoMessage.First(pm => pm.MessageName == field.MessageType);
* codeWriter.WriteLine($"request.{field.FieldName} = new {field.MessageType}();");
* foreach (var childField in childMessage.ProtoField)
* {
* if (childField.IsScalar)
* {
* codeWriter.WriteLine($"request.{field.FieldName}.{childField.FieldName} = {SampleDataService.GetSampleData(childField, SOperationIs.Undefined)}; ");
* }
* }
* }
* else
* {
* codeWriter.WriteLine($"request.{field.FieldName} = {SampleDataService.GetSampleData(field, SOperationIs.Undefined)}; ");
*
* }
* }
* }
*/
codeWriter.WriteLine(string.Empty);
codeWriter.WriteLine("//Act");
codeWriter.WriteLine(string.Empty);
codeWriter.WriteLine($"var response = await client.{rpc.RpcName}Async(request);");
codeWriter.WriteLine(string.Empty);
codeWriter.WriteLine("//Assert");
codeWriter.WriteLine(string.Empty);
codeWriter.WriteLine($@"Assert.Fail(""{method.MethodName}() test is not implemented"");");
method.CodeSnippet = codeWriter.ToString();
return(method);
}
private void AddProgramClass(CProject project, CProtoFile protoFile)
{
var programClass = new CClass("Program")
{
Namespace = new CNamespace
{
NamespaceName =
$"{_mGrpcIntegrationBusinessTestProject.CompanyName}.{_mGrpcIntegrationBusinessTestProject.ProjectName}{_mGrpcIntegrationBusinessTestProject.NamespaceSuffix}.{_mGrpcIntegrationBusinessTestProject.ProjectSuffix}"
}
};
programClass.NamespaceRef.Add(
new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = "Grpc.Core"
}
});
programClass.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = "Google.Protobuf.WellKnownTypes"
}
});
programClass.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = "Microsoft.VisualStudio.TestTools.UnitTesting"
}
});
foreach (var protoService in protoFile.ProtoService)
{
programClass.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = $"{protoService.ProtoFile.CSharpNamespace}"
}
});
}
var methodSnippet = new CodeWriter();
var mainMethod =
new CMethod
{
ReturnType = "void",
IsStatic = true,
MethodName = "Main",
Parameter = new List <CParameter> {
new CParameter {
Type = "string []", ParameterName = "args"
}
}
};
methodSnippet.WriteLine($@"Console.WriteLine(""Press any key once the service has started"");");
methodSnippet.WriteLine(@"Console.ReadKey();");
methodSnippet.WriteLine(@"Channel channel = new Channel(""0.0.0.0:50025"", ChannelCredentials.Insecure); ");
programClass.Method.Add(mainMethod);
foreach (var protoService in protoFile.ProtoService)
{
methodSnippet.WriteLine(
$"var client = new {protoService.ServiceName}.{protoService.ServiceName}Client(channel);");
}
mainMethod.CodeSnippet = methodSnippet.ToString();
methodSnippet.WriteLine(@"Console.WriteLine(""Completed"");");
methodSnippet.WriteLine(@"Console.ReadKey();");
project.ProjectContent.Add(new CProjectContent
{
Content = programClass,
BuildAction = CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"", FileName = $"{programClass.ClassName}.cs"
}
});
}
public CClass BuildExtensionsClass(KGrpcProject grpcKProject, CClass domainModelClass, CProtoFile protoFile,
string protoNamespace)
{
var extensionClass = new CClass($"{domainModelClass.ClassName}Extensions")
{
IsStatic = true,
Namespace = new CNamespace
{
NamespaceName =
$"{grpcKProject.CompanyName}.{grpcKProject.ProjectName}{grpcKProject.NamespaceSuffix}.{grpcKProject.ProjectSuffix}.Extensions"
}
};
return(extensionClass);
}
public void AddEntityToModelMethods(CClass extensionsClass, CProtoFile protoFile, IList <CClass> modelClasses,
List <CClass> convertFromEntityClasses,
string modelNamespace)
{
var alias = "Model";
extensionsClass.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = "System"
}
});
extensionsClass.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = "System.Linq"
}
});
extensionsClass.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
Alias = alias, NamespaceName = modelNamespace
}
});
//todo: should we use SProtoFile instead?
foreach (var convertFromClass in convertFromEntityClasses)
{
//this is a little "fuzzy" since one stored proc could produce 2 "Models". One for the params and another for resultset
var convertFrompProtoRpc = convertFromClass.DerivedFrom?.DerivedFrom as CProtoMessage;
//var modelClass = modelClasses.FirstOrDefault(mc => (mc.DerivedFrom?.DerivedFrom as CProtoMessage)?.Rpc == convertFrompProtoRpc);
if (convertFrompProtoRpc == null)
{
_logger.LogWarning($"convertFrompProtoRpc is null");
continue;
}
var modelClass =
modelClasses.FirstOrDefault(mc => mc.ClassName == convertFrompProtoRpc.DomainModelNameForOutput);
if (modelClass == null)
{
continue;
}
var toModelMethod = new CMethod
{
IsStatic = true,
IsExtensionMethod = true,
ReturnType = $"{alias}.{modelClass.ClassName}",
MethodName = "ToModel"
};
//todo: create method for fully qualified name
toModelMethod.Parameter.Add(new CParameter
{
Type = $"{convertFromClass.Namespace.NamespaceName}.{convertFromClass.ClassName}",//$"Model.{convertFrompProtoRpc.DomainModelNameForOutput}",// $"{convertFromClass.Namespace.NamespaceName}.{convertFromClass.ClassName}",
ParameterName = "source"
});
var codeWriter = new CodeWriter();
//var protoMessage = protoFile.ProtoMessage.FirstOrDefault(m => m.MessageName == convertFromClass.ClassName);
if (modelClass == null)
{
codeWriter.WriteLine("throw new NotImplementedException();");
}
else
{
codeWriter.WriteLine($"return new {alias}.{ modelClass.ClassName}");
codeWriter.WriteLine("{");
codeWriter.Indent();
var first = true;
foreach (var convertToProperty in modelClass.Property)
{
var convertFromProperty =
convertFromClass.Property.FirstOrDefault(p =>
p.PropertyName == convertToProperty.PropertyName);
if (convertFromProperty == null)
{
continue;
}
if (!first)
{
codeWriter.WriteLine(",");
}
first = false;
codeWriter.Write($"{convertToProperty.PropertyName} = source.{convertFromProperty.PropertyName}");
}
codeWriter.Unindent();
codeWriter.WriteLine("};");
}
toModelMethod.CodeSnippet = codeWriter.ToString();
extensionsClass.Method.Add(toModelMethod);
}
}
public string Convert(CProtoFile protoFile)
{
var codeWriter = new CodeWriter();
codeWriter.WriteLine($@"syntax = ""{protoFile.ProtoSyntax}"";");
codeWriter.WriteLine(string.Empty);
if (protoFile.Package != null)
{
foreach (var package in protoFile.Package)
{
codeWriter.WriteLine($@"package {package};");
}
}
codeWriter.WriteLine();
foreach (var import in protoFile.Import)
{
codeWriter.WriteLine($@"import ""{import}"";");
}
codeWriter.WriteLine();
//todo: remove hard coding
codeWriter.WriteLine(@"extend google.protobuf.FileOptions {");
codeWriter.WriteLine(@" string version = 50000;");
codeWriter.WriteLine(@"}");
foreach (var option in protoFile.Option)
{
codeWriter.WriteLine($"option {option}");
}
codeWriter.WriteLine();
foreach (var service in protoFile.ProtoService)
{
codeWriter.WriteLine($"service {service.ServiceName} {{");
codeWriter.Indent();
foreach (var rpc in service.Rpc)
{
codeWriter.WriteLine();
if (!string.IsNullOrEmpty(rpc.RpcDescription) && !string.IsNullOrWhiteSpace(rpc.RpcDescription))
{
codeWriter.WriteLine($@"/* {rpc.RpcDescription} */");
}
codeWriter.Write($"rpc {rpc.RpcName} ({rpc.Request.MessageName}) ");
codeWriter.WriteLine($"returns ({rpc.Response.MessageName});");
}
codeWriter.Unindent();
codeWriter.WriteLine("}");
}
codeWriter.WriteLine();
var messages = new List <CProtoMessage>();
messages.AddRange(protoFile.ProtoMessage);
foreach (var service in protoFile.ProtoService)
{
foreach (var rpc in service.Rpc)
{
messages.Add(rpc.Request);
messages.Add(rpc.Response);
}
}
foreach (var message in messages)
{
if (message.IsExternal)
{
continue;
}
codeWriter.WriteLine($"message {message.MessageName} {{");
codeWriter.Indent();
var position = 1;
foreach (var field in message.ProtoField)
{
if (field.Repeated)
{
codeWriter.Write("repeated ");
}
var fieldType = string.Empty;
if (field.FieldType == GrpcType.__message)
{
fieldType = field.MessageType;
}
else if (field.FieldType == GrpcType.__enum)
{
fieldType = field.EnumType;
}
else if (field.FieldType == GrpcType.__map)
{
fieldType = field.MapType;
}
else
{
fieldType = field.FieldType.ToString().Replace("__", "").Replace("_", ".");
}
codeWriter.WriteLine($"{fieldType} {field.FieldNameGrpc} = {position}; // {field.Comment}");
position++;
}
codeWriter.Unindent();
codeWriter.WriteLine("}");
}
codeWriter.WriteLine(string.Empty);
foreach (var enumItem in protoFile.ProtoEnum)
{
codeWriter.WriteLine($"enum {enumItem.EnumName} {{");
codeWriter.Indent();
var position = 1;
foreach (var enumItemValue in enumItem.EnumValue)
{
codeWriter.WriteLine($"{enumItemValue.EnumValueName} = {enumItemValue.EnumValueNumber}; ");
position++;
}
codeWriter.Unindent();
codeWriter.WriteLine("}");
}
codeWriter.WriteLine(string.Empty);
return(codeWriter.ToString());
}
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 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
});
}
public void AddToModelAsListMethods(CClass extensionsClass, CClass domainModelClass, CProtoFile protoFile, string protoNamespace)
{
var alias = "ProtoAlias";
extensionsClass.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = protoNamespace
}
});
extensionsClass.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = "System.Collections.Generic"
}
});
extensionsClass.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = "System.Linq"
}
});
extensionsClass.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = "Google.Protobuf.Collections"
}
});
{
if (!protoFile.ProtoMessage.Exists(m => m.MessageName == domainModelClass.ClassName))
{
return;
}
var toModelMethod = new CMethod
{
IsStatic = true,
IsExtensionMethod = true,
ReturnType = $"IEnumerable<{domainModelClass.Namespace.NamespaceName}.{domainModelClass.ClassName}>",
MethodName = "ToModel"
};
//todo: create method for fully qualified name
var parameterType = string.Empty;
parameterType = $"RepeatedField<{alias}.{domainModelClass.ClassName}>";
toModelMethod.Parameter.Add(new CParameter {
Type = parameterType, ParameterName = "source"
});
var codeWriter = new CodeWriter();
codeWriter.WriteLine($"return source.Select(s => s.ToModel()).ToList();");
toModelMethod.CodeSnippet = codeWriter.ToString();
extensionsClass.Method.Add(toModelMethod);
}
}
