package com.nanometer.smartlab.controller;

import com.nanometer.smartlab.dao.BaseMetaDao;
import com.nanometer.smartlab.dao.OpeApplyDao;
import com.nanometer.smartlab.dao.OpeReagentStatusDao;
import com.nanometer.smartlab.dao.OpeWarehouseReserveDao;
import com.nanometer.smartlab.entity.*;
import com.nanometer.smartlab.entity.dto.ApplyListDto;
import com.nanometer.smartlab.entity.enumtype.*;
import com.nanometer.smartlab.exception.BusinessException;
import com.nanometer.smartlab.exception.ExceptionEnumCode;
import com.nanometer.smartlab.service.*;
import com.nanometer.smartlab.util.*;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.primefaces.context.RequestContext;
import org.primefaces.event.SelectEvent;
import org.primefaces.event.TabChangeEvent;
import org.primefaces.model.LazyDataModel;
import org.primefaces.model.SortOrder;
import org.primefaces.model.StreamedContent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URLEncoder;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;

/**
 * Created by cmower on 17/11/20.
 */
@PropertySource(value = "WEB-INF/config.properties",encoding = "utf-8")
@Controller
@Scope("session")
public class WarehouseStockMngController extends BaseController {

	private static final long serialVersionUID = 101543880938627455L;

	private static Logger logger = Logger.getLogger(WarehouseStockMngController.class);

    @Resource
    private OpeApplyService opeApplyService;

	@Resource
	private OpeWarehouseReserveService opeWarehouseReserveService;
	@Resource
	private OpeReagentStatusService opeReagentStatusService;
	@Resource
	private SysReagentService sysReagentService;
	@Resource
	private SysUserService sysUserService;
	@Resource
	private SysSupplierService sysSupplierService;
	@Resource
	private OpeOrderService opeOrderService;
	@Resource
	private BaseMetaDao baseMetaDao;

	@Resource
	private MenuController menuController;

    @Resource
    private SysWarehouseService sysWarehouseService;
    @Resource
    private SysWarehouseContainerService sysWarehouseContainerService;
    @Resource
    private BaseMetaService baseMetaService;
    @Resource
    private SysLaboratoryService sysLaboratoryService;
    @Resource
    private SysLaboratoryContainerService sysLaboratoryContainerService;

    @Resource(name = "opeReagentStatusDao")
	OpeReagentStatusDao opeReagentStatusDao;
	@Resource
	OpeUseFlowService opeUseFlowService;

    @Resource
	OpeWarehouseReserveDao opeWarehouseReserveDao;
    @Resource
	OpeApplyDao opeApplyDao;

    @Resource
	OpeLaboratoryReserveService opeLaboratoryReserveService;
	/**
	 * 数据源
	 */
	private LazyDataModel<OpeWarehouseReserve> dataModel;

	/**
	 * 数据源
	 */
	private LazyDataModel<OpeApplyReserve> dataModelForPerson;

	/**
	 * 使用记录用
	 */
	private LazyDataModel<OpeReagentStatus> reagentStatusDataModel;
	/**
	 * 打开条形码对话框用
	 */
	private List<OpeReagentStatus> reagentStatusSelectList;

	/**
	 * 打开条形码对话框用
	 */
	private List<OpeReagentStatus> reagentStatusSelectListForPerson;
	/**
	 *打开条形码对话框用
	 */
	private Map<String,Map<String,OpeWarehouseReserve>> warehouseReserveUseTmp=new HashMap<>();
	/**
	 * 打开条形码对话框用
	 */
	private List<OpeWarehouseReserve> warehouseReserveList = new ArrayList<>();

	/**
	 * 打开条形码对话框用
	 */
	private OpeWarehouseReserve opeWarehouseReserve = new OpeWarehouseReserve();


	public List<OpeReagentStatus> getReagentStatusSelectListForPerson() {
		return reagentStatusSelectListForPerson;
	}

	public void setReagentStatusSelectListForPerson(List<OpeReagentStatus> reagentStatusSelectListForPerson) {
		this.reagentStatusSelectListForPerson = reagentStatusSelectListForPerson;
	}

	private String reagentId;
	private String reagentLogId;

	private String userName;
	private Integer tabValue = 0;

	private List<SysReagent> reagentSelectList;
	private List<String> showCodes;
	private String userId;
	private String projectNum;
	private String userLogId;
	private String reagentCode;
	private Integer useNum;
	private String startReagentCode;
	private String endReagentCode;
	private String startReagentCodeForPerson;
	private String endReagentCodeForPerson;
	private String warehouseName;

	private Integer editFlag;
	private Integer isAllApply = 0;
	private StreamedContent file;
	@Value("${pdf.export.file.path}")
	private String pdfExportFilePath;
	@Value("${institute.name}")
	String instituteName;

	private boolean isExpired;

	private Hashtable printTable;
	@Autowired
	private AccountInAndOutService accountInAndOutService;

	public Hashtable getPrintTable() {
		return printTable;
	}

	public StreamedContent getFile() {
		return file;
	}

	public void setFile(StreamedContent file) {
		this.file = file;
	}

	public Integer getEditFlag() {
		return editFlag;
	}

	public void setEditFlag(Integer editFlag) {
		this.editFlag = editFlag;
	}

	public String getStartReagentCodeForPerson() {
		return startReagentCodeForPerson;
	}

	public void setStartReagentCodeForPerson(String startReagentCodeForPerson) {
		this.startReagentCodeForPerson = startReagentCodeForPerson;
	}

	public String getEndReagentCodeForPerson() {
		return endReagentCodeForPerson;
	}

	public void setEndReagentCodeForPerson(String endReagentCodeForPerson) {
		this.endReagentCodeForPerson = endReagentCodeForPerson;
	}

	private List<SysUser> userSelectList;
	private List<SysUser> applyUserSelectList;
	private String supplierId;
	private List<SysSupplier> supplierSelectList;
	//private boolean flag = false;
	//领用单号
	private String receiptNumber;
	//备注
	private String note;
	// 试剂库
    private LazyDataModel<SysReagent> reagentDataModel;
	// 直接入库试剂List
	private List<OpeApply> reagentDStoreList;
	// 直接入库试剂已选List
	private List<OpeApply> reagentDStoreSelectedList;
    // 直接入库试剂编辑flag(1: 新建 2:修改)
    private int reagentDStoreEditFlag = Constants.ACTION_ADD;
    // 直接入库试剂
    private OpeApply reagentDStore;
    private String applyNewReagentName;
    private String applyNewCas;
    private String productSn;
	private String applyCode;
	private Integer status;
	private List<ApplyStatusVo> statusSelectList;

    private List<SysWarehouse> warehouseList;
    private List<SysWarehouseContainer> warehouseContainerList;
    private List<BaseMeta> warehouseContainerPlaceList;
    private Map<String, String> warehouseNameMap;
    private Map<String, SysWarehouseContainer> warehouseContainerMap;
    private Map<String, List<SysWarehouseContainer>> warehouseIdContainerMap;

    private String laboratoryId;
    private String oriLaboratoryId;
    private List<SysLaboratory> laboratory;
    private String laboratoryContainerId;
    private List<SysLaboratoryContainer> laboratoryContainers;

	/**
	 * 选中的list
	 */
	private List<OpeWarehouseReserve> selectedList;
	//购物车
	private List<OpeWarehouseReserve> selectedTmpList;
	//
	private List<OpeWarehouseReserve> trulySelectedList;

	/**
	 * 选中的list
	 */
	private List<OpeApplyReserve> selectedListForPerson;
	private List<OpeApplyReserve> selectedTmpOrderList;
	private List<OpeApplyReserve> trulySelectedOrderList;
	/**
	* 入库车
	*/
	private List<OpeApplyReserve> selectedInputStorageTmpOrderList;
	private List<OpeApplyReserve> trulyInputStorageTmpSelectedOrderList;
	/**
	 * 订单入库变量
	 */
	//到货时间
	private Timestamp arrivalTime;
	//收货人
	private String consigneeId;
	//OpeApply
	private List<OpeApplyReserve> opeApplyList;
	/**
	 * 条形码对话框中选择的条形码集合
	 */
	private List<String> reagentCodeSelectedList;
	/**
	 * 打开条形码对话框对应的试剂+条形码
	 */
	private OpeWarehouseReserve selectedOpeWarehouseReserve;

	/**
	 * 打开条形码对话框对应的试剂+条形码
	 */
	private OpeApplyReserve selectedOpeApplyReserve;

	/**
	 * SpringMenu中初始化
	 */
	public void initPage() {
		logger.info("WarehouseStockMngController initPage start");
		this.initReagentSelectList();
		this.initSupplierSelectList();
		this.initUserSelectList();
	}

	public void initUsePage() {
		logger.info("WarehouseStockMngController initUsePage start");
		this.initUserSelectList();
	}






	public void initDirectStorePage() {
		logger.info("WarehouseStockMngController initDirectStorePage start");
		this.initUserSelectList();

        this.warehouseList = this.sysWarehouseService.getSysWarehouseList(null, null, null, null);
        this.warehouseNameMap = new HashMap<String, String>();
        if (this.warehouseList != null && this.warehouseList.size() > 0) {
            for (SysWarehouse house : this.warehouseList) {
                this.warehouseNameMap.put(house.getId(), house.getName());
            }
        }

        this.warehouseContainerMap = new HashMap<String, SysWarehouseContainer>();
        this.warehouseIdContainerMap = new HashMap<String, List<SysWarehouseContainer>>();
        List<SysWarehouseContainer> warehouseContainerList = this.sysWarehouseContainerService.getSysWarehouseContainerList(null, null, null, null, null);
        if (warehouseContainerList != null && warehouseContainerList.size() > 0) {
            for (SysWarehouseContainer container : warehouseContainerList) {
                warehouseContainerMap.put(container.getId(), container);

                if (!warehouseIdContainerMap.containsKey(container.getWarehouseId())
                        || warehouseIdContainerMap.get(container.getWarehouseId()) == null) {
                    warehouseIdContainerMap.put(container.getWarehouseId(), new ArrayList<SysWarehouseContainer>());
                }
                warehouseIdContainerMap.get(container.getWarehouseId()).add(container);
            }
        }

        this.onWarehouseSelectChange(null);
	}

	public void initInputWarehouse() {
		logger.info("WarehouseStockMngController initInputWarehouse start");
		this.warehouseList = this.sysWarehouseService.getSysWarehouseList(null, null, null, null);
		this.warehouseNameMap = new HashMap<String, String>();
		if (this.warehouseList != null && this.warehouseList.size() > 0) {
			for (SysWarehouse house : this.warehouseList) {
				this.warehouseNameMap.put(house.getId(), house.getName());
			}
		}
		this.warehouseContainerMap = new HashMap<String, SysWarehouseContainer>();
		this.warehouseIdContainerMap = new HashMap<String, List<SysWarehouseContainer>>();
		List<SysWarehouseContainer> warehouseContainerList = this.sysWarehouseContainerService.getSysWarehouseContainerList(null, null, null, null, null);
		if (warehouseContainerList != null && warehouseContainerList.size() > 0) {
			for (SysWarehouseContainer container : warehouseContainerList) {
				warehouseContainerMap.put(container.getId(), container);

				if (!warehouseIdContainerMap.containsKey(container.getWarehouseId())
						|| warehouseIdContainerMap.get(container.getWarehouseId()) == null) {
					warehouseIdContainerMap.put(container.getWarehouseId(), new ArrayList<SysWarehouseContainer>());
				}
				warehouseIdContainerMap.get(container.getWarehouseId()).add(container);
			}
		}

		this.onWarehouseSelectChange(null);
	}

	private void initReagentSelectList() {
		logger.info("WarehouseStockMngController initReagentSelectList start");
		this.setReagentSelectList(this.sysReagentService.getSysReagentList(null, null, null, null,null, null));
	}

	private void initUserSelectList() {
		logger.info("WarehouseStockMngController initUserSelectList start");
		this.setUserSelectList(this.sysUserService.getSysUserList(null, null, null, null, null,null,null));
		/**if(sysUserService.getSysUser(userId) == null)
		{
			this.laboratory = this.sysLaboratoryService.getSysLaboratoryListByDep(this.getUserDepartment());
		}else {
			this.laboratory = this.sysLaboratoryService.getSysLaboratoryListByDep(sysUserService.getSysUser(userId).getDepartment());
		}
		this.laboratoryContainers = this.sysLaboratoryContainerService.getSysLaboratoryContainerList(laboratoryId);**/
	}

	/**
	 * 领用的操作对话框用
	 */
	private void initReagentStatusSelectList() {
		logger.info("WarehouseStockMngController initReagentStatusSelectList start");
		if (selectedOpeWarehouseReserve != null) {
			String reagentId = selectedOpeWarehouseReserve.getReagentId();
			String articleNumber = selectedOpeWarehouseReserve.getArticleNumber();

			this.setReagentStatusSelectList(opeReagentStatusService.getOpeReagentStatusList22(reagentId, articleNumber,
					ArrivalStatus.WAREHOUSE.getKey(), reagentCode, null, null, null));

//			System.out.print("this.getReagentStatusSelectList().size(): " + this.reagentStatusSelectList.size());
//			System.out.print("this.getReagentStatusSelectList().get(0): " + this.reagentStatusSelectList.get(0).getReagentCode());
		}
	}

	/**
	 * 领用的操作对话框用
	 */
	private void initReagentStatusSelectListForPerson() {
		logger.info("WarehouseStockMngController initReagentStatusSelectListForPerson start");
		if (selectedOpeApplyReserve != null) {
			String reagentId = selectedOpeApplyReserve.getReagent().getId();
			String articleNumber = selectedOpeApplyReserve.getArticleNumber();
			System.out.println(reagentId);
			System.out.println(articleNumber);
			System.out.println(reagentCode);
			this.setReagentStatusSelectListForPerson(opeReagentStatusService.getOpeReagentStatusList22(reagentId, articleNumber,
					ArrivalStatus.WAREHOUSE.getKey(), reagentCode, null, null, null));

		}
	}

	private void initSupplierSelectList() {
		logger.info("WarehouseStockMngController initSupplierSelectList start");
		System.out.println(getUser().getSeeFlag().getKey());
		//SysUser u=sysUserService.getSysUser(getUserId());
		//System.out.println(u);
		if (getUser().getSeeFlag().getKey() != SeeFlag.MANAGE.getKey()
				&& getUser().getSeeFlag().getKey() != SeeFlag.LEADING.getKey()) {
			editFlag=0;
		}else{
			editFlag=1;
		}
		this.setSupplierSelectList(this.sysSupplierService.getSysSupplierList());
	}

	private int action;

	public void add() {
		logger.info("WarehouseStockMngController onUseBtnClick start");
		if (this.selectedList == null || this.selectedList.size() == 0) {
			FacesUtils.warn("请选择数据。");
			return;
		}
		if (selectedTmpList !=null && selectedTmpList.size()>0){
			ArrayList<OpeWarehouseReserve> tmp = new ArrayList<>();
			selectedList.forEach(opeWarehouseReserve -> {
				AtomicBoolean flag = new AtomicBoolean(false);
				selectedTmpList.forEach(opeWarehouseReserve1 -> {
					if (opeWarehouseReserve.getId().equals(opeWarehouseReserve1.getId())){
						flag.set(true);
					}

				});
				if(!flag.get()) {
					tmp.add(opeWarehouseReserve);
				}
			});
			selectedTmpList.addAll(tmp);
		}else{
			selectedTmpList = new ArrayList<>();
				selectedTmpList.addAll(selectedList);
		}
	}

	public void addOrder() {
		logger.info("WarehouseStockMngController onUseBtnClick start");
		if (this.selectedListForPerson == null || this.selectedListForPerson.size() == 0) {
			FacesUtils.warn("请选择数据。");
			return;
		}
		if (selectedTmpOrderList !=null && selectedTmpOrderList.size()>0){
			ArrayList<OpeApplyReserve> tmp = new ArrayList<>();
			selectedListForPerson.forEach(opeApplyReserve -> {
				AtomicBoolean flag = new AtomicBoolean(false);
				selectedTmpOrderList.forEach(opeApplyReserve1 -> {
					if (opeApplyReserve.getId().equals(opeApplyReserve1.getId())){
						flag.set(true);
					}

				});
				if(!flag.get()) {
					tmp.add(opeApplyReserve);
				}
			});
			selectedTmpOrderList.addAll(tmp);
		}else{
			selectedTmpOrderList = new ArrayList<>();
			selectedTmpOrderList.addAll(selectedListForPerson);
		}
	}

	public void addInputStorageOrder() {
		if (this.selectedListForPerson == null || this.selectedListForPerson.size() == 0) {
			FacesUtils.warn("请选择数据。");
			return;
		}
		//1.判断非状态为确认的申购单不能入库
		for (OpeApplyReserve opeApplyReserve : this.selectedListForPerson) {
			if (opeApplyReserve.getStatus() != ApplyStatus.SUPPLIER_CONFIRM) {
				FacesUtils.warn("非已确认的数据不能入库。");
				return;
			}
		}
		//2.加入暂存
		if (selectedInputStorageTmpOrderList !=null && selectedInputStorageTmpOrderList.size()>0){
			ArrayList<OpeApplyReserve> tmp = new ArrayList<>();
			selectedListForPerson.forEach(opeApplyReserve -> {
				AtomicBoolean flag = new AtomicBoolean(false);
				selectedInputStorageTmpOrderList.forEach(opeApplyReserve1 -> {
					if (opeApplyReserve.getId().equals(opeApplyReserve1.getId())){
						flag.set(true);
					}

				});
				if(!flag.get()) {
					tmp.add(opeApplyReserve);
				}
			});
			selectedInputStorageTmpOrderList.addAll(tmp);
		}else{
			selectedInputStorageTmpOrderList = new ArrayList<>();
			selectedInputStorageTmpOrderList.addAll(selectedListForPerson);
		}
	}


	public void  clear(){
		selectedTmpList = null;
	}

	public void  clearOrderTmp(){
		selectedTmpOrderList = null;
	}

	public void hideOrderTmp() {
		//清空
		selectedTmpOrderList = null;
		//隐藏
		RequestContext.getCurrentInstance().execute("document.getElementById('showTabOrder').style.display='none'");
	}

	public void  clearInputStorageTmp(){
		selectedInputStorageTmpOrderList = null;
	}

	public void hideInputStorageTmp(){
        selectedInputStorageTmpOrderList = null;

        RequestContext.getCurrentInstance().execute("document.getElementById('putInStorage').style.display='none'");
    }

	public void cancel(){
		if (trulySelectedList == null || trulySelectedList.size()<=0){
			FacesUtils.info("至少选择一个");
			return;
		}

		if (selectedTmpList == null || selectedTmpList.size()<=0){
			FacesUtils.info("至少选择一个");
			return;
		}

			ArrayList<Object> indexs = new ArrayList<>();
        for (OpeWarehouseReserve warehouseReserve : trulySelectedList) {
            for (OpeWarehouseReserve opeWarehouseReserve : selectedTmpList) {
                if (warehouseReserve.getId().equals(opeWarehouseReserve.getId())) {
                    indexs.add(warehouseReserve);
                }
            }
        }

		if (indexs.size()>0){
			indexs.forEach(obj -> {
				selectedTmpList.remove(obj);
			});
		}

	}

	public void hide(){
		selectedTmpList = null;
		RequestContext.getCurrentInstance().execute("document.getElementById('showTab').style.display='none'");
	}
	public void cancelOrderTmp(){
		if (trulySelectedOrderList == null || trulySelectedOrderList.size()<=0){
			FacesUtils.info("至少选择一个");
			return;
		}

		if (selectedTmpOrderList == null || selectedTmpOrderList.size()<=0){
			FacesUtils.info("至少选择一个");
			return;
		}

		ArrayList<Object> indexs = new ArrayList<>();
        for (OpeApplyReserve opeApplyReserve : trulySelectedOrderList) {
            for (OpeApplyReserve applyReserve : selectedTmpOrderList) {
                if (opeApplyReserve.getId().equals(applyReserve.getId())) {
                    indexs.add(opeApplyReserve);
                }
            }
        }

		if (indexs.size()>0){
			indexs.forEach(obj -> {
				selectedTmpOrderList.remove(obj);
			});
		}

	}

	public void cancelInputStorageTmp(){
		if (trulyInputStorageTmpSelectedOrderList == null || trulyInputStorageTmpSelectedOrderList.size()<=0){
			FacesUtils.info("至少选择一个");
			return;
		}

		if (selectedInputStorageTmpOrderList == null || selectedInputStorageTmpOrderList.size()<=0){
			FacesUtils.info("至少选择一个");
			return;
		}

		ArrayList<Object> indexs = new ArrayList<>();
		for (OpeApplyReserve opeApplyReserve : trulyInputStorageTmpSelectedOrderList) {
			for (OpeApplyReserve applyReserve : selectedInputStorageTmpOrderList) {
				if (opeApplyReserve.getId().equals(applyReserve.getId())) {
					indexs.add(opeApplyReserve);
				}
			}
		}

		if (indexs.size()>0){
			indexs.forEach(obj -> {
				selectedInputStorageTmpOrderList.remove(obj);
			});
		}

	}

	public void onUseBtnClick(){
		if (selectedTmpList == null || selectedTmpList.size()<=0){
			FacesUtils.info("至少选择一个");
			return;
		}
		this.userId = getUser().getId();
		this.menuController.goToPage(Constants.PAGE_WAREHOUSE_REAGENT_USE_NEW, Constants.PAGE_WAREHOUSE_STOCK_MNG);
	}
//
	public void onUseBtnClickOrderTmp(){
		warehouseReserveUseTmp = new HashMap<>();
		opeWarehouseReserve = new OpeWarehouseReserve();
		if (selectedTmpOrderList == null || selectedTmpOrderList.size()<=0){
			FacesUtils.info("至少选择一个");
			return;
		}


		//相同的试剂不能再多选
		Set<String> checkTable = new HashSet<>();
		for (OpeApplyReserve oar : selectedTmpOrderList) {
			String reagentId = oar.getReagent().getId();
			if (!checkTable.contains(reagentId)) {
				checkTable.add(reagentId);
			}else{
				FacesUtils.info("相同试剂不能重复选择");
				return;
			}
		}
		checkTable = null;
		//
		this.userId = selectedTmpOrderList.get(0).getApplyUser();
		SysUser sysUser = sysUserService.getSysUser(this.userId);
		if (sysUser == null){
			FacesUtils.info("申领人不存在");
			return;
		}
		this.menuController.goToPage(Constants.PAGE_WAREHOUSE_REAGENT_USE_NEW_PERSON, Constants.PAGE_WAREHOUSE_STOCK_MNG);
	}

	public void onUseBtnClickInputStorageTmp(){
		if (selectedInputStorageTmpOrderList == null || selectedInputStorageTmpOrderList.size()<=0){
			FacesUtils.info("至少选择一个");
			return;
		}
		opeApplyList = new ArrayList<>();
		selectedInputStorageTmpOrderList.forEach(opeApplyReserve -> {
			OpeApplyReserve applyDetail = opeApplyService.getOpeApplyDetail(opeApplyReserve.getId());
			opeApplyList.add(applyDetail);

		});
		//跳转编辑页面
		this.menuController.goToPage(Constants.PAGE_ORDER_INPUT_WAREHOUSE, Constants.PAGE_WAREHOUSE_STOCK_MNG);
	}

	public void onUseBtnClickForPerson() {
		logger.info("WarehouseStockMngController onUseBtnClickForPerson start");
		if (this.selectedListForPerson == null || this.selectedListForPerson.size() == 0) {
			FacesUtils.warn("请选择数据。");
			return;
		}

		this.menuController.goToPage(Constants.PAGE_WAREHOUSE_REAGENT_USE_NEW_PERSON, Constants.PAGE_WAREHOUSE_STOCK_MNG);
	}

	/**
	 * 仓库库存选择操作时，获取条形码
	 */
	public void onReagentCodeBtnClick(OpeWarehouseReserve selectedOpeWarehouseReserve) {
		if (selectedOpeWarehouseReserve == null) {
			FacesUtils.warn("请选择数据。");
			return;
		}

		this.selectedOpeWarehouseReserve = selectedOpeWarehouseReserve;
		this.showCodes = opeReagentStatusService.getReagentCodes(selectedOpeWarehouseReserve.getReagentId());
		// 根据选择的试剂获取对应的条形码
		initReagentStatusSelectList();

		RequestContext.getCurrentInstance().execute("PF('reagentCodeDialog').show()");
	}

	/**
	 * 订单库存选择操作时，获取条形码
	 */
	public void onReagentCodeBtnClickForPerson(OpeApplyReserve selectedOpeApplyReserve) {
		if (selectedOpeApplyReserve == null) {
			FacesUtils.warn("请选择数据。");
			return;
		}

		this.selectedOpeApplyReserve = selectedOpeApplyReserve;

		// 根据选择的试剂获取对应的条形码
		initReagentStatusSelectListForPerson();
		//初始化试剂库存所在仓库仓库
		this.warehouseReserveList = opeWarehouseReserveService.selectWarehouseByReagentIdAndArticleNumber(selectedOpeApplyReserve.getReagent().getId(),selectedOpeApplyReserve.getArticleNumber(),true);
		//初始化第一个库存
		if (warehouseReserveList.size()>0)
			selectChangeReserve(warehouseReserveList.get(0).getWarehouseId());
		//初始化条形码,通过applyReserve保存的条码显示对应试剂的条码
		for (OpeApplyReserve oar : selectedTmpOrderList) {
			if (oar.getReagent().getId().equals(opeWarehouseReserve.getReagentId())) {
				this.endReagentCodeForPerson = oar.getEndReagentCode2();
				this.startReagentCodeForPerson = oar.getStartReagentCode2();
			}
		}
		if (warehouseReserveUseTmp.get(selectedOpeApplyReserve.getReagent().getId()) == null) {
			//初始化库中领用和大小,
			reagentCodeSelectedList = selectedOpeApplyReserve.getReagentCode();
			useNum = selectedOpeApplyReserve.getReagentCode() == null?0: selectedOpeApplyReserve.getReagentCode().size();
			this.endReagentCodeForPerson = null;
			this.startReagentCodeForPerson = null;
		}

		RequestContext.getCurrentInstance().execute("PF('reagentCodeDialogForPerson').show()");
	}
	/**
	* 变换库存
	*/
	public void selectChangeReserve(String  id) {
		if (warehouseReserveList.size() > 0) {
			warehouseReserveList.forEach(owr -> {
				if (owr.getWarehouseId().equals(id)){
					opeWarehouseReserve.setId(owr.getId());
					opeWarehouseReserve.setWarehouseId(id);
					opeWarehouseReserve.setWarehouseName(owr.getWarehouseName());
					opeWarehouseReserve.setReserve(owr.getReserve());
					opeWarehouseReserve.setReagentId(owr.getReagentId());
				}
			});
		}
	}

	/**
	* 补贴条码->添加x仓库的n个试剂
	*/
	public void add2() {

		//0.判断该批次是否再仓库有库存
		if (opeWarehouseReserve.getId() == null) {
			FacesUtils.warn("没有库存");
			return;
		}
		//1.判断领取数量
		if (useNum > opeWarehouseReserve.getReserve()) {
			FacesUtils.warn("领用数量不能超过库存");
			return;
		}
		//2.加入Map
		OpeWarehouseReserve owr = new OpeWarehouseReserve();
		owr.setId(opeWarehouseReserve.getId());
		owr.setWarehouseId(opeWarehouseReserve.getWarehouseId());
		owr.setWarehouseName(opeWarehouseReserve.getWarehouseName());
		owr.setReserve(opeWarehouseReserve.getReserve());
		owr.setReagentId(opeWarehouseReserve.getReagentId());
		owr.setUseNum(useNum);
		if (warehouseReserveUseTmp.get(owr.getReagentId()) == null) {
			Map<String, OpeWarehouseReserve> tmp = new HashMap<>();
			tmp.put(owr.getWarehouseId(), owr);
			warehouseReserveUseTmp.put(owr.getReagentId(), tmp);
		}else{
			warehouseReserveUseTmp.get(owr.getReagentId()).put(owr.getWarehouseId(), owr);
		}
		//变换条码
		btCodeChange();
	}

	/**
	* 取消一个仓库领取
	*/
	public void remove2(OpeWarehouseReserve owr) {
		if (warehouseReserveUseTmp.get(owr.getReagentId()).size() > 0) {
			warehouseReserveUseTmp.get(owr.getReagentId()).remove(owr.getWarehouseId());
			//变换条码
			btCodeChange();
		}
	}

	/**
	*  获取暂存表单
	*/
	public List<OpeWarehouseReserve> getDataTmp() {

		List<OpeWarehouseReserve> list = new ArrayList<>();


		Map<String, OpeWarehouseReserve> dataMap = warehouseReserveUseTmp.
				get(opeWarehouseReserve.getReagentId());
		if (dataMap ==null) {
			return list;
		}
		Set<Map.Entry<String, OpeWarehouseReserve>> entries = dataMap.entrySet();
		for (Map.Entry<String, OpeWarehouseReserve> e : entries) {
			list.add(e.getValue());
		}
		return list;
	}
	/**
	* @Description: 补贴结束条码的生成
	*/
	public void btCodeChange(){
		//1.获取补贴试剂总数
		List<OpeWarehouseReserve> dataTmp = getDataTmp();
		int distance =  dataTmp.stream().mapToInt(item -> item.getUseNum() == null ? 0 : item.getUseNum()).sum();

		//1.如果开始条码为空，距离为0
		if (StringUtils.isBlank(startReagentCodeForPerson)
				|| distance < 1) {
			return;
		}
		//2如果开始条码不为空
		//2.0如果包含字母不等于24位的直接不管
		if (startReagentCodeForPerson.matches(".*\\D+.*")) {
			if (startReagentCodeForPerson.length() ==24 &&
                    startReagentCodeForPerson.matches(".*([A-F]|\\d)+.*") &&
                    startReagentCodeForPerson.substring(startReagentCodeForPerson.length() - 5).matches("\\d{5}")){
				//2.2长度为24位编码的
				BigInteger arrNum = BigInteger.valueOf(distance);
				//后5位随机码
				String randomCode = startReagentCodeForPerson.substring(startReagentCodeForPerson.length() - 5);
				String reagentCodePrefix = startReagentCodeForPerson.substring(0,startReagentCodeForPerson.length() - 5);

				BigInteger startReagentCodeSuffix = new BigInteger(randomCode);
				BigInteger endReagentCodeSuffix = startReagentCodeSuffix.add(arrNum).subtract((new BigInteger("1")));
				String reagentCodeSuffix= autoGenericCode(randomCode, endReagentCodeSuffix);
				endReagentCodeForPerson = (reagentCodePrefix + reagentCodeSuffix);
			}else{
				endReagentCodeForPerson = ("");
			}
		}else{

			BigInteger startReagentCode = new BigInteger(startReagentCodeForPerson);
			//2.1长度不为24位编码
			//数据1
			BigInteger arrNum = BigInteger.valueOf(distance);
			BigInteger code1 = startReagentCode.add(arrNum).subtract(BigInteger.ONE);
			endReagentCodeForPerson = (autoGenericCode(startReagentCodeForPerson, code1));
		}
		//把数据放入applyReserve
		for (OpeApplyReserve oar : selectedTmpOrderList) {
			if (oar.getReagent().getId().equals(this.opeWarehouseReserve.getReagentId())) {
				oar.setEndReagentCode2(endReagentCodeForPerson);
				oar.setStartReagentCode2(startReagentCodeForPerson);
			}
		}
	}




	public void onYesBtnClickForPerson() {
		try {
			//if (this.reagentCodeSelectedList == null || this.reagentCodeSelectedList.size() == 0) {
			//FacesUtils.warn("请选择条形码。");
			//return;
			//}

			if(this.useNum == null || this.useNum <= 0)
			{
				FacesUtils.warn("请输入大于0的领用数量！");
				return;
			}
			System.out.println("====onYesBtnClick======");

			if(this.reagentCodeSelectedList != null){
				if(this.useNum!=this.reagentCodeSelectedList.size()){
					FacesUtils.warn("领用数量与选择的条形码个数不符");
					return;
				}
			}
			// 将当前选择条形码保存到库存中
			for (OpeApplyReserve opeApplyReserve : this.selectedTmpOrderList) {
				if (opeApplyReserve.getId().equals(this.selectedOpeApplyReserve.getId())) {
					//list OpeWarehouseReserve
					//getReserve 总数小于 useNum 报错

					OpeWarehouseReserve wa=opeWarehouseReserveService.getOpeWarehouseReserve(opeApplyReserve.getReagent().getId(),opeApplyReserve.getArticleNumber());
					if(this.useNum > wa.getReserve())
					{
						FacesUtils.warn("库存不够，请确认或申购！");
						return;
					}
					opeApplyReserve.setSelectNum(useNum);
					if(this.reagentCodeSelectedList != null)
					{
						opeApplyReserve.setReagentCode(this.reagentCodeSelectedList);
					}
					opeApplyReserve.setFlag(1);
					//删除前面部分的补贴条码领用显示
					warehouseReserveUseTmp.remove(opeApplyReserve.getReagent().getId());
					endReagentCodeForPerson = null;
					startReagentCodeForPerson = null;
					break;
				}
			}



			//FacesUtils.info("选择条形码个数为" + this.reagentCodeSelectedList.size());
			RequestContext.getCurrentInstance().execute("PF('reagentCodeDialogForPerson').hide()");
		} catch (Exception e) {
			logger.error("操作失败。", e);
			FacesUtils.warn("操作失败。");
		}
	}

	public void onYesBtnClickForPerson2() {
		try {

			//1.获取补贴试剂总数,判断数量
			List<OpeWarehouseReserve> dataTmp = getDataTmp();
			//distance为领用总数
			int distance = dataTmp.stream().mapToInt(item -> item.getUseNum() == null ? 0 : item.getUseNum()).sum();
			if (distance < 1) {
				FacesUtils.warn("请领取试剂");
				return;
			}
			//2.申购单已经领用的数量+当前准备领用的数量不能超过 单子的申请数量
			if (selectedOpeApplyReserve.getNum() < selectedOpeApplyReserve.getUsed() + distance) {
				FacesUtils.warn("当前领用数量超过订单的申请数量");
				return;
			}
			List<String> codeList = opeReagentStatusService
					.checkReagentCode(startReagentCodeForPerson, endReagentCodeForPerson, distance);


			// 将当前选择条形码保存到库存中
			for (OpeApplyReserve opeApplyReserve : this.selectedTmpOrderList) {
				if (opeApplyReserve.getId().equals(this.selectedOpeApplyReserve.getId())) {
					opeApplyReserve.setSelectNum(distance);
					opeApplyReserve.setStartReagentCode2(this.startReagentCodeForPerson);
					opeApplyReserve.setEndReagentCode2(this.endReagentCodeForPerson);
					opeApplyReserve.setReagentCode(codeList);
					opeApplyReserve.setCacheUpdateList(getDataTmp());
					opeApplyReserve.setFlag(0);
					reagentCodeSelectedList = null;
					break;
				}
			}

			//FacesUtils.info("选择条形码个数为" + codeList.size());
			RequestContext.getCurrentInstance().execute("PF('reagentCodeDialogForPerson').hide()");
		} catch (BusinessException e) {
			logger.error("操作失败。", e);
			FacesUtils.warn(e.getMessage());
		} catch (Exception e) {
			logger.error("操作失败。", e);
			FacesUtils.warn("操作失败。");
		}
	}

	public void onYesBtnClick2(){
		try {
			if (this.useNum == null || this.useNum <= 0) {
				FacesUtils.warn("请输入大于0的领用数量！");
				return;
			}
			List<String> codeList = opeReagentStatusService
					.checkReagentCode(startReagentCode, endReagentCode, useNum);

			for (OpeWarehouseReserve opeWarehouseReserve : this.selectedTmpList) {
				if (opeWarehouseReserve.getId().equals(this.selectedOpeWarehouseReserve.getId())) {
					if (this.useNum > opeWarehouseReserve.getReserve()) {
						FacesUtils.warn("库存不够，请确认或申购！");
						return;
					}
					opeWarehouseReserve.setSelectNum(useNum);
					opeWarehouseReserve.setStartReagentCode2(startReagentCode);
					opeWarehouseReserve.setEndReagentCode2(endReagentCode);

					if (codeList != null) {
						opeWarehouseReserve.setReagentCodes(codeList);
					}
					opeWarehouseReserve.setFlag(0);
					break;

				}
			}
			//FacesUtils.info("选择条形码个数为" + codeList.size());
			RequestContext.getCurrentInstance().execute("PF('reagentCodeDialog').hide()");
		} catch (BusinessException e) {
			logger.error(e.getMessage());
			FacesUtils.warn(e.getMessage());
		} catch (Exception e) {
			logger.error("操作失败。", e);
			FacesUtils.warn("操作失败。");
		}
	}

	public void onYesBtnClick() {
		try {

				if (this.reagentCodeSelectedList == null)
			{
				FacesUtils.warn("请领用");
				return;
			}else{
				this.useNum = this.reagentCodeSelectedList.size();
			}

			System.out.println("====onYesBtnClick======");
			// 将当前选择条形码保存到库存中
			for (OpeWarehouseReserve opeWarehouseReserve : this.selectedTmpList) {
				if (opeWarehouseReserve.getId().equals(this.selectedOpeWarehouseReserve.getId())) {
					if(this.useNum > opeWarehouseReserve.getReserve())
					{
						FacesUtils.warn("库存不够，请确认或申购！");
						return;
					}
					opeWarehouseReserve.setSelectNum(useNum);
					if(this.reagentCodeSelectedList != null)
					{
						opeWarehouseReserve.setReagentCodes(this.reagentCodeSelectedList);
					}
					opeWarehouseReserve.setFlag(1);
					break;
				}
			}
			//FacesUtils.info("选择条形码个数为" + this.reagentCodeSelectedList.size());
			RequestContext.getCurrentInstance().execute("PF('reagentCodeDialog').hide()");
		} catch (Exception e) {
			logger.error("操作失败。", e);
			FacesUtils.warn("操作失败。");
		}
	}

	public void onTabChange(TabChangeEvent event) {
		if ("firstTab".equals(event.getTab().getId())) {
			tabValue = 0;
		}else{
			tabValue = 1;
		}
	}


	public void onCancelBtnClick() {
		this.selectedTmpOrderList = null;
		this.selectedTmpList = null;
		this.selectedInputStorageTmpOrderList = null;
		this.endReagentCodeForPerson = null;
		this.startReagentCodeForPerson = null;
		this.laboratoryId = null;
		this.useNum = null;
		this.menuController.backToPage();
	}

	public void onClose(){
		this.selectedTmpOrderList = null;
		this.selectedTmpList = null;
		this.menuController.backToPage();
	}

	public void onResetBtnClick() {
		this.userId = null;
		this.laboratoryId =null;
		this.laboratoryId = null;
	}

	public void onSaveBtnClickForPerson(){
		try {
			if (this.selectedTmpOrderList == null || this.selectedTmpOrderList.size() == 0) {
				FacesUtils.warn("请选择申领试剂。");
				return;
			}

			if (this.userId == null) {
				FacesUtils.warn("请选择申领人。");
				return;
			}

			List<OpeApplyReserve> list=new ArrayList<>();
			List<OpeApplyReserve> list2=new ArrayList<>();
			//int size = 0;
			for(OpeApplyReserve app:this.selectedTmpOrderList){
				if (app.getFlag() == null) {
					FacesUtils.warn("请选择。");
					return;
				}
				if(app.getFlag()==1){
					list.add(app);
				}else {
					list2.add(app);
				}
			}

			//1.1判断库存
			checkReserve(list);
			checkReserve(list2);
			//1.2判断提交的条码是否重复(只有补贴条码需要判断)
			checkReagentCode(list2);
			String receiptNum = new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date());
			//库中领取
			if(list.size()>0&&list!=null){
				//扣库存 对象中的reagentCode存的是id

				for(OpeApplyReserve app:list){
					List<String> reagentCode=app.getReagentCode();
					if(reagentCode!=null && reagentCode.size()>0){
						for(String opeReagentStatusId:reagentCode){
							OpeReagentStatus opeReagentStatus=this.opeReagentStatusService.getOpeReagentStatus(opeReagentStatusId);
							if (!this.opeReagentStatusService.isAllowWarehouseUse(opeReagentStatus)) {
								FacesUtils.warn("只能申领在仓库的试剂。");
								return;
							}
						}
					}
				}

				this.opeWarehouseReserveService.claimForPerson(list, userId,projectNum,laboratoryId,laboratoryContainerId,receiptNum);
			}

			//补贴条码
			if(list2.size()>0&&list!=null){
				List<OpeApply> opeList=new ArrayList<>();
				for(int i=0;i<list2.size();i++){
					OpeApply opeApply=new OpeApply();
					opeApply.setArticleNumber(list2.get(i).getArticleNumber());
					opeApply.setHouseId(laboratoryId);
					opeApply.setContainerId(laboratoryContainerId);
					opeApply.setReagent(list2.get(i).getReagent());
					opeApply.setStartReagentCode(list2.get(i).getStartReagentCode2());
					opeApply.setEndReagentCode(list2.get(i).getEndReagentCode2());
					opeApply.setReagentCodeList(list2.get(i).getReagentCode());
					opeApply.setId(list2.get(i).getId());
					opeList.add(opeApply);
					OpeLaboratoryReserve lr=new OpeLaboratoryReserve();
					lr.setReagentId(list2.get(i).getReagent().getId());
					lr.setHouseId(laboratoryId);
					lr.setContainerId(laboratoryContainerId);
					lr.setReserve(list2.get(i).getSelectNum());
					lr.setUserId(userId);
					lr.setValidFlag(ValidFlag.VALID);
					this.opeLaboratoryReserveService.insert(lr);
				}
				this.opeWarehouseReserveService.reagentDStore3(opeList,userId);

				//扣库存
				opeWarehouseReserveService.btWarehouseReserveReduce(list2);
			}

			for(int i=0;i<list2.size();i++){
				OpeWarehouseReserve opeWarehouseReserve=new OpeWarehouseReserve();
				OpeApplyReserve re=new OpeApplyReserve();
				re.setUsed(list2.get(i).getSelectNum()+list2.get(i).getUsed());
				re.setId(list2.get(i).getId());
				opeApplyDao.updateOpeApplyUsed(re);//修改已领数量
			}

			//更新申购单状态
			for (OpeApplyReserve oar : selectedTmpOrderList) {
				//确认
				if (oar.getStatus() == ApplyStatus.SUPPLIER_CONFIRM) {
					//领用完 就改成已经入库
					if (oar.getNum() == oar.getUsed() + oar.getSelectNum()) {
						opeApplyService.updateOpeApplyInfo(ApplyStatus.STORAGE,null,null, oar.getId());
						//2.2更改订单状态
						OpeOrder oo = opeOrderService.getOrder(oar.getId());
						List<OpeApply> oas = opeOrderService.getOpeApplyListByOrder(oo.getId());
						assert oas.size() > 0;
						//子订单是否全部入库,是则父单为已入库，否则未完成
						boolean flag = oas.stream().allMatch(oa -> oa.getStatus() == ApplyStatus.STORAGE);
						oo.setArrivalTime(arrivalTime);
						if (flag){
							oo.setStatus(ApplyStatus.STORAGE);
							opeOrderService.updateOpeOrderStatus(oo);
						}else{
							oo.setStatus(ApplyStatus.UNCOMPLETED);
							opeOrderService.updateOpeOrder(oo);
						}
					}
				}
			}

			FacesUtils.info("申领成功。");
			//领用单生成
			printTable = null;
			printTable = new Hashtable();
			int sum = 0;
			List<ApplyListDto> applyList = new ArrayList<>();
			SysUser applyPersonInfo = sysUserService.getUser(userId);
			if (applyPersonInfo == null) {
				FacesUtils.warn("申领人不存在或者申领人部门被删除。");
				return;
			}
			printTable.put("head", instituteName);
			printTable.put("title", "领用单");
			printTable.put("applyPerson", applyPersonInfo.getName());
			printTable.put("department", applyPersonInfo.getDepartment());
			printTable.put("date", Utils.now("yyyy-MM-dd"));

			printTable.put("receiptNumber", receiptNum);
			if (StringUtils.isNotBlank(applyPersonInfo.getPhone())){
				printTable.put("phone", applyPersonInfo.getPhone());
			}
			if (StringUtils.isNotBlank(applyPersonInfo.getProject())){
				printTable.put("project", applyPersonInfo.getProject());
			}
			SysLaboratory lab = sysLaboratoryService.getSysLaboratory(laboratoryId);
			printTable.put("lab", lab.getName());
			this.receiptNumber = receiptNum;
			for (OpeApplyReserve oar : selectedTmpOrderList) {
				ApplyListDto lis = new ApplyListDto();
				Map reagentDetail = sysReagentService.getReagentDetail(oar.getReagent().getId());
				lis.setNum(String.valueOf(oar.getSelectNum())); //数量
				lis.setMainMetering(String.format("%s%s", reagentDetail.get("main_metering"), reagentDetail.get("unit")));
				lis.setControlProducts((String) reagentDetail.get("controlProducts"));
				lis.setProductName((String) reagentDetail.get("name"));
				lis.setReagentFormat((String) reagentDetail.get("reagentFormat"));
				lis.setProductCode((String)reagentDetail.get("productCode"));
				lis.setMemo((String)reagentDetail.get("memo"));
				applyList.add(lis);
				sum += oar.getSelectNum();
			}
			applyList.add(new ApplyListDto("合计", "", "", "", "", String.valueOf(sum), ""));
			printTable.put("applyList", applyList);
			//返回
//			onCancelBtnClick();
			RequestContext.getCurrentInstance().execute("PF('printDialog').show()");
		} catch (BusinessException e){
			logger.info(e.getMessage());
			FacesUtils.warn(e.getMessage());
		}
		catch (Exception e) {
			logger.error("操作失败。", e);
			FacesUtils.warn("操作失败。");
		}
	}

	public void receiptNumberChange( ){
	}

	/**
	 * 点击打印  关联所有流向和领用单号e
	 */
	public void associatedFlowReceiptNumber() {
		try {
			opeUseFlowService.updateReceiptNumberByCode(selectedTmpOrderList, receiptNumber, note);
			//弹出打印窗口
			RequestContext.getCurrentInstance().execute("document.getElementById('indirectPrint').click()");
		} catch (Exception e) {
			logger.info(e.getMessage());
		}

	}

	/**
	 * 点击打印  关联所有流向和领用单号e
	 */


	public void associatedFlowReceiptNumber2() {
		try {
			opeUseFlowService.updateReceiptNumberByCode2(selectedTmpList, receiptNumber,note);
			//弹出打印窗口
			RequestContext.getCurrentInstance().execute("document.getElementById('indirectPrint').click()");
		} catch (Exception e) {
			logger.info(e.getMessage());
		}

	}


	public void closeDialog() {
		try {
			opeUseFlowService.updateReceiptNumberByCode(selectedTmpOrderList, receiptNumber,note);
			onCancelBtnClick();
		} catch (Exception e) {
			logger.info(e.getMessage());
		}

	}

	public void closeDialog2() {
		try {
			opeUseFlowService.updateReceiptNumberByCode2(selectedTmpList, receiptNumber,note);
			onCancelBtnClick();
		} catch (Exception e) {
			logger.info(e.getMessage());
		}

	}


	private void checkReserve(List<OpeApplyReserve> list) {
		if (list == null || list.size() < 1) {
			return;
		}
		for (OpeApplyReserve oar : list) {

			boolean flag = (oar.getFlag() != 1);
			List<OpeWarehouseReserve> owr = opeWarehouseReserveService
					.selectWarehouseByReagentIdAndArticleNumber(oar.getReagent().getId(), oar.getArticleNumber(),flag);
			int sum = owr.stream().mapToInt(item -> item.getReserve() == null ? 0 : item.getReserve()).sum();
			//剩余库存不足领取数量
			if (sum < oar.getSelectNum()) {
				throw new BusinessException(ExceptionEnumCode.APPLY_NUM_OVER, "库存已经不够");
			}
		}
	}

	private void checkReagentCode(List<OpeApplyReserve> list){
		if (list == null || list.size() < 1) {
			return;
		}
		Set<String> checkSet = new HashSet<>();
		for (OpeApplyReserve oar : list) {
			List<String> codeList = opeReagentStatusService
					.checkReagentCode(oar.getStartReagentCode2(), oar.getEndReagentCode2(), oar.getSelectNum());
			oar.setReagentCode(codeList);
			if (codeList != null && codeList.size() > 0) {
				for (String code:codeList) {
					if (!checkSet.contains(code)) {
						checkSet.add(code);
					}else{
						throw new BusinessException(ExceptionEnumCode.PARAM_EXIST, "当前订单条码重复,"+code);
					}
				}
			}
		}
	}

	public void btn() {
		System.out.println(printTable);
		RequestContext.getCurrentInstance().execute("PF('printDialog').show()");
	}

	public void printPdf() {
		System.out.println(printTable);




	}
	public void printGasPdf(){
//        if (this.selectedList == null || this.selectedList.size() == 0) {
//            FacesUtils.warn("请选择数据。");
//            return;
//        }
//        if (this.selectedList.size() > 1) {
//            FacesUtils.warn("只能选择一个数据进行打印。");
//            return;
//        }

		/*if(this.selectGas==null){
			FacesUtils.warn("请选择数据。");
			return;
		}*/

		//查询对应的气瓶
		//this.gas = this.gasService.getGasDetail(this.selectGas.getId());
		//打印
		this.createStatementByDocx();
	}

	public void createStatementByDocx(){
		logger.info("start print gas detail A5 docx...");

		FileInputStream in = null;
		OutputStream out = null;

		try {

			WordTemplate t = new WordTemplate();
			FacesContext currentInstance = FacesContext.getCurrentInstance();
			currentInstance.responseComplete();
			ExternalContext etx = currentInstance.getExternalContext();
			HttpServletResponse response = (HttpServletResponse) etx.getResponse();
			HttpServletRequest request = (HttpServletRequest) etx.getRequest();
			String templatePath = request.getRealPath("") + "resources/template.docx";
			//System.out.println(this.getClass().getClassLoader().getResource( File.separator + "template.docx").toURI());
			//File templateFile = new File(this.getClass().getClassLoader().getResource( File.separator + "template.docx").toURI());
			File templateFile = new File(templatePath);
			System.out.println(templatePath);
			t.loadTemplate(templateFile);
			HashMap<String,String> paras = new HashMap<String,String>();
			paras.put("doccorp", instituteName);
			paras.put("doccaption", "危险化学品（气瓶）入所气瓶现场记录单");
			paras.put("dept", "1");
			paras.put("sn", "2");
			paras.put("corp", "3");
			paras.put("vname", "4");
			paras.put("vcode", "5");
			paras.put("vvolume", "6");

			paras.put("secname", "7");
			paras.put("site", "楼号：" + "8" + " - 地址号：" + "9");
			paras.put("statuscode", "10");
			paras.put("mngname", "11");
			paras.put("gendate", "12");
			paras.put("info","13");
			//检查内容
			HashMap<String,WordTemplate.Table> tables = new HashMap<String,WordTemplate.Table>();
			List<String[]> data1 = new ArrayList<String[]>();
			/*List<GasDetailRepoterModel> gasRepoterList = this.customCheckService.getGasDetailRepoter(this.gas.getId());
			if (gasRepoterList != null && gasRepoterList.size() > 0) {
				for (int i = 0; i < gasRepoterList.size(); i++) {
					GasDetailRepoterModel gasDetailRepoterModel = gasRepoterList.get(i);
					gasDetailRepoterModel.setFlagStr(gasDetailRepoterModel.getFlag() == 1 ? "是" : "否");
					gasDetailRepoterModel.setResultStr(gasDetailRepoterModel.getResult() == 1 ? "通过" : "未通过");

					data1.add(new String[]{""+(i+1),gasDetailRepoterModel.getContent(),
							gasDetailRepoterModel.getFlagStr(),gasDetailRepoterModel.getResultStr(),gasDetailRepoterModel.getDetail()});

				}

			}*/

			WordTemplate.Table t1 = new WordTemplate.Table(
					new String[]{"rownum","checkitem","value","result","memo"},data1
			);
			tables.put("mainTable", t1);
			t.replaceDocument(tables, paras);
			String fileName = "危险化学品（气瓶）入所气瓶现场记录单.docx";
			t.saveFile(pdfExportFilePath);

//            FacesUtils.getHttpServletRequest().getSession().setAttribute("PdfFilePath", pdfExportFilePath + fileName);
//            FacesUtils.getHttpServletRequest().getSession().setAttribute("PdfFileName", fileName);
//            FacesUtils.js("window.open('downloadpdf.jsp','_blank');");
//            System.out.println("打印结束");
//            return;
			try {
				response.setHeader("content-disposition", "attachment;filename=" + URLEncoder.encode(fileName, "UTF-8"));
				response.setContentType("application/msword");

				in = new FileInputStream(pdfExportFilePath + fileName);
				// 创建输出流
				out = response.getOutputStream();
				// 缓存区
				byte buffer[] = new byte[1024];
				int len = 0;
				// 循环将输入流中的内容读取到缓冲区中
				while ((len = in.read(buffer)) > 0) {
					out.write(buffer, 0, len);
				}
			} finally {
				// 关闭
				in.close();
				out.close();
			}



		}catch (Exception e){
			logger.info("print gas detail docx 出错了...");
		}finally {
			logger.info("end print gas detail docx...");
		}

	}


	public  void  onSaveBtnClick() {
		try {
			if (this.selectedTmpList == null || this.selectedTmpList.size() == 0) {
				FacesUtils.warn("请选择申领试剂。");
				return;
			}

			if (this.userId == null) {
				FacesUtils.warn("请选择申领人。");
				return;
			}
			//领用单
			printTable = null;
			printTable = new Hashtable();
			List<ApplyListDto> applyList = new ArrayList<>();
			SysUser applyPersonInfo = sysUserService.getUser(userId);
			if (applyPersonInfo == null) {
				FacesUtils.warn("申领人不存在或者申领人部门被删除。");
				return;
			}
			printTable.put("head", instituteName);
			printTable.put("title", "领用单");
			printTable.put("applyPerson", applyPersonInfo.getName());
			printTable.put("department", applyPersonInfo.getDepartment());
			printTable.put("date", Utils.now("yyyy-MM-dd"));
			if (StringUtils.isNotBlank(applyPersonInfo.getPhone())){
				printTable.put("phone", applyPersonInfo.getPhone());
			}
			if (StringUtils.isNotBlank(applyPersonInfo.getProject())){
				printTable.put("project", applyPersonInfo.getProject());
			}
			SysLaboratory lab = sysLaboratoryService.getSysLaboratorySimpleInfo(laboratoryId);
			String receiptNum = new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date());
			printTable.put("receiptNumber", receiptNum);
			printTable.put("lab", lab.getName());
			this.receiptNumber = receiptNum;

			//int size = 0;
			int sum = 0;
			List<OpeWarehouseReserve> list=new ArrayList<>();
			List<OpeWarehouseReserve> list2=new ArrayList<>();
			for (OpeWarehouseReserve selectWarehouseReserve : this.selectedTmpList) {
				if(selectWarehouseReserve.getFlag()==1){
					list.add(selectWarehouseReserve);
				}else{
					if (selectWarehouseReserve.getWarehouseId() == null) {
						FacesUtils.warn("仓库不存在。");
						return;
					}
					list2.add(selectWarehouseReserve);
				}
			}

			//list2为补贴条码,检查条码重复
			ArrayList<String> checkList = new ArrayList<>();
			if (list2.size() > 0) {
				for (OpeWarehouseReserve owr : list2) {
					checkList.addAll(owr.getReagentCodes());
				}
			}

			Set<String> checkTable = new HashSet<>();
			if (checkList.size() > 0) {
				for (String reagentCode : checkList) {
					if (checkTable.contains(reagentCode)) {
						throw new BusinessException(ExceptionEnumCode.PARAM_EXIST, "当前订单条码重复," + reagentCode);
					} else {
						checkTable.add(reagentCode);
					}
				}
			}
			checkTable = null;
			checkList = null;


			if(list.size()>0&&list!=null){
				for (OpeWarehouseReserve selectWarehouseReserve : list) {
					Map reagentDetail = sysReagentService.getReagentDetail(selectWarehouseReserve.getReagentId());
					if (reagentDetail == null) {
						throw new Exception("试剂有误,请联系管理员");
					}
					List<String> reagentCodes = selectWarehouseReserve.getReagentCodes();
					if (reagentCodes != null && reagentCodes.size() > 0)
						for (String opeReagentStatusId : reagentCodes) {
							OpeReagentStatus opeReagentStatus = this.opeReagentStatusService
									.getOpeReagentStatus(opeReagentStatusId);
							if (!this.opeReagentStatusService.isAllowWarehouseUse(opeReagentStatus)) {
								FacesUtils.warn("只能申领在仓库的试剂。");
								return;
							}else {
								opeReagentStatus.setHouseId(laboratoryId);
								opeReagentStatus.setContainerId(laboratoryContainerId);
								this.opeReagentStatusDao.updateOpeReagentStatusDao(opeReagentStatus);//更新试剂状态表
								OpeLaboratoryReserve lr=new OpeLaboratoryReserve();
								lr.setReagentId(selectWarehouseReserve.getReagentId());
								lr.setHouseId(laboratoryId);
								lr.setContainerId(laboratoryContainerId);
								lr.setReserve(selectWarehouseReserve.getSelectNum());
								lr.setUserId(userId);
								lr.setValidFlag(ValidFlag.VALID);
								this.opeLaboratoryReserveService.insert(lr);
							}
							//else {
							//size++;
							//}
						}
					ApplyListDto lis = new ApplyListDto();
					lis.setNum(String.valueOf(selectWarehouseReserve.getSelectNum())); //数量
					lis.setMainMetering(String.format("%s%s", reagentDetail.get("main_metering"), reagentDetail.get("unit")));
					lis.setControlProducts((String) reagentDetail.get("controlProducts"));
					lis.setProductName((String) reagentDetail.get("name"));
					lis.setReagentFormat((String) reagentDetail.get("reagentFormat"));
					lis.setProductCode((String)reagentDetail.get("productCode"));
					lis.setMemo((String)reagentDetail.get("memo"));
					applyList.add(lis);
					sum += selectWarehouseReserve.getSelectNum();
				}

				//if (size == 0) {
				//FacesUtils.warn("未选择一个条形码。");
				//return;
				//}
				this.opeWarehouseReserveService.claim(list, userId,projectNum,receiptNumber);
			}

			if(list2.size()>0&&list2!=null){
				List<OpeApply> opeList=new ArrayList<>();
				//this.opeApplyService.getOpeApplyList(null,null,null,null,null)
				for(int i=0;i<list2.size();i++){
					Map reagentDetail = sysReagentService.getReagentDetail(list2.get(i).getReagentId());
					if (reagentDetail == null) {
						throw new Exception("试剂有误,请联系管理员");
					}
					OpeApply opeApply=new OpeApply();
					opeApply.setArticleNumber(list2.get(i).getArticleNumber());
					opeApply.setHouseId(laboratoryId);
					opeApply.setContainerId(laboratoryContainerId);
					opeApply.setReagent(this.sysReagentService.getSysReagent(list2.get(i).getReagentId()));
					opeApply.setStartReagentCode(list2.get(i).getStartReagentCode2());
					opeApply.setEndReagentCode(list2.get(i).getEndReagentCode2());
					opeApply.setReagentCodeList(list2.get(i).getReagentCodes());
					opeList.add(opeApply);
					OpeLaboratoryReserve lr=new OpeLaboratoryReserve();
					lr.setReagentId(list2.get(i).getReagentId());
					lr.setHouseId(laboratoryId);
					lr.setContainerId(laboratoryContainerId);
					lr.setReserve(list2.get(i).getSelectNum());
					lr.setUserId(userId);
					lr.setValidFlag(ValidFlag.VALID);
					this.opeLaboratoryReserveService.insert(lr);
					//opeList.add(this.opeApplyService.getOpeApply(list2.get(i).getId()));
					ApplyListDto lis = new ApplyListDto();

					lis.setNum(String.valueOf(list2.get(i).getSelectNum())); //数量
					lis.setMainMetering(String.format("%s%s", reagentDetail.get("main_metering"), reagentDetail.get("unit")));
					lis.setControlProducts((String) reagentDetail.get("controlProducts"));
					lis.setProductName((String) reagentDetail.get("name"));
					lis.setReagentFormat((String) reagentDetail.get("reagentFormat"));
					lis.setProductCode((String)reagentDetail.get("productCode"));
					lis.setMemo((String)reagentDetail.get("memo"));
					applyList.add(lis);

					sum += list2.get(i).getSelectNum();
				}
				this.opeWarehouseReserveService.reagentDStore4(opeList,userId,receiptNum);
				for(int i=0;i<list2.size();i++){

					List<String> reagentCodes = opeReagentStatusService
							.generateReagentCode(list2.get(i).getStartReagentCode2(), list2.get(i).getEndReagentCode2());
					Integer selectNum = list2.get(i).getSelectNum();
					for (int j = 0;j<selectNum;j++){
						// 试剂使用情况入库insert
						OpeUseFlow opeUseFlow = new OpeUseFlow();
						opeUseFlow.setReagentCode(reagentCodes.get(0));
						opeUseFlow.setStatus(ArrivalStatus.WAREHOUSE);
						//仓库信息
						List<OpeWarehouseReserve> warehouseReserveInfo = opeWarehouseReserveService
								.selectWarehouseByRidAndArticleNumberAndWarehouse(list2.get(i).getReagent().getId()
										, list2.get(i).getArticleNumber()
										, list2.get(i).getWarehouseId());
						opeUseFlow.setHouseId(list2.get(i).getWarehouseId());
						opeUseFlow.setContainerId(warehouseReserveInfo.get(0).getContainerId());
						opeUseFlow.setCreateTime(warehouseReserveInfo.get(0).getUpdateTime());
						opeUseFlow.setUserId(warehouseReserveInfo.get(0).getUserId());
						opeUseFlow.setRemainder(list2.get(i).getReagent().getMainMetering()!=null?list2.get(i).getReagent().getMainMetering():new BigDecimal(0));
						opeUseFlow.setStoreType(StoreType.DIRECTSTORE);

						Map<String, String> metaMap = new HashMap<>();
						metaMap.put("groupId", "operate_status");
						metaMap.put("metaKey", String.valueOf(OperateStatus.WAREHOUSEIN.getKey()));
						List<BaseMeta> baseMetaList = baseMetaDao.getBaseMetaList(metaMap);
						opeUseFlow.setOperateState(baseMetaList.get(0).getId());
						this.opeUseFlowService.insertOpeUseFlow(opeUseFlow);
						reagentCodes.remove(0);
					}

					list2.get(i).setReserve(list2.get(i).getReserve()-list2.get(i).getSelectNum());
					opeWarehouseReserveDao.updateOpeWarehouseReserve2(list2.get(i));
				}


				//opeWarehouseReserve.setReserve(opeWarehouseReserve.getReserve()-opeWarehouseReserve.getSelectNum());
				//opeWarehouseReserveDao.updateOpeWarehouseReserve(opeWarehouseReserve);
				//this.opeWarehouseReserveService.claim(list2, userId,projectNum);
			}

			//领用票最后一行
			applyList.add(new ApplyListDto("合计", "", "", "", "", String.valueOf(sum), ""));
			printTable.put("applyList", applyList);

			FacesUtils.info("申领成功。");
			RequestContext.getCurrentInstance().execute("PF('printDialog').show()");
//            this.menuController.goToPage(Constants.PAGE_WAREHOUSE_STOCK_MNG, Constants.PAGE_WAREHOUSE_REAGENT_USE_NEW);
		} catch (BusinessException e) {
			logger.error(e.getMessage(), e);
			FacesUtils.warn(e.getMessage());

		} catch (Exception e) {
			logger.error(e.getMessage(), e);
			FacesUtils.warn("操作失败。");
		}
	}
	/**
	* @Description: 订单入库保存
	*/
	public void onSaveInputWarehouseClick(){
		try{
		    //0.0输入校验
            for (OpeApplyReserve opeApplyReserve : opeApplyList) {
                if (StringUtils.isBlank(opeApplyReserve.getArticleNumber())) {
                    throw new BusinessException(ExceptionEnumCode.PARAM_EXIST, opeApplyReserve.getReagent().getName() + ":批号不能为空");
                }
                SysReagent sysReagent = sysReagentService.getSysReagent(opeApplyReserve.getReagent().getId());
				if (sysReagent == null){
					throw new BusinessException(ExceptionEnumCode.PARAM_EXIST, opeApplyReserve.getReagent().getName() + ":被删除");
				}
            }

			//用来检验提交表单得试剂条码是否重复
			Map<String,Boolean> checkTable= new HashMap<>();
			if (opeApplyList != null && opeApplyList.size() > 0) {
				for (OpeApplyReserve opeApplyReserve:opeApplyList) {
					//0.1获取该申购单的订单
					OpeOrder oo = opeOrderService.getOrder(opeApplyReserve.getId());
					if (oo == null) {
						throw new BusinessException(ExceptionEnumCode.ORDER_ERROR,"订单不存在");
					}
					//0.2检查条码->得到试剂条码列表
					List<String> codeList = opeReagentStatusService
							.checkReagentCode(opeApplyReserve.getStartReagentCode2(), opeApplyReserve.getEndReagentCode2(), opeApplyReserve.getArrivalNum());
					if (codeList != null && codeList.size() > 0) {
						for (String code:codeList) {
							if (checkTable.get(code) == null) {
								checkTable.put(code, true);
							}else{
								throw new BusinessException(ExceptionEnumCode.PARAM_EXIST, "当前订单条码重复,"+code);
							}
						}
					}
				}


				checkTable = null;
				opeApplyService.orderInputWarehouse(opeApplyList,consigneeId,arrivalTime);
			}

			FacesUtils.info("入库完成");
			//返回
			this.onCancelBtnClick();
		}catch (BusinessException e){
			e.printStackTrace();
			FacesUtils.warn(e.getMessage());

		} catch (Exception e) {
			e.printStackTrace();
			FacesUtils.warn("系统异常，操作失败");
		}

	}

	@SuppressWarnings("serial")
	public LazyDataModel<OpeWarehouseReserve> getDataModel() {
		logger.info("WarehouseStockMngController getDataModel start");
		if (this.dataModel == null) {
			this.dataModel = new LazyDataModel<OpeWarehouseReserve>() {
				@Override
				public List<OpeWarehouseReserve> load(int first, int pageSize, String sortField, SortOrder sortOrder,
						Map<String, Object> filters) {
					List<OpeWarehouseReserve> list = null;
					try {
						int count = opeWarehouseReserveService.getOpeWarehouseReserveTotalCountByName(reagentId, supplierId,productSn,warehouseName);
						this.setRowCount(count);
						if (count > 0) {
							list = opeWarehouseReserveService.getOpeWarehouseReserveListByName(reagentId, supplierId, first,
									pageSize,productSn,warehouseName);
						}
					} catch (Exception e) {
						logger.error(e);
					}
					selectedList = null;
					return list;
				}

				@Override
				public OpeWarehouseReserve getRowData(String rowKey) {
//					Iterator<OpeWarehouseReserve> iterator = this.iterator();
//					if (iterator != null) {
//						OpeWarehouseReserve su = null;
//						while (iterator.hasNext()) {
//							su = iterator.next();
//							if (rowKey.equals(su.getId())) {
//								return su;
//							}
//						}
//					}
					return opeWarehouseReserveService.getRowData(rowKey);
				}
			};
		}
		return dataModel;
	}

	@SuppressWarnings("serial")
	public LazyDataModel<OpeApplyReserve> getDataModelForPerson() {
		logger.info("WarehouseStockMngController getDataModelForPerson start: "+this.dataModelForPerson);
		if (this.dataModelForPerson == null) {
			this.dataModelForPerson = new LazyDataModel<OpeApplyReserve>() {
				@Override
				public List<OpeApplyReserve> load(int first, int pageSize, String sortField, SortOrder sortOrder,
						Map<String, Object> filters) {
					List<OpeApplyReserve> list = null;
					SysUser loginUser = getUser();
					String id="";
					if(loginUser.getSeeFlag()==SeeFlag.MANAGE||loginUser.getSeeFlag() ==SeeFlag.LEADING){

					}else {
						//userName=loginUser.getName();
						id=loginUser.getId();
					}

					try {
						int count = opeApplyService.getOpeApplyReserveTotalCountByNameFor(id, reagentId, userName, productSn, applyCode, status, isAllApply,isExpired);
						this.setRowCount(count);
						if (count > 0) {
							list = opeApplyService.getOpeApplyReserveListByNameFor(id, reagentId, userName, first,
									pageSize, productSn, applyCode, status, isAllApply,isExpired);
						}
					} catch (Exception e) {
						logger.error(e);
					}
					selectedListForPerson = null;
					return list;
				}

				@Override
				public OpeApplyReserve getRowData(String rowKey) {
//					Iterator<OpeApplyReserve> iterator = this.iterator();
//					if (iterator != null) {
//						OpeApplyReserve su = null;
//						while (iterator.hasNext()) {
//							su = iterator.next();
//							if (rowKey.equals(su.getId())) {
//								return su;
//							}
//						}
//					}
					return opeApplyService.getOpeApplyReserveListByNameForRowData(rowKey);
				}
			};
		}
		logger.info("WarehouseStockMngController getDataModelForPerson end");
		return dataModelForPerson;
	}

	@SuppressWarnings("serial")
	public LazyDataModel<OpeReagentStatus> getReagentStatusDataModel() {
		logger.info("WarehouseStockMngController getReagentStatusDataModel start");
		if (this.reagentStatusDataModel == null) {
			this.reagentStatusDataModel = new LazyDataModel<OpeReagentStatus>() {
				@Override
				public List<OpeReagentStatus> load(int first, int pageSize, String sortField, SortOrder sortOrder,
						Map<String, Object> filters) {
					List<OpeReagentStatus> list = null;
					try {
						int count = opeReagentStatusService.getLogOpeReagentStatusTotalCount(reagentLogId,
								ArrivalStatus.PERSONAL.getKey(), userLogId, getUser().getId());
						this.setRowCount(count);
						if (count > 0) {
							list = opeReagentStatusService.getLogOpeReagentStatusList(reagentLogId,
									ArrivalStatus.PERSONAL.getKey(), userLogId, getUser().getId(), first, pageSize);
						}
					} catch (Exception e) {
						logger.error(e);
					}
					return list;
				}

				@Override
				public OpeReagentStatus getRowData(String rowKey) {
					Iterator<OpeReagentStatus> iterator = this.iterator();
					if (iterator != null) {
						OpeReagentStatus su = null;
						while (iterator.hasNext()) {
							su = iterator.next();
							if (rowKey.equals(su.getId())) {
								return su;
							}
						}
					}
					return null;
				}
			};
		}
		return reagentStatusDataModel;
	}

	public void onExportFileBtnClickOrder(){
		ServletOutputStream out = null;
		InputStream is = null;
		try {
			FacesContext ctx = FacesContext.getCurrentInstance();
			ctx.responseComplete();
			String contentType = "application/x-download";
			HttpServletResponse response = (HttpServletResponse) ctx
					.getExternalContext().getResponse();
			response.setContentType(contentType);
			StringBuffer contentDisposition = new StringBuffer();
			contentDisposition.append("attachment;");
			contentDisposition.append("filename=\"");
			contentDisposition.append("订单领取导出.xls");
			contentDisposition.append("\"");
			response.setHeader(
					"Content-Disposition",
					new String(contentDisposition.toString().getBytes(
							System.getProperty("file.encoding")), "ISO8859-1"));
			out = response.getOutputStream();
			Map<String, Integer> tempMap = new HashMap<String,Integer>();
			List<OpeApplyReserve> realDataList = new ArrayList<>();
			//map=null;
			SysUser loginUser = getUser();
			String id="";
			if(loginUser.getSeeFlag()==SeeFlag.MANAGE||loginUser.getSeeFlag() == SeeFlag.LEADING){

			}else {
				//userName=loginUser.getName();
				id=loginUser.getId();
			}
			if(selectedListForPerson!=null&&selectedListForPerson.size()>0){
				realDataList=selectedListForPerson;
			}else {
				realDataList = opeApplyService.getOpeApplyReserveListByNameFor(id,reagentId, userName, null,
						null,productSn,applyCode,status,isAllApply,isExpired);
			}
			List<String> headerList = new ArrayList<>();
			headerList.add("申购编号");
			headerList.add("产品编号");
			headerList.add("试剂名称");
			headerList.add("管制品");
			headerList.add("规格型号");
			headerList.add("包装");
			headerList.add("价格");
			headerList.add("CAS");
			headerList.add("危险性质");
			headerList.add("厂家");
			headerList.add("申请数量");
			headerList.add("已领用数量");
			headerList.add("申领人");
			headerList.add("订单状态");
			headerList.add("课题组");
			headerList.add("课题组负责人");
			headerList.add("到货时间");
			HSSFWorkbook hssfWorkbook =exportExcelOrder(headerList, realDataList);
			hssfWorkbook.write(out);
			out.flush();
			ctx.responseComplete();

		}catch (Exception e) {
			if(is!=null){
				try {
					is.close();
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}
			if(out!=null){
				try {
					out.close();
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}
			e.printStackTrace();
		}finally {
			if (is != null) {
				try {
					is.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (out != null) {
				try {
					out.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public  HSSFWorkbook exportExcelOrder(List<String> headerList, List<OpeApplyReserve> dataList){
		HSSFWorkbook hssfWorkbook = new HSSFWorkbook();
		Integer total = null;
		HSSFSheet sheet = hssfWorkbook.createSheet("订单领取导出");
		HSSFRow titlerRow = sheet.createRow(0);
		for(int i = 0; i < headerList.size(); i++) {
			titlerRow.createCell(i).setCellValue(headerList.get(i));
		}
		for (int i = 0; i < dataList.size(); i++) {
			HSSFRow dataRow = sheet.createRow(i + 1);
			dataRow.createCell(0).setCellValue(dataList.get(i).getApplyCode()== null ? "": String.valueOf(dataList.get(i).getApplyCode()));
			dataRow.createCell(1).setCellValue(dataList.get(i).getReagent().getProductSn()== null ? "": String.valueOf(dataList.get(i).getReagent().getProductSn()));
			dataRow.createCell(2).setCellValue(dataList.get(i).getReagent().getName()== null ? "": String.valueOf(dataList.get(i).getReagent().getName()));
			dataRow.createCell(3).setCellValue(dataList.get(i).getReagent().getControlProducts()== null ? "": String.valueOf(dataList.get(i).getReagent().getControlProducts()));
			dataRow.createCell(4).setCellValue(dataList.get(i).getReagent().getReagentFormat()== null ? "": String.valueOf(dataList.get(i).getReagent().getReagentFormat()));
			dataRow.createCell(5).setCellValue(dataList.get(i).getReagent().getMainMetering()== null ? "": String.valueOf(dataList.get(i).getReagent().getMainMetering()));
			dataRow.createCell(6).setCellValue(dataList.get(i).getReagent().getPrice()== null ? "": String.valueOf(dataList.get(i).getReagent().getPrice()));
			dataRow.createCell(7).setCellValue(dataList.get(i).getReagent().getCas()== null ? "": String.valueOf(dataList.get(i).getReagent().getCas()));
			dataRow.createCell(8).setCellValue(dataList.get(i).getReagent().getReagentCharacter()== null ? "": String.valueOf(dataList.get(i).getReagent().getReagentCharacter()));
			dataRow.createCell(9).setCellValue(dataList.get(i).getReagent().getProductHomeName()== null ? "":  String.valueOf(dataList.get(i).getReagent().getProductHomeName()));
			dataRow.createCell(10).setCellValue(dataList.get(i).getNum()== null ? "": String.valueOf(dataList.get(i).getNum()));
			dataRow.createCell(11).setCellValue(dataList.get(i).getUsed()== null ? "": String.valueOf(dataList.get(i).getUsed()));
			dataRow.createCell(12).setCellValue(dataList.get(i).getApplyUserId()== null ? "": String.valueOf(dataList.get(i).getApplyUserId()));
			dataRow.createCell(13).setCellValue(dataList.get(i).getStatus()== null ? "": String.valueOf(dataList.get(i).getStatus().getText()));
			dataRow.createCell(14).setCellValue(dataList.get(i).getProject()== null ? "": String.valueOf(dataList.get(i).getProject()));
			dataRow.createCell(15).setCellValue(dataList.get(i).getProjectManage()== null ? "": String.valueOf(dataList.get(i).getProjectManage()));
			dataRow.createCell(16).setCellValue(dataList.get(i).getArrivalTime()== null ? "": String.valueOf(dataList.get(i).getArrivalTime()));
		}
		return hssfWorkbook;
	}

	public void onExportFileBtnClickNew(){
		ServletOutputStream out = null;
		InputStream is = null;
		try {
			FacesContext ctx = FacesContext.getCurrentInstance();
			ctx.responseComplete();
			String contentType = "application/x-download";
			HttpServletResponse response = (HttpServletResponse) ctx
					.getExternalContext().getResponse();
			response.setContentType(contentType);
			StringBuffer contentDisposition = new StringBuffer();
			contentDisposition.append("attachment;");
			contentDisposition.append("filename=\"");
			contentDisposition.append("仓库库存.xls");
			contentDisposition.append("\"");
			response.setHeader(
					"Content-Disposition",
					new String(contentDisposition.toString().getBytes(
							System.getProperty("file.encoding")), "ISO8859-1"));
			out = response.getOutputStream();
			Map<String, Integer> tempMap = new HashMap<String,Integer>();
			List<OpeWarehouseReserve> realDataList = new ArrayList<>();
			//map=null;
			if(selectedList!=null&&selectedList.size()>0){
				realDataList=selectedList;
			}else {
				realDataList = opeWarehouseReserveService.getOpeWarehouseReserveListByName(reagentId, supplierId, null,
						null,productSn,warehouseName);
			}
				List<String> headerList = new ArrayList<>();
				headerList.add("试剂名称");
				headerList.add("产品编号");
				headerList.add("cas");
				headerList.add("厂家");
				headerList.add("供应商");
				headerList.add("规格");
				headerList.add("包装");
				headerList.add("参考价格");
				headerList.add("批号");
				headerList.add("库存");
				headerList.add("仓库");
				HSSFWorkbook hssfWorkbook =exportExcelNew(headerList, realDataList);
				hssfWorkbook.write(out);
				out.flush();
				ctx.responseComplete();

		}catch (Exception e) {
			if(is!=null){
				try {
					is.close();
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}
			if(out!=null){
				try {
					out.close();
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}
			e.printStackTrace();
		}finally {
			if (is != null) {
				try {
					is.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if (out != null) {
				try {
					out.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}


	public void onExportOutAndIn(){
		FacesContext currentInstance = FacesContext.getCurrentInstance();
		currentInstance.responseComplete();
		ExternalContext etx = currentInstance.getExternalContext();
		HttpServletResponse resp = (HttpServletResponse) etx.getResponse();
		accountInAndOutService.exportExcel(resp);
	}

	public  HSSFWorkbook exportExcelNew(List<String> headerList, List<OpeWarehouseReserve> dataList) {
		HSSFWorkbook hssfWorkbook = new HSSFWorkbook();
		Integer total = null;
		HSSFSheet sheet = hssfWorkbook.createSheet("仓库库存");
		HSSFRow titlerRow = sheet.createRow(0);
		for(int i = 0; i < headerList.size(); i++) {
			titlerRow.createCell(i).setCellValue(headerList.get(i));
		}
		for (int i = 0; i < dataList.size(); i++) {
			HSSFRow dataRow = sheet.createRow(i + 1);
			dataRow.createCell(0).setCellValue(dataList.get(i).getReagent().getName()== null ? "": String.valueOf(dataList.get(i).getReagent().getName()));
			dataRow.createCell(1).setCellValue(dataList.get(i).getReagent().getProductSn()== null ? "": String.valueOf(dataList.get(i).getReagent().getProductSn()));
			dataRow.createCell(2).setCellValue(dataList.get(i).getReagent().getCas()== null ? "": String.valueOf(dataList.get(i).getReagent().getCas()));
			dataRow.createCell(3).setCellValue(dataList.get(i).getReagent().getProductHomeName()== null ? "":  String.valueOf(dataList.get(i).getReagent().getProductHomeName()));
			dataRow.createCell(4).setCellValue(dataList.get(i).getReagent().getSupplierName()== null ? "": String.valueOf(dataList.get(i).getReagent().getSupplierName()));
			dataRow.createCell(5).setCellValue(dataList.get(i).getReagent().getReagentFormat()== null ? "": String.valueOf(baseMetaService.getBaseMetaValue(dataList.get(i).getReagent().getReagentFormat())));
			dataRow.createCell(6).setCellValue(dataList.get(i).getReagent().getMainMetering()== null ? "": String.valueOf(dataList.get(i).getReagent().getMainMetering())+baseMetaService.getBaseMetaValue(dataList.get(i).getReagent().getReagentUnit()));
			dataRow.createCell(7).setCellValue(dataList.get(i).getReagent().getPrice()== null ? "": String.valueOf(dataList.get(i).getReagent().getPrice()));
			dataRow.createCell(8).setCellValue(dataList.get(i).getArticleNumber()== null ? "": String.valueOf(dataList.get(i).getArticleNumber()));
			dataRow.createCell(9).setCellValue(dataList.get(i).getReserve()== null ? "": String.valueOf(dataList.get(i).getReserve()));
			dataRow.createCell(10).setCellValue(dataList.get(i).getWarehouseName()== null ? "": String.valueOf(dataList.get(i).getWarehouseName()));

		}
		return hssfWorkbook;
	}
	/**
	 * 试剂直接入库
	 */
	public void onDStoreBtnClick() {
        this.onResetBtnClickForNewP();
		this.menuController.goToPage(Constants.PAGE_WAREHOUSE_REAGENT_DIRECT_STORE, Constants.PAGE_WAREHOUSE_STOCK_MNG);
	}

	/**
     * 直接入库试剂List_重置
     */
    public void onResetBtnClickForNewP() {
    	this.reagentDStoreList = new ArrayList<OpeApply>();
    }

    /**
     * 直接入库试剂List_修改
     */
    public void onEditBtnClickForNewP() {

        if (this.reagentDStoreSelectedList == null
                || this.reagentDStoreSelectedList.size() == 0) {
            FacesUtils.warn("请选择数据。");
            return;
        }
        if (this.reagentDStoreSelectedList.size() > 1) {
            FacesUtils.warn("只能选择一个数据进行修改。");
            return;
        }

        this.reagentDStoreEditFlag = Constants.ACTION_EDIT;
        this.reagentDStore = this.reagentDStoreSelectedList.get(0);
    	RequestContext.getCurrentInstance().execute("PF('reagentDStoreDialog').show()");
    }

    /**
     * 直接入库试剂List_删除
     */
    public void onDeleteBtnClickForNewP() {

        if (this.reagentDStoreSelectedList == null
                || this.reagentDStoreSelectedList.size() == 0) {
            FacesUtils.warn("请选择数据。");
            return;
        }

        List<String> selectedIds = new ArrayList<String>();

        for (OpeApply oa : this.reagentDStoreSelectedList) {
        	selectedIds.add(oa.getReagent().getId());
        }

        Iterator<OpeApply> it = this.reagentDStoreList.iterator();

        while(it.hasNext()){

        	OpeApply ope = it.next();

        	if(selectedIds.contains(ope.getReagent().getId())) {
        		it.remove();
        	}
        }

        this.reagentDStoreSelectedList = null;

        FacesUtils.info("删除成功。");
    }

    /**
     * 直接入库试剂List_提交
     */
    public void onSaveBtnClickForNewP() {

    	try {
            if (this.reagentDStoreList == null || this.reagentDStoreList.size() == 0) {
                FacesUtils.warn("新建对象为空。");
                return;
            }

            SysUser loginUser = this.getUser();
            if (loginUser == null) {
                FacesUtils.warn("当前登陆用户信息未能找到。");
                return;
            }

            this.opeWarehouseReserveService.reagentDStore(this.reagentDStoreList, loginUser.getId());

            FacesUtils.info("提交成功。");
            this.menuController.backToPage();

    	} catch (BusinessException e) {
            logger.warn("操作失败。", e);
            FacesUtils.warn(e.getMessage());
        }catch (Exception e) {
            logger.error("操作失败。", e);
            FacesUtils.warn("操作失败。");
        }
    }

    /**
     * 新建申购dialog_取消
     */
    public void onCancelBtnClickNew() {

		this.reagentDStore = new OpeApply();
    	RequestContext.getCurrentInstance().execute("PF('reagentDStoreDialog').hide()");
    }

    /**
     * 新建申购dialog_增加
     */
    public void onSaveBtnClickNew() {

        if (this.reagentDStore.getReagent() == null
                || StringUtils.isBlank(this.reagentDStore.getReagent().getId())) {
            FacesUtils.warn("请选择入库试剂。");
    		RequestContext.getCurrentInstance().execute("PF('reagentDStoreDialog').hide()");
            return;
        }
        // 检查到货数量
        if (this.reagentDStore.getArrivalNum() == null || this.reagentDStore.getArrivalNum() <= 0) {
            FacesUtils.warn("入库数量不能为空，且要大于0。");
            return;
        }
        // 检查货号
        if (StringUtils.isBlank(this.reagentDStore.getArticleNumber())) {
            FacesUtils.warn("货号不能为空。");
            return;
        }
        // 检查条形码开始
        /*if (StringUtils.isBlank(this.reagentDStore.getStartReagentCode())) {
            FacesUtils.warn("条形码开始不能为空。");
            return;
        }
        // 检查条形码结束
        if (StringUtils.isBlank(this.reagentDStore.getEndReagentCode())) {
            FacesUtils.warn("条形码结束不能为空。");
            return;
        }*/

        // 检查仓库名
        if (StringUtils.isBlank(this.reagentDStore.getHouseId())) {
            FacesUtils.warn("仓库名不能为空。");
            return;
        }
        // 检查货柜名
        if (StringUtils.isBlank(this.reagentDStore.getContainerId())) {
            FacesUtils.warn("货柜名不能为空。");
            return;
        }
        // 检查货柜位置
        if (StringUtils.isBlank(this.reagentDStore.getPlaceId())) {
            FacesUtils.warn("货柜位置不能为空。");
            return;
        }

    	//输入条形码开始和结束
        if (!StringUtils.isBlank(this.reagentDStore.getEndReagentCode())&&!StringUtils.isBlank(this.reagentDStore.getEndReagentCode())){
            BigDecimal startReagentCode = new BigDecimal(this.reagentDStore.getStartReagentCode());
            BigDecimal endReagentCode = new BigDecimal(this.reagentDStore.getEndReagentCode());
            // 检查条形码结束要大于条形码开始
            if (endReagentCode.compareTo(startReagentCode) == -1) {
                FacesUtils.warn("条形码开始必须小于条形码结束。");
                return;
            }
            // 检查条形码和到货数量是否匹配
            if (endReagentCode.subtract(startReagentCode).intValue() != (this.reagentDStore.getArrivalNum() - 1)) {
                FacesUtils.warn("条形码数量和入库数量不一致。");
                return;
            }
            if(this.reagentDStoreEditFlag == Constants.ACTION_ADD) {
                if(this.reagentDStoreList.stream().filter(
                        apply -> apply.getReagent().getId().equals(this.reagentDStore.getReagent().getId())
                                && apply.getArrivalNum()==this.reagentDStore.getArrivalNum()
                                && apply.getStartReagentCode().equals(this.reagentDStore.getStartReagentCode())
                                && apply.getEndReagentCode().equals(this.reagentDStore.getEndReagentCode())).count() > 0) {
                    FacesUtils.warn("该试剂已被增加！");
                }else {
                    this.reagentDStore.setId(IDUtils.uuid());
                    this.reagentDStoreList.add(this.reagentDStore);
                    FacesUtils.info("增加成功。");
                }
            }
        }else {
            if(this.reagentDStoreEditFlag == Constants.ACTION_ADD) {
                this.reagentDStore.setStartReagentCode("");
                this.reagentDStore.setEndReagentCode("");
                if(this.reagentDStoreList.stream().filter(
                        apply -> apply.getReagent().getId().equals(this.reagentDStore.getReagent().getId())
                                && apply.getArrivalNum()==this.reagentDStore.getArrivalNum()
                                && apply.getStartReagentCode().equals(this.reagentDStore.getStartReagentCode())
                                && apply.getEndReagentCode().equals(this.reagentDStore.getEndReagentCode())).count() > 0) {
                    FacesUtils.warn("该试剂已被增加！");
                }else {
                    this.reagentDStore.setId(IDUtils.uuid());
                    this.reagentDStoreList.add(this.reagentDStore);
                    FacesUtils.info("增加成功。");
                }
            }
        }


		this.reagentDStore = new OpeApply();
		RequestContext.getCurrentInstance().execute("PF('reagentDStoreDialog').hide()");
    }

    public void onReagentRowSelect(SelectEvent event) {
    	this.reagentDStore = new OpeApply();
        this.reagentDStore.setReagent((SysReagent)event.getObject());

    	this.reagentDStoreEditFlag = Constants.ACTION_ADD;
		onWarehouseSelectChange(null);
    	RequestContext.getCurrentInstance().execute("PF('reagentDStoreDialog').show()");
    }

    public void onWarehouseSelectChange(String warehouseId) {
        this.warehouseContainerList = null;
        this.warehouseContainerPlaceList = null;
        this.changeWarehouseContainerList(warehouseId);
        this.changeWarehouseContainerPlaceList(null);
    }

	public void onWarehouseContainerSelectChange(String warehouseContainerId) {
		this.warehouseContainerPlaceList = null;
		this.changeWarehouseContainerPlaceList(warehouseContainerId);
	}

    private void changeWarehouseContainerList(String warehouseId) {
        if (StringUtils.isBlank(warehouseId)) {
            if (this.warehouseList != null && this.warehouseList.size() > 0) {
                warehouseId = this.warehouseList.get(0).getId();
            }
        }

        if (StringUtils.isNotBlank(warehouseId)) {
            this.warehouseContainerList = warehouseIdContainerMap.get(warehouseId);
        }
    }

    private void changeWarehouseContainerPlaceList(String warehouseContainerId) {
        if (StringUtils.isBlank(warehouseContainerId)) {
            if (this.warehouseContainerList != null && this.warehouseContainerList.size() > 0) {
                warehouseContainerId = this.warehouseContainerList.get(0).getId();
            }
        }

        if (StringUtils.isNotBlank(warehouseContainerId)) {
            SysWarehouseContainer container = this.warehouseContainerMap.get(warehouseContainerId);
            BaseMeta baseMeta = null;
            if (container != null
                    && (baseMeta = this.baseMetaService.getBaseMeta(container.getStructure())) != null) {
                this.warehouseContainerPlaceList = this.baseMetaService.getBaseMetaList(baseMeta.getMetaKey());
            }
        }
    }

    public String formatWarehouseName(String id) {
        if (StringUtils.isNotBlank(id)
                && this.warehouseNameMap != null) {
            return warehouseNameMap.get(id);
        }

        return "";
    }
    public String formatWarehouseContainerName(String id) {
        if (StringUtils.isNotBlank(id)
                && this.warehouseContainerMap != null) {
            if (this.warehouseContainerMap.get(id) != null) {
                return this.warehouseContainerMap.get(id).getContainerCode();
            }
        }

        return "";
    }
    public String formatWarehouseContainerPlaceName(String id) {
        if (StringUtils.isNotBlank(id)) {
            return this.baseMetaService.getBaseMetaValue(id);
        }

        return "";
    }

	public int getAction() {
		return action;
	}

	public List<SysReagent> getReagentSelectList() {
		if (this.reagentSelectList == null) {
			this.initReagentSelectList();
		}
		return reagentSelectList;
	}

	public void setReagentSelectList(List<SysReagent> reagentSelectList) {
		this.reagentSelectList = reagentSelectList;
	}

	public String getReagentId() {
		return reagentId;
	}

	public void setReagentId(String reagentId) {
		this.reagentId = reagentId;
	}

	public List<SysUser> getUserSelectList() {
		if (userSelectList == null) {
			this.initUserSelectList();
		}
		return userSelectList;
	}

	public SysUser getSelectedUserById(String userId) {
		return userSelectList.stream().filter(u->u.getId().equals(userId)).findFirst().get();
	}

	public List<SysUser> getUserSelectList(String keyword) {
    	final String key = keyword.toLowerCase();
		return userSelectList.stream().filter(u->u.getName().toLowerCase().contains(key)).collect(Collectors.toList());
	}



	public void setUserSelectList(List<SysUser> userSelectList) {
		this.userSelectList = userSelectList;
	}

	public String getUserId() {
		return userId;
	}

	public void setUserId(String userId) {
		this.userId = userId;
	}


	public String getProjectNum() {
		return projectNum;
	}

	public void setProjectNum(String projectNum) {
		this.projectNum = projectNum;
	}

	public String getSupplierId() {
		return supplierId;
	}

	public void setSupplierId(String supplierId) {
		this.supplierId = supplierId;
	}

	public List<SysSupplier> getSupplierSelectList() {
		if (supplierSelectList == null) {
			this.initSupplierSelectList();
		}
		return supplierSelectList;
	}

	public void setSupplierSelectList(List<SysSupplier> supplierSelectList) {
		this.supplierSelectList = supplierSelectList;
	}

	public List<OpeWarehouseReserve> getSelectedList() {
		return selectedList;
	}

	public void setSelectedList(List<OpeWarehouseReserve> selectedList) {
		this.selectedList = selectedList;
	}

	public OpeWarehouseReserve getSelectedOpeWarehouseReserve() {
		return selectedOpeWarehouseReserve;
	}

	public void setSelectedOpeWarehouseReserve(OpeWarehouseReserve selectedOpeWarehouseReserve) {
		this.selectedOpeWarehouseReserve = selectedOpeWarehouseReserve;
	}

	public List<OpeReagentStatus> getReagentStatusSelectList() {
		initReagentStatusSelectList();
		return reagentStatusSelectList;
	}

	public void setReagentStatusSelectList(List<OpeReagentStatus> reagentStatusSelectList) {
		this.reagentStatusSelectList = reagentStatusSelectList;
	}

	public List<String> getReagentCodeSelectedList() {
		return reagentCodeSelectedList;
	}

	public void setReagentCodeSelectedList(List<String> reagentCodeSelectedList) {
		this.reagentCodeSelectedList = reagentCodeSelectedList;
	}

	public String getReagentLogId() {
		return reagentLogId;
	}

	public void setReagentLogId(String reagentLogId) {
		this.reagentLogId = reagentLogId;
	}

	public String getUserLogId() {
		return userLogId;
	}

	public void setUserLogId(String userLogId) {
		this.userLogId = userLogId;
	}

    public void handleEvent(){
        if(reagentDStore!=null){
            if(reagentDStore.getArrivalNum()!=null && reagentDStore.getArrivalNum()>0){
                if(reagentDStore.getStartReagentCode()!=null && !reagentDStore.getStartReagentCode().equals("")){
                	BigDecimal start=new BigDecimal(reagentDStore.getStartReagentCode());
					String str=reagentDStore.getStartReagentCode();
					String up="";
					int len = reagentDStore.getStartReagentCode().length() - String.valueOf(reagentDStore.getStartReagentCode()).length();
					String temp = "";
					for (int i = 0; i < len; i++) {
						temp += "0";
					}
                	BigDecimal end=start.add(new BigDecimal(reagentDStore.getArrivalNum()-1));
                	reagentDStore.setEndReagentCode(temp +end.toString());
                    //reagentDStore.setEndReagentCode(Integer.toString(reagentDStore.getArrivalNum()-1+Integer.parseInt(reagentDStore.getStartReagentCode())));
                }else{
                    FacesUtils.info("请输入条形码开始");
                }
            }else {
                FacesUtils.info("请输入入库数量");
            }
        }
    }

	public void handleEvent2(){
			if(useNum!=null && useNum>0){
				if(startReagentCode!=null && !startReagentCode.equals("")){
				if (startReagentCode.matches(".*\\D+.*")) {
								if (startReagentCode.length() ==24 &&
					                    startReagentCode.matches(".*([A-F]|\\d)+.*") &&
					                    startReagentCode.substring(startReagentCode.length() - 5).matches("\\d{5}")){

							//2.2长度为24位编码的
							BigInteger arrNum = BigInteger.valueOf((long)useNum);
							//后5位随机码
							String randomCode = startReagentCode.substring(startReagentCode.length() - 5);
							String reagentCodePrefix = startReagentCode.substring(0,startReagentCode.length() - 5);

							BigInteger startReagentCodeSuffix = new BigInteger(randomCode);
							BigInteger endReagentCodeSuffix = startReagentCodeSuffix.add(arrNum).subtract((new BigInteger("1")));
							String reagentCodeSuffix= autoGenericCode(randomCode, endReagentCodeSuffix);
							endReagentCode= (reagentCodePrefix + reagentCodeSuffix);
						}else{
							endReagentCode = ("");
						}
					}else{

						BigInteger startReagentCode2 = new BigInteger(startReagentCode);
						//2.1长度不为24位编码
						//数据1
						BigInteger arrNum = BigInteger.valueOf((long)useNum);
						BigInteger code1 = startReagentCode2.add(arrNum).subtract(BigInteger.ONE);
						endReagentCode=(autoGenericCode(startReagentCode, code1));
					}
				}else{
					FacesUtils.info("请输入条形码开始");
				}
			}else {
				FacesUtils.info("请输入领用数量");
			}
	}

	public void clearStartAndEndCode(){
		endReagentCode = "";
	}

	public void handleEventForPerson(){
		if(useNum!=null && useNum>0){
			if(startReagentCodeForPerson!=null && !startReagentCodeForPerson.equals("")){
				BigDecimal start=new BigDecimal(startReagentCodeForPerson.trim());
				String str=startReagentCodeForPerson;
				String up="";
				int len = startReagentCodeForPerson.length() - String.valueOf(start).length();
				String temp = "";
				for (int i = 0; i < len; i++) {
					temp += "0";
				}
				BigDecimal end = start.add(new BigDecimal(useNum-1));
				endReagentCodeForPerson=temp+end.toString();
				//endReagentCodeForPerson=Integer.toString(useNum-1+Integer.parseInt(startReagentCodeForPerson.trim()));
			}else{
				FacesUtils.info("请输入条形码开始");
			}
		}else {
			FacesUtils.info("请输入领用数量");
		}
	}

	public void uploadFile(){
		System.out.println(11111111);
	}
    /*public List<SysUser> getApplyUser(String value){
        List<SysUser> list=this.userSelectList;
        List<SysUser> results=new ArrayList<>();
        for(SysUser u:list){
            if(u.getName().indexOf(value)>-1){
                results.add(u);
            }
        }
        return results;
    }*/

    /*public void handleSelect(SelectEvent event){

    }*/

	public List<SysUser> getApplyUserSelectList() {
		SysUser sysUser = getUser();
		if (sysUser == null) {
			applyUserSelectList = new ArrayList<SysUser>();
		} else {

			// 负责人，需要把部门的userid传递到SQL
			if (sysUser.getSeeFlag().getKey() == SeeFlag.LEADING.getKey()) {
				applyUserSelectList = this.sysUserService.getSeeUserList(sysUser.getDepartment());
			} else if (sysUser.getSeeFlag().getKey() == SeeFlag.NORMAL.getKey()) {
				List<SysUser> list = new ArrayList<SysUser>();
				list.add(sysUser);
				applyUserSelectList = list;
			} else {
				applyUserSelectList = this.sysUserService.getSysUserList(null, null, null, null, null,null,null);
			}
		}
		return applyUserSelectList;
	}

	public void setApplyUserSelectList(List<SysUser> applyUserSelectList) {
		this.applyUserSelectList = applyUserSelectList;
	}

	public String getReagentCode() {
		return reagentCode;
	}

	public void setReagentCode(String reagentCode) {
		this.reagentCode = reagentCode;
	}

    public LazyDataModel<SysReagent> getReagentDataModel() {
        if (this.reagentDataModel == null) {
            this.reagentDataModel = new LazyDataModel<SysReagent>() {
                @Override
                public List<SysReagent> load(int first, int pageSize, String sortField, SortOrder sortOrder, Map<String, Object> filters) {
                    List<SysReagent> list = null;
                    try {
                        int count = sysReagentService.getSysReagentTotalCountNew(applyNewReagentName, applyNewCas, null,null,productSn);
                        this.setRowCount(count);
                        if (count > 0) {
                            list = sysReagentService.getSysReagentListNew(applyNewReagentName, applyNewCas, null,null, first, pageSize,productSn);
                        }
                    } catch (Exception e) {
                        logger.error(e);
                    }
                    return list;
                }

                @Override
                public SysReagent getRowData(String rowKey) {
//                    Iterator<SysReagent> iterator = this.iterator();
//                    if (iterator != null) {
//                        SysReagent sr = null;
//                        while (iterator.hasNext()) {
//                            sr = iterator.next();
//                            if (rowKey.equals(sr.getId())) {
//                                return sr;
//                            }
//                        }
//                    }
                    return sysReagentService.getSysReagentListNewRowData(rowKey);
                }
            };
        }

        return reagentDataModel;
    }

	public List<OpeApply> getReagentDStoreList() {
		return reagentDStoreList;
	}

	public void setReagentDStoreList(List<OpeApply> reagentDStoreList) {
		this.reagentDStoreList = reagentDStoreList;
	}

	public List<OpeApply> getReagentDStoreSelectedList() {
		return reagentDStoreSelectedList;
	}

	public void setReagentDStoreSelectedList(List<OpeApply> reagentDStoreSelectedList) {
		this.reagentDStoreSelectedList = reagentDStoreSelectedList;
	}

	public int getReagentDStoreEditFlag() {
		return reagentDStoreEditFlag;
	}

	public void setReagentDStoreEditFlag(int reagentDStoreEditFlag) {
		this.reagentDStoreEditFlag = reagentDStoreEditFlag;
	}

	public OpeApply getReagentDStore() {
		return reagentDStore;
	}

	public void setReagentDStore(OpeApply reagentDStore) {

		this.reagentDStore = reagentDStore;
	}

	public String getApplyNewReagentName() {
		return applyNewReagentName;
	}

	public void setApplyNewReagentName(String applyNewReagentName) {
		this.applyNewReagentName = applyNewReagentName;
	}

	public String getApplyNewCas() {
		return applyNewCas;
	}

	public void setApplyNewCas(String applyNewCas) {
		this.applyNewCas = applyNewCas;
	}

	public List<SysWarehouse> getWarehouseList() {
		return warehouseList;
	}

	public List<SysWarehouseContainer> getWarehouseContainerList() {
		return warehouseContainerList;
	}

	public List<BaseMeta> getWarehouseContainerPlaceList() {
		return warehouseContainerPlaceList;
	}

	public Integer getUseNum() {
		return useNum;
	}

	public void setUseNum(Integer useNum) {
		this.useNum = useNum;
	}

	public String getOriLaboratoryId() {
		return oriLaboratoryId;
	}

	public void setOriLaboratoryId(String oriLaboratoryId) {
		this.oriLaboratoryId = oriLaboratoryId;
	}

	public void resetLaboratory(){
		laboratory = null;
		laboratoryId = null;
		laboratoryContainers = null;
		//getLaboratory();
		//getLaboratoryContainers();
	}

//	public void setContainerId(){
//	}
	public void resetLaboratoryContainers() {
		laboratoryContainers = null;
		//getLaboratoryContainers();
	}
	public List<SysLaboratory> getLaboratory() {
 		if(userId != null && userId.trim().length() > 0)
		{

			//Todo 修改申领人的实验室显示信息
			this.laboratory = this.sysLaboratoryService.getSysLaboratoryListByUserId(userId);
			if(this.laboratory != null && this.laboratory.size() > 0)
			{
				//flag =true;
				if(laboratoryId != null && laboratoryId.trim().length() > 0)
				{
					this.oriLaboratoryId = this.laboratoryId;
				}else
				{
					this.laboratoryId = this.laboratory.get(0).getId();
				}

//				this.laboratoryId = this.laboratory.get(0).getId();
				this.laboratoryContainers = this.sysLaboratoryContainerService.getSysLaboratoryContainerList(laboratoryId);
			}else {
				this.oriLaboratoryId = null;
				this.laboratoryContainers = null;
			}
		}else {
			this.laboratory = null;
			this.laboratoryId = null;
			this.laboratoryContainers = null;
		}

		return laboratory;
	}

	public void setLaboratory(List<SysLaboratory> laboratory) {
		this.laboratory = laboratory;
	}

	public List<SysLaboratoryContainer> getLaboratoryContainers() {
 		if(laboratoryId != null && laboratoryId.trim().length() > 0)
		{
			this.laboratoryContainers = this.sysLaboratoryContainerService.getSysLaboratoryContainerList(laboratoryId);
		}
		return laboratoryContainers;
	}

	public void setLaboratoryContainers(List<SysLaboratoryContainer> laboratoryContainers) {
		this.laboratoryContainers = laboratoryContainers;
	}

	public String getLaboratoryId() {
		return laboratoryId;
	}

	public void setLaboratoryId(String laboratoryId) {
		this.laboratoryId = laboratoryId;
	}

	public String getLaboratoryContainerId() {

		return laboratoryContainerId;
	}

	public void setLaboratoryContainerId(String laboratoryContainerId) {
		this.laboratoryContainerId = laboratoryContainerId;
	}

	public List<OpeApplyReserve> getSelectedListForPerson() {
		return selectedListForPerson;
	}

	public void setSelectedListForPerson(List<OpeApplyReserve> selectedListForPerson) {
		this.selectedListForPerson = selectedListForPerson;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    public String getStartReagentCode() {
        return startReagentCode;
    }

    public void setStartReagentCode(String startReagentCode) {
        this.startReagentCode = startReagentCode;
    }

    public String getEndReagentCode() {
        return endReagentCode;
    }

    public void setEndReagentCode(String endReagentCode) {
        this.endReagentCode = endReagentCode;
    }

	public List<OpeWarehouseReserve> getSelectedTmpList() {
		return selectedTmpList;
	}

	public void setSelectedTmpList(List<OpeWarehouseReserve> selectedTmpList) {
		this.selectedTmpList = selectedTmpList;
	}


	public List<OpeWarehouseReserve> getTrulySelectedList() {
		return trulySelectedList;
	}

	public void setTrulySelectedList(List<OpeWarehouseReserve> trulySelectedList) {
		this.trulySelectedList = trulySelectedList;
	}

	public List<String> getShowCodes() {
		return showCodes;
	}

	public void setShowCodes(List<String> showCodes) {
		this.showCodes = showCodes;
	}

	public List<OpeApplyReserve> getSelectedTmpOrderList() {
		return selectedTmpOrderList;
	}

	public void setSelectedTmpOrderList(List<OpeApplyReserve> selectedTmpOrderList) {
		this.selectedTmpOrderList = selectedTmpOrderList;
	}

	public List<OpeApplyReserve> getTrulySelectedOrderList() {
		return trulySelectedOrderList;
	}

	public void setTrulySelectedOrderList(List<OpeApplyReserve> trulySelectedOrderList) {
		this.trulySelectedOrderList = trulySelectedOrderList;
	}


	public Integer getTabValue() {
		return tabValue;
	}

	public void setTabValue(Integer tabValue) {
		this.tabValue = tabValue;
	}


	public List<OpeApplyReserve> getSelectedInputStorageTmpOrderList() {
		return selectedInputStorageTmpOrderList;
	}

	public void setSelectedInputStorageTmpOrderList(List<OpeApplyReserve> selectedInputStorageTmpOrderList) {
		this.selectedInputStorageTmpOrderList = selectedInputStorageTmpOrderList;
	}

	public List<OpeApplyReserve> getTrulyInputStorageTmpSelectedOrderList() {
		return trulyInputStorageTmpSelectedOrderList;
	}

	public void setTrulyInputStorageTmpSelectedOrderList(List<OpeApplyReserve> trulyInputStorageTmpSelectedOrderList) {
		this.trulyInputStorageTmpSelectedOrderList = trulyInputStorageTmpSelectedOrderList;
	}

	public Timestamp getArrivalTime() {
		return arrivalTime;
	}

	public void setArrivalTime(Timestamp arrivalTime) {
		this.arrivalTime = arrivalTime;
	}

	public String getConsigneeId() {
		return consigneeId;
	}

	public void setConsigneeId(String consigneeId) {
		this.consigneeId = consigneeId;
	}

	public List getConsignee() {
		List<SysUser> dataList = this.sysUserService.getSysUserList(null, null, null, null, null,null,null);
		//将admin置于首位
		for (int i = 0; i < dataList.size(); i++) {
			if ("admin".equals(dataList.get(i).getAccount())){
				dataList.add(0, dataList.remove(i));
			}
		}
		return dataList;
	}

	public List<OpeApplyReserve> getOpeApplyList() {
		return opeApplyList;
	}

	public void setOpeApplyList(List<OpeApplyReserve> opeApplyList) {
		this.opeApplyList = opeApplyList;
	}


	public void setArrival(OpeApplyReserve oar) {
		//强制-》全到货
		oar.setArrivalNum(oar.getNum());
	}

	public void reagentStartCodeChange(OpeApplyReserve oar) {
		//先输入条形码，到货数量帮填
		oar.setArrivalNum(oar.getNum());
		String startReagentCode2 = oar.getStartReagentCode2();
		String endReagentCode2 = oar.getEndReagentCode2();
		//1.如果开始条码为空，条码就为空,或者没有到货
		if (StringUtils.isBlank(startReagentCode2)
				|| oar.getArrivalNum() == null || oar.getArrivalNum() < 1) {

			oar.setStartReagentCode2("");
			oar.setEndReagentCode2("");
			return;
		}
		//2如果开始条码不为空
		//2.0如果包含字母不等于24位的直接不管

		if (startReagentCode2.matches(".*\\D+.*")) {
			if (startReagentCode2.length() ==24 &&
					startReagentCode2.matches(".*([A-F]|\\d)+.*") &&
					startReagentCode2.substring(startReagentCode2.length() - 5).matches("\\d{5}")){
				//2.2长度为24位编码的
				BigInteger arrNum = BigInteger.valueOf(oar.getArrivalNum().longValue());
				//后5位随机码
				String randomCode = startReagentCode2.substring(startReagentCode2.length() - 5);
				String reagentCodePrefix = startReagentCode2.substring(0,startReagentCode2.length() - 5);

				BigInteger startReagentCodeSuffix = new BigInteger(randomCode);
				BigInteger endReagentCodeSuffix = startReagentCodeSuffix.add(arrNum).subtract((new BigInteger("1")));
				String reagentCodeSuffix= autoGenericCode(randomCode, endReagentCodeSuffix);
				oar.setEndReagentCode2(reagentCodePrefix + reagentCodeSuffix);
			}else{
				oar.setEndReagentCode2("");
			}
		}else{

			BigInteger startReagentCode = new BigInteger(startReagentCode2);
			//2.1长度不为24位编码
				//数据1
			BigInteger arrNum = BigInteger.valueOf(oar.getArrivalNum().longValue());
			BigInteger code1 = startReagentCode.add(arrNum).subtract(BigInteger.ONE);
			oar.setEndReagentCode2(autoGenericCode(startReagentCode2, code1));
			}
	}




	private String autoGenericCode(String code, BigInteger code1) {
		String result = "";
		//补充位数
		result = String.format("%0" + code.length() + "d", code1);

		return result;
	}



	public void setProductSn(String productSn) {
		this.productSn = productSn;
	}

	public String getProductSn() {
		return productSn;
	}

	public String getApplyCode() {
		return applyCode;
	}

	public void setApplyCode(String applyCode) {
		this.applyCode = applyCode;
	}

	public Integer getStatus() {
		return status;
	}

	public void setStatus(Integer status) {
		this.status = status;
	}

	public List<ApplyStatusVo> getStatusSelectList() {
		if (this.statusSelectList == null) {
			this.statusSelectList = Arrays.asList(ApplyStatusVo.values());
		}
		return statusSelectList;
	}




	public List<OpeWarehouseReserve> getWarehouseReserveList() {
		return warehouseReserveList;
	}

	public void setWarehouseReserveList(List<OpeWarehouseReserve> warehouseReserveList) {
		this.warehouseReserveList = warehouseReserveList;
	}

	public OpeWarehouseReserve getOpeWarehouseReserve() {
		return opeWarehouseReserve;
	}

	public void setOpeWarehouseReserve(OpeWarehouseReserve opeWarehouseReserve) {
		this.opeWarehouseReserve = opeWarehouseReserve;
	}

	public String getReceiptNumber() {
		return receiptNumber;
	}

	public void setReceiptNumber(String receiptNumber) {
		this.receiptNumber = receiptNumber;
	}

	public String getWarehouseName() {
		return warehouseName;
	}

	public void setWarehouseName(String warehouseName) {
		this.warehouseName = warehouseName;
	}

	public Integer getIsAllApply() {
		return isAllApply;
	}

	public void setIsAllApply(Integer isAllApply) {
		this.isAllApply = isAllApply;
	}

	public boolean getIsExpired() {
		return isExpired;
	}

	public void setIsExpired(boolean isExpired) {
		this.isExpired = isExpired;
	}

	//过期处理
	public void expireOrder() {
		//1.判断当前订单是否是已入库的状态
		if (this.selectedListForPerson.size() < 1) {
			FacesUtils.warn("请选择数据。");
			return;
		}
		ArrayList<String> ids = new ArrayList<>();
		for (OpeApplyReserve oa : this.selectedListForPerson) {
			ids.add(oa.getId());
			if (oa.getStatus() != ApplyStatus.SUPPLIER_CONFIRM) {
				FacesUtils.warn("只能让已确认状态的单子过期。");
				return;
			}
		}

		opeApplyService.updateOpeApplyStatus(ApplyStatus.EXPIRED, null, ids);
		FacesUtils.warn("操作成功。");


	}

	public void recoverOrder(){
		if (this.selectedListForPerson.size() < 1) {
			FacesUtils.warn("请选择数据。");
			return;
		}
		ArrayList<String> ids = new ArrayList<>();
		for (OpeApplyReserve oa : this.selectedListForPerson) {
			ids.add(oa.getId());
			if (oa.getStatus() != ApplyStatus.EXPIRED) {
				FacesUtils.warn("只能让过期单子恢复确认。");
				return;
			}
		}
		opeApplyService.updateOpeApplyStatus(ApplyStatus.SUPPLIER_CONFIRM, null, ids);
		FacesUtils.warn("操作成功。");
	}

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }
}