public async Task <IActionResult> CreateAsync(TaskCreateViewModel model)
{
try
{
if (ModelState.IsValid)
{
var currentuser = await _userManager.GetUserAsync(HttpContext.User);
if (User.IsInRole("SuperAdmin") || currentuser.CompanyId == model.CompanyId)
{
model.CreatedDate = DateTime.Now;
model.CreatedBy = User.Identity.Name;
var response = _taskRepository.Create(model);
if (response != null && response.Id != 0)
{
return(RedirectToAction("Details", new { taskid = model.Id }));
}
return(View(model));
}
return(View("NotAuthorized"));
}
// error
return(View(model));
}
catch (Exception ex)
{
_logger.LogError(ex, $"When creaating tasks.");
throw;
}
}
public async Task <IActionResult> Create(TaskCreateViewModel viewModel)
{
if (!ModelState.IsValid)
{
viewModel.AllPriorities = await this.casesService.GetAllCasePrioritiesAsync();
viewModel.AllQueueStatuses = await this.casesService.GetAllQueueStatusesAsync();
viewModel.AllStatuses = await this.casesService.GetAllCaseStatusesAsync();
viewModel.AllTypes = await this.casesService.GetAllCaseTypesAsync();
viewModel.AllWaitingReasons = await this.casesService.GetAllWaitingReasonsAsync();
return(View(viewModel));
}
string userId = usersService.UserManager.GetUserId(User);
int createResult = await tasksService.CreateTaskAsync(viewModel, userId);
if (createResult > 0)
{
await usersService.UpdateUserLastActivityDateAsync(userId);
TempData["TaskCreatedSuccessfully"] = true;
return(LocalRedirect($"/Cases/ViewUpdate/{viewModel.CaseId}#tasks-table"));
}
return(View("Error", new ErrorViewModel()));
}
public async Task <IActionResult> CreateAsync(int boardid)
{
try
{
var currentuser = await _userManager.GetUserAsync(HttpContext.User);
var board = _boardRepository.GetById(boardid);
var BoardUser = _boardRepository.GetUsersofBoard(boardid).ToList();
if (board == null || board.IsDeleted == true)
{
Response.StatusCode = 404;
return(View("../Boards/BoardNotFound", boardid));
}
else if (User.IsInRole("SuperAdmin") || currentuser.CompanyId == board.CompanyId)
{
var taskCreateViewModel = new TaskCreateViewModel()
{
BoardId = board.Id,
Board = board,
CompanyId = board.CompanyId,
AvailableUsers = BoardUser
};
return(View(taskCreateViewModel));
}
return(View("NotAuthorized"));
}
catch (Exception ex)
{
_logger.LogError(ex, $"When getting the create form.");
throw;
}
}
public IActionResult Create(TaskCreateViewModel model)
{
var affectedSectors = new List <TaskSector>();
var sectors = model.AffectedSectors.Split(" ", StringSplitOptions.RemoveEmptyEntries);
foreach (var sector in sectors)
{
var sectorValue = (Sector)Enum.Parse(typeof(Sector), sector);
affectedSectors.Add(new TaskSector
{
Sector = sectorValue
});
}
var task = new Task
{
Title = model.Title,
DueDate = DateTime.Parse(model.DueDate),
Participants = model.Participants,
Description = model.Description,
AffectedSectors = affectedSectors
};
this.taskService.CreateTask(task);
return(this.RedirectToAction("/Home/Index"));
}
public async Task <int> CreateTaskAsync(TaskCreateViewModel viewModel, string userId)
{
CaseTask taskToAdd = new CaseTask
{
ReportedAt = viewModel.ReportedAt,
LastUpdatedUtc = DateTime.UtcNow,
UserId = userId,
CaseId = viewModel.CaseId,
TypeId = viewModel.SelectedTypeId,
StatusId = viewModel.SelectedStatusId,
AssignedProcessor = viewModel.AssignedProcessor,
Notes = viewModel.Notes,
PriorityId = viewModel.SelectedPriorityId,
Queue = viewModel.Queue,
QueueStatusId = viewModel.SelectedQueueStatusId,
ResumeAt = viewModel.ResumeAt,
Subject = viewModel.Subject,
WaitingReasonId = viewModel.SelectedWaitingReasonId,
};
dbContext.Tasks.Add(taskToAdd);
int result = await dbContext.SaveChangesAsync();
await casesService.UpdateCaseAsync(taskToAdd);
return(result);
}
// GET: Tasks/Create
public ActionResult Create(int?id)
{
//Ensure valid input
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "No Feature Id presented."));
}
//Find feature in database
var feature = _db.Features.Find(id);
if (feature == null)
{
return(HttpNotFound("Feature not found."));
}
//TODO: Ensure user is allowed access to this project
//Create view model and return
var model = new TaskCreateViewModel()
{
FeatureId = feature.Id
};
return(View("_Create", model));
}
public IActionResult Create(TaskCreateViewModel model)
{
if (!this.IsAuthenticated())
{
return(RedirectToAction("/users/login"));
}
if (!this.IsAdmin())
{
return(RedirectToAction("/users/login"));
}
var affectedSectors = new List <TaskSector>();
var sectors = model.AffectedSectors.Split(", ", StringSplitOptions.RemoveEmptyEntries);
foreach (var sector in sectors)
{
var sectorValue = (Sector)Enum.Parse(typeof(Sector), sector);
affectedSectors.Add(new TaskSector()
{
Sector = sectorValue
});
}
Task task = new Task
{
AffectedSectors = affectedSectors,
Description = this.DecodeString(model.Description),
DueDate = DateTime.Parse(model.DueDate),
Participants = this.DecodeString(model.Participants),
Title = this.DecodeString(model.Title)
};
this.taskService.CreateTask(task);
return(this.RedirectToAction("/"));
}
public async Task <IActionResult> Create(string btnAddTask)
{
var dbUsers = await _repo.GetUsersAsync();
IEnumerable <SelectListItem> users = dbUsers.Select(x => new SelectListItem
{
Text = x.UserName,
Value = x.UserName
});
var projects = await _repo.GetProjectsAsync(filter : false);
IEnumerable <SelectListItem> projectsToSelect = projects.Select(x => new SelectListItem
{
Text = x.Name,
Value = x.ID.ToString(),
});
var viewModel = new TaskCreateViewModel
{
availableOwners = users,
StartDate = DateTime.Today,
EstimatedEndDate = DateTime.Today,
availableProjects = projectsToSelect.Where(x => x.Value == btnAddTask)
};
return(View(viewModel));
}
public async Task <IActionResult> Create(TaskCreateViewModel vm)
{
try
{
if (ModelState.IsValid)
{
UserTask task = new UserTask()
{
Id = vm.Id, Name = vm.Name
};
await _taskService.Add(task);
return(RedirectToAction("Index"));
}
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists " +
"see your system administrator.");
}
return(View(vm));
}
// GET: TaskerTasks/Create
public async Task <IActionResult> Create()
{
var vm = new TaskCreateViewModel()
{
AddressSelectList = new SelectList(await _bll.Addresses.AllAsync(),
nameof(BLL.App.DTO.Address.Id),
nameof(BLL.App.DTO.Address.Id))
};
return(View(vm));
}
public ActionResult Create(TaskCreateViewModel model)
{
if (this.ModelState.IsValid)
{
Task task = model.ToEntity();
this.Storage.GetRepository <ITaskRepository>().Create(task, this.GetCurrentUserName());
this.Storage.Save();
return(RedirectToAction("Index"));
}
return(View(model));
}
public IActionResult Post(TaskCreateViewModel model)
{
if (this.ModelState.IsValid)
{
Task task = model.ToEntity();
var repo = this.Storage.GetRepository <ITaskRepository>();
repo.Create(task, GetCurrentUserName());
this.Storage.Save();
return(Ok(new { success = true }));
}
return(BadRequest(new { success = false }));
}
public IActionResult Create(TaskCreateViewModel model)
{
if (ModelState.IsValid)
{
ToDoTask _newTask = new ToDoTask
{
TaskName = model.TaskName,
TaskDescription = model.TaskDescription,
TaskActive = model.TaskActive
};
_taskRepository.Add(_newTask);
return(RedirectToAction("Details", new { id = _newTask.TaskID }));
}
return(View());
}
public async Task <IActionResult> Create(string projectId, TaskCreateViewModel newTaskVM)
{
int projId = _project.UnprotectProjectId(projectId);
newTaskVM.Task.MemberId = _member.GetMemberId(User);
newTaskVM.Task.ProjectId = projId;
Task newTask = await _task.AddAsync(newTaskVM.Task);
Project project = await _project.GetProjectByIdAsync(projId);
await _project.UpdateAsync(project);
return(RedirectToAction("Index", new { projectId = projectId }));
}
public async Task <IActionResult> Create(TaskCreateViewModel vm)
{
if (ModelState.IsValid)
{
_bll.Tasks.Add(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 ActionResult Delete(TaskCreateViewModel model)
{
try
{
ToDoTask _newTask = new ToDoTask();
_newTask = _taskRepository.Details(model.TaskID);
_taskRepository.Delete(_newTask);
return(RedirectToAction("index", "task"));
}
catch
{
return(View());
}
}
public async Task <IActionResult> Details(int id)
{
UserTask task = await _taskService.Get(id);
if (task == null)
{
return(RedirectToAction("Index"));
}
TaskCreateViewModel vm = new TaskCreateViewModel()
{
Id = task.Id, Name = task.Name, Priority = task.Priority
};
return(View(vm));
}
public async Task <bool> TrySaveCreateTaskViewModelAsync(TaskCreateViewModel taskCreateViewModel)
{
try
{
var task = _mapper.Map <TaskCreateViewModel, TaskModel>(taskCreateViewModel);
_dbContext.Tasks.Add(task);
await _dbContext.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
return(false);
}
}
public IHttpResponse Create(TaskCreateViewModel model)
{
var affectedSectors = new List <TaskSector>();
var sectors = new List <string>()
{
model.AffectedSectorsCustomers?.ToString(),
model.AffectedSectorsFinances?.ToString(),
model.AffectedSectorsInternal?.ToString(),
model.AffectedSectorsManagement?.ToString(),
model.AffectedSectorsMarketing?.ToString()
};
foreach (var sector in sectors)
{
if (sector == null)
{
continue;
}
if (!Enum.TryParse(sector, out Sector sectorValue))
{
return(this.BadRequestError("Invalid sector!"));
}
affectedSectors.Add(new TaskSector
{
Sector = sectorValue,
SectorId = (int)sectorValue
});
}
var task = new Task
{
Title = model.Title,
DueDate = DateTime.Parse(model.DueDate),
Participants = model.Participants,
Description = model.Description,
AffectedSectors = affectedSectors
};
this.db.Tasks.Add(task);
this.db.SaveChanges();
return(this.Redirect($"/Tasks/Details?id={task.Id}"));
}
public async Task <IActionResult> Edit(string projectId, string taskId)
{
int tId = _task.UnprotectTaskId(taskId);
var task = await _task.GetTaskAsync(tId);
TaskCreateViewModel taskVM = new TaskCreateViewModel();
taskVM.ProjectId = projectId;
taskVM.Task = task;
taskVM.TaskStatuses = await _taskStatus.GetAllTaskStatusAsync();
(await _projectMember.GetAllMembersForProjectAsync(task.ProjectId))
.ForEach(pm => taskVM.MembersPartOfProject.Add(pm.Member));
taskVM.MembersAvailableToAdd = (await _member.GetAllMembersAsync())
.Where(m => m.Id != task.MemberId)
.ToList();
List <TaskMember> taskMembers = await _taskMember.GetAllMembersForTaskAsync(tId);
taskMembers.ForEach(tm => taskVM.MembersAvailableToRemove.Add(tm.Member));
foreach (Member memberAvailableToAdd in taskVM.MembersAvailableToAdd.ToList())
{
Member projectMember = taskVM.MembersPartOfProject.FirstOrDefault(pm => pm.Id == memberAvailableToAdd.Id);
if (projectMember != null)
{
taskVM.MembersAvailableToAdd.Remove(memberAvailableToAdd);
continue;
}
TaskMember taskMember = taskMembers.FirstOrDefault(tm => tm.MemberId == memberAvailableToAdd.Id);
if (taskMember != null)
{
taskVM.MembersAvailableToAdd.Remove(memberAvailableToAdd);
taskMembers.Remove(taskMember);
}
}
taskVM.MembersAvailableToAdd = taskVM.MembersAvailableToAdd.OrderBy(m => m.GetFullName).ToList();
taskVM.MembersAvailableToRemove = taskVM.MembersAvailableToRemove.OrderBy(m => m.GetFullName).ToList();
return(View(taskVM));
}
public async Task <IActionResult> Edit(string projectId, string taskId, TaskCreateViewModel editTaskVM)
{
int tId = _task.UnprotectTaskId(taskId);
int projId = _project.UnprotectProjectId(projectId);
await _task.UpdateAsync(editTaskVM.Task);
Project project = await _project.GetProjectByIdAsync(projId);
await _project.UpdateAsync(project);
await _taskMember.AddMembersAsync(tId, editTaskVM.TaskMemberIdsToAdd);
await _taskMember.RemoveMembersAsync(tId, editTaskVM.TaskMemberIdsToRemove);
return(RedirectToAction("Index", new { projectId = projectId }));
}
public IHttpResponse Create(TaskCreateViewModel model)
{
var task = new Task
{
Title = model.Title,
IsReported = false,
Participants = model.Participants,
Description = model.Description,
};
if (model.DueDate != "")
{
task.DueDate = DateTime.Parse(model.DueDate);
}
var sectors = new[] { model.Marketing, model.Management, model.Internal, model.Finances, model.Customers, };
foreach (var sector in sectors)
{
if (Enum.TryParse(sector, out Sector currentSector))
{
var taskSector = new TaskSector()
{
Task = task,
Sector = currentSector,
};
task.Sectors.Add(taskSector);
this.DbContext.TasksSectors.Add(taskSector);
}
}
this.DbContext.Tasks.Add(task);
try
{
this.DbContext.SaveChanges();
}
catch (Exception e)
{
return(this.ServerError(e.Message));
}
return(this.Redirect("/"));
}
public async Task <ActionResult> Create(TaskCreateViewModel model)
{
//Ensure valid input
if (!ModelState.IsValid)
{
return(View("_Create", model));
}
//Find feature
var feature = _db.Features.Find(model.FeatureId);
if (feature == null)
{
return(HttpNotFound("Feature not found."));
}
//TODO: Ensure user is allowed access to this project
//Create new task
var task = new ScrumTask()
{
Title = model.Title,
Description = model.Description,
State = model.State,
TimeRemaining = model.TimeRemaining,
Priority = feature.Tasks.Count + 1,
};
try
{
//Save new feature
feature.Tasks.Add(task);
await _db.SaveChangesAsync();
return(Json(new { success = true }));
}
catch (Exception exception)
{
model.Error = exception.Message;
return(View("_Create", model));
}
}
public ActionResult Edit(int id)
{
ToDoTask _newTask = _taskRepository.Details(id);
if (_newTask == null)
{
Response.StatusCode = 404;
return(View("TaskNotFound", id));
}
TaskCreateViewModel taskCreateViewModel = new TaskCreateViewModel()
{
TaskID = _newTask.TaskID,
TaskName = _newTask.TaskName,
TaskDescription = _newTask.TaskDescription,
TaskActive = _newTask.TaskActive
};
return(View("~/Views/Task/Edit.cshtml", taskCreateViewModel));
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
UserTask task = await _taskService.Get((int)id);
if (task == null)
{
return(NotFound());
}
TaskCreateViewModel vm = new TaskCreateViewModel()
{
Id = task.Id, Name = task.Name, Priority = task.Priority
};
return(View(vm));
}
public async Task <ActionResult> Create(TaskCreateViewModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
var course = _db.CourseManager.Get(c => c.Id == model.CourseId);
var newTask = new Task(model)
{
CourseId = model.CourseId,
Course = course
};
if (_db.TaskManager.Add(User.Identity.GetUserId(), newTask))
{
await(new NewTaskNotification(course.Users.Select(u => u.User), newTask, Request.RequestContext)).Send();
return(RedirectToAction("Index", "Courses", new { courseId = model.CourseId }));
}
ModelState.AddModelError("", @"Ошибка при обновлении базы данных");
return(View());
}
public async Task <IActionResult> Create(string projectId)
{
var taskStatuses = await _taskStatus.GetDefaultTaskStatusAsync();
if (taskStatuses == 0)
{
ViewBag.ErrorTitle = "No Task Statuses or Default Task Status";
ViewBag.ErrorMessage = "Please create Task Statuses or set a default Task Status by clicking " +
"<a href=\"/TaskStatus\" class=\"text-primary\"><u>here</u></a>";
return(View("Error"));
}
TaskCreateViewModel taskVM = new TaskCreateViewModel();
taskVM.Task.StatusId = taskStatuses;
taskVM.TaskStatuses = await _taskStatus.GetAllTaskStatusAsync();
taskVM.ProjectId = projectId;
return(View(taskVM));
}
public ActionResult Edit(TaskCreateViewModel model)
{
try
{
ToDoTask _newTask = new ToDoTask();
_newTask = _taskRepository.Details(model.TaskID);
if (ModelState.IsValid && _newTask != null)
{
_newTask.TaskID = model.TaskID;
_newTask.TaskName = model.TaskName;
_newTask.TaskDescription = model.TaskDescription;
_newTask.TaskActive = model.TaskActive;
}
_taskRepository.Update(_newTask);
//return RedirectToAction("Details", model.TaskID);
return(RedirectToAction("Details", new { id = model.TaskID }));
}
catch
{
return(View());
}
}
public async Task <IActionResult> Edit(TaskCreateViewModel vm)
{
var task = await _taskService.Get(vm.Id);
try
{
task.Name = vm.Name;
task.Priority = vm.Priority;
await _taskService.Update(task);
return(RedirectToAction("Index"));
}
catch (DbUpdateException /* ex */)
{
//Log the error (uncomment ex variable name and write a log.)
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists, " +
"see your system administrator.");
}
return(View());
}
public ActionResult Create()
{
var model = new TaskCreateViewModel();
return(View(model));
}
