public void ToXml_Includes_DeviceSessionId()
{
TransactionRequest request = new TransactionRequest();
request.DeviceSessionId = "my_dsid";
Assert.IsTrue(request.ToXml().Contains("my_dsid"));
}
public void ToXml_Includes_FraudMerchantId()
{
TransactionRequest request = new TransactionRequest();
request.FraudMerchantId = "my_fmid";
Assert.IsTrue(request.ToXml().Contains("my_fmid"));
}
public void ToXml_InludesPaymentMethodNonce()
{
TransactionRequest request = new TransactionRequest();
request.PaymentMethodNonce = "1232131232";
Assert.IsTrue(request.ToXml().Contains("1232131232"));
}
public void Generate_ReturnsTransactionsSettledOnAGivenDay()
{
TransactionRequest request = new TransactionRequest
{
Amount = 1000M,
CreditCard = new TransactionCreditCardRequest
{
Number = "4111111111111111",
ExpirationDate = "05/2012",
CardholderName = "Tom Smith",
},
Options = new TransactionOptionsRequest
{
SubmitForSettlement = true
},
};
Transaction transaction = gateway.Transaction.Sale(request).Target;
Transaction settlementResult = gateway.TestTransaction.Settle(transaction.Id);
var settlementDate = settlementResult.SettlementBatchId.Substring(0,10);
transaction = gateway.Transaction.Find(transaction.Id);
var result = gateway.SettlementBatchSummary.Generate(System.DateTime.Parse(settlementDate));
var visas = new List<IDictionary<string,string>>();
foreach (var row in result.Target.Records)
{
if (CreditCardCardType.VISA.ToString().Equals(row["card_type"]))
{
visas.Add(row);
}
}
Assert.AreEqual(1, visas.Count);
}
public deviceTransaction GetDeviceTransaction(TransactionRequest transactionRequest)
{
string response = "";
Dictionary<string, string> responseMap = doRequest(GetURL(), "POST", Serializer<TransactionRequest>.Serialize(transactionRequest).InnerXml);
responseMap.TryGetValue(MESSAGE, out response);
return Serializer<deviceTransaction>.Deserialize(response);
}
private static void Main()
{
// Valid transaction
Console.WriteLine("Begin Transaction...");
Thread.Sleep(1000);
var validTransactionRequest = new TransactionRequest
{
CardNumber = "123-456-78",
CardPin = "1234",
RequestedAmount = 200
};
ProcessTransaction(validTransactionRequest);
Console.WriteLine("End Transaction...\n");
Thread.Sleep(1000);
// Invalid card number
Console.WriteLine("Begin Transaction...");
Thread.Sleep(1000);
var invalidCardNumberTransaction = new TransactionRequest
{
CardNumber = "111-11-11-111",
CardPin = "1234",
RequestedAmount = 200
};
ProcessTransaction(invalidCardNumberTransaction);
Console.WriteLine("End Transaction...\n");
Thread.Sleep(1000);
// Invalid card pin
Console.WriteLine("Begin Transaction...");
Thread.Sleep(1000);
var invalidCardPinTransaction = new TransactionRequest
{
CardNumber = "111-11-111",
CardPin = "12345",
RequestedAmount = 200
};
ProcessTransaction(invalidCardPinTransaction);
Console.WriteLine("End Transaction...\n");
Thread.Sleep(1000);
// Invalid money request
Console.WriteLine("Begin Transaction...");
Thread.Sleep(1000);
var invalidMoneyRequestTransaction = new TransactionRequest
{
CardNumber = "111-11-111",
CardPin = "1234",
RequestedAmount = -200
};
ProcessTransaction(invalidMoneyRequestTransaction);
Console.WriteLine("End Transaction...\n");
Thread.Sleep(1000);
}
public void ToXML_EscapesGeneratedXMLForString()
{
TransactionRequest request = new TransactionRequest
{
OrderId = "<>&\"'"
};
TestHelper.AssertIncludes("<order-id><>&"'</order-id>", request.ToXml());
}
public void HashIsComputedCorrectly0()
{
var request = new TransactionRequest();
request.Add("KEY1", "VALUE1");
var client = GetClient();
client.SetHash(request);
Assert.AreEqual("05b2372310c2897729f9c185517a25168e6891f2c7749329255f494e1483f181", request["HASH"]);
}
public void HashIsComputedCorrectly1()
{
var request = new TransactionRequest();
request.Add("ORDERID", "VALUE1");
request.Add("DATE", "VALUE2");
var client = GetClient();
client.SetHash(request);
Assert.AreEqual("b7c312f5d79aebc472d91b7395ba855b00bcfee5e15b13a01af85a9f64737a89", request["HASH"]);
}
public void HashIsComputedCorrectly0_Verify()
{
var hash = "05b2372310c2897729f9c185517a25168e6891f2c7749329255f494e1483f181";
var request = new TransactionRequest();
request.Add("KEY1", "VALUE1");
var client = GetClient();
var result = client.VerifyParameters(request, GetClientConfiguration().ApiKey, hash);
Assert.IsTrue(result);
}
public void TestService()
{
request = new TransactionRequest();
request.TokenUniqueId = "DWSPMC00000000010906a349d9ca4eb1a4d53e3c90a11d9c";
request.AuditInfo.UserId = "testUser";
request.AuditInfo.UserName = "******";
request.AuditInfo.Organization = "Test Org";
response = service.GetDeviceTransaction(request);
Assert.IsNotNull(response.Transactions);
}
public void ToXml_Includes_DeviceData()
{
TransactionRequest request = new TransactionRequest();
request.DeviceData = "{\"device_session_id\":\"my_dsid\", \"fraud_merchant_id\":\"my_fmid\"}";
Assert.IsTrue(request.ToXml().Contains("device-data"));
Assert.IsTrue(request.ToXml().Contains("device_session_id"));
Assert.IsTrue(request.ToXml().Contains("my_dsid"));
Assert.IsTrue(request.ToXml().Contains("fraud_merchant_id"));
Assert.IsTrue(request.ToXml().Contains("my_fmid"));
}
public void OnPaymentFinished(string orderId, TransactionRequest originalRequest, IDictionary<String, String> result, ApiPaymentCompletedStatus status)
{
//handle payment finished
string textResult = "Order ID: " + orderId + "\n" + "Status: " + status + "\n";
foreach(KeyValuePair<string, string> entry in result)
{
textResult = textResult + entry.Key + ": " + entry.Value + "\n";
}
this.paymentDataView.Text = textResult;
}
public void ToXML_EscapesGeneratedXMLForNestedSearchCriteria()
{
TransactionRequest request = new TransactionRequest
{
Customer = new CustomerRequest
{
FirstName = "<John>"
}
};
TestHelper.AssertIncludes("<first-name><John></first-name>", request.ToXml());
}
bool ITransactionProcessor.AddRequest(int tickerIndex, double quantity)
{
if (!quoteContext.GetTickerDescription(tickerIndex).CanBeBought) return false;
var req = new TransactionRequest(tickerIndex, quantity < 0 ? 0 : quantity, delay.Value);
if (delay.Value == 0)
return ProcessTransactionRequest(req);
else
transactionRequests.Add(req);
return true;
}
private static void ProcessTransaction(TransactionRequest transactionRequest)
{
try
{
AtmDbData.WithdrawMoney(transactionRequest);
Console.WriteLine("\tRequested transaction was successful!");
}
catch (Exception)
{
Console.WriteLine("\tRequested transaction was not successful!");
}
}
public void Sign_Transaction()
{
//Just checking for no errors here- not yet sure how we verify this,
//unless we call into another way of signing and verify the two match
TransactionRequest t = new TransactionRequest()
{
AmountInCents = 124,
CurrencyCode = Currency.GBP,
Description = "test description"
};
RecurlyJs signer = new RecurlyJs("testkey","testapi");
var signedString = signer.SignString(t.ToSignableString());
}
public void WithdrawMoney(TransactionRequest transactionRequest)
{
using (var transaction = new AtmDbContext().Database.BeginTransaction())
{
try
{
if (!this.validator.IsValidCardNumber(transactionRequest.CardNumber))
{
throw new ArgumentException("Invalid card number. Current transaction is aborted!");
}
if (!this.validator.IsValidCardPin(transactionRequest.CardPin))
{
throw new ArgumentException("Invalid Card PIN Code. Current transaction is aborted!");
}
var cardAccount = this.atmDbContext.CardAccounts
.FirstOrDefault(ca => ca.CardNumber == transactionRequest.CardNumber &&
ca.CardPin == transactionRequest.CardPin);
if (cardAccount == null)
{
throw new ArgumentException(
"There is no Card account with the given Card number. Current transaction is aborted!");
}
if (!this.validator.IsPinCodeMatches(transactionRequest.CardPin, cardAccount.CardPin))
{
throw new ArgumentException(
"Chosen Card PIN Code does not matches the actual PIN Code of the card account. Current transaction is aborted!");
}
if (
!this.validator.IsPermittedWithdrawalAmount(transactionRequest.RequestedAmount,
cardAccount.CardCash))
{
throw new ArgumentException(
"Invalid withdrawal money amount to retrieve. Current transaction is aborted!");
}
cardAccount.CardCash -= transactionRequest.RequestedAmount;
transaction.Commit();
this.atmDbContext.SaveChanges();
}
catch (Exception ex)
{
transaction.Rollback();
Console.WriteLine("\t" + ex.Message);
}
}
}
/// <summary>
/// Creates the authorization/payment parameters. You have to call SetPayWithForm or SetPayWithAlias after.
/// </summary>
/// <param name="uniqueOrderId">The unique order unique identifier (you have to create it).</param>
/// <param name="userId">The user unique identifier.</param>
/// <param name="userEmail">The user email.</param>
/// <param name="description">The description of the payment.</param>
/// <param name="amountInEuro">The amount information euro (not in cents).</param>
/// <param name="createAlias">if set to <c>true</c> [create alias] (to do oneclick later).</param>
/// <param name="displayCreateAlias">if set to <c>true</c> the payment form will ask whether to save the card information.</param>
/// <param name="authorizationInsteadOfPayment">if set to <c>true</c> [authorization instead of payment]. Call Capture to complete the transaction.</param>
/// <param name="language">The language.</param>
/// <returns></returns>
public TransactionRequest CreateAuthorizationParameters(
string uniqueOrderId,
string userId,
string userEmail,
string description,
decimal amountInEuro,
bool createAlias = false,
bool displayCreateAlias = false,
bool authorizationInsteadOfPayment = false,
Be2BillLanguage language = Be2BillLanguage.EN)
{
// http://developer.be2bill.com/platform
var collection = new TransactionRequest();
if (authorizationInsteadOfPayment)
{
collection.Add(Names.Params.OperationType, Names.Params.OperationTypeAuthorization);
}
else
{
collection.Add(Names.Params.OperationType, Names.Params.OperationTypePayment);
}
collection.Add(Names.Params.Description, description);
collection.Add(Names.Params.OrderId, uniqueOrderId); // be2bill seems to accept only 1 tentative per ORDERID
collection.Add(Names.Params.Amount, Math.Round(amountInEuro * 100).ToString());
collection.Add(Names.Params.Version, Names.ApiVersion);
collection.Add(Names.Params.ClientIdent, userId);
collection.Add(Names.Params.Language, language.ToString());
if (createAlias)
{
collection.Add(Names.Params.CreateAlias, Names.Params.Yes); // allow one-click for later transactions (force)
}
if (displayCreateAlias)
{
collection.Add(Names.Params.DisplayCreateAlias, Names.Params.Yes); // allow one-click for later transactions (ask user)
}
collection.Add(Names.Params.Identifier, configuration.ApiIdentifier);
if (userEmail != null)
{
collection.Add(Names.Params.ClientEmail, userEmail);
}
return collection;
}
public IList<Transaction> Get(TransactionRequest request)
{
var transactions = new List<Transaction>();
for (int i = 1; i < 30; i++)
{
transactions.Add(new Transaction()
{
Date = DateTime.Now.AddDays(i),
Details = "Transaction " + i,
CreditAmount = 10 + i,
DebitAmount = 10 - i
});
}
return transactions;
}
public void ToXML_EnsuresUSLocaleForDecimals()
{
CultureInfo existingCulture = CultureInfo.CurrentCulture;
try
{
#if netcore
CultureInfo.CurrentCulture = new CultureInfo("it-IT");
#else
Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("it-IT");
#endif
TransactionRequest transactionRequest = new TransactionRequest
{
Amount = 100.0M,
TaxAmount = 10.0M,
};
SubscriptionRequest subscriptionRequest = new SubscriptionRequest
{
Price = 200.0M,
};
SubscriptionTransactionRequest subscriptionTransactionRequest = new SubscriptionTransactionRequest
{
Amount = 300.0M
};
ModificationRequest modificationRequest = new ModificationRequest
{
Amount = 400.0M
};
TestHelper.AssertIncludes("<amount>100.00</amount>", transactionRequest.ToXml());
TestHelper.AssertIncludes("<tax-amount>10.00</tax-amount>", transactionRequest.ToXml());
TestHelper.AssertIncludes("<price>200.00</price>", subscriptionRequest.ToXml());
TestHelper.AssertIncludes("<amount>300.00</amount>", subscriptionTransactionRequest.ToXml());
TestHelper.AssertIncludes("<amount>400.00</amount>", modificationRequest.ToXml("root"));
}
finally
{
#if netcore
CultureInfo.CurrentCulture = existingCulture;
#else
Thread.CurrentThread.CurrentCulture = existingCulture;
#endif
}
}
public void Generate_ReturnsTransactionsSettledOnAGivenDay()
{
TransactionRequest request = new TransactionRequest
{
Amount = 1000M,
CreditCard = new TransactionCreditCardRequest
{
Number = "4111111111111111",
ExpirationDate = "05/2022",
CardholderName = "Tom Smith",
CVV = "123",
},
BillingAddress = new AddressRequest
{
StreetAddress = "123 fake st",
PostalCode = "90025",
},
Options = new TransactionOptionsRequest
{
SubmitForSettlement = true
},
};
var trsp = gateway.Transaction.Sale(request);
Assert.IsNotNull(trsp);
Transaction transaction = trsp.Target;
if (transaction != null)
{
Transaction settlementResult = gateway.TestTransaction.Settle(transaction.Id);
var settlementDate = settlementResult.SettlementBatchId.Substring(0, 10);
transaction = gateway.Transaction.Find(transaction.Id);
var result = gateway.SettlementBatchSummary.Generate(System.DateTime.Parse(settlementDate));
var visas = new List<IDictionary<string, string>>();
foreach (var row in result.Target.Records)
{
if (Braintree.CreditCardCardType.VISA.ToString().Equals(row["card_type"]))
{
visas.Add(row);
}
}
Assert.AreEqual(1, visas.Count);
}
else if (trsp.Message.Contains("duplicate"))
Assert.Inconclusive(trsp.Message);
else
Assert.Fail(trsp.Message);
}
public void SettlementPending()
{
var request = new TransactionRequest
{
Amount = 100M,
PaymentMethodNonce = Nonce.Transactable,
Options = new TransactionOptionsRequest
{
SubmitForSettlement = true
}
};
var transactionResult = gateway.Transaction.Sale(request);
Transaction transaction = gateway.TestTransaction.SettlementPending(transactionResult.Target.Id);
Assert.AreEqual(TransactionStatus.SETTLEMENT_PENDING, transaction.Status);
}
public void Can_Create_A_Transaction_Request()
{
//// Arrange
var gateway = BraintreeProviderSettings.AsBraintreeGateway();
var request = new TransactionRequest()
{
Amount = 100M,
PaymentMethodNonce = TestHelper.PaymentMethodNonce
};
//// Act
var result = gateway.Transaction.Sale(request);
//// Assert
Assert.IsTrue(result.IsSuccess());
}
/* Create */
public async Task<OpObject> Create(String UserGuid, CModelRequest Request)
{
/* Lookup user master id */
Int64 uMasterId = 1;// Int64.Parse(UserGuid);
Int64 mMasterId = -1;
Guid mGuid;
/* Lookup model based upon the signature
* in the template */
mGuid = GetModelGuidFromTemplate(Request.TemplateWithData);
mMasterId = await GetMasterId(mGuid, GuidType.Model);
/* Do some basic sanity checks here,
* because if mGuid is empty, model was not found
* which means the template-data was invalid */
if (mGuid == Guid.Empty
|| mMasterId == -1) {
return new OpObject(StatusCode.InvalidParameters, "The template data you submitted was either invalid or the ID of the template was removed."
+ " Please redownload the template you've used and try again.");
}
/* Proxy data */
TransactionRequest tRequest = new TransactionRequest()
{
Guid = Guid.NewGuid(),
UserMasterId = uMasterId,
ModelMasterId = mMasterId,
Template = Request.TemplateWithData,
Parameters = ((int)Request.Parameters).ToString(),
Status = 0,
Created = DateTime.Now
};
/* Create the request in database */
Database.TransactionRequests.Add(tRequest);
Database.Entry(tRequest).State = System.Data.Entity.EntityState.Added;
/* Save */
await Database.SaveChangesAsync();
/* Done */
return new OpObject(StatusCode.Ok, tRequest.Guid.ToString());
}
public void CreateTransactionFromTransparentRedirect()
{
TransactionRequest trParams = new TransactionRequest
{
Type = TransactionType.SALE
};
TransactionRequest request = new TransactionRequest
{
Amount = SandboxValues.TransactionAmount.AUTHORIZE,
CreditCard = new TransactionCreditCardRequest
{
Number = SandboxValues.CreditCardNumber.VISA,
ExpirationDate = "05/2099",
CVV = "123",
},
BillingAddress = new AddressRequest
{
StreetAddress = "123 fake st",
PostalCode = "90025",
},
};
string queryString = TestHelper.QueryStringForTR(trParams, request, gateway.TransparentRedirect.Url, service);
Result<Transaction> result = gateway.TransparentRedirect.ConfirmTransaction(queryString);
Assert.IsTrue(result.IsSuccess(), result.Message);
Transaction transaction = result.Target;
Assert.AreEqual(1000.00, transaction.Amount);
Assert.AreEqual(TransactionType.SALE, transaction.Type);
Assert.AreEqual(TransactionStatus.AUTHORIZED, transaction.Status);
Assert.AreEqual(DateTime.Now.Year, transaction.CreatedAt.Value.Year);
Assert.AreEqual(DateTime.Now.Year, transaction.UpdatedAt.Value.Year);
CreditCard creditCard = transaction.CreditCard;
Assert.AreEqual("411111", creditCard.Bin);
Assert.AreEqual("1111", creditCard.LastFour);
Assert.AreEqual("05", creditCard.ExpirationMonth);
Assert.AreEqual("2099", creditCard.ExpirationYear);
Assert.AreEqual("05/2099", creditCard.ExpirationDate);
}
public void TransactionCreate()
{
TransactionRequest request = new TransactionRequest
{
Amount = SandboxValues.TransactionAmount.AUTHORIZE,
PaymentMethodNonce = Nonce.Coinbase
};
Result<Transaction> result = gateway.Transaction.Sale(request);
Assert.IsTrue(result.IsSuccess());
CoinbaseDetails details = result.Target.CoinbaseDetails;
Assert.IsNotNull(details);
Assert.AreNotEqual("", details.UserEmail);
Assert.IsNotNull(details.UserEmail);
Assert.AreNotEqual("", details.UserName);
Assert.IsNotNull(details.UserName);
Assert.AreNotEqual("", details.UserId);
Assert.IsNotNull(details.UserId);
}
private static void sampleQuickAuth()
{
try {
// four lines are all it takes to send in a transaction:
CreditCard cReq = new CreditCard("visa", "4242424242424242", "0609", "Andrew Harcourt", "123", CreditCard.CVN_PRESENT);
String orderID = DateTime.Now.ToString("yyyyMMddHHmmss");
TransactionRequest tReq = new TransactionRequest("realexsample", "secret", "secret", "secret");
TransactionResponse tResp = tReq.Authorize("internet", orderID, "EUR", 4133, cReq);
if (tResp.ResultCode == 0) { // success
//TODO: Your code goes here.
} else { // failure
//Check the Realex Developer Documentation for transaction result codes.
//TODO: Your code goes here.
}
} catch (DataValidationException e) {
// transaction not submitted
//TODO: Your exception-handling code goes here.
Console.WriteLine("Transaction not submitted: " + e.Message);
} catch (TransactionFailedException e) {
// transaction failed
//TODO: Your exception-handling code goes here.
Console.WriteLine("Transaction failed: " + e.Message);
} catch (Exception e) {
// something else bad happened
//TODO: Your exception-handling code goes here.
Console.WriteLine("Unhandled exception: " + e.Message);
}
}
public void ToXML_EnsuresUSLocaleForDecimals()
{
System.Globalization.CultureInfo existingCulture = System.Globalization.CultureInfo.CurrentCulture;
try
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.GetCultureInfo("it-IT");
TransactionRequest transactionRequest = new TransactionRequest
{
Amount = 100.0M
};
SubscriptionRequest subscriptionRequest = new SubscriptionRequest
{
Price = 200.0M,
};
SubscriptionTransactionRequest subscriptionTransactionRequest = new SubscriptionTransactionRequest
{
Amount = 300.0M
};
ModificationRequest modificationRequest = new ModificationRequest
{
Amount = 400.0M
};
TestHelper.AssertIncludes("<amount>100.0</amount>", transactionRequest.ToXml());
TestHelper.AssertIncludes("<price>200.0</price>", subscriptionRequest.ToXml());
TestHelper.AssertIncludes("<amount>300.0</amount>", subscriptionTransactionRequest.ToXml());
TestHelper.AssertIncludes("<amount>400.0</amount>", modificationRequest.ToXml("root"));
}
finally
{
System.Threading.Thread.CurrentThread.CurrentCulture = existingCulture;
}
}
/// <summary>
/// Process a payment
/// </summary>
/// <param name="processPaymentRequest">Payment info required for an order processing</param>
/// <returns>Process payment result</returns>
public async Task <ProcessPaymentResult> ProcessPayment(ProcessPaymentRequest processPaymentRequest)
{
var processPaymentResult = new ProcessPaymentResult();
//get customer
var customer = await _customerService.GetCustomerById(processPaymentRequest.CustomerId);
//get settings
var useSandBox = _brainTreePaymentSettings.UseSandBox;
var merchantId = _brainTreePaymentSettings.MerchantId;
var publicKey = _brainTreePaymentSettings.PublicKey;
var privateKey = _brainTreePaymentSettings.PrivateKey;
//new gateway
var gateway = new BraintreeGateway {
Environment = useSandBox ? Environment.SANDBOX : Environment.PRODUCTION,
MerchantId = merchantId,
PublicKey = publicKey,
PrivateKey = privateKey
};
//new transaction request
var transactionRequest = new TransactionRequest {
Amount = processPaymentRequest.OrderTotal,
};
if (_brainTreePaymentSettings.Use3DS)
{
transactionRequest.PaymentMethodNonce = processPaymentRequest.CustomValues["CardNonce"].ToString();
}
else
{
//transaction credit card request
var transactionCreditCardRequest = new TransactionCreditCardRequest {
Number = processPaymentRequest.CreditCardNumber,
CVV = processPaymentRequest.CreditCardCvv2,
ExpirationDate = processPaymentRequest.CreditCardExpireMonth + "/" + processPaymentRequest.CreditCardExpireYear
};
transactionRequest.CreditCard = transactionCreditCardRequest;
}
//address request
var addressRequest = new AddressRequest {
FirstName = customer.BillingAddress.FirstName,
LastName = customer.BillingAddress.LastName,
StreetAddress = customer.BillingAddress.Address1,
PostalCode = customer.BillingAddress.ZipPostalCode
};
transactionRequest.BillingAddress = addressRequest;
//transaction options request
var transactionOptionsRequest = new TransactionOptionsRequest {
SubmitForSettlement = true
};
transactionRequest.Options = transactionOptionsRequest;
//sending a request
var result = gateway.Transaction.Sale(transactionRequest);
//result
if (result.IsSuccess())
{
processPaymentResult.NewPaymentStatus = PaymentStatus.Paid;
}
else
{
processPaymentResult.AddError("Error processing payment." + result.Message);
}
return(processPaymentResult);
}
public ActionResult <TransactionResponse> Post([FromBody] TransactionRequest request)
{
var result = transactionService.Add(request);
return(Ok(result));
}
public void Add_Transactions_To_Portfolio_With_Property()
{
var uuid = Guid.NewGuid().ToString();
var propertyName = $"fund-style-{uuid}";
var labelValue = "A Trader";
// Effective date of the trades. All dates/times must be supplied in UTC
var effectiveDate = new DateTimeOffset(2018, 1, 1, 0, 0, 0, TimeSpan.Zero);
// Details of the property to be created
var propertyDefinition = new CreatePropertyDefinitionRequest(
// The domain the property is to be applied to
domain: CreatePropertyDefinitionRequest.DomainEnum.Transaction,
// The scope the property will be created in
scope: TestDataUtilities.TutorialScope,
// When the property value is set it will be valid forever and cannot be changed.
// Properties whose values can change over time should be created with LifeTimeEnum.TIMEVARIANT
lifeTime: CreatePropertyDefinitionRequest.LifeTimeEnum.Perpetual,
code: propertyName,
valueRequired: false,
displayName: "Trader Id",
dataTypeId: new ResourceId("system", "string")
);
// Create the property definition
var propertyDefinitionResult = _apiFactory.Api <IPropertyDefinitionsApi>().CreatePropertyDefinition(propertyDefinition);
// Create the property value
var propertyValue = new PerpetualProperty(propertyDefinitionResult.Key, new PropertyValue(labelValue));
// Create a portfolio
var portfolioId = _testDataUtilities.CreateTransactionPortfolio(TutorialScope);
// Details of the transaction to be added
var transaction = new TransactionRequest(
// Unique transaction id
transactionId: Guid.NewGuid().ToString(),
// Transaction type, configured during system setup
type: "Buy",
// Instrument identifier for the trnasaction
instrumentIdentifiers: new Dictionary <string, string>
{
["Instrument/default/LusidInstrumentId"] = _instrumentIds.First()
},
// The properties to be added to the transaction
properties: new Dictionary <string, PerpetualProperty>
{
[propertyDefinitionResult.Key] = propertyValue
},
transactionDate: effectiveDate,
settlementDate: effectiveDate,
units: 100,
transactionPrice: new TransactionPrice(12.3, TransactionPrice.TypeEnum.Price),
totalConsideration: new CurrencyAndAmount(1230, "GBP"),
source: "Custodian"
);
// Add the transaction to the portfolio
_apiFactory.Api <ITransactionPortfoliosApi>().UpsertTransactions(TutorialScope, portfolioId, new List <TransactionRequest> {
transaction
});
// Retrieve the transaction
var transactions = _apiFactory.Api <ITransactionPortfoliosApi>().GetTransactions(TutorialScope, portfolioId);
Assert.That(transactions.Values.Count, Is.EqualTo(1));
Assert.That(transactions.Values[0].InstrumentUid, Is.EqualTo(transaction.InstrumentIdentifiers.First().Value));
Assert.That(transactions.Values[0].Properties.First().Value.Value.LabelValue, Is.EqualTo(labelValue));
}
public static string DoPurchase(string nonce, string uid, string pid)
{
string btCustomer = UserIDToCustomerId(uid);
Customer c = null;
try { c = Gateway.Customer.Find(btCustomer); } catch (Exception) { }
/*
* try
* {
* if (c == null)
* {
* Result<Customer> cr = Gateway.Customer.Create(new CustomerRequest() { CustomerId = btCustomer, PaymentMethodNonce = nonce });
* ServerCore.LogThread.GetLog().Log(NetworkCore.LogInterface.LogMessageType.System, true, "Braintree create customer: " + cr.Message);
* }
* else
* {
* Result<Customer> cr = Gateway.Customer.Update(btCustomer, new CustomerRequest() { CustomerId = btCustomer, PaymentMethodNonce = nonce });
* ServerCore.LogThread.GetLog().Log(NetworkCore.LogInterface.LogMessageType.System, true, "Braintree update customer: " + cr.Message);
* }
* }
* catch (Exception) { }
*/
NetworkCore.GlobalProduct p = Marketplace.Instance.GetProduct(pid);
var request = new TransactionRequest
{
Amount = (decimal)p.USD,
PaymentMethodNonce = nonce,
Options = new TransactionOptionsRequest
{
SubmitForSettlement = true,
StoreInVaultOnSuccess = true
}
};
if (c == null)
{
request.Customer = new CustomerRequest()
{
Id = btCustomer
}
}
;
else
{
request.CustomerId = btCustomer;
}
Result <Transaction> result = Gateway.Transaction.Sale(request);
if (result.IsSuccess())
{
string transactionJson = Newtonsoft.Json.JsonConvert.SerializeObject(result.Target);
Marketplace.Instance.FinalizeProductPurchase(uid, pid, transactionJson);
return(transactionJson);
}
return(result.Message);
}
public ActionResult <TransactionResponse> Post([FromBody] TransactionRequest transactionRequest)
{
// Idempotency check...if we've seen this transaction before, we'll
// return the prior response.
TransactionResponse response = GetCachedTransactionResponse(transactionRequest.transactionKey);
if (response != null)
{
return(response);
}
// For demonstration purposes, we'll automatically fail any GL transaction...a live
// system would access the banking core and generate a response based on that
// access.
try
{
// NOTE: not all banking cores handle memo posting. This sample
// real time banking interface is for illustration purposes. If your
// core doesn't handle memo posts or GL transactions, by all means
// create a real time interface that works well with your core.
// Just keep in mind your API consumer likely cannot deal with
// core-specific concepts and constructs (e.g.: CIF information),
// so your real time interface (this code) must translate that
// information into common structures (e.g.: strings, integers...).
response = new TransactionResponse
{
transactionKey = transactionRequest.transactionKey,
description = "Transaction successful"
};
if (transactionRequest.transactionType == TransactionRequest.TransactionTypes.DebitGL ||
transactionRequest.transactionType == TransactionRequest.TransactionTypes.CreditGL)
{
// NOTE: in failure case, HTTP RFP says to return 200 with failure
// indication in response body. However, if you can't imagine not
// returning a failure status, return some 4xx value (but probably
// not 401/403 unless those are the cause of the failure). We will
// check both cases.
response.success = false;
response.description = response.errorMessage = "Failure: cannot transact GL accounts";
}
if (transactionRequest.transactionType == TransactionRequest.TransactionTypes.CreditDDA)
{
// Reversal
response.description = "Transaction reversal successful";
}
// With a memo post we need a check number (at least for this sample
// application).
if (transactionRequest.transactionType == TransactionRequest.TransactionTypes.MemoPost)
{
if (transactionRequest.checkNumber.HasValue)
{
response.description = "Memo post successful";
}
else
{
response.success = false;
response.description = response.errorMessage = "Failure: must provide a check number when issuing a memo post";
}
}
}
catch (Exception ex)
{
// NOTE: you may not want to return the actual exception...
// by all means return what makes sense and is secure.
response = new TransactionResponse(ex);
HttpContext.Response.StatusCode = StatusCodes.Status500InternalServerError;
}
// New (successful) transaction, so add to our cache...we won't
// add errored transactions since the client could (should)
// correct the condition and re-submit. In that case we don't
// want to return the prior error.
if (response.success)
{
AddTransactionResponseToCache(response);
}
return(response);
}
public ServiceResultEnum SendTransactionRequest(ref PaymentInformation payment)
{
var request = new TransactionRequest
{
OrderId = payment.OrderId,
Amount = payment.Amount,
TaxExempt = true,
CreditCard = new TransactionCreditCardRequest
{
Number = payment.CreditCardNumber,
CVV = payment.CreditCardCvv,
ExpirationMonth = payment.CreditCardExpireMonth,
ExpirationYear = payment.CreditCardExpireYear
},
Customer = new CustomerRequest
{
Id = payment.CustomerId,
FirstName = payment.CustomerNameFirst,
LastName = payment.CustomerNameLast,
Email = payment.CustomerEmail,
Phone = payment.CustomerPhone,
Website = payment.CustomerWebsite
},
BillingAddress = new AddressRequest
{
FirstName = payment.BillingNameFirst,
LastName = payment.BillingNameLast,
StreetAddress = payment.BillingAddressStreet,
ExtendedAddress = payment.BillingAddressStreet2,
Locality = payment.BillingAddressLocality,
Region = payment.BillingAddressRegion,
PostalCode = payment.BillingAddressPostalCode,
CountryCodeAlpha2 = "US"
},
Options = new TransactionOptionsRequest
{
StoreInVaultOnSuccess = payment.OptionStoreInVault,
AddBillingAddressToPaymentMethod = true,
SubmitForSettlement = payment.OptionSubmitForSettlement,
StoreShippingAddressInVault = payment.OptionStoreInVault
},
CustomFields = new Dictionary <string, string>
{
{ "transaction_desc", payment.TransactionDescription }
}
};
if (payment.ShippingAddressStreet.IsNullOrEmpty())
{
request.ShippingAddress = new AddressRequest
{
FirstName = payment.ShippingNameFirst,
LastName = payment.ShippingNameLast,
StreetAddress = payment.ShippingAddressStreet,
ExtendedAddress = payment.ShippingAddressStreet2,
Locality = payment.ShippingAddressLocality,
Region = payment.ShippingAddressRegion,
PostalCode = payment.ShippingAddressPostalCode,
CountryCodeAlpha2 = "US"
};
}
var result = Constants.BraintreeGateway.Transaction.Sale(request);
payment.IsSuccess = result.IsSuccess();
ServiceResult = payment.IsSuccess ? ServiceResultEnum.Success : ServiceResultEnum.Failure;
payment.TransactionResult = result;
return(ServiceResult);
}
public async Task <ActionResult <BroadcastedSingleTransactionResponse> > GetSingleTransactionState(
TransactionRequest request)
{
var txState = await _transactionService.TryGetTransactionAsync(request.TransactionId);
if (txState != null)
{
var response = new BroadcastedSingleTransactionResponse
{
Amount = txState.Amount.ToString(),
Block = txState.BlockNumber.HasValue ? (long)txState.BlockNumber.Value : 0,
Fee = (txState.GasAmount * txState.GasPrice).ToString(),
Hash = txState.Hash,
OperationId = txState.TransactionId
};
if (txState.State == TransactionState.Built || txState.State == TransactionState.Deleted)
{
return(NoContent());
}
if (txState.State == TransactionState.InProgress || !txState.IsConfirmed)
{
response.State = BroadcastedTransactionState.InProgress;
response.Timestamp = txState.BuiltOn;
return(response);
}
// ReSharper disable once SwitchStatementMissingSomeCases
switch (txState.State)
{
case TransactionState.Completed:
response.State = BroadcastedTransactionState.Completed;
break;
case TransactionState.Failed:
response.State = BroadcastedTransactionState.Failed;
break;
}
if (txState.CompletedOn.HasValue)
{
response.Timestamp = txState.CompletedOn.Value;
}
if (txState.BlockNumber.HasValue)
{
response.Block = (long)txState.BlockNumber.Value;
}
if (!string.IsNullOrEmpty(txState.Error))
{
response.Error = txState.Error;
response.ErrorCode = BlockchainErrorCode.Unknown;
}
return(response);
}
else
{
return(NoContent());
}
}
public async Task <IActionResult> ConfirmWaitingVerification([FromBody] TransactionRequest req)
{
TransactionResponse response = new TransactionResponse();
try
{
string bearer = Request.HttpContext.Request.Headers["Authorization"];
string token = bearer.Substring("Bearer ".Length).Trim();
string username = string.Empty;
if (string.IsNullOrEmpty(token))
{
response.IsSuccess = false;
response.Message = "You don't have access.";
return(BadRequest(response));
}
username = sec.ValidateToken(token);
if (username == null)
{
Response.HttpContext.Response.Cookies.Append("access_token", "", new CookieOptions()
{
Expires = DateTime.Now.AddDays(-1)
});
response.IsSuccess = false;
response.Message = "Your session was expired, please re-login.";
return(BadRequest(response));
}
req.UserName = username;
var responseUserUpdate = usrFacade.UpdateFromWaitingVerification(req.Email, req.Name, req.Telp, req.Alamat, req.Instagram, req.Facebook, req.UserName).Result;
if (!responseUserUpdate.IsSuccess)
{
response.IsSuccess = false;
responseUserUpdate.Message = "Your session was expired, please re-login.";
return(BadRequest(response));
}
response = await facade.ApproveTransaction(req);
if (response.IsSuccess)
{
#region Sent Email to User
TransactionResponse transResp = await facade.GetCurrentTransaction(req);
int levelID = transResp.ListTransaction.FirstOrDefault().TrasanctionLevel.ID;
SendEmail sendEmail = new SendEmail(_emailConfiguration);
string contentEmail = string.Empty;
string subjectEmail = string.Empty;
AuthenticationResponse authResp = await facade.GetUserProfile(username);
EmailAddress emailAddress = new EmailAddress();
switch (levelID)
{
case 1:
contentEmail = configFacade.GetRedaksionalEmail("ContentEmailBuy").Result;
subjectEmail = configFacade.GetRedaksionalEmail("SubjectEmailBuy").Result;
break;
case 2:
contentEmail = configFacade.GetRedaksionalEmail("ContentEmailVerifikasi").Result;
subjectEmail = configFacade.GetRedaksionalEmail("SubjectEmailVerifikasi").Result;
break;
case 3:
contentEmail = configFacade.GetRedaksionalEmail("ContentEmailVisit").Result;
subjectEmail = configFacade.GetRedaksionalEmail("SubjectEmailVisit").Result;
break;
case 4:
contentEmail = configFacade.GetRedaksionalEmail("ContentEmailDP").Result;
subjectEmail = configFacade.GetRedaksionalEmail("SubjectEmailDP").Result;
break;
case 5:
contentEmail = configFacade.GetRedaksionalEmail("ContentEmailBBN").Result;
subjectEmail = configFacade.GetRedaksionalEmail("SubjectEmailBBN").Result;
break;
case 6:
contentEmail = configFacade.GetRedaksionalEmail("ContentEmailSTNK").Result;
subjectEmail = configFacade.GetRedaksionalEmail("SubjectEmailSTNK").Result;
break;
case 7:
contentEmail = configFacade.GetRedaksionalEmail("ContentEmailPelunasan").Result;
subjectEmail = configFacade.GetRedaksionalEmail("SubjectEmailPelunasan").Result;
break;
case 8:
contentEmail = configFacade.GetRedaksionalEmail("ContentEmailDelivery").Result;
subjectEmail = configFacade.GetRedaksionalEmail("SubjectEmailDelivery").Result;
break;
}
emailAddress.Address = username;
emailAddress.Name = authResp.Name;
List <EmailAddress> listEmailAddress = new List <EmailAddress>();
listEmailAddress.Add(emailAddress);
contentEmail = contentEmail.Replace("[user]", emailAddress.Name);
EmailAddress emailAddressFrom = new EmailAddress();
emailAddressFrom.Address = "*****@*****.**";
emailAddressFrom.Name = "Lojualguebeli.com";
List <EmailAddress> listEmailAddressFrom = new List <EmailAddress>();
listEmailAddressFrom.Add(emailAddressFrom);
EmailMessage emailMessage = new EmailMessage();
emailMessage.ToAddresses = listEmailAddress;
emailMessage.Subject = subjectEmail;
emailMessage.FromAddresses = listEmailAddressFrom;
emailMessage.Content = contentEmail;
sendEmail.Send(emailMessage);
#endregion
}
return(Ok(response));
}
catch (Exception ex)
{
if (ex.GetType().FullName ==
"Microsoft.EntityFrameworkCore.DbUpdateConcurrencyException")
{
return(NotFound());
}
return(BadRequest());
}
}
public ActionResult SubmitContact(FormCollection form)
{
Decimal planamount = 0, smscreditamount = 0, amount = 0;
if (form["hdnamount"] != null && form["hdnamount"] != "")
{
planamount = Convert.ToDecimal(form["hdnamount"]);
}
if (form["hdnsmscreditotaltamount"] != null && form["hdnsmscreditotaltamount"] != "")
{
smscreditamount = Convert.ToDecimal(form["hdnsmscreditotaltamount"]);
}
amount = planamount + smscreditamount;
#region Fetching CabOfficeAccount
var accountid = "";
if (form["hdnaccount"] != null)
{
accountid = form["hdnaccount"].ToString();
}
AccountService accountService = new AccountService();
Account account = accountService.getCabOfficeByAccountId(accountid);
if (account == null)
{
return(View());
}
#endregion
#region Payment Initilizer
bool saleResult;
Braintree.Environment environment;
if (ConfigurationManager.AppSettings["BtEnvironmentTestMode"].ToString() == "1")
{
environment = Braintree.Environment.SANDBOX;
}
else
{
environment = Braintree.Environment.PRODUCTION;
}
var gateway = new BraintreeGateway
{
Environment = environment,
MerchantId = ConfigurationManager.AppSettings["BtMerchantId"],
PublicKey = ConfigurationManager.AppSettings["BtPublicKey"],
PrivateKey = ConfigurationManager.AppSettings["BtPrivateKey"]
};
#endregion
#region Generate BTCustomer, token and Nonce
String nonce_Generated = "";
if (account.BtCustomerId == null || account.BtCustomerId == "")
{
/// Create Customer
///
var requestc = new CustomerRequest
{
FirstName = account.FullName,
LastName = account.FullName,
Company = "",
Email = account.Email,
Fax = "",
Phone = "",
Website = ""
};
Result <Customer> resultc = gateway.Customer.Create(requestc);
string customerId = resultc.Target.Id;
/// Create PaymentMethod
///
var nonce = Request["payment_method_nonce"];
var requestP = new PaymentMethodRequest
{
CustomerId = customerId,
PaymentMethodNonce = nonce
};
Result <PaymentMethod> resultP = gateway.PaymentMethod.Create(requestP);
Result <PaymentMethodNonce> resultN = gateway.PaymentMethodNonce.Create(resultP.Target.Token);
nonce_Generated = resultN.Target.Nonce;
/// Update BtCustoemrId and BtToken in CabOfficeAccount
///
accountService.UpdateBrainTreeInfo(customerId, resultP.Target.Token, account.Id);
}
else
{
Result <PaymentMethodNonce> resultN = gateway.PaymentMethodNonce.Create(account.BtPaymentMethodToken);
nonce_Generated = resultN.Target.Nonce;
}
#endregion
#region Sale
var request = new TransactionRequest
{
Amount = amount,
PaymentMethodNonce = nonce_Generated,
Options = new TransactionOptionsRequest
{
SubmitForSettlement = true
}
};
Result <Transaction> result = gateway.Transaction.Sale(request);
bool resultVal = result.IsSuccess();
Transaction transaction = result.Target;
#endregion
if (resultVal)
{
bool chkautorenewel = false;
var bit = "off";
if (form["chkautorenewel"] != null)
{
bit = form["chkautorenewel"].ToString();
}
if (bit == "on")
{
chkautorenewel = true;
}
SubscriptionService subscriptionService = new SubscriptionService();
int qty = 1;
if (form["qty"] != null && form["qty"] != "")
{
qty = Convert.ToInt32(form["qty"]);
}
int smscreditqty = 0;
if (form["smscreditqty"] != null && form["smscreditqty"] != "")
{
smscreditqty = Convert.ToInt32(form["smscreditqty"]);
}
double hdnsmscreditamount = 0;
if (form["hdnsmscreditamount"] != null && form["hdnsmscreditamount"] != "")
{
hdnsmscreditamount = Convert.ToDouble(form["hdnsmscreditamount"]);
}
int accountId = 1;
if (account != null)
{
accountId = account.Id;
}
int planId = 0;
if (form["hdnplanid"] != null)
{
planId = Convert.ToInt32(form["hdnplanid"].ToString());
}
int subscriptionId = subscriptionService.PurchaseSubscription(planId, Convert.ToDouble(amount),
accountId, qty, "", smscreditqty, hdnsmscreditamount,
transaction.Id, "", chkautorenewel, 0);
if (chkautorenewel == true)
{
/// Mark Hangfire Service
AutomatedService automatedService = new AutomatedService();
RecurringJob.AddOrUpdate(() => automatedService.MarkAutoRenewalSubscription(subscriptionId, null), Cron.Minutely);
////// Insert into execution service
WindowsServiceExecution winservice = new WindowsServiceExecution();
winservice.WindowsServiceFunction = "Automatic Charging";
winservice.WindowsServiceArgumrnt = subscriptionId;
winservice.WindowsServiceFunctionCode = (int)Constant.WindowsFunction.AutomaticCharging;
winservice.WindowsServiceStatus = (int)Constant.WindowsServiceExecutionStatus.Pending;
winservice.IsActive = true;
winservice.CreatedDate = DateTime.Now;
//WindowsServiceExecutionService windowsServiceExecutionService = new WindowsServiceExecutionService();
//windowsServiceExecutionService.InsertWindowsServiceExecutionService(winservice);
}
return(RedirectToAction("Thankyou"));
}
else
{
return(RedirectToAction("CustomError?type=btpayment"));
}
}
public async Task <IActionResult> Checkout(CheckoutViewModel model, string braintreeNonce)
{
string username = null;
int? anonymousIdentifier = null;
Cart cart = null;
ApplicationUser customer = null;
if (User.Identity.IsAuthenticated) //All controllers and views have a "User" property which I can check. This returns True if they are logged in, false otherwise
{
username = User.Identity.Name; //I can track carts by user name
customer = _context.Users.Include(x => x.Carts).ThenInclude(x => x.ShipCarts).ThenInclude(x => x.Ship).Include(x => x.Carts).ThenInclude(x => x.WeaponCarts).ThenInclude(x => x.Weapon).Include(x => x.Carts).ThenInclude(x => x.ArmorCarts).ThenInclude(x => x.Armor).FirstOrDefault(x => x.UserName == username);
cart = customer.Carts.FirstOrDefault();
}
else
{
anonymousIdentifier = null;
if (Request.Cookies.ContainsKey(ANONYMOUS_IDENTIFIER))
{
anonymousIdentifier = int.Parse(Request.Cookies[ANONYMOUS_IDENTIFIER]);
}
else
{
anonymousIdentifier = int.Parse(Guid.NewGuid().ToString());
Response.Cookies.Append(ANONYMOUS_IDENTIFIER, anonymousIdentifier.ToString());
}
cart = _context.Carts.Include(x => x.ShipCarts).ThenInclude(x => x.Ship).Include(x => x.WeaponCarts).ThenInclude(x => x.Weapon).Include(x => x.ArmorCarts).ThenInclude(x => x.Armor).FirstOrDefault(c => c.CookieId == anonymousIdentifier);
}
if (ModelState.IsValid)
{
TransactionRequest transactionRequest = new TransactionRequest
{
Amount = cart.WeaponCarts.Sum(x => x.Quantity * x.Weapon.Price) + cart.ArmorCarts.Sum(x => x.Quantity * x.Armor.Price) + cart.ShipCarts.Sum(x => x.Quantity * x.Ship.Price),
PaymentMethodNonce = braintreeNonce
};
var transactionResult = await _braintreeGateway.Transaction.SaleAsync(transactionRequest);
if (transactionResult.IsSuccess())
{
Order order = new Order
{
ContactEmail = model.Email,
ContactPhoneNumber = model.PhoneNumber,
ShippingStreet1 = model.Street1,
ShippingStreet2 = model.Street2,
ShippingCity = model.City,
ShippingState = model.State,
ShippingPostalCode = model.PostalCode,
PlacementDate = DateTime.UtcNow,
TrackingNumber = Guid.NewGuid().ToString().Substring(0, 8),
SubTotal = cart.WeaponCarts.Sum(x => x.Quantity * x.Weapon.Price) + cart.ArmorCarts.Sum(x => x.Quantity * x.Armor.Price) + cart.ShipCarts.Sum(x => x.Quantity * x.Ship.Price),
Total = cart.WeaponCarts.Sum(x => x.Quantity * x.Weapon.Price) + cart.ArmorCarts.Sum(x => x.Quantity * x.Armor.Price) + cart.ShipCarts.Sum(x => x.Quantity * x.Ship.Price),
ArmorOrders = cart.ArmorCarts.Select(cartItem => new ArmorOrder
{
Quantity = cartItem.Quantity,
ArmorId = cartItem.ArmorId
}).ToArray(),
WeaponOrders = cart.WeaponCarts.Select(cartItem => new WeaponOrder
{
Quantity = cartItem.Quantity,
WeaponId = cartItem.WeaponId
}).ToArray(),
ShipOrders = cart.ShipCarts.Select(cartItem => new ShipOrder
{
Quantity = cartItem.Quantity,
ShipId = cartItem.ShipId
}).ToArray(),
};
_context.Orders.Add(order);
_context.Carts.Remove(cart);
Response.Cookies.Delete(ANONYMOUS_IDENTIFIER);
_context.SaveChanges();
/*var message = new SendGrid.Helpers.Mail.SendGridMessage
* {
* From = new SendGrid.Helpers.Mail.EmailAddress(
* "*****@*****.**", "N7 Administration"),
* Subject = "Receipt for order #" + order.TrackingNumber,
* HtmlContent = "Thanks for your order!"
* };
* message.AddTo(model.Email);*/
await _emailSender.SendEmailAsync(
model.Email,
"Receipt for order #" + order.TrackingNumber,
"Thanks for your order!"
);
//The "actionname" i.e. the first argument must be the actual name of the view. So my receipt controller, has a method called Receipt, which is the view name.
return(RedirectToAction("Receipt", "Receipt", new { id = order.TrackingNumber }));
}
}
return(View());
}
public async Task <IActionResult> Index(Checkout model)
{
await GetCurrentCart(model);
model.Addresses = new Address[0];
if (ModelState.IsValid)
{
if (!string.IsNullOrEmpty(model.SavedAddressId) ||
(!string.IsNullOrEmpty(model.ShippingAddressLine1) && !string.IsNullOrEmpty(model.ShippingLocale) &&
!string.IsNullOrEmpty(model.ShippingRegion) && !string.IsNullOrEmpty(model.ShippingPostalCode) && !string.IsNullOrEmpty(model.ShippingCountry)))
{
Order neworder = new Order
{
TrackingNumber = Guid.NewGuid().ToString(),
OrderDate = DateTime.Now,
OrderItems = model.Cart.CartItems.Select(x => new OrderItem
{
ProductID = x.Product.ID,
ProductName = x.Product.Name,
ProductPrice = (x.Product.Price ?? 0),
Quantity = x.Quantity
}).ToArray(),
AddressLine1 = model.ShippingAddressLine1,
AddressLine2 = model.ShippingAddressLine2,
Country = model.ShippingCountry,
Email = model.ContactEmail,
PhoneNumber = model.ContactPhoneNumber,
Locale = model.ShippingLocale,
PostalCode = model.ShippingPostalCode,
Region = model.ShippingRegion
};
Braintree.Customer customer = null;
Braintree.CustomerSearchRequest search = new Braintree.CustomerSearchRequest();
search.Email.Is(model.ContactEmail);
var searchResult = await _brainTreeGateway.Customer.SearchAsync(search);
if (searchResult.Ids.Count == 0)
{
//Create a new Braintree Customer
Braintree.Result <Customer> creationResult = await _brainTreeGateway.Customer.CreateAsync(new Braintree.CustomerRequest
{
Email = model.ContactEmail,
Phone = model.ContactPhoneNumber
});
customer = creationResult.Target;
}
else
{
customer = searchResult.FirstItem;
}
CreditCard creditCard = null;
if (model.SaveBillingCard)
{
var newCardRequest = new CreditCardRequest
{
CardholderName = model.BillingNameOnCard,
CustomerId = customer.Id,
ExpirationMonth = model.BillingCardExpirationMonth.ToString().PadLeft(2, '0'),
ExpirationYear = model.BillingCardExpirationYear.ToString(),
Number = model.BillingCardNumber,
CVV = model.BillingCardVerificationValue
};
var newCardResult = await _brainTreeGateway.CreditCard.CreateAsync(newCardRequest);
if (newCardResult.IsSuccess())
{
creditCard = newCardResult.Target;
}
}
Address savedAddress = null;
if (model.SaveShippingAddress)
{
var newAddressRequest = new AddressRequest
{
StreetAddress = model.ShippingAddressLine1,
ExtendedAddress = model.ShippingAddressLine2,
CountryName = model.ShippingCountry,
PostalCode = model.ShippingPostalCode,
Locality = model.ShippingLocale,
Region = model.ShippingRegion
};
var newAddressResult = await _brainTreeGateway.Address.CreateAsync(customer.Id, newAddressRequest);
if (newAddressResult.IsSuccess())
{
savedAddress = newAddressResult.Target;
}
}
TransactionRequest transaction = new TransactionRequest
{
Amount = model.Cart.CartItems.Sum(x => x.Quantity * (x.Product.Price ?? 0)),
CustomerId = customer.Id,
LineItems = model.Cart.CartItems.Select(x => new TransactionLineItemRequest
{
Name = x.Product.Name,
Description = x.Product.Description,
ProductCode = x.Product.ID.ToString(),
Quantity = x.Quantity,
LineItemKind = TransactionLineItemKind.DEBIT,
UnitAmount = x.Product.Price * x.Quantity,
TotalAmount = x.Product.Price * x.Quantity
}).ToArray()
};
if (creditCard == null)
{
transaction.CreditCard = new TransactionCreditCardRequest
{
Number = model.BillingCardNumber,
CardholderName = model.BillingNameOnCard,
CVV = model.BillingCardVerificationValue,
ExpirationMonth = model.BillingCardExpirationMonth.ToString().PadLeft(2, '0'),
ExpirationYear = model.BillingCardExpirationYear.ToString()
};
}
else
{
transaction.PaymentMethodToken = creditCard.Token;
}
if (savedAddress != null)
{
transaction.ShippingAddressId = savedAddress.Id;
}
var transactionResult = await _brainTreeGateway.Transaction.SaleAsync(transaction);
if (transactionResult.IsSuccess())
{
_context.Orders.Add(neworder);
_context.CartItems.RemoveRange(model.Cart.CartItems);
_context.Carts.Remove(model.Cart);
await _context.SaveChangesAsync();
Response.Cookies.Delete("cartId");
RegisterViewModel regModel = new RegisterViewModel();
var plainText = "Thanks for signing up, " + regModel.FirstName + "!";
var htmlText = "<p> Thanks for Shopping with us, " + regModel.FirstName + "!</p>";
await _emailService.SendEmailAsync(model.ContactEmail, "Your Receipt", htmlText, plainText);
return(RedirectToAction("Confirmation", "Checkout", new { id = neworder.TrackingNumber }));
}
for (int i = 0; i < transactionResult.Errors.Count; i++)
{
ModelState.AddModelError("BillingCardNumber" + i, transactionResult.Errors.All()[i].Message);
}
}
//#region use the SendGrid client to send a welcome email
//var client = new SendGrid.SendGridClient(_sendGridKey);
//var senderAddress = new SendGrid.Helpers.Mail.EmailAddress("*****@*****.**", "Organic-Farm Store");
//var subject = "Your Receipt";
//var to = new SendGrid.Helpers.Mail.EmailAddress(emailReceipt.Email, emailReceipt.Email);
//var plainText = "Thanks for signing up, " + emailReceipt.FirstName + "!";
//var htmlText = "<p> Thanks for Shopping with us, " + emailReceipt.FirstName + "!</p>";
//var message = SendGrid.Helpers.Mail.MailHelper.CreateSingleEmail(senderAddress, to, subject, plainText, htmlText);
//var mailResult = await client.SendEmailAsync(message);
//if ((mailResult.StatusCode == System.Net.HttpStatusCode.OK) || (mailResult.StatusCode == System.Net.HttpStatusCode.Accepted))
//{
// return RedirectToAction("Confirmation");
//}
//else
//{
// return BadRequest(await mailResult.Body.ReadAsStringAsync());
//}
//#endregion
}
return(View(model));
}
public GetTransactionsMethod(int identifier, TransactionRequest request)
: this(identifier)
{
this.Parameters.Add(request);
}
/// <summary>
/// Envia uma requisição-transacao com os dados especificados
/// </summary>
/// <param name="transaction">Detalhes da transação</param>
/// <returns>>Uma instância de Transaction com a resposta da requisição</returns>
public Transaction transactionRequest(Transaction transaction)
{
TransactionRequest request = TransactionRequest.create(transaction);
return(TransacaoElement.unserialize(transaction, sendHttpRequest(serialize(request))));
}
private MicroCoin.Transactions.TransferTransaction TransactionRequestToTransaction(TransactionRequest data)
{
AccountDTO account = client.GetAccount(data.Sender);
string pubkey = account.EncPubKey;
PublicKeyDTO key = client.DecodePubKey(pubkey, null);
return(new MicroCoin.Transactions.TransferTransaction
{
Amount = (ulong)(data.Amount * 10000),
Fee = (ulong)(data.Fee * 10000M),
Payload = data.Payload,
SignerAccount = data.Sender,
TargetAccount = data.Target,
TransactionStyle = MicroCoin.Transactions.TransferTransaction.TransferType.Transaction,
TransactionType = MicroCoin.Transactions.TransactionType.Transaction,
NumberOfOperations = client.GetAccount(data.Sender).NumOperations + 1,
AccountKey = new ECKeyPair
{
CurveType = CurveType.Secp256K1,
PublicKey = new ECPoint
{
X = (Hash)key.X,
Y = (Hash)key.Y,
}
}
});
}
public async Task <IActionResult> SubmitSell([FromBody] TransactionRequest request)
{
try
{
TransactionResponse response = new TransactionResponse();
string bearer = Request.HttpContext.Request.Headers["Authorization"];
string token = bearer.Substring("Bearer ".Length).Trim();
string username = string.Empty;
if (string.IsNullOrEmpty(token))
{
response.IsSuccess = false;
response.Message = "You don't have access.";
return(BadRequest(response));
}
username = sec.ValidateToken(token);
if (username == null)
{
Response.HttpContext.Response.Cookies.Append("access_token", "", new CookieOptions()
{
Expires = DateTime.Now.AddDays(-1)
});
response.IsSuccess = false;
response.Message = "Your session was expired, please re-login.";
return(BadRequest(response));
}
response = await facade.SubmitSell(request.BarangID, request.Harga, username);
if (response.IsSuccess)
{
#region Sent Email to User
SendEmail sendEmail = new SendEmail(_emailConfiguration);
string contentEmail = configFacade.GetRedaksionalEmail("ContentEmailBuy").Result;
string subjectEmail = configFacade.GetRedaksionalEmail("SubjectEmailBuy").Result;
AuthenticationResponse authResp = await facade.GetUserProfile(username);
EmailAddress emailAddress = new EmailAddress();
emailAddress.Address = username;
emailAddress.Name = authResp.Name;
List <EmailAddress> listEmailAddress = new List <EmailAddress>();
listEmailAddress.Add(emailAddress);
contentEmail = contentEmail.Replace("[user]", emailAddress.Name);
EmailAddress emailAddressFrom = new EmailAddress();
emailAddressFrom.Address = "*****@*****.**";
emailAddressFrom.Name = "Lojualguebeli.com";
List <EmailAddress> listEmailAddressFrom = new List <EmailAddress>();
listEmailAddressFrom.Add(emailAddressFrom);
EmailMessage emailMessage = new EmailMessage();
emailMessage.ToAddresses = listEmailAddress;
emailMessage.Subject = subjectEmail;
emailMessage.FromAddresses = listEmailAddressFrom;
emailMessage.Content = contentEmail;
sendEmail.Send(emailMessage);
#endregion
}
return(Ok(response));
}
catch (Exception)
{
return(BadRequest());
}
}
public void Split_transaction_request()
{
var schema = TypedSchemaFactory.FromType <Order>();
var requests = new List <DataRequest>();
// simple put requests
for (int i = 0; i < 100; i++)
{
var order1 = new Order {
Id = Guid.NewGuid(), Category = "geek", ProductId = 123, Quantity = 1
};
var putRequest = new PutRequest("orders");
var packed1 = PackedObject.Pack(order1, schema, "orders");
putRequest.Items.Add(packed1);
requests.Add(putRequest);
}
// conditional put requests
for (int i = 0; i < 100; i++)
{
var order1 = new Order {
Id = Guid.NewGuid(), Category = "geek", ProductId = 123, Quantity = 1
};
var putRequest = new PutRequest("orders");
var packed1 = PackedObject.Pack(order1, schema, "orders");
putRequest.Items.Add(packed1);
putRequest.Predicate = ExpressionTreeHelper.PredicateToQuery <Order>(o => o.IsDelivered, "orders");
requests.Add(putRequest);
}
// simple delete requests
for (int i = 0; i < 100; i++)
{
var order1 = new Order {
Id = Guid.NewGuid(), Category = "geek", ProductId = 123, Quantity = 1
};
var packed1 = PackedObject.Pack(order1, schema, "orders1");
var deleteRequest = new RemoveRequest("orders1", packed1.PrimaryKey);
requests.Add(deleteRequest);
}
// delete many request
var deleteMany = new RemoveManyRequest(ExpressionTreeHelper.PredicateToQuery <Order>(o => o.IsDelivered, "orders"));
requests.Add(deleteMany);
var transactionRequest = new TransactionRequest(requests)
{
TransactionId = Guid.NewGuid()
};
var split = transactionRequest.SplitByServer(k => k.GetHashCode() % 5, 5);
var total = split.Values.Sum(r => r.ChildRequests.Count);
// 300 uniformly distributed + 5 (delete many) cloned on each server
Assert.AreEqual(305, total);
Assert.IsTrue(split.Values.All(s => s.TransactionId == transactionRequest.TransactionId));
var tr0 = split[0];
Assert.IsTrue(tr0.ConditionalRequests.All(r => r.HasCondition));
Assert.IsTrue(tr0.ConditionalRequests.Any());
var deleteManyCount = tr0.ChildRequests.Count(r => r is RemoveManyRequest);
Assert.AreEqual(1, deleteManyCount);
Assert.AreEqual(2, tr0.AllCollections.Length);// orders and orders1
}
abstract internal void ExecuteTransaction(TransactionRequest transactionRequest, string name, IsolationLevel iso, SqlInternalTransaction internalTransaction, bool isDelegateControlRequest);
/// <summary>
/// Captures a payment a.k.a POSTs a transaction.
/// </summary>
public async Task <TransactionResponse> PostCapture(string clientName, string id, TransactionRequest transaction)
{
var payment = await GetPayment(clientName, id);
var httpOperation = payment.Operations.FirstOrDefault(o => o.Rel == "create-capture");
if (httpOperation == null)
{
if (payment.Operations.Any())
{
var availableOps = payment.Operations.Select(o => o.Rel).Aggregate((x, y) => x + "," + y);
throw new PaymentNotYetAuthorizedException(id, $"This payment cannot be captured. Available operations: {availableOps}");
}
throw new NoOperationsLeftException();
}
var url = httpOperation.Href;
Func <ProblemsContainer, Exception> onError = m => new CouldNotPostTransactionException(id, m);
var payload = new TransactionRequestContainer(transaction);
var res = await CreateInternalClient(clientName).HttpPost <TransactionRequestContainer, CaptureTransactionResponseContainer>(url, onError, payload);
return(res.Capture.Transaction);
}
public async Task <IActionResult> Charge(string nonce)
{
var gateway = await _braintreeConfiguration.BraintreeGateway();
var curentUser = await _workContext.GetCurrentUser();
var cart = await _cartService.GetActiveCartDetails(curentUser.Id);
var orderCreateResult = await _orderService.CreateOrder(cart.Id, PaymentProviderHelper.BraintreeProviderId, 0, OrderStatus.PendingPayment);
if (!orderCreateResult.Success)
{
return(BadRequest(orderCreateResult.Error));
}
var order = orderCreateResult.Value;
var zeroDecimalOrderAmount = order.OrderTotal;
if (!CurrencyHelper.IsZeroDecimalCurrencies())
{
zeroDecimalOrderAmount = zeroDecimalOrderAmount * 100;
}
var regionInfo = new RegionInfo(CultureInfo.CurrentCulture.LCID);
var payment = new Payment()
{
OrderId = order.Id,
Amount = order.OrderTotal,
PaymentMethod = PaymentProviderHelper.BraintreeProviderId,
CreatedOn = DateTimeOffset.UtcNow
};
var lineItemsRequest = new List <TransactionLineItemRequest>();
//TODO: Need validation
//foreach(var item in order.OrderItems)
//{
// lineItemsRequest.Add(new TransactionLineItemRequest
// {
// Description = item.Product.Description.Substring(0, 255),
// Name = item.Product.Name,
// Quantity = item.Quantity,
// UnitAmount = item.ProductPrice,
// ProductCode = item.ProductId.ToString(),
// TotalAmount = item.ProductPrice * item.Quantity
// });
//}
//TODO: See how customer id works
var request = new TransactionRequest
{
Amount = order.OrderTotal,
PaymentMethodNonce = nonce,
OrderId = order.Id.ToString(),
//LineItems = lineItemsRequest.ToArray(),
//CustomerId = order.CustomerId.ToString(),
Options = new TransactionOptionsRequest
{
SubmitForSettlement = true,
SkipAdvancedFraudChecking = false,
SkipCvv = false,
SkipAvs = false,
}
};
var result = gateway.Transaction.Sale(request);
if (result.IsSuccess())
{
var transaction = result.Target;
payment.GatewayTransactionId = transaction.Id;
payment.Status = PaymentStatus.Succeeded;
order.OrderStatus = OrderStatus.PaymentReceived;
_paymentRepository.Add(payment);
await _paymentRepository.SaveChangesAsync();
return(Ok(transaction.Id));
}
else
{
string errorMessages = "";
foreach (var error in result.Errors.DeepAll())
{
errorMessages += "Error: " + (int)error.Code + " - " + error.Message + "\n";
}
return(BadRequest(errorMessages));
}
}
/// <summary>
/// Runs the specified argument.
/// </summary>
/// <param name="arg">The argument.</param>
/// <param name="context">The context.</param>
/// <returns>
/// A cart with federate payment component
/// </returns>
public override Task <CartEmailArgument> Run(CartEmailArgument arg, CommercePipelineExecutionContext context)
{
Condition.Requires(arg).IsNotNull($"{this.Name}: The cart can not be null");
var cart = arg.Cart;
if (!cart.HasComponent <FederatedPaymentComponent>())
{
return(Task.FromResult(arg));
}
var payment = cart.GetComponent <FederatedPaymentComponent>();
if (string.IsNullOrEmpty(payment.PaymentMethodNonce))
{
context.Abort(context.CommerceContext.AddMessage(
context.GetPolicy <KnownResultCodes>().Error,
"InvalidOrMissingPropertyValue",
new object[] { "PaymentMethodNonce" },
$"Invalid or missing value for property 'PaymentMethodNonce'."), context);
return(Task.FromResult(arg));
}
var braintreeClientPolicy = context.GetPolicy <BraintreeClientPolicy>();
if (string.IsNullOrEmpty(braintreeClientPolicy?.Environment) || string.IsNullOrEmpty(braintreeClientPolicy?.MerchantId) ||
string.IsNullOrEmpty(braintreeClientPolicy?.PublicKey) || string.IsNullOrEmpty(braintreeClientPolicy?.PrivateKey))
{
context.CommerceContext.AddMessage(
context.GetPolicy <KnownResultCodes>().Error,
"InvalidClientPolicy",
new object[] { "BraintreeClientPolicy" },
$"{this.Name}. Invalid BraintreeClientPolicy");
return(Task.FromResult(arg));
}
try
{
var gateway = new BraintreeGateway(braintreeClientPolicy?.Environment, braintreeClientPolicy?.MerchantId, braintreeClientPolicy?.PublicKey, braintreeClientPolicy?.PrivateKey);
var request = new TransactionRequest
{
Amount = payment.Amount.Amount,
PaymentMethodNonce = payment.PaymentMethodNonce,
BillingAddress = ComponentsHelper.TranslatePartyToAddressRequest(payment.BillingParty, context),
Options = new TransactionOptionsRequest
{
SubmitForSettlement = false
}
};
Result <Transaction> result = gateway.Transaction.Sale(request);
if (result.IsSuccess())
{
Transaction transaction = result.Target;
payment.TransactionId = transaction?.Id;
payment.TransactionStatus = transaction?.Status?.ToString();
CreditCard cc = transaction?.CreditCard;
payment.MaskedNumber = cc?.MaskedNumber;
payment.ExpiresMonth = Int32.Parse(cc?.ExpirationMonth);
payment.ExpiresYear = Int32.Parse(cc?.ExpirationYear);
payment.CardType = cc?.CardType?.ToString();
}
else
{
string errorMessages = result.Errors.DeepAll().Aggregate(string.Empty, (current, error) => current + ("Error: " + (int)error.Code + " - " + error.Message + "\n"));
context.Abort(context.CommerceContext.AddMessage(
context.GetPolicy <KnownResultCodes>().Error,
"CreatePaymentFailed",
new object[] { "PaymentMethodNonce" },
$"{this.Name}. Create payment failed :{ errorMessages }"), context);
}
return(Task.FromResult(arg));
}
catch (BraintreeException ex)
{
context.Abort(context.CommerceContext.AddMessage(
context.GetPolicy <KnownResultCodes>().Error,
"InvalidClientPolicy",
new object[] { "BraintreeClientPolicy" },
$"{this.Name}. Invalid BraintreeClientPolicy { ex.Message }"), context);
return(Task.FromResult(arg));
}
}
/// <summary>
/// Runs the specified argument.
/// </summary>
/// <param name="arg">The argument.</param>
/// <param name="context">The context.</param>
/// <returns>
/// A cart with federate payment component
/// </returns>
public override async Task <Order> Run(Order arg, CommercePipelineExecutionContext context)
{
Condition.Requires(arg).IsNotNull($"{this.Name}: order can not be null.");
var order = arg;
if (!order.HasComponent <OnHoldOrderComponent>())
{
var invalidOrderStateMessage = $"{this.Name}: Expected order in '{context.GetPolicy<KnownOrderStatusPolicy>().OnHold}' status but order was in '{order.Status}' status";
context.Abort(
await context.CommerceContext.AddMessage(
context.GetPolicy <KnownResultCodes>().ValidationError,
"InvalidOrderState",
new object[] { context.GetPolicy <KnownOrderStatusPolicy>().OnHold, order.Status },
invalidOrderStateMessage).ConfigureAwait(false),
context);
}
var cart = context.CommerceContext.GetEntity <Cart>(c => c.Id.Equals(order.GetComponent <OnHoldOrderComponent>().TemporaryCart.EntityTarget, StringComparison.OrdinalIgnoreCase));
if (cart == null || !cart.HasComponent <FederatedPaymentComponent>())
{
return(arg);
}
var payment = cart.GetComponent <FederatedPaymentComponent>();
if (string.IsNullOrEmpty(payment.PaymentMethodNonce))
{
context.Abort(
await context.CommerceContext.AddMessage(
context.GetPolicy <KnownResultCodes>().Error,
"InvalidOrMissingPropertyValue",
new object[] { "PaymentMethodNonce" },
"Invalid or missing value for property 'PaymentMethodNonce'.").ConfigureAwait(false),
context);
return(arg);
}
if (!string.IsNullOrEmpty(payment.TransactionId))
{
// Federated Payment was not changed
return(arg);
}
var braintreeClientPolicy = context.GetPolicy <BraintreeClientPolicy>();
if (!(await braintreeClientPolicy.IsValid(context.CommerceContext).ConfigureAwait(false)))
{
return(arg);
}
try
{
var gateway = new BraintreeGateway(braintreeClientPolicy?.Environment, braintreeClientPolicy?.MerchantId, braintreeClientPolicy?.PublicKey, braintreeClientPolicy?.PrivateKey);
// void order payment
if (order.HasComponent <FederatedPaymentComponent>())
{
var orderPayment = order.GetComponent <FederatedPaymentComponent>();
// void order payment
var voidResult = gateway.Transaction.Void(orderPayment.TransactionId);
if (voidResult.IsSuccess())
{
context.Logger.LogInformation($"{this.Name} - Void Payment succeeded: {orderPayment.Id}");
orderPayment.TransactionStatus = voidResult.Target.Status.ToString();
await this.GenerateSalesActivity(order, orderPayment, context).ConfigureAwait(false);
}
else
{
var errorMessages = voidResult.Errors.DeepAll().Aggregate(string.Empty, (current, error) => current + ("Error: " + (int)error.Code + " - " + error.Message + "\n"));
context.Abort(
await context.CommerceContext.AddMessage(
context.GetPolicy <KnownResultCodes>().Error,
"PaymentVoidFailed",
new object[] { orderPayment.TransactionId },
$"{this.Name}. Payment void failed for transaction { orderPayment.TransactionId }: { errorMessages }").ConfigureAwait(false),
context);
return(arg);
}
}
var request = new TransactionRequest
{
Amount = payment.Amount.Amount,
PaymentMethodNonce = payment.PaymentMethodNonce,
BillingAddress = ComponentsHelper.TranslatePartyToAddressRequest(payment.BillingParty),
Options = new TransactionOptionsRequest
{
SubmitForSettlement = false
}
};
var result = gateway.Transaction.Sale(request);
if (result.IsSuccess())
{
var transaction = result.Target;
payment.TransactionId = transaction?.Id;
payment.TransactionStatus = transaction?.Status?.ToString();
payment.PaymentInstrumentType = transaction?.PaymentInstrumentType?.ToString();
var cc = transaction?.CreditCard;
payment.MaskedNumber = cc?.MaskedNumber;
payment.CardType = cc?.CardType?.ToString();
if (cc?.ExpirationMonth != null)
{
payment.ExpiresMonth = int.Parse(cc.ExpirationMonth, System.Globalization.CultureInfo.InvariantCulture);
}
if (cc?.ExpirationYear != null)
{
payment.ExpiresYear = int.Parse(cc.ExpirationYear, System.Globalization.CultureInfo.InvariantCulture);
}
}
else
{
var errorMessages = result.Errors.DeepAll().Aggregate(string.Empty, (current, error) => current + ("Error: " + (int)error.Code + " - " + error.Message + "\n"));
context.Abort(
await context.CommerceContext.AddMessage(
context.GetPolicy <KnownResultCodes>().Error,
"CreatePaymentFailed",
new object[] { "PaymentMethodNonce" },
$"{this.Name}. Create payment failed :{ errorMessages }").ConfigureAwait(false),
context);
}
return(arg);
}
catch (BraintreeException ex)
{
await context.CommerceContext.AddMessage(
context.GetPolicy <KnownResultCodes>().Error,
"InvalidClientPolicy",
new object[] { "BraintreeClientPolicy", ex },
$"{this.Name}. Invalid BraintreeClientPolicy").ConfigureAwait(false);
return(arg);
}
}
public override void ReadCallback(string tableId, object recordKey, object payload)
{
switch (workload.Type)
{
case "READ":
// close the transaction
this.Close();
break;
case "UPDATE":
if (payload != null)
{
TransactionRequest updateReq = this.resourceManager.TransactionRequest(
this.sessionId,
workload.TableId,
workload.Key,
workload.Value,
OperationType.Update);
this.txRequestGCQueue.Enqueue(updateReq);
this.RequestQueue.Enqueue(updateReq);
}
else
{
this.Close();
}
break;
case "DELETE":
if (payload != null)
{
TransactionRequest deleteReq = this.resourceManager.TransactionRequest(
this.sessionId,
workload.TableId,
workload.Key,
workload.Value,
OperationType.Delete);
this.txRequestGCQueue.Enqueue(deleteReq);
this.RequestQueue.Enqueue(deleteReq);
}
else
{
this.Close();
}
break;
case "INSERT":
if (payload == null)
{
TransactionRequest insertReq = this.resourceManager.TransactionRequest(
this.sessionId,
workload.TableId,
workload.Key,
workload.Value,
OperationType.Insert);
this.txRequestGCQueue.Enqueue(insertReq);
this.RequestQueue.Enqueue(insertReq);
}
else
{
this.Close();
}
break;
default:
this.Close();
break;
}
}
abstract internal void ExecuteTransaction(TransactionRequest transactionRequest, string name, IsolationLevel iso, SqlInternalTransaction internalTransaction);
public ActionResult GetManyOutputsTransactionState(
TransactionRequest request)
=> StatusCode(StatusCodes.Status501NotImplemented);
public IGoogleAnalyticsRequest CreateRequest(string hitType, IEnumerable <Parameter> requestParameters = null)
{
if (hitType == null)
{
throw new ArgumentNullException(nameof(hitType));
}
IGoogleAnalyticsRequest request;
switch (hitType.ToLower())
{
case HitTypes.PageView:
request = new PageViewRequest(_proxy);
break;
case HitTypes.Event:
request = new EventRequest(_proxy);
break;
case HitTypes.Exception:
request = new ExceptionTrackingRequest(_proxy);
break;
case HitTypes.Item:
request = new ItemRequest(_proxy);
break;
case HitTypes.ScreenView:
request = new ScreenTrackingRequest(_proxy);
break;
case HitTypes.Social:
request = new SocialInteractionsRequest(_proxy);
break;
case HitTypes.Timing:
request = new UserTimingTrackingRequest(_proxy);
break;
case HitTypes.Transaction:
request = new TransactionRequest(_proxy);
break;
default:
throw new ApplicationException("Unknown hitType: " + hitType);
}
request.Parameters.Add(_protocolVersion);
request.Parameters.Add(_trackingId);
if (requestParameters != null)
{
request.Parameters.AddRange(requestParameters);
}
return(request);
}
public async void UpdateRanks()
{
Console.WriteLine("Doing rank job");
using (VooperContext context = new VooperContext(DBOptions))
{
Group government = context.Groups.AsQueryable().FirstOrDefault(x => x.Name == "Vooperia");
if (government == null)
{
Console.WriteLine("Holy f**k something is wrong.");
}
leaderboard = context.Users.AsEnumerable().Where(u => u.Email != u.UserName).OrderByDescending(u => u.GetTotalXP()).ToList();
List <SocketGuildUser> userList = new List <SocketGuildUser>();
// Add connected users
foreach (User userData in leaderboard)
{
SocketGuildUser user = null;
if (userData.discord_id != null)
{
//user = server.Users.FirstOrDefault(x => x.Id == (ulong)userData.discord_id);
user = server.GetUser((ulong)userData.discord_id);
}
if (user != null)
{
// Clear roles if muted
if (userData.GetDiscordRoles().Any(r => r.Name == "Muted"))
{
if (user.Roles.Contains(spleenRole))
{
await user.RemoveRoleAsync(spleenRole);
}
if (user.Roles.Contains(crabRole))
{
await user.RemoveRoleAsync(crabRole);
}
if (user.Roles.Contains(gatyRole))
{
await user.RemoveRoleAsync(gatyRole);
}
if (user.Roles.Contains(corgiRole))
{
await user.RemoveRoleAsync(corgiRole);
}
if (user.Roles.Contains(oofRole))
{
await user.RemoveRoleAsync(oofRole);
}
}
else
{
userList.Add(user);
}
}
}
int counter = 0;
int totalUsers = userList.Count;
GovControls govControls = await GovControls.GetCurrentAsync(context);
decimal UBITotal = govControls.UBIAccount;
govControls.UBIAccount = 0;
context.GovControls.Update(govControls);
await context.SaveChangesAsync();
int spleenUserCount = totalUsers / 100;
int crabUserCount = (totalUsers / 20) - spleenUserCount;
int gatyUserCount = (totalUsers / 10) - spleenUserCount - crabUserCount;
int corgiUserCount = (totalUsers / 4) - spleenUserCount - crabUserCount - gatyUserCount;
int oofUserCount = (totalUsers / 2) - spleenUserCount - crabUserCount - gatyUserCount - corgiUserCount;
int unrankedCount = totalUsers - spleenUserCount - crabUserCount - gatyUserCount - corgiUserCount - oofUserCount;
decimal spleenPay = 0.0m;
decimal crabPay = 0.0m;
decimal gatyPay = 0.0m;
decimal corgiPay = 0.0m;
decimal oofPay = 0.0m;
decimal unrankedPay = 0.0m;
if (spleenUserCount > 0)
{
spleenPay = (UBITotal * (govControls.SpleenPayPercent / 100.0m)) / spleenUserCount;
}
if (crabUserCount > 0)
{
crabPay = (UBITotal * (govControls.CrabPayPercent / 100.0m)) / crabUserCount;
}
if (gatyUserCount > 0)
{
gatyPay = (UBITotal * (govControls.GatyPayPercent / 100.0m)) / gatyUserCount;
}
if (corgiUserCount > 0)
{
corgiPay = (UBITotal * (govControls.CorgiPayPercent / 100.0m)) / corgiUserCount;
}
if (oofUserCount > 0)
{
oofPay = (UBITotal * (govControls.OofPayPercent / 100.0m)) / oofUserCount;
}
if (unrankedCount > 0)
{
unrankedPay = (UBITotal * (govControls.UnrankedPayPercent / 100.0m)) / unrankedCount;
}
foreach (SocketGuildUser discordUser in userList)
{
User webUser = context.Users.FirstOrDefault(u => u.discord_id == discordUser.Id);
// Update pfp in storage
webUser.Image_Url = webUser.GetPfpUrl();
context.Update(webUser);
await context.SaveChangesAsync();
bool hasSpleen = discordUser.Roles.Contains(spleenRole);
bool hasCrab = discordUser.Roles.Contains(crabRole);
bool hasGaty = discordUser.Roles.Contains(gatyRole);
bool hasCorgi = discordUser.Roles.Contains(corgiRole);
bool hasOof = discordUser.Roles.Contains(oofRole);
bool hasCitizen = discordUser.Roles.Contains(patreonCitizen) || discordUser.Roles.Contains(youtubeCitizen);
bool hasSoldier = discordUser.Roles.Contains(patreonSoldier);
bool hasLoyalist = discordUser.Roles.Contains(patreonLoyalist);
bool hasHero = discordUser.Roles.Contains(patreonHero);
bool hasMadlad = discordUser.Roles.Contains(patreonMadlad);
bool patron = hasCitizen || hasSoldier || hasLoyalist || hasHero || hasMadlad;
// Inactivity tax
if (Math.Abs(webUser.Discord_Last_Message_Time.Subtract(DateTime.UtcNow).TotalDays) > 14 && !patron)
{
decimal tax = webUser.Credits * (govControls.InactivityTaxRate / 100.0M);
TransactionRequest req = new TransactionRequest(webUser.Id, EconomyManager.VooperiaID, tax, "Inactivity Tax", ApplicableTax.None, true);
TaskResult result = await req.Execute();
if (result.Succeeded)
{
govControls.InactivityTaxRevenue += tax;
// Add to UBI
govControls.UBIAccount += tax * (govControls.UBIBudgetPercent / 100.0M);
context.GovControls.Update(govControls);
await context.SaveChangesAsync();
}
// Remove last role
if (hasSpleen)
{
await discordUser.RemoveRoleAsync(spleenRole);
}
if (hasCrab)
{
await discordUser.RemoveRoleAsync(crabRole);
}
if (hasGaty)
{
await discordUser.RemoveRoleAsync(gatyRole);
}
if (hasCorgi)
{
await discordUser.RemoveRoleAsync(corgiRole);
}
if (hasOof)
{
await discordUser.RemoveRoleAsync(oofRole);
}
continue;
}
// Set district
if (!String.IsNullOrWhiteSpace(webUser.district))
{
var oldDistrictRoles = discordUser.Roles.Where(x => x.Name.Contains("District") && !x.Name.Contains(webUser.district));
if (oldDistrictRoles.Count() > 0)
{
await discordUser.RemoveRolesAsync(oldDistrictRoles);
}
if (!discordUser.Roles.Any(x => x.Name == webUser.district + " District"))
{
await discordUser.AddRoleAsync(districtRoles[webUser.district + " District"]);
}
}
// Spleen rank
if (counter <= spleenUserCount)
{
// Add new role
if (!hasSpleen)
{
await discordUser.AddRoleAsync(spleenRole);
}
// Remove last role
if (hasCrab)
{
await discordUser.RemoveRoleAsync(crabRole);
}
if (hasGaty)
{
await discordUser.RemoveRoleAsync(gatyRole);
}
if (hasCorgi)
{
await discordUser.RemoveRoleAsync(corgiRole);
}
if (hasOof)
{
await discordUser.RemoveRoleAsync(oofRole);
}
if (webUser != null)
{
//TransactionRequest transaction = new TransactionRequest(webUser.economy_id, government.economy_id, 238827, "UBI Mistake Fix", ApplicableTax.None, true);
TransactionRequest transaction = new TransactionRequest(government.Id, webUser.Id, spleenPay, "UBI Payment", ApplicableTax.None, true);
EconomyManager.RequestTransaction(transaction);
}
}
// Crab rank
else if (counter <= spleenUserCount + crabUserCount)
{
// Add new role
if (!hasCrab)
{
await discordUser.AddRoleAsync(crabRole);
}
// Remove last role
if (hasSpleen)
{
await discordUser.RemoveRoleAsync(spleenRole);
}
if (hasGaty)
{
await discordUser.RemoveRoleAsync(gatyRole);
}
if (hasCorgi)
{
await discordUser.RemoveRoleAsync(corgiRole);
}
if (hasOof)
{
await discordUser.RemoveRoleAsync(oofRole);
}
if (webUser != null)
{
//TransactionRequest transaction = new TransactionRequest(webUser.economy_id, government.economy_id, 146267, "UBI Mistake Fix", ApplicableTax.None, true);
TransactionRequest transaction = new TransactionRequest(government.Id, webUser.Id, crabPay, "UBI Payment", ApplicableTax.None, true);
EconomyManager.RequestTransaction(transaction);
}
}
// Gaty rank
else if (counter <= spleenUserCount + crabUserCount + gatyUserCount)
{
// Add new role
if (!hasGaty)
{
await discordUser.AddRoleAsync(gatyRole);
}
// Remove last role
if (hasSpleen)
{
await discordUser.RemoveRoleAsync(spleenRole);
}
if (hasCrab)
{
await discordUser.RemoveRoleAsync(crabRole);
}
if (hasCorgi)
{
await discordUser.RemoveRoleAsync(corgiRole);
}
if (hasOof)
{
await discordUser.RemoveRoleAsync(oofRole);
}
if (webUser != null)
{
//TransactionRequest transaction = new TransactionRequest(webUser.economy_id, government.economy_id, 125698, "UBI Mistake Fix", ApplicableTax.None, true);
TransactionRequest transaction = new TransactionRequest(government.Id, webUser.Id, gatyPay, "UBI Payment", ApplicableTax.None, true);
EconomyManager.RequestTransaction(transaction);
}
}
// Corgi rank
else if (counter <= spleenUserCount + crabUserCount + gatyUserCount + corgiUserCount)
{
// Add new role
if (!hasCorgi)
{
await discordUser.AddRoleAsync(corgiRole);
}
// Remove last role
if (hasSpleen)
{
await discordUser.RemoveRoleAsync(spleenRole);
}
if (hasCrab)
{
await discordUser.RemoveRoleAsync(crabRole);
}
if (hasGaty)
{
await discordUser.RemoveRoleAsync(gatyRole);
}
if (hasOof)
{
await discordUser.RemoveRoleAsync(oofRole);
}
if (webUser != null)
{
//TransactionRequest transaction = new TransactionRequest(webUser.economy_id, government.economy_id, 110369, "UBI Mistake Fix", ApplicableTax.None, true);
TransactionRequest transaction = new TransactionRequest(government.Id, webUser.Id, corgiPay, "UBI Payment", ApplicableTax.None, true);
EconomyManager.RequestTransaction(transaction);
}
}
// Oof rank
else if (counter <= spleenUserCount + crabUserCount + gatyUserCount + corgiUserCount + oofUserCount)
{
// Add new role
if (!hasOof)
{
await discordUser.AddRoleAsync(oofRole);
}
// Remove last role
if (hasSpleen)
{
await discordUser.RemoveRoleAsync(spleenRole);
}
if (hasCrab)
{
await discordUser.RemoveRoleAsync(crabRole);
}
if (hasGaty)
{
await discordUser.RemoveRoleAsync(gatyRole);
}
if (hasCorgi)
{
await discordUser.RemoveRoleAsync(corgiRole);
}
if (webUser != null)
{
//TransactionRequest transaction = new TransactionRequest(webUser.economy_id, government.economy_id, 91085, "UBI Mistake Fix", ApplicableTax.None, true);
TransactionRequest transaction = new TransactionRequest(government.Id, webUser.Id, oofPay, "UBI Payment", ApplicableTax.None, true);
EconomyManager.RequestTransaction(transaction);
}
}
// Unranked
else
{
// Remove last role
if (hasSpleen)
{
await discordUser.RemoveRoleAsync(spleenRole);
}
if (hasCrab)
{
await discordUser.RemoveRoleAsync(crabRole);
}
if (hasGaty)
{
await discordUser.RemoveRoleAsync(gatyRole);
}
if (hasCorgi)
{
await discordUser.RemoveRoleAsync(corgiRole);
}
if (hasOof)
{
await discordUser.RemoveRoleAsync(oofRole);
}
if (webUser != null)
{
//TransactionRequest transaction = new TransactionRequest(webUser.economy_id, government.economy_id, 125698, "UBI Mistake Fix", ApplicableTax.None, true);
TransactionRequest transaction = new TransactionRequest(government.Id, webUser.Id, unrankedPay, "UBI Payment", ApplicableTax.None, true);
EconomyManager.RequestTransaction(transaction);
}
}
if (patron)
{
webUser = await context.Users.FindAsync(webUser.Id);
if (hasMadlad)
{
webUser.Credits += 500;
}
else if (hasHero)
{
webUser.Credits += 350;
}
else if (hasLoyalist)
{
webUser.Credits += 175;
}
else if (hasSoldier)
{
webUser.Credits += 60;
}
else if (hasCitizen)
{
webUser.Credits += 20;
}
context.Update(webUser);
await context.SaveChangesAsync();
}
counter++;
}
}
Console.WriteLine("Finished rank system");
}
public async Task <TransactionResponse> GetTransaction(TransactionRequest request)
{
return(await MakePostApiCall <TransactionResponse>(ActionTransaction, request));
}
/// <summary>
/// Creates a <see cref="TransactionRequest"/>.
/// </summary>
/// <param name="invoice">
/// The invoice.
/// </param>
/// <param name="paymentMethodNonce">
/// The payment Method Nonce.
/// </param>
/// <param name="customer">
/// The customer.
/// </param>
/// <param name="transactionOption">
/// The transaction Option.
/// </param>
/// <returns>
/// The <see cref="TransactionRequest"/>.
/// </returns>
public TransactionRequest CreateTransactionRequest(IInvoice invoice, string paymentMethodNonce, ICustomer customer = null, TransactionOption transactionOption = TransactionOption.Authorize)
{
var request = new TransactionRequest()
{
Amount = invoice.Total,
OrderId = invoice.PrefixedInvoiceNumber(),
PaymentMethodNonce = paymentMethodNonce,
BillingAddress = CreateAddressRequest(invoice.GetBillingAddress()),
Channel = Constants.TransactionChannel
};
if (customer != null) request.Customer = CreateCustomerRequest(customer);
if (transactionOption == TransactionOption.SubmitForSettlement)
{
request.Options = new TransactionOptionsRequest() { SubmitForSettlement = true };
}
return request;
}
public async Task <IActionResult> SummaryPost(IFormCollection collection, ProductUserVM ProductUserVM)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
if (User.IsInRole(WC.AdminRole))
{
//we need to create an order
//var orderTotal = 0.0;
//foreach(Product prod in ProductUserVM.ProductList)
//{
// orderTotal += prod.Price * prod.TempSqFt;
//}
OrderHeader orderHeader = new OrderHeader()
{
CreatedByUserId = claim.Value,
FinalOrderTotal = ProductUserVM.ProductList.Sum(x => x.TempSqFt * x.Price),
City = ProductUserVM.ApplicationUser.City,
StreetAddress = ProductUserVM.ApplicationUser.StreetAddress,
State = ProductUserVM.ApplicationUser.State,
PostalCode = ProductUserVM.ApplicationUser.PostalCode,
FullName = ProductUserVM.ApplicationUser.FullName,
Email = ProductUserVM.ApplicationUser.Email,
PhoneNumber = ProductUserVM.ApplicationUser.PhoneNumber,
OrderDate = DateTime.Now,
OrderStatus = WC.StatusPending
};
_orderHRepo.Add(orderHeader);
_orderHRepo.Save();
foreach (var prod in ProductUserVM.ProductList)
{
OrderDetail orderDetail = new OrderDetail()
{
OrderHeaderId = orderHeader.Id,
PricePerSqFt = prod.Price,
Sqft = prod.TempSqFt,
ProductId = prod.Id
};
_orderDRepo.Add(orderDetail);
}
_orderDRepo.Save();
string nonceFromTheClient = collection["payment_method_nonce"];
var request = new TransactionRequest
{
Amount = Convert.ToDecimal(orderHeader.FinalOrderTotal),
PaymentMethodNonce = nonceFromTheClient,
OrderId = orderHeader.Id.ToString(),
Options = new TransactionOptionsRequest
{
SubmitForSettlement = true
}
};
var gateway = _brain.GetGateway();
Result <Transaction> result = gateway.Transaction.Sale(request);
if (result.Target.ProcessorResponseText == "Approved")
{
orderHeader.TransactionId = result.Target.Id;
orderHeader.OrderStatus = WC.StatusApproved;
}
else
{
orderHeader.OrderStatus = WC.StatusCancelled;
}
_orderHRepo.Save();
return(RedirectToAction(nameof(InquiryConfirmation), new { id = orderHeader.Id }));
}
else
{
//we need to create an inquiry
var PathToTemplate = _webHostEnvironment.WebRootPath + Path.DirectorySeparatorChar.ToString()
+ "templates" + Path.DirectorySeparatorChar.ToString() +
"Inquiry.html";
var subject = "New Inquiry";
string HtmlBody = "";
using (StreamReader sr = System.IO.File.OpenText(PathToTemplate))
{
HtmlBody = sr.ReadToEnd();
}
//Name: { 0}
//Email: { 1}
//Phone: { 2}
//Products: {3}
StringBuilder productListSB = new StringBuilder();
foreach (var prod in ProductUserVM.ProductList)
{
productListSB.Append($" - Name: { prod.Name} <span style='font-size:14px;'> (ID: {prod.Id})</span><br />");
}
string messageBody = string.Format(HtmlBody,
ProductUserVM.ApplicationUser.FullName,
ProductUserVM.ApplicationUser.Email,
ProductUserVM.ApplicationUser.PhoneNumber,
productListSB.ToString());
await _emailSender.SendEmailAsync(WC.EmailAdmin, subject, messageBody);
InquiryHeader inquiryHeader = new InquiryHeader()
{
ApplicationUserId = claim.Value,
FullName = ProductUserVM.ApplicationUser.FullName,
Email = ProductUserVM.ApplicationUser.Email,
PhoneNumber = ProductUserVM.ApplicationUser.PhoneNumber,
InquiryDate = DateTime.Now
};
_inqHRepo.Add(inquiryHeader);
_inqHRepo.Save();
foreach (var prod in ProductUserVM.ProductList)
{
InquiryDetail inquiryDetail = new InquiryDetail()
{
InquiryHeaderId = inquiryHeader.Id,
ProductId = prod.Id,
};
_inqDRepo.Add(inquiryDetail);
}
_inqDRepo.Save();
TempData[WC.Success] = "Inquiry submitted successfully";
}
return(RedirectToAction(nameof(InquiryConfirmation)));
}
static Guid?CreateTransactionExample(Configuration configuration)
{
TransactionsApi api = new TransactionsApi(configuration);
// Please check our documentation at https://docs.transferzero.com/docs/transaction-flow/
// for details on how transactions work
// When adding a sender to transaction, please use either an id or external_id. Providing both will result in a validation error.
// Please see our documentation at https://docs.transferzero.com/docs/transaction-flow/#sender
Sender sender = new Sender(id: Guid.Parse("058de445-ffff-ffff-ffff-da9c751d14bf"));
// You can find the various payout options at https://docs.transferzero.com/docs/transaction-flow/#payout-details
PayoutMethodDetails ngnBankDetails = new PayoutMethodDetails(
bankAccount: "123456789",
bankAccountType: PayoutMethodBankAccountTypeEnum._20,
bankCode: "082",
firstName: "First",
lastName: "Last"
);
PayoutMethod payoutMethod = new PayoutMethod(
type: "NGN::Bank",
details: ngnBankDetails
);
// Please see https://docs.transferzero.com/docs/transaction-flow/#requested-amount-and-currency
// on what the request amount and currencies do
Recipient recipient = new Recipient(
requestedAmount: 10000,
requestedCurrency: "NGN",
payoutMethod: payoutMethod
);
// Similarly you can check https://docs.transferzero.com/docs/transaction-flow/#requested-amount-and-currency
// on details about the input currency parameter
// Find more details on external IDs at https://docs.transferzero.com/docs/transaction-flow/#external-id
Transaction transaction = new Transaction(
inputCurrency: "USD",
sender: sender,
recipients: new List <Recipient>()
{
recipient
},
externalId: "TRANSACTION-00001"
);
try
{
TransactionRequest transactionRequest = new TransactionRequest(
transaction: transaction
);
TransactionResponse transactionResponse = api.PostTransactions(transactionRequest);
System.Console.WriteLine("Transaction created! ID" + transactionResponse.Object.Id);
System.Console.WriteLine(transactionResponse.Object);
return(transactionResponse.Object.Id);
}
catch (ApiException e)
{
if (e.IsValidationError)
{
TransactionResponse transactionResponse = e.ParseObject <TransactionResponse>();
System.Console.WriteLine("Validation Error" + transactionResponse.Object.Errors);
}
else
{
throw e;
}
return(null);
}
}
public async Task <ActionResult> Index(Checkout model)
{
//Check if the model-state is valid -- this will catch anytime someone hacks your client-side validation (If Valid then Transaction may begin)
if (ModelState.IsValid)
{
var gateway = new BraintreeGateway
{
Environment = Braintree.Environment.SANDBOX,
MerchantId = ConfigurationManager.AppSettings["Braintree.MerchantID"],
PublicKey = ConfigurationManager.AppSettings["Braintree.PublicKey"],
PrivateKey = ConfigurationManager.AppSettings["Braintree.PrivateKey"]
};
CustomerSearchRequest searchRequest = new CustomerSearchRequest();
searchRequest.Email.Is(model.ContactEmail);
Customer c = null;
var existingCustomers = await gateway.Customer.SearchAsync(searchRequest);
if (existingCustomers.Ids.Any())
{
c = existingCustomers.FirstItem;
}
else
{
CustomerRequest newCustomer = new CustomerRequest();
newCustomer.Email = model.ContactEmail;
var customerResult = await gateway.Customer.CreateAsync(newCustomer);
if (customerResult.IsSuccess())
{
c = customerResult.Target;
}
else
{
throw new Exception(customerResult.Errors.All().First().Message);
}
}
string token;
CreditCardRequest card = new CreditCardRequest();
card.Number = model.CreditCardNumber;
card.CVV = model.CreditCardVerificationValue;
card.ExpirationMonth = model.CreditCardExpirationMonth.ToString().PadLeft(2, '0');
card.ExpirationYear = model.CreditCardExpirationYear.ToString();
card.CardholderName = model.NameOnCard;
card.CustomerId = c.Id;
var cardResult = await gateway.CreditCard.CreateAsync(card);
if (cardResult.IsSuccess())
{
token = cardResult.Target.Token;
}
else
{
throw new Exception(cardResult.Errors.All().First().Message);
}
//HttpCookie cartCookie = Request.Cookies["cart"];
//var order = db.Orders.Find(int.Parse(cartCookie.Value));
Braintree.TransactionRequest transaction = new TransactionRequest();
transaction.Amount = new ViewModel.BasketSummaryViewModel().TotalCost;;
transaction.CustomerId = c.Id;
transaction.PaymentMethodToken = token;
var saleResult = await gateway.Transaction.SaleAsync(transaction);
if (saleResult.IsSuccess())
{
return(RedirectToAction("Index", "Home"));
//Need to create a Receipt Controller, as well as a View to show receipt, send email confirmation.
//Check Joe's Github for inspiration
}
}
return(View(model));
}
