/// <summary>
/// Method to handle the workflow after receiving a Release Request.
/// </summary>
/// <param name="releaseRq">Release Request message.</param>
public override void AfterHandlingReleaseRequest(ReleaseRq releaseRq)
{
if (IsMessageHandled == false)
{
SendReleaseRp();
// message has now been handled
IsMessageHandled = true;
this.receiveMessages = false;
}
}
/// <summary>
/// Method to handle the workflow after receiving a Release Request.
/// </summary>
/// <param name="releaseRq">Release Request message.</param>
public override void AfterHandlingReleaseRequest(ReleaseRq releaseRq)
{
if (IsMessageHandled == false)
{
// determine which workflow to follow
switch(_scpRespondToReleaseRequest)
{
case ScpRespondToReleaseRequestEnum.WithReleaseResponse:
// send a release response
SendReleaseRp();
break;
case ScpRespondToReleaseRequestEnum.WithAbort:
default:
// send an abort request with the given parameters
SendAbort(_abortSource, _abortReason);
break;
}
// handle results files
if (_resultsFilePerAssociation == true)
{
StopResultsGathering();
StartResultsGathering();
}
// message has now been handled
IsMessageHandled = true;
}
}
/// <summary>
/// Override this method to handle an A-RELEASE-RQ.
/// </summary>
/// <param name="releaseRq">The received A-RELEASE-RQ.</param>
/// <returns>Return true when this methods has handled the received A-RELEASE-RQ, otherwise false.</returns>
public virtual bool HandleReleaseRequest(ReleaseRq releaseRq)
{
return false;
}
/// <summary>
/// This method is called after an A-RELEASE-RQ has been received and has
/// (possibly) been handled by the (zero or more) MessageHandler objects that
/// are attached to this object.
///
/// Default, nothing is done in this method. Override if needed.
/// </summary>
/// <param name="releaseRq">The received A-RELEASE-RQ.</param>
public virtual void AfterHandlingReleaseRequest(ReleaseRq releaseRq)
{
// Do nothing.
}
/// <summary>
/// This method is called after an A-RELEASE-RQ has been received but before it
/// (possibly) will be handled by the (zero or more) MessageHandler objects that
/// are attached to this object.
///
/// Default, nothing is done in this method. Override if needed.
/// </summary>
/// <param name="releaseRq">The received A-RELEASE-RQ.</param>
public virtual void BeforeHandlingReleaseRequest(ReleaseRq releaseRq)
{
// Do nothing.
}
/// <summary>
/// Receives a messages (can be a Dicom or Dul message).
/// </summary>
/// <param name="messageToExpect">Message to expect that is written in the results.</param>
/// <returns>The received message.</returns>
/// <exception cref="DicomProtocolMessageReceiveException">
/// Receiving of a message fails.
/// </exception>
private DicomProtocolMessage ReceiveMessage(String messageToExpect)
{
DicomProtocolMessage receivedMessage = null;
DvtkData.Message dvtkDataMessage = null;
if (this.hasOpenConnection)
{
if (messageToExpect == "")
{
WriteInformation("Receiving message...");
}
else
{
WriteInformation("Receiving message (expecting " + messageToExpect + ")...");
}
}
else
{
WriteInformation(String.Format("Listening for incoming Dicom connection on port {0}...", Options.LocalPort));
}
Dvtk.Sessions.ReceiveReturnCode receiveReturnCode = DvtkScriptSession.Receive(out dvtkDataMessage);
if (receiveReturnCode != Dvtk.Sessions.ReceiveReturnCode.Success)
{
throw new DicomProtocolMessageReceiveException("Error while trying to receive a Message. Error code " + receiveReturnCode.ToString() + ".", receiveReturnCode);
}
else
{
if (dvtkDataMessage is DvtkData.Dimse.DicomMessage)
{
DicomMessage receivedDicomMessage = new DicomMessage(dvtkDataMessage as DvtkData.Dimse.DicomMessage);
// Apply the inbound DicomMessage filters if this is a DicomMessage.
foreach (InboundDicomMessageFilter inboundDicomMessageFilter in this.inboundDicomMessageFilters)
{
inboundDicomMessageFilter.Apply(receivedDicomMessage);
}
receivedMessage = receivedDicomMessage;
}
else if (dvtkDataMessage is DvtkData.Dul.A_ASSOCIATE_RQ)
{
receivedMessage = new AssociateRq(dvtkDataMessage as DvtkData.Dul.A_ASSOCIATE_RQ);
hasOpenConnection = true;
}
else if (dvtkDataMessage is DvtkData.Dul.A_ASSOCIATE_AC)
{
receivedMessage = new AssociateAc(dvtkDataMessage as DvtkData.Dul.A_ASSOCIATE_AC);
this.lastAssociateAc = receivedMessage as AssociateAc;
}
else if (dvtkDataMessage is DvtkData.Dul.A_ASSOCIATE_RJ)
{
receivedMessage = new AssociateRj(dvtkDataMessage as DvtkData.Dul.A_ASSOCIATE_RJ);
hasOpenConnection = false;
}
else if (dvtkDataMessage is DvtkData.Dul.A_RELEASE_RQ)
{
receivedMessage = new ReleaseRq(dvtkDataMessage as DvtkData.Dul.A_RELEASE_RQ);
}
else if (dvtkDataMessage is DvtkData.Dul.A_RELEASE_RP)
{
receivedMessage = new ReleaseRp(dvtkDataMessage as DvtkData.Dul.A_RELEASE_RP);
hasOpenConnection = false;
}
else if (dvtkDataMessage is DvtkData.Dul.A_ABORT)
{
receivedMessage = new Abort(dvtkDataMessage as DvtkData.Dul.A_ABORT);
hasOpenConnection = false;
}
else
{
Debug.Assert(true, "Unexpected DvtkData Message descendant type.");
}
WriteInformation("... " + receivedMessage.ToString() + " received.");
// If the options AutoValidate is true, try to validate as much
// as possible for the received message.
if (Options.AutoValidate)
{
Validate(receivedMessage);
}
MessageReceived(receivedMessage);
if (receivedMessage is ReleaseRq)
{
if (AssociationReleasedEvent != null)
{
AssociationReleasedEvent(this);
}
}
}
return (receivedMessage);
}
//
// - Methods -
//
/// <summary>
/// This override makes sure that this SCP object only nadles one association and
/// exists after that.
/// </summary>
/// <param name="releaseRq">The received A-RELEASE-RQ.</param>
public override void AfterHandlingReleaseRequest(ReleaseRq releaseRq)
{
base.AfterHandlingReleaseRequest(releaseRq);
this.receiveMessages = false;
}
/// <summary>
/// Sends an A-RELEASE-RQ.
/// </summary>
/// <returns>The sent A-RELEASE-RQ.</returns>
/// <exception cref="System.Exception">
/// Sending of the A-RELEASE-RQ fails.
/// </exception>
/// <example>
/// <b>VB.NET</b>
/// <code>
/// <include file='Doc\VisualBasicExamples.xml' path='Examples/Example[@name="IncludesDicomThreadScu"]' />
/// <include file='Doc\VisualBasicExamples.xml' path='Examples/Example[@name="DicomThreadScu"]' />
/// <include file='Doc\VisualBasicExamples.xml' path='Examples/Example[@name="Main"]' />
/// </code>
/// </example>
protected internal ReleaseRq SendReleaseRq()
{
ReleaseRq releaseRq = new ReleaseRq();
SendMessage(releaseRq);
if (AssociationReleasedEvent != null)
{
AssociationReleasedEvent(this);
}
return (releaseRq);
}
public override void BeforeHandlingReleaseRequest(ReleaseRq releaseRq)
{
this.SendingMessageEvent -= new SendingMessageEventHandler(QRScp_SendingMessageEvent);
this.MessageReceivedEvent -= new MessageReceivedEventHandler(QRScp_MessageReceivedEvent);
base.BeforeHandlingReleaseRequest(releaseRq);
}
/// <summary>
/// Method to handle the workflow after receiving a Release Request.
/// </summary>
/// <param name="releaseRq">Release Request message.</param>
public override void AfterHandlingReleaseRequest(ReleaseRq releaseRq)
{
if (IsMessageHandled == false)
{
// send a release response
SendReleaseRp();
// message has now been handled
IsMessageHandled = true;
}
}
/// <summary>
/// This class was only intended as an example of a MessageIterator derived class. Please use the MessageIterator class instead.
/// </summary>
/// <param name="releaseRq">-</param>
public override void AfterHandlingReleaseRequest(ReleaseRq releaseRq)
{
if (!IsMessageHandled)
{
SendReleaseRp();
if (this.resultsFilePerAssociation)
{
StopResultsGathering();
StartResultsGathering();
}
IsMessageHandled = true;
}
}
public override void AfterHandlingReleaseRequest(ReleaseRq releaseRq)
{
if (!IsMessageHandled)
{
SendReleaseRp();
IsMessageHandled = true;
}
}
