protected override object CreateInstance(Type type, string prefix, Node node)
{
var compositeNode = node as CompositeNode;
if (compositeNode != null)
{
var leafNode = compositeNode.GetChildNode(_idProperty) as LeafNode;
if (leafNode != null)
{
Type idType = type.GetProperty(_idProperty).PropertyType;
TypeConverter converter = TypeDescriptor.GetConverter(idType);
if (converter.IsValid(leafNode.Value))
{
object id = converter.ConvertFrom(leafNode.Value);
var sessionFactory = Global.container.Resolve<ISessionFactory>();
using (IStatelessSession session = sessionFactory.OpenStatelessSession())
{
//het is onwenselijk dat wijzigingen zonder inspectie in de database komen, daarom gebruiken we een stateless session
object instance = session.Get(type.FullName, id);
if (instance != null)
{
return instance;
}
}
}
}
}
return base.CreateInstance(type, prefix, node);
}
public void AddChildNode(Node node)
{
if (node == null) throw new ArgumentNullException("node");
name2Node[node.Name] = node;
nodeList.Add(node);
node.Parent = this;
}
private object ConvertFlatNodesToArray(Type desiredType, Node[] nodes, out bool conversionSucceeded)
{
Type arrayElemType = desiredType.GetElementType();
ArrayList validItems = ConvertFlatNodesToList(arrayElemType, nodes, out conversionSucceeded);
return conversionSucceeded ? validItems.ToArray(arrayElemType) : Array.CreateInstance(arrayElemType, 0);
}
private object ConvertToArray(Type desiredType, String key, Node node, out bool conversionSucceeded)
{
Type elemType = desiredType.GetElementType();
if (node == null)
{
conversionSucceeded = false;
return Array.CreateInstance(elemType, 0);
}
else if (node.NodeType == NodeType.Leaf)
{
LeafNode leafNode = node as LeafNode;
return Converter.Convert(desiredType, leafNode.ValueType, leafNode.Value, out conversionSucceeded);
}
else if (node.NodeType == NodeType.Indexed)
{
IndexedNode indexedNode = node as IndexedNode;
if (IsSimpleProperty(elemType))
{
return ConvertFlatNodesToArray(desiredType, indexedNode.ChildNodes, out conversionSucceeded);
}
else
{
return ConvertComplexNodesToArray(desiredType, indexedNode, out conversionSucceeded);
}
}
else
{
throw new BindingException("Could not convert param to array as the node related " +
"to the param is not a leaf node nor an indexed node. Key {0}", key);
}
}
/// <summary>
/// Implementations will bound the instance itself.
/// <seealso cref="IsSpecialType"/>
/// </summary>
/// <remarks>
/// <seealso cref="IsSpecialType"/>
/// </remarks>
/// <param name="instanceType"></param>
/// <param name="prefix"></param>
/// <param name="node"></param>
/// <param name="succeeded"></param>
protected virtual object BindSpecialObjectInstance(Type instanceType, String prefix,
Node node, out bool succeeded)
{
succeeded = false;
return null;
}
protected virtual bool PerformCustomBinding(object instance, string prefix, Node node)
{
return false;
}
protected override object BindSpecialObjectInstance(Type instanceType, string prefix, Node node,
out bool succeeded)
{
succeeded = false;
var model = CurrentARModel;
if (model == null)
{
return null;
}
var container = CreateContainer(instanceType);
Type targetType = null;
ActiveRecordModel targetModel = null;
var found = FindPropertyInHasAndBelongsToMany(model, prefix, ref targetType, ref targetModel);
if (!found)
{
found = FindPropertyInHasMany(model, prefix, ref targetType, ref targetModel);
}
if (found)
{
succeeded = true;
ClearContainer(container);
if (node.NodeType == NodeType.Indexed)
{
var indexNode = (IndexedNode) node;
var collArray = Array.CreateInstance(targetType, indexNode.ChildrenCount);
collArray = (Array) InternalBindObject(collArray.GetType(), prefix, node);
foreach(var item in collArray)
{
AddToContainer(container, item);
}
}
else if (node.NodeType == NodeType.Leaf)
{
var pkModel = targetModel.PrimaryKey;
var pkType = pkModel.Property.PropertyType;
var leafNode = (LeafNode) node;
bool convSucceeded;
if (leafNode.IsArray) // Multiples values found
{
foreach(var element in (Array) leafNode.Value)
{
var keyConverted = Converter.Convert(pkType, leafNode.ValueType.GetElementType(),
element, out convSucceeded);
if (convSucceeded)
{
var item = FindByPrimaryKey(targetType, keyConverted);
AddToContainer(container, item);
}
}
}
else // Single value found
{
var keyConverted = Converter.Convert(pkType, leafNode.ValueType.GetElementType(),
leafNode.Value, out convSucceeded);
if (convSucceeded)
{
var item = FindByPrimaryKey(targetType, keyConverted);
AddToContainer(container, item);
}
}
}
}
return container;
}
private object RelaxedConvertLeafNode(Type desiredType, Node node, object defaultValue)
{
if (node == null)
{
return defaultValue;
}
if (node.NodeType != NodeType.Leaf)
{
throw new BindingException("Expected LeafNode, found {0} named {1}", node.NodeType, node.Name);
}
bool conversionSucceeded;
object result = ConvertLeafNode(desiredType, (LeafNode) node, out conversionSucceeded);
return conversionSucceeded ? result : defaultValue;
}
private object InternalBindGenericList(Type instanceType, string paramPrefix, Node node, out bool succeeded)
{
succeeded = false;
if (node == null)
{
return CreateInstance(instanceType, paramPrefix, node);
}
return ConvertToGenericList(instanceType, paramPrefix, node, out succeeded);
}
private object InternalBindObjectArray(Type instanceType, String paramPrefix, Node node, out bool succeeded)
{
succeeded = false;
if (node == null)
{
return Array.CreateInstance(instanceType.GetElementType(), 0);
}
return ConvertToArray(instanceType, paramPrefix, node, out succeeded);
}
protected void InternalRecursiveBindObjectInstance(object instance, String prefix, Node node)
{
if (node == null)
{
return;
}
if (node.NodeType != NodeType.Composite && node.NodeType != NodeType.Indexed)
{
throw new BindingException(
"Non-composite node passed to InternalRecursiveBindObjectInstance while binding {0} with prefix {1}", instance,
prefix);
}
InternalRecursiveBindObjectInstance(instance, prefix, (CompositeNode) node);
}
protected object InternalBindObject(Type instanceType, String paramPrefix, Node node, out bool succeeded)
{
succeeded = false;
if (IsSpecialType(instanceType))
{
return BindSpecialObjectInstance(instanceType, paramPrefix, node, out succeeded);
}
if (ShouldIgnoreType(instanceType))
{
return null;
}
if (instanceType.IsArray)
{
return InternalBindObjectArray(instanceType, paramPrefix, node, out succeeded);
}
else if (IsGenericList(instanceType))
{
return InternalBindGenericList(instanceType, paramPrefix, node, out succeeded);
}
else
{
succeeded = true;
object instance = CreateInstance(instanceType, paramPrefix, node);
InternalRecursiveBindObjectInstance(instance, paramPrefix, node);
return instance;
}
}
protected object InternalBindObject(Type instanceType, String paramPrefix, Node node)
{
bool succeeded;
return InternalBindObject(instanceType, paramPrefix, node, out succeeded);
}
protected override bool ShouldRecreateInstance(object value, Type type, string prefix, Node node)
{
var compositeNode = node as CompositeNode;
if (compositeNode != null)
{
var leafNode = compositeNode.GetChildNode(_idProperty) as LeafNode;
if (leafNode != null)
{
//ook als de id niet veranderd, dan halen we het object opnieuw op, want de parent is stateless opgehaald.
return true;
}
}
return base.ShouldRecreateInstance(value, type, prefix, node);
}
private ArrayList ConvertFlatNodesToList(Type elemType, Node[] nodes, out bool conversionSucceeded)
{
conversionSucceeded = true;
ArrayList validItems = new ArrayList();
foreach(Node node in nodes)
{
if (node.Name != String.Empty)
{
throw new BindingException("Unexpected non-flat node found: {0}", node.Name);
}
if (node.NodeType == NodeType.Leaf)
{
LeafNode lnode = node as LeafNode;
validItems.Add(ConvertLeafNode(elemType, lnode, out conversionSucceeded));
if (!conversionSucceeded)
{
break;
}
}
}
return validItems;
}
protected virtual object CreateInstance(Type instanceType, String paramPrefix, Node node)
{
return Activator.CreateInstance(instanceType);
}
private object ConvertToGenericList(Type desiredType, String key, Node node, out bool conversionSucceeded)
{
Type[] genericArgs = desiredType.GetGenericArguments();
if (genericArgs.Length == 0)
{
throw new BindingException("Can't infer the Generics placeholders (type parameters). Key {0}.", key);
}
Type elemType = genericArgs[0];
if (node == null)
{
conversionSucceeded = false;
return CreateInstance(desiredType, key, node);
}
else if (node.NodeType == NodeType.Leaf)
{
LeafNode leafNode = node as LeafNode;
return Converter.Convert(desiredType, leafNode.ValueType, leafNode.Value, out conversionSucceeded);
}
else if (node.NodeType == NodeType.Indexed)
{
IndexedNode indexedNode = node as IndexedNode;
IList convertedNodes;
if (IsSimpleProperty(elemType))
{
convertedNodes = ConvertFlatNodesToList(elemType, indexedNode.ChildNodes, out conversionSucceeded);
}
else
{
convertedNodes = ConvertComplexNodesToList(elemType, indexedNode, out conversionSucceeded);
}
Type desiredImplType = desiredType.IsInterface
? typeof(List<>).MakeGenericType(elemType)
: desiredType;
IList target = (IList)CreateInstance(desiredImplType, key, node);
foreach(object elem in convertedNodes)
{
target.Add(elem);
}
return target;
}
else
{
throw new BindingException("Could not convert param to generic list as the node related " +
"to the param is not a leaf node nor an indexed node. Key {0}", key);
}
}
protected virtual void BeforeBinding(object instance, String prefix, Node node)
{
if (OnBeforeBinding != null)
{
OnBeforeBinding(instance, prefix, node);
}
}
protected override object CreateInstance(Type instanceType, String paramPrefix, Node node)
{
if (node == null)
{
throw new BindingException(
"Nothing found for the given prefix. Are you sure the form fields are using the prefix " +
paramPrefix + "?");
}
if (node.NodeType != NodeType.Composite)
{
throw new BindingException("Unexpected node type. Expecting Composite, found " + node.NodeType);
}
var cNode = (CompositeNode) node;
object instance;
var shouldLoad = autoLoad != AutoLoadBehavior.Never;
if (autoLoad == AutoLoadBehavior.OnlyNested)
{
shouldLoad = StackDepth != 0;
}
var model = ActiveRecordModel.GetModel(instanceType);
if (shouldLoad && model == null) // Nested type or unregistered type
{
shouldLoad = false;
}
if (shouldLoad)
{
if (instanceType.IsArray)
{
throw new BindingException("ARDataBinder AutoLoad does not support arrays");
}
PrimaryKeyModel pkModel;
var id = ObtainPrimaryKeyValue(model, cNode, paramPrefix, out pkModel);
if (IsValidKey(id))
{
instance = FindByPrimaryKey(instanceType, id);
}
else
{
if (autoLoad == AutoLoadBehavior.NewInstanceIfInvalidKey ||
(autoLoad == AutoLoadBehavior.NewRootInstanceIfInvalidKey && StackDepth == 0))
{
instance = base.CreateInstance(instanceType, paramPrefix, node);
}
else if (autoLoad == AutoLoadBehavior.NullIfInvalidKey ||
autoLoad == AutoLoadBehavior.OnlyNested ||
(autoLoad == AutoLoadBehavior.NewRootInstanceIfInvalidKey && StackDepth != 0))
{
instance = null;
}
else
{
throw new BindingException(string.Format(
"Could not find primary key '{0}' for '{1}'",
pkModel.Property.Name, instanceType.FullName));
}
}
}
else
{
instance = base.CreateInstance(instanceType, paramPrefix, node);
}
return instance;
}
protected virtual bool ShouldRecreateInstance(object value, Type type, String prefix, Node node)
{
return value == null || type.IsArray || IsGenericList(type);
}
protected override bool ShouldRecreateInstance(object value, Type type, string prefix, Node node)
{
if (IsContainerType(type))
{
return true;
}
if (node != null && CurrentARModel != null)
{
// If it's a belongsTo ref, we need to recreate it
// instead of overwrite its properties, otherwise NHibernate will complain
if (IsBelongsToRef(CurrentARModel, prefix))
{
return true;
}
}
return base.ShouldRecreateInstance(value, type, prefix, node);
}
protected virtual object CreateInstance(Type instanceType, String paramPrefix, Node node)
{
const BindingFlags creationFlags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;
return Activator.CreateInstance(instanceType, creationFlags, null, null, null);
}
