632 lines
21 KiB
Java
632 lines
21 KiB
Java
/*
|
||
* To change this template, choose Tools | Templates
|
||
* and open the template in the editor.
|
||
*/
|
||
package com.rjconsultores.ventaboletos.service.impl;
|
||
|
||
import java.util.ArrayList;
|
||
import java.util.Calendar;
|
||
import java.util.Comparator;
|
||
import java.util.HashMap;
|
||
import java.util.List;
|
||
|
||
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.CorridaDAO;
|
||
import com.rjconsultores.ventaboletos.dao.EsquemaCorridaDAO;
|
||
import com.rjconsultores.ventaboletos.dao.RutaDAO;
|
||
import com.rjconsultores.ventaboletos.entidad.ClaseServicio;
|
||
import com.rjconsultores.ventaboletos.entidad.Empresa;
|
||
import com.rjconsultores.ventaboletos.entidad.OrgaoConcedente;
|
||
import com.rjconsultores.ventaboletos.entidad.Parada;
|
||
import com.rjconsultores.ventaboletos.entidad.ParadaSecuencia;
|
||
import com.rjconsultores.ventaboletos.entidad.ParadaSecuenciaCombinacaoLinha;
|
||
import com.rjconsultores.ventaboletos.entidad.Ruta;
|
||
import com.rjconsultores.ventaboletos.entidad.RutaCaseta;
|
||
import com.rjconsultores.ventaboletos.entidad.RutaCombinacion;
|
||
import com.rjconsultores.ventaboletos.entidad.RutaEmpresa;
|
||
import com.rjconsultores.ventaboletos.entidad.RutaSecuencia;
|
||
import com.rjconsultores.ventaboletos.entidad.Tramo;
|
||
import com.rjconsultores.ventaboletos.entidad.Via;
|
||
import com.rjconsultores.ventaboletos.exception.BusinessException;
|
||
import com.rjconsultores.ventaboletos.service.ParadaService;
|
||
import com.rjconsultores.ventaboletos.service.RutaCombinacionService;
|
||
import com.rjconsultores.ventaboletos.service.RutaSecuenciaService;
|
||
import com.rjconsultores.ventaboletos.service.RutaService;
|
||
import com.rjconsultores.ventaboletos.service.TramoService;
|
||
import com.rjconsultores.ventaboletos.utilerias.RegistroConDependenciaException;
|
||
import com.rjconsultores.ventaboletos.utilerias.UsuarioLogado;
|
||
|
||
/**
|
||
*
|
||
* @author Rafius
|
||
*/
|
||
@Service("rutaService")
|
||
@SuppressWarnings("unused")
|
||
public class RutaServiceImpl implements RutaService {
|
||
|
||
@Autowired
|
||
private RutaDAO rutaDAO;
|
||
@Autowired
|
||
private TramoService tramoService;
|
||
@Autowired
|
||
private RutaCombinacionService rutaCombinacionService;
|
||
@Autowired
|
||
private RutaSecuenciaService rutaSecuenciaService;
|
||
@Autowired
|
||
private CorridaDAO corridaDAO;
|
||
@Autowired
|
||
private EsquemaCorridaDAO esquemaCorridaDAO;
|
||
@Autowired
|
||
private ParadaService paradaService;
|
||
|
||
private static Logger log = Logger.getLogger(RutaServiceImpl.class);
|
||
|
||
public List<Ruta> obtenerTodos() {
|
||
return rutaDAO.obtenerTodos();
|
||
}
|
||
|
||
public Ruta obtenerID(Integer id) {
|
||
return rutaDAO.obtenerID(id);
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = BusinessException.class)
|
||
public Parada validaParada(String descripcionParada, Parada paradaAntiga) throws Exception {
|
||
|
||
String cve = extrairCodigoOuLocalidade(descripcionParada, true, false);
|
||
String descparada = extrairCodigoOuLocalidade(descripcionParada, false, true);
|
||
|
||
if (cve == null || descparada == null)
|
||
throw new BusinessException("editarCatalogoDeRutaController.actionCanbiarParada.businessException");
|
||
try {
|
||
List<Parada> paradas = paradaService.buscarCVE(cve);
|
||
paradas.addAll(paradaService.buscar(descparada));
|
||
if (!paradas.isEmpty()) {
|
||
return paradas.iterator().next();
|
||
} else {
|
||
return null;
|
||
}
|
||
} catch (Exception e) {
|
||
throw e;
|
||
}
|
||
}
|
||
|
||
private String extrairCodigoOuLocalidade(String descripcionParada, boolean isCodigo, boolean isLocalidade) throws Exception {
|
||
try {
|
||
String arraySplit[] = new String[2];
|
||
arraySplit = descripcionParada.split(" - ");
|
||
if (isCodigo)
|
||
return arraySplit[0];
|
||
if (isLocalidade)
|
||
return arraySplit[1];
|
||
} catch (Exception e) {
|
||
throw new BusinessException("editarCatalogoDeRutaController.actionCanbiarParada.businessException");
|
||
}
|
||
return null;
|
||
}
|
||
|
||
@Override
|
||
@Transactional(rollbackFor = BusinessException.class)
|
||
public boolean cambiarParadaRuta(Ruta ruta, Parada paradaAntiga, Parada nuevaParada, String descripcionParada) throws Exception {
|
||
|
||
try {
|
||
String cve = extrairCodigoOuLocalidade(descripcionParada, true, false);
|
||
String descparada = extrairCodigoOuLocalidade(descripcionParada, false, true);
|
||
|
||
if (nuevaParada == null) {
|
||
nuevaParada = crearNuevaParada(paradaAntiga, cve, descparada);
|
||
paradaService.suscribirActualizar(nuevaParada);
|
||
}
|
||
|
||
List<Tramo> tramos = validaTramosRuta(ruta);
|
||
List<CambioRutaTramo> cambios = new ArrayList<CambioRutaTramo>();
|
||
for (Tramo tramo : tramos) {
|
||
Tramo nTramo = crearNuevoTramo(tramo, paradaAntiga, nuevaParada);
|
||
if (nTramo != null) {
|
||
cambios.add(new CambioRutaTramo(tramo, nTramo, paradaAntiga, nuevaParada));
|
||
tramoService.suscribirActualizar(nTramo);
|
||
}
|
||
}
|
||
|
||
for (CambioRutaTramo crt : cambios) {
|
||
rutaDAO.updateAsientosVendibles(ruta, crt.getViejoTramo(), crt.getNuevoTramo());
|
||
}
|
||
|
||
return true;
|
||
|
||
} catch (Exception e) {
|
||
throw e;
|
||
}
|
||
}
|
||
|
||
private List<Tramo> validaTramosRuta(Ruta ruta) {
|
||
|
||
List<Tramo> tramosRuta = new ArrayList<Tramo>();
|
||
|
||
for (RutaCombinacion rc : ruta.getRutaCombinacionList()) {
|
||
if (!tramosRuta.contains(rc.getTramo()))
|
||
tramosRuta.add(rc.getTramo());
|
||
}
|
||
|
||
for (RutaSecuencia rs : ruta.getRutaSecuenciaList()) {
|
||
if (!tramosRuta.contains(rs.getTramo()))
|
||
tramosRuta.add(rs.getTramo());
|
||
}
|
||
|
||
return tramosRuta;
|
||
}
|
||
|
||
private Tramo crearNuevoTramo(Tramo tramo, Parada viejaParada, Parada nuevaParada) {
|
||
|
||
Tramo viejoTramo = tramoService.obtenerID(tramo.getTramoId());
|
||
if (viejoTramo.getOrigem().equals(viejaParada) || viejoTramo.getDestino().equals(viejaParada)) {
|
||
|
||
Tramo ptramo = null;
|
||
if (viejoTramo.getOrigem().equals(viejaParada)) {
|
||
ptramo = tramoService.obtenerTramotPorOrigemDestinoVia(nuevaParada, viejoTramo.getDestino(), viejoTramo.getVia());
|
||
}
|
||
|
||
if (viejoTramo.getDestino().equals(viejaParada)) {
|
||
ptramo = tramoService.obtenerTramotPorOrigemDestinoVia(viejoTramo.getOrigem(), nuevaParada, viejoTramo.getVia());
|
||
}
|
||
|
||
if (ptramo == null) {
|
||
|
||
Tramo nuevoTramo = new Tramo();
|
||
nuevoTramo.setDesctramo(viejoTramo.getDesctramo() + " II");
|
||
nuevoTramo.setVia(viejoTramo.getVia());
|
||
nuevoTramo.setKmPagoConductor(viejoTramo.getKmPagoConductor());
|
||
nuevoTramo.setKmReal(viejoTramo.getKmReal());
|
||
|
||
nuevoTramo.setLsTramoTiempo(viejoTramo.getLsTramoTiempo());
|
||
nuevoTramo.setLsOrgaoTramo(viejoTramo.getLsOrgaoTramo());
|
||
|
||
nuevoTramo.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
|
||
nuevoTramo.setFecmodif(Calendar.getInstance().getTime());
|
||
nuevoTramo.setActivo(Boolean.TRUE);
|
||
|
||
if (viejoTramo.getOrigem().equals(viejaParada)) {
|
||
nuevoTramo.setOrigem(nuevaParada);
|
||
nuevoTramo.setDestino(viejoTramo.getDestino());
|
||
}
|
||
if (viejoTramo.getDestino().equals(viejaParada)) {
|
||
nuevoTramo.setDestino(nuevaParada);
|
||
nuevoTramo.setOrigem(viejoTramo.getOrigem());
|
||
}
|
||
|
||
return nuevoTramo;
|
||
} else {
|
||
return ptramo;
|
||
}
|
||
} else {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
private Parada crearNuevaParada(Parada parada, String cve, String descparada) {
|
||
Parada nuevaParada = new Parada();
|
||
nuevaParada.setCveparada(cve);
|
||
nuevaParada.setDescparada(descparada);
|
||
nuevaParada.setCiudad(parada.getCiudad());
|
||
nuevaParada.setRegionMetropolitana(parada.getRegionMetropolitana());
|
||
nuevaParada.setNodo(parada.getNodo());
|
||
nuevaParada.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
|
||
nuevaParada.setFecmodif(Calendar.getInstance().getTime());
|
||
nuevaParada.setActivo(Boolean.TRUE);
|
||
|
||
return nuevaParada;
|
||
}
|
||
|
||
@Transactional(rollbackFor = BusinessException.class)
|
||
public Ruta suscribir(Ruta entidad, List<ParadaSecuencia> lsParadasSequencia) throws BusinessException {
|
||
entidad.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
|
||
entidad.setFecmodif(Calendar.getInstance().getTime());
|
||
entidad.setActivo(Boolean.TRUE);
|
||
|
||
if (entidad.getVentaOffLine() == null) {
|
||
entidad.setVentaOffLine(false);
|
||
}
|
||
|
||
Boolean isClone = entidad.getIsClone() != null ? entidad.getIsClone() : Boolean.FALSE;
|
||
|
||
if (entidad.getRutaId() == null) {
|
||
entidad = rutaDAO.suscribir(entidad);
|
||
} else {
|
||
entidad = rutaDAO.actualizacion(entidad);
|
||
}
|
||
if (lsParadasSequencia != null) {
|
||
if (!isClone) {
|
||
generarSecuencias(entidad, lsParadasSequencia);
|
||
}
|
||
generarCombinacion(entidad);
|
||
}
|
||
|
||
return entidad;
|
||
}
|
||
|
||
private void generarSecuencias(Ruta ruta, List<ParadaSecuencia> lsParadasSequencia) throws BusinessException {
|
||
|
||
if (lsParadasSequencia != null) {
|
||
List<RutaSecuencia> lsRutaSecuencia = new ArrayList<RutaSecuencia>();
|
||
HashMap<Integer, List<RutaCaseta>> rutaSecuenciaBackup = new HashMap<Integer, List<RutaCaseta>>();
|
||
for (RutaSecuencia rutaSecuencia : ruta.getRutaSecuenciaList()) {
|
||
rutaSecuenciaBackup.put(rutaSecuencia.getTramo().getTramoId(), rutaSecuencia.getLsRutaCase() );
|
||
}
|
||
|
||
// Desativo todas as secuencias e gero novamente.
|
||
rutaSecuenciaService.borrarSecuencias(ruta);
|
||
ruta.setRutaSecuenciaList(null);
|
||
|
||
log.info("Gera<72><61>o de Secuencia!");
|
||
log.info("Ruta: " + ruta.getRutaId() + " - " + ruta.getDescruta());
|
||
|
||
lsRutaSecuencia.clear();
|
||
StringBuilder sb = new StringBuilder("Tramo(s) inexistente(s):");
|
||
sb.append("\n");
|
||
boolean msg = false;
|
||
for (int i = 0; i < lsParadasSequencia.size() - 1; i++) {
|
||
Parada ori = lsParadasSequencia.get(i).getParada();
|
||
Via via = lsParadasSequencia.get(i).getVia();
|
||
Integer sec1 = lsParadasSequencia.get(i).getSecuencia().intValue();
|
||
log.info("Secuencia: " + sec1 + " origen " + ori.getDescparada() + " - " + ori.getCveparada() + " Via: " + via.getNombvia());
|
||
|
||
Parada des = lsParadasSequencia.get(i + 1).getParada();
|
||
Integer sec2 = lsParadasSequencia.get(i + 1).getSecuencia().intValue();
|
||
log.info("Secuencia: " + sec2 + " destino " + des.getDescparada() + " - " + des.getCveparada() + " Via: " + via.getNombvia());
|
||
|
||
ClaseServicio claseServicio = ruta.getClaseServicio();
|
||
|
||
Tramo tramo = tramoService.obtenerTramoUnicoRuta(ori, des, via, claseServicio);
|
||
|
||
if (tramo != null) {
|
||
|
||
RutaSecuencia rutaSecuencia = new RutaSecuencia();
|
||
rutaSecuencia.setRuta(ruta);
|
||
rutaSecuencia.setTramo(tramo);
|
||
rutaSecuencia.setNumsecuencia(sec1.shortValue());
|
||
rutaSecuencia.setActivo(Boolean.TRUE);
|
||
rutaSecuencia.setFecmodif(Calendar.getInstance().getTime());
|
||
rutaSecuencia.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
|
||
rutaSecuencia.setKmOriginal(tramo.getKmReal());
|
||
rutaSecuencia = rutaSecuenciaService.suscribir(rutaSecuencia);
|
||
|
||
List<RutaCaseta> lsRutaCaseta = rutaSecuenciaBackup.get(tramo.getTramoId());
|
||
if( lsRutaCaseta != null && !lsRutaCaseta.isEmpty() ) {
|
||
rutaSecuencia.setLsRutaCase(lsRutaCaseta);
|
||
}
|
||
|
||
|
||
lsRutaSecuencia.add(rutaSecuencia);
|
||
|
||
} else {
|
||
throw new BusinessException("rutaServiceImpl.msg.validacionTRamo", new Object[] { ori.getCveparada(), des.getCveparada(), via.getNombvia(), claseServicio.getDescclase() });
|
||
}
|
||
}
|
||
ruta.setRutaSecuenciaList(lsRutaSecuencia);
|
||
}
|
||
}
|
||
|
||
@Transactional(rollbackFor = BusinessException.class)
|
||
public Ruta actualizacion(Ruta ruta, List<ParadaSecuencia> lsParadasSequencia) throws BusinessException {
|
||
if (lsParadasSequencia != null) {
|
||
generarSecuencias(ruta, lsParadasSequencia);
|
||
generarCombinacion(ruta);
|
||
}
|
||
|
||
ruta.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
|
||
ruta.setFecmodif(Calendar.getInstance().getTime());
|
||
ruta.setActivo(Boolean.TRUE);
|
||
|
||
return rutaDAO.actualizacion(ruta);
|
||
}
|
||
|
||
@Transactional(rollbackFor = RegistroConDependenciaException.class)
|
||
public void borrar(Ruta entidad) throws RegistroConDependenciaException {
|
||
if ((corridaDAO.count(entidad) > 0l) || (esquemaCorridaDAO.count("ruta", entidad) > 0l)) {
|
||
throw new RegistroConDependenciaException();
|
||
}
|
||
|
||
entidad = this.obtenerID(entidad.getRutaId());
|
||
for (RutaCombinacion rutaCombinacion : entidad.getRutaCombinacionList()) {
|
||
rutaCombinacion.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
|
||
rutaCombinacion.setFecmodif(Calendar.getInstance().getTime());
|
||
rutaCombinacion.setActivo(Boolean.FALSE);
|
||
}
|
||
|
||
for (RutaSecuencia rutaSecuencia : entidad.getRutaSecuenciaList()) {
|
||
rutaSecuencia.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
|
||
rutaSecuencia.setFecmodif(Calendar.getInstance().getTime());
|
||
rutaSecuencia.setActivo(Boolean.FALSE);
|
||
}
|
||
|
||
for (RutaEmpresa rutaEmpresa : entidad.getLsRutaEmpresa()) {
|
||
rutaEmpresa.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
|
||
rutaEmpresa.setFecmodif(Calendar.getInstance().getTime());
|
||
rutaEmpresa.setActivo(Boolean.FALSE);
|
||
}
|
||
|
||
entidad.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
|
||
entidad.setFecmodif(Calendar.getInstance().getTime());
|
||
entidad.setActivo(Boolean.FALSE);
|
||
|
||
rutaDAO.actualizacion(entidad);
|
||
}
|
||
|
||
@Transactional(rollbackFor = BusinessException.class)
|
||
public void generarCombinacion(Ruta ruta) throws BusinessException {
|
||
|
||
|
||
List<RutaCombinacion> listRutaCombinacion = new ArrayList<RutaCombinacion>();
|
||
List<RutaSecuencia> lsRutaSecuencia = new ArrayList<RutaSecuencia>();
|
||
if (ruta.getRutaId() != null) {
|
||
listRutaCombinacion = rutaCombinacionService.obtenerPorRuta(ruta);
|
||
}
|
||
|
||
rutaCombinacionService.borrarCombinaciones(ruta);
|
||
|
||
ruta.setRutaCombinacionList(listRutaCombinacion);
|
||
|
||
lsRutaSecuencia = rutaSecuenciaService.buscarSecuenciaOrdenado(ruta);
|
||
|
||
StringBuilder sb = new StringBuilder();
|
||
Boolean gerou = true;
|
||
|
||
|
||
for (int i = 0; i < lsRutaSecuencia.size(); i++) {
|
||
Tramo tramoSecuencia1 = lsRutaSecuencia.get(i).getTramo();
|
||
Parada origem = tramoSecuencia1.getOrigem();
|
||
|
||
for (int x = 0; x < lsRutaSecuencia.size(); x++) {
|
||
Tramo tramoSecuencia2 = lsRutaSecuencia.get(x).getTramo();
|
||
Parada destinoOrigem = tramoSecuencia2.getDestino();
|
||
|
||
// Numero secuencia anterior > Numero secuencia atual não deve fazer.
|
||
// Essa condi<64><69>o não permiti gerar uma volta.
|
||
if (lsRutaSecuencia.get(i).getNumsecuencia().intValue() > lsRutaSecuencia.get(x).getNumsecuencia().intValue()) {
|
||
continue;
|
||
}
|
||
|
||
// IDA - A x B - A x C
|
||
if (origem == destinoOrigem) {
|
||
continue;
|
||
}
|
||
|
||
List<Tramo> listTramo = tramoService.obtenerPorOrigemDestinoFetchLazy(origem, destinoOrigem);
|
||
|
||
if (listTramo.isEmpty()) {
|
||
throw new BusinessException("rutaServiceImpl.msg.validacionTRamoCombinacion", new Object[] { origem.getDescparada(), origem.getCveparada(), destinoOrigem.getDescparada(), destinoOrigem.getCveparada() });
|
||
}
|
||
|
||
Tramo trBuscaOrigemDestino = new Tramo();
|
||
for (Tramo tm : listTramo) {
|
||
if (tm.getVia().equals(tramoSecuencia2.getVia())) {
|
||
trBuscaOrigemDestino = tm;
|
||
break;
|
||
} else if (tm.getVia().equals(tramoSecuencia1.getVia())) {
|
||
trBuscaOrigemDestino = tm;
|
||
break;
|
||
} else {
|
||
trBuscaOrigemDestino = tm;
|
||
}
|
||
}
|
||
|
||
log.debug("Tramo:" + trBuscaOrigemDestino.getDesctramo());
|
||
|
||
RutaCombinacion rc = new RutaCombinacion();
|
||
rc.setActivo(Boolean.TRUE);
|
||
rc.setFecmodif(Calendar.getInstance().getTime());
|
||
rc.setIndventa(indVenta(ruta, trBuscaOrigemDestino));
|
||
rc.setRuta(ruta);
|
||
rc.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
|
||
rc.setTramo(trBuscaOrigemDestino);
|
||
|
||
// Verifica se j<> existe o registro INATIVO para Reativa-lo e manter a configura<72><61>o se vende.
|
||
// if (!rutaCombinacionService.busquedaRutaTramo(ruta, trBuscaOrigemDestino, Boolean.FALSE)) {
|
||
rc = rutaCombinacionService.suscribir(rc);
|
||
// } else {
|
||
// rutaCombinacionService.activar(ruta, trBuscaOrigemDestino);
|
||
// }
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
private boolean indVenta(Ruta ruta, Tramo trBuscaOrigemDestino) {
|
||
for (RutaCombinacion rc : ruta.getRutaCombinacionList()) {
|
||
if (rc.getTramo().equals(trBuscaOrigemDestino)) {
|
||
return rc.getIndventa();
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
public Parada getDestino(Ruta ruta) {
|
||
return rutaDAO.buscarDestino(ruta);
|
||
}
|
||
|
||
public Parada getOrigem(Ruta ruta) {
|
||
return rutaDAO.buscarOrigen(ruta);
|
||
}
|
||
|
||
public List<Ruta> buscarPorClaseServicioEmpresa(ClaseServicio claseServicio, Empresa empresa) {
|
||
return rutaDAO.buscarPorClaseServicioEmpresa(claseServicio, empresa);
|
||
}
|
||
|
||
public List<Ruta> buscarPorClaseServicio(ClaseServicio claseServicio) {
|
||
return rutaDAO.buscarPorClaseServicio(claseServicio);
|
||
}
|
||
|
||
public List<Ruta> buscar(String nomeRuta, ClaseServicio claseServicio, Boolean nomeObrigatorio) {
|
||
return rutaDAO.buscar(nomeRuta, claseServicio, nomeObrigatorio);
|
||
}
|
||
|
||
public List<Ruta> obtenerPorEmpresa(Empresa empresa) {
|
||
return rutaDAO.obtenerPorEmpresa(empresa);
|
||
}
|
||
|
||
public List<Ruta> buscarTodosExceto(Integer... idRuta) {
|
||
return rutaDAO.buscarTodosExceto(idRuta);
|
||
}
|
||
|
||
public List<Ruta> buscarTodosEstos(Integer[] idRutas) {
|
||
return rutaDAO.buscarTodosEstos(idRutas);
|
||
}
|
||
|
||
public List<Ruta> buscarNumRuta(String numRuta) {
|
||
return rutaDAO.buscarNumRuta(numRuta);
|
||
}
|
||
|
||
@Override
|
||
public boolean paradaExisteEnLaRuta(Parada parada, Ruta ruta) {
|
||
ruta = obtenerID(ruta.getRutaId());
|
||
boolean existe = false;
|
||
for (int i = 0; (i < ruta.getRutaSecuenciaList().size()) && !existe; i++) {
|
||
RutaSecuencia rutaSecuencia = ruta.getRutaSecuenciaList().get(i);
|
||
Tramo tramo = rutaSecuencia.getTramo();
|
||
if (tramo != null) {
|
||
if (tramo.getOrigem().equals(parada) || tramo.getDestino().equals(parada)) {
|
||
existe = true;
|
||
}
|
||
}
|
||
}
|
||
return existe;
|
||
}
|
||
|
||
public List<Ruta> buscaRuta(String palavraPesquisaRuta) {
|
||
return rutaDAO.buscaRuta(palavraPesquisaRuta);
|
||
}
|
||
|
||
@Override
|
||
public List<Ruta> buscaRuta(String palavraPesquisaRuta, OrgaoConcedente orgao) {
|
||
return rutaDAO.buscaRuta(palavraPesquisaRuta, orgao);
|
||
}
|
||
|
||
public List<Ruta> buscaRutasFromOrgao(OrgaoConcedente orgao) {
|
||
return rutaDAO.buscaRutasFromOrgao(orgao);
|
||
}
|
||
|
||
@Override
|
||
public List<Ruta> buscarRutasPorEmpresas(List<Empresa> lsEmp) {
|
||
return rutaDAO.buscarPorRutaPorEmpresas(lsEmp);
|
||
}
|
||
|
||
private class RutaComparator implements Comparator<Ruta> {
|
||
@Override
|
||
public int compare(Ruta r1, Ruta r2) {
|
||
String name1 = r1.getDescruta();
|
||
String name2 = r2.getDescruta();
|
||
return name1.compareTo(name2);
|
||
}
|
||
}
|
||
|
||
@Override
|
||
public Integer getNumSecuenciaOrigen(Integer rutaId, Integer origenId) {
|
||
return obtenerID(rutaId).numSecuenciaOrigen(origenId);
|
||
}
|
||
|
||
@Override
|
||
public Integer getNumSecuenciaDestino(Integer rutaId, Integer destinoId) {
|
||
return obtenerID(rutaId).numSecuenciaDestino(destinoId);
|
||
}
|
||
|
||
@Override
|
||
public List<ParadaSecuenciaCombinacaoLinha> verificarSeqRutaNaoGerada(Ruta ruta, List<ParadaSecuencia> lsParadasSecuencia) {
|
||
|
||
List<ParadaSecuenciaCombinacaoLinha> sequencias = null;
|
||
|
||
if (lsParadasSecuencia != null) {
|
||
ClaseServicio claseServicio = ruta.getClaseServicio();
|
||
sequencias = new ArrayList<ParadaSecuenciaCombinacaoLinha>();
|
||
|
||
for (ParadaSecuencia sequenciaInformada : lsParadasSecuencia) {
|
||
|
||
Parada origem = sequenciaInformada.getParada();
|
||
Via via = sequenciaInformada.getVia();
|
||
|
||
ParadaSecuenciaCombinacaoLinha paradaSecuenciaCombinacaoLinha = new ParadaSecuenciaCombinacaoLinha();
|
||
paradaSecuenciaCombinacaoLinha.setOrigem(sequenciaInformada);
|
||
paradaSecuenciaCombinacaoLinha.setVia(via);
|
||
paradaSecuenciaCombinacaoLinha.setDestinos(new ArrayList<ParadaSecuencia>());
|
||
paradaSecuenciaCombinacaoLinha.setKmReal(sequenciaInformada.getKmReal());
|
||
paradaSecuenciaCombinacaoLinha.setKmEntradaSaida(sequenciaInformada.getKmEntradaSaida());
|
||
paradaSecuenciaCombinacaoLinha.setTempoReal(sequenciaInformada.getTempoReal());
|
||
|
||
for (ParadaSecuencia sequenciaExistente : lsParadasSecuencia) {
|
||
if (sequenciaInformada.getParada().getParadaId() == sequenciaExistente.getParada().getParadaId()) {
|
||
continue;
|
||
}
|
||
|
||
Parada destino = sequenciaExistente.getParada();
|
||
Tramo tramo = tramoService.obtenerTramoUnicoRuta(origem, destino, via, claseServicio);
|
||
|
||
if (tramo == null) {
|
||
paradaSecuenciaCombinacaoLinha.getDestinos().add(sequenciaExistente);
|
||
}
|
||
}
|
||
|
||
if (!paradaSecuenciaCombinacaoLinha.getDestinos().isEmpty()) {
|
||
sequencias.add(paradaSecuenciaCombinacaoLinha);
|
||
}
|
||
}
|
||
}
|
||
|
||
return sequencias;
|
||
}
|
||
|
||
@Override
|
||
public List<Ruta> buscarRutasPorEmpresaOrgaoConcedente(Empresa empresa, OrgaoConcedente orgao) {
|
||
return rutaDAO.buscarRutasPorEmpresaOrgaoConcedente(empresa, orgao);
|
||
}
|
||
|
||
class CambioRutaTramo {
|
||
private Tramo viejoTramo;
|
||
private Tramo nuevoTramo;
|
||
private Parada viejaParada;
|
||
private Parada nuevaParada;
|
||
|
||
public CambioRutaTramo(Tramo viejoTramo, Tramo nuevoTramo, Parada viejaParada, Parada nuevaParada) {
|
||
super();
|
||
this.viejoTramo = viejoTramo;
|
||
this.nuevoTramo = nuevoTramo;
|
||
this.viejaParada = viejaParada;
|
||
this.nuevaParada = nuevaParada;
|
||
}
|
||
|
||
public Tramo getViejoTramo() {
|
||
return viejoTramo;
|
||
}
|
||
|
||
public void setViejoTramo(Tramo viejoTramo) {
|
||
this.viejoTramo = viejoTramo;
|
||
}
|
||
|
||
public Tramo getNuevoTramo() {
|
||
return nuevoTramo;
|
||
}
|
||
|
||
public void setNuevoTramo(Tramo nuevoTramo) {
|
||
this.nuevoTramo = nuevoTramo;
|
||
}
|
||
|
||
public Parada getViejaParada() {
|
||
return viejaParada;
|
||
}
|
||
|
||
public void setViejaParada(Parada viejaParada) {
|
||
this.viejaParada = viejaParada;
|
||
}
|
||
|
||
public Parada getNuevaParada() {
|
||
return nuevaParada;
|
||
}
|
||
|
||
public void setNuevaParada(Parada nuevaParada) {
|
||
this.nuevaParada = nuevaParada;
|
||
}
|
||
}
|
||
}
|