public bool Login(string password)
{
var request = new RestRequest(ApiUris.Login, HttpMethod.Post);
request.AddParameter("DeviceId", _deviceId);
request.AddParameter("Password", password);
_sessionId = Execute<string>(request);
return _sessionId != null;
}
public async Task<List<AthleteSummary>> GetMembers(int id, int page, int itemsPerPage)
{
var request = new RestRequest(EndPoint + "/{id}/members", Method.GET);
request.AddParameter("id", id, ParameterType.UrlSegment);
if (page != 0)
request.AddParameter("page", page);
if (itemsPerPage != 0)
request.AddParameter("per_page", itemsPerPage);
var response = await _client.RestClient.Execute<List<AthleteSummary>>(request);
return response.Data;
}
public RestRequest CreateChunkedUploadRequest(ChunkedUpload upload, byte[] fileData)
{
var request = new RestRequest("{version}/chunked_upload", HttpMethod.Put);
request.AddParameter("version", _version, ParameterType.UrlSegment);
if (upload.HasUploadId)
{
request.AddParameter("upload_id", upload.UploadId, ParameterType.UrlSegment);
request.AddParameter("offset", upload.Offset, ParameterType.UrlSegment);
}
request.AddParameter("file", fileData, ParameterType.RequestBody);
return request;
}
private async Task<List<ActivitySummary>> GetAthleteActivities(DateTime before, DateTime after, int page, int itemsPerPage)
{
var request = new RestRequest("/api/v3/athlete/activities");
if (before != DateTime.MinValue)
request.AddQueryParameter("before", before.GetSecondsSinceUnixEpoch());
if (after != DateTime.MinValue)
request.AddQueryParameter("after", after.GetSecondsSinceUnixEpoch());
if (page != 0)
request.AddParameter("page", page);
if (itemsPerPage != 0)
request.AddParameter("per_page", itemsPerPage);
var response = await _client.RestClient.Execute<List<ActivitySummary>>(request);
return response.Data;
}
public async Task<Club> Get(int id)
{
var request = new RestRequest(EndPoint + "/{id}", Method.GET);
request.AddParameter("id", id, ParameterType.UrlSegment);
var response = await _client.RestClient.Execute<Club>(request);
return response.Data;
}
public async Task<Result<Address>> Search(string search, string latitude, string longitude)
{
using (var client = new RestClient(_client.BaseAddress))
{
var request = new RestRequest("search", HttpMethod.Get);
request.AddParameter("address", search);
request.AddParameter("numberpage", numberpage);
request.AddParameter("skippage", skippage);
client.IgnoreResponseStatusCode = true;
var result = await client.Execute<List<Address>>(request);
return new Result<Address>() { Success = true, Values = result.Data };
}
}
private async Task<IEnumerable<SegmentEffort>> GetEfforts(int segmentId, int? athleteId, DateTime? startDateLocal, DateTime? endDateLocal, int? page, int? perPage)
{
var request = new RestRequest(EndPoint + "/" + segmentId + "/all_efforts", Method.GET);
if (athleteId != null)
request.AddParameter("athlete_id", athleteId.Value);
if (startDateLocal != null)
request.AddParameter("start_date_local", startDateLocal);
if (endDateLocal != null)
request.AddParameter("end_date_local", endDateLocal);
if (page != null)
request.AddParameter("page", page);
if (perPage != null)
request.AddParameter("per_page", perPage);
var response = await _client.RestClient.Execute<SegmentEffort[]>(request);
return response.Data;
}
public RestRequest CreateAccountInfoRequest()
{
var request = new RestRequest("{version}/account/info", HttpMethod.Get);
request.AddParameter("version", _version, ParameterType.UrlSegment);
return request;
}
public RestRequest CreateAccessTokenRequest()
{
var request = new RestRequest("{version}/oauth/access_token", HttpMethod.Get);
request.AddParameter("version", _version, ParameterType.UrlSegment);
return request;
}
public int Register(string password)
{
var request = new RestRequest("api/Register", HttpMethod.Post);
request.AddParameter("DeviceId", _deviceId);
request.AddParameter("Password", password);
return Execute<int>(request);
}
public async Task<Activity> Get(long activityId, bool includeAllEfforts = true)
{
var request = new RestRequest(EndPoint + "/{id}", Method.GET);
request.AddParameter("id", activityId, ParameterType.UrlSegment);
var response = await _client.RestClient.Execute<Activity>(request);
return response.Data;
}
public async Task<List<SegmentSummary>> Explore(LatLng southWest, LatLng northEast, ActivityType activityType = ActivityType.Ride)
{
var request = new RestRequest(EndPoint + "/explore", Method.GET);
request.AddParameter("bounds",
string.Format("{0},{1},{2},{3}", southWest.Latitude.ToString(CultureInfo.InvariantCulture), southWest.Longitude.ToString(CultureInfo.InvariantCulture),
northEast.Latitude.ToString(CultureInfo.InvariantCulture), northEast.Longitude.ToString(CultureInfo.InvariantCulture)));
var response = await _client.RestClient.Execute<SegmentCollection>(request);
return response.Data.Segments;
}
/// <summary>
/// Converts this instance to an IRestRequest
/// </summary>
internal IRestRequest UnShim()
{
var req = new RestRequest(this.Resource, Unshim(this.Method));
if (!this.CsrfToken.IsBlank())
req.AddHeader("X-CSRF-Token", this.CsrfToken);
if (this.Body != null)
req.AddJsonBody(this.Body);
if (this.Cookies != null)
foreach (var cookie in this.Cookies)
req.AddParameter(cookie.Key, cookie.Value, ParameterType.Cookie);
if (this.Parameters != null)
{
//if (this.Parameters.Count > 0)
// req.AddHeader("Content-Type", "application/x-www-form-urlencoded");
foreach (var param in this.Parameters)
req.AddParameter(param.Key, param.Value, ParameterType.RequestBody);
}
//later: try this for attaching files to nodes:
//req.ContentCollectionMode = ContentCollectionMode.MultiPartForFileParameters;
//req.RequestFormat = DataFormat.Json; <--- Drupal ignores this
//if (this.Attachment != null)
//{
// req.AddFile(this.Attachment.Name,
// this.Attachment.Stream,
// this.Attachment.Name,
// MediaTypeHeaderValue.Parse("multipart/form-data"));
// req.AddParameter("field_name", "field_private_file");//hack: hard-code!
// //req.AddParameter("files[files]", "@" + this.Attachment.Name);
//}
return req;
}
public async Task<Result<string>> Login(string email, string password)
{
using (var client = new RestClient(_client.BaseAddress))
{
var request = new RestRequest("oauth/token", HttpMethod.Post);
request.AddParameter("username", email);
request.AddParameter("password", password);
request.AddParameter("grant_type", "password");
request.AddParameter("client_id", this.client_id);
request.AddParameter("client_secret", this.secret_id);
client.IgnoreResponseStatusCode = true;
var result = await client.Execute<Users>(request);
if (result.StatusCode == HttpStatusCode.Unauthorized)
{
return new Result<string>()
{
Success = false,
Value = "Email e/ou Senha inválidos..."
};
}
else if (result.StatusCode == HttpStatusCode.InternalServerError)
{
return new Result<string>()
{
Success = false,
Value = "Error..."
};
}
else
{
return new Result<string>()
{
Success = true,
Value = result.Data.access_token
};
}
}
}
public string GetPublicationSummaries(List<string> publicationIds)
{
var restClient = new RestClient(ServiceURLs.ESummaryBaseURL);
var restRequest = new RestRequest();
restRequest.AddParameter("db", databaseName, ParameterType.QueryString);
restRequest.AddParameter("retmode", "json", ParameterType.QueryString);
restRequest.AddParameter("rettype", "abstract", ParameterType.QueryString);
restRequest.AddParameter("id", string.Join(", ", publicationIds.ToArray()), ParameterType.QueryString);
restRequest.AddParameter("version", "2.0", ParameterType.QueryString);
// Get the response.
var waitTime = PubMedThrottler.GetWaitTime();
Thread.Sleep(waitTime);
//TODO: Fix mapping from json or xml;
var response = restClient.Execute(restRequest).Result;
return response.ToString();
}
public PubMedPublicationIdsResult GetPublicationsIds(PubMedQueryFilter filter)
{
var restClient = new RestClient(ServiceURLs.ESearchBaseURL);
var restRequest = new RestRequest();
restRequest.AddParameter("db", databaseName, ParameterType.QueryString);
restRequest.AddParameter("retmode", "json", ParameterType.QueryString);
restRequest.AddParameter("retstart", (filter.Skip * filter.Take), ParameterType.QueryString);
restRequest.AddParameter("term", filter.Query, ParameterType.QueryString);
restRequest.AddParameter("retmax", filter.Take, ParameterType.QueryString);
if (filter.RelDate != DateTime.MinValue)
{
var pmDate = PubMedDateOperations.DatetimeToPubMedDate(filter.RelDate);
restRequest.AddParameter("reldate", pmDate, ParameterType.QueryString);
}
var waitTime = PubMedThrottler.GetWaitTime();
Thread.Sleep(waitTime);
var response = restClient.Execute<PubMedResponse>(restRequest).Result;
if (response.Data == null)
throw new Exception("No Response From The Server");
var result = new PubMedPublicationIdsResult();
result.PubMedIdCollection = new List<string>();
response.Data.esearchresult.idlist.ForEach(r => result.PubMedIdCollection.Add(r));
return result;
}
public static async Task<JObject> Execute(string callback, HttpMethod httpMethod,
Dictionary<string,string> parameters,
Dictionary<string,string> files = null, object obj = null)
{
//init request
var request = new RestRequest (callback, httpMethod);
request.AddHeader("Content-Type", "application/json; charset=utf-8");
//add parameters
foreach (var key in parameters.Keys)
{
request.AddParameter (key, parameters [key].ToString ());
}
//add files
//if (files != null && files.Keys.Count > 0) {
// foreach (var key in files.Keys) {
// request.AddFile( .AddFile (key, files[key]);
// }
//}
//execute
var result = await client.Execute<string>(request);
//print response
Debug.WriteLine (callback);
Debug.WriteLine (result.Data);
//save cookies
//var sessionCookie = response.Cookies.SingleOrDefault(x => x.Name == "WRAD_SESSION");
//if (sessionCookie != null && APIHelper.restClient.CookieContainer==null)
//{
// APIHelper.restClient.CookieContainer = new CookieContainer ();
/// APIHelper.restClient.CookieContainer.Add(new Uri(APIHelper.baseUrl),new Cookie(sessionCookie.Name, sessionCookie.Value, sessionCookie.Path, sessionCookie.Domain));
//}
//string to JObect deserialization
try{
return JObject.Parse(result.Data);
} catch(Exception ex){
Debug.WriteLine (ex.Message + (ex.InnerException != null ? ("\n" + ex.InnerException.Message) : ""));
return null;
}
}
public async Task<Result<Users>> Me(string token)
{
using (var client = new RestClient(_client.BaseAddress + "/api/v1"))
{
var request = new RestRequest("user/me", HttpMethod.Get);
request.AddParameter("access_token", token);
client.IgnoreResponseStatusCode = true;
var result = await client.Execute<List<Users>>(request);
return new Result<Users>() { Success = true, Values = result.Data };
}
}
private void BuildParameters(ref RestRequest request, List<Parameter> parms)
{
request.Parameters.Clear();
if (parms != null)
foreach (var p in parms)
request.AddParameter(p);
request.AddParameter("oauth_consumer_key", wc_key);
request.AddParameter("oauth_nonce", Common.GetSHA1(Common.GetUnixTime(true)));
request.AddParameter("oauth_signature_method", "HMAC-SHA256");
request.AddParameter("oauth_timestamp", Common.GetUnixTime(false));
if (parms != null)
{
List<Parameter> sortedList = request.Parameters.OrderBy(p => p.Name).ToList();
request.Parameters.Clear();
foreach (var p in sortedList)
request.Parameters.Add(p);
}
string base_request_uri = WebUtility.UrlEncode(wc_url + request.Resource).Replace("%2f", "%2F").Replace("%3a", "%3A");
string parmstr = string.Empty;
foreach (var parm in request.Parameters)
parmstr += parm.Name + "%3D" + parm.Value + "%26";
base_request_uri = "GET&" + base_request_uri + "&" + parmstr.Substring(0, parmstr.Length - 3);
base_request_uri = base_request_uri.Replace(",", "%252C").Replace("[", "%255B").Replace("]", "%255D");
Common.DebugInfo.Append(base_request_uri);
request.AddParameter("oauth_signature", Common.GetSHA256(wc_secret, base_request_uri));
}
public async Task<dynamic> passwordForgot(string mail)
{
RestRequest request = new RestRequest("user/passwordforgot", Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("mail", mail, ParameterType.RequestBody, "application/json");
_client.IgnoreResponseStatusCode = true;
var response = await _client.Execute<dynamic>(request);
var data = Encoding.UTF8.GetString(response.RawBytes);
//Permet de recuperer le message d'erreur avant que le tache se termine
if (!response.IsSuccess)
{
throw new Exception(data);
}
return data;
}
public RestRequest CreateCommitChunkedUploadRequest(ChunkedUpload upload, string path, string root, bool overwrite, string parent_revision)
{
var request = new RestRequest("{version}/commit_chunked_upload/{root}{path}", HttpMethod.Post);
request.AddParameter("version", _version, ParameterType.UrlSegment);
request.AddParameter("path", path, ParameterType.UrlSegment);
request.AddParameter("root", root, ParameterType.UrlSegment);
request.AddParameter("overwrite", overwrite);
request.AddParameter("upload_id", upload.UploadId);
if (!String.IsNullOrEmpty(parent_revision))
{
request.AddParameter("parent_rev", parent_revision);
}
return request;
}
public async Task<UploadStatus> Upload(ActivityType activityType, DataType dataType, System.IO.Stream input, string fileName, string name = null, string description = null,
bool @private = false, bool commute = false)
{
var request = new RestRequest("/api/v3/uploads?data_type={data_type}&activity_type={activity_type}&private={private}&commute={commute}", Method.POST);
if (name != null)
{
request.Resource += "&name={name}";
request.AddParameter("name", name, ParameterType.UrlSegment);
}
if (description != null)
{
request.Resource += "&description={description}";
request.AddParameter("description", description, ParameterType.UrlSegment);
}
request.ContentCollectionMode = ContentCollectionMode.MultiPart;
request.AddParameter("data_type", dataType, ParameterType.UrlSegment);
request.AddParameter("activity_type", EnumHelper.ToString(activityType), ParameterType.UrlSegment);
request.AddParameter("private", @private ? 1 : 0, ParameterType.UrlSegment);
request.AddParameter("commute", commute ? 1 : 0, ParameterType.UrlSegment);
request.AddFile("file", input, Uri.EscapeDataString(fileName));
var response = await _client.RestClient.Execute<UploadStatus>(request);
return response.Data;
}
private async Task<Leaderboard> GetLeaderboardInternal(int segmentId, int? page, int? perPage, Gender? gender, AgeGroup? ageGroup, bool following = false)
{
var request = new RestRequest(EndPoint + "/" + segmentId + "/leaderboard", Method.GET);
if (page != null)
request.AddParameter("page", page);
if (perPage != null)
request.AddParameter("per_page", perPage);
request.AddParameter("following", following ? "true" : "false");
if (gender.HasValue)
request.AddParameter("gender", gender.Value.ToStravaString());
if (ageGroup.HasValue)
request.AddParameter("age_group", ageGroup.Value.ToStravaString());
var response = await _client.RestClient.Execute<Leaderboard>(request);
return response.Data;
}
private async void GetData(string campus)
{
bool done = false;
int page=0;
int count = 1;
while (count <= 1)
{
var client = new RestClient(new Uri("https://data.pr.gov/resource/"));
var request = new RestRequest("admit.json", HttpMethod.Get);
//request.AddParameter("$limit", 1000);
//request.AddParameter("$offset", 0);
request.AddParameter("campus", campus);
request.AddParameter("calendario", Year);
var result = await client.Execute<List<Result>>(request);
Data=(result.Data);
count = count + 1;
page = Data.Count;
result.ToString();
}
slcCampus.Items.Clear();
foreach (Result result in Data)
{
if (Programs.Count > 0)
{
bool exists = false;
foreach (string program in Programs)
{
if (program == result.program)
{
exists = true;
}
}
if (!exists)
{
Programs.Add(result.program);
slcCampus.Items.Add(result.program);
}
}
else
{
Programs.Add(result.program);
Programs[0].ToString();
}
slcCampus.SelectedIndex = -1;
HideLoading();
}
/*foreach (Result result in Data)
{
if (result.campus == "RIOPIEDRAS")
{
Rio.Add(result);
}
if (result.campus == "PONCE")
{
Ponce.Add(result);
}
if (result.campus == "BAYAMON")
{
Baya.Add(result);
}
}*/
}
async void circleImageStartTapped(object sender, EventArgs args)
{
if (circleImageStart.BorderColor == Color.Red)
return;
labelBarcode.Text = "";
labelBarcodeFormat.Text = "";
labelResult.Text = "";
string Barcode = "eifelmono "+ DateTime.Now.ToString("hh:mm:ss");
string BarcodeFormat = "";
circleImageStart.BorderColor = Color.Red;
try
{
if (Backdoor.IsCameraAvailable)
{
Barcode= "";
if (scanner == null)
scanner = new MobileBarcodeScanner();
scanner.TopText = CurrentSettingValues.ScannerTopText;
scanner.BottomText = CurrentSettingValues.ScannerBottomText;
scanner.CancelButtonText = CurrentSettingValues.ScannerCancelText;
scanner.FlashButtonText = CurrentSettingValues.ScannerFlashText;
MobileBarcodeScanningOptions options = new MobileBarcodeScanningOptions
{
PossibleFormats = CurrentSettingValues.BarcodeFormatsAsList,
AutoRotate = CurrentSettingValues.AutoRotate,
TryHarder = CurrentSettingValues.TryHarder,
TryInverted = CurrentSettingValues.TryInverted,
PureBarcode = CurrentSettingValues.PureBarcode
};
// options.BuildMultiFormatReader();
var result = await scanner.Scan(options);
if (result == null)
return;
Barcode = result.Text;
if (CurrentSettingValues.BarcodeFormatVisible)
BarcodeFormat = result.BarcodeFormat.ToString();
}
labelBarcode.Text = Barcode;
labelBarcodeFormat.Text = BarcodeFormat;
#pragma warning disable 4014
Task.Run(() =>
{
Backdoor.Vibrate();
});
#pragma warning restore 4014
if (!string.IsNullOrEmpty(CurrentSettingValues.RESTUrlBase))
try
{
circleImageStart.Source = ImageSource.FromResource("ScanAndREST.Resources.Icons.ScanAndRESTResult.png");
var client = new RestClient(CurrentSettingValues.RESTUrlBase);
client.Timeout = new TimeSpan(0, 0, CurrentSettingValues.RESTTimeout);
RestRequest request = new RestRequest(CurrentSettingValues.RESTUrlResource, RestSharp.Portable.Method.GET);
request.AddParameter("Barcode", Barcode);
var response = (await client.Execute(request));
labelResult.Text = BodyEncoding.GetString(response.RawBytes, 0, response.RawBytes.Length);
}
catch
{
labelResult.Text = "No anser from the REST Service";
}
}
finally
{
circleImageStart.BorderColor = Color.Black;
circleImageStart.Source = ImageSource.FromResource("ScanAndREST.Resources.Icons.ScanAndRESTStart.png");
}
}
/// <summary>
/// Delete an activity.
/// </summary>
/// <param name="id">Identifier of the activity.</param>
/// <returns></returns>
public async Task Delete(long id)
{
var request = new RestRequest(EndPoint + "/{id}", Method.DELETE);
request.AddParameter("id", id, ParameterType.UrlSegment);
await _client.RestClient.Execute(request);
}
/// <summary>
/// List the laps of an activity.
/// </summary>
/// <param name="activityId">Identifier of the activity.</param>
/// <returns>List of laps.</returns>
public async Task<List<ActivitySummary>> GetLaps(long activityId)
{
var request = new RestRequest("/api/v3/activities/{id}/laps", Method.GET);
request.AddParameter("id", activityId, ParameterType.UrlSegment);
var response = await _client.RestClient.Execute<List<ActivitySummary>>(request);
return response.Data;
}
public async Task<UploadStatus> GetUploadStatus(int id)
{
var request = new RestRequest("/api/v3/uploads/{id}", Method.GET);
request.AddParameter("id", id, ParameterType.UrlSegment);
var response = await _client.RestClient.Execute<UploadStatus>(request);
return response.Data;
}
/// <summary>
/// List activity kudoers
/// </summary>
/// <param name="activityId">Identifier of the activity.</param>
/// <param name="page"></param>
/// <param name="itemsPerPage"></param>
/// <returns></returns>
public async Task<List<AthleteSummary>> GetKudoers(long activityId, int page = 0, int itemsPerPage = 0)
{
var request = new RestRequest("/api/v3/activities/{id}/kudos", Method.GET);
request.AddParameter("id", activityId, ParameterType.UrlSegment);
if (page != 0)
request.AddParameter("page", page);
if (itemsPerPage != 0)
request.AddParameter("per_page", itemsPerPage);
var response = await _client.RestClient.Execute<List<AthleteSummary>>(request);
return response.Data;
}
public async Task<List<Stream>> GetActivityStreams(long activityId, params StreamType[] types)
{
var request = new RestRequest("/api/v3/activities/{id}/streams/{types}", Method.GET);
request.AddParameter("id", activityId, ParameterType.UrlSegment);
request.AddParameter("types", EnumHelper.ToString<StreamType>(types), ParameterType.UrlSegment);
var response = await _client.RestClient.Execute<List<Stream>>(request);
return response.Data;
}
