public async Task SavePaymentItemAsync(PaymentItem item)
{
if (item.Id == null)
{
await paymentTable.InsertAsync(item);
}
else
{
await paymentTable.UpdateAsync(item);
}
}
public ActionResult _MakePayment(MakePaymentVM mVm)
{
if (TryValidateModel(mVm))
{
var pymnt = new Payment
{
CustomerId = mVm.CustomerId,
PaymentDate = DateTime.Today,
PaymentSourceId = mVm.PreferredPaymentSourceId,
Amount = mVm.TenderedAmount,
Reference = mVm.Reference,
PaymentItems = new List <PaymentItem>()
};
if (mVm.RolledTransactions != null)
{
foreach (var rolldTransVm in mVm.RolledTransactions.Where(p => p.Payment != 0))
{
var pmtItm = new PaymentItem
{
Amount = rolldTransVm.Payment,
BillCycle = new BillCycle(rolldTransVm.BillCycleNo),
PaymentItemTypeId = (int)PaymentItemTypes.InvoiceSettlement,
CustomerAccountId = rolldTransVm.CustomerAccountId
};
pymnt.PaymentItems.Add(pmtItm);
}
}
if (mVm.CreditedAmount != 0)
{
var crdPmt = new PaymentItem
{
CustomerAccountId = mVm.CreditedAccountId,
BillCycle = new BillCycle(DateTime.Today).AddCycles(1),
PaymentItemTypeId = (int)PaymentItemTypes.Credit,
Amount = mVm.CreditedAmount
};
pymnt.PaymentItems.Add(crdPmt);
}
if (ExecuteRepositoryAction(() =>
{
_paymentService.AddPayment(pymnt);
_paymentService.CommitChanges();
}))
{
return(ReturnJsonFormSuccess());
}
}
mVm.CustomerAccounts = _customerService.GetCustomer(mVm.CustomerId).CustomerAccounts;
return(PartialView(mVm));
}
public override bool Update(TransactionManager transactionManager, PaymentItem entity)
{
SqlDatabase database = new SqlDatabase(this._connectionString);
DbCommand command = StoredProcedureProvider.GetCommandWrapper(database, "dbo.PaymentItem_Update", this._useStoredProcedure);
database.AddInParameter(command, "@PaymentItemCode", DbType.AnsiString, entity.PaymentItemCode);
database.AddInParameter(command, "@OriginalPaymentItemCode", DbType.AnsiString, entity.OriginalPaymentItemCode);
database.AddInParameter(command, "@PaymentCode", DbType.AnsiString, entity.PaymentCode);
database.AddInParameter(command, "@CostCode", DbType.AnsiString, entity.CostCode);
database.AddInParameter(command, "@PaymentType", DbType.AnsiString, entity.PaymentType);
database.AddInParameter(command, "@ItemMoney", DbType.Decimal, entity.ItemMoney.HasValue ? ((object)entity.ItemMoney) : ((object)DBNull.Value));
database.AddInParameter(command, "@Summary", DbType.AnsiString, entity.Summary);
database.AddInParameter(command, "@Remark", DbType.AnsiString, entity.Remark);
database.AddInParameter(command, "@AllocateCode", DbType.AnsiString, entity.AllocateCode);
database.AddInParameter(command, "@OldItemMoney", DbType.Decimal, entity.OldItemMoney.HasValue ? ((object)entity.OldItemMoney) : ((object)DBNull.Value));
database.AddInParameter(command, "@AlloType", DbType.AnsiString, entity.AlloType);
database.AddInParameter(command, "@CostBudgetSetCode", DbType.AnsiString, entity.CostBudgetSetCode);
database.AddInParameter(command, "@PBSType", DbType.AnsiString, entity.PBSType);
database.AddInParameter(command, "@PBSCode", DbType.AnsiString, entity.PBSCode);
database.AddInParameter(command, "@Description", DbType.AnsiString, entity.Description);
database.AddInParameter(command, "@ContractCostCode", DbType.AnsiString, entity.ContractCostCode);
database.AddInParameter(command, "@ItemCash", DbType.Decimal, entity.ItemCash.HasValue ? ((object)entity.ItemCash) : ((object)DBNull.Value));
database.AddInParameter(command, "@MoneyType", DbType.AnsiString, entity.MoneyType);
database.AddInParameter(command, "@ExchangeRate", DbType.Decimal, entity.ExchangeRate.HasValue ? ((object)entity.ExchangeRate) : ((object)DBNull.Value));
database.AddInParameter(command, "@ItemCash0", DbType.Decimal, entity.ItemCash0.HasValue ? ((object)entity.ItemCash0) : ((object)DBNull.Value));
database.AddInParameter(command, "@ItemCash1", DbType.Decimal, entity.ItemCash1.HasValue ? ((object)entity.ItemCash1) : ((object)DBNull.Value));
database.AddInParameter(command, "@ItemCash2", DbType.Decimal, entity.ItemCash2.HasValue ? ((object)entity.ItemCash2) : ((object)DBNull.Value));
database.AddInParameter(command, "@ItemCash3", DbType.Decimal, entity.ItemCash3.HasValue ? ((object)entity.ItemCash3) : ((object)DBNull.Value));
database.AddInParameter(command, "@ItemCash4", DbType.Decimal, entity.ItemCash4.HasValue ? ((object)entity.ItemCash4) : ((object)DBNull.Value));
database.AddInParameter(command, "@ItemCash5", DbType.Decimal, entity.ItemCash5.HasValue ? ((object)entity.ItemCash5) : ((object)DBNull.Value));
database.AddInParameter(command, "@ItemCash6", DbType.Decimal, entity.ItemCash6.HasValue ? ((object)entity.ItemCash6) : ((object)DBNull.Value));
database.AddInParameter(command, "@ItemCash7", DbType.Decimal, entity.ItemCash7.HasValue ? ((object)entity.ItemCash7) : ((object)DBNull.Value));
database.AddInParameter(command, "@ItemCash8", DbType.Decimal, entity.ItemCash8.HasValue ? ((object)entity.ItemCash8) : ((object)DBNull.Value));
database.AddInParameter(command, "@ItemCash9", DbType.Decimal, entity.ItemCash9.HasValue ? ((object)entity.ItemCash9) : ((object)DBNull.Value));
int num = 0;
if (transactionManager != null)
{
num = Utility.ExecuteNonQuery(transactionManager, command);
}
else
{
num = Utility.ExecuteNonQuery(database, command);
}
if (DataRepository.Provider.EnableEntityTracking)
{
EntityManager.StopTracking(entity.EntityTrackingKey);
}
entity.OriginalPaymentItemCode = entity.PaymentItemCode;
entity.AcceptChanges();
return(Convert.ToBoolean(num));
}
public async void DeletePaymentItemAsync(PaymentItem item)
{
IEnumerable <UserPaymentItem> users = await userpaymentTabel.Where(s => s.Id == item.Id).ToEnumerableAsync();
if (item != null)
{
await paymentTable.DeleteAsync(item);
}
foreach (UserPaymentItem user in users)
{
await userpaymentTabel.DeleteAsync(user);
}
}
public void PaymentItemInits()
{
var label = "yo-yo";
var amount = new PaymentCurrencyAmount("$", "5.00", "USD");
var pending = false;
var paymentItem = new PaymentItem(label, amount, pending);
Assert.NotNull(paymentItem);
Assert.IsType <PaymentItem>(paymentItem);
Assert.Equal(label, paymentItem.Label);
Assert.Equal(amount, paymentItem.Amount);
Assert.Equal(pending, paymentItem.Pending);
}
public PaymentProcessorBase Build(PaymentItem paymentItem)
{
switch (paymentItem.PaymentType)
{
case PaymentType.Cash:
return(new CashPaymentProcessor(paymentItem));
case PaymentType.CreditCard:
return(new CreditCardPaymentProcessor(paymentItem));
default:
throw new ArgumentOutOfRangeException(nameof(paymentItem.PaymentType), "Invalid payment type");
}
}
private IList getItems()
{
IList items = new ArrayList();
for (int i = 0; i < itemsDataGrid.Rows.Count; i++)
{
if (itemsDataGrid[invoiceNoColumn.Index, i].Tag == null)
{
continue;
}
PaymentItem st = (PaymentItem)itemsDataGrid.Rows[i].Tag;
if (st == null)
{
st = new PaymentItem();
}
itemsDataGrid.Rows[i].Tag = st;
//SupplierInvoiceJournalItem pi = (SupplierInvoiceJournalItem)itemsDataGrid[invoiceNoColumn.Index, i].Tag;
st.SUPPLIER_INVOICE_JOURNAL_ITEM = (ISupplierInvoiceJournalItem)itemsDataGrid[invoiceNoColumn.Index, i].Tag;
st.EVENT_JOURNAL = m_prn;
st.AMOUNT = Convert.ToDouble(itemsDataGrid[paymentAmountColumn.Index, i].Value);
st.PAYMENT_TYPE = (PaymentType)Enum.Parse(typeof(PaymentType), itemsDataGrid[paymentTypeColumn.Index, i].Value.ToString());
st.INVOICE_NO = itemsDataGrid[docnoColumn.Index, i].Value == null ? "" : itemsDataGrid[docnoColumn.Index, i].Value.ToString();
st.INVOICE_DATE = Convert.ToDateTime(itemsDataGrid[docdateColumn.Index, i].Value);
st.NOTES = itemsDataGrid[noteColumn.Index, i].Value == null ? "" : itemsDataGrid[noteColumn.Index, i].Value.ToString();
if (st.PAYMENT_TYPE == PaymentType.Bank)
{
st.BANK = (Bank)Utils.FindEntityInList(itemsDataGrid[bankColumn.Index, i].Value.ToString(), m_bank);
}
if (st.PAYMENT_TYPE == PaymentType.APDebitNote)
{
st.AP_DEBIT_NOTE = (APDebitNote)itemsDataGrid[docnoColumn.Index, i].Tag;
}
st.VENDOR = m_prn.VENDOR;
st.CURRENCY = m_prn.CURRENCY;
st.EMPLOYEE = m_prn.EMPLOYEE;
//st.INVOICE_NO = itemsDataGrid[invoiceNoColumn.Index, i].Value.ToString();
//st.INVOICE_DATE = Convert.ToDateTime(itemsDataGrid[invoiceDateColumn.Index, i].Value);
//st.TOP = (TermOfPayment)Utils.FindEntityInList(itemsDataGrid[topColumn.Index, i].Value.ToString(), m_tops);
//st.DUE_DATE = Convert.ToDateTime(itemsDataGrid[dueDateColumn.Index, i].Value);
//st.EMPLOYEE = (Employee)Utils.FindEntityInList(itemsDataGrid[invoicerColumn.Index, i].Value.ToString(), m_employee);
//st.VENDOR = m_prn.VENDOR;
//st.CURRENCY = m_prn.CURRENCY;
items.Add(st);
}
return(items);
}
/// <summary>
/// Method for calling the processing bank.
/// </summary>
/// <param name="payment">The payment object</param>
/// <returns>PaymentResult</returns>
public async Task <PaymentResult> ProcessPaymentAsync(PaymentItem payment)
{
PaymentResult result = new PaymentResult();
try
{
var newPayment = new
{
Card = payment.PaymentCard,
Amount = payment.PaymentAmount,
PaymentCurrency = payment.PaymentCurrency.ToString()
};
StringContent content = new StringContent(JsonConvert.SerializeObject(newPayment), Encoding.UTF8,
"application/json");
HttpResponseMessage response = await _client.PostAsync("payment", content).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
string responseMessage = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var definition = new { PaymentSucceeded = true, PaymentId = "" };
var responseJson = JsonConvert.DeserializeAnonymousType(responseMessage, definition);
result.PaymentStatus =
responseJson.PaymentSucceeded ? PaymentStatus.Approved : PaymentStatus.Declined;
result.ExternalPaymentReference = responseJson.PaymentId;
_logger.LogInformation(
"Payment processed successfully for {PaymentId}, Response - StatusCode: {StatusCode}",
payment.PaymentId, response.StatusCode);
}
else
{
_logger.LogInformation(
"Processing payment failed for {PaymentId}, Response - StatusCode: {StatusCode}",
payment.PaymentId, response.StatusCode);
result.PaymentStatus = PaymentStatus.Failed;
}
}
catch (Exception ex)
{
result.PaymentStatus = PaymentStatus.Failed;
_logger.LogWarning(ex, "An exception has occured in {name}", nameof(ProcessPaymentAsync));
}
return(result);
}
public async Task ProcessPayment_BankError()
{
PaymentItem payment = CreateValidPaymentItem();
_mockBank.Setup(x => x.ProcessPaymentAsync(It.IsAny <PaymentItem>())).ReturnsAsync((PaymentResult)null);
MerchantId merchantId = new MerchantId()
{
UUID = Guid.NewGuid().ToString()
};
PaymentHelper paymentHelper = new PaymentHelper(_mockLogger.Object, _mockBank.Object, _mockDataAccess.Object);
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(() =>
paymentHelper.ProcessPaymentAsync(merchantId, payment)).ConfigureAwait(false);
}
private void HandleMessage(string content)
{
long orderID = long.Parse(content.Substring(0, content.IndexOf("_")));
long userID = long.Parse(content.Substring(content.IndexOf("_") + 1));
using (IServiceScope scope = _provider.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <PaymentContext>();
PaymentItem paymentItem = new PaymentItem();
paymentItem.OrderID = orderID;
paymentItem.UserID = userID;
context.payments.Add(paymentItem);
context.SaveChangesAsync();
Sender.Send("Ticket", "OK");
}
}
public IList <NotFullyPaidOrderNode> GetAllNotFullyPaidOrdersByClientAndOrg(
IUnitOfWork uow, int counterpartyId, int organizationId, int closingDocumentDeliveryScheduleId)
{
VodovozOrder orderAlias = null;
OrderItem orderItemAlias = null;
PaymentItem paymentItemAlias = null;
CounterpartyContract counterpartyContractAlias = null;
Organization orderOrganizationAlias = null;
DeliverySchedule deliveryScheduleAlias = null;
CashlessMovementOperation cashlessMovementOperationAlias = null;
NotFullyPaidOrderNode resultAlias = null;
var orderSumProjection = GetOrderSumProjection(orderItemAlias);
var allocatedSumProjection = QueryOver.Of(() => paymentItemAlias)
.JoinAlias(pi => pi.CashlessMovementOperation, () => cashlessMovementOperationAlias)
.Where(pi => pi.Order.Id == orderAlias.Id)
.Where(pi => pi.PaymentItemStatus != AllocationStatus.Cancelled)
.Select(Projections.SqlFunction(new SQLFunctionTemplate(NHibernateUtil.Decimal, "IFNULL(?1, ?2)"),
NHibernateUtil.Decimal,
Projections.Sum(() => cashlessMovementOperationAlias.Expense),
Projections.Constant(0)));
return(uow.Session.QueryOver(() => orderAlias)
.Inner.JoinAlias(o => o.OrderItems, () => orderItemAlias)
.Inner.JoinAlias(o => o.Contract, () => counterpartyContractAlias)
.Inner.JoinAlias(() => counterpartyContractAlias.Organization, () => orderOrganizationAlias)
.Inner.JoinAlias(o => o.DeliverySchedule, () => deliveryScheduleAlias)
.Where(() => orderAlias.Client.Id == counterpartyId)
.And(() => orderOrganizationAlias.Id == organizationId)
.And(() => orderAlias.OrderStatus == OrderStatus.Shipped ||
orderAlias.OrderStatus == OrderStatus.UnloadingOnStock ||
orderAlias.OrderStatus == OrderStatus.Closed)
.And(() => orderAlias.PaymentType == PaymentType.cashless)
.And(() => orderAlias.OrderPaymentStatus != OrderPaymentStatus.Paid)
.And(() => deliveryScheduleAlias.Id != closingDocumentDeliveryScheduleId)
.SelectList(list =>
list.SelectGroup(o => o.Id).WithAlias(() => resultAlias.Id)
.Select(o => o.DeliveryDate).WithAlias(() => resultAlias.OrderDeliveryDate)
.Select(o => o.CreateDate).WithAlias(() => resultAlias.OrderCreationDate)
.Select(orderSumProjection).WithAlias(() => resultAlias.OrderSum)
.SelectSubQuery(allocatedSumProjection).WithAlias(() => resultAlias.AllocatedSum))
.Where(Restrictions.Gt(orderSumProjection, 0))
.TransformUsing(Transformers.AliasToBean <NotFullyPaidOrderNode>())
.OrderBy(o => o.DeliveryDate).Asc
.OrderBy(o => o.CreateDate).Asc
.List <NotFullyPaidOrderNode>());
}
public CreatePaymentResponse CreatePayment(CreatePaymentRequest req)
{
var res = new CreatePaymentResponse();
try
{
using (var idmClient = new IDMServiceClient())
using (var container = new TransactionModelContainer())
{
ValidateCreatePaymentRequest(idmClient, req);
var payment = new Payment(
req.CreateBy,
req.CustomerIDMPartyID,
req.CustomerName,
req.CustomerAddress,
req.PaymentItems.CreatePaymentItems()
);
var grandTotal = payment.GrandTotal();
var credits = container.CustomerCredits.Where(x =>
x.CustomerIdmPartyId == req.CustomerIDMPartyID &&
x.IsUsedOrRefund == false).ToList();
var credit = credits.GetCustomerCredit(grandTotal);
foreach (var c in credit)
{
payment.AddPaymentItem(PaymentItem.CreateCustomerCredit(c.Id, c.Amount));
}
CustomerCredit.UpdateCustomerCredit(credit);
container.Payments.AddObject(payment);
container.SaveChanges();
res.SetPaymentResponse(payment);
res.Succeed();
}
}
catch (Exception x)
{
res.Fail(x);
CreateLog(req, x);
}
return(res);
}
public decimal GetCounterpartyDebt(IUnitOfWork uow, int counterpartyId)
{
VodovozOrder orderAlias = null;
OrderItem orderItemAlias = null;
Counterparty counterpartyAlias = null;
PaymentItem paymentItemAlias = null;
CashlessMovementOperation cashlessMovOperationAlias = null;
var total = uow.Session.QueryOver(() => orderAlias)
.Left.JoinAlias(() => orderAlias.OrderItems, () => orderItemAlias)
.Left.JoinAlias(() => orderAlias.Client, () => counterpartyAlias)
.Where(() => counterpartyAlias.Id == counterpartyId)
.And(() => orderAlias.OrderStatus != OrderStatus.NewOrder)
.And(() => orderAlias.OrderStatus != OrderStatus.Canceled)
.And(() => orderAlias.OrderStatus != OrderStatus.DeliveryCanceled)
.And(() => orderAlias.OrderStatus != OrderStatus.NotDelivered)
.And(() => orderAlias.PaymentType == PaymentType.cashless)
.And(() => orderAlias.OrderPaymentStatus != OrderPaymentStatus.Paid)
.Select(
Projections.Sum(
Projections.SqlFunction(new SQLFunctionTemplate(NHibernateUtil.Decimal, "ROUND(?1 * IFNULL(?2, ?3) - ?4, 2)"),
NHibernateUtil.Decimal, new IProjection[] {
Projections.Property(() => orderItemAlias.Price),
Projections.Property(() => orderItemAlias.ActualCount),
Projections.Property(() => orderItemAlias.Count),
Projections.Property(() => orderItemAlias.DiscountMoney)
})
)
).SingleOrDefault <decimal>();
var totalPayPartiallyPaidOrders = uow.Session.QueryOver(() => paymentItemAlias)
.Left.JoinAlias(() => paymentItemAlias.CashlessMovementOperation, () => cashlessMovOperationAlias)
.Left.JoinAlias(() => paymentItemAlias.Order, () => orderAlias)
.Left.JoinAlias(() => orderAlias.Client, () => counterpartyAlias)
.Where(() => counterpartyAlias.Id == counterpartyId)
.And(() => orderAlias.OrderStatus != OrderStatus.NewOrder)
.And(() => orderAlias.OrderStatus != OrderStatus.Canceled)
.And(() => orderAlias.OrderStatus != OrderStatus.DeliveryCanceled)
.And(() => orderAlias.OrderStatus != OrderStatus.NotDelivered)
.And(() => orderAlias.PaymentType == PaymentType.cashless)
.And(() => orderAlias.OrderPaymentStatus == OrderPaymentStatus.PartiallyPaid)
.Select(
Projections.Sum(() => cashlessMovOperationAlias.Expense)
).SingleOrDefault <decimal>();
return(total - totalPayPartiallyPaidOrders);
}
public async Task <IActionResult> ProcessPaymentAsync(string id, [FromBody] PaymentItem payment)
{
_logger.LogInformation($"Process payment {@payment} for merchant {id}.", payment, id);
if (!ModelState.IsValid)
{
_logger.LogInformation("Failed to process payment {@payment}", payment);
return(new BadRequestObjectResult(ModelState));
}
Merchant merchant = await CheckMerchantAsync(id).ConfigureAwait(false);
if (merchant is null)
{
_logger.LogInformation("Payment processing failed, invalid merchant Id {id}", id);
return(new BadRequestObjectResult("Invalid merchant id"));
}
try
{
PaymentResult paymentResult = await _paymentHelper.ProcessPaymentAsync(merchant.MerchantId, payment)
.ConfigureAwait(false);
_logger.LogInformation("Payment completed {PaymentId}.", paymentResult.PaymentId);
return(new CreatedResult(Request.GetRequestUri().ToString(), paymentResult));
}
catch (AggregateException aex)
{
_logger.LogWarning(aex, "Exception creating merchant {@merchant}", merchant);
IActionResult handled = ExceptionExtensions.HandleException(aex);
if (handled != null)
{
return(handled);
}
throw;
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Exception creating merchant {@merchant}", merchant);
throw;
}
}
public async Task Should_Update_Payment_Item_When_Price_Does_Not_Have_Dot()
{
CreateSubMerchantRequest createSubMerchantRequest = CreateSubMerchantRequestBuilder.Create()
.PersonalSubMerchantRequest()
.Build();
SubMerchant subMerchant = await SubMerchant.CreateAsync(createSubMerchantRequest, Options);
string subMerchantKey = subMerchant.SubMerchantKey;
CreatePaymentRequest request = CreatePaymentRequestBuilder
.Create()
.MarketplacePayment(subMerchantKey, "40", "30")
.Price("40")
.PaidPrice("40")
.Build();
Payment payment = await Payment.CreateAsync(request, Options);
UpdatePaymentItemRequest updateRequest = new UpdatePaymentItemRequest
{
Locale = Locale.TR.ToString(),
ConversationId = payment.ConversationId,
SubMerchantKey = subMerchantKey,
PaymentTransactionId = payment.PaymentItems?[0]?.PaymentTransactionId,
SubMerchantPrice = "25"
};
PaymentItem paymentItem = await PaymentItem.UpdateAsync(updateRequest, Options);
PrintResponse(paymentItem);
Assert.NotNull(paymentItem);
Assert.NotNull(paymentItem.Locale);
Assert.NotNull(paymentItem.ConversationId);
Assert.NotNull(paymentItem.SubMerchantKey);
Assert.NotNull(paymentItem.PaymentTransactionId);
Assert.NotNull(paymentItem.SubMerchantPrice);
Assert.AreEqual(Status.SUCCESS.ToString(), paymentItem.Status);
Assert.AreEqual(Locale.TR.ToString(), paymentItem.Locale);
Assert.AreEqual(updateRequest.ConversationId, paymentItem.ConversationId);
Assert.AreEqual(updateRequest.SubMerchantKey, paymentItem.SubMerchantKey);
Assert.AreEqual(updateRequest.PaymentTransactionId, paymentItem.PaymentTransactionId);
Assert.AreEqual(updateRequest.SubMerchantPrice, paymentItem.SubMerchantPrice);
}
public IList <NotFullyAllocatedPaymentNode> GetAllNotFullyAllocatedPaymentsByClientAndOrg(
IUnitOfWork uow, int counterpartyId, int organizationId, bool allocateCompletedPayments)
{
Payment paymentAlias = null;
PaymentItem paymentItemAlias = null;
NotFullyAllocatedPaymentNode resultAlias = null;
var query = uow.Session.QueryOver(() => paymentAlias)
.Where(p => p.Counterparty.Id == counterpartyId)
.And(p => p.Organization.Id == organizationId);
if (allocateCompletedPayments)
{
query.And(p => p.Status == PaymentState.completed);
}
else
{
query.And(p => p.Status != PaymentState.Cancelled);
}
var unAllocatedSumProjection = Projections.SqlFunction(
new SQLFunctionTemplate(NHibernateUtil.Decimal, "?1 - IFNULL(?2, ?3)"),
NHibernateUtil.Decimal,
Projections.Property(() => paymentAlias.Total),
Projections.Sum(() => paymentItemAlias.Sum),
Projections.Constant(0));
var unAllocatedSum = QueryOver.Of(() => paymentItemAlias)
.Where(pi => pi.Payment.Id == paymentAlias.Id)
.And(pi => pi.PaymentItemStatus != AllocationStatus.Cancelled)
.Select(unAllocatedSumProjection);
var payments = query.SelectList(list =>
list.SelectGroup(p => p.Id).WithAlias(() => resultAlias.Id)
.SelectSubQuery(unAllocatedSum).WithAlias(() => resultAlias.UnallocatedSum)
.Select(p => p.Date).WithAlias(() => resultAlias.PaymentDate))
.Where(Restrictions.Gt(Projections.SubQuery(unAllocatedSum), 0))
.TransformUsing(Transformers.AliasToBean <NotFullyAllocatedPaymentNode>())
.OrderBy(Projections.SubQuery(unAllocatedSum)).Desc
.OrderBy(p => p.Date).Asc
.List <NotFullyAllocatedPaymentNode>();
return(payments);
}
public static PaymentItemDTO ToDTO(this PaymentItem paymentItem)
{
return(new PaymentItemDTO
{
ID = paymentItem.ID,
SequenceNo = paymentItem.SequenceNo,
PaymentID = paymentItem.PaymentID,
Description = paymentItem.Description != null?paymentItem.Description.Trim() : null,
Amount = paymentItem.Amount,
InvoiceID = paymentItem.InvoiceID,
InvoiceNo = paymentItem.InvoiceNo,
Concurrency = paymentItem.Concurrency,
CreateDate = paymentItem.CreateDate,
ChangeDate = paymentItem.ChangeDate,
PaymentNo = paymentItem.Payment != null ? paymentItem.Payment.PaymentNo : null,
PaymentType = paymentItem.Payment != null ? paymentItem.Payment.PaymentType : null,
PaymentDate = paymentItem.Payment != null ? paymentItem.Payment.PaymentDate : null,
});
}
public ActionResult ThanhToanThanhCong()
{
var model = new PaymentItem();
var status = Request["error_code"];
var token = Request["token"];
if (status == "00")
{
var objCheck = new RequestCheckOrder
{
Merchant_id = ConfigWeb.MerchantId,
Merchant_password = ConfigWeb.MerchantPassword,
Token = token
};
var objNlChecout = new APICheckoutV3();
var detailResult = objNlChecout.GetTransactionDetail(objCheck);
var detailPayment = _iGamePlayerRepository.GetDetailPaymentByToken(detailResult.token);
if (detailPayment != null && detailPayment.transaction_status != "00" && detailResult.transactionStatus == "00")
{
detailPayment.total_amount = Convert.ToInt32(detailResult.paymentAmount);
detailPayment.transaction_status = detailResult.transactionStatus;
detailPayment.transaction_id = detailResult.transactionId;
detailPayment.time_receive = DateTime.Now;
var updatePayment = _iGamePlayerRepository.UpdatePayment(detailPayment);
if (ConfigWeb.PercentSale > 0)
{
detailPayment.total_amount = detailPayment.total_amount +
(detailPayment.total_amount / ConfigWeb.PercentSale);
}
if (detailResult.transactionStatus == "00")
{
var updateMoney = _iGamePlayerRepository.InsertMoney(detailPayment);
}
}
return(View(detailPayment));
}
return(View(model));
}
public async Task <IActionResult> GetPaymentByPaymentId(string id, string paymentId)
{
_logger.LogInformation($"Getting payment for merchant {id} by payment id {paymentId}.", id, paymentId);
Merchant merchant = await CheckMerchantAsync(id).ConfigureAwait(false);
if (merchant is null)
{
_logger.LogInformation("Payment processing failed, invalid merchant Id {id}", id);
return(new BadRequestObjectResult("Invalid merchant id"));
}
PaymentItem payment =
await _paymentHelper.GetPaymentByPaymentId(merchant.MerchantId, new PaymentId()
{
UUID = paymentId
}).ConfigureAwait(false);
return(new OkObjectResult(payment));
}
public static decimal GetCounterpartyLastBalance(IUnitOfWork uow, int counterpartyId)
{
CashlessMovementOperation cashlessOperationAlias = null;
Payment paymentAlias = null;
PaymentItem paymentItemAlias = null;
var income = uow.Session.QueryOver(() => paymentAlias)
.Left.JoinAlias(() => paymentAlias.CashlessMovementOperation, () => cashlessOperationAlias)
.Where(() => paymentAlias.Counterparty.Id == counterpartyId)
.Select(Projections.Sum(() => cashlessOperationAlias.Income))
.SingleOrDefault <decimal>();
var expense = uow.Session.QueryOver(() => paymentItemAlias)
.Left.JoinAlias(() => paymentItemAlias.Payment, () => paymentAlias)
.Where(() => paymentAlias.Counterparty.Id == counterpartyId)
.Select(Projections.Sum(() => paymentItemAlias.Sum))
.SingleOrDefault <decimal>();
return(income - expense);
}
/// <summary>
/// Converts payment item to DTO
/// </summary>
/// <param name="paymentItem">payment item model</param>
/// <returns>Payment DTO</returns>
public static DTO.PaymentItem ToDto(this PaymentItem paymentItem)
{
return(paymentItem is null
? null
: new DTO.PaymentItem()
{
PaymentId = new DTO.PaymentId()
{
UUID = paymentItem.PaymentId
},
ExternalPaymentReference = paymentItem.ExternalPaymentReference,
PaymentAmount = paymentItem.PaymentAmount,
PaymentCard = paymentItem.PaymentCard.ToDto(),
PaymentCurrency = (DTO.PaymentCurrency)paymentItem.PaymentCurrency,
PaymentCustomer = paymentItem.PaymentCustomer.ToDto(),
PaymentMerchant = paymentItem.PaymentMerchant.ToDto(),
PaymentStatus = (DTO.PaymentStatus)paymentItem.PaymentStatus,
TransactionDateTime = paymentItem.TransactionDateTime
});
}
internal override void DeepLoad(TransactionManager transactionManager, PayoutItem entity, bool deep, DeepLoadType deepLoadType, Type[] childTypes, ChildEntityTypesList innerList)
{
if (entity != null)
{
object[] pkItems;
if (base.CanDeepLoad(entity, "Payout", "PayoutCodeSource", deepLoadType, innerList) && (entity.PayoutCodeSource == null))
{
pkItems = new object[] { entity.PayoutCode ?? string.Empty };
Payout payout = EntityManager.LocateEntity <Payout>(EntityLocator.ConstructKeyFromPkItems(typeof(Payout), pkItems), DataRepository.Provider.EnableEntityTracking);
if (payout != null)
{
entity.PayoutCodeSource = payout;
}
else
{
entity.PayoutCodeSource = DataRepository.PayoutProvider.GetByPayoutCode(entity.PayoutCode ?? string.Empty);
}
if (deep && (entity.PayoutCodeSource != null))
{
DataRepository.PayoutProvider.DeepLoad(transactionManager, entity.PayoutCodeSource, deep, deepLoadType, childTypes, innerList);
}
}
if (base.CanDeepLoad(entity, "PaymentItem", "PaymentItemCodeSource", deepLoadType, innerList) && (entity.PaymentItemCodeSource == null))
{
pkItems = new object[] { entity.PaymentItemCode ?? string.Empty };
PaymentItem item = EntityManager.LocateEntity <PaymentItem>(EntityLocator.ConstructKeyFromPkItems(typeof(PaymentItem), pkItems), DataRepository.Provider.EnableEntityTracking);
if (item != null)
{
entity.PaymentItemCodeSource = item;
}
else
{
entity.PaymentItemCodeSource = DataRepository.PaymentItemProvider.GetByPaymentItemCode(entity.PaymentItemCode ?? string.Empty);
}
if (deep && (entity.PaymentItemCodeSource != null))
{
DataRepository.PaymentItemProvider.DeepLoad(transactionManager, entity.PaymentItemCodeSource, deep, deepLoadType, childTypes, innerList);
}
}
}
}
public void PaymentDetailsModifierInits()
{
var supportedMethods = new List <string>()
{
"credit", "debit"
};
var total = new PaymentItem("Awesome");
var additionalDisplayItems = new List <PaymentItem> {
new PaymentItem("item1"), new PaymentItem("item2")
};
var data = new { };
var paymentDetailsModifier = new PaymentDetailsModifier(supportedMethods, total, additionalDisplayItems, data);
Assert.NotNull(paymentDetailsModifier);
Assert.IsType <PaymentDetailsModifier>(paymentDetailsModifier);
Assert.Equal(supportedMethods, paymentDetailsModifier.SupportedMethods);
Assert.Equal(total, paymentDetailsModifier.Total);
Assert.Equal(additionalDisplayItems, paymentDetailsModifier.AdditionalDisplayItems);
Assert.Equal(data, paymentDetailsModifier.Data);
}
public void Should_Update_Payment_Item()
{
UpdatePaymentItemRequest request = new UpdatePaymentItemRequest();
request.Locale = Locale.TR.ToString();
request.ConversationId = "123456789";
request.SubMerchantKey = "subMerchantKey";
request.PaymentTransactionId = "transactionId";
request.SubMerchantPrice = "price";
PaymentItem paymentItem = PaymentItem.Update(request, options);
PrintResponse <PaymentItem>(paymentItem);
Assert.AreEqual(Status.SUCCESS.ToString(), paymentItem.Status);
Assert.AreEqual(Locale.TR.ToString(), paymentItem.Locale);
Assert.AreEqual("123456789", paymentItem.ConversationId);
Assert.IsNotNull(paymentItem.SystemTime);
Assert.IsNull(paymentItem.ErrorCode);
Assert.IsNull(paymentItem.ErrorMessage);
Assert.IsNull(paymentItem.ErrorGroup);
}
public PayoutItemBase(string payoutItemPayoutItemCode, string payoutItemPayoutCode, string payoutItemPaymentItemCode, decimal?payoutItemPayoutMoney, string payoutItemSubjectCode, string payoutItemRemark, string payoutItemAlloType, int?payoutItemIsManualAlloc, decimal?payoutItemPayoutCash, string payoutItemMoneyType, decimal?payoutItemExchangeRate, string payoutItemPayoutMoneyType, decimal?payoutItemPayoutExchangeRate)
{
this.inTxn = false;
this._payoutCodeSource = null;
this._paymentItemCodeSource = null;
this._site = null;
this.entityData = new PayoutItemEntityData();
this.backupData = null;
this.PayoutItemCode = payoutItemPayoutItemCode;
this.PayoutCode = payoutItemPayoutCode;
this.PaymentItemCode = payoutItemPaymentItemCode;
this.PayoutMoney = payoutItemPayoutMoney;
this.SubjectCode = payoutItemSubjectCode;
this.Remark = payoutItemRemark;
this.AlloType = payoutItemAlloType;
this.IsManualAlloc = payoutItemIsManualAlloc;
this.PayoutCash = payoutItemPayoutCash;
this.MoneyType = payoutItemMoneyType;
this.ExchangeRate = payoutItemExchangeRate;
this.PayoutMoneyType = payoutItemPayoutMoneyType;
this.PayoutExchangeRate = payoutItemPayoutExchangeRate;
}
private void UpdateOldPayment()
{
using (EditPayments editPay = new EditPayments())
{
editPay.txtPayNo.text = gridOtherPay[gridOtherPay.RowSel, 1].ToString();
editPay.txtAmount.text = gridOtherPay[gridOtherPay.RowSel, 2].ToString();
editPay.calDatePaid.Value = DateTime.Parse(gridOtherPay[gridOtherPay.RowSel, 3].ToString());
editPay.ShowDialog();
if (editPay.isConfirmed == true)
{
if (gridOld[gridOld.RowSel, 2].ToString() == "Tuition Fee")
{
var payManage = new PaymentManager();
var item = new PaymentItem();
item.Payment_Number = Int32.Parse(editPay.txtPayNo.text);
item.Payment_Paid = Decimal.Parse(editPay.txtAmount.text);
item.Payment_DatePaid = editPay.calDatePaid.Value.ToString("MM/dd/yyyy");
item.Payment_Id = selectedPayId;
payManage.UpdatePayment(item);
}
else
{
var otherPay = new OtherFeesPaymentManager();
var item = new OtherFeesPaymentItem();
item.OtherPay_Number = Int32.Parse(editPay.txtPayNo.text);
item.OtherPay_Paid = Decimal.Parse(editPay.txtAmount.text);
item.OtherPay_DatePaid = editPay.calDatePaid.Value.ToString("MM/dd/yyyy");
item.OtherPay_Id = selectedPayId;
otherPay.UpdateOtherPayment(item);
}
}
}
StdClick();
}
public async Task Should_Update_Payment_Item()
{
UpdatePaymentItemRequest request = new UpdatePaymentItemRequest
{
Locale = Locale.TR.ToString(),
ConversationId = "123456789",
SubMerchantKey = "subMerchantKey",
PaymentTransactionId = "transactionId",
SubMerchantPrice = "price"
};
PaymentItem paymentItem = await PaymentItem.UpdateAsync(request, Options);
PrintResponse(paymentItem);
Assert.AreEqual(Status.SUCCESS.ToString(), paymentItem.Status);
Assert.AreEqual(Locale.TR.ToString(), paymentItem.Locale);
Assert.AreEqual("123456789", paymentItem.ConversationId);
Assert.IsNotNull(paymentItem.SystemTime);
Assert.IsNull(paymentItem.ErrorCode);
Assert.IsNull(paymentItem.ErrorMessage);
Assert.IsNull(paymentItem.ErrorGroup);
}
private void ListViewClick(object sender, AdapterView.ItemClickEventArgs e)
{
switch (type)
{
case "payments":
var activity = new Intent(this, typeof(PaymentAddActivity));
PaymentItem item = payments[e.Position];
activity.PutExtra("Payment", JsonConvert.SerializeObject(item));
activity.PutExtra("Friends", JsonConvert.SerializeObject(friends));
activity.PutExtra("Trip", JsonConvert.SerializeObject(tripItem));
StartActivity(activity);
break;
case "friends":
break;
case "history":
break;
default:
break;
}
}
/// <summary>
/// Method for saving payment details to database.
/// </summary>
/// <param name="payment">The payment</param>
/// <returns>PaymentItem object</returns>
public async Task <PaymentItem> SavePaymentItemAsync(PaymentItem payment)
{
await using PaymentControllerDbContext context = DbContextProvider.Create();
Model.PaymentItem dbPaymentItem = payment.ToDb();
context.Payments.Add(dbPaymentItem);
try
{
if (payment.PaymentCustomer.CustomerId.IsValid())
{
context.Customers.Attach(dbPaymentItem.PaymentCustomer);
}
if (payment.PaymentCustomer.Address.AddressId.IsValid())
{
context.Address.Attach(dbPaymentItem.PaymentCustomer.Address);
}
if (payment.PaymentCard.CardId.IsValid())
{
context.Card.Attach(dbPaymentItem.PaymentCard);
}
context.Merchant.Attach(dbPaymentItem.PaymentMerchant);
await context.SaveChangesAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.LogWarning(ex, "An exception has occured in {name}", nameof(SavePaymentItemAsync));
Logger.LogInformation("Payment {PaymentId} failed to process.", payment.PaymentId);
throw;
}
return(dbPaymentItem.ToDto());
}
public static PaymentItem[] CreatePaymentItems(this CalculatePaymentItemRequest[] items)
{
var input = items.ToArray();
var result = new PaymentItem[input.Count()];
using (var container = new TransactionModelContainer())
{
for (int i = 0; i < result.Length; i++)
{
//int serviceCode = input[i].ServiceCode.ToInt();
result[i] = new PaymentItem(
//input[i].ServiceCode.ToInt(),
//container.ServiceCodes.FirstOrDefault(t => t.Code == serviceCode).Name,
input[i].Quantity,
input[i].UnitAmount,
input[i].VatPercent,
input[i].WithholdingTaxPercent,
input[i].ServiceIsRevenue,
input[i].IsLegalPerson,
input[i].ItemDescription);
}
}
return(result);
}
