protected void Page_Load(object sender, EventArgs e)
{
var controller = new WorkQueueController();
WorkQueueDataList.DataSource = controller.GetWorkQueueOverview();
DataBind();
}
public void ReprocessWorkQueueItem(ServerEntityKey itemKey)
{
if (itemKey != null)
{
Model.WorkQueue item = Model.WorkQueue.Load(itemKey);
var controller = new WorkQueueController();
try
{
if (controller.ReprocessWorkQueueItem(item))
{
InformationDialog.Message = SR.ReprocessOK;
InformationDialog.MessageType = MessageBox.MessageTypeEnum.INFORMATION;
InformationDialog.Show();
}
else
{
InformationDialog.Message = SR.ReprocessFailed;
InformationDialog.MessageType = MessageBox.MessageTypeEnum.ERROR;
InformationDialog.Show();
}
}
catch (InvalidStudyStateOperationException ex)
{
ShowErrorMessage(ex.Message);
}
}
}
private static WorkQueueDetails CreateGeneralWorkQueueItemDetails(Model.WorkQueue item)
{
var detail = new WorkQueueDetails();
detail.Key = item.Key;
detail.ScheduledDateTime = item.ScheduledTime;
detail.ExpirationTime = item.ExpirationTime;
detail.InsertTime = item.InsertTime;
detail.FailureCount = item.FailureCount;
detail.Type = item.WorkQueueTypeEnum;
detail.Status = item.WorkQueueStatusEnum;
detail.Priority = item.WorkQueuePriorityEnum;
detail.FailureDescription = item.FailureDescription;
detail.ServerDescription = item.ProcessorID;
StudyStorageLocation storage = WorkQueueController.GetLoadStorageLocation(item);
detail.StorageLocationPath = storage.GetStudyPath();
// Fetch UIDs
var wqUidsAdaptor = new WorkQueueUidAdaptor();
var uidCriteria = new WorkQueueUidSelectCriteria();
uidCriteria.WorkQueueKey.EqualTo(item.GetKey());
IList <WorkQueueUid> uids = wqUidsAdaptor.Get(uidCriteria);
var mapSeries = new Hashtable();
foreach (WorkQueueUid uid in uids)
{
if (mapSeries.ContainsKey(uid.SeriesInstanceUid) == false)
{
mapSeries.Add(uid.SeriesInstanceUid, uid.SopInstanceUid);
}
}
detail.NumInstancesPending = uids.Count;
detail.NumSeriesPending = mapSeries.Count;
// Fetch the study and patient info
var ssAdaptor = new StudyStorageAdaptor();
StudyStorage storages = ssAdaptor.Get(item.StudyStorageKey);
var studyAdaptor = new StudyAdaptor();
var studycriteria = new StudySelectCriteria();
studycriteria.StudyInstanceUid.EqualTo(storages.StudyInstanceUid);
studycriteria.ServerPartitionKey.EqualTo(item.ServerPartitionKey);
Study study = studyAdaptor.GetFirst(studycriteria);
// Study may not be available until the images are processed.
if (study != null)
{
var studyAssembler = new StudyDetailsAssembler();
detail.Study = studyAssembler.CreateStudyDetail(study);
}
return(detail);
}
protected void UpdateToolBarButtons()
{
RescheduleToolbarButton.Enabled = WorkQueue != null && WorkQueueController.CanReschedule(WorkQueue);
ResetButton.Enabled = WorkQueue != null && WorkQueueController.CanReset(WorkQueue);
DeleteButton.Enabled = WorkQueue != null && WorkQueueController.CanDelete(WorkQueue);
ReprocessButton.Enabled = WorkQueue != null && WorkQueueController.CanReprocess(WorkQueue);
StudyDetailsButton.Enabled = ItemStudy != null;
}
private void CustomizeRowAttribute(GridViewRow row)
{
WorkQueueSummary item = row.DataItem as WorkQueueSummary;
row.Attributes["canreschedule"] = WorkQueueController.CanReschedule(item.TheWorkQueueItem).ToString().ToLower();
row.Attributes["canreset"] = WorkQueueController.CanReset(item.TheWorkQueueItem).ToString().ToLower();
row.Attributes["candelete"] = WorkQueueController.CanDelete(item.TheWorkQueueItem).ToString().ToLower();
row.Attributes["canreprocess"] = WorkQueueController.CanReprocess(item.TheWorkQueueItem).ToString().ToLower();
}
private void ReprocessWorkQueueItem(Model.WorkQueue item)
{
try
{
var controller = new WorkQueueController();
if (controller.ReprocessWorkQueueItem(item))
{
MessageBox.Message = SR.ReprocessOK;
MessageBox.MessageType = MessageBox.MessageTypeEnum.INFORMATION;
MessageBox.Show();
}
else
{
ShowErrorMessage(SR.ReprocessFailed);
}
}
catch (InvalidStudyStateOperationException ex)
{
ShowErrorMessage(ex.Message);
}
}
private void PreDeleteConfirmDialog_Confirmed(object data)
{
Hide();
var key = data as ServerEntityKey;
if (key != null)
{
var adaptor = new WorkQueueAdaptor();
Model.WorkQueue item = adaptor.Get(key);
if (item == null)
{
MessageBox.Message = SR.WorkQueueNotAvailable;
MessageBox.MessageType = MessageBox.MessageTypeEnum.ERROR;
MessageBox.Show();
}
else
{
if (item.WorkQueueStatusEnum == WorkQueueStatusEnum.InProgress)
{
MessageBox.Message = SR.WorkQueueBeingProcessed_CannotDelete;
MessageBox.MessageType =
MessageBox.MessageTypeEnum.ERROR;
MessageBox.Show();
return;
}
try
{
bool successful;
var controller = new WorkQueueController();
var items = new List <Model.WorkQueue>();
items.Add(item);
successful = controller.DeleteWorkQueueItems(items);
if (successful)
{
Platform.Log(LogLevel.Info, "Work Queue item deleted by user : Item Key={0}",
item.GetKey().Key);
if (WorkQueueItemDeleted != null)
{
WorkQueueItemDeleted(item);
}
if (OnHide != null)
{
OnHide();
}
}
else
{
Platform.Log(LogLevel.Error,
"PreResetConfirmDialog_Confirmed: Unable to delete work queue item. GUID={0}",
item.GetKey().Key);
MessageBox.Message = SR.WorkQueueDeleteFailed;
MessageBox.MessageType =
MessageBox.MessageTypeEnum.ERROR;
MessageBox.Show();
}
}
catch (Exception e)
{
Platform.Log(LogLevel.Error,
"PreResetConfirmDialog_Confirmed: Unable to delete work queue item. GUID={0} : {1}",
item.GetKey().Key, e.StackTrace);
MessageBox.Message = String.Format(SR.WorkQueueDeleteFailed_WithException, e.Message);
MessageBox.MessageType = MessageBox.MessageTypeEnum.ERROR;
MessageBox.Show();
}
}
}
}
protected void ApplyChanges()
{
if (WorkQueues != null)
{
var toBeUpdatedList = new List <Model.WorkQueue>();
foreach (Model.WorkQueue item in WorkQueues)
{
if (item != null)
{
toBeUpdatedList.Add(item);
}
}
if (toBeUpdatedList.Count > 0)
{
DateTime newScheduleTime = Platform.Time;
if (WorkQueueSettingsPanel.NewScheduledDateTime != null &&
WorkQueueSettingsPanel.ScheduleNow == false)
{
newScheduleTime = WorkQueueSettingsPanel.NewScheduledDateTime.Value;
}
if (newScheduleTime < Platform.Time && WorkQueueSettingsPanel.ScheduleNow == false)
{
MessageDialog.MessageType =
MessageBox.MessageTypeEnum.ERROR;
MessageDialog.Message = HttpContext.GetGlobalResourceObject("SR", "WorkQueueRescheduleFailed_MustBeInFuture") as string;
MessageDialog.Show();
ModalDialog.Show();
}
else
{
DateTime expirationTime =
newScheduleTime.AddSeconds(WorkQueueSettings.Default.WorkQueueExpireDelaySeconds);
WorkQueuePriorityEnum priority = WorkQueueSettingsPanel.SelectedPriority;
try
{
var controller = new WorkQueueController();
bool result =
controller.RescheduleWorkQueueItems(toBeUpdatedList, newScheduleTime, expirationTime,
priority);
if (result)
{
if (WorkQueueUpdated != null)
{
WorkQueueUpdated(toBeUpdatedList);
}
}
else
{
Platform.Log(LogLevel.Error, "Unable to reschedule work queue items for user");
MessageDialog.MessageType =
MessageBox.MessageTypeEnum.ERROR;
MessageDialog.Message = "Unable to reschedule this/these work queue items";
MessageDialog.Show();
}
}
catch (Exception e)
{
Platform.Log(LogLevel.Error, "Unable to reschedule work queue items for user : {0}",
e.StackTrace);
MessageDialog.MessageType =
MessageBox.MessageTypeEnum.ERROR;
MessageDialog.Message =
String.Format(HttpContext.GetGlobalResourceObject("SR", "WorkQueueRescheduleFailed_Exception") as string, e.Message);
MessageDialog.Show();
}
}
}
}
}
private static WorkQueueDetails CreateEditWorkQueueItemDetails(Model.WorkQueue item)
{
string studyPath;
try
{
StudyStorageLocation storage = WorkQueueController.GetLoadStorageLocation(item);
studyPath = storage.GetStudyPath();
}
catch (Exception)
{
studyPath = string.Empty;
}
var detail = new WorkQueueDetails
{
Key = item.Key,
ScheduledDateTime = item.ScheduledTime,
ExpirationTime = item.ExpirationTime,
InsertTime = item.InsertTime,
FailureCount = item.FailureCount,
Type = item.WorkQueueTypeEnum,
Status = item.WorkQueueStatusEnum,
Priority = item.WorkQueuePriorityEnum,
FailureDescription = item.FailureDescription,
ServerDescription = item.ProcessorID,
StorageLocationPath = studyPath
};
// Fetch UIDs
var wqUidsAdaptor = new WorkQueueUidAdaptor();
var uidCriteria = new WorkQueueUidSelectCriteria();
uidCriteria.WorkQueueKey.EqualTo(item.GetKey());
IList <WorkQueueUid> uids = wqUidsAdaptor.Get(uidCriteria);
var mapSeries = new Hashtable();
foreach (WorkQueueUid uid in uids)
{
if (mapSeries.ContainsKey(uid.SeriesInstanceUid) == false)
{
mapSeries.Add(uid.SeriesInstanceUid, uid.SopInstanceUid);
}
}
detail.NumInstancesPending = uids.Count;
detail.NumSeriesPending = mapSeries.Count;
// Fetch the study and patient info
var ssAdaptor = new StudyStorageAdaptor();
StudyStorage storages = ssAdaptor.Get(item.StudyStorageKey);
var studyAdaptor = new StudyAdaptor();
var studycriteria = new StudySelectCriteria();
studycriteria.StudyInstanceUid.EqualTo(storages.StudyInstanceUid);
studycriteria.ServerPartitionKey.EqualTo(item.ServerPartitionKey);
Study study = studyAdaptor.GetFirst(studycriteria);
// Study may not be available until the images are processed.
if (study != null)
{
var studyAssembler = new StudyDetailsAssembler();
detail.Study = studyAssembler.CreateStudyDetail(study);
}
var parser = new EditStudyWorkQueueDataParser();
EditStudyWorkQueueData data = parser.Parse(item.Data.DocumentElement);
detail.EditUpdateItems = data.EditRequest.UpdateEntries.ToArray();
return(detail);
}
private void PreResetConfirmDialog_Confirmed(object data)
{
Hide();
var key = data as ServerEntityKey;
if (key != null)
{
var adaptor = new WorkQueueAdaptor();
Model.WorkQueue item = adaptor.Get(key);
if (item == null)
{
String errorMessage = SR.WorkQueueNotAvailable;
EventsHelper.Fire(Error, this, new WorkQueueItemResetErrorEventArgs(errorMessage, null));
}
else
{
var controller = new WorkQueueController();
DateTime scheduledTime = item.ScheduledTime;
if (scheduledTime < Platform.Time)
{
scheduledTime = Platform.Time.AddSeconds(WorkQueueSettings.Default.WorkQueueProcessDelaySeconds);
}
DateTime expirationTime = item.ExpirationTime;
if (expirationTime < scheduledTime)
{
expirationTime = scheduledTime.AddSeconds(WorkQueueSettings.Default.WorkQueueExpireDelaySeconds);
}
try
{
var items = new List <Model.WorkQueue>();
items.Add(item);
controller.ResetWorkQueueItems(items, scheduledTime, expirationTime);
Platform.Log(LogLevel.Info, "{0} Work Queue item reset: Key={1}.", item.WorkQueueTypeEnum,
item.GetKey());
if (WorkQueueItemReseted != null)
{
WorkQueueItemReseted(item);
}
if (OnHide != null)
{
OnHide();
}
}
catch (Exception e)
{
Platform.Log(LogLevel.Error, e, "Unable to reset {0} work queue item. Key={1}.",
item.WorkQueueTypeEnum, item.GetKey());
String errorMessage = String.Format(SR.WorkQueueResetFailed, e.Message);
EventsHelper.Fire(Error, this, new WorkQueueItemResetErrorEventArgs(errorMessage, e));
}
}
}
}