protected override void ProcessRecord() { base.ProcessRecord(); ListSubscriptionsRequest request; try { request = new ListSubscriptionsRequest { CompartmentId = CompartmentId, TopicId = TopicId, Page = Page, Limit = Limit, OpcRequestId = OpcRequestId }; IEnumerable <ListSubscriptionsResponse> responses = GetRequestDelegate().Invoke(request); foreach (var item in responses) { response = item; WriteOutput(response, response.Items, true); } FinishProcessing(response); } catch (Exception ex) { TerminatingErrorDuringExecution(ex); } }
/// <summary> /// Initiates the asynchronous execution of the ListSubscriptions operation. /// <seealso cref="Amazon.SimpleNotificationService.IAmazonSimpleNotificationService"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the ListSubscriptions operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> public Task <ListSubscriptionsResponse> ListSubscriptionsAsync(ListSubscriptionsRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new ListSubscriptionsRequestMarshaller(); var unmarshaller = ListSubscriptionsResponseUnmarshaller.Instance; return(Invoke <IRequest, ListSubscriptionsRequest, ListSubscriptionsResponse>(request, marshaller, unmarshaller, signer, cancellationToken)); }
private static void findSubscriptions(IoTDAClient client) { ListSubscriptionsRequest req = new ListSubscriptionsRequest { Marker = "ffffffffffffffffffffffff" }; try { var resp = client.ListSubscriptions(req); Console.WriteLine(resp.HttpStatusCode); Console.WriteLine(resp.Count); Console.WriteLine(resp.Marker); foreach (var Subscription in resp.Subscriptions) { Console.WriteLine(JsonConvert.SerializeObject(Subscription)); } } catch (RequestTimeoutException requestTimeoutException) { Console.WriteLine(requestTimeoutException.ErrorMessage); } catch (ServiceResponseException clientRequestException) { Console.WriteLine(clientRequestException.HttpStatusCode); Console.WriteLine(clientRequestException.ErrorCode); Console.WriteLine(clientRequestException.ErrorMsg); } catch (ConnectionException connectionException) { Console.WriteLine(connectionException.ErrorMessage); } }
protected override void ProcessRecord() { base.ProcessRecord(); ListSubscriptionsRequest request; try { request = new ListSubscriptionsRequest { CompartmentId = CompartmentId, TopicId = TopicId, Page = Page, Limit = Limit, OpcRequestId = OpcRequestId }; IEnumerable <ListSubscriptionsResponse> responses = GetRequestDelegate().Invoke(request); foreach (var item in responses) { response = item; WriteOutput(response, response.Items, true); } if (!ParameterSetName.Equals(AllPageSet) && !ParameterSetName.Equals(LimitSet) && response.OpcNextPage != null) { WriteWarning("This operation supports pagination and not all resources were returned. Re-run using the -All option to auto paginate and list all resources."); } FinishProcessing(response); } catch (Exception ex) { TerminatingErrorDuringExecution(ex); } }
internal ListSubscriptionsResponse ListSubscriptions(ListSubscriptionsRequest request) { var marshaller = new ListSubscriptionsRequestMarshaller(); var unmarshaller = ListSubscriptionsResponseUnmarshaller.Instance; return(Invoke <ListSubscriptionsRequest, ListSubscriptionsResponse>(request, marshaller, unmarshaller)); }
/// <summary> /// Lists the subscriptions in the specified compartment or topic. /// <br/> /// Transactions Per Minute (TPM) per-tenancy limit for this operation: 60. /// /// </summary> /// <param name="request">The request object containing the details to send. Required.</param> /// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param> /// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param> /// <returns>A response object containing details about the completed operation</returns> /// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/ons/ListSubscriptions.cs.html">here</a> to see an example of how to use ListSubscriptions API.</example> public async Task <ListSubscriptionsResponse> ListSubscriptions(ListSubscriptionsRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default) { logger.Trace("Called listSubscriptions"); Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/subscriptions".Trim('/'))); HttpMethod method = new HttpMethod("GET"); HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request); requestMessage.Headers.Add("Accept", "application/json"); GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration); HttpResponseMessage responseMessage; try { if (retryingClient != null) { responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken).ConfigureAwait(false); } else { responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false); } this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage); return(Converter.FromHttpResponseMessage <ListSubscriptionsResponse>(responseMessage)); } catch (Exception e) { logger.Error($"ListSubscriptions failed with error: {e.Message}"); throw; } }
public override void Invoke(AWSCredentials creds, RegionEndpoint region, int maxItems) { AmazonSimpleNotificationServiceConfig config = new AmazonSimpleNotificationServiceConfig(); config.RegionEndpoint = region; ConfigureClient(config); AmazonSimpleNotificationServiceClient client = new AmazonSimpleNotificationServiceClient(creds, config); ListSubscriptionsResponse resp = new ListSubscriptionsResponse(); do { ListSubscriptionsRequest req = new ListSubscriptionsRequest { NextToken = resp.NextToken }; resp = client.ListSubscriptions(req); CheckError(resp.HttpStatusCode, "200"); foreach (var obj in resp.Subscriptions) { AddObject(obj); } }while (!string.IsNullOrEmpty(resp.NextToken)); }
public BaseResponse <ListSubscriptionsResponse> ListSubscriptions(ListSubscriptionsRequest request) { var method = HttpMethod.Get; var endpoint = $"/subscriptions"; var query = request.ToDictionary(); return(this.HttpClientUtil.SendRequest <ListSubscriptionsResponse>(method, endpoint, null, query)); }
/// <summary> /// 查询订阅列表 /// </summary> public async Task <ListSubscriptionsResponse> ListSubscriptionsAsync(ListSubscriptionsRequest listSubscriptionsRequest) { Dictionary <string, string> urlParam = new Dictionary <string, string>(); string urlPath = HttpUtils.AddUrlPath("/v5/iot/{project_id}/subscriptions", urlParam); SdkRequest request = HttpUtils.InitSdkRequest(urlPath, listSubscriptionsRequest); HttpResponseMessage response = await DoHttpRequestAsync("GET", request); return(JsonUtils.DeSerialize <ListSubscriptionsResponse>(response)); }
public void PropertiesReflectClientIdFactory() { var o = ListSubscriptionsRequest.WithClientId(Channel, ClientId, Limit); o.Channel.Should().Be(Channel); o.ClientId.Should().Be(ClientId); o.DeviceId.Should().BeNull(); o.Limit.Should().Be(Limit); }
private static IDictionary <string, string> ConvertListSubscriptions(ListSubscriptionsRequest request) { IDictionary <string, string> dictionary = new Dictionary <string, string>(); dictionary["Action"] = "ListSubscriptions"; if (request.IsSetNextToken()) { dictionary["NextToken"] = request.NextToken; } return(dictionary); }
/** * Convert ListSubscriptionsRequest to name value pairs */ private static IDictionary<string, string> ConvertListSubscriptions(ListSubscriptionsRequest request) { IDictionary<string, string> parameters = new Dictionary<string, string>(); parameters["Action"] = "ListSubscriptions"; if (request.IsSetNextToken()) { parameters["NextToken"] = request.NextToken; } return parameters; }
public async System.Threading.Tasks.Task <ListSubscriptionsResponse> GetSubscriptionsAsync() { ListSubscriptionsResponse listSubscription = new ListSubscriptionsResponse(); using (AmazonSimpleNotificationServiceClient snsClient = new AmazonSimpleNotificationServiceClient(credentials, Amazon.RegionEndpoint.USEast2)) { ListSubscriptionsRequest request = new ListSubscriptionsRequest(); listSubscription = await snsClient.ListSubscriptionsAsync(); } return(listSubscription); }
internal ListSubscriptionsResponse ListSubscriptions(ListSubscriptionsRequest request) { var task = ListSubscriptionsAsync(request); try { return(task.Result); } catch (AggregateException e) { ExceptionDispatchInfo.Capture(e.InnerException).Throw(); return(null); } }
/// <summary> /// Creates a new enumerable which will iterate over the SubscriptionSummary objects /// contained in responses from the ListSubscriptions operation. This enumerable will fetch more data from the server as needed. /// </summary> /// <param name="request">The request object containing the details to send</param> /// <param name="retryConfiguration">The configuration for retrying, may be null</param> /// <param name="cancellationToken">The cancellation token object</param> /// <returns>The enumerator, which supports a simple iteration over a collection of a specified type</returns> public IEnumerable <SubscriptionSummary> ListSubscriptionsRecordEnumerator(ListSubscriptionsRequest request, Common.Retry.RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default) { return(new Common.Utils.ResponseRecordEnumerable <ListSubscriptionsRequest, ListSubscriptionsResponse, SubscriptionSummary>( response => response.OpcNextPage, input => { if (!string.IsNullOrEmpty(input)) { request.Page = input; } return request; }, request => client.ListSubscriptions(request, retryConfiguration, cancellationToken), response => response.Items )); }
public async Task ListSubscriptionsAsync_RequestObject() { // Snippet: ListSubscriptionsAsync(ListSubscriptionsRequest,CallSettings) // Create client SubscriberClient subscriberClient = await SubscriberClient.CreateAsync(); // Initialize request argument(s) ListSubscriptionsRequest request = new ListSubscriptionsRequest { ProjectAsProjectName = new ProjectName("[PROJECT]"), }; // Make the request PagedAsyncEnumerable <ListSubscriptionsResponse, Subscription> response = subscriberClient.ListSubscriptionsAsync(request); // Iterate over all response items, lazily performing RPCs as required await response.ForEachAsync((Subscription item) => { // Do something with each item Console.WriteLine(item); }); // Or iterate over pages (of server-defined size), performing one RPC per page await response.AsRawResponses().ForEachAsync((ListSubscriptionsResponse page) => { // Do something with each page of items Console.WriteLine("A page of results:"); foreach (Subscription item in page) { Console.WriteLine(item); } }); // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required int pageSize = 10; Page <Subscription> singlePage = await response.ReadPageAsync(pageSize); // Do something with the page of items Console.WriteLine($"A page of {pageSize} results (unless it's the final page):"); foreach (Subscription item in singlePage) { Console.WriteLine(item); } // Store the pageToken, for when the next page is required. string nextPageToken = singlePage.NextPageToken; // End snippet }
public async Task List_ShouldCallTheCorrectUrl() { AblyRequest request = null; var rest = GetRestClient(r => { request = r; return(Task.FromResult(new AblyResponse() { TextResponse = "[]" })); }); await rest.Push.Admin.ChannelSubscriptions.ListAsync(ListSubscriptionsRequest.Empty()); request.Url.Should().Be("/push/channelSubscriptions"); request.Method.Should().Be(HttpMethod.Get); }
protected override void ProcessRecord() { base.ProcessRecord(); ListSubscriptionsRequest request; try { request = new ListSubscriptionsRequest { CompartmentId = CompartmentId, PlanNumber = PlanNumber, SubscriptionId = SubscriptionId, BuyerEmail = BuyerEmail, IsCommitInfoRequired = IsCommitInfoRequired, Limit = Limit, Page = Page, SortOrder = SortOrder, SortBy = SortBy, OpcRequestId = OpcRequestId, XOneGatewaySubscriptionId = XOneGatewaySubscriptionId, XOneOriginRegion = XOneOriginRegion }; IEnumerable <ListSubscriptionsResponse> responses = GetRequestDelegate().Invoke(request); foreach (var item in responses) { response = item; WriteOutput(response, response.Items, true); } if (!ParameterSetName.Equals(AllPageSet) && !ParameterSetName.Equals(LimitSet) && response.OpcNextPage != null) { WriteWarning("This operation supports pagination and not all resources were returned. Re-run using the -All option to auto paginate and list all resources."); } FinishProcessing(response); } catch (Exception ex) { TerminatingErrorDuringExecution(ex); } }
public static void SNSListSubscriptions() { #region SNSListSubscriptions var snsClient = new AmazonSimpleNotificationServiceClient(); var request = new ListSubscriptionsRequest(); var response = new ListSubscriptionsResponse(); do { response = snsClient.ListSubscriptions(request); foreach (var sub in response.Subscriptions) { Console.WriteLine("Subscription: {0}", sub.SubscriptionArn); } request.NextToken = response.NextToken; } while (!string.IsNullOrEmpty(response.NextToken)); #endregion Console.ReadLine(); }
public async Task List_ShouldPassTheCorrectFilters() { async Task <AblyRequest> CallList(ListSubscriptionsRequest filter) { AblyRequest request = null; var rest = GetRestClient(r => { request = r; return(Task.FromResult(new AblyResponse() { TextResponse = "[]" })); }); await rest.Push.Admin.ChannelSubscriptions.ListAsync(filter); return(request); } var emptyFilterRequest = await CallList(ListSubscriptionsRequest.Empty(100)); emptyFilterRequest.QueryParameters.Should().ContainKey("limit").WhoseValue.Should().Be("100"); var channelDeviceIdRequest = await CallList(ListSubscriptionsRequest.WithDeviceId("test-channel", "device123")); channelDeviceIdRequest.QueryParameters.Should().ContainKey("channel") .WhoseValue.Should().Be("test-channel"); channelDeviceIdRequest.QueryParameters.Should().ContainKey("deviceId") .WhoseValue.Should().Be("device123"); var channelClientIdRequest = await CallList(ListSubscriptionsRequest.WithClientId("test-channel", "clientId123")); channelClientIdRequest.QueryParameters.Should().ContainKey("channel") .WhoseValue.Should().Be("test-channel"); channelClientIdRequest.QueryParameters.Should().ContainKey("clientId") .WhoseValue.Should().Be("clientId123"); }
/// <summary> /// Lists the subscriptions in the specified compartment or topic. /// Transactions Per Minute (TPM) per-tenancy limit for this operation: 60. /// </summary> /// <param name="request"></param> /// <returns></returns> public async Task <ListSubscriptionsResponse> ListSubscriptions(ListSubscriptionsRequest request) { var uri = new Uri($"{GetEndPoint(NotificationServices.Subscriptions, this.Region)}?{request.GetOptionQuery()}"); var httpRequestHeaderParam = new HttpRequestHeaderParam() { OpcRequestId = request.OpcRequestId }; var webResponse = await this.RestClientAsync.Get(uri, httpRequestHeaderParam); using (var stream = webResponse.GetResponseStream()) using (var reader = new StreamReader(stream)) { var response = reader.ReadToEnd(); return(new ListSubscriptionsResponse() { Items = this.JsonSerializer.Deserialize <List <SubscriptionSummary> >(response), OpcRequestId = webResponse.Headers.Get("opc-request-id"), OpcNextPage = webResponse.Headers.Get("opc-request-id") }); } }
/// <summary> /// 分页返回请求者的所有的订阅列表 /// </summary> public void ListSubscriptions() { // 设置请求对象 ListSubscriptionsRequest request = new ListSubscriptionsRequest { Limit = 10, Offset = 0, }; try { // 发送请求并返回响应 ListSubscriptionsResponse response = smnClient.SendRequest(request); int result = response.SubscriptionCount; Console.WriteLine("{0}", result); Console.ReadLine(); } catch (Exception e) { // 处理异常 Console.WriteLine("{0}", e.Message); } }
public static void ResourcesExample(ClientConfig config) { var client = new NotificationClient(config) { Region = Regions.US_ASHBURN_1 }; var identityClient = new IdentityClient(config) { Region = Regions.US_ASHBURN_1 }; var listCompartmentRequest = new ListCompartmentRequest() { CompartmentId = config.TenancyId, CompartmentIdInSubtree = true, AccessLevel = ListCompartmentRequest.AccessLevels.ACCESSIBLE }; var compartments = identityClient.ListCompartment(listCompartmentRequest).Items; Console.WriteLine("* Notification Topics------------------------"); foreach (var com in compartments) { if (com.LifecycleState != "ACTIVE") { continue; } Console.WriteLine($" Compartment<{com.Name}>--------"); var listTopicsRequest = new ListTopicsRequest() { CompartmentId = com.Id, Limit = 10 }; var topics = client.ListTopics(listTopicsRequest); foreach (var topic in topics.Items) { Console.WriteLine($"\t|- Name:{topic.Name}"); Console.WriteLine($"\t|- Description:{topic.Description}"); Console.WriteLine($"\t|- LifecycleState:{topic.LifecycleState}"); Console.WriteLine($"\t|- TimeCreated:{topic.TimeCreated}"); } } foreach (var com in compartments) { if (com.LifecycleState != "ACTIVE") { continue; } Console.WriteLine($" Compartment<{com.Name}>--------"); var listSubscriptionsRequest = new ListSubscriptionsRequest() { CompartmentId = com.Id, Limit = 10 }; var subscriptions = client.ListSubscriptions(listSubscriptionsRequest); foreach (var subscription in subscriptions.Items) { Console.WriteLine($"\t|- protocol:{subscription.Protocol}"); Console.WriteLine($"\t|- policy:{subscription.DeliverPolicy}"); Console.WriteLine($"\t|- LifecycleState:{subscription.LifecycleState}"); Console.WriteLine($"\t|- CreatedTime:{subscription.CreatedTime}"); } } }
public Task <ListSubscriptionsResponse> ListSubscriptionsAsync(ListSubscriptionsRequest request, CancellationToken cancellationToken = new CancellationToken()) { throw new NotImplementedException(); }
/// <summary> /// List Subscriptions /// </summary> /// <param name="request">List Subscriptions request</param> /// <returns>List Subscriptions Response from the service</returns> /// <remarks> /// The ListSubscriptions action returns a list of the requester's subscriptions. Each call returns a limited list /// of subscriptions. If there are more subscriptions, a NextToken is also returned. Use the NextToken parameter in a /// new ListSubscriptions call to get further results. /// </remarks> public ListSubscriptionsResponse ListSubscriptions(ListSubscriptionsRequest request) { return(Invoke <ListSubscriptionsResponse>(ConvertListSubscriptions(request))); }
public void ListSubscriptionsAsync(ListSubscriptionsRequest request, AmazonServiceCallback <ListSubscriptionsRequest, ListSubscriptionsResponse> callback, AsyncOptions options = null) { throw new System.NotImplementedException(); }
public ListSubscriptionsResponse ListSubscriptions(ListSubscriptionsRequest request) { throw new System.NotImplementedException(); }
public Task <ListSubscriptionsResponse> ListSubscriptionsAsync(ListSubscriptionsRequest request, CancellationToken cancellationToken = default(CancellationToken)) { throw new System.NotImplementedException(); }
public BaseResponse <PagingResponse <GetSubscriptionResponse>, MundipaggErrorsResponse> ListSubscriptions(ListSubscriptionsRequest request) { var method = HttpMethod.Get; var endpoint = $"/subscriptions"; var query = request.ToDictionary(); return(this.SendRequest <PagingResponse <GetSubscriptionResponse> >(method, endpoint, null, query)); }