public Boolean OnLogInButtonClicked(string email, string password)
{
var hud = DependencyService.Get<IHud> ();
hud.Show ("Verifying Credentials");
var client = new RestClient("http://dev.envocsupport.com/GameStore2/");
var request = new RestRequest("api/ApiKey?email=" + email + "&password="******"application/json"; };
IRestResponse queryResult = client.Execute(request);
if (queryResult.StatusCode == HttpStatusCode.OK)
{
RestSharp.Deserializers.JsonDeserializer deserial = new JsonDeserializer();
var x = deserial.Deserialize<UserApiKey>(queryResult);
Application.Current.Properties["ApiKey"] = x.ApiKey;
Application.Current.Properties ["UserId"] = x.UserId;
//Console.WriteLine ("first" + queryResult.Content);
// Console.WriteLine ("key:"+x.ApiKey);
// next request for User
request = new RestRequest ("api/Users/"+x.UserId,Method.GET);
var ApiKey = Application.Current.Properties ["ApiKey"];
var UserId = Application.Current.Properties ["UserId"];
request.AddHeader ("xcmps383authenticationkey",ApiKey.ToString ());
request.AddHeader ("xcmps383authenticationid",UserId.ToString ());
queryResult = client.Execute (request);
User user = new User ();
statusCodeCheck (queryResult);
if (queryResult.StatusCode == HttpStatusCode.OK) {
user = deserial.Deserialize<User>(queryResult);
}
Application.Current.Properties ["FirstName"] = user.FirstName;
// Console.WriteLine (Application.Current.Properties ["UserId"]);
//Console.WriteLine ("here" + queryResult.Content);
loginStatus = true;
return loginStatus ;
}
else
{
loginStatus = false;
return loginStatus;
}
}
public void JSONDeserializationTest() {
var path = Path.Combine(Environment.CurrentDirectory, "Schedule.json");
var ds = new JsonDeserializer();
var response = new RestResponse() { ContentType = "application/json", ResponseStatus = ResponseStatus.Completed, StatusCode = System.Net.HttpStatusCode.OK };
// Read the file as one string.
StreamReader myFile = new StreamReader(path);
string json = myFile.ReadToEnd();
myFile.Close();
response.Content = json;
var mySchedule = ds.Deserialize<Schedule>(response);
Assert.IsNotNull(mySchedule);
Assert.IsNotNull(mySchedule.escalation_policies);
Assert.AreEqual("FS4LEQD", mySchedule.id);
Assert.AreEqual("24x7 Schedule", mySchedule.name);
Assert.AreEqual("UTC", mySchedule.time_zone);
Assert.AreEqual(new DateTime(635726880000000000), mySchedule.today);
Assert.AreEqual(1, mySchedule.escalation_policies.Count);
Assert.AreEqual("PAD5HK6", mySchedule.escalation_policies[0].id);
Assert.AreEqual("Escalation Policy - 24x7", mySchedule.escalation_policies[0].name);
}
private void GetToken_Click(object sender, RoutedEventArgs e)
{
var client = new RestClient("https://api.home.nest.com/oauth2/access_token");
var request = new RestRequest(Method.POST);
request.AddParameter("client_id", TextNestClientId.Text);
request.AddParameter("code", TextNestPin.Text);
request.AddParameter("client_secret", PwNestSecret.Password);
request.AddParameter("grant_type", "authorization_code");
var response = client.Execute(request);
JsonDeserializer deserializer = new JsonDeserializer();
var json = deserializer.Deserialize<Dictionary<string, string>>(response);
if (json.ContainsKey("access_token"))
{
TextNestAccessToken.Text = json["access_token"];
return;
}
if (json.ContainsKey("message"))
{
TextNestAccessToken.Text = json["message"];
return;
}
if (json.ContainsKey("error_description"))
{
TextNestAccessToken.Text = json["error_description"];
return;
}
}
public void JSONDeserializationTest() {
var path = Path.Combine(Environment.CurrentDirectory, "Incident.json");
var ds = new JsonDeserializer();
var response = new RestResponse() { ContentType = "application/json", ResponseStatus = ResponseStatus.Completed, StatusCode = System.Net.HttpStatusCode.OK };
// Read the file as one string.
StreamReader myFile = new StreamReader(path);
string json = myFile.ReadToEnd();
myFile.Close();
response.Content = json;
var myAlert = ds.Deserialize<Incident>(response);
Assert.IsNotNull(myAlert);
Assert.IsNotNull(myAlert.service);
Assert.IsNotNull(myAlert.last_status_change_by);
Assert.AreEqual("1", myAlert.incident_number);
Assert.AreEqual(new DateTime(634830005610000000), myAlert.created_on);
Assert.AreEqual("resolved", myAlert.status);
Assert.AreEqual("https://acme.pagerduty.com/incidents/P2A6J96", myAlert.html_url);
Assert.AreEqual(null, myAlert.incident_key);
Assert.AreEqual(null, myAlert.assigned_to_user);
Assert.AreEqual("https://acme.pagerduty.com/incidents/P2A6J96/log_entries/P2NQP6P", myAlert.trigger_details_html_url);
Assert.AreEqual(new DateTime(634830006590000000), myAlert.last_status_change_on);
}
private static bool HitboxOnlineState(string sStream)
{
var req = new RestRequest("/media/live/" + sStream, Method.GET);
IRestClientProvider _restClientProvider = new RestClientProvider(new RestClient("http://api.hitbox.tv"));
var response = _restClientProvider.Execute(req);
try
{
var des = new JsonDeserializer();
var data = des.Deserialize<HitboxRootObject>(response);
foreach (var item in data.livestream)
{
if(item.media_user_name.ToLower() == sStream.ToLower())
{
if(item.media_is_live == "1")
{
return true;
}
}
}
return false;
}
catch (Exception)
{
return false;
}
}
public bool FetchDiff (Push push)
{
string url = null;
try {
string response = CachingFetcher.FetchDiff (push.CHAuthID, push.Repository.Owner.Name, push.Repository.Name, ID, out url);
if (response == null)
return false;
var jdes = new JsonDeserializer ();
var wrapper = jdes.Deserialize<CommitWithDiffJsonWrapper> (response);
if (wrapper != null) {
var diff = wrapper.Commit;
if (!diff.FetchBlobs (push)) {
Log (LogSeverity.Error, "Failed to fetch blobs for commit '{0}' from URL '{1}'", ID, url);
return false;
}
Diff = diff;
} else {
Log (LogSeverity.Error, "Failed to fetch diff for commit '{0}' from URL '{1}'", ID, url);
return false;
}
} catch (Exception ex) {
Log (ex, "Exception while fetching diff for commit '{4}' from URL '{5}'\n{0}", ID, url);
return false;
}
CommitWithDiff ret = Diff;
if (ret == null)
Log (LogSeverity.Info, "FetchDiff did not fail, but no diff retrieved?");
return ret != null;
}
public void ReplayAllEvents()
{
using (IDocumentSession session = _eventStorage.OpenSession())
{
int startPos = 0;
while (true)
{
RavenQueryStatistics stats;
var events = session.Query<EventDescriptor>()
.Statistics(out stats)
.OrderBy(ev => ev.AggregateId)
.ThenBy(ev => ev.Version)
.Select(ev => ev)
.Skip(startPos)
.ToArray();
JsonDeserializer deserializer = new JsonDeserializer();
foreach (EventDescriptor ev in events)
{
Publish(deserializer.Deserialize(ev.EventType, ev.EventData));
}
if (stats.TotalResults <= startPos)
{
break;
}
startPos += 128;
}
}
}
public void TestDeserializeChannelResult()
{
var doc = File.ReadAllText(Path.Combine("Resources", "channels.json"));
var json = new JsonDeserializer();
var output = json.Deserialize<ChannelResult>(new RestResponse {Content = doc});
Assert.NotNull(output);
Assert.NotNull(output.Channels);
Assert.AreEqual(1, output.Channels.Count);
Assert.AreEqual("CHaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", output.Channels[0].Sid);
Assert.AreEqual("ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", output.Channels[0].AccountSid);
Assert.AreEqual("ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", output.Channels[0].ServiceSid);
Assert.AreEqual("my channel", output.Channels[0].FriendlyName);
Assert.IsEmpty(output.Channels[0].Attributes);
Assert.AreEqual("system", output.Channels[0].CreatedBy);
Assert.AreEqual("public", output.Channels[0].Type);
Assert.AreEqual(
"http://localhost/v1/Services/ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Channels/CHaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
output.Channels[0].Url);
Dictionary<string, string> dictionary = output.Channels[0].Links;
Assert.NotNull(dictionary);
Assert.True(dictionary.ContainsKey("members"));
Assert.True(dictionary.ContainsKey("messages"));
Assert.AreEqual(
"http://localhost/v1/Services/ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Channels/CHaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Members",
dictionary["members"]);
Assert.AreEqual(
"http://localhost/v1/Services/ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Channels/CHaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Messages",
dictionary["messages"]);
}
private void OnContentReceived(string content) {
JsonDeserializer deserializer = new JsonDeserializer();
var response = new RestResponse();
response.Content = content;
MessageContent messageContent = null;
try {
messageContent = deserializer.Deserialize<MessageContent>(response);
} catch {
MessageContent = null;
}
if (messageContent != null) {
MessageContent = messageContent;
if (Event == "message" || Event == "comment") {
ExtractedBody = messageContent.Text;
}
} else if(Event == "message") {
ExtractedBody = content;
}
Displayable = ExtractedBody != null;
TimeStamp = UnixTimeToLocal(Sent);
}
public void JSONDeserializationTest() {
var path = Path.Combine(Environment.CurrentDirectory, "User.json");
var ds = new JsonDeserializer();
var response = new RestResponse() { ContentType = "application/json", ResponseStatus = ResponseStatus.Completed, StatusCode = System.Net.HttpStatusCode.OK };
// Read the file as one string.
StreamReader myFile = new StreamReader(path);
string json = myFile.ReadToEnd();
myFile.Close();
response.Content = json;
var myUser = ds.Deserialize<User>(response);
Assert.IsNotNull(myUser);
Assert.AreEqual("PT23IWX", myUser.id);
Assert.AreEqual("Tim Wright", myUser.name);
Assert.AreEqual("*****@*****.**", myUser.email);
Assert.AreEqual("Eastern Time (US & Canada)", myUser.time_zone);
Assert.AreEqual("purple", myUser.color);
Assert.AreEqual("owner", myUser.role);
Assert.AreEqual("https://secure.gravatar.com/avatar/923a2b907dc04244e9bb5576a42e70a7.png?d=mm&r=PG", myUser.avatar_url);
Assert.AreEqual("/users/PT23IWX", myUser.user_url);
Assert.AreEqual(false, myUser.invitation_sent);
Assert.AreEqual(false, myUser.marketing_opt_out);
}
public void testDeserializeListResponse()
{
var doc = File.ReadAllText(Path.Combine("Resources", "task_queues_statistics.json"));
var json = new JsonDeserializer();
var output = json.Deserialize<TaskQueueStatisticsResult>(new RestResponse { Content = doc });
Assert.NotNull(output);
}
public void testDeserializeInstanceResponse()
{
var doc = Twilio.Api.Tests.Utilities.UnPack(BASE_NAME + "worker_statistics.json");
var json = new JsonDeserializer();
var output = json.Deserialize<WorkerStatistics>(new RestResponse { Content = doc });
Assert.NotNull(output);
}
public static SinusModel GetParams()
{
var request = new RestRequest(Method.GET);
request.Resource = "model/" + ModelId;
IRestResponse response = client.Execute (request);
var json = new JsonDeserializer();
return json.Deserialize<SinusModel>(response);
}
public void testDeserializeResponse()
{
var doc = File.ReadAllText(Path.Combine("Resources", "workspace_statistics.json"));
var json = new JsonDeserializer();
var output = json.Deserialize<WorkspaceStatistics>(new RestResponse { Content = doc });
Assert.NotNull(output);
}
public void Deserialize_SerializationRepresentation_DeserializedObject()
{
var subject = new JsonDeserializer();
var deserialized = subject.Deserialize<Serializable>(Serializable.JsonString("s", 3m));
Assert.That(deserialized.D, Is.EqualTo(3m));
Assert.That(deserialized.S, Is.EqualTo("s"));
}
public void testDeserializeListResponse()
{
//var doc = File.ReadAllText(Path.Combine("Resources", "workers_statistics.json"));
var doc = Twilio.Api.Tests.Utilities.UnPack(BASE_NAME + "workers_statistics.json");
var json = new JsonDeserializer();
var output = json.Deserialize<WorkersStatistics>(new RestResponse { Content = doc });
Assert.NotNull(output);
}
public void testDeserializeResponse()
{
var doc = File.ReadAllText(Path.Combine("Resources", "phone_number.json"));
var json = new JsonDeserializer();
var output = json.Deserialize<AssociatedPhoneNumber>(new RestResponse { Content = doc });
Assert.NotNull(output);
Assert.NotNull(output.DateCreated);
Assert.AreEqual("867-5309 (Jenny)", output.FriendlyName);
}
public PagingResponse<Company> Current()
{
var url = string.Format("Company/Get?apikey={0}", _apiKey);
var request = new RestRequest(url, Method.GET);
request.RequestFormat = DataFormat.Json;
var response = _client.Execute(request);
JsonDeserializer deserializer = new JsonDeserializer();
return deserializer.Deserialize<PagingResponse<Company>>(response);
}
public void testDeserializeListResponse()
{
var doc = Twilio.Api.Tests.Utilities.UnPack(BASE_NAME + "task_queues_statistics.json");
var json = new JsonDeserializer();
var output = json.Deserialize<TaskQueueStatisticsResult>(new RestResponse { Content = doc });
Assert.NotNull(output);
Assert.NotNull(output.Meta);
}
public void testDeserializeResponse()
{
var doc = File.ReadAllText(Path.Combine("Resources", "credential_list.json"));
var json = new JsonDeserializer();
var output = json.Deserialize<CredentialList>(new RestResponse { Content = doc });
Assert.NotNull(output);
Assert.NotNull(output.DateCreated);
Assert.AreEqual("support", output.FriendlyName);
}
public void testDeserializeResponse()
{
var doc = File.ReadAllText(Path.Combine("Resources", "alert.json"));
var json = new JsonDeserializer();
var output = json.Deserialize<Alert>(new RestResponse { Content = doc });
Assert.NotNull(output);
Assert.NotNull(output.DateCreated);
Assert.AreEqual("11200", output.ErrorCode);
Assert.AreEqual("error", output.LogLevel);
}
public void testDeserializeResponse()
{
var doc = File.ReadAllText(Path.Combine("Resources", "trunk.json"));
var json = new JsonDeserializer();
var output = json.Deserialize<Trunk>(new RestResponse { Content = doc });
Assert.NotNull(output);
Assert.NotNull(output.DateCreated);
Assert.AreEqual("test1.pstn.twilio.com", output.DomainName);
Assert.AreEqual("hello 1", output.FriendlyName);
}
public void testDeserializeResponse()
{
var doc = File.ReadAllText(Path.Combine("Resources", "origination_url.json"));
var json = new JsonDeserializer();
var output = json.Deserialize<OriginationUrl>(new RestResponse { Content = doc });
Assert.NotNull(output);
Assert.NotNull(output.DateCreated);
Assert.AreEqual(10, output.Weight);
Assert.AreEqual(true, output.Enabled);
}
public void testDeserializeListResponse()
{
var doc = File.ReadAllText(Path.Combine("../../Resources", "phone_number_countries.json"));
var json = new JsonDeserializer();
var output = json.Deserialize<PhoneNumberCountryResult>(new RestResponse { Content = doc });
Assert.NotNull(output);
Assert.AreEqual(3, output.Countries.Count);
Assert.AreEqual("AC", output.Countries [0].IsoCountry);
Assert.AreEqual("Ascension", output.Countries [0].Country);
}
public void testDeserializeResponse()
{
var doc = File.ReadAllText(Path.Combine("Resources", "event.json"));
var json = new JsonDeserializer();
var output = json.Deserialize<Event>(new RestResponse { Content = doc });
Assert.NotNull(output);
Assert.NotNull(output.EventData);
Assert.NotNull(output.Links);
Assert.True(output.Links.ContainsKey("actor"));
Assert.True(output.Links.ContainsKey("resource"));
}
private string GetToken(User user)
{
//_restRequest.AddParameter("Accept", "application/json");
string encodedBody = string.Format("grant_type={0}&username={1}&password={2}", "password", "SuperUser", "P@ssword123");
_restRequest.AddParameter("application/x-www-form-urlencoded", encodedBody, ParameterType.RequestBody);
_restRequest.AddParameter("Content-Type", "application/x-www-form-urlencoded", ParameterType.HttpHeader);
var jsonDeserializer = new JsonDeserializer();
var response = Client.Execute<User>(_restRequest);
var userResponse = jsonDeserializer.Deserialize<User>(response);
return userResponse.access_token;
}
public void testDeserializeResponse()
{
var doc = File.ReadAllText(Path.Combine("Resources", "key.json"));
var json = new JsonDeserializer();
//json.DateFormat = "ddd, dd MMM yyyy HH:mm:ss '+0000'";
var output = json.Deserialize<Key>(new RestResponse { Content = doc });
Assert.NotNull(output);
Assert.NotNull(output.DateCreated);
Assert.AreEqual("My Signing Key", output.FriendlyName);
Assert.AreEqual("PsPPv0QtxuPFID7tl4wAZdGe0I4OrWNX", output.Secret);
}
public StreamioValidationException(IRestResponse response)
{
JsonDeserializer deserializer = new JsonDeserializer();
Console.WriteLine(response.Content);
Errors = deserializer.Deserialize<Dictionary<string, List<string>>>(response);
message = "Invalid model: ";
foreach(KeyValuePair<string, List<string>> field in Errors)
{
message += field.Key + " " + string.Join("and", field.Value.ToArray());
}
}
public void JsonLocationInfoResponse()
{
// Arrange
string doc = File.ReadAllText(PathFor("LocationInfoResponse.json"));
// Act
JsonDeserializer jsonDeserializer = new JsonDeserializer() { RootElement = "LocationInfoResponse" };
LocationInfoResponse output = jsonDeserializer.Deserialize<LocationInfoResponse>(new RestResponse() { Content = Regex.Replace(doc, "") });
// Assert
Assert.NotNull(output);
}
public PagingResponse<Account> GetByCategory(int categoryId)
{
var url = string.Format("Account/GetAccountsByCategoryId/{0}?apikey={1}&companyid={2}", categoryId, _apiKey, _companyId);
var request = new RestRequest(url, Method.GET);
request.RequestFormat = DataFormat.Json;
var response = _client.Execute(request);
JsonDeserializer deserializer = new JsonDeserializer();
return deserializer.Deserialize<PagingResponse<Account>>(response);
}
public void Can_Deserialize_Elements_to_Nullable_Values()
{
string doc = CreateJsonWithoutEmptyValues();
JsonDeserializer json = new JsonDeserializer();
NullableValues output = json.Deserialize <NullableValues>(new RestResponse {
Content = doc
});
Assert.NotNull(output.Id);
Assert.NotNull(output.StartDate);
Assert.NotNull(output.UniqueId);
Assert.Equal(123, output.Id);
Assert.NotNull(output.StartDate);
Assert.Equal(
new DateTime(2010, 2, 21, 9, 35, 00, DateTimeKind.Utc),
output.StartDate.Value);
Assert.Equal(new Guid(GuidString), output.UniqueId);
}
/// <summary>
/// Searches for Rides by Athlete, Club, date, or Id range. Returns a list of Rides. The response includes the Id and Name of each matching Ride. Rides are ordered by their start date.
/// </summary>
/// <param name="clubId">Optional. Id of the Club for which to search for member's Rides.</param>
/// <param name="athleteId">Optional. Id of the Athlete for which to search for Rides.</param>
/// <param name="athleteName">Optional. Username of the Athlete for which to search for Rides.</param>
/// <param name="startDate">Optional. Day on which to start search for Rides. The date is the local time of when the ride started.</param>
/// <param name="endDate">Optional. Day on which to end search for Rides. The date is the local time of when the ride started.</param>
/// <param name="startId">Optional. Only return Rides with an Id greater than or equal to the startId.</param>
/// <param name="offset">Optional. Any search will return at most 50 rows. To retrieve results after the 50th row use the offset parameter. For example, to retrieve rows 51-100 use an offset of 50.</param>
/// <returns>List of matching rides</returns>
public List <Ride> Index(int?clubId = null, int?athleteId = null, string athleteName = null, DateTime?startDate = null, DateTime?endDate = null, int?startId = null, int?offset = null)
{
var parameters = new NameValueCollection();
if (clubId.HasValue && clubId.Value > 0)
{
parameters.Add("clubId", clubId.Value.ToString());
}
if (athleteId.HasValue && athleteId.Value > 0)
{
parameters.Add("athleteId", athleteId.Value.ToString());
}
if (!string.IsNullOrWhiteSpace(athleteName))
{
parameters.Add("athleteName", athleteName);
}
if (startDate.HasValue)
{
parameters.Add("startDate", startDate.Value.ToString(DateFormat));
}
if (endDate.HasValue)
{
parameters.Add("endDate", endDate.Value.ToString(DateFormat));
}
if (startId.HasValue && startId.Value > 0)
{
parameters.Add("startId", startId.Value.ToString());
}
if (offset.HasValue && offset.Value > 0)
{
parameters.Add("offset", offset.Value.ToString());
}
var response = Client.Download("rides", parameters);
return(JsonDeserializer.Deserialize <RidesWrapper>(response).Rides);
}
public async Task <string> PostGroup(int playersMax, GameModes gameType, DifficultyLevel difficulty, int nRounds)
{
RestRequest request = new RestRequest($"/groups", Method.POST);
request.AddParameter("SessionToken", _sessionToken, ParameterType.HttpHeader);
request.AddJsonBody(new
{
PlayersMax = playersMax,
GameType = (int)gameType,
Difficulty = (int)difficulty,
NbRound = nRounds
});
var response = await Execute(request);
var deseralizer = new JsonDeserializer();
return(deseralizer.Deserialize <dynamic>(response)["GroupID"]);
}
public static List <QueueItemAttachment> GetAttachments(RestClient client, Guid?queueItemId)
{
var request = new RestRequest($"api/v1/QueueItems/{queueItemId}/QueueItemAttachments", Method.GET);
request.RequestFormat = DataFormat.Json;
var response = client.Execute(request);
if (!response.IsSuccessful)
{
throw new HttpRequestException($"Status Code: {response.StatusCode} - Error Message: {response.ErrorMessage}");
}
var deserializer = new JsonDeserializer();
var output = deserializer.Deserialize <Dictionary <string, string> >(response);
var items = output["items"];
return(JsonConvert.DeserializeObject <List <QueueItemAttachment> >(items));
}
private Lease ParseGetByPhoneJson(IRestResponse response)
{
if (response.Content != String.Empty)
{
_jsonDeserializer = new JsonDeserializer();
var customerDictionaries = _jsonDeserializer.Deserialize <List <Dictionary <string, string> > >(response);
foreach (var dictionary in customerDictionaries)
{
ApplicantId = Convert.ToInt32(dictionary["id"]);
Name = dictionary["firstName"] + " " + dictionary["lastName"];
Status = Convert.ToInt32(dictionary["status"]);
FetchLeaseInfo(ApplicantId);
ContractID = _contractId;
LeaseProvider = _leaseProvider;
FetchDaysLate(ContractID);
}
}
return(this);
}
/// <summary>
/// Returns a list of matching Efforts on a Segment. The response includes the Id of the Effort, the elapsed time of the Effort, and the Id, Name, and Username of the Athlete who ride the Effort. Efforts are ordered by start date, oldest to newest.
/// </summary>
/// <param name="segmentId">Required. The Id of the Segment.</param>
/// <param name="clubId">Optional. Id of the Club for which to search for member's Efforts.</param>
/// <param name="athleteId">Optional. Id of the Athlete for which to search for Efforts.</param>
/// <param name="athleteName">Optional. Username of the Athlete for which to search for Rides.</param>
/// <param name="startDate">Optional. Day on which to start search for Efforts. The date is the local time of when the effort started.</param>
/// <param name="endDate">Optional. Day on which to end search for Efforts. The date is the local time of when the effort started.</param>
/// <param name="startId">Optional. Only return Effforts with an Id greater than or equal to the startId.</param>
/// <param name="isBest">Optional. Shows an best efforts per athlete sorted by elapsed time ascending (segment leaderboard).</param>
/// <returns>List of matching Efforts on a Segment.</returns>
public SegmentEfforts Efforts(int segmentId, int?clubId = null, int?athleteId = null, string athleteName = null, DateTime?startDate = null, DateTime?endDate = null, int?startId = null, bool?isBest = null)
{
var parameters = new NameValueCollection();
if (clubId.HasValue && clubId.Value > 0)
{
parameters.Add("clubId", clubId.Value.ToString());
}
if (athleteId.HasValue && athleteId.Value > 0)
{
parameters.Add("athleteId", athleteId.Value.ToString());
}
if (!string.IsNullOrWhiteSpace(athleteName))
{
parameters.Add("athleteName", athleteName);
}
if (startDate.HasValue)
{
parameters.Add("startDate", startDate.Value.ToString(DateFormat));
}
if (endDate.HasValue)
{
parameters.Add("endDate", endDate.Value.ToString(DateFormat));
}
if (startId.HasValue && startId.Value > 0)
{
parameters.Add("startId", startId.Value.ToString());
}
if (isBest.HasValue)
{
parameters.Add("best", isBest.Value.ToString().ToLower());
}
var response = Client.Download(string.Format("segments/{0}/efforts", segmentId), parameters);
return(JsonDeserializer.Deserialize <SegmentEfforts>(response));
}
public Pins GetUserRecentPin(AccessDetails Token)
{
try
{
var request = new RestRequest("/v1/me/pins/", Method.GET);
request.AddParameter("access_token", Token.AccessToken);
//request.AddParameter("fields", "first_name,image,id,last_name,username");
var response = WebServiceHelper.WebRequest(request, ApiURL);
JsonDeserializer deserial = new JsonDeserializer();
PinterestPin result = deserial.Deserialize <PinterestPin>(response);
//result.data.image.original.url = response.['data'].['image'].['60x60'].ToString();
return(result.data[0]);
}
catch (Exception)
{
throw;
}
}
private IEnumerable <Issue <TIssueFields> > EnumerateIssuesInternal(String projectKey, String issueType, String jqlQuery = null)
{
var queryCount = 50;
var resultCount = 0;
while (true)
{
var jql = "";
if (projectKey != "")
{
jql = String.Format("project={0}+AND+", Uri.EscapeUriString(projectKey));
}
if (!String.IsNullOrEmpty(issueType))
{
jql += String.Format("issueType={0}+AND+", Uri.EscapeUriString(issueType));
}
if (!String.IsNullOrEmpty(jqlQuery))
{
jql += String.Format("{0}", Uri.EscapeUriString(jqlQuery));
}
var path = String.Format("search?jql={0}&startAt={1}&maxResults={2}", jql, resultCount, queryCount);
var request = CreateRequest(Method.GET, path);
var response = ExecuteRequest(request);
AssertStatus(response, HttpStatusCode.OK);
var data = deserializer.Deserialize <IssueContainer <TIssueFields> >(response);
var issues = data.issues ?? Enumerable.Empty <Issue <TIssueFields> >();
foreach (var item in issues)
{
yield return(item);
}
resultCount += issues.Count();
if (resultCount < data.total)
{
continue;
}
else /* all issues received */ break {
;
}
}
public void PostwithTypeBody()
{
var client = new RestClient("http://localhost:3000/");
var request = new RestRequest("posts", Method.POST);
request.RequestFormat = DataFormat.Json;
request.AddBody(new posts()
{
id = 30, author = "Rao", title = "film"
});
var response = client.Execute(request);
var deserial = new JsonDeserializer();
var outPut = deserial.Deserialize <Dictionary <string, string> >(response);
var result = outPut["author"];
Assert.That(result, Is.EqualTo("Rao"));
}
public Pins GetPinInfo(string pinId, AccessDetails Token)
{
try
{
var request = new RestRequest("/v1/pins/" + pinId + "", Method.GET);
request.AddParameter("access_token", Token.AccessToken);
request.AddParameter("fields", "image,id,note");
var response = WebServiceHelper.WebRequest(request, ApiURL);
JsonDeserializer deserial = new JsonDeserializer();
PinInfoVm result = deserial.Deserialize <PinInfoVm>(response);
//result.data.image.original.url = response.['data'].['image'].['60x60'].ToString();
return(result.data);
}
catch (Exception)
{
throw;
}
}
public void VerifyTotalNumOfRecords()
{
// RestClient restClient = new RestClient("https://reqres.in");
// RestRequest restRequest = new RestRequest("api/users?page=2",Method.GET);
var restResponse = _restClient.Execute(_restRequest);
//inbuilt deserializer
var jsonDesrializer = new JsonDeserializer();
var output = jsonDesrializer.Deserialize <Dictionary <string, string> >(restResponse);
var finaloutput = output["total"];
Console.WriteLine("*** The deserialized is:: *** " + finaloutput);
//JObject - NewTonSoft
JObject jobject = JObject.Parse(restResponse.Content);
var jObjFinalOutput = jobject["total"];
Console.WriteLine("The deserialized value is::" + jObjFinalOutput);
Assert.That(jObjFinalOutput.ToString(), Is.EqualTo("12"), "Total record does not match");
}
/// <summary>
/// Method to get OAuth token for authenticate user
/// </summary>
/// <param name="Code"></param>
/// <returns></returns>
public OAuthTokens GetPinToken(string Code)
{
var request = new RestRequest("v1/oauth/token", Method.POST);
//request.AddHeader("Content-Type", "application/json");
//request.AddHeader("Authorization", "OAuth " + token);
request.AddParameter("grant_type", "authorization_code");
request.AddParameter("client_id", consumerKey);
//request.AddParameter("scope", "read_public");
//request.AddParameter("redirect_uri", RedirectURL);
request.AddParameter("client_secret", consumerSecret);
request.AddParameter("code", Code);
// request.AddParameter("host_id", "QwJrNRmITnC3ZenQzXtedg");
var response = WebServiceHelper.WebRequest(request, ApiURL);
JsonDeserializer deserial = new JsonDeserializer();
var result = deserial.Deserialize <OAuthTokens>(response);
return(result);
}
public void Can_Deserialize_Custom_Formatted_Date()
{
CultureInfo culture = CultureInfo.InvariantCulture;
const string format = "dd yyyy MMM, hh:mm ss tt";
DateTime date = new DateTime(2010, 2, 8, 11, 11, 11);
var formatted = new { StartDate = date.ToString(format, culture) };
string data = SimpleJson.SerializeObject(formatted);
RestResponse response = new RestResponse {
Content = data
};
JsonDeserializer json = new JsonDeserializer
{
DateFormat = format,
Culture = culture
};
PersonForJson output = json.Deserialize <PersonForJson>(response);
Assert.Equal(date, output.StartDate);
}
public void DeserialzeIntegerArray()
{
using (var reader = GetReader("[1,2,3]"))
{
var raw = JsonDeserializer.Deserialize(reader);
Assert.NotNull(raw);
var list = raw as JsonArray;
Assert.NotNull(list);
Assert.Equal(3, list.Length);
for (int i = 0; i < 3; ++i)
{
Assert.Equal(1, list[i].Line);
Assert.Equal(2 + 2 * i, list[i].Column);
Assert.Equal(i + 1, FromJsonNumberToInt(list[i]));
}
}
}
public void GetResponseDeserializedWithRestSharp()
{
IRestClient client = new RestClient("http://localhost:3000");
RestRequest request = new RestRequest("post/{postid}", Method.GET);
request.AddUrlSegment("postid", 1);
var content = client.Execute(request).Content;
IRestResponse response = client.Execute(request);
var deserialize = new JsonDeserializer();
var output = deserialize.Deserialize <Dictionary <string, string> >(response);
var result = output["key"];
Assert.That(result, Is.EqualTo("NEW"), "Field is different than expected");
}
public void PostWithAnonymousMethod()
{
IRestClient client = new RestClient("http://localhost:3000");
RestRequest request = new RestRequest("post", Method.POST);
request.RequestFormat = DataFormat.Json;
request.AddJsonBody(new { name = "John" });
request.AddUrlSegment("postid", 1);
IRestResponse response = client.Execute(request);
var deserialize = new JsonDeserializer();
var output = deserialize.Deserialize <Dictionary <string, string> >(response);
var result = output["name"];
Assert.That(result, Is.EqualTo("John"), "Name is different than expected");
}
public void TestMethodGet()
{
var client = new RestClient("http://localhost:3000/");
var request = new RestRequest("tests/{id}", Method.GET);
request.AddUrlSegment("id", 1);
var response = client.Execute(request);
var deserialize = new JsonDeserializer();
var output = deserialize.Deserialize <Dictionary <string, string> >(response);
var result = output["marca"];
response.StatusCode.Should().Be(200);
Assert.IsTrue(result.Contains("Audi"));
}
/// <summary>
/// Updates details about a specific athlete.
/// </summary>
/// <param name="token">Required. The login token.</param>
/// <param name="id">Required. The the id of the athlete.</param>
/// <param name="firstname">Required. The updated first name of the athlete.</param>
/// <param name="lastname">Required. The updated last name of the athlete.</param>
/// <returns></returns>
public Athlete Update(string token, int id, string firstname, string lastname)
{
if (token == null)
{
throw new ArgumentNullException("token");
}
if (token.Length == 0)
{
throw new ArgumentException("token", "token cannot be empty");
}
if (id <= 0)
{
throw new ArgumentException("id", "athlete id must be greater than 0");
}
if (firstname == null)
{
throw new ArgumentNullException("firstname");
}
if (firstname.Length == 0)
{
throw new ArgumentException("firstname", "firstname cannot be empty");
}
if (lastname == null)
{
throw new ArgumentNullException("lastname");
}
if (lastname.Length == 0)
{
throw new ArgumentException("lastname", "lastname cannot be empty");
}
var requestJson = JsonSerializer.Serialize(new { token, id, athlete = new { firstname, lastname } });
var response = Client.UploadJson(string.Format("athletes/{0}", id), requestJson, isSecure: true, versionType: ApiVersionType.VersionTwo);
return(JsonDeserializer.Deserialize <Athlete>(response));
}
public void TestEnumWithConverter()
{
Example x1 = CreateExample();
var ser = new JsonSerializer();
ser.RegisterConverter <ErrorCode>(v => ((int)v).ToString(CultureInfo.InvariantCulture));
var deser = new JsonDeserializer();
deser.RegisterConverter(v => (ErrorCode)int.Parse(v, CultureInfo.InvariantCulture));
string json = ser.Serialize(x1);
Example x2 = deser.Deserialize <Example>(json);
Assert.AreEqual(x1.Error1, x2.Error1);
Assert.AreEqual(x1.Error2, x2.Error2);
Assert.AreEqual(x1.Error3, x2.Error3);
}
public void TestDeserializeMessage()
{
var doc = File.ReadAllText(Path.Combine("Resources", "message.json"));
var json = new JsonDeserializer();
var output = json.Deserialize <Twilio.IpMessaging.Model.Message>(new RestResponse {
Content = doc
});
Assert.NotNull(output);
Assert.AreEqual("IMaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", output.Sid);
Assert.AreEqual("ACaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", output.AccountSid);
Assert.AreEqual("ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", output.ServiceSid);
Assert.False(output.WasEdited);
Assert.AreEqual("alice", output.From);
Assert.AreEqual("CHaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", output.To);
Assert.AreEqual("hi", output.Body);
Assert.AreEqual("http://localhost/v1/Services/ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Channels/CHaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Messages/IMaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
output.Url);
}
public string Upload(string path)
{
var client = new RestClient(BaseUrl)
{
Timeout = -1
};
var request = new RestRequest("image", Method.POST);
request.AddHeader("Authorization", "Client-ID " + m_apiKey);
request.AlwaysMultipartFormData = true;
request.AddParameter("image", Convert.ToBase64String(File.ReadAllBytes(path)));
var response = client.Execute(request);
var des = new JsonDeserializer();
return(des.Deserialize <ImgurDataResponse <ImgurImage> >(response).Data.Link);
}
public void Deserialization()
{
var deserialiser = new JsonDeserializer();
var testClass = deserialiser.Deserialize <TestClass>(TestClass.Json());
Assert.NotNull(testClass);
Assert.AreEqual("TheValue", testClass.StringProperty);
Assert.AreEqual(false, testClass.BoolF);
Assert.AreEqual(true, testClass.BoolT);
Assert.AreEqual("ChildStringProperty", testClass.Child.StringProperty);
CollectionAssert.AreEqual(new[] { 1, 2, 3, 4, -5 }, testClass.Int32s);
CollectionAssert.AreEqual(new[] { "One", "Two" }, testClass.VariousStrings);
CollectionAssert.AreEqual(new[] { "Three", "Four" }, testClass.VariousStrings2);
var apples = testClass.StringCounts["Apples"];
var bananas = testClass.StringCounts["Bananas"];
Assert.AreEqual(2, apples);
Assert.AreEqual(3, bananas);
}
private IEnumerable <Issue <TIssueFields> > EnumerateIssuesByQueryInternal(String jqlQuery, String[] fields, Int32 startIndex)
{
var queryCount = 50;
var resultCount = startIndex;
onPercentComplete(0);
while (true)
{
var path = String.Format("search?jql={0}&startAt={1}&maxResults={2}", jqlQuery, resultCount, queryCount);
if (fields != null)
{
path += String.Format("&fields={0}", String.Join(",", fields));
}
var request = CreateRequest(Method.GET, path);
var response = ExecuteRequest(request);
AssertStatus(response, HttpStatusCode.OK);
var data = deserializer.Deserialize <IssueContainer <TIssueFields> >(response);
var issues = data.issues ?? Enumerable.Empty <Issue <TIssueFields> >();
foreach (var item in issues)
{
yield return(item);
}
resultCount += issues.Count();
var currentPercent = (resultCount * 100) / data.total;
if (currentPercent > 100)
{
currentPercent = 100;
}
onPercentComplete(currentPercent);
if (resultCount < data.total)
{
continue;
}
else /* all issues received */ break {
;
}
}
public async void Can_Deserialize_Names_With_Underscore_Prefix()
{
var folder = Package.Current.InstalledLocation;
var file = await folder.GetFileAsync(Path.Combine("SampleData", "underscore_prefix.txt"));
var data = await FileIO.ReadTextAsync(file);
var response = new RestResponse {
Content = data
};
var json = new JsonDeserializer();
json.RootElement = "User";
var output = (SOUser)json.Deserialize(response, typeof(SOUser));
Assert.AreEqual("John Sheehan", output.DisplayName);
Assert.AreEqual(1786, output.Id);
}
public Result GetAnswer(string id, Dictionary <string, string> arguments)
{
var client = new RestClient(string.Format("{0}/{1}", baseUrl, id));
var request = new RestRequest(Method.GET);
request.AddQueryParameter("id", id);
foreach (var arg in arguments)
{
request.AddQueryParameter(arg.Key, arg.Value);
}
request.AddHeader("accept", "application/json");
IRestResponse response = client.Execute(request);
var deserial = new JsonDeserializer();
return(deserial.Deserialize <Result>(response));
}
private IEnumerable <Issue <TIssueFields> > EnumerateIssuesByQueryInternal(String jqlQuery, String[] fields, Int32 startIndex)
{
var queryCount = 50;
var resultCount = startIndex;
var allFields = new string[typeof(TIssueFields).GetProperties().Length];
for (var i = 0; i < typeof(TIssueFields).GetProperties().Length; i++)
{
allFields[i] = typeof(TIssueFields).GetProperties()[i].Name;
}
while (true)
{
var path = String.Format("search?jql={0}&startAt={1}&maxResults={2}", jqlQuery, resultCount, queryCount);
if (fields != null)
{
path += String.Format("&fields={0}", String.Join(",", allFields));
}
var request = CreateRequest(Method.GET, path);
var response = ExecuteRequest(request);
AssertStatus(response, HttpStatusCode.OK);
var data = deserializer.Deserialize <IssueContainer <TIssueFields> >(response);
var issues = data.issues ?? Enumerable.Empty <Issue <TIssueFields> >();
foreach (var item in issues.ToList())
{
yield return(item);
}
resultCount += issues.Count();
if (resultCount < data.total)
{
continue;
}
else /* all issues received */ break {
;
}
}
/// <summary>
/// Recognizes a previously detected/enrolled image in the system
/// </summary>
/// <returns>The recognition response with the possible matches</returns>
public RecognizeResponse Recognize(string imageUrlOrBase64String, string galleryId)
{
// create client
var client = new RestClient(API_BASE_URL);
// create request
var request = new RestRequest(Method.POST);
// specify request resource
request.Resource = "recognize";
// specify data format
request.RequestFormat = DataFormat.Json;
// set request headers
request.AddHeader("app_id", _applicationID);
request.AddHeader("app_key", _applicationKey);
request.AddHeader("Content-Type", "application/json");
// initialize json deserializer
var deserial = new JsonDeserializer();
// Add request content
request.AddBody(new { image = imageUrlOrBase64String, gallery_name = galleryId });
// Execute the request
var requestResponse = client.Execute <RecognizeResponse>(request);
// testing
// var content = requestResponse.Content;
try
{
// Return the deserialized response
return(deserial.Deserialize <RecognizeResponse>(requestResponse));
}
catch (SerializationException)
{
throw new SerializationException("Error serializing JSON string. JSON string: " +
requestResponse.Content);
}
}
///=============================================================
/// POST authenticate
/// Obtain a 2-legged access token.
///
/// URL
/// https://developer.api.autodesk.com/authentication/v1/authenticate
/// Method: POST
/// Doc:
/// https://developer.autodesk.com/en/docs/oauth/v2/reference/http/authenticate-POST/
///
/// Sample Response (JSON)
/// {
/// "token_type":"Bearer",
/// "expires_in":3599,
/// "access_token":"aPJ8Ibj34KgDj8tkuWQ...Fjo4hzs5sN"
/// }
///=============================================================
public static string Authenticate(string scope)
{
// (1) Build request
var client = new RestClient();
client.BaseUrl = new System.Uri(baseApiUrl);
// Set resource/end point
var request = new RestRequest();
request.Resource = "authentication/v1/authenticate";
request.Method = Method.POST;
// Set required parameters
request.AddParameter("client_id", clientID);
request.AddParameter("client_secret", clientSecret);
request.AddParameter("grant_type", "client_credentials");
request.AddParameter("scope", scope);
Debug.WriteLine("Calling POST authentication/v1/authenticate ...");
// (2) Execute request and get response
IRestResponse response = client.Execute(request);
// Save response. This is to see the response for our learning.
m_lastResponse = response;
Debug.WriteLine("StatusCode = " + response.StatusCode);
// (3) Parse the response and get the access token.
string accessToken = "";
if (response.StatusCode == HttpStatusCode.OK)
{
JsonDeserializer deserial = new JsonDeserializer();
AuthenticateResponse loginResponse =
deserial.Deserialize <AuthenticateResponse>(response);
accessToken = loginResponse.access_token;
}
return(accessToken);
}
///===============================================================
/// Project service: List
/// Get a list of projects.
/// URL
/// https://b4.autodesk.com/api/project/v1/list.{format}?
/// Methods: GET
/// Doc
/// http://b4.autodesk.com/api/project/v1/list/doc
///===============================================================
public List <Project> ProjectList(string authToken)
{
string timeStamp = Utils.GetUNIXEpochTimestamp().ToString();
string signature = Utils.ComputeMD5Hash(apiKey + apiSecret + timeStamp);
// (1) Build request
// set base url and authenticatopm info.
var client = new RestClient();
client.BaseUrl = baseApiUrl;
// Set resource or end point
var request = new RestRequest();
request.Resource = "project/v1/list.json";
request.Method = Method.GET;
// Add parameters
request.AddParameter("company_id", companyId);
request.AddParameter("api_key", apiKey);
request.AddParameter("timestamp", timeStamp);
request.AddParameter("sig", signature);
request.AddParameter("auth_token", authToken);
// (2) Execute request and get response
IRestResponse response = client.Execute(request);
// Save response. This is to see the response for our learning.
m_lastResponse = response;
if (response.StatusCode != HttpStatusCode.OK)
{
return(null);
}
// Get a list of projects.
JsonDeserializer deserial = new JsonDeserializer();
ProjectListResponse projListResponse = deserial.Deserialize <ProjectListResponse>(response);
List <Project> proj_list = projListResponse.project_list;
return(proj_list);
}
/// <summary>
/// Query Yammer and parse JSON response to define the object.
/// </summary>
/// <typeparam name="T">Object type Expected</typeparam>
/// <param name="restService">Service URI to query</param>
/// <param name="method">GET or POST</param>
/// <param name="objectForRequest">Other parameters embedded in an object</param>
/// <param name="getAuth">Try to get the access token</param>
/// <returns>The JSON response parse of type T</returns>
public Task <T> YammerRequestAsync <T>(String restService, Method method = Method.GET, Object objectForRequest = null, Boolean getAuth = true)
where T : class
{
if (getAuth && String.IsNullOrWhiteSpace(this.AccessToken))
{
this.GetAccessToken();
}
var request = new RestRequest {
Resource = restService, Method = method
};
if (this.AccessToken != null)
{
request.AddHeader("Authorization", "Bearer " + this.AccessToken);
}
if (objectForRequest != null)
{
// Request format set to JSON and AddBody instead of AddObject
// is necessary to allow posting complex objects (such as the Activity object).
request.RequestFormat = DataFormat.Json;
request.AddBody(objectForRequest);
}
var tcs = new TaskCompletionSource <T>();
this.YammerRestClient.ExecuteAsync(request, responseasync =>
{
// response sent in JSON format and deserialized
try
{
var deserializer = new JsonDeserializer();
var ret = deserializer.Deserialize <T>(responseasync);
tcs.SetResult(ret);
}
catch (Exception ex)
{
Trace.TraceError("Yammer Response:{0} | Exception:{1} | Source:{2} | StackTrace:{3}", responseasync.Content, ex.Message, ex.Source, ex.StackTrace);
throw;
}
});
return(tcs.Task);
}
