public async System.Threading.Tasks.Task <ActionResult> Edit(TaskDetail task)
{
TaskDetailValidator validator = new TaskDetailValidator();
ValidationResult validationResults = validator.Validate(task);
if (!validationResults.IsValid)
{
var getProjectsTask = _projectApiRequestHandler.GetProjectsHeaders(projectsType: ProjectType.Active);
foreach (var error in validationResults.Errors)
{
ModelState.AddModelError(nameof(TaskEditViewModel.Task) + '.' + error.PropertyName, error.ErrorMessage);
}
TaskEditViewModel viewModel = new TaskEditViewModel()
{
Task = task,
};
viewModel.ActiveProjects = await getProjectsTask;
return(View(viewModel));
}
await _taskApiRequestHandler.SaveTask(task);
return(RedirectToAction("List"));
}
// GET: Tasks/Edit/5
public async Task <ActionResult> Edit(int?id)
{
//Validate input
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//Find task in database
var task = await _db.Tasks.FindAsync(id);
if (task == null)
{
return(HttpNotFound("Task not found."));
}
//TODO: Ensure user is allowed access to this project
//Create and return view model
var model = new TaskEditViewModel()
{
Id = task.Id,
Title = task.Title,
Description = task.Description,
State = task.State,
TimeRemaining = task.TimeRemaining
};
return(View("_Edit", model));
}
public async Task <IActionResult> Edit(TaskEditViewModel vm, long id)
{
if (ModelState.IsValid)
{
TaskType type = await taskTypeRepository.GetById(vm.type);
User reporter = await userManager.GetUserAsync(HttpContext.User);
User assignee = await userManager.FindByIdAsync(vm.assignee);
Task task = new Task();
task.Id = id;
task.name = vm.name;
task.description = vm.description;
task.type = type;
task.reporter = reporter;
task.assignee = assignee;
task.state = vm.state;
await taskRepository.Update(task);
return(RedirectToAction("Index", "Kanban"));
}
return(View(vm));
}
private async System.Threading.Tasks.Task AddTasks(TaskEditViewModel taskEditViewModel)
{
var page = new TaskEditPage();
page.BindingContext = taskEditViewModel;
await Navigation.PushAsync(page);
NavigationPage.SetHasBackButton(page, true);
}
public TaskEditViewModel GetTaskEditViewModel(int taskId)
{
try
{
using (ApplicationDbContext context = new ApplicationDbContext())
{
TaskEditViewModel viewModel = new TaskEditViewModel();
var task = context.Tasks.FirstOrDefault(t => t.TaskID == taskId);
if (task != null)
{
viewModel.IsValid = true;
if (IsAuthorized(task, context))
{
viewModel.IsAuthorized = true;
string currentUserID = GetUser(context).Id;
//If user is last editing user
if (task.EditingUserID != null && task.EditingUserID != currentUserID && task.EditHeartBeat.HasValue)
{
if (task.EditHeartBeat.Value >= DateTime.Now.AddMinutes(-2)) //Client heartBeat: every 1min
{
//HeartBeat not expired
viewModel.IsLocked = true;
viewModel.UserName = context.Users.First(u => u.Id == task.EditingUserID).UserName;
return(viewModel);
}
}
task.EditHeartBeat = DateTime.Now;
task.EditingUserID = currentUserID;
viewModel.Title = task.Name + "*";
viewModel.Content = task.Content;
context.SaveChanges();
return(viewModel);
}
else
{
viewModel.IsAuthorized = false;
}
}
else
{
viewModel.IsValid = false;
}
return(viewModel);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw;
}
}
public void ShowEditDialog()
{
TaskEditViewModel vm = new TaskEditViewModel();
if (_viewModel is TaskViewModel)
{
vm.SelectedTask = (_viewModel as TaskViewModel).SelectedTask;
TaskEditWindow taskEditWindow = new TaskEditWindow(vm);
taskEditWindow.ShowDialog();
}
}
public async System.Threading.Tasks.Task <ActionResult> Edit(int id)
{
var getProjectsTask = _projectApiRequestHandler.GetProjectsHeaders(projectsType: ProjectType.Active);
var getTaskTask = _taskApiRequestHandler.GetTaskById(id);
TaskEditViewModel viewModel = new TaskEditViewModel();
viewModel.ActiveProjects = await getProjectsTask;
viewModel.Task = await getTaskTask;
return(View(viewModel));
}
public async System.Threading.Tasks.Task <ActionResult> Create()
{
var getProjectsTask = _projectApiRequestHandler.GetProjectsHeaders(projectsType: ProjectType.Active);
TaskEditViewModel viewModel = new TaskEditViewModel()
{
Task = new TaskDetail {
ID = 0
}
};
viewModel.ActiveProjects = await getProjectsTask;
return(View("Edit", viewModel));
}
public IActionResult DeleteTask(int id)
{
TaskModel taskModel = reportRepository.GetTask(id);
Enum.TryParse(taskModel.ModuleName, out EModule module);
TaskEditViewModel editTaskModel = new TaskEditViewModel
{
ModuleName = module,
TaskPriority = taskModel.TaskPriority,
Description = taskModel.Description
};
reportRepository.Delete(id);
return(View(editTaskModel));
}
public ViewResult EditTask(int id)
{
TaskModel taskModel = reportRepository.GetTask(id);
Enum.TryParse(taskModel.ModuleName, out EModule module);
TaskEditViewModel editTaskModel = new TaskEditViewModel
{
Title = taskModel.TaskTitle,
AssignedID = taskModel.AssignedID,
ModuleName = module,
TaskPriority = taskModel.TaskPriority,
Description = taskModel.Description
};
return(View(editTaskModel));
}
public ViewResult Edit(int?id, string callback)
{
if (id == null)
{
return(View());
}
TaskEditViewModel model = new TaskEditViewModel()
{
Callback = callback,
Task = _taskRepository.GetById(id.Value),
Statuses = _sr.GetAll()
};
return(View(model));
}
public ActionResult Edit(TaskEditViewModel model)
{
if (!ModelState.IsValid)
{
return(PartialView("_EditPartial", model));
}
if (!_db.TaskManager.Update(User.Identity.GetUserId(), new Task(model)))
{
ModelState.AddModelError("", @"Ошибка при обновлении базы данных");
return(PartialView("_EditPartial", model));
}
return(PartialView("TaskPartial", new TaskViewModel(model)
{
MentorId = User.Identity.GetUserId()
}));
}
public ActionResult Create(int project, TaskEditViewModel vmdl)
{
vmdl.ProjectID = project;
vmdl.Object.Projekt = DataContext.Find<Zetbox.App.Projekte.Projekt>(project);
Validate();
if (ModelState.IsValid)
{
DataContext.SubmitChanges();
return RedirectToAction("Details", "Project", new { id = project });
}
else
{
return View(vmdl);
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
TaskModel = await _taskAppService.GetTaskViewModelForEditAsync(id.Value);
if (TaskModel == null)
{
return(NotFound());
}
//ViewData["ProjectId"] = new SelectList(_context.Project, "ID", "ID");
ViewData["UserId"] = new SelectList(_context.Users, "Id", "Name");
return(Page());
}
public async Task <IActionResult> UpdateAsync(TaskEditViewModel editModel)
{
try
{
var task = _taskRepository.GetById(editModel.Id);
var currentuser = await _userManager.GetUserAsync(HttpContext.User);
if (task == null || task.IsDeleted == true)
{
Response.StatusCode = 404;
return(View("TaskNotFound", editModel.Id));
}
else if (
User.IsInRole("SuperAdmin") ||
task.Userid == currentuser.Id ||
User.IsInRole("Admin") && task.Board.CompanyId == currentuser.CompanyId
)
{
if (ModelState.IsValid)
{
task.Title = editModel.Title;
task.Description = editModel.Description;
task.Status = editModel.Status;
task.UpdatedDate = DateTime.Now;
task.UpdatedBy = User.Identity.Name;
task.Userid = editModel.Userid;
var response = _taskRepository.Update(task);
if (response != null & response.Id != 0)
{
return(RedirectToAction("taskList", new { boardid = task.BoardId }));
}
return(View());
}
}
return(View("NotAuthorized"));
}
catch (Exception ex)
{
_logger.LogError(ex, $"When updating task.");
throw;
}
}
public IActionResult TaskView(TaskEditViewModel model)
{
if (model.NewCommentBody != null)
{
CommentModel comment = new CommentModel()
{
CommentBody = model.NewCommentBody,
PosterName = User.Identity.Name,
TimePosted = DateTime.Now,
TaskId = model.Id
};
reportRepository.AddComment(comment);
TaskModel task = reportRepository.GetTask(model.Id);
SendMail(task.ReporterID, task.AssignedID, task.TaskTitle);
}
return(TaskView(model.Id));
}
// GET: Tasks/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var task = await _workContext.UserTasks
.FirstOrDefaultAsync(m => m.Id == id);
if (task == null)
{
return(NotFound());
}
TaskEditViewModel tvm = new TaskEditViewModel(task.Id, task.Name, task.Status, task.ProjectId);
return(View(tvm));
}
public async Task <IActionResult> UpdateAsync(int taskid)
{
try
{
var task = _taskRepository.GetById(taskid);
var currentuser = await _userManager.GetUserAsync(HttpContext.User);
var BoardUser = _boardRepository.GetUsersofBoard(task.BoardId).ToList();
if (task == null || task.IsDeleted == true)
{
Response.StatusCode = 404;
return(View("TaskNotFound", taskid));
}
else if (
User.IsInRole("SuperAdmin") ||
task.Userid == currentuser.Id ||
User.IsInRole("Admin") && task.Board.CompanyId == currentuser.CompanyId
)
{
var taskEditViewModel = new TaskEditViewModel
{
BoardId = task.BoardId,
Id = task.Id,
Title = task.Title,
Description = task.Description,
Status = task.Status,
UpdatedBy = User.Identity.Name,
UpdatedDate = DateTime.Now,
AvailableUsers = BoardUser,
AssginedUser = task.ApplicationUser.UserName
};
return(View(taskEditViewModel));
}
return(View("NotAuthorized"));
}
catch (Exception ex)
{
_logger.LogError(ex, $"When getting the task for updating .");
throw;
}
}
public async Task <bool> TrySaveEditTaskViewModelAsync(TaskEditViewModel taskEditViewModel)
{
try
{
var task = await _dbContext.Tasks.FirstOrDefaultAsync(m => m.Id == taskEditViewModel.Id);
task = _mapper.Map <TaskEditViewModel, TaskModel>(taskEditViewModel, task);
_dbContext.Attach(task).State = EntityState.Modified;
await _dbContext.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
return(false);
}
}
public TaskEditPage(TaskDTO item)
{
try
{
InitializeComponent();
if (item != null)
{
BindingContext = new TaskEditViewModel(item, Navigation);
}
else
{
BindingContext = new TaskAddViewModel(Navigation);
}
}
catch (Exception e)
{
Debug.WriteLine(e);
throw e;
}
}
public async Task <IActionResult> Edit(int id, TaskEditViewModel vm)
{
if (id != vm.TaskerTask.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
_bll.Tasks.Update(vm.TaskerTask);
await _bll.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
vm.AddressSelectList = new SelectList(await _bll.Addresses.AllAsync(),
nameof(BLL.App.DTO.Address.Id),
nameof(BLL.App.DTO.Address.Id),
vm.TaskerTask.AddressId);
return(View(vm));
}
public async Task <IActionResult> DetailsAsync(int taskid)
{
try
{
var task = _taskRepository.GetById(taskid);
var currentuser = await _userManager.GetUserAsync(HttpContext.User);
if (task == null || task.IsDeleted == true)
{
Response.StatusCode = 404;
return(View("TaskNotFound", taskid));
}
else if (
User.IsInRole("SuperAdmin") ||
task.Userid == currentuser.Id ||
User.IsInRole("Admin") && task.Board.CompanyId == currentuser.CompanyId
)
{
var detailViewModel = new TaskEditViewModel()
{
Board = task.Board,
Id = task.Id,
Title = task.Title,
Description = task.Description,
Status = task.Status,
CreatedBy = task.CreatedBy,
CreatedDate = task.CreatedDate,
BoardId = task.BoardId,
AssginedUser = task.ApplicationUser.UserName
};
return(View(detailViewModel));
}
return(View("NotAuthorized"));
}
catch (Exception ex)
{
_logger.LogError(ex, $"When getting task.");
throw;
}
}
public ViewResult TaskView(int id)
{
TaskModel taskModel = reportRepository.GetTask(id);
Enum.TryParse(taskModel.ModuleName, out EModule module);
var attachmentStrings = reportRepository.GetAttachmentsStrings(id);
TaskEditViewModel editTaskModel = new TaskEditViewModel
{
Id = id,
Title = taskModel.TaskTitle,
AssignedID = taskModel.AssignedID,
ModuleName = module,
TaskPriority = taskModel.TaskPriority,
Description = taskModel.Description,
Comments = LoadComments(id),
AttachmentStrings = attachmentStrings
};
return(View(editTaskModel));
}
public IActionResult EditTask(TaskEditViewModel model)
{
if (ModelState.IsValid)
{
TaskModel task = reportRepository.GetTask(model.Id);
string uniqueFileName = null;
task.TaskTitle = model.Title;
task.AssignedID = task.AssignedID;
task.ModuleName = model.ModuleName.ToString();
task.TaskPriority = model.TaskPriority;
task.TaskState = ETaskState.Reported;
task.Description = model.Description;
if (model.Attachemnts != null && model.Attachemnts.Count > 0)
{
foreach (IFormFile file in model.Attachemnts)
{
string uplodasFolder = Path.Combine(HostEnvironment.WebRootPath, "attachments");
uniqueFileName = Guid.NewGuid().ToString() + "_" + file.FileName;
string filePath = Path.Combine(uplodasFolder, uniqueFileName);
file.CopyTo(new FileStream(filePath, FileMode.Create));
FileAttachment attachment = new FileAttachment()
{
Path = uniqueFileName,
TaskId = task.TaskModelId,
Name = file.FileName
};
reportRepository.Add(attachment);
}
}
reportRepository.Edit(task);
SendMail(task.ReporterID, task.AssignedID, task.TaskTitle);
return(RedirectToAction("ReportList"));
}
return(View());
}
public async Task <ActionResult> Edit(TaskEditViewModel model)
{
//Ensure valid input
if (!ModelState.IsValid)
{
return(View("_Edit", model));
}
//Find task in database
var task = await _db.Tasks.FindAsync(model.Id);
if (task == null)
{
return(new HttpNotFoundResult("Task not found."));
}
//TODO: Ensure user is allowed access to this project
//Update task
task.Title = model.Title;
task.Description = model.Description;
task.State = model.State;
task.TimeRemaining = model.TimeRemaining;
//Save changes
try
{
await _db.SaveChangesAsync();
return(Json(new { success = true }));
}
catch (Exception exception)
{
model.Error = exception.Message;
return(View("_Edit", model));
}
}
// GET: TaskerTasks/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
var taskerTask = await _bll.Tasks.FindAsync(id);
if (taskerTask == null)
{
return(NotFound());
}
var vm = new TaskEditViewModel();
vm.TaskerTask = taskerTask;
vm.AddressSelectList = new SelectList(await _bll.Addresses.AllAsync(),
nameof(BLL.App.DTO.Address.Id),
nameof(BLL.App.DTO.Address.Id),
taskerTask.AddressId);
return(View(vm));
}
private void TaskDetails_PreviewMouseDown(object sender, MouseButtonEventArgs e)
{
TaskEditViewModel taskEditVM = (TaskEditViewModel)this.DataContext;
taskEditVM.TaskDetails = string.Empty;
}
public TaskEditView()
{
InitializeComponent();
viewModel = new TaskEditViewModel();
BindingContext = viewModel;
}
public ActionResult Edit(TaskEditViewModel vmdl)
{
Validate();
if (ModelState.IsValid)
{
DataContext.SubmitChanges();
return RedirectToAction("Details", new { id = vmdl.ID });
}
else
{
return View(vmdl);
}
}
public TaskEditWindow(TaskEditViewModel vm)
{
InitializeComponent();
this.DataContext = vm;
}
public ActionResult _EditPartial(TaskEditViewModel model)
{
return(PartialView(model));
}
public Task(TaskEditViewModel model)
{
Description = model.Description;
Title = model.Title;
Id = model.TaskId;
}
