/// <summary>
/// Updates the specified subscription's configuration.
/// <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/UpdateSubscription.cs.html">here</a> to see an example of how to use UpdateSubscription API.</example>
public async Task <UpdateSubscriptionResponse> UpdateSubscription(UpdateSubscriptionRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called updateSubscription");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/subscriptions/{subscriptionId}".Trim('/')));
HttpMethod method = new HttpMethod("PUT");
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 <UpdateSubscriptionResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"UpdateSubscription failed with error: {e.Message}");
throw;
}
}
private static void updateSubscription(IoTDAClient client)
{
UpdateSubscriptionRequest req = new UpdateSubscriptionRequest
{
SubscriptionId = "4c961c93-376c-4083-9c27-2e88b43b3c0d",
Body = new UpdateSubReq()
{
Callbackurl = "https://0.0.0.0:443/deviceActivate"
}
};
try
{
var resp = client.UpdateSubscription(req);
Console.WriteLine(resp.HttpStatusCode);
Console.WriteLine(resp);
}
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);
}
}
public async Task UpdatesSubscriptionPreservingMetadata()
{
// given
var subscription = await _resourceFactory.CreateSubscriptionFor(_mandate);
var request = new UpdateSubscriptionRequest
{
Id = subscription.Id,
Amount = 456,
Name = "Updated subscription name",
PaymentReference = "PR456789"
};
var subject = new SubscriptionsClient(_clientConfiguration);
// when
var result = await subject.UpdateAsync(request);
// then
Assert.That(result.Item.Id, Is.EqualTo(request.Id));
Assert.That(result.Item.Amount, Is.EqualTo(request.Amount));
Assert.That(result.Item.Metadata, Is.EqualTo(subscription.Metadata));
Assert.That(result.Item.Name, Is.EqualTo(request.Name));
Assert.That(result.Item.PaymentReference, Is.EqualTo(request.PaymentReference));
}
public Subscription UpdateDeadLetterPolicy(string projectId, string topicId, string subscriptionId, string deadLetterTopicId)
{
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
// This is an existing topic that the subscription with dead letter policy is attached to.
TopicName topicName = TopicName.FromProjectTopic(projectId, topicId);
// This is an existing subscription with a dead letter policy.
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
// This is an existing dead letter topic that the subscription with dead letter policy forwards
// dead letter messages to.
var deadLetterTopic = TopicName.FromProjectTopic(projectId, deadLetterTopicId).ToString();
// Construct the subscription with the dead letter policy you expect to have after the update.
// Here, values in the required fields (name, topic) help identify the subscription.
var subscription = new Subscription
{
SubscriptionName = subscriptionName,
TopicAsTopicName = topicName,
DeadLetterPolicy = new DeadLetterPolicy
{
DeadLetterTopic = deadLetterTopic,
MaxDeliveryAttempts = 20,
}
};
var request = new UpdateSubscriptionRequest
{
Subscription = subscription,
// Construct a field mask to indicate which field to update in the subscription.
UpdateMask = new FieldMask { Paths = { "dead_letter_policy" } }
};
var updatedSubscription = subscriber.UpdateSubscription(request);
return updatedSubscription;
}
public Subscription RemoveDeadLetterPolicy(string projectId, string topicId, string subscriptionId)
{
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
// This is an existing topic that the subscription with dead letter policy is attached to.
TopicName topicName = TopicName.FromProjectTopic(projectId, topicId);
// This is an existing subscription with dead letter policy.
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
var subscription = new Subscription()
{
SubscriptionName = subscriptionName,
TopicAsTopicName = topicName,
DeadLetterPolicy = null
};
var request = new UpdateSubscriptionRequest
{
Subscription = subscription,
UpdateMask = new FieldMask {
Paths = { "dead_letter_policy" }
}
};
var updatedSubscription = subscriber.UpdateSubscription(request);
return(updatedSubscription);
}
internal virtual UpdateSubscriptionResponse UpdateSubscription(UpdateSubscriptionRequest request)
{
var marshaller = UpdateSubscriptionRequestMarshaller.Instance;
var unmarshaller = UpdateSubscriptionResponseUnmarshaller.Instance;
return(Invoke <UpdateSubscriptionRequest, UpdateSubscriptionResponse>(request, marshaller, unmarshaller));
}
protected override void ProcessRecord()
{
base.ProcessRecord();
UpdateSubscriptionRequest request;
try
{
request = new UpdateSubscriptionRequest
{
SubscriptionId = SubscriptionId,
OspHomeRegion = OspHomeRegion,
CompartmentId = CompartmentId,
UpdateSubscriptionDetails = UpdateSubscriptionDetails,
OpcRequestId = OpcRequestId,
IfMatch = IfMatch
};
response = client.UpdateSubscription(request).GetAwaiter().GetResult();
WriteOutput(response, response.Subscription);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public async Task <IActionResult> UpdateSubscription(long restaurant,
[FromForm] UpdateSubscriptionRequest request)
{
var command = new UpdateSubscriptionCommand(restaurant, request.Subscription);
return(await HandleActionResultFor(command));
}
public async Task UpdatesSubscriptionReplacingMetadata()
{
// given
var subscription = await _resourceFactory.CreateSubscriptionFor(_mandate);
var request = new UpdateSubscriptionRequest
{
Id = subscription.Id,
Amount = 456,
Metadata = new Dictionary <string, string>
{
["Key4"] = "Value4",
["Key5"] = "Value5",
["Key6"] = "Value6",
},
Name = "Updated subscription name",
PaymentReference = "PR456789"
};
var subject = new SubscriptionsClient(_clientConfiguration);
// when
var result = await subject.UpdateAsync(request);
// then
Assert.That(result.Item.Id, Is.EqualTo(request.Id));
Assert.That(result.Item.Amount, Is.EqualTo(request.Amount));
Assert.That(result.Item.Metadata, Is.EqualTo(request.Metadata));
Assert.That(result.Item.Name, Is.EqualTo(request.Name));
Assert.That(result.Item.PaymentReference, Is.EqualTo(request.PaymentReference));
}
public async Task <IActionResult> Update([FromRoute] int id, UpdateSubscriptionRequest request)
{
var subscription = await _subscriptionService.UpdateSubscriptionAsync(id, request);
var mapped = _mapper.Map <SubscriptionResponse>(subscription);
return(Ok(new ApiOkResponse(mapped)));
}
/// <summary>
/// Initiates the asynchronous execution of the UpdateSubscription operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the UpdateSubscription 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>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/shield-2016-06-02/UpdateSubscription">REST API Reference for UpdateSubscription Operation</seealso>
public virtual Task <UpdateSubscriptionResponse> UpdateSubscriptionAsync(UpdateSubscriptionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = UpdateSubscriptionRequestMarshaller.Instance;
var unmarshaller = UpdateSubscriptionResponseUnmarshaller.Instance;
return(InvokeAsync <UpdateSubscriptionRequest, UpdateSubscriptionResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
public async Task <Subscription> UpdateSubscriptionAsync(long id, UpdateSubscriptionRequest updateSubscriptionRequest)
{
ValidateModel(updateSubscriptionRequest);
var response = await PutAsJsonAsync($"/subscriptions/{id}", JsonConvert.SerializeObject(updateSubscriptionRequest)).ConfigureAwait(false);
return(JsonConvert.DeserializeObject <SubscriptionResponse>(
await response.Content.ReadAsStringAsync().ConfigureAwait(false)).Subscription);
}
internal virtual UpdateSubscriptionResponse UpdateSubscription(UpdateSubscriptionRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = UpdateSubscriptionRequestMarshaller.Instance;
options.ResponseUnmarshaller = UpdateSubscriptionResponseUnmarshaller.Instance;
return(Invoke <UpdateSubscriptionResponse>(request, options));
}
/// <summary>
/// 修改订阅
/// </summary>
public async Task <UpdateSubscriptionResponse> UpdateSubscriptionAsync(UpdateSubscriptionRequest updateSubscriptionRequest)
{
Dictionary <string, string> urlParam = new Dictionary <string, string>();
urlParam.Add("subscription_id", updateSubscriptionRequest.SubscriptionId.ToString());
string urlPath = HttpUtils.AddUrlPath("/v5/iot/{project_id}/subscriptions/{subscription_id}", urlParam);
SdkRequest request = HttpUtils.InitSdkRequest(urlPath, "application/json", updateSubscriptionRequest);
HttpResponseMessage response = await DoHttpRequestAsync("PUT", request);
return(JsonUtils.DeSerialize <UpdateSubscriptionResponse>(response));
}
public void UpdateSubscriptionRequestIsNullThrows()
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
UpdateSubscriptionRequest request = null;
// when
AsyncTestDelegate test = () => subject.UpdateAsync(request);
// then
var ex = Assert.ThrowsAsync <ArgumentNullException>(test);
Assert.That(ex.ParamName, Is.EqualTo(nameof(request)));
}
public async Task <Subscription> UpdateSubscriptionAsync(int id, UpdateSubscriptionRequest request)
{
var subscription = await GetSubscriptionAsync(id);
subscription.Name = request.Name;
subscription.ValueCoins = request.ValueCoins;
subscription.IsActive = request.IsActive;
subscription.ModifiedAt = DateTime.UtcNow;
await _uow.SubscriptionRepository.UpdateAsync(subscription, id);
await _uow.CommitAsync();
return(subscription);
}
public async Task CallsUpdateSubscriptionEndpoint()
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
var request = new UpdateSubscriptionRequest
{
Id = "SB12345678"
};
// when
await subject.UpdateAsync(request);
// then
_httpTest
.ShouldHaveCalled("https://api.gocardless.com/subscriptions")
.WithVerb(HttpMethod.Put);
}
public void UpdateSubscriptionRequestIdIsNullOrWhiteSpaceThrows(string id)
{
// given
var subject = new SubscriptionsClient(_clientConfiguration);
var request = new UpdateSubscriptionRequest
{
Id = id
};
// when
AsyncTestDelegate test = () => subject.UpdateAsync(request);
// then
var ex = Assert.ThrowsAsync <ArgumentException>(test);
Assert.That(ex.ParamName, Is.EqualTo(nameof(request.Id)));
}
public ActionResult<Subscription> UpdateSubscription([FromBody] UpdateSubscriptionRequest req)
{
var service = new SubscriptionService();
var subscription = service.Get(req.Subscription);
var options = new SubscriptionUpdateOptions
{
CancelAtPeriodEnd = false,
Items = new List<SubscriptionItemOptions>
{
new SubscriptionItemOptions
{
Id = subscription.Items.Data[0].Id,
Price = Environment.GetEnvironmentVariable(req.NewPrice),
}
}
};
var updatedSubscription = service.Update(req.Subscription, options);
return updatedSubscription;
}
public async Task ThenItShouldCallManagerWithSubscriptionDetails(string subscriptionId)
{
var request = new UpdateSubscriptionRequest
{
SubscriptionId = subscriptionId,
Publisher = _fixture.Create <string>(),
EventType = _fixture.Create <string>(),
EndpointUrl = _fixture.Create <Uri>().ToString(),
};
var httpRequest = TestHelpers.BuildRequestWithBody(request);
await _function.RunAsync(httpRequest, _cancellationToken);
_subscriptionManagerMock.Verify(m => m.UpdateSubscriptionAsync(
It.Is <Subscription>(s =>
s.Id == subscriptionId &&
s.Publisher == request.Publisher &&
s.EventType == request.EventType &&
s.EndpointUrl == request.EndpointUrl), _cancellationToken),
Times.Once);
}
public async Task UpdatesSubscriptionForMerchant()
{
// given
var accessToken = Environment.GetEnvironmentVariable("GoCardlessMerchantAccessToken");
var configuration = ClientConfiguration.ForSandbox(accessToken);
var resourceFactory = new ResourceFactory(configuration);
var mandatesClient = new MandatesClient(configuration);
var mandate = (await mandatesClient.GetPageAsync()).Items.First();
var subscription = await resourceFactory.CreateSubscriptionFor(mandate, paymentReference : null);
var request = new UpdateSubscriptionRequest
{
Id = subscription.Id,
Amount = 456,
AppFee = 34,
Metadata = new Dictionary <string, string>
{
["Key4"] = "Value4",
["Key5"] = "Value5",
["Key6"] = "Value6",
},
Name = "Updated subscription name"
};
var subject = new SubscriptionsClient(configuration);
// when
var result = await subject.UpdateAsync(request);
// then
Assert.That(result.Item.Id, Is.EqualTo(request.Id));
Assert.That(result.Item.Amount, Is.EqualTo(request.Amount));
Assert.That(result.Item.AppFee, Is.EqualTo(request.AppFee));
Assert.That(result.Item.Metadata, Is.EqualTo(request.Metadata));
Assert.That(result.Item.Name, Is.EqualTo(request.Name));
}
/// <summary>
/// Updates the specified subscription's configuration.
/// Transactions Per Minute (TPM) per-tenancy limit for this operation: 60.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <UpdateSubscriptionResponse> UpdateSubscription(UpdateSubscriptionRequest request)
{
var uri = new Uri($"{GetEndPoint(NotificationServices.Subscriptions, this.Region)}/{request.SubscriptionId}");
var httpRequestHeaderParam = new HttpRequestHeaderParam()
{
OpcRequestId = request.OpcRequestId,
IfMatch = request.IfMatch
};
var webResponse = await this.RestClientAsync.Put(uri, request.UpdateSubscriptionDetails, httpRequestHeaderParam);
using (var stream = webResponse.GetResponseStream())
using (var reader = new StreamReader(stream))
{
var response = reader.ReadToEnd();
return(new UpdateSubscriptionResponse()
{
OpcRequestId = webResponse.Headers.Get("opc-request-id"),
ETag = webResponse.Headers.Get("etag"),
UpdateSubscriptionDetails = this.JsonSerializer.Deserialize <UpdateSubscriptionDetails>(response)
});
}
}
public IHttpActionResult UpdateSubscription(UpdateSubscriptionRequest updateSubscriptionRequest)
{
var responses = new Responses();
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (Utility.UserId < 0)
{
return(BadRequest(Utility.INVALID_USER));
}
var Subscription = new Subscription()
{
SubscriptionId = updateSubscriptionRequest.SubscriptionId,
StartDate = updateSubscriptionRequest.StartDate,
PaymentDate = updateSubscriptionRequest.PaymentDate,
IsExpired = updateSubscriptionRequest.IsExpired,
IsActive = updateSubscriptionRequest.IsActive,
ModifiedBy = Utility.UserId
};
int result = iSubscription.UpdateSubscription(Subscription);
switch (result)
{
case -2:
responses.Status = Utility.ERROR_STATUS_RESPONSE;
responses.Description = "Subscription already exists.";
break;
case -3:
responses.Status = Utility.ERROR_STATUS_RESPONSE;
responses.Description = "Subscription doesn't exist.";
break;
default:
if (result > 0)
{
string userName = string.Empty;
var userProfile = new UserProfile()
{
UserId = updateSubscriptionRequest.UserId
};
var userProfiles = iUserProfile.GetUserProfile(userProfile);
if (userProfiles != null)
{
userName = userProfiles.First().UserName;
var SubscriptionEmailHtmlCode = System.IO.File.ReadAllText(string.Format("{0}", HttpContext.Current.Server.MapPath(string.Format("{0}{1}", ConfigurationManager.AppSettings["EmailTemplatePath"], (updateSubscriptionRequest.StartDate != null ? ConfigurationManager.AppSettings["SubscriptionUpdateEmailTemplateForUser"] : ConfigurationManager.AppSettings["UnsubscriptionEmailTemplateForUser"])))));
var mainTemplateHtmlCode = System.IO.File.ReadAllText(string.Format("{0}", HttpContext.Current.Server.MapPath(string.Format("{0}{1}", ConfigurationManager.AppSettings["EmailTemplatePath"], ConfigurationManager.AppSettings["MainEmailTemplate"]))));
mainTemplateHtmlCode = mainTemplateHtmlCode.Replace("[SITEURL]", ConfigurationManager.AppSettings["SiteUrl"]);
mainTemplateHtmlCode = mainTemplateHtmlCode.Replace("[SITENAME]", ConfigurationManager.AppSettings["SiteName"]);
mainTemplateHtmlCode = mainTemplateHtmlCode.Replace("[PAGECONTENT]", SubscriptionEmailHtmlCode);
string subject = "Subscription | Demystify Fema";
string body = mainTemplateHtmlCode;
string displayName = ConfigurationManager.AppSettings["SiteName"];
string emailTo = userName;
bool isMailSentToUser = Utility.SendMail(emailTo, string.Empty, string.Empty, subject, body, displayName, string.Empty, true);
try
{
var subscriptionHistory = new SubscriptionHistory()
{
SubscriptionHistoryId = result,
IsMailSentToUser = isMailSentToUser,
ModifiedBy = Utility.UserId
};
iSubscription.UpdateSubscriptionHistoryMailSent(subscriptionHistory);
}
catch (Exception ex)
{
Utility.WriteLog("AddSubscription", updateSubscriptionRequest, "Error while updating Subscription History mail sent. (SubscriptionUserController)", ex.ToString());
}
}
responses.Status = Utility.SUCCESS_STATUS_RESPONSE;
responses.Description = "Subscription updated successfully.";
}
else
{
responses.Status = Utility.ERROR_STATUS_RESPONSE;
responses.Description = "Error while updating Subscription.";
}
break;
}
}
catch (Exception ex)
{
responses.Status = Utility.ERROR_STATUS_RESPONSE;
responses.Description = "Error while updating Subscription.";
Utility.WriteLog("UpdateSubscription", updateSubscriptionRequest, "Error while updating Subscription. (SubscriptionAdminController)", ex.ToString());
}
return(Ok(responses));
}
/// <summary>
/// Update a subscription
/// </summary>
public static void UpdateSubscription(UpdateSubscriptionRequest request, Action <UpdateSubscriptionResult> resultCallback, Action <PlayFabError> errorCallback, object customData = null, Dictionary <string, string> extraHeaders = null)
{
PlayFabHttp.MakeApiCall("/Catalog/UpdateSubscription", request, AuthType.EntityToken, resultCallback, errorCallback, customData, extraHeaders);
}
public ActionResult <UpdateSubscriptionResponse> UpdateSubscription([FromBody] UpdateSubscriptionRequest req)
{
if (!ModelState.IsValid)
{
return(this.FailWithMessage("invalid params"));
}
var newPrice = Environment.GetEnvironmentVariable(req.NewPrice);
if (newPrice is null || newPrice == "")
{
return(this.FailWithMessage($"No price with the new price ID ({req.NewPrice}) found in .env"));
}
var service = new SubscriptionService();
Subscription subscription;
try
{
subscription = service.Get(req.Subscription);
}
catch (StripeException e)
{
return(this.FailWithMessage($"Failed to retrieve subscription: {e}"));
}
var currentPrice = subscription.Items.Data[0].Price.Id;
List <SubscriptionItemOptions> items;
if (currentPrice == newPrice)
{
items = new List <SubscriptionItemOptions>
{
new SubscriptionItemOptions
{
Id = subscription.Items.Data[0].Id,
Quantity = req.Quantity,
},
};
}
else
{
items = new List <SubscriptionItemOptions>
{
new SubscriptionItemOptions
{
Id = subscription.Items.Data[0].Id,
Deleted = true,
},
new SubscriptionItemOptions
{
Price = newPrice,
Quantity = req.Quantity,
},
};
}
var options = new SubscriptionUpdateOptions
{
CancelAtPeriodEnd = false,
Items = items,
ProrationBehavior = "always_invoice",
};
var updatedSubscription = service.Update(req.Subscription, options);
return(new UpdateSubscriptionResponse
{
Subscription = updatedSubscription,
});
}
public async Task <ApiResponse <UpdateSubscriptionResponse> > UpdateSubscriptionAsync(UpdateSubscriptionRequest request)
{
var updateResponse = new ApiResponse <UpdateSubscriptionResponse>(new UpdateSubscriptionResponse());
_httpClient.DefaultRequestHeaders.Clear();
_httpClient.DefaultRequestHeaders.Add(ConstantString.AuthorizationKey, string.Format(ConstantString.AuthorizationValue, request.AccessToken));
var subsBody = JsonConvert.SerializeObject(request.UpdatingSubscription);
var updatingSubsContent = new StringContent(subsBody);
updatingSubsContent.Headers.ContentType = new MediaTypeHeaderValue(ConstantString.JsonContentTypeValue);
var subsRequest = await _httpClient.PutAsync(ConstantString.SubscriptionSuffix + "/" + request.SubscriptionId, updatingSubsContent).ConfigureAwait(false);
var content = await subsRequest.Content.ReadAsStringAsync().ConfigureAwait(false);
updateResponse.StatusCode = subsRequest.StatusCode;
updateResponse.Headers = subsRequest.Headers.ToDictionary(x => x.Key, x => x.Value.ToString());
updateResponse.Body = JsonConvert.DeserializeObject <UpdateSubscriptionResponse>(content);
return(updateResponse);
}
public UpdateSubscriptionResponse UpdateSubscription(UpdateSubscriptionRequest request)
{
return(Execute(() => InternalService.UpdateSubscription(request)));
}
public UpdateSubscriptionResponse UpdateSubscription(UpdateSubscriptionRequest request)
{
return(ExecuteAction <UpdateSubscriptionResponse>(request));
}
