public async Task <IActionResult> GenerateTaskView(TaskFormDataModel model)
{
var task = new TaskItemViewModel();
if (model.TaskId == 0)
{
task.ProjectId = model.ProjectId;
task.AccountId = Context.CurrentAccount.AccountId;
task.PhaseId = model.PhaseId;
}
else
{
var iResult = await EzTask.Task.GetTask(model.TaskId);
UpdateTaskFromExist(task, iResult);
}
var phases = await EzTask.Phase.GetPhases(task.ProjectId);
task.PhaseList = StaticResources.BuildPhaseSelectList(phases, task.PhaseId);
var assignees = await EzTask.Project.GetAccountList(task.ProjectId);
task.AssigneeList = StaticResources.BuildAssigneeSelectList(assignees, task.Assignee);
task.StatusList = StaticResources.BuildTaskStatusSelectList(task.Status);
task.PriorityList = StaticResources.BuildPrioritySelectList(task.Priority);
return(PartialView("_CreateOrUpdateTask", task));
}
/*
* //May not be needed anymore as tasks are not logged until after date rolls
* public static void RemoveTaskLog(DateTime start, DateTime end, int taskItemId)
* {
* var items = GetTaskLogs(start, end).Where(x => x.TaskID == taskItemId);
*
* foreach (TaskLog i in items)
* {
* Instance.TasksLog.Remove(i);
* }
*
* Instance.SaveChanges();
* }
*/
#endregion
private static bool Expand(IEnumerable <TaskItemViewModel> tasks, int id)
{
foreach (var t in tasks)
{
if (t.Data.TaskItemID == id)
{
TaskItemViewModel parent = t.Parent;
while (parent != null)
{
parent.IsExpanded = true;
parent = parent.Parent;
}
t.Selected = true;
return(true);
}
else if (t.Children != null)
{
bool expanded = Expand(t.Children, id);
if (expanded)
{
return(true);
}
}
}
return(false);
}
private async Task <bool> ChangeTaskStatus(TaskItemViewModel task, GoogleTaskStatus newStatus)
{
Messenger.Publish(new ShowProgressOverlayMsg(this));
var response = await _dataService
.TaskService
.ChangeTaskStatusAsync(task.GoogleId, newStatus);
Messenger.Publish(new ShowProgressOverlayMsg(this, false));
if (!response.Succeed)
{
Logger.Error(
$"{nameof(ChangeTaskStatus)}: An error occurred while trying to mark {task.Title} as {GetStatusMsgToUse(newStatus)}." +
$"Error = {response.Message}");
return(false);
}
task.Status = response.Result.Status;
task.CompletedOn = response.Result.CompletedOn;
task.UpdatedAt = response.Result.UpdatedAt;
Messenger.Publish(new TaskStatusChangedMsg(
this,
task.GoogleId,
task.ParentTask,
task.CompletedOn,
task.UpdatedAt,
task.Status));
return(true);
}
public async Task <IActionResult> UpdateAsync(int id, [FromBody] JsonPatchDocument <TaskItemViewModel> jsonPatchDocument)
{
if (ModelState.IsValid)
{
if (jsonPatchDocument == null)
{
return(BadRequest());
}
TaskItem taskItem = await _taskService.GetById(id);
if (taskItem == null)
{
return(NotFound(id));
}
TaskItemViewModel taskItemPatch = Mapper.Map <TaskItemViewModel>(taskItem);
jsonPatchDocument.ApplyTo(taskItemPatch);
Mapper.Map(taskItemPatch, taskItem);
AuditEntity(ref taskItem);
_taskService.Update(taskItem);
await _taskService.SaveChangesAsync();
return(Ok(taskItem));
}
return(BadRequest(ModelState));
}
private NewTaskViewModelResult(TaskItemViewModel task, bool wasCreated, bool wasUpdated, bool wasDeleted, int itemsAdded)
{
Task = task;
WasCreated = wasCreated;
WasUpdated = wasUpdated;
WasDeleted = wasDeleted;
ItemsAdded = itemsAdded;
}
public ActionResult Delete(TaskItemViewModel taskItemViewModel)
{
var taskItem = toDoListDbContext.TaskItems.Where(lmb => lmb.Id == taskItemViewModel.Id).FirstOrDefault();
toDoListDbContext.Entry(taskItem).State = System.Data.Entity.EntityState.Deleted;
toDoListDbContext.SaveChanges();
return(RedirectToAction("TaskList"));
}
public static TaskDateViewModelParameter Instance(
TaskListItemViewModel taskList,
TaskItemViewModel task,
TaskNotificationDateType dateType,
bool sendUpdatedMsg = false)
{
return(new TaskDateViewModelParameter(taskList, task, dateType, sendUpdatedMsg));
}
public ActionResult Create(TaskItemViewModel taskItemViewModel)
{
toDoListDbContext.TaskItems.Add(new Domain.Entities.TaskItem {
TaskDescription = taskItemViewModel.TaskDescription, TaskTitle = taskItemViewModel.TaskTitle, TaskDueDate = taskItemViewModel.TaskDueDate, UserId = User.Identity.GetUserId()
});
toDoListDbContext.SaveChanges();
return(RedirectToAction("TaskList"));
}
private MoveTaskDialogViewModelParameter(
TaskListItemViewModel currentTaskList,
TaskListItemViewModel newTaskList,
TaskItemViewModel task)
: base(task)
{
CurrentTaskList = currentTaskList;
NewTaskList = newTaskList;
}
public TaskDateUpdatedMsg(
object sender,
TaskItemViewModel task,
bool isAReminderDate)
: base(sender)
{
Task = task;
IsAReminderDate = isAReminderDate;
}
public ChangeTaskStatusRequestMsg(
object sender,
TaskItemViewModel task,
GoogleTaskStatus newStatus = GoogleTaskStatus.COMPLETED)
: base(sender)
{
Task = task;
NewStatus = newStatus;
}
public ActionResult Details(int id)
{
TaskItemViewModel taskItemViewModel = new TaskItemViewModel();
taskItemViewModel = toDoListDbContext.TaskItems.Where(lmb => lmb.Id == id).Select(lmb => new TaskItemViewModel {
Id = lmb.Id, TaskDescription = lmb.TaskDescription, TaskDueDate = lmb.TaskDueDate, TaskTitle = lmb.TaskTitle, UserId = lmb.UserId
}).FirstOrDefault();
return(View(taskItemViewModel));
}
public ActionResult Edit(TaskItemViewModel taskItemViewModel)
{
var taskItem = toDoListDbContext.TaskItems.Where(lmb => lmb.Id == taskItemViewModel.Id).FirstOrDefault();
taskItem.TaskTitle = taskItemViewModel.TaskTitle;
taskItem.TaskDescription = taskItemViewModel.TaskDescription;
taskItem.TaskDueDate = taskItemViewModel.TaskDueDate;
toDoListDbContext.SaveChanges();
return(RedirectToAction("TaskList"));
}
public async Task <IActionResult> GenerateAssignTaskView(TaskFormDataModel model)
{
TaskItemViewModel task = new TaskItemViewModel();
IList <ProjectMemberModel> assignees = await EzTask.Project.GetAccountList(model.ProjectId);
task.AssigneeList = StaticResources.BuildAssigneeSelectList(assignees);
return(PartialView("_AssignTask", task));
}
internal static TaskModel Get(TaskItemViewModel item)
{
return(new TaskModel()
{
Id = item.Id,
DateTime = item.Date.Date.Add(item.Time),
Name = item.Name,
Status = (int)item.Status
});
}
private TaskDateViewModelParameter(
TaskListItemViewModel taskList,
TaskItemViewModel task,
TaskNotificationDateType dateType,
bool sendUpdatedMsg)
{
TaskList = taskList ?? throw new ArgumentNullException(nameof(taskList));
Task = task ?? throw new ArgumentNullException(nameof(task));
DateType = dateType;
SendUpdateMsg = sendUpdatedMsg;
}
public async Task <IActionResult> CreateOrUpdate(TaskItemViewModel viewModel)
{
var model = CreateTaskItemModel(viewModel);
var iResult = await EzTask.Task.SaveTask(model);
if (iResult.Status == ActionStatus.Ok)
{
model.TaskCode = iResult.Data.TaskCode;
model.CreatedDate = iResult.Data.CreatedDate;
model.UpdatedDate = iResult.Data.UpdatedDate;
model.TaskId = iResult.Data.TaskId;
string diff = string.Empty;
string title;
if (viewModel.TaskId <= 0)
{
title = Context.GetStringResource("CreatedTask", StringResourceType.TaskPage) + " \"" + iResult.Data.TaskTitle + "\" <small>(" + Context.GetStringResource("Code", StringResourceType.TaskPage) + ": " + model.TaskCode + ")</small>";
SetTaskDataToSession(model);
//add notify
await EzTask.Notification.AddNewTaskNotify(Context.CurrentAccount.DisplayName,
Context.CurrentAccount.AccountId,
iResult.Data.TaskCode, viewModel.ProjectId,
Context.GetStringResource("AddNewTask", StringResourceType.Notification));
}
else
{
title = Context.GetStringResource("UpdatedTask", StringResourceType.TaskPage) + " \"" + iResult.Data.TaskTitle + "\" <small>(" + Context.GetStringResource("Code", StringResourceType.TaskPage) + ": " + model.TaskCode + ")</small>";
var oldData = ReadTaskDataFromSession(model.TaskId);
var newData = model;
diff = await EzTask.Task.CompareChangesAsync(newData, oldData);
//re-assign new data to session
SetTaskDataToSession(newData);
//add notify
await EzTask.Notification.UpdateTaskNotify(Context.CurrentAccount.DisplayName,
Context.CurrentAccount.AccountId,
iResult.Data.TaskCode, viewModel.ProjectId,
Context.GetStringResource("UpdateTask", StringResourceType.Notification));
}
await EzTask.Task.SaveHistory(iResult.Data.TaskId, title, diff, Context.CurrentAccount.AccountId);
}
return(Json(iResult));
}
public async Task <IActionResult> Index()
{
var currentUser = await _userManager.GetUserAsync(User);
if (currentUser == null)
{
return(Challenge());
}
var items = await _taskItemService.GetIncompleteItemsAsync(currentUser);
var model = new TaskItemViewModel()
{
Items = items
};
return(View(model));
}
public void addNewTaskItem(TaskItemViewModel taskItem)
{
var task = new TaskItem();
task.ChecklistId = taskItem.ChecklistId;
// task.FormId = taskItem.FormId;
task.DueTime = DateTime.ParseExact(taskItem.DueTime, "dd/MM/yyyy HH:mm:ss", CultureInfo.InvariantCulture);
//task.DueTime = Convert.ToDateTime(taskItem.DueTime);
task.Name = taskItem.Name;
task.Priority = taskItem.Priority;
task.TaskStatus = taskItem.TaskStatus;
// task.FormSubmitted = taskItem.FormSubmitted;
// task.FormId = taskItem.FormId;
context.TaskItem.Add(task);
context.SaveChanges();
}
static TaskItemViewModel GenerateTask(string subject, TaskCategory category, ContactItemViewModel contact)
{
TaskItemViewModel task = TaskItemViewModel.Create(subject, category, DateTime.Now.AddHours(-rndGenerator.Next(96)));
int rndStatus = rndGenerator.Next(10);
if (task.TimeDiff.TotalHours > 12)
{
task.PercentComplete = rndGenerator.Next(9) * 10;
task.StartDate = task.CreatedDate.AddMinutes(rndGenerator.Next(720)).Date;
if (task.TimeDiff.TotalHours > 80)
{
task.Status = TaskStatus.Completed;
task.CompletedDate = task.StartDate.Value.AddHours(rndGenerator.Next(48) + 24);
}
else
{
task.Status = TaskStatus.InProgress;
if (rndStatus == 6)
{
task.Status = TaskStatus.Deferred;
}
else if (rndStatus == 4 && task.PercentComplete < 40)
{
task.Status = TaskStatus.WaitingOnSomeoneElse;
}
}
}
if (rndStatus != 5)
{
task.DueDate = task.CreatedDate.AddHours((90 - rndStatus * 9) + 24).Date;
}
if (rndStatus > 8)
{
task.Priority = TaskPriority.High;
}
if (rndStatus < 3)
{
task.Priority = TaskPriority.Low;
}
if (rndStatus != 7 && contact != null)
{
task.AssignTo = contact;
}
return(task);
}
public async Task <IActionResult> CreateTask([FromBody] TaskItemViewModel viewmodel)
{
if (ModelState.IsValid)
{
if (viewmodel == null)
{
return(BadRequest($"{nameof(viewmodel)} cannot be null"));
}
TaskItem taskItem = Mapper.Map <TaskItem>(viewmodel);
AuditEntity(ref taskItem);
_taskService.Add(taskItem);
await _taskService.SaveChangesAsync();
return(Ok(taskItem));
}
return(BadRequest(ModelState));
}
private async Task <bool> DeleteTask(TaskItemViewModel task)
{
if (task.HasParentTask && task.IsNew ||
task.IsNew)
{
Messenger.Publish(new TaskDeletedMsg(this, task.GoogleId, task.ParentTask));
return(true);
}
Messenger.Publish(new ShowProgressOverlayMsg(this));
var deleteResponse = await _dataService
.TaskService
.RemoveTaskAsync(task.GoogleId);
if (TasksHelper.HasReminderId(task.RemindOnGUID, out int id))
{
_notificationService.RemoveScheduledNotification(id);
}
if (task.HasSubTasks)
{
foreach (var st in task.SubTasks)
{
if (TasksHelper.HasReminderId(st.RemindOnGUID, out int stReminderId))
{
_notificationService.RemoveScheduledNotification(stReminderId);
}
}
}
Messenger.Publish(new ShowProgressOverlayMsg(this, false));
if (!deleteResponse.Succeed)
{
Logger.Error(
$"{nameof(DeleteTask)}: Couldn't delete the selected task." +
$"Error = {deleteResponse.Message}");
return(false);
}
Messenger.Publish(new TaskDeletedMsg(this, task.GoogleId, task.ParentTask));
return(true);
}
// GET: TaskItemDetail/Details/5
public ActionResult Details(int id)
{
TaskItemViewModel taskItemDetail = new TaskItemViewModel();
taskItemDetail.Task = TaskManager.GetTaskById(id);
var taskCategories = TaskManager.GetCategoriesByTaskId(id);
List <CategoryDetail> categoryDetailList = new List <CategoryDetail>();
foreach (var taskCategory in taskCategories)
{
CategoryLookupObject categoryLookup = new CategoryLookupObject {
CategoryId = taskCategory.CategoryId, CategoryName = taskCategory.CategoryName
};
var taskCategoryId = taskCategory.TaskCategoryId;
var questionsAnswers = TaskManager.GetQuestionsAnswersByTaskCategoryId(taskCategoryId);
List <QuestionAnswerDetail> questionsAnswersList = new List <QuestionAnswerDetail>();
foreach (var innerItem in questionsAnswers)
{
QuestionAnswerDetail questionAnswerDetail = new QuestionAnswerDetail();
questionAnswerDetail.Question = innerItem.Question;
questionAnswerDetail.Answer = innerItem.Answer;
questionAnswerDetail.Multiplier = innerItem.Multiplier;
questionAnswerDetail.Score = innerItem.Score;
questionsAnswersList.Add(questionAnswerDetail);
}
CategoryDetail categoryDetail = new CategoryDetail {
Category = categoryLookup, QuestionsAnswers = questionsAnswersList
};
categoryDetailList.Add(categoryDetail);
}
taskItemDetail.Categories = categoryDetailList;
return(View(taskItemDetail));
}
/// <summary>
/// Create TaskItemModel from ViewModel
/// </summary>
/// <param name="viewModel"></param>
/// <returns></returns>
private TaskItemModel CreateTaskItemModel(TaskItemViewModel viewModel)
{
var data = new TaskItemModel();
data.Assignee.AccountId = viewModel.Assignee;
data.Member.AccountId = Context.CurrentAccount.AccountId;
data.Phase.Id = viewModel.PhaseId;
data.Project.ProjectId = viewModel.ProjectId;
data.Priority = viewModel.Priority.ToEnum <TaskPriority>();
data.Status = viewModel.Status.ToEnum <TaskItemStatus>();
data.TaskDetail = viewModel.TaskDetail;
data.TaskCode = viewModel.TaskCode;
data.TaskId = viewModel.TaskId;
data.TaskTitle = viewModel.TaskTitle;
data.CreatedDate = viewModel.CreatedDate;
data.PercentCompleted = viewModel.PercentCompleted;
data.EstimateTime = viewModel.EstimateTime;
data.SpentTime = viewModel.SpentTime;
return(data);
}
public TemplateViewModel getTemplate(int organizationId, String userId, int templateId)
{
var template = _context.Checklist.Where(c => c.OrganizationId == organizationId && c.Id == templateId && c.UserId.Equals(userId)).FirstOrDefault();
var templateVM = new TemplateViewModel()
{
Id = template.Id,
Description = template.Description,
Name = template.Name,
OrganizationId = template.OrganizationId,
taskItemViewModels = null,
TemplateId = template.TemplateId,
TemplateStatus = template.TemplateStatus,
TimeCreated = template.TimeCreated,
UserId = template.UserId,
Category = template.Category
};
var listTaskItem = _context.TaskItem.Where(t => t.ChecklistId == template.Id).OrderBy(t => t.Priority).ToList();
var listTaskItemVM = new List <TaskItemViewModel>();
foreach (var item in listTaskItem)
{
var taskItemVM = new TaskItemViewModel();
taskItemVM.Id = item.Id;
taskItemVM.Name = item.Name;
taskItemVM.Priority = item.Priority;
taskItemVM.TaskStatus = item.TaskStatus;
taskItemVM.ChecklistId = item.ChecklistId;
taskItemVM.DueTime = item.DueTime.ToString();
var listContent = _context.ContentDetail.Where(c => c.TaskItemId == item.Id).OrderBy(c => c.OrderContent).ToList();
taskItemVM.ContentDetails = listContent;
var listUser = _context.User.FromSql("getUserByTaskId @TaskId", new SqlParameter("@TaskId", item.Id)).ToList();
taskItemVM.UserId = listUser;
listTaskItemVM.Add(taskItemVM);
}
templateVM.taskItemViewModels = listTaskItemVM;
return(templateVM);
}
/// <summary>
/// Update from exist task model
/// </summary>
/// <param name="task"></param>
/// <param name="iResult"></param>
private void UpdateTaskFromExist(TaskItemViewModel task, ResultModel <TaskItemModel> iResult)
{
task.TaskId = iResult.Data.TaskId;
task.ProjectId = iResult.Data.Project.ProjectId;
task.PhaseId = iResult.Data.Phase.Id;
task.Assignee = iResult.Data.Assignee != null ? iResult.Data.Assignee.AccountId : 0;
task.TaskTitle = iResult.Data.TaskTitle;
task.TaskCode = iResult.Data.TaskCode;
task.TaskDetail = iResult.Data.TaskDetail;
task.Status = iResult.Data.Status.ToInt16 <TaskStatus>();
task.Priority = iResult.Status.ToInt16 <TaskPriority>();
task.AccountId = iResult.Data.Member.AccountId;
task.PercentCompleted = iResult.Data.PercentCompleted;
task.CreatedDate = iResult.Data.CreatedDate;
task.EstimateTime = iResult.Data.EstimateTime;
task.SpentTime = iResult.Data.SpentTime;
if (task.TaskId > 0)
{
SetTaskDataToSession(CreateTaskItemModel(task));
}
}
public void EntityUpdated(taskList updatedEntities)
{
using (var db = new ApplicationDbContext())
{
Trace.WriteLine("Updated Tasks");
foreach (var entry in updatedEntities)
{
var dbTask = db.Tasks.Find(entry.Item2.Id);
var indexGroup =
Clients.Group(LiveUpdateHelper.GroupName(ViewModelDataType.Task,
ActionType.Index, entry.Item2.FeatureId));
switch (entry.Item1)
{
case EntityState.Added:
//Add Task to list
var taskItemViewModelA = new TaskItemViewModel(dbTask);
indexGroup.AddData(ViewModelDataType.Task.ToString(),
ActionType.Index.ToString(), taskItemViewModelA);
break;
case EntityState.Deleted:
//Remove Task from list
indexGroup.RemoveData(ViewModelDataType.Task.ToString(),
ActionType.Index.ToString(), entry.Item2.Id);
break;
case EntityState.Modified:
//Update Tasks List
var taskItemViewModelM = new TaskItemViewModel(dbTask);
indexGroup.UpdateItemData(ViewModelDataType.Task.ToString(),
ActionType.Index.ToString(), taskItemViewModelM);
break;
}
}
}
}
private async Task <bool> MoveTask(TaskListItemViewModel selectedTaskList, TaskItemViewModel task)
{
Messenger.Publish(new ShowProgressOverlayMsg(this));
var moveResponse = await _dataService
.TaskService
.MoveAsync(selectedTaskList.GoogleId, task.GoogleId, null, null);
if (moveResponse.Succeed)
{
var movedTask = moveResponse.Result;
//If this task had a reminder, we need to recreate it
if (TasksHelper.HasReminderId(movedTask.RemindOnGUID, out int id))
{
ReAddReminderDate(id, selectedTaskList, movedTask);
}
foreach (var st in task.SubTasks)
{
st.ParentTask = moveResponse.Result.GoogleTaskID;
}
await MoveSubTasks(selectedTaskList.GoogleId, task.SubTasks);
}
else
{
Logger.Error(
$"{nameof(MoveTask)}: An error occurred while tryingg to move taskId = {task.Id}. " +
$"Error = {moveResponse.Message}");
}
Messenger.Publish(new TaskMovedMsg(this, task.GoogleId, selectedTaskList.GoogleId, task.ParentTask));
Messenger.Publish(new ShowProgressOverlayMsg(this, false));
return(moveResponse.Succeed);
}
public ActionResult Delete(TaskItemViewModel deleteTask)
{
return HandleForm(deleteTask).WithSuccessResult(this.RedirectToAction(x => x.Index()));
}
public DeleteTaskRequestMsg(object sender, TaskItemViewModel task) : base(sender)
{
Task = task;
}
public void addNewTaskItem(TaskItemViewModel taskItem)
{
taskItemRepository.addNewTaskItem(taskItem);
}
