//Create new Requisition with Detials
public static RequisitionModel CreateRequisitionwithDetails(RequisitionModel reqm, List <RequisitionDetailsModel> reqd, out string error)
{
error = "";
LUSSISEntities entities = new LUSSISEntities();
requisition req = new requisition();
List <requisitiondetail> reqlist = new List <requisitiondetail>();
try
{
req.reqid = reqm.Reqid;
req.raisedby = reqm.Raisedby;
req.approvedby = reqm.Approvedby;
req.deptid = reqm.Depid;
req.cpid = reqm.Cpid;
req.status = ConRequisition.Status.PENDING;
req.reqdate = DateTime.Now;
req = entities.requisitions.Add(req);
entities.SaveChanges();
foreach (RequisitionDetailsModel rdm in reqd)
{
requisitiondetail rqd = new requisitiondetail
{
reqid = req.reqid,
itemid = rdm.Itemid,
qty = rdm.Qty
};
rqd = entities.requisitiondetails.Add(rqd);
entities.SaveChanges();
reqlist.Add(rqd);
}
reqm = GetRequisitionByRequisitionId(req.reqid, out error);
NotificationModel nom = new NotificationModel();
nom.Deptid = DepartmentRepo.GetDepartmentByUserid(reqm.Raisedby ?? default(int), out error).Deptid;
nom.Role = ConUser.Role.HOD;
nom.Title = "Requisition Approval";
nom.NotiType = ConNotification.NotiType.RequisitionApproval;
nom.ResID = reqm.Reqid;
nom.Remark = "A new requisition has been raised by " + reqm.Rasiedbyname + "!";
nom = NotificationRepo.CreatNotification(nom, out error);
}
catch (NullReferenceException)
{
error = ConError.Status.NOTFOUND;
}
catch (Exception e)
{
error = e.Message;
}
return(reqm);
}
public IHttpActionResult CreateRequisitionwithDetails(RequisitionModel reqm)
{
string error = "";
RequisitionModel req = RequisitionRepo.CreateRequisitionwithDetails(reqm, reqm.Requisitiondetails, out error);
if (error != "" || req == null)
{
return(Content(HttpStatusCode.BadRequest, error));
}
return(Ok(req));
}
public ActionResult RepairDescription_WithdrawEditPopup(int reqID)
{
Database db = new Database();
RequisitionDAO rqDAO = new RequisitionDAO(db);
RequisitionModel reqModel = rqDAO.FindById(reqID);
db.Close();
ViewBag.REQ = reqModel;
return(View());
}
public ActionResult ApproveRequisition(ApproveRequisitionViewModel viewmodel)
{
string token = GetToken();
UserModel um = GetUser();
RequisitionModel reqm = new RequisitionModel();
NotificationModel nom = new NotificationModel();
try
{
reqm = APIRequisition.GetRequisitionByReqid(viewmodel.ReqID, token, out string error);
reqm.Status = ConRequisition.Status.APPROVED;
reqm.Approvedby = um.Userid;
if (!viewmodel.Approve)
{
reqm.Status = ConRequisition.Status.REJECTED;
nom.Deptid = reqm.Depid;
nom.Role = ConUser.Role.EMPLOYEE;
nom.Title = "Requisition Rejected";
nom.NotiType = ConNotification.NotiType.RejectedRequistion;
nom.ResID = reqm.Reqid;
nom.Remark = "The new requisition has been rejected by the HOD with remark : " + viewmodel.Remark;
nom = APINotification.CreateNoti(token, nom, out error);
nom.Deptid = reqm.Depid;
nom.Role = ConUser.Role.DEPARTMENTREP;
nom.Title = "Requisition Rejected";
nom.NotiType = ConNotification.NotiType.RejectedRequistion;
nom.ResID = reqm.Reqid;
nom.Remark = "The new requisition has been rejected by the HOD with remark : " + viewmodel.Remark;
nom = APINotification.CreateNoti(token, nom, out error);
}
reqm = APIRequisition.UpdateRequisition(reqm, token, out error);
Session["noti"] = true;
Session["notitype"] = "success";
if (viewmodel.Approve)
{
Session["notititle"] = "Requisition Approval";
Session["notimessage"] = "Requisiton is now approved!";
return(RedirectToAction("TrackRequisition", new { id = reqm.Reqid }));
}
Session["notititle"] = "Requisition Rejection";
Session["notimessage"] = "Requisiton is rejected!";
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
return(RedirectToAction("Index", "Error", new { error = ex.Message }));
}
}
public ActionResult Approbation_popup(int reqID)
{
Database db = new Database();
RequisitionDAO reqDAO = new RequisitionDAO(db);
RequisitionModel reqModel = reqDAO.FindById(reqID);
db.Close();
ViewBag.REQ = reqModel;
return(View());
}
//create the requisition
public static RequisitionModel CreateRequisition(RequisitionModel req, out string error)
{
error = "";
bool RaisedByTempHOD = true;
LUSSISEntities entities = new LUSSISEntities();
requisition reqn = new requisition();
try
{
reqn.raisedby = req.Raisedby;
reqn.approvedby = req.Approvedby;
if (req.Approvedby == null || req.Approvedby == 0)
{
reqn.approvedby = req.Raisedby;
RaisedByTempHOD = false;
}
reqn.deptid = req.Depid;
reqn.cpid = req.Cpid;
reqn.status = ConRequisition.Status.PENDING;
reqn.reqdate = DateTime.Now;
reqn = entities.requisitions.Add(reqn);
entities.SaveChanges();
req = GetRequisitionByRequisitionId(reqn.reqid, out error);
if (!RaisedByTempHOD)
{
NotificationModel nom = new NotificationModel();
nom.Deptid = DepartmentRepo.GetDepartmentByUserid(reqn.raisedby ?? default(int), out error).Deptid;
nom.Role = ConUser.Role.HOD;
nom.Title = "Requisition Approval";
nom.NotiType = ConNotification.NotiType.RequisitionApproval;
nom.ResID = reqn.reqid;
nom.Remark = "A new requisition has been raised by " + req.Rasiedbyname + "!";
nom = NotificationRepo.CreatNotification(nom, out error);
}
else
{
req.Status = ConRequisition.Status.APPROVED;
req = UpdateRequisition(req, out error);
}
}
catch (NullReferenceException)
{
error = ConError.Status.NOTFOUND;
}
catch (Exception e)
{
error = e.Message;
}
return(req);
}
private void save(RequisitionModel model)
{
Requisition entity = getEntityByModel(model);
string result = string.Empty;
if (entity.IsValid())
{
if (model.Id > 0)
{
result = service.Update(entity);
}
else
{
result = service.Insert(entity);
}
if (!string.IsNullOrEmpty(result))
{
var savedLines = getRequisitionDetail(result);
if (savedLines.Count() > model.RequisitionDetail.Count())
{
var tobeDeleted = savedLines.Take(savedLines.Count() - model.RequisitionDetail.Count());
foreach (var item in tobeDeleted)
{
service.DeleteRequisitionDetail(item.Id);
}
savedLines = getRequisitionDetail(result);
}
foreach (var detail in model.RequisitionDetail)
{
RequisitionDetail detailEntity = getEntityByModel(detail);
if (detailEntity.IsValid())
{
detailEntity.RequisitionId = Convert.ToInt64(result);
if (savedLines.Count() > 0)
{
detailEntity.Id = savedLines.FirstOrDefault().Id;
savedLines.Remove(savedLines.FirstOrDefault(rec => rec.Id == detailEntity.Id));
service.Update(detailEntity);
}
else
{
service.Insert(detailEntity);
}
}
}
}
}
}
public ActionResult WithdrawDeleting(int reqID, int repID)
{
RequisitionModel reqModel = new RequisitionModel();
reqModel.REQ_ID = reqID;
Database db = new Database();
RequisitionDAO reqDAO = new RequisitionDAO(db);
reqDAO.Delete(reqModel);
db.Close();
return(Redirect("/Services/RepairDescription?repid=" + repID));
}
public async Task <IActionResult> Create([FromBody] RequisitionModel model)
{
if (model == null)
{
return(ReturnError(ErrorCodes.IncomingPayloadIsMissing));
}
try
{
var brokerId = User.TryGetBrokerId().Value;
var apiUserId = User.UserId();
var order = await _apiOrderService.GetOrderAsync(model.OrderNumber, brokerId);
var user = await _apiUserService.GetBrokerUser(model.CallingUser, brokerId);
var request = await _dbContext.Requests.GetActiveRequestForApiWithBrokerAndOrderNumber(model.OrderNumber, brokerId);
if (request == null)
{
return(ReturnError(ErrorCodes.RequestNotFound));
}
if (!request.IsApprovedOrDelivered)
{
return(ReturnError(ErrorCodes.RequestNotInCorrectState));
}
try
{
await _requisitionService.Create(request, user?.Id ?? apiUserId, (user != null ? (int?)apiUserId : null), model.Message,
model.Outlay, model.AcctualStartedAt, model.AcctualEndedAt, model.WasteTime, model.WasteTimeInconvenientHour, EnumHelper.GetEnumByCustomName <TaxCardType>(model.TaxCard).Value,
new List <RequisitionAttachment>(), Guid.NewGuid(), model.MealBreaks.Select(m => new MealBreak
{
StartAt = m.StartedAt,
EndAt = m.EndedAt,
}).ToList(),
model.CarCompensation,
model.PerDiem);
await _dbContext.SaveChangesAsync();
}
catch (InvalidOperationException)
{
//TODO: Should log the acctual exception here!!
return(ReturnError(ErrorCodes.RequisitionNotInCorrectState));
}
return(Ok(new ResponseBase()));
}
catch (InvalidApiCallException ex)
{
return(ReturnError(ex.ErrorCode));
}
}
/// <summary>
/// Method to get all purchase requisitions to place order
/// </summary>
/// <param name="companyCode"></param>
/// <returns></returns>
public RequisitionModel GetAllPurchaseRequisitions(string companyCode)
{
RequisitionModel lstReq = null;
try
{
lstReq = ObjPR.GetAllPurchaseRequisitions(companyCode);
}
catch (Exception ex)
{
throw;
}
return(lstReq);
}
public ActionResult WithdrawUpdate(int reqID, int repID, int reqUnit)
{
RequisitionModel reqModel = new RequisitionModel();
reqModel.REQ_ID = reqID;
reqModel.REQ_UNIT = reqUnit;
Database db = new Database();
RequisitionDAO reqDAO = new RequisitionDAO(db);
reqDAO.Update(reqModel);
db.Close();
return(Redirect("~/Services/RepairDescription?repid=" + repID));
}
public IHttpActionResult UpdateRequisition(RequisitionModel reqm)
{
string error = "";
RequisitionModel rm = RequisitionRepo.UpdateRequisition(reqm, out error);
if (error != "" || rm == null)
{
if (error == ConError.Status.NOTFOUND)
{
return(Content(HttpStatusCode.NotFound, "Inventory Not Found"));
}
return(Content(HttpStatusCode.BadRequest, error));
}
return(Ok(rm));
}
public IHttpActionResult GetRequisitionByReqid(int reqid)
{
string error = "";
RequisitionModel reqm = RequisitionRepo.GetRequisitionByRequisitionId(reqid, out error);
if (error != "" || reqm == null)
{
if (error == ConError.Status.NOTFOUND)
{
return(Content(HttpStatusCode.NotFound, "Requisition Not Found"));
}
return(Content(HttpStatusCode.BadRequest, error));
}
return(Ok(reqm));
}
public ActionResult DeletePartial(RequisitionDetailModel model)
{
try
{
RequisitionModel requisition = SessionHelper.Requisition;
RequisitionDetailModel requisitionDetail = requisition.RequisitionDetail.FirstOrDefault(rec => rec.Id == model.Id);
SessionHelper.Requisition.RequisitionDetail.Remove(requisitionDetail);
}
catch (Exception ex)
{
ViewData["EditError"] = ex.Message;
}
return(PartialView("_Detail", getRequisitionDetail()));
}
public ActionResult Edit(string id)
{
RequisitionModel requisition = new RequisitionModel(service.GetSingle(id, AuthenticationHelper.CompanyId.Value));
requisition.RequisitionDetail = service.GetAllRequisitionDetail(requisition.Id).Select(x => new RequisitionDetailModel(x)).ToList();
SessionHelper.Requisition = requisition;
requisition.Buyers = buyerService.GetAll(AuthenticationHelper.CompanyId.Value, SessionHelper.SOBId, requisition.RequisitionDate, requisition.RequisitionDate).
Select(x => new SelectListItem {
Value = x.Id.ToString(),
Text = x.Name
}).ToList();
return(View("Edit", requisition));
}
public ActionResult RequisitionDetail(int id)
{
string token = GetToken();
UserModel um = GetUser();
RequisitionModel reqm = new RequisitionModel();
try
{
reqm = APIRequisition.GetRequisitionByReqid(id, token, out string error);
}
catch (Exception ex)
{
return(RedirectToAction("Index", "Error", new { error = ex.Message }));
}
return(View(reqm));
}
/// <summary>
/// Method to get all purchase requisitions for place order
/// </summary>
/// <returns></returns>
public JsonResult GetAllPurchaseRequisitions()
{
RequisitionModel lstReq = null;
string companyCode = null;
try
{
companyCode = ObjCurrInfo.GetCompanyCode();
lstReq = ObjPR.GetAllPurchaseRequisitions(companyCode);
return(Json(lstReq, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
throw;
}
}
public HttpResponseMessage AccountsForward([FromBody] RequisitionModel RequisitionModel)
{
try
{
invoiceRepository.AccountsForward(RequisitionModel);
var formatter = RequestFormat.JsonFormaterString();
return(Request.CreateResponse(HttpStatusCode.OK, new Confirmation {
output = "success", msg = "Approved successfully"
}, formatter));
}
catch (Exception ex)
{
var formatter = RequestFormat.JsonFormaterString();
return(Request.CreateResponse(HttpStatusCode.OK, new Confirmation {
output = "error", msg = ex.ToString()
}, formatter));
}
}
public IHttpActionResult UpdateRequisitionCompleted(RequisitionModel po)
{
string error = "";
po = RequisitionRepo.GetRequisitionByRequisitionId(po.Reqid, out error);
// if the staff has already updated the status to "preparing"
if (po.Status == ConRequisition.Status.COMPLETED)
{
return(Ok(po));
}
po.Status = ConRequisition.Status.COMPLETED;
OutstandingReqModel outreqm;
outreqm = OutstandingReqRepo.GetOutstandingReqByReqId(po.Reqid, out error);
if (outreqm.ReqId != 0)
{
po.Status = ConRequisition.Status.OUTSTANDINGREQUISITION;
}
// updating the status
RequisitionModel pom = RequisitionRepo.UpdateRequisition(po, out error);
// update the locker disburement to collected
DisbursementLockerModel dislm = LockerCollectionPointRepo.GetDisbursementLockerByReqID(po.Reqid, out error);
dislm = LockerCollectionPointRepo.UpdateDisbursementLockerToCollected(dislm, out error);
if (error != "" || pom == null)
{
if (error == ConError.Status.NOTFOUND)
{
return(Content(HttpStatusCode.NotFound, "PO Not Found"));
}
return(Content(HttpStatusCode.BadRequest, error));
}
return(Ok(pom));
}
public HttpResponseMessage Put([FromBody] RequisitionModel RequisitionModel)
{
try
{
//if (string.IsNullOrEmpty(RequisitionModel.RequisitionMasterData.company_id.ToString()))
////if (string.IsNullOrEmpty(RequisitionModel.RequisitionMasterData.company_id.ToString()) && RequisitionModel.RequisitionMasterData.requisition_type != "B2B Requisition")
//{
// var partyFormatter = RequestFormat.JsonFormaterString();
// return Request.CreateResponse(HttpStatusCode.OK, new Confirmation { output = "warning", msg = "Please Select Company" }, partyFormatter);
//}
if (string.IsNullOrEmpty(RequisitionModel.RequisitionMasterData.warehouse_from.ToString()))
{
var formatter = RequestFormat.JsonFormaterString();
return(Request.CreateResponse(HttpStatusCode.OK, new Confirmation {
output = "error", msg = "Please Select Warehouse !!"
}, formatter));
}
if (RequisitionModel.RequisitionMasterData.edit_count == 3)
{
var formatter = RequestFormat.JsonFormaterString();
return(Request.CreateResponse(HttpStatusCode.OK, new Confirmation {
output = "error", msg = "You have already edit three times !!"
}, formatter));
}
else
{
requisitionRepository.EditRequisition(RequisitionModel);
var formatter = RequestFormat.JsonFormaterString();
return(Request.CreateResponse(HttpStatusCode.OK, new Confirmation {
output = "success", msg = "Requisition Updated successfully"
}, formatter));
}
}
catch (Exception ex)
{
var formatter = RequestFormat.JsonFormaterString();
return(Request.CreateResponse(HttpStatusCode.OK, new Confirmation {
output = "error", msg = ex.ToString()
}, formatter));
}
}
public ActionResult WithdrawPartsInserting(int wdUnit, int repID, int stockID, int userID)
{
RequisitionModel rqModel = new RequisitionModel();
rqModel.REPAIR_NO = new RepairModel();
rqModel.REPAIR_NO.REPAIR_NO = repID;
rqModel.STOCK_NO = new StockModel();
rqModel.STOCK_NO.STOCK_ID = stockID;
rqModel.REQ_UNIT = wdUnit;
rqModel.APROVE = "wait";
rqModel.STAFF = new UsersModel();
rqModel.STAFF.USER_NO = userID;
Database db = new Database();
RequisitionDAO rqDAO = new RequisitionDAO(db);
rqDAO.Add(rqModel);
db.Close();
return(Redirect("~/Services/RepairDescription?repID=" + repID));
}
// Convert From Auto Generated DB Model to APIModel for Requsition with Requisition Details data
private static RequisitionModel CovertDBRequisitiontoAPIRequisitionwithDetails(requisition req)
{
List <RequisitionDetailsModel> reqdm = new List <RequisitionDetailsModel>();
foreach (requisitiondetail rqdm in req.requisitiondetails)
{
try
{
reqdm.Add(new RequisitionDetailsModel(rqdm.reqid, rqdm.itemid, rqdm.item.description, rqdm.qty, rqdm.item.category.name, rqdm.item.uom, rqdm.item.inventories.First().stock));
}
catch (Exception)
{
reqdm.Add(new RequisitionDetailsModel(rqdm.reqid, rqdm.itemid, rqdm.item.description, rqdm.qty, rqdm.item.category.name, rqdm.item.uom, 0));
}
}
RequisitionModel reqm = new RequisitionModel(req.reqid, req.raisedby, req.user.fullname
, req.approvedby, req.user1.fullname, req.cpid, req.collectionpoint.cpname
, req.deptid, req.department.deptname, req.status, req.reqdate, reqdm);
return(reqm);
}
public ActionResult ApproveRequisition(int id)
{
string token = GetToken();
UserModel um = GetUser();
RequisitionModel reqm = new RequisitionModel();
ViewBag.RequisitionModel = reqm;
ApproveRequisitionViewModel viewmodel = new ApproveRequisitionViewModel();
try
{
reqm = APIRequisition.GetRequisitionByReqid(id, token, out string error);
if (reqm.Status == ConRequisition.Status.APPROVED)
{
Session["noti"] = true;
Session["notitype"] = "error";
Session["notititle"] = "Already Approved Requisiton!";
Session["notimessage"] = "This requisition has already been approved!";
return(RedirectToAction("Index", "Home"));
}
else if (reqm.Status == ConRequisition.Status.REJECTED)
{
Session["noti"] = true;
Session["notitype"] = "error";
Session["notititle"] = "Already Approved Requisiton!";
Session["notimessage"] = "This requisition has already been approved!";
return(RedirectToAction("Index", "Home"));
}
ViewBag.RequisitionModel = reqm;
viewmodel.ReqID = reqm.Reqid;
}
catch (Exception ex)
{
return(RedirectToAction("Index", "Error", new { error = ex.Message }));
}
return(View(viewmodel));
}
public async Task <IActionResult> Create(RequisitionModel model)
{
if (ModelState.IsValid)
{
var request = await _dbContext.Requests.GetRequestForRequisitionCreateById(model.RequestId);
List <MealBreak> mealbreaks = new List <MealBreak>();
if (model.MealBreaks != null)
{
foreach (MealBreak mb in model.MealBreaks)
{
mealbreaks.Add(new MealBreak {
StartAt = mb.StartAtTemp.ToDateTimeOffsetSweden(), EndAt = mb.EndAtTemp.ToDateTimeOffsetSweden()
});
}
}
if ((await _authorizationService.AuthorizeAsync(User, request, Policies.CreateRequisition)).Succeeded)
{
Requisition requisition;
try
{
requisition = await _requisitionService.Create(request, User.GetUserId(), User.TryGetImpersonatorId(), model.Message, model.Outlay,
model.SessionStartedAt, model.SessionEndedAt, model.TimeWasteTotalTime.HasValue?(model.TimeWasteTotalTime ?? 0) - (model.TimeWasteIWHTime ?? 0) : model.TimeWasteTotalTime,
model.TimeWasteIWHTime, model.InterpreterTaxCard.Value, model.Files?.Select(f => new RequisitionAttachment {
AttachmentId = f.Id
}).ToList(), model.FileGroupKey.Value, mealbreaks, model.CarCompensation, model.PerDiem);
}
catch (InvalidOperationException ex)
{
_logger.LogError("Failed to create requisition for request {request.RequestId}, message {errorMessage}.", request.RequestId, ex.Message);
return(RedirectToAction("Index", "Home", new { errorMessage = $"Det gick inte att registrera rekvisition för {request.Order.OrderNumber}, det kan bero på att det redan finns en rekvisition registrerad." }));
}
return(RedirectToAction("View", "Request", new { id = requisition.RequestId, tab = "requisition" }));
}
return(Forbid());
}
return(View(nameof(Create), model));
}
private IEnumerable <RequisitionModel> GetProductFromXmalFile(string filePath)
{
List <RequisitionModel> products = new List <RequisitionModel>();
var xmlData = XDocument.Load(filePath).Element("Products")?.Elements();
foreach (XElement element in xmlData)
{
RequisitionModel aProduct = new RequisitionModel();
var elementFirstAttribute = element.FirstAttribute.Value;
aProduct.Serial = elementFirstAttribute;
var elementValue = element.Elements();
var xElements = elementValue as XElement[] ?? elementValue.ToArray();
aProduct.ProductId = Convert.ToInt32(xElements[0].Value);
aProduct.ProductName = xElements[1].Value;
aProduct.Quantity = Convert.ToInt32(xElements[2].Value);
aProduct.ToBranchId = Convert.ToInt32(xElements[3].Value);
aProduct.ToBranch = _iBranchManager.GetById(aProduct.ToBranchId);
products.Add(aProduct);
}
return(products);
}
private string generateReqNum(RequisitionModel model)
{
var currentDocument = service.GetAll(AuthenticationHelper.CompanyId.Value, SessionHelper.SOBId).OrderByDescending(rec => rec.Id).FirstOrDefault();
string newDocNo = "";
if (currentDocument != null)
{
int outVal;
bool isNumeric = int.TryParse(currentDocument.RequisitionNo, out outVal);
if (isNumeric && currentDocument.RequisitionNo.Length == 8)
{
newDocNo = (int.Parse(currentDocument.RequisitionNo) + 1).ToString();
return(newDocNo);
}
}
//Create New DocNum..
string yearDigit = model.RequisitionDate.ToString("yy");
string monthDigit = model.RequisitionDate.ToString("MM");
string docNo = int.Parse("1").ToString().PadLeft(4, '0');
return(yearDigit + monthDigit + docNo);
}
public async Task <IActionResult> ConfirmRequisition(RequisitionModel requisition, string button)
{
if (!ModelState.IsValid || button == null)
{
return(BadRequest());
}
if (button == "Yes")
{
await this.requisitionService.UpdateRequisitionStatus(requisition.RequisitionId, 1);
return(RedirectToAction("Index", "Home"));
}
else if (button == "No")
{
await this.requisitionService.DeleteRequisition(requisition.RequisitionId);
return(RedirectToAction("Index", "Home"));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
// to get the Requisition by the RequisitionId
public static RequisitionModel GetRequisitionByRequisitionId(int reqid, out string error)
{
LUSSISEntities entities = new LUSSISEntities();
error = "";
requisition requisition = new requisition();
RequisitionModel reqm = new RequisitionModel();
try
{
requisition = entities.requisitions.Where(p => p.reqid == reqid).FirstOrDefault <requisition>();
reqm = CovertDBRequisitiontoAPIRequisitionwithDetails(requisition);
}
catch (NullReferenceException)
{
error = ConError.Status.NOTFOUND;
}
catch (Exception e)
{
error = e.Message;
}
return(reqm);
}
public ActionResult Add(RequisitionModel model)
{
model.Add();
return(RedirectToAction("Index"));
}
//Update Stock records
public static void UpdateRequisitionWithRItems(InventoryDbContext inventoryDbContext, RequisitionModel requisition)
{
try
{
var checkStatus = true;
foreach (var rItems in requisition.RequisitionItems)
{
inventoryDbContext.RequisitionItems.Attach(rItems);
inventoryDbContext.Entry(rItems).Property(x => x.ReceivedQuantity).IsModified = true;
inventoryDbContext.Entry(rItems).Property(x => x.PendingQuantity).IsModified = true;
if (rItems.ReceivedQuantity >= rItems.PendingQuantity)
{
inventoryDbContext.Entry(rItems).Property(x => x.RequisitionItemStatus).IsModified = true;
}
else
{
checkStatus = false;
}
}
if (checkStatus)
{
inventoryDbContext.Requisitions.Attach(requisition);
inventoryDbContext.Entry(requisition).Property(x => x.RequisitionStatus).IsModified = true;
}
inventoryDbContext.SaveChanges();
}
catch (Exception ex)
{
throw ex;
}
}
