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)); }