public void TestLoadingWithDelegate()
{
// ARRANGE
const string sample = "EdiFabric.UnitTests.X12.Edi.X12_810_00204.txt";
var ediStream = CommonHelper.LoadStream(sample);
var expected = CommonHelper.LoadString(sample);
List <EdiItem> ediItems;
// ACT
using (var ediReader = new X12Reader(ediStream, AssemblyLoadFactory))
{
ediItems = ediReader.ReadToEnd().ToList();
}
var actual = X12Helper.Generate(ediItems, null, Environment.NewLine);
// ASSERT
Assert.IsNotNull(ediItems);
Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <TS810>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <IEA>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
Assert.AreEqual(expected, actual);
}
} // Add a breakpoint here, run in debug mode and inspect ediItems
public static void Translate_HIPAA_5010()
{
// Change the path to point to your own file to test with
var path = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files\HIPAA\ClaimPayment.txt");
List <IEdiItem> ediItems;
using (var reader = new X12Reader(path, "EdiFabric.Templates.Hipaa", new X12ReaderSettings {
ContinueOnError = true
}))
ediItems = reader.ReadToEnd().ToList();
foreach (var message in ediItems.OfType <EdiMessage>())
{
if (!message.HasErrors)
{
// Message was successfully parsed
MessageErrorContext mec;
if (message.IsValid(out mec))
{
// Message was successfully validated
}
else
{
// Message failed validation with the following validation issues:
var validationIssues = mec.Flatten();
}
}
else
{
// Message was partially parsed with errors
}
}
} // Add a breakpoint here, run in debug mode and inspect ediItems
public void TestBlankRepetition()
{
// ARRANGE
const string sample = "EdiFabric.UnitTests.X12.Edi.X12_810_00204_BlankRepetition.txt";
const string cleanSample = "EdiFabric.UnitTests.X12.Edi.X12_810_00204_BlankRepetitionClean.txt";
var ediStream = CommonHelper.LoadStream(sample);
var expected = CommonHelper.LoadString(cleanSample);
List <EdiItem> ediItems;
Separators separators;
// ACT
using (var ediReader = new X12Reader(ediStream, "EdiFabric.Rules.X12002040"))
{
ediItems = ediReader.ReadToEnd().ToList();
separators = ediReader.Separators;
}
var actual = X12Helper.Generate(ediItems, separators, Environment.NewLine);
// ASSERT
Assert.IsNotNull(ediItems);
Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <TS810>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <IEA>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
Assert.AreEqual(expected, actual);
}
public void TestCrLf()
{
// ARRANGE
const string sample = "EdiWeave.UnitTests.X12.Edi.X12_810_00204_CRLF.txt";
var ediStream = CommonHelper.LoadStream(sample);
var expected = CommonHelper.LoadString(sample);
List <EdiItem> ediItems;
Separators separators;
// ACT
using (var ediReader = new X12Reader(ediStream, "EdiWeave.Rules.X12002040"))
{
ediItems = ediReader.ReadToEnd().ToList();
separators = ediReader.Separators;
}
var actual = X12Helper.Generate(ediItems, separators, "\n");
// ASSERT
Assert.IsNotNull(ediItems);
Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <TS810>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <IEA>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
Assert.AreEqual(expected, actual);
}
public void TestParseX12WithInterchangeRead()
{
// ARRANGE
const string sample = "EdiFabric.Tests.Edi.X12_810_00204_MultipleInterchanges.txt";
var ediItems = new List <object>();
// ACT
using (var ediReader = X12Reader.Create(TestHelper.Load(sample)))
{
while (ediReader.Read())
{
ediItems.Add(ediReader.Item);
if (!(ediReader.Item is S_IEA))
{
continue;
}
// ASSERT
Assert.IsNotNull(ediItems.OfType <S_ISA>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <S_GS>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <M_810>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <S_GE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <S_IEA>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <ParsingException>().SingleOrDefault());
ediItems.Clear();
}
}
}
/// <summary>
/// Validate data element data type using the extended X12 code set. These aren't validated by default and need to be explicitly requested.
/// </summary>
public static void Extended()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
Stream ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files\X12\MixedTransactions.txt");
List <IEdiItem> ediItems;
using (var reader = new X12Reader(ediStream, "EdiFabric.Templates.X12"))
ediItems = reader.ReadToEnd().ToList();
var purchaseOrders = ediItems.OfType <TS850>();
foreach (var purchaseOrder in purchaseOrders)
{
// Validate
MessageErrorContext errorContext;
if (!purchaseOrder.IsValid(out errorContext, new ValidationSettings {
SyntaxSet = new Extended()
}))
{
// Report it back to the sender, log, etc.
var errors = errorContext.Flatten();
}
else
{
// purchaseOrder is valid, handle it downstream
}
}
}
public void TestValidAndInvalidMessageRead()
{
// ARRANGE
const string sample = "EdiWeave.UnitTests.X12.Edi.X12_810_00204_ValidAndInvalidMessage.txt";
var ediStream = CommonHelper.LoadStream(sample);
List <EdiItem> ediItems;
// ACT
using (var ediReader = new X12Reader(ediStream, "EdiWeave.Rules.X12002040"))
{
ediItems = ediReader.ReadToEnd().ToList();
}
// ASSERT
Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <TS810>().SingleOrDefault(m => m.HasErrors));
Assert.IsNotNull(ediItems.OfType <TS810>().SingleOrDefault(m => !m.HasErrors));
Assert.IsNotNull(ediItems.OfType <GE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <IEA>().SingleOrDefault());
var error = ediItems.OfType <TS810>().SingleOrDefault(m => m.HasErrors);
Assert.IsNotNull(error);
Assert.IsNotNull(error.ErrorContext.Errors.Any(e => e.Codes.Contains(SegmentErrorCode.UnrecognizedSegment)));
}
public void TestNoValidationAttributes()
{
// ARRANGE
const string sample = "EdiWeave.UnitTests.X12.Edi.X12_810_00204.txt";
var ediStream = CommonHelper.LoadStream(sample);
var expected = CommonHelper.LoadString(sample);
List <EdiItem> ediItems;
// ACT
using (var ediReader = new X12Reader(ediStream, "EdiWeave.Rules.X12002040.NoValidation"))
{
ediItems = ediReader.ReadToEnd().ToList();
}
var actual = X12Helper.Generate(ediItems, null, Environment.NewLine);
// ASSERT
Assert.IsNotNull(ediItems);
Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <TS810NoValidation>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <IEA>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
Assert.AreEqual(expected, actual);
}
public void TestTooManyComponentDataElements()
{
// ARRANGE
const string sample = "EdiWeave.UnitTests.X12.Edi.X12_810_00204_InvalidSegment2.txt";
var ediStream = CommonHelper.LoadStream(sample);
List <EdiItem> ediItems;
// ACT
using (var ediReader = new X12Reader(ediStream, "EdiWeave.Rules.X12002040.Rep"))
{
ediItems = ediReader.ReadToEnd().ToList();
}
// ASSERT
Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <EdiWeave.Rules.X12_002040.Rep.TS810>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <IEA>().SingleOrDefault());
var error = ediItems.OfType <EdiWeave.Rules.X12_002040.Rep.TS810>().SingleOrDefault();
Assert.IsNotNull(error);
Assert.IsTrue(error.HasErrors);
Assert.IsNotNull(error);
Assert.IsTrue(error.ErrorContext.Errors.Any(e => e.Errors.Any(d => d.Code == DataElementErrorCode.TooManyComponents)));
Assert.IsNotNull(error.ErrorContext);
Assert.IsTrue(error.ErrorContext.Errors.Any(e => e.SpecType != null));
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 TestInterchangeRead()
{
// ARRANGE
const string sample = "EdiWeave.UnitTests.X12.Edi.X12_810_00204_MultipleInterchanges.txt";
var ediStream = CommonHelper.LoadStream(sample);
var ediItems = new List <object>();
// ACT
using (var ediReader = new X12Reader(ediStream, "EdiWeave.Rules.X12002040"))
{
while (ediReader.Read())
{
ediItems.Add(ediReader.Item);
if (!(ediReader.Item is IEA))
{
continue;
}
// ASSERT
Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <TS810>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <IEA>().SingleOrDefault());
Assert.IsNull(ediItems.OfType <ErrorContext>().SingleOrDefault());
ediItems.Clear();
}
}
}
public void TestMultipleInterchange()
{
// ARRANGE
const string sample = "EdiWeave.UnitTests.X12.Edi.X12_810_00204_MultipleInterchanges.txt";
var ediStream = CommonHelper.LoadStream(sample);
var expected = CommonHelper.LoadString(sample);
var ediItems = new List <EdiItem>();
// ACT
var actual = "";
using (var ediReader = new X12Reader(ediStream, "EdiWeave.Rules.X12002040"))
{
while (ediReader.Read())
{
if (ediReader.Item is ISA && ediItems.Any())
{
actual = actual + X12Helper.Generate(ediItems, null, Environment.NewLine);
ediItems.Clear();
}
ediItems.Add(ediReader.Item);
}
actual = actual + X12Helper.Generate(ediItems, ediReader.Separators, Environment.NewLine);
}
// ASSERT
Assert.AreEqual(expected, actual);
}
public void TestSplitWithValidation()
{
// ARRANGE
const string sample = "EdiWeave.UnitTests.X12.Edi.X12_810_00204_Split.txt";
var ediStream = CommonHelper.LoadStream(sample);
List <EdiItem> ediItems;
// ACT
using (var ediReader = new X12Reader(ediStream, "EdiWeave.Rules.X12002040.Rep"))
{
ediItems = ediReader.ReadToEnd().ToList();
}
// ASSERT
Assert.IsNotNull(ediItems);
Assert.IsNotNull(ediItems.OfType <ISA>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <GS>().SingleOrDefault());
var messages = ediItems.OfType <TS810Split>().ToList();
Assert.IsTrue(messages.Count(m => !m.HasErrors) == 7);
Assert.IsTrue(messages.Count(m => m.HasErrors) == 2);
Assert.IsNotNull(ediItems.OfType <GE>().SingleOrDefault());
Assert.IsNotNull(ediItems.OfType <IEA>().SingleOrDefault());
var n1Loops = messages.Where(msg => msg.N1Loop1 != null).SelectMany(msg => msg.N1Loop1).ToList();
Assert.IsTrue(n1Loops.Count > 1);
Assert.IsTrue(n1Loops.First().Validate().ToList().Count == 1);
foreach (var n1Loop in n1Loops.Skip(1))
{
Assert.IsTrue(n1Loop.Validate().ToList().Count == 0);
}
}
/// <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\X12\PurchaseOrder.txt");
List <IEdiItem> ediItems;
using (var ediReader = new X12Reader(ediStream, "EdiFabric.Templates.X12"))
ediItems = ediReader.ReadToEnd().ToList();
var purchaseOrders = ediItems.OfType <TS850>();
using (var db = new X12Context())
{
foreach (var purchaseOrder in purchaseOrders)
{
purchaseOrder.ClearCache();
db.TS850.Add(purchaseOrder);
}
db.SaveChanges();
}
}
/// <summary>
/// Validate 810
/// </summary>
public static void Run()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
Stream ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files\X12\Invoice.txt");
List <IEdiItem> ediItems;
using (var reader = new X12Reader(ediStream, "EdiFabric.Examples.X12.Templates.V4010"))
ediItems = reader.ReadToEnd().ToList();
var invoices = ediItems.OfType <TS810>();
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>
/// Validate 837 P
/// </summary>
public static void Run()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
Stream ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files\Hipaa\ClaimPayment.txt");
List <IEdiItem> ediItems;
using (var reader = new X12Reader(ediStream, "EdiFabric.Templates.Hipaa"))
ediItems = reader.ReadToEnd().ToList();
var claims = ediItems.OfType <TS837P>();
foreach (var claim in claims)
{
// Validate
MessageErrorContext errorContext;
if (!claim.IsValid(out errorContext))
{
// Report it back to the sender, log, etc.
var errors = errorContext.Flatten();
}
else
{
// claim is valid, handle it downstream
}
}
}
/// <summary>
/// Serialize an EDI object to XML
/// </summary>
public static void SerializeToXml()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
Stream purchaseOrderStream =
Assembly.GetExecutingAssembly()
.GetManifestResourceStream("EdiFabric.Sdk.X12.Edi.PurchaseOrder.txt");
List <EdiItem> ediItems;
using (var ediReader = new X12Reader(purchaseOrderStream, "EdiFabric.Sdk.X12"))
{
ediItems = ediReader.ReadToEnd().ToList();
}
var purchaseOrders = ediItems.OfType <TS850>();
foreach (var po in purchaseOrders)
{
var xml = Serialize(po);
Debug.WriteLine(xml.Root.ToString());
}
}
/// <summary>
/// Reads file with a corrupt ST and a valid ST
/// </summary>
public static void Run()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
Stream ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files\X12\CorruptSt.txt");
// Set the continue on error flag to true
List <IEdiItem> ediItems;
using (var ediReader = new X12Reader(ediStream, "EdiFabric.Templates.X12", new X12ReaderSettings()
{
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 <TS850>();
foreach (var po in purchaseOrders)
{
// All valid purchase orders were extracted
}
}
public static void Run()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
var ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files\X12\PurchaseOrderCSV.txt");
List <IEdiItem> ediItems;
using (var ediReader = new X12Reader(ediStream, "EdiFabric.Templates.X12"))
{
ediItems = ediReader.ReadToEnd().ToList();
}
var transactions = ediItems.OfType <TS850>();
foreach (var transaction in transactions)
{
// Serialize each transaction
var xml = transaction.Serialize();
// Transform each XML
XDocument outputXml = new XDocument();
using (XmlWriter writer = outputXml.CreateWriter())
{
XslCompiledTransform xslt = new XslCompiledTransform();
xslt.Load(XmlReader.Create(File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\Template850ToPurchaseOrderMap.xslt")));
xslt.Transform(xml.CreateReader(), writer);
}
// Deserialize into the destination type
PurchaseOrder customTransaction = outputXml.Root.Deserialize <PurchaseOrder>();
}
}
/// <summary>
/// Read Claim
/// </summary>
static void Read()
{
var ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files.Hipaa\ClaimPayment.txt");
List <IEdiItem> ediItems;
using (var ediReader = new X12Reader(ediStream, TemplateFactory.FullTemplateFactory))
ediItems = ediReader.ReadToEnd().ToList();
var transactions = ediItems.OfType <TS837P>();
foreach (var transaction in transactions)
{
MessageErrorContext mec;
if (transaction.IsValid(out mec))
{
// valid
}
else
{
// invalid
var errors = mec.Flatten();
}
}
}
/// <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\X12\MixedTransactions.txt");
List <IEdiItem> ediItems;
using (var reader = new X12Reader(ediStream, "EdiFabric.Templates.X12"))
ediItems = reader.ReadToEnd().ToList();
var purchaseOrders = ediItems.OfType <TS850>();
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>
/// Apply custom validation for cross segment or data element scenarios
/// The custom validation logic is in the rule
/// </summary>
public static void CrossSegmentValidation()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
Stream ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files.X12\PurchaseOrderInvalid.txt");
// The custom validation logic is applied in the template by implementing IEdiValidator.
// See
List <IEdiItem> ediItems;
using (var ediReader = new X12Reader(ediStream, TemplateFactory.FullTemplateFactory))
ediItems = ediReader.ReadToEnd().ToList();
// Get the purchase order
var po = ediItems.OfType <TS850Validation>().Single();
// Check that the custom validation was triggered
MessageErrorContext errorContext;
if (!po.IsValid(out errorContext))
{
var customValidation = errorContext.Errors.FirstOrDefault(e => e.Value == "N2 segment is missing.");
Debug.WriteLine(customValidation.Value);
}
}
/// <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.X12\MixedTransactions.txt");
// 2. Read multiple transactions batched up in the same interchange
using (var ediReader = new X12Reader(ediStream, TemplateFactory.FullTemplateFactory))
{
while (ediReader.Read())
{
// Process purchase orders if no parsing errors
var po = ediReader.Item as TS850;
if (po != null && !po.HasErrors)
{
ProcessPurchaseOrder(ediReader.CurrentInterchangeHeader, ediReader.CurrentGroupHeader, po);
}
// Process invoices if no parsing errors
var invoice = ediReader.Item as TS810;
if (invoice != null && !invoice.HasErrors)
{
ProcessInvoice(ediReader.CurrentInterchangeHeader, ediReader.CurrentGroupHeader, invoice);
}
}
}
}
/// <summary>
/// Parsing partner specific message by custom template (added an extra field to BGM segment).
/// </summary>
public static void ReadCustomTemplate2()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
Stream ediStream = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files.X12\PurchaseOrderCustom2.txt");
// Resolve custom template by partner ID in the FullTemplateFactory
using (var ediReader = new X12Reader(ediStream, TemplateFactory.FullTemplateFactory))
{
var ediItems = ediReader.ReadToEnd().ToList();
foreach (var ediItem in ediItems)
{
var msg = ediItem as TS850Custom2;
if (msg != null)
{
MessageErrorContext errorContext;
if (msg.IsValid(out errorContext))
{
// The purchase order is valid, process it downstream
}
}
Debug.WriteLine(ediItem.GetType().Name);
}
}
}
/// <summary>
/// Apply custom validation for cross segment or data element scenarios
/// The custom validation logic is in the rule
/// </summary>
private static void CrossSegmentValidation()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
// Load the sample purchase order to a stream
Stream purchaseOrderStream =
Assembly.GetExecutingAssembly()
.GetManifestResourceStream("EdiFabric.Sdk.X12.Edi.PurchaseOrderCustomValidation.txt");
// Read the contents as usual
List <EdiItem> ediItems;
using (var ediReader = new X12Reader(purchaseOrderStream, a => Assembly.GetExecutingAssembly()))
{
ediItems = ediReader.ReadToEnd().ToList();
}
// Get the purchase order
var po = ediItems.OfType <TS850Validation>().Single();
// Check that the custom validation was triggered
MessageErrorContext errorContext;
if (!po.IsValid(out errorContext))
{
var customValidation = errorContext.Errors.FirstOrDefault(e => e.Value == "N2 segment is missing.");
Debug.WriteLine(customValidation.Value);
}
}
/// <summary>
/// Split a message to parts (blocks of segments) and read each part individually
/// This is used for processing very large transactions
/// </summary>
private static void ReadWithSplitting()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
// Load the sample purchase order to a stream
Stream purchaseOrderStream =
Assembly.GetExecutingAssembly()
.GetManifestResourceStream("EdiFabric.Sdk.X12.Edi.PurchaseOrderN1Split.txt");
// Read the contents as usual
// The split is driven by the rule file
List <EdiItem> ediItems;
using (var ediReader = new X12Reader(purchaseOrderStream, a => Assembly.GetExecutingAssembly()))
{
ediItems = ediReader.ReadToEnd().ToList();
}
// Find all N1 loops, they are all different ediItems
var n1Loop = ediItems.OfType <TS850Split>().Where(m => m.N1Loop1 != null).SelectMany(m => m.N1Loop1);
Debug.WriteLine(string.Format("N1 parts {0}", n1Loop.Count()));
}
public async Task <string> ProcessDocument(string companyId,
TradingChannel.TradingChannel tradingChannel,
TradingPartner.TradingPartner tradingPartner,
string message, TradingPartnerMessage.TradingPartnerMessage messageData)
{
var ediStream = new MemoryStream(Encoding.Default.GetBytes(message));
List <IEdiItem> ediItems;
using (var reader = new X12Reader(ediStream, EdiHelper.TypeFactory))
{
var items = reader.ReadToEndAsync().Result;
ediItems = items.ToList();
string controlNumber = string.Empty;
string errorMessage = null;
foreach (var item in ediItems)
{
if (item is ISA isa)
{
// find the company with the sender id
var senderId = isa.InterchangeSenderID_6.Trim();
var rId = isa.InterchangeReceiverID_8.Trim();
continue;
// VERIFY PARTNER INFORMATION IS CORRECT
}
if (item is GS gs)
{
controlNumber = gs.GroupControlNumber_6;
continue;
}
var handler = _ediHandlers.FirstOrDefault(p => p.ForType.IsAssignableFrom(item.GetType()));
if (handler != null)
{
try
{
if (item is EdiMessage edi)
{
if (edi.HasErrors)
{
errorMessage = "EDI VALIDATION: " + string.Join(Environment.NewLine, edi.ErrorContext.Flatten());
return(errorMessage);
}
}
await handler.Handle(companyId, tradingChannel, tradingPartner, item, messageData);
}
catch (Exception ex)
{
errorMessage = ex.Message + Environment.NewLine +
ex.StackTrace + (ex.InnerException?.Message ?? string.Empty) +
(ex.InnerException?.StackTrace ?? string.Empty);
return(errorMessage);
}
}
}
}
return(null);
}
public static EdiMessage <S_ISA, S_GS> ParseX12(string sample, Encoding encoding = null,
string rulesAssemblyName = null, string rulesNameSpacePrefix = null)
{
using (var ediReader = X12Reader.Create(Load(sample), encoding, rulesAssemblyName, rulesNameSpacePrefix))
{
return(ediReader.ReadMessage() ? ediReader.Message : null);
}
}
public static List <EdiMessage <S_ISA, S_GS> > ParseX12Multiple(string sample, Encoding encoding = null,
string rulesAssemblyName = null, string rulesNameSpacePrefix = null)
{
using (var ediReader = X12Reader.Create(Load(sample), encoding, rulesAssemblyName, rulesNameSpacePrefix)
)
{
return(ediReader.ReadAllMessages().ToList());
}
}
/// <summary>
/// Auto increment custom control numbers.
/// </summary>
public static void Run()
{
Debug.WriteLine("******************************");
Debug.WriteLine(MethodBase.GetCurrentMethod().Name);
Debug.WriteLine("******************************");
var edi = File.OpenRead(Directory.GetCurrentDirectory() + @"\..\..\..\Files\X12\PurchaseOrder.txt");
int isaControlNumber = 28;
int gsControlNumber = 35;
Debug.WriteLine("Start interchange control number: {0}", isaControlNumber);
Debug.WriteLine("Start group control number: {0}", gsControlNumber);
var settings = new AckSettings
{
AckHandler = (s, a) =>
{
var tsTa1 = a.Message as TSTA1;
var ts997 = a.Message as TS997;
if (tsTa1 != null)
{
// a.Message is TA1
}
if (ts997 != null)
{
var ack = AckBuilders.BuildAck(a.InterchangeHeader, a.GroupHeader, ts997, AckVersion.X12_997, ++isaControlNumber, ++gsControlNumber);
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);
}
},
AckVersion = AckVersion.X12_997
};
using (var ackMan = new Plugins.Acknowledgments.X12.AckMan(settings))
{
using (var ediReader = new X12Reader(edi, "EdiFabric.Templates.X12"))
{
while (ediReader.Read())
{
ackMan.Publish(ediReader.Item);
}
}
}
Debug.WriteLine("Last interchange control number: {0}", isaControlNumber);
Debug.WriteLine("Last group control number: {0}", gsControlNumber);
}
public static IEnumerable <object> ParseX12(string sample, Encoding encoding = null,
string rulesAssembly = null, string rulesNameSpacePrefix = null)
{
using (
var ediReader = X12Reader.Create(Load(sample), rulesAssembly ?? "EdiFabric.Rules", rulesNameSpacePrefix ?? "EdiFabric.Rules",
encoding ?? Encoding.Default))
{
return(ediReader.ReadToEnd().ToList());
}
}
