/// <summary>
/// Throttle requests using W(O) = mO(t) + c where W is the wait period, O is the opertaion duration, m and c are positive constants
/// Uses a new client every time which is released before return
/// </summary>
#region ThrottleRequest
public void ThrottleRequest(DicomRequest dicomRequest, GracefulCancellationToken cancellationToken)
{
var client = new DicomClient();
ThrottleRequest(dicomRequest, client, cancellationToken);
client.Release();
}
/// <summary>
/// Blocks until the request is received so calling code doesn't have to deal with asynchrony (see the EventWaitHandle in TrySend).
/// Only the timeout is applied no Throtelling
/// </summary>
/// <param name="dicomRequest"></param>
#region SendRequest
public void SendRequest(DicomRequest dicomRequest)
{
var client = new DicomClient();
SendRequest(dicomRequest, client);
client.Release();
}
public override Task OnRequestTimedOutAsync(DicomRequest request, TimeSpan timeout)
{
RemoveRequestFromPendingList(request);
_dicomClient.NotifyRequestTimedOut(new RequestTimedOutEventArgs(request, timeout));
return(CompletedTaskProvider.CompletedTask);
}
public override Task AddRequestAsync(DicomRequest dicomRequest)
{
_dicomClient.QueuedRequests.Enqueue(new StrongBox <DicomRequest>(dicomRequest));
_onRequestAddedTaskCompletionSource.TrySetResultAsynchronously(true);
return(CompletedTaskProvider.CompletedTask);
}
public override Task AddRequestAsync(DicomRequest dicomRequest)
{
_dicomClient.QueuedRequests.Enqueue(new StrongBox <DicomRequest>(dicomRequest));
_sendMoreRequests.Set();
return(CompletedTaskProvider.CompletedTask);
}
public RoutedItemClonable(RoutedItemManager manager)
{
Throw.IfNull(manager);
_ruleDicomTags = manager.ruleDicomTags;
_ruleDicomTag = manager.ruleDicomTag;
_rules = manager.rules;
_sourceDicomFile = manager.sourceDicomFile;
_destDicomFile = manager.destDicomFile;
_dicomRequest = manager.dicomRequest;
_stream = manager.stream;
}
public void MyDelegate(MyParameters p)
{
Leadtools.AddIn.StorageCommit.StorageCommit commit = new Leadtools.AddIn.StorageCommit.StorageCommit();
DicomRequest request = new DicomRequest(p._client);
this.AddCommitItem(p._ds, DicomTag.ReferencedPerformedProcedureStepSequence, commit);
this.AddCommitItem(p._ds, DicomTag.ReferencedSOPSequence, commit);
foreach (StorageCommitItem item in commit.Items)
{
string sql = string.Format("SELECT * FROM Images WHERE SOPInstanceUID = '{0}'", item.SOPInstanceUID);
SqlCeDataReader r = SqlCeHelper.ExecuteReader(p._connectionString, sql);
if (r.Read())
{
if (r["SOPClassUID"].ToString() == item.SOPClassUID)
{
string referencedFile = r["referencedFile"].ToString();
if (File.Exists(referencedFile))
{
item.Status = DicomCommandStatusType.Success;
}
else
{
item.Status = DicomCommandStatusType.NoSuchObjectInstance;
}
}
else
{
item.Status = DicomCommandStatusType.ClaseInstanceConflict;
}
item.StudyInstanceUID = r["StudyInstanceUID"].ToString();
}
else
{
item.Status = DicomCommandStatusType.NoSuchObjectInstance;
}
r.Close();
}
DicomDataSet commitDS = BuildDataset(p._client, commit, p.ServerAE);
PresentationContext pc = new PresentationContext();
pc.AbstractSyntax = DicomUidType.StorageCommitmentPushModelClass;
pc.TransferSyntaxes.Add(DicomUidType.ImplicitVRLittleEndian);
request.PresentationContexts.Add(pc);
request.RequireMessagePump = true;
request.ReceiveNReportResponse += new ReceiveNReportResponseDelegate(request_ReceiveNReportResponse);
request.ConnectType = ConnectType.Conditional;
_DicomRequest.SendNReportRequest(request, p._presentationId, p._messageId, DicomUidType.StorageCommitmentPushModelClass,
DicomUidType.StorageCommitmentPushModelInstance,
commit.FailedCount > 0 ? 2 : 1, commitDS);
}
private void UpdateMppsStatusInLocalCollections(DicomRequest request)
{
var description = string.Format("{0} -> {1}", request.Dataset.Get <string>(DicomTag.PatientID), request.Dataset.Get <string>(DicomTag.PerformedProcedureStepStatus));
var patientId = request.Dataset.Get <string>(DicomTag.PatientID);
var status = request.Dataset.Get <string>(DicomTag.PerformedProcedureStepStatus);
var item = m_WorklistRepository.WorklistItems.Single(w => w.Get <string>(DicomTag.PatientID).Equals(patientId));
item.AddOrUpdate(DicomTag.PerformedProcedureStepStatus, status);
SetMppsStatusFromItem(item);
}
public override Task OnRequestCompletedAsync(DicomRequest request, DicomResponse response)
{
_pendingRequests.TryRemove(request.MessageID, out DicomRequest _);
if (_pendingRequests.IsEmpty)
{
if (_dicomClient.QueuedRequests.IsEmpty)
{
_allRequestsHaveCompletedTaskCompletionSource.TrySetResultAsynchronously(new AllRequestsHaveCompletedEvent());
}
else
{
_sendMoreRequests.Set();
}
}
return(CompletedTaskProvider.CompletedTask);
}
private void RemoveRequestFromPendingList(DicomRequest request)
{
_pendingRequests.TryRemove(request.MessageID, out DicomRequest _);
if (_pendingRequests.IsEmpty)
{
if (_dicomClient.QueuedRequests.IsEmpty || _numberOfSentRequests >= _maximumNumberOfRequestsPerAssociation)
{
_allRequestsHaveCompletedTaskCompletionSource.TrySetResultAsynchronously(new AllRequestsHaveCompletedEvent());
}
else
{
_sendMoreRequests.Set();
}
}
else if (Connection.IsSendNextMessageRequired)
{
_sendMoreRequests.Set();
}
}
public Task OnRequestTimedOutAsync(DicomRequest request, TimeSpan timeout) => Task.CompletedTask;
public Task OnRequestCompletedAsync(DicomRequest request, DicomResponse response)
{
return(DicomClient.OnRequestCompletedAsync(request, response));
}
public override Task OnRequestCompletedAsync(DicomRequest request, DicomResponse response)
{
RemoveRequestFromPendingList(request);
return(CompletedTaskProvider.CompletedTask);
}
/// <summary>
/// Throttle requests using W(O) = mO(t) + c where W is the wait period, O is the opertaion duration, m and c are positive constants
/// The request is added to the client which is unreleased at the end of this request send.
/// </summary>
///
#region ThrottleRequest
public void ThrottleRequest(DicomRequest dicomRequest, DicomClient client, CancellationToken cancellationToken)
{
client.AddRequestAsync(dicomRequest).Wait(cancellationToken);
ThrottleRequest(client, cancellationToken);
}
/// <summary>
/// Blocks until the request is received so calling code doesn't have to deal with asynchrony (see the EventWaitHandle in TrySend).
/// Only the timeout is applied no Throtelling
/// </summary>
/// <param name="dicomRequest"></param>
#region SendRequest
private void SendRequest(DicomRequest dicomRequest, CancellationToken token)
{
var client = new DicomClient(_dicomConfiguration.RemoteAetUri.Host, _dicomConfiguration.RemoteAetUri.Port, false, _dicomConfiguration.LocalAetTitle, _dicomConfiguration.RemoteAetTitle);
SendRequest(dicomRequest, client, token);
}
/// <summary>
/// Initializes an instance of <see cref="RequestTimedOutEventArgs"/>
/// </summary>
/// <param name="request"></param>
/// <param name="timeout"></param>
public RequestTimedOutEventArgs(DicomRequest request, TimeSpan timeout)
{
Request = request;
Timeout = timeout;
}
public Task OnRequestTimedOutAsync(DicomRequest request, TimeSpan timeout)
{
return(DicomClient.OnRequestTimedOutAsync(request, timeout));
}
public abstract Task OnRequestTimedOutAsync(DicomRequest request, TimeSpan timeout);
public void HandleNReport(StorageCommitArgs p)
{
StorageCommitment commitRequest = p.RequestDS.Get <StorageCommitment>();
StorageCommitmentResult commitResult = new StorageCommitmentResult();
commitResult.TransactionUID = commitRequest.TransactionUID;
commitResult.RetrieveAETitle = p.Client.AETitle; //p.Client.Server.AETitle;
int failedCount = 0;
foreach (SopInstanceReference referencedSop in commitRequest.ReferencedSOPSequence)
{
string referencedFile = GetInstanceFileName.FindReferencedFile(referencedSop.ReferencedSopInstanceUid);
bool success = !string.IsNullOrEmpty(referencedFile) && File.Exists(referencedFile);
if (success)
{
// Success
if (commitResult.ReferencedSOPSequence == null)
{
commitResult.ReferencedSOPSequence = new List <SCSOPInstanceReference>();
}
SCSOPInstanceReference scSopInstanceReference = new SCSOPInstanceReference();
scSopInstanceReference.RetrieveAETitle = commitResult.RetrieveAETitle;
scSopInstanceReference.ReferencedSopClassUid = referencedSop.ReferencedSopClassUid;
scSopInstanceReference.ReferencedSopInstanceUid = referencedSop.ReferencedSopInstanceUid;
commitResult.ReferencedSOPSequence.Add(scSopInstanceReference);
}
else
{
// Fail
if (commitResult.FailedSOPSequence == null)
{
commitResult.FailedSOPSequence = new List <SCFailedSOPInstanceReference>();
}
SCFailedSOPInstanceReference scFailedSopInstanceReference = new SCFailedSOPInstanceReference();
scFailedSopInstanceReference.ReferencedSopClassUid = referencedSop.ReferencedSopClassUid;
scFailedSopInstanceReference.ReferencedSopInstanceUid = referencedSop.ReferencedSopInstanceUid;
// The following values and semantics shall be used for the Failure Reason Attribute:
// 0110H - DicomCommandStatusType.ProcessingFailure - Processing failure A general failure in processing the operation was encountered.
// 0112H - DicomCommandStatusType.NoSuchObjectInstance - No such object instance One or more of the elements in the Referenced SOP Instance Sequence was not available.
// 0213H - DicomCommandStatusType.ResourceLimitation - Resource limitation The SCP does not currently have enough resources to store the requested SOP Instance(s).
// 0122H - DicomCommandStatusType.ClassNotSupported - Referenced SOP Class not supported Storage Commitment has been requested for a SOP Instance with a SOP Class thatis not supported by the SCP.
// 0119H - DicomCommandStatusType.ClaseInstanceConflict - Class / Instance conflict The SOP Class of an element in the Referenced SOP Instance Sequence did not correspond to theSOP class registered for this SOP Instance at the SCP.
// 0131H - DicomCommandStatusType.DuplicateTransactionUid - Duplicate transaction UID The Transaction UID of the Storage Commitment Request is already in use.
scFailedSopInstanceReference.FailureReason = (int)DicomCommandStatusType.NoSuchObjectInstance;
commitResult.FailedSOPSequence.Add(scFailedSopInstanceReference);
failedCount++;
}
}
DicomDataSet resultDS = new DicomDataSet();
resultDS.Set(commitResult);
PresentationContext pc = new PresentationContext();
pc.AbstractSyntax = DicomUidType.StorageCommitmentPushModelClass;
pc.TransferSyntaxes.Add(DicomUidType.ImplicitVRLittleEndian);
DicomRequest request = new DicomRequest(p.Client);
request.PresentationContexts.Add(pc);
request.RequireMessagePump = true;
request.ReceiveNReportResponse += new ReceiveNReportResponseDelegate(request_ReceiveNReportResponse);
request.ConnectType = ConnectType.Conditional;
// request.ConnectType = ConnectType.New;
// eventTypeId - 1 -- All success
// - 2 -- One or more failures
int eventTypeId = failedCount > 0 ? 2 : 1;
_dicomRequest.SendNReportRequest(request,
p.PresentationId,
p.MessageId,
DicomUidType.StorageCommitmentPushModelClass,
DicomUidType.StorageCommitmentPushModelInstance,
eventTypeId,
resultDS);
}
public Task OnRequestTimedOutAsync(DicomRequest request, TimeSpan timeout)
{
return(CompletedTaskProvider.CompletedTask);
}
public Task OnRequestCompletedAsync(DicomRequest request, DicomResponse response) => Task.CompletedTask;
public Task AddRequestAsync(DicomRequest dicomRequest)
{
_dicomClient.QueuedRequests.Enqueue(new StrongBox <DicomRequest>(dicomRequest));
return(Task.CompletedTask);
}
private static void request_ReceiveNReportResponse(DicomRequest request, byte presentationID, int messageID, string affectedClass, string instance, DicomCommandStatusType status, int dicomEvent, DicomDataSet dataSet)
{
}
internal Task OnRequestCompletedAsync(DicomRequest request, DicomResponse response) => State.OnRequestCompletedAsync(request, response);
public abstract Task OnRequestCompletedAsync(DicomRequest request, DicomResponse response);
internal Task OnRequestTimedOutAsync(DicomRequest request, TimeSpan timeout) => State.OnRequestTimedOutAsync(request, timeout);
public abstract Task AddRequestAsync(DicomRequest dicomRequest);
public Task AddRequestAsync(DicomRequest dicomRequest) => State.AddRequestAsync(dicomRequest);
public Task OnRequestCompletedAsync(DicomRequest request, DicomResponse response)
{
return(CompletedTaskProvider.CompletedTask);
}
/// <summary>
/// Blocks until the request is received so calling code doesn't have to deal with asynchrony (see the EventWaitHandle in TrySend).
/// Only the timeout is applied no Throtelling, the client is unreleased on return
/// </summary>
/// <param name="dicomRequest"></param>
/// <param name="client"></param>
#region SendRequest
public void SendRequest(DicomRequest dicomRequest, DicomClient client, CancellationToken token)
{
client.AddRequestAsync(dicomRequest).Wait(token);
SendRequest(client, token);
}
