/// <summary>
/// Handle the HL7 message update from the Image Manager Actor.
/// </summary>
/// <param name="message">HL7 message from Image Manager Actor.</param>
public void HandleUpdateFromImageManagerActor(Hl7Message message)
{
switch(message.MessageType)
{
case "ADT" :
{
switch(message.MessageSubType)
{
case "A08" :
HandlePatientUpdate(message);
break;
case "A40" :
HandlePatientMerge(message);
break;
}
}
break;
case "ORM" :
{
switch(message.MessageSubType)
{
case "O01" :
HandleProcedureScheduled(message);
HandleProcedureUpdated(message);
break;
}
}
break;
default:
break;
}
}
/// <summary>
/// Query message handler for the received Hl7 message - send a query response.
/// </summary>
/// <param name="hl7RequestMessage">Received HL7 message.</param>
/// <returns>Hl7Message response.</returns>
public override Hl7Message MessageHandler(Hl7Message hl7RequestMessage)
{
AdrMessage hl7ResponseMessage = new AdrMessage("A19");
if (hl7RequestMessage is QryMessage)
{
QryMessage qryMessage = (QryMessage)hl7RequestMessage;
// Try to get the ADR message from those stored
hl7ResponseMessage = GetMatchingResponse(qryMessage.QRD[8]);
if (hl7ResponseMessage == null)
{
// return empty message
hl7ResponseMessage = new AdrMessage("A19");
}
// copy the QRD segment
for (int i = 0; i < qryMessage.QRD.Count; i++)
{
hl7ResponseMessage.QRD[i] = qryMessage.QRD[i];
}
}
// fill in the MSA segment
hl7ResponseMessage.MSA[1] = "AA";
hl7ResponseMessage.MSA[2] = hl7RequestMessage.MessageControlId;
return hl7ResponseMessage;
}
public static DvtkData.Dimse.DataSet Convert(Hl7Message message)
{
DvtkData.Dimse.DataSet dataset = new DvtkData.Dimse.DataSet("Transient");
try
{
if (message != null)
{
// iterate over all the segments in the HL7 message
ICollection segments = message.Segments.Values;
foreach (Hl7Segment hl7Segment in segments)
{
// iterate over all the fields in the HL7 segments
for (int i = 1; i < hl7Segment.Count; i++)
{
System.String hl7Value = hl7Segment[i];
if (hl7Value != System.String.Empty)
{
// check if there is an Hl7 Tag corresponding to the value in the DicomHl7Template
Hl7Tag hl7Tag = new Hl7Tag(hl7Segment[0], i);
DicomHl7TagMap dicomHl7TagMap = DicomHl7TagMapTemplate.FindTagMap(hl7Tag);
if (dicomHl7TagMap != null)
{
System.String dicomValue = hl7Value;
if (dicomHl7TagMap.ValueConvertor != null)
{
dicomValue = dicomHl7TagMap.ValueConvertor.FromHl7ToDicom(hl7Value, dicomHl7TagMap.Hl7ComponentIndex);
}
AddDicomAttribute(dataset, dicomHl7TagMap.DicomTagPath, dicomValue);
}
for (int componentIndex = 2; componentIndex < 7; componentIndex++)
{
dicomHl7TagMap = DicomHl7TagMapTemplate.FindTagMap(hl7Tag, componentIndex);
if (dicomHl7TagMap != null)
{
System.String dicomValue = hl7Value;
if (dicomHl7TagMap.ValueConvertor != null)
{
dicomValue = dicomHl7TagMap.ValueConvertor.FromHl7ToDicom(hl7Value, dicomHl7TagMap.Hl7ComponentIndex);
}
AddDicomAttribute(dataset, dicomHl7TagMap.DicomTagPath, dicomValue);
}
}
}
}
}
}
}
catch (System.Exception e)
{
Console.WriteLine("HL7 to DICOM conversion exception: {0} - {1}", e.Message, e.StackTrace);
}
return dataset;
}
/// <summary>
/// Get the next HL7 message read from the HL7 message directory.
/// </summary>
/// <returns>Next HL7 message read from message directory files.</returns>
public Hl7Message GetNextHl7Message()
{
Hl7Message hl7Message = GetHl7Message(_iterator);
if (hl7Message != null)
{
_iterator++;
}
return(hl7Message);
}
//
// - Methods -
//
/// <summary>
/// Create a HL7 message from the content of a file.
/// </summary>
/// <param name="fullFileName">The full file name.</param>
/// <returns>The HL7 messages created from the content of the file.</returns>
public Hl7Message In(String fullFileName)
{
// set up the file stream for reading
FileStream fileStream = new FileStream(fullFileName, FileMode.Open);
// Decode the file stream into an HL7 message
Hl7Message hl7Message = Decode(fileStream);
// Return the HL7 message
return(hl7Message);
}
/// <summary>
/// Initializes the encapsulated Dvtk.Comparator.Hl7Comparator class with the supplied HL7 message.
/// </summary>
/// <param name="hl7Message">The HL7 message.</param>
/// <returns>The encapsulated Dvtk.Comparator.Hl7Comparator instance.</returns>
public Hl7Comparator InitializeHl7Comparator(Hl7Message hl7Message)
{
_dicomComparator = null;
bool initialized = _hl7Comparator.Initialize(hl7Message);
if (initialized == false)
{
_hl7Comparator = null;
}
return _hl7Comparator;
}
/// <summary>
/// Get the HL7 message read from the indexed message file.
/// </summary>
/// <param name="index">Zero based index.</param>
/// <returns>HL7 message read from indexed file.</returns>
public Hl7Message GetHl7Message(int index)
{
Hl7Message hl7Message = null;
if ((_fileInfo != null) &&
(index < _fileInfo.Length))
{
String filename = _fileInfo[index].FullName;
Hl7FileStream hl7FileStream = new Hl7FileStream();
hl7Message = hl7FileStream.In(filename);
}
return(hl7Message);
}
private void HandleProcedureUpdated(Hl7Message message)
{
// affects the information model maintained by the Dicom Query Retrive Server
// - try to get the Dicom Query Retrive Server
String actorId = GetFirstActorIdFromDicomServer(ActorTypeEnum.ImageDisplay);
DicomServer dicomServer = GetDicomServer(new ActorName(ActorTypeEnum.ImageDisplay, actorId));
if (dicomServer == null) return;
// merge the patient with the Dicom Query Retrive Server
DicomQueryRetrieveServer dicomQueryRetrieveServer = (DicomQueryRetrieveServer) dicomServer;
Console.WriteLine("dicomQueryRetrieveServer.ProcedureUpdated(Hl7ToDicom(message));");
}
/// <summary>
/// Receive an HL7 message over the connected network stream.
/// </summary>
/// <param name="messageDelimiters">Initial HL7 message delimiters - updated to actual delimters during method.</param>
/// <returns>Correctly instantiated HL7 message.</returns>
public Hl7Message ReceiveMessage(out Hl7MessageDelimiters messageDelimiters)
{
// initialize the message delimiters to the default values
messageDelimiters = new Hl7MessageDelimiters();
Hl7Message hl7Message = new Hl7Message();
if (_networkStream == null) return null;
// set the read / write timeouts for this stream - zero means no timeout.
if (_readTimeout != 0)
{
_networkStream.ReadTimeout = _readTimeout;
}
if (_writeTimeout != 0)
{
_networkStream.WriteTimeout = _writeTimeout;
}
// initialise the segment content
System.String rxSegment = System.String.Empty;
// initialise the MLLP state
MllpStateEnum mllpState = MllpStateEnum.WaitingForStartOfMessageChar;
// loop waiting for the end of message character
while (mllpState != MllpStateEnum.DoneWaiting)
{
// check if data is available on network
try
{
// get the next character from the stream
int rxCode = _networkStream.ReadByte();
if (rxCode < 0)
{
return null;
}
char rxChar = (char) rxCode;
// switch on MLLP state
switch(mllpState)
{
case MllpStateEnum.WaitingForStartOfMessageChar:
// check if we have got the SOM
if (rxChar == _StartOfMessageChar)
{
// reset the segment
rxSegment = System.String.Empty;
// change state to waiting for end of segment
mllpState = MllpStateEnum.WaitingForEndOfSegmentChar;
}
else
{
Console.WriteLine("HL7 - MLLP: Waiting for SOM - got {0}...", rxChar);
}
break;
case MllpStateEnum.WaitingForEndOfSegmentChar:
// check if we have got the end of segment
if (rxChar == _EndOfSegmentChar)
{
// check if we have the MSH segment
// - we need to get the message delimiters
if (rxSegment.StartsWith("MSH") == true)
{
// set the message delimiters to the values received
// - we assume that the MSH segment is formatted properly at least in the first few bytes
messageDelimiters = new Hl7MessageDelimiters(rxSegment.Substring(3,5));
}
// segment is complete
Hl7Segment segment = new Hl7Segment();
segment.Decode(rxSegment, messageDelimiters);
// add the segment to the HL7 message
hl7Message.AddSegment(segment);
// reset the segment
rxSegment = System.String.Empty;
}
else if (rxChar == _EndOfMessageChar1)
{
// we have the first end of message - that's OK
// check if any characters have been received since the last end of segment
if (rxSegment == System.String.Empty)
{
// change state to waiting for second end of message
mllpState = MllpStateEnum.WaitingForEndOfMessageChar;
}
else
{
Console.WriteLine("HL7 - MLLP: First EOM does not immediately follow an EOS");
return null;
}
}
else
{
// save the received character in the current segment
rxSegment += rxChar;
}
break;
case MllpStateEnum.WaitingForEndOfMessageChar:
// check if we have got the second end of message
if (rxChar == _EndOfMessageChar2)
{
// message is complete
mllpState = MllpStateEnum.DoneWaiting;
}
else
{
Console.WriteLine("HL7 - MLLP: Second EOM does not immediately follow first EOM");
return null;
}
break;
default:
break;
}
}
catch (System.Exception e)
{
Console.WriteLine("HL7 - MLLP: ReceiveMessage() Exception: {0}", e.Message);
return null;
}
}
// return the correct instantiation of the received HL7 message
return Hl7MessageFactory.CreateHl7Message(hl7Message, messageDelimiters);
}
/// <summary>
/// Send an HL7 message over the connected network stream.
/// </summary>
/// <param name="hl7Message">HL7 message to encode.</param>
/// <param name="messageDelimiters">HL7 message delimiters.</param>
/// <returns>bool - successful sent = true else false.</returns>
public bool SendMessage(Hl7Message hl7Message, Hl7MessageDelimiters messageDelimiters)
{
if (_networkStream == null) return false;
// set the read / write timeouts for this stream - zero means no timeout.
if (_readTimeout != 0)
{
_networkStream.ReadTimeout = _readTimeout;
}
if (_writeTimeout != 0)
{
_networkStream.WriteTimeout = _writeTimeout;
}
// write the start of message character
_networkStream.WriteByte((byte)_StartOfMessageChar);
// stream all the segments - ordered by sequence number and then segment index
int sequenceNumber = 0;
int segmentIndex = 1;
bool streaming = true;
while (streaming == true)
{
bool segmentStreamed = false;
ICollection segments = hl7Message.Segments.Values;
foreach (Hl7Segment hl7Segment in segments)
{
if (hl7Segment.SequenceNumber == sequenceNumber)
{
if (hl7Segment.SegmentId.SegmentIndex == segmentIndex)
{
System.String encodedStream = hl7Segment.Encode(messageDelimiters);
if (encodedStream != System.String.Empty)
{
byte[] buffer = new byte[encodedStream.Length];
for (int j = 0; j < encodedStream.Length; j++)
{
buffer[j] = (byte) encodedStream[j];
}
// write the segment
_networkStream.Write(buffer, 0, encodedStream.Length);
// write the end of segment character
_networkStream.WriteByte((byte)_EndOfSegmentChar);
}
segmentIndex++;
segmentStreamed = true;
break;
}
}
}
if (segmentStreamed == false)
{
if (sequenceNumber < hl7Message.Segments.Count)
{
sequenceNumber++;
segmentIndex = 1;
}
else
{
streaming = false;
}
}
}
// write the end of message characters
_networkStream.WriteByte((byte)_EndOfMessageChar1);
_networkStream.WriteByte((byte)_EndOfMessageChar2);
_networkStream.Flush();
return true;
}
public void Add_hl7Message_flags()
{
FlagsHl7Attribute flags = new FlagsHl7Attribute();
Hl7Message hl7Message = new Hl7Message();
int count = attributeCollections.Count;
attributeCollections.Add(hl7Message, flags);
Assert.That(count + 1, Is.EqualTo(attributeCollections.Count));
}
public void Add_hl7Message()
{
Hl7Message hl7Message = new Hl7Message();
int count = attributeCollections.Count;
attributeCollections.Add(hl7Message);
Assert.That(count + 1, Is.EqualTo(attributeCollections.Count));
}
/// <summary>
/// Add an HL7 message with specified flags to this collection.
/// </summary>
/// <param name="hl7Message">The HL7 message.</param>
/// <param name="flags">The flags.</param>
public void Add(Hl7Message hl7Message, FlagsHl7Attribute flags)
{
Hl7AttributeCollection hl7AttributeCollection = new Hl7AttributeCollection(hl7Message, flags);
Add(hl7AttributeCollection);
}
protected DvtkData.Dimse.DataSet Hl7ToDicom(Hl7Message message)
{
DvtkData.Dimse.DataSet dataset = new DvtkData.Dimse.DataSet("Transient");
if (message != null)
{
// try to get the patient id
CommonIdFormat patientId = new CommonIdFormat();
patientId.FromHl7Format(message.Value(new Hl7Tag("PID", 3)));
if (patientId.ToDicomFormat() != System.String.Empty)
{
dataset.AddAttribute(DvtkData.Dimse.Tag.PATIENT_ID.GroupNumber, DvtkData.Dimse.Tag.PATIENT_ID.ElementNumber, DvtkData.Dimse.VR.LO, patientId.ToDicomFormat());
}
// try to get the patient's name
CommonNameFormat patientName = new CommonNameFormat();
patientName.FromHl7Format(message.Value(new Hl7Tag("PID", 5)));
if (patientName.ToDicomFormat() != System.String.Empty)
{
dataset.AddAttribute(DvtkData.Dimse.Tag.PATIENTS_NAME.GroupNumber, DvtkData.Dimse.Tag.PATIENTS_NAME.ElementNumber, DvtkData.Dimse.VR.PN, patientName.ToDicomFormat());
}
// try to get the patient's birth date
CommonDateFormat patientBirthDate = new CommonDateFormat();
patientBirthDate.FromHl7Format(message.Value(new Hl7Tag("PID", 7)));
if (patientBirthDate.ToDicomFormat() != System.String.Empty)
{
dataset.AddAttribute(DvtkData.Dimse.Tag.PATIENTS_BIRTH_DATE.GroupNumber, DvtkData.Dimse.Tag.PATIENTS_BIRTH_DATE.ElementNumber, DvtkData.Dimse.VR.DA, patientBirthDate.ToDicomFormat());
}
// try to get the patient's sex
CommonStringFormat patientSex = new CommonStringFormat();
patientSex.FromHl7Format(message.Value(new Hl7Tag("PID", 8)));
if (patientSex.ToDicomFormat() != System.String.Empty)
{
dataset.AddAttribute(DvtkData.Dimse.Tag.PATIENTS_SEX.GroupNumber, DvtkData.Dimse.Tag.PATIENTS_SEX.ElementNumber, DvtkData.Dimse.VR.CS, patientSex.ToDicomFormat());
}
// try to get the merge patient id
CommonIdFormat mergePatientId = new CommonIdFormat();
mergePatientId.FromHl7Format(message.Value(new Hl7Tag("MRG", 1)));
if (mergePatientId.ToDicomFormat() != System.String.Empty)
{
dataset.AddAttribute(DvtkData.Dimse.Tag.OTHER_PATIENT_IDS.GroupNumber, DvtkData.Dimse.Tag.OTHER_PATIENT_IDS.ElementNumber, DvtkData.Dimse.VR.LO, mergePatientId.ToDicomFormat());
}
}
return dataset;
}
/// <summary>
/// Default message handler for the received Hl7 message - just send an ACK.
/// </summary>
/// <param name="hl7RequestMessage">Received HL7 message.</param>
/// <returns>Hl7Message response.</returns>
public virtual Hl7Message MessageHandler(Hl7Message hl7RequestMessage)
{
// Set up an ACK message to return
AckMessage hl7ResponseMessage = new AckMessage(hl7RequestMessage.MessageSubType);
// fill in the MSA segment
hl7ResponseMessage.MSA[1] = "AA";
hl7ResponseMessage.MSA[2] = hl7RequestMessage.MessageControlId;
return hl7ResponseMessage;
}
//
// - Methods -
//
/// <summary>
/// Decode a Hl7Message object from a given stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns>The decoded Hl7Message.</returns>
internal Hl7Message Decode(System.IO.Stream stream)
{
Hl7Message hl7Message = new Hl7Message();
// initialize the message delimiters to the default values
_messageDelimiters = new Hl7MessageDelimiters();
// initialise the segment content
System.String rxSegment = System.String.Empty;
// read the first character from the stream to determine if the MLLP is used
int rxCode = stream.ReadByte();
if (rxCode < 0)
{
throw new System.Exception("Incomplete HL7 stream.");
}
stream.Seek(0, System.IO.SeekOrigin.Begin);
// initialise the MLLP state
MllpStateEnum mllpState = MllpStateEnum.MllpNotUsed;
if ((char)rxCode == _StartOfMessageChar)
{
// SOM read - use the MLLP protocol
mllpState = MllpStateEnum.WaitingForStartOfMessageChar;
}
// loop waiting for the end of message character
while (_continueReading)
{
// get the next character from the stream
rxCode = stream.ReadByte();
if (rxCode < 0)
{
// end of stream reached when not using the MLLP
// - check if there is any data left in the rxSegment
if ((rxSegment != System.String.Empty) &&
(mllpState == MllpStateEnum.MllpNotUsed))
{
// segment is complete
Hl7Segment segment = new Hl7Segment();
segment.Decode(rxSegment, _messageDelimiters);
// add the segment to the HL7 message
hl7Message.AddSegment(segment);
}
// message is complete
_continueReading = false;
break;
}
char rxChar = (char)rxCode;
// switch on MLLP state
switch (mllpState)
{
case MllpStateEnum.MllpNotUsed:
// check if we have got the end of segment
if (rxChar == _EndOfSegmentChar)
{
// check if we have the MSH segment
// - we need to get the message delimiters
if (rxSegment.StartsWith("MSH") == true)
{
// set the message delimiters to the values received
// - we assume that the MSH segment is formatted properly at least in the first few bytes
_messageDelimiters = new Hl7MessageDelimiters(rxSegment.Substring(3, 5));
}
// segment is complete
Hl7Segment segment = new Hl7Segment();
segment.Decode(rxSegment, _messageDelimiters);
// add the segment to the HL7 message
hl7Message.AddSegment(segment);
// reset the segment
rxSegment = System.String.Empty;
}
else if (rxChar == _NewLineChar)
{
// ignore the line feed character
}
else
{
// save the received character in the current segment
rxSegment += rxChar;
}
break;
case MllpStateEnum.WaitingForStartOfMessageChar:
// check if we have got the SOM
if (rxChar == _StartOfMessageChar)
{
// reset the segment
rxSegment = System.String.Empty;
// change state to waiting for end of segment
mllpState = MllpStateEnum.WaitingForEndOfSegmentChar;
}
else
{
Console.WriteLine("HL7 - MLLP: Waiting for SOM - got {0}...", rxChar);
}
break;
case MllpStateEnum.WaitingForEndOfSegmentChar:
// check if we have got the end of segment
if (rxChar == _EndOfSegmentChar)
{
// check if we have the MSH segment
// - we need to get the message delimiters
if (rxSegment.StartsWith("MSH") == true)
{
// set the message delimiters to the values received
// - we assume that the MSH segment is formatted properly at least in the first few bytes
_messageDelimiters = new Hl7MessageDelimiters(rxSegment.Substring(3, 5));
}
// segment is complete
Hl7Segment segment = new Hl7Segment();
segment.Decode(rxSegment, _messageDelimiters);
// add the segment to the HL7 message
hl7Message.AddSegment(segment);
// reset the segment
rxSegment = System.String.Empty;
}
else if (rxChar == _EndOfMessageChar1)
{
// we have the first end of message - that's OK
// check if any characters have been received since the last end of segment
if (rxSegment == System.String.Empty)
{
// change state to waiting for second end of message
mllpState = MllpStateEnum.WaitingForEndOfMessageChar;
}
else
{
Console.WriteLine("HL7 - MLLP: First EOM does not immediately follow an EOS");
return(null);
}
}
else
{
// save the received character in the current segment
rxSegment += rxChar;
}
break;
case MllpStateEnum.WaitingForEndOfMessageChar:
// check if we have got the second end of message
if (rxChar == _EndOfMessageChar2)
{
// message is complete
_continueReading = false;
}
else
{
Console.WriteLine("HL7 - MLLP: Second EOM does not immediately follow first EOM");
return(null);
}
break;
default:
break;
}
}
// return the correct instantiation of the received HL7 message
return(Hl7MessageFactory.CreateHl7Message(hl7Message, _messageDelimiters));
}
/// <summary>
/// Create a correctly typed HL7 message instance based on the incoming Hl7 message.
/// </summary>
/// <param name="inHl7Message">Incoming HL7 message.</param>
/// <param name="messageDelimiters">HL7 message delimiters.</param>
/// <returns>Correctly typed HL7 message instance.</returns>
public static Hl7Message CreateHl7Message(Hl7Message inHl7Message, Hl7MessageDelimiters messageDelimiters)
{
Hl7SegmentId segmentId = new Hl7SegmentId(Hl7SegmentEnum.MSH);
Hl7Segment mshSegment = (Hl7Segment)inHl7Message.Segments[segmentId.Id];
// can not determine what kind of message we have - so return the inHl7Message
if (mshSegment == null)
{
return inHl7Message;
}
System.String messageType = mshSegment[9];
Hl7Message hl7Message = null;
// check for ACK message
if (messageType == "ACK")
{
// now try to get the ORC segment
segmentId = new Hl7SegmentId(Hl7SegmentEnum.ORC);
Hl7Segment orcSegment = (Hl7Segment)inHl7Message.Segments[segmentId.Id];
if (orcSegment != null)
{
hl7Message = new OrrMessage();
}
else
{
hl7Message = new AckMessage();
}
}
else
{
System.String []messageTypeComponent = new System.String[3];
messageTypeComponent = messageType.Split(messageDelimiters.ComponentDelimiter[0]);
System.String messageMainType = System.String.Empty;
if (messageTypeComponent.Length > 0)
{
messageMainType = messageTypeComponent[0];
}
switch (messageMainType)
{
case "ADR" :
// ADR message
hl7Message = new AdrMessage();
break;
case "ADT" :
// ADT message
hl7Message = new AdtMessage();
break;
case "ORM" :
// ORM message
hl7Message = new OrmMessage();
break;
case "ORU" :
// ORU message
hl7Message = new OruMessage();
break;
case "QRY" :
// QRY message
hl7Message = new QryMessage();
break;
default:
// do not know what kind of HL7 message this is - simply return it
return inHl7Message;
}
}
// add the segments from the inMessage to the new hl7Message
ICollection segments = inHl7Message.Segments.Values;
foreach (Hl7Segment segment in segments)
{
hl7Message.CopySegment(segment);
}
return hl7Message;
}
/// <summary>
/// See the Dvtk.Comparator.Hl7Comparator.PopulateMessage method.
/// </summary>
/// <param name="hl7Message">See the Dvtk.Comparator.Hl7Comparator.PopulateMessage method.</param>
/// <param name="hl7SourceComparator">See the Dvtk.Comparator.Hl7Comparator.PopulateMessage method.</param>
/// <returns>See the Dvtk.Comparator.Hl7Comparator.PopulateMessage method.</returns>
public bool PopulateHl7Message(Hl7Message hl7Message, Hl7Comparator hl7SourceComparator)
{
bool messagePopulated = false;
if (_hl7Comparator != null)
{
messagePopulated = _hl7Comparator.PopulateMessage(hl7Message, hl7SourceComparator);
}
return messagePopulated;
}
private bool LoadTemplate(Hl7Message hl7Message)
{
if (hl7Message == null) return false;
// try to find the template tag in the dataset
foreach (Hl7ComparisonTag comparisonTag in this.Template.ComparisonTags)
{
Hl7Tag tag = comparisonTag.Tag;
System.String attributeValue = hl7Message.Value(tag.Segment, tag.FieldIndex);
if (attributeValue != System.String.Empty)
{
comparisonTag.DataFormat.FromHl7Format(attributeValue);
}
}
return true;
}
private bool CopyToHl7Message(Hl7Message hl7Message, Hl7Comparator sourceComparator)
{
bool messagePopulated = true;
// Check if both templates have been initialized correctly
if ((this.Template == null) ||
(sourceComparator.Template == null))
{
return false;
}
// Iterate over this comparator
foreach (Hl7ComparisonTag thisComparisonTag in this.Template.ComparisonTags)
{
// try to get the equivalent tag in the sourceComparator
Hl7ComparisonTag sourceComparisonTag = sourceComparator.Template.ComparisonTags.Find(thisComparisonTag.Tag);
if (sourceComparisonTag != null)
{
System.String stringValue = sourceComparisonTag.DataFormat.ToHl7Format();
if (hl7Message != null)
{
// add the value
hl7Message.AddValue(sourceComparisonTag.Tag.Segment,
sourceComparisonTag.Tag.FieldIndex,
stringValue);
}
}
}
return messagePopulated;
}
public bool SetUp(Hl7Message hl7Message)
{
System.String messageType = hl7Message.MessageType;
System.String messageSubType = hl7Message.MessageSubType;
// Try to initialise a template
_template = new Hl7ComparisonTemplate();
bool setUpDone = _template.Initialize(messageType, messageSubType);
return setUpDone;
}
public bool PopulateMessage(Hl7Message hl7Message, Hl7Comparator sourceComparator)
{
// Check for comparator equality
if (this == sourceComparator)
{
return false;
}
// Set up the comparator using the templates
bool setUpOk = SetUp(hl7Message);
if (setUpOk == true)
{
// Copy the source comparator values into the HL7 message if the tags are in this comparator
setUpOk = CopyToHl7Message(hl7Message, sourceComparator);
}
return setUpOk;
}
/// <summary>
/// Initialize the Hl7Comparator
/// </summary>
/// <param name="hl7Message"></param>
/// <returns>bool - true = template initialized, false template not initialized</returns>
public bool Initialize(Hl7Message hl7Message)
{
// Set up the comparator using the templates
bool setUpOk = SetUp(hl7Message);
if (setUpOk == true)
{
// Load the template with the corresponding attribute values
setUpOk = LoadTemplate(hl7Message);
}
return setUpOk;
}
/// <summary>
/// Create a correctly typed HL7 message instance based on the incoming Hl7 message.
/// </summary>
/// <param name="inHl7Message">Incoming HL7 message.</param>
/// <param name="messageDelimiters">HL7 message delimiters.</param>
/// <returns>Correctly typed HL7 message instance.</returns>
public static Hl7Message CreateHl7Message(Hl7Message inHl7Message, Hl7MessageDelimiters messageDelimiters)
{
Hl7SegmentId segmentId = new Hl7SegmentId(Hl7SegmentEnum.MSH);
Hl7Segment mshSegment = (Hl7Segment)inHl7Message.Segments[segmentId.Id];
// can not determine what kind of message we have - so return the inHl7Message
if (mshSegment == null)
{
return(inHl7Message);
}
System.String messageType = mshSegment[9];
Hl7Message hl7Message = null;
// check for ACK message
if (messageType == "ACK")
{
// now try to get the ORC segment
segmentId = new Hl7SegmentId(Hl7SegmentEnum.ORC);
Hl7Segment orcSegment = (Hl7Segment)inHl7Message.Segments[segmentId.Id];
if (orcSegment != null)
{
hl7Message = new OrrMessage();
}
else
{
hl7Message = new AckMessage();
}
}
else
{
System.String [] messageTypeComponent = new System.String[3];
messageTypeComponent = messageType.Split(messageDelimiters.ComponentDelimiter[0]);
System.String messageMainType = System.String.Empty;
if (messageTypeComponent.Length > 0)
{
messageMainType = messageTypeComponent[0];
}
switch (messageMainType)
{
case "ADR":
// ADR message
hl7Message = new AdrMessage();
break;
case "ADT":
// ADT message
hl7Message = new AdtMessage();
break;
case "ORM":
// ORM message
hl7Message = new OrmMessage();
break;
case "ORU":
// ORU message
hl7Message = new OruMessage();
break;
case "QRY":
// QRY message
hl7Message = new QryMessage();
break;
default:
// do not know what kind of HL7 message this is - simply return it
return(inHl7Message);
}
}
// add the segments from the inMessage to the new hl7Message
ICollection segments = inHl7Message.Segments.Values;
foreach (Hl7Segment segment in segments)
{
hl7Message.CopySegment(segment);
}
return(hl7Message);
}
private void HandlePlacerOrderManagement(Hl7Message message)
{
// affects the information model maintained by the Dicom Worklist Server
// - try to get the Dicom Worklist Server
String actorId = GetFirstActorIdFromDicomServer(ActorTypeEnum.AcquisitionModality);
DicomServer dicomServer = GetDicomServer(new ActorName(ActorTypeEnum.AcquisitionModality, actorId));
if (dicomServer == null) return;
// placer order management with the Dicom Worklist Server
DicomWorklistServer dicomWorklistServer = (DicomWorklistServer) dicomServer;
dicomWorklistServer.PlacerOrderManagement(Hl7MessageToDicomMessageConvertor.Convert(message));
}
private void ValidateMessage(Hl7Message hl7ResponseMessage, Hl7MessageDelimiters messageDelimiters)
{
try
{
// validate the HL7 message
System.String facility = hl7ResponseMessage.SendingFacility;
System.String version = hl7ResponseMessage.VersionId;
if (_hl7ProfileStore != null)
{
// get the validation profile - keyed off the facility, version and messageType
System.String messageType = hl7ResponseMessage.MessageType;
if (hl7ResponseMessage.MessageSubType != System.String.Empty)
{
messageType += ("^" + hl7ResponseMessage.MessageSubType);
}
System.String xmlProfile = _hl7ProfileStore.GetXmlHl7Profile(new Hl7ProfileId(facility, version, messageType));
if (_hl7ValidationContext != null)
{
// get the validation context
System.String xmlValidationContext = _hl7ValidationContext.XmlValidationContext;
if ((xmlProfile != System.String.Empty) &&
(xmlValidationContext != System.String.Empty) &&
(_nistWebServiceClient != null))
{
System.String errorDescription = System.String.Empty;
System.String xmlValidationResult = _nistWebServiceClient.Validate(xmlProfile, xmlValidationContext, hl7ResponseMessage.ToString(messageDelimiters), false, out errorDescription);
if (errorDescription != System.String.Empty)
{
_hl7ThreadForHl7Client.LogError(errorDescription);
}
NistXmlResultsParser xmlParser = new NistXmlResultsParser(xmlValidationResult);
_hl7ThreadForHl7Client.UpdateValidationErrorCount(xmlParser.ErrorCount);
_hl7ThreadForHl7Client.UpdateValidationWarningCount(xmlParser.WarningCount);
_hl7ThreadForHl7Client.WriteXmlStringToResults(xmlParser.RemoveHeader(xmlValidationResult));
}
}
}
}
catch (System.Exception e)
{
System.String message = System.String.Format("NIST Validation Exception: {0} - {1}",
e.Message, e.StackTrace);
Console.WriteLine(message);
_hl7ThreadForHl7Client.LogInformation(message);
}
}
//
// - Methods -
//
/// <summary>
/// Decode a Hl7Message object from a given stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns>The decoded Hl7Message.</returns>
internal Hl7Message Decode(System.IO.Stream stream)
{
Hl7Message hl7Message = new Hl7Message();
// initialize the message delimiters to the default values
_messageDelimiters = new Hl7MessageDelimiters();
// initialise the segment content
System.String rxSegment = System.String.Empty;
// read the first character from the stream to determine if the MLLP is used
int rxCode = stream.ReadByte();
if (rxCode < 0)
{
throw new System.Exception("Incomplete HL7 stream.");
}
stream.Seek(0, System.IO.SeekOrigin.Begin);
// initialise the MLLP state
MllpStateEnum mllpState = MllpStateEnum.MllpNotUsed;
if ((char)rxCode == _StartOfMessageChar)
{
// SOM read - use the MLLP protocol
mllpState = MllpStateEnum.WaitingForStartOfMessageChar;
}
// loop waiting for the end of message character
while (_continueReading)
{
// get the next character from the stream
rxCode = stream.ReadByte();
if (rxCode < 0)
{
// end of stream reached when not using the MLLP
// - check if there is any data left in the rxSegment
if ((rxSegment != System.String.Empty) &&
(mllpState == MllpStateEnum.MllpNotUsed))
{
// segment is complete
Hl7Segment segment = new Hl7Segment();
segment.Decode(rxSegment, _messageDelimiters);
// add the segment to the HL7 message
hl7Message.AddSegment(segment);
}
// message is complete
_continueReading = false;
break;
}
char rxChar = (char) rxCode;
// switch on MLLP state
switch(mllpState)
{
case MllpStateEnum.MllpNotUsed:
// check if we have got the end of segment
if (rxChar == _EndOfSegmentChar)
{
// check if we have the MSH segment
// - we need to get the message delimiters
if (rxSegment.StartsWith("MSH") == true)
{
// set the message delimiters to the values received
// - we assume that the MSH segment is formatted properly at least in the first few bytes
_messageDelimiters = new Hl7MessageDelimiters(rxSegment.Substring(3,5));
}
// segment is complete
Hl7Segment segment = new Hl7Segment();
segment.Decode(rxSegment, _messageDelimiters);
// add the segment to the HL7 message
hl7Message.AddSegment(segment);
// reset the segment
rxSegment = System.String.Empty;
}
else if (rxChar == _NewLineChar)
{
// ignore the line feed character
}
else
{
// save the received character in the current segment
rxSegment += rxChar;
}
break;
case MllpStateEnum.WaitingForStartOfMessageChar:
// check if we have got the SOM
if (rxChar == _StartOfMessageChar)
{
// reset the segment
rxSegment = System.String.Empty;
// change state to waiting for end of segment
mllpState = MllpStateEnum.WaitingForEndOfSegmentChar;
}
else
{
Console.WriteLine("HL7 - MLLP: Waiting for SOM - got {0}...", rxChar);
}
break;
case MllpStateEnum.WaitingForEndOfSegmentChar:
// check if we have got the end of segment
if (rxChar == _EndOfSegmentChar)
{
// check if we have the MSH segment
// - we need to get the message delimiters
if (rxSegment.StartsWith("MSH") == true)
{
// set the message delimiters to the values received
// - we assume that the MSH segment is formatted properly at least in the first few bytes
_messageDelimiters = new Hl7MessageDelimiters(rxSegment.Substring(3,5));
}
// segment is complete
Hl7Segment segment = new Hl7Segment();
segment.Decode(rxSegment, _messageDelimiters);
// add the segment to the HL7 message
hl7Message.AddSegment(segment);
// reset the segment
rxSegment = System.String.Empty;
}
else if (rxChar == _EndOfMessageChar1)
{
// we have the first end of message - that's OK
// check if any characters have been received since the last end of segment
if (rxSegment == System.String.Empty)
{
// change state to waiting for second end of message
mllpState = MllpStateEnum.WaitingForEndOfMessageChar;
}
else
{
Console.WriteLine("HL7 - MLLP: First EOM does not immediately follow an EOS");
return null;
}
}
else
{
// save the received character in the current segment
rxSegment += rxChar;
}
break;
case MllpStateEnum.WaitingForEndOfMessageChar:
// check if we have got the second end of message
if (rxChar == _EndOfMessageChar2)
{
// message is complete
_continueReading = false;
}
else
{
Console.WriteLine("HL7 - MLLP: Second EOM does not immediately follow first EOM");
return null;
}
break;
default:
break;
}
}
// return the correct instantiation of the received HL7 message
return Hl7MessageFactory.CreateHl7Message(hl7Message, _messageDelimiters);
}
private void UpdateImageArchiveActor(Hl7Message message)
{
String actorId = GetFirstActorIdFromDicomServer(ActorTypeEnum.ImageArchive);
ImageArchiveActor imageArchiveActor = (ImageArchiveActor)IheFramework.GetActor(new ActorName(ActorTypeEnum.ImageArchive, actorId));
if (imageArchiveActor != null)
{
imageArchiveActor.HandleUpdateFromImageManagerActor(message);
}
}
/// <summary>
/// Add a HL7 message to this collection.
/// </summary>
/// <param name="hl7Message">The HL7 message.</param>
public void Add(Hl7Message hl7Message)
{
Hl7AttributeCollection hl7AttributeCollection = new Hl7AttributeCollection(hl7Message);
Add(hl7AttributeCollection);
}
