Example #1
0
        public async Task <ActionResult <bool> > Delete([FromBody] long[] ids)
        {
            for (int i = 0; i < ids.Length; i++)
            {
                LeagueImageViewModel leagueImageToDelete = await this._supervisor.GetLeagueImageByIdAsync(ids[i]);

                if (leagueImageToDelete == null)
                {
                    return(BadRequest(Errors.AddErrorToModelState(ErrorCodes.LeagueImageNotFound, ErrorDescriptions.LeagueImageDeleteFailure, ModelState)));
                }

                DelResResult deletedFromCloudinary = await this._cloudinary.DeleteResource(leagueImageToDelete.CloudinaryPublicId);

                if (deletedFromCloudinary.StatusCode != HttpStatusCode.OK)
                {
                    return(BadRequest(Errors.AddErrorToModelState(ErrorCodes.CloudinaryDelete, ErrorDescriptions.CloudinaryImageDeleteFailure, ModelState)));
                }

                if (!await _supervisor.DeleteLeagueImageAsync(leagueImageToDelete.Id))
                {
                    return(BadRequest(Errors.AddErrorToModelState(ErrorCodes.LeagueImageDelete, ErrorDescriptions.LeagueImageDeleteFailure, ModelState)));
                }
            }

            return(new OkObjectResult(true));
        }
        public async Task <bool> UpdateLeagueImageAsync(LeagueImageViewModel leagueImageViewModel, CancellationToken ct = default)
        {
            LeagueImage leagueImageUpdate = await this._leagueImageRepository.GetByIDAsync(leagueImageViewModel.Id, ct);

            if (leagueImageUpdate == null)
            {
                return(false);
            }

            leagueImageUpdate.CloudinaryPublicId = leagueImageViewModel.CloudinaryPublicId;
            leagueImageUpdate.Name         = leagueImageViewModel.Name;
            leagueImageUpdate.Size         = leagueImageViewModel.Size;
            leagueImageUpdate.Type         = leagueImageViewModel.Type;
            leagueImageUpdate.Url          = leagueImageViewModel.Url;
            leagueImageUpdate.Small        = leagueImageViewModel.Small;
            leagueImageUpdate.Medium       = leagueImageViewModel.Medium;
            leagueImageUpdate.Big          = leagueImageViewModel.Big;
            leagueImageUpdate.ResourceType = leagueImageViewModel.ResourceType;
            leagueImageUpdate.Width        = leagueImageViewModel.Width;
            leagueImageUpdate.Height       = leagueImageViewModel.Height;
            leagueImageUpdate.Format       = leagueImageViewModel.Format;
            leagueImageUpdate.OrderId      = leagueImageViewModel.OrderId;

            return(await this._leagueImageRepository.UpdateAsync(leagueImageUpdate, ct));
        }
        public async Task <LeagueImageViewModel> AddLeagueImageAsync(LeagueImageViewModel leagueImageViewModel, CancellationToken ct = default)
        {
            LeagueImage newLeagueImage = new LeagueImage()
            {
                CloudinaryPublicId = leagueImageViewModel.CloudinaryPublicId,
                Name         = leagueImageViewModel.Name,
                Size         = leagueImageViewModel.Size,
                Type         = leagueImageViewModel.Type,
                Url          = leagueImageViewModel.Url,
                Small        = leagueImageViewModel.Small,
                Medium       = leagueImageViewModel.Medium,
                Big          = leagueImageViewModel.Big,
                ResourceType = leagueImageViewModel.ResourceType,
                Width        = leagueImageViewModel.Width,
                Height       = leagueImageViewModel.Height,
                Format       = leagueImageViewModel.Format,
                OrderId      = leagueImageViewModel.OrderId
            };

            newLeagueImage = await _leagueImageRepository.AddAsync(newLeagueImage, ct);

            leagueImageViewModel.Id = newLeagueImage.Id;

            return(leagueImageViewModel);
        }
        public async Task <bool> DeleteLeagueImageAsync(long?leagueImageId, CancellationToken ct = default)
        {
            LeagueImageViewModel leagueImageToDelete = LeagueImageConverter.Convert(await this._leagueImageRepository.GetByIDAsync(leagueImageId, ct));

            if (leagueImageToDelete == null)
            {
                return(false);
            }

            return(await this._leagueImageRepository.DeleteAsync(leagueImageToDelete.Id, ct));
        }
        public static LeagueImageViewModel Convert(LeagueImage leagueImage)
        {
            LeagueImageViewModel leagueImageViewModel = new LeagueImageViewModel();

            leagueImageViewModel.Id = leagueImage.Id;
            leagueImageViewModel.CloudinaryPublicId = leagueImage.CloudinaryPublicId;
            leagueImageViewModel.Format             = leagueImage.Format;
            leagueImageViewModel.HashTag            = leagueImage.HashTag;
            leagueImageViewModel.Height             = leagueImage.Height;
            leagueImageViewModel.Width   = leagueImage.Width;
            leagueImageViewModel.Type    = leagueImage.Type;
            leagueImageViewModel.Medium  = leagueImage.Medium;
            leagueImageViewModel.Small   = leagueImage.Small;
            leagueImageViewModel.Big     = leagueImage.Big;
            leagueImageViewModel.Name    = leagueImage.Name;
            leagueImageViewModel.Url     = leagueImage.Url;
            leagueImageViewModel.OrderId = leagueImage.OrderId;

            return(leagueImageViewModel);
        }
        public async Task <List <LeagueImageViewModel> > AddLeagueImagesAsync(IList <LeagueImageViewModel> leagueImagesViewModel, CancellationToken ct = default)
        {
            List <LeagueImageViewModel> addedLeagueImages = new List <LeagueImageViewModel>();
            List <LeagueImageViewModel> allLeagueImages   = leagueImagesViewModel.Concat(await this.GetAllLeagueImagesAsync()).OrderBy(o => o.OrderId).ToList();

            for (int i = 0; i < allLeagueImages.Count(); i++)
            {
                LeagueImageViewModel leagueImage = allLeagueImages.ElementAt(i);
                if (allLeagueImages.ElementAt(i).OrderId == null)
                {
                    leagueImage.OrderId = i + 1;
                    addedLeagueImages.Add(await this.AddLeagueImageAsync(leagueImage, ct));
                    continue;
                }
                leagueImage.OrderId = i + 1;
                await UpdateLeagueImageAsync(leagueImage, ct);
            }

            return(addedLeagueImages);
        }
        public static List <LeagueImageViewModel> ConvertList(IEnumerable <LeagueImage> leagueImages)
        {
            return(leagueImages.Select(leagueImage =>
            {
                LeagueImageViewModel leagueImageViewModel = new LeagueImageViewModel();
                leagueImageViewModel.Id = leagueImage.Id;
                leagueImageViewModel.CloudinaryPublicId = leagueImage.CloudinaryPublicId;
                leagueImageViewModel.Format = leagueImage.Format;
                leagueImageViewModel.HashTag = leagueImage.HashTag;
                leagueImageViewModel.Height = leagueImage.Height;
                leagueImageViewModel.Width = leagueImage.Width;
                leagueImageViewModel.Type = leagueImage.Type;
                leagueImageViewModel.Medium = leagueImage.Medium;
                leagueImageViewModel.Small = leagueImage.Small;
                leagueImageViewModel.Big = leagueImage.Big;
                leagueImageViewModel.Name = leagueImage.Name;
                leagueImageViewModel.Url = leagueImage.Url;
                leagueImageViewModel.ResourceType = leagueImage.ResourceType;
                leagueImageViewModel.OrderId = leagueImage.OrderId;

                return leagueImageViewModel;
            }).ToList());
        }
        public async Task <LeagueImageViewModel> GetLeagueImageByIdAsync(long?id, CancellationToken ct = default(CancellationToken))
        {
            LeagueImageViewModel leagueImageViewModel = LeagueImageConverter.Convert(await this._leagueImageRepository.GetByIDAsync(id, ct));

            return(leagueImageViewModel);
        }