Example #1
0
        public IActionResult AddFile(IFormFile file)
        {
            Ensure.Any.IsNotNull(file);
            var userId = Request.GetUserId();

            if (!file.IsSupportedFile())
            {
                throw new NotSupportedException();
            }

            var extension  = Path.GetExtension(file.FileName);
            var fileName   = userId + "_" + Guid.NewGuid() + extension;
            var uploadPath = Path.Combine(_hostingEnvironment.WebRootPath, "uploads");

            if (!Directory.Exists(uploadPath))
            {
                Directory.CreateDirectory(uploadPath);
            }
            var filePath = Path.Combine(uploadPath, fileName);

            using (var filestream = new FileStream(filePath, FileMode.Create))
            {
                file.CopyTo(filestream);
            }

            _fileFacade.AddFile(fileName, file.ContentType);

            var response = new AddFileResponse(fileName);

            return(Ok(response));
        }
Example #2
0
            public async Task <List <Image> > Handle(Command request, CancellationToken cancellationToken)
            {
                if (request.formFiles == null)
                {
                    throw new RestException(HttpStatusCode.BadRequest, "No files to upload");
                }

                try
                {
                    AddFileResponse response = await _filesRepository.UploadFiles(request.bucketName, request.formFiles);

                    if (response == null)
                    {
                        throw new RestException(HttpStatusCode.BadRequest, "Bad Request");
                    }

                    var imageList = new List <Image>();
                    foreach (var imageUrl in response.PreSignedUrl)
                    {
                        var image = new Image
                        {
                            ImageUrl = imageUrl
                        };
                        imageList.Add(image);
                    }



                    _context.Images.AddRange(imageList);

                    var success = await _context.SaveChangesAsync() > 0;

                    if (success)
                    {
                        return(imageList);
                    }

                    throw new Exception("Problem saving changes");
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
        public async Task Given_a_successful_request_when_UploadFiles_is_called_it_returns_a_successful_response_object()
        {
            //arrange
            var testBucket      = "test";
            var testFiles       = TestHelper.Generate_FileMock();
            var testUrlResponse = new List <string>
            {
                "testURL"
            };
            var expectedResponse = new AddFileResponse {
                PreSignedUrl = testUrlResponse
            };

            mockS3Client.Setup(x => x.UploadFiles(It.IsAny <string>(), It.IsAny <IList <IFormFile> >())).ReturnsAsync(expectedResponse);
            //act
            var response = await classUnderTest.UploadFiles(testBucket, testFiles);

            //assert
            Assert.AreSame(response, expectedResponse);
        }
Example #4
0
        public async Task Given_a_valid_request_when_postFilesController_method_is_called_then_it_returns_201_Created_response()
        {
            //arrange
            var expectedResponseCode = 201;
            var testBucket           = "test";
            var response             = new AddFileResponse {
                PreSignedUrl = new List <string> {
                    "test"
                }
            };
            var testFiles = TestHelper.Generate_FileMock();

            _mockPostUseCase.Setup(x => x.Execute(testBucket, testFiles)).ReturnsAsync(response);

            //act
            var controllerResponse = await _filesController.AddFiles(testBucket, testFiles);

            var result = controllerResponse.Result as ObjectResult;

            //assert
            Assert.AreEqual(expectedResponseCode, result.StatusCode);
        }