private void Awake()
{
_baseTaskItem = transform.Find("ScrollRect_Tasks/Viewport/Content/BaseTaskItem").gameObject;
_Dropdown_TaskFilter = transform.Find("Dropdown_TaskFilter").GetComponent <Dropdown>();
_Transform_TasksParent = transform.Find("ScrollRect_Tasks/Viewport/Content");
_InputField_Task = transform.Find("InputField_Task").GetComponent <InputField>();
_Button_AddTask = transform.Find("Button_Add").GetComponent <Button>();
_Dropdown_TaskFilter.onValueChanged.AddListener(OnTaskFilterSelected);
_Button_AddTask.onClick.AddListener(OnClickAddTask);
_taskPresenter = new TaskPresenter(this);
_taskPresenter.LoadTasks();
_taskPresenter.SetFiltering(TasksFilterType.ALL_TASKS);
_baseTaskItem.SetActive(false);
}
public ActionResult ValidateDetails(TaskPresenter presenter)
{
ModelState.Clear();
if (presenter != null)
{
Validate(presenter);
}
return new JsonResult { Data = presenter, MaxJsonLength = int.MaxValue };
}
public ActionResult AddTaskComments(TaskPresenter taskPresenter)
{
if (taskPresenter != null && taskPresenter.TaskDetails != null && taskPresenter.TaskDetails.TaskID > 0 && SessionData.Instance.UserInfo != null && SessionData.Instance.UserInfo.Developer != null)
{
string attachmentIds = null;
if (!string.IsNullOrEmpty(taskPresenter.CommentAttachmentId))
{
attachmentIds = taskPresenter.CommentAttachmentId;
}
this.taskService.TaskCommentInsert(taskPresenter.TaskDetails.TaskID, taskPresenter.Description, attachmentIds, SessionData.Instance.UserInfo.Developer.DeveloperID);
taskPresenter.AssignTaskComments(this.taskService.RetrieveTaskComment(taskPresenter.TaskDetails.TaskID));
this.AssignTaskCommentAttachments(taskPresenter);
taskPresenter.AssignTaskHistory(this.taskService.RetrieveTaskHistory(taskPresenter.TaskDetails.TaskID, DefaultValue, taskPresenter.Offset + TaskPresenter.NumberOfRecord));
return this.PartialView(TaskCommentsContainer, taskPresenter);
}
return this.Json(string.Empty);
}
public TaskController(IInputExecuteBoundary taskInteractor, TaskPresenter taskPresenter)
{
_taskInteractor = taskInteractor;
_taskPresenter = taskPresenter;
}
/// <summary>
/// Assigns the basic data.
/// </summary>
/// <param name="taskPresenter">The task presenter.</param>
private void AssignBasicData(TaskPresenter taskPresenter)
{
taskPresenter.AssignPriorityList(this.lookupService.RetrieveTaskPriorityList(SessionData.Instance.UserInfo.Developer.DeveloperID));
taskPresenter.AssignTaskStatusFilter(this.lookupService.RetrieveTaskStatusFilterList(SessionData.Instance.UserInfo.Developer.DeveloperID));
}
/// <summary>
/// Assigns the data.
/// </summary>
/// <param name="taskPresenter">The task presenter.</param>
private void AssignData(TaskPresenter taskPresenter)
{
if (SessionData.Instance.UserInfo != null && SessionData.Instance.UserInfo.Developer != null)
{
this.AssignBasicData(taskPresenter);
if (taskPresenter.IsEdit)
{
this.AssignEditTaskData(taskPresenter);
}
else
{
this.AssignAddTaskData(taskPresenter);
}
}
}
/// <summary>
/// Validates the added task details.
/// </summary>
/// <param name="presenter">The presenter.</param>
private static void ValidateAddedTaskDetails(TaskPresenter presenter)
{
if (string.IsNullOrWhiteSpace(presenter.TaskName))
{
presenter.ValidationErrors.Add(TaskName, Resources.TaskNameErrorMessage);
}
else
{
presenter.TaskName = presenter.TaskName.Trim();
}
if (Convert.ToInt32(presenter.SelectedDeveloper, CultureInfo.CurrentCulture) == -1 && !string.IsNullOrEmpty(presenter.PortalName) && presenter.PortalName.Equals(Resources.TeamMemberDashboard))
{
presenter.ValidationErrors.Add(Developer, Resources.TeamMemberErrorMessage);
}
if (!string.IsNullOrWhiteSpace(presenter.PortalName))
{
if (presenter.PortalName.Equals(Resources.ProjectDashboard, StringComparison.OrdinalIgnoreCase))
{
if (Convert.ToInt32(presenter.SelectedProject, CultureInfo.CurrentCulture) == -1)
{
presenter.ValidationErrors.Add(Project, Resources.ProjectErrorMessage);
}
}
}
if (presenter.EstimatedHours == null)
{
presenter.ValidationErrors.Add(EstimatedHours, Resources.EstimatedHoursNullValueErrorMessage);
}
if (presenter.EstimatedHours <= 0)
{
presenter.ValidationErrors.Add(EstimatedHours, Resources.EstimatedZeroHourErrorMessage);
}
if (presenter.DueDate != null && presenter.StartDate != null && presenter.StartDate > presenter.DueDate)
{
presenter.ValidationErrors.Add(StartDate, Resources.CompareStartDateAndDueDate);
}
if (presenter.TaskDetails.CompletedPercent != null && presenter.PercentCompleted == null)
{
presenter.ValidationErrors.Add(PercentCompleted, Resources.PercentCompletedBlankErrorMessage);
}
else if (presenter.PercentCompleted > 100)
{
presenter.ValidationErrors.Add(PercentCompleted, Resources.PercentCompletedErrorMessage);
}
if (presenter.SelectedStatus == RemoveStatus && SessionData.Instance.UserInfo.Developer.UserType == UserType.Normal)
{
presenter.ValidationErrors.Add(TaskStatus, Resources.StatusRemoveError);
}
}
public ActionResult GetDeveloperListByProject(TaskPresenter taskPresenter, string projectId)
{
if (taskPresenter != null)
{
taskPresenter.SelectedProject = Convert.ToInt32(projectId, CultureInfo.CurrentCulture);
taskPresenter.AssignDeveloperListByProjectId(this.taskService.RetrieveDeveloperByProjectId(taskPresenter.SelectedProject, SessionData.Instance.UserInfo.Developer.DeveloperID, TaskType));
return this.Json(taskPresenter);
}
return this.Json(string.Empty);
}
/// <summary>
/// Tasks the details.
/// </summary>
/// <param name="projectId">The project id.</param>
/// <param name="taskId">The task id.</param>
/// <param name="includeInactive">The include inactive.</param>
/// <param name="developerId">The developer id.</param>
/// <param name="tabId">The tab id.</param>
/// <param name="parentTaskId">The parent task identifier.</param>
/// <returns>
/// returns Task Details view
/// </returns>
public ActionResult TaskDetails(int? projectId, int? taskId, string includeInactive, string developerId, string tabId, int? parentTaskId)
{
var taskPresenter = new TaskPresenter { TabId = tabId, TaskId = taskId };
if (taskId == null)
{
return this.Redirect(Url.AccountAction());
}
var taskInfos = this.taskService.RetrieveTask(taskId);
List<string> features = new List<string>();
foreach (var item in taskInfos)
{
features.Add(item.FeatureID.ToString());
}
taskPresenter.FeatureIds = string.Join(", ", features.ToArray());
var taskInfo = taskInfos.FirstOrDefault();
if (taskInfo == null)
{
return this.Redirect(this.Url.AccountAction());
}
if (parentTaskId != null)
{
taskInfo.ParentTaskID = parentTaskId;
}
if (projectId != null)
{
taskPresenter.PortalName = Resources.ProjectDashboard;
if (!string.IsNullOrWhiteSpace(includeInactive))
{
taskPresenter.IncludeInactive = Convert.ToBoolean(includeInactive, CultureInfo.CurrentCulture);
}
this.AddBreadcrumbItem(Resources.ProjectDashboard, this.RetrieveProjectDashboardAddress(this.Url.ProjectDashboardAction(), projectId, includeInactive, taskPresenter.TabId));
}
else if (!string.IsNullOrWhiteSpace(developerId))
{
taskPresenter.SelectedDeveloper = int.Parse(developerId);
this.AddBreadcrumbItem(Resources.TeamMemberDashboard, this.RetrieveTeamMemberDashboardAddress(this.Url.TeamDashboardAction(), developerId));
taskPresenter.SelectedDeveloper = Convert.ToInt32(developerId, CultureInfo.CurrentCulture);
taskPresenter.PortalName = Resources.TeamMemberDashboard;
}
if (taskInfo.ParentTaskID != null)
{
taskPresenter.FromSubTaskDetailView = true;
this.AddBreadcrumbItem(Resources.SubTaskDetail, string.Empty);
}
else
{
this.AddBreadcrumbItem(Resources.TaskDetails, string.Empty);
}
this.AssignBasicData(taskPresenter);
taskPresenter.AssignTaskDetails(taskInfo);
taskPresenter.AssignTaskComments(this.taskService.RetrieveTaskComment(taskId));
this.AssignTaskCommentAttachments(taskPresenter);
taskPresenter.IsExpiredDueDate = taskInfo.TaskDueDate == null ? (bool?)null : taskInfo.TaskDueDate < DateTimeHelper.RetrieveCurrentDate();
taskPresenter.AssignSubTask(this.taskService.RetrieveSubtask(taskId));
taskPresenter.Offset = DefaultValue;
taskPresenter.AssignTaskHistory(this.taskService.RetrieveTaskHistory(taskId, taskPresenter.Offset, TaskPresenter.NumberOfRecord));
this.AssignAttachmentList(taskPresenter);
return this.View(taskPresenter);
}
/// <summary>
/// Saves the task.
/// </summary>
/// <param name="taskPresenter">The task presenter.</param>
/// <returns>added or updated new task</returns>
public ActionResult SaveTask(TaskPresenter taskPresenter)
{
if (taskPresenter != null)
{
byte priority = Convert.ToByte(taskPresenter.SelectedPriority, CultureInfo.CurrentCulture);
string developerId = Convert.ToString(taskPresenter.SelectedDeveloper, CultureInfo.CurrentCulture);
if (developerId.Equals(DefaultDeveloperId))
{
developerId = null;
}
if (taskPresenter.PortalName != null && taskPresenter.PortalName.Equals(Resources.TeamMemberDashboard, StringComparison.OrdinalIgnoreCase) && taskPresenter.TaskDetails.ProjectID == -1)
{
taskPresenter.TaskDetails.ProjectID = null;
}
if (SessionData.Instance.UserInfo != null && SessionData.Instance.UserInfo.Developer != null)
{
string attachmentIds = null;
if (!string.IsNullOrEmpty(taskPresenter.AttachmentIds))
{
attachmentIds = taskPresenter.AttachmentIds;
}
if (taskPresenter.IsEdit)
{
if (taskPresenter.PortalName != null && taskPresenter.PortalName.Equals(Resources.ProjectDashboard, StringComparison.OrdinalIgnoreCase) && taskPresenter.TaskDetails.ProjectID == -1)
{
taskPresenter.ValidationErrors.Add(Project, Resources.ProjectErrorMessage);
}
else
{
ErrorListItem error = this.taskService.UpdateTask(taskPresenter.TaskId, TaskType, taskPresenter.TaskDetails.ProjectID, taskPresenter.TaskName, taskPresenter.Description, taskPresenter.SelectedStatus, priority, taskPresenter.DueDate, developerId, taskPresenter.EstimatedHours, attachmentIds, SessionData.Instance.UserInfo.Developer.DeveloperID, null, taskPresenter.StartDate, taskPresenter.PercentCompleted);
if (error != null)
{
return this.Json(error.Message);
}
return null;
}
}
else
{
if (Convert.ToInt32(taskPresenter.SelectedProject, CultureInfo.CurrentCulture) == -1)
{
taskPresenter.SelectedProject = null;
}
//// to add task
this.taskService.InsertTask(TaskType, taskPresenter.SelectedProject, taskPresenter.TaskName, taskPresenter.Description, priority, taskPresenter.SelectedStatus, taskPresenter.DueDate, developerId, taskPresenter.EstimatedHours, attachmentIds, SessionData.Instance.UserInfo.Developer.DeveloperID, null, taskPresenter.StartDate, taskPresenter.PercentCompleted);
}
}
return this.Json(taskPresenter);
}
return this.Json(string.Empty);
}
/// <summary>
/// Indexes the specified project id.
/// </summary>
/// <param name="projectId">The project id.</param>
/// <param name="includeInactive">The include inactive.</param>
/// <param name="developerId">The developer id.</param>
/// <param name="tabId">The tab id.</param>
/// <returns>
/// returns Task view
/// </returns>
public ActionResult Index(string projectId, string includeInactive, string developerId, string tabId)
{
var taskPresenter = new TaskPresenter();
if (string.IsNullOrWhiteSpace(projectId) && string.IsNullOrWhiteSpace(developerId))
{
return this.Redirect(Url.AccountAction());
}
taskPresenter.TabId = tabId;
if (!string.IsNullOrEmpty(developerId))
{
this.AddBreadcrumbItem(Resources.TeamMemberDashboard, this.RetrieveTeamMemberDashboardAddress(Url.TeamDashboardAction(), developerId));
taskPresenter.PortalName = Resources.TeamMemberDashboard;
taskPresenter.SelectedDeveloper = Convert.ToInt32(developerId, CultureInfo.CurrentCulture);
}
if (!string.IsNullOrEmpty(projectId))
{
taskPresenter.PortalName = Resources.ProjectDashboard;
taskPresenter.SelectedProject = Convert.ToInt32(projectId, CultureInfo.CurrentCulture);
this.AddBreadcrumbItem(Resources.ProjectDashboard, this.RetrieveProjectDashboardAddress(Url.ProjectDashboardAction(), taskPresenter.SelectedProject, includeInactive, tabId));
}
if (!string.IsNullOrEmpty(includeInactive))
{
taskPresenter.IncludeInactive = Convert.ToBoolean(includeInactive, CultureInfo.CurrentCulture);
}
this.AddBreadcrumbItem(Resources.AddTask, string.Empty);
this.AssignData(taskPresenter);
////------------------to set default selected priority------------------------
if (taskPresenter.PriorityList.Count > 0)
{
var priority = taskPresenter.PriorityList.Where(item => item.Name.Equals(DefaultPriority));
if (priority != null)
{
var taskPriority = priority.FirstOrDefault();
if (taskPriority != null)
{
taskPresenter.SelectedPriority = taskPriority.ID;
}
}
}
return this.View(taskPresenter);
}
/// <summary>
/// Assigns the task comment attachments.
/// </summary>
/// <param name="taskPresenter">The task presenter.</param>
private void AssignTaskCommentAttachments(TaskPresenter taskPresenter)
{
if (taskPresenter.TaskComments != null)
{
foreach (TaskCommentDetail commentDetail in taskPresenter.TaskComments)
{
commentDetail.AssignCommentAttachmentList(this.taskService.RetrieveTaskAttachmentList(null, commentDetail.TaskCommentID));
IList<int> commentAttachmentIds = new List<int>();
foreach (var attachment in commentDetail.CommentAttachmentList)
{
commentAttachmentIds.Add(attachment.TaskAttachmentID);
}
string attachmentIds = string.Join(",", commentAttachmentIds);
taskPresenter.CommentAttachmentIds.Add(attachmentIds);
}
taskPresenter.AssignCommentAttachmentList(taskPresenter.CommentAttachmentIds);
}
}
/// <summary>
/// Assigns the attachment list.
/// </summary>
/// <param name="taskPresenter">The task presenter.</param>
private void AssignAttachmentList(TaskPresenter taskPresenter)
{
taskPresenter.AssigntaskAttachmentList(this.taskService.RetrieveTaskAttachmentList(taskPresenter.TaskId, null));
IList<int> taskAttachmentIds = new List<int>();
foreach (var attachment in taskPresenter.TaskAttachmentList)
{
taskAttachmentIds.Add(attachment.TaskAttachmentID);
}
taskPresenter.AttachmentIds = string.Join(",", taskAttachmentIds);
}
/// <summary>
/// Assigns the edit task data.
/// </summary>
/// <param name="taskPresenter">The task presenter.</param>
private void AssignEditTaskData(TaskPresenter taskPresenter)
{
taskPresenter.AssignProjectsList(taskPresenter.IncludeInactive ? this.lookupService.RetrieveProjects(null, null, null, false, SessionData.Instance.UserInfo.Developer.DeveloperID) : this.lookupService.RetrieveProjects(null, null, false, false, SessionData.Instance.UserInfo.Developer.DeveloperID));
taskPresenter.AssignDeveloperListByProjectId(this.taskService.RetrieveDeveloperByProjectId(taskPresenter.TaskDetails.ProjectID, SessionData.Instance.UserInfo.Developer.DeveloperID, TaskType));
if (taskPresenter.TaskStatusFilterList.Count > 0)
{
if (taskPresenter.TaskDetails != null && taskPresenter.TaskDetails.Status == InProgressStatus)
{
taskPresenter.TaskStatusFilterList.Remove(taskPresenter.TaskStatusFilterList.FirstOrDefault(item => item.Name.Equals(DefaultNewStatus)));
}
}
}
/// <summary>
/// Shows the more task history.
/// </summary>
/// <param name="presenter">The presenter.</param>
/// <param name="taskId">The task identifier.</param>
/// <returns>return task</returns>
public ActionResult ShowMoreTaskHistory(TaskPresenter presenter, string taskId)
{
if (presenter != null)
{
presenter.AssignTaskHistory(this.taskService.RetrieveTaskHistory(Convert.ToInt32(taskId, CultureInfo.CurrentCulture), presenter.Offset, TaskPresenter.NumberOfRecord));
}
return this.PartialView(TaskHistoryContainer, presenter);
}
public ActionResult GetProjectListByDeveloper(TaskPresenter taskPresenter, string developerId)
{
if (taskPresenter != null)
{
taskPresenter.SelectedDeveloper = Convert.ToInt32(developerId, CultureInfo.CurrentCulture);
taskPresenter.AssignProjectsByDeveloperId(this.taskService.RetrieveProjectByDeveloperId(taskPresenter.SelectedDeveloper, SessionData.Instance.UserInfo.Developer.DeveloperID));
return this.Json(taskPresenter);
}
return this.Json(string.Empty);
}
/// <summary>
/// Subs the task details.
/// </summary>
/// <param name="subTaskId">The sub task identifier.</param>
/// <returns>sub task partial view</returns>
public ActionResult SubTaskDetails(int? subTaskId)
{
var taskPresenter = new TaskPresenter { TaskId = subTaskId };
var taskInfo = this.taskService.RetrieveTask(subTaskId).FirstOrDefault();
if (taskInfo != null)
{
this.AssignBasicData(taskPresenter);
taskPresenter.AssignTaskDetails(taskInfo);
taskPresenter.TaskId = taskInfo.TaskID;
this.AssignAttachmentList(taskPresenter);
}
return this.PartialView("_SubTaskDetail", taskPresenter);
}
private static void Validate(TaskPresenter presenter)
{
if (presenter.PortalName != null && presenter.PortalName.Equals(Resources.TaskDetails))
{
if (string.IsNullOrWhiteSpace(presenter.Description))
{
presenter.ValidationErrors.Add(TaskComments, Resources.EmptyCommentsErrorMessage);
}
}
else if (presenter.PortalName != null && (presenter.PortalName.Equals(Resources.AddSubTask) || presenter.PortalName.Equals(Resources.EditSubTask)))
{
ValidateSubTaskDetails(presenter);
}
else
{
ValidateAddedTaskDetails(presenter);
}
}
/// <summary>
/// Adds the sub task.
/// </summary>
/// <param name="projectId">The project identifier.</param>
/// <param name="taskId">The task identifier.</param>
/// <param name="includeInactive">The include inactive.</param>
/// <param name="developerId">The developer identifier.</param>
/// <param name="tabId">The tab identifier.</param>
/// <returns>returns sub task view</returns>
public ActionResult AddSubTask(int? projectId, int? taskId, string includeInactive, string developerId, string tabId)
{
var taskPresenter = new TaskPresenter { TabId = tabId };
if (taskId == null || (projectId == null && string.IsNullOrWhiteSpace(developerId)))
{
return this.Redirect(Url.AccountAction());
}
var taskInfo = this.taskService.RetrieveTask(taskId).FirstOrDefault();
if (taskInfo == null)
{
return this.Redirect(this.Url.AccountAction());
}
if (projectId != null)
{
if (!string.IsNullOrWhiteSpace(includeInactive))
{
taskPresenter.IncludeInactive = Convert.ToBoolean(includeInactive, CultureInfo.CurrentCulture);
}
taskPresenter.SelectedProject = projectId.Value;
}
else if (!string.IsNullOrWhiteSpace(developerId))
{
taskPresenter.SelectedDeveloper = Convert.ToInt32(developerId);
}
this.AddBreadcrumbItem(Resources.TaskDetails, this.RetrieveTaskDetailsAddress(this.Url.TaskDetailsAction(), Convert.ToString(projectId), developerId, tabId, includeInactive, Convert.ToString(taskId)));
this.AddBreadcrumbItem(Resources.AddSubTask, string.Empty);
taskPresenter.PortalName = Resources.AddSubTask;
this.AssignData(taskPresenter);
taskPresenter.AssignTaskDetails(taskInfo);
taskPresenter.MainTaskStartDate = taskInfo.StartDate;
taskPresenter.MainTaskDueDate = taskInfo.TaskDueDate;
taskPresenter.StartDate = DateTimeHelper.RetrieveCurrentDate();
return this.View(taskPresenter);
}
/// <summary>
/// Validates the sub task details.
/// </summary>
/// <param name="presenter">The presenter.</param>
private static void ValidateSubTaskDetails(TaskPresenter presenter)
{
if (string.IsNullOrWhiteSpace(presenter.TaskName))
{
presenter.ValidationErrors.Add(SubTaskName, Resources.TaskNameErrorMessage);
}
else
{
presenter.TaskName = presenter.TaskName.Trim();
}
if (presenter.StartDate != null && presenter.StartDate < presenter.MainTaskStartDate)
{
presenter.ValidationErrors.Add(StartDate, Resources.CompareSubTaskStartDate);
}
else if (presenter.StartDate != null && presenter.StartDate > presenter.MainTaskDueDate)
{
presenter.ValidationErrors.Add(StartDate, Resources.CompareSubTaskStartDateEnd);
}
else if (presenter.StartDate != null && presenter.DueDate != null && presenter.StartDate > presenter.DueDate)
{
presenter.ValidationErrors.Add(StartDate, Resources.CompareStartDateAndDueDate);
}
if (presenter.DueDate != null && presenter.DueDate < presenter.MainTaskStartDate)
{
presenter.ValidationErrors.Add(DueDate, Resources.CompareSubTaskDueDateStart);
}
else if (presenter.DueDate != null && presenter.MainTaskDueDate != null && presenter.DueDate > presenter.MainTaskDueDate)
{
presenter.ValidationErrors.Add(DueDate, Resources.CompareSubTaskDueDate);
}
if (presenter.TaskDetails.CompletedPercent != null && presenter.PercentCompleted == null)
{
presenter.ValidationErrors.Add(PercentCompleted, Resources.PercentCompletedBlankErrorMessage);
}
else if (presenter.PercentCompleted > 100)
{
presenter.ValidationErrors.Add(PercentCompleted, Resources.PercentCompletedErrorMessage);
}
if (presenter.EstimatedHours == null)
{
presenter.ValidationErrors.Add(EstimatedHours, Resources.EstimatedHoursNullValueErrorMessage);
}
if (presenter.EstimatedHours <= 0)
{
presenter.ValidationErrors.Add(EstimatedHours, Resources.EstimatedZeroHourErrorMessage);
}
}
public ActionResult SaveSubTask(TaskPresenter taskPresenter)
{
if (taskPresenter != null)
{
string developerId = Convert.ToString(taskPresenter.SelectedDeveloper, CultureInfo.CurrentCulture);
if (developerId.Equals(DefaultDeveloperId))
{
developerId = null;
}
if (SessionData.Instance.UserInfo != null && SessionData.Instance.UserInfo.Developer != null)
{
string attachmentIds = null;
if (!string.IsNullOrEmpty(taskPresenter.AttachmentIds))
{
attachmentIds = taskPresenter.AttachmentIds;
}
if (taskPresenter.IsEdit)
{
////to edit sub task
this.taskService.UpdateTask(taskPresenter.TaskDetails.TaskID, TaskType, taskPresenter.TaskDetails.ProjectID, taskPresenter.TaskName, taskPresenter.Description, taskPresenter.SelectedTaskStatus, taskPresenter.TaskDetails.Priority, taskPresenter.DueDate, developerId, taskPresenter.EstimatedHours, attachmentIds, SessionData.Instance.UserInfo.Developer.DeveloperID, null, taskPresenter.StartDate, taskPresenter.PercentCompleted);
}
else
{
////to add sub task
this.taskService.InsertTask(TaskType, taskPresenter.TaskDetails.ProjectID, taskPresenter.TaskName, taskPresenter.Description, taskPresenter.TaskDetails.Priority, taskPresenter.SelectedTaskStatus, taskPresenter.DueDate, developerId, taskPresenter.EstimatedHours, attachmentIds, SessionData.Instance.UserInfo.Developer.DeveloperID, taskPresenter.TaskDetails.TaskID, taskPresenter.StartDate, taskPresenter.PercentCompleted);
}
}
return this.Json(taskPresenter);
}
return this.Json(string.Empty);
}
/// <summary>
/// Assigns the add task data.
/// </summary>
/// <param name="taskPresenter">The task presenter.</param>
private void AssignAddTaskData(TaskPresenter taskPresenter)
{
if (taskPresenter.SelectedProject != DefaultValue)
{
taskPresenter.AssignDeveloperListByProjectId(this.taskService.RetrieveDeveloperByProjectId(taskPresenter.SelectedProject, SessionData.Instance.UserInfo.Developer.DeveloperID, TaskType));
}
else
{
taskPresenter.AssignDeveloperList(this.developerService.RetrieveList(null, null, SessionData.Instance.UserInfo.Developer.DeveloperID));
}
if (taskPresenter.SelectedDeveloper != DefaultValue)
{
taskPresenter.AssignProjectsByDeveloperId(this.taskService.RetrieveProjectByDeveloperId(taskPresenter.SelectedDeveloper, SessionData.Instance.UserInfo.Developer.DeveloperID));
}
else
{
taskPresenter.AssignProjectsList(taskPresenter.IncludeInactive ? this.lookupService.RetrieveProjects(null, null, null, false, SessionData.Instance.UserInfo.Developer.DeveloperID) : this.lookupService.RetrieveProjects(null, null, false, false, SessionData.Instance.UserInfo.Developer.DeveloperID));
}
taskPresenter.StartDate = DateTimeHelper.RetrieveCurrentDate();
}
/// <summary>
/// Edits the task.
/// </summary>
/// <param name="taskPresenter">The task presenter.</param>
/// <param name="taskId">The task id.</param>
/// <param name="portalName">Name of the portal.</param>
/// <param name="includeInactive">The include inactive.</param>
/// <param name="tabId">The tab id.</param>
/// <returns>
/// returns Edit task view
/// </returns>
public ActionResult EditTask(TaskPresenter taskPresenter, string taskId, string portalName, string includeInactive, string tabId)
{
if (taskPresenter == null || string.IsNullOrWhiteSpace(taskId))
{
return this.Redirect(Url.AccountAction());
}
taskPresenter.TaskId = Convert.ToInt32(taskId, CultureInfo.CurrentCulture);
var taskInfo = this.taskService.RetrieveTask(taskPresenter.TaskId).FirstOrDefault();
this.AssignAttachmentList(taskPresenter);
if (taskInfo == null)
{
return this.Redirect(this.Url.AccountAction());
}
var subTaskInfo = this.taskService.RetrieveSubtask(taskPresenter.TaskId);
if (subTaskInfo != null && subTaskInfo.Count > 0)
{
taskPresenter.HasSubTask = true;
taskPresenter.IsAllSubTaskCompleted = subTaskInfo.All(s => s.Status == DoneStatus);
taskPresenter.SubTaskDueDate = subTaskInfo.Max(s => s.SubTaskDueDate);
}
taskPresenter.AssignTaskDetails(taskInfo);
taskPresenter.IsEdit = true;
string projectId = null;
string developerId = null;
if (!string.IsNullOrWhiteSpace(portalName))
{
if (portalName.Equals(Resources.TeamMemberDashboard))
{
developerId = taskPresenter.TaskDetails.DeveloperIDs;
}
else if (portalName.Equals(Resources.ProjectDashboard))
{
projectId = Convert.ToString(taskInfo.ProjectID, CultureInfo.CurrentCulture);
}
}
this.AddBreadcrumbItem(Resources.TaskDetails, this.RetrieveTaskDetailsAddress(this.Url.TaskDetailsAction(), projectId, developerId, tabId, includeInactive, taskId));
this.AddBreadcrumbItem(Resources.EditTask, string.Empty);
this.AssignData(taskPresenter);
return this.View(taskPresenter);
}
/// <summary>
/// Edits the sub task.
/// </summary>
/// <param name="projectId">The project identifier.</param>
/// <param name="taskId">The task identifier.</param>
/// <param name="subTaskId">The sub task identifier.</param>
/// <param name="includeInactive">The include inactive.</param>
/// <param name="developerId">The developer identifier.</param>
/// <param name="tabId">The tab identifier.</param>
/// <param name="fromSubTaskDetailView">From sub task detail view.</param>
/// <returns>edit sub task</returns>
public ActionResult EditSubTask(int? projectId, int? taskId, int? subTaskId, string includeInactive, string developerId, string tabId, string fromSubTaskDetailView)
{
var taskPresenter = new TaskPresenter { TabId = tabId, TaskId = taskId };
taskPresenter.FromSubTaskDetailView = Convert.ToBoolean(fromSubTaskDetailView, CultureInfo.CurrentCulture);
if (subTaskId == null || taskId == null || (projectId == null && string.IsNullOrWhiteSpace(developerId)))
{
return this.Redirect(this.Url.AccountAction());
}
var mainTaskInfo = this.taskService.RetrieveTask(taskId).FirstOrDefault();
var subTaskInfo = this.taskService.RetrieveTask(subTaskId).FirstOrDefault();
if (subTaskInfo == null)
{
return this.Redirect(this.Url.AccountAction());
}
if (projectId != null)
{
if (!string.IsNullOrWhiteSpace(includeInactive))
{
taskPresenter.IncludeInactive = Convert.ToBoolean(includeInactive, CultureInfo.CurrentCulture);
}
taskPresenter.SelectedProject = projectId.Value;
}
else if (!string.IsNullOrWhiteSpace(developerId))
{
taskPresenter.SelectedDeveloper = Convert.ToInt32(developerId);
}
taskPresenter.TaskId = subTaskId;
this.AssignAttachmentList(taskPresenter);
taskPresenter.IsEdit = true;
this.AddBreadcrumbItem(Resources.TaskDetails, this.RetrieveTaskDetailsAddress(this.Url.TaskDetailsAction(), Convert.ToString(projectId), developerId, tabId, includeInactive, Convert.ToString(taskId)));
this.AddBreadcrumbItem(Resources.EditSubTask, string.Empty);
taskPresenter.PortalName = Resources.EditSubTask;
taskPresenter.AssignTaskDetails(subTaskInfo);
taskPresenter.DueDate = taskPresenter.TaskDetails.TaskDueDate;
taskPresenter.StartDate = taskPresenter.TaskDetails.StartDate;
taskPresenter.MainTaskStartDate = mainTaskInfo.StartDate;
taskPresenter.MainTaskDueDate = mainTaskInfo.TaskDueDate;
taskPresenter.PercentCompleted = taskPresenter.TaskDetails.CompletedPercent;
this.AssignData(taskPresenter);
return this.View(taskPresenter);
}
/// <summary>
/// Called by Unity
/// </summary>
public void Start()
{
SetPresenter(_taskPresenter = new TaskPresenter(this));
}
