public async override Task BuildIndexAsync(MediaField field, BuildFieldIndexContext context) { var options = context.Settings.ToOptions(); var settings = context.ContentPartFieldDefinition.GetSettings <MediaFieldSettings>(); if (field.Paths?.Length > 0) { if (settings.AllowMediaText) { foreach (var key in context.Keys) { if (field.MediaTexts != null) { foreach (var mediaText in field.MediaTexts) { context.DocumentIndex.Set(key + MediaTextKeySuffix, mediaText, options); } } else { context.DocumentIndex.Set(key + MediaTextKeySuffix, "NULL", options); } } } // It doesn't really makes sense to store file contents without analyzing them for search as well. var fileIndexingOptions = options | DocumentIndexOptions.Analyze; foreach (var path in field.Paths) { var providerType = _mediaFileIndexingOptions.GetRegisteredMediaFileTextProvider(Path.GetExtension(path)); if (providerType != null) { using var fileStream = await _mediaFileStore.GetFileStreamAsync(path); if (fileStream != null) { var fileText = await _serviceProvider .CreateInstance <IMediaFileTextProvider>(providerType) .GetTextAsync(path, fileStream); foreach (var key in context.Keys) { context.DocumentIndex.Set(key + FileTextKeySuffix, fileText, fileIndexingOptions); } } } } } else { foreach (var key in context.Keys) { context.DocumentIndex.Set(key + MediaTextKeySuffix, "NULL", options); context.DocumentIndex.Set(key + FileTextKeySuffix, "NULL", options); } } }
private async Task <string> GetFileHashAsync(string filePath) { using (var fs = await _fileStore.GetFileStreamAsync(filePath)) using (HashAlgorithm hashAlgorithm = MD5.Create()) { var hash = hashAlgorithm.ComputeHash(fs); return(ByteArrayToHexString(hash)); } }
public async Task ProcessDeploymentStepAsync(DeploymentStep step, DeploymentPlanResult result) { if (!(step is MediaDeploymentStep mediaStep)) { return; } List <string> paths; if (mediaStep.IncludeAll) { var fileStoreEntries = await _mediaFileStore.GetDirectoryContentAsync(null, true); paths = ( from fileStoreEntry in fileStoreEntries where !fileStoreEntry.IsDirectory select fileStoreEntry.Path ).ToList(); } else { paths = new List <string>(mediaStep.FilePaths ?? Array.Empty <string>()); foreach (var directoryPath in mediaStep.DirectoryPaths ?? Array.Empty <string>()) { var fileStoreEntries = await _mediaFileStore.GetDirectoryContentAsync(directoryPath, true); paths.AddRange( from fileStoreEntry in fileStoreEntries where !fileStoreEntry.IsDirectory select fileStoreEntry.Path); } paths.Sort(); } foreach (var path in paths) { var stream = await _mediaFileStore.GetFileStreamAsync(path); await result.FileBuilder.SetFileAsync(path, stream); } // Adding media files result.Steps.Add(new JObject( new JProperty("name", "media"), new JProperty("Files", JArray.FromObject( (from path in paths select new { SourcePath = path, TargetPath = path }).ToArray() )) )); }
public async Task <string> ReadFile() { var fileInfo = await _mediaFileStore.GetFileInfoAsync("Demo.txt"); if (fileInfo == null) { return("Not found :("); } using var stream = await _mediaFileStore.GetFileStreamAsync("Demo.txt"); using var streamReader = new StreamReader(stream); var content = await streamReader.ReadToEndAsync(); return($"File info: size: {fileInfo.Length}, last modification UTC: {fileInfo.LastModifiedUtc}. Content: {content}"); }
// If you've created the file just go to the Dashboard and check if you can see it under Assets. You can also // find it in the App_Data/Sites/{TenantName}/Media/TrainingDemo folder. // This action will read the file you've created earlier. public async Task <string> ReadFileFromMediaFolder() { // This way you can check if the given file exists. if (await _mediaFileStore.GetFileInfoAsync(TestFileRelativePath) == null) { return("Create the file first!"); } // If you want to extract the content of the file use a StreamReader to read the stream. using (var stream = await _mediaFileStore.GetFileStreamAsync(TestFileRelativePath)) using (var streamReader = new StreamReader(stream)) { var content = streamReader.ReadToEnd(); return($"File content: {content}"); } }
public async Task <IActionResult> AppleTouchIcon() { var settings = await GetSettings(); if (settings == null || !settings.HasAppleTouchIcon) { return(NotFound()); } _contentTypeProvider.TryGetContentType(settings.AppleTouchIconPath, out var contentType); return(File(await _mediaFileStore.GetFileStreamAsync(settings.FaviconPath), contentType ?? DefaultMimeTypes.AppleTouchIcon)); }
public async Task <IContent> ImportMediaAsync(string path, string mimeType, string contentType) { var file = await _mediaFileStore.GetFileInfoAsync(path); if (file == null) { return(null); } using (var stream = await _mediaFileStore.GetFileStreamAsync(path)) { var mediaFactory = GetMediaFactory(stream, file.Name, mimeType, contentType); if (mediaFactory == null) { return(null); } return(mediaFactory.CreateMedia(stream, file.Path, mimeType, file.Length, contentType)); } }
/// <inheritdoc/> public async Task <IByteBuffer> ResolveImageAsync(HttpContext context, ILogger logger) { // Path has already been correctly parsed before here. var filePath = _mediaStore.MapPublicUrlToPath(context.Request.PathBase + context.Request.Path.Value); var file = await _mediaStore.GetFileInfoAsync(filePath); // Check to see if the file exists. if (file == null) { return(null); } IByteBuffer buffer; using (var stream = await _mediaStore.GetFileStreamAsync(filePath)) { // Buffer is returned to the pool in the middleware buffer = this.bufferManager.Allocate((int)stream.Length); await stream.ReadAsync(buffer.Array, 0, buffer.Length); } return(buffer); }
/// <inheritdoc/> public async Task <byte[]> ResolveImageAsync(HttpContext context, ILogger logger) { // Path has already been correctly parsed before here. var filePath = _mediaStore.MapPublicUrlToPath(context.Request.Path); var file = await _mediaStore.GetFileInfoAsync(filePath); // Check to see if the file exists. if (file == null) { return(null); } byte[] buffer; using (var stream = await _mediaStore.GetFileStreamAsync(filePath)) { // Buffer is returned to the pool in the middleware buffer = BufferDataPool.Rent((int)stream.Length); await stream.ReadAsync(buffer, 0, (int)stream.Length); } return(buffer); }
public async Task <IActionResult> GetUserProfilePhotoSmall(string id) { var user = await _userManager.FindByNameAsync(id) as User; if (user != null) { // byte[] file = null; var userProfileMetadata = user.As <UserMetadata>(); if (userProfileMetadata != null) { var urlProfileImageUrl = userProfileMetadata.Avatar; if (_mediaFileStore == null) { return(Content(urlProfileImageUrl)); } // This way you can check if the given file exists. if (await _mediaFileStore.GetFileInfoAsync(urlProfileImageUrl) != null) { await using (var stream = await _mediaFileStore.GetFileStreamAsync(urlProfileImageUrl)) { // var resolvedAssetPath = mediaFileStore.MapPathToPublicUrl(urlProfileImageUrl); using (var image = SixLabors.ImageSharp.Image.Load(stream)) { // Resize the image in place and return it for chaining. // 'x' signifies the current image processing context. image.Mutate(x => x.Resize(50, 50)); await using (var ms = new MemoryStream()) { image.Save(ms, new PngEncoder()); return(File(ms.ToArray(), MediaTypeNames.Application.Octet, true)); } // The library automatically picks an encoder based on the file extensions then encodes and write the data to disk. // return File(image.ToByteArray(), MediaTypeNames.Application.Octet, true); } } // If you want to extract the content of the file use a StreamReader to read the stream. /*using (var stream = await mediaFileStore.GetFileStreamAsync(urlProfileImageUrl)) * * { * * file = new byte[stream.Length]; * int numBytesToRead = (int) stream.Length; * int numBytesRead = 0; * while (numBytesToRead > 0) * { * int n = stream.Read(file, numBytesRead, numBytesToRead); * if (n == 0) * { * break; * } * * numBytesRead += n; * numBytesToRead -= n; * } * * } * return File(file, MediaTypeNames.Application.Octet, true);*/ } // return Content( _orchardHelper.ImageResizeUrl(resolvedAssetPath, 40, 40,ResizeMode.Crop)); // var fileVersionProvider = _orchardHelper.HttpContext.RequestServices.GetService<IFileVersionProvider>(); // resizedUrl = fileVersionProvider.AddFileVersionToPath(orchardHelper.HttpContext.Request.PathBase, resizedUrl); } } // var file = user.Avatar; // if (file != null) /*using (var image = new MagickImage(file)) * { * image.Resize(40, 40); * * return File(image.ToByteArray(), MediaTypeNames.Application.Octet, true); * }*/ return(NoContent()); }
/// <summary> /// Processes a request to determine if it matches a known file from the media file store, and cache it locally. /// </summary> /// <param name="context"></param> public async Task Invoke(HttpContext context) { // Support only Head requests or Get Requests. if (!HttpMethods.IsGet(context.Request.Method) && !HttpMethods.IsHead(context.Request.Method)) { await _next(context); return; } var validatePath = context.Request.Path.StartsWithNormalizedSegments(_assetsRequestPath, StringComparison.OrdinalIgnoreCase, out var subPath); if (!validatePath) { _logger.LogDebug("Request path {Path} does not match the assets request path {RequestPath}", subPath, _assetsRequestPath); await _next(context); return; } // subpath.Value returns an unescaped path value, subPath returns an escaped path value. var subPathValue = subPath.Value; var isFileCached = await _mediaFileStoreCache.IsCachedAsync(subPathValue); if (isFileCached) { // When multiple requests occur for the same file the download // may already be in progress so we wait for it to complete. if (Workers.TryGetValue(subPathValue, out var writeTask)) { await writeTask.Value; } await _next(context); return; } // When multiple requests occur for the same file we use a Lazy<Task> // to initialize the file store request once. await Workers.GetOrAdd(subPathValue, x => new Lazy <Task>(async() => { try { var fileStoreEntry = await _mediaFileStore.GetFileInfoAsync(subPathValue); if (fileStoreEntry != null) { using (var stream = await _mediaFileStore.GetFileStreamAsync(fileStoreEntry)) { await _mediaFileStoreCache.SetCacheAsync(stream, fileStoreEntry, context.RequestAborted); } } } catch (Exception ex) { // Log the error, and pass to pipeline to handle as 404. // Multiple requests at the same time will all recieve the same 404 // as we use LazyThreadSafetyMode.ExecutionAndPublication. _logger.LogError(ex, "Error retrieving file from media file store for request path {Path}", subPathValue); } finally { Workers.TryRemove(subPathValue, out var writeTask); } }, LazyThreadSafetyMode.ExecutionAndPublication)).Value; // Always call next, this middleware always passes. await _next(context); return; }