﻿import React from 'react';
import ReactDom, { findDOMNode } from 'react-dom';
import moment from 'moment';
import SweetAlert from 'sweetalert2-react';
import audio from 'simple-audio';
import TopBar from '../Common/TopBar';
import OrdersView from './Partials/OrdersView';
import OrderDetail from './Partials/OrderDetail';
import Session from '../../components/Session';
import LocalStorage from '../../components/LocalStorage';
import { ServiceRequest } from '../Request/service';
import { SiteRoutes, baseUrl } from '../../../config';
import LoginModal from '../Common/LoginModal';

class Picking extends React.Component {

    constructor() {
        super();
        this.state = {
            viewSelected: 'pendientes',
            lstOrders: [],
            lstOrderDetail: [],
            showOrderDetail: false,
            currentRowOrderDetail: {},
            cant: 1,
            index:0,
            rowOrder: {},
            disabledNext:'',
            disabledPrev: '',
            encabezadoOrder: {},
            action: '',
            rowSelected: {},
            filterCompleted: false,
            filterPartial: false,
            filterEmpty: false,
            escanerValue: '',
            startDate: moment().add(-1, 'day'),
            endDate: moment(),
            positions: [],
            ControlarCeros: '',
            EditarCantidad:'',
            //Seguridad de las acciones del menu
            showLoginModal: false,
            username: '',
            password: '',
            menu: -1,
            opcion: -1,
            accion: undefined

        }
    }
    componentWillMount() {
        this.obtenerPosiciones();
        this.obtenerParametrosSucursal();
    }

    async obtenerPosiciones() {
        let Response = await ServiceRequest.Obtener_Posiciones();
        if (Response.isError==false){
            this.setState({ positions: Response.data });
        }     
    }

   async obtenerParametrosSucursal() {
        let Response =await  ServiceRequest.Obtener_Parametros_Sucursal();
        if (Response.isError == false) {
            let _Data = Response.data;
            this.setState({ EditarCantidad: _Data.Picking_Hand_Held_Editar_Cantidad, ControlarCeros: _Data.Picking_Hand_Held_Controlar_Ceros });
        } 
    }
    componentDidMount() {
        this.loadOrdersList();
    }
    onChangeView(pTipoVista) {
        this.loadOrdersList(pTipoVista);
    }
    changeAction(pAction, pRow) {
        this.setState({ action: pAction, username: '', password: '', rowSelected: pRow });

        if (pAction == "Aplicar") {
            this.validarMenuOpcion('Picking', 'Aplicar', () => { this.applyOrder(pRow); });
        } else
            if (pAction == "Pausar") {            
                this.validarMenuOpcion('Picking', 'Pausar', () => { this.changeStateTimeOrder(pRow, 'PA'); });
            } else
                if (pAction == "Iniciar") {
                    this.validarMenuOpcion('Picking', 'Iniciar', () => { this.changeStateTimeOrder(pRow, 'IN'); });
                }
       
    }

    validarOrder() {
        const { action, username, password, rowSelected } = this.state;
       if (username == "" || password == "") {
            toastr.warning("Debe ingresar el usuario y la contrase&ntilde;a");
            return;
        }

        if (rowSelected.Pedido_Id == undefined) {
            toastr.warning("Debe seleccionar un Pedido");
            return;
        }

        if (action == "") {
            toastr.warning("No hay una accion definida");
            return;
        }        
    }


    changeStartDate(startDate) {
        this.setState({ startDate});
    }
    changeEndDate(endDate) {
        this.setState({ endDate });
    }
   async filtrarOrdersByRangeDate() {
       const {startDate, endDate } = this.state;
       const Response = await ServiceRequest.Despacho_Lista_Asignados_Terminados_Rango_Fechas(startDate, endDate);
       let lstResponse = [];
       if (Response.isError == false) {
           lstResponse = Response.data;

       } else {
           toastr.error(Response.data)
       }

       lstResponse = lstResponse.map(row => { return Object.assign(row, { Detalle: row.Detalle != undefined ? this.mapDetail(JSON.parse(row.Detalle), row.Desp_Estado) : [], Encabezado: row.Encabezado != undefined ? JSON.parse(row.Encabezado) : {} }) });

       this.setState({ lstOrders: lstResponse});
    }

    updateTimeCurrentOrder(pTiempo, pRow) {
        if (pRow != undefined) {
            let _lstOrders = this.state.lstOrders.map(item => {
                if (item.Suc_Id == pRow.Suc_Id && item.Pedido_Id == pRow.Pedido_Id && item.SubPedido_Id == pRow.SubPedido_Id) {
                    return Object.assign(item, { Tiempo: pTiempo });
                } else {
                    return item;
                }
            });

            this.setState({ lstOrders: _lstOrders });
        } else {
            let _RowOrderUpdate = Object.assign(this.state.rowOrder, { Tiempo: pTiempo });
            this.setState({ rowOrder: _RowOrderUpdate });
        }
    }
    updateEstadoCurrentOrder(pEstado) {
        let _RowOrderUpdate = Object.assign(this.state.rowOrder, { Tiempo_Estado_Actual: pEstado, Desp_Estado_Despacho: pEstado });
        this.setState({ rowOrder: _RowOrderUpdate });
    }

    updateDespEstadoOrder(pEstado, pSucId, pPedido_Id, pSubPedidoId) {
        let _lstOrders = this.state.lstOrders.map(item => {
            if (item.Suc_Id == pSucId && item.Pedido_Id == pPedido_Id && item.SubPedido_Id == pSubPedidoId) {
                return Object.assign(item, { Desp_Estado: pEstado });
            } else {
                return item;
            }
        });

        this.setState({ lstOrders: _lstOrders});
    }

    updateTiempoEstadoOrder(pEstado, pSucId, pPedido_Id, pSubPedidoId) {
        let _lstOrders = this.state.lstOrders.map(item => {
            if (item.Suc_Id == pSucId && item.Pedido_Id == pPedido_Id && item.SubPedido_Id == pSubPedidoId) {
                return Object.assign(item, { Tiempo_Estado_Actual: pEstado, Desp_Estado_Despacho: pEstado });
            } else {
                return item;
            }
        });

        this.setState({ lstOrders: _lstOrders });
    }
    async  loadOrdersList(pTipoOrdenes) {  
      let lstResponse = [];
      let response = {};
      let _Tipo = pTipoOrdenes == undefined ? 'pendientes' : pTipoOrdenes;
      if (_Tipo == 'terminadas') {

          let { startDate, endDate } = this.state;
          response = await ServiceRequest.Despacho_Lista_Asignados_Terminados_Rango_Fechas(startDate, endDate);
          
      } else {
           response = await ServiceRequest.Despacho_Lista_Asignados_Pendientes();
      }     
        if (response.isError == false) {
            lstResponse = response.data;   
        } else {
            toastr.error(response.data);
      }

        lstResponse = lstResponse.map(row => { return Object.assign(row, { Detalle: row.Detalle != undefined ? this.mapDetail(JSON.parse(row.Detalle), row.Desp_Estado) : [], Encabezado: row.Encabezado != undefined ? JSON.parse(row.Encabezado) : {}  }) });

        this.setState({ rowSelected: {}, viewSelected: _Tipo, lstOrders: lstResponse, rowOrder: {}, lstOrderDetail: [], currentRowOrderDetail: {}, showOrderDetail: false });
    }

  mapDetail(pLstDetail, pEstado) {
      const session = new Session();
      const urlFile = session.get('WSAdminFiles');
      return pLstDetail.map(item => {
          return {
              Id: item.Id,
              Nombre: item.Nombre,
              Detalle_Id:item.Detalle_Id,           
              Codigo: item.Equivalente,
              Cantidad_Solicitada: item.Pedida,
              Cantidad_Auditada: item.Auditada,
              Cantidad_Recolectado: item.Auditada,
              Butos: item.Bultos,
              Factor: item.Factor,
              Empaques:item.Empaques,
              Imagen_Url: item.Imagen_Url == '' ? baseUrl + 'Public/img/not-image.png' : urlFile + 'Archivos/Imagenes/Articulos_PEQ/' + item.Imagen_Url.split('.')[0]+'_PEQ'+'.'+item.Imagen_Url.split('.')[1],
              Pasillo: item.Pasillo,
              Columna: item.Columna,
              Fila: item.Fila,
              Picking_Cero: item.Picking_Cero==true?1:0
          }  
      });
  }

     getOrderDetail(pRowOrder) {
         let rowOrder = this.state.lstOrders.find(row => { return row.Pedido_Id == pRowOrder.Pedido_Id && row.SubPedido_Id == pRowOrder.SubPedido_Id && row.Suc_Id == pRowOrder.Suc_Id })
         if (rowOrder != undefined) {
             return { Detalle: rowOrder.Detalle, Encabezado: rowOrder.Encabezado };
         } else {
             return { Detalle: [], Encabezado: {} }       
         }
  }
      addOrderDetail(pDetail, pEncabezado, pRowOrder) {
          let lstOrders = this.state.lstOrders.map(row => {
              if (row.Pedido_Id == pRowOrder.Pedido_Id && row.SubPedido_Id == pRowOrder.SubPedido_Id && row.Suc_Id == pRowOrder.Suc_Id) {
                  return Object.assign(row, { Detalle: pDetail, Encabezado: pEncabezado });
              } else {
                  return Object.assign(row, { Detalle: row.Detalle, Encabezado: row.Encabezado });
              }
          });

          return lstOrders;
       }


    onHideOrderDetail() {
        this.setState({ showOrderDetail: false });
    }
    async onShowOrderDetail(pSucId, pPedidoId, pSubpedidoId, pRowOrder) {
        let lstResponse = [];
        let _encabezadoOrder = {};
        let _orderDetailSaved = this.getOrderDetail(pRowOrder);
        if (_orderDetailSaved.Detalle.length > 0 && _orderDetailSaved.Encabezado.Estado != undefined) {
            lstResponse = _orderDetailSaved.Detalle;
            _encabezadoOrder = _orderDetailSaved.Encabezado;
        } else {
            let response = await ServiceRequest.Consulta_Despacho_Auditoria(pSucId, pPedidoId, pSubpedidoId, pRowOrder.Bodega_CEDI);
            if (response.isError == false) {
                lstResponse = response.data.Detalle;
                _encabezadoOrder = response.data.Encabezado[0];
                lstResponse = this.mapDetail(lstResponse, _encabezadoOrder.Estado);
            } else {
                toastr.error(response.data);
            }
        }
 
        let _lstOrders = this.addOrderDetail(lstResponse, _encabezadoOrder,  pRowOrder); //Se agrega el detalle a la fila de la orden
     

        this.setState({ showOrderDetail: true, lstOrders: _lstOrders, lstOrderDetail: lstResponse, currentRowOrderDetail: lstResponse[0], rowOrder: pRowOrder, encabezadoOrder: _encabezadoOrder, escanerValue: '', filterCompleted: false, filterEmpty: false, filterPartial: false, disabledPrev: 'disabled', disabledNext: '', index: 0 });
    }

    updateCantidad(newCant) { 
        var currentItem = this.state.currentRowOrderDetail;
        if (newCant > currentItem.Cantidad_Solicitada) {
            currentItem.Cantidad_Recolectado = currentItem.Cantidad_Solicitada;
            this.playAudio('Error');
            toastr.warning("La cantidad recolectada es mayor a la cantidad solicitada. Se conservar&aacute; la cantidad solicitada.");
        } else {
            currentItem.Cantidad_Recolectado = newCant;
            this.playAudio('Exito');
        }  

        if (newCant==""){
            currentItem.Cantidad_Recolectado = 0;
        }
    this.setState({currentRowOrderDetail:currentItem});
    }
    getCantidad() {
        var currentItem = this.state.currentRowOrderDetail;
       return currentItem.Cantidad_Recolectado   
    }
    filterCompleted() {
        const { rowOrder, lstOrderDetail } = this.state;
        let _lstFiltered = rowOrder.Detalle.filter(item => { return item.Cantidad_Solicitada == item.Cantidad_Recolectado });
        if (_lstFiltered.length > 0) {
            this.setState({ lstOrderDetail: _lstFiltered, currentRowOrderDetail: _lstFiltered[0] });
        } else {
            toastr.warning("No hay coincidencias para el filtro");
        }     
    }
    doFilter() {
        const { rowOrder, filterPartial, filterEmpty, filterCompleted, lstOrderDetail } = this.state;
        let _lstFiltered = [];
       rowOrder.Detalle.map(item => {
            if (filterCompleted && item.Cantidad_Solicitada == item.Cantidad_Recolectado) {
                _lstFiltered.push(item);
            }
            if (filterPartial && item.Cantidad_Recolectado > 0 && item.Cantidad_Recolectado < item.Cantidad_Solicitada){
                _lstFiltered.push(item);
            }
            if (filterEmpty && item.Cantidad_Recolectado == 0 && item.Cantidad_Solicitada > 0) {
                _lstFiltered.push(item);
            }
        });
        if (_lstFiltered.length > 0) {
            this.setState({ lstOrderDetail: _lstFiltered, index:0, currentRowOrderDetail: _lstFiltered[0] });
        } else {
            this.setState({ filterEmpty:false, filterCompleted: false, filterPartial:false, lstOrderDetail: rowOrder.Detalle, index: 0, currentRowOrderDetail: rowOrder.Detalle[0] });
        }  


    }

  async  searchByCode(pCode) {
        const { rowOrder } = this.state;
        if (rowOrder.Detalle.length==0){
            return;
        }
        if (pCode==""){
            return;
        }

        let Response = await ServiceRequest.Consultar_Articulo_Codigo_Equivalente(pCode);
        if (Response.isError == false) {
            if (Response.data == this.state.currentRowOrderDetail.Id) {
                toastr.success("Articulo encontrado!");
                if (this.getCantidad() == "" || this.getCantidad() == 0) {
                    this.updateCantidad(1);
                    this.updateDetalleLinea();
                } else {
                    this.updateCantidad(parseInt(this.getCantidad()) + 1);
                    this.updateDetalleLinea();
                }
                
            } else {
                toastr.warning("El c&oacute;digo escaneado no corresponde al art&iacute;culo actual.");
                this.playAudio('Error');
            }
        } else {
            toastr.error(Response.data);
            this.playAudio('Error');
        }
    }

    onChangeInput(e) {
        const id= e.target.id;
        const name= e.target.name;
        const value = e.target.value;
        let checked = e.target.checked;
        if (checked==undefined){
            checked = false;
        }
        switch(id){
            case 'cantidad':
                this.updateCantidad(value);
                this.updateDetalleLinea();
                break;
            case 'escanearValue':
                this.setState({ escanerValue: value });
                break;
            case 'escanear':
                this.setState({ escanerValue: ''});
                this.searchByCode(value);
                break;
            case 'username':
                this.setState({ username: value});
                break;
            case 'password':
                this.setState({ password: value });
                break;
            case 'cb-completos':
                this.state.filterCompleted = checked;
                this.doFilter();
                break;
            case 'cb-incompletos':
                this.state.filterPartial = checked;
                this.doFilter();
                break;
            case 'cb-pendientes':
                this.state.filterEmpty = checked;
                this.doFilter();
                break;
            ;
        } 
  }

    validarNavigation(pTipo) {
        let _CurrentDetail = this.state.currentRowOrderDetail;
        if (_CurrentDetail.Cantidad_Recolectado == 0 && this.state.ControlarCeros == 'SI' && _CurrentDetail.Picking_Cero == 0) {
            ReactDom.render(<SweetAlert show={true}
                title="Confirmar"
                text={"¿Desea aceptar la cantidad del artículo " + _CurrentDetail.Id + " " + _CurrentDetail.Nombre + " en CERO?"}
                confirmButtonColor={'rgb(72, 196, 136)'}
                showCancelButton onConfirm={() => this.actualizarPickingCero(1, pTipo)}
                onCancel={() => this.doNav(pTipo)}
               
            />,
                document.getElementById('confirm-container'));
        } else {
            this.doNav(pTipo);
        }
    }

    doNav(pTipo) {
        if (pTipo == 'next') {
            this.nextItem();
        }
        if (pTipo == 'prev') {
            this.prevItem();
        }
    }
    
    actualizarPickingCero(pPickingCero, pTipo) {
        let { rowOrder, currentRowOrderDetail } = this.state;
        currentRowOrderDetail.Picking_Cero = pPickingCero;
        this.doNav(pTipo);
        ServiceRequest.Actualizar_Detalle_Linea_PickingWeb(rowOrder.Suc_Id, rowOrder.Pedido_Id, rowOrder.SubPedido_Id, currentRowOrderDetail.Cantidad_Recolectado, currentRowOrderDetail.Id, currentRowOrderDetail.Detalle_Id, pPickingCero);
       // this.setState({ currentRowOrderDetail: currentRowOrderDetail});
    }
    nextItem(){
    let _DetailList= this.state.lstOrderDetail;
    var index=this.state.index;
    if (_DetailList.length>0){
      let nextIndex= index+1;
      if (nextIndex < _DetailList.length){
          let RowCurrent = _DetailList[nextIndex];
          if (_DetailList.length == nextIndex + 1) {
              jQuery("#container-view").hide();
              this.setState({ currentRowOrderDetail: RowCurrent, index: nextIndex, disabledNext:'disabled', disabledPrev:'' });
          } else {
              jQuery("#container-view").hide();
              this.setState({ currentRowOrderDetail: RowCurrent, index: nextIndex, disabledNext: '', disabledPrev: '' });

          }
       
      }    
    }
    }

    prevItem(){
        let _DetailList= this.state.lstOrderDetail;
        var index=this.state.index;
        if (_DetailList.length>0){
          let prevIndex= index-1;
          if (prevIndex >= 0) {
              let RowCurrent = _DetailList[prevIndex];
              if (prevIndex == 0) {
                  jQuery("#container-view").hide();
                  this.setState({ currentRowOrderDetail: RowCurrent, index: prevIndex, disabledPrev:'disabled', disabledNext:'' });
              } else {
                  jQuery("#container-view").hide();
                  this.setState({ currentRowOrderDetail: RowCurrent, index: prevIndex, disabledPrev:'', disabledNext:'' });
              }
            
          } else {
             // this.setState({showOrderDetail:false});
          }    
        }
    }
    onClickBtn(e) {
        const id = e.target.id;
       switch(id){
           case 'btnNext':
               //this.nextItem();        
               this.validarNavigation('next');
               e.target.blur();
           break;
           case 'btnPrev':               
         //  this.prevItem();
               this.validarNavigation('prev');
               e.target.blur();
           break;
           case 'btn-validar':
               this.validarOrder();
               break;
           case 'escanear':
               this.setState({escanerValue:''});
               break;
               ;

       } 
    }

   

    getDataRow(pRow) {
        let _Row = {
            Emp_Id: pRow.Emp_Id,
            CEDI_Id: pRow.CEDI_Id,
            Suc_Id: pRow.Suc_Id,
            Pedido_Id: pRow.Pedido_Id,
            SubPedido_Id: pRow.SubPedido_Id,
            Detalle: pRow.Detalle
        }

        return JSON.stringify(_Row);
    }

  async  changeStateTimeOrder(pRowOrder, pState) {
      const {username, password } = this.state;
      let Response = await ServiceRequest.Despacho_Tiempo_Insertar(this.getDataRow(pRowOrder), pRowOrder.Suc_Id, pRowOrder.Pedido_Id, pRowOrder.SubPedido_Id, pState, username, password);
     if (Response.isError == false) {
         if (Response.data == "") {
             toastr.success("Operaci&oacute;n realizada correctamente.");          
             this.updateTiempoEstadoOrder(pState, pRowOrder.Suc_Id, pRowOrder.Pedido_Id, pRowOrder.SubPedido_Id);
         } else {
             toastr.error(Response.data);
         }
     } else {
         toastr.error(Response.data);
     }
     this.setState({ action: '', username: '', password: '', rowSelected: {} });
    }

  updateOrder() {
      const { rowOrder } = this.state;
      ServiceRequest.Despacho_Actualizar(this.getDataRow(rowOrder));
  }

  updateDetalleLinea() {
      const { rowOrder, currentRowOrderDetail } = this.state;
      let _PickingCero = currentRowOrderDetail.Picking_Cero == true ? 1 : 0;
      ServiceRequest.Actualizar_Detalle_Linea_PickingWeb(rowOrder.Suc_Id, rowOrder.Pedido_Id, rowOrder.SubPedido_Id, currentRowOrderDetail.Cantidad_Recolectado, currentRowOrderDetail.Id, currentRowOrderDetail.Detalle_Id, _PickingCero);
  }

  updateCurrentItemView(pCurrentRow, pCurrentIndex) {

      this.setState({ currentRowOrderDetail: pCurrentRow, index:pCurrentIndex});
  }

  async applyOrder(pRowOrder) {
      const { username, password } = this.state;   

      let Response = await ServiceRequest.Despacho_Aplicar(pRowOrder.Suc_Id, pRowOrder.Pedido_Id, pRowOrder.SubPedido_Id, this.getDataRow(pRowOrder), username, password);
     if (Response.isError == false) {
         if (Response.data!= "") {
             toastr.error(Response.data);
         } else {
            this.updateDespEstadoOrder('AP', pRowOrder.Suc_Id, pRowOrder.Pedido_Id, pRowOrder.SubPedido_Id);
            this.updateTiempoEstadoOrder('FI', pRowOrder.Suc_Id, pRowOrder.Pedido_Id, pRowOrder.SubPedido_Id);
            $('#mas-opciones').modal('hide');
            this.loadOrdersList('pendientes');
            toastr.success("Aplic&oacute; correctamente");
         }

     } else {
         toastr.error(Response.data);
     }
     this.setState({ action: '', username: '', password: '', rowSelected: {} });
  }

  //Seguridad del Menu
  onChangeLoginModal(e) {
      const id = e.target.id;
      const name = e.target.name;
      const value = e.target.value;
      this.setState({ [name]: value });
  }

  onShowLogingModal(accion) {
      this.setState({
          showLoginModal: true,
          accion: accion
      })
  }
  onCloseLoginModal() {
      this.setState({
          showLoginModal: false,
          accion: undefined,
          username: '',
          password: '',
          menu: -1,
          opcion: -1

      });
  }

  async  onValidarLoginModal() {
      const { menu, opcion, username, password, accion, action } = this.state;
      let Response = await ServiceRequest.Menu_Validar_Opcion(menu, opcion, username, password);
      if (Response.isError == false) {
          let _Usuario = Response.data.Usuario_Id;
          let _Mensaje = Response.data.Mensaje;
          if (_Usuario != undefined) {
              if (_Mensaje == "") {
                  accion();
              } else {
                  toastr.error(_Mensaje);
              }

          } else {
              toastr.error("No est&aacute; autorizado para realizar esta acci&oacute;n.")
          }
      } else {
          toastr.error("Ha ocurrido un error al procesar la acci&oacute;n.")
          console.log(Response.data);
      }
  }

  async  validarMenuOpcion(pMenuNombre, pOpcionNombre, accion) {
      let Response = await ServiceRequest.Obtener_Menu_Opcion(pMenuNombre, pOpcionNombre);
      if (Response.isError == false) {
          let _Opcion = Response.data[0];
          if (_Opcion != undefined) {
              this.setState({ menu: _Opcion.Menu_Id, opcion: _Opcion.Opcion_Id });
              if (_Opcion.Opcion_Validar) {
                  this.onShowLogingModal(accion);
              } else {
                  accion();
              }
          } else {
              toastr.error("No est&aacute; autorizado para realizar esta acci&oacute;n.")
          }
      } else {
          toastr.error("Ha ocurrido un error al procesar la acci&oacute;n.")
          console.log(Response.data);
      }
  }

  playAudio(pTipo) {
      if (pTipo == 'Exito') {
          audio.playSound('ExitoAudio');
      }
      if (pTipo == 'Error') {
          audio.playSound('ErrorAudio');
      }
  }
    render() {
        
        const { encabezadoOrder, lstOrderDetail, currentRowOrderDetail, index, disabledNext, disabledPrev, rowOrder, username, password, startDate, endDate, filterCompleted, filterEmpty, filterPartial, EditarCantidad, ControlarCeros } = this.state;
        let _filters = { filterCompleted: filterCompleted, filterPartial: filterPartial, filterEmpty: filterEmpty };
        let d = new Date();
        let time = d.getTime();
        //console.log(lstOrderDetail,'lstOrderDetail');
        return (
            <div>
                <TopBar />
                {this.state.showOrderDetail ?
                    <OrderDetail
                        tipoVista={this.state.viewSelected}
                        encabezadoOrder={encabezadoOrder}
                        data={lstOrderDetail}
                        onHideOrderDetail={this.onHideOrderDetail.bind(this)}
                        onClickBtn={this.onClickBtn.bind(this)}
                        onChangeInput={this.onChangeInput.bind(this)}
                        currentRowOrderDetail={currentRowOrderDetail}
                        index={index}
                        rowOrder={rowOrder}
                        disabledNext={disabledNext}
                        disabledPrev={disabledPrev}
                        updateTimeCurrentOrder={this.updateTimeCurrentOrder.bind(this)}
                        updateEstadoCurrentOrder={this.updateEstadoCurrentOrder.bind(this)}
                        username={username}
                        password={password}
                        changeAction={this.changeAction.bind(this)}
                        escanerValue={this.state.escanerValue}
                        positions={this.state.positions}
                        updateCurrentItemView={this.updateCurrentItemView.bind(this)}
                        filters={_filters}
                        validarMenuOpcion={this.validarMenuOpcion.bind(this)}
                        EditarCantidad={EditarCantidad}
                        ControlarCeros={ControlarCeros}
                    /> :
                    <OrdersView
                        tipoVista={this.state.viewSelected}
                        data={this.state.lstOrders}
                        onChange={this.onChangeView.bind(this)}
                        onShowOrderDetail={this.onShowOrderDetail.bind(this)}
                        onClickBtn={this.onClickBtn.bind(this)}
                        onChangeInput={this.onChangeInput.bind(this)}
                        username={username}
                        password={password}
                        changeAction={this.changeAction.bind(this)}
                        updateTimeCurrentOrder={this.updateTimeCurrentOrder.bind(this)}
                        filtrarOrdersByRangeDate={this.filtrarOrdersByRangeDate.bind(this)}
                        startDate={startDate}
                        endDate={endDate}
                        changeStartDate={this.changeStartDate.bind(this)}
                        changeEndDate={this.changeEndDate.bind(this)}
                    />
                }

                {/*Login Modal */}
                {this.state.showLoginModal ? (
                    <LoginModal
                        onClose={this.onCloseLoginModal.bind(this)}
                        onValidar={this.onValidarLoginModal.bind(this)}
                        username={this.state.username}
                        password={this.state.password}
                        onChange={this.onChangeLoginModal.bind(this)}
                    />) : null}

                {/*Container SweetAlert */}
                <div id="confirm-container"></div>
            </div>
        )
    }
};
export default Picking; 