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
});
}
