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 CodeNamespace Build(EventStoreRepositoryInterface hookClass) { var targetClass = _interfaceBuilderUtil.Build(hookClass); var nameSpace = _nameSpaceBuilderUtil.WithName(_nameSpace).WithDomain().WithTask().WithList().Build(); nameSpace.Types.Add(targetClass); return(nameSpace); }
public CodeNamespace Build(HangfireQueueInterface eventStore) { var codeNamespace = _nameSpaceBuilderUtil.WithName(_nameSpace).WithDomain().WithTask().WithList().Build(); var codeTypeDeclaration = _interfaceBuilderUtil.Build(eventStore); codeNamespace.Types.Add(codeTypeDeclaration); return(codeNamespace); }
public CodeNamespace Build(QueueRepositoryInterface repo) { var codeNamespace = _nameSpaceBuilderUtil.WithName(_nameSpace).WithDomain().WithTask().WithList().Build(); var codeTypeDeclaration = _interfaceBuilderUtil.Build(repo); codeNamespace.Types.Add(codeTypeDeclaration); return(codeNamespace); }
public void AddNameSpace() { _nameSpace = _nameSpaceBuilderUtil.WithName($"Application.{_hook.ClassType}s.AsyncHooks") .WithList() .WithTask() .WithDomainEntityNameSpace(_hook.ClassType) .Build(); }
public CodeNamespace Build(SynchronousDomainHook domainClass) { var codeNamespace = _nameSpaceBuilderUtil.WithName($"{_applicationNameSpace}.{domainClass.ClassType}s.Hooks") .WithTask() .WithDomainEntityNameSpace(domainClass.ClassType) .WithDomain() .Build(); var codeTypeDeclaration = _classBuilderUtil.BuildPartial($"{domainClass.Name}Hook"); codeTypeDeclaration.BaseTypes.Add(new CodeTypeReference(new DomainHookBaseClass().Name)); var field = new CodeMemberField { Name = $"EventType {{ get; private set; }} = typeof({domainClass.ClassType}{domainClass.MethodName}Event);NewHackGuid302315ed-3a05-4992-9f76-4cf075cde515", Attributes = MemberAttributes.Public | MemberAttributes.Final, Type = new CodeTypeReference("Type") }; codeTypeDeclaration.Members.Add(field); codeNamespace.Types.Add(codeTypeDeclaration); var codeMemberMethod = new CodeMemberMethod(); codeMemberMethod.Parameters.Add( new CodeParameterDeclarationExpression(new CodeTypeReference(new DomainEventBaseClass().Name), "domainEvent")); codeMemberMethod.ReturnType = new CodeTypeReference($"async {new DomainHookBaseClass().Methods[0].ReturnType}"); codeMemberMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final; codeMemberMethod.Name = new DomainHookBaseClass().Methods[0].Name; codeMemberMethod.Statements.Add(new CodeConditionStatement( new CodeSnippetExpression( $"domainEvent is {domainClass.ClassType}{domainClass.MethodName}Event parsedEvent"), new CodeStatement[] { new CodeExpressionStatement(new CodeSnippetExpression("return await Execute(parsedEvent)")) } )); codeMemberMethod.Statements.Add( new CodeSnippetExpression("throw new Exception(\"Event is not in the correct list\")")); codeTypeDeclaration.Members.Add(codeMemberMethod); return(codeNamespace); }
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(DomainHookBaseClass hookClass) { var targetClass = _interfaceBuilderUtil.Build(hookClass); var nameSpace = _nameSpaceBuilderUtil.WithName(_nameSpace).WithDomain().WithTask().Build(); _propertyBuilderUtil.BuildForInterface(targetClass, hookClass.Properties); nameSpace.Types.Add(targetClass); 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 void AddNameSpace() { _nameSpace = _nameSpaceBuilderUtil .WithName("SqlAdapter") .WithDomain() .WithTask() .WithList() .WithApplication() .Build(); }
public CodeNamespace Build(DomainClass domainClass) { var nsUtil = _nameSpaceBuilderUtil .WithName($"{_nameSpace}.{domainClass.Name}s") .WithList() .WithTask() .WithDomain() .WithDomainEntityNameSpace(domainClass.Name) .WithMvcImport(); foreach (var loadMethod in domainClass.LoadMethods) { foreach (var param in loadMethod.LoadParameters) { nsUtil.WithRepository(param.Type); } } var codeNamespace = nsUtil.Build(); var commandHandler = _classBuilderUtil.BuildPartial(_nameBuilderUtil.BuildCommandHandlerName(domainClass)); var codeConstructor = _constructorBuilderUtil.BuildPublic(_commandHandlerPropBuilderUtil.Build(domainClass)); _propertyBuilderUtil.Build(commandHandler, _commandHandlerPropBuilderUtil.Build(domainClass)); commandHandler.Members.Add(codeConstructor); var allMethod = _commandHandlerMethodBuilderUtil.BuildGetAllMethod(domainClass); var byIdMethod = _commandHandlerMethodBuilderUtil.BuildGetByIdMethod(domainClass); commandHandler.Members.Add(allMethod); commandHandler.Members.Add(byIdMethod); foreach (var createMethod in domainClass.CreateMethods) { var method = _commandHandlerMethodBuilderUtil.BuildCreateMethod(createMethod, domainClass); commandHandler.Members.Add(method); } foreach (var method in domainClass.Methods.Except(domainClass.LoadMethods)) { var methodParsed = _commandHandlerMethodBuilderUtil.BuildUpdateMethod(method, domainClass); commandHandler.Members.Add(methodParsed); } foreach (var method in domainClass.LoadMethods) { var methodParsed = _commandHandlerMethodBuilderUtil.BuildUpdateLoadMethod(method, domainClass); commandHandler.Members.Add(methodParsed); } codeNamespace.Types.Add(commandHandler); return(codeNamespace); }
public void AddNameSpace() { _nameSpaceBuilderUtil.WithName($"Domain.{_domainClass.Name}s").WithList(); foreach (var childHookMethod in _domainClass.ChildHookMethods) { var className = _nameBuilderUtil.GetClassName(childHookMethod, _domainClass.Properties, _domainClass.ListProperties); _nameSpaceBuilderUtil.WithDomainEntityNameSpace(className); } _nameSpaceRealClass = _nameSpaceBuilderUtil.Build(); }
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 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); }
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 AddNameSpace() { _nameSpace = _nameSpaceBuilderUtil.WithName("Domain").WithList().Build(); }
public void AddNameSpace() { _nameSpace = _nameSpaceBuilderUtil.WithName($"Domain.{_classModell.Name}s").Build(); }
public CodeNamespace Build(DomainClass domainClass) { var nameSpace = _nameSpaceBuilderUtil .WithName($"{_nameSpace}.{domainClass.Name}s") .WithList() .WithTask() .WithDomainEntityNameSpace(domainClass.Name) .Build(); var iface = new CodeTypeDeclaration($"I{domainClass.Name}Repository") { IsInterface = true }; var createMethod = new CodeMemberMethod { Name = $"Create{domainClass.Name}", ReturnType = new CodeTypeReference("Task") }; createMethod.Parameters.Add(new CodeParameterDeclarationExpression { Type = new CodeTypeReference(domainClass.Name), Name = domainClass.Name.ToLower() }); iface.Members.Add(createMethod); var updateMethod = new CodeMemberMethod { Name = $"Update{domainClass.Name}", ReturnType = new CodeTypeReference("Task") }; updateMethod.Parameters.Add(new CodeParameterDeclarationExpression { Type = new CodeTypeReference(domainClass.Name), Name = domainClass.Name.ToLower() }); iface.Members.Add(updateMethod); var getByIdMethod = new CodeMemberMethod { Name = $"Get{domainClass.Name}", ReturnType = new CodeTypeReference($"Task<{domainClass.Name}>") }; getByIdMethod.Parameters.Add(new CodeParameterDeclarationExpression { Type = new CodeTypeReference("Guid"), Name = "id" }); iface.Members.Add(getByIdMethod); var getAllMethod = new CodeMemberMethod { Name = $"Get{domainClass.Name}s", ReturnType = new CodeTypeReference($"Task<List<{domainClass.Name}>>") }; iface.Members.Add(getAllMethod); nameSpace.Types.Add(iface); iface.Members.AddRange(MakeGetParentMethods(domainClass)); return(nameSpace); }