public void New(int issuerEntityID, int receiverEntityID, int currencyID)
{
using (var ctx = new AccContexts())
using (var ts = new TransactionScope())
{
var newInvoice = new AccountingLib.Models.invoice()
{
issuerEntityID = issuerEntityID,
receiverEntityID = receiverEntityID,
currencyID = currencyID
};
ctx.invoice.AddObject(newInvoice);
ctx.SaveChanges();
//create invoice Action
var invAction = new AccountingLib.Models.invoiceAction()
{
invoiceID = newInvoice.ID,
invoiceStatID = (int)enums.invoiceStat.Generated
};
ctx.invoiceAction.AddObject(invAction);
ctx.SaveChanges();
this.loadInvoiceByInvoiceID(newInvoice.ID);
ts.Complete();
}
}
private void RecordInvoiceTransaction(List <int> transactions, enums.invoiceStat invoiceStat)
{
using (var ctx = new AccContexts())
using (var ts = new TransactionScope())
{
//create invoice Action
var invAction = new AccountingLib.Models.invoiceAction()
{
invoiceID = this.invoiceID,
invoiceStatID = (int)invoiceStat
};
ctx.invoiceAction.AddObject(invAction);
ctx.SaveChanges();
//create invoice Transactions and invoice action Transactions
foreach (var item in transactions)
{
var invActionTrans = new AccountingLib.Models.invoiceActionTransaction()
{
invoiceActionID = invAction.ID,
transactionID = item
};
ctx.invoiceActionTransaction.AddObject(invActionTrans);
ctx.SaveChanges();
}
ts.Complete();
}
}
public void New(string firstName, string lastName)
{
using (var ctx = new AccContexts())
{
base.New((int)enums.entityType.Person);
var checkDuplication = ctx.person.Where(x => x.firstName == firstName && x.lastName == lastName).FirstOrDefault();
if (checkDuplication != null)
{
throw new Exception("Person Duplicated");
}
var newPerson = new AccountingLib.Models.person()
{
firstName = firstName,
lastName = lastName,
entityID = base.ENTITYID
};
ctx.person.AddObject(newPerson);
ctx.SaveChanges();
this.id = newPerson.ID;
this.firstname = newPerson.firstName;
this.lastname = newPerson.lastName;
}
}
/*cancelling one payment od invoice at the time*/
public void cancelInvoicePaymentEXT(int paymentID)
{
using (var ctx = new AccContexts())
using (var ts = new TransactionScope())
{
accounting.classes.externalPayment payment = new accounting.classes.externalPayment();
payment.loadByPaymentID(paymentID);
List <int> transactions = payment.cancelPayment(enums.paymentAction.Void);
/*Record Invoice Payment transactions*/
this.RecordInvoicePaymentTransactions(transactions, paymentID, enums.paymentStat.VoidApproved);
/*Record Invoice Transaction*/
if (payment.extPaymentTypeID == (int)enums.extPaymentType.CreditPayment)
{
this.RecordInvoiceTransaction(transactions, enums.invoiceStat.partialCreditCardPaymantCancelled);
}
if (payment.extPaymentTypeID == (int)enums.extPaymentType.InteracPayment)
{
this.RecordInvoiceTransaction(transactions, enums.invoiceStat.partialInteracPaymantCancelled);
}
ts.Complete();
}
}
public void loadByCardID(int cardID)
{
using (var ctx = new AccContexts())
{
var paymentRecord = ctx.card
.Where(x => x.ID == cardID)
.Select(x => new
{
cardID = x.ID,
cardNumber = x.cardNumber,
cardTypeID = x.cardTypeID,
expiryDate = (DateTime)x.expiryDate,
})
.SingleOrDefault();
if (paymentRecord == null)
{
throw new Exception("no such a Card Exists");
}
this.cardID = paymentRecord.cardID;
this.cardTypeID = (int)paymentRecord.cardTypeID;
this.cardNumber = paymentRecord.cardNumber;
this.expiryDate = (DateTime)paymentRecord.expiryDate;
}
}
public AccountingLib.Models.account Create(int ownerEntityId, int currencyID, decimal balance = 0)
{
using (var ctx = new AccContexts())
{
var duplicate = ctx.account
.Where(x => x.ownerEntityID == ownerEntityId && x.currencyID == currencyID && x.catTypeID == CATTYPE)
.SingleOrDefault();
if (duplicate != null)
{
ctx.DeleteObject(duplicate);
}
var newAccount = new account()
{
catTypeID = CATTYPE,
ownerEntityID = ownerEntityId,
currencyID = currencyID,
balance = balance
};
ctx.account.AddObject(newAccount);
ctx.SaveChanges();
return(newAccount);
}
}
public void createNew(int cardTypeID)
{
if (this.cardNumber == null)
{
throw new Exception("No Card Number Entered");
}
if (this.expiryDate == null)
{
throw new Exception("No Expiy Date Entered");
}
using (var ctx = new AccContexts())
using (var ts = new TransactionScope())
{
var newCard = new AccountingLib.Models.card()
{
cardTypeID = cardTypeID,
cardNumber = this.cardNumber,
expiryDate = this.expiryDate
};
ctx.card.AddObject(newCard);
ctx.SaveChanges();
/*Reload object Props*/
this.loadByCardID(newCard.ID);
ts.Complete();
}
}
protected void loadByPaymentID(int paymentID)
{
using (var ctx = new AccContexts())
{
var paymentRecord = ctx.payment
.Where(x => x.ID == paymentID)
.Select(x => new
{
paymentID = x.ID,
payerEntityID = (int)x.payerEntityID,
payeeEntityID = (int)x.payeeEntityID,
amount = (decimal)x.amount,
paymentTypeID = (int)x.paymentTypeID,
currencyID = (int)x.currencyID
})
.SingleOrDefault();
if (paymentRecord == null)
{
throw new Exception("no such a Payment Exists");
}
this.paymentID = paymentRecord.paymentID;
this.paymentTypeID = (int)paymentRecord.paymentTypeID;
this.payerEntityID = (int)paymentRecord.payerEntityID;
this.payeeEntityID = (int)paymentRecord.payeeEntityID;
this.amount = (decimal)paymentRecord.amount;
this.currencyID = (int)paymentRecord.currencyID;
}
}
public void doCCExtPayment(decimal amount, int cardID, enums.ccCardType ccCardType)
{
//var ccFeeFor
using (var ctx = new AccContexts())
using (var ts = new TransactionScope())
{
classes.ccPayment creditCardPayment = new ccPayment();
creditCardPayment.createNew(this.receiverEntityID, this.issuerEntityID, amount, this.currencyID, cardID);
/*Record New Invoice Payment*/
var NewInvoicePayment = new AccountingLib.Models.invoicePayment()
{
invoiceID = invoiceID,
paymentID = creditCardPayment.paymentID
};
ctx.invoicePayment.AddObject(NewInvoicePayment);
ctx.SaveChanges();
//get Fee bank cardType
var card = new classes.card.CreditCard();
card.loadByCardID(cardID);
ccFee ccfee = new ccFee();
ccfee.loadccFeeByBankCardTypeID((int)ccCardType, (card as Entity).getBankByCard(card.cardID).bankID);
//Record related transctions [for invoice payment]
List <int> transactions = new List <int>();
transactions.Add(Transaction.createNew(receiverEntityID, (int)AssetCategories.CCCASH, -1 * amount, this.currencyID));
transactions.Add(Transaction.createNew(receiverEntityID, (int)LibCategories.AP, +1 * amount, this.currencyID));
transactions.Add(Transaction.createNew(issuerEntityID, (int)AssetCategories.W, +1 * amount - (decimal)ccfee.amount, this.currencyID));
transactions.Add(Transaction.createNew(issuerEntityID, (int)AssetCategories.AR, -1 * amount, this.currencyID));
transactions.Add(Transaction.createNew(issuerEntityID, (int)OECategories.EXP, (decimal)ccfee.amount, this.currencyID));
/*Record Invoice Payment transactions*/
this.RecordInvoicePaymentTransactions(transactions, creditCardPayment.paymentID, enums.paymentStat.PaidApproved);
/*Record Invoice Transaction*/
enums.invoiceStat?invoicestat = null;
switch (ccCardType)
{
case enums.ccCardType.MASTERCARD:
invoicestat = enums.invoiceStat.masterCardPaymant;
break;
case enums.ccCardType.VISACARD:
invoicestat = enums.invoiceStat.visaCardPaymant;
break;
}
this.RecordInvoiceTransaction(transactions, (enums.invoiceStat)invoicestat);
ts.Complete();
}
}
public static AccountingLib.Models.account getAccount(int entityID, int catTypeID, int currencyID)
{
using (var ctx = new AccContexts())
{
var account = ctx.account.Where(x => x.catTypeID == catTypeID && x.ownerEntityID == entityID && x.currencyID == currencyID).SingleOrDefault();
return(account);
}
}
/// <summary>
/// //Get Sum of Invoice Services added
/// </summary>
/// <param name="invoiceID"></param>
/// <returns></returns>
public decimal getInvoiceServicesSumAmt()
{
using (var ctx = new AccContexts())
{
var invoice = ctx.invoice.Where(x => x.ID == this.invoiceID).SingleOrDefault();
if (invoice == null)
{
throw new Exception();
}
var invoiceServicesAmt = ctx.invoiceService.Where(x => x.invoiceID == this.invoiceID).Sum(x => x.amount);
return((decimal)invoiceServicesAmt);
}
}
public List <AccountingLib.Models.card> fetchCards()
{
using (var ctx = new AccContexts())
{
var cardsList = ctx.entityCard
.Where(x => x.entityID == this.ENTITYID)
.Select(x => x.card).ToList();
this.cards = cardsList;
return(cardsList);
}
}
public List <AccountingLib.Models.payment> getAllPayments()
{
using (var ctx = new AccContexts())
{
var payments = ctx.invoicePayment
.Where(z => (int)z.invoiceID == this.invoiceID)
//.Where(z=>z.invoice.in)
.Select(x => x.payment)
.ToList();
return(payments);
}
}
public List <int> cancelPayment(enums.paymentAction _paymentAction)
{
//First check this payment is able to be cancelled ************
//get Related transacions and input reveres ones
using (var ctx = new AccContexts())
{
//get Payment details
var payment = ctx.payment
.Where(x => x.ID == paymentID).SingleOrDefault();
if (payment == null)
{
throw new Exception("Payment Could not be found");
}
this.paymentID = (int)payment.ID;
this.payerEntityID = (int)payment.payerEntityID;
this.payeeEntityID = (int)payment.payeeEntityID;
this.amount = (decimal)payment.amount;
this.currencyID = (int)payment.currencyID;
//get payment Transactions
var paymentTransactions = ctx.paymentAction
.Where(x => x.paymentID == this.paymentID)
.Single()
.paymentActionTransaction
.Select(x => new
{
ownerEntityID = x.transaction.account.ownerEntityID,
catTypeID = x.transaction.account.catTypeID,
amount = x.transaction.amount,
currencyID = x.transaction.account.currencyID
})
.ToList();
//enter and save revered Transactions
List <int> reveresedTransactions = new List <int>();
foreach (var txn in paymentTransactions)
{
reveresedTransactions.Add(Transaction.createNew((int)txn.ownerEntityID, (int)txn.catTypeID, -1 * (decimal)txn.amount, (int)txn.currencyID));
}
//IF PAYMENT ACTION IS REFUND, NEW FEE HANDLING TRANSACTIONS WOULD BE NEEDED
return(reveresedTransactions);
}
}
protected void New(int entityTypeID)
{
using (var ctx = new AccContexts())
{
var newEntity = new AccountingLib.Models.entity()
{
entityTypeID = entityTypeID
};
ctx.entity.AddObject(newEntity);
ctx.SaveChanges();
/*reload entity*/
this.ENTITYID = newEntity.ID;
}
}
public void loadccFeeByBankCardTypeID(int ccCardTypeID, int bankID)
{
using (var ctx = new AccContexts())
{
var ccfee = ctx.ccFee.Where(x => (int)x.ccCardTypeID == ccCardTypeID && x.bankID == bankID)
.SingleOrDefault();
if (ccfee == null)
{
throw new Exception("CC fee does not Exists [loadccFeeByBankCardTypeID]");
}
this.loadFeeByID(ccfee.ID);
}
}
public void addCard(int cardID)
{
int entityID = (int)this.ENTITYID;
using (var ctx = new AccContexts())
{
var person = ctx.person.Where(x => x.entityID == entityID).SingleOrDefault();
var newEntityCard = new AccountingLib.Models.entityCard()
{
entityID = this.ENTITYID,
CardID = cardID
};
ctx.entityCard.AddObject(newEntityCard);
ctx.SaveChanges();
}
}
/// <summary>
/// load the bank class params from DB by bankID
/// </summary>
/// <param name="bankID"></param>
private void loadBankByBankID(int bankID)
{
using (var ctx = new AccContexts())
{
var _bank = ctx.bank
.Where(x => x.ID == bankID).SingleOrDefault();
if (_bank == null)
{
throw new Exception("bank has not found");
}
this.bankID = _bank.ID;
this.bankName = _bank.name;
base.ENTITYID = (int)_bank.entityID;
}
}
public invoiceService addService(int serviceID, decimal amount)
{
using (var ctx = new AccContexts())
{
var newInvoiceService = new AccountingLib.Models.invoiceService()
{
invoiceID = this.invoiceID,
serviceID = serviceID,
currencyID = this.currencyID,
amount = amount
};
ctx.invoiceService.AddObject(newInvoiceService);
ctx.SaveChanges();
return(newInvoiceService);
}
}
private void loadInvoiceByInvoiceID(int invoiceID)
{
using (var ctx = new AccContexts())
{
var inv = ctx.invoice
.Where(x => x.ID == invoiceID).SingleOrDefault();
if (inv == null)
{
throw new Exception("Invoice does not exists");
}
this.invoiceID = inv.ID;
this.issuerEntityID = (int)inv.issuerEntityID;
this.receiverEntityID = (int)inv.receiverEntityID;
this.currencyID = (int)inv.currencyID;
}
}
public void doINTERACPayment(decimal amount, int cardID)
{
using (var ctx = new AccContexts())
using (var ts = new TransactionScope())
{
classes.dbPayment debitCardPayment = new dbPayment();
debitCardPayment.createNew(this.receiverEntityID, this.issuerEntityID, amount, this.currencyID, cardID);
/*Record New Invoice Payment*/
var NewInvoicePayment = new AccountingLib.Models.invoicePayment()
{
invoiceID = this.invoiceID,
paymentID = debitCardPayment.paymentID
};
ctx.invoicePayment.AddObject(NewInvoicePayment);
ctx.SaveChanges();
//get Fee bank cardType
var card = new classes.card.DebitCard();
card.loadByCardID(cardID);
Fee fee = new Fee();
fee.loadFeeByBankCardTypeID(card.cardTypeID, ((Entity)card).getBankByCard(cardID).bankID);
//Record related transctions [for invoice payment]
List <int> transactions = new List <int>();
transactions.Add(Transaction.createNew(receiverEntityID, (int)AssetCategories.DBCASH, -1 * amount, this.currencyID));
transactions.Add(Transaction.createNew(receiverEntityID, (int)LibCategories.AP, +1 * amount, this.currencyID));
transactions.Add(Transaction.createNew(issuerEntityID, (int)AssetCategories.W, +1 * amount - (decimal)fee.amount, this.currencyID));
transactions.Add(Transaction.createNew(issuerEntityID, (int)AssetCategories.AR, -1 * amount, this.currencyID));
transactions.Add(Transaction.createNew(issuerEntityID, (int)OECategories.EXP, (decimal)fee.amount, this.currencyID));
/*Record Invoice Payment transactions*/
this.RecordInvoicePaymentTransactions(transactions, debitCardPayment.paymentID, enums.paymentStat.PaidApproved);
/*Record Invoice Transaction*/
this.RecordInvoiceTransaction(transactions, enums.invoiceStat.interacPaymant);
ts.Complete();
}
}
public void cancelInvoicePaymentINTERNAL(int paymentID)
{
using (var ctx = new AccContexts())
using (var ts = new TransactionScope())
{
accounting.classes.internalPayment payment = new accounting.classes.internalPayment();
payment.loadByPaymentID(paymentID);
List <int> transactions = payment.cancelPayment(enums.paymentAction.Void);
/*Record Invoice Payment transactions*/
this.RecordInvoicePaymentTransactions(transactions, paymentID, enums.paymentStat.VoidApproved);
/*Record Invoice Transaction*/
this.RecordInvoiceTransaction(transactions, enums.invoiceStat.partialInternalPaymantCancelled);
ts.Complete();
}
}
protected void createNew(int payerEntityID, int payeeEntityID, decimal amount, int currencyID, int paymentTypeID)
{
using (var ctx = new AccContexts())
{
var _payment = new AccountingLib.Models.payment()
{
payerEntityID = payerEntityID,
payeeEntityID = payeeEntityID,
amount = amount,
currencyID = currencyID,
paymentTypeID = paymentTypeID
};
ctx.payment.AddObject(_payment);
ctx.SaveChanges();
loadByPaymentID(_payment.ID);
}
}
public void createNew(int payerEntityID, int payeeEntityID, decimal amount, int currencyID)
{
using (var ctx = new AccContexts())
using (var ts = new TransactionScope())
{
base.createNew(payerEntityID, payeeEntityID, amount, currencyID, (int)enums.paymentType.Internal);
var _internalPayment = new AccountingLib.Models.internalPayment()
{
paymentID = base.paymentID
};
ctx.internalPayment.AddObject(_internalPayment);
ctx.SaveChanges();
this.loadByPaymentID((int)_internalPayment.paymentID);
ts.Complete();
}
}
public new void loadByPaymentID(int paymentID)
{
using (var ctx = new AccContexts())
{
base.loadByPaymentID(paymentID);
var internalPaymentRecord = ctx.internalPayment
.Where(x => x.paymentID == paymentID)
.SingleOrDefault();
if (internalPaymentRecord == null)
{
throw new Exception("no such a EXT Payment Exists");
}
this.internalPaymentID = internalPaymentRecord.ID;
this.internalPaymentDescription = internalPaymentRecord.description;
}
}
private void loadPerson(int personEntityId)
{
using (var ctx = new AccContexts())
{
var person = ctx.person
.Where(x => x.entityID == personEntityId)
.SingleOrDefault();
if (person == null)
{
throw new Exception("no such a Person Exists");
}
this.id = person.ID;
this.firstname = person.firstName;
this.lastname = person.lastName;
base.ENTITYID = (int)person.entityID;
}
}
public void loadFeeByID(int ccfeeID)
{
using (var ctx = new AccContexts())
{
var _fee = ctx.ccFee
.Where(x => x.ID == ccfeeID)
.SingleOrDefault();
if (_fee == null)
{
throw new Exception("no such a CCFee Exists");
}
this.ccfeeID = _fee.ID;
this.bankID = (int)_fee.bankID;
this.ccCardTypeID = (int)_fee.ccCardTypeID;
this.amount = (decimal)_fee.amount;
this.deacription = _fee.description;
}
}
public void New()
{
base.createNew((int)enums.ccCardType.VISACARD);
using (var ctx = new AccContexts())
using (var ts = new TransactionScope())
{
var newvisaCard = new visaCard()
{
ccCardID = base.ccCardID
};
ctx.visaCard.AddObject(newvisaCard);
ctx.SaveChanges();
/*Reload object Props*/
this.visaCardID = newvisaCard.ID;
ts.Complete();
}
}
public void New()
{
using (var ctx = new AccContexts())
using (var ts = new TransactionScope())
{
base.createNew((int)enums.cardType.DebitCard);
var newDBCard = new AccountingLib.Models.dbCard()
{
cardID = base.cardID,
cardTypeID = this.CARDTYPEID
};
ctx.dbCard.AddObject(newDBCard);
ctx.SaveChanges();
/*reload object props*/
this.dbCardID = newDBCard.ID;
ts.Complete();
}
}
/// <summary>
/// 1-Records related transactions
/// 2-record Invoice Tranactions
/// </summary>
/// <param name="invoiceID"></param>
public void finalizeInvoice()
{
using (var ctx = new AccContexts())
using (var ts = new TransactionScope())
{
//Get Sum of Invoice Services added
decimal invoiceServicesAmt = this.getInvoiceServicesSumAmt();
//Record related transctions
List <int> transactions = new List <int>();
var trans1 = Transaction.createNew((int)this.receiverEntityID, (int)LibCategories.AP, -1 * (decimal)invoiceServicesAmt, (int)this.currencyID);
transactions.Add(trans1);
var trans2 = Transaction.createNew((int)this.issuerEntityID, (int)AssetCategories.AR, +1 * (decimal)invoiceServicesAmt, (int)this.currencyID);
transactions.Add(trans2);
/*Record Invoice Transaction*/
this.RecordInvoiceTransaction(transactions, enums.invoiceStat.Finalized);
ts.Complete();
}
}
