private async void Button_Click(object sender, RoutedEventArgs e)
{
if (CountryPhoneCode.SelectedItem != null)
{
var _id = Guid.NewGuid().ToString("N");
var _countryPhoneCode = (CountryPhoneCode.SelectedItem as Country).PhoneCode;
var _countryName = (CountryPhoneCode.SelectedItem as Country).CountryName;
var _name = FullName.Text;
var _phoneNumber = PhoneNumber.Text;
var _password = Password.Password;
var client = new HttpClient()
{
BaseAddress = new Uri("http://yochat.azurewebsites.net/chat/")
};
var json = await client.GetStringAsync("createuser?id=" + _id + "&fullName=" + _name + "&password="******"&phoneNumber=" + _phoneNumber + "&countryPhoneCode=" + _countryPhoneCode);
var serializer = new DataContractJsonSerializer(typeof(User));
var ms = new MemoryStream();
var user = serializer.ReadObject(ms) as User;
Frame.Navigate(typeof(MainPage), user);
}
else
{
MessageDialog dialog = new MessageDialog("Lütfen Ülkenizi Seçiniz!");
await dialog.ShowAsync();
}
}
/// <summary>
/// Looks up a champion with the specified id.
/// </summary>
/// <param name="region">The region to check</param>
/// <param name="championId">id of the champion to look up</param>
/// <remarks>Version 1.2</remarks>
/// <returns></returns>
public Champion GetChampion(int championId)
{
Champion championCall = new Champion();
Champion staticChampionCall = new Champion();
DataContractJsonSerializer jSerializer = new DataContractJsonSerializer(typeof(Champion));
WebClient webClient = new WebClient();
try
{
championCall = (Champion)jSerializer.ReadObject(webClient.OpenRead(String.Format("https://{0}.api.pvp.net/api/lol/{0}/v1.2/champion/{1}?api_key={2}", _region, championId, _apiKey)));
staticChampionCall = (Champion)jSerializer.ReadObject(webClient.OpenRead(string.Format("https://{0}.api.pvp.net/api/lol/static-data/{0}/v1.2/champion/{1}?champData=all&api_key={2}", _region, championId, _apiKey)));
staticChampionCall.Active = championCall.Active;
staticChampionCall.BotEnabled = championCall.BotEnabled;
staticChampionCall.BotMmEnabled = championCall.BotMmEnabled;
staticChampionCall.FreeToPlay = championCall.FreeToPlay;
staticChampionCall.RankedPlayEnabled = championCall.RankedPlayEnabled;
}
catch (WebException e)
{
throw;
}
return staticChampionCall;
}
static void ChunkedUpload(string token,int size = 1024 * 1024, int parts = 10)
{
Util.RandomFile(size, "chunked.txt");
string respHTML = Util.HttpPost("https://api.onedrive.com/v1.0/drive/root:/chunked.txt:/upload.createSession", "", token);
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(UploadSession));
UploadSession task = (UploadSession)ser.ReadObject(new MemoryStream(Encoding.ASCII.GetBytes(respHTML)));
byte[] data = File.ReadAllBytes("chunked.txt");
int offset = int.Parse(task.nextExpectedRanges[0].Split(new char[] { '-' })[0]);
while (offset < data.Length)
{
int uplen = Math.Min(size / parts, data.Length - offset);
respHTML = Util.HttpPut(task.uploadUrl, token, data, offset, uplen,
"bytes " + offset + "-" + (offset + uplen - 1) + "/" + data.Length);
if (offset + uplen < data.Length)
{
UploadSession ttask = (UploadSession)ser.ReadObject(new MemoryStream(Encoding.ASCII.GetBytes(respHTML)));
offset = int.Parse(ttask.nextExpectedRanges[0].Split(new char[] { '-' })[0]);
}
else
offset = data.Length;
}
File.Delete("chunked.txt");
}
public List<Tweet> GetLatest( string p_Query, int p_Count = 100 ) {
TwitterResults _TwitterResults;
List<Tweet> _ReturnValue = new List<Tweet>();
DataContractJsonSerializer _JsonSerializer = new DataContractJsonSerializer( typeof( TwitterResults ) );
HttpWebRequest _Request = WebRequest.Create( string.Format( "{0}?q={1}&result_type=recent&count={2}", BASE_SEARCH_URL, p_Query, p_Count ) ) as HttpWebRequest;
_Request.Headers.Add( "Authorization", string.Format( "Bearer {0}", Credentials.access_token ) );
_Request.KeepAlive = false;
_Request.Method = "GET";
HttpWebResponse _Response = _Request.GetResponse() as HttpWebResponse;
_TwitterResults = (TwitterResults)_JsonSerializer.ReadObject( _Response.GetResponseStream() );
_ReturnValue.AddRange( _TwitterResults.statuses );
while( !string.IsNullOrWhiteSpace( _TwitterResults.search_metadata.next_results ) ) {
_Request = WebRequest.Create( string.Format( "{0}{1}", BASE_SEARCH_URL, _TwitterResults.search_metadata.next_results ) ) as HttpWebRequest;
_Request.Headers.Add( "Authorization", string.Format( "Bearer {0}", Credentials.access_token ) );
_Request.KeepAlive = false;
_Request.Method = "GET";
_Response = _Request.GetResponse() as HttpWebResponse;
_TwitterResults = (TwitterResults)_JsonSerializer.ReadObject( _Response.GetResponseStream() );
_ReturnValue.AddRange( _TwitterResults.statuses );
}
return _ReturnValue;
}
public async Task TestManifest()
{
var stream = new MemoryStream();
var cli = new SpeechClient();
cli.SetStream(stream);
await cli.SendManifest();
stream.Seek(0, SeekOrigin.Begin);
var reader = new StreamReader(stream);
var size = Convert.ToInt32(reader.ReadLine());
var outp = new char[size];
reader.ReadBlock(outp, 0, size);
var str = new String(outp);
var re = new Regex(@"^([A-Z_]*)");
Assert.IsTrue(re.Match(str).Value == "APP_MANIFEST");
var jsonstr = str.TrimStart(re.Match(str).Value.ToCharArray());
var jsonstream = new MemoryStream(Encoding.UTF8.GetBytes(jsonstr));
var ser = new DataContractJsonSerializer(typeof(Manifest));
Manifest jsonobj = (Manifest)ser.ReadObject(jsonstream);
Assert.IsTrue(jsonobj.Version == "0.0.1");
Assert.IsTrue(jsonobj.Name == "speech-recognizer");
Assert.IsTrue(jsonobj.DisplayName == "Mycroft Networked Speech Recognizer");
Assert.IsTrue(jsonobj.Description == "Lets applications register speech triggers for Mycroft to look for.");
Assert.IsTrue(jsonobj.InstanceId == "primary");
}
void clientCities_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
//MessageBox.Show(e.Result.);
var serializer = new DataContractJsonSerializer(typeof(Cities));
Cities ipResult = (Cities)serializer.ReadObject(e.Result);
List<AtrractionsList> citiesList = new List<AtrractionsList>();
for (int i = 0; i <= ipResult.addresses.Length - 1; i++)
{
Random k = new Random();
Double value = 0;
String DefaultTitle = "Title";
String DefaultDescription = "Description";
String RandomType = "";
value = k.NextDouble();
DefaultTitle = ipResult.addresses[i].Name.ToString();
DefaultDescription = ipResult.addresses[i].ID.ToString();
RandomType = "Place" ;
citiesList.Add(new AtrractionsList(DefaultTitle, DefaultDescription, RandomType));
}
listBoxCities.ItemsSource = citiesList;
listBoxAttractions.ItemsSource = citiesList;
}
static string OfflineDownload(string url, string path)
{
string respHTML = Util.HttpPost("https://api.dropboxapi.com/1/save_url/auto/" + path + "?", "url=" + url, token);
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(OfflineTask));
OfflineTask link = (OfflineTask)ser.ReadObject(new MemoryStream(Encoding.ASCII.GetBytes(respHTML)));
return link.job;
}
/// <summary>
/// Deserialize String to Object
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="json"></param>
/// <returns></returns>
public static T Deserialize <T>(string json)
{
MemoryStream ms = null;
T result = result = Activator.CreateInstance <T>();
try
{
DateTime startTime = DateTime.Now;
ms = new MemoryStream(Encoding.UTF8.GetBytes(json));
System.Runtime.Serialization.Json.DataContractJsonSerializer serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(result.GetType());
/*System.Runtime.Serialization.Json.DataContractJsonSerializer serializer =
* new System.Runtime.Serialization.Json.DataContractJsonSerializer(obj.GetType(), new List<Type>(), Int16.MaxValue, false,
* new ZentoSurrogate(), false);*/
result = (T)serializer.ReadObject(ms);
double time = (DateTime.Now - startTime).TotalSeconds;
totalTimeExecution += time;
}
catch (Exception e)
{
LogHelper.LogError("exception while deserializing : " + e.Message + " - " + e.StackTrace);
throw e;
}
finally
{
ms.Close();
ms.Dispose();
}
return(result);
}
public static ExecutionResult<ListPostsModel> Execute()
{
try
{
var data = new ListPostsRequestData
{
AccessToken = DisqusOptions.GetInstance().AccessToken
};
var request = BuildRequest("https://disqus.com/api/3.0/users/listActivity.json", HttpMethod.GET, data);
var response = (HttpWebResponse)request.GetResponse();
using (var stream = new StreamReader(response.GetResponseStream()))
{
var serializer = new DataContractJsonSerializer(typeof(ListPostsModel));
var result = serializer.ReadObject(stream.BaseStream) as ListPostsModel;
return ExecutionResult<ListPostsModel>.Create(result);
}
}
catch (Exception e)
{
return ExecutionResult<ListPostsModel>.CreateError(e);
}
}
/// <summary>
/// Create a new PebbleBundle from a .pwb file and parse its metadata.
/// </summary>
/// <param name="bundle">The stream to the bundle.</param>
/// <param name="zip">The zip library implementation.</param>
public void Load(Stream bundle, IZip zip)
{
//TODO: This needs to be refactored, probably put into a Load method
if (false == zip.Open(bundle))
throw new InvalidOperationException("Failed to open pebble bundle");
using (Stream manifestStream = zip.OpenEntryStream("manifest.json"))
{
if (manifestStream == null)
{
throw new InvalidOperationException("manifest.json not found in archive - not a valid Pebble bundle.");
}
var serializer = new DataContractJsonSerializer(typeof(BundleManifest));
Manifest = (BundleManifest)serializer.ReadObject(manifestStream);
}
HasResources = (Manifest.Resources.Size != 0);
if (HasResources)
{
using (Stream resourcesBinary = zip.OpenEntryStream(Manifest.Resources.Filename))
{
if (resourcesBinary == null)
throw new PebbleException("Could not find resource entry in the bundle");
Resources = Util.GetBytes(resourcesBinary);
}
}
LoadData(zip);
}
private PaymentReceipt DeserializeOrderBlob(PaymentReceipt receipt)
{
var ser = new DataContractJsonSerializer(typeof (PaymentReceipt));
var ms = new MemoryStream(Encoding.UTF8.GetBytes(receipt.orderblob));
var deserializeReceipt = (PaymentReceipt) ser.ReadObject(ms);
return deserializeReceipt;
}
public void SaveCategories(string db)
{
foreach (Category cat in categories)
{
//Get an image for every category
string imageUrl = string.Empty;
string products = Program.ExecuteGetCommand(string.Format(Program.SSProductQueryUrl, cat.id), string.Empty, string.Empty);
using (Stream s = Program.GenerateStreamFromString(products))
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Products));
Products SSProducts = (Products)ser.ReadObject(s);
imageUrl = SSProducts.products[0].images[2].url;
}
string query = "EXEC [stp_SS_SaveCategory] @id=N'" + cat.id.Replace("'", "\"") + "', @parentId=N'" + cat.parentId.Replace("'", "\"")
+ "', @name=N'" + cat.name.Replace("'", "\"") + "', @imageUrl='" + imageUrl.Replace("'", "\"") + "'";
SqlConnection myConnection = new SqlConnection(db);
try
{
myConnection.Open();
using (SqlDataAdapter adp = new SqlDataAdapter(query, myConnection))
{
SqlCommand cmd = adp.SelectCommand;
cmd.CommandTimeout = 300000;
cmd.ExecuteNonQuery();
}
}
finally
{
myConnection.Close();
}
}
}
/// <summary>
/// This example uses the raw JSON string to create a POST
/// request for sending one or more SMTP messages through Email-On-Demand.
///
/// The JSON request generated by this sample code looks like this:
///
///{
/// "ServerId": "YOUR SERVER ID HERE",
/// "ApiKey": "YOUR API KEY HERE",
/// "Messages": [{
/// "Subject": "Email subject line for raw JSON example.",
/// "TextBody": "The text portion of the message.",
/// "HtmlBody": "<h1>The html portion of the message</h1><br/>Test",
/// "To": [{
/// "EmailAddress": "*****@*****.**",
/// "FriendlyName": "Customer Name"
/// }],
/// "From": {
/// "EmailAddress": "*****@*****.**",
/// "FriendlyName": "From Address"
/// },
/// }]
///}
/// </summary>
public static void SimpleInjectionViaStringAsJson(
int serverId, string yourApiKey, string apiUrl)
{
// The client object processes requests to the SocketLabs Injection API.
var client = new RestClient(apiUrl);
// Construct the string used to generate JSON for the POST request.
string stringBody =
"{" +
"\"ServerId\":\"" + serverId + "\"," +
"\"ApiKey\":\"" + yourApiKey + "\"," +
"\"Messages\":[{" +
"\"Subject\":\"Email subject line for raw JSON example.\"," +
"\"TextBody\":\"The text portion of the message.\"," +
"\"HtmlBody\":\"<h1>The html portion of the message</h1><br/>Test\"," +
"\"To\":[{" +
"\"EmailAddress\":\"[email protected]\"," +
"\"FriendlyName\":\"Customer Name\"" +
"}]," +
"\"From\":{" +
"\"EmailAddress\":\"[email protected]\"," +
"\"FriendlyName\":\"From Address\"" +
"}," +
"}]" +
"}";
try
{
// Generate a new POST request.
var request = new RestRequest(Method.POST) { RequestFormat = DataFormat.Json };
// Store the request data in the request object.
request.AddParameter("application/json; charset=utf-8", stringBody, ParameterType.RequestBody);
// Make the POST request.
var result = client.ExecuteAsPost(request, "POST");
// Store the response result in our custom class.
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(result.Content)))
{
var serializer = new DataContractJsonSerializer(typeof (PostResponse));
var resp = (PostResponse) serializer.ReadObject(stream);
// Display the results.
if (resp.ErrorCode.Equals("Success"))
{
Console.WriteLine("Successful injection!");
}
else
{
Console.WriteLine("Failed injection! Returned JSON is: ");
Console.WriteLine(result.Content);
}
}
}
catch (Exception ex)
{
Console.WriteLine("Error, something bad happened: " + ex.Message);
}
}
public object Deserialize(WebFormatterDeserializationContext context, Type type)
{
if (context.ContentFormat != WebFormatterDeserializationContext.DeserializationFormat.Xml)
throw new InvalidDataException("Data must be in xml format.");
var serializer = new DataContractJsonSerializer(type);
return serializer.ReadObject(context.XmlReader);
}
public Response Get(UrlRequest request)
{
using (DbConnection connection = _factory.CreateConnection())
{
connection.ConnectionString = _connectionString;
connection.Open();
DbCommand cmd = connection.CreateCommand();
cmd.CommandText = "select [Value] from EmbedlyCache where [Key] = @key";
DbParameter pKey = cmd.CreateParameter();
pKey.DbType = DbType.Guid;
pKey.Direction = ParameterDirection.Input;
pKey.ParameterName = "key";
pKey.Value = request.CacheKey;
cmd.Parameters.Add(pKey);
var value = (string)cmd.ExecuteScalar();
if (value == null)
return null;
byte[] bytes = Encoding.Default.GetBytes(value);
using (var ms = new MemoryStream(bytes))
{
var serializer = new DataContractJsonSerializer(typeof (Response));
var response = (Response)serializer.ReadObject(ms);
return response;
}
}
}
private void AutenticateWNS()
{
try
{
// get an access token
var urlEncodedSid = HttpUtility.UrlEncode(String.Format("{0}", this.Sid));
var urlEncodedSecret = HttpUtility.UrlEncode(this.Secret);
var uri =
String.Format("grant_type=client_credentials&client_id={0}&client_secret={1}&scope=notify.windows.com",
urlEncodedSid,
urlEncodedSecret);
var client = new WebClient();
client.Headers.Add("Content-Type", "application/x-www-form-urlencoded");
string response = client.UploadString("https://login.live.com/accesstoken.srf", uri);
// parse the response in JSON format
OAuthToken token;
using (var ms = new MemoryStream(Encoding.Unicode.GetBytes(response)))
{
var ser = new DataContractJsonSerializer(typeof(OAuthToken));
token = (OAuthToken)ser.ReadObject(ms);
}
this.accessToken = token.AccessToken;
}
catch (Exception ex)
{
//lblResult.Text = ex.Message;
//lblResult.ForeColor = System.Drawing.Color.Red;
throw ex;
}
}
static void GetDownloadLink()
{
string respHTML = Util.HttpPost("https://api.dropboxapi.com/1/media/auto/simple.txt", "", token);
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(DownloadLink));
DownloadLink link = (DownloadLink)ser.ReadObject(new MemoryStream(Encoding.ASCII.GetBytes(respHTML)));
Console.WriteLine(link.url);
}
/// <summary>
/// Get Presence information per user.
/// </summary>
private async void AsyncPresence()
{
var client = new HttpClient();
var uri = new Uri(string.Format(Configurations.PresenceUrl, Configurations.ApiKey, _currentMember.id));
var response = await client.GetAsync(uri);
var statusCode = response.StatusCode;
switch (statusCode)
{
// TODO: Error handling for invalid htpp responses.
}
response.EnsureSuccessStatusCode();
var theResponse = await response.Content.ReadAsStringAsync();
using (var ms = new MemoryStream(Encoding.Unicode.GetBytes(theResponse)))
{
var serializer = new DataContractJsonSerializer(typeof(PresenceRoot));
var presenceObject = serializer.ReadObject(ms) as PresenceRoot;
// This will allow the application to toggle the presence indicator color.
if (presenceObject != null && presenceObject.ok && presenceObject.IsActive())
{
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
StatusIndicator.Fill = new SolidColorBrush(Color.FromArgb(255, 127, 153, 71));
});
}
// TODO: Add more code for bad replies or invalid requests.
}
}
private void LoadFile(string path)
{
ProTeGe.ProjectSaveInfo saveInfo;
byte[] bytes;
try{
bytes = File.ReadAllBytes(path);
} catch {
labelError.text = "Could not open file:\n\n" + path;
panelError.SetActive(true);
return;
}
try{
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(ProTeGe.ProjectSaveInfo));
saveInfo = (ProTeGe.ProjectSaveInfo)serializer.ReadObject(new MemoryStream(bytes));
}
catch {
labelError.text = "File has wrong format:\n\n" + path;
panelError.SetActive(true);
return;
}
ProTeGe.ProjectManager.Load(saveInfo);
Globals.instance.components.dialogManager.CloseDialog();
}
public List<Ticket> GetTickets()
{
lock (lockObj)
{
IOrderedEnumerable<string> files = from file in Directory.GetFiles(PathInfo.Ticket)
where DateTime.Compare(DateTime.Now.AddSeconds(-10), new FileInfo(file).LastWriteTime) > 0
orderby file ascending
select file;
List<Ticket> tickets = new List<Ticket>();
foreach (string file in files)
{
Ticket ticket = null;
using (FileStream stream = new FileStream(PathInfo.CombinePath(PathInfo.Ticket, file), FileMode.Open))
{
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Ticket));
ticket = (Ticket)serializer.ReadObject(stream);
}
if (ticket != null)
{
tickets.Add(ticket);
}
}
return tickets;
}
}
public void CanRetrieveSimpleResourceDetails()
{
using (var host = new InMemoryHost(new SampleApi.Configuration()))
{
var request = new InMemoryRequest
{
Uri = new Uri("http://localhost/api-docs/simple"),
HttpMethod = "GET",
Entity = {ContentType = MediaType.Json}
};
request.Entity.Headers["Accept"] = "application/json";
var response = host.ProcessRequest(request);
var statusCode = response.StatusCode;
Assert.AreEqual(200, statusCode);
Assert.IsTrue(response.Entity.ContentLength>0);
response.Entity.Stream.Seek(0, SeekOrigin.Begin);
var serializer = new DataContractJsonSerializer(typeof(ResourceDetails));
var resourceDetails = (ResourceDetails) serializer.ReadObject(response.Entity.Stream);
Assert.IsNotNull(resourceDetails);
}
}
public static void load()
{
IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication();
try
{
IsolatedStorageFileStream stream = store.OpenFile(storeFilename, FileMode.OpenOrCreate);
if (null != stream)
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(FoundData));
App.found = (FoundData)ser.ReadObject(stream);
stream.Close();
if (null == App.found)
{ // First time app was run since installation
App.found = new FoundData();
}
}
loadUI();
}
catch (System.Exception) { };
// App.nearby.loadHosts(); Todo: Remove?
}
/// <summary>
/// Загрузка из локального хранилища настроек в формате JSON
/// </summary>
public async void LoadSettingsAsync()
{
StorageFile settingsFile = null;
bool isExists = true;
try
{
settingsFile = await StorageFile.GetFileFromPathAsync(Constants.SettingsFile);
}
catch (FileNotFoundException)
{
isExists = false;
}
if (!isExists)
{
Settings = new SettingsVariables();
}
else
{
using (var fileStream = await settingsFile.OpenStreamForReadAsync())
{
MemoryStream memoryStream = new MemoryStream();
await fileStream.CopyToAsync(memoryStream);
memoryStream.Position = 0;
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(SettingsVariables));
Settings = (SettingsVariables)serializer.ReadObject(memoryStream);
}
}
}
public void MessageProcess(object objMessage)
{
status status = new status();
Logger logger = new Logger();
DataContractJsonSerializer json = new DataContractJsonSerializer(status.GetType());
try
{
Message message = objMessage as Message;
byte[] byteArray = Encoding.UTF8.GetBytes(message.Body.ToString());
MemoryStream stream = new MemoryStream(byteArray);
//TODO: Check for multiple objects.
status = json.ReadObject(stream) as status;
Console.WriteLine(message.Body.ToString());
//TODO: Store the status object
DataStore.Add(status);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
logger.append(ex.Message, Logger.LogLevel.ERROR);
}
}
public static GeocodeResponse MakeRequest(string addressNumber, string streetName, string cityName, string countryName)
{
string requestUrl = CreateGeocodeRequest(addressNumber, streetName, cityName, countryName);
try
{
HttpWebRequest request = WebRequest.Create(requestUrl) as HttpWebRequest;
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
if (response.StatusCode != HttpStatusCode.OK)
throw new Exception(String.Format(
"Server error (HTTP {0}: {1}).",
response.StatusCode,
response.StatusDescription));
DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(GeocodeResponse));
object objResponse = jsonSerializer.ReadObject(response.GetResponseStream());
GeocodeResponse jsonResponse
= objResponse as GeocodeResponse;
return jsonResponse;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return null;
}
}
public async void Initialize()
{
SystemTray.Message = "読み込み中...";
SystemTray.IsBusy = true;
Content = "読み込み中...";
HttpClient httpClient = new HttpClient();
try
{
var uri = new Uri(Const.APIBase + "json/json");
var resp = await httpClient.GetAsync(uri);
var stream = await resp.Content.ReadAsStreamAsync();
var serializer = new DataContractJsonSerializer(typeof(DemoJson));
var result = (DemoJson)serializer.ReadObject(stream);
stream.Dispose();
Content = "Status.Code=" + result.Status.Code;
foreach (var item in result.Result.Items)
{
Items.Add(item);
}
}
catch (Exception e)
{
Content = e.ToString();
}
SystemTray.IsBusy = false;
}
protected void Page_Load(object sender, EventArgs e) {
this.RegisterAsyncTask(
new PageAsyncTask(
async ct => {
IAuthorizationState authorization = await client.ProcessUserAuthorizationAsync(new HttpRequestWrapper(Request), ct);
if (authorization == null) {
// Kick off authorization request
var request = await client.PrepareRequestUserAuthorizationAsync(cancellationToken: ct);
await request.SendAsync();
this.Context.Response.End();
} else {
string token = authorization.AccessToken;
AzureADClaims claimsAD = client.ParseAccessToken(token);
// Request to AD needs a {tenantid}/users/{userid}
var request =
WebRequest.Create("https://graph.windows.net/" + claimsAD.Tid + "/users/" + claimsAD.Oid + "?api-version=0.9");
request.Headers = new WebHeaderCollection();
request.Headers.Add("authorization", token);
using (var response = request.GetResponse()) {
using (var responseStream = response.GetResponseStream()) {
var serializer = new DataContractJsonSerializer(typeof(AzureADGraph));
AzureADGraph graphData = (AzureADGraph)serializer.ReadObject(responseStream);
this.nameLabel.Text = HttpUtility.HtmlEncode(graphData.DisplayName);
}
}
}
}));
}
/// <summary>
/// 演示DataContractJsonSerializer的序列化和反序列化
/// </summary>
void ShowDataContractJsonSerializer()
{
var dataContractJsonSerializerObject = new API.DataContractJsonSerializerObject {
ID = Guid.NewGuid(), Name = "DataContractJsonSerializer", Age = 28, Time = DateTime.Now
};
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(API.DataContractJsonSerializerObject));
// 序列化
var ms = new MemoryStream();
serializer.WriteObject(ms, dataContractJsonSerializerObject);
ms.Position = 0;
var sr = new StreamReader(ms);
var str = sr.ReadToEnd();
txtDataContractJsonSerializer.Text = str;
// 反序列化
var buffer = System.Text.Encoding.UTF8.GetBytes(str);
var ms2 = new MemoryStream(buffer);
var dataContractJsonSerializerObject2 = serializer.ReadObject(ms2) as API.DataContractJsonSerializerObject;
lblDataContractJsonSerializer.Text = dataContractJsonSerializerObject2.Name;
}
public void handleReply(string json)
{
if (json == null)
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
progressBar1.IsIndeterminate = false;
MessageBox.Show("Unable to communicate with server.");
});
return;
}
DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(StudentResponse));
student = dcjs.ReadObject(new MemoryStream(Encoding.Unicode.GetBytes(json))) as StudentResponse;
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
this.tStudentName.Text = student.nome;
StudentProfileModel.Items[0].LineTwo = student.codigo;
StudentProfileModel.Items[1].LineTwo = student.email;
StudentProfileModel.Items[2].LineTwo = student.email_alternativo;
StudentProfileModel.Items[3].LineTwo = student.curso_nome;
StudentProfileModel.Items[4].LineTwo = student.estado;
StudentProfileModel.Items[5].LineTwo = student.ano_curricular.ToString();
TiltEffect.SetIsTiltEnabled(lbItems.ItemContainerGenerator.ContainerFromIndex(1), true);
TiltEffect.SetIsTiltEnabled(lbItems.ItemContainerGenerator.ContainerFromIndex(2), true);
if (student.email_alternativo == null)
StudentProfileModel.Items.RemoveAt(2);
this.lbItems.SelectionChanged += new SelectionChangedEventHandler(sendEmailHandler);
progressBar1.IsIndeterminate = false;
});
}
static void Main(string[] args)
{
//DesktopUtil.Instance.GetChangedImages();
WebDesktopTCPServer server = new WebDesktopTCPServer();
server.Listen();
long now = System.DateTime.Now.Ticks / 10000;
while (true)
{
now = System.DateTime.Now.Ticks / 10000;
WebDesktopTCPClient CLIENT = new WebDesktopTCPClient("andy-PC", 3390, 3391);
string base64String = CLIENT.GetSliceImages();
MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(base64String));
DataContractJsonSerializer ser =
new DataContractJsonSerializer(typeof(DesktopSnapshotList));
DesktopSnapshotList ss = ser.ReadObject(ms) as DesktopSnapshotList;
// Console.WriteLine((System.DateTime.Now.Ticks / 10000 - now) + "ms");
for (int i = 0; i < ss.Count; i++)
{
// Console.WriteLine(ss[i].Width + " and " + ss[i].Height);
}
// Console.WriteLine(ss.Count);
Thread.Sleep(2000);
}
}
static void GetAccountInfo()
{
string respHTML = Util.HttpGet("https://api.dropboxapi.com/1/account/info", token);
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Person));
Person personinfo = (Person)ser.ReadObject(new MemoryStream(Encoding.ASCII.GetBytes(respHTML)));
Console.WriteLine(personinfo.display_name + " " + personinfo.email + " " + personinfo.quota_info.normal + "/" + personinfo.quota_info.quota);
}
void HandleResponse(IAsyncResult ar)
{
try
{
WebResponse response = ((HttpWebRequest)ar.AsyncState).EndGetResponse(ar);
var serializer = new DataContractJsonSerializer(typeof(respuesta));
var resp = (respuesta)serializer.ReadObject(response.GetResponseStream());
Dispatcher.BeginInvoke(() =>
{
this.DataContext = resp;
PhoneApplicationService.Current.State["respuesta"] = resp;
});
}
catch (Exception ex)
{
Dispatcher.BeginInvoke(() => {
MessageBox.Show("Tuvimos problema accediendo al internet (" + uri + "), favor verificar.");
NavigationService.GoBack();
});
}
}
public ConDepConfig GetEnvConfig(Stream stream)
{
ConDepConfig config;
using(var memStream = GetMemoryStreamWithCorrectEncoding(stream))
{
var serializer = new DataContractJsonSerializer(typeof(ConDepConfig));
config = (ConDepConfig)serializer.ReadObject(memStream);
}
if(config.Tiers == null)
{
foreach (var server in config.Servers)
{
if (!server.DeploymentUser.IsDefined)
{
server.DeploymentUser = config.DeploymentUser;
}
}
}
else
{
foreach(var tier in config.Tiers)
{
foreach (var server in tier.Servers)
{
if (!server.DeploymentUser.IsDefined)
{
server.DeploymentUser = config.DeploymentUser;
}
}
}
}
return config;
}
public static T DeSerialize <T>(string json)
{
T obj = Activator.CreateInstance <T>();
using (MemoryStream ms = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(json))) {
System.Runtime.Serialization.Json.DataContractJsonSerializer serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(obj.GetType());
return((T)serializer.ReadObject(ms));
}
}
public void LoadJsonData()
{
string Jsonstring = "";
#if !UNITY_EDITOR
Task.Run(async() =>
{
UnityEngine.WSA.Application.InvokeOnAppThread(() =>
{
m_debugLogManager.DebugLogTextWrite("MyDebug:*****************1");
}, false);
var file = await KnownFolders.DocumentsLibrary.GetFileAsync("City.txt");
UnityEngine.WSA.Application.InvokeOnAppThread(() =>
{
m_debugLogManager.DebugLogTextWrite("MyDebug:*****************2");
}, false);
Jsonstring = await FileIO.ReadTextAsync(file);
using (var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(Jsonstring)))
{
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(Prefecture));
// クラスにデータを読み込む
prefecture = serializer.ReadObject(stream) as Prefecture;
}
UnityEngine.WSA.Application.InvokeOnAppThread(() =>
{
m_debugLogManager.DebugLogTextWrite("MyDebug:*****************3");
//prefecture = JsonUtility.FromJson<Prefecture>(Jsonstring);
m_debugLogManager.DebugLogTextWrite("MyDebug:*****************4");
m_debugLogManager.DebugLogTextWrite("MyDebug:" + prefecture.Cities.Count);
m_debugLogManager.DebugLogTextWrite("MyDebug:" + prefecture.Cities[0].Name);
m_debugLogManager.DebugLogTextWrite(Jsonstring);
}, false);
});
#else
var textAsset = Resources.Load("City") as TextAsset;
Jsonstring = textAsset.text;
using (var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(Jsonstring)))
{
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(Prefecture));
// クラスにデータを読み込む
prefecture = serializer.ReadObject(stream) as Prefecture;
}
//prefecture = JsonUtility.FromJson<Prefecture>(Jsonstring);
m_debugLogManager.DebugLogTextWrite("MyDebug:" + prefecture.Cities.Count);
m_debugLogManager.DebugLogTextWrite("MyDebug:" + prefecture.Cities[0].Name);
m_debugLogManager.DebugLogTextWrite(Jsonstring);
#endif
}
public static object Deserialize(Stream streamObject, Type serializedObjectType)
{
if ((serializedObjectType == null) || (streamObject == null))
{
return(null);
}
System.Runtime.Serialization.Json.DataContractJsonSerializer serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(serializedObjectType);
return(serializer.ReadObject(streamObject));
}
/*public static bool DeserializeJson<T>(string json, ref T t)
* {
* using (var memoryStream = new MemoryStream())
* {
* byte[] jsonBytes = Encoding.UTF8.GetBytes(json);
* memoryStream.Write(jsonBytes, 0, jsonBytes.Length);
* memoryStream.Seek(0, SeekOrigin.Begin);
* using (var jsonReader = JsonReaderWriterFactory.CreateJsonReader(memoryStream, Encoding.UTF8, XmlDictionaryReaderQuotas.Max, null))
* {
* var serializer = new DataContractJsonSerializer(typeof(T));
* try
* {
* t = (T)serializer.ReadObject(jsonReader);
* }
* catch
* {
* return false;
* }
* }
* }
* return true;
* }*/
static public T DeserializeJson <T>(string json)
{
var instance = Activator.CreateInstance <T>();
using (var ms = new System.IO.MemoryStream(Encoding.Unicode.GetBytes(json)))
{
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(instance.GetType());
return((T)serializer.ReadObject(ms));
}
}
public static T Deserialize <T>(string json)
{
T obj = Activator.CreateInstance <T>();
MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(json));
System.Runtime.Serialization.Json.DataContractJsonSerializer serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(obj.GetType());
obj = (T)serializer.ReadObject(ms);
ms.Close();
ms.Dispose();
return(obj);
}
public T Deserialize <T>(string source, Encoding encoding)
{
byte[] bytes = encoding.GetBytes(source);
XmlDictionaryReader jsonReader = JsonReaderWriterFactory.CreateJsonReader(bytes,
XmlDictionaryReaderQuotas.Max);
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));
var graph = (T)serializer.ReadObject(jsonReader);
jsonReader.Close();
return(graph);
}
public void ReadExternal(IDataInput input)
{
string json = input.ReadUTF();
DataContractJsonSerializer serialiser = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(BroadcastNotification));
Stream stream = new MemoryStream(ASCIIEncoding.Default.GetBytes(json));
BroadcastNotification notification = (BroadcastNotification)serialiser.ReadObject(stream);
broadcastMessages = notification.broadcastMessages;
}
/// <summary>
/// Function to deserialize JSON string using DataContractJsonSerializer
/// </summary>
/// <typeparam name="RemoteContextType">RemoteContextType Generic Type</typeparam>
/// <param name="jsonString">string jsonString</param>
/// <returns>Generic RemoteContextType object</returns>
public static RemoteContextType DeserializeJsonString <RemoteContextType>(string jsonString)
{
//create an instance of generic type object
RemoteContextType obj = Activator.CreateInstance <RemoteContextType>();
MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(jsonString));
System.Runtime.Serialization.Json.DataContractJsonSerializer serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(obj.GetType());
obj = (RemoteContextType)serializer.ReadObject(ms);
ms.Close();
return(obj);
}
/// <summary>
/// Json转List<T>
/// </summary>
/// <param name="json"></param>
/// <param name="t"></param>
/// <returns></returns>
public static Object Json2Obj(String json, Type t)
{
try {
System.Runtime.Serialization.Json.DataContractJsonSerializer serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(t);
using (MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes(json))) {
return(serializer.ReadObject(ms));
}
} catch {
return(null);
}
}
/// <summary>
/// JSON格式字符转换为T类型的对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="jsonStr"></param>
/// <returns></returns>
public static T ParseFormByJson <T>(string jsonStr)
{
T obj = Activator.CreateInstance <T>();
using (System.IO.MemoryStream ms =
new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(jsonStr)))
{
System.Runtime.Serialization.Json.DataContractJsonSerializer serializer =
new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));
return((T)serializer.ReadObject(ms));
}
}
/// <summary>Deserializes the JSON string as a specified object</summary>
/// <typeparam name="T">Specified type of target object</typeparam>
/// <param name="jsonString">JSON string source</param>
/// <returns>Object of specied type</returns>
public static T Deserialize <T>(string jsonString)
{
using (System.IO.MemoryStream _Stream = new System.IO.MemoryStream(Encoding.Unicode.GetBytes(jsonString)))
{
try
{
var _Serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));
return((T)_Serializer.ReadObject(_Stream));
}
catch (Exception) { throw; }
}
}
public string MicrosoftTranslate(string input)
{
string clientID = "translatedhruba_123";
string clientSecret = "sJnnJgpG12Rysf7KxjeBpY5ulaCKSdaJYot7adFzXWY=";
String strTranslatorAccessURI =
"https://datamarket.accesscontrol.windows.net/v2/OAuth2-13";
String strRequestDetails =
string.Format("grant_type=client_credentials&client_id={0}&client_secret={1} &scope=http://api.microsofttranslator.com", HttpUtility.UrlEncode(clientID),
HttpUtility.UrlEncode(clientSecret));
System.Net.WebRequest webRequest = System.Net.WebRequest.Create(strTranslatorAccessURI);
webRequest.ContentType = "application/x-www-form-urlencoded";
webRequest.Method = "POST";
byte[] bytes = System.Text.Encoding.ASCII.GetBytes(strRequestDetails);
webRequest.ContentLength = bytes.Length;
string translatedtext = "";
try
{
using (System.IO.Stream outputStream = webRequest.GetRequestStream())
{
outputStream.Write(bytes, 0, bytes.Length);
}
System.Net.WebResponse webResponse = webRequest.GetResponse();
System.Runtime.Serialization.Json.DataContractJsonSerializer serializer = new
System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(AdmAccessToken));
AdmAccessToken token =
(AdmAccessToken)serializer.ReadObject(webResponse.GetResponseStream());
string headerValue = "Bearer " + token.access_token;
string txtToTranslate = input;
string uri = "http://api.microsofttranslator.com/v2/Http.svc/Translate?text=" +
System.Web.HttpUtility.UrlEncode(txtToTranslate) + "&from=no&to=en";
System.Net.WebRequest translationWebRequest = System.Net.WebRequest.Create(uri);
translationWebRequest.Headers.Add("Authorization", headerValue);
System.Net.WebResponse response = null;
response = translationWebRequest.GetResponse();
System.IO.Stream stream = response.GetResponseStream();
System.Text.Encoding encode = System.Text.Encoding.GetEncoding("utf-8");
System.IO.StreamReader translatedStream = new System.IO.StreamReader(stream, encode);
System.Xml.XmlDocument xTranslation = new System.Xml.XmlDocument();
xTranslation.LoadXml(translatedStream.ReadToEnd());
translatedtext = xTranslation.InnerText;
}
catch (Exception ex)
{
ExceptionHandling.errorMessage = ex.ToString();
}
return(translatedtext);
}
public void LoginResult(string responseStr)
{
//多网络
if (responseStr.IndexOf("CompanyName") > 0)
{
MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(responseStr));
var deserializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(System.Collections.Generic.List <UserInfo>));
//反序列化本地文件为List集合
var list = (System.Collections.Generic.List <UserInfo>)deserializer.ReadObject(ms);
ms.Close();
ms.Dispose();
//前台
Dispatcher.BeginInvoke(() =>
{
netsImtes.ItemsSource = list;
manyProject.Visibility = Visibility.Visible;
loginAnimate.Visibility = Visibility.Collapsed;
});
}
else
{
UserInfo login = new UserInfo();
MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(responseStr));
DataContractJsonSerializer ser = new DataContractJsonSerializer(login.GetType());
login = ser.ReadObject(ms) as UserInfo;
login.CompanyName = companyName;
UserDataManager.SaveUserInformation(login);
ms.Close();
ms.Dispose();
if (login.type == 1 || login.type == 7 || login.type == 8)
{
Dispatcher.BeginInvoke(() =>
{
MessageBox.Show(login.error);
//if (login.type==7)
//{
// LoginViewModel.GetChkCode((x) => {
// });
// Uri uri = new Uri("https://api.mingdao.com/code.aspx?0.7088238715659827", UriKind.Absolute);
// vImg.Source = new BitmapImage(uri);
// vBox.Visibility = Visibility.Visible;
//}
loginAnimate.Visibility = Visibility.Collapsed;
});
}
else
{
int codeindex = login.url.IndexOf("code") + 5;
string code = login.url.Substring(codeindex);
LoginViewModel.GetUserToken(code, GetUserTokenResult);
}
}
}
public static object Deserialize(Stream s, Type type)
{
if (s == null || type == null || type == null)
{
throw new ArgumentNullException();
}
if (!s.CanRead)
{
throw new ArgumentException();
}
R.DataContractJsonSerializer serializer = new R.DataContractJsonSerializer(type);
return(serializer.ReadObject(s));
}
/// <summary>
/// JSON反序列化
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
public static T Parse <T>(string source)
{
if (!string.IsNullOrWhiteSpace(source))
{
using (var ms = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(source)))
{
var ser = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));
var obj = ser.ReadObject(ms);
return((T)obj);
}
}
return(default(T));
}
public static T Deserialize <T>(string json)
{
var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
memoryStream.Position = 0;
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));
var serializedObject = (T)serializer.ReadObject(memoryStream);
memoryStream.Dispose();
return(serializedObject);
}
/// <summary>
/// JSON反序列化
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <returns></returns>
public static object Parse(Type t, string source)
{
if (!string.IsNullOrWhiteSpace(source))
{
using (var ms = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(source)))
{
var ser = new System.Runtime.Serialization.Json.DataContractJsonSerializer(t);
var obj = ser.ReadObject(ms);
return(obj);
}
}
return(null);
}
static int Main(string[] args)
{
if (args.Length == 0)
{
Console.Write("Missing api list input");
return(1);
}
var output = args[0];
var fi = new FileInfo(output);
if (!fi.Exists)
{
Console.Write("File not found: " + output);
return(2);
}
var settings = new DataContractJsonSerializerSettings();
settings.UseSimpleDictionaryFormat = true;
var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(AppliesToDataModel), settings);
var list = (AppliesToDataModel)serializer.ReadObject(File.OpenRead(fi.FullName));
var result = BuildApiList(list, fi.Directory.FullName);
var outfile = new FileInfo(Path.Combine(fi.Directory.FullName, list.Output));
if (!outfile.Directory.Exists)
{
outfile.Directory.Create();
}
using (StreamWriter sw = new StreamWriter(outfile.FullName))
{
foreach (var item in result.Values)
{
sw.WriteLine("---");
sw.WriteLine($"uid: {item.Id}");
sw.WriteLine($"appliesTo:");
foreach (var p in item.AppliesTo.GroupBy(p => p.Platform))
{
sw.WriteLine($" - platform: {p.Key}");
if (p.Where(t => !string.IsNullOrEmpty(t.Version)).Any())
{
sw.WriteLine($" versions: {string.Join(", ", p.Select(t => t.Version))}");
}
}
sw.WriteLine("---");
}
}
return(0);
}
public Optionizer()
{
SharedOptionizer = this;
saveDirectory = $"{AppDomain.CurrentDomain.BaseDirectory}\\Degra.config.json";
if (File.Exists(saveDirectory))
{
using (Stream stream = File.Open(saveDirectory, FileMode.Open))
{
if (stream.Length != 0)
{
Options = serializer.ReadObject(stream) as T;
}
}
}
else
{
Options = Activator.CreateInstance <T>();
}
}
public Optionizer(string ownAuthor, string ownTitle)
{
SharedOptionizer = this;
_ownAuthor = ownAuthor;
_ownTitle = ownTitle;
if (File.Exists($"{AppDomain.CurrentDomain.BaseDirectory}\\{ownTitle}.config.json"))
{
using (Stream stream = File.Open($"{AppDomain.CurrentDomain.BaseDirectory}\\{ownTitle}.config.json", FileMode.Open))
{
if (stream.Length != 0)
{
Options = serializer.ReadObject(stream) as T;
}
}
}
else
{
Options = Activator.CreateInstance <T> ();
}
}
/// <summary>
/// Json形式の文字列からC#で扱うデータに変換する
/// </summary>
/// <typeparam name="T">内部データ型</typeparam>
/// <param name="jsontext">Json形式文字列</param>
/// <returns>デシリアライズした内部データ型のコレクション</returns>
public static T ToData <T>(string jsontext) where T : IJsonData
{
try
{
byte[] contents = System.Text.Encoding.UTF8.GetBytes(jsontext);
MemoryStream strm = new MemoryStream();
strm.Write(contents, 0, contents.Length);
System.Runtime.Serialization.Json.DataContractJsonSerializer ser = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(T));
strm.Position = 0;
T p2 = (T)ser.ReadObject(strm);
return(p2);
}
catch (Exception ex)
{
throw new WebAPIFormatException(string.Format("{0}にデシリアライズ化できません。", typeof(T)), ex);
}
finally
{
}
}
public Pacote(byte[] msg)
{
users = new List <Amigo>();
JSON ser = new JSON(typeof(Pacote));
using (var ms = new MemoryStream(msg))
{
Pacote novo = (Pacote)ser.ReadObject(ms);
if (novo.action.ToLower() == "KEEPALIVE")
{
this.action = "";
}
this.action = novo.action.ToLower();
this.content = novo.content;
this.message = novo.message;
this.nickname = novo.nickname;
this.target = novo.target;
this.users = novo.users;
}
}
public static void Download(DocProject project, System.ComponentModel.BackgroundWorker worker, string baseurl, string username, string password)
{
if (project.Sections[4].Schemas.Count == 0)
{
project.Sections[4].Schemas.Add(new DocSchema());
}
string url = baseurl + "api/4.0/session/login?email=" + HttpUtility.UrlEncode(username) + "&password="******"POST";
request.ContentLength = 0;
request.ContentType = "application/x-www-form-urlencoded";
request.Accept = "application/json";
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
System.IO.Stream stream = response.GetResponseStream();
System.IO.StreamReader reader = new System.IO.StreamReader(stream);
string body = reader.ReadToEnd();
string cookie = response.Headers.Get("Set-Cookie");
string[] parts = cookie.Split(new char[] { ';', ',' }); // bug? comma separates session ID
string match = "peregrineapisessionid=";
string sessionid = null;
foreach (string part in parts)
{
if (part.StartsWith(match))
{
sessionid = part.Substring(match.Length);
break;
}
}
/*-Get all users:
* var client = new RestClient("http://test.bsdd.buildingsmart.org/api/4.0/IfdUser/");
* var request = new RestRequest(Method.GET);
* request.AddHeader("cookie", "peregrineapisessionid=thesessionid");
* request.AddHeader("accept", "application/json");
* request.AddHeader("content-type", "application/x-www-form-urlencoded; charset=UTF-8");
* IRestResponse response = client.Execute(request);*/
/*- Get all languages:
* var client = new RestClient("http://test.bsdd.buildingsmart.org/api/4.0/IfdLanguage/");
* var request = new RestRequest(Method.GET);
* request.AddHeader("cookie", "peregrineapisessionid={{sessionId}}");
* request.AddHeader("accept", "application/json");
* request.AddHeader("content-type", "application/x-www-form-urlencoded; charset=UTF-8");
* IRestResponse response = client.Execute(request);*/
request = (HttpWebRequest)HttpWebRequest.Create(baseurl + "api/4.0/IfdLanguage/");
request.Method = "GET";
request.ContentLength = 0;
request.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
request.Headers.Add("cookie", "peregrineapisessionid=" + sessionid);
request.Accept = "application/json";
response = (HttpWebResponse)request.GetResponse();
stream = response.GetResponseStream();
reader = new System.IO.StreamReader(stream);
body = reader.ReadToEnd();
body.ToString();
request = (HttpWebRequest)HttpWebRequest.Create(baseurl + "api/4.0/IfdConcept/search/filter/language/1ASQw0qJqHuO00025QrE$V/type/NEST/Pset_*");
request.Method = "GET";
request.ContentLength = 0;
request.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
request.Headers.Add("cookie", "peregrineapisessionid=" + sessionid);
request.Accept = "application/json";
response = (HttpWebResponse)request.GetResponse();
stream = response.GetResponseStream();
reader = new System.IO.StreamReader(stream);
body = reader.ReadToEnd();
System.IO.Stream ms = new System.IO.MemoryStream();
System.IO.StreamWriter writer = new System.IO.StreamWriter(ms);
writer.Write(body);
writer.Flush();
ms.Position = 0;
//System.IO.MemoryStream mstream = new System.IO.MemoryStream()
ResponseSearch ifdRoot;
try
{
DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings();
//settings.UseSimpleDictionaryFormat = true;
System.Runtime.Serialization.Json.DataContractJsonSerializer ser = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(ResponseSearch));
ifdRoot = (ResponseSearch)ser.ReadObject(ms);
}
catch
{
return;
}
// PERF: consider API on server that would return all information at once (currently 150+ round trips)
for (int iConc = 0; iConc < ifdRoot.IfdConcept.Length; iConc++)
{
IfdConcept concept = ifdRoot.IfdConcept[iConc];
worker.ReportProgress((int)(100.0 * (double)iConc / (double)ifdRoot.IfdConcept.Length));
// api/4.0/IfdPSet/{guid}/ifcVersion/{ifcVersion}/XML
#if true //figure out version info // language code starting at 5th character then lowercase -- e.g. "IFC-2X4" -> "2x4"
string ifcversion = "2x4"; // "IFC4";// "ifc-2X4"; //???? what should this be ???? -- code "ifc-2X4" appears in headers; "IFC-2x4" appears in UI; "IFC4" is official schema name
request = (HttpWebRequest)HttpWebRequest.Create(baseurl + "api/4.0/IfdPSet/" + concept.guid + "/ifcVersion/" + ifcversion + "/XML");
request.Method = "GET";
request.ContentLength = 0;
request.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
request.Headers.Add("cookie", "peregrineapisessionid=" + sessionid);
request.Accept = "application/xml";
#endif
#if false // worked April 1, but no longer works as of 2017-06-13 (http body returns "null" -- as in 4 character string) -- issue with test server -- CoBuilder merge wiped out content??
request = (HttpWebRequest)HttpWebRequest.Create(baseurl + "api/4.0/IfdConcept/" + concept.guid + "/children");
request.Method = "GET";
request.ContentLength = 0;
request.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
request.Headers.Add("cookie", "peregrineapisessionid=" + sessionid);
request.Accept = "application/json";
//request.Accept = "application/xml";
#endif
try
{
response = (HttpWebResponse)request.GetResponse();
stream = response.GetResponseStream();
reader = new System.IO.StreamReader(stream);
body = reader.ReadToEnd();
if (body != null && body != "null") // !!!!
{
ms = new MemoryStream();
writer = new StreamWriter(ms, Encoding.Unicode);
writer.Write(body);
writer.Flush();
ms.Position = 0;
try
{
using (FormatXML format = new FormatXML(ms, typeof(PropertySetDef), null, null))
{
format.Load();
PropertySetDef psd = (PropertySetDef)format.Instance;
Program.ImportPsd(psd, project);
}
}
catch
{
System.Diagnostics.Debug.WriteLine("Error downloading property set: " + concept.guid.ToString());
}
#if false
ResponsePset ifdResponse;
DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings();
//settings.UseSimpleDictionaryFormat = true;
System.Runtime.Serialization.Json.DataContractJsonSerializer ser = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(ResponsePset));
try
{
System.IO.Stream xs = new System.IO.MemoryStream();
System.IO.StreamWriter xwriter = new System.IO.StreamWriter(xs);
xwriter.Write(body);
xwriter.Flush();
xs.Position = 0;
ifdResponse = (ResponsePset)ser.ReadObject(xs);
ifdResponse.ToString();
DocPropertySet docPset = new DocPropertySet();
docPset.Uuid = new Guid();// concept.guid;
foreach (IfdName ifdName in concept.fullNames)
{
// if english
if (ifdName.languageFamily == "IFC")
{
docPset.Name = ifdName.name;
}
else
{
DocLocalization docLoc = new DocLocalization();
docLoc.Locale = ifdName.language.languageCode;
docLoc.Name = ifdName.name;
docPset.Localization.Add(docLoc);
}
}
docPset.Documentation = concept.definitions.description;
project.Sections[4].Schemas[0].PropertySets.Add(docPset);
foreach (IfdConceptInRelationship ifdProp in ifdResponse.IfdConceptInRelationship)
{
//ifdProp.fullNames[0].
DocProperty docProp = new DocProperty();
if (ifdProp.definitions != null)
{
docProp.Documentation = ifdProp.definitions.description;
}
docPset.Properties.Add(docProp);
foreach (IfdName ifdName in ifdProp.fullNames)
{
// if english
if (ifdName.languageFamily == "IFC")
{
//docProp.Name = ifdName.name;
string[] nameparts = ifdName.name.Split('.');
if (nameparts.Length == 2)
{
docPset.Name = nameparts[0];
docProp.Name = nameparts[1];
}
}
else
{
DocLocalization docLoc = new DocLocalization();
docLoc.Locale = ifdName.language.languageCode;
docLoc.Name = ifdName.name;
docProp.Localization.Add(docLoc);
}
}
}
}
#endif
}
}
catch
{
//...
return;
}
}
}
/// <summary>
/// 处理数据返回.
/// </summary>
/// <param name="response"></param>
private void HandleEx(RestResponse response)
{
try
{
if (response.StatusCode == HttpStatusCode.RequestTimeout ||
response.StatusCode == HttpStatusCode.GatewayTimeout)
{
mSdkResponse.errCode = SdkErrCode.TIMEOUT;
mSdkResponse.content = Constants.SdkMsg.ConnectTimeOut;
}
//未知异常(自定义)
else if (response.StatusCode != HttpStatusCode.OK || null != response.ErrorException)
{
bool isUserCanceled = false;
mSdkResponse.errCode = SdkErrCode.NET_UNUSUAL;
mSdkResponse.content = Constants.SdkMsg.NetException;
if (response.ErrorException is WebException)
{
WebException ex = response.ErrorException as WebException;
if (WebExceptionStatus.RequestCanceled == ex.Status)
{
mSdkResponse.errCode = SdkErrCode.USER_CANCEL;
mSdkResponse.content = Constants.SdkMsg.WebRequestCanceled;
isUserCanceled = true;
}
}
if (!isUserCanceled)
{
try
{
ErrorRes resObject = null;
if (response.Request.Resource.Contains(".xml") || response.Request.Resource.Contains(".XML"))
{
// Note: 推荐json格式;
}
else
{
DataContractJsonSerializer ser = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(ErrorRes));
using (MemoryStream ms = new MemoryStream(UnicodeEncoding.UTF8.GetBytes(response.Content)))
{
resObject = ser.ReadObject(ms) as ErrorRes;
}
}
if (null != resObject && resObject is ErrorRes)
{
mSdkResponse.errCode = SdkErrCode.SERVER_ERR;
mSdkResponse.specificCode = resObject.ErrCode;
mSdkResponse.content = resObject.ErrInfo;
}
else
{
throw new Exception();
}
}
catch//如果没有error_code这个节点...
{
//不是xml
//网络异常时统一错误：NET_UNUSUAL
if (response.StatusCode == HttpStatusCode.NotFound)
{
mSdkResponse.errCode = SdkErrCode.NET_UNUSUAL;
mSdkResponse.content = Constants.SdkMsg.NetException;
}
else
{
mSdkResponse.errCode = SdkErrCode.SERVER_ERR;
mSdkResponse.specificCode = response.StatusCode.ToString();
mSdkResponse.content = response.Content;
}
}
}
}
else
{
mSdkResponse.content = response.Content;
}
}
catch (Exception e)
{
mSdkResponse.errCode = SdkErrCode.SERVER_ERR;
mSdkResponse.content = Constants.SdkMsg.ServerError;
}
}
/* --- Private methods --- */
/**
* The method calls the White Source service.
*/
private R Service <R>(BaseRequest <R> request)
{
try
{
HttpWebRequest httpRequest = WebRequest.Create(serviceUrl) as HttpWebRequest;
httpRequest.Method = "POST";
httpRequest.ContentType = "application/x-www-form-urlencoded";
httpRequest.Accept = "application/json";
SetProxy(httpRequest);
// add post data to request
StringBuilder postString = new StringBuilder();
postString.AppendFormat("{0}={1}", APIConstants.PARAM_REQUEST_TYPE, System.Web.HttpUtility.UrlEncode(request.Type.ToString()));
postString.Append("&");
postString.AppendFormat("{0}={1}", APIConstants.PARAM_AGENT, System.Web.HttpUtility.UrlEncode(request.Agent));
postString.Append("&");
postString.AppendFormat("{0}={1}", APIConstants.PARAM_AGENT_VERSION, System.Web.HttpUtility.UrlEncode(request.AgentVersion));
postString.Append("&");
postString.AppendFormat("{0}={1}", APIConstants.PARAM_TOKEN, System.Web.HttpUtility.UrlEncode(request.OrgToken));
postString.Append("&");
postString.AppendFormat("{0}={1}", APIConstants.PARAM_PRODUCT, System.Web.HttpUtility.UrlEncode(request.Product));
postString.Append("&");
postString.AppendFormat("{0}={1}", APIConstants.PARAM_PRODUCT_VERSION, System.Web.HttpUtility.UrlEncode(request.ProductVersion));
postString.Append("&");
postString.AppendFormat("{0}={1}", APIConstants.PARAM_TIME_STAMP, System.Web.HttpUtility.UrlEncode(request.TimeStamp.ToString()));
// Serialize projects to JSON
switch (request.Type)
{
case RequestType.UPDATE:
UpdateInventoryRequest updateRequest = (UpdateInventoryRequest)Convert.ChangeType(request, typeof(UpdateInventoryRequest));
AppendProjects(updateRequest.Projects, postString);
break;
case RequestType.CHECK_POLICIES:
CheckPoliciesRequest checkPoliciesRequest = (CheckPoliciesRequest)Convert.ChangeType(request, typeof(CheckPoliciesRequest));
AppendProjects(checkPoliciesRequest.Projects, postString);
break;
default:
throw new InvalidOperationException("Unsupported request type.");
}
ASCIIEncoding ascii = new ASCIIEncoding();
byte[] postBytes = ascii.GetBytes(postString.ToString());
httpRequest.ContentLength = postBytes.Length;
Stream postStream = httpRequest.GetRequestStream();
postStream.Write(postBytes, 0, postBytes.Length);
postStream.Close();
using (HttpWebResponse response = httpRequest.GetResponse() as HttpWebResponse)
{
if (response.StatusCode != HttpStatusCode.OK)
{
throw new Exception(String.Format("Server error (HTTP {0}: {1}).", response.StatusCode, response.StatusDescription));
}
using (Stream stream = response.GetResponseStream())
{
StreamReader reader = new StreamReader(stream, Encoding.UTF8);
String responseString = reader.ReadToEnd();
Debug("response: " + responseString);
// convert response JSON to ResultEnvelope
ResultEnvelope resultEnvelope;
MemoryStream responseMS = new MemoryStream(Encoding.Unicode.GetBytes(responseString));
System.Runtime.Serialization.Json.DataContractJsonSerializer responseSerializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(ResultEnvelope));
resultEnvelope = responseSerializer.ReadObject(responseMS) as ResultEnvelope;
responseMS.Close();
String data = resultEnvelope.Data;
Debug("Result data is: " + data);
// convert data JSON to result according to type
R result;
MemoryStream dataMS = new MemoryStream(Encoding.Unicode.GetBytes(data));
switch (request.Type)
{
case RequestType.UPDATE:
System.Runtime.Serialization.Json.DataContractJsonSerializer updateSerializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(UpdateInventoryResult));
result = (R)Convert.ChangeType(updateSerializer.ReadObject(dataMS) as UpdateInventoryResult, typeof(R));
dataMS.Close();
break;
case RequestType.CHECK_POLICIES:
// enable Dictionary support
DataContractJsonSerializerSettings settings = new DataContractJsonSerializerSettings();
settings.UseSimpleDictionaryFormat = true;
System.Runtime.Serialization.Json.DataContractJsonSerializer checkPoliciesSerializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(CheckPoliciesResult), settings);
result = (R)Convert.ChangeType(checkPoliciesSerializer.ReadObject(dataMS) as CheckPoliciesResult, typeof(R));
dataMS.Close();
break;
default:
dataMS.Close();
throw new InvalidOperationException("Unsupported request type.");
}
dataMS.Close();
return(result);
}
}
}
catch (Exception e)
{
Debug(e.Message);
return(default(R));
}
}
