public RowControl(ClientToolsReference.Task task) : this() { TaskHistory taskHistory = new TaskHistory(task); SetHistory(taskHistory); lblId.Content = Id.ToString(); }
public async Task <TaskPageDTO> FinishTask(int taskId) { var task = await taskRepo.FindByIdAsync(taskId); TaskHistory history = new TaskHistory(); task.UpdatedById = task.ExecutorId; task.DateUpdated = DateTime.Now; history.DateUpdated = DateTime.Now; history.UpdatedByUser = task.Executor; history.StartTaskStatus = await statusRepo.FindByIdAsync((int)task.TaskStatusId); var status = (await statusRepo.GetWithIncludeAsync(s => s.Type == "Ready for verification")) .FirstOrDefault(); task.TaskStatusId = status.Id; history.FinalTaskStatus = status; await taskRepo.UpdateAsync(task); await historyRepo.CreateAsync(history); return(mapper.Map <FreelanceLand.Models.Task, TaskPageDTO>(task)); }
public RowControl(TaskHistory taskHistory) : this() { SetHistory(taskHistory); lblId.Content = Id.ToString(); lblTime.Content = taskControl.historyControl.GetFormatedTimeStamp(taskControl.historyControl.TotalTime); TimerType = taskHistory.TimerType; }
public async Task <ExcecutorDTO> AddExcecutor(ExcecutorDTO user) { var task = await taskRepo.FindByIdAsync(user.TaskId); TaskHistory history = new TaskHistory(); history.DateUpdated = DateTime.Now; history.UpdatedByUser = task.Customer; history.StartTaskStatus = await statusRepo.FindByIdAsync((int)task.TaskStatusId); task.ExecutorId = user.ExcecutorId; task.UpdatedById = task.CustomerId; task.DateUpdated = DateTime.Now; var status = (await statusRepo.GetWithIncludeAsync(s => s.Type == "In progress")).FirstOrDefault(); task.TaskStatusId = status.Id; history.FinalTaskStatus = await statusRepo.FindByIdAsync(status.Id); await taskRepo.UpdateAsync(task); await historyRepo.CreateAsync(history); return(user); }
public ActionResult UpdateHistory([Bind(Include = "id, note, state")] TaskHistory model) { try { string user_id = User.Identity.GetUserId(); TaskHistory history = db.task_history.Where(qu => qu.id == model.id).FirstOrDefault(); if (history == null) { return(new HttpStatusCodeResult(404, "Not Found History")); } Tasks task = db.tasks.Where(qu => qu.id == history.task_id).FirstOrDefault(); if (!User.IsInRole("Admin") && task.user_id != user_id) { return(new HttpStatusCodeResult(403, "Forbidden!")); } history.note = model.note; history.state = model.state; setLastHistory(task.id); db.SaveChanges(); return(new HttpStatusCodeResult(200)); } catch (Exception exs) { return(new HttpStatusCodeResult(500, exs.Message.ToString())); } }
public void Execute_Creates_History_Record() { // Setup InitializeTestEntities(); // Act DateTime start = DateTime.Now; new EditTaskCommand(_serviceFactory.Object).Execute(new EditTaskCommandParams { TaskId = _task.Id, Name = "Name", TaskDate = _changedDate, Completed = true, ContactId = _contact.Id, Category = "Category", RequestingUserId = _user.Id }); DateTime end = DateTime.Now; // Verify Task task = _unitOfWork.Tasks.Fetch().Single(); TaskHistory history = task.History.Single(); Assert.AreEqual("Name", history.Name, "The history record's name was incorrect"); Assert.AreEqual(_changedDate, history.TaskDate, "The history record's date value was incorrect"); Assert.AreEqual(_task.CompletionDate, history.CompletionDate, "The history record's completion date value was incorrect"); Assert.AreEqual(_user, history.AuthoringUser, "The history record's author was incorrect"); Assert.AreEqual(_contact, history.Contact, "The history record had an incorrect contact"); Assert.AreEqual("Category", history.Category, "The history record's category value was incorrect"); Assert.AreEqual(MJLConstants.HistoryUpdate, history.HistoryAction, "The history record's action value was incorrect"); Assert.IsTrue(history.DateModified >= start && history.DateModified <= end, "The history record's modification date was incorrect"); }
private void AddFreeTimerRow(TaskHistory th) { RowControl rowControl = new RowControl(th); rowControl.AddListener(this); FreeTimers.Children.Add(rowControl); }
private void ControlTasks(int projectID) { if (db.TaskHistories.Where(t => t.ID_Project == projectID).Count() == 0) { TaskHistory taskHistory = new TaskHistory(); taskHistory.CreateCount = 0; taskHistory.FinishCount = 0; taskHistory.ProgressCount = 0; taskHistory.ID_Project = projectID; if (db.Projects.Find(projectID).DateCreated.HasValue) { taskHistory.Date = db.Projects.Find(projectID).DateCreated.Value; } else { taskHistory.Date = DateTime.Now; } try { db.TaskHistories.Add(taskHistory); db.SaveChanges(); }catch (Exception ex) { Console.WriteLine(ex.Message); } } }
public ActionResult AddHistory([Bind(Include = "note, added, task_id, state")] TaskHistory model) { try { string user_id = User.Identity.GetUserId(); Tasks task = db.tasks.Where(qu => qu.id == model.task_id && qu.user_id == user_id).FirstOrDefault(); if (task == null) { return(new HttpStatusCodeResult(500, "Not permit to customer")); } TaskHistory q = new TaskHistory { note = model.note, added = DateTime.Now, state = model.state, task_id = model.task_id }; db.task_history.Add(q); task.order_state = model.state; task.contact_date = DateTime.Now; db.SaveChanges(); setLastHistory(task.id); return(new HttpStatusCodeResult(200)); } catch (Exception exs) { return(new HttpStatusCodeResult(500, exs.Message.ToString())); } }
public ActionResult DeleteHistory(int?id) { string user_id = User.Identity.GetUserId(); try { TaskHistory s = db.task_history.Where(src => src.id == id).FirstOrDefault(); Tasks task = db.tasks.Where(f => f.id == s.task_id).FirstOrDefault(); if (!User.IsInRole("Admin") && task.user_id != user_id) { return(new HttpStatusCodeResult(403, "Forbidden!")); } if (s == null) { return(new HttpStatusCodeResult(404)); } db.task_history.Remove(s); db.SaveChanges(); setLastHistory(task.id); return(new HttpStatusCodeResult(200)); } catch (Exception ex) { return(new HttpStatusCodeResult(500)); throw; } }
public async Task <bool> Delete(TaskHistory taskHistory) { _dbContext.Set <TaskHistory>().Remove(taskHistory); var res = await _dbContext.SaveChangesAsync(); return(res > 0); }
public async Task <TaskHistory> Update(TaskHistory taskHistory) { _dbContext.Entry(taskHistory).State = EntityState.Modified; await _dbContext.SaveChangesAsync(); return(taskHistory); }
public ActionResult AJAXCreate([Bind(Include = "TaskID,Title")] TaskItem taskItem) { if (ModelState.IsValid) { string userID = User.Identity.GetUserId(); var currentUser = db.Users.FirstOrDefault(i => i.Id == userID); taskItem.User = currentUser; taskItem.TaskID = Guid.NewGuid(); taskItem.Completed = false; TaskHistory hist = new TaskHistory { HistID = Guid.NewGuid(), TaskID = taskItem.TaskID, TimeStamp = DateTime.Now, TaskItem = taskItem, Description = "Created" }; db.History.Add(hist); db.TaskList.Add(taskItem); db.SaveChanges(); } return(PartialView("_TasksView", GetTaskItems())); }
public ActionResult Create([Bind(Include = "TaskID,Title,Completed")] TaskItem taskItem) { if (ModelState.IsValid) { string userID = User.Identity.GetUserId(); var currentUser = db.Users.FirstOrDefault(id => id.Id == userID); taskItem.User = currentUser; if (currentUser == null) { return(HttpNotFound()); } taskItem.TaskID = Guid.NewGuid(); db.TaskList.Add(taskItem); TaskHistory hist = new TaskHistory { TaskID = taskItem.TaskID, TimeStamp = DateTime.Now, Description = "Created" }; db.History.Add(hist); db.SaveChanges(); return(RedirectToAction("Index")); } return(View(taskItem)); }
public ActionResult AJAXEdit(Guid?id, bool value) { if (id == null) { return(new HttpStatusCodeResult(HttpStatusCode.BadRequest)); } TaskItem taskItem = db.TaskList.Find(id); if (taskItem == null) { return(HttpNotFound()); } taskItem.Completed = value; db.Entry(taskItem).State = EntityState.Modified; TaskHistory hist = new TaskHistory { HistID = Guid.NewGuid(), TaskID = taskItem.TaskID, TimeStamp = DateTime.Now, TaskItem = taskItem, Description = "Task modified" }; db.History.Add(hist); db.SaveChanges(); return(PartialView("_TasksView", GetTaskItems())); }
public async Task <TaskHistoryResponseModel> UpdateTaskHistoryById(int id, TaskHistoryRequestModel taskHistoryRequestModel) { var taskHistory = new TaskHistory() { TaskId = id, UserId = taskHistoryRequestModel.UserId, Title = taskHistoryRequestModel.Title, Description = taskHistoryRequestModel.Description, DueDate = taskHistoryRequestModel.DueDate, Completed = taskHistoryRequestModel.Completed, Remarks = taskHistoryRequestModel.Remarks, }; var createdTaskHistory = await _taskHistoryRepository.UpdateAsync(taskHistory); var taskHistoryResponse = new TaskHistoryResponseModel() { TaskId = createdTaskHistory.TaskId, UserId = createdTaskHistory.UserId, Title = createdTaskHistory.Title, Description = createdTaskHistory.Description, DueDate = createdTaskHistory.DueDate, Completed = createdTaskHistory.Completed, Remarks = createdTaskHistory.Remarks, }; return(taskHistoryResponse); }
public object GetAll(int taskId) { try { Logger.LogInfo("Get: Task history process start"); IList <TaskHistory> taskHistories = new List <TaskHistory>(); DataTable dtAppConfig = DataBase.DBService.ExecuteCommand( string.Format(SELECT_TASK_HISTORY, taskId)); foreach (DataRow dr in dtAppConfig.Rows) { TaskHistory task = convertToTaskHistory(dr); taskHistories.Add(task); } Logger.LogInfo("Get: Task history process completed."); return(taskHistories); } catch (Exception ex) { StackTrace st = new StackTrace(); StackFrame sf = st.GetFrame(0); MethodBase currentMethodName = sf.GetMethod(); LogDebug(currentMethodName.Name, ex); return(null); } }
public async Task UpdateBook_StateUnderTest_ExpectedBehavior() { // Arrange MessageInfo messageInfo = new MessageInfo() { ActionType = "PUT", BookDto = _fixture.Build <BookDto>() .Create() }; Book newBook = new Book() { Id = messageInfo.BookDto.Id, AuthorId = Guid.NewGuid(), Date = DateTime.Now, Description = "", TaskId = messageInfo.BookDto.TaskId, Title = "" }; mockMapper.Setup(x => x.Map <Book>(messageInfo.BookDto)).Returns(newBook); mockGenericRepository.Setup(x => x.Get(messageInfo.BookDto.Id)).ReturnsAsync(newBook); mockGenericRepository.Setup(x => x.Update(newBook)).Returns(true); TaskDto taskDto = new TaskDto() { Id = messageInfo.BookDto.TaskId, CreatedDate = DateTime.Now, Finish = "", Requested = "", StatusId = 1, UpdatedDate = DateTime.Now }; TaskHistory task = new TaskHistory() { Id = taskDto.Id, CreatedDate = DateTime.Now, Finish = "", Requested = "", StatusId = 1, UpdatedDate = DateTime.Now, }; mockTaskService.Setup(x => x.GetTask(messageInfo.BookDto.TaskId)).ReturnsAsync(taskDto); mockMapper.Setup(x => x.Map <TaskHistory>(taskDto)).Returns(task); mockTaskService.Setup(x => x.UpdateTask(task)).ReturnsAsync(true); mockUnitOfWork.Setup(x => x.CommitAsync()).Returns(Task.CompletedTask); var service = this.CreateService(); // Act var result = await service.SaveBook( messageInfo); // Assert Assert.True(result); this.mockRepository.VerifyAll(); }
public void Delete(int id) { using (UnitOfWork uow = new UnitOfWork()) { TaskHistory entity = uow.GetRepository <TaskHistory>().GetById(id); uow.GetRepository <TaskHistory>().Delete(entity); } }
public async Task <TaskHistory> Create(TaskHistory obj) { await _dbContext.AddAsync(obj); await _dbContext.SaveChangesAsync(); return(obj); }
// Default contructor that set entity to field public TaskHistoryModel(TaskHistory taskhistory) { this._task_history = taskhistory; this._id = taskhistory.Id; this._user_id = taskhistory.UserId; this._created_date = taskhistory.CreatedDate; this._task_id = taskhistory.TaskId; this._content = taskhistory.Content; this._originalTaskHistory = taskhistory.DeepClone(); }
public async Task <bool> SaveBook(MessageInfo messageInfo) { try { //save book BookDto bookDto = messageInfo.BookDto; Book newBook = _mapper.Map <Book>(bookDto); Book book = await _repository.Get(newBook.Id); if (book == null) { await _repository.Insert(newBook); } else { book.Title = newBook.Title; book.Description = newBook.Description; _repository.Update(book); } //save history var taskDto = await _taskService.GetTask(messageInfo.BookDto.TaskId); TaskHistory taskHistory = _mapper.Map <TaskHistory>(taskDto); string finish = DateTime.Now.ToString("yyyyMMddHHmmss"); if (taskHistory == null) { taskHistory = new TaskHistory { Id = messageInfo.BookDto.Id, Requested = messageInfo.BookDto.Date.ToString("yyyyMMddHHmmssff"), Finish = finish, StatusId = 1 }; await _taskService.InsertTask(taskHistory); } else { taskHistory.Finish = finish; await _taskService.UpdateTask(taskHistory); } await _unitOfWork.CommitAsync(); _logger.LogInformation("Saved a book successfully"); return(await Task.FromResult(true)); } catch (Exception ex) { _logger.LogError(string.Format("Saved a book fail \n {0}", ex.Message)); return(await Task.FromResult(false)); } }
//phase d'initialisation //initialiser MissionHistory pour la premiere foi (pa d'historique) avec les tache charger par le moteur de scénario public static TaskHistory getLoadedTaskHistory(int iD, Task task) { TaskHistory th = new TaskHistory(); th.id = iD; th.name = task.getName(); th.label = task.getLabel(); th.scene = task.getScene(); th.status = task.getStatut(); return(th); }
/// <summary> /// Load history detail /// </summary> /// <param name="historyId"></param> /// <returns></returns> public async Task <ResultModel <TaskHistoryModel> > LoadHistoryDetail(int historyId) { ResultModel <TaskHistoryModel> result = new ResultModel <TaskHistoryModel>(); TaskHistory data = await UnitOfWork.TaskHistoryRepository.Entity .Include(c => c.Task).AsNoTracking() .FirstOrDefaultAsync(c => c.Id == historyId); result.Data = data.ToModel(); return(result); }
public Task <bool> UpdateTask(TaskHistory taskHistory) { bool success = false; try { success = _repository.Update(taskHistory); } catch (Exception) { } return(Task.FromResult(success)); }
public static TaskHistory GenerateDiff(string action, string updatedField, string newVal, string origVal, int updateUser, int taskID) { var obj = new TaskHistory(); obj.TaskID = taskID; obj.UpdatedDateTime = DateTime.Now; obj.UpdatedUser = updateUser; obj.Action = action; obj.UpdatedField = (compareFieldTitle.ContainsKey(updatedField) ? compareFieldTitle[updatedField] : updatedField); obj.NewValue = newVal; obj.OriginalValue = origVal; return(obj); }
public async Task AddBook_StateUnderTest_ExpectedBehavior() { MessageInfo messageInfo = new MessageInfo() { ActionType = "POST", BookDto = _fixture.Create <BookDto>() }; Book newBook = new Book() { Id = messageInfo.BookDto.Id, AuthorId = messageInfo.BookDto.AuthorId, Date = messageInfo.BookDto.Date, Description = messageInfo.BookDto.Description, Title = messageInfo.BookDto.Title, TaskId = messageInfo.BookDto.TaskId }; mockMapper.Setup(m => m.Map <Book>(messageInfo.BookDto)).Returns(newBook); Book book = null; mockGenericRepository.Setup(x => x.Get(messageInfo.BookDto.Id)).ReturnsAsync(book); mockGenericRepository.Setup(x => x.Insert(newBook)).ReturnsAsync(true); // TaskHistory taskHistory = null;// new TaskHistory(); //TaskDto taskDto = new TaskDto() //{ // Id = messageInfo.BookDto.TaskId, // CreatedDate = DateTime.Now, // Finish = "", // Requested = "", // StatusId = 1, // UpdatedDate = DateTime.Now //}; TaskHistory task = null; TaskDto taskDto = null; mockTaskService.Setup(x => x.GetTask(messageInfo.BookDto.TaskId)).ReturnsAsync(taskDto); mockMapper.Setup(x => x.Map <TaskHistory>(taskDto)).Returns(task); mockTaskService.Setup(x => x.InsertTask(It.IsAny <TaskHistory>())).ReturnsAsync(true);//It.IsAny<TaskHistory>()) mockUnitOfWork.Setup(x => x.CommitAsync()).Returns(Task.CompletedTask); var service = this.CreateService(); // Act var result = await service.SaveBook( messageInfo); // Assert Assert.True(result); this.mockRepository.VerifyAll(); }
private TaskHistory convertToTaskHistory(DataRow dr) { TaskHistory taskHistory = new TaskHistory(); taskHistory.Id = dr.Field <int>("ID"); taskHistory.TaskId = dr.Field <int>("TaskId"); taskHistory.FieldName = dr.Field <string>("FieldName"); taskHistory.OldValue = dr.Field <string>("OldValue"); taskHistory.NewValue = dr.Field <string>("NewValue"); taskHistory.Username = dr.Field <string>("UserName"); taskHistory.UpdatedBy = dr.Field <int>("UpdatedBy"); taskHistory.UpdatedOn = dr.Field <DateTime>("UpdatedOn"); return(taskHistory); }
private void AddFreeTimerRow(int id) { TaskHistory th = new TaskHistory(); th.ExpectedTime = 10000000; th.Id = id; th.Summary = freeTimerPopup.tbTaskName.Text; RowControl rowControl = new RowControl(th); rowControl.TimerType = TimerType.Free; rowControl.AddListener(this); FreeTimers.Children.Add(rowControl); }
public async Task <bool> InsertTask(TaskHistory taskHistory) { bool success; try { success = await _repository.Insert(taskHistory); } catch (Exception) { success = false; } return(await Task.FromResult(success)); }