protected virtual void throwWhenErrResponse(RestSharp.IRestResponse response, string resource)
{
if (response.StatusCode != HttpStatusCode.OK &&
response.StatusCode != HttpStatusCode.Created &&
response.StatusCode != HttpStatusCode.Accepted &&
response.StatusCode != HttpStatusCode.NoContent
)
{
var errMsg = parseError(response);
if (string.IsNullOrWhiteSpace(errMsg))
{
errMsg = $"{response.StatusDescription}";
}
if (Logger != null)
{
Logger.Error($"Request to {resource} failed: " + errMsg, logCtx);
Logger.Error($"Request to {resource} failed: " + response.Content, logCtx);
}
throw new RestResponseException(errMsg)
{
Response = response,
StatusCode = response.StatusCode,
StatusDescription = response.StatusDescription
};
}
}
public List <Game> getPlatforms()
{
RestSharp.RestRequest request = new RestSharp.RestRequest("api/platforms", RestSharp.Method.GET);
request.AddParameter("api_key", apiKey, RestSharp.ParameterType.QueryString);
request.AddParameter("filter", "id:157|23|36|43", RestSharp.ParameterType.QueryString);
request.AddParameter("format", "json", RestSharp.ParameterType.QueryString);
request.AddParameter("sort", "original_release_date:desc", RestSharp.ParameterType.QueryString);
RestSharp.IRestResponse response = client.Execute(request);
dynamic results = JsonConvert.DeserializeObject <dynamic>(response.Content);
JObject obj = (Newtonsoft.Json.Linq.JObject)JsonConvert.DeserializeObject(response.Content);
JArray jarr = (JArray)obj["results"];
List <Game> games = new List <Game>();
foreach (var item in jarr)
{
string Id = Convert.ToString(item["id"]);
if (!Id.Equals("67742") && !Id.Equals("59938") && !Id.Equals("71095") && !Id.Equals("70513") && !Id.Equals("65713") && !Id.Equals("66679"))
{
Game game = new Game()
{
Name = Convert.ToString(item["name"]),
Image = Convert.ToString(item["image"]["original_url"])
};
games.Add(game);
}
}
return(games);
}
private void ResponseVerifications(BaseRestSharp.IRestResponse response, bool throwException, string url, Enums.Method methodType)
{
// end of index logic
if (throwException)
{
if (response.ErrorException != null)
{
throw response.ErrorException;
}
}
if (!IsRequestStatusCodeSuccess(response.StatusCode))
{
switch (response.StatusCode)
{
case HttpStatusCode.NotFound:
throw new WebApiException($"{url} has thrown status code : {response.StatusCode}. Please check that you have spelled the url correctly");
case HttpStatusCode.InternalServerError:
throw new WebApiException($"{url} has thrown status code : {response.StatusCode}.{response.ErrorMessage} Content :{response.Content}");
case HttpStatusCode.MethodNotAllowed:
throw new WebApiException($"{url} has thrown status code : {response.StatusCode}. {methodType} verb is not supported. Change the method type to a supported one");
default:
throw new WebApiException($"{url} has thrown status code : {response.StatusCode} {response.ErrorMessage} {response.Content}");
}
}
}
private static void LogRequest(RestRequest request, RestSharp.IRestResponse result)
{
RestManager rest_man = privInstance;
string log_message = String.Format("{0} - {1} {2}", result.StatusCode.ToString(), request.Method.ToString(), rest_man.Client.BuildUri(request));
FDLog.LogRequest(log_message);
}
/// <summary>
/// Manages the session credentials
/// </summary>
/// <param name="getMethod">Need to know what type of action should occur</param>
private bool ManageServerSessions(Func <RestSharp.Method> getMethod)
{
if (clientConfig.IsSessionRequired == false)
{
return(true);
}
IRestRequest updateSession = new RestSharp.RestRequest(clientConfig.SessionAddress);
if (getMethod != null)
{
updateSession.Method = getMethod();
}
else
{
throw new InvalidOperationException("Unable to manage server sessions without knowing which method to use");
}
AddAuthTokensAsNecessary(updateSession);
CleanRequest(ref updateSession);
RestSharp.IRestResponse response = client.Execute(updateSession);
SetTokenFromCookies(client);
return(response.StatusCode == HttpStatusCode.Created || response.StatusCode == HttpStatusCode.OK);
}
public static RestSharp.IRestResponse getResponse(string url)
{
RestClient clientApp = new RestClient(url);
RestRequest request = new RestRequest(Method.GET);
RestSharp.IRestResponse requestResult = clientApp.Execute(request);
return(requestResult);
}
private static string GetErrorStatus(RestSharp.IRestResponse response)
{
string str = string.Format("Http Status Code: {0} - {1} URL: {2}",
(int)response.StatusCode,
response.StatusDescription,
response.ResponseUri.AbsoluteUri);
return(str);
}
private IRestResponse GetContactList()
{
//Initialize the request object with proper method and URL
RestRequest request = new RestRequest("/contacts/list", Method.GET);
// Execute the request
RestSharp.IRestResponse response = client.Execute(request);
return(response);
}
public T Deserialize <T>(RestSharp.IRestResponse response)
{
String content = response.Content;
JsonSerializerSettings settings = new JsonSerializerSettings {
};
T result = JsonConvert.DeserializeObject <T>(content, settings);
return(result);
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times")] // this usage is perfectly correct
public T Deserialize <T>(RestSharp.IRestResponse response)
{
var content = response.Content;
using (var stringReader = new StringReader(content))
using (var jsonTextReader = new JsonTextReader(stringReader))
{
return(serializer.Deserialize <T>(jsonTextReader));
}
}
protected void StatusCodeLogging(RestSharp.IRestResponse response, Type type)
{
if (response.StatusCode == System.Net.HttpStatusCode.NoContent)
{
log.DebugFormat("[{0}] - Http Status Code: {1} - {2}", type.Name, (int)response.StatusCode, response.StatusDescription);
}
else
{
log.ErrorFormat("[{0}] - Http Status Code: {1} - {2}", type.Name, (int)response.StatusCode, response.StatusDescription);
}
}
private static string GetPagingStatus(RestSharp.IRestResponse response, int?page, int count)
{
if (page == null)
{
page = 0;
}
string str = string.Format("Page {0} Record Count {1} -- API Limit: {2}", page, count,
response.Headers.Where(x => x.Name == "X-BC-ApiLimit-Remaining").FirstOrDefault().Value);
return(str);
}
/// <summary>
/// Checks whether the user is currently authenticated
/// </summary>
public bool IsAuthenticated()
{
RestSharp.IRestRequest isAuthenticated = new RestSharp.RestRequest(clientConfig.IsAuthenticatedAddress);
CleanRequest(ref isAuthenticated);
RestSharp.IRestResponse response = client.Execute(isAuthenticated);
if (response.StatusCode != HttpStatusCode.OK)
{
ThrowExceptionIfNecessary(response, "IsAuthenticated");
}
return(response.StatusCode == HttpStatusCode.OK);
}
private bool IsResponseError(RestSharp.IRestResponse response)
{
if (response == null)
{
return(false);
}
if (string.IsNullOrWhiteSpace(response.ErrorMessage) &&
response.ErrorException == null)
{
return(false);
}
return(true);
}
public void doRestCall(string url, string body)
{
var client = new RestClient(url);
var request = new RestRequest(Method.POST);
request.XmlSerializer = new RestSharp.Serializers.DotNetXmlSerializer();
request.RequestFormat = DataFormat.Xml;
request.AddHeader("cache-control", "no-cache");
request.AddHeader("Content-Type", "text/xml");
request.AddParameter("undefined", body, ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
this.res = response;
}
private IRestResponse Convert(RestSharp.IRestResponse resp)
{
RestResponse r = new RestResponse();
r.Content = resp.Content;
r.ContentEncoding = resp.ContentEncoding;
r.ContentLength = resp.ContentLength;
r.ContentType = resp.ContentType;
r.ErrorException = resp.ErrorException;
r.ErrorMessage = resp.ErrorMessage;
r.ResponseUri = resp.ResponseUri;
r.Server = resp.Server;
r.StatusCode = resp.StatusCode;
return(r);
}
private string LoginServer()
{
var client = new RestSharp.RestClient("http://webservice.assetsapp.com/mdw/");
var requestToken = new RestSharp.RestRequest("Token", RestSharp.Method.POST);
requestToken.AddParameter("UserName", "*****@*****.**");
requestToken.AddParameter("Password", "Middleware2016!");
requestToken.AddParameter("grant_type", "password");
requestToken.AddHeader("Content-Type", "application/x-www-form-urlencoded");
RestSharp.IRestResponse responseToken = client.Execute(requestToken);
var contentToken = responseToken.Content;
TokenClass responseToken2 = client.Execute <TokenClass>(requestToken).Data;
var token = responseToken2.access_token;
var statusToken = responseToken.StatusDescription;
if (statusToken == "OK" || token != null || token != "")
{
return(token);
}
//Register
var requestRegister = new RestSharp.RestRequest("api/Account/Register", RestSharp.Method.POST);
requestRegister.AddParameter("UserName", "*****@*****.**");
requestRegister.AddParameter("Email", "*****@*****.**");
requestRegister.AddParameter("Password", "Middleware2016!");
requestRegister.AddParameter("ConfirmPassword", "Middleware00000!");
requestRegister.AddHeader("Content-Type", "application/json");
RestSharp.IRestResponse responseRegister = client.Execute(requestRegister);
var contentRegister = responseRegister.Content;
var statusRegister = responseRegister.StatusDescription;
if (contentRegister.Contains("is already taken"))
{
statusRegister = "OK";
}
if (statusRegister != "OK")
{
return("");
}
//Token
responseToken = client.Execute(requestToken);
contentToken = responseToken.Content;
responseToken2 = client.Execute <TokenClass>(requestToken).Data;
token = responseToken2.access_token;
statusToken = responseToken.StatusDescription;
return(token);
}
public dynamic SendRequest()
{
var client = new RestSharp.RestClient(this.getApiURL());
client.Timeout = -1;
var request = new RestSharp.RestRequest(Method.POST);
this.addHeaders(request);
var query = this.getQueryString();
request.AddParameter("application/json", query, ParameterType.RequestBody);
RestSharp.IRestResponse response = client.Execute(request);
dynamic resp = JsonConvert.DeserializeObject(response.Content);
return(resp);
}
public static async Task <AzureLogIn_Response> ForceAuthentication()
{
var client = new RestClient("https://login.windows.net/common/oauth2/token");
client.Timeout = -1;
var internalRequest = new RestRequest(RestSharp.Method.POST);
internalRequest.AddHeader("Cookie", "x-ms-gateway-slice=prod; stsservicecookie=ests; fpc=AgHuTQ6BuTdPsqX9wzbtm_AqP8ELAQAAADqYsdYOAAAA");
internalRequest.AlwaysMultipartFormData = true;
internalRequest.AddParameter("grant_type", "password");
internalRequest.AddParameter("username", "*****@*****.**");
internalRequest.AddParameter("password", "Micheal30");
internalRequest.AddParameter("client_id", "b68f7dee-4098-4f3f-a9db-36a8b71305aa");
internalRequest.AddParameter("resource", "https://graph.microsoft.com");
RestSharp.IRestResponse response = await client.ExecuteAsync(internalRequest);
return(JsonHelper.ToClass <AzureLogIn_Response>(response.Content));
}
static void Main(string[] args)
{
displayWelcome();
RestSharp.IRestResponse apiResponse = getResponse("https://swapi.dev/api/people/");
StarWarsResponse apiJSON = JsonConvert.DeserializeObject <StarWarsResponse>(apiResponse.Content);
foreach (var personaje in apiJSON.Results)
{
RestSharp.IRestResponse planetResponse = getResponse(personaje.Homeworld);
Homeworld planetJSON = JsonConvert.DeserializeObject <Homeworld>(planetResponse.Content);
Console.WriteLine("Nombre: " + personaje.Name);
Console.WriteLine("Altura: " + personaje.Height);
Console.WriteLine("Masa: " + personaje.Mass);
Console.WriteLine("Planeta: " + planetJSON.name);
Console.WriteLine("------------------");
}
}
public int getRegisterationStatusCode(string email, string password)
{
if (email != null && password != null)
{
RegisterRequest req = new RegisterRequest();
req.email = email;
req.password = password;
request.RequestFormat = DataFormat.Json;
restResponse = _client.Execute(request);
}
else if (email != null && password == null)
{
BadRegisterRequest req = new BadRegisterRequest();
req.email = email;
request.RequestFormat = DataFormat.Json;
restResponse = _client.Execute(request);
}
//Extract status code from received response and store as an Interger
return((int)restResponse.StatusCode);
}
/// <summary>
/// Get a valid access token using credentials.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <TokenResp> GetTokenAsync(TokenReq request)
{
var client = new RestSharp.RestClient(GlobalSettings.AzureLoginEndpoint);
client.Timeout = -1;
var internalRequest = new RestSharp.RestRequest(RestSharp.Method.POST);
internalRequest.AddHeader("Content-Type", "application/x-www-form-urlencoded");
internalRequest.AddHeader("Cookie", "x-ms-gateway-slice=prod; stsservicecookie=ests; fpc=AhfW_FJrHCJGl1Lr3XFEqOjhvS2OAQAAAPhsttYOAAAA");
internalRequest
.AddParameter("grant_type", request.GrantType)
.AddParameter("username", request.Username)
.AddParameter("password", new System.Net.NetworkCredential(string.Empty, request.Password).Password)
.AddParameter("client_id", GlobalSettings.ClientId)
.AddParameter("resource", GlobalSettings.MsGraphResourceEndpoint);
RestSharp.IRestResponse response = await client.ExecuteAsync(internalRequest);
return(JsonHelper.ToClass <TokenResp>(response.Content));
}
public String fetchToken()
{
var client = new RestSharp.RestClient(this.getTokenUrl());
client.Timeout = -1;
var request = new RestSharp.RestRequest(Method.GET);
request.AddHeader("x-visp-username", this.app_username);
request.AddHeader("x-visp-password", this.app_password);
request.AddHeader("x-visp-client-id", this.client_id);
request.AddHeader("x-visp-client-secret", this.client_secret);
request.OnBeforeDeserialization = resp => { resp.ContentType = "application/json"; };
RestSharp.IRestResponse response = client.Execute(request);
AuthResponse parsed = parseJson(response.Content);
this.token = parsed.token;
return(this.token);
}
/// <summary>
/// Get a valid access token using application credentials.
/// </summary>
/// <returns></returns>
public async Task <TokenResp> GetTokenAsync()
{
var client = new RestSharp.RestClient(GlobalSettings.AzureLoginMsOnlineEndpoint);
client.Timeout = -1;
var internalRequest = new RestSharp.RestRequest(RestSharp.Method.POST);
internalRequest.AddHeader("Content-Type", "application/x-www-form-urlencoded");
internalRequest.AddHeader("Cookie", "stsservicecookie=ests; x-ms-gateway-slice=estsfd; fpc=Ar8LiulPgZ5CpGJ2VSD-M7ldt19hAQAAAMKFttYOAAAA");
internalRequest
.AddParameter("client_id", GlobalSettings.ClientId)
.AddParameter("state", "12345")
.AddParameter("client_secret", GlobalSettings.ClientSecretId)
.AddParameter("grant_type", "client_credentials")
.AddParameter("scope", "https://graph.microsoft.com/.default");
RestSharp.IRestResponse response = await client.ExecuteAsync(internalRequest);
return(JsonHelper.ToClass <TokenResp>(response.Content));
}
protected virtual string parseError(RestSharp.IRestResponse response)
{
string errMsg = null;
try
{
var errResponse = JsonConvert.DeserializeObject <JObject>(response.Content.TrimStart((char)65279));
errMsg = errResponse?["code"]?.Value <string>() + " - " + errResponse?["message"]?.Value <string>();
// debitoor
var errArr = errResponse?["errors"];
if (errArr != null)
{
errMsg += string.Join(", ", errArr.Select(e => $" prop: {e["property"]?.Value<string>()} msg: {e["message"]?.Value<string>()}"));
}
}
catch
{
}
errMsg = errMsg ?? ($"Anfrage fehlgeschlagen: {response.StatusCode} {response.StatusDescription}");
return(errMsg);
}
public static RestClientException CreateErrorException(RSharp.RestClient restClient, RSharp.IRestResponse restResponse, Exception ex)
=> new RestClientException(HttpStatusCode.InternalServerError,
ex.Message,
restResponse.Request.ToRestClientRequest(restClient.BaseUrl),
restResponse.ToRestClientRequest());
public static RestClientException CreateFailedException(RSharp.RestClient restClient, RSharp.IRestResponse restResponse)
=> RestClientException.Create(restResponse.StatusCode,
restResponse.StatusDescription,
restResponse.Request.ToRestClientRequest(restClient.BaseUrl),
restResponse.ToRestClientRequest());
public Task <BaseRestSharp.RestResponse> InvokeCall(HttpServiceRequest httpRequest, bool throwException = true,
bool isElasticLog = false, bool invokeAsync = false)
{
ServicePointManager.DefaultConnectionLimit = 200;
// Base URL
BaseRestSharp.RestClient client = new BaseRestSharp.RestClient(httpRequest.Url);
BaseRestSharp.IRestResponse response = null;
Stopwatch watch = new Stopwatch();
// Method to be triggered
BaseRestSharp.RestRequest request = new BaseRestSharp.RestRequest(httpRequest.Action, (BaseRestSharp.Method)httpRequest.MethodType)
{
Timeout = httpRequest.Timeout
};
if (httpRequest.CookieJar != null)
{
foreach (Cookie cookie in httpRequest.CookieJar)
{
request.AddCookie(cookie.Name, cookie.Value);
}
}
if (httpRequest.Body != null)
{
request.RequestFormat = BaseRestSharp.DataFormat.Json;
request.AddJsonBody(httpRequest.Body);
}
if (httpRequest.Headers != null)
{
foreach (KeyValuePair <string, string> header in httpRequest.Headers.ToList())
{
request.AddHeader(header.Key, header.Value);
}
}
if (httpRequest.QueryStringParameters != null)
{
foreach (KeyValuePair <string, string> param in httpRequest.QueryStringParameters.ToList())
{
request.AddQueryParameter(param.Key, param.Value);
}
}
watch.Start();
BaseRestSharp.RestResponse customRestResponse = null;
TaskCompletionSource <BaseRestSharp.RestResponse> taskCompletionSource = new TaskCompletionSource <BaseRestSharp.RestResponse>();
response = client.Execute(request);
watch.Stop();
taskCompletionSource.SetResult(customRestResponse);
ResponseVerifications(response, throwException, httpRequest.Url, httpRequest.MethodType);
return(taskCompletionSource.Task);
}
