/// <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; }