public IEnumerable<Task> Get(TaskStatus taskStatus)
 {
     var url = String.Format("tasks/{0}.xml", taskStatus.ToString().ToLower());
     var response = _client.Execute<List<Task>>(new RestRequest(url, Method.GET));
     var tasks = response.Data;
     return tasks;
 }

        public List<Task> GetByProject(int projectId, TaskStatus? status, Guid participant)
        {
            var query = CreateQuery()
                .LeftOuterJoin("projects_milestones m", Exp.EqColumns("m.id", "t.milestone_id") & Exp.EqColumns("m.tenant_id", "t.tenant_id"))
                .Where("t.project_id", projectId)
                .OrderBy("t.sort_order", false)
                .OrderBy("m.status", true)
                .OrderBy("m.deadLine", true)
                .OrderBy("m.id", true)
                .OrderBy("t.status", true)
                .OrderBy("t.priority", true)
                .OrderBy("t.create_on", true);
            if (status != null)
            {
                if (status == TaskStatus.Open)
                    query.Where(!Exp.Eq("t.status", TaskStatus.Closed));
                else
                    query.Where("t.status", TaskStatus.Closed);
            }

            if (participant != Guid.Empty)
            {
                var existSubtask = new SqlQuery("projects_subtasks pst").Select("pst.task_id").Where(Exp.EqColumns("t.tenant_id", "pst.tenant_id") & Exp.EqColumns("t.id", "pst.task_id") & Exp.Eq("pst.status", TaskStatus.Open));
                var existResponsible = new SqlQuery("projects_tasks_responsible ptr1").Select("ptr1.task_id").Where(Exp.EqColumns("t.tenant_id", "ptr1.tenant_id") & Exp.EqColumns("t.id", "ptr1.task_id"));

                existSubtask.Where(Exp.Eq("pst.responsible_id", participant.ToString()));
                existResponsible.Where(Exp.Eq("ptr1.responsible_id", participant.ToString()));

                query.Where(Exp.Exists(existSubtask) | Exp.Exists(existResponsible));
            }

            return DbManager.ExecuteList(query).ConvertAll(r => ToTask(r));
        }

 //forceful terminate a behaviour
 public void Terminate(Behaviour behaviour, TaskStatus result)
 {
     behaviour.status = result;
     if(behaviour.observer != null){
         behaviour.observer();
     }
 }

 public void SetTaskComplete(TaskStatus status)
 {
     int statusId = (int)status;
     DatabaseProviderFactory factory = new DatabaseProviderFactory();
     var db = factory.CreateDefault();
     db.ExecuteNonQuery(CommandType.Text, "update app.taskqueue set statusid = " + statusId + ", completedate = '" + DateTime.Now.ToString() + "' where taskQueueId = " + this.TaskQueueId);
 }

 XpoState GetXpoState(TaskStatus taskStatus, XpoStateMachine stateMachine) {
     var xpoState = ObjectSpace.FindObject<XpoState>(CriteriaOperator.Parse("Caption=?", taskStatus.ToString()))??ObjectSpace.CreateObject<XpoState>();
     xpoState.Caption = taskStatus.ToString();
     xpoState.StateMachine=stateMachine;
     xpoState.MarkerValue = taskStatus.ToString();
     return xpoState;
 }

        public Task(string name, bool isimportant, bool ishard, int estimatetomato, 
            TaskType  tasktype, TaskPriority taskpri,
            TaskStatus taskstatus = TaskStatus.INQUEUE, DateTime? reminder = null)
        {
            this.name = name;
            this.isImportant = isimportant ? "important" : "not important";
            this.isHard = ishard ? "hard" : "easy";
            this.estimateToamto = estimatetomato;

            this.completeTomato = 0;
            this.incompleteTomato = 0;
            this.innerBreak = 0;
            this.outterBreak = 0;
            this.completeness = 0;
            this.difficulties = 0;
            this.satisfaction = 0;
            this.efficiency = 0;
            this.improvement = 0;
            this.achivement = 0;
            this.focusness = 0;

            this.taskStatus = taskstatus;
            this.taskType = tasktype;
            this.taskPriority = taskpri;
        }

 public override void OnConditionalAbort(int childIndex)
 {
     // Start from the beginning on an abort
     childrenExecutionOrder.Clear();
     executionStatus = TaskStatus.Inactive;
     ShuffleChilden();
 }

 void CreateTransition(TaskStatus startStatus, TaskStatus endStatus) {
     var caption = startStatus.ToString() + endStatus;
     var transition = ObjectSpace.FindObject<XpoTransition>(CriteriaOperator.Parse("Caption=?", caption)) ?? ObjectSpace.CreateObject<XpoTransition>();
     transition.Caption = caption;
     transition.SourceState = ObjectSpace.FindObject<XpoState>(CriteriaOperator.Parse("Caption=?", startStatus.ToString()));
     transition.TargetState =ObjectSpace.FindObject<XpoState>(CriteriaOperator.Parse("Caption=?", endStatus.ToString()));
 }

    public TaskData(JsonObject o)
    {
        count = Convert.ToInt32(o ["count"]);
        killCount = Convert.ToInt32(o ["killCount"]);
        createTime = (long)Convert.ToInt64(o ["createtime"]);
        prizedTime = (long)Convert.ToInt64(o["finishtime"]);
        templateID = Convert.ToInt32(o ["tid"]);
        status = (TaskStatus)Convert.ToInt32(o ["status"]);       
        if (o.ContainsKey("buyCount"))
        {
            buyCount = Convert.ToInt32(o ["buyCount"]);
        }

        if (o.ContainsKey("buyTime"))
        {
            buyTime = (long)Convert.ToInt64(o ["buyTime"]);
        }

        taskType = (TaskMechanism)Convert.ToInt32(o ["taskType"]);

        if (o.ContainsKey("starLevel"))
        {
            starLevel = Convert.ToInt32(o["starLevel"]);
        }
    }

 public TaskStatusChanged(Tenants.TenantId tenantId, BacklogItemId backlogItemId, TaskId taskId, TaskStatus status)
 {
     this.TenantId = tenantId;
     this.BacklogItemId = backlogItemId;
     this.TaskId = taskId;
     this.Status = status;
 }

        public Status AcknowledgeStatusUpdate(TaskStatus status)
        {
            var statusBytes = ProtoBufHelper.Serialize(status);

            using (var pinned = MarshalHelper.CreatePinnedObject(statusBytes))
                return (Status)NativeImports.SchedulerDriver.AcknowledgeStatusUpdate(_nativeDriverPtr, pinned.Ptr);
        }

 internal void InternalRun()
 {
     FCurrent = this;
     try
     {
         this.OnStarted();
         try
         {
             this.FStatus = TaskStatus.Running;
             this.Run();
             this.FStatus = ((this.FInternalState & InternalState.CancellationConfirmed) > 0) ? TaskStatus.Canceled : TaskStatus.RanToCompletion;
         }
         catch (OperationCanceledException)
         {
             this.FStatus = TaskStatus.Canceled;
         }
         catch (System.Exception exception)
         {
             this.FException = exception;
             this.FStatus = TaskStatus.Faulted;
             if (!this.OnError(exception))
             {
                 throw;
             }
         }
         finally
         {
             this.OnFinished();
         }
     }
     finally
     {
         FCurrent = null;
     }
 }

        public Subtask ChangeStatus(Task task, Subtask subtask, TaskStatus newStatus)
        {
            if (subtask == null) throw new Exception("subtask.Task");
            if (task == null) throw new ArgumentNullException("task");
            if (task.Status == TaskStatus.Closed) throw new Exception("task can't be closed");

            if (subtask.Status == newStatus) return subtask;

            ProjectSecurity.DemandEdit(task, subtask);
           
            subtask.Status = newStatus;
            subtask.LastModifiedBy = SecurityContext.CurrentAccount.ID;
            subtask.LastModifiedOn = TenantUtil.DateTimeNow();
            subtask.StatusChangedOn = TenantUtil.DateTimeNow();

            if (subtask.Responsible.Equals(Guid.Empty))
                subtask.Responsible = SecurityContext.CurrentAccount.ID;

            var senders = GetSubscribers(task);

            if (task.Status != TaskStatus.Closed && newStatus == TaskStatus.Closed && !factory.DisableNotifications && senders.Count != 0)
                NotifyClient.Instance.SendAboutSubTaskClosing(senders, task, subtask);

            if (task.Status != TaskStatus.Closed && newStatus == TaskStatus.Open && !factory.DisableNotifications && senders.Count != 0)
                NotifyClient.Instance.SendAboutSubTaskResumed(senders, task, subtask);

            return subtaskDao.Save(subtask);
        }

        public static void ReportStatus(string taskName, TaskStatus status)
        {
            if (_statuses.ContainsKey(taskName))
                throw new ArgumentOutOfRangeException("taskName", taskName, "Already reported status for this task.");

            _statuses.Add(taskName, status);
        }

 public override void OnChildExecuted(int childIndex, TaskStatus childStatus)
 {
     // The child status will be inactive immediately following an abort from OnReevaluationEnded. Ignore that status. 
     if (childStatus != TaskStatus.Inactive) {
         executionStatus = childStatus;
     }
 }

        public ReportTemplateWrapper SaveReportTemplate(string name, string period, int periodItem, int hour, bool autoGenerated, ReportType reportType,
                                         int tag, int project, TaskStatus? status, Guid departament, Guid userId, ReportTimeInterval reportTimeInterval,
                                         ApiDateTime fromDate, ApiDateTime toDate, int viewType, bool noResponsible)
        {
            ProjectSecurity.DemandAuthentication();

            if (name == null || name.Trim().Length == 0) throw new ArgumentNullException("name");

            var filter = new TaskFilter
            {
                TagId = tag,
                DepartmentId = departament,
                UserId = userId,
                TimeInterval = reportTimeInterval,
                FromDate = fromDate,
                ToDate = toDate,
                ViewType = viewType,
                NoResponsible = noResponsible
            };

            if (project != 0)
                filter.ProjectIds.Add(project);

            if (status != null)
                filter.TaskStatuses.Add((TaskStatus)status);

            var template = new ReportTemplate(reportType) { Filter = filter };

            SaveOrUpdateTemplate(template, name, period, periodItem, hour, autoGenerated);

            return new ReportTemplateWrapper(template);
        }

        public void DoInterrupt(TaskStatus status)
        {
            // An interruption has occurred. Update the interrupt status and notify the Behavior Manager. The Behavior Manager will stop all
            // child tasks from running.
            interruptStatus = status;

            BehaviorManager.instance.Interrupt(Owner, this);
        }

 public override void OnChildExecuted(TaskStatus childStatus)
 {
     // Pop the top index from the stack and set the execution status.
     if (childrenExecutionOrder.Count > 0) {
         childrenExecutionOrder.Pop();
     }
     executionStatus = childStatus;
 }

		/// <summary>
		/// 查看节点是否收到的待办/待阅
		/// </summary>
		public static bool ExistsActivityUserTasks(string activityID, TaskStatus taskStatus)
		{
			return UserTaskAdapter.Instance.LoadUserTasks(builder =>
			{
				builder.AppendItem("ACTIVITY_ID", activityID);
				builder.AppendItem("STATUS", (int)taskStatus);
			}).Count > 0;
		}

 public void Close()
 {
     if (_status != TaskStatus.Closed)
     {
         _status = TaskStatus.Closed;
         _aggregateRoot.ApplyEvent(new TaskClosedEvent(_aggregateRoot.Id, _id));
     }
 }