/// <summary>
///
/// </summary>
public virtual IPage <TaskModel> GetTasks(string processInstanceId, string businessKey, string tenantId, Pageable pageable)
{
ITaskQuery query = taskService.CreateTaskQuery();
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;
}
sortApplier.ApplySort(query, pageable);
return(pageRetriever.LoadPage(taskService as ServiceImpl, query, pageable, taskConverter, (q, firstResult, pageSize) =>
{
return new GetProcessInstanceTasksCmd(q, firstResult, pageSize);
}));
}
//----------------------------------------------------------------//
public async Task RunTasks()
{
IDbConnection connection = _serviceProvider.GetRequiredService <IDbConnection>();
connection.Open();
using (connection)
{
try
{
ITaskQuery taskQuery = _queryFactory.CreateQuery <ITaskQuery>(connection);
IEnumerable <TaskInfo> enumeration = taskQuery.GetTaskForRun();
List <Task> tasks = new List <Task>();
foreach (TaskInfo info in enumeration)
{
TaskBase taskBase = MovieTaskFactory.CreateTask(info, _serviceProvider);
tasks.Add(RunTask(taskBase, connection));
}
await Task.WhenAll(tasks);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
/// <summary>
///
/// </summary>
public virtual IPage <TaskModel> GetTasks(TaskQuery query)
{
string userId = authenticationWrapper.AuthenticatedUser.Id;
ITaskQuery taskQuery = taskService.CreateTaskQuery();
if (userId is object)
{
IList <string> groups = null;
if (userGroupLookupProxy != null)
{
groups = userGroupLookupProxy.GetGroupsForCandidateUser(userId);
}
taskQuery = taskQuery.SetTaskCandidateOrAssigned(userId, groups);
}
if (query.ProcessInstanceBusinessKey is object)
{
taskQuery.SetProcessInstanceBusinessKey(query.ProcessInstanceBusinessKey);
}
sortApplier.ApplySort(taskQuery, query.Pageable);
return(pageRetriever.LoadPage <ITask, TaskModel, ITaskQuery>(taskService as ServiceImpl, taskQuery, query.Pageable, taskConverter, (q, firstResult, pageSize) =>
{
return new GetProcessInstanceTasksCmd(q, firstResult, pageSize);
}));
}
public virtual bool TryGetTask(string businessKey, string taskName, string assignee, out ITask task)
{
if (string.IsNullOrWhiteSpace(businessKey) || (string.IsNullOrWhiteSpace(taskName) && string.IsNullOrWhiteSpace(assignee)))
{
task = null;
}
else
{
ITaskQuery query = CreateTaskQuery().SetProcessInstanceBusinessKey(businessKey);
if (string.IsNullOrWhiteSpace(taskName))
{
query.SetTaskInvolvedUser(assignee);
}
else
{
query.SetTaskName(taskName);
}
query.SetIsTaskBusinessKey(true);
task = query.List()
.FirstOrDefault();
}
return(task != null);
}
/// <summary>
///
/// </summary>
public virtual IPage <TaskModel> GetAllTasks(Pageable pageable)
{
ITaskQuery query = taskService.CreateTaskQuery();
sortApplier.ApplySort(query, pageable);
return(pageRetriever.LoadPage(taskService as ServiceImpl, query, pageable, taskConverter, (q, firstResult, pageSize) =>
{
return new GetProcessInstanceTasksCmd(q, firstResult, pageSize);
}));
}
public async Task <IActionResult> GetTaskAsync(int taskId, [FromServices] ITaskQuery query)
{
if ((await _authorizationService.AuthorizeAsync(User, new Entities.Task(), Operations.Read)).Succeeded)
{
TaskResponse response = await query.RunAsync(taskId);
return(response == null
? (IActionResult)NotFound("Task Not Found")
: Ok(response));
}
return(StatusCode(403, "Вы не можете просматривать задачи!"));
}
public virtual IList <ITask> FindTasksAndVariablesByQueryCriteria(ITaskQuery taskQuery)
{
const string query = "selectTaskWithVariablesByQueryCriteria";
TaskQueryImpl taskQueyImpl = taskQuery as TaskQueryImpl;
// paging doesn't work for combining task instances and variables due to
// an outer join, so doing it in-memory
if (taskQueyImpl.FirstResult < 0 || taskQueyImpl.MaxResults <= 0)
{
return(new List <ITask>());
}
int firstResult = taskQueyImpl.FirstResult;
int maxResults = taskQueyImpl.MaxResults;
// setting max results, limit to 20000 results for performance reasons
if (taskQueyImpl.TaskVariablesLimit != null)
{
taskQueyImpl.MaxResults = taskQueyImpl.TaskVariablesLimit.GetValueOrDefault();
}
else
{
taskQueyImpl.MaxResults = ProcessEngineConfiguration.TaskQueryLimit;
}
taskQueyImpl.FirstResult = 0;
IList <ITask> instanceList = DbSqlSession.SelectListWithRawParameterWithoutFilter <TaskEntityImpl, ITask>(query, taskQueyImpl, taskQueyImpl.FirstResult, taskQueyImpl.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 <ITask>());
}
}
else
{
int toIndex = Math.Min(maxResults, instanceList.Count);
return(instanceList.Skip(0).Take(toIndex).ToList());
}
}
return(new List <ITask>());
}
public async Task <IActionResult> GetTaskAsync(int taskId, [FromServices] ITaskQuery query)
{
try
{
TaskResponse response = await query.RunAsync(taskId);
return(Ok(response));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
//return response == null
// ? (IActionResult)NotFound()
// : Ok(response);
}
public virtual object Execute(ICommandContext commandContext)
{
lock (syncRoot)
{
ProcessEngineConfigurationImpl processEngineConfiguration = commandContext.ProcessEngineConfiguration;
Interceptor.ICommandExecutor commandExecutor = processEngineConfiguration.CommandExecutor;
ITaskEntity task = commandExecutor.Execute(new GetTaskByIdCmd(currentTaskId)) as ITaskEntity;
if (task is null)
{
throw new ActivitiObjectNotFoundException(string.Concat("No task found for id '", currentTaskId));
}
string currentExecutionId = task.ExecutionId;
IExecutionEntity execution = task.Execution;
if (execution is null)
{
throw new ActivitiObjectNotFoundException(string.Concat("No execution found for id '", currentExecutionId));
}
var flowElement = ProcessDefinitionUtil.GetFlowElement(execution.ProcessDefinitionId, returnToActivityId);
if (flowElement is null)
{
throw new ActivitiObjectNotFoundException(string.Concat("No execution found for id '", currentExecutionId, "'"));
}
IHistoricActivityInstanceEntity hisInst = processEngineConfiguration.HistoryService.CreateHistoricActivityInstanceQuery()
.SetProcessInstanceId(execution.ProcessInstanceId)
.SetActivityId(returnToActivityId)
.OrderByHistoricActivityInstanceStartTime()
.Desc()
.List()
.FirstOrDefault() as IHistoricActivityInstanceEntity;
IExecutionEntityManager executionEntityManager = commandContext.ExecutionEntityManager;
IExecutionEntity returnToExec = executionEntityManager.CreateChildExecution(execution.ProcessInstance);
returnToExec.CurrentFlowElement = flowElement;
foreach (var key in variables.Keys)
{
returnToExec.SetVariable(key, variables[key]);
}
executionEntityManager.Insert(returnToExec);
commandContext.Agenda.PlanContinueProcessOperation(returnToExec);
IExecutionEntity miRoot = commandExecutor.Execute(new GetMultiInstanceRootExecutionCmd(execution));
List <ITask> tasks = new List <ITask>();
if (miRoot != null)
{
ITaskQuery query = commandContext.ProcessEngineConfiguration.TaskService.CreateTaskQuery();
IEnumerable <IExecutionEntity> childExecutions = commandExecutor.Execute(new GetChildExecutionsCmd(miRoot));
query.SetExecutionIdIn(childExecutions.Select(x => x.Id).ToArray());
tasks.AddRange(query.List());
}
else
{
tasks.Add(task);
}
DeleteTasks(commandContext, commandExecutor, miRoot != null ? miRoot : execution, executionEntityManager, tasks);
return(null);
}
}
public virtual IList <ITask> FindTasksByQueryCriteria(ITaskQuery taskQuery)
{
const string query = "selectTaskByQueryCriteria";
return(DbSqlSession.SelectList <TaskEntityImpl, ITask>(query, taskQuery));
}
public virtual long FindTaskCountByQueryCriteria(ITaskQuery taskQuery)
{
return(DbSqlSession.SelectOne <TaskEntityImpl, long?>("selectTaskCountByQueryCriteria", taskQuery).GetValueOrDefault());
}
public virtual long FindTaskCountByQueryCriteria(ITaskQuery taskQuery)
{
return(taskDataManager.FindTaskCountByQueryCriteria(taskQuery));
}
public virtual IList <ITask> FindTasksAndVariablesByQueryCriteria(ITaskQuery taskQuery)
{
return(taskDataManager.FindTasksAndVariablesByQueryCriteria(taskQuery));
}
public TaskController(ILogger <TaskController> logger, ITaskQuery taskQuery)
{
_logger = logger;
_taskQuery = taskQuery;
}
