public async Task <IActionResult> Create(PaymentRecordCreateViewModel model)
{
if (ModelState.IsValid)
{
var record = new PaymentRecord()
{
Id = model.Id,
EmployeeId = model.EmployeeId,
FullName = _employeeService.GetById(model.EmployeeId).Fullname,
PayDate = model.PayDate,
Paymonth = model.Paymonth,
TaxYearId = model.TaxYearId,
TaxCode = model.TaxCode,
Hourlyrate = model.Hourlyrate,
HoursWoreked = model.HoursWoreked,
ContrctHours = model.ContrctHours,
OvertimeHours = ovrtime = _payComputationService.OvertimeHours(model.HoursWoreked, model.ContrctHours),
Contrctearning = contrctearn = _payComputationService.ContractualEarnings(model.ContrctHours, model.HoursWoreked, model.Hourlyrate),
Overtimeearning = ovrtimeearn = _payComputationService.OvertimeEarnings(_payComputationService.OvertimeRate(model.Hourlyrate), ovrtime),
TotalEarnings = totalearn = _payComputationService.TotalEarnings(ovrtimeearn, contrctearn),
Tax = tax = _taxService.TaxAmount(totalearn),
SLC = slc = _employeeService.StudentLoanRepaymentAmount(model.EmployeeId, totalearn),
TotalDeduction = totded = _payComputationService.TotalDeduction(tax, slc),
NetPay = _payComputationService.NetPay(totalearn, totded)
};
await _payComputationService.CreateAsync(record);
return(RedirectToAction(nameof(Index)));
}
ViewBag.employees = _employeeService.GetAllEmployeesForPayroll();
ViewBag.taxYears = _payComputationService.GetAllTaxYear();
return(View());
}
protected override DriverResult Display(PayButtonPart part, string displayType, dynamic shapeHelper)
{
if (displayType == "Detail")
{
var partSettings = part.Settings.GetModel <PayButtonPartSettings>();
var tokens = new Dictionary <string, object> {
{ "Content", part.ContentItem }
};
dynamic ci = part.ContentItem;
var payment = new PaymentRecord();
payment.ContentItemId = part.Id;
payment.Currency = partSettings.DefaultCurrency;
if (string.IsNullOrWhiteSpace(partSettings.CurrencyField) == false)
{
payment.Currency = _tokenizer.Replace(partSettings.CurrencyField, tokens);
}
payment.Amount = Convert.ToDecimal(_tokenizer.Replace(partSettings.AmountField, tokens), CultureInfo.InvariantCulture);
if (part.ContentItem.Parts.SingleOrDefault(x => x.PartDefinition.Name == "TitlePart") != null)
{
payment.Reason = ci.TitlePart.Title;
}
var nonce = _paymentService.CreatePaymentNonce(payment);
return(ContentShape("Parts_PayButton",
() => shapeHelper.Parts_PayButton(Nonce: nonce)));
}
else
{
return(null);
}
}
public PaymentContext(
string nonce, PaymentRecord paymentInfo)
: this(nonce, paymentInfo.Amount, null)
{
PaymentRecord = paymentInfo;
PurchaseOrder = PaymentRecord.PaymentUniqueKey;
}
public StartPaymentMessage(string al, string se, PaymentRecord pr)
: this(al, se)
{
importo = (pr.Amount * 100).ToString("0");
divisa = pr.Currency;
codTrans = pr.Id.ToString() + "LASER";
}
public Task <ProcessRejectedPaymentResponse> Handle(ProcessRejectedPaymentRequest request, CancellationToken cancellationToken = default)
{
var merchantKey = _merchantEncryptionKeyGetter.Key(request.Merchant.Id);
var paymentRecord = new PaymentRecord
{
Id = _guid.NewGuid().ToString(),
Source = new PaymentRecord.PaymentSource
{
CardExpiryEncrypted = _encrypter.EncryptUtf8(request.Source.CardExpiry, merchantKey),
CardNumberEncrypted = _encrypter.EncryptUtf8(request.Source.CardNumber, merchantKey),
CvvEncrypted = _encrypter.EncryptUtf8(request.Source.Cvv, merchantKey)
},
Recipient = new PaymentRecord.PaymentRecipient
{
AccountNumberEncrypted = _encrypter.EncryptUtf8(request.Recipient.AccountNumber, merchantKey),
SortCodeEncrypted = _encrypter.EncryptUtf8(request.Recipient.SortCode, merchantKey),
},
Currency = request.Currency,
Status = PaymentStatus.Rejected,
Amount = request.Amount,
CreatedAt = _dateTime.UtcNow(),
MerchantId = request.Merchant.Id,
FailureReason = request.BankResponse.FailureReason,
};
_paymentRecordCreator.Add(paymentRecord);
return(Task.FromResult(new ProcessRejectedPaymentResponse
{
Id = paymentRecord.Id
}));
}
public void Update(PaymentRecord paymentRecord)
{
var existing = _mockDocumentDb.Payments.FirstOrDefault(x => x.Id == paymentRecord.Id);
_mockDocumentDb.Payments.Remove(existing);
_mockDocumentDb.Payments.Add(paymentRecord);
}
//GET
protected override DriverResult Editor(OrderPart order, dynamic shapeHelper)
{
if (!_orchardServices.Authorizer.Authorize(OrderPermissions.ManageOrders, null, T("Cannot manage orders")))
{
return(null);
}
PaymentRecord payment = _paymentService.GetPaymentByGuid(order.Charge?.TransactionId);
return(ContentShape("Parts_Order_PaymentInfo",
() => {
if (payment == null)
{
return null;
}
var model = new PaymentInfoViewModel {
PosName = payment.PosName,
Reason = payment.Reason,
Amount = payment.Amount,
Currency = payment.Currency,
UpdateDate = payment.UpdateDate,
Success = payment.Success,
Error = payment.Error,
TransationId = payment.TransactionId,
};
return shapeHelper.EditorTemplate(
TemplateName: "Parts/Order.PaymentInfo",
Model: model);
}));
}
public void ShowObject(object keyValue)
{
Payment = keyValue as PaymentRecord;
PaymentbindingSource.DataSource = Payment;
if (Payment != null && (Payment.PaymentId == 0 && Payment.PaymentMethod == null))
{
Text = @"New Payment Records";
Payment.PaymentMethod = Convert.ToInt32(PaymentMethods.Cash);
}
if (Payment != null && Payment.PaymentId != 0)
{
Text = @"Edit Payment Records";
switch (Payment.PaymentMethod)
{
case (int)PaymentMethods.Cheque:
checkNoTextBox.Text = Payment.Reference;
break;
case (int)PaymentMethods.BankTransfer:
bankTransferTextBox.Text = Payment.Reference;
break;
case (int)PaymentMethods.Other:
othersTextBox.Text = Payment.Reference;
break;
}
//PaymentTotal = PaymentTotal - Convert.ToDouble(Payment.AmountReceived);
}
}
/// <summary>
/// Salva il pagamento e restituisce il PaymentId.
/// </summary>
/// <param name="values"></param>
/// <returns></returns>
private int SavePaymentInfo(PaymentRecord values)
{
PaymentRecord record = null;
DateTime now = DateTime.Now;
if (values.Id > 0)
{
record = _repository.Get(values.Id);
}
values.PosName = GetValidString(values.PosName, 255);
values.Reason = GetValidString(values.Reason, 255);
values.Error = GetValidString(values.Error, 255);
values.TransactionId = GetValidString(values.TransactionId, 255);
// 4000 è la massima lunghezza di stringa che nhibernate riesce a gestire
values.PosUrl = GetValidString(values.PosUrl, 4000);
values.Info = GetValidString(values.Info, 4000);
values.CustomRedirectUrl = GetValidString(values.CustomRedirectUrl, 4000);
values.CustomRedirectSchema = GetValidString(values.CustomRedirectSchema, 4000);
if (record == null)
{
values.CreationDate = now;
values.UpdateDate = now;
_repository.Create(values);
}
else
{
values.UpdateDate = now;
_repository.Update(values);
}
return(values.Id);
}
public override IEnumerable <dynamic> GetAdditionalOrderMetadataShapes(OrderPart orderPart)
{
// I need to avoid showing these shapes if I'm in the backoffice.
if (!AdminFilter.IsApplied(_workContextAccessor.GetContext().HttpContext.Request.RequestContext))
{
var transactionId = orderPart.Charge?.TransactionId;
if (transactionId != null)
{
PaymentRecord payment = _paymentService.GetPaymentByTransactionId(transactionId);
if (payment != null)
{
var metaShapes = _customPosProviders
.Select(cpp => cpp.GetAdditionalFrontEndMetadataShapes(payment))
.ToList();
// metaShapes variable is a list of lists.
foreach (var l in metaShapes)
{
foreach (var shape in l.ToList())
{
yield return(shape);
}
}
}
}
}
}
public PaymentResponse Post([FromBody] PaymentInformation paymentInformation)
{
log.Info("POST-REQUEST:" + JsonConvert.SerializeObject(paymentInformation));
try
{
EncryptedPaymentInformation encryptedPaymentInformation = new EncryptedPaymentInformation();
//Encrypt data before sending to bank
encryptedPaymentInformation = EncryptData(paymentInformation);
PaymentResponse response = _bankService.PaymentRequest(encryptedPaymentInformation);
using (var context = new PaymentsStorageContext())
{
var paymentRecord = new PaymentRecord()
{
CardNo = paymentInformation.CardNo,
Expiry = paymentInformation.Expiry,
Status = response.Status,
Identifier = response.Identifier
};
context.PaymentRecords.Add(paymentRecord);
context.SaveChanges();
}
log.Info("POST-RESPONSE:" + JsonConvert.SerializeObject(response));
return(response);
}
catch (Exception ex)
{
log.Error(ex.Message);
return(null);
}
}
public void InsertPaymentRecord(PaymentRecord record)
{
if (record != null)
{
_recordRepository.Insert(record);
}
}
public void UpdatePaymentRecord(PaymentRecord record)
{
if (record != null)
{
_recordRepository.Update(record);
}
}
public ActionResult EditPayment(PaymentRecord pr, Invoice invoice)
{
db.PaymentRecords.Find(pr.PaymentId).CardRecordId = pr.CardRecordId;
db.SaveChanges();
Session["EditInvoice"] = db.Invoices.Find(invoice.Id);
return(RedirectToAction("Edit"));
}
public async Task AddPaymentAsync(PaymentRecord paymentRecord)
{
paymentRecord.CardNumber = _encryptor.Encrypt(paymentRecord.CardNumber);
paymentRecord.CardName = _encryptor.Encrypt(paymentRecord.CardName);
await _innerRepository.AddPaymentAsync(paymentRecord);
}
public bool checkIfExistPayment(PaymentRecord pRec)
{
SQL = "select count(payment_no) from customer_payment where elt_account_number = " + elt_account_number + " and payment_no=" + pRec.payment_no;
Cmd = new SqlCommand(SQL, Con);
int rowCount = 0;
try
{
Con.Open();
rowCount = Int32.Parse(Cmd.ExecuteScalar().ToString());
}
catch (Exception ex)
{
throw ex;
}
finally
{
Con.Close();
}
if (rowCount == 1)
{
return(true);
}
else
{
return(false);
}
}
protected virtual string InnerChargeAdminUrl(PaymentRecord payment)
{
var urlHelper = new UrlHelper(_orchardServices.WorkContext.HttpContext.Request.RequestContext);
var url = urlHelper.Action("Info", "Payment", new { area = "Laser.Orchard.PaymentGateway" });
return(string.Format("{0}?paymentId={1}", url, payment.Id));
}
public void GivenAIdIsProvided_WhenTryingToGetThePaymentRecord_ThenItReturnsASuccessfulResponse()
{
// Given
var mockedLogger = Substitute.For <ILogger <PaymentRetrievalController> >();
var mockedPaymentRepository = Substitute.For <IPaymentRepository>();
var realPaymentRetrievalController = new PaymentRetrievalController(mockedLogger, mockedPaymentRepository);
var id = Guid.NewGuid();
var paymentRecord = new PaymentRecord
{
PaymentGatewayId = id
};
mockedPaymentRepository
.Get(id)
.Returns(paymentRecord);
// When
var response = realPaymentRetrievalController.Get(id.ToString()).GetAwaiter().GetResult();
// Then
response.Should().NotBeNull();
response.Should().BeOfType <OkObjectResult>();
response.As <OkObjectResult>().Value.Should().BeOfType <PaymentRecord>();
response.As <OkObjectResult>().Value.As <PaymentRecord>().PaymentGatewayId.Should().Be(id);
mockedPaymentRepository.Received(1).Get(id);
}
public void SaveChanges()
{
if (!ValidateForm())
{
return;
}
PaymentbindingSource.EndEdit();
Payment = (PaymentRecord)PaymentbindingSource.DataSource;
if (Payment != null)
{
switch (Payment.PaymentMethod)
{
case 5:
Payment.Reference = null;
break;
case 6:
Payment.Reference = checkNoTextBox.Text;
break;
case 7:
Payment.Reference = bankTransferTextBox.Text;
break;
case 8:
Payment.Reference = othersTextBox.Text;
break;
}
}
DialogResult = DialogResult.OK;
}
public void GivenAPendingPaymentRecordIsProvided_WhenUpsertingIt_ThenItAddsToTheContext()
{
// Given
using var localTestContext = new PaymentContext(new DbContextOptionsBuilder <PaymentContext>()
.UseInMemoryDatabase(databaseName: $"PaymentDatabase-Test-{Guid.NewGuid()}")
.Options);
var mockedLogger = Substitute.For <ILogger <Domain.PaymentRepository.PaymentRepository> >();
var mockedDataEncryptor = Substitute.For <IDataEncryptor>();
var realPaymentRepository = new Domain.PaymentRepository.PaymentRepository(mockedLogger, localTestContext, mockedDataEncryptor);
var expectedId = Guid.NewGuid();
var expectedPaymentRecord = new PaymentRecord
{
PaymentGatewayId = expectedId,
PaymentStatus = PaymentStatus.Pending
};
// When
realPaymentRepository.Upsert(expectedPaymentRecord).GetAwaiter().GetResult();
var actualPaymentRecord = realPaymentRepository.Get(expectedId).GetAwaiter().GetResult();
// Then
actualPaymentRecord.Should().NotBeNull();
actualPaymentRecord.Should().BeOfType <PaymentRecord>();
actualPaymentRecord.PaymentGatewayId.Should().Be(expectedId);
}
public void GivenAPaymentRecordIdTheExistsInTheContextIsProvided_WhenGettingIt_ThenItReturnsThePaymentRecord()
{
// Given
using var localTestContext = new PaymentContext(new DbContextOptionsBuilder <PaymentContext>()
.UseInMemoryDatabase(databaseName: $"PaymentDatabase-Test-{Guid.NewGuid()}")
.Options);
var mockedLogger = Substitute.For <ILogger <Domain.PaymentRepository.PaymentRepository> >();
var mockedDataEncryptor = Substitute.For <IDataEncryptor>();
var realPaymentRepository = new Domain.PaymentRepository.PaymentRepository(mockedLogger, localTestContext, mockedDataEncryptor);
var expectedId = Guid.NewGuid();
var expectedPaymentRecord = new PaymentRecord {
PaymentGatewayId = expectedId
};
localTestContext.Payments.Add(expectedPaymentRecord);
localTestContext.SaveChanges();
// When
var response = realPaymentRepository.Get(expectedId).GetAwaiter().GetResult();
// Then
response.Should().NotBeNull();
response.Should().BeOfType <PaymentRecord>();
response.PaymentGatewayId.Should().Be(expectedId);
}
public async Task AddPaymentAsync(PaymentRecord paymentRecord)
{
var payment = _mapper.Map <Payment>(paymentRecord);
await _context.Payments.AddAsync(payment);
await _context.SaveChangesAsync();
}
public virtual string GetChargeAdminUrl(PaymentRecord payment)
{
if (payment.PosName == GetPosName())
{
return(InnerChargeAdminUrl(payment));
}
return(null);
}
public PaymentRecord CreatePayment(PaymentRecord payment)
{
return(Execute(session =>
{
var svc = new MoneySourceService();
return svc.CreatePayment(payment, null, null);
}));
}
public ActionResult DeleteConfirmed(int id)
{
PaymentRecord paymentrecord = db.PaymentRecords.Find(id);
db.PaymentRecords.Remove(paymentrecord);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void Add(PaymentRecord record)
{
if (_mockDocumentDb.Payments.Any(a => a.Id == record.Id))
{
throw new ArgumentException(nameof(record));
}
_mockDocumentDb.Payments.Add(record);
}
public void UpdatePayment(PaymentRecord payment, SqlConnection con, SqlTransaction trans)
{
var ps = new PaymentRecordService();
var source = GetById(payment.MoneySourceId);
var amount = Convert.ToSingle(payment.Amount);
var original = ps.GetById(payment.Id);
var originalAmount = Convert.ToSingle(original.Amount);
if (payment.Type.Equals("Expense", StringComparison.CurrentCultureIgnoreCase) ||
payment.Type.Equals("Order-Discount", StringComparison.CurrentCultureIgnoreCase))
{
amount = -amount;
}
if (original.Type.Equals("Income", StringComparison.CurrentCultureIgnoreCase) ||
original.Type.Equals("Order-Payment", StringComparison.CurrentCultureIgnoreCase))
{
originalAmount = -originalAmount;
}
if (payment.Unit.Equals("VND"))
{
source.BalanceVND += amount;
}
else
{
source.BalanceUSD += amount;
}
if (original.Unit.Equals("VND"))
{
source.BalanceVND += originalAmount;
}
else
{
source.BalanceUSD += originalAmount;
}
if (con != null && trans != null)
{
ps.Update(payment, con, trans);
_adapter.Update(source, con, trans);
}
else
{
SqlHelper.StartTransaction(ConfigManager.ConnectionString, (connection, transaction) =>
{
ps.Update(payment, connection, transaction);
_adapter.Update(source, con, trans);
});
}
}
public HttpResponseMessage UpdatePayment(PaymentRecord payment)
{
return(Execute(session =>
{
var svc = new MoneySourceService();
svc.UpdatePayment(payment, null, null);
return Request.CreateResponse(HttpStatusCode.OK);
}));
}
private async Task <PaymentRequestCompleteResult> ProcessPaymentComplete(IInvokeActivity invoke, PaymentRequestComplete paymentRequestComplete, CancellationToken token = default(CancellationToken))
{
var paymentRequest = paymentRequestComplete.PaymentRequest;
var paymentResponse = paymentRequestComplete.PaymentResponse;
paymentRequest.Details = (await this.ProcessShippingUpdate(
new PaymentRequestUpdate()
{
Id = paymentRequest.Id,
Details = paymentRequest.Details,
ShippingAddress = paymentResponse.ShippingAddress,
ShippingOption = paymentResponse.ShippingOption
},
ShippingUpdateKind.Both,
token)).Details;
PaymentRecord paymentRecord = null;
PaymentRequestCompleteResult result = null;
Exception paymentProcessingException = null;
try
{
paymentRecord = await this.paymentService.ProcessPaymentAsync(paymentRequest, paymentResponse);
result = new PaymentRequestCompleteResult("success");
}
catch (Exception ex)
{
paymentProcessingException = ex;
// TODO: If payment is captured but not charged this would be considered "unknown" (charge the captured amount after shipping scenario).
result = new PaymentRequestCompleteResult("failure");
}
try
{
var message = invoke.RelatesTo.GetPostToBotMessage();
if (result.Result == "success")
{
// Resume the conversation with the receipt to user
message.Text = paymentRequestComplete.Id;
message.Value = paymentRecord;
}
else
{
// Resume the conversation with error message
message.Text = $"Failed to process payment with error: {paymentProcessingException?.Message}";
}
await Conversation.ResumeAsync(invoke.RelatesTo, message, token);
}
catch (Exception ex)
{
Trace.TraceError($"Failed to resume the conversation using ConversationReference: {JsonConvert.SerializeObject(invoke.RelatesTo)} and exception: {ex.Message}");
}
return(result);
}
public void SaveChanges()
{
var iv = _context.Invoices.FirstOrDefault(i => i.Id == _paymentRecord.InvoiceId);
if (!ValidateForm())
{
return;
}
var rt = (Convert.ToDouble(_invoiceListInfo.RecievedTotal) + Convert.ToDouble(_paymentRecord.AmountReceived));
if (rt > Convert.ToDouble(_invoiceListInfo.InvoiceTotal))
{
ViewHelper.ShowErrorMessage("the amount of recieved total has exceeded the amount of invoice total?");
Close();
return;
}
PaymentbindingSource.EndEdit();
_paymentRecord = (PaymentRecord)PaymentbindingSource.DataSource;
if (_newMode)
{
_context.PaymentRecords.AddObject(_paymentRecord);
}
if (rt == Convert.ToDouble(_invoiceListInfo.InvoiceTotal))
{
iv.Status = (int)InvoiceStatuses.PaidInFull;
}
try
{
switch (_paymentRecord.PaymentMethod)
{
case 5:
_paymentRecord.Reference = null;
break;
case 6:
_paymentRecord.Reference = checkNoTextBox.Text;
break;
case 7:
_paymentRecord.Reference = bankTransferTextBox.Text;
break;
case 8:
_paymentRecord.Reference = othersTextBox.Text;
break;
}
_context.SaveChanges();
Close();
}
catch (Exception)
{
ViewHelper.ShowSaveError();
return;
}
}
public static PaymentDTO AddPayment(string PaymentEmail, string DonorName, string ReceipientEmail, Double amount, string message, string paymentType, Boolean anonymous, DateTime paymentDate, int transactionID, int invoiceID)
{
ConvictsContext db = new ConvictsContext();
PaymentRecord payment = new PaymentRecord();
payment.PayerEmail = PaymentEmail;
payment.DonorName = DonorName;
payment.amount = amount;
payment.TeamCode = Helper.getTeamCode(ReceipientEmail);
payment.ConvictEmail = ReceipientEmail;
payment.PaymentType = paymentType;
payment.Message = message;
payment.CreateDate = paymentDate;
payment.Anonymous = anonymous;
payment.TransactionID = transactionID;
payment.InvoiceID = invoiceID;
string returnStatus = "false";
string errorMessage = "";
try
{
db.Payments.Add(payment);
db.SaveChanges();
returnStatus = "true";
}
catch (Exception ex)
{
returnStatus = "false";
errorMessage = ex.Message;
}
PaymentDTO returnobj = new PaymentDTO();
returnobj.status = returnStatus;
returnobj.errorMessage = errorMessage;
return returnobj;
}
private static void WritePaymentInfo(PaymentRecord paymentRecord)
{
StringBuilder stringBuilder = new StringBuilder();
AddComma(paymentRecord.paymentID.ToString(), stringBuilder);
AddComma(paymentRecord.CreateDate.ToString(), stringBuilder);
AddComma(paymentRecord.DonorName, stringBuilder);
AddComma(paymentRecord.PayerEmail, stringBuilder);
AddComma(paymentRecord.ConvictEmail, stringBuilder);
AddComma(paymentRecord.PaymentType, stringBuilder);
AddComma(paymentRecord.amount.ToString(), stringBuilder);
HttpContext.Current.Response.Write(stringBuilder.ToString());
HttpContext.Current.Response.Write(Environment.NewLine);
}
