private void UpdateSalesOrderStatus(SalesInvoiceHeader salesInvoice, SalesOrderHeader salesOrder)
{
// update the sales order status
if (salesOrder == null)
{
// get the first order line
salesOrder =
GetSalesOrderLineById(salesInvoice.SalesInvoiceLines.FirstOrDefault().SalesOrderLineId.GetValueOrDefault())
.SalesOrderHeader;
}
// if all orderline has no remaining qty to invoice, set the status to fullyinvoice
bool hasRemainingQtyToInvoice = false;
foreach (var line in salesOrder.SalesOrderLines)
{
if (line.GetRemainingQtyToInvoice() > 0)
{
hasRemainingQtyToInvoice = true;
break;
}
}
if (!hasRemainingQtyToInvoice)
{
salesOrder.Status = SalesOrderStatus.FullyInvoiced;
_salesOrderRepo.Update(salesOrder);
}
}
public ActionResult SaveSalesInvoice(Models.ViewModels.Sales.AddSalesInvoice model)
{
if (model.AddSalesInvoiceLines.Sum(i => i.Amount) == 0 || model.AddSalesInvoiceLines.Count < 1)
{
model.Customers = Models.ModelViewHelper.Customers();
model.Items = Models.ModelViewHelper.Items();
model.Measurements = Models.ModelViewHelper.Measurements();
ModelState.AddModelError("Amount", "No invoice line");
return(View(model));
}
var invoiceHeader = new SalesInvoiceHeader();
var invoiceLines = new List <SalesInvoiceLine>();
foreach (var item in model.AddSalesInvoiceLines)
{
var Item = _inventoryService.GetItemById(item.ItemId);
var invoiceDetail = new SalesInvoiceLine();
invoiceDetail.TaxId = Item.ItemTaxGroupId;
invoiceDetail.ItemId = item.ItemId;
invoiceDetail.MeasurementId = item.MeasurementId;
invoiceDetail.Quantity = item.Quantity;
invoiceDetail.Discount = item.Discount;
invoiceDetail.Amount = Convert.ToDecimal(item.Quantity * Item.Price);
invoiceLines.Add(invoiceDetail);
}
invoiceHeader.SalesInvoiceLines = invoiceLines;
invoiceHeader.CustomerId = model.CustomerId;
invoiceHeader.Date = model.Date;
invoiceHeader.ShippingHandlingCharge = 4;// model.ShippingHandlingCharge;
_salesService.AddSalesInvoice(invoiceHeader, model.SalesOrderId);
return(RedirectToAction("SalesInvoices"));
}
public ActionResult GenerateBulkInvoice(Models.ViewModels.Administration.CreateBulkInvoice model)
{
var day = 15;
var month = DateTime.Now.Month == 12 ? 1 : DateTime.Now.Month + 1;
var year = DateTime.Now.Month == 12 ? DateTime.Now.Year + 1 : DateTime.Now.Year;
DateTime invoiceDate = new DateTime(year, month, day);
var query = from c in _salesService.GetCustomers()
select c;
var customers = query.ToList();
var itemAssociationDues = (from i in _inventoryService.GetAllItems().ToList()
where (i != null &&
i.SellDescription.ToLower().Contains("dues"))
select i).FirstOrDefault();
var invoices = new List <SalesInvoiceHeader>();
foreach (var customer in customers)
{
var current = (from si in _salesService.GetSalesInvoices()
where si.CustomerId == customer.Id &&
si.Date.Year == invoiceDate.Year &&
si.Date.Month == invoiceDate.Month &&
si.Date.Day == invoiceDate.Day
select si).FirstOrDefault();
if (current != null)
{
return(RedirectToAction("BulkInvoice"));
}
var invoiceLine = new SalesInvoiceLine();
invoiceLine.ItemId = itemAssociationDues.Id;
invoiceLine.Quantity = 1;
invoiceLine.Amount = Convert.ToDecimal(itemAssociationDues.Price * invoiceLine.Quantity);
invoiceLine.MeasurementId = itemAssociationDues.SmallestMeasurementId.Value;
invoiceLine.CreatedBy = User.Identity.Name;
invoiceLine.CreatedOn = DateTime.Now;
invoiceLine.ModifiedBy = User.Identity.Name;
invoiceLine.ModifiedOn = DateTime.Now;
var invoice = new SalesInvoiceHeader();
invoice.Date = invoiceDate;
invoice.CustomerId = customer.Id;
invoice.CreatedBy = User.Identity.Name;
invoice.CreatedOn = DateTime.Now;
invoice.ModifiedBy = User.Identity.Name;
invoice.ModifiedOn = DateTime.Now;
invoice.SalesInvoiceLines.Add(invoiceLine);
invoices.Add(invoice);
}
foreach (var invoice in invoices)
{
_salesService.AddSalesInvoice(invoice, null);
}
return(RedirectToAction("SalesInvoices", "Sales"));
}
public void UpdatePaymentStatus(int invoiceid)
{
decimal payments = 0;
SalesInvoiceHeader inv = new SalesInvoiceHeader();
GenericQuery q = new GenericQuery();
try
{
inv = inv.GetSalesInvoiceHeaders(invoiceid);
string sql = "select sum(amount) as TotalPayments from payment where invoiceid=" + inv.InvoiceID;
DataSet ds = new DataSet();
ds = q.GetDataSet(false, sql);
if (ds.Tables[0].Rows.Count > 0)
{
payments = decimal.Parse(ds.Tables[0].Rows[0]["TotalPayments"].ToString());
}
if (payments >= inv.TotalDue)
{
inv.Status = 5;
inv.UpdateSalesInvoiceHeader(inv);
}
}
catch (Exception ex)
{
throw (ex);
}
finally
{
inv = null;
q = null;
}
}
public ActionResult SaveInvoice(Models.ViewModels.Sales.SalesHeaderViewModel model)
{
SalesInvoiceHeader invoice = null;
if (model.Id == 0)
{
invoice = new SalesInvoiceHeader();
invoice.CreatedBy = User.Identity.Name;
invoice.CreatedOn = DateTime.Now;
}
else
{
invoice = _salesService.GetSalesInvoiceById(model.Id);
}
invoice.ModifiedBy = User.Identity.Name;
invoice.ModifiedOn = DateTime.Now;
invoice.CustomerId = model.CustomerId.Value;
invoice.Date = model.Date;
invoice.ShippingHandlingCharge = model.ShippingHandlingCharges;
foreach (var line in model.SalesLine.SalesLineItems)
{
SalesInvoiceLine lineItem = null;
var item = _inventoryService.GetItemByNo(line.ItemNo);
if (!line.Id.HasValue)
{
lineItem = new SalesInvoiceLine();
lineItem.CreatedBy = User.Identity.Name;
lineItem.CreatedOn = DateTime.Now;
invoice.SalesInvoiceLines.Add(lineItem);
}
else
{
lineItem = invoice.SalesInvoiceLines.Where(i => i.Id == line.Id).FirstOrDefault();
}
lineItem.ModifiedBy = User.Identity.Name;
lineItem.ModifiedOn = DateTime.Now;
lineItem.ItemId = line.ItemId;
lineItem.MeasurementId = item.SellMeasurementId.Value;
lineItem.Quantity = line.Quantity;
lineItem.Discount = line.Discount;
lineItem.Amount = line.Price;
}
if (model.Id == 0)
{
_salesService.AddSalesInvoice(invoice, null);
}
else
{
_salesService.UpdateSalesInvoice(invoice);
}
return(RedirectToAction("SalesInvoices"));
}
public SalesInvoiceHeaderCollection GetAllSalesInvoiceHeadersDynamicCollection(string whereExpression, string orderBy)
{
IDBManager dbm = new DBManager();
SalesInvoiceHeaderCollection cols = new SalesInvoiceHeaderCollection();
try
{
dbm.CreateParameters(2);
dbm.AddParameters(0, "@WhereCondition", whereExpression);
dbm.AddParameters(1, "@OrderByExpression", orderBy);
IDataReader reader = dbm.ExecuteReader(CommandType.StoredProcedure, "SelectSalesInvoiceHeadersDynamic");
while (reader.Read())
{
SalesInvoiceHeader SIH = new SalesInvoiceHeader();
SIH.InvoiceID = Int32.Parse(reader["InvoiceID"].ToString());
SIH.InvoiceNumber = reader["InvoiceNumber"].ToString();
SIH.InvoiceDate = DateTime.Parse(reader["InvoiceDate"].ToString());
SIH.DueDate = DateTime.Parse(reader["DueDate"].ToString());
SIH.Status = Byte.Parse(reader["Status"].ToString());
SIH.AccountNumber = reader["AccountNumber"].ToString();
SIH.SaleOrderID = Int32.Parse(reader["SaleOrderID"].ToString());
SIH.SalesPersonID = Int32.Parse(reader["SalesPersonID"].ToString());
SIH.TerritoryID = Int32.Parse(reader["TerritoryID"].ToString());
SIH.BillToAddressID = Int32.Parse(reader["BillToAddressID"].ToString());
SIH.ShipToAddressID = Int32.Parse(reader["ShipToAddressID"].ToString());
SIH.PaymentMethodID = Int32.Parse(reader["PaymentMethodID"].ToString());
SIH.SubTotal = decimal.Parse(reader["SubTotal"].ToString());
SIH.TaxAmt = decimal.Parse(reader["TaxAmt"].ToString());
SIH.Freight = decimal.Parse(reader["Freight"].ToString());
SIH.TotalDue = decimal.Parse(reader["TotalDue"].ToString());
SIH.Comment = reader["Comment"].ToString();
SIH.ModifiedDate = DateTime.Parse(reader["ModifiedDate"].ToString());
cols.Add(SIH);
}
}
catch (Exception ex)
{
log.Write(ex.Message, "GetAllSalesInvoiceHeadersDynamicCollection");
throw (ex);
}
finally
{
dbm.Dispose();
}
return(cols);
}
public SalesInvoiceHeader GetSalesInvoiceHeader(int InvoiceID)
{
IDBManager dbm = new DBManager();
SalesInvoiceHeader SIH = new SalesInvoiceHeader();
try
{
dbm.CreateParameters(1);
dbm.AddParameters(0, "@InvoiceID", InvoiceID);
IDataReader reader = dbm.ExecuteReader(CommandType.StoredProcedure, "SelectSalesInvoiceHeader");
while (reader.Read())
{
SIH.InvoiceID = Int32.Parse(reader["InvoiceID"].ToString());
SIH.InvoiceNumber = reader["InvoiceNumber"].ToString();
SIH.InvoiceDate = DateTime.Parse(reader["InvoiceDate"].ToString());
SIH.DueDate = DateTime.Parse(reader["DueDate"].ToString());
SIH.Status = Byte.Parse(reader["Status"].ToString());
SIH.AccountNumber = reader["AccountNumber"].ToString();
SIH.SaleOrderID = Int32.Parse(reader["SaleOrderID"].ToString());
SIH.SalesPersonID = Int32.Parse(reader["SalesPersonID"].ToString());
SIH.TerritoryID = Int32.Parse(reader["TerritoryID"].ToString());
SIH.BillToAddressID = Int32.Parse(reader["BillToAddressID"].ToString());
SIH.ShipToAddressID = Int32.Parse(reader["ShipToAddressID"].ToString());
SIH.PaymentMethodID = Int32.Parse(reader["PaymentMethodID"].ToString());
SIH.SubTotal = decimal.Parse(reader["SubTotal"].ToString());
SIH.TaxAmt = decimal.Parse(reader["TaxAmt"].ToString());
SIH.Freight = decimal.Parse(reader["Freight"].ToString());
SIH.TotalDue = decimal.Parse(reader["TotalDue"].ToString());
SIH.Comment = reader["Comment"].ToString();
SIH.ModifiedDate = DateTime.Parse(reader["ModifiedDate"].ToString());
}
}
catch (Exception ex)
{
log.Write(ex.Message, "GetSalesInvoiceHeader");
throw (ex);
}
finally
{
dbm.Dispose();
}
return(SIH);
}
public int AddSalesInvoiceHeader(SalesInvoiceHeader SIH)
{
IDBManager dbm = new DBManager();
try
{
dbm.CreateParameters(18);
dbm.AddParameters(0, "@InvoiceNumber", SIH.InvoiceNumber);
dbm.AddParameters(1, "@InvoiceDate", SIH.InvoiceDate);
dbm.AddParameters(2, "@DueDate", SIH.DueDate);
dbm.AddParameters(3, "@Status", SIH.Status);
dbm.AddParameters(4, "@AccountNumber", SIH.AccountNumber);
dbm.AddParameters(5, "@SaleOrderID", SIH.SaleOrderID);
dbm.AddParameters(6, "@SalesPersonID", SIH.SalesPersonID);
dbm.AddParameters(7, "@TerritoryID", SIH.TerritoryID);
dbm.AddParameters(8, "@BillToAddressID", SIH.BillToAddressID);
dbm.AddParameters(9, "@ShipToAddressID", SIH.ShipToAddressID);
dbm.AddParameters(10, "@PaymentMethodID", SIH.PaymentMethodID);
dbm.AddParameters(11, "@SubTotal", SIH.SubTotal);
dbm.AddParameters(12, "@TaxAmt", SIH.TaxAmt);
dbm.AddParameters(13, "@Freight", SIH.Freight);
dbm.AddParameters(14, "@TotalDue", SIH.TotalDue);
dbm.AddParameters(15, "@Comment", SIH.Comment);
dbm.AddParameters(16, "@ModifiedDate", DateTime.Now);
dbm.AddParameters(17, "@InvoiceID", SIH.InvoiceID);
dbm.Parameters[17].Direction = ParameterDirection.Output;
dbm.ExecuteNonQuery(CommandType.StoredProcedure, "InsertSalesInvoiceHeader");
SIH.InvoiceID = Int32.Parse(dbm.Parameters[17].Value.ToString());
}
catch (Exception ex)
{
log.Write(ex.Message, "InsertSalesInvoiceHeader");
throw (ex);
}
finally
{
dbm.Dispose();
}
return(SIH.InvoiceID);
}
public bool DeleteSalesInvoiceHeader(SalesInvoiceHeader SIH)
{
IDBManager dbm = new DBManager();
try
{
dbm.CreateParameters(1);
dbm.AddParameters(0, "@InvoiceID", SIH.InvoiceID);
dbm.ExecuteNonQuery(CommandType.StoredProcedure, "DeleteSalesInvoiceHeader");
}
catch (Exception ex)
{
log.Write(ex.Message, "DeleteSalesInvoiceHeader");
throw (ex);
}
finally
{
dbm.Dispose();
}
return(true);
}
public void ExportDueInvoices()
{
SqlCompactConnection conn = new SqlCompactConnection();
SalesInvoiceHeader sih = new SalesInvoiceHeader();
DataSet ds = new DataSet();
int count = 0;
try
{
ds = sih.GetInvoicesBalance();
count = ds.Tables[0].Rows.Count;
progressBar1.Minimum = 0;
progressBar1.Maximum = count;
lblStatus.Text = "Exporting Invoices (" + count.ToString() + " records)";
RefreshForm();
conn.DropInvoicesBalanceTable();
//progressBar1.Value = count/5 ;
RefreshForm();
conn.SynchForm = this;
conn.CreateInvoicesBalanceTable();
//progressBar1.Value = count * 2/5;
RefreshForm();
if (ds != null)
{
conn.InsertInvoicesBalance(ds.Tables[0]);
}
//progressBar1.Value = count ;
//RefreshForm();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
finally
{
conn.CloseDatabase();
conn = null;
}
}
public static SalesInvoiceHeader CreateSalesInvoiceHeader(string dataAreaId,
string invoiceNumber,
global::System.DateTimeOffset invoiceDate,
decimal totalTaxAmount,
decimal totalDiscountCustomerGroupCode,
decimal totalChargeAmount,
decimal totalDiscountAmount,
decimal invoiceHeaderTaxAmount,
decimal totalInvoiceAmount)
{
SalesInvoiceHeader salesInvoiceHeader = new SalesInvoiceHeader();
salesInvoiceHeader.dataAreaId = dataAreaId;
salesInvoiceHeader.InvoiceNumber = invoiceNumber;
salesInvoiceHeader.InvoiceDate = invoiceDate;
salesInvoiceHeader.TotalTaxAmount = totalTaxAmount;
salesInvoiceHeader.TotalDiscountCustomerGroupCode = totalDiscountCustomerGroupCode;
salesInvoiceHeader.TotalChargeAmount = totalChargeAmount;
salesInvoiceHeader.TotalDiscountAmount = totalDiscountAmount;
salesInvoiceHeader.InvoiceHeaderTaxAmount = invoiceHeaderTaxAmount;
salesInvoiceHeader.TotalInvoiceAmount = totalInvoiceAmount;
return(salesInvoiceHeader);
}
public void SaveSalesInvoice(SalesInvoiceHeader salesInvoice, SalesOrderHeader salesOrder)
{
// This method should be in a single transaction. when one fails, roll back all changes.
try
{
// is there any new order line item? save it first. otherwise, saving invoice will fail.
if (salesOrder != null && salesOrder.SalesOrderLines.Where(id => id.Id == 0).Count() > 0)
{
if (salesOrder.Id == 0)
{
salesOrder.No = GetNextNumber(SequenceNumberTypes.SalesOrder).ToString();
_salesOrderRepo.Insert(salesOrder);
}
else
{
_salesOrderRepo.Update(salesOrder);
}
}
if (salesInvoice.Id == 0)
{
salesInvoice.No = GetNextNumber(SequenceNumberTypes.SalesInvoice).ToString();
_salesInvoiceRepo.Insert(salesInvoice);
}
else
{
_salesInvoiceRepo.Update(salesInvoice);
}
UpdateSalesOrderStatus(salesInvoice, salesOrder);
}
catch (Exception ex)
{
throw ex;
}
}
public void UpdateSalesInvoice(SalesInvoiceHeader salesInvoice)
{
_salesInvoiceRepo.Update(salesInvoice);
}
public void AddSalesInvoice(SalesInvoiceHeader salesInvoice, int?salesDeliveryId)
{
decimal totalAmount = 0, totalDiscount = 0;
var taxes = new List <KeyValuePair <int, decimal> >();
var sales = new List <KeyValuePair <int, decimal> >();
var glHeader = _financialService.CreateGeneralLedgerHeader(DocumentTypes.SalesInvoice, salesInvoice.Date, string.Empty);
var customer = _customerRepo.GetById(salesInvoice.CustomerId);
foreach (var lineItem in salesInvoice.SalesInvoiceLines)
{
var item = _itemRepo.GetById(lineItem.ItemId);
var lineAmount = lineItem.Quantity * lineItem.Amount;
if (!item.GLAccountsValidated())
{
throw new Exception("Item is not correctly setup for financial transaction. Please check if GL accounts are all set.");
}
var lineDiscountAmount = (lineItem.Discount / 100) * lineAmount;
totalDiscount += lineDiscountAmount;
var totalLineAmount = lineAmount - lineDiscountAmount;
totalAmount += totalLineAmount;
var lineTaxes = _financialService.ComputeOutputTax(salesInvoice.CustomerId, item.Id, lineItem.Quantity, lineItem.Amount, lineItem.Discount);
foreach (var t in lineTaxes)
{
taxes.Add(t);
}
var lineTaxAmount = lineTaxes != null && lineTaxes.Count > 0 ? lineTaxes.Sum(t => t.Value) : 0;
totalLineAmount = totalLineAmount - lineTaxAmount;
sales.Add(new KeyValuePair <int, decimal>(item.SalesAccountId.Value, totalLineAmount));
if (item.ItemCategory.ItemType == ItemTypes.Purchased)
{
lineItem.InventoryControlJournal = _inventoryService.CreateInventoryControlJournal(lineItem.ItemId,
lineItem.MeasurementId,
DocumentTypes.SalesInvoice,
null,
lineItem.Quantity,
lineItem.Quantity * item.Cost,
lineItem.Quantity * item.Price);
}
}
totalAmount += salesInvoice.ShippingHandlingCharge;
var debitCustomerAR = _financialService.CreateGeneralLedgerLine(DrOrCrSide.Dr, customer.AccountsReceivableAccount.Id, Math.Round(totalAmount, 2, MidpointRounding.ToEven));
glHeader.GeneralLedgerLines.Add(debitCustomerAR);
var groupedSalesAccount = from s in sales
group s by s.Key into grouped
select new
{
Key = grouped.Key,
Value = grouped.Sum(s => s.Value)
};
foreach (var salesAccount in groupedSalesAccount)
{
var salesAmount = salesAccount.Value;
var creditSalesAccount = _financialService.CreateGeneralLedgerLine(DrOrCrSide.Cr, salesAccount.Key, Math.Round(salesAmount, 2, MidpointRounding.ToEven));
glHeader.GeneralLedgerLines.Add(creditSalesAccount);
}
if (taxes != null && taxes.Count > 0)
{
var groupedTaxes = from t in taxes
group t by t.Key into grouped
select new
{
Key = grouped.Key,
Value = grouped.Sum(t => t.Value)
};
foreach (var tax in groupedTaxes)
{
var tx = _financialService.GetTaxes().Where(t => t.Id == tax.Key).FirstOrDefault();
var creditSalesTaxAccount = _financialService.CreateGeneralLedgerLine(DrOrCrSide.Cr, tx.SalesAccountId.Value, Math.Round(tax.Value, 2, MidpointRounding.ToEven));
glHeader.GeneralLedgerLines.Add(creditSalesTaxAccount);
}
}
if (totalDiscount > 0)
{
var salesDiscountAccount = base.GetGeneralLedgerSetting().SalesDiscountAccount;
var creditSalesDiscountAccount = _financialService.CreateGeneralLedgerLine(DrOrCrSide.Dr, salesDiscountAccount.Id, Math.Round(totalDiscount, 2, MidpointRounding.ToEven));
glHeader.GeneralLedgerLines.Add(creditSalesDiscountAccount);
}
if (salesInvoice.ShippingHandlingCharge > 0)
{
var shippingHandlingAccount = base.GetGeneralLedgerSetting().ShippingChargeAccount;
var creditShippingHandlingAccount = _financialService.CreateGeneralLedgerLine(DrOrCrSide.Cr, shippingHandlingAccount.Id, Math.Round(salesInvoice.ShippingHandlingCharge, 2, MidpointRounding.ToEven));
glHeader.GeneralLedgerLines.Add(creditShippingHandlingAccount);
}
if (_financialService.ValidateGeneralLedgerEntry(glHeader))
{
salesInvoice.GeneralLedgerHeader = glHeader;
salesInvoice.No = GetNextNumber(SequenceNumberTypes.SalesInvoice).ToString();
if (!salesDeliveryId.HasValue)
{
var salesDelivery = new SalesDeliveryHeader()
{
CustomerId = salesInvoice.CustomerId,
Date = salesInvoice.Date,
};
foreach (var line in salesInvoice.SalesInvoiceLines)
{
var item = _itemRepo.GetById(line.ItemId);
salesDelivery.SalesDeliveryLines.Add(new SalesDeliveryLine()
{
ItemId = line.ItemId,
MeasurementId = line.MeasurementId,
Quantity = line.Quantity,
Discount = line.Discount,
Price = item.Cost.Value,
});
}
AddSalesDelivery(salesDelivery, false);
salesInvoice.SalesDeliveryHeader = salesDelivery;
}
_salesInvoiceRepo.Insert(salesInvoice);
}
}
public void AddSalesInvoice(SalesInvoiceHeader salesInvoice, int?salesDeliveryId)
{
decimal totalAmount = 0, totalDiscount = 0;
var taxes = new List <KeyValuePair <int, decimal> >();
var sales = new List <KeyValuePair <int, decimal> >();
//var glHeader = _financialService.CreateGeneralLedgerHeader(DocumentTypes.SalesInvoice, salesInvoice.Date, string.Empty);
var customer = _customerRepo.GetById(salesInvoice.CustomerId);
foreach (var lineItem in salesInvoice.SalesInvoiceLines)
{
var item = _itemRepo.GetById(lineItem.ItemId);
var lineAmount = lineItem.Quantity * lineItem.Amount;
if (!item.GLAccountsValidated())
{
throw new Exception("Item is not correctly setup for financial transaction. Please check if GL accounts are all set.");
}
var lineDiscountAmount = (lineItem.Discount / 100) * lineAmount;
totalDiscount += lineDiscountAmount;
var totalLineAmount = lineAmount - lineDiscountAmount;
totalAmount += totalLineAmount;
var lineTaxes = _financialService.ComputeOutputTax(salesInvoice.CustomerId, item.Id, lineItem.Quantity, lineItem.Amount, lineItem.Discount);
foreach (var t in lineTaxes)
{
taxes.Add(t);
}
var lineTaxAmount = lineTaxes != null && lineTaxes.Count > 0 ? lineTaxes.Sum(t => t.Value) : 0;
totalLineAmount = totalLineAmount - lineTaxAmount;
sales.Add(new KeyValuePair <int, decimal>(item.SalesAccountId.Value, totalLineAmount));
if (item.ItemCategory.ItemType == ItemTypes.Purchased)
{
lineItem.InventoryControlJournal = _inventoryService.CreateInventoryControlJournal(lineItem.ItemId,
lineItem.MeasurementId,
DocumentTypes.SalesInvoice,
null,
lineItem.Quantity,
lineItem.Quantity * item.Cost,
lineItem.Quantity * item.Price);
}
}
totalAmount += salesInvoice.ShippingHandlingCharge;
var groupedSalesAccount = from s in sales
group s by s.Key into grouped
select new
{
Key = grouped.Key,
Value = grouped.Sum(s => s.Value)
};
foreach (var salesAccount in groupedSalesAccount)
{
var salesAmount = salesAccount.Value;
}
if (taxes != null && taxes.Count > 0)
{
var groupedTaxes = from t in taxes
group t by t.Key into grouped
select new
{
Key = grouped.Key,
Value = grouped.Sum(t => t.Value)
};
//foreach (var tax in groupedTaxes)
//{
// var tx = _financialService.GetTaxes().Where(t => t.Id == tax.Key).FirstOrDefault();
//}
}
}
//public SalesInvoiceHeader GetSalesInvoiceByNo(string no)
//{
// var query = from invoice in _salesInvoiceRepo.Table
// where invoice.No == no
// select invoice;
// return query.FirstOrDefault();
//}
public SalesInvoiceHeader SaveSaleInvoice(SalesInvoiceHeader salesInvoice)
{
decimal totalAmount = 0, totalDiscount = 0;
var taxes = new List <KeyValuePair <int, decimal> >();
var sales = new List <KeyValuePair <int, decimal> >();
var glHeader = _financialService.CreateGeneralLedgerHeader(DocumentTypes.SalesInvoice, salesInvoice.Date, salesInvoice.Description);
var customer = _customerRepo.GetById(salesInvoice.CustomerId);
foreach (var lineItem in salesInvoice.SalesInvoiceLines)
{
var item = _inventoryService.GetItemDetailById(lineItem.ItemId);
var lineAmount = lineItem.Quantity * lineItem.Amount;
//var itemCatagory = _itemCatagoryRepo.GetById(lineItem.ItemId);
item.CostOfGoodsSoldAccountId = item.CostOfGoodsSoldAccountId;
item.InventoryAccountId = item.InventoryAccountId;
item.SalesAccountId = item.SalesAccountId;
item.InventoryAdjustmentAccountId = item.InventoryAdjustmentAccountId;
//item.ItemCategory=new ItemCategory { ItemType=itemCatagory.ItemType};
if (!item.GLAccountsValidated())
{
throw new Exception("Item is not correctly setup for financial transaction. Please check if GL accounts are all set.");
}
lineItem.DiscountAmount = (lineItem.Discount / 100) * lineAmount;
totalDiscount += lineItem.DiscountAmount;
var totalLineAmount = lineAmount - lineItem.DiscountAmount;
totalAmount += totalLineAmount;
//TODO: Sarfraz has to build Taxes list
var itemTaxesToAdd = lineItem.Taxes.Select(t => new Tax()
{
Id = t.TaxId, Rate = t.Rate
}).ToList();
var lineTaxes = _financialService.ComputeOutputTax(item.Id, lineItem.Quantity, lineItem.Amount, lineItem.Discount, itemTaxesToAdd);
foreach (var t in lineTaxes)
{
taxes.Add(t);
}
//lineItem.TaxAmount = lineTaxes != null && lineTaxes.Count > 0 ? lineTaxes.Sum(t => t.Value) : 0;
//totalLineAmount = totalLineAmount - lineItem.TaxAmount;
sales.Add(new KeyValuePair <int, decimal>(item.SalesAccountId.Value, totalLineAmount));
if (item.ItemCategory.ItemType == ItemTypes.Purchased)
{
lineItem.InventoryControlJournal = _inventoryService.CreateInventoryControlJournal(lineItem.ItemId,
lineItem.MeasurementId,
DocumentTypes.SalesInvoice,
null,
lineItem.Quantity,
lineItem.Quantity * item.Cost,
lineItem.Quantity * item.Price);
}
}
decimal totalTax = 0;
foreach (var tax in taxes)
{
totalTax += tax.Value;
}
totalAmount += salesInvoice.ShippingHandlingCharge + totalTax;
var debitCustomerAR = _financialService.CreateGeneralLedgerLine(DrOrCrSide.Dr, customer.AccountsReceivableAccount.Id, Math.Round(totalAmount, 2, MidpointRounding.ToEven));
glHeader.GeneralLedgerLines.Add(debitCustomerAR);
var groupedSalesAccount = from s in sales
group s by s.Key into grouped
select new
{
Key = grouped.Key,
Value = grouped.Sum(s => s.Value)
};
foreach (var salesAccount in groupedSalesAccount)
{
var salesAmount = salesAccount.Value;
var creditSalesAccount = _financialService.CreateGeneralLedgerLine(DrOrCrSide.Cr, salesAccount.Key, Math.Round(salesAmount, 2, MidpointRounding.ToEven));
glHeader.GeneralLedgerLines.Add(creditSalesAccount);
}
if (taxes != null && taxes.Count > 0)
{
var groupedTaxes = from t in taxes
group t by t.Key into grouped
select new
{
Key = grouped.Key,
Value = grouped.Sum(t => t.Value)
};
foreach (var tax in groupedTaxes)
{
var tx = _financialService.GetTaxes().Where(t => t.Id == tax.Key).FirstOrDefault();
var creditSalesTaxAccount = _financialService.CreateGeneralLedgerLine(DrOrCrSide.Cr, tx.SalesAccountId.Value, Math.Round(tax.Value, 2, MidpointRounding.ToEven));
glHeader.GeneralLedgerLines.Add(creditSalesTaxAccount);
}
}
if (totalDiscount > 0)
{
var salesDiscountAccount = base.GetGeneralLedgerSetting().SalesDiscountAccount;
var creditSalesDiscountAccount = _financialService.CreateGeneralLedgerLine(DrOrCrSide.Dr, salesDiscountAccount.Id, Math.Round(totalDiscount, 2, MidpointRounding.ToEven));
glHeader.GeneralLedgerLines.Add(creditSalesDiscountAccount);
}
if (salesInvoice.ShippingHandlingCharge > 0)
{
var shippingHandlingAccount = base.GetGeneralLedgerSetting().ShippingChargeAccount;
var creditShippingHandlingAccount = _financialService.CreateGeneralLedgerLine(DrOrCrSide.Cr, shippingHandlingAccount.Id, Math.Round(salesInvoice.ShippingHandlingCharge, 2, MidpointRounding.ToEven));
glHeader.GeneralLedgerLines.Add(creditShippingHandlingAccount);
}
if (_financialService.ValidateGeneralLedgerEntry(glHeader))
{
salesInvoice.GeneralLedgerHeader = glHeader;
var dbObject = _salesInvoiceRepo.Table
.Include(p => p.GeneralLedgerHeader)
.ThenInclude(p => p.GeneralLedgerLines)
.Include(p => p.SalesInvoiceLines)
.ThenInclude(p2 => p2.InventoryControlJournal)
.Where(o => o.Id == salesInvoice.Id).FirstOrDefault();
#region UPDATE
if (dbObject != null)
{
dbObject.No = salesInvoice.No;
dbObject.Description = salesInvoice.Description;
dbObject.Date = salesInvoice.Date;
dbObject.CustomerId = salesInvoice.CustomerId;
dbObject.ShippingHandlingCharge = salesInvoice.ShippingHandlingCharge;
dbObject.IsActive = salesInvoice.IsActive;
dbObject.GeneralLedgerHeader.Date = salesInvoice.Date;
dbObject.GeneralLedgerHeader.Description = salesInvoice.Description;
var GLLinesToUpdateIds = dbObject.GeneralLedgerHeader.GeneralLedgerLines.Select(c => c.Id).ToList();
foreach (var generalLedgerLine in salesInvoice.GeneralLedgerHeader.GeneralLedgerLines)
{
var existinggeneralLedgerLine = dbObject.GeneralLedgerHeader.GeneralLedgerLines.FirstOrDefault(c => c.AccountId == generalLedgerLine.AccountId);
if (existinggeneralLedgerLine != null)
{
existinggeneralLedgerLine.AccountId = generalLedgerLine.AccountId;
existinggeneralLedgerLine.Amount = generalLedgerLine.Amount;
existinggeneralLedgerLine.DrCr = generalLedgerLine.DrCr;
existinggeneralLedgerLine.IsActive = generalLedgerLine.IsActive;
GLLinesToUpdateIds.Remove(existinggeneralLedgerLine.Id);
}
else
{
dbObject.GeneralLedgerHeader.GeneralLedgerLines.Add(new GeneralLedgerLine()
{
DrCr = generalLedgerLine.DrCr,
AccountId = generalLedgerLine.AccountId,
Amount = generalLedgerLine.Amount
});
}
}
foreach (var generalLedgerLine in dbObject.GeneralLedgerHeader.GeneralLedgerLines.Where(c => GLLinesToUpdateIds.Contains(c.Id)))
{
generalLedgerLine.Deleted = true;
}
var salesInvoiceLinesToUpdateIds = dbObject.SalesInvoiceLines.Select(c => c.Id).ToList();
foreach (var salesInvoiceLine in salesInvoice.SalesInvoiceLines)
{
var existingSalesInvoiceLine = dbObject.SalesInvoiceLines.FirstOrDefault(c => c.Id == salesInvoiceLine.Id);
if (existingSalesInvoiceLine != null)
{
existingSalesInvoiceLine.ItemId = salesInvoiceLine.ItemId;
existingSalesInvoiceLine.MeasurementId = salesInvoiceLine.MeasurementId;
// existingSalesInvoiceLine.TaxId = salesInvoiceLine.TaxId;
existingSalesInvoiceLine.Quantity = salesInvoiceLine.Quantity;
existingSalesInvoiceLine.Discount = salesInvoiceLine.Discount;
existingSalesInvoiceLine.Amount = salesInvoiceLine.Amount;
//existingSalesInvoiceLine.TaxAmount = salesInvoiceLine.TaxAmount;
existingSalesInvoiceLine.DiscountAmount = salesInvoiceLine.DiscountAmount;
existingSalesInvoiceLine.IsActive = salesInvoiceLine.IsActive;
if (salesInvoiceLine.InventoryControlJournal != null)
{
if (existingSalesInvoiceLine.InventoryControlJournal != null)
{
existingSalesInvoiceLine.InventoryControlJournal.MeasurementId = salesInvoiceLine.InventoryControlJournal.MeasurementId;
existingSalesInvoiceLine.InventoryControlJournal.OUTQty = salesInvoiceLine.InventoryControlJournal.OUTQty;
existingSalesInvoiceLine.InventoryControlJournal.TotalCost = salesInvoiceLine.InventoryControlJournal.TotalCost;
existingSalesInvoiceLine.InventoryControlJournal.TotalAmount = salesInvoiceLine.InventoryControlJournal.TotalAmount;
}
else
{
existingSalesInvoiceLine.InventoryControlJournal = salesInvoiceLine.InventoryControlJournal;
}
}
else
{
if (existingSalesInvoiceLine.InventoryControlJournal != null)
{
existingSalesInvoiceLine.InventoryControlJournal.Deleted = true;
existingSalesInvoiceLine.InventoryControlJournalId = -1;
}
}
salesInvoiceLinesToUpdateIds.Remove(existingSalesInvoiceLine.Id);
}
else
{
dbObject.SalesInvoiceLines.Add(salesInvoiceLine);
}
//TODO: Apply Line Tax update
}
foreach (var salesInvoiceLine in dbObject.SalesInvoiceLines.Where(c => salesInvoiceLinesToUpdateIds.Contains(c.Id)))
{
salesInvoiceLine.Deleted = true;
}
salesInvoice = dbObject;
_salesInvoiceRepo.Update(salesInvoice);
}
#endregion
#region INSERT
else
{
salesInvoice.No = GetNextNumber(SequenceNumberTypes.SalesInvoice).ToString();
_salesInvoiceRepo.Insert(salesInvoice);
}
#endregion
}
return(salesInvoice);
}
