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; })); }