public async Task <string> UploadFile(IBrowserFile file) { try { FileInfo fileInfo = new FileInfo(file.Name); var fileName = Guid.NewGuid().ToString() + fileInfo.Extension; var folderDirectory = $"{webHostEnvironment.WebRootPath}\\{imageFolder}"; var path = Path.Combine(webHostEnvironment.WebRootPath, imageFolder, fileName); var memoryStream = new MemoryStream(); await file.OpenReadStream().CopyToAsync(memoryStream); if (!Directory.Exists(folderDirectory)) { Directory.CreateDirectory(folderDirectory); } await using (var fs = new FileStream(path, FileMode.Create, FileAccess.Write)) { memoryStream.WriteTo(fs); } var url = $"{httpContextAccessor.HttpContext.Request.Scheme}://{httpContextAccessor.HttpContext.Request.Host.Value}/"; var fullPath = $"{url}{imageFolder}/{fileName}"; return(fullPath); } catch (Exception ex) { throw ex; } }
public async Task UploadEncounters(IBrowserFile file) { try { var ms = new MemoryStream(); await file.OpenReadStream().CopyToAsync(ms); var json = System.Text.Encoding.ASCII.GetString(ms.ToArray()); var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true }; var upload = JsonSerializer.Deserialize <FileUpload>(json, options); var sort = upload.Encounters.OrderBy(a => a.Name).ToList(); _bank.Encounters = sort; Notify(); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
public async Task <string> UploadFile(IBrowserFile file) { try { FileInfo fileInfo = new FileInfo(file.Name); var fileName = Guid.NewGuid().ToString() + fileInfo.Extension; var folderDir = $"{_webHostEnvironment.WebRootPath}\\RoomImages"; var path = Path.Combine(_webHostEnvironment.WebRootPath, "RoomImages", fileName); var memoryStream = new MemoryStream(); await file.OpenReadStream().CopyToAsync(memoryStream); if (!Directory.Exists(folderDir)) { Directory.CreateDirectory(folderDir); } await using (var fs = new FileStream(path, FileMode.Create, FileAccess.Write)) { memoryStream.WriteTo(fs); } var fullPath = $"RoomImages/{fileName}"; return(fullPath); } catch (Exception ex) { throw ex; } }
public async Task <string> ToBase64StringAsync(IBrowserFile file) { byte[] buffer = new byte[file.Size]; await file.OpenReadStream().ReadAsync(buffer); return($"data:{file.ContentType};base64,{Convert.ToBase64String(buffer)}"); }
protected async Task HandleFileSelection(InputFileChangeEventArgs e) { file = e.File; isFileChanged = true; if (file != null) { var ext = Path.GetExtension(file.Name); if (ext.Contains("jpg") || ext.Contains("png") || ext.Contains("jpeg") || ext.Contains("pdf")) { msFile = file.OpenReadStream(); var resizedImageFile = await file.RequestImageFileAsync("image/png", 100, 100); var buffer = new byte[resizedImageFile.Size]; await resizedImageFile.OpenReadStream().ReadAsync(buffer); var imageBase64Data = Convert.ToBase64String(buffer); imageDataURL = string.Format("data:image/png;base64,{0}", imageBase64Data); isInvalidFileType = false; } else { isInvalidFileType = true; imageDataURL = string.Empty; } } else { isInvalidFileType = false; } }
public static async Task <string> ReadStreamAsync(this IBrowserFile file) { var buffer = new byte[file.Size]; await file.OpenReadStream(MaxFileSize).ReadAsync(buffer); return(Convert.ToBase64String(buffer)); }
/** * upload the file as a static file to our server */ public async Task <string> UploadFile(IBrowserFile file) { try { FileInfo fileInfo = new FileInfo(file.Name); var fileName = Guid.NewGuid().ToString() + fileInfo.Extension; var folderDirectory = $"{_webHostEnvironment.WebRootPath}/RoomImages"; var path = Path.Combine(_webHostEnvironment.WebRootPath, "RoomImages", fileName); var memoryStream = new MemoryStream(); await file.OpenReadStream().CopyToAsync(memoryStream); // create the folder if it doesnt exist - this will run for the first ever image uploaded if (!Directory.Exists(folderDirectory)) { Directory.CreateDirectory(folderDirectory); } // use the memory stream to write the file into the folder await using (var fs = new FileStream(path, FileMode.Create, FileAccess.Write)) { memoryStream.WriteTo(fs); } var fullPath = $"RoomImages/{fileName}"; return(fullPath); } catch (Exception e) { throw e; } }
private async Task SubmitProfileImageForm(IBrowserFile file) { videoSaved = false; fileName = file.Name; stream = file.OpenReadStream(); imageSource = Base64ImageEncoder.EncodeImage(stream, file.ContentType); if (!string.IsNullOrEmpty(Id)) { try { var imageUrl = await ConsultantProfilesClient.UploadProfileImageAsync(Guid.Parse(Id), new FileParameter(stream, fileName)); consultant.ProfileImage = imageUrl; videoSaved = true; await imageUploadModal.Close(); } /* catch (ApiException exc) * { * } * catch (HttpRequestException exc) * { * } */ catch (Exception exc) { await JSHelpers.Alert(exc.Message); } } }
private async Task SubmitVideoForm(IBrowserFile file) { videoSaved = false; try { var videoUrl = await ConsultantProfilesClient.UploadVideoAsync(Guid.Parse(Id), new FileParameter(file.OpenReadStream(), file.Name)); consultant.ProfileVideo = videoUrl; videoSaved = true; await videoUploadModal.Close(); } /* catch (ApiException exc) * { * } * catch (HttpRequestException exc) * { * } */ catch (Exception exc) { await JSHelpers.Alert(exc.Message); } }
private static void CheckIfFileIsNull(IBrowserFile file) { if (file is null) { throw new UserException("No file selected"); } }
private static void CheckIfSizeLessThan500KiloByte(IBrowserFile file) { if (file.Size > 512000) { throw new UserException("The size of the image must be less than 512 KB."); } }
public override async Task SetCurrentFileAsync(IBrowserFile file) { await base.SetCurrentFileAsync(file); if (OffsetAddress > 0) { await GetOffsetValueAsync(); } }
/// <summary> /// Attempts to convert the current image file to a new one of the specified file type and maximum file dimensions. /// <para> /// Caution: there is no guarantee that the file will be converted, or will even be a valid image file at all, either /// before or after conversion. The conversion is requested within the browser before it is transferred to .NET /// code, so the resulting data should be treated as untrusted. /// </para> /// </summary> /// <remarks> /// The image will be scaled to fit the specified dimensions while preserving the original aspect ratio. /// </remarks> /// <param name="browserFile">The <see cref="IBrowserFile"/> to convert to a new image file.</param> /// <param name="format">The new image format.</param> /// <param name="maxWidth">The maximum image width.</param> /// <param name="maxHeight">The maximum image height</param> /// <returns>A <see cref="ValueTask"/> representing the completion of the operation.</returns> public static ValueTask <IBrowserFile> RequestImageFileAsync(this IBrowserFile browserFile, string format, int maxWidth, int maxHeight) { if (browserFile is BrowserFile browserFileInternal) { return(browserFileInternal.Owner.ConvertToImageFileAsync(browserFileInternal, format, maxWidth, maxHeight)); } throw new InvalidOperationException($"Cannot perform this operation on custom {typeof(IBrowserFile)} implementations."); }
private async Task OnImageUploadedAsync(InputFileChangeEventArgs e) { selectedFile = e.File; var resizedImageFile = await e.File.RequestImageFileAsync(format, 100, 100); var buffer = new byte[resizedImageFile.Size]; await resizedImageFile.OpenReadStream().ReadAsync(buffer); imageDataUrl = $"data:{format};base64,{Convert.ToBase64String(buffer)}"; }
static async Task <string> ConvertFileToBase64Async(IBrowserFile file, CancellationToken ct = default) { var buffer = new byte[file.Size]; await file .OpenReadStream(maxFileSize, ct) .ReadAsync(buffer, ct); return(Convert.ToBase64String(buffer)); }
private static async Task <byte[]> ConvertStreamToByteArray(IBrowserFile file) { await using var stream = file.OpenReadStream(); await using var memoryStream = new MemoryStream(); { await stream.CopyToAsync(memoryStream); return(memoryStream.ToArray()); } }
public async Task <List <Rectangle> > GetRectAsync(IBrowserFile file) { ms.Close(); ms = new MemoryStream(); var t = file.OpenReadStream(file.Size); await t.CopyToAsync(ms); List <Rectangle> rects = ac.GetRectangles(ms); return(rects); }
private async Task UploadFileToWebRoot(IBrowserFile files) { Stream stream = files.OpenReadStream(); var path = $"{WebHostEnvironment.WebRootPath}\\files\\{files.Name}"; FileStream fileStream = File.Create(path); await stream.CopyToAsync(fileStream); stream.Close(); fileStream.Close(); }
private async Task StoreImage(InputFileChangeEventArgs args) { if (args.FileCount != 1) { await sw.FireAsync("Errore", "You can upload only one file.", SweetAlertIcon.Error); } else { fileToUpload = args.File; } }
private static async Task <string> ReadStringFromFile(InputFileChangeEventArgs e) { IBrowserFile file = e.File; long fileSize = file.Size; byte[] buffer = new byte[fileSize]; await file.OpenReadStream().ReadAsync(buffer); var str = Encoding.Default.GetString(buffer); return(str.Trim().Trim(new char[] { '\uFEFF' })); }
public async Task ImportFile(InputFileChangeEventArgs e, IBrowserFile file, SettingsContainer sc) { if (!file.Name.EndsWith("txt")) { throw new Exception("File format must be txt"); } string fromFile = await ReadStringFromFile(e); List <Student> students = CreateStudents(fromFile); sc.Students = students; }
public static Boolean CheckFileMimeType(IBrowserFile file, IReadOnlyCollection <AudioCodec> audioCodecs) { Boolean fileMimeTypeMatches = false; if ((file != null) && (audioCodecs != null)) { var extension = Path.GetExtension(file.Name).ToLower(); var audioCodecsFound = audioCodecs.Where(x => x.MimeType.Equals(file.ContentType, StringComparison.OrdinalIgnoreCase) || x.FileExtension.Equals(extension, StringComparison.OrdinalIgnoreCase)); fileMimeTypeMatches = (audioCodecsFound != null) && (audioCodecsFound.Any()); } return(fileMimeTypeMatches); }
public static async Task <List <T> > ReadCsv <T>(ICsvMapping <T> mapping, IBrowserFile file) { CsvParserOptions csvParserOptions = new CsvParserOptions(true, ','); CsvParser <T> csvParser = new CsvParser <T>(csvParserOptions, mapping); using var reader = new StreamReader(file.OpenReadStream()); var line = await reader.ReadToEndAsync(); CsvReaderOptions csvReaderOptions = new CsvReaderOptions(new string[] { "\r", "\n" }); var results = csvParser.ReadFromString(csvReaderOptions, line); return(results.Select(x => x.Result).ToList()); }
public static async Task <byte[]> GetResizedImageAsync(this IBrowserFile file, int size, CancellationToken cancellationToken = default) { var resizedImage = await file.RequestImageFileAsync("image/jpeg", size, size); var buffer = new byte[resizedImage.Size]; using (var stream = resizedImage.OpenReadStream(MaxImageSize, cancellationToken)) { await stream.ReadAsync(buffer, cancellationToken); } return(buffer); }
public async Task <bool> ConvertAndAdd(IBrowserFile browserFile) // Skapar tempfil av filen man skickat in, för att läsa in och sedan ta bort då den inte längre behövs. // Kopierar tempfilen till en riktig fil. Ökade värdet på OpenReadStream(20000000) då filen är större än värdet som tillåts. { var dataList = new List <TemperatureReading>(); var filePath = Path.GetTempFileName(); using (var stream = File.Create(filePath)) { await browserFile.OpenReadStream(20000000).CopyToAsync(stream); /**/ } var data = await File.ReadAllLinesAsync(filePath); File.Delete(filePath); for (int i = 0; i < data.Length; i++) // Inläsning av alla rader från filen. Sparar som entiteter i en lista som vi sedan skickar till databasen och sparar. { var item = data[i]; if (item != null) { var splittedData = item.Split(","); if (splittedData.Length == 4) { try { TemperatureReading temperatureReading = new TemperatureReading() { Date = DateTime.Parse(splittedData[0].Replace(" ", "T")), Location = splittedData[1], Temperature = double.Parse(splittedData[2], NumberFormatInfo.InvariantInfo), Humidity = int.Parse(splittedData[3]) }; dataList.Add(temperatureReading); } catch (Exception e) { System.Diagnostics.Debug.WriteLine(e.Message); System.Diagnostics.Debug.WriteLine(i + 1); throw; } } } } await _efContext.TemperatureReadings.AddRangeAsync(dataList); await _efContext.SaveChangesAsync(); return(true); }
public async Task UploadFile(string folderPath, IBrowserFile file) { using var uploadFile = File.OpenWrite(Path.Combine(folderPath, file.Name)); using var stream = file.OpenReadStream(); var buffer = new byte[4 * 1096]; int bytesRead; double totalRead = 0; while ((bytesRead = await stream.ReadAsync(buffer)) != 0) { totalRead += bytesRead; await uploadFile.WriteAsync(buffer); } }
public static async Task LoadXMLfromFile(MonacoEditor editor, IBrowserFile file) { byte[] bytesOfXML = new byte[file.Size]; using (Stream strm = file.OpenReadStream()) { await strm.ReadAsync(bytesOfXML); } string stringOfXML = Encoding.UTF8.GetString(bytesOfXML); TextModel model = await MonacoEditorBase.CreateModel(stringOfXML, "xml"); await editor.SetModel(model); //List<string> lLines = stringOfXML.Split("\n").ToList<string>(); }
/// <summary> /// Denna metoden tar in en fil som användaren har valt, /// filen läses in som en temporär fil på hårddisken och tas bort så fort den inte behövs mer. /// Använder OpenReadStream(20000000) då filen var större än default värdet. /// När datan har lästs in från fil, skapar vi upp entiteter som läggs i en lista /// som vi sedan skickar in till databasen och sparar. /// </summary> /// <param name="browserFile">Filen som användaren har valt.</param> /// <returns>En boolean på om det lyckats eller inte.</returns> public async Task <bool> ConvertAndAdd(IBrowserFile browserFile) { var dataList = new List <TemperatureReading>(); var filePath = Path.GetTempFileName(); using (var stream = File.Create(filePath)) { await browserFile.OpenReadStream(20000000).CopyToAsync(stream); } var data = await File.ReadAllLinesAsync(filePath); File.Delete(filePath); for (int i = 0; i < data.Length; i++) { var item = data[i]; if (item != null) { var splittedData = item.Split(","); if (splittedData.Length == 4) { try { TemperatureReading temperatureReading = new TemperatureReading() { Date = DateTime.Parse(splittedData[0].Replace(" ", "T")), Thermometer = splittedData[1], Temperature = double.Parse(splittedData[2], NumberFormatInfo.InvariantInfo), Humidity = int.Parse(splittedData[3]) }; dataList.Add(temperatureReading); } catch (Exception e) { System.Diagnostics.Debug.WriteLine(e.Message); System.Diagnostics.Debug.WriteLine(i + 1); return(false); } } } } await _weatherDataContext.temperatureReadings.AddRangeAsync(dataList); await _weatherDataContext.SaveChangesAsync(); return(true); }
public async Task <string> ReadTextAsync(IBrowserFile browserFile) { _ = browserFile ?? throw new ArgumentNullException(nameof(browserFile)); if (!_supportedMimeTypes.Contains(browserFile.ContentType)) { throw new NotSupportedException( $"File type ({browserFile.ContentType}) is not supported."); } using var file = browserFile.OpenReadStream(); using var reader = new StreamReader(file, Encoding.UTF8); return(await reader.ReadToEndAsync().ConfigureAwait(false)); }
public async Task <string> UploadFile(IBrowserFile file) { try { var fileInfo = new FileInfo(file.Name); var fileName = Guid.NewGuid().ToString() + fileInfo.Extension; var folderDirectory = $"{_webHostEnvironment.WebRootPath}\\flatimages"; var path = Path.Combine(_webHostEnvironment.WebRootPath, "flatimages", fileName); var memoryStream = new MemoryStream(); await file.OpenReadStream().CopyToAsync(memoryStream); if (!Directory.Exists(folderDirectory)) { Directory.CreateDirectory(folderDirectory); } await using (var fileStream = new FileStream(path, FileMode.Create, FileAccess.Write)) { memoryStream.WriteTo(fileStream); } // url - содержит полный путь до файла. var url = $"{_httpContextAccessor.HttpContext.Request.Scheme}://{_httpContextAccessor.HttpContext.Request.Host.Value}/"; //var url = $"{_configuration.GetValue<string>("ServerUrl")}"; var fullPath = $"{url}flatimages/{fileName}"; return(fullPath); } catch (Exception ex) { return(ex.Message); //or throw ex; } }