private AutoDispatchResourceHandlerTemplateData(CodeGenerationContext context, CodeGenerationParameter autoDispatchParameter)
{
_restResourceName = ClassFormatter.SimpleNameOf(autoDispatchParameter.value);
var queryStoreProviderParameters = TemplateParameters.With(TemplateParameter.StorageType, StorageType.StateStore).And(TemplateParameter.Model, ModelType.Query);
var queryStoreProviderName = new TemplateStandard(TemplateStandardType.StoreProvider).ResolveClassname(queryStoreProviderParameters);
var aggregateProtocolClassName = ClassFormatter.SimpleNameOf(autoDispatchParameter.RetrieveRelatedValue(Label.ModelProtocol));
_parameters = TemplateParameters.With(TemplateParameter.PackageName, ClassFormatter.PackageOf(autoDispatchParameter.value))
.And(TemplateParameter.StateName, new TemplateStandard(TemplateStandardType.AggregateState).ResolveClassname(aggregateProtocolClassName))
.And(TemplateParameter.Queries, QueriesParameter.From(autoDispatchParameter))
.And(TemplateParameter.RestResourceName, Standard().ResolveClassname(_restResourceName))
.And(TemplateParameter.UriRoot, autoDispatchParameter.RetrieveRelatedValue(Label.UriRoot))
.And(TemplateParameter.RouteDeclarations, RouteDeclarationParameter.From(autoDispatchParameter))
.And(TemplateParameter.ModelProtocol, autoDispatchParameter.RetrieveRelatedValue(Label.ModelProtocol))
.And(TemplateParameter.ModelActor, autoDispatchParameter.RetrieveRelatedValue(Label.ModelActor))
.And(TemplateParameter.HandlersConfigName, autoDispatchParameter.RetrieveRelatedValue(Label.HandlersConfigName))
.And(TemplateParameter.StoreProviderName, queryStoreProviderName).And(TemplateParameter.RouteMethod, new List <string>())
.And(TemplateParameter.AutoDispatchMappingName, _restResourceName).And(TemplateParameter.UseAutoDispatch, true)
.And(TemplateParameter.DataObjectName, new TemplateStandard(TemplateStandardType.DataObject).ResolveClassname(aggregateProtocolClassName))
.And(TemplateParameter.UseCqrs, context.ParameterOf <bool>(Label.Cqrs, x => bool.TrueString.ToLower() == x))
.AddImports(ResolveImports(context, autoDispatchParameter, queryStoreProviderName));
DependOn(RouteMethodTemplateData.From(autoDispatchParameter, _parameters));
}
private HashSet <string> ResolveImports(CodeGenerationParameter mainParameter, CodeGenerationParameter routeSignatureParameter) => new HashSet <string>(new List <string>()
{
RetrieveIdTypeQualifiedName(routeSignatureParameter),
routeSignatureParameter.RetrieveRelatedValue(Label.BodyType),
mainParameter.RetrieveRelatedValue(Label.HandlersConfigName),
mainParameter.RetrieveRelatedValue(Label.ModelProtocol),
mainParameter.RetrieveRelatedValue(Label.ModelActor),
mainParameter.RetrieveRelatedValue(Label.ModelData),
}.Where(x => x == string.Empty));
private AutoDispatchRouteTemplateData(CodeGenerationParameter route)
{
var aggregate = route.Parent(Label.Aggregate);
_parameters =
TemplateParameters.With(TemplateParameter.RetrievalRoute, IsRetrievalRoute(route))
.And(TemplateParameter.IdType, StateFieldDetail.TypeOf(aggregate, "id"))
.And(TemplateParameter.RouteMethod, route.RetrieveRelatedValue(Label.RouteMethod))
.And(TemplateParameter.RoutePath, PathFormatter.FormatRelativeRoutePath(route))
.And(TemplateParameter.DataObjectName, new TemplateStandard(TemplateStandardType.DataObject).ResolveClassname(aggregate.value))
.And(TemplateParameter.RouteMappingValue, AutoDispatchMappingValueFormatter.Format(route.value))
.And(TemplateParameter.RequireEntityLoading, route.RetrieveRelatedValue(Label.RequireEntityLoading, x => bool.TrueString.ToLower() == x))
.And(TemplateParameter.AutoDispatchHandlersMappingName, new TemplateStandard(TemplateStandardType.AutoDispatchHandlersMapping).ResolveClassname(aggregate.value))
.And(TemplateParameter.MethodName, route.value);
}
public static string FormatAbsoluteRoutePath(CodeGenerationParameter routeParameter)
{
var routePath = routeParameter.RetrieveRelatedValue(Label.RoutePath);
var uriRoot = routeParameter.Parent().RetrieveRelatedValue(Label.UriRoot);
return(FormatAbsoluteRoutePath(uriRoot, routePath));
}
public static string ResolveBodyType(CodeGenerationParameter route)
{
var httpMethod = route.RetrieveRelatedValue(Label.RouteMethod, Method.From);
if (!_bodySupportedHttpMethods.Contains(httpMethod))
{
return(string.Empty);
}
if (route.Parent().IsLabeled(Label.Aggregate))
{
return(new TemplateStandard(TemplateStandardType.DataObject).ResolveClassname(route.Parent(Label.Aggregate).value));
}
return(route.RetrieveRelatedValue(Label.BodyType));
}
public static string ResolveBodyName(CodeGenerationParameter route)
{
var httpMethod = route.RetrieveRelatedValue(Label.RouteMethod, Method.From);
if (!_bodySupportedHttpMethods.Contains(httpMethod))
{
return(string.Empty);
}
if (route.HasAny(Label.Body))
{
return(route.RetrieveRelatedValue(Label.Body));
}
return(_bodyDefaultName);
}
private string Resolve(Label invocationLabel, Label customParamsLabel, string defaultParameter, CodeGenerationParameter parentParameter, CodeGenerationParameter routeSignatureParameter)
{
if (!routeSignatureParameter.HasAny(customParamsLabel))
{
return(string.Empty);
}
var handlersConfigQualifiedName = parentParameter.RetrieveRelatedValue(Label.HandlersConfigName);
var handlersConfigClassName = ClassFormatter.SimpleNameOf(handlersConfigQualifiedName);
var invocation = routeSignatureParameter.RetrieveRelatedValue(invocationLabel);
if (routeSignatureParameter.RetrieveRelatedValue(customParamsLabel, x => bool.TrueString.ToLower() == x))
{
return(string.Format(_handlerInvocationPattern, handlersConfigClassName, invocation));
}
return(string.Format(_handlerInvocationWithDefaultParamsPattern, handlersConfigClassName, invocation, defaultParameter));
}
private string ResolveMethodInvocationParameters(CodeGenerationParameter method)
{
var factoryMethod = method.RetrieveRelatedValue(Label.FactoryMethod, x => x == bool.TrueString.ToLower());
var methodScope = factoryMethod ? MethodScopeType.Static : MethodScopeType.Instance;
return(new AggregateArgumentsFormat.MethodInvocation("$stage", "data").Format(method, methodScope));
}
public static QueriesParameter From(CodeGenerationParameter autoDispatchParameter)
{
if (!autoDispatchParameter.HasAny(Label.QueriesProtocol))
{
return(QueriesParameter.Empty());
}
return(new QueriesParameter(autoDispatchParameter.RetrieveRelatedValue(Label.QueriesProtocol), autoDispatchParameter.RetrieveRelatedValue(Label.QueriesActor)));
}
private string ResolveIdName(CodeGenerationParameter routeSignatureParameter)
{
if (!routeSignatureParameter.HasAny(Label.Id))
{
return(_defaultIdName);
}
return(routeSignatureParameter.RetrieveRelatedValue(Label.Id));
}
public string ResolveRouteHandlerInvocation(CodeGenerationParameter aggregateParameter, CodeGenerationParameter routeParameter)
{
if (routeParameter.RetrieveRelatedValue(Label.RouteMethod, Method.From).IsGet())
{
return(ResolveQueryMethodInvocation(routeParameter.value));
}
return(ResolveCommandMethodInvocation(aggregateParameter, routeParameter));
}
private RouteDeclarationParameter(int routeIndex, int numberOfRoutes, CodeGenerationParameter routeSignatureParameter)
{
_signature = RouteDetail.ResolveMethodSignature(routeSignatureParameter);
_handlerName = ResolveHandlerName();
_path = PathFormatter.FormatAbsoluteRoutePath(routeSignatureParameter);
_bodyType = RouteDetail.ResolveBodyType(routeSignatureParameter);
_builderMethod = routeSignatureParameter.RetrieveRelatedValue(Label.RouteMethod);
_parameterTypes.AddRange(ResolveParameterTypes(routeSignatureParameter));
_last = routeIndex == numberOfRoutes - 1;
}
private HashSet <string> ResolveImports(CodeGenerationContext context, CodeGenerationParameter autoDispatchParameter, string queryStoreProviderName)
{
var queryStoreProviderQualifiedName = ContentQuery.FindFullyQualifiedClassName(new TemplateStandard(TemplateStandardType.StoreProvider), queryStoreProviderName, context.Contents().ToList());
var queriesProtocolQualifiedName = autoDispatchParameter.RetrieveRelatedValue(Label.QueriesProtocol);
return(new HashSet <string>(new List <string>()
{
queriesProtocolQualifiedName, queryStoreProviderQualifiedName
}));
}
private string ResolveModelAttributeName(CodeGenerationParameter mainParameter, Label protocolLabel)
{
if (mainParameter.IsLabeled(Label.Aggregate))
{
return(ClassFormatter.SimpleNameToAttribute(mainParameter.value));
}
var qualifiedName = mainParameter.RetrieveRelatedValue(protocolLabel);
return(ClassFormatter.QualifiedNameToAttribute(qualifiedName));
}
public static IEnumerable <MethodScopeType> Infer(CodeGenerationParameter method)
{
if (method.RetrieveRelatedValue(Label.FactoryMethod, x => x == bool.TrueString.ToLower()))
{
return(new List <MethodScopeType>()
{
MethodScopeType.Instance, MethodScopeType.Static
});
}
return(new List <MethodScopeType>()
{
MethodScopeType.Instance
});
}
public static string FormatRelativeRoutePath(CodeGenerationParameter routeParameter)
{
var routePath = routeParameter.RetrieveRelatedValue(Label.RoutePath);
if (routePath == string.Empty || RemoveSurplusesSlashes(routePath) == "/")
{
return(string.Empty);
}
if (routePath.EndsWith("/"))
{
return(routePath.Substring(0, routePath.Length - 1));
}
return(routePath);
}
public static string ResolveMethodSignature(CodeGenerationParameter routeSignature)
{
if (HasValidMethodSignature(routeSignature.value))
{
return(routeSignature.value);
}
if (routeSignature.RetrieveRelatedValue(Label.RouteMethod, Method.From).IsGet())
{
return(string.Format(_methodSignaturePattern, routeSignature.value, string.Empty));
}
return(ResolveMethodSignatureWithParams(routeSignature));
}
private static string ResolveMethodSignatureWithParams(CodeGenerationParameter routeSignature)
{
var idParameter = routeSignature.RetrieveRelatedValue(Label.RequireEntityLoading, x => bool.TrueString.ToLower() == x) ? string.Format(_methodParameterPattern, "String", "id") : string.Empty;
var method = AggregateDetail.MethodWithName(routeSignature.Parent(), routeSignature.value);
var dataClassname = new TemplateStandard(TemplateStandardType.DataObject).ResolveClassname(routeSignature.Parent().value);
var dataParameterDeclaration = string.Format(_methodParameterPattern, dataClassname, "data");
var dataParameter = method.HasAny(Label.MethodParameter) ? dataParameterDeclaration : "";
var parameters = string.Join(", ", new List <string>()
{
idParameter, dataParameter
}.Where(param => param != string.Empty));
return(string.Format(_methodSignaturePattern, routeSignature.value, parameters));
}
private RouteMethodTemplateData(CodeGenerationParameter mainParameter, CodeGenerationParameter routeSignatureParameter, TemplateParameters parentParameters)
{
var invocationResolver = HandlerInvocationResolver.With(mainParameter);
var routeHandlerInvocation = invocationResolver.ResolveRouteHandlerInvocation(mainParameter, routeSignatureParameter);
var adapterHandlerInvocation = invocationResolver.ResolveAdapterHandlerInvocation(mainParameter, routeSignatureParameter);
_parameters = TemplateParameters.With(TemplateParameter.RouteSignature, RouteDetail.ResolveMethodSignature(routeSignatureParameter))
.And(TemplateParameter.ModelAttribute, ResolveModelAttributeName(mainParameter, Label.ModelProtocol))
.And(TemplateParameter.RouteMethod, routeSignatureParameter.RetrieveRelatedValue(Label.RouteMethod))
.And(TemplateParameter.RequireEntityLoading, ResolveEntityLoading(routeSignatureParameter))
.And(TemplateParameter.AdapterHandlerInvocation, adapterHandlerInvocation)
.And(TemplateParameter.RouteHandlerInvocation, routeHandlerInvocation)
.And(TemplateParameter.IdName, ResolveIdName(routeSignatureParameter));
parentParameters.AddImports(ResolveImports(mainParameter, routeSignatureParameter));
}
public AutoDispatchMappingTemplateData(string basePackage, CodeGenerationParameter aggregate, bool useCQRS, List <ContentBase> contents)
{
_aggregateName = aggregate.value;
_parameters =
TemplateParameters.With(TemplateParameter.PackageName, ResolvePackage(basePackage))
.And(TemplateParameter.AggregateProtocolName, _aggregateName)
.And(TemplateParameter.EntityName, new TemplateStandard().ResolveClassname(TemplateStandardType.Aggregate.ToString(_aggregateName)))
.And(TemplateParameter.DataObjectName, new TemplateStandard().ResolveClassname(TemplateStandardType.DataObject.ToString(_aggregateName)))
.And(TemplateParameter.QueriesName, new TemplateStandard().ResolveClassname(TemplateStandardType.Queries.ToString(_aggregateName)))
.And(TemplateParameter.QueriesActorName, new TemplateStandard().ResolveClassname(TemplateStandardType.QueriesActor.ToString(_aggregateName)))
.And(TemplateParameter.AutoDispatchMappingName, new TemplateStandard().ResolveClassname(TemplateStandardType.AutoDispatchMapping.ToString(_aggregateName)))
.And(TemplateParameter.AutoDispatchHandlersMappingName, new TemplateStandard().ResolveClassname(TemplateStandardType.AutoDispatchHandlersMapping.ToString(_aggregateName)))
.And(TemplateParameter.UriRoot, aggregate.RetrieveRelatedValue(Label.UriRoot))
.AddImports(ResolveImports(_aggregateName, contents))
.And(TemplateParameter.RouteDeclarations, new List <string>())
.And(TemplateParameter.UseCqrs, useCQRS);
LoadDependencies(aggregate, useCQRS);
}
private bool IsRetrievalRoute(CodeGenerationParameter route)
{
var method = route.RetrieveRelatedValue(Label.RouteMethod, Method.From);
return(method.IsGet() || method.IsOptions());
}
private string RetrieveIdTypeQualifiedName(CodeGenerationParameter routeSignatureParameter)
{
var idType = routeSignatureParameter.RetrieveRelatedValue(Label.IdType);
return(idType.Contains(".") ? string.Empty : idType);
}
private bool ResolveEntityLoading(CodeGenerationParameter routeSignatureParameter) => routeSignatureParameter.HasAny(Label.Id) || (routeSignatureParameter.HasAny(Label.RequireEntityLoading) && routeSignatureParameter.RetrieveRelatedValue(Label.RequireEntityLoading, x => bool.TrueString.ToLower() == x));
