public ChoParquetWriter <T> WithFields(params string[] fieldsNames) { string fnTrim = null; if (!fieldsNames.IsNullOrEmpty()) { int maxFieldPos = Configuration.ParquetRecordFieldConfigurations.Count > 0 ? Configuration.ParquetRecordFieldConfigurations.Max(f => f.FieldPosition) : 0; PropertyDescriptor pd = null; ChoParquetRecordFieldConfiguration fc = null; foreach (string fn in fieldsNames) { if (fn.IsNullOrEmpty()) { continue; } if (!_clearFields) { ClearFields(); Configuration.MapRecordFields(Configuration.RecordType); } fnTrim = fn.NTrim(); if (Configuration.ParquetRecordFieldConfigurations.Any(o => o.Name == fnTrim)) { fc = Configuration.ParquetRecordFieldConfigurations.Where(o => o.Name == fnTrim).First(); Configuration.ParquetRecordFieldConfigurations.Remove(Configuration.ParquetRecordFieldConfigurations.Where(o => o.Name == fnTrim).First()); } else { pd = ChoTypeDescriptor.GetProperty(typeof(T), fn); } var nfc = new ChoParquetRecordFieldConfiguration(fnTrim, ++maxFieldPos) { FieldName = fn }; nfc.PropertyDescriptor = fc != null ? fc.PropertyDescriptor : pd; nfc.DeclaringMember = fc != null ? fc.DeclaringMember : null; if (pd != null) { if (nfc.FieldType == null) { nfc.FieldType = pd.PropertyType; } } Configuration.ParquetRecordFieldConfigurations.Add(nfc); } } return(this); }
public virtual void Validate(object state) { if (!IsDynamicObject) { //PIDict = ChoType.GetProperties(RecordType).ToDictionary(p => p.Name); PDDict = new Dictionary <string, PropertyDescriptor>(); if (PIDict != null) { foreach (var fn in PIDict.Keys) { PDDict.Add(fn, ChoTypeDescriptor.GetProperty(RecordType, fn)); } } } }
public ChoXmlReader <T> WithFields(params string[] fieldsNames) { string fnTrim = null; if (!fieldsNames.IsNullOrEmpty()) { PropertyDescriptor pd = null; ChoXmlRecordFieldConfiguration fc = null; foreach (string fn in fieldsNames) { if (fn.IsNullOrEmpty()) { continue; } if (!_clearFields) { ClearFields(); Configuration.MapRecordFields(Configuration.RecordType); } fnTrim = fn.NTrim(); if (Configuration.XmlRecordFieldConfigurations.Any(o => o.Name == fnTrim)) { fc = Configuration.XmlRecordFieldConfigurations.Where(o => o.Name == fnTrim).First(); Configuration.XmlRecordFieldConfigurations.Remove(Configuration.XmlRecordFieldConfigurations.Where(o => o.Name == fnTrim).First()); } else { pd = ChoTypeDescriptor.GetProperty(typeof(T), fn); } var nfc = new ChoXmlRecordFieldConfiguration(fnTrim, $"/{fnTrim}"); nfc.PropertyDescriptor = fc != null ? fc.PropertyDescriptor : pd; nfc.DeclaringMember = fc != null ? fc.DeclaringMember : null; if (pd != null) { if (nfc.FieldType == null) { nfc.FieldType = pd.PropertyType; } } Configuration.XmlRecordFieldConfigurations.Add(nfc); } } return(this); }
public static void SetDefaultValue(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, CultureInfo culture) { if (rec is ExpandoObject) { ((IDictionary <string, object>)rec).SetDefaultValue(fn, fieldConfig, culture); return; } object fieldValue = null; //Set default value to member try { bool defaultValueExists = true; object defaultValue = null; if (fieldConfig.IsDefaultValueSpecified) { defaultValue = fieldConfig.DefaultValue; } else if (ChoType.HasDefaultValue(ChoTypeDescriptor.GetProperty(rec.GetType(), fn))) { defaultValue = ChoType.GetRawDefaultValue(ChoTypeDescriptor.GetProperty(rec.GetType(), fn)); } else { defaultValueExists = false; } if (defaultValueExists) { if (fieldConfig.Converters.IsNullOrEmpty()) { fieldValue = ChoConvert.ConvertFrom(defaultValue, ChoType.GetMemberInfo(rec.GetType(), fn), null, culture); } else { fieldValue = ChoConvert.ConvertFrom(defaultValue, ChoType.GetMemberType(rec.GetType(), fn), null, fieldConfig.Converters.ToArray(), null, culture); } ChoType.SetMemberValue(rec, fn, fieldValue); } } catch { } }
private bool IsIgnored(Type type, string jsonPropertyName, string propertyName) { if (_configuration != null && _configuration.ContainsRecordConfigForType(type)) { var dict = _configuration.JSONRecordFieldConfigurationsForType[type]; if (dict != null && dict.ContainsKey(jsonPropertyName)) { return(false); } } if (!_ignores.ContainsKey(type)) { var pd = ChoTypeDescriptor.GetProperty(type, propertyName); return(pd != null?pd.Attributes.OfType <ChoIgnoreMemberAttribute>().Any() : true); } return(_ignores[type].Contains(jsonPropertyName)); }
public static object GetDefaultValue(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig) { if (fieldConfig.IsDefaultValueSpecified) { return(fieldConfig.DefaultValue); } else { if (rec is ExpandoObject) { } else if (ChoType.HasProperty(rec.GetType(), fn)) { return(ChoType.GetRawDefaultValue(ChoTypeDescriptor.GetProperty(rec.GetType(), fn))); } } return(null); }
public static bool SetFallbackValue(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, CultureInfo culture) { if (rec is ExpandoObject) { return(((IDictionary <string, object>)rec).SetFallbackValue(fn, fieldConfig, culture)); } object fieldValue = null; //Set Fallback value to member bool FallbackValueExists = true; object FallbackValue = null; if (fieldConfig.IsFallbackValueSpecified) { FallbackValue = fieldConfig.FallbackValue; } else if (ChoType.HasFallbackValue(ChoTypeDescriptor.GetProperty(rec.GetType(), fn))) { FallbackValue = ChoType.GetRawFallbackValue(ChoTypeDescriptor.GetProperty(rec.GetType(), fn)); } else { FallbackValueExists = false; } if (FallbackValueExists) { if (fieldConfig.Converters.IsNullOrEmpty()) { fieldValue = ChoConvert.ConvertFrom(FallbackValue, ChoType.GetMemberInfo(rec.GetType(), fn), null, culture); } else { fieldValue = ChoConvert.ConvertFrom(FallbackValue, ChoType.GetMemberType(rec.GetType(), fn), null, fieldConfig.Converters.ToArray(), null, culture); } ChoType.SetMemberValue(rec, fn, fieldValue); } return(FallbackValueExists); }
public static PropertyDescriptor GetNestedProperty(Type recType, string pn) { if (pn.IsNullOrWhiteSpace()) { return(null); } string[] pnTokens = pn.SplitNTrim("."); PropertyDescriptor pd = null; for (int index = 0; index < pnTokens.Length - 1; index++) { pd = ChoTypeDescriptor.GetProperty(recType, pnTokens[index]); if (pd == null) { return(null); } recType = pd.PropertyType; } return(ChoTypeDescriptor.GetProperty(recType, pnTokens.Last())); }
private bool IsIgnored(Type type, string jsonPropertyName, string propertyName, string propertyFullName) { if (_configuration.IgnoredFields.Contains(propertyFullName) || _configuration.IgnoredFields.Contains(propertyName)) { return(true); } var pd = ChoTypeDescriptor.GetProperty(type, propertyName); if (pd != null) { if (pd.Attributes.OfType <ChoIgnoreMemberAttribute>().Any()) { return(true); } else if (pd.Attributes.OfType <JsonIgnoreAttribute>().Any()) { return(true); } } return(false); }
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization) { var property = base.CreateProperty(member, memberSerialization); var propertyFullName = member.GetFullName(); if (IsIgnored(property.DeclaringType, property.PropertyName, property.UnderlyingName, propertyFullName)) { property.ShouldSerialize = i => false; property.Ignored = true; } if (IsRenamed(property.DeclaringType, property.PropertyName, property.UnderlyingName, propertyFullName, out var newJsonPropertyName)) { if (!newJsonPropertyName.IsNullOrWhiteSpace()) { property.PropertyName = newJsonPropertyName; } } if (_configuration.ContainsRecordConfigForType(property.DeclaringType)) { var dict = _configuration.GetRecordConfigDictionaryForType(property.DeclaringType); if (dict != null && dict.ContainsKey(property.UnderlyingName)) { property.Converter = property.MemberConverter = new ChoContractResolverJsonConverter(dict[property.UnderlyingName] as ChoFileRecordFieldConfiguration, _configuration.Culture, property.PropertyType, _configuration.ObjectValidationMode, member) { Configuration = _configuration as ChoFileRecordConfiguration, Reader = Reader, CallbackRecordFieldRead = CallbackRecordFieldRead, Writer = Writer, CallbackRecordFieldWrite = CallbackRecordFieldWrite }; } } else if (_configuration.RecordFieldConfigurations.Any(f => f.DeclaringMember == propertyFullName)) { var fc = _configuration.RecordFieldConfigurations.First(f => f.DeclaringMember == propertyFullName) as ChoFileRecordFieldConfiguration; property.Converter = property.MemberConverter = new ChoContractResolverJsonConverter(fc, _configuration.Culture, property.PropertyType, _configuration.ObjectValidationMode, member) { Configuration = _configuration as ChoFileRecordConfiguration, Reader = Reader, CallbackRecordFieldRead = CallbackRecordFieldRead, Writer = Writer, CallbackRecordFieldWrite = CallbackRecordFieldWrite }; property.DefaultValue = fc.DefaultValue; property.Order = fc.Order; } else if (_configuration.RecordFieldConfigurations.Any(f => f.Name == propertyFullName)) { var fc = _configuration.RecordFieldConfigurations.First(f => f.Name == propertyFullName) as ChoFileRecordFieldConfiguration; property.MemberConverter = new ChoContractResolverJsonConverter(fc, _configuration.Culture, property.PropertyType, _configuration.ObjectValidationMode, member) { Configuration = _configuration as ChoFileRecordConfiguration, Reader = Reader, CallbackRecordFieldRead = CallbackRecordFieldRead, Writer = Writer, CallbackRecordFieldWrite = CallbackRecordFieldWrite }; property.DefaultValue = fc.DefaultValue; property.Order = fc.Order; } else { var pd = ChoTypeDescriptor.GetProperty(property.DeclaringType, property.UnderlyingName); if (pd != null) { if (pd.Attributes.OfType <DefaultValueAttribute>().Any()) { property.DefaultValue = pd.Attributes.OfType <DefaultValueAttribute>().First().Value; } if (pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any()) { property.Order = pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().First().Order; } else if (pd.Attributes.OfType <DisplayAttribute>().Any()) { property.Order = pd.Attributes.OfType <DisplayAttribute>().First().Order; } else if (pd.Attributes.OfType <ColumnAttribute>().Any()) { property.Order = pd.Attributes.OfType <ColumnAttribute>().First().Order; } if (pd.Attributes.OfType <JsonPropertyAttribute>().Any()) { var jp = pd.Attributes.OfType <JsonPropertyAttribute>().First(); property.PropertyName = jp.PropertyName; property.Order = jp.Order; property.Required = jp.Required; property.ReferenceLoopHandling = jp.ItemReferenceLoopHandling; property.IsReference = jp.IsReference; property.TypeNameHandling = jp.TypeNameHandling; property.ObjectCreationHandling = jp.ObjectCreationHandling; property.ReferenceLoopHandling = jp.ReferenceLoopHandling; property.DefaultValueHandling = jp.DefaultValueHandling; property.NullValueHandling = jp.NullValueHandling; property.ItemTypeNameHandling = jp.ItemTypeNameHandling; property.ItemIsReference = jp.ItemIsReference; } else if (pd.Attributes.OfType <ChoJSONPathAttribute>().Any()) { property.PropertyName = pd.Attributes.OfType <ChoJSONPathAttribute>().First().JSONPath; } property.Converter = property.MemberConverter = new ChoContractResolverJsonConverter(null, _configuration.Culture, property.PropertyType, _configuration.ObjectValidationMode, member) { Configuration = _configuration as ChoFileRecordConfiguration, Reader = Reader, CallbackRecordFieldRead = CallbackRecordFieldRead, Writer = Writer, CallbackRecordFieldWrite = CallbackRecordFieldWrite }; } } if (_configuration.NullValueHandling == ChoNullValueHandling.Ignore) { property.NullValueHandling = NullValueHandling.Ignore; } else { property.NullValueHandling = NullValueHandling.Include; } return(property); }
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 (!IsDynamicObject && (RecordType.IsGenericType && RecordType.GetGenericTypeDefinition() == typeof(KeyValuePair <,>))) { NodeName = NodeName.IsNullOrWhiteSpace() ? "KeyValuePair" : NodeName; RootName = RootName.IsNullOrWhiteSpace() ? "KeyValuePairs" : RootName; } else if (!IsDynamicObject && !typeof(IChoScalarObject).IsAssignableFrom(RecordType)) { NodeName = NodeName.IsNullOrWhiteSpace() ? RecordType.Name : NodeName; RootName = RootName.IsNullOrWhiteSpace() ? NodeName.ToPlural() : RootName; } } else { RootName = RootName.IsNullOrWhiteSpace() ? XPath.SplitNTrim("/").Where(t => !t.IsNullOrWhiteSpace() && t.NTrim() != "." && t.NTrim() != ".." && t.NTrim() != "*").FirstOrDefault() : RootName; NodeName = NodeName.IsNullOrWhiteSpace() ? XPath.SplitNTrim("/").Where(t => !t.IsNullOrWhiteSpace() && t.NTrim() != "." && t.NTrim() != ".." && t.NTrim() != "*").Skip(1).FirstOrDefault() : NodeName; } string rootName = null; string nodeName = null; ChoXmlDocumentRootAttribute da = TypeDescriptor.GetAttributes(RecordType).OfType <ChoXmlDocumentRootAttribute>().FirstOrDefault(); if (da != null) { rootName = da.Name; } else { XmlRootAttribute ra = TypeDescriptor.GetAttributes(RecordType).OfType <XmlRootAttribute>().FirstOrDefault(); if (ra != null) { nodeName = ra.ElementName; } } RootName = RootName.IsNullOrWhiteSpace() && !rootName.IsNullOrWhiteSpace() ? rootName : RootName; NodeName = NodeName.IsNullOrWhiteSpace() && !nodeName.IsNullOrWhiteSpace() ? nodeName : NodeName; RootName = RootName.IsNullOrWhiteSpace() && !NodeName.IsNullOrWhiteSpace() ? NodeName.ToPlural() : RootName; if (!RootName.IsNullOrWhiteSpace() && RootName.ToSingular() != RootName) { NodeName = NodeName.IsNullOrWhiteSpace() && !RootName.IsNullOrWhiteSpace() ? RootName.ToSingular() : NodeName; } if (RootName.IsNullOrWhiteSpace()) { RootName = "Root"; } 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()) { DiscoverRecordFields(RecordType); } else if (xpr != null) { XmlRecordFieldConfigurations.AddRange(DiscoverRecordFieldsFromXElement(xpr)); } else if (!fieldNames.IsNullOrEmpty()) { foreach (string fn in fieldNames) { if (IgnoredFields.Contains(fn)) { continue; } if (fn.StartsWith("_")) { string fn1 = fn.Substring(1); var obj = new ChoXmlRecordFieldConfiguration(fn, xPath: $"./{fn1}"); obj.FieldName = fn1; obj.IsXmlAttribute = true; XmlRecordFieldConfigurations.Add(obj); } else if (fn.EndsWith("_")) { string fn1 = fn.Substring(0, fn.Length - 1); var obj = new ChoXmlRecordFieldConfiguration(fn, xPath: $"./{fn1}"); obj.FieldName = fn1; obj.IsXmlCDATA = true; XmlRecordFieldConfigurations.Add(obj); } else { var obj = new ChoXmlRecordFieldConfiguration(fn, xPath: $"./{fn}"); XmlRecordFieldConfigurations.Add(obj); } } } } else { IsComplexXPathUsed = false; foreach (var fc in XmlRecordFieldConfigurations) { if (fc.IsArray == null) { fc.IsArray = typeof(ICollection).IsAssignableFrom(fc.FieldType); } if (fc.FieldName.IsNullOrWhiteSpace()) { fc.FieldName = fc.Name; } 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))); } PIDict = new Dictionary <string, System.Reflection.PropertyInfo>(); PDDict = new Dictionary <string, PropertyDescriptor>(); foreach (var fc in XmlRecordFieldConfigurations) { var pd1 = fc.DeclaringMember.IsNullOrWhiteSpace() ? ChoTypeDescriptor.GetProperty(RecordType, fc.Name) : ChoTypeDescriptor.GetProperty(RecordType, fc.DeclaringMember); if (pd1 != null) { fc.PropertyDescriptor = pd1; } if (fc.PropertyDescriptor == null) { fc.PropertyDescriptor = TypeDescriptor.GetProperties(RecordType).AsTypedEnumerable <PropertyDescriptor>().Where(pd => pd.Name == fc.Name).FirstOrDefault(); } if (fc.PropertyDescriptor == null) { continue; } PIDict.Add(fc.Name, fc.PropertyDescriptor.ComponentType.GetProperty(fc.PropertyDescriptor.Name)); PDDict.Add(fc.Name, fc.PropertyDescriptor); } RecordFieldConfigurationsDict = XmlRecordFieldConfigurations.OrderBy(c => c.IsXmlAttribute).Where(i => !i.Name.IsNullOrWhiteSpace()).ToDictionary(i => i.Name); if (XmlRecordFieldConfigurations.Where(e => e.IsNullable).Any() || NullValueHandling == ChoNullValueHandling.Default) { if (NamespaceManager != null) { if (!NamespaceManager.HasNamespace("xsi")) { NamespaceManager.AddNamespace("xsi", ChoXmlSettings.XmlSchemaInstanceNamespace); } if (!NamespaceManager.HasNamespace("xsd")) { NamespaceManager.AddNamespace("xsd", ChoXmlSettings.XmlSchemaNamespace); } } } LoadNCacheMembers(XmlRecordFieldConfigurations); }
public override void Validate(object state) { if (state == null) { base.Validate(state); if (Separator.IsNullOrWhiteSpace()) { throw new ChoRecordConfigurationException("Separator can't be null or whitespace."); } if (Separator == EOLDelimiter) { throw new ChoRecordConfigurationException("Separator [{0}] can't be same as EODDelimiter [{1}]".FormatString(Separator, EOLDelimiter)); } if (Separator.Contains(QuoteChar)) { throw new ChoRecordConfigurationException("QuoteChar [{0}] can't be one of Delimiter characters [{1}]".FormatString(QuoteChar, Separator)); } if (Comments != null && Comments.Contains(Separator)) { throw new ChoRecordConfigurationException("One of the Comments contains Delimiter. Not allowed."); } if (RecordStart.IsNullOrWhiteSpace() && RecordEnd.IsNullOrWhiteSpace()) { } else { if (RecordStart.IsNullOrWhiteSpace()) { throw new ChoRecordConfigurationException("RecordStart is missing."); } //else if (RecordEnd.IsNullOrWhiteSpace()) // RecordEnd = RecordStart; //throw new ChoRecordConfigurationException("RecordEnd is missing."); if (RecordStart.Contains("*") || RecordStart.Contains("?")) { _isWildcardComparisionOnRecordStart = true; _recordStartWildCard = new ChoWildcard(RecordStart); } if (!RecordEnd.IsNullOrWhiteSpace() && (RecordEnd.EndsWith("*") || RecordStart.Contains("?"))) { _isWildcardComparisionOnRecordEnd = true; _recordEndWildCard = new ChoWildcard(RecordEnd); } } //Validate Header if (FileHeaderConfiguration != null) { if (FileHeaderConfiguration.FillChar != null) { if (FileHeaderConfiguration.FillChar.Value == ChoCharEx.NUL) { throw new ChoRecordConfigurationException("Invalid '{0}' FillChar specified.".FormatString(FileHeaderConfiguration.FillChar)); } if (Separator.Contains(FileHeaderConfiguration.FillChar.Value)) { throw new ChoRecordConfigurationException("FillChar [{0}] can't be one of Delimiter characters [{1}]".FormatString(FileHeaderConfiguration.FillChar, Separator)); } if (EOLDelimiter.Contains(FileHeaderConfiguration.FillChar.Value)) { throw new ChoRecordConfigurationException("FillChar [{0}] can't be one of EOLDelimiter characters [{1}]".FormatString(FileHeaderConfiguration.FillChar.Value, EOLDelimiter)); } if ((from comm in Comments where comm.Contains(FileHeaderConfiguration.FillChar.Value.ToString()) select comm).Any()) { throw new ChoRecordConfigurationException("One of the Comments contains FillChar. Not allowed."); } } } } else { string[] headers = state as string[]; if (AutoDiscoverColumns && KVPRecordFieldConfigurations.Count == 0) { AutoDiscoveredColumns = true; if (headers != null && IsDynamicObject) { KVPRecordFieldConfigurations = (from header in headers where !IgnoredFields.Contains(header) select new ChoKVPRecordFieldConfiguration(header)).ToList(); } else { MapRecordFields(RecordType); } } if (KVPRecordFieldConfigurations.Count <= 0) { throw new ChoRecordConfigurationException("No record fields specified."); } //Validate each record field foreach (var fieldConfig in KVPRecordFieldConfigurations) { fieldConfig.Validate(this); } //Check if any field has empty names if (KVPRecordFieldConfigurations.Where(i => i.FieldName.IsNullOrWhiteSpace()).Count() > 0) { throw new ChoRecordConfigurationException("Some fields has empty field name specified."); } //Check field names for duplicate string[] dupFields = KVPRecordFieldConfigurations.GroupBy(i => i.FieldName, FileHeaderConfiguration.StringComparer) .Where(g => g.Count() > 1) .Select(g => g.Key).ToArray(); if (dupFields.Length > 0 /* && !IgnoreDuplicateFields */) { throw new ChoRecordConfigurationException("Duplicate field name(s) [Name: {0}] found.".FormatString(String.Join(",", dupFields))); } PIDict = new Dictionary <string, System.Reflection.PropertyInfo>(FileHeaderConfiguration.StringComparer); PDDict = new Dictionary <string, PropertyDescriptor>(FileHeaderConfiguration.StringComparer); foreach (var fc in KVPRecordFieldConfigurations) { var pd1 = fc.DeclaringMember.IsNullOrWhiteSpace() ? ChoTypeDescriptor.GetProperty(RecordType, fc.Name) : ChoTypeDescriptor.GetProperty(RecordType, fc.DeclaringMember); if (pd1 != null) { fc.PropertyDescriptor = pd1; } if (fc.PropertyDescriptor == null) { fc.PropertyDescriptor = TypeDescriptor.GetProperties(RecordType).AsTypedEnumerable <PropertyDescriptor>().Where(pd => pd.Name == fc.Name).FirstOrDefault(); } if (fc.PropertyDescriptor == null) { continue; } PIDict.Add(fc.Name, fc.PropertyDescriptor.ComponentType.GetProperty(fc.PropertyDescriptor.Name)); PDDict.Add(fc.Name, fc.PropertyDescriptor); } RecordFieldConfigurationsDict = KVPRecordFieldConfigurations.Where(i => !i.Name.IsNullOrWhiteSpace()).GroupBy(i => i.Name).Select(g => g.First()).ToDictionary(i => i.Name, FileHeaderConfiguration.StringComparer); RecordFieldConfigurationsDict2 = KVPRecordFieldConfigurations.Where(i => !i.FieldName.IsNullOrWhiteSpace()).GroupBy(i => i.Name).Select(g => g.First()).ToDictionary(i => i.FieldName, FileHeaderConfiguration.StringComparer); if (IsDynamicObject) { AlternativeKeys = RecordFieldConfigurationsDict2.ToDictionary(kvp => { if (kvp.Key == kvp.Value.Name) { return(kvp.Value.Name.ToValidVariableName()); } else { return(kvp.Value.Name); } }, kvp => kvp.Key, FileHeaderConfiguration.StringComparer); } else { AlternativeKeys = RecordFieldConfigurationsDict2.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Name, FileHeaderConfiguration.StringComparer); } FCArray = RecordFieldConfigurationsDict.ToArray(); LoadNCacheMembers(KVPRecordFieldConfigurations); } }
public override void Validate(object state) { if (TurnOnAutoDiscoverJsonConverters) { ChoJSONConvertersCache.Init(); } if (_jsonSerializerSettings != null) { foreach (var conv in GetJSONConverters()) { _jsonSerializerSettings.Converters.Add(conv); } foreach (var conv in _jsonSerializerSettings.Converters.OfType <IChoJSONConverter>()) { conv.Serializer = JsonSerializer; conv.Context = new ChoDynamicObject(); conv.Context.Configuration = this; } foreach (var conv in _jsonSerializerSettings.Converters) { JsonSerializer.Converters.Add(conv); } } if (RecordType != null) { Init(RecordType); } 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 (fieldNames != null && JSONRecordFieldConfigurations.Count > 0 && FlattenNode) { JSONRecordFieldConfigurations.Clear(); } if (AutoDiscoverColumns && JSONRecordFieldConfigurations.Count == 0) { if (RecordType != null && !IsDynamicObject && /*&& RecordType != typeof(ExpandoObject)*/ ChoTypeDescriptor.GetProperties(RecordType).Where(pd => pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any()).Any()) { MapRecordFields(RecordType); } 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) { if (IgnoredFields.Contains(fn)) { continue; } 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.FieldName) .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))); } PIDict = new Dictionary <string, System.Reflection.PropertyInfo>(StringComparer.InvariantCultureIgnoreCase); PDDict = new Dictionary <string, PropertyDescriptor>(StringComparer.InvariantCultureIgnoreCase); foreach (var fc in JSONRecordFieldConfigurations) { var pd1 = fc.DeclaringMember.IsNullOrWhiteSpace() ? ChoTypeDescriptor.GetProperty(RecordType, fc.Name) : ChoTypeDescriptor.GetProperty(RecordType, fc.DeclaringMember); if (pd1 != null) { fc.PropertyDescriptor = pd1; } if (fc.PropertyDescriptor == null) { fc.PropertyDescriptor = TypeDescriptor.GetProperties(RecordType).AsTypedEnumerable <PropertyDescriptor>().Where(pd => pd.Name == fc.Name).FirstOrDefault(); } if (fc.PropertyDescriptor == null) { continue; } PIDict.Add(fc.Name, fc.PropertyDescriptor.ComponentType.GetProperty(fc.PropertyDescriptor.Name)); PDDict.Add(fc.Name, fc.PropertyDescriptor); } RecordFieldConfigurationsDict = JSONRecordFieldConfigurations.Where(i => !i.Name.IsNullOrWhiteSpace()).ToDictionary(i => i.Name); LoadNCacheMembers(JSONRecordFieldConfigurations); }
public override void Validate(object state) { base.Validate(state); string line = null; string[] fieldNames = null; if (state is Tuple <long, string> ) { line = ((Tuple <long, string>)state).Item2; } else { fieldNames = state as string[]; } if (RecordLength <= 0 && line != null) { RecordLength = line.Length; } //Validate Header if (FileHeaderConfiguration != null) { if (FileHeaderConfiguration.FillChar != null) { if (FileHeaderConfiguration.FillChar.Value == ChoCharEx.NUL) { throw new ChoRecordConfigurationException("Invalid '{0}' FillChar specified.".FormatString(FileHeaderConfiguration.FillChar)); } if (EOLDelimiter.Contains(FileHeaderConfiguration.FillChar.Value)) { throw new ChoRecordConfigurationException("FillChar [{0}] can't be one of EOLDelimiter characters [{1}]".FormatString(FileHeaderConfiguration.FillChar.Value, EOLDelimiter)); } if (Comments != null) { if ((from comm in Comments where comm.Contains(FileHeaderConfiguration.FillChar.Value.ToString()) select comm).Any()) { throw new ChoRecordConfigurationException("One of the Comments contains FillChar. Not allowed."); } } } } //string[] headers = state as string[]; if (AutoDiscoverColumns && FixedLengthRecordFieldConfigurations.Count == 0 /*&& headers != null*/) { if (RecordType != null && !IsDynamicObject && ChoTypeDescriptor.GetProperties(RecordType).Where(pd => pd.Attributes.OfType <ChoFixedLengthRecordFieldAttribute>().Any()).Any()) { MapRecordFields(RecordType); } else if (!line.IsNullOrEmpty()) { int index = 0; if (IsDynamicObject) { foreach (var item in DiscoverColumns(line)) { var obj = new ChoFixedLengthRecordFieldConfiguration(FileHeaderConfiguration.HasHeaderRecord ? item.Item1 : "Column{0}".FormatString(++index), item.Item2, item.Item3); FixedLengthRecordFieldConfigurations.Add(obj); } } else { Tuple <string, int, int>[] tuples = DiscoverColumns(line); foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(RecordType)) { if (index < tuples.Length) { var obj = new ChoFixedLengthRecordFieldConfiguration(FileHeaderConfiguration.HasHeaderRecord ? tuples[index].Item1 : pd.Name, tuples[index].Item2, tuples[index].Item3); FixedLengthRecordFieldConfigurations.Add(obj); index++; } else { break; } } } } else if (!fieldNames.IsNullOrEmpty()) { int startIndex = 0; int fieldLength = ChoFixedLengthFieldDefaultSizeConfiguation.Instance.GetSize(typeof(string)); foreach (string fn in fieldNames) { if (IgnoredFields.Contains(fn)) { continue; } var obj = new ChoFixedLengthRecordFieldConfiguration(fn, startIndex, fieldLength); FixedLengthRecordFieldConfigurations.Add(obj); startIndex += fieldLength; } } } if (FixedLengthRecordFieldConfigurations.Count == 0) { throw new ChoRecordConfigurationException("No record fields specified."); } //Derive record length from fields if (RecordLength <= 0) { int maxStartIndex = FixedLengthRecordFieldConfigurations.Max(f => f.StartIndex); int maxSize = FixedLengthRecordFieldConfigurations.Where(f => f.StartIndex == maxStartIndex).Max(f1 => f1.Size.Value); var fc = FixedLengthRecordFieldConfigurations.Where(f => f.StartIndex == maxStartIndex && f.Size.Value == maxSize).FirstOrDefault(); if (fc != null) { RecordLength = fc.StartIndex + fc.Size.Value; } } if (RecordLength <= 0) { throw new ChoRecordConfigurationException("RecordLength must be > 0"); } //Check if any field has empty names if (FixedLengthRecordFieldConfigurations.Where(i => i.FieldName.IsNullOrWhiteSpace()).Count() > 0) { throw new ChoRecordConfigurationException("Some fields has empty field name specified."); } //Check field names for duplicate string[] dupFields = FixedLengthRecordFieldConfigurations.GroupBy(i => i.FieldName, FileHeaderConfiguration.StringComparer) .Where(g => g.Count() > 1) .Select(g => g.Key).ToArray(); if (dupFields.Length > 0) { throw new ChoRecordConfigurationException("Duplicate field names [Name: {0}] specified to record fields.".FormatString(String.Join(",", dupFields))); } //Find duplicate fields with start index ChoFixedLengthRecordFieldConfiguration dupRecConfig = FixedLengthRecordFieldConfigurations.Where(c => c.Size > 0).GroupBy(i => i.StartIndex).Where(g => g.Count() > 1).Select(g => g.FirstOrDefault()).FirstOrDefault(); if (dupRecConfig != null && !IgnoreDuplicateFields) { throw new ChoRecordConfigurationException("Found duplicate '{0}' record field with same start index.".FormatString(dupRecConfig.FieldName)); } //Check any overlapping fields specified foreach (var f in FixedLengthRecordFieldConfigurations) { if (f.StartIndex + f.Size.Value > RecordLength) { throw new ChoRecordConfigurationException("Found '{0}' record field out of bounds of record length.".FormatString(f.FieldName)); } } PIDict = new Dictionary <string, System.Reflection.PropertyInfo>(); PDDict = new Dictionary <string, PropertyDescriptor>(); foreach (var fc in FixedLengthRecordFieldConfigurations) { var pd1 = fc.DeclaringMember.IsNullOrWhiteSpace() ? ChoTypeDescriptor.GetProperty(RecordType, fc.Name) : ChoTypeDescriptor.GetProperty(RecordType, fc.DeclaringMember); if (pd1 != null) { fc.PropertyDescriptor = pd1; } if (fc.PropertyDescriptor == null) { fc.PropertyDescriptor = ChoTypeDescriptor.GetProperties(RecordType).Where(pd => pd.Name == fc.Name).FirstOrDefault(); } if (fc.PropertyDescriptor == null) { continue; } PIDict.Add(fc.Name, fc.PropertyDescriptor.ComponentType.GetProperty(fc.PropertyDescriptor.Name)); PDDict.Add(fc.Name, fc.PropertyDescriptor); } RecordFieldConfigurationsDict = FixedLengthRecordFieldConfigurations.OrderBy(i => i.StartIndex).Where(i => !i.Name.IsNullOrWhiteSpace()).ToDictionary(i => i.Name, FileHeaderConfiguration.StringComparer); RecordFieldConfigurationsDict2 = FixedLengthRecordFieldConfigurations.OrderBy(i => i.StartIndex).Where(i => !i.FieldName.IsNullOrWhiteSpace()).ToDictionary(i => i.FieldName, FileHeaderConfiguration.StringComparer); if (IsDynamicObject) { AlternativeKeys = RecordFieldConfigurationsDict2.ToDictionary(kvp => { if (kvp.Key == kvp.Value.Name) { return(kvp.Value.Name.ToValidVariableName()); } else { return(kvp.Value.Name); } }, kvp => kvp.Key, FileHeaderConfiguration.StringComparer); } else { AlternativeKeys = RecordFieldConfigurationsDict2.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Name, FileHeaderConfiguration.StringComparer); } //Validate each record field foreach (var fieldConfig in FixedLengthRecordFieldConfigurations) { fieldConfig.Validate(this); } if (!FileHeaderConfiguration.HasHeaderRecord) { } else { } LoadNCacheMembers(FixedLengthRecordFieldConfigurations); }
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization) { var property = base.CreateProperty(member, memberSerialization); var propertyFullName = member.GetFullName(); if (IsIgnored(property.DeclaringType, property.PropertyName, property.UnderlyingName, propertyFullName)) { property.ShouldSerialize = i => false; property.Ignored = true; } if (IsRenamed(property.DeclaringType, property.PropertyName, property.UnderlyingName, propertyFullName, out var newJsonPropertyName)) { if (!newJsonPropertyName.IsNullOrWhiteSpace()) { property.PropertyName = newJsonPropertyName; } } if (_configuration.ContainsRecordConfigForType(property.DeclaringType)) { var dict = _configuration.JSONRecordFieldConfigurationsForType[property.DeclaringType]; if (dict != null && dict.ContainsKey(property.UnderlyingName)) { property.Converter = property.MemberConverter = new ChoContractResolverJsonConverter(dict[property.UnderlyingName], _configuration.Culture, property.PropertyType, _configuration.ObjectValidationMode, member); } } else if (_configuration.JSONRecordFieldConfigurations.Any(f => f.DeclaringMember == propertyFullName)) { var fc = _configuration.JSONRecordFieldConfigurations.First(f => f.DeclaringMember == propertyFullName); property.MemberConverter = new ChoContractResolverJsonConverter(fc, _configuration.Culture, property.PropertyType, _configuration.ObjectValidationMode, member); property.DefaultValue = fc.DefaultValue; property.Order = fc.Order; } else if (_configuration.JSONRecordFieldConfigurations.Any(f => f.Name == propertyFullName)) { var fc = _configuration.JSONRecordFieldConfigurations.First(f => f.Name == propertyFullName); property.MemberConverter = new ChoContractResolverJsonConverter(fc, _configuration.Culture, property.PropertyType, _configuration.ObjectValidationMode, member); property.DefaultValue = fc.DefaultValue; property.Order = fc.Order; } else { var pd = ChoTypeDescriptor.GetProperty(property.DeclaringType, property.UnderlyingName); if (pd != null) { if (pd.Attributes.OfType <DefaultValueAttribute>().Any()) { property.DefaultValue = pd.Attributes.OfType <DefaultValueAttribute>().First().Value; } if (pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any()) { property.Order = pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().First().Order; } } } if (_configuration.NullValueHandling == ChoNullValueHandling.Ignore) { property.NullValueHandling = NullValueHandling.Ignore; } else { property.NullValueHandling = NullValueHandling.Include; } return(property); }
public override void Validate(object state) { if (RecordType != null) { Init(RecordType); } base.Validate(state); string[] fieldNames = null; IDictionary <string, object> yamlNode = null; if (state is Tuple <long, IDictionary <string, object> > ) { yamlNode = ((Tuple <long, IDictionary <string, object> >)state).Item2; } else { fieldNames = state as string[]; } if (AutoDiscoverColumns && YamlRecordFieldConfigurations.Count == 0) { if (RecordType != null && !IsDynamicObject && /*&& RecordType != typeof(ExpandoObject)*/ ChoTypeDescriptor.GetProperties(RecordType).Where(pd => pd.Attributes.OfType <ChoYamlRecordFieldAttribute>().Any()).Any()) { MapRecordFields(RecordType); } else if (yamlNode != null) { Dictionary <string, ChoYamlRecordFieldConfiguration> dict = new Dictionary <string, ChoYamlRecordFieldConfiguration>(StringComparer.CurrentCultureIgnoreCase); foreach (var entry in yamlNode) { if (!dict.ContainsKey(entry.Key)) { dict.Add(entry.Key, new ChoYamlRecordFieldConfiguration(entry.Key, (string)null)); } else { throw new ChoRecordConfigurationException("Duplicate field(s) [Name(s): {0}] found.".FormatString(entry.Key)); } } foreach (ChoYamlRecordFieldConfiguration obj in dict.Values) { YamlRecordFieldConfigurations.Add(obj); } } else if (!fieldNames.IsNullOrEmpty()) { foreach (string fn in fieldNames) { if (IgnoredFields.Contains(fn)) { continue; } var obj = new ChoYamlRecordFieldConfiguration(fn, (string)null); YamlRecordFieldConfigurations.Add(obj); } } } else { foreach (var fc in YamlRecordFieldConfigurations) { fc.ComplexYamlPathUsed = !(fc.YamlPath.IsNullOrWhiteSpace() || String.Compare(fc.FieldName, fc.YamlPath, true) == 0); } } if (YamlRecordFieldConfigurations.Count <= 0) { throw new ChoRecordConfigurationException("No record fields specified."); } //Validate each record field foreach (var fieldConfig in YamlRecordFieldConfigurations) { fieldConfig.Validate(this); } //Check field position for duplicate string[] dupFields = YamlRecordFieldConfigurations.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))); } PIDict = new Dictionary <string, System.Reflection.PropertyInfo>(); PDDict = new Dictionary <string, PropertyDescriptor>(); foreach (var fc in YamlRecordFieldConfigurations) { var pd1 = fc.DeclaringMember.IsNullOrWhiteSpace() ? ChoTypeDescriptor.GetProperty(RecordType, fc.Name) : ChoTypeDescriptor.GetProperty(RecordType, fc.DeclaringMember); if (pd1 != null) { fc.PropertyDescriptor = pd1; } if (fc.PropertyDescriptor == null) { fc.PropertyDescriptor = TypeDescriptor.GetProperties(RecordType).AsTypedEnumerable <PropertyDescriptor>().Where(pd => pd.Name == fc.Name).FirstOrDefault(); } if (fc.PropertyDescriptor == null) { continue; } PIDict.Add(fc.Name, fc.PropertyDescriptor.ComponentType.GetProperty(fc.PropertyDescriptor.Name)); PDDict.Add(fc.Name, fc.PropertyDescriptor); } RecordFieldConfigurationsDict = YamlRecordFieldConfigurations.Where(i => !i.Name.IsNullOrWhiteSpace()).ToDictionary(i => i.Name); LoadNCacheMembers(YamlRecordFieldConfigurations); }
public static bool IsValidFor(this object @this, PropertyDescriptor mi, out Exception aggEx) { aggEx = null; ChoGuard.ArgumentNotNullOrEmpty(@this, "Target"); if (@this == null) { return(true); } var results = new List <ValidationResult>(); object surrObj = ChoMetadataObjectCache.Default.GetMetadataObject(@this); bool result = false; if (surrObj is IChoValidatable) { result = ((IChoValidatable)surrObj).TryValidateFor(@this, mi.Name, results); } else { var context = new ValidationContext(@this, null, null); context.MemberName = mi.Name; result = Validator.TryValidateValue(mi.GetValue(@this), context, results, ChoTypeDescriptor.GetPropetyAttributes <ValidationAttribute>(ChoTypeDescriptor.GetProperty <ValidationAttribute>(@this.GetType(), mi.Name))); } if (!result) { if (results.Count > 0) { aggEx = new ValidationException("Failed to validate '{0}' member. {2}{1}".FormatString(mi.Name, ToString(results), Environment.NewLine)); } else { aggEx = new ValidationException("Failed to valudate."); } } return(result); }
public static void DoMemberLevelValidation(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, ChoObjectValidationMode vm, object fieldValue) { if ((vm & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel) { if (fieldConfig.Validators.IsNullOrEmpty()) { if (!(rec is ExpandoObject)) { ChoValidator.ValidateFor(fieldValue, fn, ChoTypeDescriptor.GetPropetyAttributes <ValidationAttribute>(ChoTypeDescriptor.GetProperty <ValidationAttribute>(rec.GetType(), fn)).ToArray()); } } else { ChoValidator.ValidateFor(fieldValue, fn, fieldConfig.Validators); } } }
public static bool IsValidFor(this object @this, MemberInfo mi, out Exception aggEx) { aggEx = null; ChoGuard.ArgumentNotNullOrEmpty(@this, "Target"); if (@this == null) { return(true); } var results = new List <ValidationResult>(); object surrObj = ChoSurrogateObjectCache.Default.GetSurrogateObject(@this); if (surrObj is IChoValidatable) { ((IChoValidatable)surrObj).TryValidateFor(@this, mi.Name, results); } else { //if (ChoObjectMemberMetaDataCache.Default.IsRequired(mi) && ChoType.GetMemberValue(@this, mi) == null) // results.Add(new ValidationResult("Null value found for {0} member.".FormatString(mi.Name))); var context = new ValidationContext(@this, null, null); context.MemberName = mi.Name; Validator.TryValidateValue(ChoType.GetMemberValue(@this, mi), context, results, ChoTypeDescriptor.GetPropetyAttributes <ValidationAttribute>(ChoTypeDescriptor.GetProperty <ValidationAttribute>(@this.GetType(), mi.Name))); } if (results.Count > 0) { aggEx = new ApplicationException("Failed to validate '{0}' member. {2}{1}".FormatString(mi.Name, ToString(results), Environment.NewLine)); return(false); } else { return(true); } }