public virtual void Validate(object state)
{
if (EOLDelimiter.IsNullOrEmpty())
{
throw new ChoRecordConfigurationException("EOLDelimiter can't be null or empty.");
}
if (QuoteChar == ChoCharEx.NUL)
{
throw new ChoRecordConfigurationException("Invalid '{0}' quote character specified.".FormatString(QuoteChar));
}
if (EOLDelimiter.Contains(QuoteChar))
{
throw new ChoRecordConfigurationException("QuoteChar [{0}] can't be one EOLDelimiter characters [{1}]".FormatString(QuoteChar, EOLDelimiter));
}
if (Comments != null)
{
if (Comments.Contains(EOLDelimiter))
{
throw new ChoRecordConfigurationException("One of the Comments contains EOLDelimiter. Not allowed.");
}
else if (Comments.Where(c => c.IsNullOrWhiteSpace()).Any())
{
throw new ChoRecordConfigurationException("One of the Comments contains Whitespace characters. Not allowed.");
}
}
}
public override void Validate(object state)
{
base.Validate(state);
if (EOLDelimiter.IsNullOrEmpty())
{
throw new ChoRecordConfigurationException("EOLDelimiter can't be null or empty.");
}
if (QuoteChar == ChoCharEx.NUL)
{
throw new ChoRecordConfigurationException("Invalid '{0}' quote character specified.".FormatString(QuoteChar));
}
if (EOLDelimiter.Contains(QuoteChar))
{
throw new ChoRecordConfigurationException("QuoteChar [{0}] can't be one EOLDelimiter characters [{1}]".FormatString(QuoteChar, EOLDelimiter));
}
if (NestedColumnSeparator != null)
{
if (NestedColumnSeparator.Value == ChoCharEx.NUL)
{
throw new ChoRecordConfigurationException("Invalid '{0}' nested column separator specified.".FormatString(NestedColumnSeparator));
}
if (NestedColumnSeparator.Value == QuoteChar)
{
throw new ChoRecordConfigurationException("Nested column separator [{0}] can't be quote character [{1}]".FormatString(NestedColumnSeparator, QuoteChar));
}
if (EOLDelimiter.Contains(NestedColumnSeparator.Value))
{
throw new ChoRecordConfigurationException("Nested column separator [{0}] can't be one EOLDelimiter characters [{1}]".FormatString(NestedColumnSeparator, EOLDelimiter));
}
}
if (ArrayIndexSeparator != null)
{
if (ArrayIndexSeparator.Value == ChoCharEx.NUL)
{
throw new ChoRecordConfigurationException("Invalid '{0}' array index separator specified.".FormatString(ArrayIndexSeparator));
}
if (ArrayIndexSeparator.Value == QuoteChar)
{
throw new ChoRecordConfigurationException("Array index separator [{0}] can't be quote character [{1}]".FormatString(ArrayIndexSeparator, QuoteChar));
}
if (EOLDelimiter.Contains(ArrayIndexSeparator.Value))
{
throw new ChoRecordConfigurationException("Array index separator [{0}] can't be one EOLDelimiter characters [{1}]".FormatString(ArrayIndexSeparator, EOLDelimiter));
}
}
if (Comments != null)
{
if (Comments.Contains(EOLDelimiter))
{
throw new ChoRecordConfigurationException("One of the Comments contains EOLDelimiter. Not allowed.");
}
else if (Comments.Where(c => c.IsNullOrWhiteSpace()).Any())
{
throw new ChoRecordConfigurationException("One of the Comments contains Whitespace characters. Not allowed.");
}
}
}
private void ValidateChar(char src, string name)
{
if (src == ChoCharEx.NUL)
{
throw new ChoRecordConfigurationException("Invalid 'NUL' {0} specified.".FormatString(name));
}
if (Delimiter.Contains(src))
{
throw new ChoRecordConfigurationException("{2} [{0}] can't be one of Delimiter characters [{1}]".FormatString(FileHeaderConfiguration.FillChar, Delimiter, name));
}
if (EOLDelimiter.Contains(src))
{
throw new ChoRecordConfigurationException("{2} [{0}] can't be one of EOLDelimiter characters [{1}]".FormatString(src, EOLDelimiter, name));
}
if ((from comm in Comments
where comm.Contains(src.ToString())
select comm).Any())
{
throw new ChoRecordConfigurationException("One of the Comments contains {0}. Not allowed.".FormatString(name));
}
}
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())
{
int startIndex = 0;
int size = 0;
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(RecordType).Where(pd => pd.Attributes.OfType <ChoFixedLengthRecordFieldAttribute>().Any()))
{
//if (!pd.PropertyType.IsSimple())
// throw new ChoRecordConfigurationException("Property '{0}' is not a simple type.".FormatString(pd.Name));
if (FixedLengthFieldDefaultSizeConfiguation == null)
{
size = ChoFixedLengthFieldDefaultSizeConfiguation.Instance.GetSize(pd.PropertyType);
}
else
{
size = FixedLengthFieldDefaultSizeConfiguation.GetSize(pd.PropertyType);
}
var obj = new ChoFixedLengthRecordFieldConfiguration(pd.Name, startIndex, size);
obj.FieldType = pd.PropertyType;
FixedLengthRecordFieldConfigurations.Add(obj);
startIndex += size;
}
//RecordLength = startIndex;
}
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)
{
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.GroupBy(i => i.StartIndex).Where(g => g.Count() > 1).Select(g => g.FirstOrDefault()).FirstOrDefault();
if (dupRecConfig != null)
{
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));
}
}
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);
//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)
{
if (FileHeaderConfiguration.FillChar.Value == ChoCharEx.NUL)
{
throw new ChoRecordConfigurationException("Invalid '{0}' FillChar specified.".FormatString(FileHeaderConfiguration.FillChar));
}
if (Delimiter.Contains(FileHeaderConfiguration.FillChar.Value))
{
throw new ChoRecordConfigurationException("FillChar [{0}] can't be one of Delimiter characters [{1}]".FormatString(FileHeaderConfiguration.FillChar, Delimiter));
}
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.");
}
}
}
string[] headers = state as string[];
if (AutoDiscoverColumns &&
CSVRecordFieldConfigurations.Count == 0)
{
if (headers != null)
{
int index = 0;
CSVRecordFieldConfigurations = (from header in headers
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)
{
throw new ChoRecordConfigurationException("Duplicate field name(s) [Name: {0}] found.".FormatString(String.Join(",", dupFields)));
}
}
RecordFieldConfigurationsDict = CSVRecordFieldConfigurations.OrderBy(i => i.FieldPosition).Where(i => !i.Name.IsNullOrWhiteSpace()).ToDictionary(i => i.Name, FileHeaderConfiguration.StringComparer);
RecordFieldConfigurationsDict2 = CSVRecordFieldConfigurations.OrderBy(i => i.FieldPosition).Where(i => !i.FieldName.IsNullOrWhiteSpace()).ToDictionary(i => i.FieldName, FileHeaderConfiguration.StringComparer);
AlternativeKeys = RecordFieldConfigurationsDict2.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Name, FileHeaderConfiguration.StringComparer);
FCArray = RecordFieldConfigurationsDict.ToArray();
LoadNCacheMembers(CSVRecordFieldConfigurations);
}
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
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>();
PDDict = new Dictionary <string, PropertyDescriptor>();
foreach (var fc in KVPRecordFieldConfigurations)
{
if (fc.PropertyDescriptor == null)
{
fc.PropertyDescriptor = ChoTypeDescriptor.GetProperties(RecordType).Where(pd => pd.Name == fc.Name).FirstOrDefault();
}
if (fc.PropertyDescriptor == null)
{
continue;
}
PIDict.Add(fc.PropertyDescriptor.Name, fc.PropertyDescriptor.ComponentType.GetProperty(fc.PropertyDescriptor.Name));
PDDict.Add(fc.PropertyDescriptor.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);
AlternativeKeys = RecordFieldConfigurationsDict2.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Name, FileHeaderConfiguration.StringComparer);
FCArray = RecordFieldConfigurationsDict.ToArray();
LoadNCacheMembers(KVPRecordFieldConfigurations);
}
}
