public Task <object> Get(GetFile request) { var item = _libraryManager.GetItemById(request.Id); return(ResultFactory.GetStaticFileResult(Request, item.Path)); }
public object Get(GetRemoteSubtitles request) { var result = _subtitleManager.GetRemoteSubtitles(request.Id, CancellationToken.None).Result; return(ResultFactory.GetResult(result.Stream, MimeTypes.GetMimeType("file." + result.Format))); }
public async Task <IHttpActionResult> Get(string id) { return(await ResultFactory.Create(ModelState, async arg => await aWProductService.GetByIdWithRedisAsync(arg), id, "success", "请检查请求参数")); }
/// <summary> /// 200 - Ok response. /// </summary> public static GetRouteWithDashResult Ok(string?message = null) => new GetRouteWithDashResult(ResultFactory.CreateContentResult(HttpStatusCode.OK, message));
public async Task <IHttpActionResult> Get(string id) { return(await ResultFactory.Create(ModelState, async arg => await agrProduceAnniversaryService.GetByIdAsync(arg), id, "success", "请检查请求参数")); }
public async Task <IHttpActionResult> Delete(string id) { return(await ResultFactory.Create(ModelState, async arg => await sysMenuService.DeleteAsync(arg), id, "success", "请检查请求参数")); }
/// <summary> /// Gets the stream result. /// </summary> /// <param name="state">The state.</param> /// <param name="responseHeaders">The response headers.</param> /// <param name="isHeadRequest">if set to <c>true</c> [is head request].</param> /// <param name="cancellationTokenSource">The cancellation token source.</param> /// <returns>Task{System.Object}.</returns> private async Task <object> GetStreamResult(StreamRequest request, StreamState state, IDictionary <string, string> responseHeaders, bool isHeadRequest, CancellationTokenSource cancellationTokenSource) { // Use the command line args with a dummy playlist path var outputPath = state.OutputFilePath; responseHeaders[HeaderNames.AcceptRanges] = "none"; var contentType = state.GetMimeType(outputPath); // TODO: The isHeadRequest is only here because ServiceStack will add Content-Length=0 to the response var contentLength = state.EstimateContentLength || isHeadRequest?GetEstimatedContentLength(state) : null; if (contentLength.HasValue) { responseHeaders[HeaderNames.ContentLength] = contentLength.Value.ToString(CultureInfo.InvariantCulture); } // Headers only if (isHeadRequest) { var streamResult = ResultFactory.GetResult(null, Array.Empty <byte>(), contentType, responseHeaders); if (streamResult is IHasHeaders hasHeaders) { if (contentLength.HasValue) { hasHeaders.Headers[HeaderNames.ContentLength] = contentLength.Value.ToString(CultureInfo.InvariantCulture); } else { hasHeaders.Headers.Remove(HeaderNames.ContentLength); } } return(streamResult); } var transcodingLock = ApiEntryPoint.Instance.GetTranscodingLock(outputPath); await transcodingLock.WaitAsync(cancellationTokenSource.Token).ConfigureAwait(false); try { TranscodingJob job; if (!File.Exists(outputPath)) { job = await StartFfMpeg(state, outputPath, cancellationTokenSource).ConfigureAwait(false); } else { job = ApiEntryPoint.Instance.OnTranscodeBeginRequest(outputPath, TranscodingJobType.Progressive); state.Dispose(); } var outputHeaders = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase) { [HeaderNames.ContentType] = contentType }; // Add the response headers to the result object foreach (var item in responseHeaders) { outputHeaders[item.Key] = item.Value; } return(new ProgressiveFileCopier(FileSystem, outputPath, outputHeaders, job, Logger, CancellationToken.None)); } finally { transcodingLock.Release(); } }
/// <summary> /// 409 - Conflict response. /// </summary> public static GetUserByIdResult Conflict(string?error = null) => new GetUserByIdResult(ResultFactory.CreateContentResultWithProblemDetails(HttpStatusCode.Conflict, error));
/// <summary> /// Processes the request. /// </summary> /// <param name="request">The request.</param> /// <param name="isHeadRequest">if set to <c>true</c> [is head request].</param> /// <returns>Task.</returns> protected object ProcessRequest(StreamRequest request, bool isHeadRequest) { var state = GetState(request, CancellationToken.None).Result; var responseHeaders = new Dictionary <string, string>(); // Static remote stream if (request.Static && state.IsRemote) { AddDlnaHeaders(state, responseHeaders, true); try { return(GetStaticRemoteStreamResult(state.MediaPath, responseHeaders, isHeadRequest).Result); } finally { state.Dispose(); } } var outputPath = GetOutputFilePath(state); var outputPathExists = File.Exists(outputPath); var isStatic = request.Static || (outputPathExists && !ApiEntryPoint.Instance.HasActiveTranscodingJob(outputPath, TranscodingJobType.Progressive)); AddDlnaHeaders(state, responseHeaders, isStatic); // Static stream if (request.Static) { var contentType = state.GetMimeType(state.MediaPath); try { return(ResultFactory.GetStaticFileResult(Request, state.MediaPath, contentType, FileShare.Read, responseHeaders, isHeadRequest)); } finally { state.Dispose(); } } // Not static but transcode cache file exists if (outputPathExists && !ApiEntryPoint.Instance.HasActiveTranscodingJob(outputPath, TranscodingJobType.Progressive)) { var contentType = state.GetMimeType(outputPath); try { return(ResultFactory.GetStaticFileResult(Request, outputPath, contentType, FileShare.Read, responseHeaders, isHeadRequest)); } finally { state.Dispose(); } } // Need to start ffmpeg try { return(GetStreamResult(state, responseHeaders, isHeadRequest).Result); } catch { state.Dispose(); throw; } }
/// <summary> /// Processes the request async. /// </summary> /// <param name="request">The request.</param> /// <param name="isLive">if set to <c>true</c> [is live].</param> /// <returns>Task{System.Object}.</returns> /// <exception cref="ArgumentException">A video bitrate is required /// or /// An audio bitrate is required</exception> protected async Task <object> ProcessRequestAsync(StreamRequest request, bool isLive) { var cancellationTokenSource = new CancellationTokenSource(); var state = await GetState(request, cancellationTokenSource.Token).ConfigureAwait(false); TranscodingJob job = null; var playlist = state.OutputFilePath; if (!File.Exists(playlist)) { var transcodingLock = ApiEntryPoint.Instance.GetTranscodingLock(playlist); await transcodingLock.WaitAsync(cancellationTokenSource.Token).ConfigureAwait(false); try { if (!File.Exists(playlist)) { // If the playlist doesn't already exist, startup ffmpeg try { job = await StartFfMpeg(state, playlist, cancellationTokenSource).ConfigureAwait(false); job.IsLiveOutput = isLive; } catch { state.Dispose(); throw; } var minSegments = state.MinSegments; if (minSegments > 0) { await WaitForMinimumSegmentCount(playlist, minSegments, cancellationTokenSource.Token).ConfigureAwait(false); } } } finally { transcodingLock.Release(); } } if (isLive) { job = job ?? ApiEntryPoint.Instance.OnTranscodeBeginRequest(playlist, TranscodingJobType); if (job != null) { ApiEntryPoint.Instance.OnTranscodeEndRequest(job); } return(ResultFactory.GetResult(GetLivePlaylistText(playlist, state.SegmentLength), MimeTypes.GetMimeType("playlist.m3u8"), new Dictionary <string, string>())); } var audioBitrate = state.OutputAudioBitrate ?? 0; var videoBitrate = state.OutputVideoBitrate ?? 0; var baselineStreamBitrate = 64000; var playlistText = GetMasterPlaylistFileText(playlist, videoBitrate + audioBitrate, baselineStreamBitrate); job = job ?? ApiEntryPoint.Instance.OnTranscodeBeginRequest(playlist, TranscodingJobType); if (job != null) { ApiEntryPoint.Instance.OnTranscodeEndRequest(job); } return(ResultFactory.GetResult(playlistText, MimeTypes.GetMimeType("playlist.m3u8"), new Dictionary <string, string>())); }
/// <summary> /// 404 - NotFound response. /// </summary> public static GetUserByIdResult NotFound(string?message = null) => new GetUserByIdResult(ResultFactory.CreateContentResultWithProblemDetails(HttpStatusCode.NotFound, message));
private async Task <object> GetUniversalStream(GetUniversalAudioStream request, bool isHeadRequest) { var deviceProfile = GetDeviceProfile(request); AuthorizationContext.GetAuthorizationInfo(Request).DeviceId = request.DeviceId; var mediaInfoService = new MediaInfoService(MediaSourceManager, DeviceManager, LibraryManager, ServerConfigurationManager, NetworkManager, MediaEncoder, UserManager, JsonSerializer, AuthorizationContext, _loggerFactory) { Request = Request }; var playbackInfoResult = await mediaInfoService.GetPlaybackInfo(new GetPostedPlaybackInfo { Id = request.Id, MaxAudioChannels = request.MaxAudioChannels, MaxStreamingBitrate = request.MaxStreamingBitrate, StartTimeTicks = request.StartTimeTicks, UserId = request.UserId, DeviceProfile = deviceProfile, MediaSourceId = request.MediaSourceId }).ConfigureAwait(false); var mediaSource = playbackInfoResult.MediaSources[0]; if (mediaSource.SupportsDirectPlay && mediaSource.Protocol == MediaProtocol.Http) { if (request.EnableRedirection) { if (mediaSource.IsRemote && request.EnableRemoteMedia) { return(ResultFactory.GetRedirectResult(mediaSource.Path)); } } } var isStatic = mediaSource.SupportsDirectStream; if (!isStatic && string.Equals(mediaSource.TranscodingSubProtocol, "hls", StringComparison.OrdinalIgnoreCase)) { var service = new DynamicHlsService(ServerConfigurationManager, UserManager, LibraryManager, IsoManager, MediaEncoder, FileSystem, DlnaManager, SubtitleEncoder, DeviceManager, MediaSourceManager, JsonSerializer, AuthorizationContext, NetworkManager) { Request = Request }; var transcodingProfile = deviceProfile.TranscodingProfiles[0]; var newRequest = new GetMasterHlsAudioPlaylist { AudioBitRate = isStatic ? (int?)null : Convert.ToInt32(Math.Min(request.MaxStreamingBitrate ?? 192000, int.MaxValue)), AudioCodec = transcodingProfile.AudioCodec, Container = ".m3u8", DeviceId = request.DeviceId, Id = request.Id, MaxAudioChannels = request.MaxAudioChannels, MediaSourceId = mediaSource.Id, PlaySessionId = playbackInfoResult.PlaySessionId, StartTimeTicks = request.StartTimeTicks, Static = isStatic, SegmentContainer = request.TranscodingContainer, AudioSampleRate = request.MaxAudioSampleRate, MaxAudioBitDepth = request.MaxAudioBitDepth, BreakOnNonKeyFrames = transcodingProfile.BreakOnNonKeyFrames, TranscodeReasons = mediaSource.TranscodeReasons == null ? null : string.Join(",", mediaSource.TranscodeReasons.Select(i => i.ToString()).ToArray()) }; if (isHeadRequest) { return(await service.Head(newRequest).ConfigureAwait(false)); } return(await service.Get(newRequest).ConfigureAwait(false)); } else { var service = new AudioService(ServerConfigurationManager, UserManager, LibraryManager, IsoManager, MediaEncoder, FileSystem, DlnaManager, SubtitleEncoder, DeviceManager, MediaSourceManager, JsonSerializer, AuthorizationContext, EnvironmentInfo) { Request = Request }; var newRequest = new GetAudioStream { AudioBitRate = isStatic ? (int?)null : Convert.ToInt32(Math.Min(request.MaxStreamingBitrate ?? 192000, int.MaxValue)), AudioCodec = request.AudioCodec, Container = isStatic ? null : ("." + mediaSource.TranscodingContainer), DeviceId = request.DeviceId, Id = request.Id, MaxAudioChannels = request.MaxAudioChannels, MediaSourceId = mediaSource.Id, PlaySessionId = playbackInfoResult.PlaySessionId, StartTimeTicks = request.StartTimeTicks, Static = isStatic, AudioSampleRate = request.MaxAudioSampleRate, MaxAudioBitDepth = request.MaxAudioBitDepth, TranscodeReasons = mediaSource.TranscodeReasons == null ? null : string.Join(",", mediaSource.TranscodeReasons.Select(i => i.ToString()).ToArray()) }; if (isHeadRequest) { return(await service.Head(newRequest).ConfigureAwait(false)); } return(await service.Get(newRequest).ConfigureAwait(false)); } }
/// <summary> /// 400 - BadRequest response. /// </summary> public static UploadSingleObjectWithFilesAsFormDataResult BadRequest(string?message = null) => new UploadSingleObjectWithFilesAsFormDataResult(ResultFactory.CreateContentResultWithValidationProblemDetails(HttpStatusCode.BadRequest, message));
/// <summary> /// 200 - Ok response. /// </summary> public static UploadSingleObjectWithFilesAsFormDataResult Ok(string?message = null) => new UploadSingleObjectWithFilesAsFormDataResult(ResultFactory.CreateContentResult(HttpStatusCode.OK, message));
/// <summary> /// Gets the specified request. /// </summary> /// <param name="request">The request.</param> /// <returns>System.Object.</returns> public object Get(GetDashboardConfigurationPage request) { var page = ServerEntryPoint.Instance.PluginConfigurationPages.First(p => p.Name.Equals(request.Name, StringComparison.OrdinalIgnoreCase)); return(ResultFactory.GetStaticResult(RequestContext, page.Plugin.Version.ToString().GetMD5(), page.Plugin.AssemblyDateLastModified, null, MimeTypes.GetMimeType("page.html"), () => ModifyHtml(page.GetHtmlStream()))); }
/// <summary> /// To the optimized result. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="result">The result.</param> /// <returns>System.Object.</returns> protected object ToOptimizedResult <T>(T result) where T : class { return(ResultFactory.GetOptimizedResult(RequestContext, result)); }
public async Task <IHttpActionResult> GetAll() { return(await ResultFactory.Create(ModelState, async arg => await sysMenuService.GetAllWidthRedisAsync(), "", "success", "请检查请求参数")); }
/// <summary> /// To the optimized result using cache. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="cacheKey">The cache key.</param> /// <param name="lastDateModified">The last date modified.</param> /// <param name="cacheDuration">Duration of the cache.</param> /// <param name="factoryFn">The factory fn.</param> /// <returns>System.Object.</returns> /// <exception cref="System.ArgumentNullException">cacheKey</exception> protected object ToOptimizedResultUsingCache <T>(Guid cacheKey, DateTime lastDateModified, TimeSpan?cacheDuration, Func <T> factoryFn) where T : class { return(ResultFactory.GetOptimizedResultUsingCache(RequestContext, cacheKey, lastDateModified, cacheDuration, factoryFn)); }
/// <summary> /// Processes the request. /// </summary> /// <param name="request">The request.</param> /// <param name="isHeadRequest">if set to <c>true</c> [is head request].</param> /// <returns>Task.</returns> protected async Task <object> ProcessRequest(StreamRequest request, bool isHeadRequest) { var cancellationTokenSource = new CancellationTokenSource(); var state = await GetState(request, cancellationTokenSource.Token).ConfigureAwait(false); var responseHeaders = new Dictionary <string, string>(); if (request.Static && state.DirectStreamProvider != null) { AddDlnaHeaders(state, responseHeaders, true); using (state) { var outputHeaders = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); // TODO: Don't hardcode this outputHeaders[HeaderNames.ContentType] = Model.Net.MimeTypes.GetMimeType("file.ts"); return(new ProgressiveFileCopier(state.DirectStreamProvider, outputHeaders, null, Logger, CancellationToken.None) { AllowEndOfFile = false }); } } // Static remote stream if (request.Static && state.InputProtocol == MediaProtocol.Http) { AddDlnaHeaders(state, responseHeaders, true); using (state) { return(await GetStaticRemoteStreamResult(state, responseHeaders, isHeadRequest, cancellationTokenSource).ConfigureAwait(false)); } } if (request.Static && state.InputProtocol != MediaProtocol.File) { throw new ArgumentException(string.Format("Input protocol {0} cannot be streamed statically.", state.InputProtocol)); } var outputPath = state.OutputFilePath; var outputPathExists = File.Exists(outputPath); var transcodingJob = ApiEntryPoint.Instance.GetTranscodingJob(outputPath, TranscodingJobType.Progressive); var isTranscodeCached = outputPathExists && transcodingJob != null; AddDlnaHeaders(state, responseHeaders, request.Static || isTranscodeCached); // Static stream if (request.Static) { var contentType = state.GetMimeType("." + state.OutputContainer, false) ?? state.GetMimeType(state.MediaPath); using (state) { if (state.MediaSource.IsInfiniteStream) { var outputHeaders = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase) { [HeaderNames.ContentType] = contentType }; return(new ProgressiveFileCopier(FileSystem, state.MediaPath, outputHeaders, null, Logger, CancellationToken.None) { AllowEndOfFile = false }); } TimeSpan?cacheDuration = null; if (!string.IsNullOrEmpty(request.Tag)) { cacheDuration = TimeSpan.FromDays(365); } return(await ResultFactory.GetStaticFileResult(Request, new StaticFileResultOptions { ResponseHeaders = responseHeaders, ContentType = contentType, IsHeadRequest = isHeadRequest, Path = state.MediaPath, CacheDuration = cacheDuration }).ConfigureAwait(false)); } } //// Not static but transcode cache file exists //if (isTranscodeCached && state.VideoRequest == null) //{ // var contentType = state.GetMimeType(outputPath); // try // { // if (transcodingJob != null) // { // ApiEntryPoint.Instance.OnTranscodeBeginRequest(transcodingJob); // } // return await ResultFactory.GetStaticFileResult(Request, new StaticFileResultOptions // { // ResponseHeaders = responseHeaders, // ContentType = contentType, // IsHeadRequest = isHeadRequest, // Path = outputPath, // FileShare = FileShareMode.ReadWrite, // OnComplete = () => // { // if (transcodingJob != null) // { // ApiEntryPoint.Instance.OnTranscodeEndRequest(transcodingJob); // } // } // }).ConfigureAwait(false); // } // finally // { // state.Dispose(); // } //} // Need to start ffmpeg try { return(await GetStreamResult(request, state, responseHeaders, isHeadRequest, cancellationTokenSource).ConfigureAwait(false)); } catch { state.Dispose(); throw; } }
/// <summary> /// To the cached result. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="cacheKey">The cache key.</param> /// <param name="lastDateModified">The last date modified.</param> /// <param name="cacheDuration">Duration of the cache.</param> /// <param name="factoryFn">The factory fn.</param> /// <param name="contentType">Type of the content.</param> /// <returns>System.Object.</returns> /// <exception cref="System.ArgumentNullException">cacheKey</exception> protected object ToCachedResult <T>(Guid cacheKey, DateTime lastDateModified, TimeSpan?cacheDuration, Func <T> factoryFn, string contentType) where T : class { return(ResultFactory.GetCachedResult(RequestContext, cacheKey, lastDateModified, cacheDuration, factoryFn, contentType)); }
/// <summary> /// Processes the request async. /// </summary> /// <param name="request">The request.</param> /// <param name="isLive">if set to <c>true</c> [is live].</param> /// <returns>Task{System.Object}.</returns> /// <exception cref="ArgumentException">A video bitrate is required /// or /// An audio bitrate is required</exception> private async Task <object> ProcessRequestAsync(StreamRequest request, bool isLive) { var cancellationTokenSource = new CancellationTokenSource(); var state = await GetState(request, cancellationTokenSource.Token).ConfigureAwait(false); if (isLive) { state.Request.StartTimeTicks = null; } var playlist = state.OutputFilePath; if (!File.Exists(playlist)) { await ApiEntryPoint.Instance.TranscodingStartLock.WaitAsync(cancellationTokenSource.Token).ConfigureAwait(false); try { if (!File.Exists(playlist)) { // If the playlist doesn't already exist, startup ffmpeg try { await StartFfMpeg(state, playlist, cancellationTokenSource).ConfigureAwait(false); } catch { state.Dispose(); throw; } var waitCount = isLive ? 2 : 2; await WaitForMinimumSegmentCount(playlist, waitCount, cancellationTokenSource.Token).ConfigureAwait(false); } } finally { ApiEntryPoint.Instance.TranscodingStartLock.Release(); } } if (isLive) { return(ResultFactory.GetResult(GetLivePlaylistText(playlist, state.SegmentLength), MimeTypes.GetMimeType("playlist.m3u8"), new Dictionary <string, string>())); } var audioBitrate = state.OutputAudioBitrate ?? 0; var videoBitrate = state.OutputVideoBitrate ?? 0; var appendBaselineStream = false; var baselineStreamBitrate = 64000; var hlsVideoRequest = state.VideoRequest as GetHlsVideoStream; if (hlsVideoRequest != null) { appendBaselineStream = hlsVideoRequest.AppendBaselineStream; baselineStreamBitrate = hlsVideoRequest.BaselineStreamAudioBitRate ?? baselineStreamBitrate; } var playlistText = GetMasterPlaylistFileText(playlist, videoBitrate + audioBitrate, appendBaselineStream, baselineStreamBitrate); return(ResultFactory.GetResult(playlistText, MimeTypes.GetMimeType("playlist.m3u8"), new Dictionary <string, string>())); }
/// <summary> /// To the static file result. /// </summary> /// <param name="path">The path.</param> /// <returns>System.Object.</returns> protected object ToStaticFileResult(string path) { return(ResultFactory.GetStaticFileResult(RequestContext, path)); }
/// <summary> /// 200 - Ok response. /// </summary> public static CreateItemResult Ok(string?message = null) => new CreateItemResult(ResultFactory.CreateContentResult(HttpStatusCode.OK, message));
/// <summary> /// Gets the static remote stream result. /// </summary> /// <param name="state">The state.</param> /// <param name="responseHeaders">The response headers.</param> /// <param name="isHeadRequest">if set to <c>true</c> [is head request].</param> /// <param name="cancellationTokenSource">The cancellation token source.</param> /// <returns>Task{System.Object}.</returns> private async Task <object> GetStaticRemoteStreamResult(StreamState state, Dictionary <string, string> responseHeaders, bool isHeadRequest, CancellationTokenSource cancellationTokenSource) { string useragent = null; state.RemoteHttpHeaders.TryGetValue("User-Agent", out useragent); var trySupportSeek = false; var options = new HttpRequestOptions { Url = state.MediaPath, UserAgent = useragent, BufferContent = false, CancellationToken = cancellationTokenSource.Token }; if (trySupportSeek) { if (!string.IsNullOrWhiteSpace(Request.QueryString["Range"])) { options.RequestHeaders["Range"] = Request.QueryString["Range"]; } } var response = await HttpClient.GetResponse(options).ConfigureAwait(false); if (trySupportSeek) { foreach (var name in new[] { "Content-Range", "Accept-Ranges" }) { var val = response.Headers[name]; if (!string.IsNullOrWhiteSpace(val)) { responseHeaders[name] = val; } } } else { responseHeaders["Accept-Ranges"] = "none"; } // Seeing cases of -1 here if (response.ContentLength.HasValue && response.ContentLength.Value >= 0) { responseHeaders["Content-Length"] = response.ContentLength.Value.ToString(UsCulture); } if (isHeadRequest) { using (response) { return(ResultFactory.GetResult(null, new byte[] { }, response.ContentType, responseHeaders)); } } var result = new StaticRemoteStreamWriter(response); result.Headers["Content-Type"] = response.ContentType; // Add the response headers to the result object foreach (var header in responseHeaders) { result.Headers[header.Key] = header.Value; } return(result); }
/// <summary> /// Gets the specified request. /// </summary> /// <param name="request">The request.</param> /// <returns>System.Object.</returns> public object Get(GetDashboardConfigurationPage request) { var page = ServerEntryPoint.Instance.PluginConfigurationPages.First(p => p.Name.Equals(request.Name, StringComparison.OrdinalIgnoreCase)); return(ResultFactory.GetStaticResult(Request, page.Plugin.Version.ToString().GetMD5(), null, null, MimeTypes.GetMimeType("page.html"), () => GetPackageCreator().ModifyHtml(page.GetHtmlStream(), null, _appHost.ApplicationVersion.ToString(), null, false))); }
/// <summary> Gets the given request. </summary> /// <param name="request"> The request. </param> /// <returns> A Task<object> </returns> public async Task <object> Get(GetReportDownload request) { if (string.IsNullOrEmpty(request.IncludeItemTypes)) { return(null); } request.DisplayType = "Export"; ReportViewType reportViewType = ReportHelper.GetReportViewType(request.ReportView); var headers = new Dictionary <string, string>(); string fileExtension = "csv"; string contentType = "text/plain;charset='utf-8'"; switch (request.ExportType) { case ReportExportType.CSV: break; case ReportExportType.Excel: contentType = "application/vnd.ms-excel"; fileExtension = "xls"; break; } var filename = "ReportExport." + fileExtension; headers["Content-Disposition"] = string.Format("attachment; filename=\"{0}\"", filename); headers["Content-Encoding"] = "UTF-8"; var user = !string.IsNullOrWhiteSpace(request.UserId) ? _userManager.GetUserById(request.UserId) : null; ReportResult result = null; switch (reportViewType) { case ReportViewType.ReportData: ReportIncludeItemTypes reportRowType = ReportHelper.GetRowType(request.IncludeItemTypes); ReportBuilder dataBuilder = new ReportBuilder(_libraryManager); QueryResult <BaseItem> queryResult = await GetQueryResult(request, user).ConfigureAwait(false); result = dataBuilder.GetResult(queryResult.Items, request); result.TotalRecordCount = queryResult.TotalRecordCount; break; case ReportViewType.ReportActivities: result = GetReportActivities(request); break; } string returnResult = string.Empty; switch (request.ExportType) { case ReportExportType.CSV: returnResult = new ReportExport().ExportToCsv(result); break; case ReportExportType.Excel: returnResult = new ReportExport().ExportToExcel(result); break; } return(ResultFactory.GetResult(returnResult, contentType, headers)); }
public async Task <object> Get(GetRemoteSubtitles request) { var result = await _subtitleManager.GetRemoteSubtitles(request.Id, CancellationToken.None).ConfigureAwait(false); return(ResultFactory.GetResult(Request, result.Stream, MimeTypes.GetMimeType("file." + result.Format))); }
/// <summary> /// Gets the specified request. /// </summary> /// <param name="request">The request.</param> /// <returns>System.Object.</returns> public object Get(GetDashboardInfo request) { var result = GetDashboardInfo(_appHost, _taskManager, _sessionManager, _dtoService); return(ResultFactory.GetOptimizedResult(RequestContext, result)); }
public async Task <IHttpActionResult> GetAll() { return(await ResultFactory.Create(ModelState, async arg => await aWProductService.GetAllAsync(), "", "success", "未知")); }
public object Get(GetImage request) { var stream = GetType().Assembly.GetManifestResourceStream(GetType().Namespace + ".Images." + request.Name); return(ResultFactory.GetResult(stream, "image/png")); }