public void Analyze <TItem>(EngineImplementations <TItem> implementations, IdentifierDefinition definition)
where TItem : class
{
var factory = new IdentifierFactory <TItem>(definition);
implementations.IdentifierFactories.Add(definition.IdentifierName, factory);
}
public void IncludeDefinition_IncludeGetterExpr_AddsFactories()
{
var implementations = new EngineImplementations <Person>();
var analyzer = new SubstemDefinitionAnalyzer();
Expression <Func <Person, IEnumerable <Person> > > nameExpr = p => p.Friends;
var definition = new FieldDefinition
{
FieldName = "friends",
SubstemType = typeof(PeopleStem),
Getter = { Expression = nameExpr }
};
analyzer.Analyze(implementations, definition);
Assert.Equal(1, implementations.FullResourceFactories.Count);
Assert.Equal(1, implementations.ReaderFactories.Count);
Assert.Equal(1, implementations.WriterFactories.Count);
//var reader = implementations.ReaderFactories.First().Value.Get(null);
//var body = reader.GetSelectExpression(nameExpr.Parameters[0]);
//Assert.Equal(nameExpr.ResourceBody, body);
}
public void Analyze(EngineImplementations <TItem> implementations, StemDefinition stemDefinition)
{
foreach (FieldDefinition definition in stemDefinition.FieldDefinitions.Values)
{
foreach (IDefinitionAnalyzer <FieldDefinition> analyzer in _analyzers.FieldAnalyzers)
{
try
{
analyzer.Analyze(implementations, definition);
}
catch (Exception ex)
{
throw new StemAttributeSetupException("Error setting up the '" + definition.FieldName + "' field with " + analyzer.GetType().Name + ".", ex);
}
}
}
foreach (IdentifierDefinition definition in stemDefinition.IdentifierDefinitions.Values)
{
foreach (IDefinitionAnalyzer <IdentifierDefinition> analyzer in _analyzers.IdentifierAnalyzers)
{
try
{
analyzer.Analyze(implementations, definition);
}
catch (Exception ex)
{
throw new StemAttributeSetupException("Error setting up the '" + definition.IdentifierName + "' identifier with " + analyzer.GetType().Name + ".", ex);
}
}
}
}
public void Analyze <TItem>(EngineImplementations <TItem> implementations, FieldDefinition definition)
where TItem : class
{
if (definition.AuthorizePredicate == null)
{
return;
}
implementations.AuthorizePredicates.Add(definition.FieldName, definition.AuthorizePredicate);
}
public void Analyze <TItem>(EngineImplementations <TItem> implementations, FieldDefinition definition)
where TItem : class
{
if (definition.Description == null)
{
return;
}
var description = new AttributeFieldDescription(definition.Description);
implementations.Descriptions.Add(definition.FieldName, description);
}
public void Analyze <TItem>(EngineImplementations <TItem> implementations, FieldDefinition definition)
where TItem : class
{
if (definition.SubstemType != null)
{
return; // handled by the SubstemDefinitionResolver instead
}
if (definition.Getter.GetInstanceMethod != null)
{
return; // handled by the RuntimeMethodDefinitionResolver instead
}
if (definition.Getter.Expression != null)
{
try
{
IncludeGetterExpression(implementations, definition);
}
catch (Exception ex)
{
throw new StemAttributeSetupException("Unable create a reader from getter expression "
+ definition.FieldName, ex);
}
}
if (definition.Setter.Expression != null)
{
try
{
IncludeSetterExpression(implementations, definition);
}
catch (Exception ex)
{
throw new StemAttributeSetupException("Unable create a writer from setter expression "
+ definition.FieldName, ex);
}
}
if (definition.Locator.Expression != null)
{
try
{
IncludeLocatorExpression(implementations, definition);
}
catch (Exception ex)
{
throw new StemAttributeSetupException("Unable create a locator from expression "
+ definition.FieldName, ex);
}
}
}
public void DisplayUnspecifiedAndNameId_AppearsInNested()
{
var definition = new FieldDefinition
{
FieldName = "Id"
};
var analyzer = new DisplayNestingAnalyzer();
var implementations = new EngineImplementations <Artist>();
analyzer.Analyze(implementations, definition);
Assert.Contains("Id", implementations.Defaults[Display.Nested]);
}
public void DisplayUnspecifiedAndNameNotId_DoesNotAppearInNested()
{
var definition = new FieldDefinition
{
FieldName = "Test"
};
var analyzer = new DisplayNestingAnalyzer();
var implementations = new EngineImplementations <Artist>();
analyzer.Analyze(implementations, definition);
Assert.DoesNotContain(Display.Nested, implementations.Defaults.Keys);
}
public void DisplayNestedMany_AppearsInFullItem()
{
var definition = new FieldDefinition
{
FieldName = "Test",
Display = Display.NestedMany
};
var analyzer = new DisplayNestingAnalyzer();
var implementations = new EngineImplementations <Artist>();
analyzer.Analyze(implementations, definition);
Assert.Contains("Test", implementations.Defaults[Display.FullItem]);
}
private static void IncludeSetterExpression <TItem>(EngineImplementations <TItem> implementations, FieldDefinition definition)
where TItem : class
{
Type writerPropertyValueType =
ResolverTypeUtility.GetPropertyLambdaReturnType <TItem>(definition.Setter.Expression.GetType());
var writer = Reflect.Type(typeof(PropertyExpressionFieldWriter <,>))
.MakeGeneric(typeof(TItem), writerPropertyValueType)
.CastTo <IFieldWriter <TItem> >()
.CreateInstance(definition.Setter.Expression);
var writerFactory = new SingletonFactory <IFieldWriter <TItem>, TItem>(writer);
implementations.WriterFactories.Add(definition.FieldName, writerFactory);
}
public void DisplayHidden_DoesNotAppearInFullItem()
{
var definition = new FieldDefinition
{
FieldName = "Test",
Display = Display.Hidden
};
var analyzer = new DisplayNestingAnalyzer();
var implementations = new EngineImplementations <Artist>();
analyzer.Analyze(implementations, definition);
Assert.DoesNotContain(Display.FullItem, implementations.Defaults.Keys);
}
public void IncludeDefinition_NoGetterExpression_ThrowsSetupException()
{
var implementations = new EngineImplementations <Person>();
var resolver = new SubstemDefinitionAnalyzer();
var definition = new FieldDefinition
{
SubstemType = typeof(PeopleStem)
};
Action analyzeMethod = () => resolver.Analyze(implementations, definition);
Assert.ThrowsAny <StemAttributeSetupException>(analyzeMethod);
}
private void AnalyzeInternal <TItem>(ServiceCache serviceCache, Type stemType)
where TItem : class
{
var stemDefinition = new StemDefinition();
var attributeAnalyzer = new AttributeAnalyzer(_propertyAutoMapper);
attributeAnalyzer.Analyze(stemDefinition, stemType);
var implementations = new EngineImplementations <TItem>();
var definitionAnalyzer = new DefinitionAnalyzer <TItem>(_analyzers);
definitionAnalyzer.Analyze(implementations, stemDefinition);
serviceCache.Add(stemType, implementations);
}
private static void IncludeLocatorExpression <TItem>(EngineImplementations <TItem> implementations, FieldDefinition definition)
where TItem : class
{
Type locatorPropertyValueType =
ResolverTypeUtility.GetPropertyLambdaReturnType <TItem>(definition.Locator.Expression.GetType());
Debug.Assert(locatorPropertyValueType == definition.FieldType, "FieldType is incorrect");
var locator = Reflect.Type(typeof(IdentifierExpressionItemLocator <,>))
.MakeGeneric(typeof(TItem), locatorPropertyValueType)
.CastTo <IItemLocator <TItem> >()
.CreateInstance(definition.Locator.Expression);
var locatorFactory = new SingletonFactory <IItemLocator <TItem>, TItem>(locator);
implementations.LocatorFactories.Add(definition.FieldName, locatorFactory);
}
public void Analyze <TItem>(EngineImplementations <TItem> implementations, FieldDefinition definition)
where TItem : class
{
if (definition.SubstemType != null)
{
return; // handled by the SubstemDefinitionResolver instead
}
if (definition.Getter.GetInstanceMethod != null)
{
IFactory <IFieldReader <TItem>, TItem> factory;
if (definition.Getter.Expression != null)
{
var middleExpression = definition.Getter.Expression;
factory = Reflect.Type(typeof(InstanceMethodWithExpressionFieldReaderFactory <, ,>))
.MakeGeneric(typeof(TItem), middleExpression.ReturnType, definition.FieldType)
.CastTo <IFactory <IFieldReader <TItem>, TItem> >()
.CreateInstance(middleExpression, definition.Getter.GetInstanceMethod);
}
else
{
factory = Reflect.Type(typeof(InstanceMethodFieldReaderFactory <,>))
.MakeGeneric(typeof(TItem), definition.FieldType)
.CastTo <IFactory <IFieldReader <TItem>, TItem> >()
.CreateInstance(definition.Getter.GetInstanceMethod);
}
implementations.ReaderFactories.Add(definition.FieldName, factory);
implementations.CollatorFactories.Add(definition.FieldName, new BasicCollatorFactory <TItem>(factory));
}
if (definition.Setter.GetInstanceMethod != null)
{
Type setterType = typeof(ActionFieldWriterFactory <,>).MakeGenericType(typeof(TItem), definition.FieldType);
var setter = (IFactory <IFieldWriter <TItem>, TItem>)Activator.CreateInstance(setterType, definition.Setter.GetInstanceMethod);
implementations.WriterFactories.Add(definition.FieldName, setter);
}
if (definition.Locator.GetInstanceMethod != null)
{
var locatorFactory = new DelegateItemLocatorFactory <TItem>(definition.Locator.GetInstanceMethod);
implementations.LocatorFactories.Add(definition.FieldName, locatorFactory);
}
}
public void Analyze <TItem>(EngineImplementations <TItem> implementations, FieldDefinition definition)
where TItem : class
{
Dictionary <Display, List <string> > defaults = implementations.Defaults;
foreach (Display d in Enum.GetValues(typeof(Display)))
{
Display display = definition.Display ??
GetDefaultDisplayFromName(typeof(TItem).Name, definition.FieldName);
if (display >= d)
{
if (!defaults.ContainsKey(d))
{
defaults.Add(d, new List <string>());
}
defaults[d].Add(definition.FieldName);
}
}
}
public void Analyze <TItem>(EngineImplementations <TItem> implementations, FieldDefinition definition)
where TItem : class
{
if (definition.SubstemType == null)
{
return;
}
LambdaExpression getterExpression = definition.Getter.Expression;
if (getterExpression == null)
{
throw new StemAttributeSetupException("Substem types must be on an expression property.");
}
var typeArgs = new HandlerFactoryTypeArguments();
typeArgs.LoadExpression <TItem>(getterExpression);
AddFactory(implementations.FullResourceFactories, HandlerTypes.FullResource, typeArgs, definition);
AddFactory(implementations.ReaderFactories, HandlerTypes.Reader, typeArgs, definition);
AddFactory(implementations.WriterFactories, HandlerTypes.Writer, typeArgs, definition);
}
public AttributeFieldProvider(Stem <TItem> stem, EngineImplementations <TItem> implementations)
{
_stem = stem;
_implementations = implementations;
}
public StemAuthorizationChecker(Stem <TItem> stem, EngineImplementations <TItem> implementations)
{
_stem = stem;
_implementations = implementations;
}
