public void TotalAmount_is_correct_when_fractions_of_cents_is_low()
{
var contact = FakesHelper.CreateContact();
var invoice = new Invoice { InvoiceNumber = "10000", FromDate = DateTime.Now.AddMonths(-2), ToDate = DateTime.Now.AddMonths(-1), TotalIncGst = 100.23451M };
var line = EwayLineItem.Create(invoice, contact);
Assert.AreEqual(10023, line.TotalAmount);
}
public void Contract_activated_after_invoice_to_date_is_not_invoiced()
{
var invoice = new Invoice { FromDate = DateTime.Now.AddMonths(-2), ToDate = DateTime.Now.AddMonths(-1) };
var contract = new Contract(1, DateTime.Now.AddDays(-10))
{
ContractStatus = ContractStatus.Active,
ActivationDate = DateTime.Now.AddDays(-10),
StatusChangedDate = DateTime.Now.AddDays(-10)
};
var isBillable = invoice.IsContractBillable(contract);
Assert.IsFalse(isBillable);
}
public void HasContractBeenClosedInThisInvoicePeriod_returns_false_if_closed_after_invoice_period()
{
var invoice = new Invoice { FromDate = DateTime.Now.AddMonths(-2), ToDate = DateTime.Now.AddMonths(-1) };
var contract = new Contract(1, DateTime.Now.AddMonths(-6))
{
ContractStatus = ContractStatus.Closed,
StatusChangedDate = invoice.ToDate.AddDays(10)
};
var hasClosed = invoice.HasContractBeenClosedInThisInvoicePeriod(contract);
Assert.IsFalse(hasClosed);
}
public void CalculateContractStartProrata_returns_one_if_activated_before_invoice_start()
{
var invoice = new Invoice { FromDate = DateTime.Now.AddMonths(-2), ToDate = DateTime.Now.AddMonths(-1) };
var contract = new Contract(1, DateTime.Now.AddMonths(-6))
{
ContractStatus = ContractStatus.Active,
ActivationDate = invoice.FromDate.AddDays(-3),
StatusChangedDate = invoice.FromDate.AddDays(10)
};
var rate = invoice.CalculateContractStartProrataRate(contract);
Assert.AreEqual(1, rate);
}
public void CalculateContractStartProrata_returns_two_days_when_contract_actived_two_days_after_invocie_start_period()
{
var invoice = new Invoice { FromDate = DateTime.Now.AddMonths(-2), ToDate = DateTime.Now.AddMonths(2) };
var contract = new Contract(1, DateTime.Now.AddMonths(-6))
{
ContractStatus = ContractStatus.Active,
ActivationDate = invoice.FromDate.AddDays(2),
StatusChangedDate = invoice.FromDate.AddDays(10)
};
var rate = invoice.CalculateContractStartProrataRate(contract);
Assert.AreEqual(1-2/(365.25/12), rate);
}
public void CalculateContractStartProrata_returns_1_exception_when_activation_outside_invoice_period()
{
var invoice = new Invoice { FromDate = DateTime.Now.AddMonths(-2), ToDate = DateTime.Now.AddMonths(-1) };
var contract = new Contract(1, DateTime.Now.AddMonths(-6))
{
ContractStatus = ContractStatus.Active,
ActivationDate = invoice.ToDate.AddDays(2),
StatusChangedDate = invoice.FromDate.AddDays(10)
};
var rate = invoice.CalculateContractStartProrataRate(contract);
Assert.AreEqual(1, rate);
}
public void Can_create_ewaylineitem()
{
var invoice = new Invoice { InvoiceNumber = "10000", FromDate = DateTime.Now.AddMonths(-2), ToDate = DateTime.Now.AddMonths(-1), TotalIncGst = 100M };
var contact = new Contact
{
CreditCard =
new CreditCard
{
CardNumber = "1234567890",
CreditCardType = CreditCardType.Visa,
ExpiryDate = "11/12",
NameOnCard = "Test User"
},
Name = "Test User",
Email = "*****@*****.**",
HomeAddress =
new Address()
{
Street = "123 Here St",
Suburb = "Hereford",
State = "NSW",
Postcode = "2222"
},
};
var line = EwayLineItem.Create(invoice, contact);
Assert.AreEqual(10000, line.TotalAmount);
Assert.AreEqual("Test", line.CustomerFirstName);
Assert.AreEqual("User", line.CustomerLastName);
Assert.AreEqual("*****@*****.**", line.CustomerEmail);
Assert.AreEqual("123 Here St Hereford NSW 2222", line.CustomerAddress);
Assert.AreEqual("2222", line.CustomerPostCode);
Assert.AreEqual("I Satellite Airtime", line.CustomerInvoiceDescription);
Assert.AreEqual("10000", line.CustomerInvoiceRef);
Assert.AreEqual("Test User", line.CardHoldersName);
Assert.AreEqual("1234567890", line.CardNumber);
Assert.AreEqual("12", line.CardExpiryYear);
Assert.AreEqual("11", line.CardExpiryMonth);
}
protected void EmailInvoice(Invoice invoice, bool overrideRestrictions)
{
try
{
if (invoice == null) {
return;
}
var rootAccount = _accountRepository.GetAccount(invoice.InvoiceRootAccountId);
if (rootAccount == null) {
LoggingUtility.LogDebug("EmailInvoice", "AirtimeBilling.Service.InvoicingService",
"Could not find a root account for this invoice");
return;
}
var invoiceFile = SaveInvoiceHardcopy(invoice);
IList<string> emailAttachmentFiles = new List<string>();
// SRD-PCMS-51 (001-73) Invoice pdf and emailed to customer
if ((rootAccount.EmailBill && !string.IsNullOrEmpty(invoice.Email)) || overrideRestrictions)
{
emailAttachmentFiles.Add(invoiceFile);
}
// SRD-PCMS-54 (001-76) Invoice export file emailed
if ((rootAccount.EmailBillDataFile && !string.IsNullOrEmpty(invoice.Email)) || overrideRestrictions)
{
var creator = new InvoiceDataFileCreator();
var exportFilename = creator.CreateFile(invoice);
if (!string.IsNullOrEmpty(exportFilename))
{
emailAttachmentFiles.Add(exportFilename);
}
}
if (!string.IsNullOrEmpty(invoice.Email) && emailAttachmentFiles.Count > 0)
{
// Get the contact for the InvoiceRoot.
var contact = GetContactForInvoice(invoice);
var emailMsg = new InvoiceEmailMessage
{
InvoiceDate = invoice.InvoiceDate,
InvoiceNumber = invoice.InvoiceNumber,
Name = contact.Name
};
LoggingUtility.SendEmailWithAttachments(invoice.Email, invoice.To,
"I Airtime Invoice " + invoice.InvoiceNumber,
emailMsg,
false, emailAttachmentFiles);
// SRD-PCMS-52 (001-74) Invoice emailed to Customer Activity.
var emailMsgText = string.Format("Sent Invoice '{0}' via Email.", invoice.InvoiceNumber);
contact.LogActivity(emailMsgText);
rootAccount.LogActivity(emailMsgText);
}
}
catch (Exception ex)
{
LoggingUtility.LogException(ex);
}
}
public static void PopulateFromEntity(this InvoiceHeader header, Invoice entity)
{
header.InvoiceNumber = entity.InvoiceNumber;
header.InvoiceDate = entity.InvoiceDate;
header.FromDate = entity.FromDate;
header.ToDate = entity.ToDate;
header.InvoiceRunNumber = entity.InvoiceRunNumber;
header.To = entity.To;
header.Street = entity.InvoiceAddress.Street;
header.Street2 = entity.InvoiceAddress.Street2;
header.Suburb = entity.InvoiceAddress.Suburb;
header.State = entity.InvoiceAddress.State;
header.Postcode = entity.InvoiceAddress.Postcode;
header.PreviousBill = entity.PreviousBill;
header.AmountPaid = entity.AmountPaid;
header.NewCharges = entity.NewCharges;
header.TotalIncGst = entity.TotalIncGst;
header.TotalExGst = entity.TotalExGst;
header.TotalGst = entity.TotalGst;
header.Outstanding = entity.Outstanding;
header.PaymentDue = entity.PaymentDue;
header.CurrentBill = entity.CurrentBill;
header.IsInternational = entity is NoGstInvoice ? true : false;
header.HasFailedPayment = entity.HasFailedPayment;
}
public static Invoice GetInvoiceEntity(this InvoiceHeader header)
{
var address = new Address
{
Street = header.Street,
Street2 = header.Street2,
Suburb = header.Suburb,
State = header.State,
Postcode = header.Postcode
};
Invoice entity;
if (header.IsInternational.HasValue && header.IsInternational.Value) {
entity = new NoGstInvoice(header.InvoiceHeaderId);
} else {
entity = new Invoice(header.InvoiceHeaderId);
}
entity.InvoiceNumber = header.InvoiceNumber;
entity.InvoiceDate = header.InvoiceDate;
entity.InvoiceAddress = address;
entity.FromDate = header.FromDate;
entity.ToDate = header.ToDate;
entity.InvoiceRunNumber = header.InvoiceRunNumber;
entity.To = header.To;
entity.PreviousBill = header.PreviousBill;
entity.AmountPaid = header.AmountPaid;
entity.Outstanding = header.Outstanding;
entity.NewCharges = header.NewCharges;
entity.CurrentBill = header.CurrentBill;
entity.TotalIncGst = header.TotalIncGst;
entity.TotalGst = header.TotalGst;
entity.TotalExGst = header.TotalExGst;
entity.HasFailedPayment = header.HasFailedPayment;
if (header.PaymentDue.HasValue)
entity.PaymentDue = header.PaymentDue.Value;
foreach (var item in header.InvoiceLineItems)
{
var call = item.Call.CreateEntity();
var line = new InvoiceLine(item.InvoiceLineItemId)
{
Call = call,
Description = item.Description,
LineAmount = item.LineAmount,
GstAmount = item.GstAmount,
Invoice = entity,
ContractId = item.ContractId
};
entity.AddLine(line);
}
foreach (var account in header.AccountInvoices)
{
entity.AddAccount(account.AccountId);
if (account.Account.IsInvoiceRoot)
{
entity.InvoiceRootAccountId = account.AccountId;
}
}
using (var db = DbFactory.GetDataContext())
{
var item = (from h in db.InvoiceHeaders
join ai in db.AccountInvoices on h.InvoiceHeaderId equals ai.InvoiceHeaderId
where h.InvoiceNumber.Equals(header.InvoiceNumber) && ai.Account.IsInvoiceRoot
select new { ai.Account.Contact.Email }).FirstOrDefault();
if (item != null)
{
entity.Email = item.Email;
}
}
return entity;
}
public static EwayLineItem Create(Invoice invoice, Contact contact)
{
var exportLine = new EwayLineItem
{
TotalAmount = ((int)(Math.Round(invoice.TotalIncGst, 2) * 100)),
CustomerFirstName = contact.FirstName,
CustomerLastName = contact.LastName,
CustomerEmail = contact.Email,
CustomerAddress = contact.HomeAddress.ToString(),
CustomerPostCode = contact.HomeAddress.Postcode,
CustomerInvoiceRef = invoice.InvoiceNumber,
CustomerInvoiceDescription = "I Satellite Airtime",
CardHoldersName = contact.CreditCard.NameOnCard,
CardNumber = contact.CreditCard.CardNumber,
CardExpiryYear = contact.CreditCard.ExpiryDate.Substring(3, 2),
CardExpiryMonth = contact.CreditCard.ExpiryDate.Substring(0, 2)
};
return exportLine;
}
/// <summary>
/// Finds the Contact for the Account that is the InvoiceRoot for this invoice
/// </summary>
private Contact GetContactForInvoice(Invoice invoice)
{
if (invoice == null) return null;
var rootAccount = _accountRepository.GetAccount(invoice.InvoiceRootAccountId);
return _contactRepository.GetContactEntity(rootAccount.ContactId);
}
protected string GetInvoiceHardcopyFilename(Invoice invoice)
{
return _invoiceHardcopyRepository.Get(invoice);
}
protected void EmailInvoice(Invoice invoice)
{
EmailInvoice(invoice, false);
}
/// <summary>
/// Exports the given invoice data lines to file
/// </summary>
/// <param name="lines">Lines to export</param>
/// <param name="invoice"></param>
/// <returns>The filename of the exported file</returns>
private string ExportLinesToFile(IEnumerable<InvoiceDataExportLine> lines, Invoice invoice)
{
// Now export to something or other.
var filename = string.Format(@"{0}\{1}.csv", ConfigItems.InvoicesFolder, invoice.InvoiceNumber);
try {
if (File.Exists(filename)) File.Delete(filename);
var fileDescription = new CsvFileDescription
{
SeparatorChar = ',',
FirstLineHasColumnNames = true,
FileCultureName = "en-AU"
};
var context = new CsvContext();
context.Write(lines, filename, fileDescription);
return filename;
} catch (Exception ex) {
LoggingUtility.LogException(ex);
return null;
}
}
/// <summary>
/// Creates a datafile based on the supplied invoice.
/// </summary>
/// <param name="invoice"></param>
/// <returns>The filename of the created file.</returns>
public string CreateFile(Invoice invoice)
{
IDictionary<int, Account> accountCache = new Dictionary<int, Account>();
IDictionary<int, Contract> contractCache = new Dictionary<int, Contract>();
var exportLines = new List<InvoiceDataExportLine>();
try
{
var masterAccount = _accountRepository.GetAccount(invoice.InvoiceRootAccountId);
if (!accountCache.ContainsKey(masterAccount.Id.Value))
{
accountCache.Add(masterAccount.Id.Value, masterAccount);
}
foreach (var line in invoice.Lines)
{
var exportLine = new InvoiceDataExportLine
{
InvoiceNumber = invoice.InvoiceNumber,
InvoiceDate = invoice.InvoiceDate,
MasterAccountNumber = masterAccount.AccountNumber,
Description = line.Description,
Cost = line.LineAmount
};
if (line.ContractId.HasValue)
{
if (!contractCache.ContainsKey(line.ContractId.Value))
{
contractCache.Add(line.ContractId.Value, _contractRepository.GetContract(line.ContractId.Value));
}
var contract = contractCache[line.ContractId.Value];
if (!accountCache.ContainsKey(contract.AccountId))
{
accountCache.Add(contract.AccountId, _accountRepository.GetAccount(contract.AccountId));
}
var account = accountCache[contract.AccountId];
exportLine.AccountNumber = account.AccountNumber;
exportLine.ContractNumber = contract.ContractNumber;
}
if (line.Call != null)
{
exportLine.Duration = line.Call.Volume;
exportLine.OriginatingNumber = line.Call.PhoneNumber;
exportLine.CalledNumber = line.Call.NumberCalled;
exportLine.CallType = line.Call.Tariff;
}
exportLines.Add(exportLine);
}
return ExportLinesToFile(exportLines, invoice);
}
catch (Exception ex)
{
LoggingUtility.LogException(ex);
return null;
}
}
/// <summary>
/// Save invoice as PDF to file system
/// </summary>
/// <param name="invoice">Invoice to save</param>
public string SaveInvoiceHardcopy(Invoice invoice)
{
try {
return _invoiceHardcopyRepository.Save(invoice);
}
catch (Exception ex) {
LoggingUtility.LogException(ex);
}
return null;
}
