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)); }