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