public void File_ThrowsIfMultipleFiles() { var instance = new InputFileChangeEventArgs(new[] { new BrowserFile(), new BrowserFile() }); var ex = Assert.Throws <InvalidOperationException>(() => instance.File); Assert.StartsWith("More than one file was supplied", ex.Message); }
public void File_CanSupplySingle() { var file = new BrowserFile(); var instance = new InputFileChangeEventArgs(new[] { file }); Assert.Same(file, instance.File); }
public void File_ThrowsIfZeroFiles() { var instance = new InputFileChangeEventArgs(Array.Empty <IBrowserFile>()); var ex = Assert.Throws <InvalidOperationException>(() => instance.File); Assert.StartsWith("No file was supplied", ex.Message); }
private async Task ImportHardwareAsync(InputFileChangeEventArgs e) { if (!e.File.ContentType.Equals("text/xml", StringComparison.OrdinalIgnoreCase)) { return; } var buffer = new byte[e.File.Size]; using (var stream = e.File.OpenReadStream()) { await stream.ReadAsync(buffer); } var file = new FileModel { FileName = e.File.Name, ContentType = e.File.ContentType, Content = buffer, Size = e.File.Size }; await HttpClient.PostJsonAsync($"/api/hardware/import/{Id}", file); Contract = await HttpClient.GetFromJsonAsync <ContractDetailVm>($"api/contract/{Id}"); }
/// <summary> /// /// </summary> /// <param name="args"></param> /// <returns></returns> protected override async Task OnFileChange(InputFileChangeEventArgs args) { CurrentFile = new UploadFile() { OriginFileName = args.File.Name, Size = args.File.Size, File = args.File, Uploaded = false }; CurrentFile.ValidateId = $"{Id}_{CurrentFile.GetHashCode()}"; if (IsSingle) { // 单图片模式 DefaultFileList?.Clear(); UploadFiles.Clear(); } UploadFiles.Add(CurrentFile); await base.OnFileChange(args); // ValidateFile 后 IsValid 才有值 CurrentFile.IsValid = IsValid; if (OnChange != null) { await OnChange(CurrentFile); } else { await CurrentFile.RequestBase64ImageFileAsync(CurrentFile.File.ContentType, 320, 240); } }
protected ImageConverter _imageConverter;// = new ImageConverter(); protected async Task OnInputFileChange(InputFileChangeEventArgs e) { var maxAllowedFiles = 1; var format = "image/png"; if (e.GetMultipleFiles(maxAllowedFiles).Count > maxAllowedFiles) { Message = "max Allowed Files are 5"; return; } foreach (var imageFile in e.GetMultipleFiles(maxAllowedFiles)) { var resizedImageFile = await imageFile.RequestImageFileAsync(format, 100, 100); var buffer = new byte[resizedImageFile.Size]; await resizedImageFile.OpenReadStream().ReadAsync(buffer); var imageDataUrl = $"data:{format};base64,{Convert.ToBase64String(buffer)}"; if (imageDataUrl != null) { imageDataUrls.Clear(); imageDataUrls.Add(imageDataUrl); } LineItemEditModel.Receipt = buffer; //var image = resizedImageFile.OptimizeImageSize(700, 700); } }
private async Task LoadFilesAsync(InputFileChangeEventArgs e) { if (e.FileCount > 1) { var files = e.GetMultipleFiles(); var tasks = new List <Task>(); foreach (var file in files) { Logger.LogInformation($"uploading multiple files: {file.Name}"); tasks.Add(ChatViewModel.SendFileAsync(new File { Name = file.Name, Size = (ulong)file.Size, ContentType = file.ContentType }, file.OpenReadStream(maxAllowedSize: file.Size))); } await Task.WhenAll(tasks); } else { var file = e.File; Logger.LogInformation($"uploading file: {file.Name}"); await ChatViewModel.SendFileAsync(new File { Name = file.Name, Size = (ulong)file.Size, ContentType = file.ContentType, }, file.OpenReadStream(maxAllowedSize: file.Size)); } }
private async Task ProcessFile(InputFileChangeEventArgs e) { if (e.FileCount == 0) { return; } try { fileContent = ""; // Maximum of 10 files per upload foreach (var file in e.GetMultipleFiles(10)) { // Maximum 10 MB file upload using var reader = new StreamReader(file.OpenReadStream(10 * 1000 * 1024)); fileContent += await reader.ReadToEndAsync() + Environment.NewLine; } canImportFile = true; await InvokeAsync(StateHasChanged); } catch (Exception ex) { await js.AlertException(ex); } }
async Task OnInputFileChange(InputFileChangeEventArgs e) { var files = e.GetMultipleFiles(1); var file = files.FirstOrDefault(); List <ToDoList> todosImported; byte[] result; using (var reader = file.OpenReadStream()) { try { result = new byte[reader.Length]; await reader.ReadAsync(result, 0, ( int )reader.Length); var text = System.Text.Encoding.ASCII.GetString(result); todosImported = JsonConvert.DeserializeObject <List <ToDoList> >(text); if (todosImported.Count > 0) { foreach (var todo in todosImported) { todos.Add(todo); } } } catch (Exception exception) { message = exception.Message; } } }
private void OnInputFileChange(InputFileChangeEventArgs e) { BusyOverlayService.SetBusyState(BusyEnum.Busy); File = e.File; this.StateHasChanged(); BusyOverlayService.SetBusyState(BusyEnum.NotBusy); }
public void GetMultipleFiles_CanSupplyFiles() { var files = new[] { new BrowserFile(), new BrowserFile() }; var instance = new InputFileChangeEventArgs(files); Assert.Same(files, instance.GetMultipleFiles()); }
//async Task SaveAsUTF8(string filename, string content) //{ // byte[] data = Encoding.UTF8.GetBytes(content); // await jsRuntime.InvokeAsync<object>("saveAsFile", filename, Convert.ToBase64String(data)); //} async Task ImportNotes(InputFileChangeEventArgs e) { int count = e.FileCount; long maxId = DataService.GoalList.Any() ? DataService.GoalList.Max(g => g.Id) : 0; List <Goal> goalList = new List <Goal>(); foreach (IBrowserFile browserFile in e.GetMultipleFiles(count)) { string name = browserFile.Name; if (!name.EndsWith(".md")) { continue; } Stream stream = browserFile.OpenReadStream(); using StreamReader streamReader = new StreamReader(stream); string text = await streamReader.ReadToEndAsync(); Goal goal = new Goal { Id = ++maxId, CategoryId = DataService.RootCategory.Id, Description = name[0..^ 3],
async Task HandleFileSelected(InputFileChangeEventArgs e) { using var content = new MultipartFormDataContent(); foreach (var file in e.GetMultipleFiles(e.FileCount)) { content.Add(new StreamContent(file.OpenReadStream()), "files", file.Name); } var httpClient = _httpClientFactory.CreateClient("oidc"); using var response = await httpClient.PostAsync($"{httpClient.BaseAddress}/import", content).ConfigureAwait(false); var responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false); if (!response.IsSuccessStatusCode) { _error = new MarkupString($"{response.StatusCode}<br/>{responseContent.Replace("\n","<br/>")}"); } else { _result = JsonSerializer.Deserialize <ImportResult>(responseContent, new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }); } await InvokeAsync(StateHasChanged).ConfigureAwait(false); }
private async Task OnInputFileMetadataChange( InputFileChangeEventArgs e) { isLoading = true; if (e.FileCount != 1) { return; } try { // TODO IoC? MetadataReader metadataReader = new MetadataReader( new MetadataParser( new MetadataConverter())); this.Metadata = await metadataReader.ReadAsync(e.File.OpenReadStream()); await MetadataChanged.InvokeAsync(this.Metadata); } catch { // TODO: Indicate error state } finally { isLoading = false; } }
async Task LoadFiles(InputFileChangeEventArgs e) { this.isLoading = true; this.errorMessage = string.Empty; this.saveMassage = string.Empty; try { foreach (var file in e.GetMultipleFiles(1)) { StateHasChanged(); var buffers = new byte[file.Size]; await file.OpenReadStream().ReadAsync(buffers); this.uploadFile.FileName = file.Name; this.uploadFile.ContentType = file.ContentType; this.uploadFile.Size = file.Size; this.uploadFile.LastModified = file.LastModified; this.uploadFile.Content = buffers; } } catch (Exception ex) { this.errorMessage = ex.Message; } finally { this.isLoading = false; } }
async Task OnInputFileChange(InputFileChangeEventArgs e) { var path = Path.Combine(WebHostEnvironment.WebRootPath, imgPath); await FileStorageService.UploadFile(path, e.File); Institution.Logo = e.File.Name; }
private async Task OnFileChange(InputFileChangeEventArgs args) { var files = new List <UploadFile>(); if (IsMultiple || Style == UploadStyle.UploadFolder) { files.AddRange(args.GetMultipleFiles(MaxFileCount).Select(f => new UploadFile() { OriginFileName = f.Name, Size = f.Size, File = f, UpdateCallback = Update })); } else { var file = new UploadFile() { OriginFileName = args.File.Name, Size = args.File.Size, File = args.File, UpdateCallback = Update }; files.Add(file); } UploadFiles.AddRange(files); if (OnChange != null) { await OnChange(files); } }
private async Task UploadFiles(InputFileChangeEventArgs e) { file = e.File; if (file != null) { var format = "image/png"; var imageFile = await e.File.RequestImageFileAsync(format, 250, 250); var buffer = new byte[imageFile.Size]; await imageFile.OpenReadStream().ReadAsync(buffer); ImageDataUrl = $"data:{format};base64,{Convert.ToBase64String(buffer)}"; var request = new UpdateProfilePictureRequest() { ProfilePictureDataUrl = ImageDataUrl }; var result = await _accountManager.UpdateProfilePictureAsync(request, UserId); if (result.Succeeded) { _navigationManager.NavigateTo("/account", true); } else { foreach (var error in result.Messages) { _snackBar.Add(error, Severity.Success); } } } }
private async Task OnFileInputChanged(InputFileChangeEventArgs evt) { var file = evt.File; if (file is null) { _input.Contents = ReadOnlyMemory <byte> .Empty; _input.StatusMessage = "Please select a file to upload..."; } else if (file.Size > MAX_FILESIZE) { _input.Contents = ReadOnlyMemory <byte> .Empty; _input.StatusMessage = "File is too big..."; } else { await using var ms = new MemoryStream(); await file.OpenReadStream(MAX_FILESIZE).CopyToAsync(ms); _input.Contents = ms.ToArray(); if (_input.Contents.IsEmpty) { _input.StatusMessage = $"The file {file.Name} appears to be empty."; } else { _input.StatusMessage = $"Loaded {file.Size} bytes from {file.Name}"; } } }
protected async Task OnInputFileChange(InputFileChangeEventArgs e) { Model.Avatar = new Image(); var imagesDataUrls = await ImageUploadProcessor.GetDataUrlsFromUploadedImagesAsync(e); Model.Avatar.Path = imagesDataUrls.First(); }
private async Task LoadContract(InputFileChangeEventArgs e) { FileLoader = true; StateHasChanged(); FileName = e.File.Name; await using Stream fileStream = e.File.OpenReadStream(); await using var memoryStream = new MemoryStream(); await fileStream.CopyToAsync(memoryStream); JsDataUri = $"data:{e.File.ContentType};base64,{Convert.ToBase64String(memoryStream.ToArray())}"; try { ContractPackage = await JsRuntime.InvokeAsync <TonPackage>("getContactPackage", JsDataUri) .CatchJsExceptionAsync(ex => ToastService.ShowError(ex.Message)); } catch (JSException) { JsDataUri = null; StateHasChanged(); throw; } await Task.Delay(1000); FileLoader = false; ProgressCurrentStep++; }
public async Task OpenGraphItFile(InputFileChangeEventArgs e, bool overwrite) { Overwrite = overwrite; try { byte[] temp; Options newOptions = new Options(); using (var streamReader = new MemoryStream()) { await e.File.OpenReadStream().CopyToAsync(streamReader); temp = streamReader.ToArray(); } OpenPreference = false; string graph = DecodeAndInflate(temp); XmlDocument xmlData = new XmlDocument(); xmlData.LoadXml(graph); if (Overwrite) { Graph = new Graph(); } Traverse(xmlData, NodeService.NextId(Graph.Nodes), EdgeService.NextId(Graph.Edges)); await GraphChanged.InvokeAsync(Graph); if (Overwrite) { await OptionsChanged.InvokeAsync(Options); } } catch (ObjectDisposedException) { ErrorOpening = true; } }
async Task LoadFiles(InputFileChangeEventArgs e) { var isLoading = true; var exceptionMessage = string.Empty; try { foreach (var file in e.GetMultipleFiles(maxAllowedFiles)) { //using var reader = // new StreamReader(file.OpenReadStream()); using (var stream = new MemoryStream()) { await file.OpenReadStream().CopyToAsync(stream); stream.Position = 0; InputFiles.Add(stream.ToArray()); } //loadedFiles.Add(file, await reader.ReadToEndAsync()); } } catch (Exception ex) { exceptionMessage = ex.Message; } isLoading = false; }
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; } }
//Functions public async Task OninputFileChange(InputFileChangeEventArgs e) { var imagesFiles = e.GetMultipleFiles(); var format = "image/png"; selectedImage = imagesFiles; int i = addImageDTOs.Count; addImageDTOs = new List <AddImageDTO>(); foreach (var imageFile in imagesFiles) { var resizedImageFile = await imageFile.RequestImageFileAsync(format, 100, 100); var buffer = new byte[resizedImageFile.Size]; await resizedImageFile.OpenReadStream().ReadAsync(buffer); var imageDataUrl = $"data:{format};base64,{Convert.ToBase64String(buffer)}"; AddImageDTO dTO = new AddImageDTO { imageDataUrl = imageDataUrl, ProductImage = new ProductImage { ProductImagePosition = i, Name = imageFile.Name }, }; addImageDTOs.Add(dTO); i++; } }
private async Task OnInputFileChange(InputFileChangeEventArgs e) { IsLoading = true; this.ResponseMessage = $"Invoked: {e.FileCount} files"; this.FileName = e.File.Name; if (e.File != null) { int maxSizeInMB = (1024 * 1000) * 10; // 10MB var fileStream = e.File.OpenReadStream(maxAllowedSize: maxSizeInMB); MemoryStream memoryStream = new MemoryStream(); await fileStream.CopyToAsync(memoryStream); var imageBase64 = Convert.ToBase64String(memoryStream.ToArray()); this.ImageBase64 = imageBase64; StateHasChanged(); DescribeImageRequestModel model = new DescribeImageRequestModel() { ImageBase64 = imageBase64 }; string requestUrl = "api/AudibleComputerVision/DescribeImage"; var response = await Http.PostAsJsonAsync <DescribeImageRequestModel>(requestUrl, model); if (response.IsSuccessStatusCode) { this.AudioBase64 = await response.Content.ReadAsStringAsync(); StateHasChanged(); } this.ResponseMessage = await response.Content.ReadAsStringAsync(); } IsLoading = false; }
private async Task UploadFiles(InputFileChangeEventArgs e) { file = e.File; if (file != null) { var extension = Path.GetExtension(file.Name); var fileName = $"{UserId}-{Guid.NewGuid()}{extension}"; var format = "image/png"; var imageFile = await e.File.RequestImageFileAsync(format, 400, 400); var buffer = new byte[imageFile.Size]; await imageFile.OpenReadStream().ReadAsync(buffer); var request = new UpdateProfilePictureRequest() { Data = buffer, FileName = fileName, Extension = extension, UploadType = Application.Enums.UploadType.ProfilePicture }; var result = await _accountManager.UpdateProfilePictureAsync(request, UserId); if (result.Succeeded) { await _localStorage.SetItemAsync("userImageURL", result.Data); _navigationManager.NavigateTo("/account", true); } else { foreach (var error in result.Messages) { _snackBar.Add(localizer[error], Severity.Error); } } } }
public async Task SetCoverImage(InputFileChangeEventArgs e, ICoverImageable coverImageable) { if (coverImageable == null) { return; } var maxAllowedFiles = 1; var format = "image/png"; foreach (var imageFile in e.GetMultipleFiles(maxAllowedFiles)) { var resizedImageFile = await imageFile.RequestImageFileAsync(Format, 500, 500); var buffer = new byte[resizedImageFile.Size]; await resizedImageFile.OpenReadStream().ReadAsync(buffer); var imageDataUrl = $"data:{format};base64,{Convert.ToBase64String(buffer)}"; if (coverImageable.Blob == null) { coverImageable.Blob = new Blob(); } coverImageable.Blob.Data = imageDataUrl; } }
// Called when a new file is uploaded protected async Task OnChange(InputFileChangeEventArgs e) { using var stream = e.File.OpenReadStream(); using var ms = new MemoryStream(); await stream.CopyToAsync(ms); string content = System.Text.Encoding.UTF8.GetString(ms.ToArray()); var doc = new XmlDocument(); var args = new UploadEventArgs(); try { doc.LoadXml(content); } catch (XmlException) { args.Errors = "Invalid XML data found in uploaded SVG file."; await Upload.InvokeAsync(args); return; } // Search for the script StringWriter swScript = new(); foreach (XmlNode node in doc.DocumentElement.GetElementsByTagName("sc:script")) { if (node.ChildNodes.Count == 1 && node.ChildNodes[0] is XmlCDataSection cdata) { swScript.WriteLine(cdata.Data); } else { swScript.WriteLine(node.InnerText); } } // Search for the style StringWriter swStyle = new(); foreach (XmlNode node in doc.DocumentElement.GetElementsByTagName("style")) { swStyle.WriteLine(node.InnerText); } // Call the event args.Script = swScript.ToString(); args.Style = swStyle.ToString(); if (args.Script.Length == 0) { args.Errors = "No SimpleCircuit script metadata found in uploaded SVG file."; } else if (args.Style.Length == 0) { args.Warnings = "No styling information found in uploaded SVG file."; } await Upload.InvokeAsync(args); }
public void GetMultipleFiles_ThrowsIfTooManyFiles() { var files = new[] { new BrowserFile(), new BrowserFile() }; var instance = new InputFileChangeEventArgs(files); var ex = Assert.Throws <InvalidOperationException>(() => instance.GetMultipleFiles(1)); Assert.Equal($"The maximum number of files accepted is 1, but 2 were supplied.", ex.Message); }