/// <summary>
/// Akcja przygotowuje widok dla głównej strony aplikacji.
/// Jeżeli zalogowany zostanie użytkownik z rolą "User",
/// to zostanie wygenerowany widok listy zadań (widok użytkownika - pracownika).
/// </summary>
/// <returns>Lista zadań użytkownika lub widok strony głównej.</returns>
public async Task <IActionResult> IndexAsync()
{
if (User.IsInRole("User"))
{
var user = await userManager.GetUserAsync(User);
var employee = _context.Employees.Where(e => e.EmployeeUserID == user.Id).Single();
var ListOfTasks = _context.ProjectTasks.Where(p => p.EmployeeID == employee.EmployeeID).ToList();
List <ProjectTaskViewModel> ListOfTasksViewModel = new List <ProjectTaskViewModel>();
foreach (var item in ListOfTasks)
{
ProjectTaskViewModel projectTaskViewModel = new ProjectTaskViewModel();
projectTaskViewModel.TaskName = item.TaskName;
var CreatedBy = _context.Employees.Where(e => e.EmployeeID == item.TaskCreatedBy).First();
projectTaskViewModel.TaskID = item.TaskID;
projectTaskViewModel.TaskDeadline = item.TaskDeadline;
projectTaskViewModel.TaskCreatedBy = CreatedBy.EmployeeNameSurname;
projectTaskViewModel.IsEnd = item.IsEnd;
ListOfTasksViewModel.Add(projectTaskViewModel);
}
return(View(ListOfTasksViewModel));
}
return(View());
}
public async Task <BaseResult <int> > InsertProject(ProjectTaskViewModel model)
{
var project = _mapper.Map <Project>(model);
await Repository.InsertAsync(project);
return(BaseResult <int> .OK(project.Id, Messages.ItemInserted));
}
public async Task <ActionResult <ProjectTaskViewModel> > GetProjectTaskAsync(Guid id)
{
if (id == Guid.Empty)
{
return(BadRequest("No valid id."));
}
try
{
TaskResult <ProjectTask> result = await taskService.GetProjectTaskAsync(id);
if (!result.Succeeded)
{
if (result.Data == null)
{
return(NotFound());
}
}
ProjectTaskViewModel projectTaskViewModel = ProjectTaskViewModel.CreateVm(result.Data);
return(Ok(projectTaskViewModel));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(GetProjectTaskAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public ActionResult AddTask()
{
var item = new ProjectTaskViewModel();
item.Employeess = new SelectList(TaskServ.Displaypendingtasks(), "EmployeeId", "EmployeeName", "EmployeeDesignation");
return(View(item));
}
public async Task <ActionResult <TaskViewModel> > AddTaskToProjectAsync(ProjectTaskViewModel projectTaskViewModel)
{
if (projectTaskViewModel == null)
{
return(BadRequest("No valid ProjectTask received"));
}
if (projectTaskViewModel.ProjectId == Guid.Empty || projectTaskViewModel.TaskId == Guid.Empty)
{
return(BadRequest("Project and/or Task Ids cannot be empty"));
}
try
{
ProjectTask projectTask = ProjectTaskViewModel.CreateProjectTask(projectTaskViewModel);
if (projectTask == null)
{
return(BadRequest("Unable to convert ProjectTaskViewModel to ProjectTask"));
}
projectTask.Task = (await taskService.GetTaskAsync(projectTask.TaskId)).Data;
projectTask.Project = (await projectService.GetProjectDetailsAsync(projectTask.ProjectId)).Data;
if (projectTask.Task == null || projectTask.Project == null)
{
return(BadRequest("Unable to add project and or task to projecttask"));
}
string oid = IdentityHelper.GetOid(HttpContext.User.Identity as ClaimsIdentity);
projectTask.LastEditBy = oid;
TaskResult <ProjectTask> result;
if (projectTask.Id == Guid.Empty)
{
result = await taskService.AddTaskToProjectAsync(projectTask);
}
else
{
return(BadRequest("Cannot update existing ProjectTask with post method"));
}
if (!result.Succeeded)
{
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = result.Message
}));
}
return(Ok(TaskViewModel.CreateVm(result.Data.Task)));
}
catch (Exception ex)
{
string message = GetType().Name + "Error in " + nameof(AddTaskToProjectAsync);
logger.LogError(ex, message);
return(UnprocessableEntity(new ErrorViewModel {
Type = Type.Error, Message = message
}));
}
}
public async Task <ActionResult> Change(int id)
{
Project project = _task.GetProject(id);
ViewBag.TaskLists = new SelectList(project.TaskLists, "Id", "Name");
var model = new ProjectTaskViewModel {
CurrentTask = _task.GetById(id), TaskLists = project.TaskLists.ToList()
};
return(PartialView(model));
}
public ActionResult ProjectTaskByStatus(int id)
{
var pservice = new ProjectService();
var project = pservice.Find(id);
var tservice = new TaskService();
var tasks = tservice.GetTasks(id);
var viewmodel = new ProjectTaskViewModel();
viewmodel.ProjectId = project.ProjectId;
viewmodel.ProjectTitle = project.ProjectTitle;
viewmodel.ProjectStartDate = project.ProjectStartDate;
viewmodel.ProjectEndDate = project.ProjectEndDate;
viewmodel.EmployeeId = project.EmployeeId;
viewmodel.Tasks = tasks;
return(View(viewmodel));
}
public ActionResult DisplayProjectTask(int id)
{
var prepository = new ProjectRepository();
var project = prepository.Find(id);
var trepository = new TaskNRepository();
var tasks = trepository.GetTasks(id);
var viewmodel = new ProjectTaskViewModel();
viewmodel.ProjectId = project.ProjectId;
viewmodel.ProjectTitle = project.ProjectTitle;
viewmodel.ProjectStartDate = project.ProjectStartDate;
viewmodel.ProjectEndDate = project.ProjectEndDate;
viewmodel.EmployeeId = project.EmployeeId;
viewmodel.Tasks = tasks;
return(View(viewmodel));
}
public IHttpActionResult PostProjectTasks(ProjectTaskViewModel projectTasksVM)
//, int projectBoardId
//[FromBody]ProjectTasks projectTasks, [FromUri]int projectBoardId
{
var projectTasks = projectTasksVM.ProjectTasks;
projectTasks.CreatedOn = DateTime.Now;
if (projectTasks.StartedOn != null)
{
projectTasks.StartedOn = Convert.ToDateTime(projectTasks.StartedOn).ToLocalTime();
}
if (projectTasks.EndedOn != null)
{
projectTasks.EndedOn = Convert.ToDateTime(projectTasks.EndedOn).ToLocalTime();
}
if (projectTasks.EstimatedEndsOn != null)
{
projectTasks.EstimatedEndsOn = Convert.ToDateTime(projectTasks.EstimatedEndsOn).ToLocalTime();
}
if (User.Identity.GetUserId() != null)
{
projectTasks.CreatedBy = User.Identity.GetUserId();
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var isNeed = projectTasksVM.IsWordNeed.HasValue? projectTasksVM.IsWordNeed.Value : false;
var res = CreateProjectTask(projectTasksVM.ProjectTasks, isNeed);
//instead of trigger
var addedTask = db.ProjectTasks.Add(projectTasks);
return(CreatedAtRoute("DefaultApi", new { id = addedTask.Id }, addedTask));
}
public async Task <HttpResponse <int> > UpdateProject(ProjectTaskViewModel model)
{
var project = await Repository.FindAsync(model.Id);
if (project == null)
{
return(HttpResponse <int> .Error(Messages.ActionFailed, statusCode : System.Net.HttpStatusCode.NoContent));
}
project.Name = model.Name;
project.StartDate = model.StartDate;
project.EndDate = model.EndDate;
project.AssignTo = model.AssignTo;
project.Status = model.Status;
int saved = await _unitOfWork.SaveChangesAsync();
if (saved > 0)
{
return(HttpResponse <int> .OK(project.Id, Messages.ItemUpdated));
}
return(HttpResponse <int> .Error(Messages.ActionFailed, statusCode : System.Net.HttpStatusCode.BadRequest));
}
public async Task <IActionResult> Post([FromBody] ProjectTaskViewModel task)
{
if (ModelState.IsValid)
{
ProjectTask projectTask = Mapper.Map <ProjectTask>(task);
if (task.TaskID == 0)
{
projectTask.CreatedBy = User.Identity.Name;
projectTask.CreateDate = DateTime.Now;
}
else
{
projectTask = await _taskService.GetTask(task.TaskID);
projectTask.ModifiedBy = User.Identity.Name;
projectTask.ModifyDate = DateTime.Now;
}
await _taskService.SaveTask(projectTask);
}
return(Ok());
}
private string ProjectManagementTaskJson()
{
IEnumerable <TaskMgmtPartRecord> _tasks = _projTasks.GetTasks();
ProjectTaskViewModel _taskPartVM = new ProjectTaskViewModel(_tasks);
dynamic jsonTask = new JObject();
jsonTask.tasks = new JArray(_tasks.Select(_task =>
{
dynamic task = new JObject();
task.id = _task.Id;
task.name = "Demo";
task.status = _task.Status;
task.code = _task.TaskCode;
task.level = _task.Level;
task.duration = _task.Duration;
task.startIsMilestone = _task.StartIsMilestone;
task.endIsMilestone = _task.EndIsMilestone;
task.progress = _task.Progress;
if (_task.Dependancy != null)
{
task.depends = _task.Dependancy;
}
//task.start = DateTime.Now.AddDays(10).Millisecond;
if (_task.ProjStartDate != null)
{
DateTime start = (DateTime)_task.ProjStartDate;
task.start = (long)(start - new DateTime(1970, 1, 1)).TotalMilliseconds;
}
return(task);
}));
jsonTask.selectedRow = 0;
jsonTask.canWrite = true;
jsonTask.canWriteOnParent = true;
return(FormParametersHelper.ToJsonString(jsonTask));
}
public async Task <IActionResult> UpdateProject([FromBody] ProjectTaskViewModel model)
{
var response = await _projectService.UpdateProject(model);
return(StatusCode(response));
}
public async Task <ActionResult> Change(int id, ProjectTaskViewModel model)
{
await _task.ChangePosition(id, model.ChangeId);
return(Json(new { success = true }));
}
public async Task <ActionResult <ProjectTaskViewModel> > UpdateItem([FromForm] ProjectTaskViewModel item)
{
try
{
var existItem = await _projectTaskRepository.ProjectTaskByIdAsync(item.ProjectTaskId);
if (existItem == null)
{
return(NotFound());
}
var project = await ProjectByIdAsync(item.ProjectId);
if (project == null)
{
return(BadRequest("Выбранный проект не найден"));
}
var group = await GroupByIdAsync(item.GroupId);
if (group == null)
{
return(BadRequest("Выбранная группа не найдена"));
}
var taskType = await TaskTypeByIdAsync(item.TaskTypeId);
if (taskType == null)
{
return(BadRequest("Выбранный тип задачи не найден"));
}
var taskStatus = await ProjectTaskStatusByIdAsync(item.ProjectTaskStatusId);
if (taskStatus == null)
{
return(BadRequest("Выбранный статус не найден"));
}
existItem.Block = await BlockByIdAsync(item.BlockId);
existItem.Project = project;
existItem.Group = group;
existItem.TaskStatus = taskStatus;
existItem.TaskType = taskType;
existItem.Details = item.Details;
existItem.Note = item.Note;
existItem.Priority = item.Priority;
existItem.DurationHours = item.DurationHours;
existItem.StartPlan = item.StartPlan;
existItem.EndPlan = item.EndPlan;
existItem.StartFact = item.StartFact;
existItem.EndFact = item.EndFact;
existItem.EffectAfterHours = item.EffectAfterHours;
existItem.EffectAfterHours = item.EffectAfterHours;
existItem.Important = item.Important;
existItem.DateEdited = DateTime.Now;
var userEdited = (await _userRepository.FindAsync(e => !e.Deleted && e.Login.ToLower().Equals(_userService.userLogin.ToLower()))).SingleOrDefault();
existItem.LoginEdited = userEdited != null ? userEdited.ShortName : _userService.userLogin;
var newPerformers = new List <User>();
if (!string.IsNullOrEmpty(item.Users))
{
existItem.ProjectTaskPerformers ??= new List <ProjectTaskPerformer>();
var userIds = item.Users.Split(",").Select(e => int.Parse(e)).ToList();
foreach (var p in existItem.ProjectTaskPerformers)
{
// пользователя нет в новых данных
if (!userIds.Any(e => e == p.UserId))
{
p.Deleted = true;
}
}
foreach (int userId in userIds)
{
// проверяем
if (!existItem.ProjectTaskPerformers.Any(e => e.UserId.Equals(userId) && !e.Deleted))
{
var user = await _userRepository.FindByIdAsync(userId);
if (user != null)
{
existItem.ProjectTaskPerformers.Add(new ProjectTaskPerformer()
{
User = user
});
newPerformers.Add(user);
}
}
}
}
else if (existItem.ProjectTaskPerformers != null && existItem.ProjectTaskPerformers.Count > 0)
{
foreach (var p in existItem.ProjectTaskPerformers)
{
p.Deleted = true;
}
}
await _projectTaskRepository.EditAsync(existItem);
//тут - для новых пользователей создается почтовое уведомление о задаче
await _mailRepository.CreateMailsForNewPerformersAsync(newPerformers, existItem);
return(_mapper.Map <ProjectTaskViewModel>(existItem));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <ActionResult <ProjectTaskViewModel> > CreateItem([FromForm] ProjectTaskViewModel item)
{
try
{
if (item.ProjectTaskId > 0)
{
return(BadRequest("Идентификатор записи должен быть равен 0"));
}
var project = await ProjectByIdAsync(item.ProjectId);
if (project == null)
{
return(BadRequest("Выбранный проект не найден"));
}
var group = await GroupByIdAsync(item.GroupId);
if (group == null)
{
return(BadRequest("Выбранная группа не найдена"));
}
var taskType = await TaskTypeByIdAsync(item.TaskTypeId);
if (taskType == null)
{
return(BadRequest("Выбранный тип задачи не найден"));
}
var taskStatus = await ProjectTaskStatusByIdAsync(item.ProjectTaskStatusId);
if (taskStatus == null)
{
return(BadRequest("Выбранный статус не найден"));
}
var block = await BlockByIdAsync(item.BlockId);
var newItem = _mapper.Map <ProjectTask>(item);
newItem.Project = project;
newItem.Group = group;
newItem.TaskStatus = taskStatus;
newItem.TaskType = taskType;
if (block != null)
{
newItem.Block = block;
}
newItem.DateCreated = DateTime.Now;
var userCreated = (await _userRepository.FindAsync(e => !e.Deleted && e.Login.ToLower().Equals(_userService.userLogin.ToLower()))).SingleOrDefault();
newItem.LoginCreated = userCreated != null ? userCreated.ShortName : _userService.userLogin;
newItem.ProjectTaskPerformers = new List <ProjectTaskPerformer>();
if (!string.IsNullOrEmpty(item.Users))
{
var userIds = item.Users.Split(",").Select(e => int.Parse(e)).ToList();
foreach (int userId in userIds)
{
var user = await _userRepository.FindByIdAsync(userId);
newItem.ProjectTaskPerformers.Add(new ProjectTaskPerformer()
{
User = user
});
}
}
await _projectTaskRepository.CreateAsync(newItem);
// формируем почтовые уведомления
await _mailRepository.CreateMailsForNewPerformersAsync(newItem.ProjectTaskPerformers.Select(e => e.User).ToList(), newItem);
return(_mapper.Map <ProjectTaskViewModel>(newItem));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
