public override Task WriteToStreamAsync(
Type type,
object value,
Stream writeStream,
System.Net.Http.HttpContent content,
TransportContext transportContext)
{
// Create a serializer
JsonSerializer serializer = JsonSerializer.Create(_jsonSerializerSettings);
// Create task writing the serialized content
return(Task.Factory.StartNew(
() =>
{
using (
JsonTextWriter jsonTextWriter = new JsonTextWriter(new StreamWriter(writeStream))
{
CloseOutput = false
})
{
serializer.Serialize(jsonTextWriter, value);
jsonTextWriter.Flush();
}
}));
}
public override System.Threading.Tasks.Task <object> ReadFromStreamAsync(System.Type type
, System.IO.Stream readStream
, System.Net.Http.HttpContent content
, System.Net.Http.Formatting.IFormatterLogger formatterLogger)
{
return(System.Threading.Tasks.Task.FromResult(this.DeserializeFromStream(type, readStream)));
}
private object DeSerialize(Type type, Stream readStream, System.Net.Http.HttpContent content, IFormatterLogger formatterLogger)
{
HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
// If content length is 0 then return default value for this type
if (contentHeaders != null && contentHeaders.ContentLength == 0)
{
return(GetDefaultValueForType(type));
}
// Get the character encoding for the content
Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders);
try
{
using (var reader = new StreamReader(readStream, effectiveEncoding, false, 512, true))
{
var deserialize = TypedDeserializers.GetTyped(type);
return(deserialize(reader, _jilOptions));
}
}
catch (Exception e)
{
if (formatterLogger == null)
{
throw;
}
formatterLogger.LogError(String.Empty, e);
return(GetDefaultValueForType(type));
}
}
public override Task WriteToStreamAsync
(
Type type, object value,
Stream stream,
System.Net.Http.HttpContent content,
System.Net.TransportContext transportContext
)
{
JsonSerializer serializer = JsonSerializer.Create(_jsonSerializerSettings);
return(Task.Factory.StartNew
(
() =>
{
using
(
JsonTextWriter jsonTextWriter = new JsonTextWriter
(
new StreamWriter(stream, Encoding.UTF8)
)
{
CloseOutput = false
}
)
{
serializer.Serialize(jsonTextWriter, value);
jsonTextWriter.Flush();
}
}
));
}
/// <summary>
/// 將 PUT 要求傳送至指定的 URI
/// </summary>
/// <param name="uri">The RequestUri</param>
/// <param name="httpContent">The HttpContent</param>
public void Put(Uri uri, System.Net.Http.HttpContent httpContent)
{
if (uri == null)
{
throw new ArgumentNullException("uri");
}
if (httpContent == null)
{
throw new ArgumentNullException("httpContent");
}
using (var client = new System.Net.Http.HttpClient())
{
client.MaxResponseContentBufferSize = this.MaxResponseContentBufferSize;
client.Timeout = this.Timeout;
this.SetHttpHeader(client);
this.SetMediaTypeHeaderValue(client);
var response = client.PutAsync(uri, httpContent).Result;
this.ResponseBody = response.Content.ReadAsStringAsync().Result;
this.HttpStatusCode = response.StatusCode;
}
}
public override Task WriteToStreamAsync(Type type, object value,
Stream writeStream, System.Net.Http.HttpContent content,
System.Net.TransportContext transportContext)
{
return(Task.Factory.StartNew(() =>
{
if (typeof(IEnumerable <IData>).IsAssignableFrom(type))
{
Type elementType = type.GetGenericArguments().First();
var resultXElement = new XElement("Data");
foreach (var element in (value as IEnumerable))
{
resultXElement.Add(GetXNode(elementType.Name, element).Root);
}
resultXElement.Save(writeStream);
return;
}
XDocument xNode = GetXNode(type.Name, value);
xNode.Save(writeStream);
}));
}
private void WriteToStream(Type type, object value,
Stream writeStream, System.Net.Http.HttpContent content,
System.Net.TransportContext transportContext, CancellationToken cancellationToken)
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
using (var writer = new BinaryWriter(writeStream))
{
var serializer = ObjectBuilder.GetSerializer();
var result = serializer.Serialize(value, ModeType.WebAPI);
if (cancellationToken.IsCancellationRequested)
{
return;
}
if (result == null)
{
return;
}
writer.Write(result.Data);
}
}
public override Task WriteToStreamAsync
(
Type type,
object value,
Stream stream,
System.Net.Http.HttpContent content,
System.Net.TransportContext transportContext
)
{
Task task = null;
task = Task.Factory.StartNew
(
() =>
{
System.Web.Script.Serialization.JavaScriptSerializer ser = null;
ser = new System.Web.Script.Serialization.JavaScriptSerializer();
string json = ser.Serialize(value);
byte[] b = Encoding.UTF8.GetBytes(json);
stream.Write(b, 0, b.Length);
stream.Flush();
}
);
return(task);
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream,
System.Net.Http.HttpContent content,
System.Net.TransportContext transportContext, CancellationToken cancellationToken)
{
return(Task.Factory.StartNew(() => WriteToStream(type, value, writeStream, content,
transportContext, cancellationToken)));
}
public string PostHttpData(string url, System.Net.Http.HttpContent postdata)
{
var t = PostHttpDataAsync(url, postdata);
// t.Wait();
return(t.Result);
}
public override Task <object> ReadFromStreamAsync
(
Type type,
Stream stream,
System.Net.Http.HttpContent content,
IFormatterLogger formatterLogger
)
{
Task <object> task = null;
task = Task <object> .Factory.StartNew
(
() =>
{
System.Web.Script.Serialization.JavaScriptSerializer ser = null;
ser = new System.Web.Script.Serialization.JavaScriptSerializer();
string json;
using (var sr = new StreamReader(stream))
{
json = sr.ReadToEnd();
}
object val = ser.Deserialize(json, type);
return(val);
}
);
return(task);
}
/// <summary>
/// Read from stream
/// </summary>
/// <param name="type"></param>
/// <param name="stream"></param>
/// <param name="contentHeaders"></param>
/// <param name="formatterContext"></param>
/// <returns></returns>
public override Task <object> ReadFromStreamAsync(Type type, Stream stream, System.Net.Http.HttpContent contentHeaders, IFormatterLogger formatterContext)
{
var task = Task <object> .Factory.StartNew(() =>
{
try
{
var settings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
};
var sr = new StreamReader(stream);
var jreader = new JsonTextReader(sr);
var ser = new JsonSerializer();
ser.Converters.Add(new IsoDateTimeConverter());
object val = ser.Deserialize(jreader, type);
return(val);
}
catch (Exception ex)
{
_tracing.Error(ex, null);
return(null);
}
});
return(task);
}
public static async System.Threading.Tasks.Task <IQueryable <IndicativeExchangeRates.Model.Currency> > GetData()
{
string responseBody = string.Empty;
using (System.Net.Http.HttpResponseMessage response = await ServiceClient.GetHttpResponse())
{
if (response.IsSuccessStatusCode)
{
using (System.Net.Http.HttpContent content = response.Content)
{
responseBody = await content.ReadAsStringAsync();
}
}
else
{
Log.Logger.Instance.Error(new Exception($"UserName:{Authentication.AuthService.UserName} - Exchange rate data is not available. Response is {response.StatusCode.ToString()}"));
throw new Exception("No data available!");
}
}
if (responseBody.EndsWith(@"</Tarih_Date"))
{
responseBody = responseBody.Replace("</Tarih_Date", "</Tarih_Date>");
}
System.Xml.Linq.XDocument document = System.Xml.Linq.XDocument.Parse(responseBody);
var resultSet = (from result in document.Descendants("Currency")
.Where(result => result.Descendants("Isim").Any())
.Where(result => result.Descendants("CurrencyName").Any())
.Where(result => result.LastAttribute != null)
.Where(result => result.Descendants("ForexBuying").Any())
.Where(result => result.Descendants("ForexSelling").Any())
.Where(result => result.Descendants("BanknoteBuying").Any())
.Where(result => result.Descendants("BanknoteSelling").Any())
select
new IndicativeExchangeRates.Model.Currency
{
Tarih = document.Root.Attribute("Tarih").Value.Trim(),
Date = document.Root.Attribute("Date").Value.Trim(),
Bulten_No = document.Root.Attribute("Bulten_No").Value.Trim(),
CrossOrder = result.Attribute("CrossOrder").Value.Trim(),
Kod = result.Attribute("Kod").Value.Trim(),
CurrencyCode = result.Attribute("CurrencyCode").Value.Trim(),
Unit = Convert.ToByte(result.Element("Unit").Value.Trim()),
Isim = result.Element("Isim").Value.Trim(),
CurrencyName = result.Element("CurrencyName").Value.Trim(),
ForexBuying = (!string.IsNullOrWhiteSpace(result.Element("ForexBuying").Value.Trim()) ? Convert.ToDecimal(result.Element("ForexBuying").Value.Trim()) : default(decimal?)),
ForexSelling = (!string.IsNullOrWhiteSpace(result.Element("ForexSelling").Value.Trim()) ? Convert.ToDecimal(result.Element("ForexSelling").Value.Trim()) : default(decimal?)),
BanknoteBuying = (!string.IsNullOrWhiteSpace(result.Element("BanknoteBuying").Value.Trim()) ? Convert.ToDecimal(result.Element("BanknoteBuying").Value.Trim()) : default(decimal?)),
BanknoteSelling = (!string.IsNullOrWhiteSpace(result.Element("BanknoteSelling").Value.Trim()) ? Convert.ToDecimal(result.Element("BanknoteSelling").Value.Trim()) : default(decimal?)),
CrossRateUSD = (!string.IsNullOrWhiteSpace(result.Element("CrossRateUSD").Value.Trim()) ? Convert.ToDecimal(result.Element("CrossRateUSD").Value.Trim()) : default(decimal?)),
CrossRateOther = (!string.IsNullOrWhiteSpace(result.Element("CrossRateOther").Value.Trim()) ? Convert.ToDecimal(result.Element("CrossRateOther").Value.Trim()) : default(decimal?))
}).AsQueryable();
return(resultSet);
}
public override object ReadFromStream(Type type, System.IO.Stream readStream,
System.Net.Http.HttpContent content, IFormatterLogger formatterLogger, System.Threading.CancellationToken cancellationToken)
{
var data = new StreamReader(readStream).ReadToEnd();
var obj = JsonConvert.DeserializeObject <DataTable>(data);
return(obj);
}
public static async Task <object> ToObjectAsync(this SystemHttpContent source, Type type)
{
if (source is null)
{
return(null);
}
return(Utils.Json.ToObject(await source.ReadAsStringAsync(), type));
}
public static async Task <object> ToStreamContentAsync(this SystemHttpContent source)
{
if (source is null)
{
return(null);
}
return(new StreamContent(await source.ReadAsStreamAsync()));
}
public static async Task <object> ToDictionaryAsync(this SystemHttpContent source)
{
if (source is null)
{
return(null);
}
return(Utils.Json.ToDictionary(await source.ReadAsStringAsync()));
}
public static async Task <object> ToByteArrayContentAsync(this SystemHttpContent source)
{
if (source is null)
{
return(null);
}
return(new ByteArrayContent(await source.ReadAsByteArrayAsync()));
}
public override Task WriteToStreamAsync(Type type,
object value,
Stream writeStream,
System.Net.Http.HttpContent content,
System.Net.TransportContext transportContext)
{
// Create a document builder.
var document = new SqadXlsxDocumentBuilder(writeStream);
if (value == null)
{
return(document.WriteToStream());
}
var valueType = value.GetType();
// Get the item type.
var itemType = FormatterUtils.IsSimpleType(valueType)
? null
: FormatterUtils.GetEnumerableItemType(valueType);
// If a single object was passed, treat it like a list with one value.
if (itemType == null)
{
itemType = valueType;
}
// Used if no other matching serialiser can be found.
IXlsxSerializer serializer = null;
// Determine if a more specific serialiser might apply.
if (Serializers != null)
{
foreach (var s in Serializers)
{
if (!s.CanSerializeType(valueType, itemType) || s.SerializerType != _serializerType)
{
continue;
}
serializer = s;
break;
}
}
serializer?.Serialize(itemType, value, document, null, null, null);
if (!document.IsVBA)
{
content.Headers.ContentDisposition.FileName =
content.Headers.ContentDisposition.FileName.Replace("xlsm", "xlsx");
}
return(document.WriteToStream());
}
public override System.Threading.Tasks.Task WriteToStreamAsync(System.Type type, object value
, System.IO.Stream writeStream
, System.Net.Http.HttpContent content
, System.Net.TransportContext transportContext)
{
System.IO.StreamWriter streamWriter = new System.IO.StreamWriter(writeStream);
Jil.JSON.Serialize(value, streamWriter, _jilOptions);
streamWriter.Flush();
return(System.Threading.Tasks.Task.FromResult(writeStream));
}
public ConvertedHttpContent(System.Net.Http.HttpContent httpContent)
{
content = httpContent;
Headers = new HttpContentHeaderCollection();
foreach (KeyValuePair <string, IEnumerable <string> > header in httpContent.Headers)
{
Headers.Add(header.Key, header.Value.First());
}
}
doPost_NativeResponse(string uri, IEnumerable <KeyValuePair <string, string> > pairs = null)
{
System.Net.Http.HttpContent content = null;
if (pairs != null)
{
content = new System.Net.Http.FormUrlEncodedContent(pairs);
}
return(_httpClient.PostAsync(uri, content));
}
private static void createInitailItemPostObject()
{
StringBuilder msg = new StringBuilder();
msg.Append("[{");
msg.Append("\"op\": \"add\",");
msg.Append("\"path\": \"/fields/System.History\", ");
msg.Append(String.Format("\"value\": \"{0}\"",historyText));
msg.Append("}]");
httpStringContent = new System.Net.Http.StringContent(msg.ToString(), Encoding.UTF8, "application/json-patch+json");
}
private object Serialize(Type type, object value, Stream writeStream, System.Net.Http.HttpContent content, TransportContext transportContext)
{
Encoding effectiveEncoding = SelectCharacterEncoding(content == null ? null : content.Headers);
using (var writer = new StreamWriter(writeStream, effectiveEncoding, 512, true))
{
JSON.Serialize(value, writer, _jilOptions);
writer.Flush();
}
return(null);
}
public override Task <object> ReadFromStreamAsync(
Type type,
Stream readStream,
System.Net.Http.HttpContent content,
IFormatterLogger formatterLogger)
{
return(Task.Factory.StartNew(() => {
StreamReader reader = new StreamReader(readStream);
return (object)reader.ReadToEnd();
}));
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream,
System.Net.Http.HttpContent content,
System.Net.TransportContext transportContext)
{
return(Task.Factory.StartNew(() =>
{
if (type == typeof(FeedEntry) || type == typeof(IEnumerable <FeedEntry>))
{
BuildSyndicationFeed(value, writeStream, content.Headers.ContentType.MediaType);
}
}));
}
public override void WriteToStream(
Type type,
object value,
Stream writeStream,
System.Net.Http.HttpContent content)
{
var itemType = type.GetGenericArguments()[0];
var stringWriter = new StringWriter();
stringWriter.WriteLine(string.Join <string>(",", itemType.GetProperties().Select(x => x.Name)));
foreach (var obj in (IEnumerable <object>)value)
{
var vals = obj.GetType().GetProperties().Select(pi => new { Value = pi.GetValue(obj, null) });
var valueLine = string.Empty;
foreach (var val in vals)
{
if (val.Value != null)
{
var _val = val.Value.ToString();
//Check if the value contans a comma and place it in quotes if so
if (_val.Contains(","))
{
_val = string.Concat("\"", _val, "\"");
}
//Replace any \r or \n special characters from a new line with a space
if (_val.Contains("\r"))
{
_val = _val.Replace("\r", " ");
}
if (_val.Contains("\n"))
{
_val = _val.Replace("\n", " ");
}
valueLine = string.Concat(valueLine, _val, ",");
}
else
{
valueLine = string.Concat(string.Empty, ",");
}
}
stringWriter.WriteLine(valueLine.TrimEnd(','));
}
var streamWriter = new StreamWriter(writeStream);
streamWriter.Write(stringWriter.ToString());
}
public override void WriteToStream(Type type, object value, Stream stream, System.Net.Http.HttpContent content)
{
using (var writer = new StreamWriter(stream))
{
var timeCard = value as TimeCard;
if (timeCard == null)
{
throw new InvalidOperationException("Cannot serialize type");
}
WriteVCalendar(timeCard, writer);
}
stream.Close();
}
public override Task WriteToStreamAsync(
Type type,
object value,
Stream writeStream,
System.Net.Http.HttpContent content,
TransportContext transportContext)
{
return(Task.Factory.StartNew(() => {
StreamWriter writer = new StreamWriter(writeStream);
writer.Write(value);
writer.Flush();
}));
}
public override Task WriteToStreamAsync(Type type, object value,
Stream writeStream, System.Net.Http.HttpContent content,
System.Net.TransportContext transportContext)
{
return(Task.Factory.StartNew(() =>
{
var json = JsonConvert.SerializeObject(value);
var xml = JsonConvert
.DeserializeXmlNode("{\"Root\":" + json + "}", "");
xml.Save(writeStream);
}));
}
public async Task <string> PostHttpDataAsync(string url, System.Net.Http.HttpContent postdata)
{
var httpClient = new System.Net.Http.HttpClient();
var response = await httpClient.PostAsync(url, postdata);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return(await response.Content.ReadAsStringAsync());//加await的意思是说，主ＵＩ等待它执行完成后，再继续执行，这种就叫作并行！
}
else
{
return(null);//error
}
}
private static void createInitailItemPostObject()
{
StringBuilder msg = new StringBuilder();
msg.Append("[{");
msg.Append("\"op\": \"add\",");
msg.Append("\"path\": \"/relations/-\",");
msg.Append("\"value\": {");
msg.Append("\"rel\": \"AttachedFile\",");
msg.Append(String.Format("\"url\": \"{0}\",", attachmentUploadReturnObject.URL));
msg.Append("\"attributes\": {");
msg.Append("\"comment\": \"Spec for the work\"");
msg.Append("}");
msg.Append("}");
msg.Append("}]");
httpStringContent = new System.Net.Http.StringContent(msg.ToString(), Encoding.UTF8, "application/json-patch+json");
}
