public IActionResult Add(AddTaskViewModel item)
{
_tasks.Add(new TaskItem {
Description = item.Description, Id = Guid.NewGuid(), IsCompleted = false
});
return(Ok());
}
public ActionResult Edit(AddTaskViewModel model)
{
try
{
// validate model state
if (ModelState.IsValid == false)
{
throw new Exception("Invalid task info model");
}
// get current task info
Task task = db.Tasks.Where(t => t.TaskId == model.TaskId).FirstOrDefault();
if (task == null)
{
throw new Exception("Task not found!!!");
}
// update task info
task.TaskName = model.TaskName;
task.Description = model.Description;
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
return(View(model));
}
public async System.Threading.Tasks.Task <IActionResult> OnGetAsync(int id)
{
var defaultRedirections = new DefaultRedirections(this);
if (!User.Identity.IsAuthenticated)
{
return(defaultRedirections.ToLoginPage(HttpContext.Request.Path));
}
var contest = await _context.Contests.FindAsync(id);
var contestOwnerId = contest.IdentityUser.Id;
var currentUserId = _userManager.GetUserId(User);
if (currentUserId != contestOwnerId)
{
return(defaultRedirections.ToAccessDeniedPage(HttpContext.Request.Path));
}
ContestViewModel = CreateContestViewModel(contest);
StatusButtons = CreateStatusButtons(contest.Status);
FormTask = new AddTaskViewModel();
TasksToDisplay = contest.Tasks.Select(MapToDisplayViewModel).ToList();
ContestId = id;
TempData.Keep(nameof(ContestId));
UpdateContestSolutions();
UpdateScorePolicies();
return(Page());
}
public ActionResult AddTask(int id /*id of the contact*/, FormCollection formValues)
{
int taskId = Int32.Parse(formValues["TaskId"]);
//we retrieve the task to add to the contact
Task task = _taskService.GetTask(taskId);
//we retrieve the contact to add the task to
Contact contact = _contactService.GetContact(id);
contact.Tasks.Add(task);
if (!_contactService.EditContact(contact))
{
//we redisplay the form in case something goes wrong
string userName = this.User.Identity.Name;
//we retrieve from the db the tasks of the user, that haven't been assigned to an account yet
var tasks = _taskService.ListTasksByCriteria(t => (t.ResponsibleUser.UserName == userName) &&
(t.Contact == null));
var viewModel = new AddTaskViewModel
{
AccountId = id,
Tasks = new SelectList(tasks, "Id", "Subject", 1)
};
return(View(viewModel));
}
return(View("Details", contact));
}
public ActionResult Edit(int?id)
{
try
{
// get task info
Task task = db.Tasks.Where(t => t.TaskId == id).FirstOrDefault();
if (task == null)
{
ModelState.AddModelError("", "Task not existed!!!");
return(View());
}
// create task model
AddTaskViewModel model = new AddTaskViewModel();
model.TaskId = task.TaskId;
model.TaskName = task.TaskName;
model.Description = task.Description;
return(View(model));
}
catch (Exception ex)
{
return(RedirectToAction("ErrorMessage", "Admin",
new RouteValueDictionary(
new { message = ex.Message })));
}
}
public async Task <ServiceResult> UpdateTask([FromBody] AddTaskViewModel updateTaskModel)
{
var todoTask = await _taskService.GetAsync(updateTaskModel.TaskId.Value);
todoTask.LastModifiedDate = DateTime.Now;
if (!string.IsNullOrEmpty(updateTaskModel.Name))
{
todoTask.Name = updateTaskModel.Name;
}
if (updateTaskModel.TaskStatusId.HasValue)
{
todoTask.TaskStatusId = updateTaskModel.TaskStatusId.Value;
}
var status = await _taskService.UpdateAsync(todoTask);
ServiceResult = new ServiceResult
{
MessageType = status ? Todo.Core.Enums.EMessageType.Success : Todo.Core.Enums.EMessageType.Error,
Message = status ? "Task updated." : "Something went wrong.",
Result = todoTask
};
return(ServiceResult);
}
public async Task <IActionResult> Upsert(int?id)
{
var model = new AddTaskViewModel();
var statuses = await _taskService.GetTaskStatuses();
if (id.HasValue)
{
var task = await _taskService.GetTaskById(id.Value);
if (task.IsSucceeded)
{
model.Task = task.Data;
}
model.PageTitle = _sharedLocalizer["Edit Task"];
}
else
{
model.PageTitle = _sharedLocalizer["Add Task"];
}
model.TaskStatuses = statuses.ToList();
return(PartialView("_Upsert", model));
}
public AddTaskControl(AddTaskViewModel viewModel)
{
InitializeComponent();
this.viewModel = viewModel;
this.DataContext = viewModel;
}
public async Task <IHttpActionResult> AddTask(AddTaskViewModel model)
{
try
{
if (string.IsNullOrWhiteSpace(model.Title))
{
return(BadRequest("The title field cannot be empty."));
}
UserTaskBO userTask = new UserTaskBO
{
Title = model.Title,
Description = model.Description,
DateCreated = DateTime.UtcNow,
UserId = CurrentUserId,
DateUserAccepted = DateTime.UtcNow,
BeginDate = DateTime.UtcNow,
EndDate = DateTime.UtcNow,
Audit = new Entity.Entities.Audit(CurrentUserId)
};
zeus.evaluationManager.Add(userTask);
await AddNotificationAsync(NotificationType.NewTask, CurrentUserId, CurrentUserId, "supervisor/unacceptedtasks");
return(Ok(UserTaskDTO.Map(userTask, zeus)));
}
catch (Exception ex)
{
LogError(ex, CurrentUserId);
return(BadRequest("An Error occured while processing your request, please try again"));
}
}
public ViewModelLocator()
{
navigationService = new NavigationService();
var builder = new ContainerBuilder();
builder.RegisterType <AppViewModel>();
builder.RegisterType <ToDoListViewModel>();
builder.RegisterType <AddTaskViewModel>();
builder.RegisterType <JsonSaveLoadService>().As <ISaveLoadService>().InstancePerLifetimeScope();
builder.RegisterInstance(navigationService).As <INavigationService>();
var container = builder.Build();
using (var scope = container.BeginLifetimeScope())
{
appViewModel = scope.Resolve <AppViewModel>();
toDoListViewModel = scope.Resolve <ToDoListViewModel>();
addTaskViewModel = scope.Resolve <AddTaskViewModel>();
};
MainViewModel = appViewModel;
navigationService.AddPage(toDoListViewModel, VM.ToDoList);
navigationService.AddPage(addTaskViewModel, VM.AddTask);
navigationService.NavigateTo(VM.ToDoList);
}
public IActionResult AddTask(AddTaskViewModel model)
{
List <SubTask> subtasks = new List <SubTask>();
foreach (var subtask in model.SubTasks)
{
subtasks.Add(new SubTask()
{
Title = subtask.Title,
Descrition = subtask.Descrition,
SubStatus = subtask.SubStatus
});
}
ToDo todo = new ToDo()
{
Title = model.Title,
Descrition = model.Description,
ImporanceOfTask = model.ImporanceOfTask,
Status = Status.NotDone,
TypeOfToDo = model.TypeOfTodo,
SubTasks = subtasks
};
_todoService.AddToDo(todo);
return(View("_ThankYou"));
}
public IActionResult AddTask(AddTaskViewModel model)
{
List <SubTask> subtasks = new List <SubTask>();
foreach (var subtask in model.SubTasks)
{
subtasks.Add(new SubTask()
{
Title = subtask.Title,
Description = subtask.Description,
Status = subtask.Status
});
}
ToDoTask todo = new ToDoTask()
{
Title = model.Title,
Description = model.Description,
Priority = model.Priority,
Status = model.Status,
TaskType = model.TypeOfTask,
SubTasks = subtasks
};
_taskService.AddNewTask(todo);
return(View("_AddedTask"));
}
public void Create_add_task_view_model_with_empty_task_model()
{
AddTaskViewModel addTaskViewModel = new AddTaskViewModel(new Messenger.Messenger());
Assert.AreEqual(null, addTaskViewModel.TaskName);
Assert.AreEqual(null, addTaskViewModel.TaskDescription);
}
public IActionResult Add()
{
List <TaskCategory> categories = context.Categories.ToList();
AddTaskViewModel addTaskViewModel = new AddTaskViewModel(categories);
return(View(addTaskViewModel));
}
public ActionResult Add(AddTaskViewModel model)
{
try
{
if (ModelState.IsValid)
{
// create new task
Task task = new Task();
task.TaskId = model.TaskId;
task.TaskName = model.TaskName;
task.Description = model.Description;
// save task
db.Tasks.Add(task);
db.SaveChanges();
return(RedirectToAction("Index"));
}
else
{
throw new Exception("Invalid input data!!!");
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
return(View(model));
}
public AddTaskPage(TodoItem item = null)
{
InitializeComponent();
this.item = item;
addTaskViewModel = new AddTaskViewModel();
BindingContext = addTaskViewModel;
}
public AddTaskWindow(TermsheetViewModel termsheetVM)
{
_addTaskViewModel = new AddTaskViewModel();
_termsheetVM = termsheetVM;
InitializeComponent();
DataContext = _addTaskViewModel;
}
public AddTaskPage()
{
InitializeComponent();
var addTaskViewModel = new AddTaskViewModel(Navigation);
addTaskViewModel.Task.Start = DateTime.Today;
addTaskViewModel.Task.End = DateTime.Today;
BindingContext = addTaskViewModel;
}
public ActionResult Index(AddTaskViewModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
return(RedirectToAction("Index"));
}
public ActionResult Add()
{
AddTaskViewModel task = new AddTaskViewModel();
ViewBag.Priorities = priorities;
ViewBag.Users = GetMembersSelectList();
return(View(task));
}
public void HeaderMessage_User_ContainsUserName()
{
var vm = new AddTaskViewModel(new UserModel()
{
FirstName = "Test"
}, null, null, null);
Assert.Contains("Test", vm.HeaderMessage);
}
public IActionResult AddTask(string returnUrl, int PageID)
{
var model = new AddTaskViewModel()
{
returnUrl = returnUrl, DocPageID = PageID
};
return(View(model));
}
public void Create_add_task_view_model_can_set_properties()
{
AddTaskViewModel addTaskViewModel = new AddTaskViewModel(new Messenger.Messenger());
addTaskViewModel.TaskName = "Name";
addTaskViewModel.TaskDescription = "Description";
Assert.AreEqual("Name", addTaskViewModel.TaskName);
Assert.AreEqual("Description", addTaskViewModel.TaskDescription);
}
public IActionResult AddTask(int subjectId)
{
AddTaskViewModel model = new AddTaskViewModel
{
SubjectId = subjectId,
Deadline = DateTime.Now
};
return(View(model));
}
//ONLY GET TO THIS ACTION AFTER ADDING A TASK
public IActionResult TaskList(AddTaskViewModel model)
{
//TO ACCESS TASK LIST VIEW FROM THE HEADER LINK(rather than routing from ADD TASK VIEW
if (_currentUser.loggedIn == false)
{
var errorModel = new ErrorPageViewModel();
return(View("ErrorPage", errorModel));
}
return(ListItems());
}
public async Task <IActionResult> Add([FromForm] AddTaskViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var command = this.unitOfWork.Create <AddTaskCommand>();
var result = await command.ExecuteAsync(model);
return(Redirect($"/Tasks/Details/{result}"));
}
public void Description_NewDescription_AssignNewDescription()
{
var vm = new AddTaskViewModel(new UserModel()
{
FirstName = "Test"
}, null, null, null);
var expected = "Expected";
vm.Description = expected;
Assert.Equal(expected, vm.Description);
}
public void Priority_NewPriority_AssignNewPriority()
{
var vm = new AddTaskViewModel(new UserModel()
{
FirstName = "Test"
}, null, null, null);
var expected = 3;
vm.Priority = expected;
Assert.Equal(expected, vm.Priority);
}
public void SelectedCategory_NewCategory_AssignNewCategory()
{
var vm = new AddTaskViewModel(new UserModel()
{
FirstName = "Test"
}, null, null, null);
var expected = new CategoryModel();
vm.SelectedCategory = expected;
Assert.Equal(expected, vm.SelectedCategory);
}
public void Deadline_NewDeadline_AssignNewDeadline()
{
var vm = new AddTaskViewModel(new UserModel()
{
FirstName = "Test"
}, null, null, null);
var expected = DateTime.Today;
vm.Deadline = expected;
Assert.Equal(expected, vm.Deadline);
}
