internal int DB_InsertPayment(double Amount, int BillId, string Currency, int MemberId)
{
using (var connection = new OleDbConnection(@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source=|DataDirectory|\BC.accdb"))
using (var command = connection.CreateCommand())
{
connection.Open();
command.CommandType = CommandType.Text;
command.CommandText = "INSERT INTO Payments (MemberId, BillId, [Currency], [Amount]) VALUES (@MemberId, @BillId, @Currency, @Amount)";
command.Parameters.Add("@MemberId", OleDbType.Integer).Value = MemberId;
command.Parameters.Add("@BillId", OleDbType.Integer).Value = BillId;
command.Parameters.Add("@Currency", OleDbType.VarChar).Value = Currency;
command.Parameters.Add("@Amount", OleDbType.Double).Value = Amount;
try
{
int Rows = command.ExecuteNonQuery();
Payments.Add(new Payment(MemberId, BillId, Currency, Amount));
return(Rows);
}
catch
{
return(-1); //for error
}
}
}
public void SetupInvoice(Invoice invoice)
{
Invoice = invoice;
InvoiceId = Invoice.Id == -1 ? "Creating a New Invoice" : "#" + Invoice.Id;
if (Invoice.Client != null)
{
CompanyName = Invoice.Client.Company;
ClientName = Invoice.Client.FullName;
}
InvoiceDate = Invoice.InvoiceDate?.ToString("MMM dd, yyyy");
DueDate = Invoice.DueDate?.ToString("MMM dd, yyyy");
IsPaid = Invoice.Status.InvoiceStatusType == InvoiceStatusType.Paid;
Items.Clear();
Payments.Clear();
if (Invoice.Id == -1)
{
NewItem();
NewPayment();
}
else
{
foreach (InvoiceItem i in Invoice.Items)
{
Items.Add(i);
}
foreach (InvoicePayment i in Invoice.Payments)
{
Payments.Add(i);
}
}
}
public void generateAmortizationSchedule()
{
double balance = Loan.Principal;
double interestAmount;
double principalAmount;
// loop through each payment period
for (var i = 0; i < Loan.Term; i++)
{
// calculate payment details
interestAmount = Math.Round(Loan.Rate * balance, 2);
principalAmount = Math.Round(baseMonthlyPayment - interestAmount, 2);
// account for last payment, where principal amount will be the remaining balance
if (i + 1 == Loan.Term)
{
principalAmount = balance;
}
// update the balance
balance = Math.Round(balance - principalAmount, 2);
// create a new object to represent each payment per period
PaymentModel newPayment = new PaymentModel()
{
PaymentNumber = i + 1,
PaymentAmount = baseMonthlyPayment,
InterestAmount = interestAmount,
PrincipalAmount = principalAmount,
Balance = balance
};
// append the payment object to the list of payments
Payments.Add(newPayment);
}
}
public void PopulatePayments()
{
Payments.Clear();
if (ContestantId == null)
{
return;
}
if (CurrentOlympiadId == null)
{
return;
}
var context = DataEntitiesProvider.Provide();
var olympiadId = CurrentOlympiadId;
var contestantId = int.Parse(ContestantId);
var payments = context.Payments.Where(x => x.OlympiadId == olympiadId && x.MindSportsID == contestantId)
.OrderBy(x => x.PaymentNumber).ToList();
foreach (var p in payments)
{
Payments.Add(new PaymentVm()
{
Amount = p.Payment1.Value,
Banked = (p.Banked.HasValue && p.Banked.Value == 1),
Method = p.Payment_Method,
PaymentId = p.PaymentNumber
});
}
}
private async void LoadPayments()
{
IsBusy = true;
Payments.Clear();
var accounts = await accountRepository.FindAllWhereAsync(a => a.UserId == App.SignedUserId);
var payments = await paymentRepository.FindAllAsync();
payments = payments.Where(p => accounts.Any(a => a.Id == p.AccountId)).ToList();
var services = await serviceRepository.FindAllAsync();
services = services.Where(s => payments.Any(p => p.ServiceId == s.Id)).ToList();
payments.Reverse();
foreach (var payment in payments)
{
var account = accounts.FirstOrDefault(a => a.Id == payment.AccountId);
Payments.Add(new PaymentItem
{
Payment = payment,
Account = account?.Description,
Currency = account?.Currency,
Service = services.FirstOrDefault(s => s.Id == payment.ServiceId)?.Description
});
}
IsBusy = false;
}
protected virtual void ProcessRow(SafeReader sr)
{
LastRowType = null;
RowType nRowType;
string sRowType = sr.ContainsField("DatumType", "RowType") ? sr["DatumType"] : sr["RowType"];
if (!Enum.TryParse(sRowType, out nRowType))
{
Log.Alert("Unsupported row type encountered: '{0}'.", sRowType);
return;
} // if
LastRowType = nRowType;
Log.Debug("Auto approve agent, processing input row of type {0}.", sRowType);
switch (nRowType)
{
case RowType.MetaData:
sr.Fill(MetaData);
break;
case RowType.Payment:
Payments.Add(sr.Fill <Payment>());
break;
case RowType.OriginationTime:
OriginationTime.Process(sr);
break;
case RowType.Turnover:
Turnover.Add(sr.Fill <TurnoverDbRow>());
break;
case RowType.DirectorName:
DirectorNames.Add(new Name(sr["FirstName"], sr["LastName"]));
break;
case RowType.HmrcBusinessName:
if (sr["BelongsToCustomer"])
{
HmrcBusinessNames.Add(new NameForComparison(sr["Name"]));
}
break;
case RowType.ExperianConsumerDataCais:
this.caisAccounts.Add(sr.Fill <ExperianConsumerDataCaisAccounts>());
break;
case RowType.CompanyDissolutionDate:
MetaData.CompanyDissolutionDate = sr["CompanyDissolutionDate"];
break;
default:
throw new ArgumentOutOfRangeException();
} // switch
} // ProcessRow
public CustomerEntity AddPayment(Payment payment)
{
Payments.Add(payment);
Debit = new Price {
Currency = Currency.UsDollars, Value = 0
};
return(this);
}
public void AddPayment(Payment p)
{
Payments.Add(p);
if (p.PaymentType == PaymentType.Points)
{
_sumPointsAmount += p.Amount;
}
}
public void AddPayment(Payment payment)
{
if (payment == null)
{
throw new ArgumentNullException(nameof(payment));
}
Payments.Add(payment);
}
public void AddFunds(Payment payment)
{
var funds = payment.Value + Wallet.Funds;
Funds = funds;
Wallet = new Wallet(funds);
Payments.Add(payment);
}
/// <summary>
/// This WILL modify the current class's CurrentMonth and CurrentBalance
/// Make payment to loan returns payment information
/// Adds payment to Payments within this class
/// </summary>
/// <param name="amount"></param>
/// <returns></returns>
public Payment MakeSinglePayment(decimal amount)
{
Payment pmt = new Payment(Name, CurrentMonth, Apr, Balance, amount);
Balance = pmt.NewBalance;
CurrentMonth = CurrentMonth.AddMonths(1);
Payments.Add(pmt);
return(pmt);
}
public Enrollment(DateTime enrollmentDate, Activity activity,
Payment payment, User user) : this()
{
CancellationDate = null;
EnrollmentDate = enrollmentDate;
ReturnedFirstCuotaIfCancelledActivity = null;
//Id is managed by EE
Activity = activity;
Payments.Add(payment);
User = user;
}
public void Test_Add_and_GetRange_Empty(DateTime startAt, DateTime endAt, IEnumerable <ValueTuple <DateTime, decimal> > amounts)
{
Subject = new Payments();
foreach (var amount in amounts)
{
Subject.Add(amount.Item1, amount.Item2);
}
Assert.That(Subject.GetRange(startAt, endAt), Is.Empty);
}
/// <summary>
/// Loads the payment from the reader object and adds it to the payments collection.
/// </summary>
/// <param name="view">The view.</param>
protected void LoadPayment(DataView view)
{
// Read until we are done, since this is a collection
foreach (DataRowView row in view)
{
string type = row["ImplementationClass"].ToString();
ClassInfo classInfo = new ClassInfo(type);
Payment orderPayment = (Payment)classInfo.CreateInstance();
orderPayment.Load(row);
Payments.Add(orderPayment);
}
}
public void AddPayment(PaymentType paymentType, Account account, decimal amount, decimal exchangeRate, int userId)
{
var transaction = TransactionDocument.AddNewTransaction(paymentType.AccountTransactionType, GetTicketAccounts(account), amount, exchangeRate);
transaction.UpdateDescription(transaction.Name + " [" + account.Name + "]");
var payment = new Payment {
AccountTransaction = transaction, Amount = amount, Name = account.Name, PaymentTypeId = paymentType.Id, UserId = userId
};
Payments.Add(payment);
LastPaymentDate = DateTime.Now;
RemainingAmount = GetRemainingAmount();
}
public bool AddEftposPayment(decimal amount, Employee employee)
{
bool check = canMakePayment();
if (check == true)
{
var payment = new EftposPayment(this, amount);
Payments.Add(payment);
var message = string.Format("EftposPayment Added\nPayment Amount{0} @ Type{1}", payment.Amount, payment.PaymentType);
saleUpdated(employee, message);
}
return(check);
}
public void AddRefund(POSRefund refund)
{
foreach (POSExchange pay in Payments)
{
if (pay is POSPayment)
{
if (pay.PaymentID == refund.PaymentID)
{
((POSPayment)pay).PaymentStatus = POSPayment.Status.REFUNDED;
}
}
}
Payments.Add(refund);
}
private void AddDataToList(DataRow val)
{
Payments.Add(new BookIraHzzoModel
{
DatumPlacanja = DateTime.Parse(val[0].ToString()),
Dokument = val[1].ToString(),
OriginalniBroj = val[2].ToString(),
DatumDokumenta = DateTime.Parse(val[3].ToString()),
Program = val[4].ToString(),
Opis = val[5].ToString(),
IznosRacuna = decimal.Parse(val[6].ToString()),
PlaceniIznos = decimal.Parse(val[7].ToString())
});
}
public ResultSvc <Payment> CreatePayment(Payment payment)
{
var result = new ResultSvc <Payment>(payment);
try
{
payment.UserCreatedId = Context.HttpContext.User.GetUserId();
Payments.Add(payment);
}
catch (Exception e)
{
Logger.LogError(e.Message);
}
return(result);
}
public void AddPayment(PaymentType paymentType, Account account, decimal amount, decimal exchangeRate, int userId)
{
var transaction = TransactionDocument.AddNewTransaction(paymentType.AccountTransactionType, GetTicketAccounts(account), amount, exchangeRate);
var payment = new Payment {
AccountTransaction = transaction, Amount = amount, Name = account.Name, PaymentTypeId = paymentType.Id
};
Payments.Add(payment);
LastPaymentDate = DateTime.Now;
RemainingAmount = GetRemainingAmount();
if (RemainingAmount == 0)
{
PaidItems.Clear();
}
}
void ParseBottomLine(InvoiceLine line)
{
if (line.TransCode.ToLower() == "y")
{
Payments.Add(new Payment
{
Amount = line.Price,
PaymentType = PaymentTypeController.PaymentTypes.Where(x => x.Id == line.Description).FirstOrDefault(),
});
}
else
{
Console.WriteLine(line);
}
}
public void AddRefund(POSRefund refund)
{
foreach (POSExchange pay in Payments)
{
if (pay is POSPayment)
{
if (pay.PaymentID == refund.PaymentID)
{
((POSPayment)pay).PaymentStatus = POSPayment.Status.REFUNDED;
}
}
}
Payments.Add(refund);
onOrderChange(this, OrderChangeTarget.PAYMENT);
}
public Payment AddPayment(DateTime date, decimal amount, PaymentType paymentType, int userId, int departmentId)
{
var result = new Payment {
Amount = amount, Date = date, PaymentType = (int)paymentType, UserId = userId, DepartmentId = departmentId
};
DepartmentId = departmentId;
Payments.Add(result);
LastPaymentDate = DateTime.Now;
RemainingAmount = GetRemainingAmount();
if (RemainingAmount == 0)
{
PaidItems.Clear();
}
return(result);
}
public void AddPayment(Payment.Payment payment)
{
if (payment.Amount == 0)
{
throw new InvalidChargeException("Cannot add payment to invoice, invalid amount");
}
if (payment.Currency != this.Currency)
{
throw new InvalidChargeException("Cannot add payment to invoice, invalid currency");
}
if (payment.Date.Year != this.Year || payment.Date.Month != this.Month)
{
throw new InvalidChargeException("Cannot add payment to invoice, invalid charge date");
}
Payments.Add(payment);
}
/// <summary>
/// Привязка к таблице
/// </summary>
private void AddBindingPays(IPaymentModel paymentModel, bool isManual)
{
Payments.Add(paymentModel);
_paymentRows.Add(new PaymentRowModel()
{
Id = paymentModel.Id,
Guid = paymentModel.Guid,
PaymentDate = paymentModel.PaymentDate,
Type = GetPaymentType(paymentModel),
Amount = paymentModel.Amount,
IsManual = isManual
});
gcPays.DataSource = _paymentRows;
gcPays.RefreshDataSource();
RecalculatePayment();
}
public Order AddPayment(Payment payment)
{
if (Payments.IsNullOrZero())
{
Payments = new List <Payment>();
}
RemainingPayment -= payment.Amount;
if (RemainingPayment == 0)
{
PaymentIsComplete = true;
PaymentCompleteDateTime = DateTime.UtcNow;
}
if (RemainingPayment < 0)
{
throw new BadRequestException("Invalid payment.".MakeThisRedable());
}
Payments.Add(payment);
return(this);
}
public void ConfirmSale(string input, Customer customer)
{
Console.WriteLine("\n------------------Confirming Sale------------------\n");
float amountdue = 0;
Console.WriteLine($"\n\nCurrent Cart list (Markup: {(int)customer.TypeOfCustomer}%):\n");
foreach (var item in Cart)
{
amountdue += CalculateSalePrice(customer, item, item.Quantity);
Console.WriteLine($"\n{item.ProductName} : R{CalculateSalePrice(customer, item, item.Quantity)} ({item.Quantity})");
}
Console.WriteLine($"\n\nTotal amount due is R{amountdue}");
do
{
Console.WriteLine($"\nPlease enter amount to pay:\n");
Console.WriteLine();
input = Console.ReadLine();
if (input.All(Char.IsDigit) && Convert.ToInt64(input) >= amountdue)
{
foreach (var product in Cart)
{
ProcessSale(customer, product, product.Quantity);
}
Payments.Add(new Payment(Cart, customer.PayMethod, amountdue, customer, Convert.ToInt64(input) - amountdue));
Payments[Payments.Count - 1].DisplayPaymentInfo();
break;
}
else
{
Console.WriteLine("\n\nInvalid amount inputed or amount payed is less than amount due, please try again.");
}
} while (true);
Console.WriteLine("\n\nPayment Complete!!!");
Console.WriteLine("\n------------------------------------\n");
}
public string AddPayment(
int person_id,
decimal sum,
DateTime dateOfPayment,
string admin,
int dormId
)
{
try
{
Payments.Add(new Payment
{
person_id = person_id,
sum = sum,
date_payment = dateOfPayment
});
Accounts.GetAll().
Where(account => account.id_person == person_id).
Select(x => x).ToList().ForEach(a => a.sum += sum);
string personName = Persons.GetAll().Where(p => p.id_person == person_id).
Select(p => p.surname + " " + p.name).ToList().Last();
string description = "Успешно проведен платеж на " + sum.ToString() + " от " + personName +
". Администратор " + Dormitories.Get(dormId).name + " - " + admin + ". " + dateOfPayment.ToString();
History.Add(new History
{
admin_name = admin,
dorm_id = dormId,
description = description,
addPaymentFlag = true
});
return(description);
}
catch { return("Что-то пошло не так."); }
}
async Task GetPaymentsAsync(int machineId)
{
if (IsBusy)
{
return;
}
try
{
IsBusy = true;
var json = await Client.GetStringAsync(string.Format(Host + SelectPayment, machineId));
var payments = Payment.FromJson(json);
//Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
//() =>
// {
// Payments.Clear();
// foreach (var payment in payments)
// Payments.Add(payment);
// }
//);
Payments.Clear();
foreach (var payment in payments)
{
Payments.Add(payment);
}
}
catch (Exception ex)
{
Debug.WriteLine($"Unable to get payments: {ex.Message}");
await Application.Current.MainPage.DisplayAlert("Error!", ex.Message, "OK");
}
finally
{
IsBusy = false;
}
}
protected void FillSearchCriterias()
{
StartTime = EndTime = null;
SortAscending = false;
SearchStatus = string.Empty;
SortOrders.Clear();
Payments.Clear();
foreach (PaymentCriteria test in Enum.GetValues(typeof(PaymentCriteria)))
{
var item = new CheckListItem <PaymentCriteria>(EnumLocalizer.Default.Translate(test), test);
Payments.Add(item);
}
foreach (ProductsSortOrder test in Enum.GetValues(typeof(ProductsSortOrder)))
{
var item = new CheckListItem <ProductsSortOrder>(EnumLocalizer.Default.Translate(test), test);
SortOrders.Add(item);
}
SelectedPayment = PaymentCriteria.Any;
SelectedSortOrder = ProductsSortOrder.ByDate;
}
