From bffb7a54d5ce86b9eb265f8941a67c659303ca50 Mon Sep 17 00:00:00 2001 From: valdevir Date: Fri, 16 Feb 2024 18:36:23 -0300 Subject: [PATCH] fixes bug #AL-3494 --- pom.xml | 2 +- .../ventaboletos/dao/BoletoDAO.java | 1 + .../ventaboletos/dao/CorridaTramoDAO.java | 4 + .../dao/hibernate/BoletoHibernateDAO.java | 23 + .../hibernate/CorridaTramoHibernateDAO.java | 60 +- .../ventaboletos/entidad/CorridaTramo.java | 63 ++- .../ventaboletos/service/BoletoService.java | 2 + .../service/CorridaTramoService.java | 16 + .../service/impl/BoletoServiceImpl.java | 4 + .../service/impl/CorridaServiceImpl.java | 121 +--- .../service/impl/CorridaTramoServiceImpl.java | 533 +++++++++++++++++- .../ItemEditarCorridaTramo.java | 286 ++++++++++ 12 files changed, 1001 insertions(+), 114 deletions(-) create mode 100644 src/com/rjconsultores/ventaboletos/vo/esquemaoperacional/ItemEditarCorridaTramo.java diff --git a/pom.xml b/pom.xml index bcada0070..ebfe4287c 100644 --- a/pom.xml +++ b/pom.xml @@ -3,7 +3,7 @@ 4.0.0 br.com.rjconsultores ModelWeb - 1.37.0 + 1.38.0 diff --git a/src/com/rjconsultores/ventaboletos/dao/BoletoDAO.java b/src/com/rjconsultores/ventaboletos/dao/BoletoDAO.java index 69e78f66b..efe7f474a 100644 --- a/src/com/rjconsultores/ventaboletos/dao/BoletoDAO.java +++ b/src/com/rjconsultores/ventaboletos/dao/BoletoDAO.java @@ -25,4 +25,5 @@ public interface BoletoDAO extends GenericDAO { public String getSequenciaNumReservacion(); void insertBoletoReserva(Boleto miBoletoTemporal); public boolean isExisteBoletoPorCorrida(Integer corridaId, Date fecCorrida); + public boolean isExisteBoletoPorCorridaOrigemIdOuDestinoId(Integer corridaId, Date fecCorrida, Integer origemId, Integer destinoId); } diff --git a/src/com/rjconsultores/ventaboletos/dao/CorridaTramoDAO.java b/src/com/rjconsultores/ventaboletos/dao/CorridaTramoDAO.java index 9ce9638d3..d42e7b023 100644 --- a/src/com/rjconsultores/ventaboletos/dao/CorridaTramoDAO.java +++ b/src/com/rjconsultores/ventaboletos/dao/CorridaTramoDAO.java @@ -1,6 +1,7 @@ package com.rjconsultores.ventaboletos.dao; import java.math.BigDecimal; +import java.util.Date; import java.util.List; import com.rjconsultores.ventaboletos.entidad.Corrida; @@ -18,5 +19,8 @@ public interface CorridaTramoDAO extends GenericDAO { public BigDecimal buscarSumTarjetaMesmaCorrida(CorridaTramo ct); List buscarTramoPorCorridaId(Integer corridaId); + + public CorridaTramo buscaCorridaTramoByFecCorridaECorridaIdEdOrigemId(Date fecCorrida, Integer corridaId, boolean isAutorizaServicoIniciado, Integer paradaId); + public List buscaCorridaTramoByFecCorridaECorridaId(Date fecCorrida, Integer corridaId, boolean isAutorizaServicoIniciado); } diff --git a/src/com/rjconsultores/ventaboletos/dao/hibernate/BoletoHibernateDAO.java b/src/com/rjconsultores/ventaboletos/dao/hibernate/BoletoHibernateDAO.java index ce40d226c..d78f1630a 100644 --- a/src/com/rjconsultores/ventaboletos/dao/hibernate/BoletoHibernateDAO.java +++ b/src/com/rjconsultores/ventaboletos/dao/hibernate/BoletoHibernateDAO.java @@ -94,6 +94,29 @@ public class BoletoHibernateDAO extends GenericHibernateDAO implem } + public boolean isExisteBoletoPorCorridaOrigemIdOuDestinoId(Integer corridaId, Date fecCorrida, Integer origemId, Integer destinoId) { + try { + + StringBuilder hql = new StringBuilder(); + hql.append(" select "); + hql.append(" count(*) from boleto b where " ); + hql.append(" b.corrida_id = :corridaId and b.feccorrida = :feccorrida and ROWNUM = 1 and b.activo = :isActivo and (b.origen_id=:origemId or b.destino_id=:destinoId)"); + Query query = getSession().createSQLQuery(hql.toString()); + query.setInteger("isActivo", ActivoUtil.ATIVO); + query.setDate("feccorrida", fecCorrida); + query.setInteger("corridaId", corridaId); + query.setInteger("origemId", origemId); + query.setInteger("destinoId", destinoId); + + BigDecimal qtde = (BigDecimal) query.uniqueResult(); + return qtde !=null && MoneyHelper.isMaior(qtde, BigDecimal.ZERO) ; + }catch(Exception e) { + log.error("Erro buscar Bole to por corrida para corrida=" + corridaId + "data:" + DateUtil.getStringDate(fecCorrida), e); + return false; + } + + } + public String getSequenciaBoletoId(){ String sql = "SELECT BOLETO_SEQ.nextval FROM DUAL"; Object o = this.getSession().createSQLQuery(sql).uniqueResult(); diff --git a/src/com/rjconsultores/ventaboletos/dao/hibernate/CorridaTramoHibernateDAO.java b/src/com/rjconsultores/ventaboletos/dao/hibernate/CorridaTramoHibernateDAO.java index 6a172b36a..8818e270f 100644 --- a/src/com/rjconsultores/ventaboletos/dao/hibernate/CorridaTramoHibernateDAO.java +++ b/src/com/rjconsultores/ventaboletos/dao/hibernate/CorridaTramoHibernateDAO.java @@ -1,10 +1,10 @@ package com.rjconsultores.ventaboletos.dao.hibernate; import java.math.BigDecimal; +import java.util.Date; import java.util.List; -import org.apache.log4j.Logger; - +import org.apache.log4j.Logger; import org.hibernate.Criteria; import org.hibernate.HibernateException; import org.hibernate.Query; @@ -17,12 +17,14 @@ import org.hibernate.type.TimestampType; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Repository; +import org.springframework.transaction.annotation.Transactional; import com.rjconsultores.ventaboletos.dao.CorridaTramoDAO; import com.rjconsultores.ventaboletos.entidad.Corrida; import com.rjconsultores.ventaboletos.entidad.CorridaTramo; import com.rjconsultores.ventaboletos.entidad.Tramo; import com.rjconsultores.ventaboletos.utilerias.ActivoUtil; +import com.rjconsultores.ventaboletos.utilerias.DateUtil; @Repository("corridaTramoDAO") public class CorridaTramoHibernateDAO extends GenericHibernateDAO implements CorridaTramoDAO { @@ -107,4 +109,58 @@ public class CorridaTramoHibernateDAO extends GenericHibernateDAO 0 " : " ct.activo = 1 "); + hql.append(" and ct.corrida.id.corridaId = :corrida_id "); + hql.append(" and ct.corrida.id.feccorrida = :feccorrida "); + hql.append(" and ct.origem.paradaId = :paradaId "); + hql.append(" order by ct.numsecuencia"); + + Query sq = getSession().createQuery(hql.toString()); + sq.setInteger("corrida_id", corridaId); + sq.setDate("feccorrida", fecCorrida); + sq.setInteger("corrida_id", corridaId); + sq.setInteger("paradaId", paradaId); + return (CorridaTramo) sq.uniqueResult(); + }catch (Exception e) { + log.error("Erro ao obter CorridaTramo para corridaId:" + corridaId + " fecCorrida:" + DateUtil.getStringDate24Hour(fecCorrida) + " paradaId:" + paradaId , e); + } + return null; + } + + @Override + public List buscaCorridaTramoByFecCorridaECorridaId(Date fecCorrida, Integer corridaId, + boolean isAutorizaServicoIniciado) { + Criteria c = getSession().createCriteria(getPersistentClass()); + c.add(Restrictions.eq("activo", ActivoUtil.ATIVO)); + c.createAlias("corrida", "corrida"); + c.add(Restrictions.eq("corrida.id.corridaId", corridaId)); + c.add(Restrictions.eq("corrida.id.feccorrida", fecCorrida)); + //c.setProjection(Projections.distinct(Projections.property("tramo"))); + return c.list(); + + } + + + @Override + @Transactional + public CorridaTramo suscribir(final CorridaTramo entity) { + try { + this.getHibernateTemplate().save(entity); + getHibernateTemplate().flush(); + + return entity; + } catch (final HibernateException ex) { + throw convertHibernateAccessException(ex); + } + + } + + } diff --git a/src/com/rjconsultores/ventaboletos/entidad/CorridaTramo.java b/src/com/rjconsultores/ventaboletos/entidad/CorridaTramo.java index e6e9c420b..f44c837bd 100644 --- a/src/com/rjconsultores/ventaboletos/entidad/CorridaTramo.java +++ b/src/com/rjconsultores/ventaboletos/entidad/CorridaTramo.java @@ -33,7 +33,7 @@ import org.hibernate.annotations.NotFoundAction; @Entity @SequenceGenerator(name = "CORRIDA_TRAMO_SEQ", sequenceName = "CORRIDA_TRAMO_SEQ", allocationSize = 1) @Table(name = "CORRIDA_TRAMO") -public class CorridaTramo implements Serializable { +public class CorridaTramo implements Serializable, Comparable { private static final long serialVersionUID = 1L; @Id @@ -118,6 +118,62 @@ public class CorridaTramo implements Serializable { @Temporal(javax.persistence.TemporalType.TIMESTAMP) private Date fechorSalidaOriginalH; + public CorridaTramo(CorridaTramo corridaTramo) { + + this.numsecuencia = corridaTramo.getNumsecuencia(); + + this.fechorsalida = corridaTramo.getFechorsalida(); + + this.fechorllegada = corridaTramo.getFechorllegada(); + + this.fechortarjetaviaje =corridaTramo.getFechortarjetaviaje(); + + this.usuariotarjetaviajeId = corridaTramo.getUsuariotarjetaviajeId(); + + this.numsecorigen = corridaTramo.getNumsecorigen(); + + this.numsecdestino = corridaTramo.getNumsecdestino(); + + this.activo = corridaTramo.getActivo(); + + this.fecmodif = corridaTramo.getFecmodif(); + + this.usuarioId = corridaTramo.getUsuarioId(); + + this.tramo = corridaTramo.getTramo(); + + this.origem = corridaTramo.getOrigem(); + + this.destino = corridaTramo.getDestino(); + + this.nodo = corridaTramo.getNodo(); + + this.conductor = corridaTramo.getConductor(); + + this.conductor1 =corridaTramo.getConductor1(); + + this.autobus = corridaTramo.getAutobus(); + + this.fechorSalidaOriginal = corridaTramo.getFechorSalidaOriginal(); + + this.tiempoEstancia = corridaTramo.getTiempoEstancia(); + + this.indmanttarjeta = corridaTramo.getIndmanttarjeta(); + + this.folioTarjeta = corridaTramo.getFolioTarjeta(); + + this.plataforma = corridaTramo.getPlataforma(); + + this.tipoPassagem = corridaTramo.getTipoPassagem(); + + this.fechorsalidaH = corridaTramo.getFechorsalidaH(); + + this.fechorllegadaH = corridaTramo.getFechorllegadaH(); + + this.fechorSalidaOriginalH = corridaTramo.getFechorSalidaOriginalH(); + } + + public Boolean getIndmanttarjeta() { return indmanttarjeta; } @@ -383,4 +439,9 @@ public class CorridaTramo implements Serializable { public String toString() { return "com.rjconsultores.ventaboletos.entidad.test.CorridaTramo[corridatramoId=" + corridatramoId + "]"; } + + @Override + public int compareTo(CorridaTramo corridaTramo) { + return this.numsecuencia.compareTo(corridaTramo.getNumsecuencia()); + } } diff --git a/src/com/rjconsultores/ventaboletos/service/BoletoService.java b/src/com/rjconsultores/ventaboletos/service/BoletoService.java index 5fbae1263..54ddb9510 100644 --- a/src/com/rjconsultores/ventaboletos/service/BoletoService.java +++ b/src/com/rjconsultores/ventaboletos/service/BoletoService.java @@ -26,4 +26,6 @@ public interface BoletoService { BigDecimal valorSeguro, BigDecimal valorTaxaEmbarque, BigDecimal valorPedagio) throws Exception; public boolean isExisteBoletoPorCorrida(Integer corridaId, Date fecCorrida); + + public boolean isExisteBoletoPorCorridaOrigemIdOuDestinoId(Integer corridaId, Date fecCorrida, Integer origemId, Integer destinoId); } \ No newline at end of file diff --git a/src/com/rjconsultores/ventaboletos/service/CorridaTramoService.java b/src/com/rjconsultores/ventaboletos/service/CorridaTramoService.java index fa5de7e5d..d1d5de62a 100644 --- a/src/com/rjconsultores/ventaboletos/service/CorridaTramoService.java +++ b/src/com/rjconsultores/ventaboletos/service/CorridaTramoService.java @@ -1,10 +1,26 @@ package com.rjconsultores.ventaboletos.service; +import java.util.Date; import java.util.List; +import com.rjconsultores.ventaboletos.entidad.Autobus; +import com.rjconsultores.ventaboletos.entidad.ClaseServicio; import com.rjconsultores.ventaboletos.entidad.CorridaTramo; +import com.rjconsultores.ventaboletos.entidad.EsquemaCorrida; +import com.rjconsultores.ventaboletos.entidad.EsquemaTramo; +import com.rjconsultores.ventaboletos.entidad.Nodo; +import com.rjconsultores.ventaboletos.vo.esquemaoperacional.ItemEditarCorridaTramo; public interface CorridaTramoService extends GenericService { public List obtenerTramoTarjetaEmitida(); + + public boolean atualizaCorridaTramo(ItemEditarCorridaTramo itemEditarCorridaTramo); + + public void adicionaCorridaTramo(ItemEditarCorridaTramo itemEditarCorridaTramo, EsquemaCorrida esquemaCorrida, Date dataCorrida); + + public void excluiCorridaTramo(ItemEditarCorridaTramo itemEditarCorridaTramo); + + public List criaCorridaTramoList(Autobus autobus, Date dataGeracao, Date fechorSalidaOriginalH , + List lsEsquemaTramo, Nodo nodo, ClaseServicio claseServicio, String statusCorrida); } diff --git a/src/com/rjconsultores/ventaboletos/service/impl/BoletoServiceImpl.java b/src/com/rjconsultores/ventaboletos/service/impl/BoletoServiceImpl.java index 123f0c0ec..0d7344181 100644 --- a/src/com/rjconsultores/ventaboletos/service/impl/BoletoServiceImpl.java +++ b/src/com/rjconsultores/ventaboletos/service/impl/BoletoServiceImpl.java @@ -196,5 +196,9 @@ public class BoletoServiceImpl implements BoletoService { } + public boolean isExisteBoletoPorCorridaOrigemIdOuDestinoId(Integer corridaId, Date fecCorrida, Integer origemId, Integer destinoId) { + return boletoDAO.isExisteBoletoPorCorridaOrigemIdOuDestinoId(corridaId, fecCorrida, origemId, destinoId); + + } } diff --git a/src/com/rjconsultores/ventaboletos/service/impl/CorridaServiceImpl.java b/src/com/rjconsultores/ventaboletos/service/impl/CorridaServiceImpl.java index 798a2fbd3..cb5cecfc4 100644 --- a/src/com/rjconsultores/ventaboletos/service/impl/CorridaServiceImpl.java +++ b/src/com/rjconsultores/ventaboletos/service/impl/CorridaServiceImpl.java @@ -18,7 +18,6 @@ import javax.persistence.Transient; import org.apache.commons.lang.StringUtils; import org.apache.commons.lang.math.NumberUtils; import org.apache.log4j.Logger; - import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; @@ -70,6 +69,7 @@ import com.rjconsultores.ventaboletos.service.ConstanteService; import com.rjconsultores.ventaboletos.service.CorridaCtrlService; import com.rjconsultores.ventaboletos.service.CorridaInfoService; import com.rjconsultores.ventaboletos.service.CorridaService; +import com.rjconsultores.ventaboletos.service.CorridaTramoService; import com.rjconsultores.ventaboletos.service.DetDiagramaAutobusService; import com.rjconsultores.ventaboletos.service.EsquemaAsientoService; import com.rjconsultores.ventaboletos.service.EsquemaCorridaInfoService; @@ -98,7 +98,7 @@ public class CorridaServiceImpl implements CorridaService { private static final Logger log = Logger.getLogger(CorridaServiceImpl.class); private static int CANT_MAX_CORRIDA_GERA_MANUAL = 40; - private static SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"); + // Tipo de venda Reserva private static final Integer TPV_RESERVA_NORMAL = 15; @@ -151,7 +151,8 @@ public class CorridaServiceImpl implements CorridaService { private CorridaInfoService corridaInfoService; @Autowired private EsquemaCorridaInfoService esquemaCorridaInfoService; - + @Autowired + private CorridaTramoService corridaTramosService; @Autowired public CorridaServiceImpl(@Qualifier("transactionManager") PlatformTransactionManager transactionManager) { @@ -357,7 +358,7 @@ public class CorridaServiceImpl implements CorridaService { } else { GregorianCalendar gHoraSaidaProximo = new GregorianCalendar(); gHoraSaidaProximo.setTime(horaChegadaAnterior); - + SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"); log.debug("Tempo Recorrido : " + sdf.format(gHoraSaidaProximo.getTime())); if (tiempoEstanciaAnterior != null) { @@ -542,7 +543,11 @@ public class CorridaServiceImpl implements CorridaService { validaFlexBus(esquemaCorrida, corrida); - List lsCorridaTramo = criaCorridaTramoList(esquemaCorrida, dataGeracao, corrida, lsEsquemaTramo, corridaCtrl); + Date fechorSalidaOriginalH = null; + List lsCorridaTramo = corridaTramosService.criaCorridaTramoList(esquemaCorrida.getAutoBus(), dataGeracao, fechorSalidaOriginalH, lsEsquemaTramo, corridaCtrl.getNodo(), corrida.getClaseServicio(), esquemaCorrida.getStatusCorrida()); + for (CorridaTramo corridaTramo : lsCorridaTramo) { + corridaTramo.setCorrida(corrida); + } corrida.setCorridaTramoList(lsCorridaTramo); @@ -600,108 +605,7 @@ public class CorridaServiceImpl implements CorridaService { return corridaCtrl; } - private List criaCorridaTramoList(EsquemaCorrida esquemaCorrida, Date dataGeracao, Corrida corrida, - List lsEsquemaTramo, CorridaCtrl corridaCtrl) { - List lsCorridaTramo = new ArrayList(); - Date horaChegadaAnterior = null; - Date husoHorVeranoLlegadaAnterior = null; - Integer numSec = 1; - for (EsquemaTramo esquemaTramo : lsEsquemaTramo) { - - CorridaTramo corridaTramo = new CorridaTramo(); - - corridaTramo.setAutobus(esquemaCorrida.getAutoBus()!= null ? esquemaCorrida.getAutoBus() : null); - corridaTramo.setConductor(null); - corridaTramo.setConductor1(null); - corridaTramo.setPlataforma(esquemaTramo.getPlataforma()); - corridaTramo.setTipoPassagem(esquemaTramo.getTipoPassagem()); - - corridaTramo.setTiempoEstancia(esquemaTramo.getTiempoEstancia()); - - // numSec: 1-2, 2-3, 3-4... - corridaTramo.setNumsecorigen(numSec.shortValue()); - numSec = numSec + 1; - corridaTramo.setNumsecdestino(numSec.shortValue()); - - Date fecHorSalida = calcularFechorsalida(esquemaTramo, dataGeracao, horaChegadaAnterior, esquemaTramo.getTiempoEstancia()); - corridaTramo.setFechorsalida( getCalendarFechorSalida(fecHorSalida).getTime()); - - Date fecHorallegada = calcularFechorllegada(esquemaTramo, corrida.getClaseServicio(), dataGeracao, fecHorSalida); - corridaTramo.setFechorllegada(getCalendarFechorllegada(fecHorallegada).getTime()); - - horaChegadaAnterior = fecHorallegada; - - corridaTramo.setFechortarjetaviaje(null); - corridaTramo.setNodo(corridaCtrl.getNodo()); - - corridaTramo.setNumsecuencia(esquemaTramo.getNumsecuencia()); - Tramo tramo = esquemaTramo.getTramo(); - if (tramo != null) { - corridaTramo.setOrigem(tramo.getOrigem()); - corridaTramo.setDestino(tramo.getDestino()); - } - corridaTramo.setTramo(tramo); - corridaTramo.setUsuariotarjetaviajeId(null); - - Date excepcionTiempo = arreglaExcepcionTiempo(corridaTramo, corrida.getClaseServicio()); - if (excepcionTiempo != null) { - corridaTramo.setFechorllegada(excepcionTiempo); - horaChegadaAnterior = excepcionTiempo; - } - - if (esquemaCorrida.getStatusCorrida().equals("A")) { - corridaTramo.setActivo(ActivoUtil.ATIVO); - } else if (esquemaCorrida.getStatusCorrida().equals("L")) { - corridaTramo.setActivo(ActivoUtil.INATIVO); - } - // - corridaTramo.setFecmodif(Calendar.getInstance().getTime()); - if (UsuarioLogado.getUsuarioLogado() != null) { - corridaTramo.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId()); - } - corridaTramo.setCorrida(corrida); - corridaTramo.setFechorSalidaOriginal(fecHorSalida); - - if (husoHorVeranoLlegadaAnterior == null) { - corridaTramo.setFechorsalidaH(corridaTramo.getFechorsalida()); - } else { - - // Ajusta tambem o tempo de instancia do calculo do horario de verao - if (esquemaTramo.getTiempoEstancia() != null) { - GregorianCalendar tmp = new GregorianCalendar(); - tmp.setTime(husoHorVeranoLlegadaAnterior); - - tmp.add(Calendar.MINUTE, esquemaTramo.getTiempoEstancia().getMinutes()); - tmp.add(Calendar.HOUR_OF_DAY, esquemaTramo.getTiempoEstancia().getHours()); - - log.debug("Tempo Recorrido H + Estancia: " + sdf.format(tmp.getTime())); - - husoHorVeranoLlegadaAnterior = tmp.getTime(); - - } - - corridaTramo.setFechorsalidaH(husoHorVeranoLlegadaAnterior); - } - - husoHorVeranoLlegadaAnterior = calcularHusoHorVeranoLlegada(esquemaTramo, corridaTramo); - - if (husoHorVeranoLlegadaAnterior != null) { - corridaTramo.setFechorllegadaH(husoHorVeranoLlegadaAnterior); - corridaTramo.setFechorSalidaOriginalH(husoHorVeranoLlegadaAnterior); - } else { - corridaTramo.setFechorllegadaH(corridaTramo.getFechorllegada()); - corridaTramo.setFechorSalidaOriginalH(corridaTramo.getFechorSalidaOriginal()); - } - - if (numSec == 1) { - corrida.setFechorSalidaOriginalH(corridaTramo.getFechorsalidaH()); - } - - lsCorridaTramo.add(corridaTramo); - - } - return lsCorridaTramo; - } + private void validaFlexBus(EsquemaCorrida esquemaCorrida, Corrida corrida) { if(esquemaCorrida.getIsFlexBus()) { @@ -1355,7 +1259,6 @@ public class CorridaServiceImpl implements CorridaService { fecCorrida.setTime(corridaTramo.getFechorllegada()); if (diasSemana.contains(fecCorrida.get(Calendar.DAY_OF_WEEK))) { - log.info("Hay Excepcione de tiempo"); Calendar fechorsalida = Calendar.getInstance(); fechorsalida.setTime(corridaTramo.getFechorsalida()); @@ -1622,7 +1525,7 @@ public class CorridaServiceImpl implements CorridaService { calendarData.setTime(dataConstanteFim); dataAte = DateUtil.normalizarToFecha(calendarData.getTime()); } - + SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"); log.debug("Periodo generacion = " + sdf.format(dataInicial) + " hasta " + sdf.format(dataAte)); if (DateUtil.compareOnlyDate(dataAte, esquemaCorrida.getEsquemaOperacional().getFecfinvigencia()) > 0) { diff --git a/src/com/rjconsultores/ventaboletos/service/impl/CorridaTramoServiceImpl.java b/src/com/rjconsultores/ventaboletos/service/impl/CorridaTramoServiceImpl.java index 1a1b4587a..2095f3fb4 100644 --- a/src/com/rjconsultores/ventaboletos/service/impl/CorridaTramoServiceImpl.java +++ b/src/com/rjconsultores/ventaboletos/service/impl/CorridaTramoServiceImpl.java @@ -1,20 +1,65 @@ package com.rjconsultores.ventaboletos.service.impl; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Date; +import java.util.GregorianCalendar; import java.util.List; +import org.apache.commons.lang.math.NumberUtils; +import org.apache.log4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; import com.rjconsultores.ventaboletos.dao.CorridaTramoDAO; +import com.rjconsultores.ventaboletos.dao.TramoTiempoDAO; +import com.rjconsultores.ventaboletos.entidad.Autobus; +import com.rjconsultores.ventaboletos.entidad.Ciudad; +import com.rjconsultores.ventaboletos.entidad.ClaseServicio; +import com.rjconsultores.ventaboletos.entidad.Corrida; import com.rjconsultores.ventaboletos.entidad.CorridaTramo; +import com.rjconsultores.ventaboletos.entidad.EsquemaCorrida; +import com.rjconsultores.ventaboletos.entidad.EsquemaTramo; +import com.rjconsultores.ventaboletos.entidad.Estado; +import com.rjconsultores.ventaboletos.entidad.Nodo; +import com.rjconsultores.ventaboletos.entidad.Tramo; +import com.rjconsultores.ventaboletos.entidad.TramoServicio; +import com.rjconsultores.ventaboletos.entidad.TramoTiempo; +import com.rjconsultores.ventaboletos.service.CorridaService; import com.rjconsultores.ventaboletos.service.CorridaTramoService; +import com.rjconsultores.ventaboletos.service.TramoServicioService; +import com.rjconsultores.ventaboletos.utilerias.ActivoUtil; +import com.rjconsultores.ventaboletos.utilerias.DateUtil; +import com.rjconsultores.ventaboletos.utilerias.HoraSistema; +import com.rjconsultores.ventaboletos.utilerias.UsuarioLogado; +import com.rjconsultores.ventaboletos.vo.esquemaoperacional.ItemEditarCorridaTramo; @Service("corridaTramoService") public class CorridaTramoServiceImpl implements CorridaTramoService { + + + Logger log; + + @Autowired + private TramoServicioService tramoServicioService; + + @Autowired + private CorridaService corridaService; + + public CorridaTramoServiceImpl() { + super(); + log = Logger.getLogger(CorridaTramoServiceImpl.class); + } + @Autowired private CorridaTramoDAO corridaTramoDAO; + @Autowired + private TramoTiempoDAO tramoTiempoDAO; + @Override public List obtenerTodos() { return corridaTramoDAO.obtenerTodos(); @@ -25,12 +70,14 @@ public class CorridaTramoServiceImpl implements CorridaTramoService { return corridaTramoDAO.obtenerID(id); } - @Override + + @Transactional public CorridaTramo suscribir(CorridaTramo entidad) { return corridaTramoDAO.suscribir(entidad); } @Override + @Transactional public CorridaTramo actualizacion(CorridaTramo entidad) { return corridaTramoDAO.actualizacion(entidad); } @@ -44,4 +91,488 @@ public class CorridaTramoServiceImpl implements CorridaTramoService { public List obtenerTramoTarjetaEmitida() { return corridaTramoDAO.obtenerTramoTarjetaEmitida(); } + + + @Transactional + public boolean atualizaCorridaTramo(ItemEditarCorridaTramo itemEditarCorridaTramo) { + try { + CorridaTramo corridaTramo = corridaTramoDAO.buscaCorridaTramoByFecCorridaECorridaIdEdOrigemId(itemEditarCorridaTramo.getFecCorrida(), itemEditarCorridaTramo.getCorridaId(), false, itemEditarCorridaTramo.getParadaId()); + if(corridaTramo !=null && corridaTramo.getOrigem()!=null && corridaTramo.getOrigem().getParadaId().intValue() == itemEditarCorridaTramo.getParadaId()) { + if(itemEditarCorridaTramo.getTempoEstancia()!=null) { + corridaTramo.setTiempoEstancia(itemEditarCorridaTramo.getTempoEstancia()); + } + if(itemEditarCorridaTramo.getPlataforma()!=null) { + corridaTramo.setPlataforma(itemEditarCorridaTramo.getPlataforma()); + } + if(itemEditarCorridaTramo.getTipoPassagem()!=null) { + corridaTramo.setTipoPassagem(itemEditarCorridaTramo.getTipoPassagem()); + } + if(itemEditarCorridaTramo.getTempoExcecao()!=null) { + corridaTramo.setFechorllegada(calcularFechorllegada(corridaTramo.getFechorllegada(), itemEditarCorridaTramo.getTempoExcecao())); + corridaTramo.setFechorllegadaH(calcularFechorllegada(corridaTramo.getFechorllegadaH(), itemEditarCorridaTramo.getTempoExcecao())); + } + if(actualizacion(corridaTramo)!=null) { + return true; + } + } + + }catch (Exception e) { + log.error("Erro ao atualizar CorridaTramo para corridaId:" + itemEditarCorridaTramo.getCorridaId() + " feccorrida:" + DateUtil.getStringDate24Hour(itemEditarCorridaTramo.getFecCorrida()) + " paradaId:" + itemEditarCorridaTramo.getParadaId(), e); + } + return false; + } + + private Date calcularFechorllegada( Date horaChegada, Date tempoExcecao ) { + try { + if(horaChegada !=null) { + GregorianCalendar gHoraChegada = new GregorianCalendar(); + gHoraChegada.setTime(horaChegada); + HoraSistema hs = null; + if (tempoExcecao != null) { + hs = new HoraSistema(tempoExcecao); + gHoraChegada.add(Calendar.HOUR_OF_DAY, hs.getHora()); + gHoraChegada.add(Calendar.MINUTE, hs.getMinuto()); + } + return gHoraChegada.getTime(); + } + }catch(Exception e) { + log.error("Erro ao calcular fechorLhegada com tempo de exceção ao atualizar corridatramo", e); + } + return horaChegada; + } + + + @Override + @Transactional + public void adicionaCorridaTramo(ItemEditarCorridaTramo itemEditarCorridaTramo, EsquemaCorrida esquemaCorrida, Date dataCorrida) { + //Busca todas as corridas tramo + List corridaTramoList = corridaTramoDAO.buscaCorridaTramoByFecCorridaECorridaId(itemEditarCorridaTramo.getFecCorrida(), itemEditarCorridaTramo.getCorridaId(), false); + //Monta lista de paradas que não foram excluidas + List paradasIdItinerario = carregaParadaIdItinerario(corridaTramoList); + //Monta lista de paradas excluidas + List paradasAdicionadas = new ArrayList(); + paradasAdicionadas.add(itemEditarCorridaTramo.getParadaId()); + + List paradasIdItinerarioNovo = carregaParadaIdItinerario(corridaTramoList); + + paradasIdItinerarioNovo.addAll(paradasIdItinerario); + paradasIdItinerarioNovo.add(itemEditarCorridaTramo.getSecuencia()-1, itemEditarCorridaTramo.getParadaId()); + + inativaCorridasTramos(corridaTramoList); + + Date fechorSalidaOriginalH = null; + List lsCorridaTramo = criaCorridaTramoList(itemEditarCorridaTramo.getAutobus(), itemEditarCorridaTramo.getFecCorrida(), fechorSalidaOriginalH, itemEditarCorridaTramo.getLsEsquemaTramoNova(), itemEditarCorridaTramo.getNodo(), itemEditarCorridaTramo.getClaseServicio(), itemEditarCorridaTramo.getStatusCorrida()); + for (CorridaTramo corridaTramo : lsCorridaTramo) { + corridaTramoDAO.suscribir(corridaTramo); + } + + + } + + @Override + @Transactional + public void excluiCorridaTramo(ItemEditarCorridaTramo itemEditarCorridaTramo) { + //Busca todas as corridas tramo + List corridaTramoList = corridaTramoDAO.buscaCorridaTramoByFecCorridaECorridaId(itemEditarCorridaTramo.getFecCorrida(), itemEditarCorridaTramo.getCorridaId(), false); + + //Inativas Corridas Tramos e cria uma nova lista a ser salva + inativaCorridasTramosInstanciaNovasCorridasTramos(itemEditarCorridaTramo, corridaTramoList); + + Date fechorSalidaOriginalH = null; + List lsCorridaTramo = criaCorridaTramoList(itemEditarCorridaTramo.getAutobus(), itemEditarCorridaTramo.getFecCorrida(), fechorSalidaOriginalH, itemEditarCorridaTramo.getLsEsquemaTramoNova(), itemEditarCorridaTramo.getNodo(), itemEditarCorridaTramo.getClaseServicio(), itemEditarCorridaTramo.getStatusCorrida()); + for (CorridaTramo corridaTramo : lsCorridaTramo) { + Corrida corrida = corridaService.buscarCorridaAtivaPorId(new Corrida.Id(itemEditarCorridaTramo.getCorridaId(),itemEditarCorridaTramo.getFecCorrida() )); + corridaTramo.setCorrida(corrida); + suscribir(corridaTramo); + } + } + + + /** + * Verifica se hay una excepcione de tiempo para el tramo informado. + * + * @param corridaTramo + * @param claseServicio + * @return - Si existe una excepcion, regresa la nueva fecLlegada para el tramo, sino, regreso null + */ + private Date arreglaExcepcionTiempo(CorridaTramo corridaTramo, ClaseServicio claseServicio) { + Date nuevaFecLlegada = null; + + Tramo tramo = corridaTramo.getTramo(); + + List lsExcepciones = tramoTiempoDAO.buscar(tramo, claseServicio, corridaTramo.getFechorsalida(), corridaTramo.getFechorllegada()); + + if (!lsExcepciones.isEmpty()) { + TramoTiempo tramoTiempo = lsExcepciones.get(0); + List diasSemana = getDiaDeLaSemana(tramoTiempo); + + Calendar fecCorrida = Calendar.getInstance(); + fecCorrida.setTime(corridaTramo.getFechorllegada()); + + if (diasSemana.contains(fecCorrida.get(Calendar.DAY_OF_WEEK))) { + + Calendar fechorsalida = Calendar.getInstance(); + fechorsalida.setTime(corridaTramo.getFechorsalida()); + + HoraSistema horaSistema = new HoraSistema(tramoTiempo.getTiemporecorrido()); + + fechorsalida.add(Calendar.HOUR, horaSistema.getHora()); + fechorsalida.add(Calendar.MINUTE, horaSistema.getMinuto()); + + nuevaFecLlegada = fechorsalida.getTime(); + } + } + + return nuevaFecLlegada; + } + + + + private Date calcularFechorllegada(EsquemaTramo esquemaTramo, ClaseServicio clase, Date dataGeracao, Date horaChegada) { + GregorianCalendar gHoraChegada = new GregorianCalendar(); + gHoraChegada.setTime(horaChegada); + HoraSistema hs = null; + + if (esquemaTramo.getExcepcionRecorrido() != null) { + hs = new HoraSistema(esquemaTramo.getExcepcionRecorrido()); + + gHoraChegada.add(Calendar.HOUR_OF_DAY, hs.getHora()); + gHoraChegada.add(Calendar.MINUTE, hs.getMinuto()); + } else { + Tramo tramo = esquemaTramo.getTramo(); + List lsTramoServicio = tramoServicioService.buscarPorTramoServico(tramo, clase); + + for (TramoServicio ts : lsTramoServicio) { + hs = new HoraSistema(ts.getTiemporecorrido()); + + gHoraChegada.add(Calendar.HOUR_OF_DAY, hs.getHora()); + gHoraChegada.add(Calendar.MINUTE, hs.getMinuto()); + } + } + + return gHoraChegada.getTime(); + } + + private Calendar getCalendarFechorllegada(Date fecHorallegada) { + Calendar llegada = Calendar.getInstance(); + llegada.setTime(fecHorallegada); + llegada.set(llegada.get(Calendar.YEAR), llegada.get(Calendar.MONTH), llegada.get(Calendar.DATE), + llegada.get(Calendar.HOUR_OF_DAY), llegada.get(Calendar.MINUTE), NumberUtils.INTEGER_ZERO); + return llegada; + } + + private Calendar getCalendarFechorSalida(Date fecHorSalida) { + Calendar salida = Calendar.getInstance(); + salida.setTime(fecHorSalida); + salida.set(salida.get(Calendar.YEAR), salida.get(Calendar.MONTH), salida.get(Calendar.DATE), + salida.get(Calendar.HOUR_OF_DAY), salida.get(Calendar.MINUTE), NumberUtils.INTEGER_ZERO); + return salida; + } + private Date calcularHusoHorVeranoLlegada(EsquemaTramo esquemaTramo, CorridaTramo corridaTramo) { + + Ciudad ciudadOrigen = esquemaTramo.getTramo().getOrigem().getCiudad(); + Estado estadoOrigen = ciudadOrigen.getEstado(); + + int tiempoOrigen = estadoOrigen.getTiempoHorHuso() == null ? 0 : estadoOrigen.getTiempoHorHuso(); + + Date fecInicioHorVerano = estadoOrigen.getFecInicioHorVerano(); + Date fecFinHorVerano = estadoOrigen.getFecFinoHorVerano(); + + + + if ((fecInicioHorVerano != null) && (fecFinHorVerano != null)) { + if ((DateUtil.compareOnlyDate(fecInicioHorVerano, corridaTramo.getFechorsalida()) <= 0) && (DateUtil.compareOnlyDate(fecFinHorVerano, corridaTramo.getFechorsalida()) >= 0)) { + tiempoOrigen += estadoOrigen.getTiempoHorVerano(); + } + } + // 21688 + Ciudad ciudadDestino = esquemaTramo.getTramo().getDestino().getCiudad(); + Estado estadoDestino = ciudadDestino.getEstado(); + int tiempoDestino = 0; + + if (!estadoDestino.equals(estadoOrigen)) { + tiempoDestino = estadoDestino.getTiempoHorHuso() == null ? 0 : estadoDestino.getTiempoHorHuso(); + + + + Date fecInicioHorVeranoDestino = estadoDestino.getFecInicioHorVerano(); + Date fecFinHorVeranDestino = estadoDestino.getFecFinoHorVerano(); + + if ((fecInicioHorVeranoDestino != null) && (fecFinHorVeranDestino != null)) { + if ((DateUtil.compareOnlyDate(fecInicioHorVeranoDestino, corridaTramo.getFechorllegada()) <= 0) && (DateUtil.compareOnlyDate(fecFinHorVeranDestino, corridaTramo.getFechorllegada()) >= 0)) { + tiempoDestino += estadoDestino.getTiempoHorVerano(); + } + } + } else { + tiempoDestino =0; + tiempoOrigen=0; + } + + //Consideração do fuso por cidade. + //Nesse caso, é mandatório em relação ao estado.Ou seja, equanto que no fuso do estado, + //tem que haver Mudança de estado, para a cidade NÃO, pois pode-se considerar cada cidade + //como um único estado. Sendo assim, devendo ser considerado sempre quando preenchido + if ( (ciudadOrigen.getZonaHoraria() != null) && (ciudadOrigen.getZonaHoraria() != 0 )){ + log.info("Fuso da cidade origem " + ciudadOrigen.getNombciudad() + " : " + ciudadOrigen.getZonaHoraria()); + + tiempoOrigen += ciudadOrigen.getZonaHoraria(); + } + + if ( (ciudadDestino.getZonaHoraria() != null) && (ciudadDestino.getZonaHoraria() != 0 )){ + log.info("Fuso da cidade destino " + ciudadDestino.getNombciudad() + " : " + ciudadDestino.getZonaHoraria()); + + tiempoDestino += ciudadDestino.getZonaHoraria(); + } + //Fim consideração fuso por cidade + + Calendar horLlegada = null; + + long elapsedMinutes = DateUtil.getElapsedMinutos(corridaTramo.getFechorsalida(), corridaTramo.getFechorllegada()); + + horLlegada = Calendar.getInstance(); + horLlegada.setTime(corridaTramo.getFechorsalidaH()); + + horLlegada.add(Calendar.MINUTE, (int) elapsedMinutes); + + // Si los tiempos son distintos, hube cambio de huso horario/horario de verano + if (tiempoOrigen != tiempoDestino) { + horLlegada.add(Calendar.HOUR, (tiempoDestino - tiempoOrigen)); + + } + + return (horLlegada == null) ? null : horLlegada.getTime(); + } + + + @SuppressWarnings("deprecation") + private Date calcularFechorsalida(EsquemaTramo esquemaTramo, Date dataGeracao, Date horaChegadaAnterior, java.util.Date tiempoEstanciaAnterior) { + SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"); + Date horaSaida; + + if (horaChegadaAnterior == null) { + horaSaida = truncarDataHora(dataGeracao, esquemaTramo.getEsquemaCorrida().getHorasalida()); + } else { + GregorianCalendar gHoraSaidaProximo = new GregorianCalendar(); + gHoraSaidaProximo.setTime(horaChegadaAnterior); + + log.debug("Tempo Recorrido : " + sdf.format(gHoraSaidaProximo.getTime())); + + if (tiempoEstanciaAnterior != null) { + gHoraSaidaProximo.add(Calendar.MINUTE, tiempoEstanciaAnterior.getMinutes()); + gHoraSaidaProximo.add(Calendar.HOUR_OF_DAY, tiempoEstanciaAnterior.getHours()); + + log.debug("Tempo Recorrido + Estancia: " + sdf.format(gHoraSaidaProximo.getTime())); + } + + horaSaida = gHoraSaidaProximo.getTime(); + } + + GregorianCalendar gHoraSaida = new GregorianCalendar(); + gHoraSaida.setTime(horaSaida); + + return gHoraSaida.getTime(); + } + + + /** + * Adiciciona as horas do parametro hora na data dataGeracao. + * + * Alem disso eh zerado os campos segundos e milisegundos. + * + * @param dataGeracao + * @param hora + * @return + */ + private Date truncarDataHora(Date dataGeracao, Date hora) { + Date dataCorreta = new Date(); + + GregorianCalendar gAux = new GregorianCalendar(); + gAux.setTime(hora); + GregorianCalendar gcalendar = new GregorianCalendar(); + gcalendar.setTime(dataGeracao); + gcalendar.set(Calendar.HOUR_OF_DAY, gAux.get(Calendar.HOUR_OF_DAY)); + gcalendar.set(Calendar.MINUTE, gAux.get(Calendar.MINUTE)); + gcalendar.set(Calendar.SECOND, 0); + gcalendar.set(Calendar.MILLISECOND, 0); + + dataCorreta = gcalendar.getTime(); + + return dataCorreta; + } + + + + private void inativaCorridasTramos(List corridaTramoList) { + //Inativa corrida tramo + for (CorridaTramo corridaTramo : corridaTramoList) { + corridaTramo.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId()); + corridaTramo.setFecmodif(new Date()); + corridaTramo.setActivo(0); + corridaTramoDAO.suscribir(corridaTramo); + + } + } + + private List inativaCorridasTramosInstanciaNovasCorridasTramos(ItemEditarCorridaTramo itemEditarCorridaTramo, + List corridaTramoList) { + //Inativa corrida tramo + List corridaTramoListNovo = new ArrayList(); + for (CorridaTramo corridaTramo : corridaTramoList) { + corridaTramo.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId()); + corridaTramo.setFecmodif(new Date()); + corridaTramo.setActivo(0); + corridaTramoDAO.actualizacion(corridaTramo); + + } + return corridaTramoListNovo; + } + + + + private List getDiaDeLaSemana(TramoTiempo tramoTiempo) { + List diasValidos = new ArrayList(); + + if (tramoTiempo.getIndapliclun()) { + diasValidos.add(Calendar.MONDAY); + } + if (tramoTiempo.getIndaplicmar()) { + diasValidos.add(Calendar.TUESDAY); + } + if (tramoTiempo.getIndaplicmie()) { + diasValidos.add(Calendar.WEDNESDAY); + } + if (tramoTiempo.getIndaplicjue()) { + diasValidos.add(Calendar.THURSDAY); + } + if (tramoTiempo.getIndaplicvie()) { + diasValidos.add(Calendar.FRIDAY); + } + if (tramoTiempo.getIndaplicsab()) { + diasValidos.add(Calendar.SATURDAY); + } + if (tramoTiempo.getIndaplicdom()) { + diasValidos.add(Calendar.SUNDAY); + } + + return diasValidos; + } + + private List carregaParadaIdItinerario(List miListTramos) { + List paradasIdItinerario = new ArrayList(); + for (CorridaTramo corridaTramo : miListTramos) { + if (!paradasIdItinerario.contains(corridaTramo.getOrigem().getParadaId())) { + paradasIdItinerario.add(corridaTramo.getOrigem().getParadaId()); + } + if (!paradasIdItinerario.contains(corridaTramo.getDestino().getParadaId())) { + paradasIdItinerario.add(corridaTramo.getDestino().getParadaId()); + } + } + return paradasIdItinerario; + } + + @Override + public List criaCorridaTramoList(Autobus autobus, Date dataGeracao, Date fechorSalidaOriginalH , + List lsEsquemaTramo, Nodo nodo, ClaseServicio claseServicio, String statusCorrida) { + List lsCorridaTramo = new ArrayList(); + Date horaChegadaAnterior = null; + Date husoHorVeranoLlegadaAnterior = null; + Integer numSec = 1; + for (EsquemaTramo esquemaTramo : lsEsquemaTramo) { + + CorridaTramo corridaTramo = new CorridaTramo(); + + corridaTramo.setAutobus(autobus!= null ? autobus : null); + corridaTramo.setConductor(null); + corridaTramo.setConductor1(null); + corridaTramo.setPlataforma(esquemaTramo.getPlataforma()); + corridaTramo.setTipoPassagem(esquemaTramo.getTipoPassagem()); + + corridaTramo.setTiempoEstancia(esquemaTramo.getTiempoEstancia()); + + // numSec: 1-2, 2-3, 3-4... + corridaTramo.setNumsecorigen(numSec.shortValue()); + numSec = numSec + 1; + corridaTramo.setNumsecdestino(numSec.shortValue()); + + Date fecHorSalida = calcularFechorsalida(esquemaTramo, dataGeracao, horaChegadaAnterior, esquemaTramo.getTiempoEstancia()); + corridaTramo.setFechorsalida( getCalendarFechorSalida(fecHorSalida).getTime()); + + Date fecHorallegada = calcularFechorllegada(esquemaTramo, claseServicio, dataGeracao, fecHorSalida); + corridaTramo.setFechorllegada(getCalendarFechorllegada(fecHorallegada).getTime()); + + horaChegadaAnterior = fecHorallegada; + + corridaTramo.setFechortarjetaviaje(null); + corridaTramo.setNodo(nodo); + + corridaTramo.setNumsecuencia(esquemaTramo.getNumsecuencia()); + Tramo tramo = esquemaTramo.getTramo(); + if (tramo != null) { + corridaTramo.setOrigem(tramo.getOrigem()); + corridaTramo.setDestino(tramo.getDestino()); + } + corridaTramo.setTramo(tramo); + corridaTramo.setUsuariotarjetaviajeId(null); + + Date excepcionTiempo = arreglaExcepcionTiempo(corridaTramo, claseServicio); + if (excepcionTiempo != null) { + corridaTramo.setFechorllegada(excepcionTiempo); + horaChegadaAnterior = excepcionTiempo; + } + + if ("A".equals(statusCorrida)) { + corridaTramo.setActivo(ActivoUtil.ATIVO); + } else if ("L".equals(statusCorrida)) { + corridaTramo.setActivo(ActivoUtil.INATIVO); + } + // + corridaTramo.setFecmodif(Calendar.getInstance().getTime()); + if (UsuarioLogado.getUsuarioLogado() != null) { + corridaTramo.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId()); + } + //corridaTramo.setCorrida(corrida); + corridaTramo.setFechorSalidaOriginal(fecHorSalida); + + if (husoHorVeranoLlegadaAnterior == null) { + corridaTramo.setFechorsalidaH(corridaTramo.getFechorsalida()); + } else { + + // Ajusta tambem o tempo de instancia do calculo do horario de verao + if (esquemaTramo.getTiempoEstancia() != null) { + SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss"); + GregorianCalendar tmp = new GregorianCalendar(); + tmp.setTime(husoHorVeranoLlegadaAnterior); + + tmp.add(Calendar.MINUTE, esquemaTramo.getTiempoEstancia().getMinutes()); + tmp.add(Calendar.HOUR_OF_DAY, esquemaTramo.getTiempoEstancia().getHours()); + + log.debug("Tempo Recorrido H + Estancia: " + sdf.format(tmp.getTime())); + + husoHorVeranoLlegadaAnterior = tmp.getTime(); + + } + + corridaTramo.setFechorsalidaH(husoHorVeranoLlegadaAnterior); + } + + husoHorVeranoLlegadaAnterior = calcularHusoHorVeranoLlegada(esquemaTramo, corridaTramo); + + if (husoHorVeranoLlegadaAnterior != null) { + corridaTramo.setFechorllegadaH(husoHorVeranoLlegadaAnterior); + corridaTramo.setFechorSalidaOriginalH(husoHorVeranoLlegadaAnterior); + } else { + corridaTramo.setFechorllegadaH(corridaTramo.getFechorllegada()); + corridaTramo.setFechorSalidaOriginalH(corridaTramo.getFechorSalidaOriginal()); + } + + if (numSec == 1) { + fechorSalidaOriginalH = corridaTramo.getFechorsalidaH(); + //corrida.setFechorSalidaOriginalH(corridaTramo.getFechorsalidaH()); + } + + lsCorridaTramo.add(corridaTramo); + + } + return lsCorridaTramo; + } } diff --git a/src/com/rjconsultores/ventaboletos/vo/esquemaoperacional/ItemEditarCorridaTramo.java b/src/com/rjconsultores/ventaboletos/vo/esquemaoperacional/ItemEditarCorridaTramo.java new file mode 100644 index 000000000..83f8fa22c --- /dev/null +++ b/src/com/rjconsultores/ventaboletos/vo/esquemaoperacional/ItemEditarCorridaTramo.java @@ -0,0 +1,286 @@ +package com.rjconsultores.ventaboletos.vo.esquemaoperacional; + +import java.util.Date; +import java.util.List; + +import com.rjconsultores.ventaboletos.entidad.Autobus; +import com.rjconsultores.ventaboletos.entidad.ClaseServicio; +import com.rjconsultores.ventaboletos.entidad.EsquemaTramo; +import com.rjconsultores.ventaboletos.entidad.Nodo; + +public class ItemEditarCorridaTramo { + private Integer secuencia; + private String descParada; + private Integer paradaId; + private String estancia; + private String estado; + private Integer estadoId; + private Date tempoEstancia; + private Date tempoExcecao; + private String msgError; + private Date fechortarjetaviaje; + private String plataforma; + private String fechorllegada; + private Date fechaLlegada; + private Date fechaLlegadaNormal; + private Integer difFuso; + private String tipoPassagem; + private String fechorllegadaHusoVerano; + private Date fechaLlegadaHusoVerano; + private Date periodoInicial; + private Date periodoFinal; + private boolean isTramoEditado; + private boolean isExcluido; + private boolean isAdicionado; + private Date fecCorrida; + private Integer corridaId; + private Autobus autobus; + private List lsEsquemaTramoNova; + private ClaseServicio claseServicio; + private String statusCorrida; + private Nodo nodo; + + + + public List getLsEsquemaTramoNova() { + return lsEsquemaTramoNova; + } + + public void setLsEsquemaTramoNova(List lsEsquemaTramoNova) { + this.lsEsquemaTramoNova = lsEsquemaTramoNova; + } + + public Date getFecCorrida() { + return fecCorrida; + } + + public void setFecCorrida(Date fecCorrida) { + this.fecCorrida = fecCorrida; + } + + public Integer getCorridaId() { + return corridaId; + } + + public void setCorridaId(Integer corridaId) { + this.corridaId = corridaId; + } + + public boolean isExcluido() { + return isExcluido; + } + + public void setExcluido(boolean isExcluido) { + this.isExcluido = isExcluido; + } + + public boolean isAdicionado() { + return isAdicionado; + } + + public void setAdicionado(boolean isAdicionado) { + this.isAdicionado = isAdicionado; + } + + public boolean isTramoEditado() { + return isTramoEditado; + } + + public void setTramoEditado(boolean isTramoEditado) { + this.isTramoEditado = isTramoEditado; + } + + public Integer getSecuencia() { + return secuencia; + } + + public void setSecuencia(Integer secuencia) { + this.secuencia = secuencia; + } + + public String getDescParada() { + return descParada; + } + + public void setDescParada(String descParada) { + this.descParada = descParada; + } + + public Integer getParadaId() { + return paradaId; + } + + public void setParadaId(Integer paradaId) { + this.paradaId = paradaId; + } + + public String getEstancia() { + return estancia; + } + + public void setEstancia(String estancia) { + this.estancia = estancia; + } + + public String getEstado() { + return estado; + } + + public void setEstado(String estado) { + this.estado = estado; + } + + public Integer getEstadoId() { + return estadoId; + } + + public void setEstadoId(Integer estadoId) { + this.estadoId = estadoId; + } + + public Date getTempoEstancia() { + return tempoEstancia; + } + + public void setTempoEstancia(Date tempoEstancia) { + this.tempoEstancia = tempoEstancia; + } + + public Date getTempoExcecao() { + return tempoExcecao; + } + + public void setTempoExcecao(Date tempoExcecao) { + this.tempoExcecao = tempoExcecao; + } + + public String getMsgError() { + return msgError; + } + + public void setMsgError(String msgError) { + this.msgError = msgError; + } + + public Date getFechortarjetaviaje() { + return fechortarjetaviaje; + } + + public void setFechortarjetaviaje(Date fechortarjetaviaje) { + this.fechortarjetaviaje = fechortarjetaviaje; + } + + public String getPlataforma() { + return plataforma; + } + + public void setPlataforma(String plataforma) { + this.plataforma = plataforma; + } + + public String getFechorllegada() { + return fechorllegada; + } + + public void setFechorllegada(String fechorllegada) { + this.fechorllegada = fechorllegada; + } + + public Date getFechaLlegada() { + return fechaLlegada; + } + + public void setFechaLlegada(Date fechaLlegada) { + this.fechaLlegada = fechaLlegada; + } + + public Date getFechaLlegadaNormal() { + return fechaLlegadaNormal; + } + + public void setFechaLlegadaNormal(Date fechaLlegadaNormal) { + this.fechaLlegadaNormal = fechaLlegadaNormal; + } + + public Integer getDifFuso() { + return difFuso; + } + + public void setDifFuso(Integer difFuso) { + this.difFuso = difFuso; + } + + public String getTipoPassagem() { + return tipoPassagem; + } + + public void setTipoPassagem(String tipoPassagem) { + this.tipoPassagem = tipoPassagem; + } + + public String getFechorllegadaHusoVerano() { + return fechorllegadaHusoVerano; + } + + public void setFechorllegadaHusoVerano(String fechorllegadaHusoVerano) { + this.fechorllegadaHusoVerano = fechorllegadaHusoVerano; + } + + public Date getFechaLlegadaHusoVerano() { + return fechaLlegadaHusoVerano; + } + + public void setFechaLlegadaHusoVerano(Date fechaLlegadaHusoVerano) { + this.fechaLlegadaHusoVerano = fechaLlegadaHusoVerano; + } + + public Date getPeriodoInicial() { + return periodoInicial; + } + + public void setPeriodoInicial(Date periodoInicial) { + this.periodoInicial = periodoInicial; + } + + public Date getPeriodoFinal() { + return periodoFinal; + } + + public void setPeriodoFinal(Date periodoFinal) { + this.periodoFinal = periodoFinal; + } + + public Autobus getAutobus() { + return autobus; + } + + public void setAutobus(Autobus autobus) { + this.autobus = autobus; + } + + public ClaseServicio getClaseServicio() { + return claseServicio; + } + + public void setClaseServicio(ClaseServicio claseServicio) { + this.claseServicio = claseServicio; + } + + public String getStatusCorrida() { + return statusCorrida; + } + + public void setStatusCorrida(String statusCorrida) { + this.statusCorrida = statusCorrida; + } + + public Nodo getNodo() { + return nodo; + } + + public void setNodo(Nodo nodo) { + this.nodo = nodo; + } + + +}