public void TestInterchangeRead()
{
// ARRANGE
const string sample = "EdiFabric.UnitTests.Edifact.Edi.Edifact_INVOIC_D00A_MultipleInterchange.txt";
var ediStream = CommonHelper.LoadStream(sample);
var ediItems = new List <object>();
// ACT
using (var ediReader = new EdifactReader(ediStream, "EdiFabric.Rules.EdifactD00A"))
{
while (ediReader.Read())
{
ediItems.Add(ediReader.Item);
if (!(ediReader.Item is UNZ))
{
continue;
}
// ASSERT
Assert.IsNotNull(ediItems.OfType <UNB>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <UNG>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <TSINVOIC>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <UNE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <UNZ>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
ediItems.Clear();
}
}
}
public void TestValidAndInvalidMessageRead()
{
// ARRANGE
const string sample = "EdiFabric.UnitTests.Edifact.Edi.Edifact_INVOIC_D00A_ValidAndInvalidMessage.txt";
var ediStream = CommonHelper.LoadStream(sample);
List <EdiItem> ediItems;
// ACT
using (var ediReader = new EdifactReader(ediStream, "EdiFabric.Rules.EdifactD00A"))
{
ediItems = ediReader.ReadToEnd().ToList();
}
// ASSERT
Assert.IsNotNull(ediItems.OfType <UNB>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <UNG>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <TSINVOIC>().SingleOrDefault(m => m.HasErrors));
Assert.IsNotNull(ediItems.OfType <TSINVOIC>().SingleOrDefault(m => !m.HasErrors));
Assert.IsNull(ediItems.OfType <UNE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <UNZ>().SingleOrDefault());
var error = ediItems.OfType <TSINVOIC>().SingleOrDefault(m => m.HasErrors);
Assert.IsNotNull(error);
Assert.IsNotNull(error.ErrorContext.Errors.Any(e => e.Codes.Contains(SegmentErrorCode.UnrecognizedSegment)));
Assert.IsNotNull(error.ErrorContext);
Assert.IsTrue(error.ErrorContext.Errors.All(e => e.SpecType == null));
}
public void TestMultipleInterchange()
{
// ARRANGE
const string sample = "EdiFabric.UnitTests.Edifact.Edi.Edifact_INVOIC_D00A_MultipleInterchange.txt";
var ediStream = CommonHelper.LoadStream(sample);
var expected = CommonHelper.LoadString(sample, Encoding.UTF8);
var ediItems = new List <EdiItem>();
// ACT
var actual = "";
using (var ediReader = new EdifactReader(ediStream, "EdiFabric.Rules.EdifactD00A"))
{
while (ediReader.Read())
{
if (ediReader.Item is UNB && ediItems.Any())
{
actual = actual + EdifactHelper.Generate(ediItems, null, Environment.NewLine);
ediItems.Clear();
}
ediItems.Add(ediReader.Item);
}
actual = actual + EdifactHelper.Generate(ediItems, ediReader.Separators, Environment.NewLine);
}
// ASSERT
Assert.AreEqual(expected, actual);
}
public void TestTooManyComponentDataElements()
{
// ARRANGE
const string sample = "EdiFabric.UnitTests.Edifact.Edi.Edifact_INVOIC_D00A_InvalidSegment2.txt";
var ediStream = CommonHelper.LoadStream(sample);
List <EdiItem> ediItems;
// ACT
using (var ediReader = new EdifactReader(ediStream, "EdiFabric.Rules.EdifactD00A"))
{
ediItems = ediReader.ReadToEnd().ToList();
}
// ASSERT
Assert.IsNotNull(ediItems.OfType <UNB>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <UNG>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <TSINVOIC>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <UNE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <UNZ>().SingleOrDefault());
var error = ediItems.OfType <TSINVOIC>().SingleOrDefault();
Assert.IsNotNull(error);
Assert.IsTrue(error.HasErrors);
Assert.IsNotNull(error.ErrorContext);
Assert.IsTrue(error.ErrorContext.Errors.Any(e => e.SpecType != null));
Assert.IsTrue(error.ErrorContext.Errors.Any(e => e.Errors.Any(d => d.Code == DataElementErrorCode.TooManyComponents)));
MessageErrorContext mec;
Assert.IsFalse(error.IsValid(out mec));
Assert.IsTrue(mec.Errors.Any(e => e.Errors.Any(d => d.Code == DataElementErrorCode.TooManyComponents)));
Assert.IsTrue(mec.Errors.Count > 1);
}
public void TestTrailingBlanks()
{
// ARRANGE
const string sample = "EdiFabric.UnitTests.Edifact.Edi.Edifact_INVOIC_D00A_TrailingBlanks.txt";
const string sampleClean = "EdiFabric.UnitTests.Edifact.Edi.Edifact_INVOIC_D00A.txt";
var ediStream = CommonHelper.LoadStream(sample);
var expected = CommonHelper.LoadString(sampleClean, Encoding.UTF8);
List <EdiItem> ediItems;
// ACT
using (var ediReader = new EdifactReader(ediStream, "EdiFabric.Rules.EdifactD00A"))
{
ediItems = ediReader.ReadToEnd().ToList();
}
var actual = EdifactHelper.Generate(ediItems, null, Environment.NewLine);
// ASSERT
Assert.IsNotNull(ediItems);
Assert.IsNotNull(ediItems.OfType <UNB>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <UNG>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <UNE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <UNZ>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
Assert.IsTrue(ediItems.OfType <TSINVOIC>().Count() == 1);
Assert.AreEqual(expected, actual);
}
public void TestSplitWithValidation()
{
// ARRANGE
const string sample = "EdiFabric.UnitTests.Edifact.Edi.Edifact_INVOIC_D00A_Split.txt";
var ediStream = CommonHelper.LoadStream(sample);
List <EdiItem> ediItems;
// ACT
using (var ediReader = new EdifactReader(ediStream, "EdiFabric.Rules.EdifactD00A.Rep"))
{
ediItems = ediReader.ReadToEnd().ToList();
}
// ASSERT
Assert.IsNotNull(ediItems);
Assert.IsNotNull(ediItems.OfType <UNB>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <UNG>().SingleOrDefault());
var messages = ediItems.OfType <Rules.EDIFACT_D00A.Rep.TSINVOICSplit>().ToList();
Assert.IsTrue(messages.Count(m => !m.HasErrors) == 3);
Assert.IsTrue(messages.Count(m => m.HasErrors) == 1);
Assert.IsNull(ediItems.OfType <UNE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <UNZ>().SingleOrDefault());
var linLoops = messages.Where(msg => msg.LINLoop1 != null).SelectMany(msg => msg.LINLoop1).ToList();
Assert.IsTrue(linLoops.Count > 1);
Assert.IsTrue(linLoops.First().Validate().ToList().Count == 1);
foreach (var linLoop in linLoops.Skip(1))
{
Assert.IsTrue(linLoop.Validate().ToList().Count == 0);
}
}
public void TestPostfixLf()
{
// ARRANGE
const string sample = "EdiFabric.UnitTests.Edifact.Edi.Edifact_INVOIC_D00A_LF.txt";
var ediStream = CommonHelper.LoadStream(sample);
var expected = CommonHelper.LoadString(sample, Encoding.UTF8);
List <EdiItem> ediItems;
// ACT
using (var ediReader = new EdifactReader(ediStream, "EdiFabric.Rules.EdifactD00A"))
{
ediItems = ediReader.ReadToEnd().ToList();
}
var actual = EdifactHelper.Generate(ediItems, null, "\n", Encoding.UTF8);
// ASSERT
Assert.IsNotNull(ediItems);
Assert.IsNotNull(ediItems.OfType <UNB>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <UNG>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <TSINVOIC>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <UNE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <UNZ>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
Assert.AreEqual(expected, actual);
}
public void TestLoadingWithDelegate()
{
// ARRANGE
const string sample = "EdiFabric.UnitTests.Edifact.Edi.Edifact_INVOIC_D00A.txt";
var ediStream = CommonHelper.LoadStream(sample);
var expected = CommonHelper.LoadString(sample, Encoding.UTF8);
List <EdiItem> ediItems;
// ACT
using (var ediReader = new EdifactReader(ediStream, AssemblyLoadFactory))
{
ediItems = ediReader.ReadToEnd().ToList();
}
var actual = EdifactHelper.Generate(ediItems, null, Environment.NewLine);
// ASSERT
Assert.IsNotNull(ediItems);
Assert.IsNotNull(ediItems.OfType <UNB>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <UNG>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <TSINVOIC>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <UNE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <UNZ>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Apply custom validation.
/// </summary>
public static void CrossSegmentValidation()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
Stream ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files.Edifact\PurchaseOrderInvalid.txt");
// The custom validation logic is applied in the template by implementing IEdiValidator.
// See EF_EDIFACT_D96A_TSORDERS_Validation.cs in project EdiFabric.Sdk.Edifact.Templates.D96A.Validation.
List <IEdiItem> ediItems;
using (var ediReader = new EdifactReader(ediStream, TemplateFactory.FullTemplateFactory))
ediItems = ediReader.ReadToEnd().ToList();
// Get the purchase order
var po = ediItems.OfType <TSORDERSValidation>().Single();
// Check that the custom validation was triggered
MessageErrorContext errorContext;
if (!po.IsValid(out errorContext))
{
var customValidation = errorContext.Errors.FirstOrDefault(e => e.Value == "DTM segment is missing.");
Debug.WriteLine(customValidation.Value);
}
}
/// <summary>
/// Validate EDI transactions async
/// </summary>
public static async void Run()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
Stream ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files\EDIFACT\MixedTransactions.txt");
List <IEdiItem> ediItems;
using (var reader = new EdifactReader(ediStream, "EdiFabric.Examples.EDIFACT.Templates.D96A"))
ediItems = reader.ReadToEnd().ToList();
var purchaseOrders = ediItems.OfType <TSORDERS>();
foreach (var purchaseOrder in purchaseOrders)
{
// Validate
Tuple <bool, MessageErrorContext> result = await purchaseOrder.IsValidAsync();
if (!result.Item1)
{
// Report it back to the sender, log, etc.
var errors = result.Item2.Flatten();
}
else
{
// purchaseOrder is valid, handle it downstream
}
}
}
/// <summary>
/// Save to DB with code first - this will create a new database the first time
/// Edit the connection string in app.config, by default it looks for a local SQL Server instance
/// </summary>
public static void Run()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
Stream ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files\EDIFACT\PurchaseOrder.txt");
List <IEdiItem> ediItems;
using (var ediReader = new EdifactReader(ediStream, "EdiFabric.Templates.Edifact"))
ediItems = ediReader.ReadToEnd().ToList();
var purchaseOrders = ediItems.OfType <TSORDERS>();
using (var db = new EDIFACTContext())
{
foreach (var purchaseOrder in purchaseOrders)
{
purchaseOrder.ClearCache();
db.TSORDERS.Add(purchaseOrder);
}
db.SaveChanges();
}
}
/// <summary>
/// Parsing partner specific message by custom template (added an extra field to BGM segment).
/// </summary>
public static void ReadCustomTemplate1()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
Stream ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files.Edifact\PurchaseOrderCustom1.txt");
// Resolve custom template by partner ID in the FullTemplateFactory
using (var ediReader = new EdifactReader(ediStream, TemplateFactory.FullTemplateFactory))
{
var ediItems = ediReader.ReadToEnd().ToList();
foreach (var ediItem in ediItems)
{
var msg = ediItem as TSORDERSCustom1;
if (msg != null)
{
MessageErrorContext errorContext;
if (msg.IsValid(out errorContext))
{
// The purchase order is valid, process it downstream
}
}
Debug.WriteLine(ediItem.GetType().Name);
}
}
}
/// <summary>
/// Validate INVOIC
/// </summary>
public static void Run()
{
var ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files\Edifact\Invoice.txt");
List <IEdiItem> ediItems;
using (var ediReader = new EdifactReader(ediStream, "EdiFabric.Templates.Edifact"))
ediItems = ediReader.ReadToEnd().ToList();
var invoices = ediItems.OfType <TSINVOIC>();
foreach (var invoice in invoices)
{
// Validate
MessageErrorContext errorContext;
if (!invoice.IsValid(out errorContext))
{
// Report it back to the sender, log, etc.
var errors = errorContext.Flatten();
}
else
{
// invoice is valid, handle it downstream
}
}
}
/// <summary>
/// Reads file with corrupt UNH and valid UNH
/// </summary>
public static void Run()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
Stream ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files\Edifact\CorruptUnh.txt");
// Set the continue on error flag to true
List <IEdiItem> ediItems;
using (var ediReader = new EdifactReader(ediStream, "EdiFabric.Examples.EDIFACT.Templates.D96A", new EdifactReaderSettings()
{
ContinueOnError = true
}))
ediItems = ediReader.ReadToEnd().ToList();
var readerErrors = ediItems.OfType <ReaderErrorContext>();
if (readerErrors.Any())
{
// The stream is corrupt
Debug.WriteLine(readerErrors.First().Exception.Message);
}
var purchaseOrders = ediItems.OfType <TSORDERS>();
foreach (var po in purchaseOrders)
{
// All valid purchase orders were extracted
}
}
/// <summary>
/// Reads purchase orders and invoices batched up in the same interchange.
/// </summary>
public static void ReadMixedTransactions()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
// 1. Load to a stream
Stream ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files.Edifact\MixedTransactions.txt");
// 2. Read multiple transactions batched up in the same interchange
using (var ediReader = new EdifactReader(ediStream, TemplateFactory.FullTemplateFactory))
{
while (ediReader.Read())
{
// Process purchase orders if no parsing errors
var po = ediReader.Item as TSORDERS;
if (po != null && !po.HasErrors)
{
ProcessPurchaseOrder(ediReader.CurrentInterchangeHeader, ediReader.CurrentGroupHeader, po);
}
// Process invoices if no parsing errors
var invoice = ediReader.Item as TSINVOIC;
if (invoice != null && !invoice.HasErrors)
{
ProcessInvoice(ediReader.CurrentInterchangeHeader, ediReader.CurrentGroupHeader, invoice);
}
}
}
}
public void EdifactReader_ReadCharacterFromShortStream()
{
const string value = @"UNOD";
var bytes = Utf8.GetBytes(value);
var sr = new EdifactReader(new MemoryStream(bytes), Utf8, EdifactCharacterSet.UNOX, '.');
Assert.AreEqual(sr.CharSet, EdifactCharacterSet.UNOD);
}
public void EdifactReader_CharacterSetMissingFromStream_Fallback()
{
const string value = @"dummy";
var bytes = Utf8.GetBytes(value);
var sr = new EdifactReader(new MemoryStream(bytes), Utf8, EdifactCharacterSet.UNOX, '.');
Assert.AreEqual(sr.CharSet, EdifactCharacterSet.UNOX);
}
public static List <EdiMessage <S_UNB, S_UNG> > ParseEdifactMultiple(string sample, Encoding encoding = null,
string rulesAssemblyName = null, string rulesNameSpacePrefix = null)
{
using (var ediReader = EdifactReader.Create(Load(sample), encoding, rulesAssemblyName, rulesNameSpacePrefix)
)
{
return(ediReader.ReadAllMessages().ToList());
}
}
public static EdiMessage <S_UNB, S_UNG> ParseEdifact(string sample, Encoding encoding = null,
string rulesAssemblyName = null, string rulesNameSpacePrefix = null)
{
using (var ediReader = EdifactReader.Create(Load(sample), encoding, rulesAssemblyName, rulesNameSpacePrefix)
)
{
return(ediReader.ReadMessage() ? ediReader.Message : null);
}
}
public static IEnumerable <object> ParseEdifact(string sample, Encoding encoding = null,
string rulesAssembly = null, string rulesNameSpacePrefix = null)
{
using (
var ediReader = EdifactReader.Create(Load(sample), rulesAssembly ?? "EdiFabric.Rules", rulesNameSpacePrefix ?? "EdiFabric.Rules",
encoding ?? Encoding.Default))
{
return(ediReader.ReadToEnd().ToList());
}
}
static void Main(string[] args)
{
var ediStream = File.OpenRead(@"\\valsrv03\sistemas\test\DELFORGA-SLHINJECTOPLAST 29082018 1047323639.edi");
List <EdiItem> edifactItems;
using (var ediReader = new EdifactReader(ediStream, "EdiFabric.Templates.Edifact"))
{
edifactItems = ediReader.ReadToEnd().ToList();
}
}
/// <summary>
/// Detect duplicate groups.
/// </summary>
public static void GenerateContrlWithDuplicateGroup()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
var edi = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files.Edifact\DuplicateGroup.txt");
var settings = new AckSettings
{
AckHandler = (s, a) =>
{
var contrl = a.Message as TSCONTRL;
if (contrl != null && a.AckType == AckType.Technical)
{
// a.Message is technical acknowledgment
}
if (contrl != null && a.AckType == AckType.Functional)
{
var ack = AckBuilders.BuildAck(a.InterchangeHeader, a.GroupHeader, contrl);
Debug.Write(ack);
}
},
MessageHandler = (s, a) =>
{
if (!a.ErrorContext.HasErrors)
{
if (a.InDuplicateGroup)
{
Debug.WriteLine(string.Format("Interchange with control number {0}", a.InterchangeHeader.InterchangeControlReference_5));
Debug.WriteLine(string.Format("Group with control number {0}", a.GroupHeader.GroupReferenceNumber_5));
Debug.WriteLine("Message {0} with control number {1}", a.Message.Name, a.Message.GetTransactionContext().HeaderControlNumber);
Debug.WriteLine("Is in duplicate group: {0}", a.InDuplicateGroup);
// reject message
}
}
},
// Turn on UCM for valid messages
GenerateForValidMessages = true,
GroupDuplicates = true
};
using (var ackMan = new Plugins.Acknowledgments.Edifact.AckMan(settings))
{
using (var ediReader = new EdifactReader(edi, TemplateFactory.FullTemplateFactory))
{
while (ediReader.Read())
{
ackMan.Publish(ediReader.Item);
}
}
}
}
public static void ParseModifiedPO(string ediFile)
{
Stream ediStream = File.OpenRead(Directory.GetCurrentDirectory() + ediFile);
List <IEdiItem> ediItems;
using (var ediReader = new EdifactReader(ediStream, ModifiedTypeFactory))
ediItems = ediReader.ReadToEnd().ToList();
var modifiedPurchaseOrders = ediItems.OfType <TSORDERSModified>();
}
/// <summary>
/// Auto increment custom control numbers.
/// </summary>
public static void GenerateContrlWithControlNumbers()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
var edi = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files.Edifact\PurchaseOrder.txt");
int unbControlNumber = 28;
int ungControlNumber = 35;
Debug.WriteLine("Start interchange control number: {0}", unbControlNumber);
Debug.WriteLine("Start group control number: {0}", ungControlNumber);
var settings = new AckSettings
{
AckHandler = (s, a) =>
{
var contrl = a.Message as TSCONTRL;
if (contrl != null && a.AckType == AckType.Technical)
{
// a.Message is technical acknowledgment
}
if (contrl != null && a.AckType == AckType.Functional)
{
var ack = AckBuilders.BuildAck(a.InterchangeHeader, a.GroupHeader, contrl, ++unbControlNumber, ++ungControlNumber);
Debug.Write(ack);
}
},
MessageHandler = (s, a) =>
{
if (!a.ErrorContext.HasErrors)
{
// do something with the message a.Message
Debug.WriteLine("Message {0} with control number {1} is valid.", a.ErrorContext.Name, a.ErrorContext.ControlNumber);
}
},
};
using (var ackMan = new Plugins.Acknowledgments.Edifact.AckMan(settings))
{
using (var ediReader = new EdifactReader(edi, TemplateFactory.FullTemplateFactory))
{
while (ediReader.Read())
{
ackMan.Publish(ediReader.Item);
}
}
}
Debug.WriteLine("Last interchange control number: {0}", unbControlNumber);
Debug.WriteLine("Last group control number: {0}", ungControlNumber);
}
/// <summary>
/// Detects duplicate groups.
/// </summary>
public static void GenerateContrlWithDuplicateGroup()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
var edi = Assembly.GetExecutingAssembly().GetManifestResourceStream("EdiFabric.Sdk.Edifact.Edi.DetectDuplicateGroup.txt");
var settings = new AckSettings
{
AckHandler = (s, a) =>
{
if (a.Message.Name == "CONTRL" && a.AckType == AckType.Technical)
{
// a.AckInterchange is technical acknowledgment
}
if (a.Message.Name == "CONTRL" && a.AckType == AckType.Functional)
{
var ack = BuildAck(a.InterchangeHeader, a.GroupHeader, a.Message);
Debug.Write(ack);
}
},
MessageHandler = (s, a) =>
{
if (!a.ErrorContext.HasErrors)
{
if (a.InDuplicateGroup)
{
Debug.WriteLine(string.Format("Interchange with control number {0}", a.InterchangeHeader.InterchangeControlReference_5));
Debug.WriteLine(string.Format("Group with control number {0}", a.GroupHeader.GroupReferenceNumber_5));
Debug.WriteLine("Message {0} with control number {1}", a.Message.Name, a.Message.GetTransactionContext().HeaderControlNumber);
Debug.WriteLine("Is in duplicate group: {0}", a.InDuplicateGroup);
// reject message
}
}
},
// Turn on UCM for valid messages
GenerateForValidMessages = true,
GroupDuplicates = true
};
var ackMan = new Plugins.Acknowledgments.Edifact.AckMan(settings);
using (var ediReader = new EdifactReader(edi, "EdiFabric.Sdk.Edifact"))
{
while (ediReader.Read())
{
ackMan.Publish(ediReader.Item);
}
}
ackMan.Complete();
}
/// <summary>
/// Auto increments non default control numbers.
/// </summary>
public static void GenerateContrlWithControlNumbers()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
var edi = Assembly.GetExecutingAssembly().GetManifestResourceStream("EdiFabric.Sdk.Edifact.Edi.PurchaseOrder.txt");
int unbControlNumber = 28;
int ungControlNumber = 35;
Debug.WriteLine("Start interchange control number: {0}", unbControlNumber);
Debug.WriteLine("Start group control number: {0}", ungControlNumber);
var settings = new AckSettings
{
AckHandler = (s, a) =>
{
if (a.Message.Name == "CONTRL" && a.AckType == AckType.Technical)
{
// a.AckInterchange is technical acknowledgment
}
if (a.Message.Name == "CONTRL" && a.AckType == AckType.Functional)
{
var ack = BuildAck(a.InterchangeHeader, a.GroupHeader, a.Message, ++unbControlNumber, ++ungControlNumber);
Debug.Write(ack);
}
},
MessageHandler = (s, a) =>
{
if (!a.ErrorContext.HasErrors)
{
// do something with the message a.Message
Debug.WriteLine("Message {0} with control number {1} is valid.", a.ErrorContext.Name, a.ErrorContext.ControlNumber);
}
},
};
var ackMan = new Plugins.Acknowledgments.Edifact.AckMan(settings);
using (var ediReader = new EdifactReader(edi, "EdiFabric.Sdk.Edifact"))
{
while (ediReader.Read())
{
ackMan.Publish(ediReader.Item);
}
}
ackMan.Complete();
Debug.WriteLine("Last interchange control number: {0}", unbControlNumber);
Debug.WriteLine("Last group control number: {0}", ungControlNumber);
}
/// <summary>
/// Generate CONTRL for a valid message.
/// </summary>
public static void GenerateContrlForValid()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
var edi = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files.Edifact\PurchaseOrder.txt");
var settings = new AckSettings
{
AckHandler = (s, a) =>
{
var contrl = a.Message as TSCONTRL;
if (contrl != null && a.AckType == AckType.Technical)
{
// a.Message is technical acknowledgment
}
if (contrl != null && a.AckType == AckType.Functional)
{
// Inspect the acknowledgment
var ackCode = contrl.UCI.Actioncoded_04;
var ack = AckBuilders.BuildAck(a.InterchangeHeader, a.GroupHeader, contrl);
Debug.Write(ack);
}
},
MessageHandler = (s, a) =>
{
if (!a.ErrorContext.HasErrors)
{
// do something with the message a.Message
Debug.WriteLine("Message {0} with control number {1} is valid.", a.ErrorContext.Name, a.ErrorContext.ControlNumber);
}
},
// Turn on UCM for valid messages
GenerateForValidMessages = true
};
using (var ackMan = new Plugins.Acknowledgments.Edifact.AckMan(settings))
{
using (var ediReader = new EdifactReader(edi, TemplateFactory.FullTemplateFactory))
{
while (ediReader.Read())
{
ackMan.Publish(ediReader.Item);
}
}
}
}
public void TestSplitMessage()
{
// ARRANGE
const string sample = "EdiWeave.UnitTests.Edifact.Edi.Edifact_INVOIC_D00A_Split.txt";
var ediStream = CommonHelper.LoadStream(sample);
List <EdiItem> ediItems;
// ACT
using (var ediReader = new EdifactReader(ediStream, "EdiWeave.Rules.EdifactD00A.Rep"))
{
ediItems = ediReader.ReadToEnd().ToList();
}
// ASSERT
Assert.IsNotNull(ediItems);
Assert.IsNotNull(ediItems.OfType <UNB>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <UNG>().SingleOrDefault());
var messages = ediItems.OfType <EdiWeave.Rules.EDIFACT_D00A.Rep.TSINVOICSplit>().ToList();
Assert.IsTrue(messages.Count(m => !m.HasErrors) == 3);
foreach (var msg in messages)
{
Assert.IsTrue(msg.MessagePart > 0);
Assert.IsTrue(!string.IsNullOrEmpty(msg.ControlNumber));
Assert.IsTrue(!string.IsNullOrEmpty(msg.Name));
Assert.IsTrue(!string.IsNullOrEmpty(msg.Format));
Assert.IsTrue(!string.IsNullOrEmpty(msg.Version));
MessageErrorContext mec;
if (!msg.IsValid(out mec))
{
Assert.IsTrue(mec.MessagePart > 0);
Assert.IsTrue(!string.IsNullOrEmpty(mec.ControlNumber));
Assert.IsTrue(!string.IsNullOrEmpty(mec.Name));
}
}
Assert.IsNull(ediItems.OfType <UNE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <UNZ>().SingleOrDefault());
var errors = ediItems.OfType <EdiWeave.Rules.EDIFACT_D00A.Rep.TSINVOICSplit>().Where(m => m.HasErrors).ToList();
Assert.IsTrue(errors.Count() == 1);
foreach (var err in errors)
{
Assert.IsTrue(err.MessagePart > 0);
Assert.IsTrue(!string.IsNullOrEmpty(err.ControlNumber));
Assert.IsTrue(!string.IsNullOrEmpty(err.Name));
}
}
/// <summary>
/// Detect duplicate messages.
/// </summary>
public static void Run()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
var edi = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files\Edifact\DuplicateMessage.txt");
var settings = new AckSettings
{
AckHandler = (s, a) =>
{
var contrl = a.Message as TSCONTRL;
if (contrl != null && a.AckType == AckType.Technical)
{
// a.Message is technical acknowledgment
}
if (contrl != null && a.AckType == AckType.Functional)
{
var ack = AckBuilders.BuildAck(a.InterchangeHeader, a.GroupHeader, contrl);
Debug.Write(ack);
}
},
MessageHandler = (s, a) =>
{
if (a.ErrorContext.HasErrors && a.ErrorContext.Codes.Any(c => c == Core.ErrorCodes.MessageErrorCode.DuplicateMessageControlNumber))
{
// do something with the message a.Message
Debug.WriteLine("Message {0} with control number {1} is duplicate.", a.ErrorContext.Name, a.ErrorContext.ControlNumber);
}
},
// Turn on UCM for valid messages
GenerateForValidMessages = true,
TransactionSetDuplicates = true,
TechnicalAck = TechnicalAck.Enforce
};
using (var ackMan = new Plugins.Acknowledgments.Edifact.AckMan(settings))
{
using (var ediReader = new EdifactReader(edi, "EdiFabric.Examples.EDIFACT.Templates.D96A"))
{
while (ediReader.Read())
{
ackMan.Publish(ediReader.Item);
}
}
}
}
public static IEnumerable <object> ParseEdifact(string sample, Encoding encoding = null,
string rulesAssemblyName = null, string rulesNameSpacePrefix = null)
{
using (
var ediReader = EdifactReader.Create(Load(sample),
new ReaderSettings
{
Encoding = encoding,
RulesAssemblyName = rulesAssemblyName,
RulesNamespacePrefix = rulesNameSpacePrefix
}))
{
return(ediReader.ReadToEnd().ToList());
}
}
