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