private Tuple<IObjectSpecImmutable, string, string> FindContributee(IObjectSpecImmutable spec) {
if (!IsContributedTo(spec)) {
throw new Exception("Action is not contributed to " + spec.Type);
}
Tuple<IObjectSpecImmutable, string, string> tuple = objectContributees.First(t => spec.IsOfType(t.Item1));
return tuple;
}
public bool IsContributedToLocalCollectionOf(IObjectSpecImmutable objectSpecImmutable, string id) {
var memberOrderFacet = GetFacet<IMemberOrderFacet>();
var directlyContributed = string.Equals(memberOrderFacet?.Name, id, StringComparison.CurrentCultureIgnoreCase);
return directlyContributed || Parameters.Any(parm => {
var facet = GetFacet<IContributedActionFacet>();
return facet != null && facet.IsContributedToLocalCollectionOf(objectSpecImmutable, id);
});
}
public ActionInvocationFacetViaMethod(MethodInfo method, ITypeSpecImmutable onType, IObjectSpecImmutable returnType, IObjectSpecImmutable elementType, ISpecification holder, bool isQueryOnly)
: base(holder) {
actionMethod = method;
paramCount = method.GetParameters().Length;
this.onType = onType;
this.returnType = returnType;
this.elementType = elementType;
this.isQueryOnly = isQueryOnly;
try {
actionDelegate = DelegateUtils.CreateDelegate(actionMethod);
}
catch (Exception e) {
Log.ErrorFormat("Failed to get Delegate for {0}:{1} reason {2}", onType, method, e.Message);
}
}
private static void AddCollectionContributedAction(IReflector reflector, MethodInfo member, IObjectSpecImmutable type, ParameterInfo p, ContributedActionFacet facet, ContributedActionAttribute attribute) {
if (!type.IsQueryable) {
Log.WarnFormat("ContributedAction attribute added to a collection parameter type other than IQueryable: {0}", member.Name);
}
else {
var returnType = reflector.LoadSpecification<IObjectSpecImmutable>(member.ReturnType);
if (returnType.IsCollection) {
Log.WarnFormat("ContributedAction attribute added to an action that returns a collection: {0}", member.Name);
}
else {
Type elementType = p.ParameterType.GetGenericArguments()[0];
type = reflector.LoadSpecification<IObjectSpecImmutable>(elementType);
facet.AddCollectionContributee(type, attribute.SubMenu, attribute.Id);
}
}
}
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));
}
IObjectSpecBuilder returnSpec = reflector.LoadSpecification(parameter.ParameterType);
if (returnSpec != null && returnSpec.IsCollection)
{
Type elementType = CollectionUtils.ElementType(parameter.ParameterType);
IObjectSpecImmutable elementSpec = reflector.LoadSpecification(elementType);
facets.Add(new ElementTypeFacet(holder, elementType, elementSpec));
}
FacetUtils.AddFacets(facets);
}
public IActionSpec GetAction(INakedObjectsFramework framework)
{
if (nakedObjectAction == null)
{
GetNakedObject(framework);
IActionSpec[] actions;
if (nakedObject.Spec.IsCollection)
{
var metamodel = framework.MetamodelManager.Metamodel;
IObjectSpecImmutable elementSpecImmut = nakedObject.Spec.GetFacet <ITypeOfFacet>().GetValueSpec(nakedObject, metamodel);
var elementSpec = framework.MetamodelManager.GetSpecification(elementSpecImmut) as IObjectSpec;
Trace.Assert(elementSpec != null);
actions = elementSpec.GetCollectionContributedActions();
}
else
{
actions = nakedObject.Spec.GetObjectActions();
}
nakedObjectAction = actions.Where(a => a.IsUsable(nakedObject).IsAllowed).Where(a => a.IsVisible(nakedObject)).SingleOrDefault(a => a.Id == ActionId);
}
return(nakedObjectAction);
}
public virtual void SetUp()
{
var cache = new ImmutableInMemorySpecCache();
ReflectorConfiguration.NoValidate = true;
var config = new ReflectorConfiguration(new[] { typeof(List <TestPoco>), typeof(ArrayList) }, new Type[] { }, new[] { typeof(TestPoco).Namespace });
var functionalReflectorConfiguration = new FunctionalReflectorConfiguration(new Type[] { }, new Type[] { });
var menuFactory = new NullMenuFactory();
var classStrategy = new DefaultClassStrategy(config);
var mockLogger = new Mock <ILogger <Metamodel> >().Object;
var metamodel = new Metamodel(classStrategy, cache, mockLogger);
var mockLogger1 = new Mock <ILogger <ParallelReflector> >().Object;
var mockLoggerFactory = new Mock <ILoggerFactory>().Object;
var reflector = new ParallelReflector(classStrategy, metamodel, config, functionalReflectorConfiguration, menuFactory, new IFacetDecorator[] { }, facetFactories, mockLoggerFactory, mockLogger1);
ITypeSpecBuilder spec;
(spec, Metamodel) = LoadSpecification(reflector);
Specification = spec as IObjectSpecImmutable;
}
public ITypedMenu <TObject> AddContributedActions()
{
IObjectSpecImmutable spec = GetObjectSpec <TObject>();
foreach (IActionSpecImmutable ca in spec.ContributedActions)
{
var facet = ca.GetFacet <IContributedActionFacet>();
string subMenuName = facet.SubMenuWhenContributedTo(spec);
if (subMenuName != null)
{
string id = facet.IdWhenContributedTo(spec);
MenuImpl subMenu = GetSubMenuIfExists(subMenuName) ?? CreateMenuImmutableAsSubMenu(subMenuName, id);
subMenu.AddOrderableElementsToMenu(new List <IActionSpecImmutable> {
ca
}, subMenu);
}
else
{
//i.e. no sub-menu
AddMenuItem(new MenuAction(ca));
}
}
return(this);
}
public string IdWhenContributedTo(IObjectSpecImmutable spec)
{
return(FindContributee(spec).Item3);
}
public bool IsContributedTo(IObjectSpecImmutable spec)
{
return(objectContributees.Select(t => t.Item1).Any(spec.IsOfType));
}
public bool IsContributedToLocalCollectionOf(IObjectSpecImmutable spec, string id)
{
return(localCollectionContributees.Where(t => t.Item2 == id.ToLower()).Select(t => t.Item1).Any(spec.IsOfType));
}
// The special constructor is used to deserialize values.
public ActionSpecImmutable(SerializationInfo info, StreamingContext context) : base(info, context)
{
ownerSpec = info.GetValue <IObjectSpecImmutable>("specification");
parameters = info.GetValue <IActionParameterSpecImmutable[]>("parameters");
}
public OneToOneAssociationSpecImmutable(IIdentifier identifier, IObjectSpecImmutable ownerSpec, IObjectSpecImmutable returnSpec)
: base(identifier, returnSpec) {
this.ownerSpec = ownerSpec;
}
// The special constructor is used to deserialize values.
public ActionParameterSpecImmutable(SerializationInfo info, StreamingContext context) : base(info, context) {
specification = info.GetValue<IObjectSpecImmutable>("specification");
}
// The special constructor is used to deserialize values.
protected AssociationSpecImmutable(SerializationInfo info, StreamingContext context) : base(info, context)
{
returnSpec = info.GetValue <IObjectSpecImmutable>("returnSpec");
}
public static bool IsCollectionOfBoundedSet(this IObjectSpecImmutable specification, IObjectSpecImmutable elementSpec)
{
return(specification.IsCollection && elementSpec.IsBoundedSet());
}
public UIntValueSemanticsProvider(IObjectSpecImmutable spec, ISpecification holder)
: base(Type, holder, AdaptedType, TypicalLengthConst, Immutable, EqualByContent, DefaultValueConst, spec)
{
}
public ObjectSpec(SpecFactory memberFactory, IMetamodelManager metamodelManager, INakedObjectManager nakedObjectManager, IObjectSpecImmutable innerSpec) :
base(memberFactory, metamodelManager, nakedObjectManager, innerSpec) {}
public OneToManyAssociationSpecImmutable(IIdentifier name, IObjectSpecImmutable ownerSpec, IObjectSpecImmutable returnSpec, IObjectSpecImmutable defaultElementSpec)
: base(name, returnSpec) {
defaultElementType = defaultElementSpec.Type;
this.ownerSpec = ownerSpec;
this.defaultElementSpec = defaultElementSpec;
}
public IObjectSpec GetSpecification(IObjectSpecImmutable spec) {
return GetSpecification(spec as ITypeSpecImmutable) as IObjectSpec;
}
private IObjectSpec CreateObjectSpec(IObjectSpecImmutable specImmutable) {
Assert.AssertNotNull(framework);
return new ObjectSpec(this, framework.MetamodelManager, framework.NakedObjectManager, specImmutable);
}
private bool IsContributedTo(IObjectSpecImmutable parmSpec, IObjectSpecImmutable contributeeSpec) {
var facet = GetFacet<IContributedActionFacet>();
return facet != null && (contributeeSpec.IsOfType(parmSpec) && facet.IsContributedTo(contributeeSpec));
}
public void AddLocalCollectionContributee(IObjectSpecImmutable type, string id)
{
localCollectionContributees.Add(new Tuple <IObjectSpecImmutable, string>(type, id.ToLower()));
}
public bool IsContributedToCollectionOf(IObjectSpecImmutable objectSpecImmutable) {
return Parameters.Any(parm => {
var facet = GetFacet<IContributedActionFacet>();
return facet != null && facet.IsContributedToCollectionOf(objectSpecImmutable);
});
}
// The special constructor is used to deserialize values.
public OneToManyAssociationSpecImmutable(SerializationInfo info, StreamingContext context) : base(info, context) {
defaultElementType = info.GetValue<Type>("defaultElementType");
defaultElementSpec = info.GetValue<IObjectSpecImmutable>("defaultElementSpec");
}
public ActionParameterSpecImmutable(IObjectSpecImmutable specification, IIdentifier identifier) {
this.specification = specification;
this.identifier = identifier;
}
public OneToOneAssociationSpecImmutable(IIdentifier identifier, IObjectSpecImmutable ownerSpec, IObjectSpecImmutable returnSpec)
: base(identifier, returnSpec)
{
this.ownerSpec = ownerSpec;
}
public bool IsContributedTo(IObjectSpecImmutable spec) {
return objectContributees.Select(t => t.Item1).Any(spec.IsOfType);
}
public bool IsContributedTo(IObjectSpecImmutable objectSpecImmutable) {
return Parameters.Any(parm => IsContributedTo(parm.Specification, objectSpecImmutable));
}
public bool IsContributedToCollectionOf(IObjectSpecImmutable spec) {
return collectionContributees.Select(t => t.Item1).Any(spec.IsOfType);
}
protected AssociationSpecImmutable(IIdentifier identifier, IObjectSpecImmutable returnSpec)
: base(identifier)
{
this.returnSpec = returnSpec;
}
public string SubMenuWhenContributedTo(IObjectSpecImmutable spec) {
return FindContributee(spec).Item2;
}
private IEnumerable <IAssociationSpecImmutable> CreateCollectionSpecs(IEnumerable <PropertyInfo> collectionProperties, IObjectSpecImmutable spec)
{
var specs = new List <IAssociationSpecImmutable>();
foreach (PropertyInfo property in collectionProperties)
{
IIdentifier identifier = new IdentifierImpl(FullName, property.Name);
// create a collection property spec
Type returnType = property.PropertyType;
var returnSpec = reflector.LoadSpecification <IObjectSpecImmutable>(returnType);
Type defaultType = typeof(object);
var defaultSpec = reflector.LoadSpecification <IObjectSpecImmutable>(defaultType);
var collection = ImmutableSpecFactory.CreateOneToManyAssociationSpecImmutable(identifier, spec, returnSpec, defaultSpec);
FacetFactorySet.Process(reflector, property, new IntrospectorMethodRemover(methods), collection, FeatureType.Collections);
specs.Add(collection);
}
return(specs);
}
public string IdWhenContributedTo(IObjectSpecImmutable spec) {
return FindContributee(spec).Item3;
}
public bool IsContributedTo(IObjectSpecImmutable objectSpecImmutable)
{
return(Parameters.Any(parm => IsContributedTo(parm.Specification, objectSpecImmutable)));
}
//Here the type is the ElementType of the collection, not the type of collection.
public void AddCollectionContributee(IObjectSpecImmutable type, string subMenu, string id) {
collectionContributees.Add(new Tuple<IObjectSpecImmutable, string, string>(type, subMenu, id));
}
public virtual void Cache(string key, IObjectSpecImmutable spec)
{
specs = specs.Add(key, spec);
}
public static IActionParameterSpecImmutable CreateActionParameterSpecImmutable(IObjectSpecImmutable spec, IIdentifier identifier) {
return new ActionParameterSpecImmutable(spec, identifier);
}
public bool IsContributedToCollectionOf(IObjectSpecImmutable spec)
{
return(collectionContributees.Select(t => t.Item1).Any(spec.IsOfType));
}
public static IOneToManyAssociationSpecImmutable CreateOneToManyAssociationSpecImmutable(IIdentifier identifier, IObjectSpecImmutable ownerSpec, IObjectSpecImmutable returnSpec, IObjectSpecImmutable defaultElementSpec) {
return new OneToManyAssociationSpecImmutable(identifier, ownerSpec, returnSpec, defaultElementSpec);
}
public string SubMenuWhenContributedTo(IObjectSpecImmutable spec)
{
return(FindContributee(spec).Item2);
}
public static IOneToOneAssociationSpecImmutable CreateOneToOneAssociationSpecImmutable(IIdentifier identifier, IObjectSpecImmutable ownerSpec, IObjectSpecImmutable returnSpec) {
return new OneToOneAssociationSpecImmutable(identifier, ownerSpec, returnSpec);
}
//Here the type is the ElementType of the collection, not the type of collection.
public void AddCollectionContributee(IObjectSpecImmutable type, string subMenu, string id)
{
collectionContributees.Add(new Tuple <IObjectSpecImmutable, string, string>(type, subMenu, id));
}
public TypeOfFacetDefaultToType(ISpecification holder, Type type, IObjectSpecImmutable spec)
: base(Type, holder) {
this.type = type;
this.spec = spec;
}
private IObjectSpec CreateObjectSpec(IObjectSpecImmutable specImmutable)
{
Assert.AssertNotNull(framework);
return(new ObjectSpec(this, framework.MetamodelManager, framework.NakedObjectManager, specImmutable));
}
public ElementTypeFacet(ISpecification holder, Type type, IObjectSpecImmutable spec) : base(Type, holder) {
this.type = type;
this.spec = spec;
}
public static bool IsBoundedSet(this IObjectSpecImmutable specification)
{
return(specification.ContainsFacet <IBoundedFacet>() || specification.ContainsFacet <IEnumValueFacet>());
}
public ObjectSpec(SpecFactory memberFactory, IMetamodelManager metamodelManager, INakedObjectManager nakedObjectManager, IObjectSpecImmutable innerSpec) :
base(memberFactory, metamodelManager, nakedObjectManager, innerSpec)
{
}
public static bool IsCollectionOfEnum(this IObjectSpecImmutable specification, IObjectSpecImmutable elementSpec)
{
return(specification.IsCollection && elementSpec.ContainsFacet <IEnumFacet>());
}
private Tuple <IAssociationSpecImmutable[], IImmutableDictionary <string, ITypeSpecBuilder> > FindAndCreateFieldSpecs(IObjectSpecImmutable spec, IImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
// now create fieldSpecs for value properties, for collections and for reference properties
IList <PropertyInfo> collectionProperties = FacetFactorySet.FindCollectionProperties(properties, ClassStrategy).Where(pi => !FacetFactorySet.Filters(pi, ClassStrategy)).ToArray();
var result1 = CreateCollectionSpecs(collectionProperties, spec, metamodel);
IEnumerable <IAssociationSpecImmutable> collectionSpecs = result1.Item1;
metamodel = result1.Item2;
// every other accessor is assumed to be a reference property.
IList <PropertyInfo> allProperties = FacetFactorySet.FindProperties(properties, ClassStrategy).Where(pi => !FacetFactorySet.Filters(pi, ClassStrategy)).ToArray();
IEnumerable <PropertyInfo> refProperties = allProperties.Except(collectionProperties);
var result = CreateRefPropertySpecs(refProperties, spec, metamodel);
var refSpecs = result.Item1;
metamodel = result.Item2;
return(new Tuple <IAssociationSpecImmutable[], IImmutableDictionary <string, ITypeSpecBuilder> >(collectionSpecs.Union(refSpecs).ToArray(), metamodel));
}
public ITypeSpec GetSpecification(IObjectSpecImmutable spec)
{
return(spec == null ? null : NewObjectSpec(spec));
}
/// <summary>
/// Creates a list of Association fields for all the properties that use NakedObjects.
/// </summary>
private Tuple <IEnumerable <IAssociationSpecImmutable>, IImmutableDictionary <string, ITypeSpecBuilder> > CreateRefPropertySpecs(IEnumerable <PropertyInfo> foundProperties, IObjectSpecImmutable spec, IImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
var specs = new List <IAssociationSpecImmutable>();
foreach (PropertyInfo property in foundProperties)
{
// create a reference property spec
var identifier = new IdentifierImpl(FullName, property.Name);
Type propertyType = property.PropertyType;
var result = reflector.LoadSpecification(propertyType, metamodel);
metamodel = result.Item2;
var propertySpec = result.Item1;
if (propertySpec is IServiceSpecImmutable)
{
throw new ReflectionException(Log.LogAndReturn($"Type {propertyType.Name} is a service and cannot be used in public property {property.Name} on type {property.DeclaringType?.Name}. If the property is intended to be an injected service it should have a protected get."));
}
var referenceProperty = ImmutableSpecFactory.CreateOneToOneAssociationSpecImmutable(identifier, spec, propertySpec as IObjectSpecImmutable);
// Process facets for the property
metamodel = FacetFactorySet.Process(reflector, property, new IntrospectorMethodRemover(methods), referenceProperty, FeatureType.Properties, metamodel);
specs.Add(referenceProperty);
}
return(new Tuple <IEnumerable <IAssociationSpecImmutable>, IImmutableDictionary <string, ITypeSpecBuilder> >(specs, metamodel));
}
protected AssociationSpecImmutable(IIdentifier identifier, IObjectSpecImmutable returnSpec)
: base(identifier) {
this.returnSpec = returnSpec;
}
public bool IsFinderMethodFor(IObjectSpecImmutable spec) {
return IsFinderMethod && (ReturnSpec.IsOfType(spec) || (ReturnSpec.IsCollection && ElementSpec.IsOfType(spec)));
}
public ElementTypeFacet(ISpecification holder, Type type, IObjectSpecImmutable spec) : base(Type, holder)
{
this.type = type;
this.spec = spec;
}
// The special constructor is used to deserialize values.
protected AssociationSpecImmutable(SerializationInfo info, StreamingContext context) : base(info, context) {
returnSpec = info.GetValue<IObjectSpecImmutable>("returnSpec");
}
private Tuple <IEnumerable <IAssociationSpecImmutable>, IImmutableDictionary <string, ITypeSpecBuilder> > CreateCollectionSpecs(IEnumerable <PropertyInfo> collectionProperties, IObjectSpecImmutable spec, IImmutableDictionary <string, ITypeSpecBuilder> metamodel)
{
var specs = new List <IAssociationSpecImmutable>();
foreach (PropertyInfo property in collectionProperties)
{
IIdentifier identifier = new IdentifierImpl(FullName, property.Name);
// create a collection property spec
Type returnType = property.PropertyType;
Type defaultType = typeof(object);
var result = reflector.LoadSpecification(returnType, metamodel);
metamodel = result.Item2;
var returnSpec = result.Item1 as IObjectSpecImmutable;
result = reflector.LoadSpecification(defaultType, metamodel);
metamodel = result.Item2;
var defaultSpec = result.Item1 as IObjectSpecImmutable;
var collection = ImmutableSpecFactory.CreateOneToManyAssociationSpecImmutable(identifier, spec, returnSpec, defaultSpec);
metamodel = FacetFactorySet.Process(reflector, property, new IntrospectorMethodRemover(methods), collection, FeatureType.Collections, metamodel);
specs.Add(collection);
}
return(new Tuple <IEnumerable <IAssociationSpecImmutable>, IImmutableDictionary <string, ITypeSpecBuilder> >(specs, metamodel));
}
public static bool IsCollectionOfBoundedSet(this IObjectSpecImmutable specification, IObjectSpecImmutable elementSpec) {
return specification.IsCollection && elementSpec.IsBoundedSet();
}
public TypeOfFacetDefaultToType(ISpecification holder, Type type, IObjectSpecImmutable spec)
: base(Type, holder)
{
this.type = type;
this.spec = spec;
}
public static bool IsCollectionOfEnum(this IObjectSpecImmutable specification, IObjectSpecImmutable elementSpec) {
return specification.IsCollection && elementSpec.ContainsFacet<IEnumFacet>();
}
