public virtual IPage <TaskModel> GetHistoryTasks(string processInstanceId, string businessKey, bool?finished = null)
        {
            IHistoricTaskInstanceQuery query = historyService.CreateHistoricTaskInstanceQuery();

            query.SetProcessInstanceId(processInstanceId)
            .SetProcessInstanceBusinessKey(businessKey);

            if (finished.GetValueOrDefault(false))
            {
                query.SetFinished();
            }

            var pageable = new Pageable
            {
                PageNo   = 1,
                PageSize = int.MaxValue
            };

            pageable.Sort = new Sort();
            pageable.Sort.Add(new Sort.Order()
            {
                Property  = "startTime",
                Direction = Sort.Direction.ASC
            });
            historicSortApplier.ApplySort(query, pageable);

            return(pageRetriever.LoadPage(historyService as ServiceImpl, query, pageable, historicTaskInstanceConverter, (q, firstResult, pageSize) =>
            {
                return new GetHistoricInstanceTasksCmd(q, firstResult, pageSize);
            }));
        }
        /// <summary>
        /// 获取流程实例历史记录,默认不启用分页,返回当期流程实例下的所有历史任务.
        /// </summary>
        public virtual IPage <TaskModel> GetHistoryTasks(string processInstanceId, string businessKey, string tenantId, Pageable pageable)
        {
            IHistoricTaskInstanceQuery query = historyService.CreateHistoricTaskInstanceQuery();

            if (string.IsNullOrWhiteSpace(processInstanceId) == false)
            {
                query.SetProcessInstanceId(processInstanceId);
            }
            else
            {
                query.SetProcessInstanceBusinessKey(businessKey)
                .SetTaskTenantId(tenantId);
            }

            if (pageable.PageSize == 0)
            {
                pageable.PageNo   = 1;
                pageable.PageSize = int.MaxValue;
            }
            historicSortApplier.ApplySort(query, pageable);

            return(pageRetriever.LoadPage(historyService as ServiceImpl, query, pageable, historicTaskInstanceConverter, (q, firstResult, pageSize) =>
            {
                return new GetHistoricInstanceTasksCmd(q, firstResult, pageSize);
            }));
        }
 public virtual long FindHistoricTaskInstanceCountByQueryCriteria(IHistoricTaskInstanceQuery historicTaskInstanceQuery)
 {
     if (HistoryManager.HistoryEnabled)
     {
         return(historicTaskInstanceDataManager.FindHistoricTaskInstanceCountByQueryCriteria(historicTaskInstanceQuery));
     }
     return(0);
 }
 public virtual IList <IHistoricTaskInstance> FindHistoricTaskInstancesAndVariablesByQueryCriteria(IHistoricTaskInstanceQuery historicTaskInstanceQuery)
 {
     if (HistoryManager.HistoryEnabled)
     {
         return(historicTaskInstanceDataManager.FindHistoricTaskInstancesAndVariablesByQueryCriteria(historicTaskInstanceQuery));
     }
     return(new List <IHistoricTaskInstance>());
 }
Exemple #5
0
        public virtual IList <IHistoricTaskInstance> FindHistoricTaskInstancesAndVariablesByQueryCriteria(IHistoricTaskInstanceQuery historicTaskInstanceQuery)
        {
            var query = historicTaskInstanceQuery as HistoricTaskInstanceQueryImpl;

            // paging doesn't work for combining task instances and variables
            // due to an outer join, so doing it in-memory
            if (query.FirstResult < 0 || query.MaxResults <= 0)
            {
                return(new List <IHistoricTaskInstance>());
            }

            int firstResult = query.FirstResult;
            int maxResults  = query.MaxResults;

            // setting max results, limit to 20000 results for performance reasons
            if (query.TaskVariablesLimit != null)
            {
                query.MaxResults = query.TaskVariablesLimit.GetValueOrDefault();
            }
            else
            {
                query.MaxResults = ProcessEngineConfiguration.HistoricTaskQueryLimit;
            }
            query.FirstResult = 0;

            IList <IHistoricTaskInstance> instanceList = DbSqlSession.SelectListWithRawParameterWithoutFilter <HistoricTaskInstanceEntityImpl, IHistoricTaskInstance>("selectHistoricTaskInstancesWithVariablesByQueryCriteria", historicTaskInstanceQuery, query.FirstResult, query.MaxResults);

            if (instanceList != null && instanceList.Count > 0)
            {
                if (firstResult > 0)
                {
                    if (firstResult <= instanceList.Count)
                    {
                        int toIndex = firstResult + Math.Min(maxResults, instanceList.Count - firstResult);
                        return(instanceList.Skip(firstResult).Take(toIndex).ToList());
                    }
                    else
                    {
                        return(new List <IHistoricTaskInstance>());
                    }
                }
                else
                {
                    int toIndex = Math.Min(maxResults, instanceList.Count);
                    return(instanceList.Skip(0).Take(toIndex).ToList());
                }
            }

            return(instanceList);
        }
Exemple #6
0
 public virtual IList <IHistoricTaskInstance> FindHistoricTaskInstancesByQueryCriteria(IHistoricTaskInstanceQuery historicTaskInstanceQuery)
 {
     return(DbSqlSession.SelectList <HistoricTaskInstanceEntityImpl, IHistoricTaskInstance>("selectHistoricTaskInstancesByQueryCriteria", historicTaskInstanceQuery));
 }
Exemple #7
0
 public virtual long FindHistoricTaskInstanceCountByQueryCriteria(IHistoricTaskInstanceQuery historicTaskInstanceQuery)
 {
     return(DbSqlSession.SelectOne <HistoricTaskInstanceEntityImpl, long?>("selectHistoricTaskInstanceCountByQueryCriteria", historicTaskInstanceQuery).GetValueOrDefault());
 }