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