private T SaveInterchange(Interchange interchange, string filename, string userName)
{
DateTime date = DateTime.MaxValue;
try
{
date = interchange.InterchangeDate;
}
catch (Exception exc)
{
Trace.TraceWarning("Interchange date '{0}' and time '{1}' could not be parsed. {2}", interchange.GetElement(9), interchange.GetElement(10), exc.Message);
}
SqlCommand cmd = new SqlCommand(GetContainerIdSql("ISA") + string.Format(@"
INSERT INTO [{0}].[Interchange] (Id, SenderId, ReceiverId, ControlNumber, [Date], SegmentTerminator, ElementSeparator, ComponentSeparator, Filename, HasError, CreatedBy, CreatedDate)
VALUES (@id, @senderId, @receiverId, @controlNumber, @date, @segmentTerminator, @elementSeparator, @componentSeparator, @filename, 0, @createdBy, getdate())
SELECT @id ", _schema));
cmd.Parameters.AddWithValue("@senderId", interchange.InterchangeSenderId);
cmd.Parameters.AddWithValue("@receiverId", interchange.InterchangeReceiverId);
cmd.Parameters.AddWithValue("@controlNumber", interchange.InterchangeControlNumber);
cmd.Parameters.AddWithValue("@date", date);
cmd.Parameters.AddWithValue("@segmentTerminator", interchange.Delimiters.SegmentTerminator);
cmd.Parameters.AddWithValue("@elementSeparator", interchange.Delimiters.ElementSeparator);
cmd.Parameters.AddWithValue("@componentSeparator", interchange.Delimiters.SubElementSeparator);
cmd.Parameters.AddWithValue("@filename", filename);
cmd.Parameters.AddWithValue("@createdBy", userName);
var interchangeId = ExecuteScalar(cmd);
return(base.ConvertT(interchangeId));
}
public void UnbundleItemsFrom856Test()
{
var parser = new X12Parser();
Interchange interchange = parser.ParseMultiple(Extensions.GetEdi("ORD._856.Example1.txt")).First();
var list = parser.UnbundleByLoop(interchange, "ITEM");
}
public void TestToInterchangeWithEnvelopeSchemaValidation()
{
// ARRANGE
const string sample = "EdiFabric.Tests.Edi.X12_810_00204.txt";
const string envelopeXsd = "EdiFabric.Tests.Xsd.X12Envelope.xsd";
// ACT
var interchange = Interchange.LoadFrom(Assembly.GetExecutingAssembly().GetManifestResourceStream(sample));
var xml = TestHelper.Serialize(interchange, TargetNamespaceX12);
var schemas = new XmlSchemaSet();
var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(envelopeXsd);
if (stream != null)
{
var schema = XmlSchema.Read(stream, null);
schemas.Add(schema);
}
var doc = new XDocument(xml);
var errors = false;
doc.Validate(schemas, (o, e) => { errors = true; });
// ASSERT
Assert.IsFalse(errors);
}
/// <summary>
/// Separates all <see cref="Segment"/> objects from an <see cref="Interchange"/>
/// </summary>
/// <param name="interchange">Object to remove Segments from</param>
/// <returns>Collection of <see cref="Interchange"/> objects</returns>
public List <Interchange> UnbundleByTransaction(Interchange interchange)
{
var interchanges = new List <Interchange>();
char terminator = interchange.Delimiters.SegmentTerminator;
string isa = interchange.SegmentString;
string iea = interchange.TrailerSegments.First().SegmentString;
foreach (FunctionGroup group in interchange.FunctionGroups)
{
foreach (Transaction transaction in group.Transactions)
{
var x12 = new StringBuilder();
x12.Append($"{isa}{terminator}");
x12.Append($"{group.SegmentString}{terminator}");
x12.Append(transaction.SerializeToX12(false));
x12.Append($"{group.TrailerSegments.First().SegmentString}{terminator}");
x12.Append($"{iea}{terminator}");
using (var mstream = new MemoryStream(Encoding.ASCII.GetBytes(x12.ToString())))
{
interchanges.AddRange(this.ParseMultiple(mstream));
}
}
}
return(interchanges);
}
public void TestToEdiWithTrailingSeparator()
{
// ARRANGE
const string sample = "EdiFabric.Tests.Xml.Edifact_INVOIC_D00A_TrailingSeparator.xml";
const string expectedResult = "EdiFabric.Tests.Edi.Edifact_INVOIC_D00A_TrailingSeparator.txt";
var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(expectedResult);
Debug.Assert(stream != null, "stream != null");
var reader = new StreamReader(stream);
var expectedEdi = new List <string>();
while (reader.Peek() >= 0)
{
expectedEdi.Add(reader.ReadLine());
}
// ACT
var parsedEdi = Interchange.LoadFrom(XElement.Load(Assembly.GetExecutingAssembly().GetManifestResourceStream(sample))).ToEdi();
// ASSERT
Assert.AreEqual(expectedEdi.Count, parsedEdi.Count);
for (int i = 0; i < parsedEdi.Count; i++)
{
Assert.IsTrue(parsedEdi[i] == expectedEdi[i]);
}
}
public void ParseInterchangeToXml()
{
var x = new XmlDocument();
var i = new Interchange(DateTime.Now, 1, true);
var fg = i.AddFunctionGroup("HS", DateTime.Now, 11, "005010X279A1");
Transaction st = fg.AddTransaction("270", "1001");
var xml = i.Serialize(true);
x.PreserveWhitespace = true;
x.LoadXml(xml);
var assertCount = new Action <string, int>((s, c) =>
{
var o = int.Parse(x.SelectSingleNode(s).InnerText);
Assert.IsNotNull(o);
Assert.AreEqual(c, o, s + " count is wrong");
});
assertCount("Interchange/IEA/IEA01", 1);
assertCount("Interchange/FunctionGroup/GE/GE01", 1);
assertCount("Interchange/FunctionGroup/Transaction/SE/SE01", 2);
var prsr = new X12Parser();
var edi = prsr.TransformToX12(x.OuterXml);
prsr.ParseMultiple(edi);
}
public List <Interchange> UnbundleByTransaction(Interchange interchange)
{
List <Interchange> interchanges = new List <Interchange>();
char terminator = interchange._delimiters.SegmentTerminator;
var service = new UnbundlingService(interchange._delimiters.SegmentTerminator);
string isa = interchange.SegmentString;
string iea = interchange.TrailerSegments.First().SegmentString;
List <string> list = new List <string>();
foreach (FunctionGroup group in interchange.FunctionGroups)
{
foreach (Transaction transaction in group.Transactions)
{
StringBuilder x12 = new StringBuilder();
x12.AppendFormat("{0}{1}", isa, terminator);
x12.AppendFormat("{0}{1}", group.SegmentString, terminator);
x12.Append(transaction.SerializeToX12(false));
x12.AppendFormat("{0}{1}", group.TrailerSegments.First().SegmentString, terminator);
x12.AppendFormat("{0}{1}", iea, terminator);
using (MemoryStream mstream = new MemoryStream(Encoding.ASCII.GetBytes(x12.ToString())))
{
interchanges.AddRange(ParseMultiple(mstream));
}
}
}
return(interchanges);
}
public List <Interchange> UnbundleByLoop(Interchange interchange, string loopId)
{
char terminator = interchange._delimiters.SegmentTerminator;
var service = new UnbundlingService(interchange._delimiters.SegmentTerminator);
string isa = interchange.SegmentString;
string iea = interchange.TrailerSegments.First().SegmentString;
List <string> list = new List <string>();
foreach (FunctionGroup group in interchange.FunctionGroups)
{
foreach (Transaction transaction in group.Transactions)
{
service.UnbundleHLoops(list, transaction, loopId);
}
}
List <Interchange> interchanges = new List <Interchange>();
foreach (var item in list)
{
StringBuilder x12 = new StringBuilder();
x12.AppendFormat("{0}{1}", isa, terminator);
x12.Append(item);
x12.AppendFormat("{0}{1}", iea, terminator);
using (MemoryStream mstream = new MemoryStream(Encoding.ASCII.GetBytes(x12.ToString())))
{
interchanges.AddRange(ParseMultiple(mstream));
}
}
return(interchanges);
}
public void TestToEdiWithSegmentList()
{
// ARRANGE
const string sample = "EdiFabric.Tests.Xml.X12_810_00204_SegmentList.xml";
const string expectedResult = "EdiFabric.Tests.Edi.X12_810_00204.txt";
var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(expectedResult);
Debug.Assert(stream != null, "stream != null");
var reader = new StreamReader(stream);
var expectedEdi = new List <string>();
while (reader.Peek() >= 0)
{
expectedEdi.Add(reader.ReadLine());
}
var interchangeContext = new InterchangeContext
{
RepetitionSeparator = "|"
};
// ACT
var parsedEdi =
Interchange.LoadFrom(XElement.Load(Assembly.GetExecutingAssembly().GetManifestResourceStream(sample))).ToEdi(interchangeContext);
// ASSERT
Assert.AreEqual(expectedEdi.Count, parsedEdi.Count);
for (int i = 0; i < parsedEdi.Count; i++)
{
Assert.IsTrue(parsedEdi[i] == expectedEdi[i]);
}
}
public void TestToInterchangeWithInvalidEnum()
{
// ARRANGE
const string sample = "EdiFabric.Tests.Edi.Hipaa_837P_00401_BadSegment.txt";
const string expectedErrorMessage = "Instance validation error: 'CL' is not a valid value for S_BHT_BeginningOfHierarchicalTransaction_TS837Q1D_BHT06_ClaimOrEncounterIdentifier.";
// ACT
try
{
var interchange = Interchange.LoadFrom(Assembly.GetExecutingAssembly().GetManifestResourceStream(sample));
var message = interchange.Groups[0].Messages[0];
if (message.Context.Tag == "837" && message.Context.Origin == "X098")
{
message.DeserializeItem <M_837>();
// ASSERT
Assert.Fail();
}
else
{
Assert.Fail();
}
}
catch (Exception ex)
{
// ASSERT
Assert.IsTrue(ex.InnerException.Message == expectedErrorMessage);
}
}
public static void Main(string[] args)
{
Interchange I1= new Interchange();
I1.Swap();
I1.Display();
Console.ReadLine();
}
public void FlattenUsingXmlDocument()
{
Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("OopFactory.X12.Tests.Unit.Parsing._SampleEdiFiles.ORD._820.Example1_MortgageBankers.txt");
X12Parser parser = new X12Parser();
Interchange interchange = parser.ParseMultiple(stream).First();
string xml = interchange.Serialize();
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
FileStream fstream = new FileStream("ORD._820.Example1.txt", FileMode.Create);
StreamWriter writer = new StreamWriter(fstream);
writer.WriteLine("Transaction,Creation Date,Submitter Name, Borrower Last Name, Remittance ID");
foreach (XmlElement transaction in doc.SelectNodes("/Interchange/FunctionGroup/Transaction"))
{
foreach (XmlElement entity in transaction.SelectNodes("Loop[@LoopId='ENT']"))
{
foreach (XmlElement remit in entity.SelectNodes("Loop[@LoopId='RMR']"))
{
writer.WriteLine("{0},{1},{2},{3},{4}",
transaction.SelectSingleNode("ST/ST02").InnerText,
transaction.SelectSingleNode("DTM[DTM01='097']/DTM02").InnerText,
transaction.SelectSingleNode("Loop[@LoopId='N1']/N1[N101='41']/N102").InnerText,
entity.SelectSingleNode("Loop[@LoopId='NM1']/NM1[NM101='BW']/NM103").InnerText,
remit.SelectSingleNode("RMR/RMR02").InnerText);
}
}
}
writer.Close();
fstream.Close();
}
public void ParseModifyAndTransformBackToX12(
[ValueSource(typeof(ResourcePathManager), nameof(ResourcePathManager.ResourcePaths))]
string resourcePath)
{
var stream = GetEdi("INS._270._4010.Example1_DHHS.txt");
var parser = new X12Parser();
Interchange interchange = parser.ParseMultiple(stream).First();
string xml = interchange.Serialize();
var doc = new XmlDocument
{
PreserveWhitespace = true
};
doc.LoadXml(xml);
XmlElement dmgElement = (XmlElement)doc.GetElementsByTagName("DMG")[0];
dmgElement.ParentNode.RemoveChild(dmgElement);
string x12 = parser.TransformToX12(doc.OuterXml);
var modifiedInterchange = parser.ParseMultiple(x12).First();
string newX12 = modifiedInterchange.SerializeToX12(true);
var seSegment = modifiedInterchange.FunctionGroups.First().Transactions.First().TrailerSegments.FirstOrDefault(ts => ts.SegmentId == "SE");
Assert.IsNotNull(seSegment);
Assert.AreEqual("0001", seSegment.GetElement(2));
Assert.AreEqual("15", seSegment.GetElement(1));
}
static void Main(string[] args)
{
string inputFilename = args[0];
string outputFilename = args[1];
string isaControlNumber = args.Length > 2 ? args[2] : "999";
string gsControlNumber = args.Length > 3 ? args[3] : "99";
var service = new X12AcknowledgmentService();
using (FileStream fs = new FileStream(inputFilename, FileMode.Open, FileAccess.Read))
{
using (X12StreamReader reader = new X12StreamReader(fs, Encoding.UTF8))
{
var firstTrans = reader.ReadNextTransaction();
if (reader.LastTransactionCode == "837")
{
if (reader.TransactionContainsSegment(firstTrans.Transactions[0], "SV2"))
{
service = new InstitutionalClaimAcknowledgmentService();
}
if (reader.TransactionContainsSegment(firstTrans.Transactions[0], "SV1"))
{
service = new X12AcknowledgmentService(new ProfessionalClaimSpecificationFinder());
}
}
}
}
using (FileStream fs = new FileStream(inputFilename, FileMode.Open, FileAccess.Read))
{
// Create aknowledgements and identify errors
var responses = service.AcknowledgeTransactions(fs);
// Change any acknowledgment codes here to reject transactions with errors
// CUSTOM BUSINESS LOGIC HERE
// Transform to outbound interchange for serialization
var interchange = new Interchange(DateTime.Now, int.Parse(isaControlNumber), true);
interchange.AuthorInfoQualifier = ConfigurationManager.AppSettings["AuthorInfoQualifier"];
interchange.AuthorInfo = ConfigurationManager.AppSettings["AuthorInfo"];
interchange.SecurityInfoQualifier = ConfigurationManager.AppSettings["SecurityInfoQualifier"];
interchange.SecurityInfo = ConfigurationManager.AppSettings["SecurityInfo"];
interchange.InterchangeSenderIdQualifier = ConfigurationManager.AppSettings["InterchangeSenderIdQualifier"];
interchange.InterchangeSenderId = ConfigurationManager.AppSettings["InterchangeSenderId"];
interchange.InterchangeReceiverIdQualifier = responses.First().SenderIdQualifier;
interchange.InterchangeReceiverId = responses.First().SenderId;
interchange.SetElement(12, "00501");
var group = interchange.AddFunctionGroup("FA", DateTime.Now, int.Parse(gsControlNumber));
group.ApplicationSendersCode = ConfigurationManager.AppSettings["InterchangeSenderId"];
group.VersionIdentifierCode = "005010X231A1";
group.Add999Transaction(responses);
// This is a demonstration example only, change true to false to create continous x12 without line feeds.
File.WriteAllText(outputFilename, interchange.SerializeToX12(true));
}
}
public void TransactionCreationTest()
{
Interchange interchange = CreateSample1WithFunctionGroup();
interchange.FunctionGroups.First().AddTransaction("837", "0034");
Assert.AreEqual(TransactionSample1, interchange.SerializeToX12(true));
}
static void Main()
{
Interchange I1 = new Interchange();
I1.Swap();
I1.Display();
Console.ReadLine();
}
public static void Main(string[] args)
{
Interchange I1 = new Interchange();
I1.Swap();
I1.Display();
Console.ReadLine();
}
public void TransactionCreationWithSegmentFromStringTest()
{
Interchange interchange = this.CreateSample1WithFunctionGroup();
Transaction transaction = interchange.FunctionGroups.First().AddTransaction("837", "0034");
Segment bht = transaction.AddSegment("BHT*0019*00*3920394930203*20070816*1615*CH");
Assert.AreEqual("0019", bht.GetElement(1));
}
public void UnbundleClaimsIn837FromNthTest()
{
X12Parser parser = new X12Parser();
Interchange interchange = parser.ParseMultiple(Extensions.GetEdi("INS._837P._4010.FromNth.837_DeIdent_05.dat")).First();
var list = parser.UnbundleByLoop(interchange, "2300");
Assert.AreEqual(186, list.Count);
}
public void Unbundling835ByLoop2110()
{
X12Parser parser = new X12Parser();
Interchange interchange = parser.ParseMultiple(Extensions.GetEdi("INS._835._4010.Example1_GripElements.txt")).First();
var list = parser.UnbundleByLoop(interchange, "2110");
Assert.AreEqual(9, list.Count);
}
public void ClaimCreationTest()
{
Interchange interchange = CreateSample1WithFunctionGroup();
Transaction transaction = interchange.FunctionGroups.First().AddTransaction("837", "0034");
Segment bhtSegment = transaction.AddSegment("BHT*0019*00*3920394930203*20070816*1615*CH");
Segment refSegment = transaction.AddSegment("REF*87*004010X096A1");
Loop senderLoop = transaction.AddLoop("NM1*41*2*HOWDEE HOSPITAL*****XX*0123456789");
senderLoop.AddSegment("PER*IC*BETTY RUBBLE*TE*9195551111");
Loop receiverLoop = transaction.AddLoop("NM1*40*2*BLUE CROSS BLUE SHIELD OF NC*****46*987654321");
HierarchicalLoop providerLoop = transaction.AddHLoop("1", "20", true);
providerLoop.AddSegment("PRV*BI*ZZ*203BA0200N");
var billingProvider = providerLoop.AddLoop("NM1*85*2*HOWDEE HOSPITAL*****XX*0123456789");
billingProvider.AddSegment("N3*123 HOWDEE BOULEVARD");
billingProvider.AddSegment("N4*DURHAM*NC*27701");
billingProvider.AddSegment("REF*1J*654");
billingProvider.AddSegment("PER*IC*BETTY RUBBLE*TE*9195551111*FX*6145551212");
HierarchicalLoop subscriberLoop = providerLoop.AddHLoop("2", "22", false);
subscriberLoop.AddSegment("SBR*P*18*XYZ1234567******BL");
subscriberLoop.AddSegment("PAT*********Y");
var subscriberNameLoop = subscriberLoop.AddLoop("NM1*IL*1*DOUGH*MARY****MI*12312312312");
subscriberNameLoop.AddSegment("N3*BOX 12312");
subscriberNameLoop.AddSegment("N4*DURHAM*NC*27715");
subscriberNameLoop.AddSegment("DMG*D8*19670807*F");
subscriberLoop.AddLoop("NM1*PR*2*BLUE CROSS BLUE SHIELD OF NC*****PI*987654321");
var claimLoop = subscriberLoop.AddLoop("CLM*2235057*200***13:A:1*Y**Y*A*********N");
claimLoop.AddSegment("DTP*434*RD8*20070730-20070730");
claimLoop.AddSegment("CL1*1*9*01");
claimLoop.AddSegment("AMT*C5*160");
claimLoop.AddSegment("REF*F8*ASD0000123");
claimLoop.AddSegment("HI*BK:25000");
claimLoop.AddSegment("HI*BF:78901");
claimLoop.AddSegment("HI*BR:4491:D8:20070730");
claimLoop.AddSegment("HI*BH:41:D8:20070501*BH:27:D8:20070715*BH:33:D8:20070415*BH:C2:D8:20070410");
claimLoop.AddSegment("HI*BE:30:::20");
claimLoop.AddSegment("HI*BG:01");
var physicianLoop = claimLoop.AddLoop("NM1*71*1*SMITH*ELIZABETH*AL***34*243898989");
physicianLoop.AddSegment("REF*1G*P97777");
var claimLineLoop = claimLoop.AddLoop("LX*1");
claimLineLoop.AddSegment("SV2*0300*HC:81000*120*UN*1");
claimLineLoop.AddSegment("DTP*472*D8*20070730");
claimLineLoop = claimLoop.AddLoop("LX*2");
claimLineLoop.AddSegment("SV2*0320*HC:76092*50*UN*1");
claimLineLoop.AddSegment("DTP*472*D8*20070730");
claimLineLoop = claimLoop.AddLoop("LX*3");
claimLineLoop.AddSegment("SV2*0270*HC:J1120*30*UN*1");
claimLineLoop.AddSegment("DTP*472*D8*20070730");
Assert.AreEqual(new StreamReader(Extensions.GetEdi("INS._837I._4010.Example1.txt")).ReadToEnd(), interchange.SerializeToX12(true));
}
private Interchange CreateSample1WithFunctionGroup()
{
Interchange interchange = CreateSample1InterChange(DateTime.Parse("2002-08-16 11:44AM"));
FunctionGroup fg = interchange.AddFunctionGroup("HC", DateTime.Parse("2007-08-16 4:15PM"), 31);
fg.ApplicationSendersCode = "901234572000";
fg.ApplicationReceiversCode = "908887732000";
return(interchange);
}
public void OutlineIsSameAsOriginal()
{
var parser = new X12Parser();
Interchange interchange = parser.ParseMultiple(new MemoryStream(Encoding.ASCII.GetBytes(this.inquiry))).First();
Interchange interchangeFromOutline = parser.ParseMultiple(new MemoryStream(Encoding.ASCII.GetBytes(this.inquiryOutline))).First();
Assert.AreEqual(interchange.SerializeToX12(false), interchangeFromOutline.SerializeToX12(false));
}
private Interchange CreateSample1InterChange(DateTime date)
{
Interchange interchange = new Interchange(date, 31, false);
interchange.InterchangeSenderId = "9012345720000";
interchange.InterchangeReceiverId = "9088877320000";
return(interchange);
}
/// <summary>
/// Main entry point for the driver
/// </summary>
/// <param name="args">Additional arguments for program options</param>
public static void Main(string[] args)
{
var opts = new ExecutionOptions();
try
{
opts.LoadOptions(args);
}
catch (ArgumentException exc)
{
Console.Write(exc.Message);
return;
}
var parser = new X12Parser();
foreach (var filename in Directory.GetFiles(opts.InputDirectory, opts.FilenamePattern))
{
var inputFile = new FileInfo(filename);
var list = new List <Interchange>();
using (var fs = new FileStream(inputFile.FullName, FileMode.Open, FileAccess.Read))
{
var reader = new X12StreamReader(fs, Encoding.UTF8);
X12FlatTransaction transaction = reader.ReadNextTransaction();
while (!string.IsNullOrEmpty(transaction.Transactions.First()))
{
string x12 = transaction.ToString();
Interchange interchange = parser.ParseMultiple(x12).First();
if (opts.LoopId == "ST")
{
list.Add(interchange);
}
else
{
list.AddRange(parser.UnbundleByLoop(interchange, opts.LoopId));
}
transaction = reader.ReadNextTransaction();
}
}
for (int i = 0; i < list.Count; i++)
{
string outputFilename = string.Format(opts.FormatString, opts.OutputDirectory, inputFile.Name, i + 1, inputFile.Extension);
using (var outputFilestream = new FileStream(outputFilename, FileMode.Create, FileAccess.Write))
using (var writer = new StreamWriter(outputFilestream))
{
writer.Write(list[i].SerializeToX12(opts.IncludeWhitespace));
}
}
}
}
public void Unbundle835FromNthTest()
{
// arrange
var parser = new X12Parser();
Interchange interchange = parser.ParseMultiple(Extensions.GetEdi("INS._835._4010.FromNth.835_DeIdent_02.dat")).First();
// act
var list = parser.UnbundleByLoop(interchange, "2000");
// assert
Assert.AreEqual(6, list.Count);
}
public void TestMessageContextFromType()
{
// ARRANGE
const string sample = "EdiFabric.Tests.Edi.Hipaa_837P_00401.txt";
// ACT
var interchange = Interchange.LoadFrom(Assembly.GetExecutingAssembly().GetManifestResourceStream(sample));
var systemType = (new MessageContext(interchange.Groups[0].Messages[0].Context.SystemType)).SystemType;
// ASSERT
Assert.IsNotNull(systemType);
}
public void CreatePurchaseOrder850()
{
string expected = @"ISA*00* *00* *01*828513080 *01*001903202U *100817*0850*U*00401*000000245*0*P*:~
GS*PO*828513080*001903202U*20100817*0850*245*X*005010X222~
ST*850*0001~
BEG*05*SA*S41000439**20100810~
CUR*BY*USD~
PER*IC*Doe,Jane******Doe,Jane~
SE*5*0001~
GE*1*1~
IEA*1*000000245~";
var purcaseOrderDate = new DateTime(2010, 8, 17, 08, 50, 0);
var interchange = new Interchange(purcaseOrderDate, 245, true)
{
InterchangeSenderIdQualifier = "01",
InterchangeSenderId = "828513080",
InterchangeReceiverIdQualifier = "01",
InterchangeReceiverId = "001903202U",
InterchangeDate = purcaseOrderDate,
};
interchange.SetElement(14, "0");
FunctionGroup group = interchange.AddFunctionGroup("PO", purcaseOrderDate, 1, "005010X222");
group.ApplicationSendersCode = "828513080";
group.ApplicationReceiversCode = "001903202U";
group.Date = purcaseOrderDate;
group.ControlNumber = 245;
Transaction transaction = group.AddTransaction("850", "0001");
Segment bhtSegment = transaction.AddSegment("BEG");
bhtSegment.SetElement(1, "05");
bhtSegment.SetElement(2, "SA");
bhtSegment.SetElement(3, "S41000439");
bhtSegment.SetElement(5, "20100810");
bhtSegment = transaction.AddSegment("CUR");
bhtSegment.SetElement(1, "BY");
bhtSegment.SetElement(2, "USD");
bhtSegment = transaction.AddSegment("PER");
bhtSegment.SetElement(1, "IC");
bhtSegment.SetElement(2, "Doe,Jane");
bhtSegment.SetElement(8, "Doe,Jane");
var x12 = interchange.SerializeToX12(true);
Assert.AreEqual(expected, x12);
}
public void UnbundleItemsFrom856Test()
{
X12Parser parser = new X12Parser();
Interchange interchange = parser.ParseMultiple(Extensions.GetEdi("ORD._856.Example1.txt")).First();
var list = parser.UnbundleByLoop(interchange, "ITEM");
foreach (var item in list)
{
Trace.WriteLine("...");
Trace.WriteLine(item.SerializeToX12(true));
}
}
public void UnbundleClaimsIn837ByServiceLineTest()
{
// arrange
string lastServiceLine = @"ISA*00* *01*SECRET *ZZ*SUBMITTERS.ID *ZZ*RECEIVERS.ID *930602*1253*^*00401*000000905*1*T*:~
GS*HC*SENDER CODE*RECEIVER CODE*1994033*0802*1*X*004010X098A1~
ST*837*0021~
BHT*0019*00*0123*19981015*1023*RP~
REF*87*004010X098~
NM1*41*2*PREMIER BILLING SERVICE*****46*TGJ23~
PER*IC*JERRY*TE*3055552222*EX*231~
NM1*40*2*REPRICER XYZ*****46*66783JJT~
HL*1**20*1~
NM1*85*2*PREMIER BILLING SERVICE*****24*587654321~
N3*234 Seaway St~
N4*Miami*FL*33111~
NM1*87*2*KILDARE ASSOC*****24*581234567~
N3*2345 OCEAN BLVD~
N4*MIAMI*FL*33111~
HL*2*1*22*0~
SBR*P*18*12312-A******HM~
NM1*IL*1*SMITH*TED****34*000221111~
N3*236 N MAIN ST~
N4*MIAMI*FL*33413~
DMG*D8*19430501*M~
NM1*PR*2*ALLIANCE HEALTH AND LIFE INSURANCE*****PI*741234~
CLM*26462967*100***11::1*Y*A*Y*Y*C~
DTP*431*D8*19981003~
REF*D9*17312345600006351~
HI*BK:0340*BF:V7389~
NM1*82*1*KILDARE*BEN****34*112233334~
PRV*PE*ZZ*203BF0100Y~
NM1*77*2*KILDARE ASSOCIATES*****24*581234567~
N3*2345 OCEAN BLVD~
N4*MIAMI*FL*33111~
LX*4~
SV1*HC:86663*10*UN*1***2**N~
DTP*472*D8*19981010~
SE*33*0021~
GE*1*1~
IEA*1*000000905~";
var parser = new X12Parser();
Interchange interchange = parser.ParseMultiple(Extensions.GetEdi("INS._837P._4010.Spec_4.1.1_PatientIsSubscriber.txt")).First();
// act
var list = parser.UnbundleByLoop(interchange, "2400");
// assert
Assert.AreEqual(4, list.Count);
Assert.AreEqual(lastServiceLine, list[3].SerializeToX12(true));
}
public void ParseToXml()
{
string resourcePath = Convert.ToString(TestContext.DataRow["ResourcePath"]);
Trace.WriteLine(resourcePath);
Stream stream = GetEdi(resourcePath);
X12Parser parser = new X12Parser();
Interchange interchange = parser.ParseMultiple(stream).First();
string xml = interchange.Serialize();
#if DEBUG
new FileStream(resourcePath.Replace(".txt", ".xml"), FileMode.Create).PrintToFile(xml);
#endif
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
int index = 1;
string query = GetXPathQuery(index);
while (!string.IsNullOrWhiteSpace(query))
{
string expected = GetExpectedValue(index);
XmlNode node = doc.SelectSingleNode((string)query);
Assert.IsNotNull(node, "Query '{0}' not found in {1}.", query, resourcePath);
Assert.AreEqual(expected, node.InnerText, "Value {0} not expected from query {1} in {2}.", node.InnerText, query, resourcePath);
Trace.WriteLine(String.Format("Query '{0}' succeeded.", query));
query = GetXPathQuery(++index);
}
if (resourcePath.Contains("_837D"))
{
stream = GetEdi(resourcePath);
parser = new X12Parser(new DentalClaimSpecificationFinder());
interchange = parser.ParseMultiple(stream).First();
xml = interchange.Serialize();
#if DEBUG
new FileStream(resourcePath.Replace(".txt", "_837D.xml"), FileMode.Create).PrintToFile(xml);
#endif
}
if (resourcePath.Contains("_837I"))
{
stream = GetEdi(resourcePath);
parser = new X12Parser(new InstitutionalClaimSpecificationFinder());
interchange = parser.ParseMultiple(stream).First();
xml = interchange.Serialize();
#if DEBUG
new FileStream(resourcePath.Replace(".txt", "_837I.xml"), FileMode.Create).PrintToFile(xml);
#endif
}
}
/// <summary>
/// Parse input EDI file and convert it into JSON file.
/// </summary>
/// <param name="inputFileName"></param>
public void Parse(string inputFileName)
{
fileProvider.InputAddress = inputFileName;
char segmentSeparator, dataElementSeparator, dataComponentSeparator;
var lines = GetLinesAndSeparators(fileProvider, errors, out segmentSeparator,
out dataElementSeparator,
out dataComponentSeparator);
// Separator errors are FATAL errors!
if (errors.Logs.Count != 0)
{
errors.Report();
fileProvider.WriteAllLines(fileProvider.ErrorsAddress, errors.Logs);
return;
}
var interchange = new Interchange
{
SegmentSeparator = segmentSeparator,
DataElementSeparator = dataElementSeparator,
DataComponentSeparator = dataComponentSeparator
};
var segments = ReadAllSegments(lines, interchange.SegmentSeparator, interchange.DataElementSeparator,
errors);
TraversAllSegments(interchange, segments, errors);
// Check if errors happened and Assert the top level EDI structure, like missed IEA segment.
if (errors.Logs.Count != 0)
{
errors.Report();
fileProvider.WriteAllLines(fileProvider.ErrorsAddress, errors.Logs);
return;
}
// create JSON:
var serializedInterchange = JsonConvert.SerializeObject(interchange, Formatting.Indented);
// output JSON:
fileProvider.WriteAllText(fileProvider.OutputAddress, serializedInterchange);
Console.WriteLine("Success.");
//Console.WriteLine("Press Enter to finish.");
//Console.ReadLine();
}
private static void TraversAllSegments(Interchange interchange, IReadOnlyList<Segment> segments, Errors errors)
{
if (segments == null || segments.Count == 0)
{
errors.NewError("No segments provided for parsing.");
return;
}
Group currentGroup = null;
Document currentDocument = null;
if (
!errors.Assert(() => segments[0].Name == "ISA",
"FATAL Error: The first segment ('" + segments[0].Name + "') is not ISA segment."))
return; // FATAL error
interchange.ISASegment = new ISASegment(segments[0].Elements);
for (var i = 1; i < segments.Count; i++)
{
switch (segments[i].Name)
{
case "ST":
currentDocument = new Document();
currentDocument.STSegment = new STSegment(segments[i].Elements);
break;
case "SE":
if (currentDocument != null)
{
currentDocument.SESegment = new SESegment(segments[i].Elements);
if (currentGroup != null)
currentGroup.Documents.Add(currentDocument);
else
errors.NewError(string.Format("Segment:'{0}' placed before GS segment",
segments[i].AsString));
currentDocument = null;
}
else
errors.NewError(string.Format("Segment:'{0}' placed before ST segment", segments[i].AsString));
break;
case "GS":
currentGroup = new Group();
currentGroup.GSSegment = new GSSegment(segments[i].Elements);
break;
case "GE":
if (currentGroup != null)
{
currentGroup.GESegment = new GESegment(segments[i].Elements);
interchange.Groups.Add(currentGroup);
currentGroup = null;
}
else
errors.NewError(string.Format("Segment:'{0}' placed before GS segment", segments[i].AsString));
break;
case "IEA":
interchange.IEASegment = new IEASegment(segments[i].Elements);
break;
default:
if (currentDocument != null)
currentDocument.Segments.Add(segments[i]);
else
errors.NewError(string.Format("Segment:'{0}' placed before ST segment", segments[i].AsString));
break;
}
}
// Validate a new interchange:
interchange.Validate(errors);
}
