//Functions

        public async Task OninputFileChange(InputFileChangeEventArgs e)
        {
            var imagesFiles = e.GetMultipleFiles();
            var format      = "image/png";

            selectedImage = imagesFiles;

            int i = addImageDTOs.Count;

            addImageDTOs = new List <AddImageDTO>();

            foreach (var imageFile in imagesFiles)
            {
                var resizedImageFile = await imageFile.RequestImageFileAsync(format, 100, 100);

                var buffer = new byte[resizedImageFile.Size];
                await resizedImageFile.OpenReadStream().ReadAsync(buffer);

                var imageDataUrl = $"data:{format};base64,{Convert.ToBase64String(buffer)}";

                AddImageDTO dTO = new AddImageDTO
                {
                    imageDataUrl = imageDataUrl,
                    ProductImage = new ProductImage
                    {
                        ProductImagePosition = i,
                        Name = imageFile.Name
                    },
                };
                addImageDTOs.Add(dTO);
                i++;
            }
        }
        public async Task <IActionResult> ChangePicture([FromForm] AddImageDTO model)
        {
            var user   = _userManager.GetUserAsync(User).Result;
            var result = await _userService.ChangePicture(user, model);

            if (result.Success)
            {
                return(Ok(result));
            }
            return(BadRequest(result));
        }
        public async Task <Response <ImageAddedDTO> > ChangePicture(User user, AddImageDTO model)
        {
            Response <ImageAddedDTO> response = new Response <ImageAddedDTO>();
            var result = await _imageService.UploadImage(model.Image);

            string publicId = result.PublicId;
            string url      = result.Url.ToString();

            if (publicId == null || url == null)
            {
                response.Message = "An error occured while trying to upload your image";
                return(response);
            }

            var userToUpdate = await _userManager.FindByEmailAsync(user.Email);

            if (userToUpdate is null)
            {
                response.Message = "Could not find user";
                return(response);
            }

            userToUpdate.PublicId  = publicId;
            userToUpdate.AvatarUrl = url;

            var userResult = await _userManager.UpdateAsync(userToUpdate);

            if (userResult.Succeeded)
            {
                var responseDTO = new ImageAddedDTO
                {
                    PublicId = publicId,
                    Url      = url
                };

                response.Message = "Image Uploaded successfully!";
                response.Success = true;
                response.Data    = responseDTO;
            }
            else
            {
                response.Message = "Could not upload image";
            }

            return(response);
        }
        public async Task <IActionResult> UpdateImage(AddImageDTO addDamageDTO)
        {
            var damage = await _repo.GetDamage(addDamageDTO.Id);

            if (damage.BlobFiles == null)
            {
                damage.BlobFiles = new List <BlobFile>();
            }

            damage.BlobFiles.Add(new BlobFile()
            {
                FileName = addDamageDTO.FileName,
                FileUrl  = addDamageDTO.FileUrl,
            });

            var savedDamage = await _repo.UpdateDamage(damage);

            return(Ok(new { savedDamage.Id }));
        }