public async Task WriteTo(object entity, IHttpEntity response, IEnumerable <string> codecParameters)
{
var content = Encoding.UTF8.GetBytes((string)entity);
response.ContentLength = content.Length;
await response.Stream.WriteAsync(content, 0, content.Length);
}
public object ReadFrom(IHttpEntity request, IType destinationType, string parameterName)
{
if (destinationType.IsAssignableFrom <IEnumerable <IMultipartHttpEntity> >())
{
var multipartReader = new MultipartReader(request.ContentType.Boundary, request.Stream);
return(multipartReader.GetParts());
}
if (destinationType.IsAssignableFrom <IDictionary <string, IList <IMultipartHttpEntity> > >())
{
return(FormData(request));
}
var binder = BinderLocator.GetBinder(destinationType);
if (binder == null)
{
throw new InvalidOperationException("Cannot find a binder to create the object");
}
binder.Prefixes.Add(parameterName);
bool wasAnyKeyUsed = ReadKeyValues(request).Aggregate(false, (wasUsed, kv) => kv.SetProperty(binder) || wasUsed);
var result = binder.BuildObject();
return(wasAnyKeyUsed && result.Successful ? result.Instance : Missing.Value);
}
static async Task WriteFileWithFilenameAsync(IFile file, string disposition, IHttpEntity response)
{
var contentDispositionHeader =
response.Headers.ContentDisposition ?? new ContentDispositionHeader(disposition);
if (!string.IsNullOrEmpty(file.FileName))
{
contentDispositionHeader.FileName = file.FileName;
}
if (!string.IsNullOrEmpty(contentDispositionHeader.FileName) ||
contentDispositionHeader.Disposition != "inline")
{
response.Headers.ContentDisposition = contentDispositionHeader;
}
if (file.ContentType != null && file.ContentType != MediaType.ApplicationOctetStream ||
(file.ContentType == MediaType.ApplicationOctetStream && response.ContentType == null))
{
response.ContentType = file.ContentType;
}
if (file.Length > 0 && response.ContentLength == null)
{
response.ContentLength = file.Length;
}
using (var stream = file.OpenStream())
await stream.CopyToAsync(response.Stream);
}
private static void RenderToResponse(IHttpEntity response, ISparkView templateBase)
{
Encoding targetEncoding = Encoding.UTF8;
response.ContentType.CharSet = targetEncoding.HeaderName;
TextWriter writer = null;
bool ownsWriter = false;
try
{
if (response is ISupportsTextWriter)
{
writer = ((ISupportsTextWriter)response).TextWriter;
}
else
{
writer = new DeterministicStreamWriter(response.Stream, targetEncoding, StreamActionOnDispose.None);
ownsWriter = true;
}
templateBase.RenderView(writer);
}
finally
{
if (ownsWriter)
{
writer.Dispose();
}
}
}
public async Task WriteTo(object entity, IHttpEntity response, IEnumerable <string> codecParameters)
{
response.ContentType = MediaType;
var request = (IRequest)entity;
var responseMessage = new MemoryStream();
using (var writer = new StreamWriter(responseMessage, Encoding.UTF8, 4096, leaveOpen: true))
{
await writer.WriteAsync($"{request.HttpMethod} {request.Uri.AbsolutePath} HTTP/1.1\r\n");
foreach (var header in request.Headers)
{
await writer.WriteAsync($"{header.Key}: {header.Value}\r\n");
}
await writer.WriteAsync("\r\n");
await writer.FlushAsync();
}
await request.Entity.Stream.CopyToAsync(responseMessage);
response.ContentLength = responseMessage.Length;
responseMessage.Position = 0;
await responseMessage.CopyToAsync(response.Stream);
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
if (entity == null)
return;
bool isError = (response.Errors.Count > 0);
string status = isError ? "error" : "ok";
var writerSettings = new XmlWriterSettings { OmitXmlDeclaration = true, Encoding = Encoding.UTF8, NamespaceHandling = NamespaceHandling.OmitDuplicates };
using (var xmlTextWriter = XmlWriter.Create(response.Stream, writerSettings)) {
xmlTextWriter.WriteStartDocument();
xmlTextWriter.WriteStartElement("response");
xmlTextWriter.WriteAttributeString("xsi", "noNamespaceSchemaLocation", "", "http://api.7digital.com/1.2/static/7digitalAPI.xsd");
xmlTextWriter.WriteAttributeString("status", status);
xmlTextWriter.WriteAttributeString("version", "1.2");
xmlTextWriter.WriteAttributeString("xmlns", "xsd", "", "http://www.w3.org/2001/XMLSchema");
xmlTextWriter.WriteAttributeString("xmlns", "xsi", "", "http://www.w3.org/2001/XMLSchema-instance");
if (!isError)
OutputEntity(entity, xmlTextWriter);
else
OutputError(response, xmlTextWriter);
xmlTextWriter.WriteEndElement();
}
}
public virtual void WriteTo(object entity, IHttpEntity response, string[] parameters)
{
var responseStream = response.Stream;
var xmlSettings = new XmlWriterSettings
{
Encoding = new UTF8Encoding(false),
ConformanceLevel = ConformanceLevel.Document,
Indent = true,
NewLineOnAttributes = true,
OmitXmlDeclaration = false,
CloseOutput = true,
CheckCharacters = false
};
if (response.Headers.ContentType == null)
{
response.Headers.ContentType = new MediaType("application/xml;charset=utf-8");
}
else if (response.Headers.ContentType.Matches(MediaType.Xml))
{
response.Headers.ContentType.CharSet = "utf-8";
}
Configuration(xmlSettings);
using (Writer = XmlWriter.Create(responseStream, xmlSettings))
WriteToCore(entity, response);
}
public object ReadFrom(IHttpEntity request, IType destinationType, string destinationName)
{
using (var reader = new StreamReader(request.Stream))
{
return JsonPatchDocument.Read(reader);
}
}
private static void RenderToResponse(IHttpEntity response, ISparkView templateBase)
{
Encoding targetEncoding = Encoding.UTF8;
response.ContentType.CharSet = targetEncoding.HeaderName;
TextWriter writer = null;
bool ownsWriter = false;
try
{
if (response is ISupportsTextWriter)
{
writer = ((ISupportsTextWriter) response).TextWriter;
}
else
{
writer = new DeterministicStreamWriter(response.Stream, targetEncoding, StreamActionOnDispose.None);
ownsWriter = true;
}
templateBase.RenderView(writer);
}
finally
{
if (ownsWriter)
writer.Dispose();
}
}
public void WriteTo(object entity, IHttpEntity response, string[] paramneters)
{
if (entity == null)
return;
DataContractJsonSerializer serializer = new DataContractJsonSerializer(entity.GetType());
serializer.WriteObject(response.Stream, entity);
}
public Task WriteTo(object entity, IHttpEntity response, IEnumerable <string> codecParameters)
{
_responseMessage.Headers.Add("link", $"<{_apiDocumentationLink}>; rel=\"{_apiDocumentationRel}\"");
var resourceSelectedByUri = _context.PipelineData.SelectedResource;
var serializerFunc = resourceSelectedByUri.ResourceModel.Hydra().SerializeFunc;
if (serializerFunc == null)
{
serializerFunc = GetFuncFromResponseResourceType(_context.Response.Entity.Instance);
if (serializerFunc == null)
{
throw new InvalidOperationException($"Hydra serialiser not found for object of type {entity?.GetType()}");
}
}
var typeToTypeGen = _models.ResourceRegistrations
.Where(res => res.ResourceType != null && res.Hydra().TypeFunc != null)
.ToLookup(res => res.ResourceType, res => res.Hydra().TypeFunc);
string renderTypeNode(object resource)
{
return(typeToTypeGen[resource.GetType()].First()(resource));
}
return(serializerFunc(entity, new SerializationContext
{
BaseUri = BaseUri,
UriGenerator = resource => _uris.CreateUri(resource, _context.ApplicationBaseUri),
TypeGenerator = renderTypeNode
}, response.Stream));
}
public void WriteTo(object entity, IHttpEntity response, string[] parameters)
{
byte[] bytes = Encoding.UTF8.GetBytes(entity.ToString());
response.ContentType = new MediaType("text/plain;charset=utf-8");
response.ContentLength = bytes.Length;
response.Stream.Write(bytes, 0, bytes.Length);
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
Image image = (Image)entity;
response.ContentType = image.MediaType;
image.Data.Seek(0, SeekOrigin.Begin);
image.Data.WriteTo(response.Stream);
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
// The default webforms renderer only associate the last parameter in the codecParameters
// with a page that has been defined in the rendererParameters.
var codecParameterList = new List <string>(codecParameters);
if (!string.IsNullOrEmpty(_request.UriName))
{
codecParameterList.Add(_request.UriName);
}
string templateAddress = GetViewVPath(_configuration, codecParameterList.ToArray(), _request.UriName);
var type = _buildManager.GetCompiledType(templateAddress);
var renderTarget = DependencyManager.GetService(type) as RazorViewBase;
if (renderTarget == null)
{
throw new InvalidOperationException("View page doesn't inherit from RazorViewBase");
}
renderTarget.SetResource(entity);
renderTarget.Errors = response.Errors;
RenderTarget(response, renderTarget);
}
public async Task WriteTo(object entity, IHttpEntity response, IEnumerable <string> codecParameters)
{
_responseMessage.Headers.Add("link", $"<{_apiDocumentationLink}>; rel=\"{_apiDocumentationRel}\"");
if (entity is IEnumerable enumerableEntity)
{
entity = ConvertToHydraCollection(enumerableEntity, _context.Request.Uri);
}
var customConverter = new JsonSerializer
{
NullValueHandling = NullValueHandling.Ignore,
MissingMemberHandling = MissingMemberHandling.Ignore,
ContractResolver = new JsonLdContractResolver(BaseUri, _uris, _models),
TypeNameHandling = TypeNameHandling.None,
Converters =
{
new StringEnumConverter(),
new JsonLdTypeRefConverter(_models),
new HydraUriModelConverter(BaseUri),
new RdfPropertyFromJsonPropertyConverter(_models),
new ContextDocumentConverter()
}
};
using (var writer = new StreamWriter(response.Stream, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false),
bufferSize: 1024, leaveOpen: true))
using (var jsonWriter = new JsonTextWriter(writer))
{
customConverter.Serialize(jsonWriter, entity);
}
}
public override object ReadFrom(IHttpEntity request, IType destinationType, string parameterName)
{
if (destinationType.StaticType == null)
throw new InvalidOperationException();
return new XmlSerializer(destinationType.StaticType).Deserialize(request.Stream);
}
public object ReadFrom(IHttpEntity request, IType destinationType, string parameterName)
{
if (destinationType.IsAssignableFrom<IEnumerable<IMultipartHttpEntity>>())
{
var multipartReader = new MultipartReader(request.ContentType.Boundary, request.Stream);
return multipartReader.GetParts();
}
if (destinationType.IsAssignableFrom<IDictionary<string, IList<IMultipartHttpEntity>>>())
{
return FormData(request);
}
var binder = BinderLocator.GetBinder(destinationType);
if (binder == null)
{
throw new InvalidOperationException("Cannot find a binder to create the object");
}
binder.Prefixes.Add(parameterName);
bool wasAnyKeyUsed = ReadKeyValues(request).Aggregate(false, (wasUsed, kv) => kv.SetProperty(binder) || wasUsed);
var result = binder.BuildObject();
return wasAnyKeyUsed && result.Successful ? result.Instance : Missing.Value;
}
void IMediaTypeWriter.WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
if (!GetWriters(entity, response).Any(x => x))
{
throw new InvalidOperationException();
}
}
public object ReadFrom(IHttpEntity request, IType destinationType, string destinationName)
{
using (var reader = new StreamReader(request.Stream))
{
return(JsonPatchDocument.Read(reader));
}
}
async Task <RequestReadResult> TryReadPayloadAsObject(IHttpEntity requestEntity, Func <IHttpEntity, IType, string, Task <object> > reader, IOperation operation)
{
Log.CodecSupportsFullObjectResolution();
foreach (var member in operation.Inputs.Where(m => m.Binder.IsEmpty))
{
Log.ProcessingMember(member);
try
{
var entityInstance = await reader(requestEntity,
member.Member.Type,
member.Member.Name);
Log.Result(entityInstance);
if (entityInstance != Missing.Value)
{
if (!member.Binder.SetInstance(entityInstance))
{
Log.BinderInstanceAssignmentFailed();
return(RequestReadResult.BinderFailure);
}
Log.BinderInstanceAssignmentSucceeded();
}
}
catch (Exception e)
{
ErrorCollector.AddServerError(CreateErrorForException(e));
return(RequestReadResult.CodecFailure);
}
}
return(RequestReadResult.Success);
}
public async Task WriteTo(object entity, IHttpEntity response, IEnumerable <string> codecParameters)
{
var proxyResponse = (ReverseProxyResponse)entity;
try
{
_response.StatusCode = proxyResponse.StatusCode;
if (proxyResponse.Via != null)
{
response.Headers.Add("via", $"{_protocol} {proxyResponse.Via}");
}
if (proxyResponse.ResponseMessage != null)
{
SetHeaders(response.Headers, proxyResponse.ResponseMessage.Headers);
SetHeaders(response.Headers, proxyResponse.ResponseMessage.Content.Headers);
await proxyResponse.ResponseMessage.Content.CopyToAsync(response.Stream);
}
else if (proxyResponse.Error != null)
{
var errorMessage = Encoding.UTF8.GetBytes(proxyResponse.Error.ToString());
await response.Stream.WriteAsync(errorMessage, 0, errorMessage.Length);
}
}
finally
{
proxyResponse.Dispose();
}
}
bool TryReadPayloadAsObject(IHttpEntity requestEntity, IMediaTypeReader reader, IOperation operation)
{
Log.CodecSupportsFullObjectResolution();
foreach (var member in from m in operation.Inputs
where m.Binder.IsEmpty
select m)
{
Log.ProcessingMember(member);
try
{
var entityInstance = reader.ReadFrom(requestEntity,
member.Member.Type,
member.Member.Name);
Log.Result(entityInstance);
if (entityInstance != Missing.Value)
{
if (!member.Binder.SetInstance(entityInstance))
{
Log.BinderInstanceAssignmentFailed();
return(false);
}
Log.BinderInstanceAssignmentSucceeded();
}
}
catch (Exception e)
{
ErrorCollector.AddServerError(CreateErrorForException(e));
return(false);
}
}
return(true);
}
public object ReadFrom(IHttpEntity request, OpenRasta.TypeSystem.IType destinationType, string destinationName)
{
using (var reader = XmlReader.Create(request.Stream))
{
return(ReadFrom(reader));
}
}
public async Task WriteTo(object entity, IHttpEntity response, IEnumerable <string> codecParameters)
{
var proxyResponse = (ReverseProxyResponse)entity;
try
{
_response.StatusCode = proxyResponse.StatusCode;
response.Headers["via"] = string.Join(response.Headers["via"], $"1.1 {proxyResponse.Via}");
if (proxyResponse.ResponseMessage != null)
{
foreach (var header in proxyResponse.ResponseMessage.Headers.Concat(proxyResponse.ResponseMessage.Content
.Headers))
{
SetHeader(response, header);
}
await proxyResponse.ResponseMessage.Content.CopyToAsync(response.Stream);
}
else if (proxyResponse.Error != null)
{
var jsonCodec = new NewtonsoftJsonCodec(_context);
await jsonCodec.WriteTo(proxyResponse.Error, response, new string[] { });
}
}
finally
{
proxyResponse.Dispose();
}
}
public object ReadFrom(IHttpEntity request, OpenRasta.TypeSystem.IType destinationType, string destinationName)
{
using (var reader = new StreamReader(request.Stream))
{
JsonReader jsr = new JsonReader();
return(jsr.Read(reader, typeof(TEntity)));
}
}
// Note that we store in the pipeline data because the same codec may be called for resolving several request entities
protected IDictionary <string, IList <IMultipartHttpEntity> > FormData(IHttpEntity source)
{
if (Cache[source] == null)
{
Cache[source] = PreLoadAllParts(source);
}
return(Cache[source]);
}
public object ReadFrom(IHttpEntity request, IType destinationType, string destinationName)
{
using (var streamReader = new StreamReader(request.Stream))
{
var ser = new JsonSerializer();
return(ser.Deserialize(streamReader, destinationType.StaticType));
}
}
void CheckEntity(IHttpEntity entity, MediaType httpContentType, string expectedContent)
{
entity.ContentType
.Matches(httpContentType)
.ShouldBeTrue();
string actualContent = new StreamReader(entity.Stream).ReadToEnd();
actualContent.ShouldBe(expectedContent);
}
void CheckEntity(IHttpEntity entity, MediaType httpContentType, string expectedContent)
{
entity.ContentType
.Matches(httpContentType).ShouldBeTrue();
string actualContent = new StreamReader(entity.Stream).ReadToEnd();
actualContent.ShouldBe(expectedContent);
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
Image image = (Image)entity;
response.ContentType = image.MediaType;
image.Data.Seek(0, SeekOrigin.Begin);
image.Data.WriteTo(response.Stream);
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
var codecParameterList = new List<string>(codecParameters);
if (!string.IsNullOrEmpty(request.UriName))
codecParameterList.Add(request.UriName);
string templateAddress = GetViewVPath(Configuration, codecParameterList.ToArray());
RenderTemplate(response, templateAddress, entity);
}
public IEnumerable <KeyedValues <string> > ReadKeyValues(IHttpEntity entity)
{
yield return(new KeyedValues <string>("FirstName", new[] { "John" }, Converter));
yield return(new KeyedValues <string>("LastName", new[] { "Doe" }, Converter));
yield return(new KeyedValues <string>("Username", new[] { "johndoe" }, Converter));
}
RequestReadResult TryAssignKeyedValues(IHttpEntity requestEntity, ICodec codec, Type codecType, IOperation operation)
{
Log.CodecSupportsKeyedValues();
return(codec.TryAssignKeyValues(requestEntity, operation.Inputs.Select(x => x.Binder), Log.KeyAssigned,
Log.KeyFailed)
? RequestReadResult.Success : RequestReadResult.CodecFailure);
}
public override object ReadFrom(IHttpEntity request, IType destinationType, string parameterName)
{
if (destinationType.StaticType == null)
{
throw new InvalidOperationException();
}
return(new DataContractSerializer(destinationType.StaticType).ReadObject(request.Stream));
}
private static void WriteJsonp(object entity, IHttpEntity response, string jsonpId)
{
var front = Encoding.UTF8.GetBytes(jsonpId + "(");
response.Stream.Write(front, 0, front.Length);
WriteJson(entity, response);
var back = Encoding.UTF8.GetBytes(")");
response.Stream.Write(back, 0, back.Length);
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
// The default webforms renderer only associate the last parameter in the codecParameters
// with a page that has been defined in the rendererParameters.
object renderTarget = null;
if (entity != null && entity is Page)
{
renderTarget = entity as Page;
}
var codecParameterList = new List <string>(codecParameters);
if (!string.IsNullOrEmpty(_request.UriName))
{
codecParameterList.Add(_request.UriName);
}
if (renderTarget == null)
{
string templateAddress = GetViewVPath(Configuration, codecParameterList.ToArray(), _request.UriName);
var type = BuildManager.GetCompiledType(templateAddress);
renderTarget = DependencyManager.GetService(type);
if (entity != null)
{
var page = renderTarget as Page;
if (page != null)
{
page.Init += (s, e) =>
{
SetAnyPropertyOfCorrectType(page, entity);
SetAnyPropertyOfCorrectType(page, response.Errors);
var master = page.Master;
while (master != null)
{
SetAnyPropertyOfCorrectType(master, entity);
SetAnyPropertyOfCorrectType(master, response.Errors);
master = master.Master;
}
};
}
else
{
SetAnyPropertyOfCorrectType(renderTarget, entity);
SetAnyPropertyOfCorrectType(renderTarget, response.Errors);
}
}
}
if (renderTarget != null)
{
RenderTarget(response, renderTarget);
}
else
{
throw new InvalidOperationException("No http handler has been found to render the resource.");
}
}
public void WriteTo(object entity, IHttpEntity response, string[] parameters)
{
var entityString = entity.ToString();
var encodedText = Encoding.GetEncoding(EncodingIso88591).GetBytes(entityString);
response.ContentType = new MediaType("text/plain;charset=ISO-8859-1");
response.ContentLength = encodedText.Length;
response.Stream.Write(encodedText, 0, encodedText.Length);
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
Cat c = (Cat)entity;
using (var writer = new StreamWriter(response.Stream))
{
writer.Write(c.Name);
}
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
Cat c = (Cat)entity;
using (var writer = new StreamWriter(response.Stream))
{
writer.Write(string.Format("<html><body><p>{0}</p></body></html>", c.Name));
}
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
Cat c = (Cat)entity;
using (var writer = new StreamWriter(response.Stream))
{
writer.Write(c.Name);
}
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
Cat c = (Cat)entity;
using (var writer = new StreamWriter(response.Stream))
{
writer.Write(string.Format("<html><body><p>{0}</p></body></html>", c.Name));
}
}
public object ReadFrom(IHttpEntity request, OpenRasta.TypeSystem.IType destinationType, string destinationName)
{
string text = null;
using (StreamReader r = new StreamReader(request.Stream, Encoding.UTF8))
{
text = r.ReadToEnd();
}
return new Cat { Name = text };
}
/// <exception cref="IOException">This method might throw this exception.</exception>
protected override Stream GetStreamFromNetwork(string imageUri, Java.Lang.Object extra)
{
HttpGet httpRequest = new HttpGet(imageUri);
IHttpResponse response = httpClient.Execute(httpRequest);
IHttpEntity entity = response.Entity;
BufferedHttpEntity bufHttpEntity = new BufferedHttpEntity(entity);
return(bufHttpEntity.Content);
}
public object ReadFrom(IHttpEntity request, IType destinationType, string paramName)
{
if (destinationType.StaticType == null)
{
throw new InvalidOperationException();
}
return new DataContractJsonSerializer(destinationType.StaticType).ReadObject(request.Stream);
}
public static bool TryAssignKeyValues(this ICodec codec, IHttpEntity entity, IObjectBinder binder, Action<KeyedValues> assigned, Action<KeyedValues> failed)
{
return codec.ReadKeyValues(entity)
.AsObservable(x => from kv in x
where kv.SetProperty(binder)
select kv,
assigned,
failed)
.Count() > 0;
}
public void Write(IHttpEntity formDataField)
{
WriteLine();
WriteBoundary();
foreach (var header in formDataField.Headers)
WriteHeader(header);
WriteContentLength(formDataField);
WriteLine();
WriteBody(formDataField);
}
public object ReadFrom(IHttpEntity request, IType destinationType, string destinationName)
{
JsonSerializer serializer = new JsonSerializer();
using (StreamReader sr = new StreamReader(request.Stream))
using (JsonReader jr = new JsonTextReader(sr))
{
return(serializer.Deserialize <T>(jr));
}
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
if (entity == null)
return;
var json = JsonConvert.SerializeObject(entity);
using(var writer = new StreamWriter(response.Stream))
{
writer.Write(json);
}
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
string text = entity as string;
if (text == null)
throw new ArgumentException("Entity was not a string", "entity");
using (var writer = new StreamWriter(response.Stream))
{
writer.Write(text);
}
}
private static void OutputError(IHttpEntity response, XmlWriter xmlTextWriter)
{
xmlTextWriter.WriteStartElement("error", "");
foreach (var error in response.Errors) {
xmlTextWriter.WriteStartElement("errorMessage");
xmlTextWriter.WriteAttributeString("code", "1001");
xmlTextWriter.WriteString(error.Message);
xmlTextWriter.WriteEndElement();
}
xmlTextWriter.WriteEndElement();
}
public object ReadFrom(IHttpEntity request, IType destinationType, string destinationName)
{
if(destinationType != null)
{
using(var reader = new StreamReader(request.Stream))
{
var json = reader.ReadToEnd();
return JsonConvert.DeserializeObject(json, destinationType.StaticType);
}
}
return Missing.Value;
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
if (entity == null)
{
return;
}
var output = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(entity));
response.Stream.Write(output, 0, output.Length);
response.ContentType = new MediaType("application/json") { CharSet = "utf-8" };
}
public void WriteTo(object entity, IHttpEntity response, string[] paramneters)
{
var queryParams = HttpUtility.ParseQueryString(_request.Uri.Query);
if (queryParams["jsoncallback"] != null)
{
WriteJsonp(entity, response, queryParams["jsoncallback"]);
}
else
{
WriteJson(entity, response);
}
}
public void WriteTo(object entity, IHttpEntity response, string[] paramneters)
{
var errors = entity as IList<Error>;
if (errors == null)
return;
response.ContentType = MediaType.Html;
using (var streamWriter = new StreamWriter(response.Stream))
{
var writer = new XhtmlNodeWriter();
writer.Write(new XhtmlTextWriter(streamWriter), new HtmlErrorPage(errors));
}
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
SchemaTypeResource tr = entity as SchemaTypeResource;
if (tr == null)
throw new InvalidOperationException("Expected Type in JSON schema writer");
Type t = tr.SchemaType;
using (StreamWriter sw = new StreamWriter(response.Stream))
{
WriteSchema(sw, t);
}
}
public void WriteTo(object entity, IHttpEntity response, string[] codecParameters)
{
if (entity == null || !(entity is SparqlEndpoint)) return;
var sparqlEndpoint = entity as SparqlEndpoint;
var client = BrightstarService.GetClient();
using (var resultStream = client.ExecuteQuery(sparqlEndpoint.Store, sparqlEndpoint.SparqlQuery))
{
var resultsDoc = XDocument.Load(resultStream);
var resultsWriter = new System.Xml.XmlTextWriter(response.Stream, Encoding.Unicode);
resultsDoc.WriteTo(resultsWriter);
resultsWriter.Flush();
}
}
public object ReadFrom(IHttpEntity request, IType destinationType, string destinationParameterName)
{
if (request.ContentLength == 0)
return string.Empty;
if (!_values.ContainsKey(request))
{
var encoding = DetectTextEncoding(request);
string result = new StreamReader(request.Stream, encoding).ReadToEnd();
_values.Add(request, result);
}
return _values[request];
}
private void WriteContentLength(IHttpEntity formDataField)
{
if (formDataField.ContentLength != null)
{
if (formDataField.Stream != null && formDataField.Stream.CanSeek)
{
this.WriteHeader(new KeyValuePair<string, string>("Content-Length", formDataField.Stream.Length.ToString()));
}
else if (formDataField.Stream == null)
{
this.WriteHeader(new KeyValuePair<string, string>("Content-Length", "0"));
}
}
}
public object ReadFrom(IHttpEntity request, IType destinationType, string destinationName)
{
if (IsRawDictionary(destinationType))
return FormData(request);
var binder = _binderLocator.GetBinder(destinationType);
if (binder == null)
throw new InvalidOperationException("Cannot find a binder to create the object");
binder.Prefixes.Add(destinationName);
bool wasAnyKeyUsed = ReadKeyValues(request).Aggregate(false, (wasUsed, kv) => kv.SetProperty(binder) || wasUsed);
var result = binder.BuildObject();
return wasAnyKeyUsed && result.Successful ? result.Instance : Missing.Value;
}
protected virtual void Dispose(bool disposing)
{
if (_disposed) return;
if (disposing)
{
if (_entity != null)
{
_entity.Dispose();
_entity = null;
}
}
_disposed = true;
}
