public Task HandleRequest(HttpContext context, Entity ent)
{
#if NET48
var method = ent.GetMethod(context.Request.HttpMethod);
#else
var method = ent.GetMethod(context.Request.Method);
#endif
foreach (var interceptor in this.requestInterceptors)
{
var shouldIntercept = interceptor.OnBeforeRequest(context, new RequestInterceptorContext(
ent, method, this.dbConnection));
if (shouldIntercept != null)
{
context.Response.StatusCode = shouldIntercept.Value.statusCode;
return(HttpHandlingUtils.HttpContentToResponse(shouldIntercept.Value.responseContent, context.Response));
}
}
#if NET48
var accept = (context.Request.Headers["Accept"] ?? "").Split(',').Select(ac => MediaTypeHeaderValue.Parse(ac)).ToList();
#else
var accept = context.Request.GetTypedHeaders().Accept;
#endif
IGenericSPSerializer?serializer = serializerResolver.GetSerialializerOrNull(accept,
ent, method);
if (serializer == null)
{
context.Response.StatusCode = 415;
return(Task.CompletedTask);
}
if (this.sPMiddlewareOptions.RequireAuthenticated && context.User?.Identity == null)
{
context.Response.StatusCode = 401;
return(Task.CompletedTask);
}
#if NET48
if (context.Request.HttpMethod.ToUpper() == "GET")
#else
if (context.Request.Method.ToUpper() == "GET")
#endif
{
return(HandleGetRequest(context, ent, serializer));
}
return(HandleBodyRequest(context, method, ent, serializer));
}
/// <summary>
/// Writes the result data to the body
/// </summary>
/// <param name="context">The HttpContext</param>
/// <param name="cmd">The Db Command</param>
/// <param name="method">The Http/SP mapping</param>
/// <param name="ent">The Entity mapping</param>
/// <returns>A Task</returns>
public async Task ReadResultToBody(SerializationContext serializationContext)
{
var context = serializationContext.HttpContext;
var method = serializationContext.Method;
var ent = serializationContext.Entity;
bool html = IsHtmlRequest(context);
#if !NETSTD2 && !NETFX
var syncIOFeature = context.Features.Get <Microsoft.AspNetCore.Http.Features.IHttpBodyControlFeature>();
if (syncIOFeature != null)
{
syncIOFeature.AllowSynchronousIO = true;
}
#endif
try
{
using (var rdr = await serializationContext.ExecuteReaderAsync())
{
bool firstRead = rdr.Read();
await PrepareHeader(context, method, ent, 200);
#if NET48
using (var xmlWriter = new System.Xml.XmlTextWriter(context.Response.OutputStream, options.Encoding))
#else
using (var xmlWriter = new System.Xml.XmlTextWriter(context.Response.Body, options.Encoding))
#endif
{
string[] fieldNames = new string[rdr.FieldCount];
for (int i = 0; i < fieldNames.Length; i++)
{
fieldNames[i] = rdr.GetName(i);
}
fieldNames = namingMappingHandler.GetNames(fieldNames).ToArray();
xmlWriter.WriteStartElement("table");
{
if (html)
{
xmlWriter.WriteStartElement("thead");
{
xmlWriter.WriteStartElement("tr");
foreach (var field in fieldNames)
{
xmlWriter.WriteStartElement("th");
xmlWriter.WriteValue(field);
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();//thead
xmlWriter.WriteStartElement("tbody");
}
while (firstRead || rdr.Read())
{
firstRead = false;
xmlWriter.WriteStartElement("tr");
for (int p = 0; p < fieldNames.Length; p++)
{
xmlWriter.WriteStartElement(html ? "td" : fieldNames[p]);
object vl = rdr.GetValue(p);
xmlWriter.WriteValue(vl == DBNull.Value ? null : vl);
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
if (html)
{
xmlWriter.WriteEndElement();
}
}
xmlWriter.WriteEndElement();
}
}
}
catch (Exception err)
{
bool handled = false;
foreach (var hand in errorHandlers)
{
var result = hand.GetContent(err, o =>
{
var ser = new System.Xml.Serialization.XmlSerializer(o.GetType());
string xml;
using (var strW = new System.IO.StringWriter())
{
ser.Serialize(strW, o);
xml = strW.ToString();
}
var content = new System.Net.Http.StringContent(xml);
content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/xml");
return(content);
});
if (result != null)
{
(var status, var content) = result.Value;
#if NET48
if (!context.Response.HeadersWritten)
#else
if (!context.Response.HasStarted)
#endif
{
await PrepareHeader(context, method, ent, status);
await HttpHandlingUtils.HttpContentToResponse(content, context.Response).ConfigureAwait(false);
}
else
{
logger.LogError(err, $"Could not execute {serializationContext} and could not handle error");
}
handled = true;
break;
}
}
if (!handled)
{
throw;
}
}
}
/// <summary>
/// Writes the result data to the body
/// </summary>
/// <param name="context">The HttpContext</param>
/// <param name="cmd">The Db Command</param>
/// <param name="method">The Http/SP mapping</param>
/// <param name="ent">The Entity mapping</param>
/// <returns>A Task</returns>
public async Task ReadResultToBody(SerializationContext serializationContext)
{
var context = serializationContext.HttpContext;
var method = serializationContext.Method;
var ent = serializationContext.Entity;
try
{
using (var rdr = await serializationContext.ExecuteReaderAsync())
{
bool firstRead = rdr.Read();
if (!firstRead)
{
await PrepareHeader(context, method, ent, 404, "application/json", null);
return;
}
byte[] content = (byte[])rdr.GetValue(rdr.GetOrdinal(ContentColumn));
string?fileName = rdr.GetNString(FileNameColumn);
string contentType = rdr.GetNString(ContentTypeColumn) ?? DefaultContentType;
await PrepareHeader(context, method, ent, 200, contentType, fileName);
#if NETFX
await context.Response.OutputStream.WriteAsync(content, 0, content.Length);
#else
await context.Response.Body.WriteAsync(content, 0, content.Length);
#endif
}
}
catch (Exception err)
{
bool handled = false;
foreach (var hand in errorHandlers)
{
var result = hand.GetContent(err, o =>
{
string json = Newtonsoft.Json.JsonConvert.SerializeObject(o);
var content = new System.Net.Http.StringContent(json);
content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
return(content);
});
if (result != null)
{
(var status, var content) = result.Value;
#if NETFX
if (!context.Response.HeadersWritten)
#else
if (!context.Response.HasStarted)
#endif
{
await PrepareHeader(context, method, ent, status, "application/json", null);
await HttpHandlingUtils.HttpContentToResponse(content, context.Response).ConfigureAwait(false);
}
else
{
logger.LogError(err, $"Could not execute {serializationContext} and could not handle error");
}
handled = true;
break;
}
}
if (!handled)
{
throw;
}
}
}
/// <summary>
/// Writes the result data to the body
/// </summary>
/// <param name="context">The HttpContext</param>
/// <param name="cmd">The Db Command</param>
/// <param name="method">The Http/SP mapping</param>
/// <param name="ent">The Entity mapping</param>
/// <returns>A Task</returns>
public async Task ReadResultToBody(SerializationContext serializationContext)
{
var context = serializationContext.HttpContext;
var method = serializationContext.Method;
var ent = serializationContext.Entity;
var outParameters = serializationContext.GetParameters()
.Where(p => p.Direction == System.Data.ParameterDirection.Output || p.Direction == System.Data.ParameterDirection.InputOutput)
.ToArray();
bool wrap = options.AlwaysWrapJson || outParameters.Length > 0;
try
{
using (var rdr = await serializationContext.ExecuteReaderAsync())
{
bool firstReadResult = rdr.Read();
await PrepareHeader(context, method, ent, 200);
string[] fieldNames = new string[rdr.FieldCount];
// Will store the types of the fields. Nullable datatypes will map to normal types
for (int i = 0; i < fieldNames.Length; i++)
{
fieldNames[i] = rdr.GetName(i);
}
fieldNames = namingMappingHandler.GetNames(fieldNames).ToArray();
#if NETFX
var stream = context.Response.OutputStream;;
#else
var stream = context.Response.Body;
#endif
if (wrap)
{
await WriteRaw(stream, $"{{ \"{codeConvention.FirstResultKey}\": \r\n");
await WriteCurrentResultSet(stream, rdr, fieldNames, firstReadResult);
bool first = true;
bool hasAnyResults = false;
while (await rdr.NextResultAsync())
{
if (first)
{
await WriteRaw(stream, $", \"{codeConvention.OtherResultsKey}\": [");
first = false;
hasAnyResults = true;
}
else
{
await WriteRaw(stream, ",");
}
await WriteCurrentResultSet(stream, rdr, fieldNames, false);
}
if (hasAnyResults)
{
await WriteRaw(stream, "]");
}
if (outParameters.Length > 0)
{
await WriteRaw(stream, $", \"{codeConvention.OutputParametersKey}\": ");
await WriteOutputParameters(stream, outParameters);
}
await WriteRaw(stream, "\r\n}");
}
else
{
await WriteCurrentResultSet(stream, rdr, fieldNames, firstReadResult);
}
await stream.FlushAsync();
#if NET48
await context.Response.FlushAsync();
#endif
}
}
catch (Exception err)
{
#if NETFX
logger.LogWarning($"Error executing {serializationContext} {err}");
#else
logger.LogWarning(err, $"Error executing {serializationContext}");
#endif
bool handled = false;
foreach (var hand in errorHandlers)
{
var result = hand.GetContent(err, o =>
{
string json = Newtonsoft.Json.JsonConvert.SerializeObject(o);
var content = new System.Net.Http.StringContent(json);
content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
return(content);
});
if (result != null)
{
(var status, var content) = result.Value;
#if NETFX
if (!context.Response.HeadersWritten)
#else
if (!context.Response.HasStarted)
#endif
{
await PrepareHeader(context, method, ent, status);
await HttpHandlingUtils.HttpContentToResponse(content, context.Response).ConfigureAwait(false);
}
else
{
logger.LogError(err, $"Could not execute {serializationContext} and could not handle error");
}
handled = true;
break;
}
}
if (!handled)
{
throw;
}
}
}
