public async Task <IActionResult> EditTask(Guid id, Guid assignmentId, EditTaskViewModel model)
{
if (ModelState.IsValid)
{
ATask task = await _taskService.GetTaskById(id);
AppUser currentUser = _userManager.GetUserAsync(User).Result;
task.Title = model.Title;
task.Description = model.Description;
task.ATaskStatus = model.ATaskStatus;
if (model.ATaskStatus == CompletionStatus.Done)
{
task.CompleteTime = DateTime.Now;
}
await _taskService.EditTask(task);
if (await _userManager.IsInRoleAsync(currentUser, "Manager"))
{
if (assignmentId != null && assignmentId != Guid.Empty)
{
return(RedirectToAction("CreateAssignmentTask", "ATask", new { assignmentId }));
}
return(RedirectToAction("GetCompanyTasks", "ATask"));
}
else if (await _userManager.IsInRoleAsync(currentUser, "Member"))
{
return(RedirectToAction("GetMemberAssignmentsTasks", "Member"));
}
return(RedirectToAction("GetAllTasks", "ATask"));
}
return(View(model));
}
public EditTaskView()
{
EditTaskViewModel dataContext = (EditTaskViewModel)ViewModelLocatorService.GetViewModel(GetType());
DataContext = dataContext;
InitializeComponent();
}
public virtual ActionResult Add(int companyId, int contactId = 0)
{
var companyByIdQuery = _serviceFactory.GetService <CompanyByIdQuery>();
// Retrieve the specified company value
var company = companyByIdQuery.WithCompanyId(companyId).RequestedByUserId(CurrentUserId).Execute();
if (company == null)
{
ViewBag.EntityType = "Company";
return(View(MVC.Shared.Views.EntityNotFound));
}
// Form the view model
var model = new EditTaskViewModel(company);
model.AvailableCategoryList = _serviceFactory.GetService <CategoriesAvailableForTasksQuery>().Execute();
if (contactId != 0)
{
model.Contact = new ContactSummaryViewModel(
_serviceFactory.GetService <ContactByIdQuery>()
.WithContactId(contactId)
.RequestedByUserId(CurrentUserId)
.Execute());
model.AssociatedContactId = contactId;
}
// Create contact list
CreateCompanyContactList(contactId, company, model);
return(View(MVC.Task.Views.Edit, model));
}
public EditTaskViewModel BuildEditorViewModel(TaskPart part)
{
var possibleParents = _contentManager.Query(ContentTypes.Task)
.List <TaskPart>()
.Where(taskPart => !taskPart.Id.Equals(part.Id))
.ToList();
var projects = _contentManager.Query(ContentTypes.Project)
.List <ProjectPart>();
var viewModel = new EditTaskViewModel
{
Deadline = part.Deadline,
ElapsedTime = part.ElapsedTime,
EstimatedTime = part.EstimatedTime,
IsSubtask = part.IsSubtask,
PossibleParents = possibleParents,
Projects = projects
};
if (part.ParentRecord != null)
{
viewModel.ParentId = part.ParentRecord.Id.ToString();
}
if (part.ProjectRecord != null)
{
viewModel.ProjectId = part.ProjectRecord.Id.ToString();
}
return(viewModel);
}
public ActionResult Show(int?id)
{
EditTaskViewModel model = null;
TaskService taskRep = new TaskService();
Task task = id.HasValue ? taskRep.GetTaskById(id.Value, includeAssigners: true) : null;
if (task != null)
{
model = new EditTaskViewModel()
{
Id = task.Id,
Status = task.Status.Value,
Name = task.Name,
Number = task.Number,
Priority = task.Priority.Value,
ExpBeginDate = task.ExpBeginDate,
ExpEndDate = task.ExpEndDate,
AssignedTo = task.AssignedToUsers == null ? "NULL" : task.AssignedToUsers.FirstOrDefault().UserId.ToString(),
Desription = task.Description
};
ViewBag.IsAdmin = new UserService().IsUserAdmin(new User()
{
Id = User.Identity.GetUserId <int>()
});
ViewBag.Priorities = priorities;
ViewBag.Users = GetMembersSelectList();
}
return(View(model));
}
public ActionResult Edit(EditTaskViewModel tvm)
{
tvm.AdminID = Convert.ToInt32(Session["CurrentUserID"]);
tvm.DateOfTask = DateTime.Now;
if (ModelState.IsValid)
{
if (Request.Files.Count >= 1)
{
var File = Request.Files[0];
var ImgByte = new Byte[File.ContentLength - 1];
File.InputStream.Read(ImgByte, 0, ImgByte.Length);
var Base64String = Convert.ToBase64String(ImgByte, 0, ImgByte.Length);
tvm.Attachments = Base64String;
}
this.ts.UpdateTask(tvm);
}
else
{
int SessionID = Convert.ToInt32(Session["CurrentUserID"]);
ModelState.AddModelError("x", "Invalid");
List <Projects> projects = db.projects.Where(temp => temp.AdminID == SessionID).ToList();
List <Users> users = db.users.Where(temp => temp.Role != "Admin").ToList();
ViewBag.Projects = projects;
ViewBag.User = users;
return(View());
}
return(RedirectToAction("Index", "Task", new { area = "Admin" }));
}
public Tasks EditTask(Tasks entity, EditTaskViewModel model)
{
var repo = _uow.GetService <ITasksRepository>();
repo.Edit(entity, model);
return(entity);
}
public void UpdateTaskForContentItem(ContentItem contentItem, EditTaskViewModel viewModel)
{
var taskPart = contentItem.As <TaskPart>();
taskPart.Deadline = viewModel.Deadline;
taskPart.ElapsedTime = viewModel.ElapsedTime;
taskPart.EstimatedTime = viewModel.EstimatedTime;
taskPart.IsSubtask = viewModel.IsSubtask;
if (viewModel.ProjectId != "" && !viewModel.IsSubtask)
{
taskPart.ProjectRecord = _contentManager.Query(ContentTypes.Project)
.List <ProjectPart>()
.FirstOrDefault(project => project.Id.ToString().Equals(viewModel.ProjectId))
.Record;
}
if (viewModel.ParentId != "" && viewModel.IsSubtask)
{
taskPart.ParentRecord = _contentManager.Query(ContentTypes.Task)
.List <TaskPart>()
.FirstOrDefault(task => task.Id.ToString().Equals(viewModel.ParentId))
.Record;
}
}
public virtual ActionResult Edit(int id)
{
// Retrieve the task
var taskByIdQuery = _serviceFactory.GetService <TaskByIdQuery>();
var task = taskByIdQuery.WithTaskId(id).RequestedByUserId(CurrentUserId).Execute();
if (task == null)
{
ViewBag.EntityType = "Task";
return(View(MVC.Shared.Views.EntityNotFound));
}
// Get the list of available task categories
var categories = _serviceFactory.GetService <CategoriesAvailableForTasksQuery>().Execute();
// Form the view model
var model = new EditTaskViewModel(task);
model.AvailableCategoryList = categories;
// Create contact list
CreateCompanyContactList(Convert.ToInt32(task.ContactId), task.Company, model);
return(View(MVC.Task.Views.Edit, model));
}
public async Task <ActionResult> Edit(EditTaskViewModel editedTask)
{
UserTask task = new UserTask();
task.TaskParticipants = _factory.UserFriendsRepository.GetUsersFriends(User.Identity.GetUserId()).Select(x => new TaskParticipant
{
UserTask = task,
ParticipantId = x.FriendId.ToString()
}).ToList();
task.Latitude = editedTask.Latitude;
task.Longitude = editedTask.Longitude;
task.Place = editedTask.Place;
task.TaskDescription = editedTask.TaskDescription;
task.TaskName = editedTask.TaskName;
task.TaskState = editedTask.TaskState;
task.Time = editedTask.Time;
task.UserId = User.Identity.GetUserId();
if (ModelState.IsValid)
{
_factory.UserTaskRepository.Add(task);
foreach (TaskParticipant participant in task.TaskParticipants)
{
_factory.TaskParticipantrepository.Add(participant);
}
return(RedirectToAction("Index", "Home"));
}
return(View(task));
}
private void prepareEditModel(EditTaskViewModel model)
{
model.BusinessUnitList = LookupService.FindLOVItemsListItemModel(CurrentCompany, LOVName.BusinessUnit);
model.TaskTypeList = LookupService.FindLOVItemsListItemModel(null, LOVName.TaskType);
model.StatusList = LookupService.FindLOVItemsListItemModel(null, LOVName.TaskStatus);
model.UserList = MembershipManagementService.FindUserListItemModel();
}
public async ASYNC.Task <IActionResult> Edit(EditTaskViewModel model, int id)
{
if (id != model.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
await this.taskService.Edit(model, id);
}
catch (DbUpdateConcurrencyException)
{
//Handle error
throw;
}
}
return(RedirectToAction("Details", new RouteValueDictionary(new
{
controller = "Topics",
action = "Details",
Id = model.TopicId
})));
}
public Tasks Edit(Tasks entity, EditTaskViewModel editModel)
{
entity.Name = editModel.Name;
entity.TaskContent = editModel.TaskContent;
entity.Deadline = editModel.Deadline?.ToUniversalTime();
return(entity);
}
public IActionResult Edit(int?taskId)
{
var task = _db.Tasks.Include("AdditionalFiles.Files").Include(x => x.WorkPeriods).Include("Activities.List")
.Include("Comments.List.Autor.User").Include(x => x.BaseTask).Include("Assignee.User").Include(x => x.Team).Include(x => x.Subtasks).FirstOrDefault(x => x.Id == taskId);
var vm = new EditTaskViewModel();
vm.Task = task;
var userId = _userManager.GetUserId(HttpContext.User);
var user = _db.Users.FirstOrDefault(x => x.Id == userId);
var participant = _db.Participants.Include(x => x.Project).ThenInclude(x => x.Departments).ThenInclude(x => x.Teams).ThenInclude(x => x.Participants).
ThenInclude(x => x.User).FirstOrDefault(x => (x.Project.Id == user.LastSelectedProjectId) & (x.User.Id == user.Id));
if ((task.Assignee != null) && (task.Assignee.Id == participant.Id))
{
vm.IsMyTask = true;
var activePeriod = task.WorkPeriods.FirstOrDefault(x => x.Finished == false);
if (activePeriod != null)
{
vm.HaveActivePeriod = true;
}
vm.AlreadySpentTime = task.WorkPeriods.Where(x => x.Finished)
.Sum(x => (x.End.Subtract(new DateTime(1970, 1, 1)).TotalMilliseconds) - (x.Start.Subtract(new DateTime(1970, 1, 1)).TotalMilliseconds));
vm.AlreadySpentTime += activePeriod != null?DateTime.Now.Subtract(activePeriod.Start).TotalMilliseconds : 0;
}
else if (task.Team.Id == participant.Team?.Id)
{
vm.CanIAssingThisTask = true;
}
return(View(vm));
}
public async ASYNC.Task <IActionResult> Edit(int id)
{
var task = await this.taskService.GetById(id);
var student = await this.userService.GetUserById(task.StudentId);
if (task == null)
{
return(NotFound());
}
var taskModel = new EditTaskViewModel()
{
Id = task.Id,
FirstName = student.FirstName,
LastName = student.LastName,
FacultyNumber = student.FacultyNumber,
MainTask = task.MainTask,
OutputData = task.OutputData,
CreatedOn = task.CreatedOn,
DueDate = task.DueDate,
IsApproved = task.IsApproved,
StudentId = task.StudentId,
TopicId = task.TopicId,
};
return(View(taskModel));
}
//Controller is used to get data on the update form.
//Call through JQuerry.
public IActionResult EditTaskModal(int userId)
{
var user = _taskAppService.GetTaskById(userId);
var model = new EditTaskViewModel(user);
return(View("_TaskEditModal", model));
}
public ActionResult UpdateTask(EditTaskViewModel taskView)
{
if (!ModelState.IsValid)
{
List <UserSelectViewModel> userList = new List <UserSelectViewModel>();
TaskModel model = _dataManager.FindTaskById(taskView.Id);
var usersOnProject = _dataManager.GetProjectTeam(model.ProjectId);
foreach (var userModel in usersOnProject)
{
var selectUser = Mapper.Map <UserSelectViewModel>(userModel);
userList.Add(selectUser);
}
taskView.UserList = userList;
taskView.PriorityType = TaskPriority.List;
taskView.TaskStateList = TaskState.List;
return(PartialView("EditTask", taskView));
}
TaskModel taskModel = Mapper.Map <TaskModel>(taskView);
if (taskModel.Status.Equals(TaskState.Finished))
{
taskModel.TaskCompletionDate = DateTime.Today;
}
_dataManager.UpdateTask(taskModel);
_dataManager.SaveChanges();
return(RedirectToAction("ViewProject", "Projects", new { Id = taskModel.ProjectId }));
}
public ActionResult Edit(string taskId)
{
List <UserFriend> friends = _factory.UserFriendsRepository.GetUsersFriends(User.Identity.GetUserId()).ToList();
UserTask task = _factory.UserTaskRepository.FindById(taskId);
EditTaskViewModel editTaskViewModel = new EditTaskViewModel();
editTaskViewModel.Latitude = task.Latitude;
editTaskViewModel.Longitude = task.Longitude;
editTaskViewModel.Place = task.Place;
editTaskViewModel.TaskDescription = task.TaskDescription;
editTaskViewModel.TaskName = task.TaskName;
editTaskViewModel.TaskParticipants = friends.Select(x => new AddTaskParticipantViewModel()
{
FullName = _factory.UserRepository.FindById(x.FriendId.ToString()).UserName,
UserId = x.FriendId.ToString(),
IsChecked = false
}).ToList();
foreach (AddTaskParticipantViewModel addTaskParticipantViewModel in editTaskViewModel.TaskParticipants)
{
foreach (TaskParticipant participant in task.TaskParticipants)
{
if (participant.ParticipantId.ToString() == addTaskParticipantViewModel.UserId)
{
addTaskParticipantViewModel.IsChecked = true;
}
}
}
editTaskViewModel.TaskState = task.TaskState;
editTaskViewModel.Time = task.Time;
editTaskViewModel.TaskId = task.TaskId;
editTaskViewModel.UserId = task.UserId;
return(View(editTaskViewModel));
}
public async ASYNC.Task Edit(EditTaskViewModel model, int id)
{
// Try to make it async
Task taskToUpdate = await this.GetById(id);
Topic topicToUpdate = await this.topicService.GetById(model.TopicId);
ApplicationUser student = await this.userService.GetUserById(model.StudentId);
// Fix error handling (but in controller)
// Think about asynchronously updating the database
taskToUpdate.MainTask = model.MainTask;
taskToUpdate.OutputData = model.OutputData;
taskToUpdate.DueDate = model.DueDate;
taskToUpdate.IsApproved = model.IsApproved;
if (model.IsApproved)
{
topicToUpdate.StudentId = model.StudentId;
student.TopicId = model.TopicId;
}
this.context.Tasks.Update(taskToUpdate);
this.context.Topics.Update(topicToUpdate);
this.context.Users.Update(student);
this.context.SaveChanges();
}
public async Task <ActionResult> Edit(EditTaskViewModel model)
{
if (ModelState.IsValid)
{
Tasks task = await db.Tasks.Include(t => t.Users).SingleAsync(t => t.Id == model.Id);
if (task == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
task.Name = model.Name;
task.State = model.State;
task.Statement = model.Statement;
task.Users = db.Users.Where(u => model.UsersId.Contains(u.Id)).ToList();
task.DateOfUpdate = DateTime.Now;
task.ProjectId = model.ProjectId;
db.Entry(task).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(model));
}
private void TaskEditStart(Task obj)
{
var taskEditViewModel = new EditTaskViewModel(obj, _dataService, _estimateService);
var taskEditView = new EditTaskViewWindow();
taskEditView.ViewModel = (taskEditViewModel);
taskEditView.Show();
}
public void UpdateTask(EditTaskViewModel tvm)
{
var Config = new MapperConfiguration(cfg => { cfg.CreateMap <EditTaskViewModel, Tasks>(); });
IMapper mapper = Config.CreateMapper();
Tasks tasks = mapper.Map <EditTaskViewModel, Tasks>(tvm);
tr.UpdateTask(tasks);
}
public void UpdateTask(EditTaskViewModel etvm)
{
var task = _context.Tasks.Where(x => x.TasksId == etvm.TasksId).FirstOrDefault();
task.Lines = etvm.Lines;
_context.SaveChanges();
}
public IActionResult CreateTask([FromBody] EditTaskViewModel newTask)
{
string author = HttpContext.User.Identity.Name;
taskService.CreateTask(mapper.Map <EditTaskViewModel, EditTaskDTO>(newTask), author, newTask.AssigneeId, newTask.Priority);
Log.Information($"Task was been created by the manager with UserName: {author}");
return(Ok(new { message = "Task has created!" }));
}
public IActionResult UpdateTask(int id, [FromBody] EditTaskViewModel taskUpdate)
{
string author = HttpContext.User.Identity.Name;
var task = mapper.Map <EditTaskViewModel, EditTaskDTO>(taskUpdate);
taskService.UpdateTask(task, id, author, taskUpdate.AssigneeId, taskUpdate.Priority);
Log.Information($"Task with Id: {id} was been updated by the manager with UserName: {author}");
return(Ok(new { message = "Task has changed" }));
}
protected override DriverResult Editor(TaskPart part, Orchard.ContentManagement.IUpdateModel updater, dynamic shapeHelper)
{
var viewModel = new EditTaskViewModel();
updater.TryUpdateModel(viewModel, Prefix, null, null);
if (part.ContentItem.Id != 0)
_taskService.UpdateTaskForContentItem(part.ContentItem, viewModel);
return Editor(part, shapeHelper);
}
public void StartDialog()
{
EditTaskViewModel etvm = new EditTaskViewModel(currentTask);
etvm.EditResult += (res) =>
{
EndEvent?.Invoke(res);
};
presenter.ShowPage(etvm);
}
public ActionResult AddEditTask(int id)
{
var model = new EditTaskViewModel();
model.Task = TaskManagerService.FindTaskModel(id, CurrentCompany, CurrentUser, true);
prepareEditModel(model);
model.LGS = TaskManagerService.LockTask(model.Task);
return(View("AddEditTask", model));
}
public async Task <IActionResult> UpdateTask(EditTaskViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(View("EditTask", viewModel));
}
return(await tasksManager.UpdateTask(viewModel.Id, viewModel.Description, viewModel.DateDeadline)
? (IActionResult)RedirectToAction("Index", "Tasks").PushAlert("Task was updated")
: View(viewModel.WithAlert("Updating task failed")));
}
public IActionResult UpdateTask([Bind("TasksId, Lines")] EditTaskViewModel etvm)
{
try
{
_repository.UpdateTask(etvm);
return(RedirectToAction("Index"));
} catch
{
return(View());
}
}
