public void Close(BackgroundWorker worker)
{
using (var context = new ERPContext())
{
var items = context.Inventory.ToList();
var index = 1;
foreach (var item in items)
{
foreach (var warehouse in _warehouses)
{
var beginningBalance = GetBeginningBalance(context, warehouse, item);
var endingBalance = GetEndingBalance(context, warehouse, item, beginningBalance);
SetEndingBalance(context, warehouse, item, endingBalance);
}
var status = index++ * (items.Count / 100) - 1;
if (status < 0) status = 0;
worker.ReportProgress(status);
}
context.SaveChanges();
}
MessageBox.Show("Successfully closed stock!", "Succecss", MessageBoxButton.OK);
}
public void RefreshDisplayLines()
{
DisplayedTransactionLines.Clear();
using (var context = new ERPContext())
{
SetBeginningBalanceFromDatabaseContext(context);
var balanceTracker = _selectedBeginningBalance;
var transactionLines = context.Ledger_Transaction_Lines
.Where(e => e.LedgerAccountID == _selectedAccount.ID && e.LedgerTransaction.Date.Month == _selectedMonth)
.Include("LedgerTransaction")
.Include("LedgerAccount")
.OrderBy(e => e.LedgerTransaction.Date);
if (_selectedClass == "Asset" || _selectedClass == "Expense") _normalSeq = "Debit";
else _normalSeq = "Credit";
foreach (var opposingLine in transactionLines.ToList().Select(
line => new LedgerTransactionLineVM { Model = line }).SelectMany(lineVM => lineVM.OpposingLines))
{
opposingLine.Seq = opposingLine.Seq == "Debit" ? "Credit" : "Debit";
if (_normalSeq == opposingLine.Seq) balanceTracker += opposingLine.Amount;
else balanceTracker -= opposingLine.Amount;
if (opposingLine.Seq == "Debit") _totalDebit += opposingLine.Amount;
else _totalCredit += opposingLine.Amount;
opposingLine.Balance = balanceTracker;
DisplayedTransactionLines.Add(opposingLine);
}
_selectedEndingBalance = balanceTracker;
}
}
public void UpdateItems()
{
var oldSelectedItem = _selectedItem;
using (var context = new ERPContext())
{
Items.Clear();
var allItem = new Item {
ID = "-1", Name = "All"
};
Items.Add(new ItemVM {
Model = allItem
});
var itemsFromDatabase = _selectedCategory.Name.Equals("All")
? context.Inventory
.Include("Suppliers")
.Include("ItemCategory")
.OrderBy(item => item.Name)
: context.Inventory
.Include("Suppliers")
.Include("ItemCategory")
.Where(
item => item.ItemCategory.ID.Equals(_selectedCategory.ID))
.OrderBy(item => item.Name);
foreach (var item in itemsFromDatabase)
{
Items.Add(new ItemVM {
Model = item, SelectedSupplier = item.Suppliers.FirstOrDefault()
});
}
}
UpdateSelectedItem(oldSelectedItem);
}
private void UpdateDisplayedLines()
{
DisplayedLines.Clear();
using (var context = new ERPContext())
{
if (_selectedWarehouse.Name.Equals("All") && _selectedItem.Name.Equals("All"))
{
DisplayAllItems(context);
}
else if (_selectedWarehouse.Name.Equals("All") && !_selectedItem.Name.Equals("All"))
{
DisplaySelectedItemFromAllWarehouses(context);
}
else if (!_selectedWarehouse.Name.Equals("All") && _selectedItem.Name.Equals("All"))
{
DisplayListedItemsFromSelectedWarehouse(context);
}
else
{
DisplaySelectedItemFromSelectedWarehouse(context);
}
}
UpdateUITotal();
}
public static void AddSalesReturnTransactionToDatabase(SalesReturnTransaction salesReturnTransaction)
{
IsLastSaveSuccessful = false;
using (var ts = new TransactionScope())
{
var context = new ERPContext();
AttachSalesReturnTransactionPropertiesToDatabaseContext(context, ref salesReturnTransaction);
var lines = salesReturnTransaction.SalesReturnTransactionLines.ToList();
salesReturnTransaction.SalesReturnTransactionLines.Clear();
foreach (var salesReturnTransactionLine in lines)
{
salesReturnTransactionLine.SalesReturnTransaction = salesReturnTransaction;
AddSalesReturnTransactionLineToDatabaseContext(context, salesReturnTransactionLine);
DecreaseSalesReturnTransactionLineItemSoldOrReturnedInDatabaseContext(context,
salesReturnTransactionLine);
InceaseSalesReturnTransactionLineItemStockInDatabaseContext(context, salesReturnTransactionLine);
context.SaveChanges();
}
AddSalesReturnTransactionLedgerTransactionsToDatabaseContext(context, salesReturnTransaction);
// Deduct member's points
ts.Complete();
}
IsLastSaveSuccessful = true;
}
private static void IncreaseSoldOrReturned(ERPContext context, Item item, int quantity)
{
var purchases = context.PurchaseTransactionLines
.Include("PurchaseTransaction")
.Where(e => e.ItemID.Equals(item.ID) && e.SoldOrReturned < e.Quantity)
.OrderBy(purchaseTransactionLine => purchaseTransactionLine.PurchaseTransactionID)
.ThenByDescending(purchaseTransactionLine => purchaseTransactionLine.Quantity - purchaseTransactionLine.SoldOrReturned)
.ThenByDescending(purchaseTransactionLine => purchaseTransactionLine.PurchasePrice)
.ThenByDescending(purchaseTransactionLine => purchaseTransactionLine.Discount)
.ThenByDescending(purchaseTransactionLine => purchaseTransactionLine.WarehouseID)
.ToList();
var tracker = quantity;
foreach (var purchase in purchases)
{
var availableQuantity = purchase.Quantity - purchase.SoldOrReturned;
if (tracker <= availableQuantity)
{
purchase.SoldOrReturned += tracker;
break;
}
if (tracker > availableQuantity)
{
purchase.SoldOrReturned += availableQuantity;
tracker -= availableQuantity;
}
}
}
private int GetBeginningBalance(ERPContext context, Warehouse warehouse, Item item)
{
var periodYearBalances = context.StockBalances.FirstOrDefault(e => e.ItemID.Equals(item.ID) && e.WarehouseID.Equals(warehouse.ID) && e.Year == _periodYear);
if (periodYearBalances == null) return 0;
switch (_period)
{
case 1:
return periodYearBalances.BeginningBalance;
case 2:
return periodYearBalances.Balance1;
case 3:
return periodYearBalances.Balance2;
case 4:
return periodYearBalances.Balance3;
case 5:
return periodYearBalances.Balance4;
case 6:
return periodYearBalances.Balance5;
case 7:
return periodYearBalances.Balance6;
case 8:
return periodYearBalances.Balance7;
case 9:
return periodYearBalances.Balance8;
case 10:
return periodYearBalances.Balance9;
case 11:
return periodYearBalances.Balance10;
default:
return periodYearBalances.Balance11;
}
}
public void RefreshListings(ERPContext context)
{
foreach (string acocuntName in sellerIdDictionary.Keys)
{
RefreshListings(context, acocuntName);
}
}
public static void AddSalesReturnTransactionToDatabase(SalesReturnTransaction salesReturnTransaction)
{
IsLastSaveSuccessful = false;
using (var ts = new TransactionScope())
{
var context = new ERPContext();
AttachSalesReturnTransactionPropertiesToDatabaseContext(context, ref salesReturnTransaction);
var lines = salesReturnTransaction.SalesReturnTransactionLines.ToList();
salesReturnTransaction.SalesReturnTransactionLines.Clear();
foreach (var salesReturnTransactionLine in lines)
{
salesReturnTransactionLine.SalesReturnTransaction = salesReturnTransaction;
AddSalesReturnTransactionLineToDatabaseContext(context, salesReturnTransactionLine);
DecreaseSalesReturnTransactionLineItemSoldOrReturnedInDatabaseContext(context,
salesReturnTransactionLine);
InceaseSalesReturnTransactionLineItemStockInDatabaseContext(context, salesReturnTransactionLine);
context.SaveChanges();
}
AddSalesReturnTransactionLedgerTransactionsToDatabaseContext(context, salesReturnTransaction);
// Deduct member's points
ts.Complete();
}
IsLastSaveSuccessful = true;
}
public AmazonService(PlatformServiceFactory platformServiceFactory, string company, string connectionString)
{
m_platformServiceFactory = platformServiceFactory;
m_company = company;
m_connectionString = connectionString;
using (ERPContext context = new ERPContext(m_connectionString))
{
var q = from amazonAccount in context.AmazonAccount
select amazonAccount;
foreach (var row in q)
{
sellerIdDictionary[row.AccountName] = row.SellerId;
mwsAuthTokenDictionary[row.AccountName] = row.MWSAuthToken;
}
}
MarketplaceWebServiceOrdersConfig config = new MarketplaceWebServiceOrdersConfig();
config.ServiceURL = serviceURL;
client = new MarketplaceWebServiceOrdersClient(accessKey, secretKey, appName, appVersion, config);
MarketplaceWebServiceConfig mwsConfig = new MarketplaceWebServiceConfig();
mwsConfig.ServiceURL = serviceURL;
mwsClient = new MarketplaceWebServiceClient(accessKey, secretKey, appName, appVersion, mwsConfig);
}
public IActionResult Edit(OrderRequest oModel)
{
Respuesta oRespuesta = new Respuesta();
try
{
using (ERPContext db = new ERPContext())
{
Order oOrder = db.Orders.Find(oModel.Id);
oOrder.Status = oModel.Status;
oOrder.Priority = oModel.Priority;
oOrder.Client = oModel.Client;
oOrder.Employee = oModel.Employee;
oOrder.DateOfCreation = oModel.DateOfCreation;
oOrder.DateOfAssignment = oModel.DateOfAssignment;
oOrder.DateOfCompletion = oModel.DateOfCompletion;
oOrder.Address = oModel.Address;
oOrder.Price = oModel.Price;
db.Entry(oOrder).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
db.SaveChanges();
oRespuesta.Exito = 1;
}
}
catch (Exception ex)
{
oRespuesta.Mensaje = ex.Message;
}
return(Ok(oRespuesta));
}
public IActionResult Add(OrderRequest oModel)
{
Respuesta oRespuesta = new Respuesta();
try
{
using (ERPContext db = new ERPContext())
{
Order oOrder = new Order();
oOrder.Status = oModel.Status;
oOrder.Priority = oModel.Priority;
oOrder.Client = oModel.Client;
oOrder.Employee = oModel.Employee;
oOrder.DateOfCreation = oModel.DateOfCreation;
oOrder.DateOfAssignment = oModel.DateOfAssignment;
oOrder.DateOfCompletion = oModel.DateOfCompletion;
oOrder.Address = oModel.Address;
oOrder.Price = oModel.Price;
db.Orders.Add(oOrder);
db.SaveChanges();
oRespuesta.Exito = 1;
}
}
catch (Exception ex)
{
oRespuesta.Mensaje = ex.Message;
}
return(Ok(oRespuesta));
}
public IEnumerable <CompanyViewModel> getCompanies()
{
using (ERPContext context = new ERPContext())
{
var companiesList = context.Company.AsNoTracking().Include(x => x.Cities).ToList();
if (companiesList != null)
{
List <CompanyViewModel> _companiesViewModelList = new List <CompanyViewModel>();
foreach (var item in companiesList)
{
CompanyViewModel model = new CompanyViewModel();
model.CompanyID = item.CompanyId;
model.CompanyName = item.CompanyName;
model.CityID = item.CityId;
model.CityName = item.Cities.CityName;
model.Address = item.Address;
model.PhoneNo = item.Phone;
model.WebsiteUrl = item.WebsiteURL;
_companiesViewModelList.Add(model);
}
return(_companiesViewModelList);
}
}
return(null);
}
private static void AddPurchaseReturnTransactionLineToDatabaseContext(ERPContext context, PurchaseReturnTransactionLine purchaseReturnTransactionLine)
{
purchaseReturnTransactionLine.Item = context.Inventory.Single(item => item.ID.Equals(purchaseReturnTransactionLine.Item.ID));
purchaseReturnTransactionLine.Warehouse = context.Warehouses.Single(warehouse => warehouse.ID.Equals(purchaseReturnTransactionLine.Warehouse.ID));
purchaseReturnTransactionLine.ReturnWarehouse = context.Warehouses.Single(warehouse => warehouse.ID.Equals(purchaseReturnTransactionLine.ReturnWarehouse.ID));
context.PurchaseReturnTransactionLines.Add(purchaseReturnTransactionLine);
}
private void DeleteIdentityInternal(Guid Id)
{
var context = new ERPContext();
EntityBase.ERPContext.Identity.Remove(context.Identity.Where(i => i.Id == Id).First());
context.SaveChanges();
}
public static void AddPurchaseReturnTransactionToDatabase(PurchaseReturnTransaction purchaseReturnTransaction)
{
IsLastSaveSuccessful = false;
using (var ts = new TransactionScope())
{
var context = new ERPContext();
AttachPurchaseReturnTransactionPropertiesToDatabaseContext(context, ref purchaseReturnTransaction);
purchaseReturnTransaction.PurchaseTransaction.Supplier.PurchaseReturnCredits +=
purchaseReturnTransaction.NetTotal;
decimal totalCOGS = 0;
var lines = purchaseReturnTransaction.PurchaseReturnTransactionLines.ToList();
purchaseReturnTransaction.PurchaseReturnTransactionLines.Clear();
foreach (var purchaseReturnTransactionLine in lines)
{
if (!IsThereEnoughLineItemStockInDatabaseContext(context, purchaseReturnTransactionLine)) return;
purchaseReturnTransactionLine.PurchaseReturnTransaction = purchaseReturnTransaction;
AddPurchaseReturnTransactionLineToDatabaseContext(context, purchaseReturnTransactionLine);
DecreasePurchaseReturnTransactionLineItemStockInDatabaseContext(context, purchaseReturnTransactionLine);
totalCOGS += CalculateLineCOGSFromDatabaseContext(context, purchaseReturnTransactionLine);
IncreasePurchaseReturnTransactionLineItemSoldOrReturnedInDatabaseContext(context, purchaseReturnTransactionLine);
context.SaveChanges();
}
AddPurchaseReturnTransactionLedgerTransactionToDatabaseContext(context, purchaseReturnTransaction, totalCOGS);
ts.Complete();
}
IsLastSaveSuccessful = true;
}
private void UpdateSuppliers()
{
var oldSelectedSupplier = _selectedSupplier;
Suppliers.Clear();
Suppliers.Add(new SupplierVM {
Model = new Supplier {
ID = -1, Name = "All"
}
});
using (var context = new ERPContext())
{
var suppliersFromDatabase = context.Suppliers.Where(supplier => !supplier.Name.Equals("-")).OrderBy(supplier => supplier.Name);
foreach (
var supplier in
suppliersFromDatabase.Where(supplier => supplier.IsActive.Equals(_isSupplierActiveChecked)))
{
Suppliers.Add(new SupplierVM {
Model = supplier
});
}
}
UpdateSelectedSupplier(oldSelectedSupplier);
}
private void DisplaySalesTransaction()
{
using (var context = new ERPContext())
{
var salesTransactionFromDatabase =
context.SalesTransactions
.Include("SalesTransactionLines")
.Include("SalesTransactionLines.Item")
.Include("SalesTransactionLines.Warehouse")
.SingleOrDefault(
transaction => transaction.SalesTransactionID.Equals(_salesTransactionID));
if (salesTransactionFromDatabase == null)
{
MessageBox.Show("Sales transaction could not be found.", "Invalid ID", MessageBoxButton.OK);
return;
}
foreach (var line in salesTransactionFromDatabase.SalesTransactionLines)
SalesTransactionLines.Add(new SalesTransactionLineVM {Model = line});
SalesTransactionDate = salesTransactionFromDatabase.Date;
SalesTransactionGrossTotal = salesTransactionFromDatabase.GrossTotal;
SalesTransactionDiscount = salesTransactionFromDatabase.Discount;
SalesTransactionNetTotal = salesTransactionFromDatabase.Total;
}
}
private async Task SetUpData(UserSession userSession, ERPContext dbContext)
{
dbContext.News.Add(new Models.News()
{
ID = Guid.NewGuid(), OrganizationID = userSession.OrganizationID, Title = "Unit Test", NrIntern = "Unit Test"
});
dbContext.News.Add(new Models.News()
{
ID = Guid.NewGuid(), OrganizationID = userSession.OrganizationID, Title = "Unit Test", NrIntern = "Unit Test"
});
dbContext.News.Add(new Models.News()
{
ID = Guid.NewGuid(), OrganizationID = userSession.OrganizationID, Title = "Unit Test", NrIntern = "Unit Test"
});
dbContext.News.Add(new Models.News()
{
ID = Guid.NewGuid(), OrganizationID = Guid.NewGuid(), Title = "Unit Test", NrIntern = "Unit Test"
});
dbContext.News.Add(new Models.News()
{
ID = Guid.NewGuid(), OrganizationID = Guid.NewGuid(), Title = "Unit Test", NrIntern = "Unit Test"
});
await dbContext.SaveChangesAsync();
}
private async Task SetUpData(UserSession userSession, ERPContext dbContext)
{
dbContext.Orders.Add(new Models.Order()
{
ID = Guid.NewGuid(), OrganizationID = userSession.OrganizationID, Title = "Unit Test", NrIntern = "Unit Test", DeliveryDate = DateTime.Now, SupplierID = Guid.NewGuid()
});
dbContext.Orders.Add(new Models.Order()
{
ID = Guid.NewGuid(), OrganizationID = userSession.OrganizationID, Title = "Unit Test", NrIntern = "Unit Test", DeliveryDate = DateTime.Now, SupplierID = Guid.NewGuid()
});
dbContext.Orders.Add(new Models.Order()
{
ID = Guid.NewGuid(), OrganizationID = userSession.OrganizationID, Title = "Unit Test", NrIntern = "Unit Test", DeliveryDate = DateTime.Now, SupplierID = Guid.NewGuid()
});
dbContext.Orders.Add(new Models.Order()
{
ID = Guid.NewGuid(), OrganizationID = userSession.OrganizationID, Title = "Unit Test", NrIntern = "Unit Test", DeliveryDate = DateTime.Now, SupplierID = Guid.NewGuid()
});
dbContext.Orders.Add(new Models.Order()
{
ID = Guid.NewGuid(), OrganizationID = Guid.NewGuid(), Title = "Unit Test", NrIntern = "Unit Test", DeliveryDate = DateTime.Now, SupplierID = Guid.NewGuid()
});
await dbContext.SaveChangesAsync();
}
private static void DecreaseSalesReturnTransactionLineItemSoldOrReturnedInDatabaseContext(ERPContext context,
SalesReturnTransactionLine salesReturnTransactionLine)
{
var purchases = context.PurchaseTransactionLines
.Where(e => e.ItemID.Equals(salesReturnTransactionLine.Item.ID) && e.SoldOrReturned > 0)
.OrderByDescending(transaction => transaction.PurchaseTransactionID)
.ThenByDescending(transaction => transaction.Quantity - transaction.SoldOrReturned)
.ThenByDescending(transaction => transaction.PurchasePrice)
.ThenByDescending(transaction => transaction.Discount)
.ThenByDescending(transaction => transaction.WarehouseID);
var tracker = salesReturnTransactionLine.Quantity;
foreach (var purchase in purchases)
{
if (purchase.SoldOrReturned >= tracker)
{
purchase.SoldOrReturned -= tracker;
break;
}
if (purchase.SoldOrReturned < tracker)
{
tracker -= purchase.SoldOrReturned;
purchase.SoldOrReturned = 0;
}
}
context.SaveChanges();
}
public IHttpActionResult ExportExcel(int Id)
{
_db = new ERPContext();
var emp = _db.Employees;
var dailydetails = _db.DailyFileDetailses.Where(x => x.DailyFile.DailyId == Id)
.GroupBy(p => p.EmployeeId)
.Select(g => new DailyDetailsInfoVM
{
Id = g.Key,
Name = emp.FirstOrDefault(x => x.Id == g.Key).Name,
Code = emp.FirstOrDefault(x => x.Id == g.Key).Code,
Net = g.Sum(i => i.Net)
}).ToList();
try
{
string filePath = HttpContext.Current.Server.MapPath("~/Uploads/SourceFile/output.xls");
if (!IsFileLocked(new FileInfo(filePath)) &&
!IsFileLocked(new FileInfo(HttpContext.Current.Server.MapPath("~/Uploads/SourceFile/output2.xls").ToString())))
{
File.Copy(filePath,
HttpContext.Current.Server.MapPath("~/Uploads/SourceFile/output2.xls").ToString(), true);
}
else
{
return(Ok(new { errorMsg = "الملف مفتوح من قبل برنامج اخر" }));
}
filePath = HttpContext.Current.Server.MapPath("~/Uploads/SourceFile/output2.xls");
string filePath2 = HttpContext.Current.Server.MapPath("~/Uploads/SourceFile/ATM.xls");
BL bl = new BL(@"Provider = Microsoft.ACE.OLEDB.12.0; Data Source = " + filePath2 + "; Extended Properties = Excel 12.0");
DataTable dt = new DataTable();
dt = bl.GetTable("select * from [Sheet1$]");
dt.PrimaryKey = new DataColumn[] { dt.Columns[4] };
BL b2 =
new BL(@"Provider = Microsoft.ACE.OLEDB.12.0; Data Source = " + filePath +
"; Extended Properties = Excel 12.0");
DataTable dt2 = new DataTable();
foreach (var row in dailydetails)
{
// if(row.Code.ToString()== oSheet.Rows.Find(row.Code))
var found = dt.Rows.Find(row.Code).ItemArray;
b2.Insert(string.Format("insert into [Sheet1$] values('{0}','{1}','{2}','{3}','{4}','{5}',{6})",
found[0], found[1], found[2], found[3], found[4], found[5], row.Net));
}
return(Ok(new { result = filePath }));
}
catch (Exception ex)
{
return(Ok(new { errorMsg = ex.Message }));
}
}
private void UpdateCategoryItems()
{
var oldSelectedCategoryItem = _selectedCategoryItem;
CategoryItems.Clear();
var allCategoryItem = new Item {
ID = "-1", Name = "All"
};
CategoryItems.Add(new ItemVM {
Model = allCategoryItem
});
using (var context = new ERPContext())
{
var categoryItemsFromDatabase = _selectedCategory.Name.Equals("All")
? context.Inventory.Include("Suppliers").OrderBy(item => item.Name)
: context.Inventory.Include("Suppliers")
.Where(item => item.ItemCategory.ID.Equals(_selectedCategory.ID))
.OrderBy(item => item.Name);
foreach (var item in categoryItemsFromDatabase)
{
CategoryItems.Add(new ItemVM {
Model = item
});
}
}
UpdateSelectedCategoryItem(oldSelectedCategoryItem);
}
private static void SaveSupplierEditsToDatabaseContext(ERPContext context, Supplier editingSupplier,
Supplier editedSupplier)
{
context.Entry(editingSupplier).State = EntityState.Modified;
DeepCopySupplierProperties(editedSupplier, editingSupplier);
context.SaveChanges();
}
private static void AttachPurchaseReturnTransactionPropertiesToDatabaseContext(ERPContext context, ref PurchaseReturnTransaction purchaseReturnTransaction)
{
//var user = Application.Current.FindResource("CurrentUser") as User;
//purchaseReturnTransaction.User = context.Users.FirstOrDefault(e => e.Username.Equals(user.Username));
context.PurchaseTransactions.Attach(purchaseReturnTransaction.PurchaseTransaction);
context.Suppliers.Attach(purchaseReturnTransaction.PurchaseTransaction.Supplier);
}
private string isExistBarCode(string barcodes)
{
var result = "";
if (!string.IsNullOrWhiteSpace(barcodes))
{
var barcodeCollection = barcodes.Split(';');
barcodeCollection = barcodeCollection.Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();
foreach (var code in barcodeCollection)
{
try
{
using (var ctx = new ERPContext())
{
var str = string.Format("SELECT Barcode FROM DM_VATTU WHERE Barcode LIKE '%;{0};%'", code);
var data = ctx.Database.SqlQuery <string>(str);
if (data.Count() > 0)
{
result = string.Format("{0};{1}", result, code);
}
}
}
catch (Exception e)
{
throw e;
}
}
}
return(result);
}
private void UpdateWarehouses()
{
var oldSelectedWarehouse = _selectedWarehouse;
Warehouses.Clear();
var allWarehouse = new Warehouse {
ID = -1, Name = "All"
};
Warehouses.Add(new WarehouseVM {
Model = allWarehouse
});
using (var context = new ERPContext())
{
var warehousesFromDatabase = context.Warehouses.OrderBy(warehouse => warehouse.Name);
foreach (var warehouse in warehousesFromDatabase)
{
Warehouses.Add(new WarehouseVM {
Model = warehouse
});
}
}
UpdateSelectedWarehouse(oldSelectedWarehouse);
}
private static void AddStockAdjustmentTransactionToDatabaseContext(ERPContext context, StockAdjustmentTransaction stockAdjustmentTransaction)
{
var user = Application.Current.FindResource("CurrentUser") as User;
stockAdjustmentTransaction.User = context.Users.Single(e => e.Username.Equals(user.Username));
context.StockAdjustmentTransactions.Add(stockAdjustmentTransaction);
}
private static void AddPurchaseReturnTransactionLineToDatabaseContext(ERPContext context, PurchaseReturnTransactionLine purchaseReturnTransactionLine)
{
purchaseReturnTransactionLine.Item = context.Inventory.Single(item => item.ID.Equals(purchaseReturnTransactionLine.Item.ID));
purchaseReturnTransactionLine.Warehouse = context.Warehouses.Single(warehouse => warehouse.ID.Equals(purchaseReturnTransactionLine.Warehouse.ID));
purchaseReturnTransactionLine.ReturnWarehouse = context.Warehouses.Single(warehouse => warehouse.ID.Equals(purchaseReturnTransactionLine.ReturnWarehouse.ID));
context.PurchaseReturnTransactionLines.Add(purchaseReturnTransactionLine);
}
public void UpdateSuppliers()
{
var oldSelectedSupplier = _selectedSupplier;
Suppliers.Clear();
var allSupplier = new Supplier {
ID = -1, Name = "All"
};
Suppliers.Add(new SupplierVM {
Model = allSupplier
});
using (var context = new ERPContext())
{
var suppliersFromDatabase = context.Suppliers.Where(supplier => !supplier.Name.Equals("-")).OrderBy(supplier => supplier.Name);
foreach (var supplier in suppliersFromDatabase)
{
Suppliers.Add(new SupplierVM {
Model = supplier
});
}
}
UpdateSelectedSupplier(oldSelectedSupplier);
}
public IHttpActionResult GetParent(int Id)
{
_db = new ERPContext();
_db.Configuration.ProxyCreationEnabled = false;
var result = _db.Dailies
.Include("ExpensessType")
.Include("DailyFiles")
.FirstOrDefault(x => x.Id == Id);
List <DailyFile> resultfiles = _db.DailyFiles
.Where(x => x.DailyId == Id).ToList();
decimal totalamount = 0;
//foreach (DailyFile data in resultfiles)
//{
// totalamount = data.DailyFileDetailses.Where(x => x.DailyFileId == data.Id).Sum(x => x.Net);
//}
return(Ok(new
{
result = result,
totalamount = totalamount
}));
}
/// <summary>
/// Return a list of companies where the credit limit of the given customer is exceeded orelse has been blocked.
/// </summary>
/// <param name="strCustomer">Customer to be analised</param>
/// <returns>List<String></String></returns>
internal static List <String> CreditLimitExceeded(ERPContext ERPContext, String strCustomer)
{
List <String> companiesList = new List <String>();
Dictionary <String, String> groupCompanies = CrossCompany.Platform.GetGroupCompanies(ERPContext);
foreach (string company in groupCompanies.Keys)
{
ErpBS currentCompany = new ErpBS();
currentCompany.AbreEmpresaTrabalho(
StdBETipos.EnumTipoPlataforma.tpEmpresarial,
company,
Properties.Settings.Default.User, //ERPContext.BSO.Contexto.ObjUtilizador.Codigo,
Properties.Settings.Default.Password //ERPContext.BSO.Contexto.ObjUtilizador.Password
);
if ((currentCompany.Base.Clientes.DaValorAtributo(strCustomer, "TipoCred") == "2") ||
(currentCompany.Base.Clientes.DaValorAtributo(strCustomer, "limitecred") < currentCompany.Base.Clientes.DaValorAtributo(strCustomer, "totaldeb")))
{
companiesList.Add(company);
}
currentCompany.FechaEmpresaTrabalho();
}
return(companiesList);
}
public IHttpActionResult Delete(int Id)
{
_db = new ERPContext();
var daily = _db.Dailies.Find(Id);
if (daily != null)
{
_db.Dailies.Remove(daily);
_db.SaveChanges();
var filePath =
HttpContext.Current.Server.MapPath("~/Uploads/DailyFiles/Daily-" + Id);
if (Directory.Exists(filePath))
{
try
{
Directory.Delete(filePath, true);
}
catch (IOException)
{
Thread.Sleep(0);
Directory.Delete(filePath, true);
}
}
return(Ok(new { msg = "success" }));
}
return(BadRequest("Wrong Request"));
}
private void SetPurchaseReturnTransactionID()
{
var year = _purchaseReturnTransactionDate.Year;
var month = _purchaseReturnTransactionDate.Month;
var newEntryID = "PR" + (long)((year - 2000) * 100 + month) * 1000000;
string lastEntryID = null;
using (var context = new ERPContext())
{
var latestPurchaseReturnTransaction = context.PurchaseReturnTransactions.Where(
transaction =>
string.Compare(transaction.PurchaseReturnTransactionID, newEntryID, StringComparison.Ordinal) >=
0)
.OrderByDescending(transaction => transaction.PurchaseReturnTransactionID)
.FirstOrDefault();
if (latestPurchaseReturnTransaction != null)
{
lastEntryID = latestPurchaseReturnTransaction.PurchaseReturnTransactionID;
}
}
if (lastEntryID != null)
{
newEntryID = "PR" + (Convert.ToInt64(lastEntryID.Substring(2)) + 1);
}
Model.PurchaseReturnTransactionID = newEntryID;
_purchaseReturnTransactionID = newEntryID;
OnPropertyChanged("PurchaseReturnTransactionID");
}
private static void AttachItemSupplierToDatabaseContext(ERPContext context, Item item)
{
var supplierToBeAttached = item.Suppliers.First();
item.Suppliers.RemoveAt(0);
supplierToBeAttached = context.Suppliers.FirstOrDefault(e => e.ID.Equals(supplierToBeAttached.ID));
item.Suppliers.Add(supplierToBeAttached);
}
public void Close(BackgroundWorker worker)
{
using (var context = new ERPContext())
{
var items = context.Inventory.ToList();
var index = 1;
foreach (var item in items)
{
foreach (var warehouse in _warehouses)
{
var beginningBalance = GetBeginningBalance(context, warehouse, item);
var endingBalance = GetEndingBalance(context, warehouse, item, beginningBalance);
SetEndingBalance(context, warehouse, item, endingBalance);
}
var status = index++ *(items.Count / 100) - 1;
if (status < 0)
{
status = 0;
}
worker.ReportProgress(status);
}
context.SaveChanges();
}
MessageBox.Show("Successfully closed stock!", "Succecss", MessageBoxButton.OK);
}
private static void ChangeSupplierLedgerAccountNameInDatabaseContext(ERPContext context, Supplier editingSupplier, Supplier editedSupplier)
{
var ledgerAccountFromDatabase = GetSupplierLedgerAccountFromDatabaseContext(context, editingSupplier);
ledgerAccountFromDatabase.Name = $"{editedSupplier.Name} Accounts Payable";
context.SaveChanges();
}
public void UpdateListingQuantities(ERPContext context, string accountName, Dictionary <string, int> inventoryDictionary, Dictionary <string, Dictionary <string, int> > productCombineDictionary)
{
Dictionary <string, int> quantities = new Dictionary <string, int>();
var q = from amazonList in context.AmazonList
where amazonList.AccountName == accountName
select amazonList;
foreach (var row in q)
{
int oldQuantity = row.Quantity;
int warehouseQuantity = 0;
int newQuantity = 0;
bool update = m_platformServiceFactory.GetInventoryService(m_company).GetNewQuantity(inventoryDictionary, productCombineDictionary, row.SKU, 1, oldQuantity, out warehouseQuantity, out newQuantity);
m_logger.Info(accountName + ": " + row.SKU + " listing quantity: " + oldQuantity + " warehouse quantity: " + warehouseQuantity);
if (update)
{
quantities[row.SKU] = newQuantity;
row.Quantity = newQuantity;
m_logger.Info(accountName + ": Quantity of " + row.SKU + " has been changed from " + oldQuantity + " to " + newQuantity);
}
}
if (quantities.Count() > 0)
{
UpdateInventory(accountName, quantities);
context.SaveChanges();
}
}
private void UpdateCategories()
{
var oldSelectedCategory = _selectedCategory;
Categories.Clear();
var allCategory = new ItemCategory {
ID = -1, Name = "All"
};
Categories.Add(new ItemCategoryVM {
Model = allCategory
});
using (var context = new ERPContext())
{
var categoriesFromDatabase = context.Categories.OrderBy(category => category.Name);
foreach (var category in categoriesFromDatabase)
{
Categories.Add(new ItemCategoryVM {
Model = category
});
}
}
UpdateSelectedCategory(oldSelectedCategory);
}
public void Close(BackgroundWorker worker)
{
using (var ts = new TransactionScope())
{
var context = new ERPContext();
var accounts = context.Ledger_Accounts
.Include("LedgerGeneral")
.Include("LedgerAccountBalances")
.ToList();
var revenueAndExpenseAccounts = context.Ledger_Accounts
.Include("LedgerGeneral")
.Include("LedgerAccountBalances")
.Where(e => e.Class.Equals("Expense") || e.Class.Equals("Revenue"))
.ToList();
var index = 1;
var totalAccounts = accounts.Count + revenueAndExpenseAccounts.Count;
// Close the Revenue and Expense Accounts to Retained Earnings
foreach (var account in revenueAndExpenseAccounts)
{
if (account.LedgerGeneral.Debit != 0 || account.LedgerGeneral.Credit != 0)
CloseRevenueOrExpenseAccountToRetainedEarnings(account, context);
worker.ReportProgress(index++ * (totalAccounts / 100));
}
foreach (var account in accounts)
{
if (UtilityMethods.GetCurrentDate().Month == 12)
{
var newBalance = new LedgerAccountBalance { LedgerAccount = account, PeriodYear = UtilityMethods.GetCurrentDate().Year + 1 };
context.Ledger_Account_Balances.Add(newBalance);
}
if (Period != 12) account.LedgerGeneral.Period++;
else
{
account.LedgerGeneral.PeriodYear++;
account.LedgerGeneral.Period = 1;
}
// Close the balances
if (account.Class.Equals("Asset") || account.Class.Equals("Expense"))
CloseAssetOrExpenseAccount(account, context);
else
CloseLiabilityOrRevenueAccount(account, context);
worker.ReportProgress(index++ * (totalAccounts / 100));
}
context.SaveChanges();
ts.Complete();
}
OnPropertyChanged("PeriodYear");
OnPropertyChanged("Period");
}
public ClosingVM()
{
using (var context = new ERPContext())
{
_periodYear = context.Ledger_General.First().PeriodYear;
_period = context.Ledger_General.First().Period;
}
}
public static void AddCustomerAlongWithItsLedgerToDatabase(Customer customer)
{
using (var context = new ERPContext())
{
context.Customers.Add(customer);
context.SaveChanges();
}
}
private static void AttachSalesReturnTransactionPropertiesToDatabaseContext(ERPContext context,
ref SalesReturnTransaction salesReturnTransaction)
{
//var user = Application.Current.FindResource("CurrentUser") as User;
//salesReturnTransaction.User = context.Users.FirstOrDefault(e => e.Username.Equals(user.Username));
context.SalesTransactions.Attach(salesReturnTransaction.SalesTransaction);
if (salesReturnTransaction.SalesTransaction.Customer != null)
context.Customers.Attach(salesReturnTransaction.SalesTransaction.Customer);
}
public static void SaveItemEditsToDatabase(Item editingItem, Item editedItem)
{
using (var ts = new TransactionScope())
{
var context = new ERPContext();
SaveItemEditsToDatabaseContext(context, editingItem, editedItem);
ts.Complete();
}
}
public static void ActivateItemInDatabase(Item item)
{
using (var context = new ERPContext())
{
context.Entry(item).State = EntityState.Modified;
item.IsActive = true;
context.SaveChanges();
}
}
private static void AddSalesReturnTransactionLineToDatabaseContext(ERPContext context,
SalesReturnTransactionLine salesReturnTransactionLine)
{
var item = context.Inventory.First(e => e.ID.Equals(salesReturnTransactionLine.Item.ID));
var warehouse = context.Warehouses.First(e => e.ID.Equals(salesReturnTransactionLine.Warehouse.ID));
salesReturnTransactionLine.Item = item;
salesReturnTransactionLine.Warehouse = warehouse;
context.SalesReturnTransactionLines.Add(salesReturnTransactionLine);
}
public static void SaveCustomerEditsToDatabase(Customer editingCustomer, Customer editedCustomer)
{
using (var ts = new TransactionScope())
{
var context = new ERPContext();
SaveCustomerEditsToDatabaseContext(context, editingCustomer, editedCustomer);
ts.Complete();
}
}
public static void SaveSupplierEditsToDatabase(Supplier editingSupplier, Supplier editedSupplier)
{
using (var ts = new TransactionScope())
{
var context = new ERPContext();
if (!IsSupplierNameChange(editingSupplier, editedSupplier))
ChangeSupplierLedgerAccountNameInDatabaseContext(context, editingSupplier, editedSupplier);
SaveSupplierEditsToDatabaseContext(context, editingSupplier, editedSupplier);
ts.Complete();
}
}
private static void CreateAndAddSupplierLedgerToDatabaseContext(ERPContext context, Supplier suppplier)
{
var ledgerAccount = CreateSupplierLedgerAccount(suppplier);
context.Ledger_Accounts.Add(ledgerAccount);
var ledgerGeneral = CreateSupplierLedgerGeneral(ledgerAccount);
context.Ledger_General.Add(ledgerGeneral);
var ledgerAccountBalance = CreateSupplierLedgerAccountBalance(ledgerAccount);
context.Ledger_Account_Balances.Add(ledgerAccountBalance);
}
private static void IncreaseLineItemStockInDatabaseContext(ERPContext context, PurchaseTransactionLine line)
{
var stockFromDatabase = context.Stocks.SingleOrDefault(
stock => stock.ItemID.Equals(line.Item.ID) && stock.WarehouseID.Equals(line.Warehouse.ID));
if (stockFromDatabase == null)
{
context.Stocks.Add(new Stock { Item = line.Item, Warehouse = line.Warehouse, Pieces = line.Quantity });
context.SaveChanges();
}
else
stockFromDatabase.Pieces += line.Quantity;
}
private static bool IsThereEnoughLineItemStockInDatabaseContext(ERPContext context, PurchaseReturnTransactionLine purchaseReturnTransactionLine)
{
var stockFromDatabase = context.Stocks.SingleOrDefault(
stock => stock.Item.ID.Equals(purchaseReturnTransactionLine.Item.ID) &&
stock.Warehouse.ID.Equals(purchaseReturnTransactionLine.ReturnWarehouse.ID));
if (stockFromDatabase != null && stockFromDatabase.Pieces >= purchaseReturnTransactionLine.Quantity)
return true;
var availableQuantity = stockFromDatabase?.Pieces ?? 0;
MessageBox.Show(
$"{purchaseReturnTransactionLine.Item.Name} has only {availableQuantity} left.",
"Invalid Quantity", MessageBoxButton.OK);
return false;
}
public static decimal GetSalesReturnTransactionLineCOGS(SalesReturnTransactionLine salesReturnTransactionLine)
{
decimal amount = 0;
using (var context = new ERPContext())
{
var purchases = context.PurchaseTransactionLines
.Include("PurchaseTransaction")
.Where(
line => line.ItemID.Equals(salesReturnTransactionLine.Item.ID) && line.SoldOrReturned > 0)
.OrderByDescending(e => e.PurchaseTransactionID)
.ThenByDescending(transaction => transaction.Quantity - transaction.SoldOrReturned)
.ThenByDescending(transaction => transaction.PurchasePrice)
.ThenByDescending(transaction => transaction.Discount)
.ThenByDescending(transaction => transaction.WarehouseID);
var tracker = salesReturnTransactionLine.Quantity;
foreach (var purchase in purchases)
{
var purchaseLineTotal = purchase.PurchasePrice - purchase.Discount;
if (purchase.SoldOrReturned >= tracker)
{
if (purchaseLineTotal == 0) break;
var fractionOfTransactionDiscount = tracker*purchaseLineTotal/
purchase.PurchaseTransaction.GrossTotal*
purchase.PurchaseTransaction.Discount;
var fractionOfTransactionTax = tracker*purchaseLineTotal/purchase.PurchaseTransaction.GrossTotal*
purchase.PurchaseTransaction.Tax;
amount += tracker*purchaseLineTotal - fractionOfTransactionDiscount + fractionOfTransactionTax;
break;
}
if (purchase.SoldOrReturned < tracker)
{
tracker -= purchase.SoldOrReturned;
if (purchaseLineTotal == 0) continue;
var fractionOfTransactionDiscount = purchase.SoldOrReturned*purchaseLineTotal/
purchase.PurchaseTransaction.GrossTotal*
purchase.PurchaseTransaction.Discount;
var fractionOfTransactionTax = purchase.SoldOrReturned*purchaseLineTotal/
purchase.PurchaseTransaction.GrossTotal*
purchase.PurchaseTransaction.Tax;
amount += purchase.SoldOrReturned*purchaseLineTotal - fractionOfTransactionDiscount +
fractionOfTransactionTax;
}
}
}
return amount;
}
public CloseStockVM()
{
using (var context = new ERPContext())
{
PeriodYears = new ObservableCollection<int> { DateTime.Now.Year - 1, DateTime.Now.Year };
var firstOrDefault = context.Ledger_General.FirstOrDefault();
if (firstOrDefault != null)
_periodYear = firstOrDefault.PeriodYear;
Periods = new ObservableCollection<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
_period = UtilityMethods.GetCurrentDate().Month;
_warehouses = context.Warehouses.ToList();
}
}
public static void EditTransactionInDatabase(PurchaseTransaction editedPurchaseTransaction)
{
IsLastSaveSuccessful = false;
using (var ts = new TransactionScope())
{
var context = new ERPContext();
RecordEditedPurchaseTransactionLedgerTransactionsInDatabaseContext(context, editedPurchaseTransaction);
SetPurchaseTransactionInDatabaseContextToEditedPurchaseTransactionProperties(context, editedPurchaseTransaction);
ts.Complete();
}
IsLastSaveSuccessful = true;
}
private void LoadSuppliersAvailableForAddition()
{
SuppliersAvailableForAddition.Clear();
using (var context = new ERPContext())
{
var allSuppliersFromDatabase = context.Suppliers.Where(
supplier => !supplier.Name.Equals("-") && supplier.IsActive)
.OrderBy(supplier => supplier.Name)
.ToList();
foreach (var supplier in from supplier in allSuppliersFromDatabase
let supplierVM = new SupplierVM {Model = supplier}
where !_editSuppliers.Contains(supplierVM)
select supplier)
SuppliersAvailableForAddition.Add(new SupplierVM { Model = supplier });
}
}
private static decimal CalculateLineCOGSFromDatabaseContext(ERPContext context, PurchaseReturnTransactionLine purchaseReturnTransactionLine)
{
var purchaseTransactionLine = context.PurchaseTransactionLines
.Single(
line => line.PurchaseTransactionID.Equals(purchaseReturnTransactionLine.PurchaseReturnTransaction.PurchaseTransaction.PurchaseID) &&
line.ItemID.Equals(purchaseReturnTransactionLine.Item.ID) && line.WarehouseID.Equals(purchaseReturnTransactionLine.Warehouse.ID) &&
line.PurchasePrice.Equals(purchaseReturnTransactionLine.PurchasePrice) && line.Discount.Equals(purchaseReturnTransactionLine.Discount));
var purchaseLineNetTotal = purchaseTransactionLine.PurchasePrice - purchaseTransactionLine.Discount;
if (purchaseLineNetTotal == 0) return 0;
var fractionOfTransactionDiscount = purchaseReturnTransactionLine.Quantity * purchaseLineNetTotal /
purchaseTransactionLine.PurchaseTransaction.GrossTotal * purchaseTransactionLine.PurchaseTransaction.Discount;
var fractionOfTransactionTax = purchaseReturnTransactionLine.Quantity * purchaseLineNetTotal /
purchaseTransactionLine.PurchaseTransaction.GrossTotal * purchaseTransactionLine.PurchaseTransaction.Tax;
return purchaseReturnTransactionLine.Quantity * purchaseLineNetTotal - fractionOfTransactionDiscount + fractionOfTransactionTax;
}
private static PurchaseTransaction MakeNewstockAdjustmentPurchaseTransaction(ERPContext context, StockAdjustmentTransaction stockAdjustmentTransaction)
{
return new PurchaseTransaction
{
PurchaseID = stockAdjustmentTransaction.StockAdjustmentTransactionID,
Supplier = context.Suppliers.Single(e => e.Name.Equals("-")),
Date = UtilityMethods.GetCurrentDate().Date,
DueDate = UtilityMethods.GetCurrentDate().Date,
Discount = 0,
GrossTotal = 0,
Total = 0,
Paid = 0,
User = stockAdjustmentTransaction.User,
PurchaseTransactionLines = new ObservableCollection<PurchaseTransactionLine>()
};
}
public static void AddTransactionLineToDatabase(ERPContext context, LedgerTransaction transaction, string accountName, string seq, decimal amount)
{
var transactionLine = new LedgerTransactionLine();
var account = context.Ledger_Accounts.First(e => e.Name.Equals(accountName));
var ledgerAccount = context.Ledger_General.First(e => e.ID.Equals(account.ID));
transactionLine.LedgerTransaction = transaction;
transactionLine.LedgerAccount = account;
transactionLine.Seq = seq;
transactionLine.Amount = amount;
// Update the amount of the account
if (seq == "Debit") ledgerAccount.Debit += amount;
else if (seq == "Credit") ledgerAccount.Credit += amount;
context.Ledger_Transaction_Lines.Add(transactionLine);
}
public static void MakePayment(PurchaseTransaction purchaseTransaction, decimal paymentAmount,
decimal useCreditsAmount, string paymentMode)
{
using (var ts = new TransactionScope())
{
var context = new ERPContext();
context.Entry(purchaseTransaction).State = EntityState.Modified;
purchaseTransaction.Paid += paymentAmount + useCreditsAmount;
purchaseTransaction.Supplier.PurchaseReturnCredits -= useCreditsAmount;
RecordPaymentLedgerTransactionInDatabaseContext(context, purchaseTransaction, paymentAmount, paymentMode);
context.SaveChanges();
ts.Complete();
}
}
public static void AddSupplierAlongWithItsLedgerToDatabase(Supplier supplier)
{
var context = new ERPContext();
try
{
context.Suppliers.Add(supplier);
CreateAndAddSupplierLedgerToDatabaseContext(context, supplier);
context.SaveChanges();
}
catch
{
MessageBox.Show("The supplier's name is already being used.", "Invalid Supplier", MessageBoxButton.OK);
}
finally
{
context.Dispose();
}
}
