protected override void ProcessRecord()
{
try
{
string mfaDevice = Environment.GetEnvironmentVariable("DEVOPS_AWS_MFA_DEVICE");
string devopsAccessKey = Environment.GetEnvironmentVariable("DEVOPS_AWS_ACCESS_KEY_ID");
string devopsSecretKey = Environment.GetEnvironmentVariable("DEVOPS_AWS_SECRET_ACCESS_KEY");
AmazonSecurityTokenServiceClient stsClient = string.IsNullOrEmpty(devopsAccessKey)
? new AmazonSecurityTokenServiceClient()
: new AmazonSecurityTokenServiceClient(new BasicAWSCredentials(devopsAccessKey, devopsSecretKey));
using (stsClient)
{
GetSessionTokenRequest request = new GetSessionTokenRequest
{
DurationSeconds = Duration,
SerialNumber = mfaDevice,
TokenCode = MFAToken
};
Task <GetSessionTokenResponse> response = stsClient.GetSessionTokenAsync(request);
response.Wait(1000);
WriteObject(response.Result.Credentials);
}
}
catch (Exception exception)
{
ThrowTerminatingError(new ErrorRecord(new Exception("Error getting session token", exception), "Error getting session token", ErrorCategory.InvalidOperation, null));
}
}
internal GetSessionTokenResponse GetSessionToken(GetSessionTokenRequest request)
{
var marshaller = new GetSessionTokenRequestMarshaller();
var unmarshaller = GetSessionTokenResponseUnmarshaller.Instance;
return(Invoke <GetSessionTokenRequest, GetSessionTokenResponse>(request, marshaller, unmarshaller));
}
public void TestGetSessionTokenRegional()
{
using (var uswest2Client = TestBase.CreateClient <AmazonSecurityTokenServiceClient>(endpoint: RegionEndpoint.USWest2))
{
var gstRequest = new GetSessionTokenRequest()
{
DurationSeconds = 3600
};
var gstResult = uswest2Client.GetSessionTokenAsync(gstRequest).Result;
Assert.IsNotNull(gstResult.Credentials.AccessKeyId);
Assert.IsNotNull(gstResult.Credentials.SecretAccessKey);
Assert.IsNotNull(gstResult.Credentials.SessionToken);
Assert.IsNotNull(gstResult.Credentials.Expiration);
var time = DateTime.Now;
var approximateExpires = time.AddHours(1);
var expiresAfter = approximateExpires.AddMinutes(-5);
var expiresBefore = approximateExpires.AddMinutes(5);
var expires = gstResult.Credentials.Expiration;
Assert.IsTrue(expires > expiresAfter);
Assert.IsTrue(expires < expiresBefore);
}
}
internal GetSessionTokenResponse GetSessionToken(GetSessionTokenRequest request)
{
GetSessionTokenRequestMarshaller getSessionTokenRequestMarshaller = new GetSessionTokenRequestMarshaller();
GetSessionTokenResponseUnmarshaller instance = GetSessionTokenResponseUnmarshaller.Instance;
return(this.Invoke <GetSessionTokenRequest, GetSessionTokenResponse>(request, getSessionTokenRequestMarshaller, instance));
}
public void TestGetSessionTokenAsync()
{
var gstRequest = new GetSessionTokenRequest()
{
DurationSeconds = 3600
};
GetSessionTokenResponse asyncResponse = null;
var task = Client.GetSessionTokenAsync(gstRequest);
asyncResponse = task.Result;
UtilityMethods.Sleep(TimeSpan.FromSeconds(5));
Assert.IsNotNull(asyncResponse);
var gstResult = asyncResponse;
Assert.IsNotNull(gstResult);
Assert.IsNotNull(gstResult.Credentials.AccessKeyId);
Assert.IsNotNull(gstResult.Credentials.SecretAccessKey);
Assert.IsNotNull(gstResult.Credentials.SessionToken);
Assert.IsNotNull(gstResult.Credentials.Expiration);
var time = DateTime.Now;
var approximateExpires = time.AddHours(1);
var expiresAfter = approximateExpires.AddMinutes(-5);
var expiresBefore = approximateExpires.AddMinutes(5);
var expires = gstResult.Credentials.Expiration;
Assert.IsTrue(expires > expiresAfter);
Assert.IsTrue(expires < expiresBefore);
}
/// <summary>
/// Initiates the asynchronous execution of the GetSessionToken operation.
/// <seealso cref="Amazon.SecurityToken.IAmazonSecurityTokenService"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetSessionToken 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 <GetSessionTokenResponse> GetSessionTokenAsync(GetSessionTokenRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetSessionTokenRequestMarshaller();
var unmarshaller = GetSessionTokenResponseUnmarshaller.Instance;
return(Invoke <IRequest, GetSessionTokenRequest, GetSessionTokenResponse>(request, marshaller, unmarshaller, signer, cancellationToken));
}
public Credentials GetSessionToken(AWSCredentials credentials)
{
Credentials sessionCredentials = null;
using (var stsClient = new AmazonSecurityTokenServiceClient(credentials))
{
try
{
var getSessionTokenRequest = new GetSessionTokenRequest()
{
DurationSeconds = 7200
};
GetSessionTokenResponse response = stsClient.GetSessionToken(getSessionTokenRequest);
sessionCredentials = response.Credentials;
}
catch (Exception ex)
{
throw ex;
}
}
return(sessionCredentials);
}
private async Task <Credentials> GetTemporaryCredentials(
string accessKeyId, string secretAccessKeyId)
{
AmazonSecurityTokenServiceClient stsClient =
new AmazonSecurityTokenServiceClient(accessKeyId,
secretAccessKeyId);
GetSessionTokenRequest getSessionTokenRequest =
new GetSessionTokenRequest();
getSessionTokenRequest.DurationSeconds = 7200; // seconds
GetSessionTokenResponse sessionTokenResponse =
await stsClient.GetSessionTokenAsync(getSessionTokenRequest);
Credentials credentials = sessionTokenResponse.Credentials;
//SessionAWSCredentials sessionCredentials =
// new SessionAWSCredentials(credentials.AccessKeyId,
// credentials.SecretAccessKey,
// credentials.SessionToken);
return(credentials);
}
/// <summary>
/// <para>
/// Get a set of temporary security credentials representing your account.
/// </para>
/// <para>
/// An extra ACL string can be set in the request, which specify permissions for the returning credentials.
/// </para>
/// </summary>
/// <param name="request"> The GetSessionTokenRequest object that specifies all the parameters of this
/// operation. </param>
public GetSessionTokenResponse GetSessionToken(GetSessionTokenRequest request)
{
CheckNotNull(request, "request should not be null.");
InternalRequest internalRequest = this.CreateInternalRequest(
request, BceConstants.HttpMethod.Post, new string[] { UrlPrefix, "sessionToken" });
if (request.DurationSeconds.HasValue)
{
internalRequest.Parameters["durationSeconds"] = request.DurationSeconds.ToString();
}
if (request.AccessControlList != null)
{
FillRequestBodyForJson(internalRequest, request.AccessControlList);
}
return(internalRequest.Config.RetryPolicy.Execute(attempt =>
{
var httpWebResponse = this.httpClient.Execute(internalRequest);
using (httpWebResponse)
{
return ToObject <GetSessionTokenResponse>(httpWebResponse);
}
}));
}
/// <summary>
/// </summary>
///
/// <param name="getSessionTokenRequest">Container for the necessary parameters to execute the GetSessionToken service method on
/// AmazonSecurityTokenService.</param>
///
/// <returns>The response from the GetSessionToken service method, as returned by AmazonSecurityTokenService.</returns>
///
public GetSessionTokenResponse GetSessionToken(GetSessionTokenRequest getSessionTokenRequest)
{
IRequest <GetSessionTokenRequest> request = new GetSessionTokenRequestMarshaller().Marshall(getSessionTokenRequest);
GetSessionTokenResponse response = Invoke <GetSessionTokenRequest, GetSessionTokenResponse> (request, this.signer, GetSessionTokenResponseUnmarshaller.GetInstance());
return(response);
}
private async Task EC2Instance(AssetScanCompletedEvent request)
{
IAmazonSecurityTokenService STSClient = new AmazonSecurityTokenServiceClient("AKIAXMJHA33LOQPJKCXO", "t1EvatLh4zIl7cBNyGR8rEE2k1vgKOiiDu6wg8IT", RegionEndpoint.USEast2);
using (var client = STSClient)
{
GetSessionTokenRequest getSessionTokenRequest = new GetSessionTokenRequest()
{
DurationSeconds = 900
};
GetSessionTokenResponse tokenResponse = await client.GetSessionTokenAsync(getSessionTokenRequest);
//Console.WriteLine("SecretAccessKey: "+tokenResponse.Credentials.SecretAccessKey+" \n AccessKeyId: "+tokenResponse.Credentials.AccessKeyId+"\n SessionToken: "+tokenResponse.Credentials.SessionToken+" \n Expiration: "+tokenResponse.Credentials.Expiration);
var response = STSClient.AssumeRoleAsync(new AssumeRoleRequest
{
RoleArn = "arn:aws:iam::507424857814:role/DemoEC2",
RoleSessionName = "EC2User",
DurationSeconds = 900
});
var tempCredentials = new SessionAWSCredentials
(
response.Result.Credentials.AccessKeyId,
response.Result.Credentials.SecretAccessKey,
response.Result.Credentials.SessionToken
);
// var test= new BasicAWSCredentials("AKIAXMJHA33LOQPJKCXO","t1EvatLh4zIl7cBNyGR8rEE2k1vgKOiiDu6wg8IT");
//Console.WriteLine("SecretAccessKey: " + response.Result.Credentials.SecretAccessKey + " \n AccessKey: " + response.Result.Credentials.AccessKeyId + " \n SessionToken: " + response.Result.Credentials.SessionToken + " \n Expiration: " + response.Result.Credentials.Expiration);
//await Task.Delay(900500);
//Console.WriteLine("Afetr 15 minute .......");
IAmazonEC2 ec2 = new AmazonEC2Client(tempCredentials, Amazon.RegionEndpoint.USEast2);
//Amazon.Util.EC2InstanceMetadata.Hostname;
// list of Instance
var result = await ec2.DescribeInstancesAsync();
// Console.WriteLine("\n List of Instance");
foreach (var reservation in result.Reservations)
{
foreach (var instance in reservation.Instances)
{
_logger.LogInformation("EC2 for instance ID {0} {1} {2}", request.ScanID, instance.InstanceId, instance.InstanceType);
//Console.WriteLine(instance.InstanceId);
}
}
//Console.WriteLine("\n Get by InstanceID");
//var response2 = ec2.DescribeInstancesAsync(new DescribeInstancesRequest
//{
// InstanceIds = new List<string>
// {
// "i-0e76148b03298009a"
// }
//});
//Console.WriteLine(response2.Result.HttpStatusCode);
}
}
/// <summary>
/// Initiates the asynchronous execution of the GetSessionToken operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetSessionToken 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/sts-2011-06-15/GetSessionToken">REST API Reference for GetSessionToken Operation</seealso>
public virtual Task <GetSessionTokenResponse> GetSessionTokenAsync(GetSessionTokenRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = GetSessionTokenRequestMarshaller.Instance;
var unmarshaller = GetSessionTokenResponseUnmarshaller.Instance;
return(InvokeAsync <GetSessionTokenRequest, GetSessionTokenResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
public void TestChecksumWithMd5Algorithm()
{
var getSessionTokenRequest = new GetSessionTokenRequest(validMerchantInfoMd5Algo);
var response = requestExecutor.GetSessionToken(getSessionTokenRequest).GetAwaiter().GetResult();
Assert.IsTrue(response.ErrorType != ErrorType.InvalidChecksum);
}
private static async Task Main(string[] args)
{
var credentials = new BasicAWSCredentials("censored", "censored");
var client = new AmazonSecurityTokenServiceClient(credentials);
var request = new GetSessionTokenRequest {
DurationSeconds = 900
};
var response = await client.GetSessionTokenAsync(request);
Console.WriteLine(response.Credentials.AccessKeyId);
Console.WriteLine(response.Credentials.SecretAccessKey);
var credentials2 = response.Credentials;
var client2 = new AmazonSecurityTokenServiceClient(credentials2);
var req = new AssumeRoleRequest();
req.DurationSeconds = 900;
req.RoleArn = "arn:aws:s3:::my-test-bucket-coolrocket";
req.RoleSessionName = "user1";
//var x = await client2.AssumeRoleAsync(req);
var s3client = new AmazonS3Client(response.Credentials, RegionEndpoint.EUCentral1);
var r = new GetObjectRequest();
r.BucketName = "my-test-bucket-coolrocket";
r.Key = "user1/big_buck_bunny.mp4";
//r.Path = "user1/big_buck_bunny.mp4";
var temp = await s3client.GetObjectAsync(r);
//using (var client = new AmazonMediaStoreClient(credentials, RegionEndpoint.EUCentral1))
//using (var storeDataClient = await CreateStoreDataClientAsync(client: client, containerName: "test", credentials: credentials))
//{
// //var user = await CreateIamUserAsync(credentials, "zero");
// //await DeleteIamUserAsync(credentials, "zero");
// //await DeleteObjectFromContainerAsync(storeDataClient, "id3/sample.mp4");
// var t = await GetContainerPolicyAsync(client, "test");
// //await PutObjectToContainerAsync(storeDataClient, "path2/sample.mp4");
// //var stream = await GetObjectAsync(storeDataClient, "path1/sample.mp4");
//}
Console.ReadKey();
}
/// <summary>
/// Initiates the asynchronous execution of the GetSessionToken operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetSessionToken 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/sts-2011-06-15/GetSessionToken">REST API Reference for GetSessionToken Operation</seealso>
public virtual Task <GetSessionTokenResponse> GetSessionTokenAsync(GetSessionTokenRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = GetSessionTokenRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetSessionTokenResponseUnmarshaller.Instance;
return(InvokeAsync <GetSessionTokenResponse>(request, options, cancellationToken));
}
IAsyncResult invokeGetSessionToken(GetSessionTokenRequest getSessionTokenRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new GetSessionTokenRequestMarshaller().Marshall(getSessionTokenRequest);
var unmarshaller = GetSessionTokenResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return(result);
}
internal virtual GetSessionTokenResponse GetSessionToken(GetSessionTokenRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = GetSessionTokenRequestMarshaller.Instance;
options.ResponseUnmarshaller = GetSessionTokenResponseUnmarshaller.Instance;
return(Invoke <GetSessionTokenResponse>(request, options));
}
private string GetSessionToken()
{
var request = new GetSessionTokenRequest(merchantInfo);
var response = this.safechargeRequestExecutor.GetSessionToken(request).GetAwaiter().GetResult();
if (response.Status == ResponseStatus.Error)
{
throw new SafechargeConfigurationException(response.Reason);
}
return(response.SessionToken);
}
internal GetSessionTokenResponse GetSessionToken(GetSessionTokenRequest request)
{
var task = GetSessionTokenAsync(request);
try
{
return(task.Result);
}
catch (AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return(null);
}
}
public virtual void Setup()
{
requestExecutor = new SafechargeRequestExecutor();
merchantInfo = new MerchantInfo(
MerchantKeyValue,
MerchantIdValue,
MerchantSiteIdValue,
ServerHostValue,
HashAlgorithmType.SHA256);
var getSessionTokenRequest = new GetSessionTokenRequest(merchantInfo);
var response = requestExecutor.GetSessionToken(getSessionTokenRequest).GetAwaiter().GetResult();
sessionToken = response.SessionToken;
}
public void TestCreatingInvalidServerHost()
{
var merchantInfo = new MerchantInfo(
MerchantKeyValue,
MerchantIdValue,
MerchantSiteIdValue,
ApiConstants.IntegrationHost + "invalid",
HashAlgorithmType.SHA256);
var getSessionTokenRequest = new GetSessionTokenRequest(merchantInfo);
ActualValueDelegate <object> getSessionTokenRequestDelegate =
() => requestExecutor.GetSessionToken(getSessionTokenRequest).GetAwaiter().GetResult();
Assert.That(getSessionTokenRequestDelegate, Throws.TypeOf <SafechargeException>());
}
/// <summary>
/// Initiates the asynchronous execution of the GetSessionToken operation.
/// <seealso cref="Amazon.SecurityToken.IAmazonSecurityTokenService"/>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the GetSessionToken operation.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes</param>
/// <returns>void</returns>
public void GetSessionTokenAsync(GetSessionTokenRequest request, AmazonServiceCallback callback, object state)
{
if (!AmazonInitializer.IsInitialized)
{
throw new Exception("AWSPrefab is not added to the scene");
}
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate
{
var marshaller = new GetSessionTokenRequestMarshaller();
var unmarshaller = GetSessionTokenResponseUnmarshaller.Instance;
Invoke(request, callback, state, marshaller, unmarshaller, signer);
}));
return;
}
private static async Task <SessionAWSCredentials> GetTemporaryCredentialsAsync()
{
using (var stsClient = new AmazonSecurityTokenServiceClient())
{
var getSessionTokenRequest = new GetSessionTokenRequest
{
DurationSeconds = 900
};
var sessionTokenResponse = await stsClient.GetSessionTokenAsync(getSessionTokenRequest);
var credentials = sessionTokenResponse.Credentials;
return(new SessionAWSCredentials(credentials.AccessKeyId, credentials.SecretAccessKey,
credentials.SessionToken));
}
}
protected virtual async Task <SessionAWSCredentials> GetTemporaryCredentialsAsync(
AwsBlobProviderConfiguration configuration)
{
var temporaryCredentialsCache = await Cache.GetAsync(configuration.TemporaryCredentialsCacheKey);
if (temporaryCredentialsCache == null)
{
AmazonSecurityTokenServiceClient stsClient;
if (!configuration.AccessKeyId.IsNullOrEmpty() && !configuration.SecretAccessKey.IsNullOrEmpty())
{
stsClient = new AmazonSecurityTokenServiceClient(configuration.AccessKeyId,
configuration.SecretAccessKey);
}
else
{
var awsCredentials = GetAwsCredentials(configuration);
stsClient = awsCredentials == null
? new AmazonSecurityTokenServiceClient()
: new AmazonSecurityTokenServiceClient(awsCredentials);
}
using (stsClient)
{
var getSessionTokenRequest = new GetSessionTokenRequest
{
DurationSeconds = configuration.DurationSeconds
};
var sessionTokenResponse =
await stsClient.GetSessionTokenAsync(getSessionTokenRequest);
var credentials = sessionTokenResponse.Credentials;
temporaryCredentialsCache =
await SetTemporaryCredentialsCache(configuration, credentials);
}
}
var sessionCredentials = new SessionAWSCredentials(
StringEncryptionService.Decrypt(temporaryCredentialsCache.AccessKeyId),
StringEncryptionService.Decrypt(temporaryCredentialsCache.SecretAccessKey),
StringEncryptionService.Decrypt(temporaryCredentialsCache.SessionToken));
return(sessionCredentials);
}
public void GetSessionTokenAsync(GetSessionTokenRequest request, AmazonServiceCallback <GetSessionTokenRequest, GetSessionTokenResponse> callback, AsyncOptions options = null)
{
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
options = ((options == null) ? ((object)new AsyncOptions()) : ((object)options));
GetSessionTokenRequestMarshaller getSessionTokenRequestMarshaller = new GetSessionTokenRequestMarshaller();
GetSessionTokenResponseUnmarshaller instance = GetSessionTokenResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> action = null;
if (callback != null)
{
action = delegate(AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao)
{
AmazonServiceResult <GetSessionTokenRequest, GetSessionTokenResponse> val = new AmazonServiceResult <GetSessionTokenRequest, GetSessionTokenResponse>((GetSessionTokenRequest)req, (GetSessionTokenResponse)res, ex, ao.get_State());
callback.Invoke(val);
};
}
this.BeginInvoke <GetSessionTokenRequest>(request, getSessionTokenRequestMarshaller, instance, options, action);
}
public void TestGetSessionTokenAsync()
{
var gstRequest = new GetSessionTokenRequest()
{
DurationSeconds = 3600
};
GetSessionTokenResponse asyncResponse = null;
#if ASYNC_AWAIT
var task = Client.GetSessionTokenAsync(gstRequest);
asyncResponse = task.Result;
#else
var asyncResult = Client.BeginGetSessionToken(gstRequest,
ar =>
{
var client = ar.AsyncState as AmazonSecurityTokenServiceClient;
asyncResponse = client.EndGetSessionToken(ar);
}
, Client);
asyncResult.AsyncWaitHandle.WaitOne();
#endif
Thread.Sleep(TimeSpan.FromSeconds(5));
Assert.IsNotNull(asyncResponse);
var gstResult = asyncResponse;
Assert.IsNotNull(gstResult);
Assert.IsNotNull(gstResult.Credentials.AccessKeyId);
Assert.IsNotNull(gstResult.Credentials.SecretAccessKey);
Assert.IsNotNull(gstResult.Credentials.SessionToken);
Assert.IsNotNull(gstResult.Credentials.Expiration);
var time = DateTime.Now;
var approximateExpires = time.AddHours(1);
var expiresAfter = approximateExpires.AddMinutes(-5);
var expiresBefore = approximateExpires.AddMinutes(5);
var expires = gstResult.Credentials.Expiration;
Assert.IsTrue(expires > expiresAfter);
Assert.IsTrue(expires < expiresBefore);
}
public void TestSimpleUPORequestPaymentSuccess()
{
var paymentRequest = new PaymentRequest(merchantInfo, sessionToken, currency, amount, paymentOptionCard)
{
UserTokenId = "MusalaTestUser",
BillingAddress = userAddress,
DeviceDetails = new DeviceDetails {
IpAddress = "93.146.254.172"
},
AmountDetails = new AmountDetails {
TotalDiscount = "0", TotalHandling = "0", TotalShipping = "0", TotalTax = "0"
},
Items = items
};
var paymentResponse = requestExecutor.Payment(paymentRequest).GetAwaiter().GetResult();
var getSessionTokenRequest = new GetSessionTokenRequest(merchantInfo);
var response = requestExecutor.GetSessionToken(getSessionTokenRequest).GetAwaiter().GetResult();
sessionToken = response.SessionToken;
var paymentOptionUpo = new PaymentOption
{
UserPaymentOptionId = paymentResponse.PaymentOption.UserPaymentOptionId
};
var paymentUPORequest = new PaymentRequest(merchantInfo, sessionToken, currency, amount, paymentOptionUpo)
{
UserTokenId = "MusalaTestUser",
Items = items
};
var paymentUPOResponse = requestExecutor.Payment(paymentUPORequest).GetAwaiter().GetResult();
Assert.IsNotNull(paymentUPOResponse);
Assert.IsEmpty(paymentUPOResponse.Reason);
Assert.AreEqual(ResponseStatus.Success, paymentUPOResponse.Status);
Assert.IsNull(paymentUPOResponse.GwErrorReason);
Assert.IsNull(paymentUPOResponse.PaymentMethodErrorReason);
Assert.AreNotEqual(ApiConstants.TransactionStatusError, paymentUPOResponse.TransactionStatus);
}
private async Task <SessionAWSCredentials> GetTemporaryCredentials()
{
AmazonSecurityTokenServiceClient stsClient =
new AmazonSecurityTokenServiceClient(_options.AwsAccessKey,
_options.AwsSerectKey);
GetSessionTokenRequest getSessionTokenRequest = new GetSessionTokenRequest {
DurationSeconds = 7200
};
GetSessionTokenResponse sessionTokenResponse = await
stsClient.GetSessionTokenAsync(getSessionTokenRequest);
Credentials credentials = sessionTokenResponse.Credentials;
SessionAWSCredentials sessionCredential =
new SessionAWSCredentials(credentials.AccessKeyId,
credentials.SecretAccessKey,
credentials.SessionToken);
return(sessionCredential);
}
private static async Task <SessionAWSCredentials> GetTemporaryCredentialsAsync()
{
using var stsClient = new AmazonSecurityTokenServiceClient();
var getSessionTokenRequest = new GetSessionTokenRequest
{
DurationSeconds = 7200 // seconds
};
GetSessionTokenResponse sessionTokenResponse =
await stsClient.GetSessionTokenAsync(getSessionTokenRequest);
Credentials credentials = sessionTokenResponse.Credentials;
var sessionCredentials =
new SessionAWSCredentials(credentials.AccessKeyId,
credentials.SecretAccessKey,
credentials.SessionToken);
return(sessionCredentials);
}
public void TestValidRequest()
{
var getSessionTokenRequest = new GetSessionTokenRequest(validMerchantInfoShaAlgo);
var response = requestExecutor.GetSessionToken(getSessionTokenRequest).GetAwaiter().GetResult();
Assert.IsTrue(response.ApiType == ApiType.Payment);
Assert.IsNull(response.ClientUniqueId);
Assert.IsTrue(response.ErrCode == default);
Assert.IsNull(response.ErrorType);
Assert.IsNull(response.Hint);
Assert.IsNotNull(response.InternalRequestId);
Assert.IsNotNull(response.MerchantId);
Assert.IsNotNull(response.MerchantSiteId);
Assert.IsEmpty(response.Reason);
Assert.IsNotNull(response.SessionToken);
Assert.IsNotEmpty(response.SessionToken);
Assert.IsTrue(response.Status == ResponseStatus.Success);
Assert.IsNotEmpty(response.Version);
}
