/// <summary> /// Uploads files to the repository. /// </summary> /// <param name="dataFile">File to be uploaded.</param> /// <returns>Uploaded files.</returns> public IEnumerable<DataDetail> Upload(DataFile dataFile) { Check.IsNotNull(dataFile, "dataFile"); List<DataDetail> collection = new List<DataDetail>(); DataDetail dataDetail = base.Upload(dataFile); collection.Add(dataDetail); return collection; }
public void Upload_ShouldReturnUploadedFileWithFileIdGreaterThanZero_WhenAFileIsUploaded() { IFileService fileService = new StubIFileService() { UploadFileDataDetail = dd => { dd.FileDetail.FileId = 1; return dd; } }; DefaultFileHandler defaultFileHandler = new DefaultFileHandler(fileService); DataFile dataFile = new DataFile() { FileContent = new byte[0] }; DataDetail dataDetail = defaultFileHandler.Upload(dataFile).First(); Assert.IsTrue(dataDetail.FileDetail.FileId > 0); }
public static void SetValuesFrom(this DataDetail dataDetail, DataFile dataFile) { Check.IsNotNull(dataDetail, "dataDetail"); Check.IsNotNull(dataFile, "dataFile"); dataDetail.FileDetail.CreatedBy = dataFile.CreatedBy; dataDetail.FileDetail.CreatedOn = DateTime.UtcNow; dataDetail.FileDetail.MimeType = dataFile.ContentType; dataDetail.FileDetail.Name = dataFile.FileName; dataDetail.FileDetail.Size = dataFile.FileContent.Length; dataDetail.FileDetail.Title = Path.GetFileNameWithoutExtension(dataFile.FileName); dataDetail.FileDetail.Status = FileStatus.Uploaded.ToString(); dataDetail.FileDetail.CreatedBy = dataFile.CreatedBy; dataDetail.FileDetail.isDeleted = false; }
public DataDetail(DataFile dataFile) : this() { Check.IsNotNull(dataFile, "dataFile"); this.DataStream = dataFile.FileContent; this.FileDetail.CreatedBy = dataFile.CreatedBy; this.FileDetail.CreatedOn = DateTime.UtcNow; this.FileDetail.MimeType = dataFile.ContentType; this.FileDetail.Name = dataFile.FileName; this.FileDetail.Size = dataFile.FileContent.Length; this.FileDetail.Title = System.IO.Path.GetFileNameWithoutExtension(dataFile.FileName); this.FileDetail.Status = FileStatus.Uploaded.ToString(); this.FileDetail.CreatedBy = dataFile.CreatedBy; this.FileDetail.isDeleted = false; }
public IEnumerable<DataDetail> Upload(DataFile dataFile) { Check.IsNotNull(dataFile, "dataFile"); List<DataDetail> collection = new List<DataDetail>(); List<DataFile> dataFiles = null; using (MemoryStream memoryStream = new MemoryStream(dataFile.FileContent)) { dataFiles = ZipUtilities.GetListOfFilesFromStream(memoryStream, this.userId); } foreach (var df in dataFiles) { var uploadedDataFiles = base.Upload(df); collection.Add(uploadedDataFiles); } return collection; }
public void Upload_ShouldReturnUploadedFileWithFileIdGreaterThanZero_WhenAFileIsUploaded() { IFileService fileService = new StubIFileService() { UploadFileDataDetail = dd => { dd.FileDetail.FileId = 1; return dd; } }; DefaultFileHandler defaultFileHandler = new DefaultFileHandler(fileService); DataFile dataFile = new DataFile() { FileContent = new byte[0] }; IEnumerable<DataDetail> dataDetails; List<DataFile> dataFiles = new List<DataFile>(); dataFiles.Add(new DataFile() { FileContent = new byte[0] }); dataFiles.Add(new DataFile() { FileContent = new byte[0] }); using (ShimsContext.Create()) { ShimZipUtilities.GetListOfFilesFromStreamStreamInt32 = (zipstream, userId) => dataFiles; dataDetails = defaultFileHandler.Upload(dataFile); } Assert.IsTrue(dataDetails.All(fd => fd.FileDetail.FileId > 0)); }
/// <summary> /// Method to download the file from the repository. /// </summary> /// <param name="downloadInput">Input data required to download the file from the repository.</param> /// <returns>Downloaded file data.</returns> public DataFile DownloadFile(string downloadUrl, string authorization, string fileName) { DataFile dataFile = new DataFile(); AuthToken token = new AuthToken() { AccessToken = authorization }; dataFile.FileContent = this.DownloadFile(downloadUrl, token); string extension = Path.GetExtension(fileName); if (extension.ToUpperInvariant().Equals(Constants.XLSX, StringComparison.OrdinalIgnoreCase)) { dataFile.FileExtentsion = extension; } else { dataFile.FileExtentsion = ".zip"; } dataFile.FileName = string.Format("{0}{1}", Path.GetFileNameWithoutExtension(fileName), dataFile.FileExtentsion); return dataFile; }
/// <summary> /// Method to download the fiel from the specific repository. /// </summary> /// <param name="downloadInput">Input data required to download the file from the repository.</param> /// <returns>Downloaded file data.</returns> public DataFile DownloadFile(string downloadUrl, string authorization, string fileName) { DataFile dataFile = new DataFile(); Stream outStream = null; try { HttpWebRequest httpRequest = (HttpWebRequest)WebRequest.Create(downloadUrl); httpRequest.Method = "GET"; httpRequest.Headers.Add("Authorization", "Basic " + authorization); System.Net.ServicePointManager.ServerCertificateValidationCallback = delegate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors) { return true; }; HttpWebResponse ws = (HttpWebResponse)httpRequest.GetResponse(); outStream = ws.GetResponseStream(); string zipFileName = Path.GetFileNameWithoutExtension(fileName) + ".zip"; if (outStream != null) { //// writing stream to a temp path string filePath = string.Format(@"{0}{1}\", Path.GetTempPath(), Path.GetFileNameWithoutExtension(Path.GetRandomFileName())); string totalFilePath = string.Format("{0}{1}", filePath, zipFileName); DirectoryInfo dir = Directory.CreateDirectory(filePath); using (Stream zipStream = System.IO.File.OpenWrite(totalFilePath)) { outStream.CopyToStream(zipStream); } using (ZipFile tmpZipFile = ZipFile.Read(totalFilePath)) { tmpZipFile.ExtractAll(filePath, ExtractExistingFileAction.OverwriteSilently); } // FileInfo[] directories = null; var fileList = dir.GetFiles("*", SearchOption.AllDirectories).ToList(); // If the file is xlsx file then download only the actual file if (Path.GetExtension(fileName).Equals(MerritConstants.XLSX, StringComparison.OrdinalIgnoreCase)) { var fileDownload = fileList.Find(s => s.Name.Equals(fileName, StringComparison.InvariantCultureIgnoreCase)); dataFile.FileContent = File.ReadAllBytes(fileDownload.FullName); dataFile.FileName = fileName; dataFile.ContentType = Helper.GetContentType(Path.GetExtension(fileDownload.FullName)); } else { string subDirPath = Path.GetFileNameWithoutExtension(Path.GetRandomFileName()); string fileNameWithOutExt = Path.GetFileNameWithoutExtension(fileName); var fileDownload = fileList.Where(file => (file.Name.Contains(fileNameWithOutExt) || file.Name.Contains("metadata")) && (Path.GetExtension(file.Name) != ".zip")).ToList(); if (fileDownload != null && fileDownload.Count > 0) { dir.CreateSubdirectory(subDirPath); foreach (var fileInf in fileDownload) { fileInf.CopyTo(filePath + subDirPath + "\\" + fileInf.Name); } } dataFile.FileName = fileNameWithOutExt + ".zip"; dataFile.ContentType = MerritConstants.ZipMimeType; dataFile.FileContent = ZipFileHelper.ZipFiles(filePath + subDirPath).GetBytes(); } } } catch (WebException ex) { if (ex.Status == WebExceptionStatus.ProtocolError) { WebResponse errResp = ex.Response; using (Stream respStream = errResp.GetResponseStream()) { using (StreamReader sr = new StreamReader(respStream)) { throw new Exception(ex.Message); } } } } return dataFile; }
/// <summary> /// Uploads files to the repository. /// </summary> /// <param name="dataFile">File to be uploaded.</param> /// <returns>Uploaded files.</returns> public virtual DataDetail Upload(DataFile dataFile) { var uploadedDataDetail = this.fileService.UploadFile(new DataDetail(dataFile)); return uploadedDataDetail; }
/// <summary> /// Removes errors from a file sheet. /// </summary> /// <param name="userId">User Id</param> /// <param name="fileId">File Id</param> /// <param name="sheetName">Sheet Name</param> /// <param name="errorTypeList">Error type list</param> /// <returns>Boolean indicating whether the removal was successful or not.</returns> public async Task RemoveErrors(int userId, int fileId, string sheetName, IEnumerable<ErrorType> errorTypeList) { DM.File file = this.FileDataRepository.GetItem(userId, fileId); if (null == file) { throw new DataFileNotFoundException() { FileId = fileId }; } else if (Path.GetExtension(file.Name) != Constants.XLFileExtension) { throw new InvalidOperationException(Messages.BestPractisesNotSupportedMessage); } IFileProcesser fileProcesser = FileFactory.GetFileTypeInstance(Path.GetExtension(file.Name), this.BlobDataRepository, this.FileDataRepository, this.RepositoryService); using (Stream stream = GetFileStream(file.BlobId)) { await fileProcesser.RemoveError(stream, sheetName, errorTypeList); if (Constants.UploadToAzure) { DataFile dataFile = new DataFile() { FileContent = await stream.GetBytesAsync(), ContentType = MimeMapping.GetMimeMapping(file.Name), FileName = file.Name, CreatedBy = userId, FileExtentsion = Path.GetExtension(file.Name) }; DataDetail dataDetail = new DataDetail(dataFile); file.ModifiedBy = dataDetail.FileDetail.CreatedBy; file.ModifiedOn = DateTime.UtcNow; file.Size = dataDetail.FileDetail.Size; dataDetail.FileDetail.BlobId = file.BlobId; if (this.BlobDataRepository.UploadFile(dataDetail)) { file = this.FileDataRepository.UpdateFile(file); } this.UnitOfWork.Commit(); dataDetail.DataStream = null; } } }
public DataFile GetDataFile(DM.File file) { Check.IsNotNull(file, "file"); IFileProcesser fileProcesser = FileFactory.GetFileTypeInstance(Path.GetExtension(file.Name), this.BlobDataRepository, this.FileDataRepository, this.RepositoryService); DataDetail dataDetail = fileProcesser.DownloadDocument(file); DataFile dataFile = new DataFile(); dataFile.ContentType = dataDetail.MimeTypeToDownLoad; dataFile.CreatedBy = dataDetail.FileDetail.CreatedBy; dataFile.FileInfo = dataDetail.FileDetail; dataFile.FileExtentsion = System.IO.Path.GetExtension(dataDetail.FileNameToDownLoad); dataFile.FileName = dataDetail.FileNameToDownLoad; dataFile.FileContent = dataDetail.DataStream; dataFile.IsCompressed = true; if (dataFile.FileExtentsion.Equals(Constants.XLFileExtension, StringComparison.OrdinalIgnoreCase)) { dataFile.IsCompressed = false; } return dataFile; }
public async Task<HttpResponseMessage> Post(string fileName, string fileExtension, string contentType) { try { Check.IsNotEmptyOrWhiteSpace(fileName, "fileName"); Check.IsNotEmptyOrWhiteSpace(fileExtension, "fileExtension"); Check.IsNotEmptyOrWhiteSpace(contentType, "contentType"); byte[] fileContent = default(byte[]); if (Request.Content.IsMimeMultipartContent("form-data")) { string root = Path.GetTempPath(); MultipartFormDataStreamProvider streamProvider = new MultipartFormDataStreamProvider(root); await Request.Content.ReadAsMultipartAsync(streamProvider); MultipartFileData multipartFileData = streamProvider.FileData.First(); /********************************************************* * This API under stress can cause IO exception, for File read * or Delete operation. More details @https://aspnetwebstack.codeplex.com/workitem/176 * Following logic retries file operations at most 3 times * inducing the recommended delay in case of failure. */ int executionDelay = 50, readRetryCount = 3, deleteRetryCount = 3; // Retry mechanics for file read operation while (readRetryCount-- > 0) { try { using (FileStream fileSource = new FileStream(multipartFileData.LocalFileName, FileMode.Open, FileAccess.Read)) { fileContent = await fileSource.GetBytesAsync(); } break; } catch (IOException ioe) { diagnostics.WriteErrorTrace(TraceEventId.Exception, ioe.ToString()); } await Task.Delay(executionDelay); } // Retry mechanics for file delete operation while (deleteRetryCount-- > 0) { try { await Task.Factory.StartNew(() => System.IO.File.Delete(multipartFileData.LocalFileName)); break; } catch (IOException ioe) { diagnostics.WriteErrorTrace(TraceEventId.Exception, ioe.ToString()); } await Task.Delay(executionDelay); } } else { var bufferlessInputStream = HttpContext.Current.Request.GetBufferlessInputStream(); Check.IsNotNull(bufferlessInputStream, "HttpContext.Current.Request.GetBufferlessInputStream()"); fileContent = await bufferlessInputStream.GetBytesAsync(); } this.fileService.ValidateForUpload(fileName, this.user.UserId); DataFile dataFile = new DataFile { FileContent = fileContent, ContentType = contentType, FileName = fileName, CreatedBy = this.user.UserId, FileExtentsion = fileExtension }; IFileHandler fileHandler = this.fileHandlerFactory.GetFileHandler(contentType, this.user.UserId); diagnostics.WriteInformationTrace(Utilities.Enums.TraceEventId.Flow, "blob-before file upload"); var uploadedDataDetails = fileHandler.Upload(dataFile); diagnostics.WriteInformationTrace(Utilities.Enums.TraceEventId.Flow, "blob-after file upload"); if (!uploadedDataDetails.Any() || uploadedDataDetails.Any(dd => dd.FileDetail.FileId == 0)) { return Request.CreateErrorResponse(HttpStatusCode.BadRequest, MessageStrings.UploadFailed); } return Request.CreateResponse<IEnumerable<DataDetail>>(HttpStatusCode.OK, uploadedDataDetails); } catch (ValidationException validationException) { HttpError error = validationException.GetHttpError(string.Format(MessageStrings.Upload_Validation_Error_Template, validationException.FileName)); return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error); } catch (ArgumentException ex) { message = string.Format(CultureInfo.CurrentCulture, MessageStrings.Argument_Error_Message_Template, ex.ParamName); status = HttpStatusCode.BadRequest; } return Request.CreateErrorResponse(status, message); }
public async Task<HttpResponseMessage> Post(string nameIdentifier) { try { Check.IsNotEmptyOrWhiteSpace(nameIdentifier, "nameIdentifier"); if (!Request.Content.IsMimeMultipartContent("form-data")) { throw new HttpResponseException(HttpStatusCode.UnsupportedMediaType); } string root = Path.GetTempPath(); MultipartFormDataStreamProvider streamProvider = new MultipartFormDataStreamProvider(root); await Request.Content.ReadAsMultipartAsync(streamProvider); MultipartFileData multipartFileData = streamProvider.FileData.First(); byte[] fileContent; using (FileStream fileSource = new FileStream(multipartFileData.LocalFileName, FileMode.Open, FileAccess.Read)) { fileContent = await fileSource.GetBytesAsync(); } string fileName = multipartFileData.Headers.ContentDisposition.FileName.Trim(new char[] { '\"' }); string fileExtension = Path.GetExtension(fileName); string contentType = MimeMapping.GetMimeMapping(fileName); Task.Factory.StartNew(() => System.IO.File.Delete(multipartFileData.LocalFileName)); User impersonatedUser = IdentityHelper.GetUser(this.userService, nameIdentifier); this.fileService.ValidateForUpload(fileName, impersonatedUser.UserId); DataFile dataFile = new DataFile { FileContent = fileContent, ContentType = contentType, FileName = fileName, CreatedBy = impersonatedUser.UserId, FileExtentsion = fileExtension }; IFileHandler fileHandler = this.fileHandlerFactory.GetFileHandler(contentType, impersonatedUser.UserId); var uploadedDataDetails = fileHandler.Upload(dataFile); if (!uploadedDataDetails.Any() || uploadedDataDetails.Any(dd => dd.FileDetail.FileId == 0)) { return Request.CreateErrorResponse(HttpStatusCode.BadRequest, MessageStrings.UploadFailed); } return Request.CreateResponse<IEnumerable<DataDetail>>(HttpStatusCode.OK, uploadedDataDetails); } catch (ArgumentException ex) { message = string.Format(CultureInfo.CurrentCulture, MessageStrings.Argument_Error_Message_Template, ex.ParamName); status = HttpStatusCode.BadRequest; } return Request.CreateErrorResponse(status, message); }