Example #1
0
        public async Task <IActionResult> UploadImage(IFormFile file, PropertyImage image)// [FromBody] PropertyImage image)    //public async Task<IActionResult> UploadImage(IFormFile file, string id)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }


            if (file == null || file.Length == 0)
            {
                return(Content("file not selected"));
            }

            string path = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot\\images\\");

            using (var fs = new FileStream(Path.Combine(path, file.FileName), FileMode.Create))
            {
                await file.CopyToAsync(fs);

                // Add image path to DB

                await _imageRepository.AddImageAsync(new PropertyImage
                {
                    //Url = "~/Contents/" + file.FileName, // Path.Combine(path, file.FileName),
                    Url        = "images/" + file.FileName,
                    Caption    = "First image for the property",
                    PropertyId = image.PropertyId, // "62541",
                    DateAdded  = DateTime.Now
                });
            }

            return(Content("file uploaded"));
        }
Example #2
0
        public async Task AddAndGetImageAsyncTest1()
        {
            await _imageRepository.AddImageAsync(ImageHelper.ToImage(dataImage));

            Image <Rgb24> image = await _imageRepository.GetImageAsync(ImageHelper.ToImage(dataImage).GetHash());

            Assert.IsTrue(image != null);
        }
Example #3
0
 public async Task AddImageAsync(ImageModel model)
 {
     Image image = _mapper.Map <ImageModel, Image>(model);
     await _imageRepository.AddImageAsync(image);
 }
Example #4
0
        private async Task <IActionResult> UploadImage(IFormFile uploadedFile)
        {
            string errorMessage;

            if (uploadedFile != null)
            {
                if (uploadedFile.Length < 10 * 1024 * 1024)
                {
                    if (uploadedFile.IsImage())
                    {
                        Image <Rgb24> image = uploadedFile.ToImage();

                        float width  = image.Width;
                        float height = image.Height;

                        // Resize the image if necessary.
                        if (width > height && width > 1000)
                        {
                            image.ResizeImage(1000, (int)(height / width * 1000));
                        }
                        else if (height > width && height > 1000)
                        {
                            image.ResizeImage((int)(width / height * 1000), 1000);
                        }
                        else if (height == width && height > 1000)
                        {
                            image.ResizeImage(1000, 1000);
                        }
                        else
                        {
                            // We have to create a new bitmap, because using the image created from the input stream directly causes an error.
                            image.ResizeImage((int)width, (int)height);
                        }

                        string fileName = await _imageRepository.AddImageAsync(image);

                        _logger.LogInformation("Uploaded file has been successfully added. FileName: '{0}'.", uploadedFile.FileName);

                        return(Json(new ImageModel()
                        {
                            FileName = fileName
                        }));
                    }
                    else
                    {
                        errorMessage = string.Format("Uploaded file is not image. FileName: '{0}'. ContentType: '{1}'.", uploadedFile.FileName, uploadedFile.ContentType);
                        _logger.LogWarning(errorMessage);
                    }
                }
                else
                {
                    errorMessage = string.Format("Uploaded file size is more than 1 MB. FileName: '{0}'. ContentType: '{1}'. ContentSize: '{2}'.", uploadedFile.FileName, uploadedFile.ContentType, (float)uploadedFile.Length / 1024 / 1024);
                    _logger.LogWarning(errorMessage);
                }
            }
            else
            {
                errorMessage = "Uploaded file is null.";
                _logger.LogWarning(errorMessage);
            }

            return(BadRequest(new ErrorModel {
                ErrorMessage = errorMessage
            }));
        }