/// <summary>
/// Creates a new list for the user associated with the current session
/// </summary>
/// <param name="name">The name of the new list</param>
/// <param name="description">Optional description for the list</param>
/// <param name="language">Optional language that might indicate the language of the content in the list</param>
/// <remarks>Requires a valid user session</remarks>
/// <exception cref="UserSessionRequiredException">Thrown when the current client object doens't have a user session assigned.</exception>
public async Task<string> ListCreate(string name, string description = "", string language = null)
{
RequireSessionId(SessionType.UserSession);
if (string.IsNullOrWhiteSpace(name))
throw new ArgumentNullException("name");
// Description is expected by the API and can not be null
if (string.IsNullOrWhiteSpace(description))
description = "";
RestRequest request = new RestRequest("list") { RequestFormat = DataFormat.Json };
AddSessionId(request, SessionType.UserSession);
language = language ?? DefaultLanguage;
if (!String.IsNullOrWhiteSpace(language))
{
request.AddBody(new { name = name, description = description, language = language });
}
else
{
request.AddBody(new { name = name, description = description });
}
IRestResponse<ListCreateReply> response = await _client.ExecutePostTaskAsync<ListCreateReply>(request).ConfigureAwait(false);
return response.Data == null ? null : response.Data.ListId;
}
internal static RestRequest Get(Type type, ContractObject restObj)
{
restObj.type = restObj.Type;
var request = new RestRequest
{
RequestFormat = DataFormat.Json
};
switch (type)
{
case Type.Get:
request.Method = Method.GET;
request.Resource = restObj.Uri + "/" + restObj.id + "?depth=" + restObj.depth;
break;
case Type.Put:
request.Method = Method.PUT;
request.Resource = restObj.Uri + "/" + restObj.id;
request.AddBody(restObj);
break;
case Type.Post:
request.Method = Method.POST;
request.Resource = restObj.Uri;
request.AddBody(restObj);
break;
case Type.Delete:
request.Method = Method.DELETE;
request.Resource = restObj.Uri + "/" + restObj.id;
break;
case Type.Search:
request.Method = Method.GET;
var resource = new StringBuilder(100);
resource.Append(restObj.Uri);
resource.Append("s"); // pluralize the endpoint
var searchObj = restObj as ISearchable;
resource.Append("?search=" + searchObj.searchTerm +
"&count=" + searchObj.pageSize +
"&page=" + searchObj.page
);
request.Resource = resource.ToString();
break;
default:
throw new NotSupportedException(type.ToString());
}
return request;
}
/// <summary>
/// Adds a new load balancer to the IP
/// </summary>
/// <param name="server_id">Unique server's identifier.</param>
/// <param name="ip_id">Unique server's identifier.</param>
public ServerResponse CreateLoadBalancer(string server_id, string ip_id, string loadBalancerId)
{
try
{
var request = new RestRequest("/servers/{server_id}/ips/{ip_id}/load_balancers", Method.POST)
{
RequestFormat = DataFormat.Json,
JsonSerializer = new CustomSerializer()
};
request.AddUrlSegment("server_id", server_id);
request.AddUrlSegment("ip_id", ip_id);
string load_balancer_id = loadBalancerId;
request.AddBody(new { load_balancer_id });
var result = restclient.Execute<ServerResponse>(request);
if (result.StatusCode != HttpStatusCode.Accepted)
{
throw new Exception(result.Content);
}
return result.Data;
}
catch
{
throw;
}
}
public void RequestFriend(string username, Action<string> onCompleted)
{
var friendRequest = new InitialFriendRequest { username = username };
var friendRequestRootObject = new InitialFriendRequestRoot { friend_request = friendRequest };
var request = new RestRequest(Method.POST);
request.RequestFormat = RestSharp.DataFormat.Json;
request.AddBody(friendRequestRootObject);
var friendsRequestApiCall = _pgSession.GetWebAppFunction("/api", "/friend_requests");
var client = new RestClient(friendsRequestApiCall);
_pgSession.Begin(delegate
{
var apiResponse = (RestResponse<ApiResponse>)client.Execute<ApiResponse>(request);
if (!apiResponse.IsOk())
{
onCompleted(apiResponse.Data.message);
}
else
{
onCompleted(null);
}
});
}
public IRestRequest Build()
{
var request = new RestRequest(methodInfo.Path, methodInfo.Method);
request.RequestFormat = DataFormat.Json; // TODO: Allow XML requests?
for (int i = 0; i < arguments.Count(); i++)
{
Object argument = arguments[i];
var usage = methodInfo.ParameterUsage[i];
switch (usage)
{
case RestMethodInfo.ParamUsage.Query:
request.AddParameter(methodInfo.ParameterNames[i], argument);
break;
case RestMethodInfo.ParamUsage.Path:
request.AddUrlSegment(methodInfo.ParameterNames[i], argument.ToString());
break;
case RestMethodInfo.ParamUsage.Body:
request.AddBody(argument);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return request;
}
/// <summary>
/// Changes the priority of a list of issues on a given priority ID
/// </summary>
/// <param name="IssueKeys"></param>
/// <param name="PriorityId"></param>
/// <param name="waiter"></param>
/// <param name="eventHandler"></param>
public static void SetPriorities(List<string> IssueKeys, string PriorityId,
EventHandler<ResponseArg> eventHandler)
{
List<RestRequest> requests = new List<RestRequest>();
foreach (var issueKey in IssueKeys)
{
var request = new RestRequest("issue/" + issueKey, Method.PUT);
request.AddHeader("Content-Type", "application/json");
request.RequestFormat = RestSharp.DataFormat.Json;
var newissue =
new
{
fields = new
{
priority = new
{
id = PriorityId
}
}
};
request.AddBody(newissue);
requests.Add(request);
}
BackgroundJira bj = new BackgroundJira();
bj.WorkerComplete += eventHandler;
bj.Start<Priority>(requests);
}
/// <summary>
/// Limited to campaigns containing emails and segments
/// </summary>
public Campaign CreateCampaign(int emailId, int segmentId)
{
CampaignEmail campaignEmail = _elementHelper.GetCampaignEmail(emailId, -101);
CampaignSegment campaignSegment = _elementHelper.GetCampaignSegment(segmentId, -100, -101);
Campaign campaign = new Campaign
{
name = "sample campaign",
campaignType = "sample",
type = "Campaign",
startAt = ConvertToUnixEpoch(DateTime.Now),
endAt = ConvertToUnixEpoch(DateTime.Today.AddDays(1)),
elements = new List<CampaignElement>
{
campaignSegment,
campaignEmail
}
};
RestRequest request = new RestRequest(Method.POST)
{
Resource = "/assets/campaign",
RequestFormat = DataFormat.Json
};
request.AddBody(campaign);
IRestResponse<Campaign> response = _client.Execute<Campaign>(request);
return response.Data;
}
///<summary>
//Attaches servers to a private network.
//</summary>
/// <param name="private_network_id">Unique private network's identifier.</param>
public PrivateNetworkServerResponse CreatePrivateNetworkServers(AttachPrivateNetworkServersRequest privateNetworkServers, string private_network_id)
{
try
{
var request = new RestRequest("/private_networks/{private_network_id}/servers", Method.POST)
{
RequestFormat = DataFormat.Json,
JsonSerializer = new CustomSerializer()
};
request.AddUrlSegment("private_network_id", private_network_id);
request.AddHeader("Content-Type", "application/json");
request.AddBody(privateNetworkServers);
var result = restclient.Execute<PrivateNetworkServerResponse>(request);
if (result.StatusCode != HttpStatusCode.Accepted)
{
throw new Exception(result.Content);
}
return result.Data;
}
catch
{
throw;
}
}
/// <summary>
/// Confirm a newly-created subscription, pre-authorzation or one-off
/// payment. This method also checks that the resource response data includes
/// a valid signature and will throw a {SignatureException} if the signature is
/// invalid.
/// </summary>
/// <param name="requestContent">the response parameters returned by the API server</param>
/// <returns>the confirmed resource object</returns>
public ConfirmResource ConfirmResource(NameValueCollection requestContent)
{
var resource = DeserializeAndValidateRequestSignature(requestContent);
var request = new RestRequest("confirm", Method.POST);
request.RequestFormat = DataFormat.Json;
request.AddBody(
new
{
resource_id = resource.ResourceId,
resource_type = resource.ResourceType
});
var client = new RestClient
{
BaseUrl = new System.Uri(ApiClient.ApiUrl),
UserAgent = GoCardless.UserAgent
};
var serializer = new JsonSerializer
{
ContractResolver = new UnderscoreToCamelCasePropertyResolver(),
};
client.AddHandler("application/json", new NewtonsoftJsonDeserializer(serializer));
client.Authenticator = new HttpBasicAuthenticator(GoCardless.AccountDetails.AppId, GoCardless.AccountDetails.AppSecret);
var response = client.Execute(request);
if (response.StatusCode != HttpStatusCode.OK)
{
throw new ApiException("Unexpected response : " + (int)response.StatusCode + " " + response.StatusCode);
}
return resource;
}
public bool CheckConnectivity()
{
bool connected = true;
try
{
var request = new RestRequest("query", Method.POST);
request.RequestFormat = DataFormat.Json;
//request.RequestBody
request.AddBody(new { txtQuery = "f2a0341b3" });
var response = this._client.Execute(request);
Console.WriteLine(response.Content);
connected = true;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
connected = false;
}
return connected;
}
public string Invoke(string method, string action, object message)
{
Method m;
Method.TryParse(method, true, out m);
var client = new RestClient(ApiUrl);
var request = new RestRequest(action, m) { RequestFormat = DataFormat.Json };
if (message != null)
request.AddBody(message);
request.AddHeader("apikey", ApiKey);
var response = client.Execute(request);
if (response.StatusCode != HttpStatusCode.OK)
throw new Exception("Api call failed: " + response.StatusDescription);
logger.InfoFormat("{0} invoked successfully",ApiUrl + action);
if (response.Headers.Any(h => h.Name == "watchr.commandsavailable"))
Bus.SendLocal(new FetchCommands());
return response.Content;
}
internal IRestResponse CreateCustomer( CustomerSummary customer )
{
var request = new RestRequest( GetApiPrefix( ApiType.Consume ) + "/customer", Method.POST );
request.RequestFormat = DataFormat.Json;
request.AddBody( customer );
return Execute( request );
}
public IRestResponse PutCustomer( string href, CustomerSummary customer )
{
var request = new RestRequest( href, Method.PUT );
request.RequestFormat = DataFormat.Json;
request.AddBody( customer );
return Execute( request );
}
private static IEnumerable<CarScoreView> Evaluate(IReadOnlyCollection<CarView> cars)
{
var request = new RestRequest("simulation/evaluate/" + _maTeam, Method.POST) {RequestFormat = DataFormat.Json};
request.AddBody(cars);
return _client.Execute<List<CarScoreView>>(request).Data;
}
public static bool Query(dynamic requestData, Action<dynamic> successCallback, Action<dynamic> failCallback)
{
var client = new RestClient(WxPayConfig.WEB_SERVICE_BASE);
var token = WgServiceHelper.Token;
if (token == null)
{
CommonUtil.Log.Info("token is empty");
return false;
}
var notifyRequest = new RestRequest("pay/orderquery?access_token={access_token}", Method.POST);
notifyRequest.RequestFormat = DataFormat.Json;
notifyRequest.AddUrlSegment("access_token", token.access_token);
notifyRequest.AddBody(requestData);
var notifyResponse =JsonConvert.DeserializeObject<dynamic>(client.Execute(notifyRequest).Content);
if (notifyResponse.errcode == 0)
{
if (successCallback != null)
successCallback(notifyResponse);
return true;
}
else
{
Logger.Debug(notifyResponse);
if (failCallback != null)
failCallback(notifyResponse);
return false;
}
}
public IList<Artifact> SearchArtifacts(IEnumerable<ArtifactSearch> searches)
{
var result = new List<Artifact>(searches.Count());
while (searches.Any())
{
var request = new RestRequest(Method.POST);
request.Resource = "search/artifact/";
request.RequestFormat = DataFormat.Json;
request.OnBeforeDeserialization = BeforeSerialization;
request.AddBody(searches.Take(this._pageSize));
var response = Execute<ArtifactResponse>(request);
if (response.ResponseStatus == ResponseStatus.Error)
{
throw new ApiClientTransportException(response.ErrorMessage, response.ErrorException);
}
result.AddRange(response.Data);
searches = searches.Skip(this._pageSize);
}
return result;
}
//public string RESTServiceURL { get; set; }
public RestResponse<CRMTask> CreateTask(CRMTask task, K2CRMConfig config)
{
var client = new RestClient(config.RESTUrl);
var request = new RestRequest();
request.Method = Method.POST;
if (config.CredentialCache != null)
{
request.Credentials = config.CredentialCache;
}
if (config.Credentials != null)
{
request.Credentials = config.Credentials;
}
request.RequestFormat = RestSharp.DataFormat.Json;
request.Resource = "K2CRM/CRMCreateTask";
request.AddBody(task);
RestResponse<CRMTask> response = null;
if (config.Async)
{
client.ExecuteAsync<CRMTask>(request, null);
}
else
{
response = client.Execute<CRMTask>(request);
}
return response;
}
private RestClient PrepareRestClientWithRequestBody(object requestBody,
string nancyapiSubmiterrors, out RestRequest request) {
var client = new RestClient(string.Format("{0}{1}", _baseUrl, nancyapiSubmiterrors));
request = new RestRequest { RequestFormat = DataFormat.Json };
request.AddBody(requestBody);
return client;
}
internal IRestResponse InviteCustomer( string inviteLink, CustomerInvite invite )
{
var request = new RestRequest( inviteLink, Method.POST );
request.RequestFormat = DataFormat.Json;
request.AddBody( invite );
return Execute( request );
}
/// <summary>
/// Create an Export
/// </summary>
/// <param name="fields"></param>
/// <param name="destinationUri"></param>
/// <param name="filter"> </param>
/// <returns>The URI for the export</returns>
public string CreateExport(Dictionary<string, string> fields, string destinationUri, ExportFilter filter)
{
Export export = new Export
{
name = "sample export",
fields = fields,
filter = filter,
secondsToAutoDelete = 3600,
secondsToRetainData = 3600,
syncActions = new List<SyncAction>
{
new SyncAction
{
action = SyncActionType.add,
destinationUri = destinationUri
}
}
};
RestRequest request = new RestRequest(Method.POST)
{
Resource = "/contact/export",
RequestFormat = DataFormat.Json,
RootElement = "export"
};
request.AddBody(export);
IRestResponse<Export> response = _client.Execute<Export>(request);
Export returnedExport = response.Data;
return returnedExport.uri;
}
public static void LogOut(User user)
{
RestClient client = new RestClient(ConfigurationManager.AppSettings["endpoint"]);
RestRequest request = new RestRequest("Users/Login", Method.POST);
request.AddBody(user);
var response = client.Execute(request) as RestResponse;
}
bool RecordTime(TimeEntry timeEntry, Task task)
{
var timeEntryModel = new TimeEntryModel
{
Date = GetCompatibleDate(timeEntry).ToString("O"),
Notes = timeEntry.Comment,
TimeString = timeEntry.MinutesSpent + "m",
DurationSeconds = timeEntry.MinutesSpent*60,
ProjectId = timeEntry.Project?.Id,
TaskId = task?.Id,
WorkItems = new List<string>(), // TODO: add functionality for tracking WorkItems
};
var post = new RestRequest
{
Resource = "Time/Save",
Method = Method.POST,
RequestFormat = DataFormat.Json
};
post.AddBody(timeEntryModel);
var result = _api.Execute<TimeEntryModel>(post);
return result != null;
}
public IRestResponse Post(string resource, object postData)
{
RestSharp.RestRequest restReq = new RestSharp.RestRequest(resource, Method.POST);
restReq.RequestFormat = DataFormat.Json;
restReq.AddBody(postData);
return(Convert(Execute(restReq)));
}
public void UpdatePerformance(Performance performance)
{
var request = new RestRequest("api/Performance/UpdatePerformance", Method.POST);
request.RequestFormat = DataFormat.Json;
request.AddBody(performance);
client.Execute(request);
}
public void SendScreenshot(Guid screenshotId, string macAddress, Guid requestId)
{
if (base64Image == null)
{
Logger.Instance.Write("SendScreenshot", LogLevel.Medium, "No screenshot taken.");
return;
}
var request = new RestRequest("v1/signboards/{macAddress}/screenshots", Method.POST);
request.RequestFormat = RestSharp.DataFormat.Json;
request.AddUrlSegment("macAddress", macAddress);
request.AddBody(ScreenshotModel.From(screenshotId, base64Image));
var response = Client.Execute(request);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
Logger.Instance.Write("SendScreenshot", LogLevel.Medium, "Screenshot request successfull");
RequestComponent.GetInstance().FinishRequest(macAddress, RequestInputModel.From(requestId, true));
return;
}
else
{
Logger.Instance.Write("SendScreenshot", LogLevel.Medium, "Screenshot request failed. " + ((response != null && response.ErrorMessage != null ) ? response.ErrorMessage.ToString() : " Response object is null"));
RequestComponent.GetInstance().FinishRequest(macAddress, RequestInputModel.From(requestId, false));
return;
}
}
public IRestResponse PutCustomerTags( IEnumerable<CustomerTag> tags )
{
var request = new RestRequest( "tag", Method.PUT );
request.RequestFormat = DataFormat.Json;
request.AddBody( tags.ToList() );
return Execute( request );
}
public IRestResponse PutLicenseTags( string licenseTagsAssignmentHref, IEnumerable<LicenseTag> tags )
{
var request = new RestRequest( licenseTagsAssignmentHref, Method.PUT );
request.RequestFormat = DataFormat.Json;
request.AddBody( tags );
return Execute( request );
}
public ActionResult PostMessage(string webHookUrl)
{
var client = new RestClient(webHookUrl);
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.RequestFormat = DataFormat.Json;
request.AddBody(new
{
title = "Outlook Custom Connector Webhooks Demo",
text = "Message posted from my ASP.NET MVC Appplication",
themeColor = "DB4C3F"
});
var response = client.Execute(request);
var content = response.Content;
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
return View("Success");
}
else
{
return View();
}
}
public void Given_A_Checklist_Is_Being_Saved_Then_Returns_Status_OK()
{
// Given
var client = new RestClient(Url.AbsoluteUri);
client.Authenticator = new NtlmAuthenticator( "continuous.int","is74rb80pk52" );
const int numberOfRequestsToSend = 15;
var stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
var parallelLoopResult = Parallel.For(0, numberOfRequestsToSend, x =>
{
//GIVEN
var model = CreateChecklistViewModel();
var resourceUrl = string.Format("{0}{1}/{2}", ApiBaseUrl, "checklists", model.Id.ToString());
var request = new RestRequest(resourceUrl);
request.AddHeader("Content-Type", "application/json");
request.RequestFormat = DataFormat.Json;
request.Method = Method.POST;
request.AddBody(model);
// When
var response = client.Execute(request);
//THEN
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
});
stopWatch.Stop();
var processingSeconds = TimeSpan.FromMilliseconds(stopWatch.ElapsedMilliseconds).TotalSeconds;
Assert.That(parallelLoopResult.IsCompleted);
Console.WriteLine(string.Format("average: {0}", processingSeconds / numberOfRequestsToSend));
}
public ActionResult Create(SetGameDTO createGame)
{
if (!Session["Role"].Equals("Admin"))
{
return RedirectToAction("Index", "Home");
}
var request = new RestRequest("api/Games", Method.POST);
var apiKey = Session["ApiKey"];
var UserId = Session["UserId"];
request.AddHeader("xcmps383authenticationkey", apiKey.ToString());
request.AddHeader("xcmps383authenticationid", UserId.ToString());
request.RequestFormat = DataFormat.Json;
request.AddBody(createGame);
var queryResult = client.Execute(request);
statusCodeCheck(queryResult);
var redirectUrl = new UrlHelper(Request.RequestContext).Action("Create", "Game");
if (queryResult.StatusCode != HttpStatusCode.Created)
{
redirectUrl = new UrlHelper(Request.RequestContext).Action("Create", "Game");
return Json(new { Url = redirectUrl });
}
else if (queryResult.StatusCode == HttpStatusCode.Forbidden)
{
redirectUrl = new UrlHelper(Request.RequestContext).Action("Login", "User");
return Json(new { Url = redirectUrl });
}
redirectUrl = new UrlHelper(Request.RequestContext).Action("Index", "Game");
return Json(new { Url = redirectUrl });
}
public void Given_A_Bespoke_Question_Is_Being_Saved_Then_Returns_Status_OK()
{
QuestionViewModel model = new QuestionViewModel()
{
Id = Guid.NewGuid(),
Text = "Is there life on Mars?",
CategoryId = Guid.Parse("3DEE8018-575E-4609-A5AC-C1DE2475C2DB"), // Employees
};
model.PossibleResponses = new List<QuestionResponseViewModel>();
model.PossibleResponses.Add( new QuestionResponseViewModel() { Id = Guid.NewGuid(), ResponseType = "Neutral", Title="Improvement Required" });
model.PossibleResponses.Add( new QuestionResponseViewModel() { Id = Guid.NewGuid(), ResponseType = "Positive", Title = "Acceptable" });
model.PossibleResponses.Add( new QuestionResponseViewModel() { Id = Guid.NewGuid(), ResponseType = "Negative", Title = "Unacceptable" });
model.Category = new CategoryViewModel() {Id = model.CategoryId};
Guid checklistID = Guid.Parse("EDAD1451-EF0F-2D38-16BF-BBFF6920C192");
ResourceUrl = string.Format("{0}{1}?newQuestionId={2}&checklistId={3}", ApiBaseUrl, "question", model.Id.ToString(), checklistID);
// Given
var client = new RestClient(Url.AbsoluteUri);
var request = new RestRequest(ResourceUrl);
request.AddHeader("Content-Type", "application/json");
request.RequestFormat = DataFormat.Json;
request.Method = Method.POST;
request.AddBody(model);
// When
var response = client.Execute(request);
// Then
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
public List <T> GetDataPostSync <T>(string filterType, string filterText)
{
App_Settings appSettings = App.Database.GetApplicationSettings();
// Set up our return data object -- a list of typed objects.
List <T> returnData = new List <T>();
// set up the proper URL
string url = GetRestServiceUrl();
if (!url.EndsWith(@"/"))
{
url += @"/";
}
if ((filterType != null) &&
(filterType.Length > 0) &&
(filterText != null) &&
(filterText.Length > 0))
{
url += @"q/" + typeof(T).Name + @"/" + filterType;// + @"?v=" + Uri.EscapeDataString(filterText);
}
else
{
url += @"all/" + typeof(T).Name;
}
// Create a HTTP client to call the REST service
RestSharp.RestClient client = new RestSharp.RestClient(url);
var request = new RestSharp.RestRequest(Method.POST);
if (appSettings.DeviceID != null)
{
SimpleAES encryptText = new SimpleAES("V&WWJ3d39brdR5yUh5(JQGHbi:FB@$^@", "W4aRWS!D$kgD8Xz@");
string authid = encryptText.EncryptToString(appSettings.DeviceID);
string datetimever = encryptText.EncryptToString(DateTime.Now.ToString("yyyy-MM-ddTHH:mm:sszzz"));
request.AddHeader("x-tdws-authid", authid);
request.AddHeader("x-tdws-auth", datetimever);
}
request.RequestFormat = DataFormat.Json;
request.AddBody(filterText);
var response = client.Execute(request);
if (response.StatusCode != System.Net.HttpStatusCode.OK)
{
//throw new Exception("Bad request");
ErrorReporting errorReporting = new ErrorReporting();
// dch rkl 12/07/2016 add the call/sub/proc to log
//errorReporting.sendException(new Exception(response.Content));
errorReporting.sendException(new Exception(response.Content), "RestClient.cs.GetDataPostSync");
}
string JsonResult = response.Content;
returnData = JsonConvert.DeserializeObject <List <T> >(JsonResult);
return(returnData);
}
public static T ExecuteRequest <T>(string url, Method method, T body, RestClient client, IDictionary <string, object> requestParameters)
where T : new()
{
var request = new RestRequest(url, method);
if (requestParameters != null)
{
foreach (var requestParameter in requestParameters)
{
request.AddParameter(requestParameter.Key, requestParameter.Value);
}
}
if (ShouldAddBody(method))
{
var serializer = new NewtonsoftJsonSerializer(
JsonSerializer.Create(
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
}));
request.JsonSerializer = serializer;
request.RequestFormat = DataFormat.Json;
request.AddBody(body);
}
//Fixed bug that prevents RestClient for adding custom headers to the request
//https://stackoverflow.com/questions/22229393/why-is-restsharp-addheaderaccept-application-json-to-a-list-of-item
client.ClearHandlers();
client.AddHandler("application/json", new JsonDeserializer());
var result = ExectueRequest <T>(method, client, request);
if (result.ErrorException != null)
{
throw new WebException("REST client encountered an error: " + result.ErrorMessage, result.ErrorException);
}
// This is a hack in order to allow this method to work for simple types as well
// one example of this is the GetRevisionRaw method
if (RequestingSimpleType <T>())
{
return(result.Content as dynamic);
}
return(result.Data);
}
