static bool IsImage(string extension) => AcceptedMimeTypesImage.Contains(MimeTypeMap.GetMimeType(extension));
//public static void ShowOkAlert(Context context,string Message) //{ // AlertDialog.Builder alert = new AlertDialog.Builder(context); // alert.SetMessage(Message); // alert.SetPositiveButton("Ok", (senderAlert, args) => { // }); // Dialog dialog = alert.Create(); // dialog.Show(); //} //Download from url------------------------------------------ public static async void DownLoadSource(string url, Java.IO.File _appDirectory, Java.IO.File newFile, string filePath, Context context, string FileName, int notificationId) { // ShowToast(context, context.Resources.GetString(Resource.String.downloading) + Newsrc); var NotificationId = notificationId; string localPath; try { System.Uri uri = new System.Uri(url); WebClient webClient = new WebClient(); string localFileName; webClient.DownloadDataAsync(uri); Log.Debug("tag", "File to download = " + newFile.ToString()); MimeTypeMap mime = MimeTypeMap.Singleton; String ext = newFile.Name.Substring(newFile.Name.IndexOf(".") + 1); String type = mime.GetMimeTypeFromExtension(ext); Intent openFile = new Intent(Intent.ActionView, Android.Net.Uri.FromFile(newFile)); openFile.SetDataAndType(Android.Net.Uri.FromFile(newFile), type); openFile.AddFlags(ActivityFlags.ClearTop | ActivityFlags.SingleTop | ActivityFlags.NewTask); PendingIntent p = PendingIntent.GetActivity(context, 0, openFile, 0); var notification = new Android.Support.V4.App.NotificationCompat.Builder(context) .SetSmallIcon(Android.Resource.Drawable.StatNotifySync) .SetContentTitle(FileName) .SetContentText(" Downloading") .SetOngoing(false); notification.SetProgress(0, 0, true); NotificationManager notificationmanager = (NotificationManager)Android.App.Application.Context.GetSystemService(Service.NotificationService); // Build Notification with Notification Manager notificationmanager.Notify((int)NotificationId, notification.Build()); webClient.DownloadDataCompleted += (s, e) => { try { if (!_appDirectory.Exists()) { _appDirectory.Mkdirs(); } var bytes = e.Result; // get the downloaded data { notification.SetContentText(" Downloaded"); notification.SetContentTitle(FileName); notification.SetContentIntent(p); notification.SetProgress(0, 0, false); notification.SetAutoCancel(true);// Notification.Flags = NotificationFlags.AutoCancel; //System.IO.File.WriteAllBytes(filePath, bytes); notificationmanager.Notify((int)NotificationId, notification.Build()); // writes to local storage } } catch (Exception ex) { } }; } catch (System.Exception ex) { } }
/// <summary> /// This is a method that responds to the customer according to the event received. /// </summary> /// <param name="requestEvent">HttpRequestEventArgs: Request event.</param> /// <returns>HttpOutputStream: Event respond of the argument received.</returns> public HttpOutputStream GetRespond(HttpRequestEventArgs requestEvent) { ActionRequest = new Dictionary <string, object>(); Site site; /// Array of the URL path received. string[] UrlSplited = requestEvent.Request.Path.Replace("favicon.ico", string.Empty).Split('/'); string SiteName = UrlSplited[1]; // show state in the console. Console.WriteLine("Client: {0} makes request => {1}", SiteName, requestEvent.Request.Path); // Do it if the site not exist. if (!Exist(SiteName)) { requestEvent.Response.ContentType = MimeTypeMap .GetMimeType(Path.GetExtension(configurationManager.errorPages["404"])); requestEvent.Response.Status = "404"; data = File.ReadAllBytes(configurationManager.errorPages["404"]); } // else: execute method of one of the apps loaded. else { string URLPath = requestEvent.Request.Path.Replace("/", "").ToLower(); if (URLPath.Equals(SiteName.ToLower())) { site = configurationManager.GetSiteByVirtualPath(SiteName); if (string.IsNullOrEmpty(site.defaultDocument["index"])) { requestEvent.Response.ContentType = MimeTypeMap.GetMimeType(Path.GetExtension(configurationManager.defaultDocument["index"])); requestEvent.Response.Status = "200"; data = File.ReadAllBytes(configurationManager.defaultDocument["index"]); } else { requestEvent.Response.ContentType = MimeTypeMap.GetMimeType(Path.GetExtension(site.defaultDocument["index"])); requestEvent.Response.Status = "200"; data = File.ReadAllBytes(site.defaultDocument["index"]); } } else { ActionRequest.Add("URLPath", requestEvent.Request.Path.Replace("/" + SiteName, "").ToLower()); ActionRequest.Add("HttpMethod", requestEvent.Request.HttpMethod); ActionRequest.Add("Params", requestEvent.Request.Form); ActionRequest.Add("Header", requestEvent.Request.Headers); ActionRequest.Add("QueryParams", requestEvent.Request.Params); Dictionary <string, HttpFile> files = new Dictionary <string, HttpFile>(); for (int i = 0; i < requestEvent.Request.Files.Count; i++) { HttpPostedFile file = requestEvent.Request.Files.Get(i); HttpFile httpFile = new HttpFile(file.ContentLength, file.ContentType, file.FileName, file.InputStream); files.Add(requestEvent.Request.Files.GetKey(i), httpFile); } ActionRequest.Add("Files", files); foreach (IPHttpApplication Application in AllApps.Result) { Site AppSite = (Site)Application.GetSite(); if (AppSite.virtualPath.ToLower() == SiteName.ToLower()) { var response = Application.ExecuteAction(ActionRequest); requestEvent.Response.Status = ((ActionResult)response).GetStatusCode(); requestEvent.Response.ContentType = ((ActionResult)response).GetContentType(); try { stream = (MemoryStream)((ActionResult)response).GetRespond(); return(new HttpOutputStream(stream)); } catch (Exception ex) { requestEvent.Response.ContentType = MimeTypeMap.GetMimeType(Path.GetExtension(configurationManager.errorPages["404"])); requestEvent.Response.Status = "404"; data = File.ReadAllBytes(configurationManager.errorPages["404"]); } } } } /// TODO:hacer que se actualize site en el js despues que el user cree algun view. } stream = new MemoryStream(data); return(new HttpOutputStream(stream)); }
public string GetMimeType(string fileName) { var extension = _rgx.Match(fileName).Value; return(MimeTypeMap.GetMimeType(extension)); }
public Intent SaveAndView(string fileName, string contentType, MemoryStream stream, PDFOpenContext context, Context appctx) { string exception = string.Empty; string root = null; if (Android.OS.Environment.IsExternalStorageEmulated) { root = Android.OS.Environment.ExternalStorageDirectory.ToString(); } else { root = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments); } Java.IO.File myDir = new Java.IO.File(root + "/PDFFiles"); myDir.Mkdir(); Java.IO.File file = new Java.IO.File(myDir, fileName); if (file.Exists()) { file.Delete(); } try { FileOutputStream outs = new FileOutputStream(file); outs.Write(stream.ToArray()); outs.Flush(); outs.Close(); } catch (Exception e) { exception = e.ToString(); return(null); } if (file.Exists() && contentType != "application/html") { string extension = MimeTypeMap.GetFileExtensionFromUrl(Android.Net.Uri.FromFile(file).ToString()); string mimeType = MimeTypeMap.Singleton.GetMimeTypeFromExtension(extension); Intent intent = new Intent(Intent.ActionView); intent.SetFlags(ActivityFlags.ClearTop | ActivityFlags.NewTask); Android.Net.Uri path = FileProvider.GetUriForFile(appctx, Android.App.Application.Context.PackageName + ".fileprovider", file); intent.SetDataAndType(path, mimeType); intent.AddFlags(ActivityFlags.GrantReadUriPermission); return(intent); //switch (context) //{ // case PDFOpenContext.InApp: // appctx.StartActivity(intent); // break; // case PDFOpenContext.ChooseApp: // appctx.StartActivity(Intent.CreateChooser(intent, "Choose App")); // break; // default: // break; //} } else { return(null); } }
public async void SearchForHigherResolutionOnlineAsync() { // Don't scan for videos. if (MediaData is VideoData) { return; } var onlineMedias = new Dictionary <Uri, (Size, long)>(); // Get file size and dimensions of every fully matched image. foreach (var webImage in FullyMatchedImages) { // Parse URL. if (Uri.TryCreate(webImage.Url, UriKind.Absolute, out var uri)) { // Check to make sure this URL points to a file and not a webpage. if (Path.HasExtension(uri.AbsoluteUri)) { // Get MIME type of online file. var mimeType = MimeTypeMap.GetMimeType(Path.GetExtension(uri.AbsoluteUri)); // Check if MIME type of online file is supported. if (FileTypes.IsSupportedMIME(mimeType)) { try { // Get dimensions of online image. var dimensions = await ImageUtilities.GetWebDimensionsAsync(uri); // If dimensions is empty, continue. if (dimensions.IsEmpty) { continue; } // Get file size of online image. var contentLength = await OnlineUtil.GetContentSizeAsync(uri); // Add to dictionary. onlineMedias.Add(uri, (dimensions, contentLength)); } catch (Exception e) { // Log Exception. LifecycleLog.Exception(e); } } } } } // If these are null then no comparisons can be made. if (MediaData?.Meta == null) { return; } if (MediaData?.BasicProperties == null) { return; } // Check if any of the fully matched images are higher resolution or larger than local file. var largerMedia = new KeyValuePair <Uri, (Size, long)>(); foreach (var urlAndData in onlineMedias) { var url = urlAndData.Key; var(dimensions, contentLength) = urlAndData.Value; // If online media is larger in file size than local media. if (contentLength > (long)MediaData.BasicProperties.Size) { // If size of this online media is larger than the currently largest media. if (Math.Max(largerMedia.Value.Item2, contentLength) == contentLength) { largerMedia = urlAndData; // Update largerMedia. } } else if (dimensions.Height > MediaData.Meta.Height && // If online media is larger in both width and height dimensions.Width > MediaData.Meta.Width) // than the local media. { // If dimensions of this online media is larger than the currently largest media. if (Math.Max(largerMedia.Value.Item1.Height, dimensions.Height) == dimensions.Height && Math.Max(largerMedia.Value.Item1.Width, dimensions.Width) == dimensions.Width) { largerMedia = urlAndData; // Update largerMedia. } } } // If no larger media has been found, return. if (largerMedia.Key == null) { return; } // Set property. LargerMedia = largerMedia.Key; }
private static string GetMimeType(string ext) { return(string.IsNullOrEmpty(ext) ? "text/html" : MimeTypeMap.GetMimeType(ext)); }
/// <summary> /// Uploads the BLOB. /// </summary> /// <param name="containerName">Name of the container.</param> /// <param name="fileName">Name of the file.</param> /// <param name="connectionString">The connection string.</param> /// <param name="stream">The stream.</param> /// <returns></returns> public async Task <Uri> UploadBlob(Guid containerName, Guid fileName, string connectionString, Stream stream) { string filePath = SaveFile(fileName.ToString(), stream); if (!string.IsNullOrEmpty(filePath)) { // Get the file byte[] fileInfo = LoadFile(fileName.ToString("D")); if (fileInfo.Length > 0) { string newFileName = fileName.ToString("D"); // Get the container CloudBlobContainer container = await GetContainer(containerName, connectionString).ConfigureAwait(false); CloudBlockBlob blob = container.GetBlockBlobReference(newFileName); BlobRequestOptions options = new BlobRequestOptions { ServerTimeout = new TimeSpan(12, 0, 0) }; try { using (Stream fileStream = new MemoryStream(fileInfo)) { // If file is larger than 4MB, split file into 250kb chunks and upload int maxSize = 1 * 1024 * 1024; // 4 MB if (fileStream.Length > maxSize) { byte[] data = ReadToEnd(fileStream); int id = 0; int byteslength = data.Length; int bytesread; int index = 0; List <string> blocklist = new List <string>(); const int numBytesPerChunk = 250 * 1024; do { byte[] buffer = new byte[numBytesPerChunk]; int limit = index + numBytesPerChunk; for (int loops = 0; index < limit; index++) { buffer[loops] = data[index]; loops++; } bytesread = index; string blockIdBase64 = Convert.ToBase64String(BitConverter.GetBytes(id)); await blob.PutBlockAsync(blockIdBase64, new MemoryStream(buffer, true), null).ConfigureAwait(false); blocklist.Add(blockIdBase64); id++; }while (byteslength - bytesread > numBytesPerChunk); int final = byteslength - bytesread; byte[] finalbuffer = new byte[final]; for (int loops = 0; index < byteslength; index++) { finalbuffer[loops] = data[index]; loops++; } string blockId = Convert.ToBase64String(BitConverter.GetBytes(id)); await blob.PutBlockAsync(blockId, new MemoryStream(finalbuffer, true), null).ConfigureAwait(false); blocklist.Add(blockId); await blob.PutBlockListAsync(blocklist, null, options, null).ConfigureAwait(false); } else { await blob.UploadFromStreamAsync(fileStream).ConfigureAwait(false); } } } catch (Exception ex) { if (ex is ArgumentException || ex is UnauthorizedAccessException || ex is FileNotFoundException || ex is NotSupportedException || ex is StorageException) { return(default(Uri)); } throw; } // Update the mime type await blob.FetchAttributesAsync().ConfigureAwait(false); string type = null; var extension = MimeTypeMap.GetFileExtensionFromUrl(fileName.ToString().ToLower()); if (extension != null) { blob.Properties.ContentType = MimeTypeMap.Singleton.GetMimeTypeFromExtension(extension); await blob.SetPropertiesAsync().ConfigureAwait(false); // Success! return(GenerateUrl(containerName, fileName, connectionString)); } } } return(default(Uri)); }
void UnZipAndProcess(string filename) { if (!File.Exists(filename)) { throw new OpException(ErrMsg.FormatString(ErrMsg.ID.CMD_INVALID_FILE_OR_DIR, filename)); } //zip itself may be too huge for timely processing if (new FileInfo(filename).Length > MAX_ZIP_FILE_SIZE) { throw new OpException(ErrMsg.FormatString(ErrMsg.ID.ANALYZE_FILESIZE_HALT, filename)); } // Ignore images and other junk like that var fileExtension = new FileInfo(filename).Extension; var mimeType = MimeTypeMap.GetMimeType(fileExtension); bool mimeMatch = false; if (!IgnoreMimeRegex.IsMatch(mimeType)) { var isValidExtension = COMPRESSED_EXTENSIONS.Any(fileExtension.Contains); if (isValidExtension || fileExtension == "ts") { mimeMatch = true; } else if (mimeType.Contains("zip", StringComparison.CurrentCultureIgnoreCase) || // Should have been caught in file extensions above, but still OK. mimeType.Contains("tar", StringComparison.CurrentCultureIgnoreCase) || mimeType.Contains("compressed", StringComparison.CurrentCultureIgnoreCase)) { mimeMatch = true; } if (mimeMatch) { // Now process the file switch (fileExtension) { case ".tgz": ProcessTarGzFile(filename); break; case ".gz": if (filename.Contains(".tar.gz")) { ProcessTarGzFile(filename); } else { WriteOnce.SafeLog("no support for .gz unless .tar.gz: " + fileExtension, LogLevel.Warn); _appProfile.MetaData.PackageTypes.Add("compressed-unsupported"); } break; case ".jar": case ".zip": ProcessZipFile(filename); break; case ".gem": case ".tar": case ".nupkg": WriteOnce.SafeLog($"Processing of {fileExtension} not implemented yet.", LogLevel.Warn); break; default: WriteOnce.SafeLog("no support for compressed type: " + fileExtension, LogLevel.Warn); break; } _appProfile.MetaData.PackageTypes.Add("compressed"); } else { _appProfile.MetaData.PackageTypes.Add("compressed-unsupported"); } } }
private static string GetMimeType(string filePath) { var fileInfo = new FileInfo(filePath); return(MimeTypeMap.GetMimeType(fileInfo.Extension)); }
private async Task SetVideoSourceKeepingPlaytime(bool newMovie) { var videoPath = $"/{string.Join("/", pathComponents)}"; dlLinkAge = DateTimeOffset.UtcNow; lastRetry = DateTimeOffset.UtcNow; try { TimeSpan currentPlaytime = new TimeSpan(0); if (!newMovie) { try { await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { currentPlaytime = mediaPlayer.MediaPlayer.PlaybackSession.Position; }); } catch (Exception e) { System.Diagnostics.Debug.WriteLine("Error fetching current playtime: ", e.Message); } } var builder = oneDriveClient.Drive.Root.ItemWithPath(videoPath); var file = await builder.Request().GetAsync(); string mimeType = MimeTypeMap.GetMimeType(file.Name); System.Diagnostics.Debug.WriteLine("Playing item with mime type: " + mimeType); try { Analytics.TrackEvent("VideoUri Set", new Dictionary <string, string> { { "MimeType", mimeType } }); } catch (Exception e) { // let's not do anything more about this. System.Diagnostics.Debug.WriteLine("Exception when submitting analytics: " + e.Message); } if (file.AdditionalData.TryGetValue("@content.downloadUrl", out object downloadUrl)) { await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { mediaPlayer.Source = MediaSource.CreateFromUri(new Uri((string)downloadUrl)); }); } else { // NOTE: this stream can lead to out of memory exceptions. // might want to try also the VLC movie element again? Stream contentStream = await builder.Content.Request().GetAsync(); await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { mediaPlayer.Source = MediaSource.CreateFromStream(contentStream.AsRandomAccessStream(), mimeType); }); } await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { mediaPlayer.MediaPlayer.PlaybackSession.Position = currentPlaytime; // setup listeners if (newMovie) { mediaPlayer.MediaPlayer.PlaybackSession.PlaybackStateChanged += PlaybackSession_PlaybackStateChangedAsync; } }); } catch (Exception ex) { Crashes.TrackError(ex, new Dictionary <string, string> { { "On", "Setting Video Source" }, { "Where", "MoviePlayerPage.xaml:SetVideoSourceKeepingPlaytime" }, { "DueTo", ex.Message }, { "IsNewMovie", newMovie.ToString() } }); try { await ExitOrRetryWithMessage("Failed to load movie. Error: " + ex.ToString() + " (" + ex.Message + ")"); } catch (Exception e) { Crashes.TrackError(e, new Dictionary <string, string> { { "On", "Call Error Dialog" }, { "Where", "MoviePlayerPage.xaml:SetVideoSourceKeepingPlaytime" }, { "DueTo", ex.Message } }); } } }
public async Task AppendStreamAsync(string blobName, Stream stream, string mimeType = null, NameValueCollection metadata = null, string cacheControl = null, string contentEncoding = null, bool acquireLease = false, int maxLeaseAttempts = 1, CancellationToken cancellationToken = default(CancellationToken)) { var cleanBlobName = SanitizeBlobName(blobName); var blob = await GetBlobReferenceAsync(cleanBlobName, cancellationToken).ConfigureAwait(false); var leaseId = string.Empty; if (acquireLease && blob != null) { maxLeaseAttempts = Math.Max(maxLeaseAttempts, 1); // At least one attempt maxLeaseAttempts = Math.Min(maxLeaseAttempts, 10); // No more than 10 attempts for (var attempts = 0; attempts < maxLeaseAttempts; attempts++) { leaseId = await blob.TryAcquireLeaseAsync(null, maxLeaseAttempts, cancellationToken); if (string.IsNullOrEmpty(leaseId)) { break; } else if (attempts + 1 < maxLeaseAttempts) { await Task.Delay(500); // Make sure we don't attempt too quickly } } if (string.IsNullOrEmpty(leaseId)) { throw new Exception("Unable to obtain blob lease"); } } if (blob == null) { // We make the assumption that new blobs should be of type 'block blob' blob = _blobContainer.GetBlockBlobReference(cleanBlobName); } blob.Properties.ContentType = mimeType ?? MimeTypeMap.GetMimeType(Path.GetExtension(cleanBlobName)); if (!string.IsNullOrEmpty(cacheControl)) { blob.Properties.CacheControl = cacheControl; } if (!string.IsNullOrEmpty(contentEncoding)) { blob.Properties.ContentEncoding = contentEncoding; } await blob.AppendStreamAsync(stream, leaseId, cancellationToken).ConfigureAwait(false); if (metadata != null) { foreach (var key in metadata.AllKeys) { blob.Metadata[key] = metadata[key]; } await blob.SetMetadataAsync(leaseId, cancellationToken); } if (!string.IsNullOrEmpty(leaseId)) { await blob.ReleaseLeaseAsync(leaseId, cancellationToken).ConfigureAwait(false); } }
public UploadModule(IRepository repository, IShareMappable edocFolder, ArcOnlineHttpClient client) { Post["/upload", true] = async(_, ctx) => { var model = this.Bind <UploadAttachment>(); var edoc = repository.Get(model.Id); edoc = new EDocEntry(edoc, model.FacilityId); var filename = Path.GetFileName(edoc.Path); var extension = Path.GetExtension(filename); var contentType = MimeTypeMap.GetMimeType(extension); try { var file = edocFolder.GetPathFrom(edoc.Path); var fileInfo = new FileInfo(file); var byteCount = fileInfo.Length; if (byteCount > MaxUpload) { var readableSize = ReadableFileSizer.MakeReadable(byteCount); Log.Warning("{file} is larger than allowed upload. {size}", edoc.Path, readableSize); return(Response.AsJson(new Errorable { Error = new Error { Message = $"This file is too large to be stored in ArcGIS Online. The file is around {readableSize} " + $"and the allowable size is {ReadableFileSizer.MakeReadable(MaxUpload)}." } })); } var token = await client.GetToken(); // upload to arcgis online using (Stream document = File.OpenRead(file)) using (var formContent = new MultipartFormDataContent()) { try { var streamContent = new StreamContent(document); streamContent.Headers.Add("Content-Type", contentType); streamContent.Headers.Add("Content-Disposition", $"form-data; name=\"file\"; filename=\"{edoc.File}\""); formContent.Add(streamContent, "file", edoc.File); formContent.Add(new StringContent("json"), "f"); formContent.Add(new StringContent(token), "token"); } catch (ArgumentNullException ex) { Log.Error(ex, "Token expired?"); return(Response.AsJson(new Errorable { Error = new Error { Message = "Your arcgis online token expired. Please sign in again." } })); } var url = $"{model.ServiceUrl}/{model.FeatureId}{AttachmentUrl}"; var response = await client.UploadDocument(url, formContent).ConfigureAwait(false); return(Response.AsJson(response.Result)); } } catch (Exception ex) { Log.Error(ex, "Unknown error getting EDocs File"); return(Response.AsJson(new Errorable { Error = new Error { Message = $"Unknown error getting EDocs File. {ex.Message}" } })); } }; Delete["/upload", true] = async(_, ctx) => { var model = this.Bind <RemoveAttachment>(); using (var formContent = new MultipartFormDataContent()) { try { var token = await client.GetToken(); formContent.Add(new StringContent("json"), "f"); formContent.Add(new StringContent(model.UploadId.ToString()), "attachmentIds"); formContent.Add(new StringContent(token), "token"); } catch (ArgumentNullException ex) { Log.Error(ex, "Token expired?"); return(Response.AsJson(new Errorable { Error = new Error { Message = "Your arcgis online token expired. Please sign in again." } })); } var url = $"{model.ServiceUrl}/{model.FeatureId}{DeleteAttachmentUrl}"; var response = await client.DeleteDocument(url, formContent); return(Response.AsJson(response.Result)); } }; Post["/upload/external", true] = async(_, ctx) => { var model = this.Bind <UploadExternal>(); var attachment = Request.Files.SingleOrDefault(); if (attachment == null || attachment.Value.Length < 1) { return(Response.AsJson(new Errorable { Error = new Error { Message = "The file is empty." } })); } var extension = Path.GetExtension(attachment.Name); var contentType = MimeTypeMap.GetMimeType(extension); if (string.IsNullOrEmpty(extension)) { extension = ""; } var filename = attachment.Name.Replace(extension, ""); var extLength = 0; if (!string.IsNullOrEmpty(extension)) { extLength = extension.Length; } const int maxSize = 100; var stripNonAlphaNumeric = new Regex("[^a-zA-Z0-9-]"); var charactersAllowed = maxSize - extLength; var title = filename.Replace('/', '-'); title = stripNonAlphaNumeric.Replace(title, ""); if (title.Length > charactersAllowed) { title = title.Substring(0, charactersAllowed); } var day = DateTime.Today.Day.ToString("d2"); var month = DateTime.Today.Month.ToString("d2"); var renamed = $"x{month}-{day}x{title}{extension}"; using (var document = attachment.Value) using (var formContent = new MultipartFormDataContent()) { try { var token = await client.GetToken(); var streamContent = new StreamContent(document); streamContent.Headers.Add("Content-Type", contentType); streamContent.Headers.Add("Content-Disposition", $"form-data; name=\"file\"; filename=\"{renamed}\""); formContent.Add(streamContent, "file", attachment.Name); formContent.Add(new StringContent("json"), "f"); formContent.Add(new StringContent(token), "token"); } catch (ArgumentNullException) { return(Response.AsJson(new Errorable { Error = new Error { Message = "Your arcgis online token expired. Please sign in again." } })); } var url = $"{model.ServiceUrl}/{model.FeatureId}{AttachmentUrl}"; var response = await client.UploadDocument(url, formContent); return(Response.AsJson(response.Result)); } }; }
public virtual FileResult DownloadFile(string path, string name) { var bytes = System.IO.File.ReadAllBytes(Environment.WebRootPath + path); return(File(bytes, MimeTypeMap.GetMimeType(Path.GetExtension(path)), name)); }
/// <summary> /// Determines whether this instance is extension. /// </summary> /// <param name="extension">The extension.</param> /// <returns> /// <c>true</c> if the specified extension is extension; otherwise, <c>false</c>. /// </returns> public static bool IsExtension(this string extension) { return(extension.StartsWith(".") && MimeTypeMap.HasExtension(extension)); }
public void ShowAttachment(string AttachmentName) { File attachment = this.GetFilePath(AttachmentName); if (!attachment.Exists()) { return; } Device.BeginInvokeOnMainThread((Action)(() => { Uri uriForFile = FileProvider.GetUriForFile(Application.get_Context(), "hu.eKreta.KretaAndroid.provider", attachment); Intent intent = new Intent("android.intent.action.VIEW"); string typeFromExtension = MimeTypeMap.get_Singleton().GetMimeTypeFromExtension(MimeTypeMap.GetFileExtensionFromUrl(Object.op_Explicit((Object)uriForFile)).ToLower()); intent.SetDataAndType(uriForFile, typeFromExtension); intent.SetFlags((ActivityFlags)268959744); intent.AddFlags((ActivityFlags)1); try { Xamarin.Forms.Forms.get_Context().StartActivity(intent); } catch (Exception ex) { Toast.MakeText(Xamarin.Forms.Forms.get_Context(), "No Application Available to View this file", (ToastLength)0).Show(); } })); }
public static async Task <(int, dynamic)> AddNewPost_Async(string postId, string postPage, string textContent, string privacy, string feelingType, string feeling, string location, ObservableCollection <Attachments> postAttachments, ObservableCollection <PollAnswers> pollAnswersList, string idColor, string albumName) { try { var client = new HttpClient() { Timeout = TimeSpan.FromMinutes(5) }; var multi = new MultipartFormDataContent(Guid.NewGuid().ToString()) { { new StringContent(textContent), "\"postText\"" }, { new StringContent(privacy), "\"postPrivacy\"" }, { new StringContent(UserDetails.AccessToken), "\"s\"" }, { new StringContent(UserDetails.UserId), "\"user_id\"" }, }; if (!string.IsNullOrEmpty(feelingType)) { multi.Add(new StringContent(feelingType), "\"feeling_type\""); } if (!string.IsNullOrEmpty(feeling)) { multi.Add(new StringContent(feeling), "\"feeling\""); } if (!string.IsNullOrEmpty(location)) { multi.Add(new StringContent(location), "\"postMap\""); } if (!string.IsNullOrEmpty(idColor)) { multi.Add(new StringContent(idColor), "\"post_color\""); } if (!string.IsNullOrEmpty(albumName)) { multi.Add(new StringContent(albumName), "\"album_name\""); } if (pollAnswersList != null) { foreach (var item in pollAnswersList) { multi.Add(new StringContent(item.Answer), "\"answer[]\""); } } switch (postPage) { case "SocialGroup": multi.Add(new StringContent(postId), "\"group_id\""); break; case "SocialPage": multi.Add(new StringContent(postId), "\"page_id\""); break; case "SocialEvent": multi.Add(new StringContent(postId), "\"event_id\""); break; } if (postAttachments.Count > 0) { foreach (var attachment in postAttachments) { if (!attachment.FileUrl.Contains(".gif")) { FileStream fs = System.IO.File.OpenRead(attachment.FileUrl); StreamContent content = new StreamContent(fs); content.Headers.ContentType = new MediaTypeHeaderValue(MimeTypeMap.GetMimeType(attachment.FileUrl?.Split('.').LastOrDefault())); content.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data") { Name = attachment.TypeAttachment, FileName = attachment.FileUrl?.Split('\\').LastOrDefault()?.Split('/').LastOrDefault() }; //video thumbnail if (!string.IsNullOrEmpty(attachment.Thumb?.FileUrl)) { FileStream fs2 = System.IO.File.OpenRead(attachment.Thumb.FileUrl); StreamContent content2 = new StreamContent(fs2); content2.Headers.ContentType = new MediaTypeHeaderValue(MimeTypeMap.GetMimeType(attachment.Thumb.FileUrl?.Split('.').LastOrDefault())); content2.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data") { Name = attachment.Thumb.TypeAttachment, FileName = attachment.Thumb.FileUrl?.Split('\\').LastOrDefault()?.Split('/').LastOrDefault() }; multi.Add(content2); } multi.Add(content); } else { if (!string.IsNullOrEmpty(textContent) && !string.IsNullOrWhiteSpace(textContent)) { var text = textContent; multi.Add(new StringContent(text), "\"postText\""); multi.Add(new StringContent(attachment.FileUrl), "\"postSticker\""); } else { multi.Add(new StringContent(attachment.FileUrl), "\"postSticker\""); } } } } var request = new HttpRequestMessage() { RequestUri = new Uri(ApiAddNewPost), Method = System.Net.Http.HttpMethod.Post, Content = multi, }; request.Headers.Add("Connection", new[] { "Keep-Alive" }); var response = await client.SendAsync(request); //var response = await client.PostAsync(ApiAddNewPost, multi); string json = await response.Content.ReadAsStringAsync(); var data = JsonConvert.DeserializeObject <AddPostObject>(json); if (data.ApiStatus == "200") { return(200, data); } var error = JsonConvert.DeserializeObject <ErrorObject>(json); return(400, error); } catch (Exception e) { Console.WriteLine(e); return(404, e.Message); } }
/// <summary> /// Host a static page /// </summary> /// <param name="app">The App Builder to use</param> /// <param name="path">The path to host the page on</param> /// <param name="resource">The name/path to the resource</param> /// <param name="getModel">A method that takes the context and returns any replacements required</param> public static void HostPageAsync(this IAppBuilder app, string path, string resource, Func <IOwinContext, Task <object> > getModel) { // check inputs if (string.IsNullOrWhiteSpace(path)) { throw new ArgumentNullException(nameof(path)); } if (string.IsNullOrWhiteSpace(resource)) { throw new ArgumentNullException(nameof(resource)); } var assemblyName = new AssemblyName(ContentExtensions.ContentAssembly); app.Use(async(context, next) => { var runNext = true; // get current request path var currentPath = context.Request.Path; // if we don't have a request for embedded content // run the next thing in the OWIN pipeline if (currentPath.HasValue) { // get the value var currentPathValue = currentPath.Value; // check that it contains our path for embedded content var hasContentPath = currentPathValue.Equals(path); // if we don't have a request for embedded content // run the next thing in the OWIN pipeline if (hasContentPath) { // create a resource helper var resourceHelper = new ResourceHelper(); // attempt to get the file parts var fileParts = resource.Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries); var extension = ".txt"; // if we have some file parts if (fileParts.Length > 0) { // get the last one var lastIndex = fileParts.Length - 1; // if we have a valid index, grab the extension if (lastIndex > -1) { extension = $".{fileParts[lastIndex]}"; } } // get resource from assembly var view = resourceHelper.GetResourceAsString(assemblyName.FullName, resource); // get replacements var replacements = await getModel(context); // always perform replacements view = StringMapper.Replace(view, replacements); // force response type to match resource type context.Response.ContentType = MimeTypeMap.GetMimeType(extension); // ensure nothing else runs after this runNext = false; // return content of resource await context.Response.WriteAsync(view); } } if (runNext) { await next.Invoke(); } }); }
public void Get([Url] string map) { if (Skip) { Response.Close(); return; } Response.ContentType = MimeTypeMap.GetMimeType(".png"); var bsp = Program.GetMap(map); var lightingLump = bsp.LightingHdr.Length > 0 ? bsp.LightingHdr.LumpType : bsp.Lighting.LumpType; using (var sampleStream = bsp.GetLumpStream(lightingLump)) { var lightmap = bsp.LightmapLayout; var width = lightmap.TextureSize.X; var height = lightmap.TextureSize.Y; var pixels = new byte[width * height * 4]; var sampleBuffer = new ColorRGBExp32[256 * 256]; var faces = bsp.FacesHdr.Length > 0 ? bsp.FacesHdr : bsp.Faces; for (int i = 0, iEnd = faces.Length; i < iEnd; ++i) { var face = faces[i]; if (face.LightOffset == -1) { continue; } var rect = lightmap.GetLightmapRegion(i); var sampleCount = rect.Width * rect.Height; sampleStream.Seek(face.LightOffset, SeekOrigin.Begin); LumpReader <ColorRGBExp32> .ReadLumpFromStream(sampleStream, sampleCount, sampleBuffer); for (var y = 0; y < rect.Height; ++y) { for (var x = 0; x < rect.Width; ++x) { var s = Math.Max(0, Math.Min(x, rect.Width - 1)); var t = Math.Max(0, Math.Min(y, rect.Height - 1)); var index = (rect.X + x + width * (rect.Y + y)) * 4; var sampleIndex = s + t * rect.Width; var sample = sampleBuffer[sampleIndex]; pixels[index + 0] = sample.B; pixels[index + 1] = sample.G; pixels[index + 2] = sample.R; pixels[index + 3] = (byte)(sample.Exponent + 128); } } } using (var img = new MagickImage(pixels, new MagickReadSettings { Width = width, Height = height, PixelStorage = new PixelStorageSettings(StorageType.Char, "BGRA") })) { img.Write(Response.OutputStream, MagickFormat.Png); } Response.OutputStream.Close(); } }
public static string ToMediaType(this string imageUrl) { var fileExtension = ToFileExtension(imageUrl); return(MimeTypeMap.GetMimeType(fileExtension)); }
public bool TryGetMimeType(string str, out string mimeType) => MimeTypeMap.TryGetMimeType(str, out mimeType);
/// <summary> /// Uploads data to the bucket (the mimetype is inferred). /// </summary> /// <param name="fileName">Filename to save as in bucket</param> /// <param name="data">The byte array to read from</param> /// <param name="permissionLevel">The permission level to set</param> public Bucket UploadData(string fileName, byte[] data, Permissions permissionLevel = Permissions.OwnerOnly) { return(UploadData(fileName, data, MimeTypeMap.GetMimeType(Path.GetExtension(fileName)), permissionLevel)); }
public string GetExtension(string mimeType, bool throwErrorIfNotFound = true) => MimeTypeMap.GetExtension(mimeType, throwErrorIfNotFound);
/// <summary> /// Uploads a file to the bucket. Mimetype is inferred. /// </summary> /// <param name="fileNameInBucket">The filename to save as in the bucket</param> /// <param name="pathToFile">Path to the file (relative or absolute)</param> /// <param name="permissionLevel">Permission level to set</param> public Bucket UploadFile(string fileNameInBucket, string pathToFile, Permissions permissionLevel = Permissions.OwnerOnly) { return(UploadFile(fileNameInBucket, pathToFile, MimeTypeMap.GetMimeType(Path.GetExtension(fileNameInBucket)), permissionLevel)); }
/// <summary> /// Streams a file contents to the response as a HTTP response message /// </summary> /// <param name="controller">The controller reference</param> /// <param name="fileContents">The file contents to stream</param> /// <param name="contentType">The file content type</param> /// <param name="fileName">The file name to display (optional)</param> /// <param name="dispositionType">The content disposition type (optional)</param> /// <returns>An action result with the streamed file data</returns> public static HttpResponseMessage StreamFile ( this ApiController controller, byte[] fileContents, string contentType, string fileName = null, string dispositionType = "inline" ) { if (fileContents == null || fileContents.Length == 0) { throw new ArgumentException ( "An empty file cannot be streamed." ); } if (String.IsNullOrEmpty(fileName)) { var fileExtension = MimeTypeMap.GetExtension ( contentType ); fileName = $"Attachment.{fileExtension}"; } // Remove commas from the file name as they are not supported fileName = fileName.Replace ( ",", String.Empty ); var result = new HttpResponseMessage ( HttpStatusCode.OK ); var contentTypeHeader = new MediaTypeHeaderValue ( contentType ); var dispositionHeader = new ContentDispositionHeaderValue ( dispositionType ) { FileName = fileName }; result.Content = new ByteArrayContent ( fileContents ); result.Content.Headers.ContentType = contentTypeHeader; result.Content.Headers.ContentLength = fileContents.Length; result.Content.Headers.ContentDisposition = dispositionHeader; return(result); }
public virtual FileResult DownloadReportByLonNumber( string operationNumber, string loanNumber, string fundCode, string loanTcdNum, string loanProjectNumber, string loanCurrencyCode, string format = "", string group = DisbursementValues.SELECTED) { if ((format == DisbursementValues.PDF) || (format == DisbursementValues.EXCEL)) { string pcMail = IDBContext.Current.UserName; OperationLevelProjectionsViewModel model; var projectionMatrix = _disbursementService.GetProjectionMatrixWithCache( null, operationNumber, pcMail, loanNumber, fundCode, loanTcdNum, loanProjectNumber, loanCurrencyCode); var oldProjection = _disbursementService.GetMonthlyProyections( operationNumber, projectionMatrix.CurrentProjectionMonth, false, projectionMatrix.IsExecution, new string[] { loanNumber }); model = new OperationLevelProjectionsViewModel { ProjectedMonths = projectionMatrix.ProjectedMonths, ProjectedYears = projectionMatrix.ProjectedYears, OldProjection = oldProjection, CurrentProjectionMonth = projectionMatrix.CurrentProjectionMonth, Balance = projectionMatrix.Balance }; var exportModel = _disbursementService.FormatOperationLevelModelToExport(model); try { DownloadDisbursementReportResponse response = _disbursementService .DownloadDisbursementProjectionsReport(exportModel, format); if (!response.IsValid) { throw new Exception(DisbursementValues.MSJ_ERROR_EXPORT + DisbursementValues.UNDERLINE_STRING + response.ErrorMessage); } string fileName = IDBContext.Current.Operation + DisbursementValues.UNDERLINE_STRING + Localization.GetText(DisbursementValues.DISBURSEMENT_PROJECTIONS) + Localization.GetText(DisbursementValues.LOAN_LEVEL); string application; switch (format) { case DisbursementValues.EXCEL: application = MimeTypeMap.GetMimeType(DisbursementValues.EXCEL); fileName = fileName + DisbursementValues.DOT_STRING + DisbursementValues.EXCEL; break; default: application = MimeTypeMap.GetMimeType(DisbursementValues.PDF); fileName = fileName + DisbursementValues.DOT_STRING + DisbursementValues.PDF; break; } return(File(response.File, application, fileName)); } catch (Exception) { MessageHandler.SetMessage( Localization.GetText(DisbursementValues.WARNING_UNHANDLED_ERROR), DisbursementValues.ERROR); } } return(null); }
public virtual FileResult DownloadReport( string operationNumber, string format = "", string group = DisbursementValues.SELECTED) { string pcMail = IDBContext.Current.UserName; OperationLevelProjectionsViewModel model; string cacheName = string.Format( DisbursementValues.DISBURSEMENT_CACHE_SKELETON, pcMail, operationNumber, group); var isInExecution = _disbursementService.IsInExecution(operationNumber); model = _disbursementService.GetProjectionMatrixWithCache( null, pcMail, operationNumber, group, isInExecution.IsValid); var oldProjection = _disbursementService.GetMonthlyProyections( operationNumber, model.CurrentProjectionMonth, true, model.IsExecution, model.LoanNumbers, model.ExchangeRates); model.OldProjection = oldProjection != null ? oldProjection : new List <ActualsFromEdwViewModel>(); var exportModel = _disbursementService.FormatOperationLevelModelToExport(model); try { DownloadDisbursementReportResponse response = _disbursementService.DownloadDisbursementProjectionsReport(exportModel, format); if (!response.IsValid) { throw new Exception(DisbursementValues.MSJ_ERROR_EXPORT + DisbursementValues.UNDERLINE_STRING + response.ErrorMessage); } string fileName = IDBContext.Current.Operation + DisbursementValues.UNDERLINE_STRING + Localization.GetText(DisbursementValues.DISBURSEMENT_PROJECTIONS) + Localization.GetText(DisbursementValues.LOAN_LEVEL); string application; switch (format) { case DisbursementValues.EXCEL: application = MimeTypeMap.GetMimeType(DisbursementValues.EXCEL); fileName = fileName + DisbursementValues.DOT_STRING + DisbursementValues.EXCEL; break; default: application = MimeTypeMap.GetMimeType(DisbursementValues.PDF); fileName = fileName + DisbursementValues.DOT_STRING + DisbursementValues.PDF; break; } return(File(response.File, application, fileName)); } catch (Exception) { MessageHandler.SetMessage( Localization.GetText(DisbursementValues.WARNING_UNHANDLED_ERROR), DisbursementValues.ERROR); } return(null); }
public async Task UploadAsync(string containerName, string fileName, Stream stream, string contentType = null, bool reportProgress = false) { var container = await CreateIfNotExistsAsync(containerName); var blockBlobClient = container.GetBlockBlobClient(fileName); BlobClient blobProgress = null; const int blockSize = 1 * 1024 * 1024; //1 MB Block const int offset = 0; var counter = 0; var blockIds = new List <string>(); var bytesRemaining = stream.Length; do { if (reportProgress) { if (blobProgress == null) { blobProgress = container.GetBlobClient($"{fileName}.progress"); } var p = (double)(stream.Length - bytesRemaining) / stream.Length * 100; await blobProgress.UploadAsync(new MemoryStream(Encoding.UTF8.GetBytes(p.ToString(CultureInfo.InvariantCulture))), true); } var dataToRead = Math.Min(bytesRemaining, blockSize); var data = new byte[dataToRead]; var dataRead = await stream.ReadAsync(data.AsMemory(offset, (int)dataToRead)); bytesRemaining -= dataRead; if (dataRead > 0) { var blockId = Convert.ToBase64String(Encoding.UTF8.GetBytes(counter.ToString("d6"))); await blockBlobClient.StageBlockAsync(blockId, new MemoryStream(data)); blockIds.Add(blockId); counter++; } }while (bytesRemaining > 0); await blockBlobClient.CommitBlockListAsync(blockIds); if (string.IsNullOrEmpty(contentType)) { await blockBlobClient.SetHttpHeadersAsync(new BlobHttpHeaders { ContentType = MimeTypeMap.GetMimeType(Path.GetExtension(fileName)) }); } else { await blockBlobClient.SetHttpHeadersAsync(new BlobHttpHeaders { ContentType = contentType }); } if (blobProgress != null) { await blobProgress.DeleteIfExistsAsync(); } }
private void PreviewHandler(string file) { if (File.Exists(file)) { Uri uri = new Uri(file); if (MimeTypeMap.GetMimeType(uri.ToString()).Contains("image")) { HidePreview(); BitmapImage image = new BitmapImage(); image.BeginInit(); image.CreateOptions = BitmapCreateOptions.IgnoreImageCache; image.CacheOption = BitmapCacheOption.OnLoad; image.UriSource = uri; image.EndInit(); if (MimeTypeMap.GetMimeType(uri.ToString()).Contains("gif")) { gifPreview.Visibility = Visibility.Visible; ImageBehavior.SetAnimatedSource(gifPreview, image); } else { imgPreview.Visibility = Visibility.Visible; imgPreview.Source = image; } } else if (MimeTypeMap.GetMimeType(uri.ToString()).Contains("video") || MimeTypeMap.GetMimeType(uri.ToString()).Contains("audio")) { HidePreview(); previewGrid.Visibility = Visibility.Visible; previewGrid.BringIntoView(); time.Start(); media.Play(new Media(lib, uri)); media.Volume = 100; } else if (MimeTypeMap.GetMimeType(uri.ToString()).Contains("text")) { HidePreview(); try { string contents = File.ReadAllText(file); txtPreviewScroller.Visibility = Visibility.Visible; txtPreview.Visibility = Visibility.Visible; txtPreview.Text = contents; } catch (Exception exc) { nullPreview.Visibility = Visibility.Visible; } } else { HidePreview(); nullPreview.Visibility = Visibility.Visible; } } }
void IHttpHandler.ProcessRequest(HttpContext context) { var url = EwfApp.GetRequestAppRelativeUrl(context.Request); var queryIndex = url.IndexOf("?", StringComparison.Ordinal); if (queryIndex >= 0) { url = url.Remove(queryIndex); } var extensionIndex = url.LastIndexOf(".", StringComparison.Ordinal); var versionStringOrFileExtensionIndex = extensionIndex; var urlVersionString = ""; if (url.StartsWith(VersionedFilesFolderName + "/") || url.StartsWith(EwfFolderName + "/" + VersionedFilesFolderName + "/")) { urlVersionString = "invariant"; } else { // We assume that all URL version strings will have the same length as the format string. var prefixedVersionStringIndex = extensionIndex - (urlVersionStringPrefix.Length + EwfSafeResponseWriter.UrlVersionStringFormat.Length); if (prefixedVersionStringIndex >= 0) { DateTimeOffset dateAndTime; var versionString = url.Substring(prefixedVersionStringIndex + urlVersionStringPrefix.Length, EwfSafeResponseWriter.UrlVersionStringFormat.Length); if (DateTimeOffset.TryParseExact( versionString, EwfSafeResponseWriter.UrlVersionStringFormat, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.None, out dateAndTime)) { versionStringOrFileExtensionIndex = prefixedVersionStringIndex; urlVersionString = versionString; } } } if (versionStringOrFileExtensionIndex < 0) { throw new ResourceNotAvailableException("Failed to find the extension in the URL.", null); } var extension = url.Substring(extensionIndex); var staticFileInfo = EwfApp.GlobalType.Assembly.CreateInstance( CombineNamespacesAndProcessEwfIfNecessary( EwfApp.GlobalType.Namespace, (url.Remove(versionStringOrFileExtensionIndex) + extension.CapitalizeString()).Separate("/", false) .Select(i => EwlStatics.GetCSharpIdentifier(i.CapitalizeString())) .Aggregate((a, b) => a + "." + b) + "+Info")) as StaticFileInfo; if (staticFileInfo == null) { throw new ResourceNotAvailableException("Failed to create an Info object for the request.", null); } var mediaTypeOverride = EwfApp.Instance.GetMediaTypeOverrides().SingleOrDefault(i => i.FileExtension == extension); var contentType = mediaTypeOverride != null ? mediaTypeOverride.MediaType : MimeTypeMap.GetMimeType(extension); Func <string> cacheKeyGetter = () => staticFileInfo.GetUrl(false, false, false); EwfSafeResponseWriter responseWriter; if (contentType == TewlContrib.ContentTypes.Css) { Func <string> cssGetter = () => File.ReadAllText(staticFileInfo.FilePath); responseWriter = urlVersionString.Any() ? new EwfSafeResponseWriter( cssGetter, urlVersionString, () => new ResponseMemoryCachingSetup(cacheKeyGetter(), staticFileInfo.GetResourceLastModificationDateAndTime())) : new EwfSafeResponseWriter( () => EwfResponse.Create( TewlContrib.ContentTypes.Css, new EwfResponseBodyCreator(() => CssPreprocessor.TransformCssFile(cssGetter()))), staticFileInfo.GetResourceLastModificationDateAndTime(), memoryCacheKeyGetter: cacheKeyGetter); } else { Func <EwfResponse> responseCreator = () => EwfResponse.Create( contentType, new EwfResponseBodyCreator( responseStream => { using (var fileStream = File.OpenRead(staticFileInfo.FilePath)) fileStream.CopyTo(responseStream); })); responseWriter = urlVersionString.Any() ? new EwfSafeResponseWriter( responseCreator, urlVersionString, memoryCachingSetupGetter: () => new ResponseMemoryCachingSetup( cacheKeyGetter(), staticFileInfo.GetResourceLastModificationDateAndTime())) : new EwfSafeResponseWriter( responseCreator, staticFileInfo.GetResourceLastModificationDateAndTime(), memoryCacheKeyGetter: cacheKeyGetter); } responseWriter.WriteResponse(); }