/// <inheritdoc />
protected override Task WriteFileAsync(HttpResponse response)
{
var bufferingFeature = response.HttpContext.Features.Get<IHttpBufferingFeature>();
bufferingFeature?.DisableResponseBuffering();
return response.Body.WriteAsync(FileContents, offset: 0, count: FileContents.Length);
}
/// <inheritdoc />
protected override async Task WriteFileAsync(HttpResponse response, CancellationToken cancellation)
{
if (!Path.IsPathRooted(FileName))
{
throw new FileNotFoundException(Resources.FormatFileResult_InvalidPath(FileName), FileName);
}
var sendFile = response.HttpContext.Features.Get<IHttpSendFileFeature>();
if (sendFile != null)
{
await sendFile.SendFileAsync(
FileName,
offset: 0,
length: null,
cancellation: cancellation);
return;
}
else
{
var fileStream = GetFileStream(FileName);
using (fileStream)
{
await fileStream.CopyToAsync(response.Body, DefaultBufferSize, cancellation);
}
return;
}
}
public StaticFileContext(HttpContext context, StaticFileOptions options, PathString matchUrl, ILogger logger)
{
_context = context;
_options = options;
_matchUrl = matchUrl;
_request = context.Request;
_response = context.Response;
_logger = logger;
_requestHeaders = _request.GetTypedHeaders();
_responseHeaders = _response.GetTypedHeaders();
_method = null;
_isGet = false;
_isHead = false;
_subPath = PathString.Empty;
_contentType = null;
_fileInfo = null;
_length = 0;
_lastModified = new DateTimeOffset();
_etag = null;
_ifMatchState = PreconditionState.Unspecified;
_ifNoneMatchState = PreconditionState.Unspecified;
_ifModifiedSinceState = PreconditionState.Unspecified;
_ifUnmodifiedSinceState = PreconditionState.Unspecified;
_ranges = null;
}
/// <inheritdoc />
protected override async Task WriteFileAsync(HttpResponse response)
{
if (!Path.IsPathRooted(FileName))
{
throw new NotSupportedException(Resources.FormatFileResult_PathNotRooted(FileName));
}
var sendFile = response.HttpContext.Features.Get<IHttpSendFileFeature>();
if (sendFile != null)
{
await sendFile.SendFileAsync(
FileName,
offset: 0,
length: null,
cancellation: default(CancellationToken));
}
else
{
var fileStream = GetFileStream(FileName);
using (fileStream)
{
await fileStream.CopyToAsync(response.Body, DefaultBufferSize);
}
}
}
internal static HttpResponsePacket ToHttpResponse(HttpResponse response, ServiceMessage msg)
{
var rsp = new HttpResponsePacket();
foreach (var hdr in response.Headers)
{
// TODO: Fix adding response headers
//AddHttpHeader(hdr);
}
//TODO: Decide if to read mostly from ServiceMessage or from response.
//rsp.Version = response.... //TODO: Add a default version here
rsp.StatusCode = (int)response.StatusCode;
rsp.StatusDescription = ((IHttpResponseFeature)msg).ReasonPhrase;
if (response.Body != null)
{
using (MemoryStream ms = new MemoryStream())
{
response.Body.Position = 0;
response.Body.CopyTo(ms);
rsp.Content = ms.ToArray();
}
}
return rsp;
}
/// <inheritdoc />
protected override Task WriteFileAsync(HttpResponse response, CancellationToken cancellation)
{
var bufferingFeature = response.HttpContext.Features.Get<IHttpBufferingFeature>();
bufferingFeature?.DisableResponseBuffering();
return response.Body.WriteAsync(FileContents, 0, FileContents.Length, cancellation);
}
/// <inheritdoc />
protected async override Task WriteFileAsync(HttpResponse response, CancellationToken cancellation)
{
var outputStream = response.Body;
using (FileStream)
{
await FileStream.CopyToAsync(outputStream, BufferSize, cancellation);
}
}
private void SetCacheHeaders(HttpResponse response)
{
if (_options.CacheLength != null)
{
var expires = DateTime.Now.AddSeconds(_options.CacheLength.TotalSeconds);
response.Headers.SetCommaSeparatedValues("Cache-Control", "public", $"max-age={_options.CacheLength.TotalSeconds}");
response.Headers.Set("Expires", expires.ToUniversalTime().ToString("R"));
}
}
private void RespondWithSwaggerJson(HttpResponse response, SwaggerDocument swagger)
{
response.StatusCode = 200;
response.ContentType = "application/json";
using (var writer = new StreamWriter(response.Body))
{
_swaggerSerializer.Serialize(writer, swagger);
}
}
private void SerializeResponseObject(HttpResponse response, object value)
{
using (var writer = new StreamWriter(response.Body))
{
using (var jsonWriter = new JsonTextWriter(writer))
{
jsonWriter.CloseOutput = false;
var jsonSerializer = JsonSerializer.Create(/*TODO: SerializerSettings*/);
jsonSerializer.Serialize(jsonWriter, value);
}
}
}
/// <inheritdoc />
protected async override Task WriteFileAsync(HttpResponse response, CancellationToken cancellation)
{
var outputStream = response.Body;
using (FileStream)
{
var bufferingFeature = response.HttpContext.Features.Get<IHttpBufferingFeature>();
bufferingFeature?.DisableResponseBuffering();
await FileStream.CopyToAsync(outputStream, BufferSize, cancellation);
}
}
internal static Task WriteResponseBodyAsync(HttpResponse response, string uid, DateTimeOffset? datetime, TimeSpan? duration, string summary, string description, string location) {
return response.WriteAsync(
"BEGIN:VCALENDAR\r\n" +
"VERSION:2.0\r\n" +
"BEGIN:VEVENT\r\n" +
"UID:" + uid + "\r\n" +
"DTSTART:" + datetime?.ToString(DateTimeFormat) + "\r\n" +
"DTEND:" + datetime?.Add(duration ?? TimeSpan.Zero).ToString(DateTimeFormat) + "\r\n" +
"SUMMARY:" + summary + "\r\n" +
"DESCRIPTION:" + description + "\r\n" +
"LOCATION:" + location +
"END:VEVENT\r\n" +
"END:VCALENDAR\r\n");
}
public static void AddLocationHeaderToMapping(
HttpResponse response,
IDictionary<string, string> contentIdToLocationMapping,
string contentId)
{
//Contract.Assert(response != null);
//Contract.Assert(contentIdToLocationMapping != null);
//Contract.Assert(contentId != null);
//if (response.Headers.Location != null)
//{
// contentIdToLocationMapping.Add(contentId, response.Headers.Location.AbsoluteUri);
//}
throw new NotImplementedException("AddLocationHeaderToMapping");
}
public static async Task WriteOutput(HttpResponse Response, string Title, Head.Tag[] HeadTags, string Body) {
var sb = new StringBuilder();
sb.Append("<!DOCTYPE html><head><meta charset=\"utf-8\">");
if (Title != null) {
sb.Append("<title>" + Title + "</title>");
}
if (HeadTags != null) {
foreach (var a in HeadTags) {
sb.Append(a.Output());
}
}
sb.Append("</head><body>");
sb.Append(Body);
sb.Append("</body></html>");
await Response.WriteAsync(sb.ToString());
}
/// <inheritdoc />
protected override Task WriteFileAsync(HttpResponse response, CancellationToken cancellation)
{
var fileProvider = GetFileProvider(response.HttpContext.RequestServices);
var resolveFilePathResult = ResolveFilePath(fileProvider);
if (resolveFilePathResult.PhysicalFilePath != null)
{
return CopyPhysicalFileToResponseAsync(response, resolveFilePathResult.PhysicalFilePath, cancellation);
}
else
{
// Example: An embedded resource
var sourceStream = resolveFilePathResult.FileInfo.CreateReadStream();
return CopyStreamToResponseAsync(sourceStream, response, cancellation);
}
}
private static ActionContext CreateMockActionContext(
HttpResponse response = null,
string requestAcceptHeader = "application/*",
string requestContentType = "application/json",
string requestAcceptCharsetHeader = "",
bool respectBrowserAcceptHeader = false)
{
var httpContext = new Mock<HttpContext>();
if (response != null)
{
httpContext.Setup(o => o.Response).Returns(response);
}
var content = "{name: 'Person Name', Age: 'not-an-age'}";
var contentBytes = Encoding.UTF8.GetBytes(content);
var request = new DefaultHttpContext().Request;
request.Headers["Accept-Charset"] = requestAcceptCharsetHeader;
request.Headers["Accept"] = requestAcceptHeader;
request.ContentType = requestContentType;
request.Body = new MemoryStream(contentBytes);
httpContext.Setup(o => o.Request).Returns(request);
httpContext.Setup(o => o.RequestServices).Returns(GetServiceProvider());
var optionsAccessor = new MockMvcOptionsAccessor();
optionsAccessor.Options.OutputFormatters.Add(new StringOutputFormatter());
optionsAccessor.Options.OutputFormatters.Add(new JsonOutputFormatter());
optionsAccessor.Options.RespectBrowserAcceptHeader = respectBrowserAcceptHeader;
var mockContextAccessor = new Mock<IScopedInstance<ActionBindingContext>>();
mockContextAccessor
.SetupGet(o => o.Value)
.Returns(new ActionBindingContext()
{
OutputFormatters = optionsAccessor.Options.OutputFormatters
});
httpContext.Setup(o => o.RequestServices.GetService(typeof(IScopedInstance<ActionBindingContext>)))
.Returns(mockContextAccessor.Object);
httpContext.Setup(o => o.RequestServices.GetService(typeof(IOptions<MvcOptions>)))
.Returns(optionsAccessor);
httpContext.Setup(o => o.RequestServices.GetService(typeof(ILogger<ObjectResult>)))
.Returns(new Mock<ILogger<ObjectResult>>().Object);
return new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor());
}
public Core(Server server, HttpContext context, string viewstate = "", string type = "")
{
Server = server;
Context = context;
Request = context.Request;
Response = context.Response;
Session = context.Session;
Sql = new Sql(this);
Util = new Utility.Util(this);
User = new User();
//load viewstate
if (useViewState == true)
{
ViewStateId = viewstate;
if(ViewStateId == "") { ViewStateId = Util.Str.CreateID(); }
if (Session["viewstate-" + ViewStateId] != null)
{
ViewState vs = new ViewState();
vs = (ViewState)Util.Serializer.ReadObject(Util.Str.GetString(Session["viewstate-" + ViewStateId]), vs.GetType());
Page = vs.Page;
Elements = new Elements(this, Page.themeFolder);
}else { Page = new Page(); }
}else { Page = new Page(); }
if (Session["user"] != null)
{
User = (User)Util.Serializer.ReadObject(Util.Str.GetString(Session["user"]), User.GetType());
}
//load references to Core R
Sql.Load();
Page.Load(this);
User.Load(this);
//generate visitor id
if (User.visitorId == "" || User.visitorId == null) { User.visitorId = Util.Str.CreateID(); }
//detect request type & host type
if (type == "service") { isWebService = true; }
if (Request.Host.Value.IndexOf("localhost") >= 0 || Request.Host.Value.IndexOf("192.168.") >= 0) { isLocal = true; }
}
/// <inheritdoc />
protected override async Task WriteFileAsync(HttpResponse response, CancellationToken cancellation)
{
var fileProvider = GetFileProvider(response.HttpContext.RequestServices);
var normalizedPath = FileName;
if (normalizedPath.StartsWith("~"))
{
normalizedPath = normalizedPath.Substring(1);
}
var fileInfo = fileProvider.GetFileInfo(normalizedPath);
if (fileInfo.Exists)
{
var physicalPath = fileInfo.PhysicalPath;
var sendFile = response.HttpContext.Features.Get<IHttpSendFileFeature>();
if (sendFile != null && !string.IsNullOrEmpty(physicalPath))
{
await sendFile.SendFileAsync(
physicalPath,
offset: 0,
length: null,
cancellation: cancellation);
return;
}
else
{
var fileStream = GetFileStream(fileInfo);
using (fileStream)
{
await fileStream.CopyToAsync(response.Body, DefaultBufferSize, cancellation);
}
return;
}
}
throw new FileNotFoundException(
Resources.FormatFileResult_InvalidPath(FileName), FileName);
}
private static ActionContext CreateMockActionContext(
HttpResponse response = null,
string requestAcceptHeader = "application/*",
string requestContentType = "application/json",
string requestAcceptCharsetHeader = "",
bool respectBrowserAcceptHeader = false)
{
var formatters = new IOutputFormatter[] { new StringOutputFormatter(), new JsonOutputFormatter() };
var httpContext = new Mock<HttpContext>();
if (response != null)
{
httpContext.Setup(o => o.Response).Returns(response);
}
var content = "{name: 'Person Name', Age: 'not-an-age'}";
var contentBytes = Encoding.UTF8.GetBytes(content);
var request = new DefaultHttpContext().Request;
request.Headers["Accept-Charset"] = requestAcceptCharsetHeader;
request.Headers["Accept"] = requestAcceptHeader;
request.ContentType = requestContentType;
request.Body = new MemoryStream(contentBytes);
httpContext.Setup(o => o.Request).Returns(request);
httpContext.Setup(o => o.RequestServices).Returns(GetServiceProvider());
httpContext.Setup(o => o.RequestServices.GetService(typeof(IOutputFormattersProvider)))
.Returns(new TestOutputFormatterProvider(formatters));
var options = new Mock<IOptions<MvcOptions>>();
options.SetupGet(o => o.Options)
.Returns(new MvcOptions()
{
RespectBrowserAcceptHeader = respectBrowserAcceptHeader
});
httpContext.Setup(o => o.RequestServices.GetService(typeof(IOptions<MvcOptions>)))
.Returns(options.Object);
return new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor());
}
public IBookshelfSession GetSession(HttpResponse response,string userName, string clientId,string userEmail)
{
var hashCode = GetSessionHashCode(userName, clientId);
IBookshelfSession session;
var sessionFound = _sessions.TryGetValue(hashCode, out session);
if (sessionFound && session.IsExpired())
{
//remove expired session - IsExpired removes expired session by it's call
//esnure session not found workflow is going to be applied
sessionFound = false;
}
//if there is no such session in storage, or there is but it's expired - create new one
if (!sessionFound)
{
var userInfo = new InSessionUserInfo { UserEmail = userEmail, UserClientId = clientId, UserName = userName };
session = CreateServerSession(hashCode, userInfo,response);
//check if there is proper active device alreadybeen created
if (_cache.Get(userName) != null)
{
Dictionary<string, IBookshelfSession> deviceSessions =
(Dictionary<string, IBookshelfSession>) _cache.Get(userName);
if (!deviceSessions.ContainsKey(clientId))
{
deviceSessions.Add(clientId, session);
}
}
else
{
_cache.Set(userName, new Dictionary<string, IBookshelfSession>
{
{
clientId, session
}
});
}
}
return session;
}
private static ActionContext CreateMockActionContext(
IEnumerable<IOutputFormatter> outputFormatters,
HttpResponse response = null,
string requestAcceptHeader = "application/*",
string requestContentType = "application/json",
string requestAcceptCharsetHeader = "",
bool respectBrowserAcceptHeader = false,
bool setupActionBindingContext = true)
{
var httpContext = new Mock<HttpContext>();
if (response != null)
{
httpContext.Setup(o => o.Response).Returns(response);
}
var content = "{name: 'Person Name', Age: 'not-an-age'}";
var contentBytes = Encoding.UTF8.GetBytes(content);
var request = new DefaultHttpContext().Request;
request.Headers["Accept-Charset"] = requestAcceptCharsetHeader;
request.Headers["Accept"] = requestAcceptHeader;
request.ContentType = requestContentType;
request.Body = new MemoryStream(contentBytes);
httpContext.Setup(o => o.Request).Returns(request);
httpContext.Setup(o => o.RequestServices).Returns(GetServiceProvider());
var optionsAccessor = new MockMvcOptionsAccessor();
foreach (var formatter in outputFormatters)
{
optionsAccessor.Options.OutputFormatters.Add(formatter);
}
optionsAccessor.Options.RespectBrowserAcceptHeader = respectBrowserAcceptHeader;
httpContext.Setup(o => o.RequestServices.GetService(typeof(IOptions<MvcOptions>)))
.Returns(optionsAccessor);
httpContext.Setup(o => o.RequestServices.GetService(typeof(ILogger<ObjectResult>)))
.Returns(new Mock<ILogger<ObjectResult>>().Object);
ActionBindingContext actionBindingContext = null;
if (setupActionBindingContext)
{
actionBindingContext = new ActionBindingContext { OutputFormatters = outputFormatters.ToList() };
}
httpContext.Setup(o => o.RequestServices.GetService(typeof(IActionBindingContextAccessor)))
.Returns(new ActionBindingContextAccessor() { ActionBindingContext = actionBindingContext });
return new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor());
}
public async Task WriteOtherSettingsAsync(HttpResponse response)
{
await response.WriteAsync(
$"OtherSettings Strings: {string.Join(", ", _otherSettings.Strings)}<br>" +
$"OtherSettings Numbers: {string.Join(", ", _otherSettings.Numbers)}");
}
private static ActionContext CreateMockActionContext(
HttpResponse response = null,
string requestAcceptHeader = "application/*",
string requestContentType = "application/json",
string requestAcceptCharsetHeader = "",
bool respectBrowserAcceptHeader = false)
{
var formatters = new IOutputFormatter[] { new StringOutputFormatter(), new JsonOutputFormatter() };
return CreateMockActionContext(
formatters,
response: response,
requestAcceptHeader: requestAcceptHeader,
requestContentType: requestContentType,
requestAcceptCharsetHeader: requestAcceptCharsetHeader,
respectBrowserAcceptHeader: respectBrowserAcceptHeader);
}
private void RespondWithContentHtml(HttpResponse response, Stream content)
{
response.StatusCode = 200;
response.ContentType = "text/html";
content.CopyTo(response.Body);
}
/// <inheritdoc />
public virtual void ApplyResult(CorsResult result, HttpResponse response)
{
var headers = response.Headers;
if (result.AllowedOrigin != null)
{
headers.Add(CorsConstants.AccessControlAllowOrigin, new[] { result.AllowedOrigin });
}
if (result.VaryByOrigin)
{
headers.Set("Vary", "Origin");
}
if (result.SupportsCredentials)
{
headers.Add(CorsConstants.AccessControlAllowCredentials, new[] { "true" });
}
if (result.AllowedMethods.Count > 0)
{
// Filter out simple methods
var nonSimpleAllowMethods = result.AllowedMethods
.Where(m =>
!CorsConstants.SimpleMethods.Contains(m, StringComparer.OrdinalIgnoreCase))
.ToArray();
if (nonSimpleAllowMethods.Length > 0)
{
headers.SetCommaSeparatedValues(
CorsConstants.AccessControlAllowMethods,
nonSimpleAllowMethods);
}
}
if (result.AllowedHeaders.Count > 0)
{
// Filter out simple request headers
var nonSimpleAllowRequestHeaders = result.AllowedHeaders
.Where(header =>
!CorsConstants.SimpleRequestHeaders.Contains(header, StringComparer.OrdinalIgnoreCase))
.ToArray();
if (nonSimpleAllowRequestHeaders.Length > 0)
{
headers.SetCommaSeparatedValues(
CorsConstants.AccessControlAllowHeaders,
nonSimpleAllowRequestHeaders);
}
}
if (result.AllowedExposedHeaders.Count > 0)
{
// Filter out simple response headers
var nonSimpleAllowResponseHeaders = result.AllowedExposedHeaders
.Where(header =>
!CorsConstants.SimpleResponseHeaders.Contains(header, StringComparer.OrdinalIgnoreCase))
.ToArray();
if (nonSimpleAllowResponseHeaders.Length > 0)
{
headers.SetCommaSeparatedValues(
CorsConstants.AccessControlExposeHeaders,
nonSimpleAllowResponseHeaders);
}
}
if (result.PreflightMaxAge.HasValue)
{
headers.Set(
CorsConstants.AccessControlMaxAge,
result.PreflightMaxAge.Value.TotalSeconds.ToString());
}
}
public static async Task WriteJsonAsync(this HttpResponse response, object o)
{
var json = JsonConvert.SerializeObject(o, settings);
await response.WriteJsonAsync(json);
}
private static void Describe(HttpResponse res, AuthenticateContext result)
{
res.StatusCode = 200;
res.ContentType = "text/xml";
var xml = new XElement("xml");
if (result != null && result.Principal != null)
{
xml.Add(result.Principal.Claims.Select(claim => new XElement("claim", new XAttribute("type", claim.Type), new XAttribute("value", claim.Value))));
}
if (result != null && result.Properties != null)
{
xml.Add(result.Properties.Select(extra => new XElement("extra", new XAttribute("type", extra.Key), new XAttribute("value", extra.Value))));
}
using (var memory = new MemoryStream())
{
using (var writer = new XmlTextWriter(memory, Encoding.UTF8))
{
xml.WriteTo(writer);
}
res.Body.Write(memory.ToArray(), 0, memory.ToArray().Length);
}
}
private static string ReadBody(HttpResponse response)
{
response.Body.Seek(0, SeekOrigin.Begin);
using (var reader = new StreamReader(response.Body))
{
return reader.ReadToEnd();
}
}
protected override Task WriteFileAsync(HttpResponse response, CancellationToken cancellation)
{
WasWriteFileCalled = true;
return Task.FromResult(0);
}
public static async Task WriteJsonAsync(this HttpResponse response, string json)
{
response.ContentType = "application/json";
await response.WriteAsync(json);
}
public static void SetNoCache(this HttpResponse response)
{
response.Headers.Add("Cache-Control", "no-store, no-cache, max-age=0");
response.Headers.Add("Pragma", "no-cache");
}
private static void Describe(HttpResponse res, ClaimsPrincipal principal)
{
res.StatusCode = 200;
res.ContentType = "text/xml";
var xml = new XElement("xml");
if (principal != null)
{
foreach (var identity in principal.Identities)
{
xml.Add(identity.Claims.Select(claim => new XElement("claim", new XAttribute("type", claim.Type), new XAttribute("value", claim.Value))));
}
}
using (var memory = new MemoryStream())
{
using (var writer = new XmlTextWriter(memory, Encoding.UTF8))
{
xml.WriteTo(writer);
}
res.Body.Write(memory.ToArray(), 0, memory.ToArray().Length);
}
}
/// <summary> /// Writes the file to the response. /// </summary> /// <param name="response"> /// The <see cref="HttpResponse"/> where the file will be written /// </param> /// <param name="cancellation">The <see cref="CancellationToken"/>to cancel the operation.</param> /// <returns> /// A <see cref="Task"/> that will complete when the file has been written to the response. /// </returns> protected abstract Task WriteFileAsync(HttpResponse response, CancellationToken cancellation);
public HttpResponse(Microsoft.AspNet.Http.HttpResponse response)
{
_response = response;
}
