private CMethod GetTestMethod(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(string.Empty);
codeWriter.WriteLine(string.Empty);
codeWriter.WriteLine("//Act");
codeWriter.WriteLine(string.Empty);
codeWriter.WriteLine(string.Empty);
codeWriter.WriteLine("//Assert");
codeWriter.WriteLine(string.Empty);
method.CodeSnippet = codeWriter.ToString();
return(method);
}
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 IEnumerable <CColumn> InferColumns(CTable table, CProtoRpc rpc, CProtoMessageField protoField)
{
var columns = new List <CColumn>();
DbType columnType1 = DbType.AnsiString;
string columnType1Raw = null;
var field = protoField;
if (field.IsMap)
{
//todo: don't hard code ast <string, bool>
//loop thru the 2 fields in the map and add columns
columnType1 =
SqlMapper.SqlDbTypeToDbType(SqlMapper.GrpcTypeToSqlDbType(Pass2.CModel.GrpcType.__string));
var col1 = new CColumn(table)
{
ColumnName = $"{field.FieldName}{columnType1.ToString()}",
ColumnType = columnType1,
ColumnTypeRaw = "varchar"
};
columns.Add((col1));
var columnType2 =
SqlMapper.SqlDbTypeToDbType(SqlMapper.GrpcTypeToSqlDbType(Pass2.CModel.GrpcType.__bool));
var col2 = new CColumn(table)
{
ColumnName = $"{field.FieldName}{columnType2.ToString()}",
ColumnType = columnType2,
ColumnTypeRaw = "bit"
};
columns.Add((col2));
}
else
{
if (field.IsTimestampMessage)
{
columnType1 = DbType.DateTime2;
columnType1Raw = DbType.DateTime2.ToString();
}
else
{
if (field.FieldType == GrpcType.__message)
{
//if the inner message is just a single scalar field, lets use that
var m = rpc.ProtoService.ProtoFile.ProtoMessage.FirstOrDefault(pm =>
pm.MessageName == field.MessageType);
if (m.ProtoField.Count == 1)
{
field = m.ProtoField.First();
}
}
columnType1 = SqlMapper.SqlDbTypeToDbType(SqlMapper.GrpcTypeToSqlDbType(field.FieldType));
columnType1Raw = SqlMapper.GrpcTypeToSqlDbType(field.FieldType).ToString();
if (field.FieldName.EndsWith("ExternalId"))
{
columnType1 = System.Data.DbType.AnsiStringFixedLength;
columnType1Raw = "char";
}
}
var col = new CColumn(table)
{
ColumnName = field.FieldName,
ColumnType = columnType1,
ColumnTypeRaw = columnType1Raw
};
if (columnType1 == System.Data.DbType.AnsiStringFixedLength)
{
if (col.ColumnName.EndsWith("ExternalId"))
{
col.ColumnLength = 32;
}
else
{
col.ColumnLength = 255;
}
}
else if (columnType1 == System.Data.DbType.AnsiString)
{
col.ColumnLength = 255;
}
columns.Add(col);
}
return(columns);
}
private void InferTableType(IList <CTableType> tableTypes, CProtoRpc rpc, CProtoMessage messageIn)
{
var tableType = new CTableType(DataStoreTypes.SqlServer);
tableType.Schema = InferSchema(rpc.ProtoService);
tableType.TableName = "tt" + InferTableName(messageIn);
tableType.DerivedFrom = messageIn;
//add PK
tableType.Column.Add(new CColumn(tableType)
{
ColumnName = $"{tableType.TableName}Id", IsNullable = false, ColumnTypeRaw = "bigint", ColumnType = System.Data.DbType.Int64, IsPrimaryKey = true, IsIdentity = false
});
foreach (var p in messageIn.ProtoField)
{
var parameter = p;
if (parameter.FieldType == GrpcType.__message)
{
//if the inner message is just a single scalar field, lets use that
var m = rpc.ProtoService.ProtoFile.ProtoMessage.FirstOrDefault(pm => pm.MessageName == parameter.MessageType);
if (m.ProtoField.Count == 1 && !parameter.Repeated)
{
parameter = m.ProtoField.First();
}
else if (m.ProtoField.Count > 1)
{
continue;
}
else
{
continue;
}
}
var columns = InferColumns(tableType, rpc, parameter);
foreach (var col in columns)
{
if (!tableType.ColumnExists(col))
{
tableType.Column.Add(col);
}
}
}
var existingTable = tableTypes.FirstOrDefault(t => t.TableName == tableType.TableName);
if (existingTable != null)
{
//merge the tableTypes
foreach (var col in tableType.Column)
{
if (!existingTable.ColumnExists(col))
{
existingTable.Column.Add(col);
}
}
}
else
{
tableTypes.Add(tableType);
}
//now that tables has been added, add children
//this will attempt to make sure they are in correct order for FK constraints
foreach (var p in messageIn.ProtoField)
{
if (p.FieldType == GrpcType.__message && p.Repeated)
{
//if the inner message is just a single scalar field, lets use that
var m = rpc.ProtoService.ProtoFile.ProtoMessage.FirstOrDefault(pm =>
pm.MessageName == p.MessageType);
// if (m.ProtoField.Count > 1) //its repeated, so field count doesn't matter
{
//recurse
InferTableType(tableTypes, rpc, m);
}
}
}
}
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 CMethod GetTestMethod(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(string.Empty);
codeWriter.WriteLine($"var request = new {rpc.Request.MessageName}();");
if (!rpc.OperationIs.HasFlag(COperationIs.Bulk)) //ignore, for now
{
foreach (var field in rpc.Request.ProtoField)
{
if (!field.IsScalar)
{
var childMessage =
rpc.ProtoService.ProtoFile.ProtoMessage.First(pm => pm.MessageName == field.FieldName);
codeWriter.WriteLine($"request.{field.FieldName} = new {field.FieldName}();");
foreach (var childField in childMessage.ProtoField)
{
if (childField.IsScalar)
{
codeWriter.WriteLine(
$"request.{field.FieldName}.{childField.FieldName} = {SampleDataService.GetSampleData(childField, COperationIs.Undefined)}; ");
}
}
}
else
{
codeWriter.WriteLine(
$"request.{field.FieldName} = {SampleDataService.GetSampleData(field, COperationIs.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 CMethod GetTestMethod(CProtoRpc rpc, COperationIs operationIs)
{
if (rpc.OperationIs.HasFlag(COperationIs.Bulk))
{
return(null);
}
var codeWriter = new CodeWriter();
var methodName = $"{rpc.RpcName}";
if (operationIs == COperationIs.Add)
{
methodName += "Add";
}
else if (operationIs == COperationIs.Update)
{
methodName += "Update";
}
var method = new CMethod
{
MethodIs = operationIs,
DerivedFrom = rpc,
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 SMethodAttribute { AttributeName = "TestMethod" });
codeWriter.WriteLine("//Arrange");
codeWriter.WriteLine(string.Empty);
codeWriter.WriteLine($"var request = new {rpc.Request.MessageName}();");
if (!rpc.OperationIs.HasFlag(COperationIs.Bulk)) //ignore, for now
{
foreach (var field in rpc.Request.ProtoField)
{
if (field.FieldType == GrpcType.__enum)
{
var childEnum = rpc.ProtoService.ProtoFile.ProtoEnum.First(pm =>
pm.EnumName.ToLower() == field.EnumType.ToLower());
}
else if (field.FieldType == GrpcType.__map)
{
//todo:
}
else if (field.FieldType == GrpcType.__message)
{
var childMessage = rpc.ProtoService.ProtoFile.ProtoMessage.First(pm =>
pm.MessageName.ToLower() == field.MessageType.ToLower());
if (!field.Repeated)
{
codeWriter.WriteLine($"request.{field.FieldName} = new {field.FieldName}();");
foreach (var childField in childMessage.ProtoField)
{
if (childField.IsScalar && !childField.Repeated)
{
codeWriter.WriteLine(
$"request.{field.FieldName}.{childField.FieldName} = {SampleDataService.GetSampleData(childField, operationIs)}; ");
}
else if (childField.IsScalar && childField.Repeated)
{
codeWriter.WriteLine(
$"request.{field.FieldName}.{childField.FieldName}.Add({SampleDataService.GetSampleData(childField, operationIs)}); ");
}
}
}
else
{
codeWriter.WriteLine($"var {field.FieldName.ToLower()} = new {field.MessageType}();");
foreach (var childField in childMessage.ProtoField)
{
if (childField.IsScalar && !childField.Repeated)
{
codeWriter.WriteLine(
$"{field.FieldName.ToLower()}.{childField.FieldName} = {SampleDataService.GetSampleData(childField, operationIs)}; ");
}
else if (childField.IsScalar && childField.Repeated)
{
codeWriter.WriteLine(
$"{field.FieldName.ToLower()}.{childField.FieldName}.Add({SampleDataService.GetSampleData(childField, operationIs)}); ");
}
}
codeWriter.WriteLine($"request.{field.FieldName}.Add({field.FieldName.ToLower()});");
}
}
else
{
if (field.Repeated)
{
codeWriter.WriteLine(
$"request.{field.FieldName}.Add({SampleDataService.GetSampleData(field, operationIs)}); ");
}
else
{
if (rpc.DerivedFrom is CStoredProcedure &&
(rpc.DerivedFrom as CStoredProcedure).DataOperationIs.HasFlag(COperationIs.Delete))
{
if (field.FieldType == GrpcType.__int64 || field.FieldType == GrpcType.__int32)
{
codeWriter.WriteLine($"request.{field.FieldName} = _currentDbIdentityValue;");
}
else
{
codeWriter.WriteLine(
$"request.{field.FieldName} = {SampleDataService.GetSampleData(field, operationIs)};");
}
}
else
{
codeWriter.WriteLine(
$"request.{field.FieldName} = {SampleDataService.GetSampleData(field, operationIs)}; ");
}
}
}
}
}
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");
if (rpc.ResponseIsList())
{
codeWriter.WriteLine($"Console.BackgroundColor = ConsoleColor.DarkGreen;");
codeWriter.WriteLine(
$@"Console.WriteLine($""{{response.{rpc.Response.ProtoField.First().FieldName}.Count}} {rpc.Response.ProtoField.First().FieldName} records returned"");");
}
else
{
codeWriter.WriteLine($"Console.BackgroundColor = ConsoleColor.DarkGreen;");
foreach (var field in rpc.Response.ProtoField)
{
codeWriter.WriteLine(
$@"Console.WriteLine($""{{response.{field.FieldName}}}"");");
}
}
//codeWriter.WriteLine(string.Empty);
// codeWriter.WriteLine($@"Assert.Fail(""{method.MethodName}() test is not implemented"");");
method.CodeSnippet = codeWriter.ToString();
return(method);
}
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
});
}
