private async Task <bool> DispatchToHandler <T, TKey>(HttpListenerContext context, object handler,
string httpMethod, SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
MethodInfo method = typeof(VerbRouteActioner).GetMethod("CreateVerbHandler",
BindingFlags.NonPublic | BindingFlags.Instance);
MethodInfo generic = method.MakeGenericMethod(new[] { typeof(T), typeof(TKey) });
IVerbHandler <T, TKey> actualHandler =
(IVerbHandler <T, TKey>)generic.Invoke(this, new[] { handler });
var result = false;
switch (httpMethod)
{
case "GET":
result = await HandleGet <T, TKey>(actualHandler, context, serializationToUse);
break;
case "PUT":
result = await HandlePut <T, TKey>(actualHandler, context, serializationToUse);
break;
case "POST":
result = await HandlePost <T, TKey>(actualHandler, context, serializationToUse);
break;
case "DELETE":
result = await HandleDelete <T, TKey>(actualHandler, context, serializationToUse);
break;
}
return result;
}));
}
public async Task <HttpStatusCode> Put <T>(string url, T item, SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
await UploadDataForMethod(url, "PUT", item, serializationToUse);
return await StatusCode();
}));
}
public async Task <RESTResponse <T> > Get <T>(string url, SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
string response = await Task.Run(() => DownloadString(url));
return await CreateResponse <T>(response, serializationToUse);
}));
}
public ISerializer ObtainSerializer(SerializationToUse serializationToUse, string contentType)
{
if (contentType == "application/json" || serializationToUse == SerializationToUse.Json)
{
return(jsonPipelineSerializer);
}
if (contentType == "application/xml" || serializationToUse == SerializationToUse.Xml)
{
return(xmlPipelineSerializer);
}
throw new InvalidOperationException(
"Can only deserialize using either 'application/json' or 'application/xml' content types");
}
public async Task <RESTResponse <T> > Post <T>(string url, T item, SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
byte[] responsebytes = await UploadDataForMethod(url, "POST", item, serializationToUse);
string responsebody = string.Empty;
if (serializationToUse == SerializationToUse.Xml)
{
responsebody = Encoding.UTF8.GetString(responsebytes);
}
if (serializationToUse == SerializationToUse.Json)
{
responsebody = Encoding.UTF8.GetString(responsebytes);
}
return await CreateResponse <T>(responsebody, serializationToUse);
}));
}
public async Task <bool> SetResponse <T>(HttpListenerContext context, T result,
SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
HttpListenerResponse response = context.Response;
using (System.IO.Stream output = response.OutputStream)
{
ISerializer serializer = ObtainSerializer(serializationToUse, context.Request.ContentType);
string serialized = await serializer.Serialize <T>(result);
var buffer = Encoding.UTF8.GetBytes(serialized);
output.Write(buffer, 0, buffer.Length);
response.StatusCode = 200;
response.StatusDescription = Enum.GetName(typeof(HttpStatusCode), HttpStatusCode.OK);
}
return true;
}));
}
private async Task <bool> HandleGet <T, TKey>(DynamicMethodInfo methodInfo, object handler,
HttpListenerContext context, SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
var result = false;
if (restMethodActioner.IsGetAll(context.Request.RawUrl))
{
if (methodInfo.IsTask)
{
var items = await(Task <IEnumerable <T> >) methodInfo.Method.Invoke(handler, null);
result = await restMethodActioner.SetResponse <List <T> >(context,
items.ToList(), serializationToUse);
}
else
{
var items = (IEnumerable <T>)methodInfo.Method.Invoke(handler, null);
result = await restMethodActioner.SetResponse <List <T> >(context,
items.ToList(), serializationToUse);
}
}
else
{
TKey id = await restMethodActioner.ExtractId <TKey>(context.Request);
if (methodInfo.IsTask)
{
var item = await(Task <T>) methodInfo.Method.Invoke(handler, new object[] { id });
result = await restMethodActioner.SetResponse <T>(context,
item, serializationToUse);
}
else
{
var item = (T)methodInfo.Method.Invoke(handler, new object[] { id });
result = await restMethodActioner.SetResponse <T>(context,
item, serializationToUse);
}
}
return result;
}));
}
private async Task <bool> HandlePost <T, TKey>(DynamicMethodInfo methodInfo, object handler,
HttpListenerContext context, SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
T itemAdded = default(T);
T item = await restMethodActioner.ExtractContent <T>(context.Request, serializationToUse);
if (methodInfo.IsTask)
{
itemAdded = await(Task <T>) methodInfo.Method.Invoke(handler, new object[] { item });
}
else
{
itemAdded = (T)methodInfo.Method.Invoke(handler, new object[] { item });
}
bool result = await restMethodActioner.SetResponse <T>(context, itemAdded, serializationToUse);
return result;
}));
}
private async Task <bool> HandlePut <T, TKey>(DynamicMethodInfo methodInfo, object handler,
HttpListenerContext context, SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
T item = await restMethodActioner.ExtractContent <T>(context.Request, serializationToUse);
TKey id = await restMethodActioner.ExtractId <TKey>(context.Request);
var updatedOk = false;
if (methodInfo.IsTask)
{
updatedOk = await(Task <bool>) methodInfo.Method.Invoke(handler, new object[] { id, item });
}
else
{
updatedOk = (bool)methodInfo.Method.Invoke(handler, null);
}
updatedOk &= await restMethodActioner.SetOkResponse(context);
return updatedOk;
}));
}
public async Task <T> ExtractContent <T>(HttpListenerRequest request,
SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
using (StreamReader sr = new StreamReader(request.InputStream))
{
string rawData = sr.ReadToEnd();
switch (serializationToUse)
{
case SerializationToUse.Json:
return await DeSerialize <T>(rawData, jsonPipelineSerializer);
case SerializationToUse.Xml:
return await DeSerialize <T>(rawData, xmlPipelineSerializer);
default:
return await ObtainDeSerializedItemFromBodyContentType <T>(rawData, request.ContentType);
}
}
}));
}
private async Task <bool> HandleGet <T, TKey>(IVerbHandler <T, TKey> actualHandler,
HttpListenerContext context, SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
var result = false;
if (restMethodActioner.IsGetAll(context.Request.RawUrl))
{
var items = await actualHandler.Get();
result = await restMethodActioner.SetResponse <List <T> >(context, items.ToList(),
serializationToUse);
}
else
{
TKey id = await restMethodActioner.ExtractId <TKey>(context.Request);
var item = await actualHandler.Get(id);
result = await restMethodActioner.SetResponse <T>(context, item, serializationToUse);
}
return result;
}));
}
private async Task <RESTResponse <T> > CreateResponse <T>(string response, SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
if (serializationToUse == SerializationToUse.Xml)
{
return new RESTResponse <T>()
{
Content = await xmlPipelineSerializer.Deserialize <T>(response),
StatusCode = await StatusCode()
};
}
if (serializationToUse == SerializationToUse.Json)
{
return new RESTResponse <T>()
{
Content = await jsonPipelineSerializer.Deserialize <T>(response),
StatusCode = await StatusCode()
};
}
throw new InvalidOperationException("You need to specify either Xml or Json serialization");
}));
}
public RouteBaseAttribute(string urlBase, SerializationToUse serializationToUse)
{
this.UrlBase = urlBase;
this.SerializationToUse = serializationToUse;
}
private async Task <bool> DispatchToHandler <T, TKey>(HttpListenerContext context, object handler,
string httpMethod, string url, SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
var result = false;
DynamicMethodInfo method = null;
switch (httpMethod)
{
case "GET":
method = await ObtainGetMethod <T, TKey>(handler, url);
result = await HandleGet <T, TKey>(method, handler, context, serializationToUse);
break;
case "PUT":
method = await ObtainPutMethod <T, TKey>(handler, url);
result = await HandlePut <T, TKey>(method, handler, context, serializationToUse);
break;
case "POST":
method = await ObtainPostMethod <T, TKey>(handler, url);
result = await HandlePost <T, TKey>(method, handler, context, serializationToUse);
break;
case "DELETE":
method = await ObtainDeleteMethod <T, TKey>(handler, url);
result = await HandleDelete <T, TKey>(method, handler, context, serializationToUse);
break;
}
return result;
}));
}
private async Task <bool> HandlePut <T, TKey>(IVerbHandler <T, TKey> actualHandler, HttpListenerContext context, SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
TKey id = await restMethodActioner.ExtractId <TKey>(context.Request);
T item = await restMethodActioner.ExtractContent <T>(context.Request, serializationToUse);
bool updatedOk = await actualHandler.Put(id, item);
updatedOk &= await restMethodActioner.SetOkResponse(context);
return updatedOk;
}));
}
private async Task <byte[]> UploadDataForMethod <T>(string url, string httpMethod, T item, SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
if (serializationToUse == SerializationToUse.Xml)
{
Headers.Add("Content-Type", "application/xml");
var serialized = await xmlPipelineSerializer.SerializeAsBytes(item);
return await Task.Run(() => UploadData(url, httpMethod, serialized));
}
if (serializationToUse == SerializationToUse.Json)
{
Headers.Add("Content-Type", "application/json");
var serialized = await jsonPipelineSerializer.SerializeAsBytes(item);
return await Task.Run(() => UploadData(url, httpMethod, serialized));
}
throw new InvalidOperationException("You need to specify either Xml or Json serialization");
}));
}
public RouteBaseAttribute(string urlBase, SerializationToUse serializationToUse)
{
this.UrlBase = urlBase;
this.SerializationToUse = serializationToUse;
}
private async Task <bool> HandlePost <T, TKey>(IVerbHandler <T, TKey> actualHandler, HttpListenerContext context, SerializationToUse serializationToUse)
{
return(await Task.Run(async() =>
{
T item = await restMethodActioner.ExtractContent <T>(context.Request, serializationToUse);
T itemAdded = await actualHandler.Post(item);
bool result = await restMethodActioner.SetResponse <T>(context, itemAdded, serializationToUse);
return result;
}));
}
