public static void Initialize(this object target)
{
if (target == null)
{
return;
}
object defaultValue = null;
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties <DefaultValueAttribute>(target.GetType()))
{
try
{
defaultValue = ChoTypeDescriptor.GetPropetyAttribute <DefaultValueAttribute>(pd).Value;
if (defaultValue != null)
{
ChoType.ConvertNSetMemberValue(target, pd.Name, defaultValue);
}
}
catch (Exception ex)
{
ChoETLFramework.WriteLog(ChoETLFramework.TraceSwitch.TraceError, "Error while assigning default value '{0}' to '{1}' member. {2}".FormatString(defaultValue, ChoType.GetMemberName(pd), ex.Message));
}
}
ChoETLFramework.InitializeObject(target);
if (target is IChoInitializable)
{
((IChoInitializable)target).Initialize();
}
}
private void DiscoverRecordFields(Type recordType, string declaringMember, bool optIn = false)
{
if (recordType == null)
{
return;
}
if (!recordType.IsDynamicType())
{
IsComplexXPathUsed = false;
Type pt = null;
if (optIn) //ChoTypeDescriptor.GetProperties(recordType).Where(pd => pd.Attributes.OfType<ChoXmlNodeRecordFieldAttribute>().Any()).Any())
{
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
{
pt = pd.PropertyType.GetUnderlyingType();
var fa = pd.Attributes.OfType <ChoXmlNodeRecordFieldAttribute>().FirstOrDefault();
bool optIn1 = fa == null || fa.UseXmlSerialization ? optIn : ChoTypeDescriptor.GetProperties(pt).Where(pd1 => pd1.Attributes.OfType <ChoXmlNodeRecordFieldAttribute>().Any()).Any();
if (false) //optIn1 && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt))
{
DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn1);
}
else if (pd.Attributes.OfType <ChoXmlNodeRecordFieldAttribute>().Any())
{
bool useCache = true;
string xpath = null;
ChoXmlNodeRecordFieldAttribute attr = ChoTypeDescriptor.GetPropetyAttribute <ChoXmlNodeRecordFieldAttribute>(pd);
if (attr.XPath.IsNullOrEmpty())
{
if (!attr.FieldName.IsNullOrWhiteSpace())
{
attr.XPath = $"/{attr.FieldName}|/@{attr.FieldName}";
}
else
{
attr.XPath = xpath = $"/{pd.Name}|/@{pd.Name}";
}
IsComplexXPathUsed = true;
}
else
{
useCache = false;
}
var obj = new ChoXmlRecordFieldConfiguration(pd.Name, attr, pd.Attributes.OfType <Attribute>().ToArray());
obj.FieldType = pt;
obj.PropertyDescriptor = pd;
obj.DeclaringMember = declaringMember == null ? null : "{0}.{1}".FormatString(declaringMember, pd.Name);
obj.UseCache = useCache;
if (obj.XPath.IsNullOrWhiteSpace())
{
if (!obj.FieldName.IsNullOrWhiteSpace())
{
obj.XPath = $"/{obj.FieldName}|/@{obj.FieldName}";
}
else
{
obj.XPath = $"/{obj.Name}|/@{obj.Name}";
}
}
obj.FieldType = pd.PropertyType.GetUnderlyingType();
if (!XmlRecordFieldConfigurations.Any(c => c.Name == pd.Name))
{
XmlRecordFieldConfigurations.Add(obj);
}
}
}
}
else
{
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
{
XmlIgnoreAttribute xiAttr = pd.Attributes.OfType <XmlIgnoreAttribute>().FirstOrDefault();
if (xiAttr != null)
{
continue;
}
pt = pd.PropertyType.GetUnderlyingType();
if (false) //pt != typeof(object) && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt))
{
DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn);
}
else
{
var obj = new ChoXmlRecordFieldConfiguration(pd.Name, $"/{pd.Name}|/@{pd.Name}");
obj.FieldType = pt;
obj.PropertyDescriptor = pd;
obj.DeclaringMember = declaringMember == null ? null : "{0}.{1}".FormatString(declaringMember, pd.Name);
StringLengthAttribute slAttr = pd.Attributes.OfType <StringLengthAttribute>().FirstOrDefault();
if (slAttr != null && slAttr.MaximumLength > 0)
{
obj.Size = slAttr.MaximumLength;
}
XmlElementAttribute xAttr = pd.Attributes.OfType <XmlElementAttribute>().FirstOrDefault();
if (xAttr != null && !xAttr.ElementName.IsNullOrWhiteSpace())
{
obj.FieldName = xAttr.ElementName;
}
else
{
XmlAttributeAttribute xaAttr = pd.Attributes.OfType <XmlAttributeAttribute>().FirstOrDefault();
if (xAttr != null && !xaAttr.AttributeName.IsNullOrWhiteSpace())
{
obj.FieldName = xaAttr.AttributeName;
}
else
{
DisplayNameAttribute dnAttr = pd.Attributes.OfType <DisplayNameAttribute>().FirstOrDefault();
if (dnAttr != null && !dnAttr.DisplayName.IsNullOrWhiteSpace())
{
obj.FieldName = dnAttr.DisplayName.Trim();
}
else
{
DisplayAttribute dpAttr = pd.Attributes.OfType <DisplayAttribute>().FirstOrDefault();
if (dpAttr != null)
{
if (!dpAttr.ShortName.IsNullOrWhiteSpace())
{
obj.FieldName = dpAttr.ShortName;
}
else if (!dpAttr.Name.IsNullOrWhiteSpace())
{
obj.FieldName = dpAttr.Name;
}
}
}
}
}
DisplayFormatAttribute dfAttr = pd.Attributes.OfType <DisplayFormatAttribute>().FirstOrDefault();
if (dfAttr != null && !dfAttr.DataFormatString.IsNullOrWhiteSpace())
{
obj.FormatText = dfAttr.DataFormatString;
}
if (dfAttr != null && !dfAttr.NullDisplayText.IsNullOrWhiteSpace())
{
obj.NullValue = dfAttr.NullDisplayText;
}
if (!XmlRecordFieldConfigurations.Any(c => c.Name == pd.Name))
{
XmlRecordFieldConfigurations.Add(obj);
}
}
}
}
}
}
internal void WithField(string name, string jsonPath = null, Type fieldType = null, ChoFieldValueTrimOption fieldValueTrimOption = ChoFieldValueTrimOption.Trim, string fieldName = null, Func <object, object> valueConverter = null,
Func <object, object> itemConverter = null,
Func <object, object> customSerializer = null,
object defaultValue = null, object fallbackValue = null, string fullyQualifiedMemberName = null,
string formatText = null, bool?isArray = null, string nullValue = null, Type recordType = null,
Type subRecordType = null, Func <JObject, Type> fieldTypeSelector = null)
{
ChoGuard.ArgumentNotNull(recordType, nameof(recordType));
if (!name.IsNullOrEmpty())
{
if (subRecordType != null)
{
MapRecordFieldsForType(subRecordType);
}
string fnTrim = fieldName.IsNullOrWhiteSpace() ? name.NTrim() : fieldName;
ChoJSONRecordFieldConfiguration fc = null;
PropertyDescriptor pd = null;
if (JSONRecordFieldConfigurations.Any(o => o.FieldName == fnTrim))
{
fc = JSONRecordFieldConfigurations.Where(o => o.FieldName == fnTrim).First();
JSONRecordFieldConfigurations.Remove(fc);
pd = ChoTypeDescriptor.GetNestedProperty(recordType, fullyQualifiedMemberName.IsNullOrWhiteSpace() ? name : fullyQualifiedMemberName);
}
else if (subRecordType != null)
{
pd = ChoTypeDescriptor.GetNestedProperty(subRecordType, fullyQualifiedMemberName.IsNullOrWhiteSpace() ? name : fullyQualifiedMemberName);
}
else
{
pd = ChoTypeDescriptor.GetNestedProperty(recordType, fullyQualifiedMemberName.IsNullOrWhiteSpace() ? name : fullyQualifiedMemberName);
}
var nfc = new ChoJSONRecordFieldConfiguration(fnTrim, pd != null ? ChoTypeDescriptor.GetPropetyAttribute <ChoJSONRecordFieldAttribute>(pd) : null,
pd != null ? pd.Attributes.OfType <Attribute>().ToArray() : null)
{
};
nfc.JSONPath = !jsonPath.IsNullOrWhiteSpace() ? jsonPath : nfc.JSONPath;
nfc.FieldType = fieldType != null ? fieldType : nfc.FieldType;
nfc.FieldValueTrimOption = fieldValueTrimOption;
nfc.FieldName = fieldName.IsNullOrWhiteSpace() ? (name.IsNullOrWhiteSpace() ? nfc.FieldName : name) : fieldName;
nfc.ValueConverter = valueConverter != null ? valueConverter : nfc.ValueConverter;
nfc.CustomSerializer = customSerializer != null ? customSerializer : nfc.CustomSerializer;
nfc.DefaultValue = defaultValue != null ? defaultValue : nfc.DefaultValue;
nfc.FallbackValue = fallbackValue != null ? fallbackValue : nfc.FallbackValue;
nfc.FormatText = !formatText.IsNullOrWhiteSpace() ? formatText : nfc.FormatText;
nfc.ItemConverter = itemConverter != null ? itemConverter : nfc.ItemConverter;
nfc.IsArray = isArray != null ? isArray : nfc.IsArray;
nfc.NullValue = !nullValue.IsNullOrWhiteSpace() ? nullValue : nfc.NullValue;
nfc.FieldTypeSelector = fieldTypeSelector != null ? fieldTypeSelector : nfc.FieldTypeSelector;
if (fullyQualifiedMemberName.IsNullOrWhiteSpace())
{
nfc.PropertyDescriptor = fc != null ? fc.PropertyDescriptor : pd;
nfc.DeclaringMember = fc != null ? fc.DeclaringMember : fullyQualifiedMemberName;
}
else
{
if (subRecordType == null)
{
pd = ChoTypeDescriptor.GetNestedProperty(recordType, fullyQualifiedMemberName);
}
else
{
pd = ChoTypeDescriptor.GetNestedProperty(subRecordType, fullyQualifiedMemberName);
}
nfc.PropertyDescriptor = pd;
nfc.DeclaringMember = fullyQualifiedMemberName;
}
if (pd != null)
{
if (nfc.FieldType == null)
{
nfc.FieldType = pd.PropertyType;
}
}
if (subRecordType == null)
{
JSONRecordFieldConfigurations.Add(nfc);
}
else
{
AddFieldForType(subRecordType, nfc);
}
}
}
private Type DiscoverRecordFields(Type recordType, string declaringMember, bool optIn = false,
List <ChoJSONRecordFieldConfiguration> recordFieldConfigurations = null, bool isTop = false)
{
if (recordType == null)
{
return(recordType);
}
if (!recordType.IsDynamicType())
{
Type pt = null;
if (ChoTypeDescriptor.GetProperties(recordType).Where(pd => pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any()).Any())
{
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
{
pt = pd.PropertyType.GetUnderlyingType();
bool optIn1 = ChoTypeDescriptor.GetProperties(pt).Where(pd1 => pd1.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any()).Any();
if (optIn1 && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt) && FlatToNestedObjectSupport)
{
DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn1, recordFieldConfigurations, false);
}
else if (pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any())
{
var obj = new ChoJSONRecordFieldConfiguration(pd.Name, pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().First(), pd.Attributes.OfType <Attribute>().ToArray());
obj.FieldType = pt;
obj.PropertyDescriptor = pd;
obj.DeclaringMember = declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name);
if (recordFieldConfigurations != null)
{
if (!recordFieldConfigurations.Any(c => c.Name == pd.Name))
{
recordFieldConfigurations.Add(obj);
}
}
}
}
}
else
{
if (isTop)
{
if (typeof(IList).IsAssignableFrom(recordType) || (recordType.IsGenericType && recordType.GetGenericTypeDefinition() == typeof(IList <>)))
{
throw new ChoParserException("Record type not supported.");
}
else if (typeof(IDictionary <string, object>).IsAssignableFrom(recordType))
{
recordType = typeof(ExpandoObject);
return(recordType);
}
else if (typeof(IDictionary).IsAssignableFrom(recordType))
{
recordType = typeof(ExpandoObject);
return(recordType);
}
}
if (recordType.IsSimple())
{
var obj = new ChoJSONRecordFieldConfiguration("Value", "$.Value");
obj.FieldType = recordType;
recordFieldConfigurations.Add(obj);
return(recordType);
}
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
{
JsonIgnoreAttribute jiAttr = pd.Attributes.OfType <JsonIgnoreAttribute>().FirstOrDefault();
if (jiAttr != null)
{
continue;
}
pt = pd.PropertyType.GetUnderlyingType();
if (pt != typeof(object) && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt) && FlatToNestedObjectSupport)
{
DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn, recordFieldConfigurations, false);
}
else
{
var obj = new ChoJSONRecordFieldConfiguration(pd.Name, ChoTypeDescriptor.GetPropetyAttribute <ChoJSONRecordFieldAttribute>(pd),
pd.Attributes.OfType <Attribute>().ToArray());
obj.FieldType = pt;
obj.PropertyDescriptor = pd;
obj.DeclaringMember = declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name);
StringLengthAttribute slAttr = pd.Attributes.OfType <StringLengthAttribute>().FirstOrDefault();
if (slAttr != null && slAttr.MaximumLength > 0)
{
obj.Size = slAttr.MaximumLength;
}
ChoUseJSONSerializationAttribute sAttr = pd.Attributes.OfType <ChoUseJSONSerializationAttribute>().FirstOrDefault();
if (sAttr != null)
{
obj.UseJSONSerialization = sAttr.Flag;
}
ChoJSONPathAttribute jpAttr = pd.Attributes.OfType <ChoJSONPathAttribute>().FirstOrDefault();
if (jpAttr != null)
{
obj.JSONPath = jpAttr.JSONPath;
}
JsonPropertyAttribute jAttr = pd.Attributes.OfType <JsonPropertyAttribute>().FirstOrDefault();
if (jAttr != null && !jAttr.PropertyName.IsNullOrWhiteSpace())
{
obj.FieldName = jAttr.PropertyName;
obj.JSONPath = jAttr.PropertyName;
obj.Order = jAttr.Order;
}
else
{
DisplayNameAttribute dnAttr = pd.Attributes.OfType <DisplayNameAttribute>().FirstOrDefault();
if (dnAttr != null && !dnAttr.DisplayName.IsNullOrWhiteSpace())
{
obj.FieldName = dnAttr.DisplayName.Trim();
}
else
{
DisplayAttribute dpAttr = pd.Attributes.OfType <DisplayAttribute>().FirstOrDefault();
if (dpAttr != null)
{
if (!dpAttr.ShortName.IsNullOrWhiteSpace())
{
obj.FieldName = dpAttr.ShortName;
}
else if (!dpAttr.Name.IsNullOrWhiteSpace())
{
obj.FieldName = dpAttr.Name;
}
obj.Order = dpAttr.Order;
}
else
{
ColumnAttribute clAttr = pd.Attributes.OfType <ColumnAttribute>().FirstOrDefault();
if (clAttr != null)
{
obj.Order = clAttr.Order;
if (!clAttr.Name.IsNullOrWhiteSpace())
{
obj.FieldName = clAttr.Name;
}
}
}
}
}
DisplayFormatAttribute dfAttr = pd.Attributes.OfType <DisplayFormatAttribute>().FirstOrDefault();
if (dfAttr != null && !dfAttr.DataFormatString.IsNullOrWhiteSpace())
{
obj.FormatText = dfAttr.DataFormatString;
}
if (dfAttr != null && !dfAttr.NullDisplayText.IsNullOrWhiteSpace())
{
obj.NullValue = dfAttr.NullDisplayText;
}
if (recordFieldConfigurations != null)
{
if (!recordFieldConfigurations.Any(c => c.Name == pd.Name))
{
recordFieldConfigurations.Add(obj);
}
}
}
}
}
}
return(recordType);
}
private bool FillRecord(object rec, Tuple <int, string> pair)
{
int lineNo;
string line;
lineNo = pair.Item1;
line = pair.Item2;
object fieldValue = null;
string[] fieldValues = (from x in line.Split(Configuration.Delimiter, Configuration.StringSplitOptions, Configuration.QuoteChar)
select x).ToArray();
if (Configuration.ColumnCountStrict)
{
if (fieldValues.Length != Configuration.RecordFieldConfigurations.Count)
{
throw new ChoParserException("Incorrect number of field values found at line [{2}]. Expected [{0}] field values. Found [{1}] field values.".FormatString(Configuration.RecordFieldConfigurations.Count, fieldValues.Length, pair.Item1));
}
}
Dictionary <string, string> _fieldNameValues = ToFieldNameValues(fieldValues);
ValidateLine(pair.Item1, fieldValues);
ChoCSVRecordFieldConfiguration fieldConfig = null;
foreach (KeyValuePair <string, ChoCSVRecordFieldConfiguration> kvp in Configuration.RecordFieldConfigurationsDict)
{
fieldConfig = kvp.Value;
if (Configuration.CSVFileHeaderConfiguration.HasHeaderRecord)
{
if (_fieldNameValues.ContainsKey(fieldConfig.FieldName))
{
fieldValue = _fieldNameValues[fieldConfig.FieldName];
}
else if (Configuration.ColumnCountStrict)
{
throw new ChoParserException("No matching '{0}' field header found.".FormatString(fieldConfig.FieldName));
}
}
else
{
if (fieldConfig.FieldPosition - 1 < fieldValues.Length)
{
fieldValue = fieldValues[fieldConfig.FieldPosition - 1];
}
else if (Configuration.ColumnCountStrict)
{
throw new ChoParserException("Missing field value for {0} [Position: {1}] field.".FormatString(fieldConfig.FieldName, fieldConfig.FieldPosition));
}
}
fieldValue = CleanFieldValue(fieldConfig, fieldValue as string);
if (!RaiseBeforeRecordFieldLoad(rec, pair.Item1, kvp.Key, ref fieldValue))
{
continue;
}
try
{
bool ignoreFieldValue = fieldConfig.IgnoreFieldValue(fieldValue);
if (!ignoreFieldValue)
{
if (rec is ExpandoObject)
{
if (fieldConfig.FieldType != typeof(string))
{
fieldValue = ChoConvert.ConvertTo(fieldValue, fieldConfig.FieldType, Configuration.Culture);
}
var x = rec as IDictionary <string, Object>;
x.Add(kvp.Key, fieldValue);
}
else
{
if (ChoType.HasProperty(rec.GetType(), kvp.Key))
{
ChoType.ConvertNSetMemberValue(rec, kvp.Key, fieldValue);
fieldValue = ChoType.GetMemberValue(rec, kvp.Key);
if ((Configuration.ObjectValidationMode & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel)
{
ChoValidator.ValididateFor(rec, kvp.Key);
}
}
else
{
throw new ChoMissingRecordFieldException("Missing '{0}' property in {1} type.".FormatString(kvp.Key, ChoType.GetTypeName(rec)));
}
}
}
if (!RaiseAfterRecordFieldLoad(rec, pair.Item1, kvp.Key, fieldValue))
{
return(false);
}
}
catch (ChoParserException)
{
throw;
}
catch (ChoMissingRecordFieldException)
{
if (Configuration.ThrowAndStopOnMissingField)
{
throw;
}
}
catch (Exception ex)
{
ChoETLFramework.HandleException(ex);
if (fieldConfig.ErrorMode == ChoErrorMode.ThrowAndStop)
{
throw;
}
try
{
ChoFallbackValueAttribute fbAttr = ChoTypeDescriptor.GetPropetyAttribute <ChoFallbackValueAttribute>(rec.GetType(), kvp.Key);
if (fbAttr != null)
{
if (!fbAttr.Value.IsNullOrDbNull())
{
ChoType.ConvertNSetMemberValue(rec, kvp.Key, fbAttr.Value);
}
}
else
{
throw;
}
}
catch
{
if (fieldConfig.ErrorMode == ChoErrorMode.IgnoreAndContinue)
{
continue;
}
else if (fieldConfig.ErrorMode == ChoErrorMode.ReportAndContinue)
{
if (!RaiseRecordFieldLoadError(rec, pair.Item1, kvp.Key, fieldValue, ex))
{
throw;
}
}
else
{
throw;
}
}
}
}
return(true);
}
public override void Validate(object state)
{
base.Validate(state);
if (XPath.IsNull())
{
throw new ChoRecordConfigurationException("XPath can't be null or whitespace.");
}
if (XPath.IsNullOrWhiteSpace())
{
if (RecordType != null)
{
NodeName = RecordType.Name;
RootName = RecordType.Namespace;
}
}
else
{
RootName = XPath.SplitNTrim("/").Where(t => !t.IsNullOrWhiteSpace() && t.NTrim() != "." && t.NTrim() != ".." && t.NTrim() != "*").FirstOrDefault();
NodeName = XPath.SplitNTrim("/").Where(t => !t.IsNullOrWhiteSpace() && t.NTrim() != "." && t.NTrim() != ".." && t.NTrim() != "*").Skip(1).FirstOrDefault();
}
if (RootName.IsNullOrWhiteSpace())
{
ChoXmlDocumentRootAttribute da = TypeDescriptor.GetAttributes(RecordType).OfType <ChoXmlDocumentRootAttribute>().FirstOrDefault();
if (da != null)
{
NodeName = da.Name;
}
if (RootName.IsNullOrWhiteSpace())
{
RootName = "Root";
}
}
if (NodeName.IsNullOrWhiteSpace())
{
if (!IsDynamicObject)
{
XmlRootAttribute ra = TypeDescriptor.GetAttributes(RecordType).OfType <XmlRootAttribute>().FirstOrDefault();
if (ra != null)
{
NodeName = ra.ElementName;
}
}
if (NodeName.IsNullOrWhiteSpace())
{
NodeName = "XElement";
}
}
//Encode Root and node names
RootName = System.Net.WebUtility.HtmlEncode(RootName);
NodeName = System.Net.WebUtility.HtmlEncode(NodeName);
string[] fieldNames = null;
XElement xpr = null;
if (state is Tuple <long, XElement> )
{
xpr = ((Tuple <long, XElement>)state).Item2;
}
else
{
fieldNames = state as string[];
}
if (AutoDiscoverColumns &&
XmlRecordFieldConfigurations.Count == 0)
{
if (RecordType != null && !IsDynamicObject &&
ChoTypeDescriptor.GetProperties(RecordType).Where(pd => pd.Attributes.OfType <ChoXmlNodeRecordFieldAttribute>().Any()).Any())
{
IsComplexXPathUsed = false;
long startIndex = 0;
long size = 0;
string xpath = null;
bool useCache = true;
ChoXmlNodeRecordFieldAttribute attr = null;
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(RecordType).Where(pd => pd.Attributes.OfType <ChoXmlNodeRecordFieldAttribute>().Any()))
{
//if (!pd.PropertyType.IsSimple())
// throw new ChoRecordConfigurationException("Property '{0}' is not a simple type.".FormatString(pd.Name));
attr = ChoTypeDescriptor.GetPropetyAttribute <ChoXmlNodeRecordFieldAttribute>(pd);
if (attr.XPath.IsNullOrEmpty())
{
xpath = $"//{pd.Name}|//@{pd.Name}";
IsComplexXPathUsed = true;
}
else
{
useCache = false;
}
var obj = new ChoXmlRecordFieldConfiguration(pd.Name, xpath);
obj.FieldType = pd.PropertyType;
obj.UseCache = useCache;
XmlRecordFieldConfigurations.Add(obj);
startIndex += size;
}
//RecordLength = startIndex;
}
else if (xpr != null)
{
IsComplexXPathUsed = false;
ChoXmlNamespaceManager nsMgr = new ChoXmlNamespaceManager(NamespaceManager);
Dictionary <string, ChoXmlRecordFieldConfiguration> dict = new Dictionary <string, ChoXmlRecordFieldConfiguration>(StringComparer.CurrentCultureIgnoreCase);
string name = null;
foreach (var attr in xpr.Attributes())
{
//if (!attr.Name.NamespaceName.IsNullOrWhiteSpace()) continue;
name = GetNameWithNamespace(attr.Name);
if (!dict.ContainsKey(name))
{
dict.Add(name, new ChoXmlRecordFieldConfiguration(name, $"//@{name}")); // DefaultNamespace.IsNullOrWhiteSpace() ? $"//@{name}" : $"//@{DefaultNamespace}" + ":" + $"{name}") { IsXmlAttribute = true });
}
else
{
throw new ChoRecordConfigurationException("Duplicate field(s) [Name(s): {0}] found.".FormatString(name));
}
}
bool hasElements = false;
var z = xpr.Elements().Where(a => !a.HasElements).ToArray();
foreach (var ele in xpr.Elements().Where(a => !a.HasElements))
{
name = GetNameWithNamespace(ele.Name);
hasElements = true;
if (!dict.ContainsKey(name))
{
dict.Add(name, new ChoXmlRecordFieldConfiguration(name, $"//{name}")); // DefaultNamespace.IsNullOrWhiteSpace() ? $"//{name}" : $"//{DefaultNamespace}" + ":" + $"{name}"));
}
else
{
if (dict[name].IsXmlAttribute)
{
throw new ChoRecordConfigurationException("Duplicate field(s) [Name(s): {0}] found.".FormatString(name));
}
dict[name].IsCollection = true;
}
}
if (!hasElements)
{
name = xpr.Name.LocalName;
dict.Add(name, new ChoXmlRecordFieldConfiguration(name, "text()"));
}
foreach (ChoXmlRecordFieldConfiguration obj in dict.Values)
{
XmlRecordFieldConfigurations.Add(obj);
}
}
else if (!fieldNames.IsNullOrEmpty())
{
foreach (string fn in fieldNames)
{
var obj = new ChoXmlRecordFieldConfiguration(fn, xPath: $"//{fn}");
XmlRecordFieldConfigurations.Add(obj);
}
}
}
else
{
IsComplexXPathUsed = false;
foreach (var fc in XmlRecordFieldConfigurations)
{
if (fc.XPath.IsNullOrWhiteSpace())
{
fc.XPath = $"//{fc.FieldName}|//@{fc.FieldName}";
}
else
{
if (fc.XPath == fc.FieldName ||
fc.XPath == $"//{fc.FieldName}" || fc.XPath == $"/{fc.FieldName}" || fc.XPath == $"./{fc.FieldName}" ||
fc.XPath == $"//@{fc.FieldName}" || fc.XPath == $"/@{fc.FieldName}" || fc.XPath == $"./@{fc.FieldName}"
)
{
}
else
{
IsComplexXPathUsed = true;
fc.UseCache = false;
}
}
}
}
if (XmlRecordFieldConfigurations.Count <= 0)
{
throw new ChoRecordConfigurationException("No record fields specified.");
}
//Validate each record field
foreach (var fieldConfig in XmlRecordFieldConfigurations)
{
fieldConfig.Validate(this);
}
//Check field position for duplicate
string[] dupFields = XmlRecordFieldConfigurations.GroupBy(i => i.Name)
.Where(g => g.Count() > 1)
.Select(g => g.Key).ToArray();
if (dupFields.Length > 0)
{
throw new ChoRecordConfigurationException("Duplicate field(s) [Name(s): {0}] found.".FormatString(String.Join(",", dupFields)));
}
RecordFieldConfigurationsDict = XmlRecordFieldConfigurations.OrderBy(c => c.IsXmlAttribute).Where(i => !i.Name.IsNullOrWhiteSpace()).ToDictionary(i => i.Name);
LoadNCacheMembers(XmlRecordFieldConfigurations);
}
public override void Validate(object state)
{
base.Validate(state);
string[] fieldNames = null;
JObject jObject = null;
if (state is Tuple <long, JObject> )
{
jObject = ((Tuple <long, JObject>)state).Item2;
}
else
{
fieldNames = state as string[];
}
if (AutoDiscoverColumns &&
JSONRecordFieldConfigurations.Count == 0)
{
if (RecordType != null && !IsDynamicObject && /*&& RecordType != typeof(ExpandoObject)*/
ChoTypeDescriptor.GetProperties(RecordType).Where(pd => pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any()).Any())
{
long startIndex = 0;
long size = 0;
string jpath = null;
ChoJSONRecordFieldAttribute attr = null;
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(RecordType).Where(pd => pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any()))
{
attr = ChoTypeDescriptor.GetPropetyAttribute <ChoJSONRecordFieldAttribute>(pd);
var obj = new ChoJSONRecordFieldConfiguration(pd.Name, jpath);
obj.FieldType = pd.PropertyType;
JSONRecordFieldConfigurations.Add(obj);
startIndex += size;
}
}
else if (jObject != null)
{
Dictionary <string, ChoJSONRecordFieldConfiguration> dict = new Dictionary <string, ChoJSONRecordFieldConfiguration>(StringComparer.CurrentCultureIgnoreCase);
string name = null;
foreach (var attr in jObject.Properties())
{
name = attr.Name;
if (!dict.ContainsKey(name))
{
dict.Add(name, new ChoJSONRecordFieldConfiguration(name, (string)null));
}
else
{
throw new ChoRecordConfigurationException("Duplicate field(s) [Name(s): {0}] found.".FormatString(name));
}
}
foreach (ChoJSONRecordFieldConfiguration obj in dict.Values)
{
JSONRecordFieldConfigurations.Add(obj);
}
}
else if (!fieldNames.IsNullOrEmpty())
{
foreach (string fn in fieldNames)
{
var obj = new ChoJSONRecordFieldConfiguration(fn, (string)null);
JSONRecordFieldConfigurations.Add(obj);
}
}
}
else
{
foreach (var fc in JSONRecordFieldConfigurations)
{
fc.ComplexJPathUsed = !(fc.JSONPath.IsNullOrWhiteSpace() || String.Compare(fc.FieldName, fc.JSONPath, true) == 0);
}
}
if (JSONRecordFieldConfigurations.Count <= 0)
{
throw new ChoRecordConfigurationException("No record fields specified.");
}
//Validate each record field
foreach (var fieldConfig in JSONRecordFieldConfigurations)
{
fieldConfig.Validate(this);
}
//Check field position for duplicate
string[] dupFields = JSONRecordFieldConfigurations.GroupBy(i => i.Name)
.Where(g => g.Count() > 1)
.Select(g => g.Key).ToArray();
if (dupFields.Length > 0)
{
throw new ChoRecordConfigurationException("Duplicate field(s) [Name(s): {0}] found.".FormatString(String.Join(",", dupFields)));
}
RecordFieldConfigurationsDict = JSONRecordFieldConfigurations.Where(i => !i.Name.IsNullOrWhiteSpace()).ToDictionary(i => i.Name);
LoadNCacheMembers(JSONRecordFieldConfigurations);
}
protected virtual object Serialize(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
IList result = ChoActivator.CreateInstance(typeof(IList <>).MakeGenericType(targetType)) as IList;
if (value != null && !value.GetType().IsCollectionType())
{
if (targetType == typeof(object) || targetType.IsSimple())
{
foreach (var p in ChoTypeDescriptor.GetProperties(value.GetType()).Where(pd => ChoTypeDescriptor.GetPropetyAttribute <ChoIgnoreMemberAttribute>(pd) == null))
{
result.Add(ChoConvert.ConvertTo(ChoType.GetPropertyValue(value, p.Name), targetType, culture));
}
}
}
return(result.OfType <object>().ToArray());
}
protected virtual object Deserialize(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (value != null && value.GetType().IsCollectionType())
{
if (targetType != typeof(object) && !targetType.IsSimple() && !typeof(ICollection).IsAssignableFrom(targetType))
{
IList coll = value as IList;
var itemType = value.GetType().GetItemType();
if (itemType == typeof(object) || itemType.IsSimple())
{
value = ChoActivator.CreateInstance(targetType);
foreach (var p in ChoTypeDescriptor.GetProperties <ChoArrayIndexAttribute>(targetType).Select(pd => new { pd, a = ChoTypeDescriptor.GetPropetyAttribute <ChoArrayIndexAttribute>(pd) })
.GroupBy(g => g.a.Position).Select(g => g.First()).Where(g => g.a.Position >= 0).OrderBy(g => g.a.Position))
{
if (p.a.Position < coll.Count)
{
ChoType.ConvertNSetPropertyValue(value, p.pd.Name, coll[p.a.Position], culture);
}
}
}
}
}
return(value);
}