public async Task <IActionResult> Post([FromBody] TaskRequest model) { Task newRecord = null; if (ModelState.IsValid) { InitUserCredentials(); newRecord = new Task { Guid = Guid.NewGuid(), UserGuid = UserGuid, CompanyGuid = CompanyGuid, CreationTime = DateTime.UtcNow, CreationUserGuid = UserGuid }; newRecord = _mapper.Map(model, newRecord); try { await _taskService.Save(newRecord); } catch (Exception e) { Log.Error(e.StackTrace); throw; } } return(CreatedAtAction(nameof(Post), _mapper.Map(newRecord, new TaskResponse()))); }
private void MergeTask(Task originalTask, TaskRequest Task) { originalTask.Ticket = this.TicketRepository.GetById(Task.TicketId); originalTask.Status = this.StatusRepository.GetById(Task.StatusId); originalTask.OpenDate = Task.OpenDate; originalTask.Priority = this.PriorityRepository.GetById(Task.PriorityId); originalTask.Creator = this.BacklogUserRepository.GetById(Task.CreatorId); originalTask.Description = Task.Description; if (Task.WorkerId.HasValue) { originalTask.Worker = this.WorkerRepository.GetById(Task.WorkerId.Value); } if (Task.ProviderId.HasValue) { originalTask.Provider = this.ProviderRepository.GetById(Task.ProviderId.Value); } if (Task.ManagerId.HasValue) { originalTask.Manager = this.ManagerRepository.GetById(Task.ManagerId.Value); } if (Task.CloseDate.HasValue) { originalTask.CloseDate = Task.CloseDate.Value; } }
private IAsyncResult BeginAsync(object sender, EventArgs e, AsyncCallback cb, object state) { TaskRequest request = new TaskRequest() { TaskType = TaskTypeEnum.Email, EmailToAddress = this.Email.Text, EmailSubject = this.Subject.Text, EmailMesssage = this.Body.Text }; SqlConnection conn = new SqlConnection(ConnString); SqlCommand cmd = new SqlCommand("[dbo].[SendTaskRequest]", conn); cmd.CommandType = CommandType.StoredProcedure; BinaryFormatter formatter = new BinaryFormatter(); using (MemoryStream stream = new MemoryStream()) { formatter.Serialize(stream, request); stream.Flush(); cmd.Parameters.Add("msg", SqlDbType.VarBinary).Value = stream.ToArray(); } conn.Open(); IAsyncResult ar = cmd.BeginExecuteNonQuery(cb, cmd); return(ar); }
protected override TaskResponse Run(TaskRequest task) { if (string.IsNullOrEmpty(Condition)) { throw new NullReferenceException("This step's Condition field is Empty."); } dynamic data = JsonConvert.DeserializeObject <dynamic>(task.Input); var globals = new Globals { Data = data }; var refs = new List <MetadataReference> { MetadataReference.CreateFromFile(typeof(Microsoft.CSharp.RuntimeBinder.RuntimeBinderException).GetTypeInfo().Assembly.Location), MetadataReference.CreateFromFile(typeof(System.Runtime.CompilerServices.DynamicAttribute).GetTypeInfo().Assembly.Location) }; bool result = CSharpScript.EvaluateAsync <bool>(Condition, options: ScriptOptions.Default.AddReferences(refs), globals: globals).GetAwaiter().GetResult(); TaskResponse response = new TaskResponse { Status = StatusType.Complete, ReleaseValue = result.ToString(), Output = task.Input }; return(response); }
private task TraslateTaskRequestToDbTask(TaskRequest input) { var dbTask = new task(); var user = _commonService.GetCurrentUserContext(); var modelTask = input as TaskRequest; if (modelTask != null) { dbTask.ONBOARDING_DATE = Convert.ToDateTime(modelTask.OnBoardingDate, CultureInfo.InvariantCulture); dbTask.TASK_NAME = modelTask.TaskName; dbTask.COMMENTS = modelTask.Comments; dbTask.DETAILS = modelTask.Description; dbTask.DUE_DATE = Convert.ToDateTime(modelTask.DueDate, CultureInfo.InvariantCulture); dbTask.USER_ID = user.UserId; dbTask.HOURS = modelTask.Hours; dbTask.ID = modelTask.Id; dbTask.PROJECT_NAME = modelTask.ProjectName; dbTask.PROJECT_WBS_Code = modelTask.WBSCode; //dbTask.REQUESTOR_EMAIL_ID = user.EmailId; //dbTask.SKILLS = modelTask.SkillSet; dbTask.STATUS = TaskStatus.Active.ToString(); dbTask.STATUS_DATE = DateTime.Now; dbTask.TASK_TYPE_ID = Convert.ToInt32(modelTask.SelectedTaskType); dbTask.SERVICE_LINE_ID = 1; //Dummy value, to suppress foreign key excption. Need to be removed once schema updated dbTask.OFFERING_ID = Convert.ToInt32(modelTask.SelectedOffering); if (Convert.ToDateTime(modelTask.DueDate) < DateTime.Today) { input.Status = dbTask.STATUS = TaskStatus.Closed.ToString(); } } return(dbTask); }
public IActionResult CreateTask(TasksModel task) { if (ModelState.IsValid) { task.TaskId = Guid.NewGuid().ToString("n"); if (task.AssignedTo != null) { var taskId = task.TaskId; var find = db.Users.Where(c => c.UserId == task.AssignedTo).FirstOrDefault(); TaskRequest model = new TaskRequest(); model.TaskId = taskId; model.UserId = find.UserId; model.RequestDate = DateTime.UtcNow; model.DeadLine = task.DeadLine; model.Status = "Not Confirmed"; model.Description = task.Description; db.TaskRequests.Add(model); db.SaveChanges(); var token = JwtToken.GenerateToken(find.UserId, taskId, find.Email); var confirmationLink = Url.Action("ConfirmTask", "Task", new { Areas = "Administration", userId = find.UserId, token = token }, Request.Scheme); var To = find.Email; mailHelper.Send(To, confirmationLink); } db.Tasks.Add(task); db.SaveChanges(); ViewBag.Message = "Added Succesfully"; return(RedirectToAction(nameof(ListTask))); } ViewBag.Message = "Cannot Process. Try Again"; return(View()); }
public ITaskRequest <TRequest> Create(IServiceBus bus) { var request = new TaskRequest <TRequest>(RequestId, Request, Timeout, TimeoutHandler, CancellationToken.None, bus, Handlers); return(request); }
public async Task <IActionResult> Put(string id, [FromBody] TaskRequest request, [FromServices] IUpdateTaskAsync command) { request.SetId(id); await _executor.ExecuteCommandAsync(command, request); return(Ok()); }
public IActionResult UpdateTask(Guid taskId, [FromBody] TaskRequest task) { if (!ModelState.IsValid) { return(StatusCode(400, "Model is not valid")); } try { var newTask = mapper.Map <TaskDto>(task); newTask.TaskId = taskId; var updated = taskService.UpdateTask(newTask); if (updated) { return(StatusCode(201, "Task was updated")); } else { return(StatusCode(404, "Task not found")); } } catch (Exception ex) { return(StatusCode(500, "Internal server error")); } }
public Response <TaskRequest> RequestWork(WorkerRequest request) { Logger.Info(string.Format("RequestWork Begin {0} {1}", DateTime.Now.Ticks, Thread.CurrentThread)); lock (_object) { var registration = _registry.GetRegistration(request.Token); Assumes.NotNull(registration); WorkItem workItem = _repository.Query <WorkItem>().FirstOrDefault(wi => wi.Status == (WorkItemStatus.Pending)); Task task = null; if (workItem != null) { task = _mappingEngine.Map <Task>(workItem); workItem.AssignTo(registration); _repository.Put(workItem); } var taskRequest = new TaskRequest { NoWorkAvailable = task == null, Task = task }; Logger.Info("RequestWork End " + DateTime.Now.Ticks + " " + Thread.CurrentThread); return(new Response <TaskRequest>(true, "", taskRequest)); } }
public async Task <ActionResult> PutAsync(Guid id, [FromBody] TaskRequest taskRequest) { if (id == null || id == Guid.Empty) { return(new BadRequestResult()); } if (taskRequest == null) { return(new BadRequestResult()); } var foundTask = await _taskService.GetByIdAync(id); if (foundTask == null) { return(new NotFoundObjectResult($" {id} Not Found")); } foundTask.Description = taskRequest.Description; var task = await _taskService.UpdateAsync(foundTask); var responseTask = GetTaskResponse(task); return(new JsonResult(responseTask)); }
public int StartBatch(string[] filenames, string environment, string username) { int batchId = Interlocked.Increment(ref _lastBatchId); List <int> taskIds = new List <int>(filenames.Length); foreach (string filename in filenames) { var taskRequest = new TaskRequest { Environment = environment, Filename = filename, Username = username }; int taskId = _testFileQueue.Add(taskRequest); taskIds.Add(taskId); } // cache batch info only for a limited time... string key = $"{KeyPrefix}{batchId}"; _objectCache.Set(key, taskIds, DateTimeOffset.Now.AddHours(1)); return(batchId); }
public TestFileRunResult RunTestFile(string filename, string environment, string username) { DateTime startTime = DateTime.UtcNow; var taskRequest = new TaskRequest { Environment = environment, Filename = filename, Username = username }; try { // Wait 2 minutes for the tests to run, this can be made configurable later int taskId = Start(taskRequest); TestFileRunnerTaskInfo task = _fileQueue.GetTestFileTaskInfo(taskId); bool completed = task.CurrentTask.Wait(TimeSpan.FromMinutes(2)); TimeSpan timeTaken = DateTime.UtcNow - startTime; return(_testFileResultFactory.Create(task, !completed, timeTaken)); } catch (Exception ex) { TimeSpan timeTaken = DateTime.UtcNow - startTime; // Error return(new TestFileRunResult() { Finished = false, TimeTaken = timeTaken, ErrorMessage = ex.ToString() }); } }
private void Callback(TaskToBeWorked message) { try { _logger.LogDebug("Processing {0} for task {1}", message.StepType, message.TaskId); _dal.UpdateTaskStatus(message.TaskId, StatusType.Processing); TaskRequest request = new TaskRequest { TaskId = message.TaskId, Status = StatusType.Processing, Input = _dal.GetTaskData(message.TaskId) }; TaskResponse response = ExecuteStep(message.StepId, message.StepType, request); if (response.Status == StatusType.Complete) { _dal.ReleaseTask(message.TaskId, response.ReleaseValue, response.Output); } else { _dal.UpdateTaskStatus(message.TaskId, response.Status); } } catch (Exception ex) { _logger.LogError(ex, "Error processing task {0}", message.TaskId); _dal.UpdateTaskStatus(message.TaskId, StatusType.Error); } }
public void AddTaskResponse(string taskId, string requestId, string requestHost) { TaskRequest taskRequest = Repository.QueryEntities <TaskRequest>() .Single(t => t.RequestId == requestId); string requestJson = taskRequest.Content.FromBase64(); var requestForms = requestJson.FromJson <Dictionary <string, string> >(); string responseXml = ""; using (var httpClient = new HttpClient()) { var httpContent = new FormUrlEncodedContent(requestForms); var httpResponse = httpClient.PostAsync(requestHost, httpContent).Result; httpResponse.EnsureSuccessStatusCode(); string responseString = httpResponse.Content.ReadAsStringAsync().Result; responseXml = Uri.UnescapeDataString(responseString); } Repository.AddTaskResponse(requestId, responseXml, null); dynamic response = responseXml.FromXml <dynamic>(); string responseResult = response.PaymentReturn.returnStatus; string stateName = (responseResult == "1003" || responseResult == "1006" || responseResult == "1" || responseResult == "2" || responseResult == "3" || responseResult == "5" || responseResult == "120") ? nameof(TaskStates.Completed) : nameof(TaskStates.Failed); AddTaskState(taskId, stateName); }
public async Task CreateTagAsync_ShouldCreteTagAndReturnTagDto() { // Prepare some project var projectRequest = new ProjectRequest { Name = "Create task project", Color = "#FF00FF" }; var createProjectResult = await _client.CreateProjectAsync(_workspaceId, projectRequest); createProjectResult.IsSuccessful.Should().BeTrue(); var projectId = createProjectResult.Data.Id; var taskRequest = new TaskRequest { Name = "Test task", }; var createResult = await _client.CreateTaskAsync(_workspaceId, projectId, taskRequest); createResult.IsSuccessful.Should().BeTrue(); createResult.Data.Should().NotBeNull(); var findResult = await _client.FindAllTasksAsync(_workspaceId, projectId); findResult.IsSuccessful.Should().BeTrue(); findResult.Data.Should().ContainEquivalentOf(createResult.Data); }
public async Task <TaskModel[]> GetTaskList(TaskRequest task) { string responseString = await CallAsync(GetTaskListServiceName, JsonConvert.SerializeObject(task), MethodTypeEnum.POST, _state.userState.Token); TaskModel[] response = JsonConvert.DeserializeObject <TaskModel[]>(responseString); return(response); }
protected override TaskResponse Run(TaskRequest task) { switch (Method) { case "GET": break; case "POST": break; case "PUT": break; case "PATCH": break; case "DELETE": break; default: break; } TaskResponse result = new TaskResponse { Status = StatusType.Complete, Output = task.Input }; return(result); }
public TaskResult create(TaskRequest taskRequest) { try { if (!verifyUser(taskRequest.connectionId)) return new TaskResult() { code = 0 }; _entity.tasks.Add(new task() { event_id = taskRequest.eventId, user_id = taskRequest.userId, created = DateTime.Now, deadline = taskRequest.deadline, description = taskRequest.description, priority = taskRequest.priority }); _entity.SaveChanges(); return new TaskResult() { code = 1, eventId = taskRequest.eventId, userId = taskRequest.userId, created = DateTime.Now, deadline = taskRequest.deadline, description = taskRequest.description, priority = taskRequest.priority }; } catch (Exception) { return new TaskResult() { code = 0 }; } }
public ActionResult CloseTask(int id) { var task = this.TasksService.GetTask(id); if (task.Status.Description != "closed") { var statusList = this.StatusService.GetAll(); task.Status.Id = statusList.Where(x => x.Description.Equals("closed")).FirstOrDefault().Id; task.CloseDate = DateTime.Now; var ntask = new TaskRequest() { Id = task.Id, OpenDate = task.OpenDate, CreatorId = task.Creator.Id, Description = task.Description, StatusId = task.Status.Id, PriorityId = task.Priority.Id, WorkerId = task.Worker != null ? task.Worker.Id : 0, ProviderId = task.Provider != null ? task.Provider.Id : 0, ManagerId = task.Manager != null ? task.Manager.Id : 0, TicketId = task.Ticket.Id }; this.TasksService.UpdateTask(ntask); } return(Redirect(string.Format("/Backlog/UpdateTicketById/{0}", task.Ticket.Id))); }
public async Task DeleteTaskAsync_ShouldRemoveTask() { // Prepare some project var projectRequest = new ProjectRequest { Name = "Delete task project" + Guid.NewGuid(), Color = "#FF00FF" }; var createProjectResult = await _client.CreateProjectAsync(_workspaceId, projectRequest); createProjectResult.IsSuccessful.Should().BeTrue(); var projectId = createProjectResult.Data.Id; var taskRequest = new TaskRequest { Name = "Test task", }; var createResult = await _client.CreateTaskAsync(_workspaceId, projectId, taskRequest); createResult.IsSuccessful.Should().BeTrue(); createResult.Data.Should().NotBeNull(); var findResult = await _client.FindAllTasksAsync(_workspaceId, projectId); findResult.IsSuccessful.Should().BeTrue(); findResult.Data.Should().ContainEquivalentOf(createResult.Data); var deleteResult = await _client.DeleteTaskAsync(_workspaceId, projectId, createResult.Data.Id); deleteResult.IsSuccessful.Should().BeTrue(); var findResult2 = await _client.FindAllTasksAsync(_workspaceId, projectId); findResult2.IsSuccessful.Should().BeTrue(); findResult2.Data.Should().BeEmpty(); }
public object Any(TaskRequest request) { DTOResponseLayUI dtoResponseLayUi = new DTOResponseLayUI(); TaskService taskService = new TaskService(); DTOResponse response; if (request.ACTION == 100) { response = taskService.GetTaskList(request); } else if (request.ACTION == 1001) { response = taskService.GetTaskStepList(request); } else if (request.ACTION == 101) { response = taskService.TaskOprationByMen(request); } else { dtoResponseLayUi.code = -1; dtoResponseLayUi.msg = "未定义的操作类型:" + request.ACTION.ToString(); return(dtoResponseLayUi); } return(this.ConvertTo(response)); }
public IActionResult GetTaskList(TaskRequest taskRequest) { using (TeamsDbEntities entities = new TeamsDbEntities()) { List <Data.Task> taskEntity = entities.Tasks.Where(x => taskRequest.UserID.Contains(x.UserID.Value) && x.IsDelete == false && taskRequest.TeamID == x.TeamID).ToList(); List <TaskModel> taskList = new List <TaskModel>(); foreach (var task in taskEntity) { TaskModel tempTask = new TaskModel { Header = task.Header, Detail = task.Detail, UserID = task.UserID.Value, Progress = (ProgressTypeEnum)Enum.ToObject(typeof(ProgressTypeEnum), task.Progress), CreateByModel = new UserModel { Email = task.User1.Email, FirstName = task.User1.FirstName, LastName = task.User1.LastName, ID = task.CreateBy.Value }, CreateBy = task.CreateBy.Value, CreateDate = task.CreateDate.Value, StartDate = task.StartDate.Value, EndDate = task.EndDate.Value, ID = task.ID }; tempTask.TaskLogs = new List <TaskLogModel>(); foreach (var tLog in task.TaskLogs) { tempTask.TaskLogs.Add(new TaskLogModel { ID = tLog.ID, ModifyBy = tLog.ModifyBy, UserID = tLog.UserID, ModifyByModel = new UserModel { Email = tLog.User.Email, FirstName = tLog.User.FirstName, LastName = tLog.User.LastName, ID = tLog.User.ID }, UserModel = new UserModel { Email = tLog.User1.Email, FirstName = tLog.User1.FirstName, LastName = tLog.User1.LastName, ID = tLog.User1.ID }, ModifyDate = tLog.ModifyDate, Progress = (ProgressTypeEnum)Enum.ToObject(typeof(ProgressTypeEnum), tLog.ProgressID), TaskID = tLog.TaskID }); } taskList.Add(tempTask); } return(Ok(taskList.ToArray())); } }
public void Query() { var request = new TaskRequest(); if (this.State != TaskStates.All) { request.State = State; } request.CommandTypeName = this.CommandType; var query = this.TaskService.Query(request); // fill condition List = query.ToList(this, x => new ListTask(x)); // commandName, descripton object foreach (var task in List) { var type = Type.GetType(task.InnerObject.CommandTypeName, false, true); if (type != null) { var desc = ViewModelDescriptor.GetTypeDescriptor(type); task.CommandName = desc.Name; } } // users var userids = List.Select(x => x.InnerObject.CreatorId).Union(List.Select(x => x.InnerObject.EditorId)).ToArray(); var users = MembershipService.GetByIds(userids).ToList(); foreach (var task in List) { var user = users.FirstOrDefault(x => x.UserId == task.InnerObject.CreatorId); if (user != null) { task.CreatorUserName = user.DisplayName; } user = users.FirstOrDefault(x => x.UserId == task.InnerObject.EditorId); if (user != null) { task.EditorUserName = user.DisplayName; } } var accountIds = List.Select(x => x.InnerObject.AccountId).ToArray(); var accounts = AccountService.GetByIds(accountIds); foreach (var task in List) { var account = accounts.FirstOrDefault(x => x.AccountId == task.InnerObject.AccountId); if (account != null) { task.AccountName = account.Name; } } }
public void TaskCancelReq_Read() { string filepath = TestCommon.TestHelper.TestFileFolder + @"\TaskCancelRequest.xml"; var testObject = new TaskRequest(ReadFile(filepath)); Assert.AreEqual("mytask", testObject.TaskId); Assert.AreEqual(TaskOperationType.Cancel, testObject.Operation); }
// PUT api/<controller>/5 /// <summary> /// Modifica un Task /// </summary> /// <param name="Task">Task a modificar</param> /// <returns></returns> public IHttpActionResult Put(int id, TaskRequest Task) { var originalTask = TaskService.GetById(id); var ret = TaskService.UpdateTask(originalTask, Task); return(Ok()); }
/// <summary> /// Wraps call to ResolveAsync in a request /// </summary> virtual public Request <ResolveResultDTO <DataType> > Resolve( Action <Request <ResolveResultDTO <DataType> > > callback = null) { var r = new TaskRequest <ResolveResultDTO <DataType> >(ResolveAsync()); r.Execute(callback); return(r); }
private void TaskUpdateReq_Create_Assert(TaskRequest testObjectIn) { Assert.AreEqual(1, testObjectIn.Parameters.ItemNames.Count); Assert.IsTrue(testObjectIn.Parameters.ItemNames.Contains("myparam")); Assert.AreEqual("myprocedure", testObjectIn.ProcedureId); Assert.AreEqual("mytask", testObjectIn.TaskId); Assert.AreEqual(TaskOperationType.Update, testObjectIn.Operation); }
public async Task <IHttpActionResult> Post(TaskRequest request) { Log.Info($"Received task {request.TaskJson}"); IHttpActionResult result = await HandleTask(request); Log.Info("Done"); return(result); }
public IHttpActionResult Complete(TaskRequest model) { _taskBusiness.Complete(model); var tasks = _taskBusiness.GetAllTasks(); return(Ok(tasks)); }
public IHttpActionResult Post(TaskRequest Task) { var result = TaskService.CreateTask(Task); return(Created <Entidad>("", new Entidad { Id = result.Id })); }
private static bool RecoursiveCheckGraph(TaskRequest root, ImmutableList<Guid> previousTasks) { if (previousTasks.Contains(root.Id)) return false; foreach (var task in root.Dependencies) { if (previousTasks.Contains(task.Id)) return false; if (!RecoursiveCheckGraph(task, previousTasks.Add(root.Id))) return false; } return true; }
public TaskActionResult Execute(TaskRequest taskRequest) { var taskType = this.GetType(); var actionMethods = taskType.GetMethods().Where(m => m.Name == taskRequest.ActionName); var actionMethod = actionMethods.SingleOrDefault(m => m.GetParameters().All(p => taskRequest.ContentData.ContainsKey(p.Name))); if (actionMethod == null) { throw new Exception(string.Format("No action named {0} on {1} has the correct parameters", taskRequest.ActionName, taskRequest.TaskName)); } try { var parameters = actionMethod.GetParameters().Select(p => taskRequest.ContentData[p.Name]).Cast<object>().ToArray(); return actionMethod.Invoke(this, parameters) as TaskActionResult; } catch (Exception ex) { return new ErrorResult(ex); } }
public override void Execute(TaskRequest taskRequest, TaskContext context) { context.Storage.ActionResult(taskRequest.Id, m_Result); }
public abstract void Execute(TaskRequest taskRequest,TaskContext context);
public override void Execute(TaskRequest taskRequest, TaskContext context) { context.Storage.ActionError(taskRequest.Id, Exception); }
public IEnumerable<TaskRequest> GetTasks(int id, int userId, int count = 1, TaskRequest.Filter filter = TaskRequest.Filter.Remaining, TaskRequest.Type type = TaskRequest.Type.Both) { // GET: api/Study/4/Task?userId=5&count=1&filter=Remaining&type=Review throw new NotImplementedException(); }
public IEnumerable<int> GetTaskIDs(int id, int userId, TaskRequest.Filter filter = TaskRequest.Filter.Editable, TaskRequest.Type type = TaskRequest.Type.Both) { // GET: api/Study/4/TaskIDs?userId=5&filter=Editable throw new NotImplementedException(); }