public void AddPaymentItem(PaymentItem item)
{
if (Installments.Count() <= 0 && PayInSlips.Count() <= 0)
{
PaymentItems.Add(item);
}
}
/// <summary>
/// Request a direct payment session
/// </summary>
/// <param name="credentials">PagSeguro credentials</param>
/// <returns><c cref="T:Uol.PagSeguro.CancelRequestResponse">Result</c></returns>
public static Installments GetInstallments(Credentials credentials, Decimal amount, String cardBrand, Int32 maxInstallmentNoInterest)
{
PagSeguroTrace.Info(String.Format(CultureInfo.InvariantCulture, "InstallmentService.GetInstallments() - begin"));
try
{
using (var response = HttpURLConnectionUtil.GetHttpGetConnection(
BuildInstallmentURL(credentials, amount, cardBrand, maxInstallmentNoInterest)))
{
using (XmlReader reader = XmlReader.Create(response.Content.ReadAsStreamAsync().Result))
{
Installments result = new Installments();
InstallmentsSerializer.Read(reader, result);
PagSeguroTrace.Info(String.Format(CultureInfo.InvariantCulture, "InstallmentService.Register({0}) - end", result.ToString()));
return(result);
}
}
}
catch (ArgumentException exception)
{
PagSeguroServiceException pse = new PagSeguroServiceException(exception.Message);
PagSeguroTrace.Error(String.Format(CultureInfo.InvariantCulture, "InstallmentService.Register() - error {0}", exception.Message));
throw pse;
}
catch (System.Exception exception)
{
PagSeguroServiceException pse = HttpURLConnectionUtil.CreatePagSeguroServiceException(exception);
PagSeguroTrace.Error(String.Format(CultureInfo.InvariantCulture, "InstallmentService.Register() - error {0}", pse));
throw pse;
}
}
/// <summary>
/// Request a direct payment session
/// </summary>
/// <param name="credentials">PagSeguro credentials</param>
/// <param name="amount"></param>
/// <param name="cardBrand"></param>
/// <param name="maxInstallmentNoInterest"></param>
/// <returns><c cref="T:Uol.PagSeguro.CancelRequestResponse">Result</c></returns>
public static Installments GetInstallments(Credentials credentials, decimal amount, string cardBrand, int maxInstallmentNoInterest)
{
PagSeguroTrace.Info(string.Format(CultureInfo.InvariantCulture, "InstallmentService.GetInstallments() - begin"));
try
{
using (var response = HttpUrlConnectionUtil.GetHttpGetConnection(
BuildInstallmentUrl(credentials, amount, cardBrand, maxInstallmentNoInterest)))
{
using (var reader = XmlReader.Create(response.GetResponseStream()))
{
var result = new Installments();
InstallmentsSerializer.Read(reader, result);
PagSeguroTrace.Info(string.Format(CultureInfo.InvariantCulture, "InstallmentService.Register({0}) - end", result.ToString()));
return(result);
}
}
}
catch (ArgumentException exception)
{
var pse = new PagSeguroServiceException(exception.Message);
PagSeguroTrace.Error(string.Format(CultureInfo.InvariantCulture, "InstallmentService.Register() - error {0}", exception.Message));
throw pse;
}
catch (WebException exception)
{
var pse = HttpUrlConnectionUtil.CreatePagSeguroServiceException((HttpWebResponse)exception.Response);
PagSeguroTrace.Error(string.Format(CultureInfo.InvariantCulture, "InstallmentService.Register() - error {0}", pse));
throw pse;
}
}
public List<Installments> DeleteDeleteInstallment(long Id, long bulkBuyID)
{
List<Installments> lstinstallments = new List<Installments>();
using (ShopDevEntities db = new ShopDevEntities())
{
try
{
BulkBuyInstallment installment = GetInstallment(db, Id);
var bulkbuy = db.BulkBuys.Where(m => m.BulkBuyID == bulkBuyID).FirstOrDefault();
var outstandingAmount = bulkbuy.OustandingAmont;
bulkbuy.OustandingAmont = outstandingAmount == null ? installment.Amount : outstandingAmount + installment.Amount;
var interstableAmount = bulkbuy.InterstableAmount;
bulkbuy.InterstableAmount = interstableAmount == null ? installment.Amount : interstableAmount + installment.Amount;
db.BulkBuyInstallments.Remove(installment);
db.SaveChanges();
var lstproducts = db.BulkBuyInstallments.Where(m => m.BulkBuyID == bulkBuyID).ToList();
foreach (var cusprod in lstproducts)
{
Installments objInstallments = new Installments();
cusprod.CopyProperties(objInstallments);
lstinstallments.Add(objInstallments);
}
}
catch (Exception)
{
}
return lstinstallments;
}
}
public async Task <ActionResult <Installments> > PostInstallments(Installments installments)
{
_context.Installments.Add(installments);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetInstallments", new { id = installments.InstallmentId }, installments));
}
static void Main(string[] args)
{
bool isSandbox = false;
EnvironmentConfiguration.ChangeEnvironment(isSandbox);
Decimal amount = 1000.00m;
String creditCardBrand = "visa";
Int32 maxInstallmentNoInterest = 5;
try
{
AccountCredentials credentials = PagSeguroConfiguration.GetAccountCredentials(isSandbox);
Installments result = InstallmentService.GetInstallments(credentials, amount, creditCardBrand, maxInstallmentNoInterest);
foreach (Installment installment in result.Get())
{
}
}
catch (PagSeguroServiceException exception)
{
foreach (ServiceError element in exception.Errors)
{
}
}
}
public Installments GetInstallmentsPagSeguro(Decimal amount, string creditCardBrand, int maxInstallmentNoInterest)
{
PagSeguroConfiguration.UrlXmlConfiguration = this.configuration;
bool isSandbox = true;
EnvironmentConfiguration.ChangeEnvironment(isSandbox);
try
{
AccountCredentials credentials = PagSeguroConfiguration.Credentials(isSandbox);
Installments result = InstallmentService.GetInstallments(credentials, amount, creditCardBrand, maxInstallmentNoInterest);
return(result);
}
catch (PagSeguroServiceException exception)
{
return(new Installments());
//foreach (ServiceError element in exception.Errors)
//{
//}
}
catch (Exception ex)
{
return(new Installments());
}
}
static void Main(string[] args)
{
bool isSandbox = false;
EnvironmentConfiguration.ChangeEnvironment(isSandbox);
Decimal amount = 1000.00m;
String creditCardBrand = "visa";
try
{
AccountCredentials credentials = PagSeguroConfiguration.Credentials(isSandbox);
Installments result = InstallmentService.GetInstallments(credentials, amount, creditCardBrand);
Console.WriteLine("Começando listagem de parcelas - \n");
foreach (Installment installment in result.Get())
{
Console.WriteLine(installment.ToString());
}
Console.WriteLine(" - Terminando listagem de parcelas ");
Console.ReadKey();
}
catch (PagSeguroServiceException exception)
{
Console.WriteLine(exception.Message + "\n");
foreach (ServiceError element in exception.Errors)
{
Console.WriteLine(element + "\n");
}
Console.ReadKey();
}
}
public void AddInstallments(string installedBy, params Installment[] installments)
{
if (string.IsNullOrEmpty(installedBy))
{
throw new ApplicationException("MISSING_UPDATE_BY");
}
if (installments == null || installments.Length < 1)
{
throw new ApplicationException("AT_LEAST_ONE_ITEM_REQUIRED");
}
UpdatedBy = installedBy;
UpdatedDate = DateTime.Now;
foreach (var installment in installments)
{
Installments.Add(installment);
var remaining = RemainingAmount();
if (remaining == 0)
{
Status = PaymentStatusEnum.PAID.ToString();
}
else if (remaining <= 0)
{
Status = PaymentStatusEnum.OVERPAID.ToString();
installment.CustomerCredits.Add(new CustomerCredit("System", Math.Abs(remaining), installment.Id,
CustomerIdmPartyId, CustomerName, CustomerAddress));
}
}
}
public void Update(Entities.Transactions.Transaction transaction)
{
TransactionDate = transaction.TransactionDate;
ApprovedDate = transaction.ApprovedDate;
ReprovedDate = transaction.ReprovedDate;
StatusAnticipation = transaction.Anticipation;
Confirmation = transaction.Confirmation;
GrossValue = transaction.GrossValue;
NetValue = transaction.NetValue;
FixedTax = transaction.FixedTax;
NumberParcel = transaction.NumberParcel;
CreditCardSuffix = transaction.CreditCardSuffix;
if (Installments.Any())
{
foreach (var installment in transaction.Installments)
{
foreach (var i in Installments)
{
if (i.Id == installment.Id)
{
i.Update(installment);
}
}
}
}
}
public async Task <IActionResult> PutInstallments(int id, Installments installments)
{
if (id != installments.InstallmentId)
{
return(BadRequest());
}
_context.Entry(installments).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InstallmentsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
// First Installment always occurs on PaymentPlan creation date
private void InitializeInstallments()
{
for (int interval = 0; interval < InstallmentCount; interval++)
{
Installments.Add(new Installment(OriginationDate.AddDays(interval * InstallmentIntervalDays), InstallmentAmount));
}
Installments.OrderBy(i => i.Date);
}
// Installments are paid in order by Date
public Installment NextInstallment()
{
var next = Installments.Where(i => i.IsPending)
.OrderBy(i => i.Date)
.FirstOrDefault();
return(next);
}
public BulkBuyViewModel GetBulk(long? bulkID)
{
BulkBuyViewModel bulkmodel = new BulkBuyViewModel();
using (ShopDevEntities db = new ShopDevEntities())
{
try
{
var bulkBuycustomerInfo = db.BulkBuys.Where(m => m.BulkBuyID == bulkID).FirstOrDefault();
var lstproducts = db.BulkBuyProducts.Where(m => m.BulkBuyID == bulkID).ToList();
var AllInstallments = db.BulkBuyInstallments.Where(m => m.BulkBuyID == bulkID).ToList();
var Allvendors = db.VendorDetails.Where(m => m.BulkByID == bulkID).ToList();
BulkBuyModel bbModel = new BulkBuyModel();
bulkBuycustomerInfo.CopyProperties(bbModel);
List<BulkBuyProductsModel> lstcsproducts = new List<BulkBuyProductsModel>();
foreach (var cusprod in lstproducts)
{
BulkBuyProductsModel objcsproduct = new BulkBuyProductsModel();
cusprod.CopyProperties(objcsproduct);
lstcsproducts.Add(objcsproduct);
}
List<VendorDetailsModel> lstvendors = new List<VendorDetailsModel>();
foreach (var cusprod in Allvendors)
{
VendorDetailsModel objcsproduct = new VendorDetailsModel();
cusprod.CopyProperties(objcsproduct);
lstvendors.Add(objcsproduct);
}
List<Installments> lstInstallments = new List<Installments>();
foreach (var cusprod in AllInstallments)
{
Installments objcsproduct = new Installments();
cusprod.CopyProperties(objcsproduct);
lstInstallments.Add(objcsproduct);
}
bulkmodel.bulkBuyModel = bbModel;
bulkmodel.Products = new BulkBuyProductsModel();
bulkmodel.lstbulkBuyProducts = new List<BulkBuyProductsModel>();
bulkmodel.lstbulkBuyProducts.AddRange(lstcsproducts);
bulkmodel.Vendors = new VendorDetailsModel();
bulkmodel.lstVendors = new List<VendorDetailsModel>();
bulkmodel.lstVendors.AddRange(lstvendors);
bulkmodel.installments = new Installments();
bulkmodel.lstinstallments = new List<Installments>();
bulkmodel.lstinstallments.AddRange(lstInstallments);
}
catch (Exception) { }
}
return bulkmodel;
}
public Installment FirstInstallment()
{
if (!Installments.Any())
{
throw new ApplicationException($"No Installments for Payment Plan Id {Id.ToString()}");
}
return(Installments.OrderBy(i => i.Date).FirstOrDefault());
}
public decimal OustandingBalance()
{
var outstandingBalance =
Installments
.Where(i => i.IsPending || i.IsDefaulted)
.Sum(i => i.Amount);
return(outstandingBalance);
}
// We only accept payments matching the Installment Amount.
public void MakePayment(decimal amount, Guid installmentId)
{
Installment installment = Installments.First(i => i.Id == installmentId);
if (amount != installment.Amount)
{
throw new ArgumentException();
}
installment.SetPaid(Id, DateTime.Now);
}
public void ProcessContract(Contract contract)
{
double valueInstallment = contract.TotalValue / Number;
for (int i = 1; i <= Number; i++)
{
DateTime newDate = contract.Date.AddMonths(i);
double v = _paymentService.Tax(valueInstallment, i);
Installments installment = new Installments(newDate, v);
contract.AddInstallments(installment);
}
}
// We only accept payments matching the Installment Amount.
public void MakePayment(decimal amount, Guid installmentId)
{
var activeAccount = Installments.Where(x => x.Id == installmentId);
foreach (var singleInstallment in activeAccount)
{
if (!singleInstallment.IsPaid && singleInstallment.Amount == amount)
{
singleInstallment.IsPaid = true;
break;
}
}
}
public decimal OustandingBalance(Guid installmentId)
{
var activeAccount = Installments.Where(x => x.Id == installmentId);
var balance = 0M;
foreach (var singleInstallment in activeAccount)
{
if (!singleInstallment.IsPaid && !singleInstallment.AccountClosed)
{
balance = balance + singleInstallment.Amount;
}
}
return(balance);
}
// Installments are paid in order by Date
public Installment NextInstallment()
{
var activeAccount = Installments.Where(x => x.Id == Id);
foreach (var singleInstallment in activeAccount)
{
if (!singleInstallment.IsPaid)
{
return(singleInstallment);
}
}
return(new Installment());
}
public Installments GetInstallmentDetails(long Id)
{
Installments objModel = new Installments();
using (ShopDevEntities db = new ShopDevEntities())
{
try
{
BulkBuyInstallment installment = GetInstallment(db, Id);
installment.CopyProperties(objModel);
}
catch (Exception)
{
}
}
return objModel;
}
public void AddPaymentItem(int serviceCode, string serviceName, int quantity, decimal unitAmount, decimal taxOrVat,
decimal withHoldingTax, bool isRevenue, bool isLegalPerson, string itemDescription)
{
if (Installments.Count() <= 0 && PayInSlips.Count() <= 0)
{
PaymentItems.Add(new PaymentItem(
//serviceCode,
//serviceName,
quantity,
unitAmount,
taxOrVat,
withHoldingTax,
isRevenue,
isLegalPerson,
itemDescription));
}
}
public List <Installments> CreateInstallmentsStrategy(Debt debt)
{
var installmentsList = new List <Installments>();
var installment = new Installments
{
Id = Guid.NewGuid(),
CreatedAt = DateTime.Now,
InstallmentNumber = 1,
Date = debt.Date,
Status = Status.NotPaid,
PaymentDate = null,
Value = debt.Value
};
installmentsList.Add(installment);
return(installmentsList);
}
public IList <Installment> PendingInstallments()
{
var intervals = InstallmentIntervalOfDays;
for (int i = 1; i < CountOfInstallations; i++)
{
var pendingInstallment = new Installment()
{
Id = Install.Id,
Amount = Install.Amount * 1 / CountOfInstallations,
Date = Install.Date.AddDays(intervals)
};
Installments.Add(pendingInstallment);
intervals = intervals + InstallmentIntervalOfDays;
}
return(Installments);
}
// First Installment always occurs on PaymentPlan creation date
private void InitializeInstallments()
{
var paymentAmountPerInstallment = TotalAmountDue / NumberOfInstallments;
//initialize with first payment
var initialPayment = new Installment(paymentAmountPerInstallment, OriginationDate);
Installments.Add(initialPayment);
var paymentDate = OriginationDate;
//rest of the payments
for (var i = 1; i < NumberOfInstallments; i++)
{
paymentDate = paymentDate.AddDays(InstallmentIntervalDays);
var installmentPayment = new Installment(paymentAmountPerInstallment, paymentDate);
Installments.Add(installmentPayment);
}
}
// We only accept payments matching the Installment Amount.
public void MakePayment(decimal amount, Guid installmentId)
{
if (!Installments.Any(i => i.Id == installmentId))
{
throw new ArgumentException($"No Installment Found for Provided installmentId: {installmentId}", nameof(installmentId));
}
var installment = Installments.Where(i => i.Id == installmentId).FirstOrDefault();
if (installment.Amount != amount)
{
throw new ArgumentException($"Payment amount must match installment amount.", nameof(amount));
}
//Simulating a third party api call
var paymentReferenceId = _thirdPartyPaymentService.MakePayment(amount);
installment.SetStatus(paymentReferenceId);
}
// We only accept payments matching the Installment Amount.
public void MakePayment(decimal amount, Guid installmentId)
{
if (!Installments.Any(i => i.Id == installmentId))
{
throw new ArgumentException($"No Installment Found for Provided installmentId: {installmentId}", nameof(installmentId));
}
var installment = Installments.Where(i => i.Id == installmentId).FirstOrDefault();
if (installment.Amount != amount)
{
throw new ArgumentException($"Payment amount must match installment amount.", nameof(amount));
}
//we call payment domain logic here, ie. service call or writing to an event stream
var paymentReferenceId = Guid.NewGuid(); //in this instance, i'm just setting some guid to be the payment reference id,
//but an actual implementation could call another service i.e 3rd party payment API
installment.SetPaid(paymentReferenceId.ToString());
}
/// <summary>
/// Read a direct payment session request result
/// </summary>
/// <param name="streamReader"></param>
/// <param name="installments"></param>
internal static void Read(XmlReader reader, Installments installments)
{
if (reader.IsEmptyElement)
{
XMLParserUtils.SkipNode(reader);
return;
}
reader.ReadStartElement(SerializerHelper.Installments);
reader.MoveToContent();
while (!reader.EOF)
{
if (XMLParserUtils.IsEndElement(reader, SerializerHelper.Installments))
{
XMLParserUtils.SkipNode(reader);
break;
}
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case SerializerHelper.Installment:
Installment installment = new Installment();
InstallmentSerializer.Read(reader, installment);
installments.Add(installment);
break;
default:
XMLParserUtils.SkipElement(reader);
break;
}
}
else
{
XMLParserUtils.SkipNode(reader);
}
}
}
public Installment FirstInstallment()
{
if (Install.Amount < 0 || CountOfInstallations < 1)
{
throw new ArgumentException();
}
var firstInstall = new Installment()
{
Id = Install.Id,
Amount = Install.Amount * 1 / CountOfInstallations,
Date = Install.Date
};
if (Install.IsPending)
{
Install.IsPending = false;
Installments.Add(firstInstall);
PendingInstallments();
}
return(firstInstall);
}
