private CProject BuildGrpcProject(KSolution kSolution, KDataStoreProject databaseKProject,
KDataLayerProject dataLayerKProject, KGrpcProject grpcKProjectIn, CSolution solution, CProject sqlProject,
CProject dataProject)
{
var grpcProject = _grpcServiceProjectService.BuildProject(kSolution, databaseKProject, dataLayerKProject,
grpcKProjectIn, sqlProject, dataProject);
return(grpcProject);
}
public override CProject BuildProject(KSolution kSolution, KDataStoreProject databaseKProject,
KDataLayerProject dataLayerKProject, KGrpcProject grpcKProject, CProject sqlProject, CProject dataProject)
{
var project = base.BuildProject(kSolution, databaseKProject, dataLayerKProject, grpcKProject, sqlProject,
dataProject);
project.ProjectIs = CProjectIs.Grpc | CProjectIs.Service;
return(project);
}
public CProject BuildProject(KGrpcProject mGrpcProject, KGrpcServiceUnitTestProject grpcMServiceUnitTestProject,
CProject grpcProject, bool addProtoRef = false)
{
_mGrpcProject = mGrpcProject;
_grpcMServiceUnitTestProject = grpcMServiceUnitTestProject;
var project = new CProject
{
ProjectName = grpcMServiceUnitTestProject.ProjectFullName,
ProjectShortName = grpcMServiceUnitTestProject.ProjectShortName,
ProjectFolder = grpcMServiceUnitTestProject.ProjectFolder,
ProjectType = CProjectType.CsProj,
ProjectIs = grpcMServiceUnitTestProject.ProjectIs
};
project.TemplateProjectPath = @"templates\NetCore31ConsoleApp.csproj";
project.NuGetReference.Add(new CNuGet {
NuGetName = "Microsoft.NET.Test.Sdk", Version = "15.3.0"
});
project.NuGetReference.Add(new CNuGet {
NuGetName = "Moq", Version = "4.7.99"
});
project.NuGetReference.Add(new CNuGet {
NuGetName = "MSTest.TestAdapter", Version = "1.1.18"
});
project.NuGetReference.Add(new CNuGet {
NuGetName = "MSTest.TestFramework", Version = "1.1.18"
});
//AddProgramClass(project);
foreach (var protoFile in _mGrpcProject.ProtoFile)
{
foreach (var protoService in protoFile.GeneratedProtoFile.ProtoService)
{
var testClass = BuildTestClass(protoService);
project.ProjectContent.Add(new CProjectContent
{
Content = testClass,
BuildAction = CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"", FileName = $"{testClass.ClassName}.cs"
}
});
}
if (addProtoRef)
{
AddProtoRpcRef(project, protoFile.GeneratedProtoFile);
}
}
project.ProjectReference.Add(grpcProject);
return(project);
}
private KGrpcProject BuildGrpcProject(KickstartWizardModel kickstartWizardModel, KDataStoreProject databaseProject, KDataLayerProject dataLayerProject, KProtoFile kProtoFile)
{
var grpcProject = new KGrpcProject()
{
CompanyName = kickstartWizardModel.CompanyName, ProjectName = kickstartWizardModel.ProjectName, Kickstart = kickstartWizardModel.CreateGrpcServiceProject
};
if (kProtoFile != null)
{
grpcProject.ProtoFile.Add(kProtoFile);
}
grpcProject.DependsOnProject.Add(databaseProject);
grpcProject.DependsOnProject.Add(dataLayerProject);
return(grpcProject);
}
public CClass BuildExtensionsClass(KGrpcProject grpcKProject, CClass domainModelClass, CProtoFile protoFile,
string protoNamespace)
{
var extensionClass = new CClass($"{domainModelClass.ClassName}Extensions")
{
IsStatic = true,
Namespace = new CNamespace
{
NamespaceName =
$"{grpcKProject.CompanyName}.{grpcKProject.ProjectName}{grpcKProject.NamespaceSuffix}.{grpcKProject.ProjectSuffix}.Extensions"
}
};
return(extensionClass);
}
public CProject BuildProject(KGrpcProject mGrpcProject,
KGrpcServiceIntegrationTestProject grpcMServiceIntegrationTestProject,
CProject grpcIntegrationTestBusinessProject, bool addProtoRef = false)
{
_mGrpcProject = mGrpcProject;
_grpcMServiceIntegrationTestProject = grpcMServiceIntegrationTestProject;
var project = new CProject
{
ProjectName = grpcMServiceIntegrationTestProject.ProjectFullName,
ProjectShortName = grpcMServiceIntegrationTestProject.ProjectShortName,
ProjectFolder = _grpcMServiceIntegrationTestProject.ProjectFolder,
ProjectType = CProjectType.CsProj,
ProjectIs = _grpcMServiceIntegrationTestProject.ProjectIs
};
project.TemplateProjectPath = @"templates\NetCore31ConsoleApp.csproj";
/*
* AddProgramClass(project);
* foreach (var protoFile in mGrpcProject.ProtoFile)
* {
* foreach (var protoService in protoFile.GeneratedProtoFile.ProtoService)
* {
* var @testClass = BuildTestClass(protoService);
* project.ProjectContent.Add(new SProjectContent()
* {
* Content = @testClass,
* BuildAction = SBuildAction.DoNotInclude,
* File = new SFile() { Folder = $@"", FileName = $"{@testClass.ClassName}.cs" }
* });
*
* }
* if (addProtoRef)
* {
* AddProtoRpcRef(project, protoFile.GeneratedProtoFile);
* }
* }*/
AddNugetRefs(project);
AddProtoBatchFile(project);
project.ProjectReference.Add(grpcIntegrationTestBusinessProject);
return(project);
}
/*
* private KProtoFile FindKProtoFile(KGrpcProject grpcKProject, CMethod method)
* {
* KProtoFile kProtoFile = null;
*
* foreach (var mPf in grpcKProject.ProtoFile)
* {
* foreach (var mRpc in mPf.Rpc)
* if (mRpc.RpcName.ToLower() == method.MethodName.ToLower())
* {
* kProtoFile = mPf;
* break;
* }
* if (kProtoFile != null)
* break;
* }
*
* if (kProtoFile == null)
* {
* kProtoFile = grpcKProject.ProtoFile.FirstOrDefault();
* if (kProtoFile == null)
* {
* kProtoFile = new KProtoFile {ProtoFileName = grpcKProject.ProjectName};
* grpcKProject.ProtoFile.Add(kProtoFile);
* }
* }
* if (kProtoFile.GeneratedProtoFile == null)
* {
* var protoNamespace = kProtoFile.CSharpNamespace; //
* if (string.IsNullOrEmpty(protoNamespace))
* protoNamespace =
* $@"{grpcKProject.CompanyName}.{grpcKProject.ProjectName}{grpcKProject.NamespaceSuffix}.{
* grpcKProject.ProjectSuffix
* }.Proto.Types";
* kProtoFile.GeneratedProtoFile = BuildProtoFile(grpcKProject, kProtoFile, protoNamespace);
* }
*
*
* return kProtoFile;
* }*/
private CProtoFile BuildProtoFile(KGrpcProject grpcKProject, KProtoFile kProtoFile, string protoNamespace)
{
var protoFile = new CProtoFile();
protoFile.Import.Add("google/protobuf/timestamp.proto");
protoFile.Import.Add("google/protobuf/duration.proto");
protoFile.Import.Add("google/protobuf/descriptor.proto");
protoFile.CSharpNamespace = protoNamespace;
protoFile.Option.Add($@"csharp_namespace = ""{protoNamespace}"";");
protoFile.Option.Add($@"(version) = ""1.0.0"";");
var protoService = new CProtoService(protoFile)
{
ServiceName = $@"{kProtoFile.ProtoFileName}Service"
};
protoFile.ProtoService.Add(protoService);
return(protoFile);
}
public CProject BuildProject(KSolution kSolution, KGrpcProject mGrpcProject,
KGrpcServiceClientTestProject grpcMServiceClientTestProject, CProject grpcProject, bool addProtoRef = false)
{
_kSolution = kSolution;
_mGrpcProject = mGrpcProject;
_grpcMServiceClientTestProject = grpcMServiceClientTestProject;
var project = new CProject
{
ProjectName = grpcMServiceClientTestProject.ProjectFullName,
ProjectShortName = grpcMServiceClientTestProject.ProjectShortName,
ProjectFolder = grpcMServiceClientTestProject.ProjectFolder,
ProjectType = CProjectType.CsProj,
ProjectIs = CProjectIs.Test | CProjectIs.Client,
StartupObject =
$"{grpcMServiceClientTestProject.CompanyName}.{grpcMServiceClientTestProject.ProjectName}{grpcMServiceClientTestProject.NamespaceSuffix}.{grpcMServiceClientTestProject.ProjectSuffix}.Program"
};
project.TemplateProjectPath = @"templates\NetCore31ConsoleApp.csproj";
project.NuGetReference.Add(new CNuGet {
NuGetName = "Microsoft.NET.Test.Sdk", Version = "15.3.0"
});
project.NuGetReference.Add(new CNuGet {
NuGetName = "Moq", Version = "4.7.99"
});
project.NuGetReference.Add(new CNuGet {
NuGetName = "MSTest.TestAdapter", Version = "1.1.18"
});
project.NuGetReference.Add(new CNuGet {
NuGetName = "MSTest.TestFramework", Version = "1.1.18"
});
var testClasses = new List <CClass>();
foreach (var protoFile in _mGrpcProject.ProtoFile)
{
foreach (var protoService in protoFile.GeneratedProtoFile.ProtoService)
{
var testClass = BuildTestClass(protoService);
testClasses.Add(testClass);
project.ProjectContent.Add(new CProjectContent
{
Content = testClass,
BuildAction = CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"", FileName = $"{testClass.ClassName}.cs"
}
});
}
if (addProtoRef)
{
AddProtoRpcRef(project, protoFile.GeneratedProtoFile);
}
}
AddProgramClass(project, grpcProject, testClasses);
AddProtoBatchFile(project);
project.ProjectReference.Add(grpcProject);
return(project);
}
public IList <KProtoFile> Convert(KDataStoreProject databaseProject, KDataLayerProject dataLayerProject,
KGrpcProject grpcKProject)
{
var protoFiles = new List <KProtoFile>();
_databaseProject = databaseProject;
foreach (var dataLayerInter in dataLayerProject.DataServiceInterface)
{
//var messagesToAddToBulkRpc = new List<SProtoMessage>();
var kProtoFile = new KProtoFile {
ProtoFileName = grpcKProject.ProjectName
};
kProtoFile.GeneratedProtoFile = BuildProtoFile(grpcKProject, kProtoFile,
$@"{grpcKProject.CompanyName}.{grpcKProject.ProjectName}{grpcKProject.NamespaceSuffix}.{grpcKProject.ProjectSuffix}.Proto.Types");
protoFiles.Add(kProtoFile);
foreach (var method in dataLayerInter.Method)
{
var protoFile = kProtoFile.GeneratedProtoFile;
var protoService = protoFile.ProtoService.FirstOrDefault();
var storedProcedure = method.DerivedFrom as CStoredProcedure;
var storedProcedureList = method.DerivedFrom as CStoredProcList;
if (storedProcedure != null)
{
if (!storedProcedure.KickstartApi)
{
continue;
}
/*
* if (!grpcKProject.KickstartCRUD)
* {
* //filter out anything that is CRUD
* if (storedProcedure.DataOperationIs.HasFlag(SOperationIs.CRUD))
* {
* continue;
* }
*
* }*/
var rpc = BuildRpcFromStoredProc(protoFile, protoService, method, storedProcedure);
//if using Proto first, Rpc may already exist
if (!protoService.Rpc.Any(r => r.RpcName == rpc.RpcName))
{
protoService.Rpc.Add(rpc);
}
}
else if (storedProcedureList != null && storedProcedureList.List.Any())
{
var rpc = BuildBulkRpcFromStoredProcList(protoFile, protoService, method, storedProcedureList);
protoService.Rpc.Add(rpc);
}
else if (method.MethodIs.HasFlag(COperationIs.Bulk))
{
// if (addBulkRpc)
if (false)
{
/*
* var rpc = new SProtoRpc(protoService)
* {
* RpcName = $"{method.MethodName}",
* OperationIs = SOperationIs.Bulk | SOperationIs.Add | SOperationIs.Update | SOperationIs.Delete
* };
*
* var request = new SProtoMessage
* {
* IsRequest = true,
* MessageName = $"{rpc.RpcName}Request"
*
* };
*
* rpc.Request = request;
* foreach (var message in messagesToAddToBulkRpc)
* {
* request.ProtoField.Add(new SProtoMessageField(null) { IsScalar = false, Repeated = true, MessageType = message.MessageName, FieldName = $"{message.MessageName}" });
* }
*
* var response = new SProtoMessage
* {
* IsResponse = true,
* MessageName = $"{rpc.RpcName}Response"
* };
* rpc.Response = response;
*
*
* protoService.Rpc.Add(rpc);*/
}
}
}
}
return(protoFiles);
}
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);
}
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);
}
public CClass AddContainerClass(KGrpcProject grpcKProject, DataStoreTypes connectsToDatabaseType,
CProject project,
CInterface dbProviderInterface,
CClass dbProviderClass,
CInterface dbDiagnosticsFactoryInterface,
CClass dbDiagnosticsFactoryClass)
{
var @class = new CClass($"ContainerExtensions")
{
Namespace = new CNamespace
{
NamespaceName =
$"{grpcKProject.CompanyName}.{grpcKProject.ProjectName}{grpcKProject.NamespaceSuffix}.{grpcKProject.ProjectSuffix}.Infrastructure"
},
AccessModifier = CAccessModifier.Public,
IsStatic = true
};
@class.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = "System"
}
});
@class.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = "Grpc.Core"
}
});
@class.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = "Microsoft.Extensions.DependencyInjection"
}
});
@class.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = "Microsoft.Extensions.Configuration"
}
});
@class.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = "Microsoft.Extensions.Options"
}
});
//@class.NamespaceRef.Add(new CNamespaceRef { ReferenceTo = new CNamespace { NamespaceName = "StructureMap" } });
@class.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = "MediatR"
}
});
@class.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = "Company.GrpcCommon.Infrastructure"
}
});
@class.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = "Company.GrpcCommon.Tracing"
}
});
@class.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = new CNamespace {
NamespaceName = $"{grpcKProject.CompanyName}.{grpcKProject.ProjectName}{grpcKProject.NamespaceSuffix}.{grpcKProject.ProjectSuffix}.Config"
}
});
@class.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = dbProviderInterface.Namespace
});
@class.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = dbDiagnosticsFactoryInterface.Namespace
});
@class.NamespaceRef.Add(new CNamespaceRef
{
ReferenceTo = dbDiagnosticsFactoryClass.Namespace
});
@class.NamespaceRef.Add(new CNamespaceRef {
ReferenceTo = new CNamespace {
NamespaceName = "Lamar"
}
});
@class.Method.Add(new CMethod
{
AccessModifier = CAccessModifier.Public,
ReturnType = "void",
IsStatic = true,
IsExtensionMethod = true,
MethodName = "Configure",
Parameter = new List <CParameter>
{
new CParameter {
Type = "ServiceRegistry", ParameterName = "r"
},
new CParameter {
Type = "IConfiguration", ParameterName = "configuration"
}
},
CodeSnippet = GetConfigureCodeSnippet(grpcKProject.ProjectNameAsClassNameFriendly)
});
/*
* @class.Method.Add(new CMethod()
* {
* AccessModifier = CAccessModifier.Public,
* ReturnType = "IServiceProvider",
* MethodName = "GetServiceProvider",
* CodeSnippet = "return _container.GetInstance<IServiceProvider>();"
* });
*
* @class.Method.Add(new CMethod
* {
* AccessModifier = CAccessModifier.Public,
* ReturnType = "void",
* MethodName = "ConfigureContainer",
*
* CodeSnippet =
* $@"_container.Configure(config =>
* {{
* // Register stuff in container, using the StructureMap APIs
* // also register MediatR specifics
* config.Scan(scanner =>
* {{
* scanner.AssembliesAndExecutablesFromApplicationBaseDirectory(a => a.FullName.StartsWith(""{
* grpcKProject.CompanyName
* }""));
* scanner.AssemblyContainingType<IMediator>();
* scanner.WithDefaultConventions();
* scanner.ConnectImplementationsToTypesClosing(typeof(IRequestHandler<,>));
* scanner.ConnectImplementationsToTypesClosing(typeof(IRequestHandler<,>));
* scanner.ConnectImplementationsToTypesClosing(typeof(INotificationHandler<>));
* scanner.ConnectImplementationsToTypesClosing(typeof(INotificationHandler<>));
* }});
*
* config.For<ServiceFactory>().Use<ServiceFactory>(ctx => ctx.GetInstance);
*
* config.For<IMediatorExecutor>().Use<MediatorExecutor>();
* // Populate the container using the service collection
* config.Populate(_services);
* }});"
* });
*/
@class.Method.Add(BuildAddAppServicesMethod(grpcKProject, connectsToDatabaseType, dbProviderInterface, dbProviderClass));
project.ProjectContent.Add(new CProjectContent
{
Content = @class,
BuildAction = grpcKProject.DotNetType == DotNetType.Framework ? CBuildAction.Compile : CBuildAction.DoNotInclude,
File = new CFile {
Folder = $@"Infrastructure", FileName = $"{@class.ClassName}.cs"
}
});
return(@class);
}
