/// <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); }