public static ANetApiResponse PostData <TQ, TS>(AuthorizeNet.Environment env, TQ request)
where TQ : ANetApiRequest
where TS : ANetApiResponse
{
ANetApiResponse response = null;
if (null == request)
{
throw new ArgumentNullException("request");
}
Logger.LogDebug("MerchantInfo->LoginId/TransactionKey: '{0}':'{1}'->{2}", request.merchantAuthentication.name, request.merchantAuthentication.ItemElementName, request.merchantAuthentication.Item);
var postUrl = GetPostUrl(env);
var requestType = typeof(TQ);
string responseAsString = null;
using (var clientHandler = new HttpClientHandler())
{
//TODO: clientHandler.Proxy = SetProxyIfRequested(clientHandler.Proxy);
using (var client = new HttpClient(clientHandler))
{
//set the http connection timeout
var httpConnectionTimeout = AuthorizeNet.Environment.getIntProperty(Constants.HttpConnectionTimeout);
client.Timeout = TimeSpan.FromMilliseconds(httpConnectionTimeout != 0 ? httpConnectionTimeout : Constants.HttpConnectionDefaultTimeout);
//set the time out to read/write from stream
//var httpReadWriteTimeout = AuthorizeNet.Environment.getIntProperty(Constants.HttpReadWriteTimeout);
//client.ReadWriteTimeout = (httpReadWriteTimeout != 0 ? httpReadWriteTimeout : Constants.HttpReadWriteDefaultTimeout);
var content = new StringContent(XmlUtility.Serialize(request), Encoding.UTF8, "text/xml");
var webResponse = client.PostAsync(postUrl, content).Result;
Logger.LogDebug("Retrieving Response from Url: '{0}'", postUrl);
// Get the response
Logger.LogDebug("Received Response: '{0}'", webResponse);
responseAsString = webResponse.Content.ReadAsStringAsync().Result;
Logger.LogDebug("Response from Stream: '{0}'", responseAsString);
}
}
if (null != responseAsString)
{
try
{
// try deserializing to the expected response type
response = XmlUtility.Deserialize <TS>(responseAsString);
}
catch (Exception)
{
// probably a bad response, try if this is an error response
response = XmlUtility.Deserialize <ANetApiResponse>(responseAsString);
}
//if error response
if (response is ErrorResponse)
{
response = response as ErrorResponse;
}
}
return(response);
}
protected void BtnSubmit_Click(object sender, EventArgs e)
{
if (amount != 0.00m)
{
//ANetApiResponse res = Run("2hUJrx4D6S", "68jgK54v4jD3W5rL", amount); //testing
ANetApiResponse res = Run("4XZ9RqmC8k6", "4U466w8dBYdwsM5f", amount);//production
if (paymentStatus == "success")
{
String id = TxtEmail.Text + Guid.NewGuid().ToString("N");
HotelDBApp.Payment payment = new HotelDBApp.Payment()
{
Amount = amount, SubscriptionEndDate = expiryDate, PaymentDate = DateTime.Now, Email = TxtEmail.Text, HotelId = hotelid, Id = id, URL = Request.Url.ToString().Substring(0, Request.Url.ToString().LastIndexOf('/')) + "/"
};
String paymentId = HotelDBApp.Payment.AddPayment(payment);
if (string.IsNullOrEmpty(hotelid))
{
Email email = CreateEmail(paymentId, payment.Email, payment.URL);
SendEmail(email);
}
LblPrice.Text = "Your transaction was successful";
LblPrice.ForeColor = System.Drawing.Color.Green;
}
else
{
LblPrice.Text = "Your transaction was unsuccessful";
LblPrice.ForeColor = System.Drawing.Color.Red;
}
}
else
{
LblPrice.Text = "Please select one of the Subscription Plans";
LblPrice.ForeColor = System.Drawing.Color.Red;
}
}
public void MockdeleteCustomerProfileTest()
{
//define all mocked objects as final
var mockController = GetMockController <deleteCustomerProfileRequest, deleteCustomerProfileResponse>();
var mockRequest = new deleteCustomerProfileRequest
{
merchantAuthentication = new merchantAuthenticationType {
name = "mocktest", Item = "mockKey", ItemElementName = ItemChoiceType.transactionKey
},
};
var mockResponse = new deleteCustomerProfileResponse
{
refId = "1234",
sessionToken = "sessiontoken",
};
var errorResponse = new ANetApiResponse();
var results = new List <String>();
const messageTypeEnum messageTypeOk = messageTypeEnum.Ok;
SetMockControllerExpectations <deleteCustomerProfileRequest, deleteCustomerProfileResponse, deleteCustomerProfileController>(
mockController.MockObject, mockRequest, mockResponse, errorResponse, results, messageTypeOk);
mockController.MockObject.Execute(AuthorizeNet.Environment.CUSTOM);
//mockController.MockObject.Execute();
// or var controllerResponse = mockController.MockObject.ExecuteWithApiResponse(AuthorizeNet.Environment.CUSTOM);
var controllerResponse = mockController.MockObject.GetApiResponse();
Assert.IsNotNull(controllerResponse);
}
/// <summary>
/// w/ card exp date in format YYYY-MM
/// </summary>
/// <param name="profileId"></param>
/// <param name="paymentProfile"></param>
/// <returns></returns>
public ANetApiResponse UpdatePaymentProfile(string profileId, PaymentProfile paymentProfile)
{
if (string.IsNullOrWhiteSpace(profileId))
{
throw new ArgumentNullException("profileId", ErrorMessages.ProfileIdNullErrorCode + ErrorMessages.ProfileIdNullErrorMessage);
}
if (paymentProfile == null)
{
throw new ArgumentNullException("paymentProfile", ErrorMessages.PaymentProfileNullErrorCode + ErrorMessages.PaymentProfileNullErrorMessage);
}
ANetApiResponse result = null;
try
{
result = Gateway.UpdatePaymentProfile(profileId, paymentProfile);
return(result);
}
catch
{
throw;
}
finally
{
OnUpdatePaymentProfile(result, profileId, paymentProfile);
}
}
public void MockauthenticateTestTest()
{
//define all mocked objects as final
var mockController = GetMockController <authenticateTestRequest, authenticateTestResponse>();
var mockRequest = new authenticateTestRequest
{
merchantAuthentication = new merchantAuthenticationType()
{
name = "mocktest", Item = "mockKey", ItemElementName = ItemChoiceType.transactionKey
},
};
var mockResponse = new authenticateTestResponse
{
refId = "1234",
sessionToken = "sessiontoken",
};
var errorResponse = new ANetApiResponse();
var results = new List <String>();
const messageTypeEnum messageTypeOk = messageTypeEnum.Ok;
SetMockControllerExpectations <authenticateTestRequest, authenticateTestResponse, authenticateTestController>(
mockController.MockObject, mockRequest, mockResponse, errorResponse, results, messageTypeOk);
mockController.MockObject.Execute(AuthorizeNet.Environment.CUSTOM);
//mockController.MockObject.Execute();
// or var controllerResponse = mockController.MockObject.ExecuteWithApiResponse(AuthorizeNet.Environment.CUSTOM);
var controllerResponse = mockController.MockObject.GetApiResponse();
Assert.IsNotNull(controllerResponse);
// Assert.IsNotNull(controllerResponse.);
LogHelper.info(Logger, "authenticateTest: Details:{0}", controllerResponse);
}
public void TestChargeCreditCardAmount()
{
foreach (string values in GenerateRandomString(1, 5))
{
transactionRequest.amount = Convert.ToDecimal(values);
response = ChargeCreditCard.Run(apiLoginId, transactionKey, GetAmount(), transactionRequest);
Assert.IsNotNull(response);
Assert.AreEqual(response.messages.resultCode, messageTypeEnum.Ok);
}
foreach (string values in GenerateNegativeString(1, 5))
{
if (values != "")
{
transactionRequest.amount = Convert.ToDecimal(values);
}
else
{
transactionRequest.amount = 0;
}
response = ChargeCreditCard.Run(apiLoginId, transactionKey, GetAmount(), transactionRequest);
Assert.IsNotNull(response);
Assert.AreNotEqual(response.messages.resultCode, messageTypeEnum.Ok);
}
}
public void TestAllSampleCodes()
{
string fileName = Constants.CONFIG_FILE;
StreamReader reader = File.OpenText(fileName);
TestRunner tr = new TestRunner();
var numRetries = 3;
string line;
while ((line = reader.ReadLine()) != null)
{
string[] items = line.Split('\t');
string apiName = items[0];
string isDependent = items[1];
string shouldApiRun = items[2];
if (!shouldApiRun.Equals("1"))
{
continue;
}
Console.WriteLine(new String('-', 20));
Console.WriteLine("Running test case for :: " + apiName);
Console.WriteLine(new String('-', 20));
ANetApiResponse response = null;
for (int i = 0; i < numRetries; ++i)
{
try
{
if (isDependent.Equals("0"))
{
response = InvokeRunMethod(apiName);
}
else
{
response = (ANetApiResponse)typeof(TestRunner).GetMethod("Test" + apiName).Invoke(tr, new Object[] { });
}
if ((response != null) && (response.messages.resultCode == messageTypeEnum.Ok))
{
break;
}
}
catch (Exception ex)
{
//Console.WriteLine(apiName);
Console.WriteLine(ex.ToString());
}
Assert.IsNotNull(response);
Assert.AreEqual(response.messages.resultCode, messageTypeEnum.Ok);
}
}
}
public ActionResult <AcceptResponse> AcceptJs(string apiLoginId, string apiTransactionKey, string token)
{
AcceptResponse objAcceptResponse = new AcceptResponse();
try
{
ProxyMethod();
ANetApiResponse profileResponse = CreateAnAcceptPaymentTransaction.Run(apiLoginId, apiTransactionKey, token);
if (profileResponse != null)
{
if (profileResponse.messages.resultCode.ToString().ToLower() == "ok")
{
objAcceptResponse.status = true;
objAcceptResponse.successValue = ((AuthorizeNet.Api.Contracts.V1.createTransactionResponse)profileResponse)
.transactionResponse.transId;
}
else
{
objAcceptResponse.status = false;
if (profileResponse.messages.resultCode.ToString().ToLower() == "error")
{
objAcceptResponse.errorMessage = profileResponse.messages.message[0].code + " " +
profileResponse.messages.message[0].text;
}
else
{
objAcceptResponse.errorMessage = ((AuthorizeNet.Api.Contracts.V1.createTransactionResponse)profileResponse)
.transactionResponse
.errors[0].errorCode +
((AuthorizeNet.Api.Contracts.V1.createTransactionResponse)profileResponse)
.transactionResponse.errors[0].errorText;
}
}
}
else
{
objAcceptResponse.status = false;
return(NotFound());
}
}
catch (Exception e)
{
objAcceptResponse.status = false;
objAcceptResponse.errorMessage = "Error occured while executing payment. " + e.Message;
}
return(objAcceptResponse);
}
public void MockARBGetSubscriptionListTest()
{
//define all mocked objects as final
var mockController = GetMockController <ARBGetSubscriptionListRequest, ARBGetSubscriptionListResponse>();
var mockRequest = new ARBGetSubscriptionListRequest
{
merchantAuthentication = new merchantAuthenticationType {
name = "mocktest", Item = "mockKey", ItemElementName = ItemChoiceType.transactionKey
},
refId = RefId,
searchType = ARBGetSubscriptionListSearchTypeEnum.subscriptionActive,
paging = new Paging {
limit = 100, offset = 1
},
sorting = new ARBGetSubscriptionListSorting
{
orderBy = ARBGetSubscriptionListOrderFieldEnum.id,
orderDescending = false
},
};
var subscriptionDetail = new SubscriptionDetail
{
id = 1234,
accountNumber = "1234",
amount = SetValidTransactionAmount(Counter) / 100,
};
var subscriptionDetails = new List <SubscriptionDetail> {
subscriptionDetail
};
var mockResponse = new ARBGetSubscriptionListResponse
{
refId = "1234",
sessionToken = "sessiontoken",
subscriptionDetails = subscriptionDetails.ToArray(),
totalNumInResultSet = subscriptionDetails.Count,
};
var errorResponse = new ANetApiResponse();
var results = new List <String>();
const messageTypeEnum messageTypeOk = messageTypeEnum.Ok;
SetMockControllerExpectations <ARBGetSubscriptionListRequest, ARBGetSubscriptionListResponse, ARBGetSubscriptionListController>(
mockController.MockObject, mockRequest, mockResponse, errorResponse, results, messageTypeOk);
mockController.MockObject.Execute(AuthorizeNet.Environment.CUSTOM);
//mockController.MockObject.Execute();
// or var controllerResponse = mockController.MockObject.ExecuteWithApiResponse(AuthorizeNet.Environment.CUSTOM);
var controllerResponse = mockController.MockObject.GetApiResponse();
Assert.IsNotNull(controllerResponse);
Assert.IsNotNull(controllerResponse.subscriptionDetails);
LogHelper.info(Logger, "ARBGetSubscriptionList: Count:{0}, Details:{1}", controllerResponse.totalNumInResultSet, controllerResponse.subscriptionDetails);
}
private static TS ExecuteTestRequest <TQ, TS, TT>(bool successExpected, TQ request, AuthorizeNet.Environment execEnvironment = null)
where TQ : ANetApiRequest
where TS : ANetApiResponse
where TT : ApiOperationBase <TQ, TS>
{
LogHelper.debug(Logger, "Created {0} Request: '{1}'", request.GetType(), request);
TS response = null;
TT controller = null;
_errorResponse = null;
var controllerClass = typeof(TT);
try {
var parameters = new object[] { request };
var controllerObject = Activator.CreateInstance(controllerClass, parameters);
if (controllerObject is TT)
{
controller = (TT)controllerObject;
}
if (null != controller)
{
ANetApiResponse baseResponse = controller.ExecuteWithApiResponse(execEnvironment);
LogHelper.info(Logger, "{0} ResultCode: {1}", controllerClass, controller.GetResultCode());
LogHelper.info(Logger, "{0} Results: {1}", controllerClass, controller.GetResults());
response = (TS)baseResponse;
}
else
{
LogHelper.error(Logger, "Unable to instantiate Controller: '{0}'", controllerClass);
}
} catch (Exception e) {
LogHelper.error(Logger, "Exception : '{0}' during {1}", e.Message, controllerClass);
}
if (successExpected)
{
ProcessFailureResult <TQ, TS, TT>(true, controller, response);
ValidateSuccess <TQ, TS, TT>(controller, response);
}
else
{
ValidateFailure <TQ, TS, TT>(controller, response);
}
if (null == response && null != controller && null != controller.GetErrorResponse())
{
_errorResponse = controller.GetErrorResponse();
}
return(response);
}
/// <summary>
/// Determine the type of the response object and process accordingly.
/// Since this is just sample code the only processing being done here is to write a few
/// bits of information to the console window.
/// </summary>
/// <param name="response"></param>
private void CheckResponseForErrors(object response)
{
// Every response is based on ANetApiResponse so you can always do this sort of type casting.
ANetApiResponse baseResponse = (ANetApiResponse)response;
// If the result code is "Ok" then the request was successfully processed.
if (baseResponse.messages.resultCode == messageTypeEnum.Error)
{
// Write error messages to console window
string exceptionMessage = String.Join("\r\n", baseResponse.messages.message.Select(a => (String.Format("[{0}] {1}", a.code, a.text))).ToArray());
//Array.ForEach(baseResponse.messages.message, a => exceptionMessage += (String.Format("[{0}] {1}\r\n", a.code, a.text)));
throw new PaymentException(PaymentException.ErrorType.ProviderError, baseResponse.messages.message.Length > 0 ? baseResponse.messages.message[0].code : String.Empty, exceptionMessage);
}
}
public void MockcreateFingerPrintTest()
{
var fingerPrintSupportInformation = new fingerPrintSupportInformationType
{
amount = SetValidTransactionAmount(Counter) / 100,
currencyCode = "INR",
sequence = CounterStr,
timestamp = DateTime.UtcNow.ToString(CultureInfo.InvariantCulture),
};
//define all mocked objects as final
var mockController = GetMockController <createFingerPrintRequest, createFingerPrintResponse>();
var mockRequest = new createFingerPrintRequest
{
merchantAuthentication = new merchantAuthenticationType()
{
name = "mocktest", Item = "mockKey", ItemElementName = ItemChoiceType.transactionKey
},
supportInformation = fingerPrintSupportInformation,
};
var mockResponse = new createFingerPrintResponse
{
refId = "1234",
sessionToken = "sessiontoken",
supportInformation = fingerPrintSupportInformation,
fingerPrint = new fingerPrintType
{
sequence = fingerPrintSupportInformation.sequence,
timestamp = fingerPrintSupportInformation.timestamp,
hashValue = CounterStr,
},
};
var errorResponse = new ANetApiResponse();
var results = new List <String>();
const messageTypeEnum messageTypeOk = messageTypeEnum.Ok;
SetMockControllerExpectations <createFingerPrintRequest, createFingerPrintResponse, createFingerPrintController>(
mockController.MockObject, mockRequest, mockResponse, errorResponse, results, messageTypeOk);
mockController.MockObject.Execute(AuthorizeNet.Environment.CUSTOM);
//mockController.MockObject.Execute();
// or var controllerResponse = mockController.MockObject.ExecuteWithApiResponse(AuthorizeNet.Environment.CUSTOM);
var controllerResponse = mockController.MockObject.GetApiResponse();
Assert.IsNotNull(controllerResponse);
Assert.IsNotNull(controllerResponse.fingerPrint);
LogHelper.info(Logger, "createFingerPrint: Details:{0}", controllerResponse.fingerPrint);
}
protected static void DisplayResponse(ANetApiResponse response, String source)
{
LogHelper.info(Logger, "Source '{0}' ", source);
if (null != response)
{
var messageType = response.messages;
if (null != messageType)
{
LogHelper.info(Logger, "MessageCode: '{0}' ", messageType.resultCode.ToString());
foreach (var aMessage in messageType.message)
{
LogHelper.info(Logger, "Message: '{0}':'{1}' ", aMessage.code, aMessage.text);
}
}
}
}
public void TestAllSampleCodes()
{
string fileName = Constants.CONFIG_FILE;
StreamReader reader = File.OpenText(fileName);
TestRunner tr = new TestRunner();
string line;
while ((line = reader.ReadLine()) != null)
{
string[] items = line.Split('\t');
string apiName = items[0];
string isDependent = items[1];
string shouldApiRun = items[2];
Console.WriteLine(apiName);
if (!shouldApiRun.Equals("1"))
{
continue;
}
ANetApiResponse response = null;
try
{
if (isDependent.Equals("0"))
{
response = InvokeRunMethod(apiName);
}
else
{
response = (ANetApiResponse)typeof(TestRunner).GetMethod("Test" + apiName).Invoke(tr, new Object[] { });
}
//Console.WriteLine(apiName);
Assert.IsNotNull(response);
Assert.AreEqual(response.messages.resultCode, messageTypeEnum.Ok);
}
catch (Exception e)
{
Console.WriteLine(apiName);
Console.WriteLine(e.ToString());
Assert.IsNotNull(response);
}
}
}
public ActionResult <AcceptResponse> AcceptHosted(string apiLoginId, string apiTransactionKey, string iFrameCommunicatorUrl, string customerId = null)
{
AcceptResponse objAcceptResponse = new AcceptResponse();
try
{
ProxyMethod();
// generates a token by calling the sample code API
ANetApiResponse response = GetAnAcceptPaymentPage.Run(apiLoginId, apiTransactionKey, iFrameCommunicatorUrl, customerId);
if (response != null)
{
if (response.messages.resultCode.ToString().ToLower() == "ok")
{
objAcceptResponse.status = true;
objAcceptResponse.successValue =
((getHostedPaymentPageResponse)response).token;
}
else
{
objAcceptResponse.status = false;
objAcceptResponse.errorMessage = "Failed to get hosted payment page Error: " +
response.messages.message[0].code + " " +
response.messages.message[0].text;
}
}
else
{
objAcceptResponse.status = false;
return(NotFound());
}
}
catch (Exception e)
{
objAcceptResponse.status = false;
objAcceptResponse.errorMessage = "Error occured while executing payment. " + e.Message;
}
return(objAcceptResponse);
}
public ActionResult <AcceptResponse> ValidateCustomer(string apiLoginId, string apiTransactionKey, string customerId)
{
AcceptResponse objAcceptResponse = new AcceptResponse();
try
{
ProxyMethod();
// validates customer by calling the sample code API
ANetApiResponse response = GetCustomerProfile.Run(apiLoginId, apiTransactionKey, customerId);
if (response != null)
{
if (response.messages.resultCode.ToString().ToLower() == "ok")
{
objAcceptResponse.status = true;
objAcceptResponse.successValue = response.messages.message[0].code + " " + response.messages.message[0].text;
}
else
{
objAcceptResponse.status = false;
objAcceptResponse.errorMessage = "Error: " +
response.messages.message[0].code + " " +
response.messages.message[0].text;
}
}
else
{
objAcceptResponse.status = false;
return(NotFound());
}
}
catch (Exception e)
{
objAcceptResponse.status = false;
objAcceptResponse.errorMessage = "Error . " + e.Message;
}
return(objAcceptResponse);
}
public ActionResult <AcceptResponse> AcceptHosted(string apiLoginId, string apiTransactionKey, string iFrameCommunicatorUrl)
{
AcceptResponse objAcceptResponse = new AcceptResponse();
try
{
ProxyMethod();
ANetApiResponse response = GetAnAcceptPaymentPage.Run(apiLoginId, apiTransactionKey, iFrameCommunicatorUrl);
if (response != null)
{
if (response.messages.resultCode.ToString() == "Ok")
{
objAcceptResponse.Status = true;
objAcceptResponse.Value =
((AuthorizeNet.Api.Contracts.V1.getHostedPaymentPageResponse)response).token;
}
else
{
objAcceptResponse.Status = false;
objAcceptResponse.Message = "Failed to get hosted payment page Error: " +
response.messages.message[0].code + " " +
response.messages.message[0].text;
}
}
else
{
objAcceptResponse.Status = false;
return(NotFound());
}
}
catch (Exception e)
{
objAcceptResponse.Status = false;
objAcceptResponse.Message = "Error occured while executing payment. " + e.Message;
}
return(objAcceptResponse);
}
public void TestChargeCreditCardTerminalNumber()
{
foreach (string values in GenerateRandomString(4, 5000))
{
transactionRequest.terminalNumber = values;
response = ChargeCreditCard.Run(apiLoginId, transactionKey, GetAmount(), transactionRequest);
Assert.IsNotNull(response);
Assert.AreEqual(response.messages.resultCode, messageTypeEnum.Ok);
}
foreach (string values in GenerateNegativeString(1, 50))
{
transactionRequest.solution.id = values;
response = ChargeCreditCard.Run(apiLoginId, transactionKey, GetAmount(), transactionRequest);
Assert.IsNotNull(response);
Assert.AreNotEqual(response.messages.resultCode, messageTypeEnum.Ok);
}
}
public void TestChargeCreditCardCreditCardNumber()
{
string[] possibleValues = { "41111111111111111", "411111111111" };
foreach (string values in possibleValues)
{
transactionRequest.payment = new paymentType
{
Item = new creditCardType
{
cardNumber = values,
expirationDate = "0718",
cardCode = "123"
}
};
response = ChargeCreditCard.Run(apiLoginId, transactionKey, GetAmount(), transactionRequest);
Assert.IsNotNull(response);
Assert.AreNotEqual(response.messages.resultCode, messageTypeEnum.Ok);
}
}
public void MockcreateCustomerProfileTransactionTest()
{
//define all mocked objects as final
var mockController = GetMockController <createCustomerProfileTransactionRequest, createCustomerProfileTransactionResponse>();
var mockRequest = new createCustomerProfileTransactionRequest
{
merchantAuthentication = new merchantAuthenticationType {
name = "mocktest", Item = "mockKey", ItemElementName = ItemChoiceType.transactionKey
},
transaction = new profileTransactionType
{
Item = new profileTransAuthCaptureType(),
},
};
var transactionResponse = new transactionResponse()
{
accountNumber = "1234",
};
var mockResponse = new createCustomerProfileTransactionResponse
{
refId = "1234",
sessionToken = "sessiontoken",
transactionResponse = transactionResponse,
};
var errorResponse = new ANetApiResponse();
var results = new List <String>();
const messageTypeEnum messageTypeOk = messageTypeEnum.Ok;
SetMockControllerExpectations <createCustomerProfileTransactionRequest, createCustomerProfileTransactionResponse, createCustomerProfileTransactionController>(
mockController.MockObject, mockRequest, mockResponse, errorResponse, results, messageTypeOk);
mockController.MockObject.Execute(AuthorizeNet.Environment.CUSTOM);
//mockController.MockObject.Execute();
// or var controllerResponse = mockController.MockObject.ExecuteWithApiResponse(AuthorizeNet.Environment.CUSTOM);
var controllerResponse = mockController.MockObject.GetApiResponse();
Assert.IsNotNull(controllerResponse);
Assert.IsNotNull(controllerResponse.transactionResponse);
LogHelper.info(Logger, "createCustomerProfileTransaction: Details:{0}", controllerResponse.transactionResponse);
}
public void TestChargeCreditInvoiceNumber()
{
foreach (string values in GenerateRandomString(2, 20))
{
transactionRequest.order = new orderType {
invoiceNumber = values
};
response = ChargeCreditCard.Run(apiLoginId, transactionKey, GetAmount(), transactionRequest);
Assert.IsNotNull(response);
Assert.AreEqual(response.messages.resultCode, messageTypeEnum.Ok);
}
foreach (string values in GenerateNegativeString(1, 20))
{
transactionRequest.order = new orderType {
invoiceNumber = values
};
response = ChargeCreditCard.Run(apiLoginId, transactionKey, GetAmount(), transactionRequest);
Assert.IsNotNull(response);
Assert.AreNotEqual(response.messages.resultCode, messageTypeEnum.Ok);
}
}
private void CheckForErrors(ANetApiResponse response)
{
if (response.GetType() == typeof(createCustomerProfileTransactionResponse))
{
var createCustomerProfileTransactionResponse = (createCustomerProfileTransactionResponse)response;
createCustomerProfileTransactionResponse.directResponse =
_xmlDoc.ChildNodes[1].ChildNodes[1].InnerText;
response = createCustomerProfileTransactionResponse;
return;
}
if (response.messages.message.Length > 0 && response.messages.resultCode == messageTypeEnum.Error)
{
var stringBuilder = new StringBuilder();
for (var i = 0; i < response.messages.message.Length; i++)
{
stringBuilder.AppendFormat("Error processing request: {0} - {1}",
response.messages.message[i].code, response.messages.message[i].text);
}
throw new InvalidOperationException(stringBuilder.ToString());
}
}
protected void SetMockControllerExpectations <TQ, TS, TT> (
IApiOperation <TQ, TS> mockController,
TQ mockRequest,
TS mockResponse,
ANetApiResponse errorResponse,
List <String> results,
messageTypeEnum messageType)
where TQ : ANetApiRequest
where TS : ANetApiResponse
where TT : IApiOperation <TQ, TS>
{
var mockEnvironment = AuthorizeNet.Environment.CUSTOM;
//using (MockContext.Unordered())
{
//Expect.On(mockController).Any.Method(i => i.Execute(mockEnvironment));
Expect.On(mockController).Any.Method(i => i.Execute(mockEnvironment)).With(mockEnvironment);
Expect.On(mockController).Any.Method(i => i.GetApiResponse()).WillReturn(mockResponse);
//Expect.On(mockController).Between(0, 10).Method(i => i.ExecuteWithApiResponse(mockEnvironment)).WillReturn(mockResponse);
Expect.On(mockController).Any.Method(i => i.ExecuteWithApiResponse(mockEnvironment)).With(mockEnvironment).WillReturn(mockResponse);
Expect.On(mockController).Any.Method(i => i.GetResults()).WillReturn(results);
Expect.On(mockController).Any.Method(i => i.GetResultCode()).WillReturn(messageType);
Expect.On(mockController).Any.Method(i => i.GetErrorResponse()).WillReturn(errorResponse);
}
if (null != mockRequest && null != mockResponse)
{
mockResponse.refId = mockRequest.refId;
}
var realController = Activator.CreateInstance(typeof(TT), mockRequest);
Assert.IsNotNull(realController);
LogHelper.info(Logger, "Request: {0}", mockRequest);
ShowProperties(mockRequest);
LogHelper.info(Logger, "Response: {0}", mockResponse);
ShowProperties(mockResponse);
}
public void MockmobileDeviceLoginTest()
{
//define all mocked objects as final
var mockController = GetMockController <mobileDeviceLoginRequest, mobileDeviceLoginResponse>();
var mockRequest = new mobileDeviceLoginRequest
{
merchantAuthentication = new merchantAuthenticationType {
name = "mocktest", Item = "mockKey", ItemElementName = ItemChoiceType.transactionKey
},
};
var transRetailInfoType = new transRetailInfoType
{
deviceType = "android",
marketType = "marketplace",
};
var mockResponse = new mobileDeviceLoginResponse
{
refId = "1234",
sessionToken = "sessiontoken",
merchantAccount = transRetailInfoType,
};
var errorResponse = new ANetApiResponse();
var results = new List <String>();
const messageTypeEnum messageTypeOk = messageTypeEnum.Ok;
SetMockControllerExpectations <mobileDeviceLoginRequest, mobileDeviceLoginResponse, mobileDeviceLoginController>(
mockController.MockObject, mockRequest, mockResponse, errorResponse, results, messageTypeOk);
mockController.MockObject.Execute(AuthorizeNet.Environment.CUSTOM);
//mockController.MockObject.Execute();
// or var controllerResponse = mockController.MockObject.ExecuteWithApiResponse(AuthorizeNet.Environment.CUSTOM);
var controllerResponse = mockController.MockObject.GetApiResponse();
Assert.IsNotNull(controllerResponse);
Assert.IsNotNull(controllerResponse.merchantAccount);
LogHelper.info(Logger, "mobileDeviceLogin: Details:{0}", controllerResponse.merchantAccount);
}
public void MockcreateCustomerProfileTest()
{
//define all mocked objects as final
var mockController = GetMockController <createCustomerProfileRequest, createCustomerProfileResponse>();
var mockRequest = new createCustomerProfileRequest
{
merchantAuthentication = new merchantAuthenticationType {
name = "mocktest", Item = "mockKey", ItemElementName = ItemChoiceType.transactionKey
},
};
var mockResponse = new createCustomerProfileResponse
{
refId = "1234",
sessionToken = "sessiontoken",
customerProfileId = "1234",
customerPaymentProfileIdList = new [] { "12345" },
customerShippingAddressIdList = new[] { "12345" },
validationDirectResponseList = new string[] {},
};
var errorResponse = new ANetApiResponse();
var results = new List <String>();
const messageTypeEnum messageTypeOk = messageTypeEnum.Ok;
SetMockControllerExpectations <createCustomerProfileRequest, createCustomerProfileResponse, createCustomerProfileController>(
mockController.MockObject, mockRequest, mockResponse, errorResponse, results, messageTypeOk);
mockController.MockObject.Execute(AuthorizeNet.Environment.CUSTOM);
//mockController.MockObject.Execute();
// or var controllerResponse = mockController.MockObject.ExecuteWithApiResponse(AuthorizeNet.Environment.CUSTOM);
var controllerResponse = mockController.MockObject.GetApiResponse();
Assert.IsNotNull(controllerResponse);
Assert.IsNotNull(controllerResponse.customerProfileId);
LogHelper.info(Logger, "createCustomerProfile: Details:{0}", controllerResponse.customerProfileId);
}
public static ANetApiResponse PostData <TQ, TS>(AuthorizeNet.Environment env, TQ request)
where TQ : ANetApiRequest
where TS : ANetApiResponse
{
ANetApiResponse response = null;
if (null == request)
{
throw new ArgumentNullException("request");
}
Logger.debug(string.Format("MerchantInfo->LoginId/TransactionKey: '{0}':'{1}'->{2}",
request.merchantAuthentication.name, request.merchantAuthentication.ItemElementName, request.merchantAuthentication.Item));
var postUrl = GetPostUrl(env);
var webRequest = (HttpWebRequest)WebRequest.Create(postUrl);
webRequest.Method = "POST";
webRequest.ContentType = "text/xml";
webRequest.KeepAlive = true;
webRequest.Proxy = SetProxyIfRequested(webRequest.Proxy);
//set the http connection timeout
var httpConnectionTimeout = AuthorizeNet.Environment.getIntProperty(Constants.HttpConnectionTimeout);
webRequest.Timeout = (httpConnectionTimeout != 0 ? httpConnectionTimeout : Constants.HttpConnectionDefaultTimeout);
//set the time out to read/write from stream
var httpReadWriteTimeout = AuthorizeNet.Environment.getIntProperty(Constants.HttpReadWriteTimeout);
webRequest.ReadWriteTimeout = (httpReadWriteTimeout != 0 ? httpReadWriteTimeout : Constants.HttpReadWriteDefaultTimeout);
var requestType = typeof(TQ);
var serializer = new XmlSerializer(requestType);
using (var writer = new XmlTextWriter(webRequest.GetRequestStream(), Encoding.UTF8))
{
serializer.Serialize(writer, request);
}
// Get the response
String responseAsString = null;
Logger.debug(string.Format("Retreiving Response from Url: '{0}'", postUrl));
using (var webResponse = webRequest.GetResponse())
{
Logger.debug(string.Format("Received Response: '{0}'", webResponse));
using (var responseStream = webResponse.GetResponseStream())
{
if (null != responseStream)
{
using (var reader = new StreamReader(responseStream))
{
responseAsString = reader.ReadToEnd();
}
Logger.debug(string.Format("Response from Stream: '{0}'", responseAsString));
}
}
}
if (null != responseAsString)
{
using (var memoryStreamForResponseAsString = new MemoryStream(Encoding.UTF8.GetBytes(responseAsString)))
{
var responseType = typeof(TS);
var deSerializer = new XmlSerializer(responseType);
Object deSerializedObject;
try
{
// try deserializing to the expected response type
deSerializedObject = deSerializer.Deserialize(memoryStreamForResponseAsString);
}
catch (Exception)
{
// probably a bad response, try if this is an error response
memoryStreamForResponseAsString.Seek(0, SeekOrigin.Begin); //start from beginning of stream
var genericDeserializer = new XmlSerializer(typeof(ANetApiResponse));
deSerializedObject = genericDeserializer.Deserialize(memoryStreamForResponseAsString);
}
//if error response
if (deSerializedObject is ErrorResponse)
{
response = deSerializedObject as ErrorResponse;
}
else
{
//actual response of type expected
if (deSerializedObject is TS)
{
response = deSerializedObject as TS;
}
else if (deSerializedObject is ANetApiResponse) //generic response
{
response = deSerializedObject as ANetApiResponse;
}
}
}
}
return(response);
}
public TransactionResponse ChargeCredit(PaymentModel payment)
{
// determine run Environment to SANDBOX for developemnt level
ApiOperationBase <ANetApiRequest, ANetApiResponse> .RunEnvironment = AuthorizeNet.Environment.SANDBOX;
// define the merchant information (authentication / transaction id)
ApiOperationBase <ANetApiRequest, ANetApiResponse> .MerchantAuthentication = new merchantAuthenticationType()
{
name = apiLoginId,
ItemElementName = ItemChoiceType.transactionKey,
Item = transactionKey,
};
var creditCard = new creditCardType
{
cardNumber = payment.CardNumber,
expirationDate = payment.Month + payment.Year,
cardCode = payment.CardCode,
};
var bilingAddress = new customerAddressType
{
firstName = payment.FirstName,
lastName = payment.LastName,
city = payment.Address1,
address = payment.Address2,
zip = payment.PostCode
};
//standard api call to retrieve response
var paymentType = new paymentType {
Item = creditCard
};
//getting payment that student paying
var studentAmount = new PaymentModel();
var studentID = new Student();
//Add line Items you pay to obtain these
var lineItems = new lineItemType[1];
lineItems[0] = new lineItemType {
itemId = studentID.ID.ToString(), name = "Tution Fees", quantity = 1, unitPrice = studentAmount.Amount, taxRate = 7.5M, totalAmount = studentAmount.Amount
};
var transactionRequest = new transactionRequestType
{
transactionType = transactionTypeEnum.authCaptureTransaction.ToString(),// charge the card
amount = Convert.ToDecimal(payment.Amount),
payment = paymentType,
billTo = bilingAddress,
lineItems = lineItems
};
var request = new createTransactionRequest {
transactionRequest = transactionRequest
};
// instantiate the contoller that will call the service
var controller = new createTransactionController(request);
controller.Execute();
var resCode = controller.GetResultCode();
var resAll = controller.GetResults();
//get the response from the service (errors contained if any)
var response = controller.GetApiResponse();
//validate
TransactionResponse result = new TransactionResponse();
if (response != null)
{
result.ResultCode = response.messages.resultCode;
if (response.messages.resultCode == messageTypeEnum.Ok)
{
if (response.transactionResponse.messages != null)
{
result.TransId = response.transactionResponse.transId;
result.ResponseCode = response.transactionResponse.responseCode;
result.MessageCode = response.transactionResponse.messages[0].code;
result.Description = response.transactionResponse.messages[0].description;
result.AuthCode = response.transactionResponse.authCode;
result.AmountPaid = payment.Amount;
}
else
{
if (response.transactionResponse.errors != null)
{
result.ErrorCode = response.transactionResponse.errors[0].errorCode;
result.ErrorText = response.transactionResponse.errors[0].errorText;
}
}
}
else
{
if (response.transactionResponse != null && response.transactionResponse.errors != null)
{
result.ErrorCode = response.transactionResponse.errors[0].errorCode;
result.ErrorText = response.transactionResponse.errors[0].errorText;
}
else
{
result.ErrorCode = response.messages.message[0].code;
result.ErrorText = response.messages.message[0].text;
}
}
}
else
{
//result.errorCode = "NONE";
//result.errorText = "Failed Transaction, Unknown Error";
ANetApiResponse errorResponse = controller.GetErrorResponse();
result.ErrorText = errorResponse.messages.message[0].text;
result.ErrorCode = errorResponse.messages.message[0].code;
result.ResultCode = messageTypeEnum.Error;
}
return(result);
}
public static ANetApiResponse Run(String ApiLoginID, String ApiTransactionKey)
{
Console.WriteLine("Create a ChasePay Transaction Sample");
ApiOperationBase <ANetApiRequest, ANetApiResponse> .RunEnvironment = AuthorizeNet.Environment.SANDBOX;
// define the merchant information (authentication / transaction id)
ApiOperationBase <ANetApiRequest, ANetApiResponse> .MerchantAuthentication = new merchantAuthenticationType()
{
name = ApiLoginID,
ItemElementName = ItemChoiceType.transactionKey,
Item = ApiTransactionKey,
};
var creditCard = new creditCardType
{
cardNumber = "4111111111111111",
expirationDate = "0725",
cardCode = "999",
// Set the token specific info
isPaymentToken = true,
// Set this to the value of the cryptogram received from the token provide
cryptogram = "EjRWeJASNFZ4kBI0VniQEjRWeJA=",
tokenRequestorName = "CHASE_PAY",
tokenRequestorId = "12345678901",
tokenRequestorEci = "07"
};
//standard api call to retrieve response
var paymentType = new paymentType {
Item = creditCard
};
var transactionRequest = new transactionRequestType
{
transactionType = transactionTypeEnum.authCaptureTransaction.ToString(),
amount = 133.45m,
payment = paymentType
};
var request = new createTransactionRequest {
transactionRequest = transactionRequest
};
// instantiate the controller that will call the service
var controller = new createTransactionController(request);
controller.Execute();
// get the response from the service (errors contained if any)
var response = controller.GetApiResponse();
// validate response
if (response != null)
{
if (response.messages.resultCode == messageTypeEnum.Ok)
{
if (response.transactionResponse.messages != null)
{
Console.WriteLine("Successfully created transaction with Transaction ID: " + response.transactionResponse.transId);
Console.WriteLine("Response Code: " + response.transactionResponse.responseCode);
Console.WriteLine("Message Code: " + response.transactionResponse.messages[0].code);
Console.WriteLine("Description: " + response.transactionResponse.messages[0].description);
Console.WriteLine("Hash Code: " + response.transactionResponse.transHash);
Console.WriteLine("Success, Auth Code : " + response.transactionResponse.authCode);
}
else
{
Console.WriteLine("Failed Transaction.");
if (response.transactionResponse.errors != null)
{
Console.WriteLine("Error Code: " + response.transactionResponse.errors[0].errorCode);
Console.WriteLine("Error message: " + response.transactionResponse.errors[0].errorText);
}
}
}
else
{
Console.WriteLine("Failed Transaction.");
if (response.transactionResponse != null && response.transactionResponse.errors != null)
{
Console.WriteLine("Error Code: " + response.transactionResponse.errors[0].errorCode);
Console.WriteLine("Error message: " + response.transactionResponse.errors[0].errorText);
}
else
{
Console.WriteLine("Error Code: " + response.messages.message[0].code);
Console.WriteLine("Error message: " + response.messages.message[0].text);
}
}
}
else
{
// Display the error code and message when response is null
ANetApiResponse errorResponse = controller.GetErrorResponse();
Console.WriteLine("Failed to get response");
if (!string.IsNullOrEmpty(errorResponse.messages.message.ToString()))
{
Console.WriteLine("Error Code: " + errorResponse.messages.message[0].code);
Console.WriteLine("Error message: " + errorResponse.messages.message[0].text);
}
}
return(response);
}
public void MockARBGetSubscriptionTest()
{
//define all mocked objects as final
var mockController = GetMockController <ARBGetSubscriptionRequest, ARBGetSubscriptionResponse>();
var mockRequest = new ARBGetSubscriptionRequest
{
merchantAuthentication = new merchantAuthenticationType()
{
name = "mocktest", Item = "mockKey", ItemElementName = ItemChoiceType.transactionKey
},
subscriptionId = "1234"
};
var customerPaymentProfileMaskedType = new customerPaymentProfileMaskedType
{
customerPaymentProfileId = "1234",
};
Random rnd = new Random(DateTime.Now.Millisecond);
var SubscriptionMaskedType = new ARBSubscriptionMaskedType()
{
name = "Test",
paymentSchedule = new paymentScheduleType
{
interval = new paymentScheduleTypeInterval
{
length = 1,
unit = ARBSubscriptionUnitEnum.months,
},
startDate = DateTime.UtcNow,
totalOccurrences = 12
},
amount = 9.99M,
amountSpecified = true,
trialAmount = 100,
trialAmountSpecified = true,
status = ARBSubscriptionStatusEnum.active,
statusSpecified = true,
profile = new subscriptionCustomerProfileType()
{
paymentProfile = customerPaymentProfileMaskedType,
},
order = new orderType {
description = string.Format("member monthly {0}", rnd.Next(99999))
}
};
var mockResponse = new ARBGetSubscriptionResponse
{
refId = "1234",
sessionToken = "sessiontoken",
subscription = SubscriptionMaskedType
};
var errorResponse = new ANetApiResponse();
var results = new List <String>();
const messageTypeEnum messageTypeOk = messageTypeEnum.Ok;
SetMockControllerExpectations <ARBGetSubscriptionRequest, ARBGetSubscriptionResponse, ARBGetSubscriptionController>(
mockController.MockObject, mockRequest, mockResponse, errorResponse, results, messageTypeOk);
mockController.MockObject.Execute(AuthorizeNet.Environment.CUSTOM);
//mockController.MockObject.Execute();
// or var controllerResponse = mockController.MockObject.ExecuteWithApiResponse(AuthorizeNet.Environment.CUSTOM);
var controllerResponse = mockController.MockObject.GetApiResponse();
Assert.IsNotNull(controllerResponse);
Assert.IsNotNull(controllerResponse.subscription);
LogHelper.info(Logger, "ARBGetSubscription: Details:{0}", controllerResponse.subscription);
}
private void SetErrorResponse(ANetApiResponse errorResponse)
{
_errorResponse = errorResponse;
}
