public async stt::Task CreateBudgetRequestObjectAsync()
{
moq::Mock <BudgetService.BudgetServiceClient> mockGrpcClient = new moq::Mock <BudgetService.BudgetServiceClient>(moq::MockBehavior.Strict);
CreateBudgetRequest request = new CreateBudgetRequest
{
ParentAsBillingAccountName = gagr::BillingAccountName.FromBillingAccount("[BILLING_ACCOUNT]"),
Budget = new Budget(),
};
Budget expectedResponse = new Budget
{
BudgetName = BudgetName.FromBillingAccountBudget("[BILLING_ACCOUNT]", "[BUDGET]"),
DisplayName = "display_name137f65c2",
BudgetFilter = new Filter(),
Amount = new BudgetAmount(),
ThresholdRules =
{
new ThresholdRule(),
},
AllUpdatesRule = new AllUpdatesRule(),
Etag = "etage8ad7218",
};
mockGrpcClient.Setup(x => x.CreateBudgetAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Budget>(stt::Task.FromResult(expectedResponse), null, null, null, null));
BudgetServiceClient client = new BudgetServiceClientImpl(mockGrpcClient.Object, null);
Budget responseCallSettings = await client.CreateBudgetAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Budget responseCancellationToken = await client.CreateBudgetAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
/// <summary>
/// Creates a new Budget.
///
/// </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/budget/CreateBudget.cs.html">here</a> to see an example of how to use CreateBudget API.</example>
public async Task <CreateBudgetResponse> CreateBudget(CreateBudgetRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called createBudget");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/budgets".Trim('/')));
HttpMethod method = new HttpMethod("POST");
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 <CreateBudgetResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"CreateBudget failed with error: {e.Message}");
throw;
}
}
/// <summary>
/// Creates a budget and, if included, notifications and subscribers.
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the CreateBudget service method.</param>
///
/// <returns>The response from the CreateBudget service method, as returned by Budgets.</returns>
/// <exception cref="Amazon.Budgets.Model.CreationLimitExceededException">
/// You've exceeded the notification or subscriber limit.
/// </exception>
/// <exception cref="Amazon.Budgets.Model.DuplicateRecordException">
/// The budget name already exists. Budget names must be unique within an account.
/// </exception>
/// <exception cref="Amazon.Budgets.Model.InternalErrorException">
/// An error on the server occurred during the processing of your request. Try again later.
/// </exception>
/// <exception cref="Amazon.Budgets.Model.InvalidParameterException">
/// An error on the client occurred. Typically, the cause is an invalid input value.
/// </exception>
public virtual CreateBudgetResponse CreateBudget(CreateBudgetRequest request)
{
var marshaller = CreateBudgetRequestMarshaller.Instance;
var unmarshaller = CreateBudgetResponseUnmarshaller.Instance;
return(Invoke <CreateBudgetRequest, CreateBudgetResponse>(request, marshaller, unmarshaller));
}
public async Task <JsonResult> CreateBudget([FromBody] CreateBudgetRequest body)
{
CreateBudgetCommand command = new CreateBudgetCommand(this.unitOfWork, body.ParentBudgetId, body.Name, body.SetAmount);
await command.Run();
return(new JsonResult(new { success = true }));
}
public virtual CreateBudgetResponse CreateBudget(CreateBudgetRequest request)
{
var response = new CreateBudgetResponse();
try {
// Raise Initialization Event
var initialization = CreateBudgetInitialization;
if (initialization != null)
{
initialization(request, response);
}
// Raise Execute Event
var execute = CreateBudgetExecute;
if (execute != null)
{
response = execute(request);
}
// Raise Complete Event
var complete = CreateBudgetComplete;
if (complete != null)
{
complete(request, response);
}
}
catch (Exception exception) {
// Raise Error Event
var error = CreateBudgetError;
if (error != null)
{
error(request, response, exception);
}
}
return(response);
}
public void CreateBudgetRequestObject()
{
moq::Mock <BudgetService.BudgetServiceClient> mockGrpcClient = new moq::Mock <BudgetService.BudgetServiceClient>(moq::MockBehavior.Strict);
CreateBudgetRequest request = new CreateBudgetRequest
{
ParentAsBillingAccountName = gagr::BillingAccountName.FromBillingAccount("[BILLING_ACCOUNT]"),
Budget = new Budget(),
};
Budget expectedResponse = new Budget
{
BudgetName = BudgetName.FromBillingAccountBudget("[BILLING_ACCOUNT]", "[BUDGET]"),
DisplayName = "display_name137f65c2",
BudgetFilter = new Filter(),
Amount = new BudgetAmount(),
ThresholdRules =
{
new ThresholdRule(),
},
AllUpdatesRule = new AllUpdatesRule(),
Etag = "etage8ad7218",
};
mockGrpcClient.Setup(x => x.CreateBudget(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
BudgetServiceClient client = new BudgetServiceClientImpl(mockGrpcClient.Object, null);
Budget response = client.CreateBudget(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
internal CreateBudgetResponse CreateBudget(CreateBudgetRequest request)
{
var marshaller = new CreateBudgetRequestMarshaller();
var unmarshaller = CreateBudgetResponseUnmarshaller.Instance;
return(Invoke <CreateBudgetRequest, CreateBudgetResponse>(request, marshaller, unmarshaller));
}
/// <summary>
/// Initiates the asynchronous execution of the CreateBudget operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateBudget 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 virtual Task <CreateBudgetResponse> CreateBudgetAsync(CreateBudgetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = CreateBudgetRequestMarshaller.Instance;
var unmarshaller = CreateBudgetResponseUnmarshaller.Instance;
return(InvokeAsync <CreateBudgetRequest, CreateBudgetResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
/// <summary>
/// Creates a budget and, if included, notifications and subscribers.
///
/// <important>
/// <para>
/// Only one of <code>BudgetLimit</code> or <code>PlannedBudgetLimits</code> can be present
/// in the syntax at one time. Use the syntax that matches your case. The Request Syntax
/// section shows the <code>BudgetLimit</code> syntax. For <code>PlannedBudgetLimits</code>,
/// see the <a href="https://docs.aws.amazon.com/aws-cost-management/latest/APIReference/API_budgets_CreateBudget.html#API_CreateBudget_Examples">Examples</a>
/// section.
/// </para>
/// </important>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the CreateBudget 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 CreateBudget service method, as returned by Budgets.</returns>
/// <exception cref="Amazon.Budgets.Model.AccessDeniedException">
/// You are not authorized to use this operation with the given parameters.
/// </exception>
/// <exception cref="Amazon.Budgets.Model.CreationLimitExceededException">
/// You've exceeded the notification or subscriber limit.
/// </exception>
/// <exception cref="Amazon.Budgets.Model.DuplicateRecordException">
/// The budget name already exists. Budget names must be unique within an account.
/// </exception>
/// <exception cref="Amazon.Budgets.Model.InternalErrorException">
/// An error on the server occurred during the processing of your request. Try again later.
/// </exception>
/// <exception cref="Amazon.Budgets.Model.InvalidParameterException">
/// An error on the client occurred. Typically, the cause is an invalid input value.
/// </exception>
public virtual Task <CreateBudgetResponse> CreateBudgetAsync(CreateBudgetRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateBudgetRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateBudgetResponseUnmarshaller.Instance;
return(InvokeAsync <CreateBudgetResponse>(request, options, cancellationToken));
}
internal virtual CreateBudgetResponse CreateBudget(CreateBudgetRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateBudgetRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateBudgetResponseUnmarshaller.Instance;
return(Invoke <CreateBudgetResponse>(request, options));
}
/// <summary>Snippet for CreateBudget</summary>
/// <remarks>
/// This snippet has been automatically generated for illustrative purposes only.
/// It may require modifications to work in your environment.
/// </remarks>
public void CreateBudgetRequestObject()
{
// Create client
BudgetServiceClient budgetServiceClient = BudgetServiceClient.Create();
// Initialize request argument(s)
CreateBudgetRequest request = new CreateBudgetRequest
{
ParentAsBillingAccountName = BillingAccountName.FromBillingAccount("[BILLING_ACCOUNT]"),
Budget = new Budget(),
};
// Make the request
Budget response = budgetServiceClient.CreateBudget(request);
}
public override CreateBudgetResponse OnCreateBudgetExecute(CreateBudgetRequest request)
{
var budgetFactory = new BudgetFactory();
var response = new CreateBudgetResponse();
try
{
response.CreateBudget = budgetFactory.CreateBudget(request.Items, request.ClientCode, request.CnpjCpf, false, false);
}
catch (Exception ex)
{
response.Exception = ex;
response.Message = ex.Message;
}
return(response);
}
/// <summary>Snippet for CreateBudgetAsync</summary>
public async Task CreateBudgetRequestObjectAsync()
{
// Snippet: CreateBudgetAsync(CreateBudgetRequest, CallSettings)
// Additional: CreateBudgetAsync(CreateBudgetRequest, CancellationToken)
// Create client
BudgetServiceClient budgetServiceClient = await BudgetServiceClient.CreateAsync();
// Initialize request argument(s)
CreateBudgetRequest request = new CreateBudgetRequest
{
ParentAsBillingAccountName = BillingAccountName.FromBillingAccount("[BILLING_ACCOUNT]"),
Budget = new Budget(),
};
// Make the request
Budget response = await budgetServiceClient.CreateBudgetAsync(request);
// End snippet
}
protected override void ProcessRecord()
{
base.ProcessRecord();
CreateBudgetRequest request;
try
{
request = new CreateBudgetRequest
{
CreateBudgetDetails = CreateBudgetDetails,
OpcRetryToken = OpcRetryToken,
OpcRequestId = OpcRequestId
};
response = client.CreateBudget(request).GetAwaiter().GetResult();
WriteOutput(response, response.Budget);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
/// <summary>
/// Creates a new Budget.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public CreateBudgetResponse CreateBudget(CreateBudgetRequest request)
{
var uri = new Uri($"{GetEndPoint(BudgetsServices.Budgets, this.Region, "oci.oraclecloud.com")}");
var httpRequestHeaderParam = new HttpRequestHeaderParam()
{
OpcRetryToken = request.OpcRetryToken,
OpcRequestId = request.OpcRequestId
};
using (var webResponse = this.RestClient.Post(uri, request.CreateBudgetDetails, httpRequestHeaderParam))
using (var stream = webResponse.GetResponseStream())
using (var reader = new StreamReader(stream))
{
var response = reader.ReadToEnd();
return(new CreateBudgetResponse()
{
Budget = JsonSerializer.Deserialize <BudgetDetails>(response),
OpcRequestId = webResponse.Headers.Get("opc-request-id"),
Etag = webResponse.Headers.Get("etag")
});
}
}
public async Task <IActionResult> CreateBudget([FromBody] CreateBudgetRequest payload, CancellationToken cancellationToken)
{
await _createBudgetCommand.Value.ExecuteAsync(payload, HttpContext.User, cancellationToken);
return(Ok());
}
public abstract CreateBudgetResponse OnCreateBudgetExecute(CreateBudgetRequest request);
