Серверная часть подсистемы передачи заданий

 [OperationContract]
    public void CreateProjectTask(string code, string text, DateTime FinishDate, long FolderId, int[] departmentsIds, string[] savedFilePaths, string[] savedFileNames, bool draft)
    {
        if (savedFilePaths.Length != savedFileNames.Length)
        {
            throw new ArgumentException("Количество сохранённый файлов и имён не совпадает");
        }
        using (var dbContext = new FalconDbContext())
        {

            var curUser = GetCurrentUser();
            var curDepartment = GetDepartmentByUser(FolderId, curUser);
            var project = dbContext.GetProjectFolder(FolderId, false);
            var gip = dbContext.GetGipByFolderId(FolderId);

            foreach (int departmentId in departmentsIds)
            {
                var newTask = new ProjectTask()
                {
                    Code = code,
                    Text = text,
                    DtCreate = DateTime.Today,
                    IdAutor = curUser.Id,
                    IdAutorDepartment = curDepartment.Id,
                    IdProject = project.Id,
                    DtFinish = FinishDate,
                    IdExecutorDepartment = departmentId,
                    Status = ProjectTask.Statuses.created
                };
                dbContext.ProjectTasks.Add(newTask);
                dbContext.SaveChanges();
                for (int i = 0; i < savedFilePaths.Length; i++)
                {
                    var fileName = IO.Path.Combine(Falcon_configuration.public_file_storage, savedFilePaths[i]);
                    dbContext.FalconFiles.Add(new FalconFile()
                    {
                        Path = fileName,
                        FileSize = (int)new IO.FileInfo(fileName).Length,
                        Name = savedFileNames[i],
                        IdProjectTask = newTask.Id
                    });
                }

                dbContext.LogSimples.Add(new LogSimple()
                {
                    Action = "Задание создано",
                    Comment = code,
                    Dt = DateTime.Now,
                    Entity = "projectTask",
                    Id = newTask.Id,
                    IdUser = curUser.Id
                });
                dbContext.UserTasks.AddProjectTaskAgreement(newTask, curUser.Id, curUser.Id, "Передать на согласование");
                dbContext.SaveChanges();
                if (!draft)
                {
                    AgreeProjectTask(newTask.Id, null, null);
                }
            }
        }
    }
    [OperationContract]
    public void EditProjectPask(long projectTaskId, string text, DateTime dateTime, string[] savedFilePaths, string[] savedFileNames, long[] deletedFileIds)
    {
        if (savedFilePaths.Length != savedFileNames.Length)
        {
            throw new ArgumentException("Количество сохранённый файлов и имён не совпадает");
        }

        using (var dbContext = new FalconDbContext())
        {
            var curUser = GetCurrentUser();
            var projectTask = dbContext.ProjectTasks.Include(pt => pt.Folder)
              .Include(pt => pt.User_IdAutor)
              .Include(pt => pt.User_IdExecutor)
              .Include(pt => pt.Department_IdAutorDepartment.User)
              .Include(pt => pt.Department_IdExecutorDepartment.User)
              .First(pt => pt.Id == projectTaskId);
            var curDepartment = GetDepartmentByUser(projectTask.IdProject, curUser);
            var gip = dbContext.Gips.Include(g => g.User).Include(g => g.Users).First(g => g.Id == projectTask.Folder.IdGip);

            if ((projectTask.Status == ProjectTask.Statuses.releaseDepartmentManagerTaskAgreement && projectTask.IdAutorDepartment == curDepartment.Id && curUser.Id == curDepartment.IdManager)
                  ||
                ((projectTask.Status == ProjectTask.Statuses.created || projectTask.Status == ProjectTask.Statuses.revision) && projectTask.IdAutor == curUser.Id)
                  ||
                ((projectTask.Status == ProjectTask.Statuses.projectGIPTaskAgreement) && (gip.Includes(curUser)))
                )
            {

                var comentBuilder = new StringBuilder();
                if (projectTask.Text != text)
                    comentBuilder.AppendLine($"{projectTask.Text}->{text}");

                if (projectTask.DtFinish != dateTime)
                    comentBuilder.AppendLine($"{projectTask.DtFinish.ToShortDateString()}->{dateTime.ToShortDateString()}");

                if (savedFilePaths.Any())
                    comentBuilder.AppendLine($"Добавлено {savedFilePaths.Count()} файлов");

                if (deletedFileIds.Any())
                    comentBuilder.AppendLine($"Удалено {deletedFileIds.Count()} файлов");


                foreach (var deletedFileId in deletedFileIds)
                {
                    var deletedFile = dbContext.FalconFiles.Single(f => f.Id == deletedFileId);
                    IO.File.Delete(deletedFile.Path);
                    dbContext.FalconFiles.Remove(deletedFile);
                }

                for (int i = 0; i < savedFilePaths.Length; i++)
                {
                    var fileName = IO.Path.Combine(Falcon_configuration.public_file_storage, savedFilePaths[i]);
                    dbContext.FalconFiles.Add(new FalconFile()
                    {
                        Path = fileName,
                        FileSize = (int)new IO.FileInfo(fileName).Length,
                        Name = savedFileNames[i],
                        IdProjectTask = projectTask.Id
                    });
                }

                dbContext.LogSimples.Add(new LogSimple()
                {
                    Action = "Задание откорректировано",
                    Comment = comentBuilder.ToString(),
                    Dt = DateTime.Now,
                    Entity = "projectTask",
                    Id = projectTask.Id,
                    IdUser = curUser.Id
                });

                projectTask.Text = text;
                projectTask.DtFinish = dateTime;
                dbContext.SaveChanges();
            }
            else
            {
                throw new Exception("Не прав на редактирование задания. Обратитесь к администратору Falcon");
            }

        }
    }

    [OperationContract]
    public ProjectTask GetProjectTask(out ProjectTask.UserCapabilities Capabilities, long projectTaskId)
    {
        using (var dbContext = new FalconDbContext())
        {
            var curUser = GetCurrentUser();
            var projectTask = dbContext.ProjectTasks.Include(pt => pt.FalconFiles).Include(pt => pt.Folder).First(pt => pt.Id == projectTaskId);
            var curDepartment = GetDepartmentByUser(projectTask.IdProject, curUser);
            var gip = dbContext.Gips.Include(g => g.Users).First(g => g.Id == projectTask.Folder.IdGip);

            var projectNotices = dbContext.UserTasks.Where(t => t.IdUserExecutor == curUser.Id
                    && t.IdEntityType == (int)UserTask.EntityTypes.projectTask
                    && t.IdEntity == projectTask.Id
                    && t.IdType == (int)UserTask.Types.Notice);

            foreach (var projectNotice in projectNotices)
            {
                projectNotice.Status = UserTask.Statuses.closed;
            }

            switch (projectTask.Status)
            {
                case ProjectTask.Statuses.revision:
                case ProjectTask.Statuses.created:
                    if (projectTask.IdAutor == curUser.Id)
                        Capabilities = ProjectTask.UserCapabilities.Edit | ProjectTask.UserCapabilities.Agree;
                    else
                        Capabilities = ProjectTask.UserCapabilities.None;
                    break;
                case ProjectTask.Statuses.releaseDepartmentManagerTaskAgreement:
                    if (projectTask.IdAutorDepartment == curDepartment.Id && curUser.Id == curDepartment.IdManager)
                        Capabilities = ProjectTask.UserCapabilities.Edit | ProjectTask.UserCapabilities.Agree | ProjectTask.UserCapabilities.Reject;
                    else
                        Capabilities = ProjectTask.UserCapabilities.None;
                    break;
                case ProjectTask.Statuses.projectGIPTaskAgreement:
                    if (gip.Includes(curUser))
                        Capabilities = ProjectTask.UserCapabilities.EditDate | ProjectTask.UserCapabilities.Agree | ProjectTask.UserCapabilities.Reject;
                    else
                        Capabilities = ProjectTask.UserCapabilities.None;
                    break;

                case ProjectTask.Statuses.receiveDepartmentManagerTaskAgreement:
                    if ((projectTask.IdExecutorDepartment == curDepartment.Id && curUser.Id == curDepartment.IdManager)
                        ||
                        (projectTask.IdExecutorDepartment == 0 && curUser.Id == gip.IdManager))
                        Capabilities = ProjectTask.UserCapabilities.Agree | ProjectTask.UserCapabilities.Reject | ProjectTask.UserCapabilities.AssignExecutor;
                    else
                        Capabilities = ProjectTask.UserCapabilities.None;
                    break;
                case ProjectTask.Statuses.expectsExecution:
                    if (projectTask.IdExecutor.Value == curUser.Id)
                        Capabilities = ProjectTask.UserCapabilities.Agree | ProjectTask.UserCapabilities.Reject;
                    else
                        Capabilities = ProjectTask.UserCapabilities.None;
                    break;
                case ProjectTask.Statuses.executing:
                    if (projectTask.IdExecutor.Value == curUser.Id)
                        Capabilities = ProjectTask.UserCapabilities.AssignResult;
                    else
                        Capabilities = ProjectTask.UserCapabilities.None;
                    break;
                case ProjectTask.Statuses.receiveDepartmentManagerResultAgreement:
                    if (projectTask.IdExecutorDepartment == curDepartment.Id && curUser.Id == curDepartment.IdManager)
                        Capabilities = ProjectTask.UserCapabilities.Agree | ProjectTask.UserCapabilities.Reject;
                    else
                        Capabilities = ProjectTask.UserCapabilities.None;
                    break;

                default:
                    Capabilities = ProjectTask.UserCapabilities.None;
                    break;
            }
            dbContext.SaveChanges();
            return projectTask;
        }
    }
    [OperationContract]
    public void RejectProjectTask(long projectTaskId, string comment)
    {
        using (var dbContext = new FalconDbContext())
        {
            var curUser = GetCurrentUser();
            var projectTask = dbContext.ProjectTasks.Include(pt => pt.Folder)
                .Include(pt => pt.User_IdAutor)
                .Include(pt => pt.User_IdExecutor)
                .Include(pt => pt.Department_IdAutorDepartment.User)
                .Include(pt => pt.Department_IdExecutorDepartment.User)
                .First(pt => pt.Id == projectTaskId);
            var curDepartment = GetDepartmentByUser(projectTask.IdProject, curUser);
            if (curUser.Id == 19 && projectTask.IdExecutorDepartment == 19)
            {
                curDepartment = dbContext.Departments.Find(19);
            }
            var gip = dbContext.Gips.Include(g => g.User).Include(g => g.Users).First(g => g.Id == projectTask.Folder.IdGip);

            //временно подставляем начальника БГИП в качестве начальника выдающего отдела, если выдаёт задание БГИП (в базу эти изменения не идут, т.к на разных проектах гипы разные)
            if (projectTask.Department_IdAutorDepartment.Id == 0)
            {
                projectTask.Department_IdAutorDepartment.User = gip.User;
            }
            //временно подставляем начальника БГИП в качестве начальника принимающего отдела, если принимает задание БГИП (в базу эти изменения не идут, т.к на разных проектах гипы разные)
            if (projectTask.Department_IdExecutorDepartment.Id == 0)
            {
                projectTask.Department_IdExecutorDepartment.User = gip.User;
            }

            switch (projectTask.Status)
            {
                case ProjectTask.Statuses.created:
                case ProjectTask.Statuses.revision:
                    throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");

                case ProjectTask.Statuses.releaseDepartmentManagerTaskAgreement:
                    if (projectTask.IdAutorDepartment == curDepartment.Id && curUser.Id == curDepartment.IdManager)
                    {
                        projectTask.Status = ProjectTask.Statuses.revision;
                        dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, projectTask.IdAutor, "Доработать задание");

                        ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.User_IdAutor);
                        dbContext.UserTasks.GetProjectTaskAgreement(projectTask.Id, curUser.Id).Status = UserTask.Statuses.closed;
                    }
                    else
                        throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
                    break;

                case ProjectTask.Statuses.projectGIPTaskAgreement:
                    if (gip.Includes(curUser))
                    {
                        projectTask.Status = ProjectTask.Statuses.revision;

                        dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, projectTask.IdAutor, "Доработать задание");
                        ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.User_IdAutor);

                        if (projectTask.Department_IdAutorDepartment.User.Id != projectTask.IdAutor)
                        {

                            dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, projectTask.Department_IdAutorDepartment.User.Id);
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.Department_IdAutorDepartment.User);
                        }
                        var gipMembersIds = gip.Users.Select(u => u.Id).ToArray();
                        var userTasks = dbContext.UserTasks.Where(t =>
                            (t.IdUserExecutor == curUser.Id || gipMembersIds.Contains(t.IdUserExecutor)) &&
                            t.IdEntity == projectTaskId && t.IdStatus == (int)UserTask.Statuses.created);
                        foreach (var userTask in userTasks)
                        {
                            userTask.Status = UserTask.Statuses.closed;
                        }
                    }
                    else
                        throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
                    break;

                case ProjectTask.Statuses.receiveDepartmentManagerTaskAgreement:
                    if (projectTask.IdExecutorDepartment == curDepartment.Id && curUser.Id == curDepartment.IdManager)
                    {
                        projectTask.Status = ProjectTask.Statuses.revision;

                        if (projectTask.Department_IdAutorDepartment.Id > 0)
                        {
                            dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, projectTask.IdAutor, "Доработать задание");
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.User_IdAutor);
                        }
                        else
                        {
                            dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, gip.IdManager, "Доработать задание");
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gip.User);
                            foreach (var gipUser in gip.Users)
                            {
                                dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, gipUser.Id, "Доработать задание");
                                ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gipUser);
                            }
                        }

                        if (projectTask.Department_IdAutorDepartment.User.Id != projectTask.IdAutor)
                        {
                            dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, projectTask.Department_IdAutorDepartment.User.Id);
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.Department_IdAutorDepartment.User);
                        }

                        if (projectTask.IdExecutorDepartment != 0 && !gip.Includes(projectTask.User_IdAutor))
                        {
                            dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, gip.IdManager);
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gip.User);
                            foreach (var gipUser in gip.Users)
                            {
                                dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, gipUser.Id);
                                ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gipUser);
                            }
                        }
                        dbContext.UserTasks.GetProjectTaskAgreement(projectTask.Id, curUser.Id).Status = UserTask.Statuses.closed;
                    }
                    else
                        throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
                    break;

                case ProjectTask.Statuses.expectsExecution:
                    if (projectTask.IdExecutor.Value == curUser.Id)
                    {
                        projectTask.Status = ProjectTask.Statuses.revision;
                        dbContext.UserTasks.GetProjectTaskAgreement(projectTask.Id, curUser.Id).Status = UserTask.Statuses.closed;

                        if (projectTask.Department_IdAutorDepartment.Id > 0)
                        {
                            dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, projectTask.IdAutor, "Доработать задание");
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.User_IdAutor);

                            if (projectTask.Department_IdAutorDepartment.User.Id != projectTask.IdAutor)
                            {
                                dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, projectTask.Department_IdAutorDepartment.User.Id);
                                ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.Department_IdAutorDepartment.User);
                            }

                            if (!gip.Includes(projectTask.User_IdAutor))
                            {
                                dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, gip.IdManager);
                                ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gip.User);
                                foreach (var gipUser in gip.Users)
                                {
                                    dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, gipUser.Id);
                                    ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gipUser);
                                }
                            }
                        }
                        else
                        {
                            dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, gip.IdManager, "Доработать задание");
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gip.User);
                            foreach (var gipUser in gip.Users)
                            {
                                dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, gipUser.Id, "Доработать задание");
                                ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gipUser);
                            }
                        }

                        if (curUser.Id != projectTask.Department_IdExecutorDepartment.User.Id)
                        {
                            dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, projectTask.Department_IdExecutorDepartment.User.Id);
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.Department_IdExecutorDepartment.User);
                        }
                    }
                    else
                        throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
                    break;

                case ProjectTask.Statuses.receiveDepartmentManagerResultAgreement:
                    if (projectTask.Department_IdExecutorDepartment.User.Id == curUser.Id)
                    {
                        dbContext.UserTasks.GetProjectTaskAgreement(projectTask.Id, curUser.Id).Status = UserTask.Statuses.closed;
                        projectTask.Status = ProjectTask.Statuses.executing;
                        dbContext.UserTasks.Add(new UserTask()
                        {
                            Type = UserTask.Types.Agreement,
                            EntityType = UserTask.EntityTypes.projectTask,
                            IdEntity = projectTask.Id,
                            IdUserAutor = curUser.Id,
                            Text = "Доработать результат задания " + projectTask.Code,
                            IdUserExecutor = projectTask.IdExecutor.Value,
                            DtFinish = projectTask.DtFinish
                        });
                        ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.User_IdExecutor);
                    }
                    else
                        throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
                    break;
                default:
                    throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
            }

            dbContext.LogSimples.Add(new LogSimple()
            {
                Action = "Возвращено на доработку",
                Comment = comment,
                Dt = DateTime.Now,
                Entity = "projectTask",
                Id = projectTask.Id,
                IdUser = curUser.Id
            });

            dbContext.Entry(projectTask.Department_IdExecutorDepartment).Property(h => h.IdManager).IsModified = false;
            dbContext.Entry(projectTask.Department_IdAutorDepartment).Property(h => h.IdManager).IsModified = false;
            dbContext.SaveChanges();
        }
    }

    [OperationContract]
    public void AgreeProjectTask(long projectTaskId, string comment, long? ExecutorUserId)
    {
        using (var dbContext = new FalconDbContext())
        {
            var curUser = GetCurrentUser();
            var projectTask = dbContext.ProjectTasks.Include(pt => pt.Folder)
                .Include(pt => pt.User_IdExecutor)
                .Include(pt => pt.User_IdAutor)
                .Include(pt => pt.Department_IdAutorDepartment.User)
                .Include(pt => pt.Department_IdExecutorDepartment.User)
                .First(pt => pt.Id == projectTaskId);

            var curDepartment = GetDepartmentByUser(projectTask.IdProject, curUser);

            if (curUser.Id == 19 && projectTask.IdExecutorDepartment == 19)//todo: КОСТЫЛЬ
            {
                curDepartment = dbContext.Departments.Find(19);
            }

            var gip = dbContext.Gips.Include(g => g.User).Include(g => g.Users).First(g => g.Id == projectTask.Folder.IdGip);
            //временно подставляем начальника БГИП в качестве начальника выдающего отдела, если выдаёт задание БГИП (в базу эти изменения не идут, т.к на разных проектах гипы разные)
            if (projectTask.Department_IdAutorDepartment.Id == 0)
            {
                projectTask.Department_IdAutorDepartment.User = gip.User;
            }
            //временно подставляем начальника БГИП в качестве начальника принимающего отдела, если принимает задание БГИП (в базу эти изменения не идут, т.к на разных проектах гипы разные)
            if (projectTask.Department_IdExecutorDepartment.Id == 0)
            {
                projectTask.Department_IdExecutorDepartment.User = gip.User;
            }
            string actionText = "Согласовано";
            switch (projectTask.Status)
            {
                case ProjectTask.Statuses.created:
                case ProjectTask.Statuses.revision:
                    if (projectTask.IdAutor == curUser.Id)
                    {
                        if (gip.IdManager == curUser.Id)
                            goto case ProjectTask.Statuses.projectGIPTaskAgreement;

                        if (projectTask.Department_IdAutorDepartment.User.Id == curUser.Id)
                            goto case ProjectTask.Statuses.releaseDepartmentManagerTaskAgreement;

                        dbContext.UserTasks.GetProjectTaskAgreement(projectTask.Id, curUser.Id).Status = UserTask.Statuses.closed;
                        actionText = "Передано на согласование";
                        projectTask.Status = ProjectTask.Statuses.releaseDepartmentManagerTaskAgreement;
                        dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, projectTask.Department_IdAutorDepartment.User.Id);

                        ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.Department_IdAutorDepartment.User);
                    }
                    else
                        throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
                    break;

                case ProjectTask.Statuses.releaseDepartmentManagerTaskAgreement:
                    if (projectTask.IdAutorDepartment == curDepartment.Id && curUser.Id == curDepartment.IdManager)
                    {

                        dbContext.UserTasks.GetProjectTaskAgreement(projectTask.Id, curUser.Id).Status = UserTask.Statuses.closed;
                        if (projectTask.IdExecutorDepartment == 0 || projectTask.IdAutorDepartment == 0)
                        {
                            projectTask.Status = ProjectTask.Statuses.receiveDepartmentManagerTaskAgreement;
                            dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, projectTask.Department_IdExecutorDepartment.User.Id);
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.Department_IdExecutorDepartment.User);
                        }
                        else
                        {
                            projectTask.Status = ProjectTask.Statuses.projectGIPTaskAgreement;
                            dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, gip.IdManager);
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gip.User);
                            foreach (var gipUser in gip.Users)
                            {
                                dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, gipUser.Id);
                                ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gipUser);
                            }
                        }
                    }
                    else
                        throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
                    break;

                case ProjectTask.Statuses.projectGIPTaskAgreement:
                    if (gip.Includes(curUser))
                    {
                        projectTask.Status = ProjectTask.Statuses.receiveDepartmentManagerTaskAgreement;
                        dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, projectTask.Department_IdExecutorDepartment.User.Id);
                        ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.Department_IdExecutorDepartment.User);
                        var gipMembersIds = gip.Users.Select(u => u.Id).ToArray();
                        dbContext.UserTasks.GetProjectTaskAgreement(projectTask.Id, gip.IdManager).Status = UserTask.Statuses.closed;
                        foreach (var gipUser in gip.Users)
                        {
                            var gipUserTask = dbContext.UserTasks.GetProjectTaskAgreement(projectTask.Id, gipUser.Id);
                            if (gipUserTask != null)
                                gipUserTask.Status = UserTask.Statuses.closed;
                        }
                    }
                    else
                        throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
                    break;

                case ProjectTask.Statuses.receiveDepartmentManagerTaskAgreement:
                    if (ExecutorUserId.HasValue && projectTask.IdExecutorDepartment == curDepartment.Id && curUser.Id == curDepartment.IdManager)
                    {
                        projectTask.Status = ProjectTask.Statuses.expectsExecution;
                        projectTask.IdExecutor = ExecutorUserId;
                        dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, ExecutorUserId.Value, "Принять назание на выполнение");

                        ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, dbContext.Users.Find(ExecutorUserId.Value));
                        dbContext.UserTasks.GetProjectTaskAgreement(projectTask.Id, curUser.Id).Status = UserTask.Statuses.closed;
                    }
                    else
                        throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
                    break;

                case ProjectTask.Statuses.expectsExecution:
                    if (projectTask.IdExecutor.Value == curUser.Id)
                    {
                        actionText = "Принято в работу";
                        projectTask.Status = ProjectTask.Statuses.executing;

                        dbContext.UserTasks.Add(new UserTask()
                        {
                            Type = UserTask.Types.Agreement,
                            EntityType = UserTask.EntityTypes.projectTask,
                            IdEntity = projectTask.Id,
                            IdUserAutor = curUser.Id,
                            Text = "Выполнить задание " + projectTask.Code,
                            IdUserExecutor = curUser.Id,
                            DtFinish = projectTask.DtFinish
                        });

                        dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, projectTask.User_IdAutor.Id, "Принято в работу");
                        ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.User_IdAutor);

                        if (projectTask.User_IdAutor.Id != projectTask.Department_IdAutorDepartment.User.Id)
                        {
                            dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, projectTask.Department_IdAutorDepartment.User.Id, "Принято в работу");
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.Department_IdAutorDepartment.User);
                        }

                        if (projectTask.User_IdExecutor.Id != projectTask.Department_IdExecutorDepartment.User.Id)
                        {
                            dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, projectTask.User_IdExecutor.Id, "Принято в работу");
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.User_IdExecutor);
                        }

                        if (projectTask.IdExecutorDepartment != 0 && !gip.Includes(projectTask.User_IdAutor))
                        {
                            dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, gip.IdManager, "Принято в работу");
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gip.User);
                            foreach (var gipUser in gip.Users)
                            {
                                dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, gipUser.Id, "Принято в работу");
                                ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gipUser);
                            }
                        }

                        ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, curUser);
                        dbContext.UserTasks.GetProjectTaskAgreement(projectTask.Id, curUser.Id).Status = UserTask.Statuses.closed;
                    }
                    else
                        throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
                    break;

                case ProjectTask.Statuses.executing:
                    if (projectTask.IdExecutor.Value == curUser.Id)
                    {
                        if (projectTask.Department_IdExecutorDepartment.User.Id == curUser.Id
                            ||
                           (projectTask.Department_IdExecutorDepartment.Id == 0 && gip.IdManager == curUser.Id))
                            goto case ProjectTask.Statuses.receiveDepartmentManagerResultAgreement;

                        actionText = "Выполнено";
                        projectTask.Status = ProjectTask.Statuses.receiveDepartmentManagerResultAgreement;

                        if (projectTask.Department_IdExecutorDepartment.Id > 0)
                        {
                            dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, projectTask.Department_IdExecutorDepartment.User.Id, "Согласовать результат");
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.Department_IdExecutorDepartment.User);
                        }
                        else
                        {
                            dbContext.UserTasks.AddProjectTaskAgreement(projectTask, curUser.Id, gip.IdManager, "Согласовать результат");
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gip.User);
                        }

                        dbContext.UserTasks.GetProjectTaskAgreement(projectTask.Id, curUser.Id).Status = UserTask.Statuses.closed;
                    }
                    else
                        throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
                    break;

                case ProjectTask.Statuses.receiveDepartmentManagerResultAgreement:
                    if (projectTask.IdExecutorDepartment == curDepartment.Id && curUser.Id == curDepartment.IdManager)
                    {
                        actionText = "Закрыто";
                        projectTask.Status = ProjectTask.Statuses.done;

                        dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, projectTask.User_IdAutor.Id, "Задание закрыто");
                        ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.User_IdAutor);

                        if (projectTask.User_IdAutor.Id != projectTask.Department_IdAutorDepartment.User.Id)
                        {
                            dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, projectTask.Department_IdAutorDepartment.User.Id, "Задание закрыто");
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.Department_IdAutorDepartment.User);
                        }

                        if (projectTask.User_IdExecutor.Id != projectTask.Department_IdExecutorDepartment.User.Id)
                        {
                            dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, projectTask.User_IdExecutor.Id, "Задание закрыто");
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, projectTask.User_IdExecutor);
                        }

                        if (projectTask.IdExecutorDepartment != 0 && !gip.Includes(projectTask.User_IdAutor))
                        {
                            dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, gip.IdManager, "Задание закрыто");
                            ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gip.User);
                            foreach (var gipUser in gip.Users)
                            {
                                dbContext.UserTasks.AddProjectTaskNotice(projectTask.Id, curUser.Id, gipUser.Id, "Задание закрыто");
                                ServerMessageService.SendNotificationMessage("PROJECTTASK", projectTaskId, gipUser);
                            }
                        }

                        dbContext.UserTasks.GetProjectTaskAgreement(projectTask.Id, curUser.Id).Status = UserTask.Statuses.closed;
                    }
                    else
                        throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
                    break;

                default:
                    throw new Exception("Ошибка передачи задания, обратитесть к администратору Falcon");
            }



            dbContext.LogSimples.Add(new LogSimple()
            {
                Action = actionText,
                Comment = comment,
                Dt = DateTime.Now,
                Entity = "projectTask",
                Id = projectTask.Id,
                IdUser = curUser.Id
            });

            dbContext.Entry(projectTask.Department_IdExecutorDepartment).Property(h => h.IdManager).IsModified = false;
            dbContext.Entry(projectTask.Department_IdAutorDepartment).Property(h => h.IdManager).IsModified = false;
            dbContext.SaveChanges();
        }
    }