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()); } }