public CodeNamespace Build(AsyncDomainHook hook)
{
var targetClass = _classBuilderUtil.Build(_nameBuilderUtil.AsyncEventHookHandlerName(hook));
var codeNamespace = _nameSpaceBuilderUtil.WithName($"{_nameSpace}.{hook.ClassType}s.AsyncHooks").WithApplication().WithTask().WithList().WithDomainEntityNameSpace(hook.ClassType).Build();
codeNamespace.Types.Add(targetClass);
var handler = new AsyncHookCreateEventHandler(hook);
_propertyBuilderUtil.Build(targetClass, handler.Properties);
var constructor = _constructorBuilderUtil.BuildPublic(handler.Properties);
targetClass.Members.Add(constructor);
var method = new CodeMemberMethod();
method.Name = "Run";
method.ReturnType = new CodeTypeReference("async Task");
method.Attributes = MemberAttributes.Public | MemberAttributes.Final;
method.Statements.Add(new CodeSnippetExpression($"var events = await {handler.Properties[1].Name}.GetEvents(\"{hook.Name}\")"));
method.Statements.Add(new CodeSnippetExpression($"var handledEvents = new List<{new EventAndJobClass().Name}>()"));
method.Statements.Add(new CodeSnippetExpression("var enumerator = events.GetEnumerator()"));
var codeIterationStatement = CreateLoopOverEvents(hook);
method.Statements.Add(codeIterationStatement);
method.Statements.Add(
new CodeSnippetExpression($"await {handler.Properties[1].Name}.RemoveEventsFromQueue(handledEvents)"));
targetClass.Members.Add(method);
return(codeNamespace);
}
public CodeNamespace Build(List <AsyncDomainHook> domainHooks)
{
var nameSpace = _nameSpaceBuilderUtil.WithName($"{_nameSpace}").WithList().Build();
var generatedClass = _classBuilderUtil.Build("EventJobRegistration");
var constructor = new CodeConstructor();
constructor.Attributes = MemberAttributes.Public | MemberAttributes.Final;
constructor.Statements.Add(new CodeSnippetExpression($"EventJobs = new List<{new EventTupleClass().Name}>()"));
foreach (var domainHook in domainHooks)
{
nameSpace.Imports.Add(new CodeNamespaceImport($"Domain.{domainHook.ClassType}s"));
constructor.Statements.Add(new CodeSnippetExpression(
$"EventJobs.Add(new EventTuple(typeof({_nameBuilderUtil.HooKEventName(domainHook)}).ToString(), \"{domainHook.Name}\"))"));
}
_propertyBuilderUtil.Build(generatedClass, new List <Property> {
new Property {
Name = "EventJobs", Type = $"List<{new EventTupleClass().Name}>"
}
});
generatedClass.Members.Add(constructor);
nameSpace.Types.Add(generatedClass);
return(nameSpace);
}
public CodeNamespace Build(QueueRepositoryClass hangfireQueue)
{
var targetClass = _classBuilderUtil.Build(hangfireQueue.Name);
var codeNamespace = _nameSpaceBuilderUtil.WithName($"{_nameSpace}").WithApplication().WithTask()
.WithDomain().WithList().WithLinq().WithEfCore().Build();
codeNamespace.Types.Add(targetClass);
targetClass.BaseTypes.Add(new CodeTypeReference($"I{hangfireQueue.Name}"));
_propertyBuilderUtil.Build(targetClass, hangfireQueue.Properties);
var constructor = _constructorBuilderUtil.BuildPublic(hangfireQueue.Properties);
targetClass.Members.Add(constructor);
var addEventsMethod = CreateAddEventsMethod();
targetClass.Members.Add(addEventsMethod);
var getEventsMethod = CreateGetEventsMethod();
targetClass.Members.Add(getEventsMethod);
var removeEventsMethod = CreateRemoveEventsMethod();
targetClass.Members.Add(removeEventsMethod);
return(codeNamespace);
}
public void AddClassType()
{
_targetClass = _classBuilder.Build(_userClass.Name);
var userClassGenericType = new CodeTypeParameter(_userClass.GenericType);
userClassGenericType.Constraints.Add(" class");
_targetClass.TypeParameters.Add(userClassGenericType);
}
public CodeNamespace Build(List <DomainClass> domainClasses)
{
_nameSpaceBuilderUtil.WithName($"{_nameSpace}").WithDomain().WithEfCore();
foreach (var domainClass in domainClasses)
{
_nameSpaceBuilderUtil.WithDomainEntityNameSpace(domainClass.Name);
}
var nameSpace = _nameSpaceBuilderUtil.Build();
var eventStore = _classBuilderUtil.Build("EventStoreContext");
eventStore.BaseTypes.Add(new CodeTypeReference("DbContext"));
var properties = new List <Property>();
properties.Add(new Property {
Name = "EventHistory", Type = $"DbSet<{new DomainEventBaseClass().Name}>"
});
foreach (var domainClass in domainClasses)
{
properties.Add(new Property {
Name = $"{domainClass.Name}s", Type = $"DbSet<{domainClass.Name}>"
});
foreach (var method in domainClass.Methods)
{
properties.Add(new Property
{
Name = $"{_nameBuilderUtil.EventName(domainClass, method)}s",
Type = $"DbSet<{_nameBuilderUtil.EventName(domainClass, method)}>"
});
}
foreach (var method in domainClass.CreateMethods)
{
properties.Add(new Property
{
Name = $"{_nameBuilderUtil.EventName(domainClass, method)}s",
Type = $"DbSet<{_nameBuilderUtil.EventName(domainClass, method)}>"
});
}
}
_propertyBuilderUtil.Build(eventStore, properties);
var codeConstructor = _constructorBuilderUtil.BuildPublicWithBaseCall(new List <Property>(),
new List <Property> {
new Property {
Name = "options", Type = "DbContextOptions<EventStoreContext>"
}
});
eventStore.Members.Add(codeConstructor);
nameSpace.Types.Add(eventStore);
return(nameSpace);
}
public CodeNamespace Build(IList <DomainClass> domainClasses, IList <SynchronousDomainHook> domainHooks)
{
var codeTypeDeclaration = _classBuilderUtil.Build("GeneratedDependencies");
codeTypeDeclaration.Attributes = MemberAttributes.Final | MemberAttributes.Public;
_nameSpaceBuilderUtil.WithName("Host")
.WithApplication()
.WithDependencyInjection()
.WithSqlAdapter();
var codeMemberMethod = new CodeMemberMethod();
codeMemberMethod.Attributes = MemberAttributes.Static | MemberAttributes.Public | MemberAttributes.Final;
codeMemberMethod.Name = "ConfigureGeneratedServices";
codeTypeDeclaration.Members.Add(codeMemberMethod);
codeMemberMethod.Parameters.Add(new CodeParameterDeclarationExpression("IServiceCollection", "collection"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression("collection.AddTransient<IEventStore, EventStore>()"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression("collection.AddTransient<IEventStoreRepository, EventStoreRepository>()"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression($"collection.AddTransient<{new QueueRepositoryInterface().Name}, {new QueueRepositoryClass().Name}>()"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression("collection.AddTransient<EventJobRegistration>()"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression($"collection.AddTransient<{new HangfireQueueInterface().Name}, HangfireQueue>()"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression($"collection.AddMvc().AddApplicationPart(typeof({domainClasses[0].Name}Controller).Assembly)"));
foreach (var domainClass in domainClasses)
{
_nameSpaceBuilderUtil
.WithApplicationEntityNameSpace(domainClass.Name)
.WithHttpAdapterEntityNameSpace(domainClass.Name)
.WithSqlEntityNameSpace(domainClass.Name);
codeMemberMethod.Statements.Add(new CodeSnippetExpression(
$"collection.AddTransient<I{domainClass.Name}Repository, {domainClass.Name}Repository>()"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression(
$"collection.AddTransient<{domainClass.Name}CommandHandler>()"));
foreach (var hook in domainClass.ChildHookMethods)
{
var onChildHookMethodName = _nameBuilderUtil.OnChildHookMethodName(hook);
codeMemberMethod.Statements.Add(new CodeSnippetExpression($"collection.AddTransient<{new DomainHookBaseClass().Name}, {onChildHookMethodName}Hook>()"));
}
}
foreach (var hook in domainHooks)
{
_nameSpaceBuilderUtil.WithHookEntityNameSpace(hook.ClassType);
codeMemberMethod.Statements.Add(new CodeSnippetExpression($"collection.AddTransient<{new DomainHookBaseClass().Name}, {hook.Name}Hook>()"));
}
var codeNamespace = _nameSpaceBuilderUtil.Build();
codeNamespace.Types.Add(codeTypeDeclaration);
return(codeNamespace);
}
public CodeNamespace Build(DomainClass domainClass)
{
var nameSpace = _nameSpaceBuilderUtil
.WithName($"{_nameSpace}.{domainClass.Name}s")
.WithList()
.WithLinq()
.WithTask()
.WithDomainEntityNameSpace(domainClass.Name)
.WithApplicationEntityNameSpace(domainClass.Name)
.WithEfCore()
.Build();
var repository = _classBuilderUtil.Build($"{domainClass.Name}Repository");
repository.BaseTypes.Add(new CodeTypeReference($"I{domainClass.Name}Repository"));
var properties = new List <Property> {
new Property {
Name = "EventStore", Type = "EventStoreContext"
}
};
_propertyBuilderUtil.Build(repository,
properties);
var codeConstructor = _constructorBuilderUtil.BuildPublic(properties);
repository.Members.Add(codeConstructor);
var createMethod = MakeCreateMethod(domainClass);
repository.Members.Add(createMethod);
var updateMethod = MakeUpdateMethod(domainClass);
repository.Members.Add(updateMethod);
var getByIdMethod = MakeGetByIdMethod(domainClass);
repository.Members.Add(getByIdMethod);
var getAllMethod = MakeGetAllMethod(domainClass);
repository.Members.Add(getAllMethod);
var getParentMethods = MakeGetParentMethods(domainClass);
repository.Members.AddRange(getParentMethods);
nameSpace.Types.Add(repository);
return(nameSpace);
}
public CodeNamespace Build(EventStore eventStore)
{
var targetClass = _classBuilderUtil.Build(eventStore.Name);
targetClass.BaseTypes.Add(new EventStoreInterface().Name);
_nameSpaceBuilderUtil.WithName(_nameSpace).WithDomain().WithTask().WithList().WithLinq();
_propertyBuilderUtil.BuildWithoutSet(targetClass, eventStore.Properties);
var constructor = _constructorBuilderUtil.BuildPublic(eventStore.Properties);
targetClass.Members.Add(constructor);
var methodList = new List <CodeMemberMethod>();
foreach (var eventStoreMethod in eventStore.Methods)
{
var method = new CodeMemberMethod();
method.Name = eventStoreMethod.Name;
method.ReturnType = new CodeTypeReference(eventStoreMethod.ReturnType);
method.Attributes = MemberAttributes.Public | MemberAttributes.Final;
foreach (var parameter in eventStoreMethod.Parameters)
{
method.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(parameter.Type),
parameter.Name));
}
methodList.Add(method);
}
var codeMemberMethod = methodList[0];
codeMemberMethod.Statements.Add(new CodeSnippetExpression("var domainEventsFromHooks = new List<DomainEventBase>()"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression("var enumerator = domainEvents.GetEnumerator()"));
var codeWhile = CreateLoopOverDomainEvents();
codeMemberMethod.Statements.Add(codeWhile);
codeMemberMethod.Statements.Add(
new CodeSnippetExpression("await EventStoreRepository.AddEvents(domainEvents)"));
codeMemberMethod.Statements.Add(
new CodeSnippetExpression("await EventStoreRepository.AddEvents(domainEventsFromHooks)"));
codeMemberMethod.Statements.Add(
new CodeSnippetExpression($"return {new HookResultBaseClass().Name}.OkResult()"));
targetClass.Members.Add(methodList[0]);
var nameSpace = _nameSpaceBuilderUtil.Build();
nameSpace.Types.Add(targetClass);
return(nameSpace);
}
public CodeNamespace Build(EventAndJobClass domainClasses)
{
var nameSpace = _nameSpaceBuilderUtil.WithName($"{_nameSpace}").WithDomain().Build();
var generatedClass = _classBuilderUtil.Build(domainClasses.Name);
_propertyBuilderUtil.Build(generatedClass, domainClasses.Properties);
var constructor = _constructorBuilderUtil.BuildPublicWithIdCreateInBody(domainClasses.Properties.Skip(1).ToList(), domainClasses.Properties[0].Name);
var constructorEmpty = _constructorBuilderUtil.BuildPrivate(new List <Property>());
generatedClass.Members.Add(constructor);
generatedClass.Members.Add(constructorEmpty);
nameSpace.Types.Add(generatedClass);
return(nameSpace);
}
public CodeNamespace Build(DomainMethod method, DomainClass domainClass)
{
var commandNameSpace = _nameSpaceBuilderUtil.WithName($"Application.{domainClass.Name}s").WithList().Build();
var commandName = _nameBuilderUtil.UpdateApiCommandName(domainClass, method);
var properties = method.Parameters.Select(param => new Property {
Name = param.Name, Type = param.Type
}).ToList();
var loadProperties = method.LoadParameters.Select(param => new Property {
Name = $"{param.Name}Id", Type = "Guid"
}).ToList();
properties.AddRange(loadProperties);
var command = _classBuilderUtil.Build(commandName);
var codeConstructor = _constructorBuilderUtil.BuildPublic(properties);
_propertyBuilderUtil.Build(command, properties);
command.Members.Add(codeConstructor);
commandNameSpace.Types.Add(command);
return(commandNameSpace);
}
public CodeNamespace Build(HookResultBaseClass userClass)
{
var targetClass = _classBuilder.Build(userClass.Name);
var nameSpace = _nameSpaceBuilderUtil.WithName(_nameSpace).WithList().WithDomain().Build();
var constructor = _constructorBuilderUtil.BuildPrivate(userClass.Properties);
_propertyBuilderUtil.Build(targetClass, userClass.Properties);
var buildOkResultConstructor = BuildOkResultConstructor(userClass);
var buildOkResultOverloadConstructor = BuildOkResultOverloadConstructor(userClass);
var errorResultConstructor = BuildErrorResultConstructor(userClass);
targetClass.Members.Add(constructor);
targetClass.Members.Add(buildOkResultConstructor);
targetClass.Members.Add(buildOkResultOverloadConstructor);
targetClass.Members.Add(errorResultConstructor);
nameSpace.Types.Add(targetClass);
return(nameSpace);
}
public void AddClassType()
{
_targetClass = _classBuilder.Build(_domainEvent.Name);
}
public void AddClassType()
{
_targetClass = _classBuilder.Build(_resultBaseClass.Name);
}
public void AddClassType()
{
_targetClass = _classBuilder.Build(new DomainEventBaseClass().Name);
}
public void AddClassType()
{
_targetClass = _classBuilderUtil.Build(_eventStoreRepository.Name);
}
public CodeNamespace Write(IList <DomainClass> domainClasses, IList <AsyncDomainHook> domainHooks)
{
var codeTypeDeclaration = _classBuilderUtil.Build("GeneratedDependencies");
codeTypeDeclaration.Attributes = MemberAttributes.Final | MemberAttributes.Public;
_nameSpaceBuilderUtil.WithName("AsyncHost")
.WithApplication()
.WithDependencyInjection()
.WithHangfire()
.WithApplicatioBuilder()
.WithSqlAdapter();
var codeMemberMethod = new CodeMemberMethod();
codeMemberMethod.Attributes = MemberAttributes.Static | MemberAttributes.Public | MemberAttributes.Final;
codeMemberMethod.Name = "ConfigureGeneratedServices";
codeTypeDeclaration.Members.Add(codeMemberMethod);
codeMemberMethod.Parameters.Add(new CodeParameterDeclarationExpression("IServiceCollection", "collection"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression("collection.AddTransient<IEventStore, EventStore>()"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression("collection.AddTransient<IEventStoreRepository, EventStoreRepository>()"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression($"collection.AddTransient<{new QueueRepositoryInterface().Name}, {new QueueRepositoryClass().Name}>()"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression("collection.AddTransient<EventJobRegistration>()"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression($"collection.AddTransient<{new HangfireQueueInterface().Name}, HangfireQueue>()"));
foreach (var domainClass in domainClasses)
{
_nameSpaceBuilderUtil
.WithApplicationEntityNameSpace(domainClass.Name)
.WithSqlEntityNameSpace(domainClass.Name);
codeMemberMethod.Statements.Add(new CodeSnippetExpression(
$"collection.AddTransient<I{domainClass.Name}Repository, {domainClass.Name}Repository>()"));
}
foreach (var hook in domainHooks)
{
_nameSpaceBuilderUtil.WithAsyncHookEntityNameSpace(hook.ClassType);
codeMemberMethod.Statements.Add(new CodeSnippetExpression($"collection.AddTransient<{_nameBuilderUtil.AsyncEventHookHandlerName(hook)}>()"));
codeMemberMethod.Statements.Add(new CodeSnippetExpression($"collection.AddTransient<{_nameBuilderUtil.AsyncEventHookName(hook)}>()"));
}
var codeNamespace = _nameSpaceBuilderUtil.Build();
var codeMemberMethodApplicationConfig = new CodeMemberMethod();
codeMemberMethodApplicationConfig.Attributes = MemberAttributes.Static | MemberAttributes.Public | MemberAttributes.Final;
codeMemberMethodApplicationConfig.Name = "ConfigureApplication";
codeMemberMethodApplicationConfig.Parameters.Add(new CodeParameterDeclarationExpression("IApplicationBuilder", "app"));
codeTypeDeclaration.Members.Add(codeMemberMethodApplicationConfig);
codeMemberMethodApplicationConfig.Statements.Add(new CodeSnippetExpression("var option = new BackgroundJobServerOptions {WorkerCount = 1}"));
codeMemberMethodApplicationConfig.Statements.Add(new CodeSnippetExpression("app.UseHangfireServer(option)"));
codeMemberMethodApplicationConfig.Statements.Add(new CodeSnippetExpression("app.UseHangfireDashboard()"));
foreach (var hook in domainHooks)
{
codeMemberMethodApplicationConfig.Statements.Add(new CodeSnippetExpression($"RecurringJob.AddOrUpdate<{_nameBuilderUtil.AsyncEventHookHandlerName(hook)}>(handler => handler.Run(), Cron.Minutely())"));
}
codeNamespace.Types.Add(codeTypeDeclaration);
return(codeNamespace);
}
public void AddClassType()
{
_targetClass = _classBuilderUtil.Build(_nameBuilderUtil.AsyncEventHookName(_hook));
_nameSpace.Types.Add(_targetClass);
}
public List <CodeNamespace> Build(DomainClass domainClass)
{
var commandList = new List <CodeNamespace>();
foreach (var method in domainClass.Methods.Except(domainClass.LoadMethods))
{
var commandNameSpace = _nameSpaceBuilderUtil.WithName($"Domain.{domainClass.Name}s").WithList().Build();
var commandName = _nameBuilderUtil.UpdateCommandName(domainClass, method);
var properties = method.Parameters.Select(param => new Property {
Name = param.Name, Type = param.Type
}).ToList();
var command = _classBuilderUtil.Build(commandName);
var codeConstructor = _constructorBuilderUtil.BuildPublic(properties);
_propertyBuilderUtil.Build(command, properties);
command.Members.Add(codeConstructor);
commandNameSpace.Types.Add(command);
commandList.Add(commandNameSpace);
}
foreach (var loadMethod in domainClass.LoadMethods)
{
var nsBuilder = _nameSpaceBuilderUtil.WithName($"Domain.{domainClass.Name}s").WithList();
foreach (var lodParam in loadMethod.LoadParameters)
{
nsBuilder.WithDomainEntityNameSpace(lodParam.Type);
}
var commandNameSpace = nsBuilder.Build();
var commandName = _nameBuilderUtil.UpdateCommandName(domainClass, loadMethod);
var properties = loadMethod.Parameters.Select(param => new Property {
Name = param.Name, Type = param.Type
}).ToList();
var loadProperties = loadMethod.LoadParameters.Select(param => new Property {
Name = param.Name, Type = param.Type
}).ToList();
properties.AddRange(loadProperties);
var command = _classBuilderUtil.Build(commandName);
var codeConstructor = _constructorBuilderUtil.BuildPublic(properties);
_propertyBuilderUtil.Build(command, properties);
command.Members.Add(codeConstructor);
commandNameSpace.Types.Add(command);
commandList.Add(commandNameSpace);
}
foreach (var method in domainClass.CreateMethods)
{
var commandNameSpace = _nameSpaceBuilderUtil.WithName($"Domain.{domainClass.Name}s").WithList().Build();
var commandName = _nameBuilderUtil.CreateCommandName(domainClass, method);
var properties = method.Parameters.Select(param => new Property {
Name = param.Name, Type = param.Type
}).ToList();
var command = _classBuilderUtil.Build(commandName);
var codeConstructor = _constructorBuilderUtil.BuildPublic(properties);
_propertyBuilderUtil.Build(command, properties);
command.Members.Add(codeConstructor);
commandNameSpace.Types.Add(command);
commandList.Add(commandNameSpace);
}
return(commandList);
}
public CodeNamespace Build(DomainClass domainClass)
{
var nameSpace = _nameSpaceBuilderUtil.WithName($"{_nameSpace}.{domainClass.Name}s")
.WithList()
.WithTask()
.WithDomainEntityNameSpace(domainClass.Name)
.WithMvcImport()
.WithApplicationEntityNameSpace(domainClass.Name)
.Build();
var repository = _classBuilderUtil.Build($"{domainClass.Name}Controller");
repository.BaseTypes.Add(new CodeTypeReference("Controller"));
var properties = new List <Property>
{
new Property {
Name = "Handler", Type = $"{domainClass.Name}CommandHandler"
}
};
_propertyBuilderUtil.Build(repository,
properties);
var codeConstructor = _constructorBuilderUtil.BuildPublic(properties);
repository.Members.Add(codeConstructor);
foreach (var createM in domainClass.CreateMethods)
{
var createMethod = MakeCreateMethod(domainClass, createM);
createMethod.CustomAttributes.Add(new CodeAttributeDeclaration("HttpPost"));
repository.Members.Add(createMethod);
}
foreach (var domainMethod in domainClass.Methods.Except(domainClass.LoadMethods))
{
var updateMethod = MakeUpdateMethod(domainClass, domainMethod);
updateMethod.CustomAttributes.Add(new CodeAttributeDeclaration("HttpPut",
new CodeAttributeArgument(new CodePrimitiveExpression($"{{id}}/{domainMethod.Name.ToLower()}"))));
repository.Members.Add(updateMethod);
}
foreach (var domainMethod in domainClass.LoadMethods)
{
var updateMethod = MakeUpdateLoadMethod(domainClass, domainMethod);
updateMethod.CustomAttributes.Add(new CodeAttributeDeclaration("HttpPut",
new CodeAttributeArgument(new CodePrimitiveExpression($"{{id}}/{domainMethod.Name.ToLower()}"))));
repository.Members.Add(updateMethod);
}
var getByIdMethod = MakeGetByIdMethod(domainClass);
getByIdMethod.CustomAttributes.Add(new CodeAttributeDeclaration("HttpGet",
new CodeAttributeArgument(new CodePrimitiveExpression("{id}"))));
repository.Members.Add(getByIdMethod);
var getAllMethod = MakeGetAllMethod(domainClass);
getAllMethod.CustomAttributes.Add(new CodeAttributeDeclaration("HttpGet"));
repository.Members.Add(getAllMethod);
repository.CustomAttributes.Add(new CodeAttributeDeclaration("Route",
new CodeAttributeArgument(new CodePrimitiveExpression($"api/{domainClass.Name.ToLower()}s"))));
nameSpace.Types.Add(repository);
return(nameSpace);
}
