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