private void CheckMissingMandatoryElements(IPluglet currentPluglet, IDocumentFragment currentDocumentFragment) { foreach (IPluglet childPluglet in currentPluglet.Children) { if (childPluglet.IsMandatory == false) { continue; } bool childExist = false; foreach (IDocumentFragment childDocumentFragment in currentDocumentFragment.Children) { if (childDocumentFragment.Pluglet.Tag == childPluglet.Tag) { childExist = true; break; } } EdiErrorType errorType = EdiErrorType.Error; if (childPluglet.IsIgnore) { errorType = EdiErrorType.Warning; } if (childExist == false) { Errors.AddSegmentError(childPluglet.Tag, X12ErrorCode.MandatorySegmentMissingCode , string.Format("{0} : {1}", X12ErrorCode.GetStandardSegmentErrorDescription(X12ErrorCode.MandatorySegmentMissingCode), childPluglet.Tag) , CurrentElementNumber, CurrentLinePayloadStart + TotalPayloadLength, CurrentLinePayloadEnd + TotalPayloadLength, errorType); } } }
public SegmentError(string segID, int sequenceNo, int code, string desc, string explicitLoopID, long startIndex, long endIndex, EdiErrorType errorType) : base(code, desc, sequenceNo, errorType, startIndex, endIndex) { mSegmentID = segID; mExplicitLoopID = explicitLoopID; }
public EdiError(int code, string desc, int segNo, EdiErrorType errorType, long startIndex, long endIndex) { ErrorCode = code; Description = desc; EdiErrorType = errorType; StartIndex = startIndex; EndIndex = endIndex; mPositionInTS = segNo; }
public FieldError(string fieldId, int positionInSegment, int positionInField, int repetitionCount, int code, string desc, int segmentNo, string val, string refDesignator, long startIndex, long endIndex, EdiErrorType errorType) : base(code, desc, segmentNo, errorType, startIndex, endIndex) { FieldId = fieldId; mPositionInSegment = positionInSegment; mPositionInField = positionInField; mRepetitionCount = repetitionCount; mDataValue = val; mReferenceDesignator = refDesignator; }
public SchemaValidationError(int code, string desc, EdiErrorType errorType, string xpath) : base(code, desc, -1, errorType, -1, -1) { mNodeXPath = xpath; }
/// <summary> /// Construct DocumentFragment for leaf node parent and then create and attach leaf nodes to it. /// </summary> /// <param name="pluglet"></param> /// <param name="segmentDetails"></param> /// <param name="internalSegment"></param> /// <param name="ediDelimiters"></param> /// <param name="segmentStartIndex"></param> /// <param name="segmentEndIndex"></param> /// <param name="ediErrors"></param> /// <param name="error"></param> /// <returns></returns> public static DocumentFragment ConstructDocumentFragment(this IPluglet pluglet, string[] segmentDetails, bool internalSegment, Delimiters ediDelimiters, int segmentSeqNumber, long segmentStartIndex, long segmentEndIndex, ref InterchangeErrors ediErrors, out string error) { if (pluglet == null) { throw new ArgumentNullException("pluglet"); } if (segmentDetails == null) { throw new ArgumentNullException("segmentDetails"); } LoggerFactory.Logger.Info("PlugletExtensions.ConstructDocumentFragment", "Constructing {0} instance", pluglet.Tag); if (pluglet.Children == null) { error = string.Format("Pluglet {0} does not have childrens", pluglet.Name); return(null); } // -1 is required since SegmentDetails[0] is the SegmentName if (pluglet.Children.Count < segmentDetails.Length - 1) { error = string.Format("Document has {1} data elements, it is less than segment children count {2} as described in Spec", pluglet.Name, pluglet.Children.Count, segmentDetails.Length); return(null); } error = string.Empty; ++pluglet.CurrentOccurrences; DocumentFragment documentFragment = new DocumentFragment() { Pluglet = pluglet, Children = new List <IDocumentFragment>(), SequenceNumber = segmentSeqNumber, StartOffset = segmentStartIndex, EndOffset = segmentEndIndex, }; int plugletNum = 0; DocumentFragment dataFragment; IPluglet plugletChild; bool validateValue; long currentSegmentFieldStartIndex = segmentStartIndex; //SegmentNum start from 1 since SegmentDetails[0] is Segment name int segmentNum = 1; // if this is internal segment (composite segment - segment handing data and segment as children) then // start segmentDetails from 0 if (internalSegment == true) { segmentNum = 0; } EdiErrorType errorType = pluglet.IsIgnore ? EdiErrorType.Warning : EdiErrorType.Error; for (; segmentNum < segmentDetails.Length; segmentNum++, plugletNum++) { if (segmentNum != 0) { currentSegmentFieldStartIndex += segmentDetails[segmentNum - 1].Length + 1; } validateValue = false; plugletChild = pluglet.Children[plugletNum]; if (plugletChild.PlugletType == PlugletType.Data) { dataFragment = new DocumentFragment() { Parent = documentFragment, Pluglet = plugletChild, Value = segmentDetails[segmentNum], /*SequenceNumber = segmentSeqNumber, * StartOffset = currentSegmentFieldStartIndex, * EndOffset = currentSegmentFieldStartIndex + segmentDetails[segmentNum].Length,*/ }; validateValue = true; } else if (plugletChild.PlugletType == PlugletType.Segment) { if (string.IsNullOrEmpty(segmentDetails[segmentNum]) == false) { string segmentError = string.Empty; string [] internalSegmentDetails = segmentDetails[segmentNum].Split((char)ediDelimiters.ComponentSeperator); dataFragment = plugletChild.ConstructDocumentFragment(internalSegmentDetails, true, ediDelimiters, segmentSeqNumber, currentSegmentFieldStartIndex, currentSegmentFieldStartIndex + segmentDetails[segmentNum].Length, ref ediErrors, out segmentError); if (string.IsNullOrEmpty(segmentError) == false) { if (string.IsNullOrEmpty(error) == true) { error = string.Format("ConstructDocumentSegmentInstance: Pluglet {0}: ", pluglet.Name); } error = string.Format("{0} Error constructing {1}: {2}", error, plugletChild.Name, segmentError); } } else { dataFragment = new DocumentFragment() { Parent = documentFragment, Pluglet = plugletChild, Value = segmentDetails[segmentNum], }; } } else { error = string.Format("ConstructDocumentSegmentInstance: Error constructing SegmentInstance. Pluglet {0} is of type {1}", pluglet.Name, plugletChild.Name); return(null); } if (validateValue == true && plugletChild.DataType != null && string.IsNullOrEmpty(segmentDetails[segmentNum]) == false) { FieldError fieldError = plugletChild.DataType.ValidateValue(new StringBuilder(segmentDetails[segmentNum])); if (fieldError != null) { if (string.IsNullOrEmpty(error) == true) { error = string.Format("ConstructDocumentSegmentInstance: Pluglet {0}: ", pluglet.Name); } error = string.Format("{0} Error data validation failed {1}: {2} ({3})", error, plugletChild.Name, fieldError.Description, fieldError.DataValue); ediErrors.AddFieldError(segmentDetails[0], plugletChild.Tag, fieldError.ErrorCode, fieldError.Description, segmentSeqNumber, segmentNum, segmentDetails[segmentNum], currentSegmentFieldStartIndex, currentSegmentFieldStartIndex + segmentDetails[segmentNum].Length - 1, errorType); } } //TODO: Add validation (extension method) documentFragment.Children.Add(dataFragment); if (string.IsNullOrEmpty(segmentDetails[segmentNum]) && plugletChild.IsMandatory == true) { if (string.IsNullOrEmpty(error) == true) { error = string.Format("ConstructDocumentSegmentInstance: Pluglet {0}: ", pluglet.Name); } error = string.Format("{0} Child {1} is mandatory but missing", error, plugletChild.Name); ediErrors.AddFieldError(segmentDetails[0], plugletChild.Tag, X12ErrorCode.DeMandatoryDataElementMissingCode, X12ErrorCode.GetDataElementErrorDescription(X12ErrorCode.DeMandatoryDataElementMissingCode), segmentSeqNumber, segmentNum, string.Empty, currentSegmentFieldStartIndex, currentSegmentFieldStartIndex, errorType); } } for (; segmentNum <= pluglet.Children.Count; segmentNum++, plugletNum++) { plugletChild = pluglet.Children[plugletNum]; if (plugletChild.IsMandatory == true) { if (string.IsNullOrEmpty(error) == true) { error = string.Format("ConstructDocumentSegmentInstance: Pluglet {0}: ", pluglet.Name); } error = string.Format("{0} Child {1} is mandatory but missing", error, plugletChild.Name); ediErrors.AddFieldError(segmentDetails[0], plugletChild.Tag, X12ErrorCode.DeMandatoryDataElementMissingCode, X12ErrorCode.GetDataElementErrorDescription(X12ErrorCode.DeMandatoryDataElementMissingCode), segmentSeqNumber, segmentNum, string.Empty, currentSegmentFieldStartIndex, currentSegmentFieldStartIndex, errorType); } } return(documentFragment); }
/// <summary> /// Find corrosponding Pluglet for given segmentname and create new segment /// </summary> /// <param name="segmentName"></param> /// <param name="segmentDetails"></param> private void CreateAndAddNewSegment(string segmentName, string[] segmentDetails) { const string firstSegmentName = "ST"; string errorMsgs = string.Empty; IPluglet nextPluglet; string location = "EDIReader.CreateAndAddNewSegment"; Logger.Debug(location, "Adding {0} segment", segmentName); string missingMandatorySegments; nextPluglet = CurrentPluglet.GetSegmentPluglet(segmentName, segmentDetails, firstSegmentName, out missingMandatorySegments); // First add missing mandatory segment errors if (nextPluglet != null && !string.IsNullOrWhiteSpace(missingMandatorySegments)) { string error = string.Format("Missing mandatory segments ({0}) between {1} and {2}" , missingMandatorySegments, CurrentPluglet.Tag, segmentName); if (FatpipeDocumentInst.Errors == null) { FatpipeDocumentInst.Errors = new List <string>(); } FatpipeDocumentInst.Errors.Add(error); Logger.Error("EDIReader.CreateAndAddNewSegment", EventId.EDIReaderMissingMandatorySegment, "{0} - {1}", GetCurrentPosContext(), error); EdiErrorType errorType = nextPluglet.IsIgnore ? EdiErrorType.Warning : EdiErrorType.Error; foreach (string segment in missingMandatorySegments.Split(',')) { Errors.AddSegmentError(segmentName, X12ErrorCode.MandatorySegmentMissingCode , string.Format("{0} : {1}", X12ErrorCode.GetStandardSegmentErrorDescription(X12ErrorCode.MandatorySegmentMissingCode), segment) , SegmentNumber, this.CurrentSegmentStartPos, this.CurrentSegmentEndPos - 1, errorType); } } if (nextPluglet == null) { /* //TODO: Revisit following if condition - do we really want to ignore ISA/GS segment missing in schema? * if (segmentName != "ISA" && segmentName != "GS") * { * errors = string.Format("{0} segment not found in schema after {1}", segmentName, CurrentPluglet.Name); * * Logger.Error(location, EventId.EDIReaderUnknownSegment, "{0} - {1}", GetCurrentPosContext(), errors); * Errors.AddSegmentError(segmentName, X12ErrorCode.UnrecognizedSegmentIDCode * , X12ErrorCode.GetStandardSegmentErrorDescription(X12ErrorCode.UnrecognizedSegmentIDCode), SegmentNumber); * } */ //experimenting with unknown here above is actual //IPluglet unknown = new Pluglet("UNRECOGNIZED_SEGMENT", "Unknown Segment", PlugletType.Segment, CurrentPluglet.Parent); IPluglet unknown = new Pluglet( new PlugletInput() { Name = "UNRECOGNIZED_SEGMENT", Definition = "Unknown Segment", Type = PlugletType.Segment, Parent = CurrentPluglet.Parent, IsIgnore = false, AddToParent = false, IsTagSameAsName = true, }); // IPluglet x = new Pluglet("child"+i, "Unknown Data", PlugletType.Data, unknown); //unknown.Children.Add(x); //} //DocumentFragment newFragment = unknown.ConstructDocumentFragment(segmentDetails, false, EDIDelimiters, out errors); errorMsgs = string.Format("{0} segment not found in schema after {1}", segmentName, CurrentPluglet.Name); Errors.AddSegmentError(segmentName, X12ErrorCode.UnrecognizedSegmentIDCode , X12ErrorCode.GetStandardSegmentErrorDescription(X12ErrorCode.UnrecognizedSegmentIDCode), SegmentNumber , this.CurrentSegmentStartPos, this.CurrentSegmentEndPos - 1, EdiErrorType.Error); DocumentFragment newFragment = new DocumentFragment() { Pluglet = unknown, Children = new List <IDocumentFragment>(), }; IPluglet childPluglet = new Pluglet("Data", "Data", PlugletType.Data, null); DocumentFragment child = new DocumentFragment() { Parent = newFragment, Pluglet = childPluglet, Children = null, SequenceNumber = SegmentNumber, StartOffset = this.CurrentSegmentStartPos, EndOffset = this.CurrentSegmentEndPos - 1, }; newFragment.Children.Add(child); child.Value = CurrentSegment; if (newFragment == null) { errorMsgs = string.Format("{0} DocumentFragment creation failed. Errors: {1}", segmentName, errorMsgs); Logger.Error(location, EventId.EDIReaderDocFragmentCreation, "{0} - {1}", GetCurrentPosContext(), errorMsgs); //TODO: what should be the code here? //Errors.AddGenericError(segmentName, X12ErrorCode.??? } else { ((DocumentFragment)FatpipeDocumentInst.RootFragment).AddDocumentFragment(newFragment); // CurrentPluglet = newFragment.Pluglet; } //experimenting with unknown here } else { if (nextPluglet.RepetitionInfo.MaxOccurs == 0) { Errors.AddSegmentError(segmentName, X12ErrorCode.UnexpectedSegmentCode , string.Format("{0} : {1}", X12ErrorCode.GetStandardSegmentErrorDescription(X12ErrorCode.UnexpectedSegmentCode), nextPluglet.Tag) , SegmentNumber, this.CurrentSegmentStartPos, this.CurrentSegmentEndPos - 1, EdiErrorType.Error); } else { DocumentFragment newFragment = nextPluglet.ConstructDocumentFragment(segmentDetails, false, EDIDelimiters, SegmentNumber, this.CurrentSegmentStartPos, this.CurrentSegmentEndPos - 1, ref errors, out errorMsgs); if (newFragment == null) { //errorMsgs = string.Format("{0} DocumentFragment creation failed. Errors: {1}", segmentName, errorMsgs); Logger.Error(location, EventId.EDIReaderDocFragmentCreation, "{0} - {1}", GetCurrentPosContext(), errorMsgs); // TODO: Replace UnexpectedSegmentCode with appropriate one Errors.AddGenericError(segmentName, X12ErrorCode.UnexpectedSegmentCode, errorMsgs, SegmentNumber, this.CurrentSegmentStartPos, this.CurrentSegmentEndPos); } else { ((DocumentFragment)FatpipeDocumentInst.RootFragment).AddDocumentFragment(newFragment); CurrentPluglet = newFragment.Pluglet; } } } if (!string.IsNullOrEmpty(errorMsgs)) { if (FatpipeDocumentInst.Errors == null) { FatpipeDocumentInst.Errors = new List <string>(); } FatpipeDocumentInst.Errors.Add(errorMsgs); } }
public static void AddFieldError(this InterchangeErrors errors, string segmentName, string fieldName, int errorCode, string errorDescription, int segmentNo, int positionInSegment, string fieldValue, long startIndex, long endIndex, EdiErrorType errorType) { if (errors == null) { throw new ArgumentNullException("errors"); } int positionInField = -1; int repetitionCount = 0; string refDesignator = ""; if (errors == null) { throw new ArgumentNullException("errors"); } FieldError fieldError = new FieldError(string.Format("{0}-{1}", segmentName, fieldName), positionInSegment, positionInField, repetitionCount, errorCode, errorDescription, segmentNo, fieldValue, refDesignator, startIndex, endIndex, errorType); EdiSectionErrors ediSectionErrors = GetEdiSectionErrors(errors, segmentName); ediSectionErrors.FieldErrorList.Add(fieldError); }
public static void AddSegmentError(this InterchangeErrors errors, string segmentName, int errorCode, string errorDescription, int segmentNumber, long startIndex, long endIndex, EdiErrorType errorType) { if (errors == null) { throw new ArgumentNullException("errors"); } string explicitLoopId = ""; SegmentError segmentError = new SegmentError(segmentName, segmentNumber, errorCode, errorDescription, explicitLoopId, startIndex, endIndex, errorType); EdiSectionErrors ediSectionErrors = GetEdiSectionErrors(errors, segmentName); ediSectionErrors.SegmentErrorList.Add(segmentError); }