Exemplo n.º 1
0
        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);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Initializes the encapsulated Dvtk.Comparator.DicomComparator class with the supplied DICOM message.
        /// </summary>
        /// <param name="dicomMessage">The DICOM message.</param>
        /// <returns>The encapsulated Dvtk.Comparator.DicomComparator instance.</returns>
        public DicomComparator InitializeDicomComparator(DicomMessage dicomMessage)
        {
            _hl7Comparator = null;

            bool initialized = _dicomComparator.Initialize(dicomMessage.DvtkDataDicomMessage);
            if (initialized == false)
            {
                _dicomComparator = null;
            }

            return _dicomComparator;
        }
Exemplo n.º 3
0
        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);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Set the Comparators needed to handle each message in the Transaction.
        /// </summary>
        /// <param name="comparatorCollection">Comparator collection to fill.</param>
        public void SetComparators(Dvtk.Comparator.BaseComparatorCollection comparatorCollection)
        {
            if (_transaction is DicomTransaction)
            {
                System.String name = System.String.Empty;

                DicomTransaction dicomTransaction = (DicomTransaction)_transaction;
                switch (dicomTransaction.Direction)
                {
                case TransactionDirectionEnum.TransactionReceived:
                    name = System.String.Format("Received by {0}:{1} from {2}:{3}",
                                                ActorTypes.Type(_toActorName.Type),
                                                _toActorName.Id,
                                                ActorTypes.Type(_fromActorName.Type),
                                                _fromActorName.Id);
                    break;

                case TransactionDirectionEnum.TransactionSent:
                    name = System.String.Format("Sent from {0}:{1} to {2}:{3}",
                                                ActorTypes.Type(_toActorName.Type),
                                                _toActorName.Id,
                                                ActorTypes.Type(_fromActorName.Type),
                                                _fromActorName.Id);
                    break;

                default:
                    break;
                }

                for (int i = 0; i < dicomTransaction.DicomMessages.Count; i++)
                {
                    DicomMessage dicomMessage = (DicomMessage)dicomTransaction.DicomMessages[i];

                    DvtkHighLevelInterface.Comparator.Comparator comparator = new DvtkHighLevelInterface.Comparator.Comparator(name);
                    Dvtk.Comparator.DicomComparator dicomComparator         = comparator.InitializeDicomComparator(dicomMessage);
                    if (dicomComparator != null)
                    {
                        comparatorCollection.Add(dicomComparator);
                    }
                }
            }
            else if (_transaction is Hl7Transaction)
            {
                System.String name = System.String.Empty;

                Hl7Transaction hl7Transaction = (Hl7Transaction)_transaction;
                switch (hl7Transaction.Direction)
                {
                case TransactionDirectionEnum.TransactionReceived:
                    name = System.String.Format("Received by {0}:{1} from {2}:{3}",
                                                ActorTypes.Type(_toActorName.Type),
                                                _toActorName.Id,
                                                ActorTypes.Type(_fromActorName.Type),
                                                _fromActorName.Id);
                    break;

                case TransactionDirectionEnum.TransactionSent:
                    name = System.String.Format("Sent from {0}:{1} to {2}:{3}",
                                                ActorTypes.Type(_toActorName.Type),
                                                _toActorName.Id,
                                                ActorTypes.Type(_fromActorName.Type),
                                                _fromActorName.Id);
                    break;

                default:
                    break;
                }

                Hl7Message hl7Message = hl7Transaction.Request;

                DvtkHighLevelInterface.Comparator.Comparator comparator = new DvtkHighLevelInterface.Comparator.Comparator(name);
                Dvtk.Comparator.Hl7Comparator hl7Comparator             = comparator.InitializeHl7Comparator(hl7Message);
                if (hl7Comparator != null)
                {
                    comparatorCollection.Add(hl7Comparator);
                }
            }
        }
Exemplo n.º 5
0
        /// <summary>
        /// Compare the two messages.
        /// </summary>
        /// <param name="tagValueFilterCollection">Tag Value Filter.</param>
        /// <param name="resultsReporter">Results reporter.</param>
        /// <param name="thatBaseComparator">Reference comparator.</param>
        /// <returns>bool - true = messages compared, false messages not compared</returns>
        public override bool Compare(TagValueCollection tagValueFilterCollection, ResultsReporter resultsReporter, BaseComparator thatBaseComparator)
        {
            bool compared = false;

            if (thatBaseComparator is Hl7Comparator)
            {
                Hl7Comparator thatHl7Comparator = (Hl7Comparator)thatBaseComparator;

                // Check if both templates have been initialized correctly
                if ((this.Template == null) ||
                    (thatHl7Comparator.Template == null))
                {
                    return(false);
                }

                // Check for comparator equality
                if (this == thatHl7Comparator)
                {
                    return(true);
                }

                // filter out comparators for the same message types
                if ((this.Template.MessageType == thatHl7Comparator.Template.MessageType) &&
                    (this.Template.MessageSubType == thatHl7Comparator.Template.MessageSubType))
                {
                    return(false);
                }

                // generate a local Tag Value collection from this
                // - this collection will include any tag value pair from the original collection and
                // the tag value pairs of any tags only (in the original collection) that match from this
                // comparator - that is the values are taken from this comparator.
                TagValueCollection lTagValueFilterCollection = GenerateTagValueCollection(tagValueFilterCollection);

                // check to see if the comparision filters match - without Univeral Matching
                // - now try to match this local filter collection against thatDicomComparator
                // - comparators that match will have the same tag value pairs (including the value) as
                // each other.
                if ((tagValueFilterCollection.Count == lTagValueFilterCollection.Count) &&
                    (thatHl7Comparator.UseComparator(lTagValueFilterCollection, false) == true))
                {
                    MessageComparisonResults messageComparisonResults
                        = new MessageComparisonResults(this.Name,
                                                       thatHl7Comparator.Name,
                                                       this.Template.MessageType,
                                                       thatHl7Comparator.Template.MessageType,
                                                       this.Template.MessageSubType,
                                                       thatHl7Comparator.Template.MessageSubType);

                    // Iterate over this comparator
                    foreach (Hl7ComparisonTag thisComparisonTag in this.Template.ComparisonTags)
                    {
                        // try to get the equivalent tag in thatHl7Comparator
                        Hl7ComparisonTag thatComparisonTag = thatHl7Comparator.Template.ComparisonTags.Find(thisComparisonTag.Tag);
                        if (thatComparisonTag != null)
                        {
                            AttributeComparisonResults attributeComparisonResults
                                = new AttributeComparisonResults(SegmentNames.Name(thisComparisonTag.Tag.Segment),
                                                                 thisComparisonTag.Tag.FieldIndex,
                                                                 thisComparisonTag.DataFormat.ToHl7Format(),
                                                                 thatComparisonTag.DataFormat.ToHl7Format());
                            attributeComparisonResults.Name = DicomHl7TagMapTemplate.Hl7NameFromHl7Tag(thisComparisonTag.Tag);
                            if (thisComparisonTag.DataFormat.Equals(thatComparisonTag.DataFormat) == false)
                            {
                                DvtkData.Validation.ValidationMessage validationMessage = new DvtkData.Validation.ValidationMessage();
                                validationMessage.Type    = DvtkData.Validation.MessageType.Error;
                                validationMessage.Message = "Attribute values do not match.";

                                attributeComparisonResults.Messages.Add(validationMessage);
                            }
                            messageComparisonResults.Add(attributeComparisonResults);
                        }
                    }

                    resultsReporter.WriteMessageComparisonResults(messageComparisonResults);

                    compared = true;
                }
            }
            else if (thatBaseComparator is DicomComparator)
            {
                DicomComparator thatDicomComparator = (DicomComparator)thatBaseComparator;

                // Check if both templates have been initialized correctly
                if ((this.Template == null) ||
                    (thatDicomComparator.Template == null))
                {
                    return(false);
                }

                // generate a local Tag Value collection from this
                // - this collection will include any tag value pair from the original collection and
                // the tag value pairs of any tags only (in the original collection) that match from this
                // comparator - that is the values are taken from this comparator.
                TagValueCollection lTagValueFilterCollection = GenerateTagValueCollection(tagValueFilterCollection);

                // check to see if the comparision filters match - without Univeral Matching
                // - now try to match this local filter collection against thatDicomComparator
                // - comparators that match will have the same tag value pairs (including the value) as
                // each other.
                if ((tagValueFilterCollection.Count == lTagValueFilterCollection.Count) &&
                    (thatDicomComparator.UseComparator(lTagValueFilterCollection, false) == true))
                {
                    MessageComparisonResults messageComparisonResults
                        = new MessageComparisonResults(this.Name,
                                                       thatDicomComparator.Name,
                                                       this.Template.MessageType,
                                                       thatDicomComparator.Template.Command,
                                                       this.Template.MessageSubType,
                                                       thatDicomComparator.Template.SopClassUid);

                    // Iterate over this comparator
                    foreach (Hl7ComparisonTag thisComparisonTag in this.Template.ComparisonTags)
                    {
                        // try to get the equivalent tag in thatDicomComparator
                        DicomComparisonTag thatComparisonTag = thatDicomComparator.Template.ComparisonTags.Find(DicomHl7TagMapTemplate.Hl7ToDicomTag(thisComparisonTag.Tag));
                        if (thatComparisonTag != null)
                        {
                            AttributeComparisonResults attributeComparisonResults
                                = new AttributeComparisonResults(thatComparisonTag.Tag,
                                                                 SegmentNames.Name(thisComparisonTag.Tag.Segment),
                                                                 thisComparisonTag.Tag.FieldIndex,
                                                                 thisComparisonTag.DataFormat.ToHl7Format(),
                                                                 thatComparisonTag.DataFormat.ToDicomFormat());

                            if (thisComparisonTag.DataFormat.Equals(thatComparisonTag.DataFormat) == false)
                            {
                                DvtkData.Validation.ValidationMessage validationMessage = new DvtkData.Validation.ValidationMessage();
                                validationMessage.Type    = DvtkData.Validation.MessageType.Error;
                                validationMessage.Message = "Attribute values do not match.";

                                attributeComparisonResults.Messages.Add(validationMessage);
                            }
                            messageComparisonResults.Add(attributeComparisonResults);
                        }
                    }

                    resultsReporter.WriteMessageComparisonResults(messageComparisonResults);

                    compared = true;
                }
            }

            return(compared);
        }
Exemplo n.º 6
0
        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;
        }
Exemplo n.º 7
0
        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;
        }
Exemplo n.º 8
0
        /// <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;
        }
Exemplo n.º 9
0
 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="name">Name to supply to the encapsulated Dvtk.Comparator.DicomComparator and Dvtk.Comparator.Hl7Comparator classes.</param>
 public Comparator(System.String name)
 {
     _dicomComparator = new DicomComparator(name);
     _hl7Comparator = new Hl7Comparator(name);
 }
Exemplo n.º 10
0
        /// <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;
        }