private static void SetIsSubToElements(SummonerRequestView view)
 {
     try
     {
         view.RequestedSummoners[4].IsSub = true;
         view.RequestedSummoners[5].IsSub = true;
     }
     catch (Exception)
     {
         //ignore
     }
 }
Beispiel #2
0
        public async Task <IActionResult> RequestPlayers(SummonerRequestView model)
        {
            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            var user = await _userManager.GetUserAsync(User);

            if (user == null)
            {
                var returnUrl = "http://www.casualeal.com/Summoner/RequestPlayers";
                return(RedirectToAction("Login", "Account", routeValues: new { returnUrl }));
            }

            var tempList = new List <RequestedSummoner>();

            foreach (var summoner in model.RequestedSummoners)
            {
                if (!tempList.Select(x => x.SummonerName).Contains(summoner.SummonerName))
                {
                    tempList.Add(summoner);
                }
            }

            model.RequestedSummoners = tempList;

            var result = await _accountService.UpdateSummonerRequestsAsync(user, model);

            if (!result)
            {
                throw new ApplicationException($"Unexpected error occurred updating Summoner Requests for user '{user.Id}'.");
            }

            StatusMessage = "Your requests have been updated";
            return(RedirectToAction(nameof(RequestPlayers)));
        }
        public async Task <bool> UpdateSummonerRequestsAsync(UserEntity user, SummonerRequestView view)
        {
            var seasonInfo = await _seasonInfoRepository.GetCurrentSeasonAsync();

            SetIsSubToElements(view);
            var summoners      = (await _summonerInfoRepository.GetAllSummonersAsync()).ToDictionary(x => x.Id, x => x);
            var summonerEntity = summoners.First(x => x.Value.UserId == user.Id);

            summoners.Remove(summonerEntity.Key);

            var requestedSummonerEntities = (await _requestedSummonerRepository.ReadAllForSummonerAsync(summonerEntity.Key, seasonInfo.Id)).ToList();

            //pulled from db
            var kvp = new Dictionary <string, SummonerRequestEntity>();

            foreach (var requestEntity in requestedSummonerEntities)
            {
                if (summoners.TryGetValue(requestEntity.SummonerRequestedId, out var summoner))
                {
                    kvp.TryAdd(summoner.SummonerName, requestEntity);
                }
            }

            var createList = new List <SummonerRequestEntity>();
            var updateList = new List <SummonerRequestEntity>();
            var deleteList = new List <SummonerRequestEntity>();

            //new list
            foreach (var requestedSummoner in view.RequestedSummoners)
            {
                //skip these
                if (requestedSummoner.SummonerName == null || requestedSummoner.SummonerName == DefaultText)
                {
                    continue;
                }
                //insert
                if (!kvp.TryGetValue(requestedSummoner.SummonerName, out var oldSummonerRequest))
                {
                    var newEntity = new SummonerRequestEntity
                    {
                        Id                  = Guid.NewGuid(),
                        SummonerId          = summonerEntity.Key,
                        SummonerRequestedId = summoners.First(x => x.Value.SummonerName == requestedSummoner.SummonerName).Key,
                        IsSub               = requestedSummoner.IsSub,
                        SeasonInfoId        = seasonInfo.Id
                    };
                    createList.Add(newEntity);
                }
                //update
                else
                {
                    oldSummonerRequest.SummonerRequestedId =
                        summoners.First(x => x.Value.SummonerName == requestedSummoner.SummonerName).Key;
                    oldSummonerRequest.IsSub = requestedSummoner.IsSub;
                    updateList.Add(oldSummonerRequest);
                }
            }

            //delete
            foreach (var oldEntity in kvp)
            {
                if (!view.RequestedSummoners.Select(x => x.SummonerName).Contains(oldEntity.Key))
                {
                    deleteList.Add(oldEntity.Value);
                }
            }

            var createTask = _requestedSummonerRepository.CreateAsync(createList);
            var updateTask = _requestedSummonerRepository.UpdateAsync(updateList);
            var deleteTask = _requestedSummonerRepository.DeleteAsync(deleteList);

            return(await createTask && await updateTask && await deleteTask);
        }
        public async Task <SummonerRequestView> GetRequestedSummonersAsync(UserEntity user)
        {
            var seasonInfo = await _seasonInfoRepository.GetCurrentSeasonAsync();

            var summoners      = (await _summonerInfoRepository.GetAllValidSummonersAsync()).ToList();
            var summonerEntity = summoners.First(x => x.UserId == user.Id);

            summoners.Remove(summonerEntity);
            if (summonerEntity.IsAcademyPlayer)
            {
                summoners = summoners.Where(x => x.IsAcademyPlayer).ToList();
            }

            var requestedSummonerEntities = (await _requestedSummonerRepository.ReadAllForSummonerAsync(summonerEntity.Id, seasonInfo.Id)).ToList();
            var view = new SummonerRequestView
            {
                SummonerName  = summonerEntity.SummonerName,
                SummonerNames = summoners.Select(x => x.SummonerName).OrderBy(x => x).ToList(),
                Names         = GetSelectListItems(summoners.Select(x => x.SummonerName).OrderBy(x => x))
            };

            if (!requestedSummonerEntities.Any())
            {
                var count = RequestingSummonerCount;
                if (summonerEntity.IsAcademyPlayer)
                {
                    count = 1;
                }
                view.RequestedSummoners.AddRange(AddEmptyRequestedSummonerViews(count));
            }
            else
            {
                var requestedSummoners = new List <RequestedSummoner>();

                foreach (var entity in requestedSummonerEntities)
                {
                    var summoner = summoners.First(x => x.Id == entity.SummonerRequestedId);
                    requestedSummoners.Add(new RequestedSummoner
                    {
                        SummonerName = summoner.SummonerName,
                        IsSub        = entity.IsSub
                    });
                }

                view.RequestedSummoners = requestedSummoners;

                var missingCount = RequestingSummonerCount - view.RequestedSummoners.Count;
                if (summonerEntity.IsAcademyPlayer)
                {
                    missingCount = 1 - view.RequestedSummoners.Count;
                }

                view.RequestedSummoners.AddRange(AddEmptyRequestedSummonerViews(missingCount));
            }

            if (!summonerEntity.IsAcademyPlayer)
            {
                SetIsSubToElements(view);
            }

            return(view);
        }