public void UpdateAndSave(int requisitionId, FormCollection form)
{
var rds = (from rqDetail in db.RequisitionDetails
where rqDetail.RequisitionID == requisitionId
select rqDetail).ToList();
foreach (var rd in rds)
{
db.RequisitionDetails.Remove(rd);
db.SaveChanges();
}
var Items = form.GetValues("Item");
var Quantities = form.GetValues("Quantity");
for (int i = 0; i < Items.Count(); i++)
{
RequisitionDetail newReqDetail = new RequisitionDetail
{
RequisitionID = requisitionId,
ItemID = Int32.Parse(Items[i]),
Quantity = Int32.Parse(Quantities[i]),
QuantityReceived = 0
};
db.RequisitionDetails.Add(newReqDetail);
db.SaveChanges();
}
}
//Create the requisition
protected void Confirm_Click(object sender, EventArgs e)
{
if (Cart.Rows.Count == 0)
{
Msg.Text = "You must select at least one item.";
}
else
{
cartitem = (List <RaisedItem>)Session["session"];
int isissueBy = Profile.EmpNo;
dateIssue = DateTime.Today;
string status = "Pending";
List <RequisitionDetail> detailList = new List <RequisitionDetail>();
foreach (RaisedItem k in cartitem)
{
RequisitionDetail rd = new RequisitionDetail();
rd.ItemNo = k.ItemNo;
rd.Qty = Convert.ToInt32(k.quantity);
detailList.Add(rd);
}
EmployeeController.RaisedRequisition(isissueBy, dateIssue, status, detailList);
Session["success"] = dateIssue;
Response.Redirect("RaisedRequisitionSuccessPage.aspx");
Session.Remove("session");
Msg.Text = "Success!";
}
}
public RequisitionDetailPayload(RequisitionDetail rq)
{
RequisitionDetailID = rq.RequisitionDetailsID;
ItemName = rq.Item.ItemName;
Quantity = rq.Quantity;
UnitOfMeasure = rq.Item.UnitOfMeasure;
}
// PENDING MODIFICATION TO METHOD
public RetrievalDTO constructAdHocRetrievalDTO(LoginDTO loginDTO, int requisitionId)
{
List <RetrievalPrepItemDTO> retrievalPrepList = new List <RetrievalPrepItemDTO>();
List <RetrievalItemDTO> retrievalList = new List <RetrievalItemDTO>();
List <RequisitionDetail> preparingRequisitionDetailsFromSelectedRequisition = (List <RequisitionDetail>)requisitionDetailRepo.FindBy(x => x.RequisitionId == requisitionId && x.Status == "PREPARING").ToList();
List <int> stationeriesInPreparingRequisitionDetails = RetrieveStationeryDetailsByRequisitionDetailsList(preparingRequisitionDetailsFromSelectedRequisition).ToList();
foreach (int s in stationeriesInPreparingRequisitionDetails)
{
RetrievalItemDTO rID = new RetrievalItemDTO();
rID.StationeryId = s;
rID.Description = stationeryRepo.FindOneBy(x => x.Id == s).Description;
rID.Location = stationeryRepo.FindOneBy(x => x.Id == s).Bin;
List <RetrievalPrepItemDTO> tempRPIDTO = new List <RetrievalPrepItemDTO>();
List <RequisitionDetail> reqDetailList = (List <RequisitionDetail>)preparingRequisitionDetailsFromSelectedRequisition.FindAll(x => x.StationeryId == rID.StationeryId).ToList();
foreach (RequisitionDetail reDList in reqDetailList)
{
RetrievalPrepItemDTO rPID = new RetrievalPrepItemDTO();
rPID.ReqStationery = stationeryRepo.FindOneBy(x => x.Id == reDList.StationeryId);
rPID.ReqDetail = reDList;
rPID.Req = requisitionRepo.FindOneBy(x => x.Id == requisitionId);
rPID.ReqOwner = employeeRepo.FindOneBy(x => x.Id == rPID.Req.EmployeeId);
int deptId = rPID.ReqOwner.DepartmentId;
rPID.ReqDepartmentRep = employeeRepo.FindOneBy(x => x.RoleId == (int)Enums.Roles.DepartmentRepresentative && x.DepartmentId == deptId);
rPID.ReqDepartment = departmentRepo.FindOneBy(x => x.Id == deptId);
rPID.ReqCollectionPoint = collectionPointRepo.FindOneBy(x => x.Id == rPID.ReqDepartment.CollectionPointId);
tempRPIDTO.Add(rPID);
}
rID.RetrievalPrepItemList = tempRPIDTO;
int count = 0;
foreach (RetrievalPrepItemDTO retriPrepItem in tempRPIDTO)
{
RequisitionDetail x = retriPrepItem.ReqDetail;
int y = x.QuantityOrdered;
count = count + y;
}
rID.NeededQuantity = count;
rID.RetrievedQty = count;
retrievalList.Add(rID);
}
RetrievalDTO retrieval = new RetrievalDTO();
retrieval.RetrievalDate = System.DateTime.Now.ToString("yyyy-MM-dd");
Employee clerk = (Employee)employeeRepo.FindOneBy(x => x.Id == loginDTO.EmployeeId);
if (clerk.Name == null)
{
retrieval.GeneratedBy = null;
}
else
{
retrieval.GeneratedBy = clerk.Name;
}
retrieval.RetrievalItem = retrievalList;
return(retrieval);
}
private RequisitionDetail getEntityByModel(RequisitionDetailModel model)
{
if (model == null)
{
return(null);
}
RequisitionDetail entity = new RequisitionDetail();
if (model.Id == 0)
{
entity.CreateBy = AuthenticationHelper.UserId;
entity.CreateDate = DateTime.Now;
}
else
{
entity.CreateBy = model.CreateBy;
entity.CreateDate = model.CreateDate;
}
entity.Id = model.Id;
entity.ItemId = model.ItemId;
entity.NeedByDate = model.NeedByDate;
entity.Price = model.Price;
entity.Quantity = model.Quantity;
entity.RequisitionId = model.RequisitionId;
entity.Status = model.Status;
entity.VendorId = model.VendorId;
entity.VendorSiteId = model.VendorSiteId;
return(entity);
}
//supplementary method (not declared in interface)
private void AddDisbursementDetailToTempList(int?currentDisbursementListId, RequisitionDetail reqDetails, RetrievalList retrievalList, List <DisbursementDetail> tempDisbursementDetailList)
{
DisbursementDetail newDisbursementDetail = new DisbursementDetail();
newDisbursementDetail.DisbursementListId = currentDisbursementListId;
newDisbursementDetail.ItemNo = reqDetails.ItemNo;
var x = (from y in retrievalList.itemsToRetrieve
where y.itemNo == newDisbursementDetail.ItemNo
select y).SingleOrDefault();
if (x != null)
{
if (x.collectedQuantity >= reqDetails.OutstandingQuantity && x.collectedQuantity != 0)
{
newDisbursementDetail.PreparedQuantity = reqDetails.OutstandingQuantity;
newDisbursementDetail.DeliveredQuantity = newDisbursementDetail.PreparedQuantity;
x.collectedQuantity = x.collectedQuantity - (int)reqDetails.OutstandingQuantity;
}
else
{
newDisbursementDetail.PreparedQuantity = x.collectedQuantity;
newDisbursementDetail.DeliveredQuantity = newDisbursementDetail.PreparedQuantity;
x.collectedQuantity = x.collectedQuantity - (int)newDisbursementDetail.PreparedQuantity;
}
tempDisbursementDetailList.Add(newDisbursementDetail);
}
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
StaffRequisition requisition = new StaffRequisition();
List <RequisitionDetail> requisitiondetails = new List <RequisitionDetail>();
requisition.StaffRequisitionId = lblRequisition.Text;
requisition.DepartmentId = user.DepartmentId;
requisition.StaffId = user.StaffId;
requisition.CreateDate = Convert.ToDateTime(lblDate.Text);
requisition.Status = "Pending";
foreach (GridViewRow row in gv_Items.Rows)
{
RequisitionDetail details = new RequisitionDetail();
details.StaffReqisitionId = lblRequisition.Text;
details.ItemId = gv_Items.DataKeys[row.RowIndex].Value.ToString();
details.Quantity = Convert.ToInt32(row.Cells[3].Text);
requisitiondetails.Add(details);
}
viewStationeryRequisitionController.saveDataToRequisition(requisition, requisitiondetails);
dt = null;
gv_Items.DataSource = dt;
gv_Items.DataBind();
btnSubmit.CssClass = "btn btn-success disabled";
btnSubmit.Attributes.Add("disabled", "disabled");
btnSubmit.Text = "Sent";
txtQuantity.Text = "";
lblUOM.Text = "";
BindDropDownList();
SendMailToDepartmentHead();
ScriptManager.RegisterClientScriptBlock(this, this.GetType(), "alertMessage",
"alert('Submit successfully') ;window.location = '" + "ViewStationaryRequisitionList.aspx';", true);
}
public List <OutstandingRequisitionRow> getOutstandingRequisitionRows()
{
List <OutstandingRequisitionRow> orrs = new List <OutstandingRequisitionRow>();
List <OutstandingRequisitionView> orvs = context.OutstandingRequisitionViews.ToList();
foreach (OutstandingRequisitionView orv in orvs)
{
// get requisition detail related to outstanding requisition
RequisitionDetail rd = context.RequisitionDetails.First(r => r.RequisitionDetailsID == orv.RequisitionDetailsID);
// get order supplier details related to outstanding requisitions
List <OrderSupplierDetail> osds = getOrdersServingOutstandingRequisitions(orv.RequisitionDetailsID);
foreach (OrderSupplierDetail osd in osds)
{
OutstandingRequisitionRow orr = new OutstandingRequisitionRow();
orr.OutstandingRequisitionView = orv;
orr.RequisitionDetail = rd;
orr.OrderSupplierDetail = osd;
orrs.Add(orr);
}
}
orrs = orrs.OrderBy(o => o.RequisitionDetail.Requisition.Requester.DepartmentID)
.OrderBy(o => o.RequisitionDetail.Requisition.RequestedDate)
.ToList();
return(orrs);
}
public void CreateRequisition(string userId)
{
List <EmployeeCart> cartList = dbcontext.employeeCarts.Where(x => x.EmployeeId == userId).ToList();
Employee emp = deptService.findEmployeeById(userId);
Requisition newRequisition = new Requisition(emp.Departments.DeptCode);
newRequisition.status = ReqStatus.AWAITING_APPROVAL;
Employee approver = deptService.setApprover(userId);
newRequisition.ApprovedEmployee = approver;
newRequisition.ApprovedEmployeeId = approver.Id;
newRequisition.Employee = emp;
newRequisition.EmployeeId = emp.Id;
newRequisition.DepartmentId = emp.Departments.Id;
foreach (var i in cartList)
{
/* Inventory inv = dbcontext.inventories.Where(x => x.Id == i.Id).FirstOrDefault();*/
RequisitionDetail requisitionDetail = new RequisitionDetail();
requisitionDetail.Id = Guid.NewGuid().ToString();
requisitionDetail.RequisitionId = newRequisition.Id;
requisitionDetail.Inventory = i.Inventory;
requisitionDetail.RequestedQty = i.Qty;
dbcontext.Add(requisitionDetail);
}
dbcontext.Add(newRequisition);
dbcontext.employeeCarts.RemoveRange(cartList);
dbcontext.SaveChanges();
notificationService.sendNotification(NotificationType.REQUISITION, newRequisition, null, null);
}
public void resubmitRequisitionDetails(string requisitionDetailsId, int quantity)
{
RequisitionDetail rd = context.RequisitionDetails.Where(x => x.RequisitionDetailsID == requisitionDetailsId).FirstOrDefault();
rd.ItemQuantity = quantity;
context.SaveChanges();
}
public void UpdateRequisitionDetailsAfterRetrieval(int qtyRetrieved, List <int> requisitionDetailIds)
{
List <RequisitionDetail> requisitionDetails = GetSortedRequisitionDetailsListFromListOfIds(requisitionDetailIds);
int qtyToDisburse = qtyRetrieved;
foreach (RequisitionDetail rd in requisitionDetails)
{
RequisitionDetail rqD = (RequisitionDetail)requisitionDetailRepo.FindById(rd.Id);
if (qtyToDisburse >= rd.QuantityOrdered)
{
//can give all
rqD.QuantityDelivered = rd.QuantityOrdered;
qtyToDisburse = qtyToDisburse - rd.QuantityOrdered;
}
else //qtyToDisburse < ordered
{
//can give some
rqD.QuantityDelivered = qtyToDisburse;
qtyToDisburse = 0;
}
//update status to PENDING COLLECTION and update db
rqD.Status = RequisitionDetailStatusEnum.PENDING_COLLECTION.ToString();
requisitionDetailRepo.Update(rqD);
}
}
private void DistributeIncomingGoodsAmongWaitlistApprovedRds(int qty, List <RequisitionDetail> requisitionDetails)
{
int qtyToAllocate = qty;
int rdIndex = 0;
while (qtyToAllocate != 0 && rdIndex < requisitionDetails.Count())
{
RequisitionDetail rd = requisitionDetails[rdIndex];
if (qtyToAllocate >= rd.QuantityOrdered) //enough for this record
{
qtyToAllocate = qtyToAllocate - rd.QuantityOrdered;
rd.Status = RequisitionDetailStatusEnum.PREPARING.ToString();
}
else
{
int diff = rd.QuantityOrdered - qtyToAllocate;
rd.QuantityOrdered = qtyToAllocate; //update qtyOrdered column
qtyToAllocate = 0; //after this item exits the loop
rd.Status = RequisitionDetailStatusEnum.PREPARING.ToString();
createNewRequisitionDetail(diff, rd.RequisitionId, rd.StationeryId, RequisitionDetailStatusEnum.WAITLIST_APPROVED);
}
requisitionDetailRepo.Update(rd); //persist chnages in db
rdIndex++;
}
}
public string makeRequisitionDetail(JToken list, int RequisitionId)
{
using (TransactionScope scope = new TransactionScope())
{
try
{
foreach (JToken j in list)
{
RequisitionDetail reqD = new RequisitionDetail();
reqD.description = j.Value <string>("description");
reqD.inventoryCode = j.Value <string>("itemId");
reqD.quantity = j.Value <int>("Quantity");
reqD.requisitionID = RequisitionId;
db.RequisitionDetails.Add(reqD);
}
db.SaveChanges();
scope.Complete();
return("success");
}
catch (Exception)
{
return("fail");
}
}
}
//Update
// for editing of requisition quantities
public void editRequisitionDetailQty(int reqDetailId, int qty)
{
RequisitionDetail rd = context.RequisitionDetails.First(rdt => rdt.RequisitionDetailsID == reqDetailId);
rd.Quantity = qty;
context.SaveChanges();
}
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;
}
}
public void deleteRequisitionDetail(int reqDetailId)
{
RequisitionDetail rd = context.RequisitionDetails.First(rdt => rdt.RequisitionDetailsID == reqDetailId);
context.RequisitionDetails.Remove(rd);
context.SaveChanges();
}
public async Task <IActionResult> PutRequisitionDetail([FromRoute] int id, [FromBody] RequisitionDetail requisitionDetail)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != requisitionDetail.RequisitionDetailId)
{
return(BadRequest());
}
_context.Entry(requisitionDetail).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RequisitionDetailExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Show one requisition according to requisitionId parameter
/// Created By:JinChengCheng
/// Created Date:26-01-2012
/// Modified By:
/// Modified Date:
/// Modification Reason:
/// Modified By:
/// Modified Date:
/// Modification Reason:
/// </summary>
/// <param name="requisitionId"></param>
/// <returns>The return type of this method is datatable.</returns>
public DataTable getRequisition(string requisitionId)
{
//requisition = new Requisition();
//requisition.Id = requisitionId;
//requisition = RequisitionList.Find(delegate(Requisition req) { return requisitionId == req.Id; });
requisitionDetail = new RequisitionDetail(0, new Requisition(), new Item(), 0, 0);
requisitionDetail.Requisition.Id = requisitionId;
requisitionDetail = requisitionBroker.GetRequisitionDetail(requisitionDetail);
dt = new DataTable();
dt.Columns.Add("requisitionId");
dt.Columns.Add("requisitionDate/Time");
dt.Columns.Add("status");
dt.Columns.Add("remainingQty");
dt.Columns.Add("remarks");
dt.Columns.Add("deptCode");
dt.Columns.Add("deptName");
dt.Columns.Add("empName");
dt.Columns.Add("empNumber");
dt.Columns.Add("empEmail");
dr = dt.NewRow();
dr["requisitionId"] = requisition.Id;
dr["requisitionDate/Time"] = requisition.CreatedDate;
dr["status"] = requisition.Status;
dr["remainingQty"] = requisitionDetail.Qty - requisitionDetail.DeliveredQty;
dr["remarks"] = requisition.Remarks;
dr["deptCode"] = requisition.Department.Id;
dr["deptName"] = requisition.Department.Name;
dr["empName"] = requisition.CreatedBy.Name;
dr["empNumber"] = requisition.CreatedBy.Id;
dr["empEmail"] = requisition.CreatedBy.Email;
dt.Rows.Add(dr);
return(dt);
}
protected void gvStationeryCatalogue_RowCommand(object sender, GridViewCommandEventArgs e)
{
if (e.CommandName == "AddToRequest")
{
requisitionDetails = Session["RequestsDetails"] as List <RequisitionDetail>;
bool duplicate = false;
Stationery s = iss.FindStationeryById(e.CommandArgument.ToString());
foreach (RequisitionDetail rd in requisitionDetails)
{
if (rd.ItemCode == s.ItemCode)
{
duplicate = true;
break;
}
}
if (!duplicate)
{
RequisitionDetail rd = new RequisitionDetail()
{
ItemCode = s.ItemCode,
QuantityRequest = 1
};
requisitionDetails.Add(rd);
Session["RequestsDetails"] = requisitionDetails;
lblItem.Text = s.Description + " is added to your Requisition Form";
}
else
{
lblItem.Text = s.Description + " has already been added to your Requisition Form.";
}
}
}
public void updateRequisitionItem(RequisitionDetail requisitionDetail)
{
RequisitionDetail oldRequisitionDetail = context.RequisitionDetails.Where(x => x.StaffReqisitionId == requisitionDetail.StaffReqisitionId && x.ItemId == requisitionDetail.ItemId).FirstOrDefault();
oldRequisitionDetail.StaffRequisition.Status = StatusType.Pending.ToString();
oldRequisitionDetail.Quantity = requisitionDetail.Quantity;
context.SaveChanges();
}
public RequisitionDetail GetLastStatTransId()
{
using (SSAEntities s = new SSAEntities())
{
RequisitionDetail rd = s.RequisitionDetails.OrderByDescending(x => x.StatTransId).FirstOrDefault();
return(rd);
}
}
public HttpResponseMessage PostRequisitionDetail([FromBody] RequisitionDetail req)
{
db.RequisitionDetails.Add(req);
db.SaveChanges();
var resp = new HttpResponseMessage(HttpStatusCode.OK);
return(resp);
}
//----------------------------------
public int CreateRequisitionDetail(RequisitionDetail r)
{
using (SSAEntities s = new SSAEntities())
{
s.RequisitionDetails.Add(r);
return(s.SaveChanges());
}
}
public void SelectRequisition(Requisition requisition)
{
RequisitionDetail requisitionDetail = new RequisitionDetail();
requisitionDetail.Requisition = requisition;
RequisitionDetail resultRequisitionDetail = requisitionBroker.GetRequisitionDetail(requisitionDetail);
// show on UI
}
public void UpdateRequisitionDetailQuantityRequest(int SI, int q)
{
using (SSAEntities s = new SSAEntities())
{
RequisitionDetail rd = s.RequisitionDetails.Where(x => x.StatTransId == SI).FirstOrDefault();
rd.QuantityRequest = q;
s.SaveChanges();
}
}
//-----------------------------------------
//delete requisitionDetail
public void DeleteRequisitionDetail(int SI)
{
using (SSAEntities s = new SSAEntities())
{
RequisitionDetail r = s.RequisitionDetails.Where(x => x.StatTransId == SI).FirstOrDefault();
s.RequisitionDetails.Remove(r);
s.SaveChanges();
}
}
public RequisitionDetail UpdateRetrievalId(RequisitionDetail rd)
{
dbcontext.RequisitionDetails.Update(rd);
dbcontext.SaveChanges();
return(dbcontext.RequisitionDetails.Include(m => m.Requisition)
.Include(m => m.Product)
.Include(m => m.Retrieval)
.Include(m => m.Retrieval).FirstOrDefault(x => x.Id == rd.Id));
}
public string Update(RequisitionDetail entity)
{
var originalEntity = this.Context.RequisitionDetails.Find(entity.Id);
this.Context.Entry(originalEntity).CurrentValues.SetValues(entity);
this.Context.Entry(originalEntity).State = EntityState.Modified;
this.Commit();
return(entity.Id.ToString());
}
/// <summary>
/// CreateRequisition
/// </summary>
/// <param name="itemList">CartItems List (EmpID, ItemID, Qty)</param>
/// <returns></returns>
public int createRequisition(List <CartItems> itemList)
{
int result = 0;
int ReqID = 0;
if (itemList.FirstOrDefault() != null)
{
//create and add new requisition
Requisition req = new Requisition();
req.EmpID = itemList.First().EmpID;
int empid = itemList.First().EmpID;
req.DeptID = ctx.Employee.Where(x => x.EmpID == empid).First().DeptID;
req.Date = DateTime.Now;
req.StatusID = 1;
ctx.Requisition.Add(req);
ctx.SaveChanges();
//obtain the ReqID of the newly added requisition
List <Requisition> reqList = ctx.Requisition.Where(x => x.EmpID == empid).ToList();
ReqID = reqList.Last().ReqID;
//create and add new requisition details
foreach (CartItems item in itemList)
{
RequisitionDetail reqDetail = new RequisitionDetail();
reqDetail.ReqID = ReqID;
reqDetail.ItemID = item.ItemID;
reqDetail.RequestQty = item.Qty;
ctx.RequisitionDetail.Add(reqDetail);
}
//delete items from request cart
foreach (CartItems item in itemList)
{
CartItems cartItem = ctx.CartItems.Where(x => x.EmpID == item.EmpID && x.ItemID == item.ItemID).FirstOrDefault();
ctx.CartItems.Remove(cartItem);
}
}
int count = ctx.SaveChanges();
if (count > 0)
{
result = ReqID;
}
if (result == ReqID)
{
//send notification:
NotificationController nt = new NotificationController();
nt.sendNotification(1, itemList.First().EmpID, Convert.ToString(ReqID));
}
return(result);
}
public void CancelWaitlistedRequisitionDetail(int requisitionDetailId, int cancelledBy)
{
RequisitionDetail rd = requisitionDetailRepo.FindById(requisitionDetailId);
if (rd.Requisition.EmployeeId == cancelledBy)
{
rd.Status = RequisitionDetailStatusEnum.CANCELLED.ToString();
requisitionDetailRepo.Update(rd);
}
}
