public async Task <IActionResult> JoinTeam([FromBody] ManageUserTeamViewModel model)
        {
            logger.LogInformation($"POST Request {HttpContext.Request.Headers[":path"]}. Body: {JsonConvert.SerializeObject(model)}");

            var user = await context.Users
                       .Include(x => x.UserTeams)
                       .FirstOrDefaultAsync(u => u.Id == model.UserId);

            var userTeam = user.UserTeams.First(x => x.TeamId == model.TeamId);

            switch (userTeam.UserAction)
            {
            case UserActionEnum.ConsideringOffer when !await accessChecker.CanManageTeamOrSelfInTeam(model.TeamId, model.UserId):
            case UserActionEnum.SentRequest when !await accessChecker.CanManageTeam(model.TeamId):
                throw new HttpStatusException(HttpStatusCode.Forbidden, CommonErrorMessages.Forbidden);
            }

            var userIsNotAllowedToJoinTeam = userTeam.UserAction != UserActionEnum.ConsideringOffer &&
                                             userTeam.UserAction != UserActionEnum.SentRequest;

            if (userIsNotAllowedToJoinTeam)
            {
                var debugMsg = TeamErrorMessages.InvalidUserAction(model.UserId, userTeam, model.TeamId, UserActionEnum.SentRequest);

                throw new HttpStatusException(HttpStatusCode.BadRequest, UserErrorMessages.AppendToTeam, debugMsg);
            }

            var wasAction = userTeam.UserAction;

            userTeam.UserAction = UserActionEnum.JoinedTeam;

            try
            {
                context.Update(user);
                await context.SaveChangesAsync();
            }
            catch (Exception)
            {
                throw new HttpStatusException(HttpStatusCode.InternalServerError, CommonErrorMessages.SaveChanges);
            }

            var team = await context.Teams
                       .Include(t => t.Image)
                       .Include(x => x.UserTeams)
                       .ThenInclude(y => y.User)
                       .FirstOrDefaultAsync(x => x.Id == model.TeamId);

            await JoinTeamNotify(model.UserId, team, user, wasAction);

            return(Json(team));
        }
        public async Task <IActionResult> RejectedOrRemoveUser([FromBody] ManageUserTeamViewModel model)
        {
            logger.LogInformation($"POST Request {HttpContext.Request.Headers[":path"]}. Body: {JsonConvert.SerializeObject(model)}");

            if (!await accessChecker.CanManageTeamOrSelfInTeam(model.TeamId, model.UserId))
            {
                throw new HttpStatusException(HttpStatusCode.Forbidden, CommonErrorMessages.Forbidden);
            }

            var team = await context.Teams
                       .Include(t => t.Image)
                       .Include(u => u.UserTeams)
                       .ThenInclude(ut => ut.User)
                       .FirstOrDefaultAsync(u => u.Id == model.TeamId);

            var userTeam = team?.UserTeams.FirstOrDefault(ut => ut.UserId == model.UserId);

            if (userTeam == null)
            {
                throw new HttpStatusException(HttpStatusCode.NotFound, UserErrorMessages.NotFound,
                                              UserErrorMessages.DebugNotFoundUserTeam(model.UserId, model.TeamId));
            }

            userTeam.UserAction = userTeam.UserAction switch
            {
                UserActionEnum.SentRequest => UserActionEnum.RejectedTeamRequest,
                UserActionEnum.JoinedTeam => UserActionEnum.QuitTeam,
                UserActionEnum.ConsideringOffer => UserActionEnum.RejectedTeamRequest,
                _ => throw new HttpStatusException(HttpStatusCode.BadRequest,
                                                   TeamErrorMessages.QuitDeclineTeam,
                                                   TeamErrorMessages.InvalidUserAction(model.UserId, userTeam, team.Id,
                                                                                       UserActionEnum.SentRequest, UserActionEnum.JoinedTeam, UserActionEnum.ConsideringOffer))
            };

            //По этому свойству отображается капитан в команде. А так как капитан может самоустраниться, то нужно менять свойство
            userTeam.IsOwner = false;

            try
            {
                context.Update(userTeam);
                await context.SaveChangesAsync();
            }
            catch (Exception)
            {
                throw new HttpStatusException(HttpStatusCode.InternalServerError, CommonErrorMessages.SaveChanges);
            }

            await RejectedOrRemoveUserNotify(model.UserId, team, userTeam.UserAction);

            return(Json(team));
        }
        public async Task <IActionResult> CancelRequestUser([FromBody] ManageUserTeamViewModel model)
        {
            logger.LogInformation($"POST Request {HttpContext.Request.Headers[":path"]}. Body: {JsonConvert.SerializeObject(model)}");

            var team = await context.Teams
                       .Include(t => t.Image)
                       .Include(u => u.UserTeams)
                       .ThenInclude(ut => ut.User)
                       .FirstOrDefaultAsync(u => u.Id == model.TeamId);

            var userTeam = team?.UserTeams.FirstOrDefault(ut => ut.UserId == model.UserId);

            if (userTeam == null)
            {
                throw new HttpStatusException(HttpStatusCode.BadRequest, UserErrorMessages.NotFoundUserTeam,
                                              UserErrorMessages.DebugNotFoundUserTeam(model.UserId, model.TeamId));
            }

            switch (userTeam.UserAction)
            {
            case UserActionEnum.ConsideringOffer when !await accessChecker.CanManageTeam(model.TeamId):
            case UserActionEnum.SentRequest when !await accessChecker.CanManageTeamOrSelfInTeam(model.TeamId, model.UserId):
                throw new HttpStatusException(HttpStatusCode.Forbidden, CommonErrorMessages.Forbidden);
            }

            if (userTeam.UserAction != UserActionEnum.ConsideringOffer && userTeam.UserAction != UserActionEnum.SentRequest)
            {
                throw new HttpStatusException(HttpStatusCode.BadRequest,
                                              TeamErrorMessages.QuitDeclineTeam,
                                              TeamErrorMessages.InvalidUserAction(model.UserId, userTeam, model.TeamId,
                                                                                  UserActionEnum.ConsideringOffer, UserActionEnum.SentRequest));
            }

            try
            {
                context.Remove(userTeam);
                await context.SaveChangesAsync();
            }
            catch (Exception)
            {
                throw new HttpStatusException(HttpStatusCode.InternalServerError, CommonErrorMessages.SaveChanges);
            }

            return(Json(team));
        }