public override ImmutableDictionary <String, ITypeSpecBuilder> ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder, ImmutableDictionary <String, ITypeSpecBuilder> metamodel) { ParameterInfo parameter = method.GetParameters()[paramNum]; var facets = new List <IFacet>(); if (parameter.ParameterType.IsGenericType && (parameter.ParameterType.GetGenericTypeDefinition() == typeof(Nullable <>))) { facets.Add(new NullableFacetAlways(holder)); } var result = reflector.LoadSpecification(parameter.ParameterType, metamodel); metamodel = result.Item2; var returnSpec = result.Item1 as IObjectSpecBuilder; if (returnSpec != null && IsCollection(parameter.ParameterType)) { Type elementType = CollectionUtils.ElementType(parameter.ParameterType); result = reflector.LoadSpecification(elementType, metamodel); metamodel = result.Item2; var elementSpec = result.Item1 as IObjectSpecImmutable; facets.Add(new ElementTypeFacet(holder, elementType, elementSpec)); } FacetUtils.AddFacets(facets); return(metamodel); }
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) => FacetUtils.AddFacets( new IFacet[] { new DescribedAsFacetNone(specification), new ImmutableFacetNever(specification), new TitleFacetNone(specification) });
private static void Process(ISpecification holder) { var facets = new List <IFacet>(); if (holder is IMemberSpecImmutable specImmutable) { facets.Add(new NamedFacetInferred(specImmutable.Identifier.MemberName, holder)); facets.Add(new DescribedAsFacetNone(holder)); } if (holder is IAssociationSpecImmutable) { facets.Add(new ImmutableFacetNever(holder)); facets.Add(new PropertyDefaultFacetNone(holder)); facets.Add(new PropertyValidateFacetNone(holder)); } if (holder is IOneToOneAssociationSpecImmutable immutable) { facets.Add(new MaxLengthFacetZero(holder)); DefaultTypicalLength(facets, immutable.ReturnSpec, immutable); facets.Add(new MultiLineFacetNone(holder)); } if (holder is IActionSpecImmutable) { facets.Add(new ExecutedFacetDefault(holder)); facets.Add(new ActionDefaultsFacetNone(holder)); facets.Add(new ActionChoicesFacetNone(holder)); facets.Add(new PageSizeFacetDefault(holder)); } FacetUtils.AddFacets(facets); }
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) { var facets = new List <IFacet>(); if (IsAbstract(type)) { facets.Add(new TypeIsAbstractFacet(specification)); } if (IsInterface(type)) { facets.Add(new TypeIsInterfaceFacet(specification)); } if (IsSealed(type)) { facets.Add(new TypeIsSealedFacet(specification)); } if (IsVoid(type)) { facets.Add(new TypeIsVoidFacet(specification)); } FacetUtils.AddFacets(facets); }
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) { var facets = new List <IFacet>(); var namedFacet = specification.GetFacet <INamedFacet>(); if (namedFacet == null) { string inferredName = NameUtils.NaturalName(ShortName(type)); namedFacet = new NamedFacetInferred(inferredName, specification); facets.Add(namedFacet); Log.InfoFormat("No name facet found inferring name {0}", inferredName); } var pluralFacet = specification.GetFacet <IPluralFacet>(); if (pluralFacet == null) { string pluralName = NameUtils.PluralName(namedFacet.Value); pluralFacet = new PluralFacetInferred(pluralName, specification); facets.Add(pluralFacet); Log.InfoFormat("No plural facet found inferring name {0}", pluralName); } FacetUtils.AddFacets(facets); }
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) { var namedFacet = specification.GetFacet <INamedFacet>() ?? new NamedFacetInferred(type.Name, specification); IFacet pluralFacet = specification.GetFacet <IPluralFacet>() ?? new PluralFacetInferred(NameUtils.PluralName(namedFacet.NaturalName), specification); var facets = new[] { namedFacet, pluralFacet }; FacetUtils.AddFacets(facets); }
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, Type type, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) { FacetUtils.AddFacets( new IFacet[] { new DescribedAsFacetNone(specification), new ImmutableFacetNever(specification), new TitleFacetNone(specification) }); return(metamodel); }
public override ImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification, ImmutableDictionary <string, ITypeSpecBuilder> metamodel) { var facets = new List <IFacet> { new TypeIsAbstractFacet(specification, IsAbstract(type)), new TypeIsInterfaceFacet(specification, IsInterface(type)), new TypeIsSealedFacet(specification, IsSealed(type)), new TypeIsVoidFacet(specification, IsVoid(type)) }; FacetUtils.AddFacets(facets); return(metamodel); }
public override void Process(IReflector reflector, MethodInfo actionMethod, IMethodRemover methodRemover, ISpecificationBuilder action) { string capitalizedName = NameUtils.CapitalizeName(actionMethod.Name); Type type = actionMethod.DeclaringType; var facets = new List <IFacet>(); ITypeSpecBuilder onType = reflector.LoadSpecification(type); var returnSpec = reflector.LoadSpecification <IObjectSpecBuilder>(actionMethod.ReturnType); IObjectSpecImmutable elementSpec = null; bool isQueryable = IsQueryOnly(actionMethod) || CollectionUtils.IsQueryable(actionMethod.ReturnType); if (returnSpec != null && returnSpec.IsCollection) { Type elementType = CollectionUtils.ElementType(actionMethod.ReturnType); elementSpec = reflector.LoadSpecification <IObjectSpecImmutable>(elementType); } RemoveMethod(methodRemover, actionMethod); facets.Add(new ActionInvocationFacetViaMethod(actionMethod, onType, returnSpec, elementSpec, action, isQueryable)); MethodType methodType = actionMethod.IsStatic ? MethodType.Class : MethodType.Object; Type[] paramTypes = actionMethod.GetParameters().Select(p => p.ParameterType).ToArray(); FindAndRemoveValidMethod(reflector, facets, methodRemover, type, methodType, capitalizedName, paramTypes, action); DefaultNamedFacet(facets, actionMethod.Name, action); // must be called after the checkForXxxPrefix methods AddHideForSessionFacetNone(facets, action); AddDisableForSessionFacetNone(facets, action); FindDefaultHideMethod(reflector, facets, methodRemover, type, methodType, "ActionDefault", action); FindAndRemoveHideMethod(reflector, facets, methodRemover, type, methodType, capitalizedName, action); FindDefaultDisableMethod(reflector, facets, methodRemover, type, methodType, "ActionDefault", action); FindAndRemoveDisableMethod(reflector, facets, methodRemover, type, methodType, capitalizedName, action); var actionSpecImmutable = action as IActionSpecImmutable; if (actionSpecImmutable != null) { // Process the action's parameters names, descriptions and optional // an alternative design would be to have another facet factory processing just ActionParameter, and have it remove these // supporting methods. However, the FacetFactory API doesn't allow for methods of the class to be removed while processing // action parameters, only while processing Methods (ie actions) IActionParameterSpecImmutable[] actionParameters = actionSpecImmutable.Parameters; string[] paramNames = actionMethod.GetParameters().Select(p => p.Name).ToArray(); FindAndRemoveParametersAutoCompleteMethod(reflector, methodRemover, type, capitalizedName, paramTypes, actionParameters); FindAndRemoveParametersChoicesMethod(reflector, methodRemover, type, capitalizedName, paramTypes, paramNames, actionParameters); FindAndRemoveParametersDefaultsMethod(reflector, methodRemover, type, capitalizedName, paramTypes, paramNames, actionParameters); FindAndRemoveParametersValidateMethod(reflector, methodRemover, type, capitalizedName, paramTypes, paramNames, actionParameters); } FacetUtils.AddFacets(facets); }
public override ImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, PropertyInfo property, IMethodRemover methodRemover, ISpecificationBuilder specification, ImmutableDictionary <string, ITypeSpecBuilder> metamodel) { string capitalizedName = property.Name; var paramTypes = new[] { property.PropertyType }; var facets = new List <IFacet> { new PropertyAccessorFacet(property, specification) }; if (property.PropertyType.IsGenericType && (property.PropertyType.GetGenericTypeDefinition() == typeof(Nullable <>))) { facets.Add(new NullableFacetAlways(specification)); } if (property.GetSetMethod() != null) { if (property.PropertyType == typeof(byte[])) { facets.Add(new DisabledFacetAlways(specification)); } else { facets.Add(new PropertySetterFacetViaSetterMethod(property, specification)); } facets.Add(new PropertyInitializationFacet(property, specification)); } else { facets.Add(new NotPersistedFacet(specification)); facets.Add(new DisabledFacetAlways(specification)); } FindAndRemoveModifyMethod(reflector, facets, methodRemover, property.DeclaringType, capitalizedName, paramTypes, specification); FindAndRemoveAutoCompleteMethod(reflector, facets, methodRemover, property.DeclaringType, capitalizedName, property.PropertyType, specification); metamodel = FindAndRemoveChoicesMethod(reflector, facets, methodRemover, property.DeclaringType, capitalizedName, property.PropertyType, specification, metamodel); FindAndRemoveDefaultMethod(reflector, facets, methodRemover, property.DeclaringType, capitalizedName, property.PropertyType, specification); FindAndRemoveValidateMethod(reflector, facets, methodRemover, property.DeclaringType, paramTypes, capitalizedName, specification); AddHideForSessionFacetNone(facets, specification); AddDisableForSessionFacetNone(facets, specification); FindDefaultHideMethod(reflector, facets, methodRemover, property.DeclaringType, MethodType.Object, "PropertyDefault", specification); FindAndRemoveHideMethod(reflector, facets, methodRemover, property.DeclaringType, MethodType.Object, capitalizedName, specification); FindDefaultDisableMethod(reflector, facets, methodRemover, property.DeclaringType, MethodType.Object, "PropertyDefault", specification); FindAndRemoveDisableMethod(reflector, facets, methodRemover, property.DeclaringType, MethodType.Object, capitalizedName, specification); FacetUtils.AddFacets(facets); return(metamodel); }
public override void Process(IReflector reflector, PropertyInfo property, IMethodRemover methodRemover, ISpecificationBuilder collection) { string capitalizedName = property.Name; Type type = property.DeclaringType; var facets = new List <IFacet> { new PropertyAccessorFacet(property, collection) }; AddSetFacet(facets, property, collection); AddHideForSessionFacetNone(facets, collection); AddDisableFacetAlways(facets, collection); FindDefaultHideMethod(reflector, facets, methodRemover, property.DeclaringType, MethodType.Object, "PropertyDefault", collection); FindAndRemoveHideMethod(reflector, facets, methodRemover, type, MethodType.Object, capitalizedName, collection); FacetUtils.AddFacets(facets); }
public override void ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder) { var facets = new List <IFacet>(); if (holder is IActionParameterSpecImmutable param) { var name = method.GetParameters()[paramNum].Name ?? method.GetParameters()[paramNum].ParameterType.FullName; INamedFacet namedFacet = new NamedFacetInferred(name, holder); facets.Add(namedFacet); facets.Add(new DescribedAsFacetNone(holder)); facets.Add(new MultiLineFacetNone(holder)); facets.Add(new MaxLengthFacetZero(holder)); facets.Add(new TypicalLengthFacetZero(holder)); DefaultTypicalLength(facets, param.Specification, param); } FacetUtils.AddFacets(facets); }
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, PropertyInfo property, ISpecificationBuilder collection, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) { var capitalizedName = property.Name; var type = property.DeclaringType; var facets = new List <IFacet> { new PropertyAccessorFacet(property, collection) }; AddSetFacet(facets, property, collection); MethodHelpers.AddHideForSessionFacetNone(facets, collection); MethodHelpers.AddDisableFacetAlways(facets, collection); MethodHelpers.FindDefaultHideMethod(reflector, facets, property.DeclaringType, MethodType.Object, "PropertyDefault", collection, LoggerFactory); MethodHelpers.FindAndRemoveHideMethod(reflector, facets, type, MethodType.Object, capitalizedName, collection, LoggerFactory); FacetUtils.AddFacets(facets); return(metamodel); }
public override void ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder) { var facets = new List <IFacet>(); var param = holder as ActionParameterSpecImmutable; if (param != null) { string name = method.GetParameters()[paramNum].Name; INamedFacet namedFacet = name == null ? (INamedFacet) new NamedFacetNone(holder) : new NamedFacetInferred(NameUtils.NaturalName(name), holder); facets.Add(namedFacet); facets.Add(new DescribedAsFacetNone(holder)); facets.Add(new MultiLineFacetNone(holder)); facets.Add(new MaxLengthFacetZero(holder)); facets.Add(new TypicalLengthFacetZero(holder)); DefaultTypicalLength(facets, param.Specification, param); } FacetUtils.AddFacets(facets); }
public override IImmutableDictionary <string, ITypeSpecBuilder> ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) { var facets = new List <IFacet>(); var param = holder as IActionParameterSpecImmutable; if (param != null) { string name = method.GetParameters()[paramNum].Name ?? method.GetParameters()[paramNum].ParameterType.FullName; INamedFacet namedFacet = new NamedFacetInferred(name, holder); facets.Add(namedFacet); facets.Add(new DescribedAsFacetNone(holder)); facets.Add(new MultiLineFacetNone(holder)); facets.Add(new MaxLengthFacetZero(holder)); facets.Add(new TypicalLengthFacetZero(holder)); DefaultTypicalLength(facets, param.Specification, param); } FacetUtils.AddFacets(facets); return(metamodel); }
public override void ProcessParams(IReflector reflector, MethodInfo method, int paramNum, ISpecificationBuilder holder) { ParameterInfo parameter = method.GetParameters()[paramNum]; var facets = new List <IFacet>(); if (parameter.ParameterType.IsGenericType && (parameter.ParameterType.GetGenericTypeDefinition() == typeof(Nullable <>))) { facets.Add(new NullableFacetAlways(holder)); } var returnSpec = reflector.LoadSpecification <IObjectSpecBuilder>(parameter.ParameterType); if (returnSpec != null && returnSpec.IsCollection) { Type elementType = CollectionUtils.ElementType(parameter.ParameterType); var elementSpec = reflector.LoadSpecification <IObjectSpecImmutable>(elementType); facets.Add(new ElementTypeFacet(holder, elementType, elementSpec)); } FacetUtils.AddFacets(facets); }
public override void Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification) { var facets = new List <IFacet>(); var namedFacet = specification.GetFacet <INamedFacet>(); if (namedFacet == null) { namedFacet = new NamedFacetInferred(type.Name, specification); facets.Add(namedFacet); } var pluralFacet = specification.GetFacet <IPluralFacet>(); if (pluralFacet == null) { string pluralName = NameUtils.PluralName(namedFacet.NaturalName); pluralFacet = new PluralFacetInferred(pluralName, specification); facets.Add(pluralFacet); } FacetUtils.AddFacets(facets); }
public override IImmutableDictionary <string, ITypeSpecBuilder> Process(IReflector reflector, Type type, IMethodRemover methodRemover, ISpecificationBuilder specification, IImmutableDictionary <string, ITypeSpecBuilder> metamodel) { var facets = new List <IFacet>(); var namedFacet = specification.GetFacet <INamedFacet>(); if (namedFacet == null) { namedFacet = new NamedFacetInferred(type.Name, specification); facets.Add(namedFacet); } var pluralFacet = specification.GetFacet <IPluralFacet>(); if (pluralFacet == null) { string pluralName = NameUtils.PluralName(namedFacet.NaturalName); pluralFacet = new PluralFacetInferred(pluralName, specification); facets.Add(pluralFacet); } FacetUtils.AddFacets(facets); return(metamodel); }
private static void Process(ISpecification holder) { var facets = new List <IFacet>(); if (holder is MemberSpecImmutable) { facets.Add(new NamedFacetNone(holder)); facets.Add(new DescribedAsFacetNone(holder)); } if (holder is AssociationSpecImmutable) { facets.Add(new ImmutableFacetNever(holder)); facets.Add(new PropertyDefaultFacetNone(holder)); facets.Add(new PropertyValidateFacetNone(holder)); } var immutable = holder as OneToOneAssociationSpecImmutable; if (immutable != null) { OneToOneAssociationSpecImmutable association = immutable; facets.Add(new MaxLengthFacetZero(holder)); DefaultTypicalLength(facets, association.ReturnSpec, immutable); facets.Add(new MultiLineFacetNone(holder)); } if (holder is ActionSpecImmutable) { facets.Add(new ExecutedFacetDefault(holder)); facets.Add(new ActionDefaultsFacetNone(holder)); facets.Add(new ActionChoicesFacetNone(holder)); facets.Add(new PageSizeFacetDefault(holder)); } FacetUtils.AddFacets(facets); }
public override void Process(IReflector reflector, Type type, IMethodRemover remover, ISpecificationBuilder specification) { var facets = new List <IFacet>(); var methods = new List <MethodInfo>(); var method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.CreatedMethod, typeof(void), Type.EmptyTypes); if (method != null) { methods.Add(method); facets.Add(new CreatedCallbackFacetViaMethod(method, specification)); } else { facets.Add(new CreatedCallbackFacetNull(specification)); } method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.PersistingMethod, typeof(void), Type.EmptyTypes); if (method != null) { methods.Add(method); facets.Add(new PersistingCallbackFacetViaMethod(method, specification)); } else { facets.Add(new PersistingCallbackFacetNull(specification)); } method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.PersistedMethod, typeof(void), Type.EmptyTypes); if (method != null) { methods.Add(method); facets.Add(new PersistedCallbackFacetViaMethod(method, specification)); } else { facets.Add(new PersistedCallbackFacetNull(specification)); } method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.UpdatingMethod, typeof(void), Type.EmptyTypes); if (method != null) { methods.Add(method); facets.Add(new UpdatingCallbackFacetViaMethod(method, specification)); } else { facets.Add(new UpdatingCallbackFacetNull(specification)); } method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.UpdatedMethod, typeof(void), Type.EmptyTypes); if (method != null) { methods.Add(method); facets.Add(new UpdatedCallbackFacetViaMethod(method, specification)); } else { facets.Add(new UpdatedCallbackFacetNull(specification)); } method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.LoadingMethod, typeof(void), Type.EmptyTypes); if (method != null) { methods.Add(method); facets.Add(new LoadingCallbackFacetViaMethod(method, specification)); } else { facets.Add(new LoadingCallbackFacetNull(specification)); } method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.LoadedMethod, typeof(void), Type.EmptyTypes); if (method != null) { methods.Add(method); facets.Add(new LoadedCallbackFacetViaMethod(method, specification)); } else { facets.Add(new LoadedCallbackFacetNull(specification)); } method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.DeletingMethod, typeof(void), Type.EmptyTypes); if (method != null) { methods.Add(method); facets.Add(new DeletingCallbackFacetViaMethod(method, specification)); } else { facets.Add(new DeletingCallbackFacetNull(specification)); } method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.DeletedMethod, typeof(void), Type.EmptyTypes); if (method != null) { methods.Add(method); facets.Add(new DeletedCallbackFacetViaMethod(method, specification)); } else { facets.Add(new DeletedCallbackFacetNull(specification)); } method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.OnUpdatingErrorMethod, typeof(string), new[] { typeof(Exception) }); if (method != null) { methods.Add(method); facets.Add(new OnUpdatingErrorCallbackFacetViaMethod(method, specification, Logger <OnUpdatingErrorCallbackFacetViaMethod>())); } else { facets.Add(new OnUpdatingErrorCallbackFacetNull(specification)); } method = FindMethod(reflector, type, MethodType.Object, RecognisedMethodsAndPrefixes.OnPersistingErrorMethod, typeof(string), new[] { typeof(Exception) }); if (method != null) { methods.Add(method); facets.Add(new OnPersistingErrorCallbackFacetViaMethod(method, specification, Logger <OnPersistingErrorCallbackFacetViaMethod>())); } else { facets.Add(new OnPersistingErrorCallbackFacetNull(specification)); } remover.RemoveMethods(methods); FacetUtils.AddFacets(facets); }