public void ProcessRequisitionsTest_CreatesRetrieval()
{
// Arrange
List <Requisition> reqList = new List <Requisition>();
reqList.Add(context.Requisition.Where(x => x.RequisitionId == "GAB1").ToList().First());
reqList.Add(context.Requisition.Where(x => x.RequisitionId == "GAB2").ToList().First());
reqList.Add(context.Requisition.Where(x => x.RequisitionId == "GAB3").ToList().First());
// Act
string retrievalId = requisitionService.ProcessRequisitions(reqList);
// Assert - the Retrieval ID that ProcessRequisitions returns should return a Requisition
Retrieval result = context.Retrieval.Where(x => x.RetrievalId == retrievalId).ToList().First();
Assert.IsNotNull(result);
// Cleanup
var disb = context.Disbursement.Where(x => x.Retrieval.RetrievalId == result.RetrievalId).AsEnumerable();
context.Disbursement.RemoveRange(disb);
context.Retrieval.Remove(result);
context.SaveChanges();
}
public bool UpdateRetrieval(Retrieval r1)
{
try
{
var original = dbcontext.Retrievals.Find(r1.Id);
if (original == null)
{
throw new Exception();
}
original.NeedAdjustment = r1.NeedAdjustment;
original.Remark = r1.Remark;
original.ClerkId = r1.ClerkId;
if (r1.RetrievedDate != null)
{
original.RetrievedDate = r1.RetrievedDate;
}
if (r1.Status == Status.RetrievalStatus.retrieved)
{
original.Status = r1.Status;
}
dbcontext.SaveChanges();
return(true);
}
catch
{
throw new Exception("Error updating retrieval form");
}
}
public IEnumerable <TRow> Scan(Func <TIndexKey, bool> predicate, Retrieval retrieval) => _map.GetItems(retrieval.Reverse) .Where(d => predicate(d.Key)) .SelectMany(s => s.Value.GetItems(false)) .Skip(retrieval.Skip ?? 0) .Take(retrieval.Take ?? Int32.MaxValue) .Select(s => s.Row);
public Dictionary <String, List <DisbursementDetail> > GenerateDisbursementDetailPerItem()
{
Retrieval retrieval = this.GetCurrentRetrieval();
List <DisbursementDetail> ddList = new List <DisbursementDetail>();
Dictionary <String, List <DisbursementDetail> > ddDict = new Dictionary <string, List <DisbursementDetail> >();
foreach (var item in retrieval.RetrievalDetails)
{
ddDict.Add(item.ItemCode, new List <DisbursementDetail>());
}
if (disbursementDAO.SearchDbmByStatus("allocating").Count == 0)
{
foreach (var item in disbursementDAO.SearchDbmByStatus("disbursing"))
{
ddList.AddRange(disbursementDetailsDAO.SearchDDByDCode(item.DisbursementCode));
}
}
else
{
foreach (var item in disbursementDAO.SearchDbmByStatus("allocating"))
{
ddList.AddRange(disbursementDetailsDAO.SearchDDByDCode(item.DisbursementCode));
}
}
foreach (var item in ddList)
{
ddDict[item.ItemCode].Add(item);
}
return(ddDict);
}
public Retrieval GetCurrentRetrieval()
{
Retrieval retrieval = retrievalDAO.ListRetrievalByStatus("processing").FirstOrDefault();
//Retrieval rTest = retrievalList.FirstOrDefault();
if (retrieval == null)
{
if (GetDisbursingDisbursements().Count == 0)
{
retrieval = new Retrieval();
retrieval.RetrievalDetails = new List <RetrievalDetail>();
retrieval.RetrievalCode = "RT" + DateTime.Now.ToString("yyMMddHHmmssfff");
retrieval.Status = "processing";
//retrieval.UserName = "******";
retrieval.DateRetrieved = DateTime.Today;
//retrieval.UserName = Identity.User;
//retrieval.DateRetrieved = DateTime.Now;
retrieval = CreateRetrievalDetails(retrieval);
retrievalDAO.AddRetrieval(retrieval);
return(retrieval);
}
return(null);
}
else
{
Retrieval newRetrieval = new Retrieval();
newRetrieval.RetrievalCode = retrieval.RetrievalCode;
newRetrieval.Status = retrieval.Status;
newRetrieval.DateRetrieved = retrieval.DateRetrieved;
newRetrieval.RetrievalDetails = new List <RetrievalDetail>();
newRetrieval.RetrievalDetails = retrievalDetailsDAO.ListRetrievalDetailsByRetrievalCode(newRetrieval.RetrievalCode);
return(newRetrieval);
}
}
/// <summary>
/// GetRetrievalDetail
/// </summary>
/// <param name="RetID">Retrieval ID</param>
/// <returns></returns>
public List <ProcessRetSuccess> getRetrievalDetail(string RetID)
{
int retid = Convert.ToInt32(RetID);
Retrieval ret = ctx.Retrieval.Where(x => x.RetID == retid).FirstOrDefault();
List <RetrievalDetail> retDetailList = ctx.RetrievalDetail.Where(x => x.RetID == retid).ToList();
List <ProcessRetSuccess> retSuccessList = new List <ProcessRetSuccess>();
foreach (RetrievalDetail retDetail in retDetailList)
{
Item i = ctx.Item.Where(x => x.ItemID == retDetail.ItemID).FirstOrDefault();
ProcessRetSuccess retSuccess = new ProcessRetSuccess();
retSuccess.Date = ret.Date.ToString();
retSuccess.Bin = i.Bin;
retSuccess.ItemID = i.ItemID;
retSuccess.ItemName = i.ItemName;
retSuccess.TotalQty = (int)retDetail.RequestQty;
if (retDetail.ActualQty != null)
{
retSuccess.ActualQty = (int)retDetail.ActualQty;
}
retSuccessList.Add(retSuccess);
}
return(retSuccessList);
}
/// <summary>
/// Submit
/// </summary>
/// <param name="retDetailList">RetrievalDetail List (RetID, ItemID, ActualQty)</param>
/// <returns></returns>
public bool submit(List <RetrievalDetail> retDetailList)
{
bool result = true;
foreach (RetrievalDetail retDetail in retDetailList)
{
//update actual quantity of retrieval detail
RetrievalDetail retDetailSearch = ctx.RetrievalDetail.Where(x => x.RetID == retDetail.RetID && x.ItemID == retDetail.ItemID).FirstOrDefault();
retDetailSearch.ActualQty = retDetail.ActualQty;
}
//update status of retrieval to "Retrieved"
int retid = (int)retDetailList.First().RetID;
Retrieval ret = ctx.Retrieval.Where(x => x.RetID == retid).FirstOrDefault();
ret.Status = "RETRIEVED";
try
{
ctx.SaveChanges();
}
catch
{
result = false;
}
return(result);
}
internal void SetRetrevalAsRetreved(int retrId)
{
Retrieval ret = db.Retrievals.Where(r => r.RetrievalID == retrId).FirstOrDefault();
ret.IsCollected = true;
db.SaveChanges();
}
public Retrieval CreateRetrievalDetails(Retrieval retrieval)
{
List <RequestDetail> rdList = this.GetNotDisbursedRequestDetailList();
Dictionary <String, RetrievalDetail> retrievalList = new Dictionary <string, RetrievalDetail>();
foreach (RequestDetail rd in rdList)
{
if (retrievalList.ContainsKey(rd.ItemCode))
{
retrievalList[rd.ItemCode].QuantityNeeded += rd.RemainingQuant;
}
else
{
retrievalList.Add(rd.ItemCode, new RetrievalDetail());
retrievalList[rd.ItemCode].ItemCode = rd.ItemCode;
retrievalList[rd.ItemCode].RetrievalCode = retrieval.RetrievalCode;
retrievalList[rd.ItemCode].QuantityNeeded = rd.RemainingQuant;
}
}
if (retrievalList != null)
{
foreach (var item in retrievalList)
{
int stock = (int)stationeryDAO.GetStationery(item.Value.ItemCode).Stock;
item.Value.QuantityRetrieved = GetMaxRetrieved(item.Value);
retrieval.RetrievalDetails.Add(item.Value);
}
}
return(retrieval);
}
public virtual void Delete(Guid id)
{
var retrieval = Retrieval.ForEntity <TEntity>(id);
var entity = Client.Retrieve(retrieval);
Client.Delete(entity);
}
public IActionResult Post([FromBody] List <RetrievalDetailsAPI> retrievalDetailsList)
{
List <RetrievalDetailsAPI> list = retrievalDetailsList;
bool status = true;
foreach (RetrievalDetailsAPI rd in list)
{
int rtDetailsId = rd.RetrievalDetailsId;
int actualRetQty = rd.ActualRetrievedQty;
if (actualRetQty > 0)
{
RetrievalDetails rtd = rs.FindRetDetailsByRetDetailsId(rtDetailsId);
rs.UpdateRetrievedQty(rtd, actualRetQty);
}
else
{
status = false;
}
}
if (status)
{
Retrieval retrieval = rs.FindRetById(retrievalDetailsList.First().RetrievalId);
rs.UpdateRetStatus(retrieval);
return(Ok(retrievalDetailsList));
}
else
{
return(NotFound());
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
if (sClerkCtrl.GetDisbursementsByStatus("allocating").Count != 0)
{
lvRetrievalList.Enabled = false;
btnTickAll.Visible = false;
lblNoData.Text = "Retrieval has been confirmed, please proceed to allocation.";
}
retrieval = sClerkCtrl.GetCurrentRetrieval();//Context.User.Identity.GetUserName()
if (retrieval == null)
{
btnReset.Visible = false;
btnNext.Text = "Proceed to Disbursement Generation>";
btnTickAll.Visible = false;
lblNoData.Text = "There is no retrieval at the moment. You may need to complete all current disbursement to get new retrieval.";
}
else
{
lblRetrievalCode.Text = retrieval.RetrievalCode;
lblRetrievalDate.Text = ((DateTime)retrieval.DateRetrieved).ToString("dd MMM yyyy");
rdList = retrieval.RetrievalDetails.ToList <RetrievalDetail>();
BindGrid();
}
//lblCreatedBy.Text = Master.GetEmployeeName(retrieval.UserName) ;
}
}
public bool UpdateRetrieval(Retrieval r1)
{
try
{
foreach (RequisitionDetail rd in r1.RequisitionDetails) //Check for sufficient balance in stock
{
RequisitionDetail i = rdrepo.GetRequisitionDetailById(rd.Id);
Transaction t = trepo.GetLatestTransactionByProductId(i.ProductId);
if (rd.QtyDisbursed > t.Balance)
{
throw new Exception("Unable to update retrieval due to insufficient stocks");
}
}
/* if there is insufficient stocks based on transactions, error will be thrown, bottom code will not execute, retrieval form will not be updated */
DateTime dateTime = DateTime.UtcNow.Date;
DateTimeOffset dt = new DateTimeOffset(dateTime, TimeSpan.Zero).ToUniversalTime();
r1.RetrievedDate = dt.ToUnixTimeMilliseconds();
retrivrepo.UpdateRetrieval(r1);
foreach (RequisitionDetail rd in r1.RequisitionDetails)
{
rdrepo.UpdateRequsitionDetail(rd);
if (r1.Status == Status.RetrievalStatus.retrieved)
{
UpdateStockCardUponFinaliseRetrieval(rd, r1);
}
}
return(true);
}
catch (Exception exception)
{
throw exception;
}
}
/// <summary>
/// Update Retrieval data to Retrieval Table according to the Retrieval Parameter
/// Return Constants.DB_STATUS
/// </summary>
/// <param name="retrieval"></param>
/// <returns></returns>
public Constants.DB_STATUS Update(Retrieval retrieval)
{
Constants.DB_STATUS status = Constants.DB_STATUS.UNKNOWN;
try
{
Retrieval retrievalObj = inventory.Retrievals.Where(rObj => rObj.Id == retrieval.Id).First();
Employee createdBy = inventory.Employees.Where(e => e.Id == retrieval.CreatedBy.Id).First();
retrievalObj.Id = retrieval.Id;
retrievalObj.CreatedBy = createdBy;
retrievalObj.CreatedDate = retrieval.CreatedDate;
foreach (RetrievalDetail retrievalDetail in retrieval.RetrievalDetails)
{
this.Update(retrievalDetail);
}
inventory.SaveChanges();
status = Constants.DB_STATUS.SUCCESSFULL;
}
catch (Exception e)
{
status = Constants.DB_STATUS.FAILED;
}
return(status);
}
static async Task Main(string[] args)
{
await Retrieval.GetAlleClienten();
await Retrieval.Get1Client();
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettingsJP.json", optional: true, reloadOnChange: true);
var expFolder = builder.Build().GetSection("AppSettings").GetSection("ExportFolderFromClientApp").Value;
var expFilePut = builder.Build().GetSection("AppSettings").GetSection("ExportFilePut").Value;
var expFilePost = builder.Build().GetSection("AppSettings").GetSection("ExportFilePost").Value;
await PostPutDel.PutOrPost1Client(Mode.Post, expFolder, expFilePost);
await PostPutDel.PutOrPost1Client(Mode.Put, expFolder, expFilePut);
await PostPutDel.Delete1Client();
//----------------------------------------------------------
Console.Write("\nEinde Client Applic, druk op toets");
Console.ReadKey();
}
//Overall page
protected void Page_Load(object sender, EventArgs e)
{
if (!Context.User.IsInRole("Store Clerk"))
{
Response.Redirect("~/ErrorPages/Unauthorised");
}
else
{
storeClerkId = (int)Session["employeeId"];
storeClerk = myBz.FindEmpById(storeClerkId);
stkAdjList = (List <StockAdjustment>)Session["StockAdjustment"];
PanelMessage.Visible = false;
retrieval = myBz.FindRetrListByEmplIdAndStatus(storeClerkId, "Allocating").FirstOrDefault();
if (retrieval != null)
{
int retrId = retrieval.RetrievalId;
retrDetList = myBz.FindRetrDetByRetrId(retrId);
retrDetList.Sort((x, y) => GetStatus(y.ItemCode).CompareTo(GetStatus(x.ItemCode)));
if (!IsPostBack)
{
gvAllocation.DataSource = retrDetList;
gvAllocation.DataBind();
}
}
else
{
PanelMessage.Visible = true;
PanelAll.Visible = false;
}
}
}
public Constants.ACTION_STATUS SetDeliveryDate(int retrievalNo, DateTime deliveryDate)
{
Constants.ACTION_STATUS setStatus = Constants.ACTION_STATUS.UNKNOWN;
Retrieval retrieval = retrievalList.Find(delegate(Retrieval r) { return(r.Id == retrievalNo); });
foreach (RetrievalDetail retrievalDetail in retrieval.RetrievalDetails)
{
Requisition requisition = new Requisition();
requisition.Id = retrievalDetail.Requisition.Id;
requisition = requisitionBroker.GetRequisition(requisition);
RequisitionCollectionDetail requisitionCollectionDetail = requisitionCollectionBroker.GetRequisitionCollectionDetail(requisition);
RequisitionCollection requisitionCollection = new RequisitionCollection();
requisitionCollection.Id = requisitionCollectionDetail.RequisitionCollection.Id;
requisitionCollection = requisitionCollectionBroker.GetRequisitionCollection(requisitionCollection);
requisitionCollection.DeliveryDate = DateTime.Now;
requisitionCollection.DeliveryBy = Util.GetEmployee(employeeBroker);
requisitionCollectionBroker.Update(requisitionCollection);
}
return(setStatus);
}
public List <WCF_RetrievalDetail> GetProcessingRetrievalDetails(String email, String password)
{
if (loginService.ValidateUser(email, password))
{
if (sClerkCtrl.GetDisbursementsByStatus("allocating").Count == 0)
{
Retrieval r = sClerkCtrl.GetCurrentRetrieval();
if (r == null)
{
return(null);
}
else
{
List <RetrievalDetail> rdList = r.RetrievalDetails.ToList <RetrievalDetail>();
List <WCF_RetrievalDetail> wrdList = new List <WCF_RetrievalDetail>();
foreach (var item in rdList)
{
WCF_RetrievalDetail wrd = new WCF_RetrievalDetail(item.RetrievalCode, sClerkCtrl.GetStationeryByCode(item.ItemCode).Description, item.QuantityRetrieved.ToString(), item.QuantityNeeded.ToString(), item.Notes, r.Status, r.DateRetrieved == null ? "" : ((DateTime)r.DateRetrieved).ToString("dd MMM yyyy"), sClerkCtrl.GetStationeryByCode(item.ItemCode).Stock.ToString(), sClerkCtrl.GetStationeryByCode(item.ItemCode).Location, item.ItemCode);
wrdList.Add(wrd);
}
return(wrdList);
}
}
else
{
return(null);
}
}
else
{
return(null);
}
}
public Retrieval SaveRetrieval(Retrieval r, List <RetrievalDetail> rdList)
{
r.RetrievalDetails = rdList;
db.Retrievals.Add(r);
db.SaveChanges();
return(r);
}
/// <summary>
/// Update RetrievalDetail data to RetrievalDetail Table according to the RetrievalDetail Parameter
/// Return Constants.DB_STATUS
/// </summary>
/// <param name="retrievalDetail"></param>
/// <returns></returns>
public Constants.DB_STATUS Update(RetrievalDetail retrievalDetail)
{
Constants.DB_STATUS status = Constants.DB_STATUS.UNKNOWN;
try
{
RetrievalDetail rDetail = inventory.RetrievalDetails.Where(rObj => rObj.Id == retrievalDetail.Id).First();
if (!rDetail.Equals(null))
{
retrieval = inventory.Retrievals.Where(r => r.Id == retrievalDetail.Retrieval.Id).First();
Item item = inventory.Items.Where(i => i.Id == retrievalDetail.Item.Id).First();
Department department = inventory.Departments.Where(d => d.Id == retrievalDetail.Department.Id).First();
rDetail.Retrieval = retrieval;
rDetail.Item = item;
rDetail.Department = department;
rDetail.NeededQty = retrievalDetail.NeededQty;
rDetail.ActualQty = retrievalDetail.ActualQty;
inventory.SaveChanges();
status = Constants.DB_STATUS.SUCCESSFULL;
}
}
catch (Exception e)
{
status = Constants.DB_STATUS.FAILED;
}
return(status);
}
// GET (or POST): /Requisiton/StationeryRetrieval
public ActionResult StationeryRetrieval(string rid, string message)
{
Retrieval r = retrievalService.FindRetrievalById(rid);
StationeryRetrievalViewModel viewModel = new StationeryRetrievalViewModel();
if (TempData["message"] != null)
{
ViewBag.Message = TempData["message"].ToString();
}
else
{
ViewBag.Message = message;
}
try
{
viewModel.StatusId = r.Status.StatusId;
viewModel.RetrievalID = r.RetrievalId;
viewModel.CreatedBy = r.CreatedBy != null?String.Format("{0} {1}", r.CreatedBy.FirstName, r.CreatedBy.LastName) : "";
viewModel.CreatedOn = String.Format("{0} {1}", r.CreatedDateTime.ToShortDateString(), r.CreatedDateTime.ToShortTimeString());
viewModel.UpdatedBy = r.UpdatedBy != null?String.Format("{0} {1}", r.UpdatedBy.FirstName, r.UpdatedBy.LastName) : "";
viewModel.UpdatedOn = r.UpdatedDateTime != null?String.Format("{0} {1}", r.UpdatedDateTime.Value.ToShortDateString(), r.UpdatedDateTime.Value.ToShortTimeString()) : "";
}
catch
{
return(new HttpStatusCodeResult(400));
}
return(View(viewModel));
}
public void FindDisbursementsByRetrievalIdTest()
{
//Arrange
//get retrival object
Retrieval retrieval = context.Retrieval.Where(x => x.RetrievalId == "TEST").First();
//save 2 disbursement objects
Disbursement a = new Disbursement();
a.DisbursementId = IdService.GetNewDisbursementId(context);
a.Retrieval = retrieval;
a.CreatedDateTime = DateTime.Now;
disbursementService.Save(a);
Disbursement b = new Disbursement();
b.DisbursementId = IdService.GetNewDisbursementId(context);
b.Retrieval = retrieval;
b.CreatedDateTime = DateTime.Now;
disbursementService.Save(b);
//find any existing data in disbursement where RetrievalId = TESTER and add 2 more
int expected = context.Disbursement.Where(x => x.Retrieval.RetrievalId == "TEST").Count();
//Act
var result = disbursementService.FindDisbursementsByRetrievalId(retrieval.RetrievalId).Count;
//Assert
Assert.AreEqual(expected, result);
//Delete dummy test objects in TestCleanUp
}
public List <Retrieval> GetItemsAndQty()
{
List <Retrieval> retrievals = new List <Retrieval>();
SqlConnection conn = connection;
conn.Open();
string sql = @"select list.itemid as itemid, SUM(list.NeededQty) as sum from (select i.ID as itemid,r.ID as reqid,ir.NeededQty
from Request r, ItemRequest ir, Item i
where r.Status in ('Disbursed', 'Approved') and convert(date,r.DateTime) < CONVERT(date, @date) and r.ID = ir.RequestID and ir.ItemID = i.id) as list group by list.itemid";
SqlCommand command = new SqlCommand(sql, conn);
command.Parameters.AddWithValue("@date", DateUtils.GetLastRequestDate());
SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
Retrieval r = new Retrieval();
r.ItemId = (string)reader["ItemID"];
r.Qty = (int)reader["sum"];
retrievals.Add(r);
}
reader.Close();
conn.Close();
return(retrievals);
}
public static Retrieval GetRetrievalById(int id)
{
Team10ADModel context = new Team10ADModel();
Retrieval ret = context.Retrievals.Where(x => x.RetrievalID == id).First();
return(ret);
}
public ActionResult DeleteConfirmed(int id)
{
Retrieval retrieval = db.Retrievals.Find(id);
db.Retrievals.Remove(retrieval);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IEnumerable <TRow> Seek(SeekTarget <TIndexKey> seekTarget, Retrieval retrieval)
{
seekTarget.Prepare(_map.KeyComparer, retrieval);
return(QueryAnalyser.Pick(seekTarget, _map.Count,
() => _map.SeekMany(seekTarget.Keys !).Select(s => s.Value.Row),
() => RangedScan(seekTarget, retrieval.Reverse)));
}
public void Create(Retrieval ret)
{
if (ret.RetrievalID == 0)
{
db.Retrievals.Add(ret);
}
db.SaveChanges();
}
public int UpdateRetrieval(Retrieval retrieval)
{
Retrieval r = context.Retrievals.Where(x => x.RetrievalId == retrieval.RetrievalId).FirstOrDefault();
r.Status = retrieval.Status;
r.Remark = retrieval.Remark;
return(context.SaveChanges());
}
protected void btnReset_Click(object sender, EventArgs e)
{
Retrieval r = sClerkCtrl.ResetRetrieval(sClerkCtrl.GetCurrentRetrieval());
rdList = sClerkCtrl.GetCurrentRetrieval().RetrievalDetails.ToList <RetrievalDetail>();
BindGrid();
}
public int UpdateRetrival(Retrieval r)
{
using (EntityModel em = new EntityModel())
{
em.Entry(r).State = EntityState.Modified;
return(em.SaveChanges());
}
}
