public ActionResult <UserTaskViewModel> PostTask(UserTaskViewModel taskViewModel)
{
// Exclude property from binding.
taskViewModel.Id = 0;
if (!ModelState.IsValid)
{
var errorMessages = ModelState.Values
.SelectMany(modelStateEntry => modelStateEntry.Errors.Select(b => b.ErrorMessage)).ToList();
return(BadRequest(errorMessages));
}
var user = userService.GetUserByLogin(taskViewModel.OwnerLogin);
if (user == null)
{
return(BadRequest(new List <string>()
{
$"User with Login = {taskViewModel.OwnerLogin} not found"
}));
}
var task = mapper.Map <UserTask>(taskViewModel);
task.Owner = user;
taskService.Save(task);
taskViewModel = mapper.Map <UserTaskViewModel>(task);
return(CreatedAtAction("GetTask", new { id = taskViewModel.Id }, taskViewModel));
}
public async Task <ActionResult> AssignUserTask([FromBody] UserTaskViewModel userTaskView)
{
Console.WriteLine(userTaskView.IsBpmEngine);
if (!userTaskView.IsBpmEngine)
{
userTaskView.InvokerId = ((ClaimsIdentity)HttpContext.User.Identity).FindFirst(ClaimTypes.NameIdentifier).Value;
}
string roleId = await _management.getRoleIdAsync(userTaskView.RoleName);
if (roleId != null)
{
Console.WriteLine(roleId);
var userTask = new UserTask
{
ApplicationRoleId = roleId,
UserTaskParameters = userTaskView.UserTaskParameters,
Title = userTaskView.Title,
InvokerID = userTaskView.InvokerId,
IsBpmEngine = userTaskView.IsBpmEngine
};
await _userTaskRepository.AssigneUserTask(userTask);
return(Ok());
}
return(BadRequest("this Role Does not exist"));
}
public ActionResult Create(TaskViewModel task)
{
try
{
if (ModelState.IsValid)
{
var taskDTO = _mapper.Map <TaskViewModel, TaskDTO>(task);
_taskService.SaveTask(taskDTO);
task.TaskId = _taskService.GetLastTaskId();
foreach (var item in task.SelectedUsers)
{
var userTask = new UserTaskViewModel
{
UserId = Convert.ToInt32(item),
TaskId = task.TaskId,
TaskName = task.Name,
StartDate = task.StartDate,
DeadlineDate = task.DeadLineDate,
State = TaskStates.Active.ToString()
};
var userTaskDTO = _mapper.Map <UserTaskViewModel, UserTaskDTO>(userTask);
_vUserTaskService.SaveTaskForUser(userTaskDTO);
}
return(RedirectToAction("Index"));
}
}
catch (RetryLimitExceededException /* dex */)
{
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
}
return(View(task));
}
// GET: UserTasks/Edit/5
public IActionResult Edit(int?id)
{
UserProfile user = UserProfile.GetUsers(_context).Find(x => x.Mail.ToLower() == User.Identity.Name.ToLower());
if (id == null)
{
return(HttpNotFound());
}
UserTask userTask = _context.UserTask.FirstOrDefault(m => m.TaskId == id);
if (userTask == null || userTask.UserId != user.UserId)
{
return(RedirectToAction("Index"));
}
UserTaskViewModel utvm = new UserTaskViewModel(_context, userTask);
utvm.DateStart = userTask.DateStart;
if (utvm.DateStart != null)
{
DateTime dateValueStart = DateTime.Parse(userTask.DateStart.ToString());
utvm.DateStartStr = dateValueStart.ToString("s");
}
utvm.DateEnd = userTask.DateEnd;
if (utvm.DateEnd != null)
{
DateTime dateValueEnd = DateTime.Parse(userTask.DateEnd.ToString());
utvm.DateEndStr = dateValueEnd.ToString("s");
}
utvm.Period = "0 0 * * 1";
return(View("Edit", utvm));
}
public IHttpActionResult CreateNewQuickUserTask(UserTaskViewModel userTaskViewModel)
{
var userId = User.Identity.GetUserId <int>();
userTaskViewModel.Title = userTaskViewModel.Title.Trim();
userTaskViewModel.StatusId = Convert.ToInt32(UserTaskStatus.Create);
var _CRUDResult = new CRUDResult();
var result = new ResponseResult();
IUserTaskManager _userTaskManager = new UserTaskManager();
if (!_userTaskManager.CheckExistsWithSameTitle(userId, userTaskViewModel.Title))
{
var _userTask = userTaskViewModel.MapToEntity();
_userTask.CreateDate = DateTime.Now;
_userTask.CreateByUserId = userId;
_userTaskManager.Save(_userTask);
}
else
{
_CRUDResult.Result = OperationResult.Failed;
_CRUDResult.Validations.Add(new ValidationResult()
{
Key = "",
Message = "Title already in use..."
});
}
result.Result = _CRUDResult;
return(Ok(result));
}
public IActionResult TaskMoveNonTime(int id)
{
UserTaskViewModel cvm = new UserTaskViewModel();
cvm.TaskId = id;
return(View("TaskMoveNonTime", cvm));
}
public IHttpActionResult AddTask([FromBody] TaskViewModel task)
{
if (ModelState.IsValid)
{
var taskDTO = Mapper.Map <TaskViewModel, TaskDTO>(task);
_taskService.SaveTask(taskDTO);
task.TaskId = _taskService.GetLastTaskId();
//why do we need to do it?
foreach (var item in task.SelectedUsers)
{
var userTask = new UserTaskViewModel
{
UserId = Convert.ToInt32(item),
TaskId = task.TaskId,
TaskName = task.Name,
StartDate = task.StartDate,
DeadlineDate = task.DeadLineDate,
State = "Active"
};
var userTaskDTO = Mapper.Map <UserTaskViewModel, UserTaskDTO>(userTask);
_vUserTaskService.SaveTaskForUser(userTaskDTO);
}
return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, "Task has been successfully created!")));
}
return(ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Something went wrong! Please try again.")));
}
public IActionResult Edit(UserTaskViewModel userTaskViewModel)
{
var userTask = mapper.Map <UserTask>(userTaskViewModel);
userTaskRepository.Save(userTask);
return(RedirectToAction(nameof(Index)));
}
public IActionResult Create(UserTask userTask)
{
ModelValidationState entry = ModelState.GetFieldValidationState("Duration");
if (entry == ModelValidationState.Invalid)
{
ModelStateEntry durationEntry = ModelState["Duration"];
userTask.Duration = Helper.ConvertDurationToInt32(durationEntry.RawValue.ToString());
ModelState["Duration"].RawValue = userTask.Duration;
ModelState["Duration"].ValidationState = ModelValidationState.Valid;
}
UserProfile user = UserProfile.GetUsers(_context).Find(x => x.Mail.ToLower() == User.Identity.Name.ToLower());
if (ModelState.IsValid)
{
userTask.Date_create = DateTime.Now;
userTask.UserId = user.UserId;
_context.UserTask.Add(userTask);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
UserTaskViewModel utvm = new UserTaskViewModel(_context, userTask);
return(View(utvm));
}
public void Mapper_ShouldCorrectlyMap_UserTaskViewModelToUserTaskEntity()
{
var userTaskViewModel = new UserTaskViewModel
{
Id = 1,
Name = "TestTask",
TaskStatus = 1,
User = new UserViewModel
{
Id = 1,
FirstName = "Name",
LastName = "Surname"
},
Deadline = new DateTime(2003, 2, 1),
GroupId = 1
};
var expected = new UserTaskEntity
{
Id = 1,
Name = "TestTask",
TaskStatus = 1,
UserId = 1,
Deadline = "01.02.2003 00:00:00",
GroupId = 1
};
var result = _mapperConfig.CreateMapper().Map <UserTaskEntity>(userTaskViewModel);
Assert.IsInstanceOf <UserTaskEntity>(result);
Assert.AreEqual(expected.Name, result.Name);
Assert.AreEqual(expected.UserId, result.UserId);
Assert.AreEqual(expected.Id, result.Id);
Assert.AreEqual(expected.TaskStatus, result.TaskStatus);
Assert.AreEqual(expected.Deadline, result.Deadline);
}
public void Mapper_ShouldCorrectlyMap_UserTaskEntityToUserTaskViewModel()
{
var userTaskEntity = new UserTaskEntity
{
Deadline = "01.02.2003",
Id = 1,
Name = "TestTask",
TaskStatus = 1,
UserId = null,
GroupId = 1
};
var expected = new UserTaskViewModel
{
Deadline = new DateTime(2003, 2, 1),
Id = 1,
Name = "TestTask",
TaskStatus = 1,
User = null,
GroupId = 1
};
var result = _mapperConfig.CreateMapper().Map <UserTaskViewModel>(userTaskEntity);
Assert.That(result, Is.InstanceOf <UserTaskViewModel>());
Assert.That(result.Id, Is.EqualTo(expected.Id));
Assert.That(result.Name, Is.EqualTo(expected.Name));
Assert.That(result.User, Is.EqualTo(expected.User));
Assert.That(result.TaskStatus, Is.EqualTo(result.TaskStatus));
Assert.That(result.Deadline, Is.EqualTo(expected.Deadline));
}
public ActionResult <UserTaskViewModel> Create(UserTaskViewModel taskDetailsViewModel)
{
var newTaskId = _userTaskDbManager.Create(taskDetailsViewModel);
taskDetailsViewModel.Id = newTaskId;
return(CreatedAtAction(nameof(Get), new { id = newTaskId }, taskDetailsViewModel));
}
public void Set_Task_Status()
{
var result = controller.SetTaskAsSuccess(1, 5, true) as ViewResult;
UserTaskViewModel resultStatus = result.Model as UserTaskViewModel;
Assert.IsNull(resultStatus);
}
public async Task <ActionResult> Create(UserTaskViewModel taskModel)
{
if (ModelState.IsValid)
{
var _userTaskDto = new UserTaskDto {
Name = taskModel.Name,
Description = taskModel.Description,
DueDate = taskModel.DueDate,
ApplicationUserId = User.Identity.GetUserId()
};
try {
await this._taskService.Create(_userTaskDto);
return(RedirectToAction("Index", "Home"));//Add partial "New task was created!"
} catch (ValidationException ex) {
ModelState.AddModelError(ex.Property, ex.Message);
}
}
else
{
var _duplicatedModelState = ModelState.Values.SingleOrDefault(ms => ms.Errors.Count > 1 && ms.Errors[0].ErrorMessage == ms.Errors[1].ErrorMessage);
if (_duplicatedModelState != null)
{
_duplicatedModelState.Errors.Remove(_duplicatedModelState.Errors[1]);
}
}
return(View(taskModel));
}
public IActionResult Update(int id, UserTaskViewModel taskDetailsViewModel)
{
if (_userTaskDbManager.Update(id, taskDetailsViewModel))
{
return(NoContent());
}
return(NotFound());
}
// GET: UserTasks/Create
public IActionResult Create()
{
UserProfile user = UserProfile.GetUsers(_context).Find(x => x.Mail.ToLower() == User.Identity.Name.ToLower());
UserTaskViewModel cvm = new UserTaskViewModel(_context, user.UserId);
cvm.Period = "0 0 * * 1";
return(View("Create", cvm));
}
public ActionResult EditPost(int?id, TaskViewModel task)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var taskDto = _taskService.GetTask(id);
var newUsers = new List <string>();
foreach (var item in task.SelectedUsers)
{
newUsers.Add(item);
}
var oldUsers = new List <string>();
oldUsers = GetUsersForTask(id);
var UsersForDeleteTask = oldUsers.Except(newUsers).ToList();
var UsersForAddTask = newUsers.Except(oldUsers).ToList();
if (TryUpdateModel(taskDto))
//"",
//new string[] { nameof(sampleDto.Name), nameof(sampleDto.Description) }))
{
try
{
_taskService.UpdateTask(taskDto);
task = Mapper.Map <TaskTransferModel, TaskViewModel>(taskDto);
foreach (var item in UsersForAddTask)
{
var userTask = new UserTaskViewModel
{
UserId = Convert.ToInt32(item),
TaskId = task.TaskId,
TaskName = task.Name,
StartDate = task.StartDate,
DeadlineDate = task.DeadlineDate,
State = "Active"
};
var userTaskDto = Mapper.Map <UserTaskViewModel, UserTaskTransferModel>(userTask);
_vUserTaskService.SaveTaskForUser(userTaskDto);
}
foreach (var item in UsersForDeleteTask)
{
_vUserTaskService.DeleteUserTask(Convert.ToInt32(item), id);
}
return(RedirectToAction("Index"));
}
catch (RetryLimitExceededException /* dex */)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
}
return(View(task));
}
public ActionResult Edit(TaskManagePageViewModel taskManagePageViewModel, int id)
{
var taskDto = _mapper.Map <TaskViewModel, VTaskDTO>(taskManagePageViewModel.taskViewModel);
taskDto.TaskId = id;
var newUsers = new List <string>();
var oldUsers = GetUsersForTask(id);
IEnumerable <string> selectedUsers = Request.Form.GetValues("SelectedUsers");
int activeState = 1;
if (selectedUsers != null)
{
foreach (var item in selectedUsers)
{
newUsers.Add(item);
}
}
var UsersForDeleteTask = oldUsers.Except(newUsers);
var UsersForAddTask = newUsers.Except(oldUsers);
if (TryUpdateModel(taskDto))
{
try
{
_vTaskService.Update(taskDto);
foreach (var item in UsersForAddTask)
{
var userTask = new UserTaskViewModel
{
UserId = Convert.ToInt32(item),
TaskId = taskDto.TaskId,
StateId = activeState
};
var userTaskDto = _mapper.Map <UserTaskViewModel, VUserTaskDTO>(userTask);
_vUserTaskService.Save(userTaskDto);
}
foreach (var userId in UsersForDeleteTask)
{
_userTaskService.DeleteItemByTaskIdAndUserId(taskDto.TaskId, Convert.ToInt32(userId));
}
return(RedirectToAction("Index"));
}
catch (RetryLimitExceededException /* dex */)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
}
return(PartialView(taskManagePageViewModel.taskViewModel));
}
public async Task <IActionResult> GetUserTask(string userName)
{
if (string.IsNullOrEmpty(userName))
{
return(ValidationProblem(MessageInfo.User_DidntPassUserName));
}
AppUser user = await userManager.FindByNameAsync(userName);
if (user == null)
{
return(NotFound());
}
IQueryable <UserTask> userTaskList = context.UserTasks
.Include(a => a.Subtasks)
.Where(u => u.User == user && u.IsArchived == false)
.OrderBy(o => o.CreateDate);
if (!userTaskList.Any())
{
return(NotFound());
}
IList <UserTaskViewModel> userTaskViewModels = new List <UserTaskViewModel>();
foreach (var userTask in userTaskList)
{
IList <UserSubtaskViewModel> userSubtaskList = new List <UserSubtaskViewModel>();
foreach (var subtask in userTask.Subtasks)
{
UserSubtaskViewModel subtaskViewModel = new UserSubtaskViewModel
{
Name = subtask.Name,
IsCompleted = subtask.IsCompleted,
TaskStartDate = subtask.TaskStartDate,
TaskEndDate = subtask.TaskEndDate
};
userSubtaskList.Add(subtaskViewModel);
}
UserTaskViewModel taskViewModel = new UserTaskViewModel
{
Taskid = userTask.Id,
Name = userTask.Name,
IsCompleted = userTask.IsCompleted,
IsArchiwed = userTask.IsArchived,
TaskStartDate = userTask.TaskStartDate,
TaskEndDate = userTask.TaskEndDate,
UserSubtasks = userSubtaskList,
UserName = userTask.User.UserName
};
userTaskViewModels.Add(taskViewModel);
}
return(Ok(userTaskViewModels));
}
public int Create(UserTaskViewModel taskDetailsViewModel)
{
var newTask = _mapper.Map <UserTaskEntity>(taskDetailsViewModel);
newTask = _dbContext.UserTasks.Add(newTask).Entity;
_dbContext.SaveChanges();
return(newTask.Id);
}
public async Task <IActionResult> UpdateUserTask([FromBody] UserTaskViewModel model)
{
if (!ModelState.IsValid)
{
return(ValidationProblem(ModelState));
}
AppUser user = await userManager.FindByNameAsync(model.UserName);
if (user == null)
{
return(NotFound());
}
UserTask userTask = await context.UserTasks
.Include(i => i.Subtasks)
.FirstOrDefaultAsync(t => t.Id == model.Taskid);
if (userTask == null)
{
return(NotFound());
}
IList <UserSubtask> userSubtaskList = new List <UserSubtask>();
foreach (var subtask in model.UserSubtasks)
{
UserSubtask userSubtask = new UserSubtask
{
Name = subtask.Name,
IsCompleted = subtask.IsCompleted,
TaskStartDate = subtask.TaskStartDate,
TaskEndDate = subtask.TaskEndDate
};
userSubtaskList.Add(userSubtask);
}
userTask.Name = model.Name;
userTask.IsCompleted = model.IsCompleted;
userTask.TaskStartDate = model.TaskStartDate;
userTask.TaskEndDate = model.TaskEndDate;
userTask.Subtasks = userSubtaskList;
try
{
context.UserTasks.Update(userTask);
await context.SaveChangesAsync();
return(Ok());
}
catch (Exception)
{
throw;
}
}
public ActionResult CreateTask(UserTaskViewModel model)
{
var client = new RestClient(Constant.CreateTaskAsync);
var request = new RestRequest(Method.POST)
.AddParameter("Name", model.name)
.AddParameter("IdUserHistories", model.idUs);
var result = client.Execute(request).Content;
return(Content(result, "application/json"));
}
public ActionResult Edit(UserTaskViewModel userTask)
{
if (ModelState.IsValid)
{
var userTaskResult = MapperGetUserTasks(userTask);
userTaskService.Edit(userTaskResult);
return(RedirectToAction("Index"));
}
return(View(userTask));
}
public ActionResult UpdateTaskState(UserTaskViewModel model)
{
var client = new RestClient(Constant.UpdateTaskAsync);
var request = new RestRequest(Method.POST)
.AddParameter("IdTask", model.idTask)
.AddParameter("State", model.state);
var result = client.Execute(request).Content;
return(Content(result, "application/json"));
}
//Get All member tasks && all member Written tasks
public async Task <IActionResult> GetMemberAssignmentsTasks()
{
AppUser user = _userManager.GetUserAsync(User).Result;
var taskViewModel = new UserTaskViewModel
{
UserTasks = await _taskService.GetUserAssignmentTaskList(user.Id),
UserWrittenTasks = await _taskService.GetUseWrittenTaskList(user.Id)
};
return(View(taskViewModel));
}
public bool Update(int id, UserTaskViewModel taskDetailsViewModel)
{
if (!TryFindTaskInDb(id, out var taskFromDb))
{
return(false);
}
var updatedTask = _mapper.Map <UserTaskEntity>(taskDetailsViewModel);
_dbContext.Entry(taskFromDb).CurrentValues.SetValues(updatedTask);
_dbContext.SaveChanges();
return(true);
}
// GET: UserTasks
public IActionResult Index()
{
UserProfile user = UserProfile.GetUsers(_context).Find(x => x.Mail.ToLower() == User.Identity.Name.ToLower());
List <UserTaskViewModel> utvml = new List <UserTaskViewModel>();
List <UserTask> utl = _context.UserTask.Where(x => x.UserId == user.UserId).ToList();
foreach (UserTask t in utl)
{
UserTaskViewModel utvm = new UserTaskViewModel(_context, t);
utvml.Add(utvm);
}
return(View(utvml));
}
public IActionResult Edit(UserTaskViewModel userTaskViewModel)
{
if (!ModelState.IsValid)
{
return(View(userTaskViewModel));
}
var userTask = mapper.Map <UserTask>(userTaskViewModel);
var user = userService.FindByLogin(userTaskViewModel.OwnerLogin);
userTask.Owner = user;
taskService.Save(userTask);
var urlReferrer = Request.Headers["Referer"].ToString();
return(Redirect(urlReferrer));
}
public IActionResult Edit(UserTask userTask)
{
if (ModelState.IsValid)
{
UserProfile user = UserProfile.GetUsers(_context).Find(x => x.Mail.ToLower() == User.Identity.Name.ToLower());
userTask.Duration = Helper.ConvertDurationToInt32(Request.Form["Duration"]);
userTask.UserId = user.UserId;
// userTask.DateActivate = DateTime.Now;
_context.Update(userTask);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
UserTaskViewModel utvm = new UserTaskViewModel(_context, userTask);
return(View(utvm));
}
private void OnUserTaskUpdate(object sender, UserTaskModifiedEventArgs args)
{
bool contain = false;
for (int i = 0; i < UserTasks.Count; i++)
{
if (UserTasks[i].Id == args.UserTask?.Id)
{
UserTasks[i] = new UserTaskViewModel(args.UserTask);
contain = true;
break;
}
}
if (!contain)
{
UserTasks.Add(new UserTaskViewModel(args.UserTask));
}
}
public UserTaskAddedMessage(UserTaskViewModel task)
{
Task = task;
}
