private static void NewMethod(CMethod method)
{
if (method.ReturnType == null)
{
throw new ArgumentException("ReturnType not set");
}
}
public void PrintSimpleFunctionTest()
{
var ifStatement = new CIf((CExpression)5 != 3.2f, new CBlock(
new CLabel("Start"),
new CWhile(true),
new CGoto("Start"),
CExpression.Assign(new CVariable("Something")[5], "Thing")
));
var procedure = new CMethod("test_a", (new CType("void", true), "a"), (new CType("int"), "b"))
{
IsStatic = true,
Body = new CBlock(ifStatement)
};
Console.WriteLine(procedure);
}
}
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);
}
}
private CMethod BuildSetupMethod()
{
var setupMethod = new CMethod
{
AccessModifier = CAccessModifier.Public,
ReturnType = "void",
MethodName = "Setup"
};
setupMethod.Attribute.Add(new CMethodAttribute {
AttributeName = "TestInitialize"
});
return(setupMethod);
}
private static void AddParameterInUpdate(CMethod m, CFieldM f)
{
if (!f.IsNullable)
{
m.AddSentence(new CTextualSentence($"\tcom.Parameters.AddWithValue({ SUtil.DoubleQuote(f.ParameterName)},item.{f.Name});"));
}
else
{
m.AddSentence(new CTextualSentence($"if (item.{f.Name} == null) {{"));
m.AddSentence(new CTextualSentence($"\tcom.Parameters.AddWithValue({ SUtil.DoubleQuote(f.ParameterName)},DBNull.Value);"));
m.AddSentence(new CTextualSentence("}else{"));
m.AddSentence(new CTextualSentence($"\tcom.Parameters.AddWithValue({ SUtil.DoubleQuote(f.ParameterName)},item.{f.Name});"));
m.AddSentence(new CTextualSentence("}"));
}
}
private CMethod BuildDisposeMethod()
{
var disposeMethod = new CMethod
{
AccessModifier = CAccessModifier.Public,
ReturnType = "void",
MethodName = "Dispose"
};
disposeMethod.Attribute.Add(new CMethodAttribute {
AttributeName = "TestCleanup"
});
return(disposeMethod);
}
private CMethod BuildInitializeMethod()
{
var setupMethod = new CMethod
{
AccessModifier = CAccessModifier.Public,
ReturnType = "void",
MethodName = "Initialize"
};
setupMethod.CodeSnippet = "//todo: create mock data service";
setupMethod.Attribute.Add(new CMethodAttribute {
AttributeName = "TestInitialize"
});
return(setupMethod);
}
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 CMethod BuildDisposeMethod()
{
var disposeMethod = new CMethod
{
AccessModifier = CAccessModifier.Public,
ReturnType = "void",
MethodName = "Dispose"
};
disposeMethod.Attribute.Add(new CMethodAttribute {
AttributeName = "TestCleanup"
});
disposeMethod.CodeSnippet =
$@" _channel.ShutdownAsync().Wait();
_server.ShutdownAsync().Wait();";
return(disposeMethod);
}
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);
}
}
private List <CMethod> GetDataServiceMethodsFromQueries()
{
var methods = new List <CMethod>();
foreach (var kQuery in _dataStoreKProject.Query)
{
if (kQuery.GeneratedQuery == null)
{
//todo: shouldn't have any null
continue;
}
var query = kQuery.GeneratedQuery;
CClass dtoParameterClass = null; // GetParameterDto(query, query.ParameterSetName);
CClass dtoResultClass = null; //GetResultDto(query, query.ResultSetName);
var method = new CMethod
{
AccessModifier = CAccessModifier.Public,
IsAsync = true,
ReturnType = query.HasResultSet
? $"Task<IEnumerable<{dtoResultClass.ClassName}>>"
: "Task<bool>",
MethodName = $"{query.QueryName}Async",
//DerivedFrom = query
};
if (dtoParameterClass != null)
{
var methodParameter = new CParameter
{
Type = dtoParameterClass.ClassName,
ParameterName = dtoParameterClass.ClassName.ToLower() //.ParameterNameCamelCase
};
method.Parameter.Add(methodParameter);
}
else
{
foreach (var parameter in query.Parameter)
{
var type = "object";
if (!parameter.ParameterTypeIsUserDefined)
{
type = SqlMapper.ParseValueAsSqlDbType(parameter.ParameterTypeRaw).ToClrTypeName();
if (parameter.IsCollection)
{
type = $"IEnumerable<{type}>";
}
}
else if (parameter.ParameterTypeIsUserDefined)
{
var parameterType = parameter.ParameterTypeRaw;
if (parameterType.StartsWith("tt"))
{
parameterType = parameterType.Substring(2, parameterType.Length - 2);
}
var tableDto = FindTableByParameterTypeRaw(parameterType);
type = GetTableDto(_tables, tableDto, tableDto.TableName).ClassName;
type = $"IEnumerable<{type}>";
/*
* var tableType = FindTableType(parameter.ParameterTypeRaw);
*
* type = GetTableTypeDto(tableType.GeneratedTableType, tableType.TableTypeName).ClassName;
* type = $"IEnumerable<{type}>";
*/
}
var methodParameter = new CParameter
{
Type = type,
ParameterName = parameter.ParameterNameCamelCase
};
method.Parameter.Add(methodParameter);
}
}
var codeWriter = new CodeWriter();
codeWriter.WriteLine($@"using var connection = DbProvider.GetConnection();");
codeWriter.WriteLine("");
codeWriter.WriteLine("var sqlParams = new DynamicParameters();");
if (dtoParameterClass != null)
{
foreach (var property in dtoParameterClass.Property)
{
var propertyName = property.PropertyName;
/*
* if (ConnectsToDatabaseType == DatabaseTypes.Postgres)
* propertyName = propertyName.ToSnakeCase();
*/
var dbType = SqlMapper.GetDbType(property.Type);
codeWriter.WriteLine(
$@"sqlParams.Add(""@{propertyName}"",{dtoParameterClass.ClassName.ToLower()}.{
property.PropertyName
}, DbType.{dbType});");
}
}
else
{
foreach (var parameter in query.Parameter)
{
var parameterName = parameter.ParameterName;
/*
* if (ConnectsToDatabaseType == DatabaseTypes.Postgres)
* parameterName = parameterName.ToSnakeCase();
*/
if (parameter.ParameterTypeIsUserDefined)
{
var tableType = FindTableType(parameter.ParameterTypeRaw);
var tableTypeClass = BuildTableTypeList(tableType);
codeWriter.WriteLine(
$@"sqlParams.Add(""@{parameterName}"",new {tableTypeClass.ClassName}({
parameter.ParameterNameCamelCase
}), DbType.Object);");
}
else
{
var dbType = parameter.ParameterType.ToClrType().ToDbType();
codeWriter.WriteLine(
$@"sqlParams.Add(""@{parameter.ParameterName}"",{
parameter.ParameterNameCamelCase
}, DbType.{dbType});");
}
}
}
codeWriter.WriteLine("");
if (query.HasResultSet)
{
var schemaName = query.Schema.SchemaName;
var queryName = query.QueryName;
var resultClassName = dtoResultClass.ClassName;
/*
* if (ConnectsToDatabaseType == DatabaseTypes.Postgres)
* {
* schemaName = schemaName.ToSnakeCase();
* queryName = queryName.ToSnakeCase();
* resultClassName = resultClassName.ToSnakeCase();
* }*/
codeWriter.WriteLine($@"var result = await connection");
codeWriter.WriteLine($@" .QueryAsync<{dtoResultClass.ClassName}>(");
codeWriter.WriteLine(
$@" ""{schemaName}.{queryName}"",");
codeWriter.WriteLine($@" sqlParams,");
codeWriter.WriteLine($@" commandType: CommandType.StoredProcedure)");
codeWriter.WriteLine($@" .ConfigureAwait(false);");
codeWriter.WriteLine("");
codeWriter.WriteLine($@"return result.ToList();");
}
else
{
codeWriter.WriteLine($@"var result = await connection");
codeWriter.WriteLine($@" .ExecuteAsync(");
codeWriter.WriteLine(
$@" ""{query.QueryName}"",");
codeWriter.WriteLine($@" sqlParams,");
codeWriter.WriteLine($@" commandType: CommandType.StoredProcedure)");
codeWriter.WriteLine($@" .ConfigureAwait(false);");
codeWriter.WriteLine("");
codeWriter.WriteLine($@"return result > 0;");
}
codeWriter.WriteLine(@"");
method.CodeSnippet = codeWriter.ToString();
methods.Add(method);
}
return(methods);
}
private List <CMethod> GetDataServiceMethodsFromStoredProcs()
{
var methods = new List <CMethod>();
foreach (var storedProcedure in _dataStoreKProject.StoredProcedure.Select(s => s.GeneratedStoredProcedure))
{
var dtoParameterClass = BuildParameterEntityClass(storedProcedure, storedProcedure.ParameterSetName);
var dtoResultClass = BuildResultEntityClass(storedProcedure, storedProcedure.ResultSetName, _dataLayerKProject);
var method = new CMethod
{
AccessModifier = CAccessModifier.Public,
IsAsync = true,
ReturnType = storedProcedure.HasResultSet
? $"Task<IEnumerable<{dtoResultClass.ClassName}>>"
: "Task<bool>",
MethodName = $"{storedProcedure.StoredProcedureName}Async",
DerivedFrom = storedProcedure
};
if (dtoParameterClass != null)
{
var methodParameter = new CParameter
{
Type = dtoParameterClass.ClassName,
ParameterName = dtoParameterClass.ClassName.ToLower() //.ParameterNameCamelCase
};
method.Parameter.Add(methodParameter);
}
else
{
foreach (var parameter in storedProcedure.Parameter)
{
var type = "object";
if (!parameter.ParameterTypeIsUserDefined)
{
type = SqlMapper.ParseValueAsSqlDbType(parameter.ParameterTypeRaw).ToClrTypeName();
if (parameter.IsCollection)
{
type = $"IEnumerable<{type}>";
}
}
else if (parameter.ParameterTypeIsUserDefined)
{
var parameterType = parameter.ParameterTypeRaw;
if (parameterType.StartsWith("tt"))
{
parameterType = parameterType.Substring(2, parameterType.Length - 2);
}
var tableDto = FindTableByParameterTypeRaw(parameterType);
type = GetTableDto(_tables, tableDto, tableDto.TableName).ClassName;
type = $"IEnumerable<{type}>";
/*
* var tableType = FindTableType(parameter.ParameterTypeRaw);
*
* type = GetTableTypeDto(tableType.GeneratedTableType, tableType.TableTypeName).ClassName;
* type = $"IEnumerable<{type}>";
*/
}
var methodParameter = new CParameter
{
Type = type,
ParameterName = parameter.ParameterNameCamelCase
};
method.Parameter.Add(methodParameter);
}
}
var codeWriter = new CodeWriter();
codeWriter.WriteLine($@"using var connection = DbProvider.GetConnection();");
codeWriter.WriteLine("");
codeWriter.WriteLine("var sqlParams = new DynamicParameters();");
if (dtoParameterClass != null)
{
foreach (var property in dtoParameterClass.Property)
{
var propertyName = property.PropertyName;
if (storedProcedure.ConvertToSnakeCase)
{
propertyName = propertyName.ToSnakeCase();
}
var dbType = SqlMapper.GetDbType(property.Type);
codeWriter.WriteLine(
$@"sqlParams.Add(""@{propertyName}"", {dtoParameterClass.ClassName.ToLower()}.{
property.PropertyName
}, DbType.{dbType});");
}
}
else
{
foreach (var parameter in storedProcedure.Parameter)
{
var parameterName = parameter.ParameterName;
if (storedProcedure.ConvertToSnakeCase)
{
parameterName = parameterName.ToSnakeCase();
}
if (parameter.ParameterTypeIsUserDefined)
{
var tableType = FindTableType(parameter.ParameterTypeRaw);
var tableTypeClass = BuildTableTypeList(tableType);
if (tableTypeClass != null)
{
codeWriter.WriteLine(
$@"sqlParams.Add(""@{parameterName}"", new {tableTypeClass.ClassName}({
parameter.ParameterNameCamelCase
}), DbType.Object);");
}
else
{
codeWriter.WriteLine("//todo");
}
}
else
{
var dbType = parameter.ParameterType.ToClrType().ToDbType();
codeWriter.WriteLine(
$@"sqlParams.Add(""@{parameterName}"", {
parameter.ParameterNameCamelCase
}, DbType.{dbType});");
}
}
}
codeWriter.WriteLine("");
var resultClassName = dtoResultClass.ClassName;
var storedProcName = storedProcedure.StoredProcedureName;
var storedProcNameOriginal = storedProcedure.StoredProcedureName;
var schemaName = storedProcedure.Schema.SchemaName;
if (storedProcedure.ConvertToSnakeCase)
{
resultClassName = resultClassName.ToSnakeCase();
storedProcName = storedProcName.ToSnakeCase();
schemaName = schemaName.ToSnakeCase();
}
if (storedProcedure.GenerateAsEmbeddedQuery)
{
codeWriter.WriteLine($@"var sqlQuery = Assembly.GetExecutingAssembly().GetEmbeddedQuery(""{storedProcNameOriginal}"");");
}
if (storedProcedure.HasResultSet)
{
codeWriter.WriteLine($@"var result = await connection");
codeWriter.WriteLine($@" .QueryAsync<{dtoResultClass.ClassName}>(");
if (storedProcedure.GenerateAsEmbeddedQuery)
{
codeWriter.WriteLine(
$@" sqlQuery,");
codeWriter.WriteLine($@" sqlParams,");
codeWriter.WriteLine($@" commandType: CommandType.Text)");
}
else
{
codeWriter.WriteLine(
$@" ""{schemaName}.{storedProcName}"",");
codeWriter.WriteLine($@" sqlParams,");
codeWriter.WriteLine($@" commandType: CommandType.StoredProcedure)");
}
codeWriter.WriteLine($@" .ConfigureAwait(false);");
codeWriter.WriteLine("");
codeWriter.WriteLine($@"return result.ToList();");
}
else
{
codeWriter.WriteLine($@"var result = await connection");
codeWriter.WriteLine($@" .ExecuteAsync(");
if (storedProcedure.GenerateAsEmbeddedQuery)
{
codeWriter.WriteLine(
$@" sqlQuery,");
codeWriter.WriteLine($@" sqlParams,");
codeWriter.WriteLine($@" commandType: CommandType.Text)");
}
else
{
codeWriter.WriteLine(
$@" ""{schemaName}.{storedProcName}"",");
codeWriter.WriteLine($@" sqlParams,");
codeWriter.WriteLine($@" commandType: CommandType.StoredProcedure)");
}
codeWriter.WriteLine($@" .ConfigureAwait(false);");
codeWriter.WriteLine("");
codeWriter.WriteLine($@"return result > 0;");
}
codeWriter.Write(@"");
method.CodeSnippet = codeWriter.ToString();
methods.Add(method);
}
return(methods);
}
private CClass BuildDataHealthCheckClass(CInterface dataHealthCheckInterface, CClass baseDataService, CInterface dbProviderInterface)
{
var @class = new CClass("DataHealthCheckService")
{
AccessModifier = CAccessModifier.Public,
Implements = new List <CInterface>()
{
dataHealthCheckInterface
},
InheritsFrom = baseDataService
};
@class.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = "System"
}
});
@class.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = "System.Threading.Tasks"
}
});
/*
* @class.NamespaceRef.Add(new CNamespaceRef
* {
* ReferenceTo = new CNamespace { NamespaceName = "Dapper" }
* });
*/
@class.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = baseDataService.Namespace
});
@class.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = dbProviderInterface.Namespace
});
@class.Namespace = new CNamespace {
NamespaceName = dataHealthCheckInterface.Namespace.NamespaceName
};
var constructor = new CConstructor
{
AccessModifier = CAccessModifier.Public,
ConstructorName = "DataHealthCheckService",
Parameter = new List <CParameter>
{
new CParameter {
Type = dbProviderInterface.InterfaceName, ParameterName = "dbProvider", PassToBaseClass = true
},
},
CodeSnippet = "//Empty Constructor"
};
@class.Constructor.Add(constructor);
var methodCheck = new CMethod {
ReturnType = "Task<bool>", MethodName = "Check", IsAsync = true, AccessModifier = CAccessModifier.Public
};
/*
* methodCheck.CodeSnippet =
* @"using var connection = DbProvider.GetConnection();
*
* return await connection.QueryFirstAsync<bool>(""select 1"").ConfigureAwait(false);
* ";
*/
methodCheck.CodeSnippet = "throw new NotImplementedException();";
@class.Method.Add(methodCheck);
return(@class);
}
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 void VisitCMethod(CMethod method)
{
_methodVisitor.Visit(this, method);
}
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);
}
}
private CMethod BuildAddAppServicesMethod(KGrpcProject grpcKProject, DataStoreTypes connectsToDatabaseType, CInterface dbProviderInterface, CClass dbProviderClass)
{
var method = new CMethod
{
AccessModifier = CAccessModifier.Private,
IsStatic = true,
IsExtensionMethod = true,
ReturnType = "void",
MethodName = "AddAppServices",
Parameter = new List <CParameter>
{
new CParameter {
Type = "IServiceCollection", ParameterName = "services"
},
new CParameter {
Type = "IConfiguration", ParameterName = "configuration"
}
}
};
var methodSnippet = new CodeWriter();
methodSnippet.WriteLine($@"services.AddSingleton(");
methodSnippet.WriteLine($@"p => p.GetRequiredService<IOptions<ServiceSettings>>().Value);");
methodSnippet.WriteLine();
methodSnippet.Unindent();
methodSnippet.WriteLine($@"services.AddSingleton(");
methodSnippet.Indent();
methodSnippet.WriteLine($@"p => p.GetRequiredService<IOptions<CloudformationOutputs>>().Value);");
methodSnippet.Unindent();
methodSnippet.WriteLine();
methodSnippet.WriteLine($@"services.AddSingleton(");
methodSnippet.Indent();
methodSnippet.WriteLine($@"p => p.GetRequiredService<IOptions<AuthenticationSettings>>().Value);");
methodSnippet.WriteLine();
methodSnippet.Unindent();
if (dbProviderInterface != null)
{
methodSnippet.WriteLine($@"services.AddTransient<{dbProviderInterface.InterfaceName}>(");
methodSnippet.Indent();
methodSnippet.WriteLine(
$@"p =>
{{
var outputs = p.GetRequiredService<CloudformationOutputs>();");
methodSnippet.Indent();
if (connectsToDatabaseType == DataStoreTypes.SqlServer ||
connectsToDatabaseType == DataStoreTypes.Postgres ||
connectsToDatabaseType == DataStoreTypes.MySql)
{
methodSnippet.WriteLine(
$@"if (!string.IsNullOrWhiteSpace(outputs.DBEndpoint))
{{
return new {grpcKProject.ProjectNameAsClassNameFriendly}DbProvider(
outputs.DBEndpoint,
outputs.Database,
outputs.DBUsername,
outputs.DBPassword,
outputs.Port);
}}
return new {dbProviderClass.ClassName}(configuration.GetConnectionString(""{
grpcKProject.ProjectName
}""));");
}
else
{
methodSnippet.WriteLine($@"return new {dbProviderClass.ClassName}();");
methodSnippet.Unindent();
}
methodSnippet.WriteLine("});");
methodSnippet.WriteLine();
methodSnippet.Unindent();
methodSnippet.Unindent();
}
method.CodeSnippet = methodSnippet.ToString();
return(method);
}
private void AddProgramClass(CProject project)
{
var programClass = new CClass("Program")
{
Namespace = new CNamespace
{
NamespaceName =
$"{_grpcMServiceIntegrationTestProject.CompanyName}.{_grpcMServiceIntegrationTestProject.ProjectName}{_grpcMServiceIntegrationTestProject.NamespaceSuffix}.{_grpcMServiceIntegrationTestProject.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 protoFile in _mGrpcProject.ProtoFile)
{
foreach (var protoService in protoFile.GeneratedProtoFile.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 protoFile in _mGrpcProject.ProtoFile)
{
foreach (var protoService in protoFile.GeneratedProtoFile.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"
}
});
}
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 void AddProgramClass(CProject project, CProject grpcProject, List <CClass> testClasses)
{
var programClass = new CClass("Program")
{
Namespace = new CNamespace
{
NamespaceName =
$"{_grpcMServiceClientTestProject.CompanyName}.{_grpcMServiceClientTestProject.ProjectName}{_grpcMServiceClientTestProject.NamespaceSuffix}.{_grpcMServiceClientTestProject.ProjectSuffix}"
}
};
programClass.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = "System.Diagnostics"
}
});
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 protoFile in _mGrpcProject.ProtoFile)
{
foreach (var protoService in protoFile.GeneratedProtoFile.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("bool includeDeletes = false;");
/* methodSnippet.WriteLine(
* $@"Console.WriteLine(""Press any key once the service ({
* grpcProject.ProjectName
* }) has started.\r\nPress 'D' to include deletes"");");
*/
methodSnippet.WriteLine(
$@"Console.WriteLine(""Press any key once the service ({
grpcProject.ProjectName
}) has started."");");
methodSnippet.WriteLine(@"var key = Console.ReadKey().KeyChar;");
/*methodSnippet.WriteLine(@"includeDeletes = key.ToString().ToLower() == ""d"";");
* methodSnippet.WriteLine(@"Console.WriteLine(""Input current DB identity value (default = 1000):"");");
* methodSnippet.WriteLine(@"int currentDbIdentityValue = 1000;");
* methodSnippet.WriteLine(@"if (!Int32.TryParse(Console.ReadLine(), out currentDbIdentityValue))");
* methodSnippet.WriteLine("{");
* methodSnippet.Indent();
* methodSnippet.WriteLine("currentDbIdentityValue = 1000;");
* methodSnippet.Unindent();
* methodSnippet.WriteLine("}");
*/
var portNumber = _grpcPortService.GeneratePortNumber(_kSolution.SolutionName);
methodSnippet.WriteLine(
$@"Channel channel = new Channel(""127.0.0.1:{portNumber++}"", ChannelCredentials.Insecure); ");
programClass.Method.Add(mainMethod);
foreach (var protoFile in _mGrpcProject.ProtoFile)
{
foreach (var protoService in protoFile.GeneratedProtoFile.ProtoService)
{
methodSnippet.WriteLine(
$"var client{protoService.ServiceName} = new {protoService.ServiceName}.{protoService.ServiceName}Client(channel);");
}
}
//create an instance of the class, and call each method
foreach (var testClass in testClasses)
{
var protoService = testClass.DerivedFrom as CProtoService;
//methodSnippet.WriteLine(
// $"var {testClass.ClassNameAsCamelCase} = new {testClass.ClassName}(currentDbIdentityValue);");
methodSnippet.WriteLine(
$"var {testClass.ClassNameAsCamelCase} = new {testClass.ClassName}(0);");
foreach (var method in testClass.Method)
{
methodSnippet.WriteLine();
if (method.MethodIs == COperationIs.Delete)
{
methodSnippet.WriteLine("if (includeDeletes)");
methodSnippet.WriteLine("{");
methodSnippet.Indent();
}
methodSnippet.WriteLine("try");
methodSnippet.WriteLine("{");
methodSnippet.Indent();
methodSnippet.WriteLine("var sw = Stopwatch.StartNew();");
if (method.IsAsync)
{
methodSnippet.WriteLine(
$"{testClass.ClassNameAsCamelCase}.{method.MethodName}(client{protoService.ServiceName}).Wait();");
}
else
{
methodSnippet.WriteLine(
$"{testClass.ClassNameAsCamelCase}.{method.MethodName}(client{protoService.ServiceName});");
}
methodSnippet.WriteLine($" Console.BackgroundColor = ConsoleColor.DarkGreen;");
methodSnippet.WriteLine(
$@"Console.WriteLine($""{method.MethodName}() completed in {{sw.ElapsedMilliseconds}} ms"");");
methodSnippet.Unindent();
methodSnippet.WriteLine("}");
methodSnippet.WriteLine("catch");
methodSnippet.WriteLine("{");
methodSnippet.Indent();
methodSnippet.WriteLine($" Console.BackgroundColor = ConsoleColor.Red;");
methodSnippet.WriteLine($@"Console.WriteLine(""{method.MethodName}() failed"");");
methodSnippet.Unindent();
methodSnippet.WriteLine("}");
if (method.MethodIs == COperationIs.Delete)
{
methodSnippet.Unindent();
methodSnippet.WriteLine("}");
}
}
}
methodSnippet.WriteLine($" Console.BackgroundColor = ConsoleColor.Black;");
methodSnippet.WriteLine(@"Console.WriteLine(""Completed. Press any key to exit."");");
methodSnippet.WriteLine(@"Console.ReadKey();");
;
mainMethod.CodeSnippet = methodSnippet.ToString();
project.ProjectContent.Add(new CProjectContent
{
Content = programClass,
BuildAction = CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"", FileName = $"{programClass.ClassName}.cs"
}
});
}
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 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);
}
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);
}
}
public void Visit(IVisitor visitor, CMethod method)
{
NewMethod(method);
foreach (var methodAttribute in method.Attribute)
{
methodAttribute.Accept(visitor);
}
var modifier = !method.SignatureOnly ? method.AccessModifier.GetString() + " " : string.Empty;
var abstractText = method.IsAbstract ? "abstract " : string.Empty;
var overrideText = method.IsOverride ? "override " : string.Empty;
var @static = method.IsStatic ? "static " : string.Empty;
var asyncText = method.IsAsync ? "async " : string.Empty;
var thisText = method.IsExtensionMethod ? "this " : string.Empty;
_codeWriter.Write(
$"{modifier}{@static}{abstractText}{overrideText}{asyncText}{method.ReturnType} {method.MethodName}({thisText}");
var first = true;
var paramIndex = 0;
_codeWriter.SaveIndent();
var methodTextLength = method.TextLength;
foreach (var param in method.Parameter)
{
if (!first)
{
_codeWriter.Write(", ");
}
if (methodTextLength > 100 && method.Parameter.Count > 1) //attempt to Mirror Resharper's rules
{
//wrap the parameters to next line
_codeWriter.WriteLine("");
if (first)
{
_codeWriter.Indent();
}
}
visitor.VisitCParameter(param);
first = false;
paramIndex++;
}
_codeWriter.Write(")");
_codeWriter.RestoreIndent();
if (method.SignatureOnly || method.IsAbstract)
{
_codeWriter.WriteLine(";");
}
else if (method.UseExpressionDefinition)
{
_codeWriter.WriteLine($" => {method.CodeSnippet}");
}
else
{
_codeWriter.WriteLine(string.Empty);
_codeWriter.WriteLine("{");
_codeWriter.SaveIndent();
_codeWriter.Indent();
if (!string.IsNullOrEmpty(method.CodeSnippetFile) || !string.IsNullOrEmpty(method.CodeSnippet))
{
if (!string.IsNullOrEmpty(method.CodeSnippet))
{
_codeWriter.WriteLine(method.CodeSnippet);
}
if (!string.IsNullOrEmpty(method.CodeSnippetFile))
{
var snippetService = new SnippetService();
_codeWriter.WriteLine(snippetService.GetCodeSnippet(method.MethodName, method.CodeSnippetFile));
}
}
else if (method.ReturnType != "void")
{
_codeWriter.WriteLine("throw new NotImplementedException();");
}
_codeWriter.Unindent();
_codeWriter.RestoreIndent();
_codeWriter.WriteLine("}");
// _codeWriter.WriteLine();
}
}
public void AddToProtoMethods(CClass extensionClass, CClass modelClass, string protoNamespace)
{
var alias = "ProtoAlias";
extensionClass.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
Alias = alias, NamespaceName = protoNamespace
}
});
extensionClass.NamespaceRef.Add(
new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = "Google.Protobuf"
}
});
extensionClass.NamespaceRef.Add(
new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = protoNamespace
}
});
var protoMessage = modelClass?.DerivedFrom?.DerivedFrom as CProtoMessage;
if (protoMessage == null)
{
return;
}
// if (protoMessage.Rpc == null)
// continue;
;
var toModelMethod = new CMethod
{
IsStatic = true,
IsExtensionMethod = true,
ReturnType = $"{modelClass.Namespace.NamespaceName}.{modelClass.ClassName}",
MethodName = "ToModel"
};
//todo: create method for fully qualified name
var parameterType = string.Empty;
parameterType = $"{alias}.{protoMessage.MessageName}";
toModelMethod.Parameter.Add(new CParameter {
Type = parameterType, ParameterName = "source"
});
var codeWriter = new CodeWriter();
codeWriter.WriteLine($"return new {modelClass.Namespace.NamespaceName}.{modelClass.ClassName}");
codeWriter.WriteLine("{");
codeWriter.Indent();
var first = true;
foreach (var property in modelClass.Property)
{
var protoField = FindProtoMessageField(protoMessage, property);
if (!first)
{
codeWriter.WriteLine(",");
}
first = false;
//todo: clean this up
if (protoField == null)
{
codeWriter.Write($"//{property.PropertyName} = source.<unfound proto file>");
}
else if (property.Type.ToLower() == "char[]" && protoField.FieldType == GrpcType.__string)
{
//assume tostring is needed
codeWriter.Write($"{property.PropertyName} = source.{protoField.FieldName}");
codeWriter.Write(".ToCharArray()");
}
else if (property.Type.ToLower() == "datetime" &&
protoField.FieldType == GrpcType.__google_protobuf_Timestamp)
{
codeWriter.Write($"{property.PropertyName} = source.{protoField.FieldName}");
codeWriter.Write(".ToDateTime()");
}
else if (property.Type.ToLower() == "datetimeoffset" &&
protoField.FieldType == GrpcType.__google_protobuf_Timestamp)
{
codeWriter.Write($"{property.PropertyName} = source.{protoField.FieldName}");
codeWriter.Write(".ToDateTime()");
}
else if (property.Type.ToLower() == "byte" && protoField.FieldType == GrpcType.__int32)
{
codeWriter.Write($"{property.PropertyName} = (byte)source.{protoField.FieldName}");
}
else if (property.Type.ToLower() == "decimal" && protoField.FieldType == GrpcType.__string)
{
codeWriter.Write($"{property.PropertyName} = Decimal.Parse(source.{protoField.FieldName})");
}
else if (property.Type.ToLower() == "byte[]" && protoField.FieldType == GrpcType.__bytes)
{
codeWriter.Write($"{property.PropertyName} = source.{protoField.FieldName}");
codeWriter.Write($" != ByteString.Empty ? source.{protoField.FieldName}");
codeWriter.Write(".ToByteArray() : null");
}
else
{
codeWriter.Write($"{property.PropertyName} = source.{protoField.FieldName}");
}
}
codeWriter.WriteLine(string.Empty);
codeWriter.Unindent();
codeWriter.WriteLine("};");
toModelMethod.CodeSnippet = codeWriter.ToString();
extensionClass.Method.Add(toModelMethod);
}
public void AddModelToEntityMethods(CClass extensionsClass, CClass convertFromModelClass, CProject dataLayerProject,
string namespaceName)
{
var alias = "EntityAlias";
//todo: should we use SProtoFile instead?
//foreach (var convertFromModelClass in convertFromModelClasses)
{
//don't have a direct connection. See if they have a common Table
var entityClass =
dataLayerProject.Class.FirstOrDefault(c => c.DerivedFrom == convertFromModelClass.DerivedFrom);
if (entityClass == null)
{
return;
}
extensionsClass.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
Alias = alias, NamespaceName = entityClass.Namespace.NamespaceName
}
});
var toEntityMethod = new CMethod
{
IsStatic = true,
IsExtensionMethod = true,
ReturnType = $"{alias}.{entityClass.ClassName}",
MethodName = "ToEntity"
};
//todo: create method for fully qualified name
toEntityMethod.Parameter.Add(new CParameter
{
Type = $"{convertFromModelClass.Namespace.NamespaceName}.{convertFromModelClass.ClassName}",
ParameterName = "source"
});
var codeWriter = new CodeWriter();
codeWriter.WriteLine($"return new {alias}.{entityClass.ClassName}");
codeWriter.WriteLine("{");
codeWriter.Indent();
var first = true;
foreach (var modelProperty in convertFromModelClass.Property)
{
var entityProperty =
entityClass.Property.FirstOrDefault(p => p.PropertyName == modelProperty.PropertyName); // FindProtoMessageField(protoMessage, property);
if (!first)
{
codeWriter.WriteLine(",");
}
first = false;
if (entityProperty == null)
{
codeWriter.Write($"//<unknownEntityProperty> = source.{modelProperty.PropertyName}");
}
else
{
codeWriter.Write($"{entityProperty.PropertyName} = source.{modelProperty.PropertyName}");
}
}
codeWriter.WriteLine(string.Empty);
codeWriter.Unindent();
codeWriter.WriteLine("};");
toEntityMethod.CodeSnippet = codeWriter.ToString();
extensionsClass.Method.Add(toEntityMethod);
var ToEntityForListMethod = new CMethod
{
IsStatic = true,
IsExtensionMethod = true,
ReturnType = $"IEnumerable<{alias}.{entityClass.ClassName}>",
MethodName = "ToEntity"
};
//todo: create method for fully qualified name
var parameterType = string.Empty;
parameterType =
$"IEnumerable<{convertFromModelClass.Namespace.NamespaceName}.{convertFromModelClass.ClassName}>";
ToEntityForListMethod.Parameter.Add(new CParameter {
Type = parameterType, ParameterName = "source"
});
var codeWriter3 = new CodeWriter();
codeWriter3.WriteLine($"return source.Select(s => s.ToEntity()).ToList();");
ToEntityForListMethod.CodeSnippet = codeWriter3.ToString();
extensionsClass.Method.Add(ToEntityForListMethod);
}
extensionsClass.NamespaceRef.Add(new CNamespaceRef("System.Collections.Generic"));
extensionsClass.NamespaceRef.Add(new CNamespaceRef("System.Linq"));
}
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);
}
