protected override SchemaRow ReadRow(ExcelWorksheet schemaWorksheet, int row) { if (row > schemaWorksheet.Dimension.End.Row) { return(null); } FlatFileSchemaRow schemaRow = new FlatFileSchemaRow(); schemaRow.Grouping = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, GroupingIndex); schemaRow.Loop = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, LoopIndex); schemaRow.Segment = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, SegmentIndex); schemaRow.DataElementTag = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, DataElementTagIndex); schemaRow.DataElementName = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, DataElementNameIndex); base.ReadBasicRowData(schemaWorksheet, schemaRow, row); // Check for invalid loop names if (string.IsNullOrWhiteSpace(schemaRow.Loop) == false && string.Equals(schemaRow.Loop, "n/a", StringComparison.InvariantCultureIgnoreCase) == false && schemaRow.Loop.Trim().Contains('|')) { AddValidationResult(ResultType.Error, row, GCExcelReaderHelper.GetColumnIndex(MinMaxIndex), string.Format("Invalid loop value {0}", schemaRow.Loop)); } return(schemaRow); }
protected void GetMinMax(string minMax, int row, out int minL, out int maxL) { minL = -1; maxL = -1; if (string.IsNullOrEmpty(minMax)) { return; } string[] numbers = minMax.Split('/'); if (numbers == null || numbers.Length != 2) { AddValidationResult(ResultType.Error, row, GCExcelReaderHelper.GetColumnIndex(MinMaxIndex), string.Format("Invalid MinMax value", minMax)); } else { // TODO: enhance SchemaReaderException to have segment, row as properties if (int.TryParse(numbers[0], out minL) == false) { AddValidationResult(ResultType.Error, row, GCExcelReaderHelper.GetColumnIndex(MinMaxIndex), string.Format("Cannot parse Min value {0}", numbers[0])); //throw new SchemaReaderException(string.Format("Cannot parse Min value {0} on row {1}", numbers[0], row)); } if (int.TryParse(numbers[1], out maxL) == false) { AddValidationResult(ResultType.Error, row, GCExcelReaderHelper.GetColumnIndex(MinMaxIndex), string.Format("Cannot parse Max value {0}", numbers[1])); //throw new SchemaReaderException(string.Format("Cannot parse Max value {0} on row {1}", numbers[1], row)); } } }
private void ReadMetadata(ExcelWorksheet schemaWorksheet) { int row; string cellValue; for (row = 1; row < schemaWorksheet.Dimension.End.Row; ++row) { cellValue = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, 1); if (cellValue == null) { continue; } if (string.Compare("Root Node", cellValue, true) == 0) { RootNodeName = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, 3); if (string.IsNullOrWhiteSpace(RootNodeName)) { AddValidationResult(ResultType.Error, row, GCExcelReaderHelper.GetColumnIndex(3), string.Format("Root node name is empty", cellValue)); } break; } } }
protected override SchemaRow ReadRow(ExcelWorksheet schemaWorksheet, int row) { if (row > schemaWorksheet.Dimension.End.Row) { return(null); } XmlFileSchemaRow schemaRow = new XmlFileSchemaRow(); // Read all first 5 cell value for (int i = 0; i < 5; i++) { schemaRow.ElementName = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, i + 1); if (string.IsNullOrWhiteSpace(schemaRow.ElementName) == false) { schemaRow.Level = i + 1; break; } } base.ReadBasicRowData(schemaWorksheet, schemaRow, row); // If data type is not-null then set IsLeafNode flag true schemaRow.IsLeafNode = !string.IsNullOrWhiteSpace(schemaRow.DataType); return(schemaRow); }
protected override SchemaRow ReadRow(ExcelWorksheet schemaWorksheet, int row) { if (row > schemaWorksheet.Dimension.End.Row) { return(null); } X12SchemaRow schemaRow = new X12SchemaRow(); schemaRow.Grouping = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, GroupingIndex); schemaRow.Loop = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, LoopIndex); schemaRow.Segment = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, SegmentIndex); schemaRow.DataElementTag = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, DataElementTagIndex); schemaRow.DataElementName = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, DataElementNameIndex); base.ReadBasicRowData(schemaWorksheet, schemaRow, row); // This code was added during contingency field handling, however maps migration project generate spec certs without contingencies and hence the following code was removed. // if (string.IsNullOrWhiteSpace(schemaRow.DataElementTag) == false && string.Compare(schemaRow.DataElementTag, "HL03", true) == 0) // schemaRow.IsTriggerField = true; // Check for invalid loop names if (string.IsNullOrWhiteSpace(schemaRow.Loop) == false && string.Equals(schemaRow.Loop, "n/a", StringComparison.InvariantCultureIgnoreCase) == false && schemaRow.Loop.Trim().Contains('|')) { AddValidationResult(ResultType.Error, row, GCExcelReaderHelper.GetColumnIndex(MinMaxIndex), string.Format("Invalid loop value {0}", schemaRow.Loop)); } return(schemaRow); }
private void ReadMetadata(DocumentPlug documentPlug, ExcelWorksheet schemaWorksheet) { int row; string cellValue; int delimiterCount = 0; for (row = 1; row < schemaWorksheet.Dimension.End.Row && delimiterCount < 2; ++row) { // column 1 has name 'Element Segment' or 'Segment Delimiter' // Column 3 has delimiter cellValue = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, 1); if (cellValue == null) { continue; } if (string.Compare("Element Delimiter", cellValue, true) == 0) { cellValue = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, 3); // delimiter can be more than 1 char, // split the string by ' ', convert each string to int documentPlug.ElementDelimiters = GetDelimiters(cellValue); if (documentPlug.ElementDelimiters == null) { AddValidationResult(ResultType.Error, row, GCExcelReaderHelper.GetColumnIndex(3), string.Format("'{0}' is invalid element delimiter", cellValue)); } delimiterCount++; } else if (string.Compare("Segment Delimiter", cellValue, true) == 0) { cellValue = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, 3); documentPlug.SegmentDelimiters = GetDelimiters(cellValue); if (documentPlug.SegmentDelimiters == null) { AddValidationResult(ResultType.Error, row, GCExcelReaderHelper.GetColumnIndex(3), string.Format("'{0}' is invalid segment delimiter", cellValue)); } delimiterCount++; } } }
protected void ReadBasicRowData(ExcelWorksheet schemaWorksheet, SchemaRow schemaRow, int row) { if (row > schemaWorksheet.Dimension.End.Row) { return; } schemaRow.MandatoryCode = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, MandatoryCodeIndex); schemaRow.DataType = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, DataTypeIndex); schemaRow.MinMaxLength = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, MinMaxIndex); schemaRow.EnumCode = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, EnumCodeIndex); schemaRow.EnumName = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, EnumNameIndex); schemaRow.EnumFlag = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, EnumFlagIndex, true); schemaRow.MandatoryFlag = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, MandatoryFlagIndex, true); schemaRow.IgnoreFlag = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, IgnoreFlagIndex, true); schemaRow.Contingencies = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, ContingenciesIndex, true); schemaRow.ContingencyType = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, ContingencyTypeIndex, true); if (TriggerFieldIndex != -1) { string triggerFieldText = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, TriggerFieldIndex, true); if (string.IsNullOrWhiteSpace(triggerFieldText) == false && triggerFieldText.Trim().ToUpperInvariant().Equals(TriggerFieldValue)) { schemaRow.IsTriggerField = true; } } if (string.IsNullOrWhiteSpace(schemaRow.EnumFlag)) { schemaRow.EnumFlag = "?"; } if (string.IsNullOrWhiteSpace(schemaRow.MandatoryFlag)) { schemaRow.MandatoryFlag = ""; } if (string.IsNullOrWhiteSpace(schemaRow.IgnoreFlag)) { schemaRow.IgnoreFlag = "P"; } }
private void ReadMessageDomainIds(ExcelWorksheet schemaWorksheet, int row, BizRuleSet bizRuleSet) { int domainIdIndex = 3; int domainId; while (true) { string cellValue = GCExcelReaderHelper.ReadCell(schemaWorksheet, row, domainIdIndex); // Stop if cell value is non-integer if (cellValue == null || int.TryParse(cellValue, out domainId) == false) { return; } bizRuleSet.MessageDomainIds.Add(domainId); domainIdIndex++; } }
private List <string> ReadBizRuleRow(ExcelWorksheet schemaWorksheet, int columnCount, ref int row) { while (row <= schemaWorksheet.Dimension.End.Row && GCExcelReaderHelper.ReadCell(schemaWorksheet, row, 1) == null) { row++; } if (row > schemaWorksheet.Dimension.End.Row) { return(null); } List <string> bizRuleRow = new List <string>(); for (int i = 1; i <= columnCount; i++) { bizRuleRow.Add(GCExcelReaderHelper.ReadCell(schemaWorksheet, row, i)); } return(bizRuleRow); }
// crossSegmentPointer = Path to data element followed by expected value in "[]" e.g. HLO->REF->REF01[PK] private void AddIdValue(SchemaRow segmentRow, int row, string crossSegmentPointer, List <string> optionalValues, Dictionary <string, string> allowedValues, Dictionary <string, Contingency> contingencies) { allowedValues.Add(segmentRow.EnumCode, segmentRow.EnumName); if (string.Compare(segmentRow.IgnoreFlag, "I", true) == 0 || string.Compare(segmentRow.EnumFlag, "?", true) == 0) { optionalValues.Add(segmentRow.EnumCode); } if (string.IsNullOrWhiteSpace(segmentRow.ContingencyType) == false) { segmentRow.ContingencyType = segmentRow.ContingencyType.Trim(); if (string.Compare(segmentRow.ContingencyType, "E", true) != 0 && string.Compare(segmentRow.ContingencyType, "CS", true) != 0) { AddValidationResult(ResultType.Error, row, GCExcelReaderHelper.GetColumnIndex(ContingencyTypeIndex), string.Format("Invalid contingency type {0}", segmentRow.ContingencyType)); } else { Contingency contingency = new Contingency(); if (string.Compare(segmentRow.ContingencyType, "E", true) == 0) { contingency.Type = ContingencyType.Enumeration; } else if (string.Compare(segmentRow.ContingencyType, "CS", true) == 0) { contingency.Type = ContingencyType.CrossSegment; } AddPendingContingencies(row, segmentRow.Contingencies, contingency); ResolveContingency(row, crossSegmentPointer, segmentRow.EnumCode); contingencies.Add(segmentRow.EnumCode, contingency); } } }
// here contingencyValues are row numbers private void AddPendingContingencies(int currentRow, string contingencyValues, Contingency currentRowContingency) { if (string.IsNullOrWhiteSpace(contingencyValues) == true) { AddValidationResult(ResultType.Error, currentRow, GCExcelReaderHelper.GetColumnIndex(ContingenciesIndex), "No contigency specified"); return; } string[] contingencyValueArr = contingencyValues.Split(','); int[] contingencyValueRows = new int[contingencyValueArr.Length]; int contingencyRow; foreach (string contingencyValueRow in contingencyValueArr) { if (int.TryParse(contingencyValueRow.Trim(), out contingencyRow) == true) { // Check if contingency value is already present if (contingencyRow <= currentRow) { if (contingencyRow == currentRow) { AddValidationResult(ResultType.Error, currentRow, GCExcelReaderHelper.GetColumnIndex(ContingenciesIndex), "Same row cannot be marked as its own contingency"); continue; } string contingencyValue = null; if (currentRowContingency.Type == ContingencyType.Enumeration && ContingencyValue.ContainsKey(contingencyRow)) { contingencyValue = ContingencyValue[contingencyRow]; } else if (currentRowContingency.Type == ContingencyType.CrossSegment && ContingencyPath.ContainsKey(contingencyRow)) { contingencyValue = ContingencyPath[contingencyRow]; } if (contingencyValue != null) { currentRowContingency.AddContingencyValue(contingencyValue); } else { AddValidationResult(ResultType.Error, currentRow, GCExcelReaderHelper.GetColumnIndex(ContingenciesIndex), string.Format("Invalid contingency row {0}. Rule: Cotingency row should be marked as each other's contingency.", contingencyRow)); } } else { List <Contingency> contingencies; if (PendingContingencies.TryGetValue(contingencyRow, out contingencies) == true) { contingencies.Add(currentRowContingency); } else { contingencies = new List <Contingency>(); contingencies.Add(currentRowContingency); PendingContingencies.Add(contingencyRow, contingencies); } } } else { AddValidationResult(ResultType.Error, currentRow, GCExcelReaderHelper.GetColumnIndex(ContingenciesIndex), string.Format("Invalid contingency row {0}", contingencyValueRow)); } } }
protected X12BaseDataType ReadDataType(SchemaRow segmentRow, ExcelWorksheet schemaWorksheet, string segmentPath, ref int row) { List <string> optionalValues = new List <string>(); Dictionary <string, string> allowedValues = new Dictionary <string, string>(); Dictionary <string, Contingency> contingencies = new Dictionary <string, Contingency>(); X12BaseDataType dataType; string dataTypeName = segmentRow.DataType; string currentTag = segmentRow.GetDataElementTag(); int dataTypeRow = row - 1; // In sample schema ISA016 has data type blank hence AN and default is set to AN if (string.IsNullOrEmpty(dataTypeName) == true) { dataTypeName = "AN"; AddValidationResult(ResultType.Warning, dataTypeRow, GCExcelReaderHelper.GetColumnIndex(DataTypeIndex), string.Format("'{0}' segment is missing data type, treating it as AlphaNumeric", currentTag)); } int minL, maxL; GetMinMax(segmentRow.MinMaxLength, row, out minL, out maxL); // add current row enum code if present if (string.IsNullOrWhiteSpace(segmentRow.EnumCode) == false && string.Compare(segmentRow.EnumFlag, "n", true) != 0) { AddIdValue(segmentRow, row, string.Format("{0}[{1}]", segmentPath, segmentRow.EnumCode), optionalValues, allowedValues, contingencies); } // Traverse all sub rows - these rows are mostly relevant for enums (containing enum values) // however sample schema shows multiple rows for other data types too while ((segmentRow = ReadRow(schemaWorksheet, row)) != null) { if ((string.IsNullOrEmpty(segmentRow.GetDataElementTag()) == false && string.Compare(segmentRow.GetDataElementTag(), currentTag, true) != 0) || IsDataTypeRowsOver(segmentRow, row)) { break; } switch (dataTypeName) { case "ID": if (string.IsNullOrEmpty(segmentRow.EnumCode) == false && string.Compare(segmentRow.EnumFlag, "n", true) != 0) { AddIdValue(segmentRow, row, string.Format("{0}[{1}]", segmentPath, segmentRow.EnumCode), optionalValues, allowedValues, contingencies); } break; case "DT": case "AN": case "N0": case "N2": case "TM": case "R": break; default: //AddValidationResult(ResultType.Error, row, GetColumnIndex(EnumCodeIndex), string.Format("Unknown data type {0}", dataTypeName)); //throw new SchemaReaderException(string.Format("Unknown data type {0} on row {1}", dataTypeName, row)); break; } ++row; } switch (dataTypeName) { case "ID": if (allowedValues == null || allowedValues.Count == 0) { dataType = new X12_AnDataType(dataTypeName, minL, maxL); AddValidationResult(ResultType.Warning, dataTypeRow, GCExcelReaderHelper.GetColumnIndex(EnumCodeIndex), string.Format("'{0}' segment has ID type without any values, treating it as AlphaNumeric.", currentTag)); } else { dataType = new X12_IdDataType(dataTypeName, optionalValues, allowedValues, contingencies); } break; case "DT": dataType = new X12_DtDataType(dataTypeName, minL, maxL); break; case "Comp": case "AN": dataType = new X12_AnDataType(dataTypeName, minL, maxL); break; case "N": dataType = X12_NDataType.GetDataTypeWithPrecision(0, minL, maxL); break; case "N0": dataType = X12_NDataType.GetDataTypeWithPrecision(0, minL, maxL); break; case "N2": dataType = X12_NDataType.GetDataTypeWithPrecision(2, minL, maxL); break; case "TM": dataType = new X12_TmDataType(dataTypeName, minL, maxL); break; case "R": dataType = new X12_RDataType(dataTypeName, minL, maxL); break; default: AddValidationResult(ResultType.Error, dataTypeRow, GCExcelReaderHelper.GetColumnIndex(EnumCodeIndex), string.Format("Unknown data type {0}", dataTypeName)); dataType = new X12_AnDataType(dataTypeName, minL, maxL); // This is to avoid compiler error. //throw new SchemaReaderException(string.Format("Unknown data type {0} on row {1}", dataTypeName, row)); break; } return(dataType); }