public override bool Execute() { // Find ignored fields var ignoredFields = IgnoredFields.GetIgnoredFields(annotationRepositoryService, compilerAdapterService); // Sort types by inheritance hierarchy var toEnhance = this.GetTypesToEnhance(); HashCodeInjection hashCodeInjection = new HashCodeInjection(this.Project); EqualsInjection equalsInjection = new EqualsInjection(this.Project); OperatorInjection operatorInjection = new OperatorInjection(this.Project); foreach (EqualsType enhancedTypeData in toEnhance) { var enhancedType = enhancedTypeData.EnhancedType; var config = enhancedTypeData.Config; try { if (!config.DoNotAddEquals) { equalsInjection.AddEqualsTo(enhancedType, config, ignoredFields); } if (!config.DoNotAddEqualityOperators) { operatorInjection.ProcessEqualityOperators(enhancedType, config); } if (!config.DoNotAddGetHashCode) { hashCodeInjection.AddGetHashCodeTo(enhancedType, config, ignoredFields); } } catch (InjectionException exception) { Message.Write(enhancedType, SeverityType.Error, exception.ErrorCode, exception.Message); return(false); } } return(true); }
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 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) { 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); }
public override void Validate(object state) { base.Validate(state); if (Delimiter.IsNull()) { throw new ChoRecordConfigurationException("Delimiter can't be null or whitespace."); } if (Delimiter == EOLDelimiter) { throw new ChoRecordConfigurationException("Delimiter [{0}] can't be same as EODDelimiter [{1}]".FormatString(Delimiter, EOLDelimiter)); } if (Delimiter.Contains(QuoteChar)) { throw new ChoRecordConfigurationException("QuoteChar [{0}] can't be one of Delimiter characters [{1}]".FormatString(QuoteChar, Delimiter)); } if (Comments != null && Comments.Contains(Delimiter)) { throw new ChoRecordConfigurationException("One of the Comments contains Delimiter. Not allowed."); } //Validate Header if (FileHeaderConfiguration != null) { if (FileHeaderConfiguration.FillChar != null) { ValidateChar(FileHeaderConfiguration.FillChar.Value, nameof(FileHeaderConfiguration.FillChar)); } } string[] headers = state as string[]; if (AutoDiscoverColumns && CSVRecordFieldConfigurations.Count == 0) { if (headers != null && IsDynamicObject) { int index = 0; CSVRecordFieldConfigurations = (from header in headers where !IgnoredFields.Contains(header) select new ChoCSVRecordFieldConfiguration(header, ++index) ).ToList(); } else { MapRecordFields(RecordType); } } else { int maxFieldPos = CSVRecordFieldConfigurations.Max(r => r.FieldPosition); foreach (var fieldConfig in CSVRecordFieldConfigurations) { if (fieldConfig.FieldPosition > 0) { continue; } fieldConfig.FieldPosition = ++maxFieldPos; } } if (CSVRecordFieldConfigurations.Count > 0) { MaxFieldPosition = CSVRecordFieldConfigurations.Max(r => r.FieldPosition); } else { throw new ChoRecordConfigurationException("No record fields specified."); } //Validate each record field foreach (var fieldConfig in CSVRecordFieldConfigurations) { fieldConfig.Validate(this); } //Check if any field has 0 if (CSVRecordFieldConfigurations.Where(i => i.FieldPosition <= 0).Count() > 0) { throw new ChoRecordConfigurationException("Some fields contain invalid field position. All field positions must be > 0."); } //Check field position for duplicate int[] dupPositions = CSVRecordFieldConfigurations.GroupBy(i => i.FieldPosition) .Where(g => g.Count() > 1) .Select(g => g.Key).ToArray(); if (dupPositions.Length > 0) { throw new ChoRecordConfigurationException("Duplicate field position(s) [Index: {0}] found.".FormatString(String.Join(",", dupPositions))); } if (!FileHeaderConfiguration.HasHeaderRecord) { } else { //Check if any field has empty names if (CSVRecordFieldConfigurations.Where(i => i.FieldName.IsNullOrWhiteSpace()).Count() > 0) { throw new ChoRecordConfigurationException("Some fields has empty field name specified."); } //Check field names for duplicate string[] dupFields = CSVRecordFieldConfigurations.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>(); PDDict = new Dictionary <string, PropertyDescriptor>(); foreach (var fc in CSVRecordFieldConfigurations) { if (fc.PropertyDescriptor == null) { fc.PropertyDescriptor = ChoTypeDescriptor.GetProperties(RecordType).Where(pd => pd.Name == fc.Name).FirstOrDefault(); } if (fc.PropertyDescriptor == null) { continue; } PIDict.Add(fc.FieldName, fc.PropertyDescriptor.ComponentType.GetProperty(fc.PropertyDescriptor.Name)); PDDict.Add(fc.FieldName, fc.PropertyDescriptor); } RecordFieldConfigurationsDict = CSVRecordFieldConfigurations.OrderBy(i => i.FieldPosition).Where(i => !i.FieldName.IsNullOrWhiteSpace()).ToDictionary(i => i.FieldName, FileHeaderConfiguration.StringComparer); //RecordFieldConfigurationsDictGroup = RecordFieldConfigurationsDict.GroupBy(kvp => kvp.Key.Contains(".") ? kvp.Key.SplitNTrim(".").First() : kvp.Key).ToDictionary(i => i.Key, i => i.ToArray()); RecordFieldConfigurationsDict2 = CSVRecordFieldConfigurations.OrderBy(i => i.FieldPosition).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); } //FCArray = RecordFieldConfigurationsDict.ToArray(); LoadNCacheMembers(CSVRecordFieldConfigurations); if (Sanitize) { ValidateChar(InjectionEscapeChar, nameof(InjectionEscapeChar)); foreach (char injectionChar in InjectionChars) { ValidateChar(injectionChar, nameof(InjectionChars)); if (injectionChar.ToString().IsAlphaNumeric()) { throw new ChoRecordConfigurationException("Invalid '{0}' injection char specified.".FormatString(injectionChar)); } } } if (RecordTypeConfiguration != null) { if (RecordSelector == null && RecordTypeCodeExtractor == null) { } } }