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)}"); }
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 <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; } }
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; } }
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); } } }
/** * 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; } }
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)); }
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 WriteToStreamAsync(Stream stream) { var buffer = new byte[fileUploadEntry.Size]; await fileUploadEntry.OpenReadStream(104857600).ReadAsync(buffer); await stream.WriteAsync(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()); } }
private async Task UploadToBlobAsync() { using var stream = selectedFile.OpenReadStream(); var content = new StreamContent(stream); content.Headers.Add("type", selectedFile.ContentType); await HttpClient.PostAsync($"api/uploadData/{selectedFile.Name}", content); await PullListAsync(); }
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 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 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 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); }
private async Task UploadFile() { if (SelectedFile != null) { Stream stream = SelectedFile.OpenReadStream(); MemoryStream ms = new(); await stream.CopyToAsync(ms); FileRequest.Byte = ms.ToArray(); FileRequest.FileName = WebUtility.HtmlEncode(SelectedFile.Name); await EventCallback.InvokeAsync(); } }
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>(); }
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); } }
/// <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> UploadImage(IBrowserFile bfile) { string uniqueFileName = null; var file = bfile.OpenReadStream(maxAllowedSize: 4096000); if (file is not null) { string uploadsFolder = Path.Combine(webHostEnvironment.WebRootPath, "images"); uniqueFileName = Guid.NewGuid().ToString() + "_" + bfile.Name; string filePath = Path.Combine(uploadsFolder, uniqueFileName); using (var fileStream = new FileStream(filePath, FileMode.Create)) { await file.CopyToAsync(fileStream); } } return(uniqueFileName); }
private async Task SaveSweet() { try { bool success; SweetWithImage si = new SweetWithImage(s); if (fileToUpload is not null) { using Stream stream = fileToUpload.OpenReadStream(); using MemoryStream ms = new MemoryStream(); await stream.CopyToAsync(ms); UploadedFile uploadedFile = new UploadedFile(fileToUpload.Name, ms.ToArray()); si.ImageFile = uploadedFile; } if (si.Sweet.Id == default(int)) { var resp = await http.PostAsJsonAsync("sweet", si); success = resp.IsSuccessStatusCode; } else { var resp = await http.PutAsJsonAsync("sweet/withimage", si); success = resp.IsSuccessStatusCode; } if (success) { s.ImageFileName = fileToUpload.Name; await sw.FireAsync("Success", "Sweet save success.", SweetAlertIcon.Success); TitlePage = "Modify sweet"; } else { await sw.FireAsync("Error", "Something is wrong.", SweetAlertIcon.Error); } } catch (AccessTokenNotAvailableException exception) { exception.Redirect(); } }
public async Task <(int Count, string Message, Document?Entity)> SaveAsync(ClaimsPrincipal?principal, IBrowserFile file, object?documentedObject, string?fileExtension, int maxFileSizeKb) { if (principal.IsAuthenticated()) { using var dbContext = Factory.CreateDbContext(); var fileSize = (int)file.Size; using var stream = file.OpenReadStream(maxFileSizeKb * 1024); var(Id, DocumentId, TypeName) = DocumentedObject(documentedObject, fileExtension); if (DocumentId.HasValue) { var existing = await dbContext.Documents.FindAsync(DocumentId); if (existing is null) { return(principal.NothingToUpdate <Document>()); } existing.Content = new byte[fileSize]; var bytes = await stream.ReadAsync(existing.Content.AsMemory(0, fileSize)); existing.LastModifiedTime = TimeProvider.Now; var count = await dbContext.SaveChangesAsync(); return(count.SaveResult(existing)); } else { var document = new Document { FileExtension = fileExtension, ContentType = ContentType(fileExtension), Content = new byte[file.Size], LastModifiedTime = TimeProvider.Now }; var bytes = await stream.ReadAsync(document.Content.AsMemory(0, fileSize)); dbContext.Documents.Add(document); var count = await dbContext.SaveChangesAsync(); count += await UpdateDocumentReference(dbContext, document, documentedObject); return(count.SaveResult(document)); }; } return(principal.SaveNotAuthorised <Document>());
public async Task <string> Upload(IBrowserFile file) { string uploadFolder = Path.Combine(webHostEnvironment.WebRootPath, "images", "products"); string uniqueFileName = Guid.NewGuid().ToString() + "-" + file.Name; string filePath = Path.Combine(uploadFolder, uniqueFileName); using (Stream stream = file.OpenReadStream(maxFileSize)) { using (MemoryStream memoryStream = new()) { await stream.CopyToAsync(memoryStream); await File.WriteAllBytesAsync(filePath, memoryStream.ToArray()); } } return(uniqueFileName); }
private async Task OnFileSelection(InputFileChangeEventArgs e) { IBrowserFile imgFile = e.File; var buffers = new byte[imgFile.Size]; await imgFile.OpenReadStream(maxFileSize).ReadAsync(buffers); string imageType = imgFile.ContentType; imgUrl = $"data:{imageType};base64,{Convert.ToBase64String(buffers)}"; //todo //IBrowserFile file = e.File; // //var buffers = new byte[imgFile.Size]; // using var reader = new StreamReader(file.OpenReadStream(maxFileSize)); // await reader.ReadAsync(content); // string imageType = file.ContentType; // imgUrl =$"data:{imageType};base64,{Convert.ToBase64String(loadedFileContent)}"; }
public async Task <string> PublishFile(IBrowserFile file) { using MultipartFormDataContent formContent = new(); using StreamContent streamContent = new(file.OpenReadStream(MaxFileSize)); formContent.Add(streamContent, "\"files\"", file.Name); await _apiClient.EnsureAuthorizationHeader(); HttpResponseMessage response = await _apiClient.HttpClient.PostAsync("", formContent); using Stream contentStream = await response.Content.ReadAsStreamAsync(); var result = await JsonSerializer.DeserializeAsync <FileUploadResult>(contentStream, options : new() { PropertyNameCaseInsensitive = true }); return(result.LocalPath); }
public async Task <string> UploadFile(IBrowserFile WebFile, Models.File CirrusFile) { var DirectoryClient = FileSystemClient.GetDirectoryClient(CirrusFile.UserId); DataLakeFileClient FileClient = null; foreach (Category Category in CirrusFile.Categories) { FileClient = DirectoryClient.CreateSubDirectoryAsync(Category.CategoryName).Result.Value.CreateFileAsync(CirrusFile.FileName).Result.Value; using (var MS = new MemoryStream()) { await WebFile.OpenReadStream(10485760).CopyToAsync(MS); MS.Position = 0; await FileClient.AppendAsync(MS, 0); await FileClient.FlushAsync(position : MS.Length); } } return(FileClient == null ? null : FileClient.Path + "/" + CirrusFile.FileName); }
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; } }