internal DeleteEndpointResponse DeleteEndpoint(DeleteEndpointRequest request)
{
var marshaller = new DeleteEndpointRequestMarshaller();
var unmarshaller = DeleteEndpointResponseUnmarshaller.Instance;
return(Invoke <DeleteEndpointRequest, DeleteEndpointResponse>(request, marshaller, unmarshaller));
}
private async Task DeleteEndpointAsync(string endpointArnToDelete)
{
DeleteEndpointRequest deReq = new DeleteEndpointRequest();
deReq.EndpointArn = endpointArnToDelete;
await snsClient.DeleteEndpointAsync(deReq);
}
/// <summary>Snippet for DeleteEndpointAsync</summary>
public async Task DeleteEndpointRequestObjectAsync()
{
// Snippet: DeleteEndpointAsync(DeleteEndpointRequest, CallSettings)
// Additional: DeleteEndpointAsync(DeleteEndpointRequest, CancellationToken)
// Create client
IDSClient iDSClient = await IDSClient.CreateAsync();
// Initialize request argument(s)
DeleteEndpointRequest request = new DeleteEndpointRequest
{
EndpointName = EndpointName.FromProjectLocationEndpoint("[PROJECT]", "[LOCATION]", "[ENDPOINT]"),
RequestId = "",
};
// Make the request
Operation <Empty, OperationMetadata> response = await iDSClient.DeleteEndpointAsync(request);
// Poll until the returned long-running operation is complete
Operation <Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;
// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation <Empty, OperationMetadata> retrievedResponse = await iDSClient.PollOnceDeleteEndpointAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
// If it has completed, then access the result
Empty retrievedResult = retrievedResponse.Result;
}
// End snippet
}
public async Task <UnRegisterUserSuccessfulResult> UnRegisterUserAsync(string userId)
{
UnRegisterUserSuccessfulResult result = new UnRegisterUserSuccessfulResult();
List <DynamoSubscriber> subscribers = await subscribersTableOperator.GetAllSubcribersOfUserAsync(userId);
if (subscribers.Count == 0)
{
result.NotRegistered = true;
return(result);
}
if (tagOperator.IsTaggingAvailable())
{
var tagSubscibers = subscribers.Select(s => new Subscriber {
UserId = s.UserId, Token = s.NotificationToken
}).ToList();
await tagOperator.RemoveSubscribers(tagSubscibers);
}
foreach (var subscriber in subscribers)
{
DeleteEndpointRequest deReq = new DeleteEndpointRequest();
deReq.EndpointArn = subscriber.EndpointARN;
await snsClient.DeleteEndpointAsync(deReq);
await subscribersTableOperator.RemoveSubscriberAsync(subscriber);
}
return(result);
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteEndpoint operation.
/// <seealso cref="Amazon.SimpleNotificationService.IAmazonSimpleNotificationService"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteEndpoint 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 <DeleteEndpointResponse> DeleteEndpointAsync(DeleteEndpointRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new DeleteEndpointRequestMarshaller();
var unmarshaller = DeleteEndpointResponseUnmarshaller.Instance;
return(Invoke <IRequest, DeleteEndpointRequest, DeleteEndpointResponse>(request, marshaller, unmarshaller, signer, cancellationToken));
}
protected override void ProcessRecord()
{
base.ProcessRecord();
if (!ConfirmDelete("OCIDataconnectivityEndpoint", "Remove"))
{
return;
}
DeleteEndpointRequest request;
try
{
request = new DeleteEndpointRequest
{
EndpointId = EndpointId,
RegistryId = RegistryId,
IsForceOperation = IsForceOperation,
IfMatch = IfMatch,
OpcRequestId = OpcRequestId
};
response = client.DeleteEndpoint(request).GetAwaiter().GetResult();
WriteOutput(response, CreateWorkRequestObject(response.OpcWorkRequestId));
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
/// <summary>
/// S3 on Outposts access points simplify managing data access at scale for shared datasets
/// in Amazon S3 on Outposts. S3 on Outposts uses endpoints to connect to Outposts buckets
/// so that you can perform actions within your virtual private cloud (VPC).
///
///
/// <para>
/// This action deletes an endpoint.
/// </para>
///
/// <para>
/// Related actions include:
/// </para>
/// <ul> <li>
/// <para>
/// <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_s3outposts_CreateEndpoint.html">CreateEndpoint</a>
///
/// </para>
/// </li> <li>
/// <para>
/// <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_s3outposts_ListEndpoints.html">ListEndpoints</a>
///
/// </para>
/// </li> </ul>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DeleteEndpoint service method.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the DeleteEndpoint service method, as returned by S3Outposts.</returns>
/// <exception cref="Amazon.S3Outposts.Model.AccessDeniedException">
/// Access was denied for this action.
/// </exception>
/// <exception cref="Amazon.S3Outposts.Model.InternalServerException">
/// There was an exception with the internal server.
/// </exception>
/// <exception cref="Amazon.S3Outposts.Model.ResourceNotFoundException">
/// The requested resource was not found.
/// </exception>
/// <exception cref="Amazon.S3Outposts.Model.ValidationException">
/// There was an exception validating this data.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/s3outposts-2017-07-25/DeleteEndpoint">REST API Reference for DeleteEndpoint Operation</seealso>
public virtual Task <DeleteEndpointResponse> DeleteEndpointAsync(DeleteEndpointRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteEndpointRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteEndpointResponseUnmarshaller.Instance;
return(InvokeAsync <DeleteEndpointResponse>(request, options, cancellationToken));
}
/// <summary>
/// S3 on Outposts access points simplify managing data access at scale for shared datasets
/// in Amazon S3 on Outposts. S3 on Outposts uses endpoints to connect to Outposts buckets
/// so that you can perform actions within your virtual private cloud (VPC).
///
///
/// <para>
/// This action deletes an endpoint.
/// </para>
///
/// <para>
/// Related actions include:
/// </para>
/// <ul> <li>
/// <para>
/// <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_s3outposts_CreateEndpoint.html">CreateEndpoint</a>
///
/// </para>
/// </li> <li>
/// <para>
/// <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_s3outposts_ListEndpoints.html">ListEndpoints</a>
///
/// </para>
/// </li> </ul>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DeleteEndpoint service method.</param>
///
/// <returns>The response from the DeleteEndpoint service method, as returned by S3Outposts.</returns>
/// <exception cref="Amazon.S3Outposts.Model.AccessDeniedException">
/// Access was denied for this action.
/// </exception>
/// <exception cref="Amazon.S3Outposts.Model.InternalServerException">
/// There was an exception with the internal server.
/// </exception>
/// <exception cref="Amazon.S3Outposts.Model.ResourceNotFoundException">
/// The requested resource was not found.
/// </exception>
/// <exception cref="Amazon.S3Outposts.Model.ValidationException">
/// There was an exception validating this data.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/s3outposts-2017-07-25/DeleteEndpoint">REST API Reference for DeleteEndpoint Operation</seealso>
public virtual DeleteEndpointResponse DeleteEndpoint(DeleteEndpointRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteEndpointRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteEndpointResponseUnmarshaller.Instance;
return(Invoke <DeleteEndpointResponse>(request, options));
}
/// <summary>
/// Initiates the asynchronous execution of the DeleteEndpoint operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DeleteEndpoint operation on AmazonS3OutpostsClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteEndpoint
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/s3outposts-2017-07-25/DeleteEndpoint">REST API Reference for DeleteEndpoint Operation</seealso>
public virtual IAsyncResult BeginDeleteEndpoint(DeleteEndpointRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = DeleteEndpointRequestMarshaller.Instance;
options.ResponseUnmarshaller = DeleteEndpointResponseUnmarshaller.Instance;
return(BeginInvoke(request, options, callback, state));
}
internal DeleteEndpointResponse DeleteEndpoint(DeleteEndpointRequest request)
{
var task = DeleteEndpointAsync(request);
try
{
return(task.Result);
}
catch (AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return(null);
}
}
/// <summary>
/// Atualiza o registro de endpoint de notificação no SNS
/// </summary>
/// <param name="device"></param>
/// <returns></returns>
public static bool RemoveNotificationEndpoint(DeviceEntity device)
{
DeleteEndpointRequest request = new DeleteEndpointRequest()
{
EndpointArn = device.BrokerEndpoint
};
var result = AWSFactory.SNSClient.DeleteEndpoint(request);
if (result.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
return(true);
}
return(false);
}
public static void SNSMobilePushAPIsDeletePlatformEndpoint()
{
#region SNSMobilePushAPIsDeletePlatformEndpoint
var snsClient = new AmazonSimpleNotificationServiceClient();
var request = new DeleteEndpointRequest
{
EndpointArn = "arn:aws:sns:us-east-1:80398EXAMPLE:" +
"endpoint/GCM/TimeCardProcessingApplication/" +
"d84b5f0d-7136-3bbe-9b42-4e001EXAMPLE"
};
snsClient.DeleteEndpoint(request);
#endregion
}
public static bool RemoveDevice(string DeviceARN)
{
try
{
using (var client = CreateClient())
{
var request = new DeleteEndpointRequest()
{
EndpointArn = DeviceARN
};
var resp = client.DeleteEndpoint(request);
return(resp.HttpStatusCode == System.Net.HttpStatusCode.OK);
}
}
catch (Exception ex)
{
Entities.Log.Error("SNS.RemoveDeviceEndpoint", ex);
return(false);
}
}
public async Task <UnRegisterSubscriberSuccessfulResult> UnRegisterSubscriberAsync(DynamoSubscriber subscriber, List <IDynamoTagEntry> tags)
{
UnRegisterSubscriberSuccessfulResult result = new UnRegisterSubscriberSuccessfulResult();
if (subscriber != null)
{
if (tagOperator.IsTaggingAvailable())
{
await tagOperator.RemoveTagSubscribers(tags);
}
DeleteEndpointRequest deReq = new DeleteEndpointRequest();
deReq.EndpointArn = subscriber.EndpointARN;
await snsClient.DeleteEndpointAsync(deReq);
await subscribersTableOperator.RemoveSubscriberAsync(subscriber);
}
else
{
result.NotRegistered = true;
return(result);
}
return(result);
}
public DeleteEndpointResponse DeleteEndpoint(DeleteEndpointRequest request)
{
throw new System.NotImplementedException();
}
public Task <DeleteEndpointResponse> DeleteEndpointAsync(DeleteEndpointRequest request, CancellationToken cancellationToken = new CancellationToken())
{
throw new NotImplementedException();
}
public void DeleteEndpointAsync(DeleteEndpointRequest request, AmazonServiceCallback <DeleteEndpointRequest, DeleteEndpointResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
public Task <DeleteEndpointResponse> DeleteEndpointAsync(DeleteEndpointRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
throw new System.NotImplementedException();
}
/// <summary>
/// This is the main function for sending notification
/// </summary>
public void sendNotification()
{
foreach (Client client in clients)
{
int clientID = client.getClientID();
#region AWS connection - This code block is same for every push message type - This is the basic block.
_client = new AmazonSimpleNotificationServiceClient("XXXXXXX", "XXXXXXXXXX", Amazon.RegionEndpoint.EUCentral1);
string token = client.getPushToken();
Platfroms mobilOsType = client.getMobileType() == 0 ? Platfroms.IOS_PATFORM : Platfroms.ANDROID_PLATFORM;
try
{
string applicationArn = "";
try
{
applicationArn = applications[(int)mobilOsType].getArn();
}
catch
{
continue;
}
string endPointArn = createEndPointArn(token, applicationArn);
if (string.IsNullOrEmpty(endPointArn))
{
continue;
}
else
{
PublishRequest publishRequest = new PublishRequest();
Dictionary <string, string> messageMap = new Dictionary <string, string>();
messageMap.Add("default", "default message");
string platform = mobilOsType == 0 ? "APNS_SANDBOX" : "GCM";
// This application developed for IOS and Android
if (mobilOsType != Platfroms.IOS_PATFORM && mobilOsType != Platfroms.ANDROID_PLATFORM)
{
continue;
}
int clientsID = client.getClientID();
Guid pushesID = client.getPushID();
string message = mobilOsType == 0 ? getAPNSMessage(notification, title, pushesID, clientsID) : getGCMMessage(notification, title, pushesID, clientsID);
messageMap.Add(platform, message);
publishRequest.TargetArn = endPointArn;
publishRequest.MessageStructure = "json";
string messageJSON = "";
try
{
messageJSON = JsonConvert.SerializeObject(messageMap);
}
catch
{
continue;
}
try
{
publishRequest.Message = messageJSON;
_client.Publish(publishRequest);
}
catch
{
continue;
}
try
{
// for deleting endPointArn
DeleteEndpointRequest _request = new DeleteEndpointRequest();
_request.EndpointArn = endPointArn;
_client.DeleteEndpoint(_request);
}
catch
{
continue;
}
}
}
catch
{
continue;
}
#endregion
}
}