Autocomplete disponibles en base a rango de dos fechas seleccionadas

Deseamos que al seleccionar la fecha y hora de inicio y de fin desde <p:calendar>, mostrar en un autocomplete los vehículos disponibles entre ese intervalo.

Video:

https://youtu.be/j_PWFAbPBsg

Se usa para formularios de edición de fecha hora que estan en rangos
Al cambiar la fecha y hora tener presente que puede caer en otro rango
Por ejemplo si editamos las fechas y horas del ferrari, que esta entre 16.00 y 23.00 si tratamos de editar el segundo registro colocando lo en un intervalo que este entre 1.50 7 15.00 horas no lo pemitira
El formulario permite editar fechas y vehículos y conductores validando el rango.

Personalizar el <p:calendar>

En este ejemplo creamos un componente <p:calendar> personalizado,

Invocamos el evento dateSelect

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:p="http://primefaces.org/ui"
      xmlns:composite="http://java.sun.com/jsf/composite"
      xmlns:b="http://bootsfaces.net/ui"
      xmlns:f="http://xmlns.jcp.org/jsf/core">
    <composite:interface >


        <composite:attribute name="id" />
        <composite:attribute name="value" />
        <composite:attribute name="label"/>
        <composite:attribute name="mindate" default=""/>
        <composite:attribute name="mode" default="popup"/>
        <composite:attribute name="required" default="false"/>
        <composite:attribute name="pattern" default="dd/MM/yyyy" />
    </composite:interface>
    <composite:implementation>




        <p:calendar
            id="#{cc.attrs.id}" 
           mode="#{cc.attrs.mode}"

            value="#{cc.attrs.value}"
            placeholder="#{cc.attrs.label}"  
            required="#{cc.attrs.required}" 
            requiredMessage="#{cc.attrs.label} #{app['info.required']}"
            pattern="#{cc.attrs.pattern}"
            selectOtherMonths="true"
            showTodayButton="true"
            mindate="#{cc.attrs.mindate}"
            navigator="true">
   <p:ajax event="dateSelect" listener="#{viajeController.handleSelect}"
            update=":form:vehiculo, :form:conductor, :form:msg"     />

        </p:calendar>

    </composite:implementation>

</html>

Los autocomplete deben excluir los registros actuales

  <extensionviaje:autocompletevehiculos id="vehiculo"/>

Componente

<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:p="http://primefaces.org/ui"
      xmlns:composite="http://java.sun.com/jsf/composite"
      xmlns:h="http://xmlns.jcp.org/jsf/html">
    <composite:interface >


        <composite:attribute name="value" />
            <composite:attribute name="disabled" default="false" />
        <composite:attribute name="itemLabel" />
        <composite:attribute name="multiple" default="false" />
        <composite:attribute name="dropdown"  default="false"/>
        <composite:attribute name="minQueryLength"  default="1"/>
        <composite:attribute name="update" />
        <composite:attribute name="rendered"/>
        <composite:attribute name="required" default="false" />
        <composite:attribute name="field"/>
        <composite:attribute name="fromstart" default="true"/>
        <composite:attribute name="size"  default="25"/>
        <composite:attribute name="listener"  
                             method-signature="void handleSelect(org.primefaces.event.SelectEvent)" />

    </composite:interface>
    <composite:implementation>

                    <p:autoComplete dropdown="true"
                                    id="vehiculo"
                                    multiple="false"
                                    scrollHeight="250"
                                    size="25"

                                    emptyMessage="#{app['info.nohayregistros']}"
                                    value="#{viajeController.viaje.vehiculo}"
                                    completeMethod="#{viajeController.completeVehiculo}"
                                    var="p"
                                    required="true"
                                    requiredMessage="#{msg['field.vehiculo']}"
                                    itemLabel=" #{p.marca} #{p.modelo} #{p.placa}"
                                    itemValue="#{p}" forceSelection="true">
                        <f:converter binding="#{vehiculoConverter}"/>
                        <f:attribute name="field" value="marca"/>
                        <f:attribute name="fielddropdown" value="false"/>
                        <f:attribute name="fieldquerylenth" value="0"/>
                        <p:ajax event="itemSelect" listener="#{viajeController.handleSelect}"
                                update=""    />
                        <p:ajax event="itemUnselect"  listener="#{viajeController.handleSelect}"
                                update=""
                                />
                        <f:facet name="itemtip">
                            <h:panelGrid columns="2" cellpadding="5">
                                <h:outputText value="#{msg['field.idvehiculo']}" />
                                <h:outputText value="#{p.idvehiculo}" />
                                <h:outputText value="#{msg['field.marca']}" />
                                <h:outputText value="#{p.marca}" />
                                <h:outputText value="#{msg['field.modelo']}" />
                                <h:outputText value="#{p.modelo}" />
                                <h:outputText value="#{msg['field.placa']}" />
                                <h:outputText value="#{p.placa}" />


                            </h:panelGrid>
                        </f:facet>
                    </p:autoComplete>


    </composite:implementation>

</html>

ViajeController.java

Definir atributo

  Boolean iseditable = false;

init()

  @PostConstruct
    public void init() {
        try {
            iseditable = false;
            vehiculoSelected = new Vehiculo();
            conductorSelected = new Conductor();
            String action = loginController.get("viaje");
            String id = loginController.get("idviaje");
            String pageSession = loginController.get("pageviaje");
            //Search

            if (loginController.get("searchviaje") == null || loginController.get("searchviaje").equals("")) {
                loginController.put("searchviaje", "_init");
            }
            writable = false;

            viajeList = new ArrayList<>();
            viajeFiltered = new ArrayList<>();
            viaje = new Viaje();
            viajeDataModel = new ViajeDataModel(viajeList);

            if (pageSession != null) {
                page = Integer.parseInt(pageSession);
            }
            Integer c = viajeRepository.sizeOfPage(rowPage);
            page = page > c ? c : page;
            if (action != null) {
                switch (action) {
                    case "gonew":
                        viaje = new Viaje();
                        viaje.setFechahorainicioreserva(DateUtil.getFechaHoraActual());
                        viaje.setFechahorafinreserva(DateUtil.getFechaHoraActual());
                        viaje.setActivo("si");
                        viaje.setLugarpartida("UTP-AZUERO");
                        viajeSelected = viaje;

                        writable = false;
                        break;
                    case "view":
                        if (id != null) {
                            Optional<Viaje> optional = viajeRepository.find("idviaje", Integer.parseInt(id));
                            if (optional.isPresent()) {
                                viaje = optional.get();
                                viajeSelected = viaje;
                                vehiculoSelected = viaje.getVehiculo();
                                conductorSelected = viaje.getConductor();

                                fechaHoraInicioReservaanterior = viaje.getFechahorainicioreserva();
                                fechaHoraFinReservaAnterior = viaje.getFechahorafinreserva();
                                iseditable = true;
                                writable = true;

                            }
                        }
                        break;
                    case "golist":
                        move();
                        break;
                }
            } else {
                move();
            }

        } catch (Exception e) {
            errorServices.errorMessage(nameOfClass(), nameOfMethod(), e.getLocalizedMessage());
        }
    }// </editor-fold>

Método completeVehiculo()

Verificamos si hay cambios en fechas horas

 public List<Vehiculo> completeVehiculo(String query) {
        List<Vehiculo> suggestions = new ArrayList<>();
        List<Vehiculo> temp = new ArrayList<>();

        try {
            Boolean found = false;
            query = query.trim();
            if (iseditable && noHayCambioFechaHoras()) {
                suggestions.add(vehiculoSelected);
            }
            String field = (String) UIComponent.getCurrentComponent(FacesContext.getCurrentInstance()).getAttributes().get("field");
            temp = vehiculoRepository.findRegex(field, query, true, new Document(field, 1));

            if (!temp.isEmpty()) {
                List<Vehiculo> validos = new ArrayList<>();
                if (noHayCambioFechaHoras()) {
                    validos = temp.stream()
                            .filter(x -> isVehiculoActivoDisponible(x)).collect(Collectors.toList());

                } else {
                    validos = temp.stream()
                            .filter(x -> isVehiculoActivoDisponibleExcluyendoMismoViaje(x)).collect(Collectors.toList());
                    //si cambia el vehiculo

                }

                if (validos.isEmpty()) {

                    return suggestions;
                }
                if (vehiculoList == null || vehiculoList.isEmpty()) {

                    validos.forEach((v) -> {
                        suggestions.add(v);
                    }); //  validos.add(vehiculoSelected);

                    //   return validos;
                } else {
// REMOVERLOS SI YA ESTAN EN EL LISTADO

                    validos.forEach((v) -> {
                        Optional<Vehiculo> optional = vehiculoList.stream()
                                .filter(v2 -> v2.getIdvehiculo() == v.getIdvehiculo())
                                .findAny();
                        if (!optional.isPresent()) {
                            suggestions.add(v);
                        }
                    });

                }
            }

        } catch (Exception e) {
            errorServices.errorMessage(nameOfClass(), nameOfMethod(), e.getLocalizedMessage());
        }
        return suggestions;
    }

Verifica si cambio la fecha y hora

private Boolean noHayCambioFechaHoras() {
        return fechaHoraInicioReservaanterior.equals(viaje.getFechahorainicioreserva()) && fechaHoraFinReservaAnterior.equals(viaje.getFechahorafinreserva());

    }

isVehiculoActivoDisponible()

 public Boolean isVehiculoActivoDisponible(Vehiculo vehiculo) {
        Boolean valid = false;
        try {

            if (vehiculo.getActivo().equals("no") && vehiculo.getEnreparacion().equals("si")) {

            } else {
                if (viajeServices.vehiculoDisponible(vehiculo, viaje.getFechahorainicioreserva(), viaje.getFechahorafinreserva())) {
                    valid = true;
                }
            }

        } catch (Exception e) {
            errorServices.errorDialog(nameOfClass(), nameOfMethod(), nameOfMethod(), e.getLocalizedMessage());
        }
        return valid;
    }

isVehiculoActivoDisponibleExcluyendoMismoViaje(Vehiculo vehiculo)

Busca el vehiculo y excluye el actual

public Boolean isVehiculoActivoDisponibleExcluyendoMismoViaje(Vehiculo vehiculo) {
        Boolean valid = false;
        try {

            if (vehiculo.getActivo().equals("no") && vehiculo.getEnreparacion().equals("si")) {

            } else {
                if (viajeServices.vehiculoDisponibleExcluyendoMismoViaje(vehiculo, viaje.getFechahorainicioreserva(), viaje.getFechahorafinreserva(), viaje.getIdviaje())) {
                    valid = true;
                }
            }

        } catch (Exception e) {
            errorServices.errorDialog(nameOfClass(), nameOfMethod(), "isVehiculoValid()", e.getLocalizedMessage());
        }
        return valid;
    }

save()

 public String save() {
        try {
            if (!viajeServices.isValid(viaje)) {
                return "";
            }

            if (!viajeServices.vehiculoDisponible(viaje)) {
                JsfUtil.warningMessage(rf.getMessage("warning.vehiculoenviajefechas"));
                return null;
            }

            if (viaje.getConductor().getEscontrol().equals("no")) {
                if (!viajeServices.conductorDisponible(viaje)) {
                    JsfUtil.warningMessage(rf.getMessage("warning.conductoresenviajefechas"));
                    return null;
                }
            }

            Integer idviaje = autoincrementableTransporteejbServices.getContador("viaje");
            viaje.setIdviaje(idviaje);
            viaje.setRealizado("no");
            viaje.setActivo("si");

            //Lo datos del usuario
            viaje.setUserInfo(userInfoServices.generateListUserinfo(loginController.getUsername(), "create"));
            if (viajeRepository.save(viaje)) {
                //guarda el contenido anterior
                revisionHistoryTransporteejbRepository.save(revisionHistoryServices.getRevisionHistory(viaje.getIdviaje().toString(), loginController.getUsername(),
                        "create", "viaje", viajeRepository.toDocument(viaje).toString()));

                JsfUtil.successMessage(rf.getAppMessage("info.save"));
                reset();
            } else {
                JsfUtil.successMessage("save() " + viajeRepository.getException().toString());
            }

        } catch (Exception e) {
            errorServices.errorMessage(nameOfClass(), nameOfMethod(), e.getLocalizedMessage());
        }
        return "";
    }// </editor-fold>

edit()

Validar si cambio la fecha y hora

 public String edit() {
        try {
            if (!viajeServices.isValid(viaje)) {
                return "";
            }

            if (noHayCambioFechaHoras()) {
                //si cambia el vehiculo
                if (!viaje.getVehiculo().getIdvehiculo().equals(vehiculoSelected.getIdvehiculo())) {
                    if (!viajeServices.vehiculoDisponible(viaje)) {
                        JsfUtil.warningMessage(rf.getMessage("warning.vehiculoenviajefechas"));
                        return null;
                    }
                }
                // si cambio el conductor
                if (!viaje.getConductor().getIdconductor().equals(conductorSelected.getIdconductor())) {
                    if (viaje.getConductor().getEscontrol().equals("no")) {
                        if (!viajeServices.conductorDisponible(viaje)) {
                            JsfUtil.warningMessage(rf.getMessage("warning.conductoresenviajefechas"));
                            return null;
                        }
                    }
                }

            } else {
                //si cambia el vehiculo
                if (!viajeServices.vehiculoDisponibleExcluyendoMismoViaje(viaje)) {
                    JsfUtil.warningMessage(rf.getMessage("warning.vehiculoenviajefechas"));
                    return null;
                }

                // si cambio el conductor
                if (viaje.getConductor().getEscontrol().equals("no")) {
                    if (!viajeServices.conductorDisponibleExcluyendoMismoViaje(viaje)) {
                        JsfUtil.warningMessage(rf.getMessage("warning.conductoresenviajefechas"));
                        return null;
                    }
                }
            }

            viaje.getUserInfo().add(userInfoServices.generateUserinfo(loginController.getUsername(), "update"));

            //guarda el contenido actualizado
            revisionHistoryTransporteejbRepository.save(revisionHistoryServices.getRevisionHistory(viaje.getIdviaje().toString(), loginController.getUsername(),
                    "update", "viaje", viajeRepository.toDocument(viaje).toString()));

            viajeRepository.update(viaje);
            JsfUtil.successMessage(rf.getAppMessage("info.update"));
        } catch (Exception e) {
            errorServices.errorMessage(nameOfClass(), nameOfMethod(), e.getLocalizedMessage());
        }
        return "";
    }// </editor-fold>

ViajesServices.java

vehiculoDisponible()

Verifica si esta disponible el vehiculo

public Boolean vehiculoDisponible(Vehiculo vehiculo, Date fechahorainicioreserva, Date fechahorafinreserva) {
        try {
           Bson filter= Filters.and(eq("vehiculo.idvehiculo",vehiculo.getIdvehiculo()),eq("activo","si"));
//           
              return repository.isAvailableBetweenDateHour(filter,
                   "fechahorainicioreserva", fechahorainicioreserva, "fechahorafinreserva", fechahorafinreserva);

        } catch (Exception e) {
            JsfUtil.errorDialog("vehiculoDisponible() ", e.getLocalizedMessage().toString());
        }
        return false;
    }

vehiculoDisponibleExcluyendoMismoViaje()

Verifica si esta disponible excluyendo el mismo viaje para edición.

public Boolean vehiculoDisponibleExcluyendoMismoViaje(Vehiculo vehiculo, Date fechahorainicioreserva, Date fechahorafinreserva,Integer idviaje) {
        try {
           Bson filter= Filters.and(eq("vehiculo.idvehiculo",vehiculo.getIdvehiculo()),eq("activo","si"),ne("idviaje",idviaje));

              return repository.isAvailableBetweenDateHour(filter,
                   "fechahorainicioreserva", fechahorainicioreserva, "fechahorafinreserva", fechahorafinreserva);

        } catch (Exception e) {
            JsfUtil.errorDialog("vehiculoDisponible() ", e.getLocalizedMessage().toString());
        }
        return false;
    }

PreviousDisponible entre dos fechas en rangos de fechas inicial y final NextAutocomplete en rangos de fechas excluyendo el mismo entity

Last updated 6 years ago

Was this helpful?