public void ShouldConvertFromASingleXCNElement()
{
HL7Message mesg = OBR1;
var xcn1 = mesg.Element("OBR.16").AsXCN();
Assert.Equal("MCINTYRE", xcn1.FamilyName);
}
private void btnConvertHL7_Click(object sender, EventArgs e)
{
if (rtBoxXML.Text.Trim().Equals(""))
{
return;
}
//MemoryStream ms = new MemoryStream();
string str = "";
DateTime start = DateTime.Now;
try
{
HL7Message msg = new HL7Message(rtBoxXML.Text, 1);
str = msg.get();
}catch (Exception ee)
{
MessageBox.Show(ee.Message);
}
DateTime end = DateTime.Now;
label3.Text = (end - start).ToString();
rtBoxHL72.Clear();
rtBoxHL72.Text = str;
}
private void BgwParse_DoWork(object sender, DoWorkEventArgs e)
{
try
{
string data = File.ReadAllText(_hl7DataFile);
string[] stringSeparators = new string[] { "\r\n" };
this._hl7DataList = data.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
}
catch (Exception ex)
{
LogError(string.Format("Failed to parse the data file. ERROR: {0}", ex.Message));
_isSuccess = false;
}
for (int x = 0; x <= this._hl7DataList.Length - 1; x++)
{
try
{
PipeParser parser = new PipeParser();
HL7Message msg = parser.Parse(_hl7DataList[x]);
lstFileData.Items.Add(msg);
}
catch (ParserException ex)
{
LogError(string.Format("Failed to parse. ERROR: {0}", ex.Message));
_isSuccess = false;
}
}
}
public override bool TransformXmlToHL7v2(string xmlMsg, out string hl7Msg)
{
try
{
HL7Message msg = new HL7Message(xmlMsg, 1);
hl7Msg = msg.get();
// ensure the ending of the HL7 text message payload is "\r" or "\r\n"
// so that the outgoing message should have a '\r' on the end of the message payload
// in order to pass the Mesa testing
if (hl7Msg != null && hl7Msg.Length > 1)
{
if (hl7Msg.Substring(hl7Msg.Length - 2, 2) != "\r\n" &&
hl7Msg.Substring(hl7Msg.Length - 1, 1) != "\r")
{
hl7Msg = hl7Msg + "\r";
}
}
return(true);
}
catch (Exception e)
{
hl7Msg = "";
_log.Write(e);
return(false);
}
}
private static string getHL7ValueSEL(HL7Message message,
List <MessageGroupInstance> messageGroupInstances,
List <MessageGroup> messageGroups,
WebservicePropertySet wsProperty
)
{
// get the ms groups
List <MessageGroup> msGroups
= ConfigurationUtility.GetIncomingWebserviceMessageGroup(wsProperty, messageGroups);
// get segment string type
MessageGroupInstance messageGroupInstance
= messageGroupInstances.Find(i => i.id == msGroups[ZERO].messageGroupInstanceId);
// get the message position for this specific column
List <Configuration> configMessagePoisition
= ConfigurationDAO.GetMessagePosition(messageGroupInstance);
// get the coordinates for the message item
string messageCoordinates = HL7MessageUtility.getItemCoordinates(configMessagePoisition);
// get segment string type
string segmentType = configMessagePoisition[ZERO_ELEMENT].segmentType.name;
// get the value for the database inside of the value position
string hl7Value = HL7MessageUtility.getValueByPosition(
message,
HL7MessageUtility.getSegmentType(segmentType),
messageCoordinates);
return(hl7Value);
}
public static MessageType getMessageType(HL7Message message, string hl7Input)
{
if (hl7Input == BLANK)
{
throw new ArgumentException(ERROR_NO_MESSAGE_TYPE);
}
Dictionary <string, MessageType> messageTypeDictionary = new Dictionary <string, MessageType>()
{
{ MESSAGE_TYPE_ADT, MessageType.ADT },
{ MESSAGE_TYPE_ORM, MessageType.ORM },
{ MESSAGE_TYPE_ORU, MessageType.ORU },
{ MESSAGE_TYPE_SIU, MessageType.SIU },
{ MESSAGE_TYPE_UNK, MessageType.UNKNOWN }
};
// get the message type based on the configuration value
MessageType result;
messageTypeDictionary.TryGetValue(HL7MessageUtility.getValueByPosition(message,
SegmentType.MSH,
MESSAGE_TYPE_POSITION),
out result);
// based on the configuration file, we'll return the message type
return(result);
}
public static bool isReportAddendum(HL7Message hl7Message)
{
List <Segment> segments = hl7Message.segments.FindAll(s => s.fields[ZERO_ELEMENT].value == SEGMENT_TYPE_OBX);
string obxData = BLANK;
bool isAddendum = false;
try
{
segments.ForEach(delegate(Segment segment)
{
if (isAddendum)
{
// just leave the for - loop
return;
}
obxData = segment.fields[REPORT_TEXT_ELEMENT].value;
if (Regex.IsMatch(obxData, HAS_ADDENDUM_PATTERN))
{
isAddendum = true;
// exit foreach
return;
}
});
}
catch (Exception ex)
{
// log error
ErrorLogger.LogError(ex, "isReportAddendum(String obxData)", obxData);
}
return(isAddendum);
}
public void Handle(HL7Message msg)
{
Message = msg;
using (_persistenceManager = new CachingPersistenceManager(PersistenceScope.CurrentContext))
{
Handle();
}
}
public static HL7Message getMessage(string hl7Input)
{
HL7Message hl7 = new HL7Message();
HL7Message.Parse(hl7, hl7Input);
return(hl7);
}
public void ShouldThrowExceptionForRepeatingXCNElement()
{
HL7Message mesg = OBR2;
var obr = mesg.Element("OBR[1]");
var xcns = obr.IndexedElement(16);
Assert.Throws <InvalidOperationException>(() => xcns.AsXCN());
}
public void CRLineEndingsOBX64ReturnsWithEscapedCRLF()
{
HL7Message resultMsg = ExampleCRMessageWithB64;
var obx3 = resultMsg.Element("OBX[3]");
string obx3txt = obx3;
Assert.Contains("Clinical PDF Report MR077065T-1", (string)obx3);
Assert.Contains(@"\X0D\\X0A\", obx3txt);
}
public TestLineEnding()
{
ExampleLFMessage = ExampleCRMessage.Replace('\r', '\n');
ExampleCRLFMessage = ExampleCRMessage.Replace("\r", "\r\n");
CrMsg = ExampleCRMessage;
LfMsg = ExampleLFMessage;
CrLfMsg = ExampleCRLFMessage;
}
/// <summary>
/// Forward message to interested parties.
/// </summary>
/// <param name="message">
/// The message.
/// </param>
private void Foward(HL7Message message)
{
var subscriptions = this.subscriptionService.FindBySourceMessageType(MessageProtocol.HL7.ToString());
foreach (var subscription in subscriptions)
{
this.ForwardMessage(subscription, message);
}
}
private void LstFileData_DoubleClick(object sender, EventArgs e)
{
HL7Message msg = lstFileData.SelectedItem as HL7Message;
if (OnHL7ObjectSelected != null)
{
OnHL7ObjectSelected(msg);
}
}
public void CRLFLineEndingsOBX64ReturnsWithEscapedCRLF()
{
var crlfWithB64 = ExampleCRMessage.Replace("\r", "\r\n") + OBXBase64 + '\n';
HL7Message resultMsg = crlfWithB64;
var obx3 = resultMsg.Element("OBX[3]");
string obx3txt = obx3;
Assert.Contains("Clinical PDF Report MR077065T-1", (string)obx3);
Assert.Contains(@"\X0D\\X0A\", obx3txt);
}
public void ShouldConvertToAIEnumerableForOneXCNElement()
{
HL7Message mesg = OBR4;
var obr = mesg.Element("OBR[1]");
var xcns = obr.IndexedElement(16);
var xcnList = xcns.AsXCNs();
Assert.Single(xcnList);
Assert.Equal("Hooker", xcnList.FirstOrDefault().FamilyName);
Assert.Equal("1620", xcnList.FirstOrDefault().ID);
}
public void OnMessage(HL7Message message)
{
if (_handlers.ContainsKey(message.Type))
{
var instance = Activator.CreateInstance(_handlers[message.Type]) as THandlerInterface;
if (instance != null)
{
instance.Handle(message);
}
}
}
void LoadHL7(string hl7Data)
{
this._hl7Message = null;
toolStripButtonLoad.Enabled = false;
toolStripButtonLoadHL7DatFile.Enabled = false;
toolStripButtonDBCompare.Enabled = false;
bgwParser.RunWorkerAsync(hl7Data);
StartProgressBar();
}
public void ShouldConvertToAIEnumerableForRepeatingXCNElements()
{
HL7Message mesg = OBR2;
var obr = mesg.Element("OBR[1]");
var xcns = obr.IndexedElement(16);
var xcnList = xcns.AsXCNs();
Assert.Equal(2, xcnList.Count());
Assert.Equal("MCINTYRE", xcnList.FirstOrDefault().FamilyName);
Assert.Equal("McIntyre", xcnList.Skip(1).FirstOrDefault().FamilyName);
Assert.Equal("1620", xcnList.Skip(1).FirstOrDefault().ID);
}
public void onDebugStartWithMessage()
{
string path = @"C:\Users\chrisb\Documents\ApplicationDevelopment\Working\HL7Broker.root\HL7Broker\HL7Broker\Messages\ORMSC_LOCATION.hl7";
string input = HL7Message.ReadHL7FromFile(path);
// attempt to scrub message
string hl7Input = HL7MessageUtility.scrubHL7MessageForParse(input);
// Get Incoming HL7 Message Configuration
HL7Message hl7Message = HL7MessageDAO.getMessage(hl7Input);
string value = HL7MessageUtility.getValueByPosition(hl7Message, Generic.SegmentType.PV1, "11.2");
}
private void bgwParser_DoWork(object sender, DoWorkEventArgs e)
{
PipeParser parser = new PipeParser();
try
{
_hl7Message = parser.Parse(e.Argument.ToString());
}
catch (ParserException ex)
{
LogError(string.Format("Parser error: {0}", ex.Message));
}
}
public static int getNumberOfReportEntries(HL7Message hl7Message)
{
int reportEntries = ZERO;
List <Segment> obxSegments = new List <Segment>();
// get all obx segments
obxSegments = hl7Message.segments.FindAll(s => s.fields[ZERO_ELEMENT].value == SEGMENT_TYPE_OBX);
// get max number in iteration field
reportEntries = obxSegments.Max(x => Convert.ToInt32(x.fields[FIRST_ELEMENT].value));
return(reportEntries);
}
public void ShouldConvertIdentifier()
{
HL7Message message = MSH + PID2;
var firstIdentifier = message.Element($"PID.3[1]");
var hl7Id = firstIdentifier.AsCX();
Assert.Equal("01", hl7Id.CheckDigit);
Assert.Equal("IDCODE", hl7Id.CheckDigitScheme.Value);
Assert.Equal("AUSIC", hl7Id.AssigningAuthority.NamespaceId.BestValue);
Assert.Equal("NI", hl7Id.IdentifierTypeCode.BestValue);
Assert.Equal("RMH", hl7Id.AssigningFacility.NamespaceId.BestValue);
Assert.Equal(new DateTime(2020, 07, 01).ToUniversalTime(), hl7Id.EffectiveDate.Value.ToUniversalTime());
Assert.Equal(new DateTime(2025, 07, 01).ToUniversalTime(), hl7Id.ExpirationDate.Value.ToUniversalTime());
}
/// <summary>
/// Parse HL7 message using the local DB for Segments and trigger events
/// </summary>
/// <param name="message">Raw HL7 formated string. Multiple message file should be formated with \r\n after each message.</param>
/// <returns>HL7 object with segments and events</returns>
public HL7Message Parse(string message)
{
string[] tempMessage = message.Split(new string[] { "\r", "\n" }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i <= tempMessage.Length - 1; i++)
{
string segment = tempMessage[i].Substring(0, 3);
if (segment == "MSH")
{
tempMessage[i] = string.Format("{0}", tempMessage[i]);
}
tempMessage[i].Trim();
}
this._hl7 = new HL7Message(tempMessage);
base.LogInfoMessage(string.Format("Creating HL7 message object from {0}", message));
//The Fields in the message should drive this, to handle multiple similar segments.
TriggerEvent[] triggerEvents = this._repo.GetTriggerEventsBy(this._hl7.MessageToken.MessageVersion, this._hl7.MessageToken.MessageType, this._hl7.MessageToken.EventType).AsParallel().ToArray <TriggerEvent>();
base.LogInfoMessage(string.Format("Fetching TriggerEvent configuration for verions {0} {1}_{2}", this._hl7.MessageToken.MessageVersion
, this._hl7.MessageToken.MessageType
, this._hl7.MessageToken.EventType));
if (triggerEvents.Length == 0)
{
throw new ParserException(string.Format("No trigger events found for version {0}, message type {1}_{2}", this._hl7.MessageToken.MessageVersion, this._hl7.MessageToken.MessageType, this._hl7.MessageToken.EventType));
}
else
{
foreach (string s in this._hl7.MessageToken.Segments)
{
string segId = s.Substring(0, 3);
base.LogInfoMessage(string.Format("Searching TriggerEvent configuration for segment {0}", segId));
TriggerEvent tr = triggerEvents.Where(x => x.Segment == segId).FirstOrDefault();
if (tr != null)
{
HL7Segment newEvent = this.CreateFromSegmentString(s, tr);
base.LogInfoMessage(string.Format("Successfully created HL7 segment {0} for TriggerEvent {1}_{2}", newEvent.Name, tr.MessageType, tr.EventType));
if (newEvent != null)
{
_hl7.AddEventSegment(newEvent);
}
}
}
return(_hl7);
}
}
public void ShouldExtractNumbersFromNM()
{
HL7Message mesg = OBX3;
var obx = mesg.Element("OBX[1]");
var valueElement = obx.IndexedElement(5);
DataTypes.NM_Number number = valueElement;
Assert.True(number.IsNumber);
Assert.Equal(59, (int)number);
Assert.Equal((Int64)59, number.AsInt64());
Assert.Equal((float)59, number.AsFloat());
Assert.Equal(59M, number.AsDecimal());
Assert.Equal(59.0D, (double)number);
}
public void ShouldConvertED()
{
var txt = MSH + PID2 + OBR1 + OBX1;
var message = new HL7Message(txt);
var OBXResult = message.Element("OBX[1].5");
var hl7Ed = OBXResult.AsED();
//MIA^Image^PDF^Base64
Assert.Equal("MIA", hl7Ed.SourceApplication.NamespaceId.BestValue);
Assert.Equal("Image", hl7Ed.TypeOfData.BestValue);
Assert.Equal("PDF", hl7Ed.DataSubType.BestValue);
Assert.Equal("Base64", hl7Ed.Encoding.BestValue);
Assert.StartsWith("JVBERi0xLjQKJeLjz9", hl7Ed.Data, StringComparison.InvariantCultureIgnoreCase);
}
public void ShouldConvertASingleCE()
{
var message = new HL7Message(OBX1);
var OBXResult = message.Element("OBX[1].3");
var hl7CE = OBXResult.AsCE();
//ClinicalPDFReport1^Clinical PDF Report MR077065T-1^^PDF^Display format in PDF^AUSPDI
Assert.Equal("ClinicalPDFReport1", hl7CE.Identifier);
Assert.Equal("Clinical PDF Report MR077065T-1", hl7CE.Text);
Assert.Equal("", hl7CE.NameOfCodingSystem.Value);
Assert.Equal("PDF", hl7CE.AlternateIdentifier);
Assert.Equal("Display format in PDF", hl7CE.AlternateText);
Assert.Equal("AUSPDI", hl7CE.NameOfAlternateCodingSystem.Value);
}
public override bool TransformHL7v2ToXml(string hl7Msg, out string xmlMsg)
{
try
{
HL7Message msg = new HL7Message(hl7Msg, 0);
xmlMsg = msg.getXML();
return(true);
}
catch (Exception e)
{
xmlMsg = "";
_log.Write(e);
return(false);
}
}
/// <summary>
/// Forward message as specified in the given subscription.
/// </summary>
/// <param name="subscription">
/// The subscription.
/// </param>
/// <param name="message">
/// The message.
/// </param>
private void ForwardMessage(RealtimeSubscription subscription, HL7Message message)
{
// Example routing key template: "HL7.{MessageType}.{EventType}"
var exchangeName = subscription.Name;
var exchangeType = "topic";
var routingKey = BuildRoutingKey(subscription, message);
var serializedMessaged = JsonConvert.SerializeObject(message);
var body = Encoding.UTF8.GetBytes(serializedMessaged);
using (var connection = this.connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchangeName, exchangeType);
channel.BasicPublish(exchangeName, routingKey, null, body);
}
}
private static void UseParseOnlyToConfirmWeCanProcessTheMessage(string msgText)
{
Console.WriteLine("Parse Only");
Console.WriteLine("----------");
Console.WriteLine("Used when you don't want to proces the whole message, just check fields");
Console.WriteLine("Eg: Determine if the message type is supported by the application");
Console.WriteLine("OR For logging purposes where the system is simply storing the whole message");
string messageType = HL7Message.ParseOnly(msgText, "MSH.9");
if (!messageType.Substring(0, 3).Equals("ORU", StringComparison.CurrentCultureIgnoreCase))
{
Console.WriteLine();
throw new FormatException($"Only processing ORU MessageType. Found message type {messageType}");
}
}
