@RequestMapping(value = "/vendorReturnAdvanceSearch", method = RequestMethod.GET)
  public String vendorReturnAdvanceSearch(
      @ModelAttribute("vendorReturnCommand") VendorReturn vendorReturn,
      HttpServletRequest request,
      HttpServletResponse response) {

    String name1 = "vendorReturn", s1 = null, s2 = null;

    List<Object[]> returnString = null;

    vrList = new ArrayList<VendorReturn>();
    vendorReturn.setAdvanceSearchHidden(1);
    try {
      returnString = xmlService.populateXml(name1);

      for (Object[] object : returnString) {
        VendorReturn vend = new VendorReturn();

        s1 = (String) object[0];
        s2 = (String) object[1];
        vend.setFirstLabel(s1);

        vend.setSecondLabel(s2);
        vrList.add(vend);
      }

    } catch (Exception e) {
      e.printStackTrace();
    }

    request.setAttribute("vendorReturnSearchAdvance", vrList);
    return "vendorReturnHome";
  }
  /**
   * ========================================Duplicate Checking for edit===========================
   */
  @RequestMapping(value = "/vendorReturnDuplicateEditCheck", method = RequestMethod.POST)
  public @ResponseBody String checknameEdit(
      HttpServletRequest request, HttpServletResponse response, VendorReturn vend) {
    response.setCharacterEncoding("UTF-8");
    String msg = null;
    int pname = 0;

    try {

      String beforeedit = request.getParameter("vendorReturnNo");
      int iid = Integer.parseInt(request.getParameter("vid"));
      pname = vrService.checkEditDuplicate(beforeedit, iid);

      if (pname != 0) {
        vend.setVendorReturnIdEditt(1);
        request.setAttribute(
            "updateVendorReturnDuplicate", "Vendor Return No Already Exists Choose Another One");
        vend.setVendorReturnNoEditt("");

        msg = "Vendor Return No Already Exists Choose Another One";
      }
      if (pname == 0) {
        vend.setVendorReturnIdEditt(1);
        request.setAttribute(
            "updateQuotDuplicate", "Vendor Return No Already Exists Choose Another One");
        vend.setVendorReturnNoEditt("");

        msg = "";
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return msg;
  }
  /*
   * ===========================Duplicate checking for
   * add========================
   */
  @RequestMapping(value = "/vendorReturnDuplicateAddCheck", method = RequestMethod.POST)
  public @ResponseBody String checkVrNo(
      HttpServletRequest request, HttpServletResponse response, VendorReturn vend) {
    response.setCharacterEncoding("UTF-8");
    String msg = null;
    int pname = 0;

    try {

      String before = request.getParameter("vendorReturnNo");
      pname = vrService.checkDuplicate(before);
      if (pname != 0) {
        vend.setAid(2);

        request.setAttribute(
            "addVendorReturnDuplicate", "Vendor Return No Already Exists Choose Another One");

        vend.setVendorReturnNo("");

        msg = "Vendor Return No Already Exists Choose Another One";
      }
      if (pname == 0) {
        vend.setAid(2);
        request.setAttribute(
            "addVendorReturnDuplicate", "Vendor Return No Already Exists Choose Another One");
        vend.setVendorReturnNo("");

        msg = "";
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return msg;
  }
  /* ===================================Update Method======================== */
  @RequestMapping(value = "/vendorReturnEdit", method = RequestMethod.GET)
  public String updateVendorReturn(
      @ModelAttribute("vendorReturnCommand") VendorReturn vrEdit,
      HttpServletRequest request,
      HttpServletResponse response,
      Model model) {
    response.setCharacterEncoding("UTF-8");
    VendorReturnLine vrLine = null;
    List<VendorReturnLine> vrLines = null;
    String vendorReturnUpdate = null;
    List<Object[]> ob = null;
    float rejQty = 0.0f, returnQty = 0.0f, qty = 0.0f, diffQty = 0.0f;
    List<String> list = new ArrayList<String>();
    String msg = null;

    String checkVrNo = vrEdit.getVendorReturnNoEditt();

    int id = vrEdit.getVendorReturnIdEditt();

    int list1 = vrService.checkEditDuplicate(checkVrNo, id);

    if (list1 == 0) {

      try {
        float stockEdit = vrEdit.getStockEdit();
        vrEdit.setVendorReturnId(id);
        vrEdit.setVendorReturnNo(vrEdit.getVendorReturnNoEditt());
        vrEdit.setVendorReturnDate(
            dateService.dateFormat(
                dateService.dateParse(vrEdit.getVendorReturnDateEditt(), "au"), "au"));
        vrEdit.setReference(vrEdit.getReferenceEditt());
        vrEdit.setDescription(vrEdit.getDescriptionEditt());
        vrEdit.setPurchaseOrderId(vrEdit.getPurchaseOrderIdEditt());
        vrEdit.setGoodsReceiptId(vrEdit.getGoodsReceiptIdEdit());
        vrLines = new ArrayList<VendorReturnLine>();
        List<Float> newQty = new ArrayList<Float>();

        int[] vrIdUpdate = vrEdit.getVendorReturnLineIdEditt();
        String[] bno = vrEdit.getBatchNoEdit();
        String materialedit = vrEdit.getmIdEditt();
        List<String> meditlist = Arrays.asList(materialedit.split(","));
        Object[] materialiidedit = meditlist.toArray();

        Integer[] quantity = vrEdit.getQuantityEditt();

        String unitedit = vrEdit.getUommEditt();
        List<String> uomeditlist = Arrays.asList(unitedit.split(","));
        Object[] uomidedit = uomeditlist.toArray();

        float[] price = vrEdit.getPriceEditt();

        String rfredit = vrEdit.getRfrIdEditt();
        List<String> rfreditlist = Arrays.asList(rfredit.split(","));
        Object[] rfridedit = rfreditlist.toArray();

        String storageedit = vrEdit.getUommEditt();
        List<String> storageeditlist = Arrays.asList(storageedit.split(","));
        Object[] storageidedit = storageeditlist.toArray();

        String idQL = null;

        if (quantity != null) {
          session = request.getSession(false);
          @SuppressWarnings("unchecked")
          List<Float> oldQty = (List<Float>) session.getAttribute("qtyList");
          for (int i = 0; i < quantity.length; i++) {
            int kk = vrIdUpdate[i];
            // get the Qtys
            ob =
                vrService.getRejQty(
                    Integer.parseInt(vrEdit.getPurchaseOrderId()),
                    Integer.parseInt(vrEdit.getGoodsReceiptId()),
                    materialiidedit[i].toString(),
                    bno[i]);

            if (kk == 0) {
              vrLine = new VendorReturnLine();
              vrLine.setBatchNo(bno[i]);
              vrLine.setMaterial_Id(materialiidedit[i].toString());
              vrLine.setQuantity(quantity[i]);

              /*
               * float afterEdit = vrLine.getQuantity(); int
               * materialId = Integer.parseInt(vrLine
               * .getMaterial_Id()); float finalStock = 0;
               * finalStock = stockEdit - afterEdit;
               *
               * materialService.materialStockUpdate(materialId,
               * finalStock);
               */
              vrLine.setUom_Id(uomidedit[i].toString());
              vrLine.setPrice(price[i]);
              vrLine.setReasonForRejectionId(rfridedit[i].toString());
              vrLine.setStorageLocationId(storageidedit[i].toString());
              vrLines.add(vrLine);
              // update qty returns in GRL
              if (ob != null) {
                Iterator<Object[]> itr = ob.iterator();
                while (itr.hasNext()) {
                  Object[] obj = (Object[]) itr.next();
                  if (obj[0] != null && obj[1] != null) {
                    rejQty = (Float) obj[0];
                    returnQty = (Float) obj[1];
                  } else if (obj[0] != null) {
                    rejQty = (Float) obj[0];
                  }
                }
                diffQty = returnQty + quantity[i].floatValue();
                // update qty returns in GRL
                vrService.updateGRLQtyReturns(
                    Integer.parseInt(vrEdit.getGoodsReceiptIdEdit()),
                    materialiidedit[i].toString(),
                    String.valueOf(bno[i]),
                    diffQty);
              }

            } else {

              vrLine = new VendorReturnLine();
              vrLine.setBatchNo(bno[i]);
              vrLine.setMaterial_Id(materialiidedit[i].toString());
              vrLine.setQuantity(quantity[i]);
              vrLine.setUom_Id(uomidedit[i].toString());
              vrLine.setPrice(price[i]);
              vrLine.setReasonForRejectionId(rfridedit[i].toString());
              vrLine.setStorageLocationId(storageidedit[i].toString());

              newQty.add((float) (quantity[i]));
              String ch = "1", ch1 = "0";
              idQL = request.getParameter(kk + "Check");
              if (ch.equals(idQL)) {
                vrService.deleteVendorReturnLine(kk);
              }
              if (ch1.equals(idQL) || idQL == null) {
                vrLines.add(vrLine);
              }

              if (oldQty.get(i) > (newQty.get(i))) {
                qty = oldQty.get(i) - newQty.get(i);
                if (ob != null) {
                  Iterator<Object[]> itr = ob.iterator();
                  while (itr.hasNext()) {
                    Object[] obj = (Object[]) itr.next();
                    if (obj[0] != null && obj[1] != null) {
                      rejQty = (Float) obj[0];
                      returnQty = (Float) obj[1];
                    } else if (obj[0] != null) {
                      rejQty = (Float) obj[0];
                    }
                  }
                  diffQty = returnQty - qty;
                  // update qty returns in GRL
                  vrService.updateGRLQtyReturns(
                      Integer.parseInt(vrEdit.getGoodsReceiptIdEdit()),
                      materialiidedit[i].toString(),
                      String.valueOf(bno[i]),
                      diffQty);
                }
              } else if (oldQty.get(i) < (newQty.get(i))) {
                qty = newQty.get(i) - oldQty.get(i);
                if (ob != null) {
                  Iterator<Object[]> itr = ob.iterator();
                  while (itr.hasNext()) {
                    Object[] obj = (Object[]) itr.next();
                    if (obj[0] != null && obj[1] != null) {
                      rejQty = (Float) obj[0];
                      returnQty = (Float) obj[1];
                    } else if (obj[0] != null) {
                      rejQty = (Float) obj[0];
                    }
                  }

                  diffQty = returnQty + qty;
                  // update qty returns in GRL
                  vrService.updateGRLQtyReturns(
                      Integer.parseInt(vrEdit.getGoodsReceiptIdEdit()),
                      materialiidedit[i].toString(),
                      String.valueOf(bno[i]),
                      diffQty);
                }

              } else { // Two Quantitys are Equal No update... }

              }
            }
          }
        }
        vrEdit.setVendorReturnLine(vrLines);
        msg = vrService.updateVendorReturn(vrEdit);

        request.setAttribute("updateVendorReturn", "Vendor Return Details Updated Successfully");
      } catch (Exception e) {
        e.printStackTrace();
      }
      if (msg.equals("Vendor Return Details Updated Successfully")) {
        vendorReturnUpdate = "Vendor Return Details Updated Successfully";
        list.add("2");
      } else {
        return "redirect:VendorReturn.mnt?updateFail=" + vendorReturnUpdate + "";
      }

      model.addAttribute("vendorReturnCommand", new VendorReturn());

      return "redirect:VendorReturn.mnt?updateSuccess=" + vendorReturnUpdate + "";
    } else {

      request.setAttribute("vrEditList", "vrEditList");
      return "redirect:VendorReturn.mnt?updateFail=" + vendorReturnUpdate + "";
    }
  }
  /*
   * =====================================Edit
   * Method==============================
   */
  @RequestMapping(value = "/vendorReturnIdEdit1", method = RequestMethod.GET)
  @Scope("request")
  public String vendorReturnEdit(
      @ModelAttribute VendorReturn vendorReturnIdEdit1,
      BindingResult result,
      HttpServletRequest request,
      HttpServletResponse response,
      Model model) {
    response.setCharacterEncoding("UTF-8");
    List<Float> qtyList = new ArrayList<Float>();
    List<Object> list = null;
    List<VendorReturn> vrEditList = new ArrayList<VendorReturn>();
    List<VendorReturnLine> vrLineEditList = new ArrayList<VendorReturnLine>();
    int vrid = vendorReturnIdEdit1.getVendorReturnId();

    try {

      list = vrService.editVendorReturnWithId(vrid);

      Iterator<Object> iterator = list.iterator();

      if (iterator.hasNext()) {
        Object vrObj = iterator.next();
        VendorReturn vr = (VendorReturn) vrObj;

        vendorReturnIdEdit1.setVendorReturnIdEditt(vr.getVendorReturnId());
        vendorReturnIdEdit1.setVendorReturnNoEditt(vr.getVendorReturnNo());
        vendorReturnIdEdit1.setVendorReturnDateEditt(
            dateService.dateFormat(dateService.dateParse(vr.getVendorReturnDate(), "se"), "se"));
        vendorReturnIdEdit1.setReferenceEditt(vr.getReference());
        vendorReturnIdEdit1.setDescriptionEditt(vr.getDescription());
        vendorReturnIdEdit1.setPurchaseOrderIdEditt(vr.getPurchaseOrderId());
        vendorReturnIdEdit1.setGoodsReceiptIdEdit(vr.getGoodsReceiptId());

        List<VendorReturnLine> listEdit = vr.getVendorReturnLine();

        Iterator<VendorReturnLine> iterator1 = listEdit.iterator();
        while (iterator1.hasNext()) {
          Object vrLineObj = iterator1.next();
          VendorReturnLine vrLine = (VendorReturnLine) vrLineObj;
          VendorReturnLine vrMultiple = new VendorReturnLine();
          vrMultiple.setVendorReturnLineId(vrLine.getVendorReturnLineId());

          int materialId = Integer.parseInt(vrLine.getMaterial_Id());

          int previousUpdatedStock;
          previousUpdatedStock = materialService.materialStockGet(materialId);

          int materialQtyInEditField = (int) (vrLine.getQuantity());
          int stockEdit = previousUpdatedStock + materialQtyInEditField;

          vrMultiple.setStockEdit(stockEdit);

          Material material = vrLine.getMaterialDetails();
          Uom uom = vrLine.getUomDetails();
          ReasonForRejection rfr = vrLine.getRfrDetails();
          StorageLocation storage = vrLine.getStorageDetails();

          vrMultiple.setMaterial_IdEditt((vrLine.getMaterial_Id()));
          vrMultiple.setMaterialName(material.getMaterialName());
          vrMultiple.setQuantityEditt((vrLine.getQuantity()));

          vrMultiple.setBatchNoEdit(vrLine.getBatchNo());
          vrMultiple.setUom_IdEditt(vrLine.getUom_Id());
          vrMultiple.setUomName(uom.getUom());
          vrMultiple.setPriceEditt(vrLine.getPrice());
          vrMultiple.setReasonForRejectionIdEditt(vrLine.getReasonForRejectionId());
          vrMultiple.setRfrName(rfr.getReasonForRejection());
          vrMultiple.setStorageLocationIdEditt(vrLine.getStorageLocationId());
          vrMultiple.setStorageName(storage.getStorageLocation());
          vrLineEditList.add(vrMultiple);
          qtyList.add((float) vrLine.getQuantity());
        }
        vrEditList.add(vendorReturnIdEdit1);
      }

      model.addAttribute("vendorReturnCommand", vendorReturnIdEdit1);
      session = request.getSession(false);
      session.setAttribute("qtyList", qtyList);
      request.setAttribute("vrEditList", vrEditList);
      request.setAttribute("vrLineEditList", vrLineEditList);

    } catch (Exception e) {
      e.printStackTrace();
    }
    return "vendorReturnHome";
  }
  @RequestMapping(value = "/vendorReturnAdvanceSearchOperations", method = RequestMethod.POST)
  public String vendorReturnAdvanceSearchOperations(
      @ModelAttribute("vendorReturnCommand") VendorReturn vendorReturn,
      HttpServletRequest request,
      HttpServletResponse response,
      Model model) {

    vr1 = new ArrayList<VendorReturn>();
    String columns = vendorReturn.getFirstLabel();
    String operations = vendorReturn.getOperations1();
    String advanceSearchText = vendorReturn.getAdvanceSearchText();

    if (advanceSearchText.length() != 0) {
      objectsArray = vrService.getVendorReturnAdvance(columns, operations, advanceSearchText);
    } else {
      objectsArray = vrService.getVendorReturn("ALL");
    }
    iterator = objectsArray.iterator();
    while (iterator.hasNext()) {

      VendorReturn vr = (VendorReturn) iterator.next();
      vr.setVendorReturnId(vr.getVendorReturnId());
      vr.setVendorReturnNo(vr.getVendorReturnNo());
      vr.setVendorReturnDate(vr.getVendorReturnDate());
      vr.setReference(vr.getReference());
      vr.setDescription(vr.getDescription());
      vr1.add(vr);
    }

    request.setAttribute("vendorReturnSearch", vr1);
    model.addAttribute("vendorReturn", new VendorReturn());
    vendorReturn.setAdvanceSearchHidden(0);
    return "vendorReturnHome";
  }
  @RequestMapping(value = "/vendorReturnSearch", method = RequestMethod.GET)
  @Scope("request")
  public ModelAndView searchVendorReturn(
      @ModelAttribute("vendorReturnCommand") VendorReturn vendorReturnSearch,
      BindingResult bindingResult,
      HttpServletRequest request,
      HttpServletResponse response) {
    response.setCharacterEncoding("UTF-8");
    List<VendorReturn> vrlist = new ArrayList<VendorReturn>();
    List<Object> list = null;
    List<Object> lob = null;
    try {

      String dbField = vendorReturnSearch.getXmlLabel();
      String operation = vendorReturnSearch.getOperations();
      String basicSearchId = vendorReturnSearch.getBasicSearchId();

      if (operation.equals("_%")) {
        operation = " like ";
        basicSearchId = basicSearchId + "%";

      } else if (operation.equals("%_")) {
        operation = " like ";
        basicSearchId = "%" + basicSearchId;

      } else if (operation.equals("%_%")) {
        operation = " like ";
        basicSearchId = "%" + basicSearchId + "%";
      }
      if (basicSearchId == "") {

        lob = vrService.searchVendorReturn();

        Iterator<Object> iterator = lob.iterator();

        while (iterator.hasNext()) {
          VendorReturn vr = (VendorReturn) iterator.next();
          vr.setVendorReturnId(vr.getVendorReturnId());
          vr.setVendorReturnNo(vr.getVendorReturnNo());
          vr.setVendorReturnDate(
              dateService.dateFormat(dateService.dateParse(vr.getVendorReturnDate(), "se"), "se"));
          vr.setReference(vr.getReference());
          vr.setDescription(vr.getDescription());
          vr.setBatchNo(vr.getBatchNo());

          vrlist.add(vr);
        }

      } else {

        list = vrService.basicSearchVendorReturn(dbField, operation, basicSearchId);
        Iterator<Object> iter = list.iterator();

        while (iter.hasNext()) {
          VendorReturn vr = (VendorReturn) iter.next();
          vr.setVendorReturnId(vr.getVendorReturnId());
          vr.setVendorReturnNo(vr.getVendorReturnNo());
          vr.setVendorReturnDate(
              dateService.dateFormat(dateService.dateParse(vr.getVendorReturnDate(), "se"), "se"));
          vr.setReference(vr.getReference());
          vr.setDescription(vr.getDescription());
          vr.setBatchNo(vr.getBatchNo());
          vrlist.add(vr);
        }
      }

    } catch (Exception e) {
      e.printStackTrace();
    }
    request.setAttribute("vendorReturnSearch", vrlist);
    ModelAndView modelAndView = new ModelAndView();
    modelAndView.setViewName("vendorReturnHome");
    modelAndView.addObject("vendorReturnCommand");

    return modelAndView;
  }
  /* ================================Add Method========================== */
  @RequestMapping(value = "/vendorReturn", method = RequestMethod.GET)
  public String addVendorReturn(
      @ModelAttribute("vendorReturnCommand") VendorReturn vendorReturnAdd,
      HttpServletRequest request,
      HttpServletResponse response,
      Model model) {

    response.setCharacterEncoding("UTF-8");
    List<String> list = new ArrayList<String>();
    VendorReturnLine vrLine = null;
    List<VendorReturnLine> vrLines = null;
    String vrAddSus = null;
    String msg = null;

    String checkVrNo = vendorReturnAdd.getVendorReturnNo();
    int list1 = vrService.checkDuplicate(checkVrNo);
    if (list1 == 0) {

      try {

        vrLines = new ArrayList<VendorReturnLine>();

        String material = vendorReturnAdd.getmId();
        String[] bNo = vendorReturnAdd.getBatchNo();
        List<String> mlist = Arrays.asList(material.split(","));
        Object[] materialiid = mlist.toArray();

        Integer[] quantity = vendorReturnAdd.getQuantity();
        String unit = vendorReturnAdd.getUomm();
        List<String> uomlist = Arrays.asList(unit.split(","));
        Object[] uomid = uomlist.toArray();

        float[] price = vendorReturnAdd.getPrice();

        String rfr = vendorReturnAdd.getRfrId();
        List<String> rfrlist = Arrays.asList(rfr.split(","));
        Object[] rfrid = rfrlist.toArray();

        String storage = vendorReturnAdd.getStLId();
        List<String> storagelist = Arrays.asList(storage.split(","));
        Object[] storageid = storagelist.toArray();

        for (int i = 0; i < quantity.length; i++) {
          vrLine = new VendorReturnLine();
          vrLine.setMaterial_Id(materialiid[i].toString());
          vrLine.setQuantity(quantity[i]);
          vrLine.setUom_Id(uomid[i].toString());
          vrLine.setPrice(price[i]);
          vrLine.setReasonForRejectionId(rfrid[i].toString());
          vrLine.setStorageLocationId(storageid[i].toString());
          vrLine.setBatchNo(bNo[i]);
          vrLines.add(vrLine);

          float enteredQty = vrLine.getQuantity();
          int materialid = Integer.parseInt(vrLine.getMaterial_Id());
          float materialStock;
          materialStock = materialService.materialStockGet(materialid);
          float updatedStock = 0;
          updatedStock = materialStock - enteredQty;
          // msg =
          // materialService.materialStockUpdate(materialid,updatedStock);
          // Update Goods Receipt Line Returns Qty
          vrService.updateGRLQtyReturns(
              Integer.parseInt(vendorReturnAdd.getGoodsReceiptId()),
              materialiid[i].toString(),
              String.valueOf(bNo[i]),
              quantity[i].floatValue());
        }
        vendorReturnAdd.setVendorReturnDate(
            dateService.dateFormat(
                dateService.dateParse(vendorReturnAdd.getVendorReturnDate(), "au"), "au"));
        vendorReturnAdd.setVendorReturnLine(vrLines);
        msg = vrService.addVendorReturn(vendorReturnAdd);
        request.setAttribute("addVendorReturn", "Vendor Return Details Successfully Saved");
      } catch (Exception e) {
        e.printStackTrace();
      }

      if (msg.equals("S")) {
        session = request.getSession(false);
        Date dates = new Date();
        String modifiedDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(dates);
        auditLogService.setAuditLogSave(
            session.getAttribute("userId").toString(),
            "A",
            "Vendor Returns",
            "ROW",
            String.valueOf(vendorReturnAdd.getVendorReturnId()),
            "1",
            modifiedDate,
            session.getAttribute("userName").toString());
        vrAddSus = "Vendor Return Details Successfully Saved";
        list.add("2");
      }
      model.addAttribute("vendorReturnCommand", new VendorReturn());

      return "redirect:VendorReturn.mnt?Addsuccess=" + vrAddSus + "";

    } else {
      vendorReturnAdd.setAid(1);

      request.setAttribute(
          "addVendorReturnDuplicate", "Vendor Return No Already Exists Choose Another One");
      return "redirect:VendorReturn.mnt?AddFail=" + vrAddSus + "";
    }
  }