private void PopulateDropdownLists()
        {
            var workQueueTypes      = WorkQueueTypeEnum.GetAll();
            var workQueueStatuses   = WorkQueueStatusEnum.GetAll();
            var workQueuePriorities = WorkQueuePriorityEnum.GetAll();

            if (TypeListBox.Items.Count == 0)
            {
                foreach (WorkQueueTypeEnum t in workQueueTypes)
                {
                    TypeListBox.Items.Add(new ListItem(ServerEnumDescription.GetLocalizedDescription(t), t.Lookup));
                }
            }
            if (StatusListBox.Items.Count == 0)
            {
                foreach (WorkQueueStatusEnum s in workQueueStatuses)
                {
                    // #10784: remove Completed status filter
                    if (s != WorkQueueStatusEnum.Completed)
                    {
                        StatusListBox.Items.Add(new ListItem(ServerEnumDescription.GetLocalizedDescription(s), s.Lookup));
                    }
                }
            }

            if (PriorityDropDownList.Items.Count == 0)
            {
                PriorityDropDownList.Items.Clear();
                PriorityDropDownList.Items.Add(new ListItem(SR.Any, string.Empty));
                foreach (WorkQueuePriorityEnum p in workQueuePriorities)
                {
                    PriorityDropDownList.Items.Add(new ListItem(ServerEnumDescription.GetLocalizedDescription(p), p.Lookup));
                }
            }
        }
        /// <summary>
        /// Reset queue items that were unadvertly left in "in progress" state by previous run.
        /// </summary>
        public static void ResetFailedItems()
        {
            var settings = WorkQueueSettings.Instance;

            WorkQueueStatusEnum pending = WorkQueueStatusEnum.Pending;
            WorkQueueStatusEnum failed  = WorkQueueStatusEnum.Failed;

            using (IUpdateContext ctx = PersistentStoreRegistry.GetDefaultStore().OpenUpdateContext(UpdateContextSyncMode.Flush))
            {
                IWorkQueueReset          reset = ctx.GetBroker <IWorkQueueReset>();
                WorkQueueResetParameters parms = new WorkQueueResetParameters();
                parms.ProcessorID = ServerPlatform.ProcessorId;

                // reschedule to start again now
                parms.RescheduleTime = Platform.Time;
                // retry will expire X minutes from now (so other process MAY NOT remove them)
                parms.RetryExpirationTime = Platform.Time.AddMinutes(2);

                // if an entry has been retried more than WorkQueueMaxFailureCount, it should be failed
                parms.MaxFailureCount = 3;
                // failed item expires now (so other process can remove them if desired)
                parms.FailedExpirationTime = Platform.Time;

                IList <Model.WorkQueue> modifiedList = reset.Find(parms);

                if (modifiedList != null)
                {
                    // output the list of items that have been reset
                    foreach (Model.WorkQueue queueItem in modifiedList)
                    {
                        if (queueItem.WorkQueueStatusEnum.Equals(pending))
                        {
                            Platform.Log(LogLevel.Info, "Cleanup: Reset Queue Item : {0} --> Status={1} Scheduled={2} ExpirationTime={3}",
                                         queueItem.GetKey().Key,
                                         queueItem.WorkQueueStatusEnum,
                                         queueItem.ScheduledTime,
                                         queueItem.ExpirationTime);
                        }
                    }

                    // output the list of items that have been failed because it exceeds the max retry count
                    foreach (Model.WorkQueue queueItem in modifiedList)
                    {
                        if (queueItem.WorkQueueStatusEnum.Equals(failed))
                        {
                            Platform.Log(LogLevel.Info, "Cleanup: Fail Queue Item  : {0} : FailureCount={1} ExpirationTime={2}",
                                         queueItem.GetKey().Key,
                                         queueItem.FailureCount,
                                         queueItem.ExpirationTime);
                        }
                    }
                }

                ctx.Commit();
            }
        }
        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);

            ClearScheduleDateButton.OnClientClick = ScriptHelper.ClearDate(ScheduleDate.ClientID, ScheduleCalendarExtender.ClientID);

            // setup child controls
            GridPagerTop.InitializeGridPager(SR.GridPagerWorkQueueSingleItem, SR.GridPagerWorkQueueMultipleItems, workQueueItemList.WorkQueueItemGridView,
                                             () => workQueueItemList.ResultCount, ImageServerConstants.GridViewPagerPosition.Top);
            workQueueItemList.Pager = GridPagerTop;

            workQueueItemList.ServerPartition = _serverPartition;

            workQueueItemList.DataSourceCreated += delegate(WorkQueueDataSource source)
            {
                if (!String.IsNullOrEmpty(PatientName.TrimText))
                {
                    source.PatientsName = SearchHelper.NameWildCard(PatientName.TrimText);
                }

                source.Partition = ServerPartition;

                if (!String.IsNullOrEmpty(PatientId.TrimText))
                {
                    source.PatientId = SearchHelper.TrailingWildCard(PatientId.TrimText);
                }

                if (!String.IsNullOrEmpty(ProcessingServer.TrimText))
                {
                    source.ProcessingServer = SearchHelper.TrailingWildCard(ProcessingServer.TrimText);
                }

                source.ScheduledDate = !string.IsNullOrEmpty(ScheduleDate.Text) ? ScheduleDate.Text : string.Empty;

                source.DateFormats = ScheduleCalendarExtender.Format;

                if (TypeListBox.SelectedIndex > -1)
                {
                    var types = new List <WorkQueueTypeEnum>();
                    foreach (ListItem item in TypeListBox.Items)
                    {
                        if (item.Selected)
                        {
                            types.Add(WorkQueueTypeEnum.GetEnum(item.Value));
                        }
                    }
                    source.TypeEnums = types.ToArray();
                }

                if (StatusListBox.SelectedIndex > -1)
                {
                    var statuses = new List <WorkQueueStatusEnum>();
                    foreach (ListItem item in StatusListBox.Items)
                    {
                        if (item.Selected)
                        {
                            statuses.Add(WorkQueueStatusEnum.GetEnum(item.Value));
                        }
                    }
                    source.StatusEnums = statuses.ToArray();
                }

                if (PriorityDropDownList.SelectedValue != string.Empty)
                {
                    source.PriorityEnum = WorkQueuePriorityEnum.GetEnum(PriorityDropDownList.SelectedValue);
                }
            };

            MessageBox.Confirmed += delegate
            {
                workQueueItemList.RefreshCurrentPage();
            };
        }