public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Task task = db.Task.Find(id);
if (task == null)
{
return(HttpNotFound());
}
var taskEditModel = new TaskEditModel
{
TaskId = task.TaskId,
TaskName = task.TaskName,
TaskDescription = task.TaskDescription,
IsDone = task.IsDone,
SprintId = task.SprintId
};
ViewBag.SprintId = new SelectList(db.Sprint, "SprintId", "SprintStart", task.SprintId);
return(View(taskEditModel));
}
public void Edit_Post_ValidationFailed()
{
// Arrange
var taskRepoMock = new Mock <IRepository <Task> >();
var controller = new HomeController(taskRepoMock.Object);
var inModel = new TaskEditModel {
Id = 1, ParentId = 2, Name = "3"
};
controller.ModelState.AddModelError("", "");
taskRepoMock.Verify(r => r.Save(), Times.Never);
// Act
var rez = controller.Edit(inModel);
// Assert
rez.ShouldBeOfType <ViewResult>();
var modelTemp = ((ViewResult)rez).Model;
modelTemp.ShouldNotBeNull();
modelTemp.ShouldBeOfType <TaskEditModel>();
var model = (TaskEditModel)modelTemp;
model.Id.ShouldBe(1);
model.ParentId.ShouldBe(2);
model.Name.ShouldBe("3");
}
private void WarnDateTimeOutOfRange(ref TaskEditModel model)
{
if (model.StartDateTime.HasValue || model.EndDateTime.HasValue)
{
var campaignEvent = GetEventBy(model.EventId);
var timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(campaignEvent.Campaign.TimeZoneId);
DateTimeOffset?convertedStartDateTime = null;
if (model.StartDateTime.HasValue)
{
var startDateValue = model.StartDateTime.Value;
var startDateTimeOffset = timeZoneInfo.GetUtcOffset(startDateValue);
convertedStartDateTime = new DateTimeOffset(startDateValue.Year, startDateValue.Month, startDateValue.Day, startDateValue.Hour, startDateValue.Minute, 0, startDateTimeOffset);
}
DateTimeOffset?convertedEndDateTime = null;
if (model.EndDateTime.HasValue)
{
var endDateValue = model.EndDateTime.Value;
var endDateTimeOffset = timeZoneInfo.GetUtcOffset(endDateValue);
convertedEndDateTime = new DateTimeOffset(endDateValue.Year, endDateValue.Month, endDateValue.Day, endDateValue.Hour, endDateValue.Minute, 0, endDateTimeOffset);
}
if ((convertedStartDateTime < campaignEvent.StartDateTime || convertedEndDateTime > campaignEvent.EndDateTime) &&
(model.IgnoreTimeRangeWarning == false))
{
ModelState.AddModelError("", "Although valid, task time is out of range for event time from " +
campaignEvent.StartDateTime.DateTime.ToString("g") + " to " + campaignEvent.EndDateTime.DateTime.ToString("g") + " " + campaignEvent.Campaign.TimeZoneId);
ModelState.Remove("IgnoreTimeRangeWarning");
model.IgnoreTimeRangeWarning = true;
}
}
}
public void Edit_Post_Success()
{
// Arrange
var taskRepoMock = new Mock <IRepository <Task> >();
var controller = new HomeController(taskRepoMock.Object);
var inModel = new TaskEditModel {
Id = 1, Name = "a1"
};
var callbackTask = new Task {
Id = 1, ParentId = 2, Name = "test"
};
taskRepoMock.Setup(r => r.GetByID(1)).Returns(callbackTask);
taskRepoMock.Setup(r => r.Save()).Verifiable();
// Act
var rez = controller.Edit(inModel);
// Assert
taskRepoMock.VerifyAll();
callbackTask.ShouldNotBeNull();
callbackTask.Name.ShouldBe("a1");
rez.ShouldBeOfType <RedirectToRouteResult>();
var routeResult = (RedirectToRouteResult)rez;
routeResult.RouteValues.Count.ShouldBe(2);
routeResult.RouteValues["action"].ShouldBe("Index");
routeResult.RouteValues["id"].ShouldBe(2);
}
public void Edit_Post_ErrorNotHandledText()
{
// Arrange
var taskRepoMock = new Mock <IRepository <Task> >();
var controller = new HomeController(taskRepoMock.Object);
var inModel = new TaskEditModel {
Id = 1, Name = "a1"
};
var callbackTask = new Task {
Id = 1, ParentId = 2, Name = "test"
};
taskRepoMock.Setup(r => r.GetByID(1)).Returns(callbackTask);
var ex = new Exception("Wrong exception message");
var dbEx = new System.Data.Entity.Infrastructure.DbUpdateException("", new Exception("", ex));
taskRepoMock.Setup(r => r.Save()).Throws(dbEx);
// Act
Should.Throw <System.Data.Entity.Infrastructure.DbUpdateException>(() => { controller.Edit(inModel); });
// Assert
taskRepoMock.VerifyAll();
callbackTask.ShouldNotBeNull();
callbackTask.Name.ShouldBe("a1");
controller.ModelState.Count.ShouldBe(0);
}
public async Task <IActionResult> TaskEdit(int?id1, int?id2, string data)
{
if (id1 == null)
{
return(NotFound());
}
var fromDateAsDateTime = DateTime.Parse(data);
var uslugaprojekt = await _s16693context.UslugaProjekt.FirstOrDefaultAsync(x => x.IdProjekt == id1& x.IdUsluga == id2& x.DataPrzypisaniaZadania == fromDateAsDateTime);
if (uslugaprojekt == null)
{
return(NotFound());
}
var pakiet = await _s16693context.ProjektPakiet.FirstOrDefaultAsync(x => x.IdProjekt == id1 && x.DataZakonczeniaWspolpracy == null);
var pU = await _s16693context.PakietUsluga.Where(x => x.IdPakiet == pakiet.IdPakiet).Include(u => u.IdUslugaNavigation).ToListAsync();
List <Usluga> uslugas = new List <Usluga>();
foreach (var item in pU)
{
uslugas.Add(await _s16693context.Usluga.FirstOrDefaultAsync(x => x.IdUsluga == item.IdUsluga));
}
var tEM = new TaskEditModel
{
UslugaProjekt = uslugaprojekt,
uslugas = uslugas
};
return(View(tEM));
}
public async Task <IActionResult> Edit(int id, TaskEditModel taskEditModel)
{
var allTask = _context.AllTask.Find(taskEditModel.Id);
if (id != allTask.Id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(taskEditModel));
}
try
{
allTask.Title = taskEditModel.Title;
allTask.Description = taskEditModel.Description;
//allTask.UserId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
_context.Update(allTask);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AllTaskExists(allTask.Id))
{
return(NotFound());
}
throw;
}
return(RedirectToAction(nameof(Index)));
}
private void WarnDateTimeOutOfRange(ref TaskEditModel model)
{
if (model.StartDateTime.HasValue || model.EndDateTime.HasValue)
{
var activity = _dataAccess.GetActivity(model.ActivityId);
TimeZoneInfo timeZone = TimeZoneInfo.FindSystemTimeZoneById(activity.Campaign.TimeZoneId);
DateTimeOffset?convertedStartDateTime = null;
if (model.StartDateTime.HasValue)
{
var startDateValue = model.StartDateTime.Value;
var startDateTimeOffset = timeZone.GetUtcOffset(startDateValue);
convertedStartDateTime = new DateTimeOffset(startDateValue.Year, startDateValue.Month, startDateValue.Day, startDateValue.Hour, startDateValue.Minute, 0, startDateTimeOffset);
}
DateTimeOffset?convertedEndDateTime = null;
if (model.EndDateTime.HasValue)
{
var endDateValue = model.EndDateTime.Value;
var endDateTimeOffset = timeZone.GetUtcOffset(endDateValue);
convertedEndDateTime = new DateTimeOffset(endDateValue.Year, endDateValue.Month, endDateValue.Day, endDateValue.Hour, endDateValue.Minute, 0, endDateTimeOffset);
}
if ((convertedStartDateTime < activity.StartDateTime || convertedEndDateTime > activity.EndDateTime) &&
(model.IgnoreTimeRangeWarning == false))
{
ModelState.AddModelError("", "Although valid, task time is out of range for activity time from " +
activity.StartDateTime.DateTime.ToString("g") + " to " + activity.EndDateTime.DateTime.ToString("g") + " " + activity.Campaign.TimeZoneId.ToString());
ModelState.Remove("IgnoreTimeRangeWarning");
model.IgnoreTimeRangeWarning = true;
}
}
}
public ActionResult Edit(TaskEditModel model)
{
if (ModelState.IsValid)
{
var task = _taskRepo.GetByID(model.Id);
task.Name = model.Name;
_taskRepo.Update(task);
try
{
_taskRepo.Save();
}
catch (System.Data.Entity.Infrastructure.DbUpdateException ex)
{
var msg = ex.InnerException?.InnerException?.Message;
if (msg != null && msg.StartsWith("Cannot insert duplicate key row in object 'dbo.Task' with unique index 'IX_ParentId_Name'"))
{
ModelState.AddModelError("", NameUniquenessMessage);
model.ParentId = task.ParentId;
return(View(model));
}
throw;
}
return(RedirectToAction("Index", new { Id = task.ParentId }));
}
return(View(model));
}
// GET: AllTasks/Edit/5
public async Task <IActionResult> Edit(int?id, TaskEditModel taskEditModel)
{
if (id is null or 0)
{
return(NotFound());
}
//Проверяем, есть ли задача с таким ID.
taskEditModel.Id = (int)id;
var allTask = await _context.AllTask.FindAsync(taskEditModel.Id);
if (allTask == null)
{
return(NotFound());
}
//Проверяем, относятся ли данные к тому пользователю, который авторзован.
if (allTask.UserId != User.FindFirstValue(ClaimTypes.NameIdentifier))
{
return(NotFound());
}
//Передаем в модель представления данные, которые нужно редактировать.
taskEditModel.Title = allTask.Title;
taskEditModel.Description = allTask.Description;
return(View(taskEditModel));
}
public TaskListItemViewModel Create(TaskEditModel editModel)
{
TaskDefinition definition = _taskDefinitionDAO.Get(editModel.DefinitionId);
TimeSpan allowedExposureTime = new TimeSpanFactory().CreateFromStrings(editModel.Hours, editModel.Minutes);
Task task = new Task()
{
Title = editModel.Title,
Role = _roleDAO.Get(editModel.RoleId),
NoiseProtection = _noiseProtectionDAO.Get(editModel.NoiseProtectionId),
NoiseLevelGuideline = Convert.ToDecimal(editModel.NoiseLevelGuideline.Trim(), new CultureInfo("en-US")),
Frequency = editModel.Frequency,
AllowedExposureMinutes = Convert.ToInt32(allowedExposureTime.TotalMinutes),
TaskDefinition = definition,
ButtonPressed = editModel.ButtonPressed,
CultureName = editModel.SelectedCultureName,
};
definition.Tasks.Add(task);
_taskDefinitionDAO.Store(definition);
TaskListItemViewModel viewModel = CreateTaskListItemViewModel(task);
return(viewModel);
}
public async Task EditPostReturnsHttpUnauthorizedResultWhenModelStateIsValidAndUserIsNotAnOrganizationAdminUser()
{
var startDateTime = DateTimeOffset.Now.AddDays(-1);
var endDateTime = DateTimeOffset.Now.AddDays(1);
var model = new TaskEditModel {
StartDateTime = startDateTime, EndDateTime = endDateTime, OrganizationId = 1
};
var mediator = new Mock <IMediator>();
mediator.Setup(x => x.Send(It.IsAny <ActivityByActivityIdQuery>())).Returns(new Activity
{
Campaign = new Campaign {
TimeZoneId = "Eastern Standard Time"
},
StartDateTime = startDateTime.AddDays(-1),
EndDateTime = endDateTime.AddDays(1)
});
var sut = new TaskController(mediator.Object);
sut.SetDefaultHttpContext();
var result = await sut.Edit(model);
Assert.IsType <HttpUnauthorizedResult>(result);
}
public async Task EditPostSendsEditTaskCommandAsyncWhenModelStateIsValidAndUserIsOrganizationAdmin()
{
const int organizationId = 1;
var taskSummaryModel = new TaskSummaryModel {
OrganizationId = organizationId
};
var startDateTime = DateTimeOffset.Now.AddDays(-1);
var endDateTime = DateTimeOffset.Now.AddDays(1);
var model = new TaskEditModel {
StartDateTime = startDateTime, EndDateTime = endDateTime, OrganizationId = organizationId
};
var mediator = new Mock <IMediator>();
mediator.Setup(x => x.Send(It.IsAny <ActivityByActivityIdQuery>())).Returns(new Activity
{
Campaign = new Campaign {
TimeZoneId = "Eastern Standard Time"
}, StartDateTime = startDateTime.AddDays(-1), EndDateTime = endDateTime.AddDays(1)
});
mediator.Setup(x => x.SendAsync(It.IsAny <TaskQueryAsync>())).ReturnsAsync(taskSummaryModel);
var sut = new TaskController(mediator.Object);
MakeUserOrganizationAdminUser(sut, organizationId.ToString());
await sut.Edit(model);
mediator.Verify(x => x.SendAsync(It.Is <EditTaskCommandAsync>(y => y.Task == model)));
}
public void SetUpFixture()
{
taskService = new Mock <ITaskRemoteService>();
var eventAgregator = new Mock <IEventAggregator>();
taskEditStartEvent = new Mock <TaskEditStartedEvent>();
var categoryEditStartedEvent = new Mock <CategoryEditStartedEvent>();
eventAgregator.Setup(x => x.GetEvent <TaskEditStartedEvent>()).Returns(taskEditStartEvent.Object);
eventAgregator.Setup(x => x.GetEvent <CategoryEditStartedEvent>()).Returns(categoryEditStartedEvent.Object);
var mapper = new Mock <IMapper>();
model = new TaskEditModel(taskService.Object, eventAgregator.Object, mapper.Object);
_task = new DomainModel.Task
{
TaskId = Guid.NewGuid(),
TaskName = "Test",
CreationTime = DateTime.Today,
Status = Pinz.DomainModel.TaskStatus.TaskNotStarted,
CategoryId = Guid.NewGuid(),
Category = new Category.CategoryModel()
{
Project = new ProjectModel()
{
ProjectUsers = new ObservableCollection <User>()
}
}
};
}
public IActionResult Update(TaskEditModel task)
{
var newTask = mapper.Map <TaskBase>(task);
taskManager.Change(newTask);
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "TaskId,SprintId,TaskName,TaskDescription,IsDone")] TaskEditModel task)
{
if (!ModelState.IsValid)
{
return(View(task));
}
var taskEntity = db.Task.FirstOrDefault(x => x.TaskId == task.TaskId);
if (taskEntity == null)
{
return(HttpNotFound());
}
taskEntity.SprintId = task.SprintId;
taskEntity.TaskName = task.TaskName;
taskEntity.TaskDescription = task.TaskDescription;
taskEntity.IsDone = task.IsDone;
db.Entry(taskEntity).State = EntityState.Modified;
db.SaveChanges();
ViewBag.SprintId = new SelectList(db.Sprint, "SprintId", "SprintId", task.SprintId);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Edit(TaskEditModel task)
{
int result = await _taskData.EditTask(task.ID, task.Task, task.Description);
if (result < 0)
{
return(BadRequest()); // to test without
}
return(Ok());
}
public ActionResult Edit(TaskEditModel editModel)
{
if (editModel.IsValid() == false)
{
Response.StatusCode = 500;
return(PartialView("_ValidationErrorSummary", new ValidationErrorSummaryViewModel(editModel.GetValidationErrors())));
}
TaskListItemViewModel viewModel = _genericTaskService.Edit(editModel);
return(PartialView("_TaskTableRow", viewModel));
}
public TaskEditView(TaskEditModel model)
{
InitializeComponent();
this.DataContext = model;
RegionContext.GetObservableContext(this).PropertyChanged += (s, e) =>
{
if (RegionContext.GetObservableContext(this).Value != null)
{
model.Task = RegionContext.GetObservableContext(this).Value as Task;
}
};
}
public async Task <IActionResult> TaskEdit(TaskEditModel tEM)
{
if (ModelState.IsValid)
{
_s16693context.Update(tEM.UslugaProjekt);
await _s16693context.SaveChangesAsync();
return(RedirectToAction("ProjectDetails", new { id = tEM.UslugaProjekt.IdProjekt }));
}
else if (!ModelState.IsValid)
{
return(View("TaskEdit", tEM));
}
return(View(tEM));
}
public void Validate_Success()
{
// Arrange
var model = new TaskEditModel
{
Name = "OK"
};
var context = new ValidationContext(model, null, null);
var result = new List <ValidationResult>();
// Act
var valid = Validator.TryValidateObject(model, context, result, true);
// Assert
valid.ShouldBe(true);
}
/// <summary>
/// Method for get TaskEditModel from DBModel.
/// </summary>
/// <param name="TaskId">Current task id</param>
/// <returns></returns>
public TaskEditModel GetTaskEditModel(int TaskId)
{
var model = _dataManager.Tasks.GetTaskById(TaskId);
var editModel = new TaskEditModel()
{
Id = model.Id,
SolutionId = model.SolutionId,
task_status = model.task_status,
TaskName = model.TaskName,
Description = model.Description,
Priority = model.Priority
};
return(editModel);
}
public async Task <IActionResult> TaskDelay(TaskEditModel tEM)
{
if (ModelState.IsValid)
{
DateTime tmpDate = (DateTime)tEM.UslugaProjekt.DataZakonczeniaZadania;
tEM.UslugaProjekt.DataZakonczeniaZadania = tmpDate.AddDays(7);
tEM.UslugaProjekt.Status = "Opóźnione";
_s16693context.Update(tEM.UslugaProjekt);
await _s16693context.SaveChangesAsync();
return(RedirectToAction("ProjectDetails", new { id = tEM.UslugaProjekt.IdProjekt }));
}
else if (!ModelState.IsValid)
{
return(View("TaskEdit", tEM));
}
return(View(tEM));
}
public TaskListItemViewModel Edit(TaskEditModel editModel)
{
Task task = _taskDAO.Get(editModel.Id);
TimeSpan allowedExposureTime = new TimeSpanFactory().CreateFromStrings(editModel.Hours, editModel.Minutes);
task.Title = editModel.Title;
task.NoiseLevelGuideline = Convert.ToDecimal(editModel.NoiseLevelGuideline.Trim(), new CultureInfo("en-US"));
task.AllowedExposureMinutes = Convert.ToInt32(allowedExposureTime.TotalMinutes);
task.Role = _roleDAO.Get(editModel.RoleId);
task.NoiseProtection = _noiseProtectionDAO.Get(editModel.NoiseProtectionId);
task.ButtonPressed = editModel.ButtonPressed;
task.Frequency = editModel.Frequency;
_taskDAO.Store(task);
TaskListItemViewModel viewModel = CreateTaskListItemViewModel(task);
return(viewModel);
}
public void Edit_Post_ErrorHandled()
{
// Arrange
var taskRepoMock = new Mock <IRepository <Task> >();
var controller = new HomeController(taskRepoMock.Object);
var inModel = new TaskEditModel {
Id = 1, Name = "a1"
};
var callbackTask = new Task {
Id = 1, ParentId = 2, Name = "test"
};
taskRepoMock.Setup(r => r.GetByID(1)).Returns(callbackTask);
var ex = new Exception("Cannot insert duplicate key row in object 'dbo.Task' with unique index 'IX_ParentId_Name' some other text");
var dbEx = new System.Data.Entity.Infrastructure.DbUpdateException("", new Exception("", ex));
taskRepoMock.Setup(r => r.Save()).Throws(dbEx);
// Act
var rez = controller.Edit(inModel);
// Assert
taskRepoMock.VerifyAll();
callbackTask.ShouldNotBeNull();
callbackTask.Name.ShouldBe("a1");
controller.ModelState.Count.ShouldBe(1);
controller.ModelState[""].Errors.Single().ErrorMessage.ShouldBe("Task name should be unique on this nesting level");
rez.ShouldBeOfType <ViewResult>();
var modelTemp = ((ViewResult)rez).Model;
modelTemp.ShouldNotBeNull();
modelTemp.ShouldBeOfType <TaskEditModel>();
var model = (TaskEditModel)modelTemp;
model.Id.ShouldBe(1);
model.ParentId.ShouldBe(2);
model.Name.ShouldBe("a1");
}
public async Task EditPostReturnsCorrectViewAndViewModelWhenEndDateTimeIsLessThanStartDateTimeAndModelStateIsInvalid()
{
var model = new TaskEditModel {
EndDateTime = DateTimeOffset.Now.AddDays(-1), StartDateTime = DateTimeOffset.Now.AddDays(1)
};
var mediator = new Mock <IMediator>();
mediator.Setup(x => x.Send(It.IsAny <ActivityByActivityIdQuery>())).Returns(new Activity {
Campaign = new Campaign {
TimeZoneId = "Eastern Standard Time"
}
});
var sut = new TaskController(mediator.Object);
var result = await sut.Edit(model) as ViewResult;
var modelResult = result.ViewData.Model as TaskEditModel;
Assert.IsType <ViewResult>(result);
Assert.Equal(modelResult, model);
}
public async Task CreatePostRedirectsToCorrectAction()
{
const int organizationId = 1;
var taskSummaryModel = new TaskSummaryModel {
OrganizationId = organizationId
};
var startDateTime = DateTimeOffset.Now.AddDays(-1);
var endDateTime = DateTimeOffset.Now.AddDays(1);
const int taskEditModelId = 1;
var model = new TaskEditModel {
Id = taskEditModelId, StartDateTime = startDateTime, EndDateTime = endDateTime, OrganizationId = organizationId
};
var mediator = new Mock <IMediator>();
mediator.Setup(x => x.Send(It.IsAny <ActivityByActivityIdQuery>())).Returns(new Activity
{
Campaign = new Campaign {
TimeZoneId = "Eastern Standard Time"
},
StartDateTime = startDateTime.AddDays(-1),
EndDateTime = endDateTime.AddDays(1)
});
mediator.Setup(x => x.SendAsync(It.IsAny <TaskQueryAsync>())).ReturnsAsync(taskSummaryModel);
var routeValues = new Dictionary <string, object> {
["id"] = model.Id
};
var sut = new TaskController(mediator.Object);
MakeUserOrganizationAdminUser(sut, organizationId.ToString());
var result = await sut.Create(taskEditModelId, model) as RedirectToActionResult;
Assert.Equal(result.ActionName, nameof(TaskController.Details));
Assert.Equal(result.ControllerName, "Activity");
Assert.Equal(result.RouteValues, routeValues);
}
public IActionResult Create(int activityId)
{
var activity = _dataAccess.GetActivity(activityId);
if (activity == null || !User.IsOrganizationAdmin(activity.Campaign.ManagingOrganizationId))
{
return(HttpUnauthorized());
}
var viewModel = new TaskEditModel()
{
ActivityId = activity.Id,
ActivityName = activity.Name,
CampaignId = activity.CampaignId,
CampaignName = activity.Campaign.Name,
OrganizationId = activity.Campaign.ManagingOrganizationId,
TimeZoneId = activity.Campaign.TimeZoneId,
StartDateTime = activity.StartDateTime,
EndDateTime = activity.EndDateTime,
};
return(View("Edit", viewModel));
}
public async Task EditGetReturnsCorrectViewModelAndView()
{
const int organizationId = 1;
var taskEditModel = new TaskEditModel {
OrganizationId = organizationId
};
var mediator = new Mock <IMediator>();
mediator.Setup(x => x.SendAsync(It.IsAny <EditTaskQueryAsync>())).ReturnsAsync(taskEditModel);
var sut = new TaskController(mediator.Object);
MakeUserOrganizationAdminUser(sut, organizationId.ToString());
var result = await sut.Edit(It.IsAny <int>()) as ViewResult;
var modelResult = result.ViewData.Model as TaskEditModel;
Assert.IsType <ViewResult>(result);
Assert.IsType <TaskEditModel>(modelResult);
Assert.Equal(modelResult, taskEditModel);
}
public async Task <IActionResult> Edit(TaskEditModel model)
{
if (model.EndDateTime < model.StartDateTime)
{
ModelState.AddModelError(nameof(model.EndDateTime), "Ending time cannot be earlier than the starting time");
}
WarnDateTimeOutOfRange(ref model);
if (ModelState.IsValid)
{
if (!User.IsOrganizationAdmin(model.OrganizationId))
{
return(HttpUnauthorized());
}
await _mediator.SendAsync(new EditTaskCommandAsync { Task = model });
return(RedirectToAction(nameof(Details), "Task", new { id = model.Id }));
}
return(View(model));
}
