private async void btnAdd_Clicked(object sender, EventArgs e)
{
try
{
StockBalance list = new StockBalance()
{
Qty = !string.IsNullOrEmpty(txtBalance.Text)? Convert.ToInt32(txtBalance.Text.Trim()): 0,
ItemId = itemId
};
var a = await App.Database.GetStockById(itemId);
if (a == null)
{
await App.Database.insertStock(list);
}
else
{
await App.Database.UpdateItemStock(list);
}
MessagingCenter.Send(this, "StockUpdated");
await Navigation.PopPopupAsync();
}
catch (Exception ex)
{
return;
}
}
public void UpdateStockBalance(Stock Stock)
{
StockBalance StockBalance = Find(Stock.ProductId, Stock.Dimension1Id, Stock.Dimension2Id, Stock.ProcessId, Stock.LotNo, Stock.GodownId, Stock.CostCenterId);
if (StockBalance == null)
{
StockBalance StockBalance_NewRecord = new StockBalance();
StockBalance_NewRecord.ProductId = Stock.ProductId;
StockBalance_NewRecord.Dimension1Id = Stock.Dimension1Id;
StockBalance_NewRecord.Dimension2Id = Stock.Dimension2Id;
StockBalance_NewRecord.ProcessId = Stock.ProcessId;
StockBalance_NewRecord.GodownId = Stock.GodownId;
StockBalance_NewRecord.CostCenterId = Stock.CostCenterId;
StockBalance_NewRecord.LotNo = Stock.LotNo;
if (Stock.Qty_Iss != 0)
{
StockBalance_NewRecord.Qty = -Stock.Qty_Iss;
}
if (Stock.Qty_Rec != 0)
{
StockBalance_NewRecord.Qty = Stock.Qty_Rec;
}
Create(StockBalance_NewRecord);
}
else
{
StockBalance.Qty = StockBalance.Qty - Stock.Qty_Iss;
StockBalance.Qty = StockBalance.Qty + Stock.Qty_Rec;
StockBalance.ObjectState = Model.ObjectState.Added;
Update(StockBalance);
}
}
public ActionResult Create([Bind(Include = "SupplyId,Date,ProductId,Quantity,UnitPrice,SellingPrice,Creator,CreateDate")] Supply supply)
{
if (ModelState.IsValid)
{
db.Supplies.Add(supply);
var stockBalance = db.StockBalances.Where(x => x.ProductId == supply.ProductId).FirstOrDefault();
if (stockBalance != null)
{
stockBalance.Quantity += supply.Quantity;
stockBalance.SellingPrice = supply.SellingPrice;
db.Entry(stockBalance).State = EntityState.Modified;
}
else
{
var newStock = new StockBalance()
{
ProductId = supply.ProductId, Quantity = supply.Quantity, SellingPrice = supply.SellingPrice, Creator = User.Identity.Name, CreateDate = DateTime.Now
};
db.StockBalances.Add(newStock);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ProductId = new SelectList(db.Products, "ProductId", "Name", supply.ProductId);
return(View(supply));
}
public async Task WhenCreate_ThenSuccess()
{
var headers = await _defaultRequestHeadersService.GetAsync();
var room = await _create.StockRoom.BuildAsync();
var productStatus = await _create.ProductStatus.BuildAsync();
var product = await _create.Product
.WithStatusId(productStatus.Id)
.BuildAsync();
var balance = new StockBalance
{
Id = Guid.NewGuid(),
RoomId = room.Id,
ProductId = product.Id,
Count = 1,
IsDeleted = true
};
var createdBalanceId = await _stockBalancesClient.CreateAsync(balance, headers);
var createdBalance = await _stockBalancesClient.GetAsync(createdBalanceId, headers);
Assert.NotNull(createdBalance);
Assert.Equal(createdBalanceId, createdBalance.Id);
Assert.Equal(balance.RoomId, createdBalance.RoomId);
Assert.Equal(balance.ProductId, createdBalance.ProductId);
Assert.Equal(balance.Count, createdBalance.Count);
Assert.True(!createdBalance.CreateUserId.IsEmpty());
Assert.Equal(balance.IsDeleted, createdBalance.IsDeleted);
Assert.True(createdBalance.CreateDateTime.IsMoreThanMinValue());
}
private void btn_Update_Click_1(object sender, EventArgs e)
{
//Updates the number of books of a user-chosen book at a user-chosen bookstore.
using (var db = new LAM_Lab2Context())
{
try
{
var item = comboBox_bookstore.SelectedValue;
var id = Convert.ToInt32(item);
var bookInStock = new StockBalance()
{
NumberOfItems = Int32.Parse(tb_nrOfItems.Text),
BookStoresId = id,
BooksIsbn13 = comboBox_book.SelectedValue.ToString()
};
db.StockBalances.Update(bookInStock);
db.SaveChanges();
}
catch (Exception ee)
{
MessageBox.Show($"{ee}", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
dataGridView_storeData.DataSource = sqlResult();
}
}
public async Task <Guid> CreateAsync(Guid userId, StockBalance balance, CancellationToken ct)
{
var newStockBalance = new StockBalance();
var change = newStockBalance.CreateWithLog(userId, x =>
{
x.Id = balance.Id;
x.AccountId = balance.AccountId;
x.CreateUserId = userId;
x.RoomId = balance.RoomId;
x.ProductId = balance.ProductId;
x.Count = balance.Count;
x.IsDeleted = balance.IsDeleted;
x.CreateDateTime = DateTime.UtcNow;
// x.UniqueElementIds = balance.UniqueElementIds;
});
var entry = await _storage.AddAsync(newStockBalance, ct);
await _storage.AddAsync(change, ct);
await _storage.SaveChangesAsync(ct);
return(entry.Entity.Id);
}
private void btn_remove_Click(object sender, EventArgs e)
{
//Remove a user-chosen book at a user-chosen bookstore.
using (var db = new LAM_Lab2Context())
{
var result = MessageBox.Show("Are you sure?", "Confirm delete",
MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
if (result == DialogResult.Yes)
{
try
{
var item = comboBox_bookstore.SelectedValue;
var id = Convert.ToInt32(item);
var bookInStock = new StockBalance()
{
BookStoresId = id,
BooksIsbn13 = comboBox_book.SelectedValue.ToString()
};
db.StockBalances.Remove(bookInStock);
db.SaveChanges();
}
catch (Exception ee)
{
MessageBox.Show($"{ee}", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
dataGridView_storeData.DataSource = sqlResult();
}
}
}
private void btn_Save_Click(object sender, EventArgs e)
{
using (var db = new LAM_Lab2Context())
{
// Adds a new book (from combobox_book) to a bookstore.
// Shows errormessage if fail.
try
{
var item = comboBox_bookstore.SelectedValue;
var id = Convert.ToInt32(item);
var bookInStock = new StockBalance()
{
NumberOfItems = Int32.Parse(tb_nrOfItems.Text),
BookStoresId = id,
BooksIsbn13 = comboBox_book.SelectedValue.ToString()
};
db.StockBalances.Add(bookInStock);
db.SaveChanges();
}
catch (Exception ee)
{
MessageBox.Show($"{ee}", "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
dataGridView_storeData.DataSource = sqlResult();
}
}
public void DeleteStockDB(int StockId, bool IsDBbased)
{
Stock Stock = Find(StockId);
StockBalance StockBalance = (from p in _unitOfWork.Repository <StockBalance>().Instance
where p.ProductId == Stock.ProductId &&
p.Dimension1Id == Stock.Dimension1Id &&
p.Dimension2Id == Stock.Dimension2Id &&
p.ProcessId == Stock.ProcessId &&
p.LotNo == Stock.LotNo &&
p.GodownId == Stock.GodownId &&
p.CostCenterId == Stock.CostCenterId
select p).FirstOrDefault();
if (StockBalance != null)
{
StockBalance.Qty = StockBalance.Qty + Stock.Qty_Iss;
StockBalance.Qty = StockBalance.Qty - Stock.Qty_Rec;
StockBalance.ObjectState = Model.ObjectState.Modified;
_stockBalanceService.Update(StockBalance);
}
Stock.ObjectState = Model.ObjectState.Deleted;
Delete(StockId);
}
public Task UpdateAsync(
StockBalance balance,
Dictionary <string, string> headers = default,
CancellationToken ct = default)
{
return(_factory.PatchAsync(_host + "/Stock/Balances/v1/Update", null, balance, headers, ct));
}
public Task <Guid> CreateAsync(
StockBalance balance,
Dictionary <string, string> headers = default,
CancellationToken ct = default)
{
return(_factory.PostAsync <Guid>(_host + "/Stock/Balances/v1/Create", null, balance, headers, ct));
}
public async Task <ActionResult <Guid> > Create(StockBalance balance, CancellationToken ct = default)
{
balance.AccountId = _userContext.AccountId;
var id = await _stockBalancesService.CreateAsync(_userContext.UserId, balance, ct);
return(Created(nameof(Get), id));
}
public StockBalance FindStockBalance(int ProductId, int?Dimension1Id, int?Dimension2Id, int?ProcessId, string LotNo, int GodownId, int?CostCenterId)
{
StockBalance stockbalance = (from L in _unitOfWork.Repository <StockBalance>().Instance
where L.ProductId == ProductId && L.Dimension1Id == Dimension1Id && L.Dimension2Id == Dimension2Id && L.ProcessId == ProcessId && L.LotNo == LotNo && L.GodownId == GodownId && L.CostCenterId == CostCenterId
select L).FirstOrDefault();
return(stockbalance);
}
public ActionResult DeleteConfirmed(int id)
{
StockBalance stockBalance = db.StockBalances.Find(id);
db.StockBalances.Remove(stockBalance);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public static bool FilterByAdditional(this StockBalance balance, StockBalanceGetPagedListRequest request)
{
return((request.CreateUserIds == null || !request.CreateUserIds.Any() ||
request.CreateUserIds.Any(x => CreateUserIdsPredicate(balance, x))) &&
(request.RoomIds == null || !request.RoomIds.Any() ||
request.RoomIds.Any(x => RoomIdsPredicate(balance, x))) &&
(request.ProductIds == null || !request.ProductIds.Any() ||
request.ProductIds.Any(x => ProductIdsPredicate(balance, x))));
}
internal Task insertStock(StockBalance list)
{
StockBalance st = new StockBalance()
{
ItemId = list.ItemId,
Qty = list.Qty,
};
return(Database.InsertAsync(st));
}
public ActionResult Edit([Bind(Include = "StockBalanceId,ProductId,Quantity,SellingPrice,Creator,CreateDate")] StockBalance stockBalance)
{
if (ModelState.IsValid)
{
db.Entry(stockBalance).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.ProductId = new SelectList(db.Products, "ProductId", "Name", stockBalance.ProductId);
return(View(stockBalance));
}
public StockBalance Find(int ProductId, int?Dimension1Id, int?Dimension2Id, int?ProcessId, string LotNo, int GodownId, int?CostCenterId)
{
StockBalance stockbalance = _StockBalanceRepository.Query().Get().Where(i => i.ProductId == ProductId &&
i.Dimension1Id == Dimension1Id &&
i.Dimension2Id == Dimension2Id &&
i.ProcessId == ProcessId &&
i.LotNo == LotNo &&
i.GodownId == GodownId &&
i.CostCenterId == CostCenterId).FirstOrDefault();
return(stockbalance);
}
public StockBalanceBuilder(
IDefaultRequestHeadersService defaultRequestHeadersService,
IStockBalancesClient balancesClient)
{
_balancesClient = balancesClient;
_defaultRequestHeadersService = defaultRequestHeadersService;
_balance = new StockBalance
{
Id = Guid.NewGuid(),
Count = 0,
IsDeleted = false
};
}
public void DeleteStockMultiple(List <int> StockId)
{
var StockIdArray = StockId.ToArray();
var Stock = (from p in _StockRepository.Instance
where StockIdArray.Contains(p.StockId)
select p).ToList();
var GroupedStock = (from p in Stock
group p by new
{
p.ProductId,
p.Dimension1Id,
p.Dimension2Id,
p.ProcessId,
p.LotNo,
p.GodownId,
p.CostCenterId
} into g
select g).ToList();
foreach (var item in GroupedStock)
{
StockBalance StockBalance = (from p in _unitOfWork.Repository <StockBalance>().Instance
where p.ProductId == item.Key.ProductId &&
p.Dimension1Id == item.Key.Dimension1Id &&
p.Dimension2Id == item.Key.Dimension2Id &&
p.ProcessId == item.Key.ProcessId &&
p.LotNo == item.Key.LotNo &&
p.GodownId == item.Key.GodownId &&
p.CostCenterId == item.Key.CostCenterId
select p).FirstOrDefault();
if (StockBalance != null)
{
StockBalance.Qty = StockBalance.Qty + item.Sum(m => m.Qty_Iss);
StockBalance.Qty = StockBalance.Qty - item.Sum(m => m.Qty_Rec);
StockBalance.ObjectState = Model.ObjectState.Modified;
_stockBalanceService.Update(StockBalance);
}
foreach (var IStock in item)
{
Delete(IStock);
}
}
}
public async Task <ActionResult> Update(StockBalance balance, CancellationToken ct = default)
{
var oldBalance = await _stockBalancesService.GetAsync(balance.Id, true, ct);
if (oldBalance == null)
{
return(NotFound(balance.Id));
}
return(await ActionIfAllowed(
() => _stockBalancesService.UpdateAsync(_userContext.UserId, oldBalance, balance, ct),
Roles.Stock,
oldBalance.AccountId));
}
// GET: StockBalances/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
StockBalance stockBalance = db.StockBalances.Find(id);
if (stockBalance == null)
{
return(HttpNotFound());
}
return(View(stockBalance));
}
// GET: StockBalances/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
StockBalance stockBalance = db.StockBalances.Find(id);
if (stockBalance == null)
{
return(HttpNotFound());
}
ViewBag.ProductId = new SelectList(db.Products, "ProductId", "Name", stockBalance.ProductId);
return(View(stockBalance));
}
public void DeleteStock(int StockId)
{
Stock Stock = Find(StockId);
StockBalance StockBalance = _stockBalanceService.Find(Stock.ProductId, Stock.Dimension1Id, Stock.Dimension2Id, Stock.ProcessId, Stock.LotNo, Stock.GodownId, Stock.CostCenterId);
if (StockBalance != null)
{
StockBalance.Qty = StockBalance.Qty + Stock.Qty_Iss;
StockBalance.Qty = StockBalance.Qty - Stock.Qty_Rec;
_stockBalanceService.Update(StockBalance);
}
Delete(StockId);
}
public static StockBalanceChange CreateWithLog(
this StockBalance balance,
Guid userId,
Action <StockBalance> action)
{
action(balance);
return(new StockBalanceChange
{
StockBalanceId = balance.Id,
ChangerUserId = userId,
CreateDateTime = DateTime.UtcNow,
OldValueJson = string.Empty,
NewValueJson = balance.ToJsonString()
});
}
public StockBalance Find(int ProductId, int?Dimension1Id, int?Dimension2Id, int?Dimension3Id, int?Dimension4Id, int?ProcessId, string LotNo, int GodownId, int?CostCenterId)
{
//StockBalance stockbalance = (from L in db.StockBalance
// where L.ProductId == ProductId && L.Dimension1Id == Dimension1Id && L.Dimension2Id == Dimension2Id && L.ProcessId == ProcessId && L.LotNo == LotNo && L.GodownId == GodownId && L.CostCenterId == CostCenterId
// select L).FirstOrDefault();
StockBalance stockbalance = _unitOfWork.Repository <StockBalance>().Query().Get().Where(i => i.ProductId == ProductId &&
i.Dimension1Id == Dimension1Id &&
i.Dimension2Id == Dimension2Id &&
i.Dimension3Id == Dimension3Id &&
i.Dimension4Id == Dimension4Id &&
i.ProcessId == ProcessId &&
i.LotNo == LotNo &&
i.GodownId == GodownId &&
i.CostCenterId == CostCenterId).FirstOrDefault();
return(stockbalance);
}
public void UpdateStock()
{
if (transItem.Reason_code == (int)EjItemReasonCodes.NORMAL_ITEM)
{
//Update stock
TransStock transStock = new TransStock();
transStock.Organization_no = PosSettings.Default.Organization;
transStock.Store_no = PosSettings.Default.Store;
transStock.Sku = transItem.Sku;
transStock.Transaction_type = (int)TransStockTypes.SALE_OUT;
transStock.Reference_number = TransItem.Trans_no.ToString().PadLeft(10, '0') + "/" + TransItem.Line_no.ToString().PadLeft(3, '0');
transStock.Quantity = PosContext.Instance.PosMath.Negate(transItem.Quantity);
transStock.Transaction_time = DateTime.Now;
transStock.Add();
StockBalance stockBalance = new StockBalance();
stockBalance.Organization_no = PosSettings.Default.Organization;
stockBalance.Store_no = PosSettings.Default.Store;
stockBalance.Sku = transItem.Sku;
stockBalance.Quantity_on_hand = PosContext.Instance.PosMath.Negate(transItem.Quantity);
stockBalance.AddBalance();
}
}
public async Task UpdateAsync(
Guid userId,
StockBalance oldBalance,
StockBalance newBalance,
CancellationToken ct)
{
var change = oldBalance.UpdateWithLog(userId, x =>
{
x.AccountId = newBalance.AccountId;
x.RoomId = newBalance.RoomId;
x.ProductId = newBalance.ProductId;
x.Count = newBalance.Count;
x.IsDeleted = newBalance.IsDeleted;
x.ModifyDateTime = DateTime.UtcNow;
// x.UniqueElementIds = newBalance.UniqueElementIds;
});
_storage.Update(oldBalance);
await _storage.AddAsync(change, ct);
await _storage.SaveChangesAsync(ct);
}
public StockBalance Add(StockBalance pt)
{
_StockBalanceRepository.Insert(pt);
return(pt);
}
public void Update(StockBalance pt)
{
pt.ObjectState = ObjectState.Modified;
_StockBalanceRepository.Update(pt);
}
private void SetEndingBalance(ERPContext context, Warehouse warehouse, Item item, int endingBalance)
{
var stockBalance = context.StockBalances.SingleOrDefault(e => e.ItemID.Equals(item.ID) && e.WarehouseID.Equals(warehouse.ID) && e.Year == _periodYear);
var flag = true;
if (stockBalance == null)
{
flag = false;
stockBalance = new StockBalance
{
Item = context.Inventory.SingleOrDefault(e => e.ID.Equals(item.ID)),
Warehouse = context.Warehouses.SingleOrDefault(e => e.ID.Equals(warehouse.ID)),
Year = _periodYear
};
}
switch (_period)
{
case 1:
stockBalance.Balance1 = endingBalance;
break;
case 2:
stockBalance.Balance2 = endingBalance;
break;
case 3:
stockBalance.Balance3 = endingBalance;
break;
case 4:
stockBalance.Balance4 = endingBalance;
break;
case 5:
stockBalance.Balance5 = endingBalance;
break;
case 6:
stockBalance.Balance6 = endingBalance;
break;
case 7:
stockBalance.Balance7 = endingBalance;
break;
case 8:
stockBalance.Balance8 = endingBalance;
break;
case 9:
stockBalance.Balance9 = endingBalance;
break;
case 10:
stockBalance.Balance10 = endingBalance;
break;
case 11:
stockBalance.Balance11 = endingBalance;
break;
default:
stockBalance.Balance12 = endingBalance;
break;
}
if (!flag)
{
context.StockBalances.Add(stockBalance);
}
}
