public bool CanBindParameter(Type desiredType, String paramName, CompositeNode treeRoot) { bool canConvert; Node childNode = treeRoot.GetChildNode(paramName); if (childNode != null) { canConvert = true; } else if (desiredType == typeof(DateTime)) { TrySpecialDateTimeBinding(desiredType, treeRoot, paramName, out canConvert); } else if (desiredType == typeof(DateTimeOffset)) { TrySpecialDateTimeOffsetBinding(desiredType, treeRoot, paramName, out canConvert); } else { canConvert = false; } return(canConvert); }
public object BindParameter(Type desiredType, String paramName, CompositeNode treeRoot) { bool conversionSucceeded; object result; try { if (desiredType.IsArray) { Node childNode = treeRoot.GetChildNode(paramName); result = ConvertToArray(desiredType, paramName, childNode, out conversionSucceeded); } else { result = ConvertToSimpleValue(desiredType, paramName, treeRoot, out conversionSucceeded); } } catch (Exception ex) { // Something unexpected during convertion // throw new exception with paramName specified throw new BindingException( "Exception converting param '" + paramName + "' to " + desiredType + ". Check inner exception for details", ex); } return(result); }
public object BindObject(Type targetType, string prefix, string excludedProperties, string allowedProperties, CompositeNode treeRoot) { if (targetType == null) { throw new ArgumentNullException("targetType"); } if (prefix == null) { throw new ArgumentNullException("prefix"); } if (treeRoot == null) { throw new ArgumentNullException("treeRoot"); } errors = new ArrayList(); instanceStack = new Stack(); prefixStack = new Stack <string>(); excludedPropertyList = CreateNormalizedList(excludedProperties); allowedPropertyList = CreateNormalizedList(allowedProperties); return(InternalBindObject(targetType, prefix, treeRoot.GetChildNode(prefix))); }
private object ConvertToSimpleValue(Type desiredType, string key, CompositeNode parent, out bool conversionSucceeded) { conversionSucceeded = false; Node childNode = parent.GetChildNode(key); if (childNode == null && IsDateTimeType(desiredType)) { return(TrySpecialDateTimeBinding(desiredType, parent, key, out conversionSucceeded)); } if (childNode == null && IsDateTimeOffsetType(desiredType)) { return(TrySpecialDateTimeOffsetBinding(desiredType, parent, key, out conversionSucceeded)); } if (childNode == null) { return(null); } if (childNode.NodeType == NodeType.Leaf) { return(ConvertLeafNode(desiredType, (LeafNode)childNode, out conversionSucceeded)); } throw new BindingException("Could not convert param as the node related " + "to the param is not a leaf node. Param {0} parent node: {1}", key, parent.Name); }
public bool CanBindParameter(Type desiredType, String paramName, CompositeNode treeRoot) { bool canConvert; Node childNode = treeRoot.GetChildNode(paramName); if (childNode != null) { canConvert = true; } else if (desiredType == typeof (DateTime)) { TrySpecialDateTimeBinding(desiredType, treeRoot, paramName, out canConvert); } else if (desiredType == typeof(DateTimeOffset)) { TrySpecialDateTimeOffsetBinding(desiredType, treeRoot, paramName, out canConvert); } else { canConvert = false; } return canConvert; }
public void BindObjectInstance(object instance, string prefix, string excludedProperties, string allowedProperties, CompositeNode treeRoot) { if (instance == null) { throw new ArgumentNullException("instance"); } if (prefix == null) { throw new ArgumentNullException("prefix"); } if (treeRoot == null) { throw new ArgumentNullException("treeRoot"); } errors = new ArrayList(); instanceStack = new Stack(); prefixStack = new Stack <string>(); excludedPropertyList = CreateNormalizedList(excludedProperties); allowedPropertyList = CreateNormalizedList(allowedProperties); if (instance != null) { var instanceType = instance.GetType(); if (IsGenericList(instanceType)) { bool success; var elemType = instanceType.GetGenericArguments()[0]; ConvertToGenericList((IList)instance, elemType, prefix, treeRoot.GetChildNode(prefix), out success); } } InternalRecursiveBindObjectInstance(instance, prefix, treeRoot.GetChildNode(prefix)); }
private IndexedNode GetOrCreateIndexedNode(CompositeNode parent, string nodeName) { Node node = parent.GetChildNode(nodeName); if (node != null && node.NodeType != NodeType.Indexed) { throw new BindingException("Attempt to create or obtain an indexed node " + "named {0}, but a node with the same exists with the type {1}", nodeName, node.NodeType); } if (node == null) { node = new IndexedNode(nodeName); parent.AddChildNode(node); } return((IndexedNode)node); }
protected bool CheckForValidationFailures(object instance, Type instanceType, PropertyInfo prop, CompositeNode node, string name, string prefix, ErrorSummary summary) { object value = null; if (validator == null) { return(false); } IValidator[] validators = validator.GetValidators(instanceType, prop); if (validators.Length != 0) { Node valNode = node.GetChildNode(name); if (valNode != null && valNode.NodeType == NodeType.Leaf) { value = ((LeafNode)valNode).Value; } if (value == null && IsDateTimeType(prop.PropertyType)) { bool conversionSucceeded; value = TryGetDateWithUTCFormat(node, name, out conversionSucceeded); } if (value == null && valNode == null) { // Value was not present on the data source. Skip validation return(false); } } return(CheckForValidationFailures(instance, instanceType, prop, value, name, prefix, summary)); }
private string TryGetDateWithUTCFormat(CompositeNode treeRoot, string paramName, out bool conversionSucceeded) { // YYYY-MM-DDThh:mm:ss.sTZD (eg 1997-07-16T19:20:30.45+01:00) string fullDateTime = ""; conversionSucceeded = false; Node dayNode = treeRoot.GetChildNode(paramName + "day"); Node monthNode = treeRoot.GetChildNode(paramName + "month"); Node yearNode = treeRoot.GetChildNode(paramName + "year"); Node hourNode = treeRoot.GetChildNode(paramName + "hour"); Node minuteNode = treeRoot.GetChildNode(paramName + "minute"); Node secondNode = treeRoot.GetChildNode(paramName + "second"); if (dayNode != null) { var day = (int)RelaxedConvertLeafNode(typeof(int), dayNode, 0); var month = (int)RelaxedConvertLeafNode(typeof(int), monthNode, 0); var year = (int)RelaxedConvertLeafNode(typeof(int), yearNode, 0); fullDateTime = string.Format("{0:0000}-{1:00}-{2:00}", year, month, day); conversionSucceeded = true; } if (hourNode != null) { var hour = (int)RelaxedConvertLeafNode(typeof(int), hourNode, 0); var minute = (int)RelaxedConvertLeafNode(typeof(int), minuteNode, 0); var second = (int)RelaxedConvertLeafNode(typeof(int), secondNode, 0); fullDateTime += string.Format("T{0:00}:{1:00}:{2:00}", hour, minute, second); conversionSucceeded = true; } return(fullDateTime == "" ? null : fullDateTime); }
private object ConvertToSimpleValue(Type desiredType, string key, CompositeNode parent, out bool conversionSucceeded) { conversionSucceeded = false; Node childNode = parent.GetChildNode(key); if (childNode == null && IsDateTimeType(desiredType)) { return TrySpecialDateTimeBinding(desiredType, parent, key, out conversionSucceeded); } else if (childNode == null) { return null; } else if (childNode.NodeType == NodeType.Leaf) { return ConvertLeafNode(desiredType, (LeafNode) childNode, out conversionSucceeded); } else { throw new BindingException("Could not convert param as the node related " + "to the param is not a leaf node. Param {0} parent node: {1}", key, parent.Name); } }
protected bool CheckForValidationFailures(object instance, Type instanceType, PropertyInfo prop, CompositeNode node, string name, string prefix, ErrorSummary summary) { object value = null; if (validator == null) { return false; } IValidator[] validators = validator.GetValidators(instanceType, prop); if (validators.Length != 0) { Node valNode = node.GetChildNode(name); if (valNode != null && valNode.NodeType == NodeType.Leaf) { value = ((LeafNode)valNode).Value; } if (value == null && IsDateTimeType(prop.PropertyType)) { bool conversionSucceeded; value = TryGetDateWithUTCFormat(node, name, out conversionSucceeded); } if (value == null && valNode == null) { // Value was not present on the data source. Skip validation return false; } } return CheckForValidationFailures(instance, instanceType, prop, value, name, prefix, summary); }
protected void InternalRecursiveBindObjectInstance(object instance, String prefix, CompositeNode node) { if (node == null || instance == null) { return; } BeforeBinding(instance, prefix, node); if (PerformCustomBinding(instance, prefix, node)) { return; } PushInstance(instance, prefix); ErrorSummary summary = new ErrorSummary(); validationErrorSummaryPerInstance[instance] = summary; Type instanceType = instance.GetType(); PropertyInfo[] props = instanceType.GetProperties(PropertiesBindingFlags); string nodeFullName = node.FullName; foreach(PropertyInfo prop in props) { if (ShouldIgnoreProperty(prop, nodeFullName)) { continue; } Type propType = prop.PropertyType; String paramName = prop.Name; String translatedParamName = Translate(instanceType, paramName); if (translatedParamName == null) { continue; } bool isSimpleProperty = IsSimpleProperty(propType); // There are some caveats by running the validators here. // We should follow the validator's execution order... if (isSimpleProperty) { if (CheckForValidationFailures(instance, instanceType, prop, node, translatedParamName, prefix, summary)) { continue; } } BeforeBindingProperty(instance, prop, prefix, node); try { bool conversionSucceeded; if (isSimpleProperty) { object value = ConvertToSimpleValue(propType, translatedParamName, node, out conversionSucceeded); if (conversionSucceeded) { SetPropertyValue(instance, prop, value); } } else { // if the property is an object, we look if it is already instanciated object value = prop.GetValue(instance, null); Node nestedNode = node.GetChildNode(paramName); if (nestedNode != null) { if (ShouldRecreateInstance(value, propType, paramName, nestedNode)) { value = InternalBindObject(propType, paramName, nestedNode, out conversionSucceeded); if (conversionSucceeded) { SetPropertyValue(instance, prop, value); } } else { InternalRecursiveBindObjectInstance(value, paramName, nestedNode); } } CheckForValidationFailures(instance, instanceType, prop, value, translatedParamName, prefix, summary); } } catch(Exception ex) { errors.Add(new DataBindError(prefix, prop.Name, ex)); } } PopInstance(instance, prefix); AfterBinding(instance, prefix, node); }
public void BindObjectInstance(object instance, string prefix, string excludedProperties, string allowedProperties, CompositeNode treeRoot) { if (instance == null) { throw new ArgumentNullException("instance"); } if (prefix == null) { throw new ArgumentNullException("prefix"); } if (treeRoot == null) { throw new ArgumentNullException("treeRoot"); } errors = new ArrayList(); instanceStack = new Stack(); prefixStack = new Stack<string>(); excludedPropertyList = CreateNormalizedList(excludedProperties); allowedPropertyList = CreateNormalizedList(allowedProperties); InternalRecursiveBindObjectInstance(instance, prefix, treeRoot.GetChildNode(prefix)); }
public object BindObject(Type targetType, string prefix, string excludedProperties, string allowedProperties, CompositeNode treeRoot) { if (targetType == null) { throw new ArgumentNullException("targetType"); } if (prefix == null) { throw new ArgumentNullException("prefix"); } if (treeRoot == null) { throw new ArgumentNullException("treeRoot"); } errors = new ArrayList(); instanceStack = new Stack(); prefixStack = new Stack<string>(); excludedPropertyList = CreateNormalizedList(excludedProperties); allowedPropertyList = CreateNormalizedList(allowedProperties); return InternalBindObject(targetType, prefix, treeRoot.GetChildNode(prefix)); }
public object BindParameter(Type desiredType, String paramName, CompositeNode treeRoot) { bool conversionSucceeded; object result; try { if (desiredType.IsArray) { Node childNode = treeRoot.GetChildNode(paramName); result = ConvertToArray(desiredType, paramName, childNode, out conversionSucceeded); } else { result = ConvertToSimpleValue(desiredType, paramName, treeRoot, out conversionSucceeded); } } catch(Exception ex) { // Something unexpected during convertion // throw new exception with paramName specified throw new BindingException( "Exception converting param '" + paramName + "' to " + desiredType + ". Check inner exception for details", ex); } return result; }
public bool CanBindObject(Type targetType, String prefix, CompositeNode treeRoot) { Node childNode = treeRoot.GetChildNode(prefix); return childNode != null; }
private IndexedNode GetOrCreateIndexedNode(CompositeNode parent, string nodeName) { Node node = parent.GetChildNode(nodeName); if (node != null && node.NodeType != NodeType.Indexed) { throw new BindingException("Attempt to create or obtain an indexed node " + "named {0}, but a node with the same exists with the type {1}", nodeName, node.NodeType); } if (node == null) { node = new IndexedNode(nodeName); parent.AddChildNode(node); } return (IndexedNode) node; }
protected void InternalRecursiveBindObjectInstance(object instance, String prefix, CompositeNode node) { if (node == null || instance == null) { return; } BeforeBinding(instance, prefix, node); if (PerformCustomBinding(instance, prefix, node)) { return; } PushInstance(instance, prefix); var summary = new ErrorSummary(); validationErrorSummaryPerInstance[instance] = summary; Type instanceType = instance.GetType(); PropertyInfo[] props = instanceType.GetProperties(PropertiesBindingFlags); string nodeFullName = node.FullName; foreach (PropertyInfo prop in props) { if (ShouldIgnoreProperty(string.Format("{0}.{1}", nodeFullName, prop.Name))) { continue; } Type propType = prop.PropertyType; String paramName = prop.Name; String translatedParamName = Translate(instanceType, paramName); if (translatedParamName == null) { continue; } bool isSimpleProperty = IsSimpleProperty(propType); if (isSimpleProperty && prop.CanWrite == false) { continue; } BeforeBindingProperty(instance, prop, prefix, node); try { bool conversionSucceeded; if (isSimpleProperty) { object value = ConvertToSimpleValue(propType, translatedParamName, node, out conversionSucceeded); if (conversionSucceeded) { SetPropertyValue(instance, prop, value); } } else { // if the property is an object, we look if it is already instantiated Node nestedNode = node.GetChildNode(paramName); if (nestedNode != null) { object value = prop.GetValue(instance, null); if (ShouldRecreateInstance(value, propType, paramName, nestedNode)) { value = InternalBindObject(propType, paramName, nestedNode, out conversionSucceeded); if (conversionSucceeded) { SetPropertyValue(instance, prop, value); } } else { InternalRecursiveBindObjectInstance(value, paramName, nestedNode); } } } } catch (Exception ex) { errors.Add(new DataBindError(prefix, prop.Name, ex)); } } CheckForValidationFailures(instance, prefix, node, summary); PopInstance(instance, prefix); AfterBinding(instance, prefix, node); }
private string TryGetDateWithUTCFormat(CompositeNode treeRoot, string paramName, out bool conversionSucceeded) { // YYYY-MM-DDThh:mm:ss.sTZD (eg 1997-07-16T19:20:30.45+01:00) string fullDateTime = ""; conversionSucceeded = false; Node dayNode = treeRoot.GetChildNode(paramName + "day"); Node monthNode = treeRoot.GetChildNode(paramName + "month"); Node yearNode = treeRoot.GetChildNode(paramName + "year"); Node hourNode = treeRoot.GetChildNode(paramName + "hour"); Node minuteNode = treeRoot.GetChildNode(paramName + "minute"); Node secondNode = treeRoot.GetChildNode(paramName + "second"); if (dayNode != null) { int day = (int) RelaxedConvertLeafNode(typeof(int), dayNode, 0); int month = (int) RelaxedConvertLeafNode(typeof(int), monthNode, 0); int year = (int) RelaxedConvertLeafNode(typeof(int), yearNode, 0); fullDateTime = string.Format("{0:0000}-{1:00}-{2:00}", year, month, day); conversionSucceeded = true; } if (hourNode != null) { int hour = (int) RelaxedConvertLeafNode(typeof(int), hourNode, 0); int minute = (int) RelaxedConvertLeafNode(typeof(int), minuteNode, 0); int second = (int) RelaxedConvertLeafNode(typeof(int), secondNode, 0); fullDateTime += string.Format("T{0:00}:{1:00}:{2:00}", hour, minute, second); conversionSucceeded = true; } return fullDateTime == "" ? null : fullDateTime; }
public void BindObjectInstance(object instance, string prefix, string excludedProperties, string allowedProperties, CompositeNode treeRoot) { if (instance == null) { throw new ArgumentNullException("instance"); } if (prefix == null) { throw new ArgumentNullException("prefix"); } if (treeRoot == null) { throw new ArgumentNullException("treeRoot"); } errors = new ArrayList(); instanceStack = new Stack(); prefixStack = new Stack<string>(); excludedPropertyList = CreateNormalizedList(excludedProperties); allowedPropertyList = CreateNormalizedList(allowedProperties); if (instance != null) { var instanceType = instance.GetType(); if (IsGenericList(instanceType)) { bool success; var elemType = instanceType.GetGenericArguments()[0]; ConvertToGenericList((IList)instance, elemType, prefix, treeRoot.GetChildNode(prefix), out success); } } InternalRecursiveBindObjectInstance(instance, prefix, treeRoot.GetChildNode(prefix)); }
private object ObtainPrimaryKeyValue(ActiveRecordModel model, CompositeNode node, String prefix, out PrimaryKeyModel pkModel) { pkModel = ObtainPrimaryKey(model); var pkPropName = pkModel.Property.Name; var idNode = node.GetChildNode(pkPropName); if (idNode == null) return null; if (idNode != null && idNode.NodeType != NodeType.Leaf) { throw new BindingException("Expecting leaf node to contain id for ActiveRecord class. " + "Prefix: {0} PK Property Name: {1}", prefix, pkPropName); } var lNode = (LeafNode) idNode; if (lNode == null) { throw new BindingException("ARDataBinder autoload failed as element {0} " + "doesn't have a primary key {1} value", prefix, pkPropName); } bool conversionSuc; return Converter.Convert(pkModel.Property.PropertyType, lNode.ValueType, lNode.Value, out conversionSuc); }
public bool CanBindObject(Type targetType, String prefix, CompositeNode treeRoot) { Node childNode = treeRoot.GetChildNode(prefix); return(childNode != null); }