Esempio n. 1
0
        public void Reprioritize(WorkItemPriorityEnum priority)
        {
            if (WorkItem == null)
            {
                return;
            }

            if (WorkItem.Status == WorkItemStatusEnum.Deleted)
            {
                return;
            }

            WorkItemUpdateResponse response = null;

            Platform.GetService <IWorkItemService>(s => response = s.Update(new WorkItemUpdateRequest
            {
                Priority    = priority,
                Identifier  = WorkItem.Identifier,
                ProcessTime = priority == WorkItemPriorityEnum.Stat ? DateTime.Now : default(DateTime?)
            }));

            // TODO (CR Jun 2012): The passed-in WorkItem contract should not be updated;
            // it should be done by the service and a new instance returned, or something should be returned by this
            // method to let the caller decide what to do.

            if (response.Item == null)
            {
                WorkItem.Status = WorkItemStatusEnum.Deleted;
            }
            else
            {
                WorkItem = response.Item;
            }
        }
Esempio n. 2
0
        public void Delete()
        {
            if (WorkItem == null)
            {
                return;
            }

            if (WorkItem.Status == WorkItemStatusEnum.Deleted)
            {
                return;
            }

            WorkItemUpdateResponse response = null;

            Platform.GetService <IWorkItemService>(s => response = s.Update(new WorkItemUpdateRequest
            {
                Delete     = true, // TODO (Marmot) - This delete flag could be removed, and we could just use the status
                Identifier = WorkItem.Identifier
            }));

            // TODO (CR Jun 2012): The passed-in WorkItem contract should not be updated;
            // it should be done by the service and a new instance returned, or something should be returned by this
            // method to let the caller decide what to do.

            if (response.Item == null)
            {
                WorkItem.Status = WorkItemStatusEnum.Deleted;
            }
            else
            {
                WorkItem = response.Item;
            }
        }
Esempio n. 3
0
        public void Cancel()
        {
            if (WorkItem == null)
            {
                return;
            }

            if (WorkItem.Progress != null && !WorkItem.Progress.IsCancelable)
            {
                return;
            }

            if (WorkItem.Status == WorkItemStatusEnum.Deleted)
            {
                return;
            }

            WorkItemUpdateResponse response = null;

            Platform.GetService <IWorkItemService>(s => response = s.Update(new WorkItemUpdateRequest
            {
                Cancel     = true,
                Identifier = WorkItem.Identifier
            }));

            // TODO (CR Jun 2012): The passed-in WorkItem contract should not be updated;
            // it should be done by the service and a new instance returned, or something should be returned by this
            // method to let the caller decide what to do.
            if (response.Item == null)
            {
                WorkItem.Status = WorkItemStatusEnum.Deleted;
            }
            else
            {
                WorkItem = response.Item;
            }
        }
Esempio n. 4
0
        public WorkItemUpdateResponse Update(WorkItemUpdateRequest request)
        {
            var response = new WorkItemUpdateResponse();

            var workItem = IoC.Get <IWorkItemOperation>().GetWorkItem(request.Identifier);

            if (workItem == null)
            {
                response.Item = null;
                return(response);
            }

            var deleted = false;

            if (request.Delete.HasValue && request.Delete.Value)
            {
                if (workItem.Status != WorkItemStatusEnum.InProgress)
                {
                    workItem.Status = WorkItemStatusEnum.Deleted;
                    deleted         = true;

                    // If StudyDelete we're removing, "undelete" the study
                    // CheckDeleteStudyCanceled(context, workItem);
                }
            }
            if (!deleted)
            {
                if (request.ExpirationTime.HasValue)
                {
                    workItem.ExpirationTime = request.ExpirationTime.Value;
                }
                if (request.Priority.HasValue)
                {
                    workItem.Priority = request.Priority.Value;
                }
                if (request.Status.HasValue && workItem.Status != WorkItemStatusEnum.InProgress)
                {
                    workItem.Status = request.Status.Value;
                    if (request.Status.Value == WorkItemStatusEnum.Canceled)
                    {
                        workItem.DeleteTime =
                            DateTime.Now.AddMinutes(WorkItemServiceSettings.Default.DeleteDelayMinutes);
                    }
                    else if (request.Status.Value == WorkItemStatusEnum.Pending)
                    {
                        workItem.ScheduledTime = DateTime.Now;
                        workItem.FailureCount  = 0;
                    }

                    // Cache the UserIdentityContext for later use by the shred
                    //if (workItem.Request.WorkItemType.Equals(ImportFilesRequest.WorkItemTypeString) &&
                    //    request.Status.Value == WorkItemStatusEnum.Pending)
                    //    UserIdentityCache.Put(workItem.Oid, UserIdentityContext.CreateFromCurrentThreadPrincipal());
                }
                if (request.ProcessTime.HasValue)
                {
                    workItem.ProcessTime = request.ProcessTime.Value;
                }

                // Cancel
                if (request.Cancel.HasValue && request.Cancel.Value)
                {
                    if (workItem.Progress == null || workItem.Progress.IsCancelable)
                    {
                        if (workItem.Status.Equals(WorkItemStatusEnum.Idle) ||
                            workItem.Status.Equals(WorkItemStatusEnum.Pending))
                        {
                            workItem.Status = WorkItemStatusEnum.Canceled;

                            // If StudyDelete we're removing, "undelete" the study
                            // CheckDeleteStudyCanceled(context, workItem);
                        }
                        else if (workItem.Status.Equals(WorkItemStatusEnum.InProgress))
                        {
                            // Abort the WorkItem
                            WorkItemProcessor.Instance.Cancel(workItem.Oid);
                        }
                    }
                }

                // Pause
                if (request.Pause.HasValue && request.Pause.Value)
                {
                    if (workItem.Progress == null || workItem.Progress.IsPauseable)
                    {
                        if (workItem.Status.Equals(WorkItemStatusEnum.Idle) ||
                            workItem.Status.Equals(WorkItemStatusEnum.Pending))
                        {
                            workItem.Status = WorkItemStatusEnum.Pause;
                        }
                        else if (workItem.Status.Equals(WorkItemStatusEnum.InProgress))
                        {
                            // Pause the WorkItem
                            WorkItemProcessor.Instance.Pause(workItem.Oid);
                        }
                    }
                }

                IoC.Get <IWorkItemOperation>().SaveWorkItem(workItem);

                response.Item = WorkItemDataHelper.FromWorkItem(workItem);
            }

            WorkItemPublishSubscribeHelper.PublishWorkItemChanged(WorkItemsChangedEventType.Update, response.Item);

            return(response);
        }