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)); } } }
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); }
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); } 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++; } } }
// 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); }