public Task Submit(HttpContext http)
{
string accept = "application/json";
StringValues headers;
if (http.Request.Headers.TryGetValue("accept", out headers))
{
accept = headers[0];
}
T command;
try
{
command = (T)serialization.Deserialize(http.Request.Body, typeof(T), http.Request.ContentType, streamingContext);
}
catch (Exception ex)
{
logger.LogError(ex.ToString());
return(ReturnError(http.Response, $"Error deserializing command: {ex.Message}", 400));
}
try
{
Dictionary <string, List <string> > errors;
using (var context = objectFactory.DoWork())
{
context.Submit(command);
errors = command.GetValidationErrors();
if (errors.Count == 0)
{
context.Commit();
}
}
http.Response.ContentType = accept;
if (errors.Count == 0)
{
http.Response.StatusCode = 200;
serialization.Serialize(command, accept, http.Response.Body);
}
else
{
http.Response.StatusCode = 400;
serialization.Serialize(errors, accept, http.Response.Body);
}
//ideally Revenj could provide async DB API :(
return(Task.CompletedTask);
}
catch (CustomException ex)
{
logger.LogError(ex.ToString());
return(ReturnError(http.Response, ex.Message, 400));
}
catch (Exception ex)
{
logger.LogError(ex.ToString());
return(ReturnError(http.Response, "Unknown error", 500));
}
}
private static string SerializeToString(this IWireSerialization serializer, object instance)
{
using (var cms = ChunkedMemoryStream.Create())
{
var ct = serializer.Serialize(instance, ThreadContext.Request.Accept, cms);
ThreadContext.Response.ContentType = ct;
return(cms.GetReader().ReadToEnd());
}
}
private static string SerializeToString(this IWireSerialization serializer, object instance)
{
using (var ms = new MemoryStream())
{
var ct = serializer.Serialize(instance, ThreadContext.Request.Accept, ms);
ThreadContext.Response.ContentType = ct;
var sr = new StreamReader(ms);
return(sr.ReadToEnd());
}
}
public static Stream Serialize(
IWireSerialization serialization,
IRequestContext request,
IResponseContext response,
object result,
ChunkedMemoryStream outputStream)
{
outputStream.Reset();
response.ContentType = serialization.Serialize(result, request.Accept, outputStream);
response.ContentLength = outputStream.Position;
outputStream.Position = 0;
return(outputStream);
}
public Stream Find(string uri)
{
if (!Permissions.CanAccess(typeof(T)))
{
return(Explain("You don't have permission to access: " + typeof(T)));
}
var aggs = Cache.Find(new[] { uri });
var filtered = Permissions.ApplyFilters(aggs);
if (filtered.Length == 1)
{
ThreadContext.Response.StatusCode = HttpStatusCode.OK;
var cms = ChunkedMemoryStream.Create();
var ct = Serialization.Serialize(filtered[0], ThreadContext.Request.Accept, cms);
ThreadContext.Response.ContentType = ct;
ThreadContext.Response.ContentLength = cms.Position;
cms.Position = 0;
return(cms);
}
ThreadContext.Response.StatusCode = HttpStatusCode.NotFound;
return(Explain("Can't find " + typeof(T).FullName + " with Uri: " + uri));
}
public void ConvertStream <TCommand, TArgument>(HttpContext contex, TArgument argument)
{
if (argument == null)
{
Application.Execute(typeof(TCommand), null, contex);
return;
}
using (var ms = ChunkedMemoryStream.Create())
{
Serialization.Serialize(argument, contex.Request.ContentType, ms);
ms.Position = 0;
Application.Execute(typeof(TCommand), ms, contex);
}
}
private static string SerializeToString(this IWireSerialization serializer, object instance, HttpContext context)
{
StringValues headers;
string accept = null;
if (context.Request.Headers.TryGetValue("accept", out headers) && headers.Count > 0)
{
accept = headers[0];
}
using (var cms = ChunkedMemoryStream.Create())
{
var ct = serializer.Serialize(instance, accept, cms);
context.Response.ContentType = ct;
return(cms.GetReader().ReadToEnd());
}
}
public Stream ConvertStream <TCommand, TArgument>(TArgument argument)
{
var request = ThreadContext.Request;
var match = new UriTemplateMatch();
match.RelativePathSegments.Add(typeof(TCommand).FullName);
request.UriTemplateMatch = match;
if (argument == null)
{
return(Application.Get());
}
using (var ms = ChunkedMemoryStream.Create())
{
Serialization.Serialize(argument, request.ContentType, ms);
ms.Position = 0;
return(Application.Post(ms));
}
}
public Task ConvertStream <TCommand, TArgument>(HttpContext contex, TArgument argument)
{
if (argument == null)
{
return(Application.Execute(typeof(TCommand), null, contex));
}
var ms = ChunkedMemoryStream.Create();
Serialization.Serialize(argument, contex.Request.ContentType, ms);
ms.Position = 0;
var task = Application.Execute(typeof(TCommand), ms, contex);
return(task.ContinueWith(t =>
{
ms.Dispose();
return t;
}));
}
internal static Stream ExecuteCommands <TFormat>(
IProcessingEngine engine,
IWireSerialization serialization,
IServerCommandDescription <TFormat>[] commands,
IRequestContext request,
IResponseContext response,
string accept)
{
var result = Execute(engine, commands, request, response);
if (result.Error != null)
{
return(result.Error);
}
if (result.Result == null)
{
response.ContentType = accept;
return(null);
}
if (accept == "application/octet-stream")
{
response.ContentType = "application/octet-stream";
if (result.Result is Stream)
{
return(result.Result as Stream);
}
else if (result.Result is StreamReader)
{
return((result.Result as StreamReader).BaseStream);
}
else if (result.Result is StringBuilder)
{
var sb = result.Result as StringBuilder;
var cms = ChunkedMemoryStream.Create();
var sw = cms.GetWriter();
for (int i = 0; i < sb.Length;)
{
var min = Math.Min(sb.Length - i, cms.CharBuffer.Length);
sb.CopyTo(i, cms.CharBuffer, 0, min);
i += min;
sw.Write(cms.CharBuffer, 0, min);
}
sw.Flush();
cms.Position = 0;
return(cms);
}
else if (result.Result is byte[])
{
return(new MemoryStream(result.Result as byte[]));
}
else if (result.Result is string)
{
var cms = ChunkedMemoryStream.Create();
var sw = cms.GetWriter();
sw.Write(result.Result as string);
sw.Flush();
cms.Position = 0;
return(cms);
}
else if (result.Result is char[])
{
var cms = ChunkedMemoryStream.Create();
var sw = cms.GetWriter();
sw.Write(result.Result as char[]);
sw.Flush();
cms.Position = 0;
return(cms);
}
return(response.ReturnError(
"Unexpected command result. Can't convert "
+ result.Result.GetType().FullName + " to octet-stream. Use application/x-dotnet mime type for .NET binary serialization",
HttpStatusCode.UnsupportedMediaType));
}
if (accept == "application/base64")
{
response.ContentType = "application/base64";
if (result.Result is Stream)
{
var stream = result.Result as Stream;
try
{
var cms = stream as ChunkedMemoryStream;
if (cms != null)
{
return(cms.ToBase64Stream());
}
else
{
cms = new ChunkedMemoryStream(stream);
try { return(cms.ToBase64Stream()); }
finally { cms.Dispose(); }
}
}
finally { stream.Dispose(); }
}
else if (result.Result is StreamReader)
{
var sr = result.Result as StreamReader;
try
{
var cms = sr.BaseStream as ChunkedMemoryStream;
if (cms != null)
{
return(cms.ToBase64Stream());
}
else
{
cms = new ChunkedMemoryStream(sr.BaseStream);
try { return(cms.ToBase64Stream()); }
finally { cms.Dispose(); }
}
}
finally { sr.Dispose(); }
}
else if (result.Result is StringBuilder)
{
var sb = result.Result as StringBuilder;
using (var cms = ChunkedMemoryStream.Create())
{
var sw = cms.GetWriter();
for (int i = 0; i < sb.Length;)
{
var min = Math.Min(sb.Length - i, cms.CharBuffer.Length);
sb.CopyTo(i, cms.CharBuffer, 0, min);
i += min;
sw.Write(cms.CharBuffer, 0, min);
}
sw.Flush();
cms.Position = 0;
return(cms.ToBase64Stream());
}
}
else if (result.Result is byte[])
{
var bytes = result.Result as byte[];
using (var cms = ChunkedMemoryStream.Create())
{
cms.Write(bytes, 0, bytes.Length);
cms.Position = 0;
return(cms.ToBase64Stream());
}
}
else if (result.Result is string)
{
using (var cms = ChunkedMemoryStream.Create())
{
var sw = cms.GetWriter();
sw.Write(result.Result as string);
sw.Flush();
cms.Position = 0;
return(cms.ToBase64Stream());
}
}
else if (result.Result is char[])
{
using (var cms = ChunkedMemoryStream.Create())
{
var sw = cms.GetWriter();
sw.Write(result.Result as char[]);
sw.Flush();
cms.Position = 0;
return(cms.ToBase64Stream());
}
}
return(response.ReturnError("Unexpected command result. Can't convert to base64.", HttpStatusCode.UnsupportedMediaType));
}
if (accept == "application/x-dotnet")
{
response.ContentType = "application/x-dotnet";
var bf = new BinaryFormatter();
bf.AssemblyFormat = FormatterAssemblyStyle.Simple;
var cms = ChunkedMemoryStream.Create();
bf.Serialize(cms, result.Result);
cms.Position = 0;
return(cms);
}
var ms = ChunkedMemoryStream.Create();
response.ContentType = serialization.Serialize(result.Result, accept, ms);
ms.Position = 0;
return(ms);
}
public static Stream Serialize(
IWireSerialization serialization,
IRequestContext request,
IResponseContext response,
object result,
ChunkedMemoryStream outputStream)
{
outputStream.Reset();
response.ContentType = serialization.Serialize(result, request.Accept, outputStream);
response.ContentLength = outputStream.Position;
outputStream.Position = 0;
return outputStream;
}
public static Stream ExecuteCommand <TFormat>(
IProcessingEngine engine,
IWireSerialization serialization,
IServerCommandDescription <TFormat> command,
string accept)
{
if (accept == "application/json-experimental")
{
var instance = Execute <TFormat, object>(engine, command);
if (instance.Error != null)
{
return(instance.Error);
}
if (instance.Result == null)
{
return(null);
}
var cms = ChunkedMemoryStream.Create();
var ct = serialization.Serialize(instance.Result, accept, cms);
ThreadContext.Response.ContentType = ct;
cms.Position = 0;
return(cms);
}
if (accept.Contains("application/json"))
{
var json = Execute <TFormat, StreamReader>(engine, command);
if (json.Error != null)
{
return(json.Error);
}
ThreadContext.Response.ContentType = "application/json";
if (json.Result == null)
{
return(null);
}
return(json.Result.BaseStream);
}
if (accept.Contains("application/octet-stream"))
{
var native = Execute <TFormat, object>(engine, command);
if (native.Error != null)
{
return(native.Error);
}
ThreadContext.Response.ContentType = "application/octet-stream";
if (native.Result == null)
{
return(null);
}
if (native.Result is Stream)
{
return(native.Result as Stream);
}
else if (native.Result is StreamReader)
{
return((native.Result as StreamReader).BaseStream);
}
//Warning LOH leak
else if (native.Result is StringBuilder)
{
return((native.Result as StringBuilder).ToStream());
}
//Warning LOH leak
else if (native.Result is byte[])
{
return(new MemoryStream(native.Result as byte[]));
}
//Warning LOH leak
else if (native.Result is string)
{
return(new StringBuilder(native.Result as string).ToStream());
}
//Warning LOH leak
else if (native.Result is char[])
{
var ch = native.Result as char[];
var sb = new StringBuilder(ch.Length);
sb.Append(ch);
return(sb.ToStream());
}
return(Utility.ReturnError(
"Unexpected command result. Can't convert "
+ native.Result.GetType().FullName + " to octet-stream. Use application/x-dotnet mime type for .NET binary serialization",
HttpStatusCode.BadRequest));
}
if (accept.Contains("application/base64"))
{
var native = Execute <TFormat, object>(engine, command);
if (native.Error != null)
{
return(native.Error);
}
ThreadContext.Response.ContentType = "application/base64";
if (native.Result == null)
{
return(null);
}
if (native.Result is Stream)
{
var stream = native.Result as Stream;
try { return(stream.ToBase64Stream()); }
finally { stream.Dispose(); }
}
else if (native.Result is StreamReader)
{
var sr = native.Result as StreamReader;
try { return(sr.BaseStream.ToBase64Stream()); }
finally { sr.Dispose(); }
}
//Warning LOH leak
else if (native.Result is StringBuilder)
{
var sb = native.Result as StringBuilder;
return(sb.ToBase64Stream());
}
//Warning LOH leak
else if (native.Result is byte[])
{
var bytes = native.Result as byte[];
using (var cms = ChunkedMemoryStream.Create())
{
cms.Write(bytes, 0, bytes.Length);
cms.Position = 0;
return(cms.ToBase64Stream());
}
}
//Warning LOH leak
else if (native.Result is string)
{
var sb = new StringBuilder(native.Result as string);
return(sb.ToBase64Stream());
}
//Warning LOH leak
else if (native.Result is char[])
{
var ch = native.Result as char[];
var sb = new StringBuilder(ch.Length);
sb.Append(ch);
return(sb.ToBase64Stream());
}
return(Utility.ReturnError("Unexpected command result. Cant convert to base64.", HttpStatusCode.BadRequest));
}
if (accept.Contains("application/x-protobuf"))
{
var proto = Execute <TFormat, Stream>(engine, command);
if (proto.Error != null)
{
return(proto.Error);
}
ThreadContext.Response.ContentType = "application/x-protobuf";
return(proto.Result);
}
if (accept.Contains("application/x-dotnet"))
{
var native = Execute <TFormat, object>(engine, command);
if (native.Error != null)
{
return(native.Error);
}
ThreadContext.Response.ContentType = "application/x-dotnet";
if (native.Result == null)
{
return(null);
}
var bf = new BinaryFormatter();
bf.AssemblyFormat = FormatterAssemblyStyle.Simple;
var cms = ChunkedMemoryStream.Create();
bf.Serialize(cms, native.Result);
cms.Position = 0;
return(cms);
}
var xml = Execute <TFormat, XElement>(engine, command);
if (xml.Error != null)
{
return(xml.Error);
}
ThreadContext.Response.ContentType = "application/xml";
if (xml.Result == null)
{
return(null);
}
var ms = ChunkedMemoryStream.Create();
xml.Result.Save(ms);
ms.Position = 0;
return(ms);
}
