public async Task <JsonResult> Delete([FromQuery] uint?id)
        {
            int projectId = this.ParseValue(id);
            int userId    = int.Parse(User.Identity.Name);

            // Проверяем доступ
            var linkedProject = await _dbContext.GetLinkedAcceptedProject(projectId, userId)
                                .ConfigureAwait(false);

            if (linkedProject == null || linkedProject.RoleId == 1)
            {
                throw new Exception(TextResource.API_NoAccess);
            }

            // Получае проект по указанному ИД
            var project = await _dbContext.Projects.FirstOrDefaultAsync(x => x.Id == projectId)
                          .ConfigureAwait(false);

            if (project == null)
            {
                throw new Exception(TextResource.API_NotExistProjectId);
            }

            // Если на задачу кто-то тречит - заставить их прекратить
            var runningWorktracksUsers = _dbContext.Worktracks.Where(x => x.Worktask.ProjectId == projectId && x.Running)
                                         .ToList();

            if (runningWorktracksUsers.Any())
            {
                foreach (var userName in runningWorktracksUsers)
                {
                    await _hub.Value.Clients.Group(userName.UserId.ToString()).SendAsync("getActiveTracking", false, null, false, TextResource.SignalR_TaskIsRemoved)
                    .ConfigureAwait(false);
                }

                var now = DateTime.UtcNow;
                runningWorktracksUsers.ForEach(x =>
                {
                    x.Running     = false;
                    x.StoppedTime = now;
                });

                _dbContext.UpdateRange(runningWorktracksUsers);
            }

            var linkedProjects = _dbContext.LinkedProjects.Where(x => x.ProjectId == projectId);

            // Сбрасываем кэш
            var cache = (IMemoryCache)Request.HttpContext.RequestServices.GetService(typeof(IMemoryCache));

            foreach (var lp in linkedProjects.ToList())
            {
                cache.Remove($"LinkedAcceptedProject:{projectId}:{lp.UserId}");
            }

            _dbContext.LinkedProjects.RemoveRange(linkedProjects);

            _dbContext.Projects.Remove(project);

            await _dbContext.SaveChangesAsync()
            .ConfigureAwait(false);

            return(new JsonResult(project));
        }
Esempio n. 2
0
        public async Task <JsonResult> Update([FromBody] UpdateStateModel model)
        {
            var dbWorkTask = await _context.Worktasks.FirstOrDefaultAsync(x => x.Id == model.TaskId)
                             .ConfigureAwait(false);

            if (dbWorkTask == null)
            {
                throw new Exception(TextResource.API_NotExistWorktaskId);
            }

            var stateExist = await _context.States.AnyAsync(x => x.Id == model.StateId)
                             .ConfigureAwait(false);

            if (!stateExist)
            {
                throw new Exception(TextResource.API_NotExistStateId);
            }

            int projectId = dbWorkTask.ProjectId;
            int userId    = int.Parse(User.Identity.Name);

            var linkedProject = _context.GetLinkedAcceptedProject(projectId, userId);

            if (linkedProject == null)
            {
                throw new Exception(TextResource.API_NoAccess);
            }

            // Если на задачу кто-то тречит - заставить их прекратить
            var runningWorktracks = _context.Worktracks.Where(x => x.WorktaskId == dbWorkTask.Id && x.Running);

            if (model.StateId == 6 && runningWorktracks.Any())
            {
                var tracks = runningWorktracks.ToList();
                var users  = tracks.Select(x => x.UserId);

                foreach (var userName in users)
                {
                    await _hub.Value.Clients.Group(userName.ToString()).SendAsync("getActiveTracking", false, null, false, TextResource.API_TrackingTaskClosed)
                    .ConfigureAwait(false);
                }

                var now = DateTime.UtcNow;
                tracks.ForEach(x =>
                {
                    x.Running     = false;
                    x.StoppedTime = now;
                });

                _context.UpdateRange(tracks);
            }

            dbWorkTask.StateId = ( byte )model.StateId;

            _context.Update(dbWorkTask);

            await _context.SaveChangesAsync(true)
            .ConfigureAwait(false);

            return(new JsonResult(new OkResponse
            {
                message = "Вы успешно изменили состояние задачи"
            }));
        }