/// <summary>
/// Flushes any remaining data before a control segment.
/// </summary>
/// <param name="segment">The control segment.</param>
/// <returns>The parsed segments.</returns>
protected EdiItem Flush(string segment)
{
if (!CurrentSegments.Any())
{
return(null);
}
var firstSegment = CurrentSegments.First().Value;
if (Separators != null)
{
Buffer(segment + Separators.Segment);
}
else
{
Buffer(segment);
}
var result = ParseSegments() ?? new ReaderErrorContext(
new Exception(string.Format("Invalid control structure beginning with {0}",
firstSegment)), ReaderErrorCode.InvalidControlStructure);
CurrentMessageContext = null;
SegmentIndex = 0;
PartsIndex = 0;
return(result);
}
/// <summary>
/// Reads an EDI item from the stream.
/// </summary>
/// <returns>Indication if an item was read.</returns>
public override bool Read()
{
if (Item is ReaderErrorContext && !ContinueOnError)
{
return(false);
}
Item = null;
try
{
while ((!StreamReader.EndOfStream || InternalBuffer.Any()) && Item == null)
{
var segment = ReadSegment();
if (Separators == null)
{
throw new ReaderException("No valid separator set was found.", ReaderErrorCode.InvalidControlStructure);
}
if (string.IsNullOrEmpty(segment))
{
continue;
}
Item = Split(segment) ?? Process(segment);
}
}
catch (ReaderException ex)
{
Item = new ReaderErrorContext(ex, ex.ErrorCode);
}
catch (ParserMessageException ex)
{
Item = new ReaderErrorContext(ex, ReaderErrorCode.InvalidSpecOrAssembly, ex.MessageErrorContext);
}
catch (Exception ex)
{
Item = new ReaderErrorContext(ex, ReaderErrorCode.Unknown);
}
if (StreamReader.EndOfStream && CurrentSegments.Any())
{
Item = new ReaderErrorContext(new Exception("Improper end of file."), ReaderErrorCode.ImproperEndOfFile);
}
var readerErrorContext = Item as ReaderErrorContext;
if (readerErrorContext != null)
{
CurrentSegments.Clear();
if (readerErrorContext.MessageErrorContext == null)
{
Separators = null;
}
}
return(Item != null);
}
private MessageContext BuildContext()
{
if (_currentIsa == null)
{
throw new Exception("Interchange header is missing.");
}
if (CurrentSegments.Count == 1)
{
var ta1 = CurrentSegments.SingleOrDefault(es => es.Name == "TA1");
if (ta1 != null)
{
return(new MessageContext("TA1", "", "", "X12", _currentIsa.InterchangeSenderID_6,
_currentIsa.SenderIDQualifier_5, _currentIsa.InterchangeReceiverID_8,
_currentIsa.ReceiverIDQualifier_7, RulesAssembly));
}
}
if (_currentGroupHeader == null)
{
throw new Exception("GS was not found.");
}
var ediCompositeDataElementsGs = _currentGroupHeader.Value.GetDataElements(Separators);
if (ediCompositeDataElementsGs.Count() < 8)
{
throw new Exception("GS is invalid. Too little data elements.");
}
var version = ediCompositeDataElementsGs[7];
var st = CurrentSegments.SingleOrDefault(es => es.Name == "ST");
if (st == null)
{
throw new Exception("ST was not found.");
}
var ediCompositeDataElementsSt = st.Value.GetDataElements(Separators);
var tag = ediCompositeDataElementsSt[0];
if (ediCompositeDataElementsSt.Count() == 3)
{
version = ediCompositeDataElementsSt[2];
}
if (ediCompositeDataElementsSt.Count() < 2)
{
throw new Exception("ST is invalid.Too little data elements.");
}
var controlNumber = ediCompositeDataElementsSt[1];
return(new MessageContext(tag, controlNumber, version, "X12", _currentIsa.InterchangeSenderID_6,
_currentIsa.SenderIDQualifier_5, _currentIsa.InterchangeReceiverID_8, _currentIsa.ReceiverIDQualifier_7, RulesAssembly));
}
/// <summary>
/// Reads an item from the stream.
/// </summary>
/// <returns>Indication if an item was read.</returns>
public override bool Read()
{
if (Item is ReaderErrorContext && !ContinueOnError)
{
return(false);
}
Item = null;
try
{
while ((!StreamReader.EndOfStream || InternalBuffer.Any()) && Item == null)
{
var segment = ReadSegment();
if (string.IsNullOrEmpty(segment))
{
continue;
}
Item = Process(segment);
}
}
catch (ReaderException ex)
{
Item = new ReaderErrorContext(ex, ex.ErrorCode);
}
catch (ParserMessageException ex)
{
Item = new ReaderErrorContext(ex, ReaderErrorCode.InvalidSpecOrAssembly, ex.MessageErrorContext);
}
catch (Exception ex)
{
Item = new ReaderErrorContext(ex, ReaderErrorCode.Unknown);
}
if (StreamReader.EndOfStream && CurrentSegments.Any())
{
Item = Flush(null);
}
var readerErrorContext = Item as ReaderErrorContext;
if (readerErrorContext != null)
{
CurrentSegments.Clear();
}
return(Item != null);
}
public IDocumentFragment SelectSegment(SegmentPath segmentPath, string value)
{
IDocumentFragment segmentDocumentFragment = null;
// If SegmentPath is conditional group then replace value with conditional value
if (string.IsNullOrWhiteSpace(segmentPath.Value) == false)
{
value = segmentPath.Value;
}
if (CurrentSegments.TryGetValue(segmentPath.Path, out segmentDocumentFragment) == false)
{
List <IDocumentFragment> unusedSegmentsList;
if (UnusedSegments.TryGetValue(segmentPath.Path, out unusedSegmentsList) == false)
{
PopulateUnusedSegments(segmentPath);
}
List <IDocumentFragment> documentFragments;
if (UnusedSegments.TryGetValue(segmentPath.Path, out documentFragments))
{
if (documentFragments.Count > 0)
{
if (string.IsNullOrWhiteSpace(value) == false && documentFragments.Count != 1)
{
foreach (IDocumentFragment documentFragment in documentFragments)
{
string segmentValue = documentFragment.GetDataSegmentValue(segmentPath.DataSegmentName);
if (string.Equals(segmentValue, value, StringComparison.OrdinalIgnoreCase))
{
segmentDocumentFragment = documentFragment;
}
}
}
else
{
segmentDocumentFragment = documentFragments[0];
}
if (segmentDocumentFragment != null)
{
documentFragments.Remove(segmentDocumentFragment);
CurrentSegments.Add(segmentPath.Path, segmentDocumentFragment);
}
}
}
}
return(segmentDocumentFragment);
}
internal MetalRouteContext MoveCapturedToParent(IMetalRoute parentRoute, IEnumerable <string> capturedSegments)
{
var currentCapturedSegments = CurrentSegments.TakeWhile((cseg, idx) => capturedSegments.ElementAtOrDefault(idx).EqualsIgnoreCase(cseg));
if (currentCapturedSegments is null || !currentCapturedSegments.Any())
{
return(this);
}
return(new MetalRouteContext(
parentRoute,
ParentSegments.Concat(currentCapturedSegments),
CurrentSegments.Skip(currentCapturedSegments.Count())
));
}
public void MoveCurrentToUsed()
{
List <IDocumentFragment> documentFragments;
foreach (string path in CurrentSegments.Keys)
{
if (UsedSegments.TryGetValue(path, out documentFragments) == false)
{
documentFragments = new List <IDocumentFragment>();
UsedSegments.Add(path, documentFragments);
}
documentFragments.Add(CurrentSegments[path]);
}
CurrentSegments.Clear();
}
private MessageContext BuildContext()
{
if (_currentUnb == null)
{
throw new Exception("Interchange header is missing.");
}
var unh = CurrentSegments.SingleOrDefault(es => es.Name == "UNH");
if (unh == null)
{
throw new Exception("UNH was not found.");
}
var ediCompositeDataElements = unh.Value.GetDataElements(Separators);
if (ediCompositeDataElements.Count() < 2)
{
throw new Exception("UNH is invalid. Too little data elements.");
}
var ediDataElements = ediCompositeDataElements[1].GetComponentDataElements(Separators);
if (ediDataElements.Count() < 3)
{
throw new Exception("UNH is invalid. Unable to read message type or version.");
}
var tag = ediDataElements[0];
var version = ediDataElements[1] + ediDataElements[2];
var controlNumber = ediCompositeDataElements[0];
if (ediDataElements.Count() >= 5 && ediDataElements[4].StartsWith("EAN"))
{
version = version + "EAN";
if (version.StartsWith("D01B"))
{
version = version + _currentUnb.SYNTAXIDENTIFIER_1.SyntaxVersionNumber_2;
}
}
return(new MessageContext(tag, controlNumber, version, "EDIFACT",
_currentUnb.INTERCHANGESENDER_2.InterchangeSenderIdentification_1,
_currentUnb.INTERCHANGESENDER_2.IdentificationCodeQualifier_2,
_currentUnb.INTERCHANGERECIPIENT_3.InterchangeRecipientIdentification_1,
_currentUnb.INTERCHANGERECIPIENT_3.IdentificationCodeQualifier_2, RulesAssembly));
}
protected override EdiItem Process(string segment)
{
var segmentContext = new SegmentContext(segment.Substring(0, 3), segment, segment.Substring(3, 2), null,
false);
var messageContext = MessageContext(segment);
if (messageContext != null)
{
var result = Flush(segment + _postFix);
if (result != null)
{
return(result);
}
CurrentMessageContext = messageContext;
}
CurrentSegments.Add(segmentContext);
return(null);
}
/// <summary>
/// Parses the accumulated segments.
/// </summary>
protected EdiItem ParseSegments()
{
if (CurrentMessageContext == null)
{
CurrentSegments.Clear();
return(null);
}
EdiItem result;
try
{
var message = new TransactionSet(CurrentMessageContext.MessageType);
var errorContext = message.Analyze(CurrentSegments, CurrentMessageContext, Separators, PartsIndex,
SegmentIndex);
var ediMessage = (EdiMessage)message.ToInstance();
ediMessage.MessagePart = PartsIndex;
ediMessage.ControlNumber = CurrentMessageContext.ControlNumber;
ediMessage.ErrorContext = errorContext;
result = ediMessage;
}
catch (Exception ex)
{
result = new ReaderErrorContext(ex, ReaderErrorCode.InvalidSpecOrAssembly,
new MessageErrorContext(CurrentMessageContext.Name,
CurrentMessageContext.ControlNumber, CurrentMessageContext.Version, PartsIndex, ex.Message,
MessageErrorCode.MissingOrInvalidTransactionSet));
}
finally
{
SegmentIndex = SegmentIndex + CurrentSegments.Count;
CurrentSegments.Clear();
}
return(result);
}
protected override EdiItem Process(string segment)
{
EdiItem result = null;
var segmentContext = new SegmentContext(segment, Separators);
switch (segmentContext.Name)
{
case "ISA":
case "GS":
case "ST":
case "GE":
case "IEA":
result = Flush(segment);
if (result != null)
{
return(result);
}
break;
}
switch (segmentContext.Name)
{
case "ISA":
var isa = ParseSegment <ISA>(segmentContext.Value, Separators);
_currentIsa = isa;
result = isa;
_currentGroupHeader = null;
break;
case "TA1":
result = ParseSegment <TA1>(segmentContext.Value, Separators);
_currentGroupHeader = null;
break;
case "GS":
result = ParseSegment <GS>(segmentContext.Value, Separators);
_currentGroupHeader = segmentContext;
break;
case "ST":
CurrentSegments.Add(segmentContext);
CurrentMessageContext = BuildContext();
SegmentIndex = 0;
PartsIndex = 0;
break;
case "SE":
CurrentSegments.Add(segmentContext);
result = ParseSegments();
CurrentMessageContext = null;
SegmentIndex = 0;
PartsIndex = 0;
break;
case "GE":
result = ParseSegment <GE>(segmentContext.Value, Separators);
_currentGroupHeader = null;
break;
case "IEA":
result = ParseSegment <IEA>(segmentContext.Value, Separators);
_currentGroupHeader = null;
_currentIsa = null;
break;
default:
CurrentSegments.Add(segmentContext);
break;
}
return(result);
}
protected override EdiItem Process(string segment)
{
EdiItem result = null;
var segmentContext = new SegmentContext(segment, Separators);
switch (segmentContext.Name)
{
case "UNA":
case "UNB":
case "UNG":
case "UNH":
case "UNE":
case "UNZ":
result = Flush(segment);
if (result != null)
{
return(result);
}
break;
}
switch (segmentContext.Name)
{
case "UNA":
break;
case "UNB":
var unb = ParseSegment <UNB>(segmentContext.Value, Separators);
_currentUnb = unb;
result = unb;
break;
case "UNG":
result = ParseSegment <UNG>(segmentContext.Value, Separators);
break;
case "UNH":
CurrentSegments.Add(segmentContext);
CurrentMessageContext = BuildContext();
SegmentIndex = 0;
PartsIndex = 0;
break;
case "UNT":
CurrentSegments.Add(segmentContext);
result = ParseSegments();
CurrentMessageContext = null;
SegmentIndex = 0;
PartsIndex = 0;
break;
case "UNE":
result = ParseSegment <UNE>(segmentContext.Value, Separators);
break;
case "UNZ":
result = ParseSegment <UNZ>(segmentContext.Value, Separators);
_currentUnb = null;
break;
default:
CurrentSegments.Add(segmentContext);
break;
}
return(result);
}
public override string ToString()
{
return($"ParentSegments={ParentSegments.JoinPath()}, CurrentSegments={CurrentSegments.JoinPath()}");
}
