public static string FormatAbsoluteRoutePath(CodeGenerationParameter routeParameter)
{
var routePath = routeParameter.RetrieveRelatedValue(Label.RoutePath);
var uriRoot = routeParameter.Parent().RetrieveRelatedValue(Label.UriRoot);
return(FormatAbsoluteRoutePath(uriRoot, routePath));
}
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));
}
//TODO:
public string ResolveRouteHandlerInvocation(CodeGenerationParameter parentParameter, CodeGenerationParameter routeSignatureParameter)
{
//var httpMethod = routeSignatureParameter.RetrieveRelatedValue(Label.RouteMethod, Method::from);
string defaultParameter = string.Empty;//httpMethod.isGET() ? QUERIES_PARAMETER : _defaultFactoryMethodParameter;
return(Resolve(Label.RouteHandlerInvocation, Label.UseCustomRouteHandlerParam, defaultParameter, parentParameter, routeSignatureParameter));
}
public static IHandlerInvocationResolver With(CodeGenerationParameter parentParameter)
{
if (parentParameter.IsLabeled(Label.AutoDispatchName))
{
return(new AutoDispatchHandlerInvocationResolver());
}
return(new DefaultHandlerInvocationResolver());
}
private void LoadDependencies(CodeGenerationParameter aggregate, bool useCQRS)
{
if (useCQRS)
{
aggregate.Relate(RouteDetail.DefaultQueryRouteParameter(aggregate));
}
this.DependOn(AutoDispatchRouteTemplateData.From(aggregate.RetrieveAllRelated(Label.RouteSignature)));
}
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));
}
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 static void InferModelParameters(CodeGenerationParameter aggregateParameter, List <ContentBase> contents)
{
var modelActor = new TemplateStandard(TemplateStandardType.Aggregate).ResolveClassname(aggregateParameter.value);
var modelProtocolQualifiedName = ContentQuery.FindFullyQualifiedClassName(new TemplateStandard(TemplateStandardType.AggregateProtocol), aggregateParameter.value, contents);
var modelActorQualifiedName = ContentQuery.FindFullyQualifiedClassName(new TemplateStandard(TemplateStandardType.Aggregate), modelActor, contents);
aggregateParameter.Relate(Label.ModelProtocol, modelProtocolQualifiedName).Relate(Label.ModelActor, modelActorQualifiedName);
}
private List <string> FormatMethodParameters(CodeGenerationParameter parameter)
{
return(parameter.RetrieveAllRelated(ResolveFieldsLabel(parameter)).Select(param =>
{
var paramType = StateFieldDetail.TypeOf(param.Parent(Label.Aggregate), param.value);
return string.Format(_signaturePatttern, paramType, param.value);
}).ToList());
}
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 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));
}
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 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 string ResolveCommandMethodInvocation(CodeGenerationParameter aggregateParameter, CodeGenerationParameter routeParameter)
{
var argumentsFormat = new AggregateArgumentsFormat.MethodInvocation("stage()", "data");
var method = AggregateDetail.MethodWithName(aggregateParameter, routeParameter.value);
var factoryMethod = method.RetrieveRelatedValue(Label.FactoryMethod, x => bool.TrueString.ToLower() == x);
var scope = factoryMethod ? MethodScopeType.Static : MethodScopeType.Instance;
var methodInvocationParameters = argumentsFormat.Format(method, scope);
var invoker = factoryMethod ? aggregateParameter.value : ClassFormatter.SimpleNameToAttribute(aggregateParameter.value);
return(string.Format(_commandPattern, invoker, method.value, methodInvocationParameters));
}
public override string Format(CodeGenerationParameter method, MethodScopeType scope)
{
var args = scope == MethodScopeType.Static ? new List <string>()
{
_stageVariableName
} : new List <string>();
return(string.Join(", ", new List <List <string> >()
{
args, FormatMethodParameters(method)
}.SelectMany(x => x)));
}
public static QueriesParameter From(CodeGenerationParameter aggregateParameter, List <ContentBase> contents, bool useCQRS)
{
if (!useCQRS)
{
return(QueriesParameter.Empty());
}
var queriesProtocol = new TemplateStandard(TemplateStandardType.Queries).ResolveClassname(aggregateParameter.value);
var queriesActor = new TemplateStandard(TemplateStandardType.QueriesActor).ResolveClassname(aggregateParameter.value);
return(new QueriesParameter(ContentQuery.FindFullyQualifiedClassName(new TemplateStandard(TemplateStandardType.Queries), queriesProtocol, contents), ContentQuery.FindFullyQualifiedClassName(new TemplateStandard(TemplateStandardType.QueriesActor), queriesActor, contents)));
}
public string Format(CodeGenerationParameter parameter, MethodScopeType scope)
{
var args = scope == MethodScopeType.Static ? new List <string>()
{
_stateArgument
} : new List <string>();
return(string.Join(", ", new List <List <string> >()
{
args, FormatMethodParameters(parameter)
}.SelectMany(x => x)));
}
private List <string> ResolveHandlerIndexes(CodeGenerationParameter aggregate, bool useCQRS)
{
var handlers = new List <List <CodeGenerationParameter> >()
{
aggregate.RetrieveAllRelated(Label.RouteSignature).ToList(), new List <CodeGenerationParameter>()
{
_stateAdapterHandler
}
}.SelectMany(x => x).ToList();
return(Enumerable.Range(0, handlers.Count()).Select(index => string.Format(_handlerIndexPattern, AutoDispatchMappingValueFormatter.Format(handlers[index].value), index)).ToList());
}
private List <string> ResolveParameterTypes(CodeGenerationParameter routeSignatureParameter)
{
var bodyParameterName = RouteDetail.ResolveBodyName(routeSignatureParameter);
var parameters = _signature.Substring(_signature.IndexOf("(") + 1, _signature.LastIndexOf(")"));
if (parameters.Trim() == string.Empty)
{
return(new List <string>());
}
return(parameters.Split(',').Select(parameter => parameter.Replace("readonly", string.Empty).Trim()).Where(parameter => !parameter.EndsWith(string.Concat(" ", bodyParameterName)))
.Select(parameter => parameter.Substring(0, parameter.IndexOf(" "))).ToList());
}
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 ResolveDefaultValue(CodeGenerationParameter aggregate, string stateFieldName)
{
var type = TypeOf(aggregate, stateFieldName);
if (string.Equals(type, typeof(bool).Name, StringComparison.OrdinalIgnoreCase))
{
return("false");
}
if (_numericTypes.Contains(TypeOf(aggregate, stateFieldName).ToLower()))
{
return("0");
}
return("null");
}
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));
}
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);
}
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 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);
}
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));
}
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));
}
private AutoDispatchHandlerEntryTemplateData(CodeGenerationParameter route)
{
var aggregate = route.Parent(Label.Aggregate);
var method = AggregateDetail.MethodWithName(aggregate, route.value);
var factoryMethod = method.RetrieveRelatedValue(Label.FactoryMethod, x => bool.TrueString.ToLower());
//TODO: TemplateStandartType enum methods
_parameters =
TemplateParameters.With(TemplateParameter.MethodName, route.value)
.And(TemplateParameter.FactoryMethod, factoryMethod)
.And(TemplateParameter.AggregateProtocolName, aggregate.value)
.And(TemplateParameter.DataObjectName, TemplateStandardType.DataObject)
.And(TemplateParameter.AggregateProtocolVariable, Content.ClassFormatter.SimpleNameToAttribute(aggregate.value))
.And(TemplateParameter.StateName, TemplateStandardType.AggregateState)
.And(TemplateParameter.IndexName, AutoDispatchMappingValueFormatter.Format(route.value))
.And(TemplateParameter.MethodInvocationParameters, ResolveMethodInvocationParameters(method));
}
