public void EditSelectedWorklist()
{
if (_selectedWorklist != null)
{
WorklistAdminDetail detail = new WorklistAdminDetail();
detail.Name = _selectedWorklist.Name;
detail.Description = _selectedWorklist.Description;
detail.WorklistClass = _selectedWorklist.Class;
WorklistDetailEditorComponent editor =
new WorklistDetailEditorComponent(
detail,
this.WorklistClasses,
_ownerGroupChoices,
WorklistEditorMode.Edit,
true,
true);
if (ApplicationComponent.LaunchAsDialog(this.Host.DesktopWindow,
editor,
SR.TitleEditWorklist) == ApplicationComponentExitCode.Accepted)
{
_selectedWorklist.Name = detail.Name;
_selectedWorklist.Description = detail.Description;
_worklistTable.Items.NotifyItemUpdated(_selectedWorklist);
}
}
}
public override bool ResolveNameInteractive(string query, out ExternalPractitionerSummary result)
{
result = null;
ExternalPractitionerSummaryComponent component = new ExternalPractitionerSummaryComponent(true);
component.IncludeDeactivatedItems = this.IncludeDeactivatedItems;
if (!string.IsNullOrEmpty(query))
{
string[] names = query.Split(',');
if (names.Length > 0)
{
component.LastName = names[0].Trim();
}
if (names.Length > 1)
{
component.FirstName = names[1].Trim();
}
}
ApplicationComponentExitCode exitCode = ApplicationComponent.LaunchAsDialog(
_desktopWindow, component, SR.TitleExternalPractitioner);
if (exitCode == ApplicationComponentExitCode.Accepted)
{
result = (ExternalPractitionerSummary)component.SummarySelection.Item;
}
return(result != null);
}
private void Edit()
{
DicomPrinterEditValidation oih = new DicomPrinterEditValidation
{
dicomPrinterSummaryComponent = this
};
oih.dicomPrinter = this._checkableDicomPrinter.Item;
Checkable <DicomPrinter> oldCheckAble = this._checkableDicomPrinter;
DicomPrinterEditorComponent component = new DicomPrinterEditorComponent(oih.dicomPrinter);
component.Validation.Add(new ValidationRule("Name", new ValidationRule.ValidationDelegate(oih.Validation)));
IApplicationComponentHost host = base.Host;
DesktopWindow desktopWindow = host.DesktopWindow;
if (ApplicationComponentExitCode.Accepted == ApplicationComponent.LaunchAsDialog(desktopWindow, component, "Edit DICOM Printer"))
{
int num = this._dicomPrinterTable.Items.IndexOf(oldCheckAble);
this._dicomPrinterTable.Items.Remove(oldCheckAble);
bool isChecked = oldCheckAble.IsChecked;
Checkable <DicomPrinter> checkable = new Checkable <DicomPrinter>(oih.dicomPrinter, isChecked);
this._dicomPrinterTable.Items.Insert(num, checkable);
this.Modified = true;
}
}
protected override void ActivateCore()
{
var component = new AnonymizeStudyComponent(Context.GetStudyRootData())
{
ShowKeepReportsAndAttachments = false, ShowPreserveSeriesData = false
};
if (ApplicationComponent.LaunchAsDialog(Context.DesktopWindow, component, SR.TitleQuickAnonymize) != ApplicationComponentExitCode.Accepted)
{
return;
}
bool applyToAll = false;
if (_promptForAll)
{
if (this.Context.DesktopWindow.ShowMessageBox(SR.MessageConfirmAnonymizeAllFiles, MessageBoxActions.YesNo) == DialogBoxAction.Yes)
{
applyToAll = true;
}
}
this.Context.DumpManagement.Anonymize(applyToAll, component.AnonymizedData, component.KeepPrivateTags);
this.Context.UpdateDisplay();
}
public void AnonymizeStudy()
{
_component = new AnonymizeStudyComponent(Context.SelectedStudy);
if (ApplicationComponentExitCode.Accepted ==
ApplicationComponent.LaunchAsDialog(Context.DesktopWindow, _component, SR.TitleAnonymizeStudy))
{
if (LocalStorageMonitor.IsMaxUsedSpaceExceeded)
{
Context.DesktopWindow.ShowMessageBox(SR.MessageCannotAnonymizeMaxDiskUsageExceeded, MessageBoxActions.Ok);
return;
}
BackgroundTask task = null;
try
{
task = new BackgroundTask(Anonymize, false, Context.SelectedStudy);
ProgressDialog.Show(task, Context.DesktopWindow, true);
}
catch (Exception e)
{
Platform.Log(LogLevel.Error, e);
Context.DesktopWindow.ShowMessageBox(SR.MessageAnonymizeStudyFailed, MessageBoxActions.Ok);
}
finally
{
if (task != null)
{
task.Dispose();
}
}
}
}
/// <summary>
/// Shows a dialog to allow user to resolve the specified query to a single staff.
/// The query may consist of part of the surname,
/// optionally followed by a comma and then part of the given name (e.g. "sm, b" for smith, bill).
/// The method returns true if the name is successfully resolved, or false otherwise.
/// </summary>
/// <param name="query"></param>
/// <param name="result"></param>
/// <returns></returns>
public override bool ResolveNameInteractive(string query, out StaffSummary result)
{
result = null;
var staffComponent = new StaffSummaryComponent(true, _staffTypesFilter);
staffComponent.IncludeDeactivatedItems = this.IncludeDeactivatedItems;
if (!string.IsNullOrEmpty(query))
{
var names = query.Split(',');
if (names.Length > 0)
{
staffComponent.LastName = names[0].Trim();
}
if (names.Length > 1)
{
staffComponent.FirstName = names[1].Trim();
}
}
var exitCode = ApplicationComponent.LaunchAsDialog(
_desktopWindow, staffComponent, SR.TitleStaff);
if (exitCode == ApplicationComponentExitCode.Accepted)
{
result = (StaffSummary)staffComponent.SummarySelection.Item;
}
return(result != null);
}
public void RenameStudy()
{
_component = new RenameStudyComponent(this.Context.SelectedStudy);
if (ApplicationComponentExitCode.Accepted ==
ApplicationComponent.LaunchAsDialog(this.Context.DesktopWindow, _component, "Rename Study"))
{
BackgroundTask task = null;
try
{
task = new BackgroundTask(Rename, false, this.Context.SelectedStudy.StudyInstanceUid);
ProgressDialog.Show(task, this.Context.DesktopWindow, true);
}
catch (Exception e)
{
Platform.Log(LogLevel.Error, e);
string message = String.Format("Must Delete Manually", _tempPath);
this.Context.DesktopWindow.ShowMessageBox(message, MessageBoxActions.Ok);
}
finally
{
_tempPath = null;
if (task != null)
{
task.Dispose();
}
}
}
}
public static bool ShowReconciliationDialog(EntityRef targetProfile, IDesktopWindow window)
{
IList <ReconciliationCandidate> candidates = null;
IList <PatientProfileSummary> reconciledProfiles = null;
Platform.GetService <IPatientReconciliationService>(
delegate(IPatientReconciliationService service)
{
ListPatientReconciliationMatchesResponse response =
service.ListPatientReconciliationMatches(new ListPatientReconciliationMatchesRequest(targetProfile));
candidates = response.MatchCandidates;
reconciledProfiles = response.ReconciledProfiles;
});
if (candidates.Count > 0)
{
ReconciliationComponent component = new ReconciliationComponent(targetProfile, reconciledProfiles, candidates);
ApplicationComponentExitCode exitCode = ApplicationComponent.LaunchAsDialog(
window,
component,
SR.TitlePatientReconciliation);
return(exitCode == ApplicationComponentExitCode.Accepted);
}
else
{
window.ShowMessageBox(SR.MessageNoReconciliationCandidate, MessageBoxActions.Ok);
return(false);
}
}
public void Duplicate()
{
var folder = (IWorklistFolder)this.Context.SelectedFolder;
if (!CanDuplicate(folder))
{
return;
}
try
{
var fs = (IWorklistFolderSystem)this.Context.SelectedFolderSystem;
var initialWorklistClassName = folder.WorklistClassName;
var editor = new WorklistEditorComponent(folder.WorklistRef, false, fs.SupportedWorklistClasses, initialWorklistClassName);
var exitCode = ApplicationComponent.LaunchAsDialog(
this.Context.DesktopWindow,
new DialogBoxCreationArgs(editor, "New Worklist", null, DialogSizeHint.Large));
if (exitCode == ApplicationComponentExitCode.Accepted)
{
AddNewWorklistsToFolderSystem(editor.EditedWorklistSummaries, fs);
}
}
catch (Exception e)
{
ExceptionHandler.Report(e, this.Context.DesktopWindow);
}
}
public void Compose()
{
if (_composer != null)
{
return;
}
try
{
BackgroundTask task = new BackgroundTask(new BackgroundTaskMethod(InitComposer), true, null);
ProgressDialogComponent progressDialog = new ProgressDialogComponent(task, true, ProgressBarStyle.Continuous);
ApplicationComponent.LaunchAsDialog(this.Context.DesktopWindow, progressDialog, SR.MessageStartingStudyComposer);
if (_composer != null)
{
SimpleComposerAdapterComponent component = new SimpleComposerAdapterComponent(_composer);
ApplicationComponent.LaunchAsDialog(this.Context.DesktopWindow, component, SR.StudyComposer);
_composer = null;
}
}
catch (Exception ex)
{
ExceptionHandler.Report(ex, base.Context.DesktopWindow);
}
}
public void Launch()
{
if (LoginSession.Current == null)
{
this.Context.DesktopWindow.ShowMessageBox(
"This feature will be available the next time you start the workstation.",
MessageBoxActions.Ok);
return;
}
try
{
if (LoginSession.Current.Staff == null)
{
this.Context.DesktopWindow.ShowMessageBox(
string.Format("There is no staff profile associated with the user '{0}'", LoginSession.Current.UserName),
MessageBoxActions.Ok);
return;
}
var component = new StaffEditorComponent(LoginSession.Current.Staff.StaffRef);
ApplicationComponent.LaunchAsDialog(
this.Context.DesktopWindow,
component,
SR.TitleStaff);
}
catch (Exception e)
{
// could not launch component
ExceptionHandler.Report(e, this.Context.DesktopWindow);
}
}
public void Launch()
{
if (LoginSession.Current == null)
{
this.Context.DesktopWindow.ShowMessageBox(
SR.MessageFeatureRequiresWorkstationRestart,
MessageBoxActions.Ok);
return;
}
try
{
if (LoginSession.Current.Staff == null)
{
this.Context.DesktopWindow.ShowMessageBox(
string.Format(SR.FormatUserHasNoStaffProfile, LoginSession.Current.UserName),
MessageBoxActions.Ok);
return;
}
var component = new StaffEditorComponent(LoginSession.Current.Staff.StaffRef);
ApplicationComponent.LaunchAsDialog(
this.Context.DesktopWindow,
component,
SR.TitleStaff);
}
catch (Exception e)
{
// could not launch component
ExceptionHandler.Report(e, this.Context.DesktopWindow);
}
}
protected bool ExecuteCore(WorklistItemSummaryBase item)
{
var list = new List <TItem>(this.Context.SelectedItems);
var orderRefs = CollectionUtils.Map <TItem, EntityRef>(list, x => x.OrderRef);
var component = new MergeOrdersComponent(orderRefs);
string failureReason;
if (!ValidateMergeRequest(orderRefs, out failureReason))
{
this.Context.DesktopWindow.ShowMessageBox(failureReason, MessageBoxActions.Ok);
return(false);
}
var args = new DialogBoxCreationArgs(component, SR.TitleMergeOrders, null)
{
AllowUserResize = true
};
if (ApplicationComponentExitCode.Accepted != ApplicationComponent.LaunchAsDialog(this.Context.DesktopWindow, args))
{
return(false);
}
InvalidateFolders();
return(true);
}
/// <summary>
/// Shows all <see cref="IConfigurationPage"/>s returned by extensions of <see cref="ConfigurationPageProviderExtensionPoint"/>
/// in a dialog, with a navigable tree to select the pages.
/// </summary>
public static ApplicationComponentExitCode Show(IDesktopWindow desktopWindow, string initialPageIdentifier)
{
var container = new ConfigurationDialogComponent(GetPages(), initialPageIdentifier);
var exitCode = ApplicationComponent.LaunchAsDialog(desktopWindow, container, SR.TitleMenuOptions);
return(exitCode);
}
private void DoReconciliation()
{
var checkedPatients = new List <EntityRef>();
foreach (var entry in _reconciliationProfileTable.Items)
{
if (entry.Checked && !checkedPatients.Contains(entry.ReconciliationCandidate.PatientProfile.PatientRef))
{
checkedPatients.Add(entry.ReconciliationCandidate.PatientProfile.PatientRef);
}
}
Platform.GetService <IPatientReconciliationService>(service =>
{
// get the full list of all the profiles that will be reconciled if this operation is carried out
var indirectlyReconciledProfiles = service.ListProfilesForPatients(new ListProfilesForPatientsRequest(checkedPatients)).Profiles;
// confirmation
var confirmComponent = new ReconciliationConfirmComponent(_targetProfiles, indirectlyReconciledProfiles);
var confirmExitCode = ApplicationComponent.LaunchAsDialog(
this.Host.DesktopWindow, confirmComponent, SR.TitleConfirmReconciliation);
if (confirmExitCode == ApplicationComponentExitCode.Accepted)
{
// add the target patient to the set
checkedPatients.Add(_targetProfiles[0].PatientRef);
// reconcile
service.ReconcilePatients(new ReconcilePatientsRequest(checkedPatients));
}
});
}
protected override bool Execute(ReportingWorklistItemSummary item)
{
if (item.ReportRef == null)
{
return(false);
}
try
{
//todo: loc
var title = string.Format("Print Report for {0} {1} - {2}",
Formatting.MrnFormat.Format(item.Mrn),
Formatting.PersonNameFormat.Format(item.PatientName),
Formatting.AccessionFormat.Format(item.AccessionNumber));
var component = new PrintReportComponent(item.OrderRef, item.ReportRef);
ApplicationComponent.LaunchAsDialog(
this.Context.DesktopWindow,
component,
title);
}
catch (Exception e)
{
ExceptionHandler.Report(e, this.Context.DesktopWindow);
}
// always return false - we didn't change any data
return(false);
}
/// <summary>
/// Called by the framework when the user clicks the "apply" menu item or toolbar button.
/// </summary>
public void Apply()
{
CalendarEvent appt = this.Context.SelectedAppointment;
if (appt != null)
{
try
{
EmailComponent component = new EmailComponent();
ApplicationComponentExitCode exitCode = ApplicationComponent.LaunchAsDialog(this.Context.DesktopWindow,
component, SR.EmailDialogTitle);
if (exitCode == ApplicationComponentExitCode.Accepted)
{
// create a background task to send the mail, so that we can use a progress dialog
BackgroundTask sendMailTask = new BackgroundTask(
delegate(IBackgroundTaskContext context)
{
// set a message on the progress dialog
context.ReportProgress(new BackgroundTaskProgress(0, SR.SendingMailMessage));
// call helper method to send the email
SendMail(appt, component.EmailAddress);
}, false);
// Use marquee style since we have no way of knowing how long it will take
ProgressDialog.Show(sendMailTask, this.Context.DesktopWindow, true, ProgressBarStyle.Marquee);
}
}
catch (Exception e)
{
ExceptionHandler.Report(e, this.Context.DesktopWindow);
}
}
}
protected static void Open(EntityRef orderRef, IDesktopWindow window)
{
ApplicationComponent.LaunchAsDialog(
window,
new WorkflowHistoryComponent(orderRef),
"Workflow History");
}
public void Edit()
{
var folder = (IWorklistFolder)this.Context.SelectedFolder;
if (!CanEdit(folder))
{
return;
}
try
{
var editor = new WorklistEditorComponent(folder.WorklistRef, false);
var exitCode = ApplicationComponent.LaunchAsDialog(
this.Context.DesktopWindow,
new DialogBoxCreationArgs(editor, "Edit Worklist" + " - " + folder.Name, null, DialogSizeHint.Large));
if (exitCode == ApplicationComponentExitCode.Accepted)
{
var worklist = CollectionUtils.FirstElement(editor.EditedWorklistSummaries);
var fs = (IWorklistFolderSystem)this.Context.SelectedFolderSystem;
// update folder properties
fs.UpdateWorklistFolder(folder, worklist);
// refresh folder content
fs.InvalidateFolder(folder);
}
}
catch (Exception e)
{
ExceptionHandler.Report(e, this.Context.DesktopWindow);
}
}
public override bool ResolveNameInteractive(string query, out DiagnosticServiceSummary result)
{
result = null;
try
{
IDiagnosticServiceInteractiveLookupProvider provider = (IDiagnosticServiceInteractiveLookupProvider)
new DiagnosticServiceInteractiveLookupProviderExtensionPoint().CreateExtension();
result = provider.ResolveDiagnosticService(query, _desktopWindow);
}
catch (NotSupportedException)
{
// default
DiagnosticServiceSummaryComponent summaryComponent = new DiagnosticServiceSummaryComponent(true);
summaryComponent.IncludeDeactivatedItems = this.IncludeDeactivatedItems;
if (!string.IsNullOrEmpty(query))
{
summaryComponent.Name = query;
}
ApplicationComponentExitCode exitCode = ApplicationComponent.LaunchAsDialog(
_desktopWindow, summaryComponent, "Imaging Services");
if (exitCode == ApplicationComponentExitCode.Accepted)
{
result = (DiagnosticServiceSummary)summaryComponent.SummarySelection.Item;
}
}
return(result != null);
}
public void Print()
{
var selectedFolder = this.Context.SelectedFolder;
if (selectedFolder == null)
{
return;
}
var fsName = selectedFolder.FolderSystem != null ? selectedFolder.FolderSystem.Title : "";
var folderName = selectedFolder.Name;
var folderDescription = selectedFolder.Tooltip;
var totalItemCount = selectedFolder.TotalItemCount;
var items = new List <object>();
foreach (var item in selectedFolder.ItemsTable.Items)
{
items.Add(item);
}
ApplicationComponent.LaunchAsDialog(
this.Context.DesktopWindow,
new WorklistPrintComponent(fsName, folderName, folderDescription, totalItemCount, items),
SR.TitlePrintWorklist);
}
bool ILookupHandler.Resolve(string query, bool interactive, out object result)
{
result = null;
ExternalPractitionerDetail practitionerDetail = null;
Platform.GetService <IExternalPractitionerAdminService>(
service =>
{
var response = service.LoadExternalPractitionerForEdit(new LoadExternalPractitionerForEditRequest(_practitionerRef));
practitionerDetail = response.PractitionerDetail;
});
var component = new ExternalPractitionerContactPointSummaryComponent(_practitionerRef);
practitionerDetail.ContactPoints.ForEach(p => component.Subject.Add(p));
var exitCode = ApplicationComponent.LaunchAsDialog(
_desktopWindow, component, SR.TitleContactPoints);
if (exitCode == ApplicationComponentExitCode.Accepted)
{
result = component.SummarySelection.Item;
}
return(result != null);
}
private void Open(IDesktopWindow desktopWindow)
{
try
{
var editor = new PatientProfileEditorComponent();
var result = ApplicationComponent.LaunchAsDialog(
desktopWindow,
editor,
SR.TitleNewPatient);
if (result == ApplicationComponentExitCode.Accepted && this.Context is IRegistrationWorkflowItemToolContext)
{
// if patient successfully added, invoke a search on the MRN so that the patient appears in the Home page
var searchParams = new WorklistSearchParams(new WorklistItemTextQueryRequest.AdvancedSearchFields()
{
Mrn = editor.PatientProfile.Mrn.Id
});
((IRegistrationWorkflowItemToolContext)this.Context).ExecuteSearch(searchParams);
}
}
catch (Exception e)
{
ExceptionHandler.Report(e, desktopWindow);
}
}
public void RenameNode()
{
try
{
if (this.CanRename)
{
AbstractActionModelTreeNode selectedNode = base.SelectedNode;
RenameNodeComponent component = new RenameNodeComponent();
component.Name = selectedNode.Label;
ApplicationComponentExitCode result = ApplicationComponent.LaunchAsDialog(
this.Context.DesktopWindow,
new SimpleComponentContainer(component),
SR.TitleRename);
if (result == ApplicationComponentExitCode.Accepted)
{
selectedNode.Label = component.Name;
}
}
}
catch (Exception ex)
{
ExceptionHandler.Report(ex, this.Context.DesktopWindow);
}
}
public void Apply()
{
var component = new AIMTCGAComponent();
var exitCode = ApplicationComponent.LaunchAsDialog(
Context.DesktopWindow,
component,
"AIM Data Service Options");
}
private void AddNewServerGroup()
{
ServerTree _serverTree = this.Context.ServerTree;
this.Context.UpdateType = (int)ServerUpdateType.Add;
DicomServerGroupEditComponent editor = new DicomServerGroupEditComponent(_serverTree, ServerUpdateType.Add);
ApplicationComponentExitCode exitCode = ApplicationComponent.LaunchAsDialog(this.Context.DesktopWindow, editor, SR.TitleAddServerGroup);
this.Context.UpdateType = (int)ServerUpdateType.None;
}
public void Apply()
{
var component = new AttachDocumentComponent(this.Context.Site);
var exitCode = ApplicationComponent.LaunchAsDialog(this.Context.DesktopWindow, component, SR.TitleAttachFile);
if (exitCode == ApplicationComponentExitCode.Accepted)
{
this.Context.AddAttachment(component.Document, component.Category);
}
}
public void OpenOptions()
{
if (optionComponent == null)
{
optionComponent = new MediaWriterOptionsComponent();
optionComponent.PropertyChanged += propertyChanged;
}
ApplicationComponent.LaunchAsDialog(this.Host.DesktopWindow, optionComponent, "Media Write Options");
}
public void Apply()
{
OrderNoteboxConfigurationComponent component = new OrderNoteboxConfigurationComponent();
ApplicationComponentExitCode exitCode = ApplicationComponent.LaunchAsDialog(
this.Context.DesktopWindow, component, "Group Notebox Folder Configuration");
if (exitCode == ApplicationComponentExitCode.Accepted)
{
this.Context.RebuildGroupFolders();
}
}
protected EntityRef GetSupervisorRef()
{
ProtocollingSupervisorSelectionComponent component = new ProtocollingSupervisorSelectionComponent();
if (ApplicationComponentExitCode.Accepted == ApplicationComponent.LaunchAsDialog(this.Context.DesktopWindow, component, SR.TitleSelectSupervisor))
{
return(component.Staff != null ? component.Staff.StaffRef : null);
}
else
{
return(null);
}
}