public IHttpResponse Details(int id)
{
var task = this.DbContext.Tasks.FirstOrDefault(t => t.Id == id);
if (task == null)
{
return(this.BadRequestErrorWithView($"Task with id {id} does not exist."));
}
var taskDetailsViewModel = new TaskDetailsViewModel
{
Title = task.Title,
Level = task.Sectors.Count(),
Participants = task.Participants,
Description = task.Description,
AffectedSectors = string.Join(", ", task.Sectors.Select(s => s.Sector)),
};
if (task.DueDate != null)
{
taskDetailsViewModel.DueDate = task.DueDate.Value.ToString("dd/MM/yyyy", CultureInfo.InvariantCulture);
}
return(this.View(viewName: "TaskDetails", model: taskDetailsViewModel));
}
public IActionResult Details(TaskDetailsViewModel viewModel)
{
if (viewModel.Task.Status == Strings.TaskStatus.Closed)
{
viewModel.Task.Completed = DateTime.Now;
}
if (viewModel.AddComment && !string.IsNullOrEmpty(viewModel.CommentBody))
{
var comment = new TaskCommentModel
{
Timestamp = DateTime.Now,
TaskID = viewModel.Task.ID,
UserID = Utils.GetUserID(User),
Body = viewModel.CommentBody
};
var commentHistory = viewModel.Task.AddHistory($"{User.Identity.Name} added a comment");
_database.TaskComments.Add(comment);
_database.TaskHistory.Add(commentHistory);
}
var updateHistory = viewModel.CreateUpdateHistory(User.Identity.Name);
updateHistory.ForEach(uh => _database.TaskHistory.Add(uh));
_database.Tasks.Update(viewModel.Task);
_database.SaveChanges();
return(RedirectToAction("Details", new { id = viewModel.Task.ID }));
}
public IHttpResponse Details(int id)
{
var taskExists =
this.DbContext
.Tasks.Any(t => t.Id == id);
if (taskExists == false)
{
return(this.BadRequestError("Task doesn't exist"));
}
TaskDetailsViewModel viewModel =
this.DbContext
.Tasks
.Where(t => t.Id == id)
.Select(t => new TaskDetailsViewModel()
{
Title = t.Title,
Level = t.AffectedSectors.Count,
Description = t.Description,
DueDate = t.DueDate.ToString("d"),
AffectedSectors = string.Join(", ", t.AffectedSectors.Select(a => a.Sector.SectorType.ToString())),
Participants = string.Join(", ", t.Participants.Select(p => p.Participant.Name))
})
.First();
return(this.View(viewModel));
}
public IActionResult TaskDetails(int id)
{
ToDo todo = _todoService.GetToDoById(id);
if (todo == null)
{
return(View("_Error"));
}
List <SubTaskViewModel> subtasks = new List <SubTaskViewModel>();
foreach (var subtask in todo.SubTasks)
{
subtasks.Add(new SubTaskViewModel()
{
Title = subtask.Title,
Descrition = subtask.Descrition,
SubStatus = subtask.SubStatus
});
}
TaskDetailsViewModel taskDetail = new TaskDetailsViewModel()
{
Id = todo.Id,
Title = todo.Title,
Descrition = todo.Descrition,
ImporanceOfTask = todo.ImporanceOfTask,
Status = todo.Status,
SubTasks = subtasks
};
return(View(taskDetail));
}
public TaskDetailsPage(PlantTask plantTask)
{
InitializeComponent();
vm = new TaskDetailsViewModel(plantTask);
this.BindingContext = vm;
}
public TaskDetailsPage(Model.Response.TaskDetails task)
{
InitializeComponent();
BindingContext = model = new TaskDetailsViewModel()
{
TaskDetails = task
};
}
public TaskDetailsView(ITaskList taskList)
{
InitializeComponent();
_viewModel = new TaskDetailsViewModel(this, taskList);
DataContext = ViewModel;
}
/// <summary>
/// This is the constructor for Details of Task View
/// </summary>
/// <param name="targetTask">The Task currenty showing in this view</param>
public TaskDetailsView(TaskViewModel targetTask)
{
InitializeComponent();
SubscribingInformation();
vm = new TaskDetailsViewModel(targetTask);
BindingContext = vm;
FrameClass.BorderColor = Color.FromRgba(0, 0, 0, 0.1);
}
public async Task <ActionResult> GetTaskDetails(string taskId)
{
return(await Task <ActionResult> .Factory.StartNew(() =>
{
var id = Guid.Parse(taskId);
var model = new TaskDetailsViewModel(id, _contextHolder.GetContext(HttpContext).Repository);
return PartialView("TaskDetails", model);
}));
}
public IActionResult Create(TaskDetailsViewModel taskDetailsViewModel)
{
if (ModelState.IsValid)
{
var newTask = taskDetailsViewModel.ToKnapssackTask();
_taskSolverService.AddTask(newTask);
return(RedirectToAction("Index"));
}
return(View());
}
public TaskDetailsViewModel TaskDetails(int taskId, int teamId, USER user)
{
TASK task = _taskRepository.GetTaskById(taskId);
TEAM team = _teamRepository.GetTeamById(teamId);
TaskDetailsViewModel taskDetail = new TaskDetailsViewModel();
if (task != null && team != null && task.TEAM == team)
{
taskDetail.TeamId = team.ID;
UserTeamPermissionsViewModel permissions = _permissionService.GetPermissionsForUserTeam(user, team.ID);
taskDetail.CanAssignTask = permissions.CanAssignTasks;
taskDetail.CanComment = permissions.CanComment;
taskDetail.CanCreateTask = permissions.CanCreateTasks;
taskDetail.CurrentUserId = user.Id;
taskDetail.TaskId = task.ID;
taskDetail.Title = task.TITLE;
taskDetail.Description = task.DESCRIPTION;
taskDetail.Deathline = task.DEATHLINE;
taskDetail.CreateTime = task.CREATE_TIME;
taskDetail.StartTime = task.START_TIME;
taskDetail.EndTime = task.END_TIME;
taskDetail.User = task.USER;
taskDetail.CurrentTaskStatus = task.TASK_STATUS;
taskDetail.Comments = task.COMMENTs;
taskDetail.IsUserAssignedToTask = (task.USER == user);
List <USER> teamUsers = new List <USER>();
teamUsers.AddRange(_userRepository.GetUsersByTeam(team).Except(new List <USER> {
task.USER
}));
if (task.USER != null)
{
teamUsers.Add(new USER {
UserName = "******", Id = ""
});
taskDetail.TeamUsers = teamUsers.Prepend(task.USER);
}
else
{
taskDetail.TeamUsers = teamUsers.Prepend(new USER {
UserName = "******", Id = ""
});
}
List <TASK_STATUS> taskStatuses = new List <TASK_STATUS>();
taskStatuses.AddRange(_taskRepository.GetTaskStatusesByTeam(team).Except(new List <TASK_STATUS> {
task.TASK_STATUS
}));
taskDetail.TeamTaskStatuses = taskStatuses.Prepend(task.TASK_STATUS);
}
return(taskDetail);
}
public TaskDetailsView(MyTask task)
{
InitializeComponent();
TaskDetailsViewModel taskDetailsViewModel = new TaskDetailsViewModel
{
Item = task
};
BindingContext = taskDetailsViewModel;
}
public async Task <IActionResult> Details(int?id)
{
AuthorizeUser();
if (id == null)
{
return(NotFound());
}
if (HttpContext.Session.GetString("DeletedMessage") != null)
{
DeletedMessage = HttpContext.Session.GetString("DeletedMessage");
HttpContext.Session.Remove("DeletedMessage");
}
if (HttpContext.Session.GetString("errorMessage") != null)
{
errorMessage = HttpContext.Session.GetString("errorMessage");
HttpContext.Session.Remove("errorMessage");
}
ViewBag.errorMessage = errorMessage;
ViewBag.DeletedMessage = DeletedMessage;
var task = await _context.Task.FirstOrDefaultAsync(m => m.TaskId == id);
task.TaskTaskState = await _context.TaskState.FirstOrDefaultAsync(t => t.TaskStateId == task.TaskTaskStateId);
ViewData["StateList"] = new SelectList(_context.TaskState, "TaskStateId", "TaskStateName", task.TaskTaskStateId);
List <Account> assignees = await
(from acc in _context.Account
join jt in _context.JAccountTask
on acc.AccountId equals jt.AccountId
where jt.TaskId == id
select acc).ToListAsync();
List <Comment> comments = await _context.Comment.Where(c => c.CommentTaskId == id).ToListAsync();
comments.ForEach(comm => comm.CommentAccount = _context.Account.Where(acc => acc.AccountId == comm.CommentAccountId).FirstOrDefault());
task_details_model = new TaskDetailsViewModel
{
Task = task,
Assignees = assignees,
Comments = comments
};
if (accountLoggedIn)
{
return(View(task_details_model));
}
else
{
return(RedirectToAction("Index", "Home", new { Unlogged = 1 }));
}
}
public TaskDetailsPage() : base()
{
try
{
InitializeComponent();
ViewModel = BindingContext as TaskDetailsViewModel;
ViewModel.Navigation = Navigation;
}
catch (Exception ex)
{
ExceptionHandler.HandleException(ex);
}
}
public IActionResult TaskDetails(TaskDetailsViewModel model)
{
//List<SubTask> subtasks = _todoService.GetAllSubTasks().ToList();
//foreach (var item in model.SubTasks)
//{
// foreach (var sub in subtasks)
// {
// if (item.Id == sub.Id)
// {
// sub.Title = item.Title;
// sub.Descrition = item.Descrition;
// sub.SubStatus = item.SubStatus;
// }
// }
//}
ToDo todo = _todoService.GetAllToDos().SingleOrDefault(t => t.Id == model.Id);
todo.Title = model.Title;
todo.Descrition = model.Descrition;
todo.ImporanceOfTask = model.ImporanceOfTask;
todo.Status = model.Status;
todo.TypeOfToDo = model.TypeOfTodo;
List <SubTaskViewModel> subtasksViewModel = new List <SubTaskViewModel>();
foreach (var st in model.SubTasks)
{
subtasksViewModel.Add(st);
}
List <SubTask> subtasks = new List <SubTask>();
foreach (var stv in subtasksViewModel)
{
subtasks.Add(new SubTask()
{
Id = stv.Id,
Title = stv.Title,
Descrition = stv.Descrition,
SubStatus = stv.SubStatus
});
}
todo.SubTasks = subtasks;
_todoService.UpdateTask(todo);
return(View("_ThankYou"));
}
public async Task <IActionResult> Index()
{
return(await Task <ActionResult> .Factory.StartNew(() =>
{
var taskId = HttpContext.Request.Query["id"].ToString();
if (string.IsNullOrEmpty(taskId))
{
return View("TaskDetails");
}
var id = Guid.Parse(taskId);
var model = new TaskDetailsViewModel(id, _contextHolder.GetContext(HttpContext).Repository);
return View("TaskDetails", model);
}));
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
TaskModel = await _taskAppService.GetTaskViewModelForDetailsAsync(id.Value);
if (TaskModel == null)
{
return(NotFound());
}
return(Page());
}
public async Task <IActionResult> Create(TaskDetailsViewModel task)
{
if (!AuthenticationHelper.isAuthorizedUser(HttpContext.Session.GetString("Username")))
{
Response.Redirect("/Login");
}
if (ModelState.IsValid)
{
//create task
await createTask(task);
return(RedirectToAction(nameof(Index)));
}
return(View(task));
}
public ActionResult Details(int id)
{
Task task = TasksService.GetTask(id);
if (task == null)
{
return(View("../Shared/Error"));
}
List <SpendItem> spendItemsList = this.SpendItemsService.GetAll().ToList();
TaskDetailsViewModel model = new TaskDetailsViewModel()
{
Task = task, SpendItemList = spendItemsList
};
return(View(model));
}
public ViewResult Details(int?Id)
{
TaskDetailsViewModel taskDetailsViewModel = new TaskDetailsViewModel();
ToDoTask _tmpTask = _taskRepository.Details((int)Id);
if (_tmpTask == null)
{
Response.StatusCode = 404;
return(View("TaskNotFound", Id));
}
taskDetailsViewModel.ToDoTask = _tmpTask;
taskDetailsViewModel.PageTitle = "User Details";
return(View("~/Views/Task/TaskDetails.cshtml", taskDetailsViewModel));
}
public TaskDetailsViewModel GetTaskById(int id)
{
var taskViewModel = new TaskDetailsViewModel();
var task = this.context.Tasks.FirstOrDefault(t => t.Id == id);
var sectors = this.GetAffectedSectors(id);
taskViewModel.Title = task.Title;
taskViewModel.Description = task.Description;
taskViewModel.DueDate = task.DueDate.ToString("dd/MM/yyyy");
taskViewModel.Participants = task.Participants;
taskViewModel.AffectedSectors =
sectors.Any() ? string.Join(", ", sectors.Select(a => a.ToString())) : "No affected sectors";
taskViewModel.Level = sectors.Count;
return(taskViewModel);
}
public IActionResult Details(int id)
{
if (id > 0)
{
Task gotById = _taskRepository.GetTaskById(id);
TaskDetailsViewModel modelId = new TaskDetailsViewModel()
{
Id = gotById.Id,
UserId = gotById.UserId,
Title = gotById.Title,
Descripton = gotById.Descripton,
Importance = gotById.Importance,
Type = gotById.Type,
Status = gotById.Status,
SubTasks = gotById.SubTasks
};
return(View("_TaskDetailsView", modelId));
}
;
var allTasks = _taskRepository.GetAllTasks();
List <TaskDetailsViewModel> tasksWithDetails = new List <TaskDetailsViewModel>();
foreach (var task in allTasks)
{
TaskDetailsViewModel thisTask = new TaskDetailsViewModel()
{
Id = task.Id,
UserId = task.UserId,
Title = task.Title,
Descripton = task.Descripton,
Importance = task.Importance,
Status = task.Status,
Type = task.Type,
SubTasks = task.SubTasks
};
tasksWithDetails.Add(thisTask);
}
TasksDetailsViewModel model = new TasksDetailsViewModel()
{
Details = tasksWithDetails
};
return(View(model));
}
public IActionResult Details(int id)
{
var task = this.taskService.GetById(id);
var taskDetailsViewModel = new TaskDetailsViewModel
{
Title = task.Title,
DueDate = task.DueDate?.ToString("dd/MM/yyyy", CultureInfo.InvariantCulture),
AffectedSectors = string.Join(", ", task.AffectedSectors.Select(s => s.Sector.ToString())),
Level = task.AffectedSectors.Count,
Participants = task.Participants,
Description = task.Description
};
this.Model.Data["TaskDetails"] = taskDetailsViewModel;
return(this.View());
}
// GET: TaskController/Details/5
public IActionResult Details(int id)
{
try
{
var task = _taskManager.GetListWithType(User.Identity.UserId())
.FirstOrDefault(t => t.Id == id);
var model = new TaskDetailsViewModel
{
Task = task,
};
return(View(model));
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(RedirectToAction("Error", "Home"));
}
}
/// <summary>
/// Updates the task.
/// </summary>
/// <returns>Success or Failure.</returns>
/// <param name="vm">TaskDetailsViewModel.</param>
protected async Task <Boolean> UpdateTask(TaskDetailsViewModel vm)
{
//Check for error if any
try
{
//Fetch task which needs to be updated
Task task = _context.Tasks.Where(x => x.TaskId == vm.TaskId).FirstOrDefault();
task.Priority = vm.Priority;
task.Status = vm.Status;
task.DueDate = vm.DueDate;
task.Title = vm.Title;
task.Severity = vm.Severity;
task.AssignedTo = _context.Users.Where(usr => usr.Username == vm.AssignedTo).FirstOrDefault();
//Check FIle count
if (vm.Files.Count() > 0)
{
using (var ms = new MemoryStream())
{
vm.Files.FirstOrDefault().CopyTo(ms);
var fileBytes = ms.ToArray();
Attachment attachment = new Models.Attachment()
{
file = fileBytes
};
attachment.Filename = vm.Files.FirstOrDefault().FileName;
_context.Attachments.Add(attachment);
task.Attachment = attachment;
}
}
//Update Task
_context.Tasks.Update(task);
await _context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
Console.Write(ex);
return(false);
}
}
/// <summary>
/// Fills the task details vm.
/// </summary>
/// <returns>The task details vm.</returns>
/// <param name="task">Task.</param>
private TaskDetailsViewModel fillTaskDetailsVM(Task task)
{
//Fill View Model
TaskDetailsViewModel vm = new TaskDetailsViewModel()
{
TaskId = task.TaskId,
AssignedTo = task.AssignedTo.Username,
CreatedBy = task.CreatedBy.Username,
DueDate = task.DueDate,
Created = task.Created,
Status = task.Status,
Priority = task.Priority,
Severity = task.Severity,
Title = task.Title,
AttachmentName = task.Attachment.Filename
};
return(vm);
}
public IActionResult Details(TaskDetailsViewModel model)
{
if (model != null)
{
Task toUpdate = new Task()
{
Id = model.Id,
UserId = model.UserId,
Title = model.Title,
Descripton = model.Descripton,
Status = model.Status,
Importance = model.Importance,
Type = model.Type,
SubTasks = model.SubTasks
};
_taskRepository.UpdateTask(toUpdate);
}
return(RedirectToAction("Index", "Home"));
}
internal void Init()
{
m_ViewModel = new TaskDetailsViewModel();
cmbBoxFileType.Properties.DataSource = DataModel.Constant.FileTypeInfos;
cmbBoxFileType.Properties.DisplayMember = "Name";
cmbBoxFileType.Properties.ValueMember = "Id";
Framework.Container.Instance.VVMDataBindings.AddBinding(cmbBoxFileType, "EditValue", m_ViewModel, "FileType");
Framework.Container.Instance.VVMDataBindings.AddBinding(this, "Visible", m_ViewModel, "HasSelectedTask");
Framework.Container.Instance.VVMDataBindings.AddBinding(txtBoxName, "Text", m_ViewModel, "Name");
// Framework.Container.Instance.VVMDataBindings.AddBinding(cmbBoxFileType, "SelectedIndex", m_ViewModel, "FileType");
Framework.Container.Instance.VVMDataBindings.AddBinding(txtBoxURL, "Text", m_ViewModel, "Path");
Framework.Container.Instance.VVMDataBindings.AddBinding(timeEditCreate, "EditValue", m_ViewModel, "CreateTime");
gridControl1.DataSource = m_ViewModel.DTSummary;
//Framework.Container.Instance.VVMDataBindings.AddBinding(txtBoxUserName, "Text", m_ViewModel, "UserName");
//Framework.Container.Instance.VVMDataBindings.AddBinding(txtBoxPassword, "Text", m_ViewModel, "Password");
//Framework.Container.Instance.VVMDataBindings.AddBinding(spinEdit1, "Value", m_ViewModel, "PictureCount");
}
public IHttpResponse Details(int id)
{
var task = this.db.Tasks.FirstOrDefault(t => t.Id == id);
if (task == null)
{
return(this.BadRequestError("Invalid task id!"));
}
var taskDetailsViewModel = new TaskDetailsViewModel
{
Title = task.Title,
Level = task.AffectedSectors.Count,
DueDate = task.DueDate.ToShortDateString(),
Participants = task.Participants,
AffectedSectors = string.Join(", ", task.AffectedSectors.Select(s => s.Sector.ToString())),
Description = task.Description
};
return(this.View(taskDetailsViewModel));
}
/// <summary>
/// Creates the task from TaskDetailsViewModel.
/// </summary>
/// <param name="task">TaskDetailsViewModel.</param>
private async System.Threading.Tasks.Task createTask(TaskDetailsViewModel task)
{
var s = HttpContext.Session.GetString("Username");
if (s == null)
{
Response.Redirect("/Login");
}
//Copy View Model data to new Task Object
Models.Task newTask = new Models.Task();
newTask.Created = DateTime.Now;
newTask.CreatedBy = _context.Users.Where(usr => usr.Username == HttpContext.Session.GetString("Username")).FirstOrDefault();
newTask.Priority = task.Priority;
newTask.Status = task.Status;
newTask.DueDate = task.DueDate;
newTask.Title = task.Title;
newTask.Severity = task.Severity;
newTask.AssignedTo = _context.Users.Where(usr => usr.Username == task.AssignedTo).FirstOrDefault();
//Create Attachment file if any
if (task.Files.Count() > 0)
{
using (var ms = new MemoryStream())
{
task.Files.FirstOrDefault().CopyTo(ms);
var fileBytes = ms.ToArray();
Attachment attachment = new Models.Attachment()
{
file = fileBytes
};
attachment.Filename = task.Files.FirstOrDefault().FileName;
_context.Attachments.Add(attachment);
newTask.Attachment = attachment;
}
}
//Create task in DB
_context.Add(newTask);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> Edit(TaskDetailsViewModel task)
{
if (!AuthenticationHelper.isAuthorizedUser(HttpContext.Session.GetString("Username")))
{
Response.Redirect("/Login");
}
if (ModelState.IsValid)
{
Boolean result = await UpdateTask(task);
if (result)
{
return(RedirectToAction("Index", "Tasks"));
}
else
{
return(View(task));
}
}
return(View(task));
}
