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