public int PayUpdate(MemberRegistrationDTO obj, int MemberID)
{
try
{
PaymentDetailsDTO PayPD = new PaymentDetailsDTO();
PayPD.PaymentID = 0;
PayPD.PlanID = Convert.ToInt32(obj.PlantypeID);
PayPD.WorkouttypeID = Convert.ToInt32(obj.WorkouttypeID);
string[] joing = obj.JoiningDate.ToString().Split('-');
int year2 = Convert.ToInt32(obj.JoiningDate.Value.Year);
int month2 = Convert.ToInt32(obj.JoiningDate.Value.Month);
int day2 = Convert.ToInt32(obj.JoiningDate.Value.Day);
DateTime joining = new DateTime(year2, month2, day2);
PayPD.PaymentFromdt = joining;
PayPD.PaymentAmount = Convert.ToDecimal(obj.Amount);
PayPD.CreateUserID = Convert.ToInt32(Session["UserID"]);
PayPD.ModifyUserID = 0;
PayPD.MemberID = MemberID;
PayPD.PaymentID = Convert.ToInt32(obj.PaymentID);
int payresult = objpay.UpdatePaymentDetails(PayPD);
return(payresult);
}
catch (Exception)
{
throw;
}
}
public async Task SavePaymentDetails_ShouldSavePayment_WhenGivenValidDetails()
{
var expectedPaymentDetails = new PaymentDetailsDTO
{
CardNumber = "1234123412341266",
ExpiryMonth = 5,
ExpiryDate = 23,
CardHolderName = "Y LI",
Amount = 18.99M,
Currency = "GBP",
CVV = "111"
};
await _paymentRepository.SavePaymentDetails(expectedPaymentDetails);
var getPaymentDetails = $@"SELECT
CardNumber,
ExpiryMonth,
ExpiryDate,
CardHolderName,
Amount,
Currency,
CVV
FROM {_databaseName}.payment_details;";
await using var connection = new MySqlConnection(ConnectionString);
await connection.OpenAsync();
var dt = new DataTable("PaymentDetails");
await using var command = new MySqlCommand(getPaymentDetails, connection);
var da = new MySqlDataAdapter(command);
da.Fill(dt);
var actual = (from DataRow row in dt.Rows
select new PaymentDetailsDTO
{
CardNumber = Convert.ToString(row[dt.Columns["CardNumber"].Ordinal]),
ExpiryMonth = Convert.ToInt32(row[dt.Columns["ExpiryMonth"].Ordinal]),
ExpiryDate = Convert.ToInt32(row[dt.Columns["ExpiryDate"].Ordinal]),
CardHolderName = Convert.ToString(row[dt.Columns["CardHolderName"].Ordinal]),
Amount = Convert.ToDecimal(row[dt.Columns["Amount"].Ordinal]),
Currency = Convert.ToString(row[dt.Columns["Currency"].Ordinal]),
CVV = Convert.ToString(row[dt.Columns["CVV"].Ordinal])
}).ToList().FirstOrDefault();
Assert.Equal(expectedPaymentDetails.CardNumber, actual.CardNumber);
Assert.Equal(expectedPaymentDetails.ExpiryMonth, actual.ExpiryMonth);
Assert.Equal(expectedPaymentDetails.ExpiryDate, actual.ExpiryDate);
Assert.Equal(expectedPaymentDetails.CardHolderName, actual.CardHolderName);
Assert.Equal(expectedPaymentDetails.Amount, actual.Amount);
Assert.Equal(expectedPaymentDetails.Currency, actual.Currency);
Assert.Equal(expectedPaymentDetails.CVV, actual.CVV);
}
public int Pay_Gap(RenewalDATA obj)
{
try
{
DateTime dt = new DateTime();
dt = DateTime.Now;
string[] date = dt.ToString("yyyy/MM/dd").Split('/');
int month = Convert.ToInt32(date[1]);
int day = Convert.ToInt32(date[2]);
int year = Convert.ToInt32(date[0]);
DateTime Newdt = new DateTime(year, month, day);
DateTime joiningDT = DateTime.Now;
PaymentDetailsDTO PayPD = new PaymentDetailsDTO();
PayPD.PaymentID = 0;
PayPD.PlanID = Convert.ToInt32(obj.PlantypeID);
PayPD.WorkouttypeID = Convert.ToInt32(obj.WorkouttypeID);
PayPD.Paymenttype = "Cash";
string[] PFFromdate = obj.NewDate.Split('-');
int yearPD = Convert.ToInt32(PFFromdate[0]);
int monthPD = Convert.ToInt32(PFFromdate[1]);
int dayPD = Convert.ToInt32(PFFromdate[2]);
joiningDT = new DateTime(yearPD, monthPD, dayPD);
PayPD.PaymentFromdt = joiningDT;
int PDID = Convert.ToInt32(objRenewal.Get_PeriodID_byPlan(obj.PlantypeID));
PayPD.PaymentTodt = joiningDT.AddMonths(PDID).AddDays(-1);
PayPD.PaymentAmount = Convert.ToDecimal(obj.PaymentAmount);
PayPD.NextRenwalDate = joiningDT.AddMonths(PDID).AddDays(-1);
PayPD.CreateDate = Newdt;
PayPD.CreateUserID = Convert.ToInt32(Session["UserID"]);
PayPD.ModifyUserID = 0;
PayPD.ModifyDate = Newdt;
PayPD.RecStatus = "A";
PayPD.MemberID = Convert.ToInt32(obj.MemberID);
PayPD.MemberNo = obj.MemberNo;
int payresult = objpay.InsertPaymentDetails(PayPD);
TempData["Message"] = "Renewal Done Successfully";
return(payresult);
}
catch (Exception)
{
throw;
}
}
public async Task <int> SavePaymentDetails(PaymentDetailsDTO paymentDetails)
{
var insertPaymentDetailsQuery = $@"
USE {_mySqlConfig.PaymentGatewayDB};
INSERT INTO payment_details (
CardNumber,
ExpiryMonth,
ExpiryDate,
CardHolderName,
Amount,
Currency,
CVV)
VALUES (
@CardNumber,
@ExpiryMonth,
@ExpiryDate,
@CardHolderName,
@Amount,
@Currency,
@CVV);
SELECT LAST_INSERT_ID()";
try
{
await using var _connection = new MySqlConnection(_mySqlConfig.ConnectionString);
var paymentDetailsID = await _connection.QuerySingleAsync <int>(insertPaymentDetailsQuery,
new
{
paymentDetails.CardNumber,
paymentDetails.ExpiryMonth,
paymentDetails.ExpiryDate,
paymentDetails.CardHolderName,
paymentDetails.Amount,
paymentDetails.Currency,
paymentDetails.CVV
});
return(paymentDetailsID);
}
catch (MySqlException e)
{
_logger.Error(e, "Error saving payment details");
throw;
}
catch (Exception e)
{
_logger.Error(e, "Error saving payment details");
throw;
}
}
public void AddTokenDetails([FromBody] PaymentDetailsDTO paymentDetailsDTO)
{
if (Is <PaymentFeature> .Enabled)
{
var employee = db.Employees.Find(paymentDetailsDTO.EmployeeID);
if (employee != null)
{
if (ClaimsAuthorization.CheckAccess("Put", "BusinessLocationId", employee.BusinessLocation.Id.ToString()))
{
var paymentdetails = new PaymentDetails
{
Id = Guid.NewGuid()
};
if (employee.PaymentDetails != null)
{
paymentdetails = employee.PaymentDetails;
}
paymentdetails.TokenCustomerID = paymentDetailsDTO.TokenCustomerID;
paymentdetails.BusinessLocation = employee.BusinessLocation;
paymentdetails.CreatedDate = WebUI.Common.Common.DateTimeNowLocal();
//If there is another payment detail from a different employee then delete
if (employee.BusinessLocation.PaymentDetails != null &&
employee.BusinessLocation.PaymentDetails.Employee.Id != employee.Id)
{
//employee.BusinessLocation.PaymentDetails.
db.Entry(employee.BusinessLocation.PaymentDetails).State = EntityState.Deleted;
}
employee.PaymentDetails = paymentdetails;
db.SaveChanges();
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
}
}
else
{
throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotImplemented));
}
}
// GET: Payment
public ActionResult Index(Guid businessLocationId)
{
PaymentDetailsDTO paymentDetailsDTO = new PaymentDetailsDTO();
//Get a summary of the employes currently linked to the Employee
using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
{
Task <String> response = httpClient.GetStringAsync("api/PaymentAPI/businesslocation/" + businessLocationId.ToString());
paymentDetailsDTO = Task.Factory.StartNew(() => JsonConvert.DeserializeObject <PaymentDetailsDTO>(response.Result)).Result;
}
ViewBag.BusinessLocationId = businessLocationId;
return(PartialView(paymentDetailsDTO));
}
public async Task <PaymentResult> MakePayment(PaymentDetailsDTO paymentDetails)
{
var newPayment = new PaymentDetail
{
CardNumber = paymentDetails.CardNumber,
CVV = paymentDetails.CVV,
CardOwnerName = paymentDetails.CardOwnerName,
ExpirationDate = paymentDetails.ExpirationDate
};
await _context.PaymentDetails.AddAsync(newPayment);
await _context.SaveChangesAsync();
return(new PaymentResult()
{
IsComplete = true
});
}
// GET: TokenReturn
public ActionResult TokenReturn(string employeeId, string businessLocationId, string accessCode)
{
var requestURL = Request.Url;
PaymentDetailsDTO paymentDetailsDTO = new PaymentDetailsDTO();
using (HttpClient httpClient = new HttpClient())
{
//To validate the user we need to pass the credentials to the api using Basic Authentication
//if authenticated, a session token will be returned.
var apiUser = ConfigurationManager.AppSettings.Get("eWayRapidAPIKey");
var apiPassword = ConfigurationManager.AppSettings.Get("eWayRapidAPIPassword");
httpClient.DefaultRequestHeaders.Authorization = new BasicAuthenticationHeaderValue(apiUser, apiPassword);
httpClient.BaseAddress = new Uri("https://api.sandbox.ewaypayments.com");
HttpResponseMessage response = httpClient.GetAsync("AccessCode/" + accessCode).Result;
response.EnsureSuccessStatusCode();
var objResponse = JsonConvert.DeserializeObject <eWayAccessCodeResponseDTO>(response.Content.ReadAsStringAsync().Result);
var tokenCustomerID = objResponse.TokenCustomerID;
//Save token to database for current logged in employee, then redirect to Index
paymentDetailsDTO.TokenCustomerID = long.Parse(tokenCustomerID);
paymentDetailsDTO.EmployeeID = Guid.Parse(employeeId);
}
using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
{
var responseMessage = httpClient.PostAsJsonAsync("api/PaymentAPI/AddToken", paymentDetailsDTO).Result;
if (responseMessage.IsSuccessStatusCode)
{
//Successfully updated token, now redirect back to payment index
return(RedirectToAction("Index", new { businessLocationId = businessLocationId }));
}
else
{
//TODO: handle error
}
}
return(View());
}
private void savebtn_Click(object sender, EventArgs e)
{
Mapper.CreateMap <TransactionDTO, Transaction>();
Mapper.CreateMap <TransactionDetailDTO, TransactionDetail>();
Mapper.CreateMap <PaymentDetailsDTO, PaymentDetail>();
TransactionDTO transactionVales = new TransactionDTO();
transactionVales.DealCustomerId = CustomerId;
transactionVales.Type = purchasesalesLabel.Text;
transactionVales.GrandTotal = decimal.Parse(grandtotalbox.Text);
transactionVales.Discount = decimal.Parse(discountbox.Text);
transactionVales.Tax = decimal.Parse(vatbox.Text);
transactionVales.TransactionDate = billDatetimePicker.Value;
var user = new UserDashBoard();
var productIdentifier = 0;
using (var db = new Model1())
{
transactionVales.AddedBy = db.Users.FirstOrDefault(
x => x.UserName == user.currentUser).id;
}
var mapped = Mapper.Map <Transaction>(transactionVales);
var payments = new PaymentDetailsDTO();
var saved = false;
var transactionType = purchasesalesLabel.Text;
using (var db = new Model1())
{
db.Transactions.Add(mapped);
var transcationdetailsVales = new TransactionDetailDTO();
for (int i = 0; i < dataForTable.Rows.Count; i++)
{
var name = dataForTable.Rows[i][1].ToString();
productIdentifier = db.Products.FirstOrDefault(
x => x.Name == name).id;
transcationdetailsVales.ProductId = productIdentifier;
transcationdetailsVales.AddedDate = DateTime.Now;
transcationdetailsVales.DealCustomerId = CustomerId;
transcationdetailsVales.Rate = decimal.Parse(dataForTable.Rows[i][2].ToString());
transcationdetailsVales.Quantity = decimal.Parse(dataForTable.Rows[i][3].ToString());
transcationdetailsVales.Total = decimal.Parse(dataForTable.Rows[i][4].ToString());
var mapping = Mapper.Map <TransactionDetail>(transcationdetailsVales);
db.TransactionDetails.Add(mapping);
var answer = db.Products.FirstOrDefault(x => x.id == productIdentifier);
if (transactionType.ToLower() == "sales")
{
answer.Quantity = answer.Quantity - transcationdetailsVales.Quantity;
db.Products.AddOrUpdate(answer);
}
else if (transactionType.ToLower() == "purchase")
{
answer.Quantity = answer.Quantity + transcationdetailsVales.Quantity;
db.Products.AddOrUpdate(answer);
}
}
var saving = db.SaveChanges() > 0;
if (!saving)
{
MessageBox.Show("An error occured cannot ");
}
var collector = db.Transactions.ToList().Last();
payments.TransactionId = collector.Id;
payments.AmountPaid = decimal.Parse(paidamountbox.Text);
payments.BalanceorChange = decimal.Parse(returnamountbox.Text);
// payments.Transaction = mapped;
var paymentIntoDb = Mapper.Map <PaymentDetail>(payments);
db.PaymentDetails.Add(paymentIntoDb);
saved = db.SaveChanges() > 0;
}
if (saved)
{
MessageBox.Show("Transaction saved successfully");
//printing the transaction.
PrintTransaction();
}
else
{
MessageBox.Show("Error saving transactions");
}
clearTable_Click(sender, e);
cleaner();
}
public async Task GetTransactionHistoryById_ShouldGetTransactionHistory_WhenTransactionHistoryExists()
{
var transactionID = 2121;
var expectedCardNumber = "1234123412341266";
var expectedCardHolderName = "John J";
var expectedAmount = 734.7m;
var expectedCurrency = "GBP";
var expectedSuccess = true;
var expectedCreatedDate = new DateTime(2021, 5, 19, 22, 17, 00);
var paymentDetails = new PaymentDetailsDTO
{
CardNumber = expectedCardNumber,
ExpiryMonth = 5,
ExpiryDate = 23,
CardHolderName = expectedCardHolderName,
Amount = expectedAmount,
Currency = expectedCurrency,
CVV = "111"
};
var transactionDetails = new TransactionDetailsDTO
{
TransactionID = transactionID,
Success = expectedSuccess,
PaymentDetailsID = 1,
CreatedDate = expectedCreatedDate
};
var insertDetails = $@"INSERT INTO {_databaseName}.payment_details
(`CardNumber`,
`ExpiryMonth`,
`ExpiryDate`,
`CardHolderName`,
`Amount`,
`Currency`,
`CVV`)
VALUES
(@CardNumber,
@ExpiryMonth,
@ExpiryDate,
@CardHolderName,
@Amount,
@Currency,
@CVV);
INSERT INTO {_databaseName}.transaction_details
(`TransactionID`,
`Success`,
`PaymentDetailsID`,
`CreatedDate`)
VALUES
(@TransactionID,
@Success,
@PaymentDetailsID,
@CreatedDate);";
await using var connection = new MySqlConnection(ConnectionString);
await connection.OpenAsync();
await using var command = new MySqlCommand(insertDetails, connection);
command.Parameters.AddWithValue("@CardNumber", paymentDetails.CardNumber);
command.Parameters.AddWithValue("@ExpiryMonth", paymentDetails.ExpiryMonth);
command.Parameters.AddWithValue("@ExpiryDate", paymentDetails.ExpiryDate);
command.Parameters.AddWithValue("@CardHolderName", paymentDetails.CardHolderName);
command.Parameters.AddWithValue("@Amount", paymentDetails.Amount);
command.Parameters.AddWithValue("@Currency", paymentDetails.Currency);
command.Parameters.AddWithValue("@CVV", paymentDetails.CVV);
command.Parameters.AddWithValue("@TransactionID", transactionDetails.TransactionID);
command.Parameters.AddWithValue("@Success", transactionDetails.Success);
command.Parameters.AddWithValue("@PaymentDetailsID", transactionDetails.PaymentDetailsID);
command.Parameters.AddWithValue("@CreatedDate", transactionDetails.CreatedDate);
command.ExecuteNonQuery();
var actual = await _transactionRepository.GetTransactionHistoryById(transactionID);
Assert.Equal(expectedCardNumber, actual.CardNumber);
Assert.Equal(expectedCardHolderName, actual.CardHolderName);
Assert.Equal(expectedAmount, actual.Amount);
Assert.Equal(expectedSuccess, actual.Success);
Assert.Equal(expectedCreatedDate, actual.CreatedDate);
}
