public FileCallbackResult(string contentType, FileCallback callback) : base(contentType) { Guard.NotNull(callback, nameof(callback)); Callback = callback; }
public IActionResult GetImage(string app) { if (App.Image == null) { return(NotFound()); } var etag = App.Image.Etag; Response.Headers[HeaderNames.ETag] = etag; var callback = new FileCallback(async(body, range, ct) => { var resizedAsset = $"{App.Id}_{etag}_Resized"; try { await assetStore.DownloadAsync(resizedAsset, body, ct: ct); } catch (AssetNotFoundException) { await ResizeAsync(resizedAsset, App.Image.MimeType, body, ct); } }); return(new FileCallbackResult(App.Image.MimeType, callback) { ErrorAs404 = true }); }
public IActionResult GetImage(string app) { if (App.Image == null) { return(NotFound()); } var etag = App.Image.Etag; Response.Headers[HeaderNames.ETag] = etag; var callback = new FileCallback(async(body, range, ct) => { var resizedAsset = $"{App.Id}_{etag}_Resized"; try { await assetStore.DownloadAsync(resizedAsset, body, ct: ct); } catch (AssetNotFoundException) { using (Profiler.Trace("Resize")) { using (var sourceStream = GetTempStream()) { using (var destinationStream = GetTempStream()) { using (Profiler.Trace("ResizeDownload")) { await appImageStore.DownloadAsync(App.Id, sourceStream); sourceStream.Position = 0; } using (Profiler.Trace("ResizeImage")) { await assetThumbnailGenerator.CreateThumbnailAsync(sourceStream, destinationStream, ResizeOptions); destinationStream.Position = 0; } using (Profiler.Trace("ResizeUpload")) { await assetStore.UploadAsync(resizedAsset, destinationStream); destinationStream.Position = 0; } await destinationStream.CopyToAsync(body, ct); } } } } }); return(new FileCallbackResult(App.Image.MimeType, callback) { ErrorAs404 = true }); }
/// <summary> /// Scans the directory and all subdirectories, running the callback for each found file. /// </summary> /// <param name="basePath">Base directory to scan for matching files.</param> /// <param name="extensions">Array of extension names to match. Do not include dots.</param> /// <param name="callback">Callback for each found file.</param> static void ScanDirectories(string basePath, string[] extensions, FileCallback callback) { foreach (var file in Directory.EnumerateFiles(basePath, "*", SearchOption.AllDirectories)) { FileInfo fi = new FileInfo(file); if (extensions.Contains(fi.Extension.ToLower())) { callback(fi); } } }
public void Initialize(DirectoryInfo starting_directory, ValidateFile validation_method, FileCallback fileCallback, DirectoryCallback directoryCallback) { NGUITools.SetActive(gameObject, true); SelectedFileText.text = ""; dragPanel.ResetPosition(); validate_method = validation_method; current_directory = starting_directory; callback_function = fileCallback; directory_callback = directoryCallback; directory_label.text = starting_directory.Name; LoadData(); }
public IActionResult GetLogFile(string token) { var appId = DomainId.Create(dataProtector.Unprotect(token)); var today = DateTime.UtcNow.Date; var fileName = $"Usage-{today:yyy-MM-dd}.csv"; var callback = new FileCallback((body, range, ct) => { return(appLogStore.ReadLogAsync(appId, today.AddDays(-30), today, body, ct)); }); return(new FileCallbackResult("text/csv", callback) { FileDownloadName = fileName }); }
/// <summary> /// Scans the directory and all subdirectories, running the callback for each found file. /// </summary> /// <param name="basePath">Base directory to scan for matching files.</param> /// <param name="extensions">Array of extension names to match. Do not include dots.</param> /// <param name="callback">Callback for each found file.</param> private static void ScanDirectories(string basePath, string[] extensions, FileCallback callback) { foreach (var file in Directory.EnumerateFiles(basePath, "*", SearchOption.AllDirectories)) { FileInfo fi = new FileInfo(file); string extension = fi.Extension.ToLowerInvariant(); if (extension.StartsWith(".")) { extension = extension.Substring(1); } if (extensions.Contains(extension)) { callback(fi); } } }
public async Task <IActionResult> GetBackupContent(string app, string id) { var backup = await backupservice.GetBackupAsync(AppId, id); if (backup == null || backup.Status != JobStatus.Completed) { return(NotFound()); } var fileName = $"backup-{app}-{backup.Started:yyyy-MM-dd_HH-mm-ss}.zip"; var callback = new FileCallback((body, range, ct) => { return(backupArchiveStore.DownloadAsync(id, body, ct)); }); return(new FileCallbackResult("application/zip", callback) { FileDownloadName = fileName }); }
public bool BeginGetFileDetails(string path, FileCallback callback) { path = PathUtil.CleanPath(path); var file = GetFile(path); if (file != null) { callback(file); return(true); } // If file is local and wasn't found, throw error. var parts = path.Split('/'); if (parts.Length > 1 && parts[1] == "local") { throw new Exception("File does not exist"); } // If remote file, request it! lock (remoteFileCallbacks) { if (!remoteFileCallbacks.ContainsKey(path)) { remoteFileCallbacks.Add(path, new List <FileCallback>()); } var list = remoteFileCallbacks[path]; list.Add(callback); } var network = PathUtil.GetNetwork(core, path); network.RequestFileDetails(path); return(false); }
public void File(FileCallback successCallback, FileErrorCallback errorCallback) { }
private async Task <IActionResult> DeliverAssetAsync(IAssetEntity?asset, AssetContentQueryDto query) { query ??= new AssetContentQueryDto(); if (asset == null) { return(NotFound()); } if (asset.IsProtected && !Resources.CanReadEvents) { return(StatusCode(403)); } if (query.Version > EtagVersion.Any && asset.Version != query.Version) { asset = await assetLoader.GetAsync(asset.Id, query.Version); } var resizeOptions = query.ToResizeOptions(asset); FileCallback callback; Response.Headers[HeaderNames.ETag] = asset.FileVersion.ToString(); if (query.CacheDuration > 0) { Response.Headers[HeaderNames.CacheControl] = $"public,max-age={query.CacheDuration}"; } var contentLength = (long?)null; if (asset.Type == AssetType.Image && resizeOptions.IsValid) { callback = new FileCallback(async(bodyStream, range, ct) => { var resizedAsset = $"{asset.Id}_{asset.FileVersion}_{resizeOptions}"; if (query.ForceResize) { await ResizeAsync(asset, bodyStream, resizedAsset, resizeOptions, true, ct); } else { try { await assetStore.DownloadAsync(resizedAsset, bodyStream); } catch (AssetNotFoundException) { await ResizeAsync(asset, bodyStream, resizedAsset, resizeOptions, false, ct); } } }); } else { contentLength = asset.FileSize; callback = new FileCallback(async(bodyStream, range, ct) => { await assetFileStore.DownloadAsync(asset.Id, asset.FileVersion, bodyStream, range, ct); }); } return(new FileCallbackResult(asset.MimeType, callback) { EnableRangeProcessing = contentLength > 0, ErrorAs404 = true, FileDownloadName = asset.FileName, FileSize = contentLength, LastModified = asset.LastModified.ToDateTimeOffset(), SendInline = query.Download != 1 }); }
public void file(FileCallback successCallback, ErrorCallback errorCallback) {}
public void BrowseForFile(DirectoryInfo starting_directory, FileCallback fileCallback) { Initialize(starting_directory, ValidateEverything, fileCallback, null); SetErrorText("Could Not Open File"); }
public void file(FileCallback successCallback) {}
// Upload File to Firebase Storage public IEnumerator UploadToFirebaseStorage(byte[] data, string fileName, string folder, FileCallback Callback) { StorageReference images = storage_ref.Child(folder); #if UNITY_5_0 || UNITY_5_1 || UNITY_5_2 || UNITY_5_3 || UNITY_5_4 var task = reference.PutBytesAsync(Encoding.UTF8.GetBytes(data), null, null, default(System.Threading.CancellationToken), null); #else var task = images.Child(fileName).PutBytesAsync(data); #endif yield return(new WaitUntil(() => task.IsCompleted)); if (task.IsFaulted) { Callback(null, "Error Uploading Enemy Image"); DebugLog(task.Exception.ToString()); throw task.Exception; } else { Callback(task.Result.DownloadUrl.ToString(), "Enemy Image Uploaded Succesfully"); DebugLog("Finished uploading... Download Url: " + task.Result.DownloadUrl.ToString()); } }
public void File(FileCallback successCallback) { }
public TorrentParser(string path, FileCallback readNotify) { _rCallback = readNotify; Process(path); }
static void Main(string[] args) { if (args.Length < 2 || args.Length > 3) { WaitAndClose("Improper usage. Expected:" + "\nSpawnableItemFetcher.exe <asset_path> <output_file>" + "\n<asset_path>: Absolute path to unpacked assets." + "\n<output_file>: Absolute path to file to write results to." + "\nOutput file should be /yourMod/sipCustomItems.json.patch"); } basePath = args[0]; string outputFile = args[1]; if (args.Length > 2) { resultType = ResultType.Normal; } if (basePath.LastIndexOf("\\") == basePath.Length - 1) { basePath = basePath.Substring(0, basePath.Length - 1); } // Confirm asset path if (!Directory.Exists(basePath)) { WaitAndClose("Asset directory '" + basePath + "' not found. Invalid directory given."); } // Confirm overwriting if (File.Exists(outputFile)) { Console.WriteLine("Output file '" + outputFile + "' already exists!\n1. Overwrite file\n2. Cancel"); ConsoleKeyInfo cki = Console.ReadKey(true); switch (cki.Key) { default: WaitAndClose("Cancelling task."); break; case ConsoleKey.D1: case ConsoleKey.NumPad1: Console.WriteLine("Output file will be overwritten."); break; } } result = new JArray(); FileCallback fc = new FileCallback(AddItem); // Scan all folders and subfolders. Adds all found items to result. ScanDirectories(basePath, extensions, fc); // Write results to selected file. Newtonsoft.Json.Formatting format = resultType == ResultType.Patch ? Newtonsoft.Json.Formatting.Indented : Newtonsoft.Json.Formatting.None; File.WriteAllText(outputFile, result.ToString(format)); Console.WriteLine("Done fetching items!\nPress any key to exit..."); Console.ReadKey(); }
static void Main(string[] args) { WriteColoredLine(ConsoleColor.White, "= Spawnable Item Fetcher"); if (args.Length == 0) { args = PromptArgs(); } if (args.Length != 2) { WaitAndClose("Improper usage. Expected:" + "\nSpawnableItemFetcher.exe <asset_path> <output_file>" + "\n<asset_path>: Absolute path to unpacked assets." + "\n<output_file>: Absolute path to file to write results to."); } basePath = args[0]; string outputFile = args[1]; if (basePath.LastIndexOf("\\") == basePath.Length - 1) { basePath = basePath.Substring(0, basePath.Length - 1); } // Show paths Console.Write("Asset Path: "); WriteColoredLine(ConsoleColor.Cyan, basePath); Console.Write("Output File: "); WriteColoredLine(ConsoleColor.Cyan, outputFile); Console.WriteLine(); // Confirm asset path if (!Directory.Exists(basePath)) { WaitAndClose("Asset directory '" + basePath + "' not found."); } // Confirm overwriting if (File.Exists(outputFile)) { Console.WriteLine("Overwrite existing output file?"); Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("[1] Overwrite file. [2] Cancel."); Console.ResetColor(); ConsoleKeyInfo cki = Console.ReadKey(true); switch (cki.Key) { default: WaitAndClose("Cancelled."); break; case ConsoleKey.D1: case ConsoleKey.NumPad1: Console.WriteLine("The file will be overwritten."); break; } Console.WriteLine(); } // Get result type. resultType = PromptResultType(); if (resultType == ResultType.Patch && !outputFile.EndsWith(".patch")) { Console.WriteLine("You're trying to make a patch file, but the output file does not end with '.patch'!"); } Console.WriteLine(); // Start scan Console.WriteLine("Starting to scan assets. This can take a while..."); result = new JArray(); FileCallback fc = new FileCallback(AddItem); // Scan all folders and subfolders. Adds all found items to result. ScanDirectories(basePath, extensions, fc); // Write results to selected file. Newtonsoft.Json.Formatting format = Newtonsoft.Json.Formatting.None; Directory.CreateDirectory(Path.GetDirectoryName(outputFile)); File.WriteAllText(outputFile, result.ToString(format)); WaitAndClose("Done fetching items!"); }
public TorrentParser(string TPath, FileCallback ReadNotify) { _rCallback = ReadNotify; Process(TPath); }
public void BrowseForImage(DirectoryInfo starting_directory, FileCallback fileCallback) { Initialize(starting_directory, ValidateImage, fileCallback, null); SetErrorText("Invalid Image File"); }
public void file(FileCallback successCallback, ErrorCallback errorCallback) { }