Example #1
0
        public async Task <IActionResult> UpdateRequisition(Guid id, [FromBody] RequisitionViewModel formdata)
        {
            try
            {
                if (formdata == null)
                {
                    return(BadRequest(new JsonResult(new { message = "object sent from client is null." })));
                }
                if (id == null || id == Guid.Empty)
                {
                    return(BadRequest(new JsonResult(new { message = "object sent from client is null." })));
                }
                if (id != formdata.Id)
                {
                    return(BadRequest(new JsonResult(new { message = "please ensure you are updating right object" })));
                }
                if (!ModelState.IsValid)
                {
                    return(BadRequest("Invalid model object sent from client."));
                }
                var requisition   = _mapper.Map <RequisitionDto>(formdata);
                var requisitionId = await _requisitionService.UpdateRequisition(requisition);

                if (requisitionId == Guid.Empty)
                {
                    return(NotFound());
                }
                requisition.Id = requisitionId;
                return(CreatedAtAction(nameof(GetRequisition), new { id = requisitionId }, _mapper.Map <RequisitionViewModel>(requisition)));
            }
            catch (Exception e)
            {
                return(StatusCode(500, new JsonResult(new { message = $"Something went wrong inside update requisition action: {e.Message}" })));
            }
        }
Example #2
0
        public ActionResult Edit([Bind(Include = "Id,FromPlace,DestinationPlace,StartDateTime,StartTime,EndDateTime,EndTime,Description,RequestFor,EmployeeId,RequisitionNumber")] RequisitionViewModel requisitionViewModel)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    var      startDate     = requisitionViewModel.StartDateTime.ToString("MM/dd/yyyy");
                    var      startTime     = requisitionViewModel.StartTime;
                    DateTime startDateTime = Convert.ToDateTime(startDate + " " + startTime);
                    requisitionViewModel.StartDateTime = startDateTime;

                    var      endDate     = requisitionViewModel.EndDateTime.ToString("MM/dd/yyyy");
                    var      endTime     = requisitionViewModel.EndTime;
                    DateTime endDateTime = Convert.ToDateTime(endDate + " " + endTime);
                    requisitionViewModel.EndDateTime = endDateTime;

                    Requisition requisition = Mapper.Map <Requisition>(requisitionViewModel);

                    _requisitionManager.Update(requisition);
                    TempData["msg"] = "Information has been updated successfully";
                    return(RedirectToAction("Index"));
                }
                ViewBag.EmployeeId = new SelectList(_employeeManager.GetAll(), "Id", "FullName", requisitionViewModel.EmployeeId);
                return(View(requisitionViewModel));
            }
            catch (Exception ex)
            {
                return(View("Error", new HandleErrorInfo(ex, "Requisitions", "Edit")));
            }
        }
Example #3
0
        public async Task <IActionResult> AddRequisition([FromBody] RequisitionViewModel formdata)
        {
            try
            {
                if (formdata == null)
                {
                    return(BadRequest(new JsonResult(new { message = "object sent from client is null." })));
                }
                else if (!ModelState.IsValid)
                {
                    return(BadRequest("Invalid model object sent from client."));
                }
                var requisition     = _mapper.Map <RequisitionDto>(formdata);
                var requisitionData = await _requisitionService.AddRequisition(requisition);

                if (requisitionData == Guid.Empty)
                {
                    return(NotFound());
                }
                requisition.Id = requisitionData;
                var addedRequisition = _mapper.Map <RequisitionViewModel>(requisition);
                return(CreatedAtAction(nameof(GetRequisition), new { id = requisitionData }, addedRequisition));
            }
            catch (Exception e)
            {
                return(StatusCode(500, $"Something went wrong inside add requisition action: {e.Message}"));
            }
        }
Example #4
0
        // Author: Benedict, Ayisha
        // Dept Head can approve or reject a requisition, including an optional reason
        public IActionResult DeptHeadChangeRequisitionStatus(RequisitionViewModel input)
        {
            if (getUserRole().Equals(""))
            {
                return(RedirectToAction("Login", "Login"));
            }
            //Security
            if (!(getUserRole() == DeptRole.DeptHead.ToString() ||
                  getUserRole() == DeptRole.DelegatedEmployee.ToString()))
            {
                if (getUserRole() == DeptRole.Employee.ToString() ||
                    getUserRole() == DeptRole.Contact.ToString() ||
                    getUserRole() == DeptRole.DeptRep.ToString())
                {
                    return(RedirectToAction(_filterService.Filter(getUserRole()), "Dept"));
                }
                else
                {
                    return(RedirectToAction(_filterService.Filter(getUserRole()), "Store"));
                }
            }
            int      userId = (int)HttpContext.Session.GetInt32("Id");
            Employee user   = _dbContext.Employees.SingleOrDefault(e => e.Id == userId);
            int      deptId = user.Dept.id;

            var requisition = _dbContext.DeptRequisitions.FirstOrDefault(dr => dr.Id == input.DeptRequisition.Id && dr.Employee.Dept.id == deptId);

            requisition.Reason = input.DeptRequisition.Reason;
            requisition.RequisitionApprovalStatus = input.DeptRequisition.RequisitionApprovalStatus;

            _dbContext.SaveChanges();
            return(RedirectToAction("DeptHeadRequisitionList", "Dept"));
        }
Example #5
0
        protected void initData()
        {
            clearPage();
            List <RequisitionViewModel> crViewModelList = new List <RequisitionViewModel>();

            Item ditem = RC.GetDefaultItem();

            List <string> categoryList = RC.getCategoryList();
            List <string> itemIDList   = RC.getAllItemIDList();
            List <string> itemDesList  = RC.getAllItemDesList();



            RequisitionViewModel newcrViewModel = new RequisitionViewModel();

            newcrViewModel.categoryID  = ditem.Category_ID;
            newcrViewModel.ItemID      = ditem.Item_ID;
            newcrViewModel.ItemName    = ditem.Item_Name;
            newcrViewModel.UOM         = ditem.UOM;
            newcrViewModel.RequiredQty = 0;

            crViewModelList.Add(newcrViewModel);
            Session["defaultReqItem"] = newcrViewModel;
            Session["ReqItemList"]    = crViewModelList;
            Session["categoryList"]   = categoryList;
            Session["itemIDList"]     = itemIDList;
            Session["itemDesList"]    = itemDesList;

            GridViewCreateRequisition.DataSource = crViewModelList;
            GridViewCreateRequisition.DataBind();
        }
        //Get
        public ActionResult Create(int requisitionId)
        {
            try
            {
                if (requisitionId == 0)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
                }
                Requisition requisition = _requisitionManager.FindById(requisitionId);
                if (requisition == null)
                {
                    return(HttpNotFound());
                }

                RequisitionViewModel requisitionViewModel = Mapper.Map <RequisitionViewModel>(ViewBag.Requisition = requisition);


                AssignRequisitionViewModel assignRequisitionViewModel = new AssignRequisitionViewModel();
                assignRequisitionViewModel.RequisitionId = requisitionId;
                ViewBag.RequisitionNumber = requisition.RequisitionNumber;

                ViewBag.EmployeeId          = new SelectList(_employeeManager.GetAllDriver(), "Id", "FullName");
                ViewBag.VehicleId           = new SelectList(_vehicleManager.GetAll(), "Id", "RegNo");
                ViewBag.RequisitionStatusId = new SelectList(_requisitionStatusManager.GetAllStatusNew(), "Id", "StatusType");
                return(View(assignRequisitionViewModel));
            }
            catch (Exception ex)
            {
                return(View("Error", new HandleErrorInfo(ex, "AssignRequisitions", "Create")));
            }
        }
        public ActionResult ViewDetails(int?id)
        {
            try
            {
                if (id == null)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
                }
                Requisition requisition = _requisitionManager.FindById((int)id);
                if (requisition == null)
                {
                    return(HttpNotFound());
                }
                if (requisition != null)
                {
                    RequisitionViewModel requisitionViewModel = Mapper.Map <RequisitionViewModel>(requisition);

                    return(View(requisitionViewModel));
                }
                return(View("Error"));
            }
            catch (Exception ex)
            {
                return(View("Error", new HandleErrorInfo(ex, "AssignRequisitions", "ViewDetails")));
            }
        }
Example #8
0
        // Author: Benedict, Yeo Jia Hui
        // API GET Request that shows Requisition Details for the Department Head
        public IActionResult DeptHeadRequisitionDetail(int id)
        {
            if (getUserRole().Equals(""))
            {
                return(RedirectToAction("Login", "Login"));
            }
            //Security
            if (!(getUserRole() == DeptRole.DeptHead.ToString() ||
                  getUserRole() == DeptRole.DelegatedEmployee.ToString()))
            {
                if (getUserRole() == DeptRole.Employee.ToString() ||
                    getUserRole() == DeptRole.Contact.ToString() ||
                    getUserRole() == DeptRole.DeptRep.ToString())
                {
                    return(RedirectToAction(_filterService.Filter(getUserRole()), "Dept"));
                }
                else
                {
                    return(RedirectToAction(_filterService.Filter(getUserRole()), "Store"));
                }
            }
            var viewModel = new RequisitionViewModel();

            viewModel.DeptRequisition = _dbContext.DeptRequisitions.Find(id);
            return(View(viewModel));
        }
Example #9
0
        //Get
        public ActionResult Create(int requisitionId)
        {
            try
            {
                if (requisitionId == 0)
                {
                    return(View("Error"));
                }
                Requisition requisition = _requisitionManager.FindById(requisitionId);
                if (requisition == null)
                {
                    return(HttpNotFound());
                }

                RequisitionViewModel requisitionViewModel = Mapper.Map <RequisitionViewModel>(ViewBag.Requisition = requisition);

                AssignRequisitionViewModel assignRequisitionViewModel = new AssignRequisitionViewModel();
                assignRequisitionViewModel.RequisitionId = requisitionId;
                assignRequisitionViewModel.VehicleTypes  = _vehicleTypeManager.GetAll().ToList();

                ViewBag.RequisitionNumber = requisition.RequisitionNumber;
                ViewBag.EmployeeId        = new SelectList(_employeeManager.GetAllDriver(), "Id", "FullName");
                ViewBag.VehicleId         = new SelectListItem[] { new SelectListItem()
                                                                   {
                                                                       Value = "", Text = "Select Vehicle"
                                                                   } };
                ViewBag.RequisitionStatusId = new SelectList(_requisitionStatusManager.GetAllStatusNew(), "Id", "StatusType");
                return(View(assignRequisitionViewModel));
            }
            catch (Exception ex)
            {
                ExceptionMessage(ex);
                return(View("Error", new HandleErrorInfo(ex, "AssignRequisitions", "Create")));
            }
        }
Example #10
0
        /// <summary>
        /// Populates the RequisitionViewModel for the property requestor
        /// </summary>
        /// <param name="unitOfWork"></param>
        /// <param name="requisitions"></param>
        /// <returns></returns>
        public static List <RequisitionViewModel> populateRequisitionVMForRequestor(UnitOfWork unitOfWork, IEnumerable <PropertyRequisition> requisitions)
        {
            List <RequisitionViewModel> requisitionInfo = null;

            if (requisitions != null)
            {
                requisitionInfo = new List <RequisitionViewModel>();

                foreach (var req in requisitions)
                {
                    RequisitionViewModel model = new RequisitionViewModel();

                    model.PropertyRequisition.User = new User();

                    model.ImageUrl = unitOfWork.PropertyImage.GetPrimaryImageURLByPropertyId(req.PropertyID);
                    model.PropertyRequisition.ID             = req.ID;
                    model.PropertyRequisition.PropertyID     = req.PropertyID;
                    model.PropertyRequisition.User.FirstName = req.Property.Owner.User.FirstName;
                    model.PropertyRequisition.User.LastName  = req.Property.Owner.User.LastName;
                    model.PropertyRequisition.User.CellNum   = req.Property.Owner.User.CellNum;
                    model.PropertyRequisition.Msg            = req.Msg;
                    model.PropertyRequisition.IsAccepted     = req.IsAccepted;
                    model.PropertyRequisition.DateTCreated   = req.DateTCreated;
                    model.isUserPropOwner = false;

                    requisitionInfo.Add(model);
                }
            }

            return(requisitionInfo);
        }
        public ActionResult Create([Bind(Include = "Id,CommentText,RequisitionId")] FeedbackViewModel feedbackViewModel)
        {
            try
            {
                if (ModelState.IsValid)
                {
                    var      requisitionByEmployee = _requisitionManager.FindById(feedbackViewModel.RequisitionId);
                    var      empId    = requisitionByEmployee.EmployeeId;
                    Feedback feedback = Mapper.Map <Feedback>(feedbackViewModel);
                    feedback.EmployeeId = empId;
                    feedback.CreatedOn  = DateTime.Now;
                    _feedbackManager.Add(feedback);
                    TempData["Msg"] = "Comment Save successfully";


                    Requisition          requisition          = _requisitionManager.FindById(feedbackViewModel.RequisitionId);
                    RequisitionViewModel requisitionViewModel = Mapper.Map <RequisitionViewModel>(requisition);
                    feedbackViewModel.Requisition = requisition;
                    ViewBag.Feedback = _feedbackManager.GetAllByRequisitionId(feedbackViewModel.RequisitionId);
                }
                return(View(feedbackViewModel));
            }
            catch (Exception ex)
            {
                ExceptionMessage(ex);
                return(View("Error", new HandleErrorInfo(ex, "Requisitions", "Feedback")));
            }
        }
Example #12
0
        public async Task <IActionResult> View(int id, bool returnPartial = false)
        {
            var requisition = await _dbContext.Requisitions.GetFullRequisitionById(id);

            if ((await _authorizationService.AuthorizeAsync(User, requisition, Policies.View)).Succeeded)
            {
                var model = RequisitionViewModel.GetViewModelFromRequisition(requisition);

                model.UserCanAccept = (await _authorizationService.AuthorizeAsync(User, requisition, Policies.Accept)).Succeeded;
                model.UserCanCreate = (await _authorizationService.AuthorizeAsync(User, requisition.Request, Policies.Edit)).Succeeded;
                model.RequestOrReplacingOrderPricesAreUsed = requisition.RequestOrReplacingOrderPeriodUsed;

                await _listToModelService.AddInformationFromListsToModel(model);

                model.EventLog = new EventLogModel
                {
                    Header          = "Rekvisitionshändelser",
                    Id              = "EventLog_Requisition",
                    DynamicLoadPath = $"Requisition/{nameof(GetEventLog)}/{id}",
                };
                if (returnPartial)
                {
                    return(PartialView(model));
                }
                return(View(model));
            }
            return(Forbid());
        }
        /// <summary>
        /// Check for blocked or Nonexisting products for requisition
        /// </summary>
        /// <param name="requisition"></param>
        /// <param name="navDatabaseName"></param>
        /// <param name="navCompanyName"></param>
        /// <returns></returns>
        public static ErrorHandler CheckProductsAvailability(RequisitionViewModel requisition, string navDatabaseName, string navCompanyName)
        {
            //garantir que todos os produtos estão desbloqueados
            var          productsIds = requisition.Lines.Select(x => x.Code).Distinct().ToList();
            var          products    = GetProductsById(navDatabaseName, navCompanyName, productsIds);
            ErrorHandler result      = new ErrorHandler(1, "Os produtos não estão bloqueados.");

            if (products != null)
            {
                if (products.Count == 0)
                {
                    var existingIds         = products.Select(x => x.Code).Distinct();
                    var blockedOrUnexisting = requisition.Lines.Where(x => !existingIds.Contains(x.Code)).ToList();

                    result.eReasonCode = 22;
                    result.eMessage    = "Os seguintes produtos não existem ou estão bloqueados: " + string.Join(", ", blockedOrUnexisting.Select(x => x.Code + " - " + x.Description).ToArray());
                }
                else if (products.Count < productsIds.Count)
                {
                    var existingIds         = products.Select(x => x.Code).Distinct();
                    var blockedOrUnexisting = requisition.Lines.Where(x => !existingIds.Contains(x.Code)).ToList();

                    result.eReasonCode = 2;
                    result.eMessage    = "Os seguintes produtos não existem ou estão bloqueados: " + string.Join(", ", blockedOrUnexisting.Select(x => x.Code + " - " + x.Description).ToArray());
                }
            }
            return(result);
        }
Example #14
0
        //}
        protected void getPreviousData()
        {
            List <RequisitionViewModel> crViewModelList = (List <RequisitionViewModel>)Session["ReqItemList"];

            crViewModelList.Clear();
            for (int t = 0; t < GridViewCreateRequisition.Rows.Count; t++)
            {
                ddlCategory = (DropDownList)GridViewCreateRequisition.Rows[t].Cells[0].FindControl("DropDownListCategory");
                ddlItemDes  = (DropDownList)GridViewCreateRequisition.Rows[t].Cells[1].FindControl("DropDownListDesc");
                tbQty       = (TextBox)GridViewCreateRequisition.Rows[t].Cells[2].FindControl("TextboxQty");
                lblUOM      = (Label)GridViewCreateRequisition.Rows[t].Cells[3].FindControl("lblUOM");


                RequisitionViewModel crViewModel = new RequisitionViewModel();
                crViewModel.categoryID  = ddlCategory.SelectedValue;
                crViewModel.ItemID      = ddlItemDes.SelectedValue;
                crViewModel.RequiredQty = Convert.ToInt32(tbQty.Text);
                crViewModel.UOM         = lblUOM.Text;
                crViewModelList.Add(crViewModel);
            }

            Session["ReqItemList"] = crViewModelList;
            GridViewCreateRequisition.DataSource = crViewModelList;
            GridViewCreateRequisition.DataBind();
        }
Example #15
0
        // GET: Requisitions/Edit/5
        public ActionResult Edit(int?id)
        {
            try
            {
                RequisitionViewModel requisitionView = new RequisitionViewModel();
                if (id == null)
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
                }

                var status = _requisitionStatusManager.FindByRequisitionId((int)id);
                if (status.StatusType == "New")
                {
                    Requisition requisition = _requisitionManager.FindById((int)id);

                    if (requisition == null)
                    {
                        return(HttpNotFound());
                    }
                    ViewBag.EmployeeId = new SelectList(_employeeManager.GetAll(), "Id", "FullName", requisition.EmployeeId);
                    RequisitionViewModel requisitionViewModel = Mapper.Map <RequisitionViewModel>(requisition);
                    return(View(requisitionViewModel));
                }

                TempData["EditMsg"] = " Your requisition already assigned or completed. You Cant't Edid or Update. ";
                return(RedirectToAction("Create"));
            }
            catch (Exception ex)
            {
                ExceptionMessage(ex);
                return(View("Error", new HandleErrorInfo(ex, "Requisitions", "Edit")));
            }
        }
Example #16
0
        public IActionResult ViewRF(int id)
        {
            RequisitionViewModel vmRequisition = new RequisitionViewModel();
            //emp = JsonConvert.DeserializeObject<Employee>(HttpContext.Session.GetString("employee")) as Employee;

            Employee        emp = eservice.GetEmployeeById(6); //hard-coded id for test
            RequisitionForm rf  = rpService.FindRequisitionFormById(id);
            List <RequisitionFormsProduct> rfpList = rpService.FindRequisitionFormProductListById(id);

            vmRequisition.employee        = emp;
            vmRequisition.requisitionForm = rf;
            vmRequisition.rfpList         = rfpList;

            if (emp.EmployeeType.EmployeeTypeName.Equals("Store Manager") || emp.EmployeeType.EmployeeTypeName.Equals("Department Head"))
            {
                if (!rf.RFStatus.Equals(Enums.RFStatus.Submitted))
                {
                    return(Ok(vmRequisition));
                }
                else
                {
                    for (int i = 0; i < rfpList.Count; i++)
                    {
                        rfpList[i].ProductApproved = rfpList[i].ProductRequested;
                    }
                    return(Ok(vmRequisition));
                }
            }
            else
            {
                return(Ok(vmRequisition));
            }
        }
Example #17
0
        public ActionResult RaiseRequisition()
        {
            string    error = "";
            string    token = GetToken();
            UserModel um    = GetUser();
            DepartmentCollectionPointModel dcpm = new DepartmentCollectionPointModel();
            List <ItemModel>     ItemsList      = new List <ItemModel>();
            RequisitionViewModel reqvm          = new RequisitionViewModel();

            try
            {
                reqvm.Reqdate     = DateTime.Now;
                reqvm.Raisedby    = um.Userid;
                reqvm.Depid       = um.Deptid;
                dcpm              = APICollectionPoint.GetActiveDepartmentCollectionPointByDeptID(token, um.Deptid, out error);
                reqvm.Cpid        = dcpm.CpID;
                reqvm.Cpname      = dcpm.CpName;
                reqvm.Status      = ConRequisition.Status.PENDING;
                ItemsList         = APIItem.GetAllItems(token, out error);
                ViewBag.ItemsList = ItemsList;
            }
            catch (Exception ex)
            {
                return(RedirectToAction("Index", "Error", new { error = ex.Message }));
            }
            return(View(reqvm));
        }
Example #18
0
        public ActionResult Edit([Bind(Include = "Id,FromPlace,DestinationPlace,StartDateTime,StartTime,EndDateTime,EndTime,PassengerQty,Description,RequestFor,EmployeeId,RequisitionNumber,RequisitionType,SubmitDateTime")] RequisitionViewModel requisitionViewModel)

        {
            try
            {
                if (ModelState.IsValid)
                {
                    var      startDate     = requisitionViewModel.StartDateTime.ToString("MM/dd/yyyy");
                    var      startTime     = requisitionViewModel.StartTime;
                    DateTime startDateTime = Convert.ToDateTime(startDate + " " + startTime);
                    requisitionViewModel.StartDateTime = startDateTime;

                    var      endDate     = requisitionViewModel.EndDateTime.ToString("MM/dd/yyyy");
                    var      endTime     = requisitionViewModel.EndTime;
                    DateTime endDateTime = Convert.ToDateTime(endDate + " " + endTime);
                    requisitionViewModel.EndDateTime = endDateTime;

                    //DateTime submitedDateTime=Convert.ToDateTime(requisitionViewModel.StringSubmitDateTime);
                    if (requisitionViewModel.RequestFor != "Own" && requisitionViewModel.EmployeeId != null && requisitionViewModel.EmployeeId > 0)
                    {
                        var emp = _employeeManager.FindById((int)requisitionViewModel.EmployeeId);
                        requisitionViewModel.RequestFor = emp.FullName;
                    }
                    //Get employee Id by user login id
                    var loginUserId = Convert.ToInt32(User.Identity.GetUserId());
                    var empId       = _employeeManager.FindByLoginId(loginUserId);
                    requisitionViewModel.EmployeeId = empId.Id;

                    Requisition requisition = Mapper.Map <Requisition>(requisitionViewModel);

                    bool IsUpdated = _requisitionManager.Update(requisition);
                    if (IsUpdated)
                    {
                        var historyId = _requisitionHistoryManager.FindByRequisitionId(requisition.Id);

                        historyId.Id             = historyId.Id;
                        historyId.Status         = "New";
                        historyId.RequisitionId  = requisition.Id;
                        historyId.UpdateDateTime = DateTime.Now;
                        _requisitionHistoryManager.Update(historyId);
                    }
                    TempData["msg"] = " Information has been updated successfully! ";

                    return(RedirectToAction("Create"));
                }

                ViewBag.EmployeeId = new SelectList(_employeeManager.GetAll(), "Id", "FullName", requisitionViewModel.EmployeeId);

                TempData["msg1"] = "Requisition send failed! You are missing to input proper value. Please check and try again!";

                return(View(requisitionViewModel));
            }
            catch (Exception ex)
            {
                ExceptionMessage(ex);
                return(View("Error", new HandleErrorInfo(ex, "Requisitions", "Edit")));
            }
        }
Example #19
0
        public static List <RequisitionViewModel> ReturnRequisitionGroupByReuisitionNo(List <ReliefRequisition> requisition)
        {
            if (requisition == null)
            {
                return(new List <RequisitionViewModel>());
            }


            var result = (from req in requisition
                          select new RequisitionViewModel()
            {
                RequisitionNo = req.RequisitionNo,
                RequisitionId = req.RequisitionID,
                RequisitionDate = DateTime.Parse(req.RequestedDate.ToString()),
                Commodity = req.Commodity.Name,
                BenficiaryNo = req.ReliefRequisitionDetails.Sum(a => a.BenficiaryNo),
                Amount = req.ReliefRequisitionDetails.Sum(a => a.Amount).ToPreferedWeightUnit(),
                Status = int.Parse(req.Status.ToString()),
                Region = req.AdminUnit.Name,
                RegionId = (int)req.RegionID,
                Zone = req.AdminUnit1.Name,
                Program = req.Program.Name,
                ProgramId = req.ProgramID,
                Round = req.Round,
                Month = req.Month,
                MonthName = RequestHelper.GetMonthList().Find(t => t.Id == req.Month).Name,
                AmountAllocated = req.ReliefRequisitionDetails.Sum(a => a.Amount),
                StrRequisitionDate = req.RequestedDate.Value.ToCTSPreferedDateFormat(UserAccountHelper.UserCalendarPreference())
            });

            var r = new List <RequisitionViewModel>();

            foreach (var req in requisition)
            {
                var n = new RequisitionViewModel();
                n.RequisitionNo   = req.RequisitionNo;
                n.RequisitionId   = req.RequisitionID;
                n.RequisitionDate = DateTime.Parse(req.RequestedDate.ToString());
                n.Commodity       = req.Commodity.Name;
                n.BenficiaryNo    = req.ReliefRequisitionDetails.Sum(a => a.BenficiaryNo);
                var m = req.ReliefRequisitionDetails.Sum(a => a.Amount);
                n.Amount             = m.ToPreferedWeightUnit();
                n.Status             = int.Parse(req.Status.ToString());
                n.Region             = req.AdminUnit.Name;
                n.RegionId           = (int)req.RegionID;
                n.Zone               = req.AdminUnit1.Name;
                n.Program            = req.Program.Name;
                n.Round              = req.Round;
                n.Month              = req.Month;
                n.MonthName          = RequestHelper.GetMonthList().Find(t => t.Id == req.Month).Name;
                n.AmountAllocated    = req.ReliefRequisitionDetails.Sum(a => a.Amount);
                n.StrRequisitionDate = req.RequestedDate.Value.ToCTSPreferedDateFormat(UserAccountHelper.UserCalendarPreference());

                r.Add(n);
            }

            return(r.ToList());
        }
        public IActionResult CreateRequisitionForm()
        {
            emp = JsonConvert.DeserializeObject <Employee>(HttpContext.Session.GetString("employee")) as Employee;
            RequisitionViewModel rVModel = new RequisitionViewModel();

            rVModel.employee    = emp;
            rVModel.productList = pService.FindProducts();
            return(View("RequisitionFormApply", rVModel));
        }
Example #21
0
        public async Task <ActionResult <Requisition> > processRetrieval(
            [FromBody] RequisitionViewModel requistitions)
        {
            var result = await _clkService.findAllRequsitionDetailsAsync();

            Console.WriteLine("post");
            Console.WriteLine(requistitions);
            return(Ok(requistitions));
        }
Example #22
0
        public ActionResult SearchRequisition(DateTime startDate, DateTime endDate)
        {
            var viewModel = new RequisitionViewModel()
            {
                GroupedItemRequisitions = itemRequisitionService.groupItemRequisitionsByDateRange(startDate, endDate)
            };

            return(View("Requisition", viewModel));
        }
Example #23
0
        public ActionResult Create()
        {
            var requisitionViewModel = new RequisitionViewModel()
            {
                Items = itemService.GetAll()
            };

            return(View("RequisitionForm", requisitionViewModel));
        }
Example #24
0
        public GenericResult CreateTransferShipmentFor(RequisitionViewModel requisition)
        {
            GenericResult response = new GenericResult();

            if (requisition != null && requisition.Lines != null && requisition.Lines.Count > 0)
            {
                try
                {
                    TransferShipment transferShipment = new TransferShipment();
                    transferShipment.ProjectNo        = requisition.ProjectNo;
                    transferShipment.Comments         = requisition.Comments;
                    transferShipment.FunctionalAreaNo = requisition.FunctionalAreaCode;
                    transferShipment.RequisitionNo    = requisition.RequisitionNo;
                    transferShipment.Lines            = requisition.Lines.Select(line => new TransferShipmentLine()
                    {
                        ProductNo              = line.Code,
                        ProductDescription     = line.Description,
                        Quantity               = line.QuantityToProvide,
                        UnitOfMeasureNo        = line.UnitMeasureCode,
                        UnitCost               = line.UnitCost,
                        RegionNo               = line.RegionCode,
                        FunctionalAreaNo       = line.FunctionalAreaCode,
                        CenterResponsibilityNo = line.CenterResponsibilityCode
                    }).ToList();

                    Task <WSTransferShipmentHeader.Create_Result> createTransferShipHeaderTask = NAVTransferShipmentService.CreateHeaderAsync(transferShipment, configws);
                    createTransferShipHeaderTask.Wait();
                    if (createTransferShipHeaderTask.IsCompletedSuccessfully)
                    {
                        transferShipment.TransferShipmentNo = createTransferShipHeaderTask.Result.WSShipmentDocHeader.Nº_Guia_Transporte;

                        Task <WSTransferShipmentLine.CreateMultiple_Result> createTransferShipLinesTask = NAVTransferShipmentService.CreateLinesAsync(transferShipment, configws);
                        createTransferShipLinesTask.Wait();
                        if (createTransferShipLinesTask.IsCompletedSuccessfully)
                        {
                            Task <WSGenericCodeUnit.FxPostShipmentDoc_Result> createTransferShipDocTask = WSGeneric.CreateTransferShipment(transferShipment.TransferShipmentNo, configws);
                            createTransferShipDocTask.Wait();
                            if (createTransferShipDocTask.IsCompletedSuccessfully)
                            {
                                response.CompletedSuccessfully = true;
                                response.ResultValue           = createTransferShipDocTask.Result.return_value;
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    response.ErrorMessage = ex.Message;
                }
            }
            else
            {
                response.ErrorMessage = "A requisição é nula ou não tem linhas.";
            }
            return(response);
        }
        // GET: Requisitions/Create
        public ActionResult Create()
        {
            var userId = User.Identity.GetUserId();

            RequisitionViewModel requisitionViewModel = new RequisitionViewModel();

            requisitionViewModel.Employee = _employeeManager.GetByUserId(userId);

            return(View(requisitionViewModel));
        }
Example #26
0
        public ActionResult Create(int?id)
        {
            var userName = System.Web.HttpContext.Current.User.Identity.Name;
            var user     = _systemService.GetUserAndRole(0, userName);

            if (user == null)
            {
                return(RedirectToAction("Index", "Login"));
            }

            if (user.RequisitionR == 0)
            {
                return(RedirectToAction("Index", "Home"));
            }

            var item = new WAMS_REQUISITION_MASTER();

            if (id.HasValue)
            {
                item = _service.GetByKey(id.Value);
            }
            else
            {
                item.vMRF =
                    (Convert.ToInt32(_service.GetCodeLastest()) + 1).ToString(CultureInfo.InvariantCulture);
            }

            var model = new RequisitionViewModel
            {
                Id               = item.Id,
                vMRF             = item.vMRF,
                vFrom            = item.vFrom,
                iStore           = item.iStore,
                vDeliverLocation = item.vDeliverLocation,
                vProjectID       = item.vProjectID,
                Timestamp        = item.Timestamp,
                UserLogin        = user,
                Stores           = new SelectList(_systemService.StoreList(), "Id", "Name"),
                Projects         = new SelectList(_systemService.ProjectList(), "Id", "vProjectID"),
                ProjectNames     = new SelectList(_systemService.ProjectList(), "Id", "vProjectName")
            };

            if (id.HasValue)
            {
                var temp = _service.ListConditionDetail(id.Value, "1");
                model.GetRequisitionDetailsVResults = temp;
                model.TotalRecords = temp.Count;
            }
            if (item.dDeliverDate.HasValue)
            {
                model.DeliverDateTemp = item.dDeliverDate.Value.ToString("dd/MM/yyyy");
            }

            return(View(model));
        }
Example #27
0
        public ActionResult LoadRequisitionDetail(int id, string enable)
        {
            var detailList = _service.ListConditionDetail(id, enable);
            var model      = new RequisitionViewModel
            {
                GetRequisitionDetailsVResults = detailList,
                TotalRecords = detailList.Count()
            };

            return(PartialView("_RequisitionDetailPartial", model));
        }
        public ActionResult Create(int? id)
        {
            var userName = System.Web.HttpContext.Current.User.Identity.Name;
            var user = _systemService.GetUserAndRole(0, userName);
            if (user == null)
            {
                return RedirectToAction("Index", "Login");
            }

            if (user.RequisitionR == 0)
            {
                return RedirectToAction("Index", "Home");
            }

            var item = new WAMS_REQUISITION_MASTER();
            if (id.HasValue)
            {
                item = _service.GetByKey(id.Value);
            }
            else
            {
                item.vMRF =
                    (Convert.ToInt32(_service.GetCodeLastest()) + 1).ToString(CultureInfo.InvariantCulture);
            }

            var model = new RequisitionViewModel
            {
                Id = item.Id,
                vMRF = item.vMRF,
                vFrom = item.vFrom,
                iStore = item.iStore,
                vDeliverLocation = item.vDeliverLocation,
                vProjectID = item.vProjectID,
                Timestamp = item.Timestamp,
                UserLogin = user,
                Stores = new SelectList(_systemService.StoreList(), "Id", "Name"),
                Projects = new SelectList(_systemService.ProjectList(), "Id", "vProjectID"),
                ProjectNames = new SelectList(_systemService.ProjectList(), "Id", "vProjectName")
            };

            if (id.HasValue)
            {
                var temp = _service.ListConditionDetail(id.Value, "1");
                model.GetRequisitionDetailsVResults = temp;
                model.TotalRecords = temp.Count;
            }
            if (item.dDeliverDate.HasValue)
            {
                model.DeliverDateTemp = item.dDeliverDate.Value.ToString("dd/MM/yyyy");
            }

            return View(model);
        }
Example #29
0
        public ActionResult DepartmentSearchRequisition(DateTime startDate, DateTime endDate)
        {
            var departmentId = User.Identity.GetDepartmentId();

            var viewModel = new RequisitionViewModel()
            {
                GroupedItemRequisitions = itemRequisitionService
                                          .groupDepartmentItemRequisitionsByDateRange(startDate, endDate, departmentId)
            };

            return(View("DepartmentRequisition", viewModel));
        }
        public IActionResult ViewApprovalRF(int id)
        {
            RequisitionViewModel rVModel = new RequisitionViewModel();
            //emp = JsonConvert.DeserializeObject<Employee>(HttpContext.Session.GetString("employee")) as Employee;
            RequisitionForm rf = rpservice.FindRequisitionFormById(id);
            List <RequisitionFormsProduct> rfpList = rpservice.FindRequisitionFormProductListById(id);

            //rVModel.employee = emp;
            rVModel.requisitionForm = rf;
            rVModel.rfpList         = rfpList;
            return(Ok(rVModel));
        }
Example #31
0
        // GET: Requisition
        public ActionResult Index()
        {
            var requistionViewModel = new RequisitionViewModel()
            {
                Items        = itemService.GetAll(),
                Requisitions = requisitionService.GetAll()
                               .Where(x => x.DepartmentId == User.Identity.GetDepartmentId())
                               .OrderByDescending(r => r.createdDateTime)
                               .OrderBy(r => r.Status)
            };

            return(View("Index", requistionViewModel));
        }
        private JsonResult EditData(RequisitionViewModel model)
        {
            if (model.CheckCode != model.RequisitionMaster.vMRF)
            {
                if (_service.ExistedCode(model.RequisitionMaster.vMRF))
                {
                    return Json(new { result = Constants.DuplicateCode, mRf = (Convert.ToInt32(_service.GetCodeLastest()) + 1).ToString(CultureInfo.InvariantCulture) });
                }
            }

            var entity = _service.GetByKey(model.RequisitionMaster.Id);
            if (!Convert.ToBase64String(model.RequisitionMaster.Timestamp).Equals(Convert.ToBase64String(entity.Timestamp)))
            {
                return Json(new { result = Constants.DataJustChanged });
            }

            try
            {
                entity.iStore = model.RequisitionMaster.iStore;
                entity.dDeliverDate = model.RequisitionMaster.dDeliverDate;
                entity.vDeliverLocation = model.RequisitionMaster.vDeliverLocation;
                entity.vFrom = model.RequisitionMaster.vFrom;
                entity.vProjectID = model.RequisitionMaster.vProjectID;
                entity.iModified = model.LoginId;
                entity.dModified = DateTime.Now;
                _service.Update(entity, model.ListRequisitionDetails, model.LstDeleteDetailItem);

                return Json(new { result = Constants.Success });
            }
            catch (Exception e)
            {
                Log.Error("Update Requisition!", e);
                return Json(new { result = Constants.UnSuccess });
            }
        }
        private JsonResult CreateData(RequisitionViewModel model)
        {
            if (_service.ExistedCode(model.RequisitionMaster.vMRF))
            {
                return Json(new { result = Ap.Common.Constants.Constants.DuplicateCode, mRf = (Convert.ToInt32(_service.GetCodeLastest()) + 1).ToString(CultureInfo.InvariantCulture) });
            }

            try
            {
                model.RequisitionMaster.vStatus = "Open";
                model.RequisitionMaster.iEnable = true;
                model.RequisitionMaster.iCreated = model.LoginId;
                model.RequisitionMaster.dCreated = DateTime.Now;
                _service.Insert(model.RequisitionMaster, model.ListRequisitionDetails);
                return Json(new { result = Constants.Success });
            }
            catch (Exception e)
            {
                Log.Error("Create New Requisition!", e);
                return Json(new { result = Constants.UnSuccess });
            }
        }
        public ActionResult LoadRequisitionDetail(int id, string enable)
        {
            var detailList = _service.ListConditionDetail(id, enable);
            var model = new RequisitionViewModel
            {
                GetRequisitionDetailsVResults = detailList,
                TotalRecords = detailList.Count()
            };

            return PartialView("_RequisitionDetailPartial", model);
        }
        public ActionResult LoadRequisition(int page, int size, int store, string mrf, string stockCode, string stockName, string status, string fd, string td, string enable)
        {
            var userName = System.Web.HttpContext.Current.User.Identity.Name;
            var totalRecord = _service.ListConditionCount(page, size, store, mrf, stockCode, stockName, status, fd, td, enable);
            var totalTemp = Convert.ToDecimal(totalRecord) / Convert.ToDecimal(size);
            var totalPages = Convert.ToInt32(Math.Ceiling(totalTemp));
            var model = new RequisitionViewModel
            {
                UserLogin = _systemService.GetUserAndRole(0, userName),
                RequisitionGetListResults = _service.ListCondition(page, size, store, mrf, stockCode, stockName, status, fd, td, enable),
                TotalRecords = Convert.ToInt32(totalRecord),
                TotalPages = totalPages,
                CurrentPage = page,
                PageSize = size
            };

            return PartialView("_RequisitionPartial", model);
        }
 public ActionResult Index()
 {
     var userName = System.Web.HttpContext.Current.User.Identity.Name;
     var user = _systemService.GetUserAndRole(0, userName);
     if (user == null) return RedirectToAction("Index", "Login");
     if (user.RequisitionR == 0) return RedirectToAction("Index", "Home");
     var model = new RequisitionViewModel
     {
         UserLogin = user,
         Stores = new SelectList(_systemService.StoreList(), "Id", "Name"),
         Projects = new SelectList(_systemService.ProjectList(), "Id", "vProjectID")
     };
     return View(model);
 }
        public JsonResult Create(RequisitionViewModel model)
        {
            if (model.V3 != true)
            {
                return Json(new { result = Constants.UnSuccess });
            }

            if (!string.IsNullOrEmpty(model.DeliverDateTemp))
            {
                model.RequisitionMaster.dDeliverDate = DateTime.ParseExact(model.DeliverDateTemp, "dd/MM/yyyy", CultureInfo.InvariantCulture);
            }

            return model.RequisitionMaster.Id == 0 ? CreateData(model) : EditData(model);
        }