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;
}
}
