1096 lines
37 KiB
Plaintext
Executable File
1096 lines
37 KiB
Plaintext
Executable File
package com.fp.frontend.controller.armas.solicitud;
|
|
|
|
import java.io.InputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.Calendar;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import javax.annotation.PostConstruct;
|
|
import javax.faces.bean.ManagedBean;
|
|
import javax.faces.bean.ManagedProperty;
|
|
import javax.faces.bean.ViewScoped;
|
|
import javax.faces.context.FacesContext;
|
|
import javax.faces.event.AjaxBehaviorEvent;
|
|
|
|
import org.primefaces.component.selectbooleancheckbox.SelectBooleanCheckbox;
|
|
import org.primefaces.context.RequestContext;
|
|
import org.primefaces.event.SelectEvent;
|
|
|
|
import com.fp.dto.AbstractDataTransport;
|
|
import com.fp.dto.Request;
|
|
import com.fp.dto.Response;
|
|
import com.fp.dto.save.DtoSave;
|
|
import com.fp.frontend.controller.AbstractController;
|
|
import com.fp.frontend.controller.ReportController;
|
|
import com.fp.frontend.controller.alfresco.AlfrescoController;
|
|
import com.fp.frontend.controller.armas.funcionalidad.RegistroArmController;
|
|
import com.fp.frontend.controller.armas.lov.SancionarLovController;
|
|
import com.fp.frontend.controller.armas.parametros.CentroControlArmasController;
|
|
import com.fp.frontend.controller.armas.parametros.DatosParaSancionesController;
|
|
import com.fp.frontend.controller.armas.parametros.TiposArmasExplosivosController;
|
|
import com.fp.frontend.controller.pcustomer.PersonDetailController;
|
|
import com.fp.frontend.controller.pgeneral.gene.CantonController;
|
|
import com.fp.frontend.controller.pgeneral.gene.CatalogDetailController;
|
|
import com.fp.frontend.controller.pgeneral.gene.CityController;
|
|
import com.fp.frontend.controller.pgeneral.gene.ParroquiaController;
|
|
import com.fp.frontend.controller.pgeneral.gene.ProvinceController;
|
|
import com.fp.frontend.helper.MessageHelper;
|
|
import com.fp.frontend.utility.MsgControlArmas;
|
|
import com.fp.persistence.parmas.fun.TarmRegistroArmas;
|
|
import com.fp.persistence.parmas.param.TarmCentroControl;
|
|
import com.fp.persistence.parmas.param.TarmTipoArmaExplosivo;
|
|
import com.fp.persistence.parmas.param.TarmTipoSancion;
|
|
import com.fp.persistence.parmas.param.TarmTramite;
|
|
import com.fp.persistence.parmas.soli.TarmArmas;
|
|
import com.fp.persistence.parmas.soli.TarmDecomiso;
|
|
import com.fp.persistence.parmas.soli.TarmDecomisoArma;
|
|
import com.fp.persistence.parmas.soli.TarmDocumentoHabilitante;
|
|
import com.fp.persistence.pcustomer.gene.TcustPersonDetail;
|
|
import com.fp.persistence.pgeneral.gene.TgeneCatalogDetail;
|
|
import com.fp.persistence.pgeneral.safe.TsafeUserDetail;
|
|
|
|
/**
|
|
* @author Andres Cevallos
|
|
* Sanciona un arma
|
|
*/
|
|
|
|
@SuppressWarnings("serial")
|
|
@ManagedBean
|
|
@ViewScoped
|
|
public class SancionarController extends AbstractController<AbstractDataTransport> {
|
|
|
|
@ManagedProperty(value="#{alfrescoController}")
|
|
private AlfrescoController alfrescoController;
|
|
/**
|
|
* Boleano que activa el boton de generarreporte
|
|
*/
|
|
private Boolean reporte;
|
|
/**
|
|
* Codigo de Transaccion
|
|
*/
|
|
private Long cTransaccion;
|
|
/**
|
|
* Activa el boton enviar
|
|
*/
|
|
private String btnEnviar;
|
|
/**
|
|
* Controlador inyectado decomiso arma controller
|
|
*/
|
|
@ManagedProperty(value = "#{decomisoArmaController}")
|
|
private DecomisoArmaController decomisoArmaController;
|
|
|
|
@ManagedProperty(value = "#{sancionDecomisoController}")
|
|
private SancionDecomisoController sancionDecomisoController;
|
|
/**
|
|
* Controlador inyectado documento habilitante
|
|
*/
|
|
@ManagedProperty(value = "#{documentoHabilitanteController}")
|
|
private DocumentoHabilitanteController documentoHabilitanteController;
|
|
/**
|
|
* controlador inyectado sancion recomendacion
|
|
*/
|
|
@ManagedProperty(value = "#{sancionRecomendacionController}")
|
|
private SancionRecomendacionController sancionRecomendacionController;
|
|
|
|
@ManagedProperty(value = "#{armasController}")
|
|
private ArmasController armasController;
|
|
|
|
@ManagedProperty(value = "#{reportController}")
|
|
private ReportController reportController;
|
|
/**
|
|
* Controlador inyectado sanciondecomiso controller
|
|
*/
|
|
private long cdocumentohabilitanteaut;
|
|
|
|
private TarmArmas armaactual;
|
|
/**
|
|
* Instancia de la entidad Tarmdecomiso
|
|
*/
|
|
private TarmDecomiso decomiso;
|
|
/**
|
|
* Instancia de la entidad TarmDecomisoArma
|
|
*/
|
|
private Boolean sanc=false;
|
|
|
|
private TcustPersonDetail personaUsuario;
|
|
/**
|
|
* Instancia de la entidad TarmDecomisoArma
|
|
*/
|
|
private TarmDecomisoArma decomisoArmaObj;
|
|
/**
|
|
* Instancia de la entidad TarmTipoArmaExplosivo
|
|
*/
|
|
private TarmTipoArmaExplosivo tipoarmaexplosivo;
|
|
|
|
// private String tabid1 = "tabDetalleDeArmas";
|
|
/**
|
|
* Bandera de tipo booleano para indicar si se ha grabado el reporte generado
|
|
* */
|
|
private Boolean isEnableGrabar;
|
|
/**
|
|
* Bandera de tipo booleano para indicar que se debe deshabilitar el boton ENVIAR
|
|
* */
|
|
private Boolean isEnableEnviar;
|
|
|
|
private List<TarmDocumentoHabilitante> autorizacion;
|
|
|
|
private Boolean aut;
|
|
/**
|
|
* Atributo para listar las armas decomisadas
|
|
*/
|
|
private List<TarmArmas> larmas;
|
|
/**
|
|
* Instancia de una lista de tipo de sancion
|
|
*/
|
|
private List<TarmTipoSancion> tsancion1;
|
|
/**
|
|
* Provincia
|
|
*/
|
|
private String provincia;
|
|
/**
|
|
* Instan de un tipo de sancion
|
|
*/
|
|
private TarmTipoSancion sancion;
|
|
/**
|
|
* Canton
|
|
*/
|
|
private TarmCentroControl centroControl;
|
|
|
|
private String canton;
|
|
/**
|
|
* Ciudad
|
|
*/
|
|
private String ciudad;
|
|
/**
|
|
* Parroquia
|
|
*/
|
|
private String parroquia;
|
|
/**
|
|
* Clase de arma
|
|
*/
|
|
private String clasearma;
|
|
/**
|
|
* Detalle de grado
|
|
*/
|
|
private TgeneCatalogDetail gradoCatalogDatail;
|
|
/**
|
|
* Detalle de unidad
|
|
*/
|
|
private TgeneCatalogDetail unidadCatalogDatail;
|
|
|
|
private TsafeUserDetail userDetail;
|
|
/**
|
|
* Atributo asociado a al documento de la utorizacion que se seleccione
|
|
*/
|
|
private TarmTramite tramite;
|
|
/**
|
|
*Tipo de sancion, a la autorización o al permiso
|
|
*/
|
|
private String tipsancion="";
|
|
|
|
private TarmRegistroArmas regarma;
|
|
|
|
private List<TarmDocumentoHabilitante> documentos;
|
|
|
|
//private TarmDocumentoHabilitante doc1;
|
|
|
|
private String institucionCentroControl="";
|
|
|
|
/**
|
|
* Bandera usada para identificar si existe o no un documento habilitante para el arma a sancionarse
|
|
*/
|
|
private Boolean isExistDocHabilitante = Boolean.FALSE;
|
|
|
|
private TcustPersonDetail responsableCentroControl= null;
|
|
private Boolean grillaAut;
|
|
private String sanciontipo;
|
|
|
|
@Override
|
|
public void query() {
|
|
|
|
}
|
|
|
|
@Override
|
|
protected void querydatabase() {
|
|
}
|
|
|
|
public SancionarController() throws Exception {
|
|
super(AbstractDataTransport.class);
|
|
}
|
|
|
|
@PostConstruct
|
|
private void postconstruct() {
|
|
startQuery();
|
|
this.init();
|
|
}
|
|
|
|
public void startQuery() {
|
|
try {
|
|
this.pasteBpmScreenParameters();
|
|
//cDecomiso=(long)376;
|
|
cTransaccion=Long.parseLong(super.getMfilters().get("numerotransaccion"));
|
|
super.getMfilters().clear();
|
|
} catch (Exception e) {
|
|
MessageHelper.setMessageError(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Incializa el controlador, cuando se esta utilizando una pagina que utliza el controlador.
|
|
*/
|
|
private void init() {
|
|
try {
|
|
aut=false;
|
|
userDetail=(TsafeUserDetail)FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("TSAFEUSERDETAIL");
|
|
isEnableGrabar=Boolean.TRUE;
|
|
isEnableEnviar=Boolean.FALSE;
|
|
grillaAut=true;
|
|
larmas=new ArrayList<TarmArmas>();
|
|
personaUsuario=PersonDetailController.find(userDetail.getPk().getPersoncode().toString());
|
|
// //lista de las armas decomisadas
|
|
// List<TarmDecomisoArma> lRecepcionArmasDetalle = DecomisoArmaController.findByCodigoDecomiso(cDecomiso.toString());
|
|
List<TarmDecomisoArma> lRecepcionArmasDetalle = DecomisoArmaController.findArmasPorSancionar(cTransaccion);
|
|
for(TarmDecomisoArma decomisoArmaDetalle : lRecepcionArmasDetalle ){
|
|
TarmArmas arma = ArmasController.findPorCodigo(decomisoArmaDetalle.getCarma());
|
|
TarmRegistroArmas regarmaa= RegistroArmController.findByCodigo(arma.getCregistro().toString());
|
|
arma.getModifiedData().put("tipoarmaexplosivos", TiposArmasExplosivosController.findarma(arma.getCtipoarmaexplosivo()));
|
|
TarmTipoArmaExplosivo tipoarmaexplosivo = (TarmTipoArmaExplosivo) arma.getModifiedData().get("tipoarmaexplosivos");
|
|
String clasearma = CatalogDetailController.findxCodigoCodcatalogo(tipoarmaexplosivo.getClase(), tipoarmaexplosivo.getClasecodigo()).getDescription();
|
|
|
|
arma.getModifiedData().put("clase", clasearma);
|
|
// arma.getModifiedData().put("tsancion", DatosParaSancionesController.find(tipoarmaexplosivo.getClase()));
|
|
arma.getModifiedData().put("persona", regarmaa.getPersoncode().toString());
|
|
|
|
// if(SancionDecomisoController.findsancionarmadec(cDecomiso.toString(),arma.getPk().toString()) != null){
|
|
if(SancionDecomisoController.findsancionarmadec(decomisoArmaDetalle.getCdecomiso().toString(),arma.getPk().toString()) != null){
|
|
arma.getModifiedData().put("sancionada", "true");
|
|
}
|
|
//seteo del deomiso del arma TarmDecomiso
|
|
arma.getModifiedData().put("decomisoArma", decomisoArmaDetalle);
|
|
larmas.add(arma);
|
|
}
|
|
// sancion=new TarmTipoSancion();
|
|
btnEnviar=null;
|
|
checkenviar();
|
|
// }
|
|
// else{
|
|
// MessageHelper.setMessageError(MsgControlArmas.getProperty("msg_error_numReciboNoRegistrado"));
|
|
// }
|
|
} catch (Exception e) {
|
|
MessageHelper.setMessageError(e);
|
|
}
|
|
}
|
|
|
|
public void checkenviar(){
|
|
for(TarmArmas arm : larmas){
|
|
if(arm.getModifiedData().get("sancionada")==null || arm.getModifiedData().get("sancionada").toString()!="true")
|
|
{return;}
|
|
}
|
|
isEnableEnviar=Boolean.TRUE;
|
|
btnEnviar="ok";
|
|
}
|
|
|
|
/**
|
|
* Metodo para seleccionar el documento en el combo de la autorizacion
|
|
* @throws Exception
|
|
*/
|
|
@SuppressWarnings("static-access")
|
|
public void changetype() throws Exception{
|
|
if( cdocumentohabilitanteaut!=0){
|
|
documentoHabilitanteController.setRecord(documentoHabilitanteController.find(cdocumentohabilitanteaut+""));
|
|
tramite=TarmTramiteController.find(documentoHabilitanteController.getRecord().getCtramite().toString());
|
|
isExistDocHabilitante = Boolean.TRUE;
|
|
tipsancion="AUTORIZACION";
|
|
sancion=new TarmTipoSancion();
|
|
}
|
|
else{
|
|
tramite= new TarmTramite();
|
|
documentoHabilitanteController.setRecord(null);
|
|
//cuando no tiene asociado a un documento
|
|
sancion=DatosParaSancionesController.findxPk("0");
|
|
sancion.getModifiedData().put("nfalta", null);
|
|
sancion.getModifiedData().put("ntipoFalta", null);
|
|
sancionDecomisoController.create();
|
|
|
|
btnEnviar="true";
|
|
tipsancion="";
|
|
isExistDocHabilitante = Boolean.FALSE;
|
|
}
|
|
}
|
|
|
|
public void setDocumentoHabilitanteController(
|
|
DocumentoHabilitanteController documentoHabilitanteController) {
|
|
this.documentoHabilitanteController = documentoHabilitanteController;
|
|
}
|
|
|
|
/**
|
|
* Sancion Aplicada al permiso
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public void sancionarPermiso(TarmArmas armar){
|
|
//inicializamos las variables
|
|
TarmDecomisoArma decomisoArmaSel = (TarmDecomisoArma) armar.getModifiedData().get("decomisoArma");
|
|
decomiso = DecomisoController.findByCodigo(decomisoArmaSel.getCdecomiso().toString());
|
|
|
|
provincia = ProvinceController.getDescProvByCodigo(decomiso.getCountrycode(), decomiso.getProvincecode());
|
|
canton = CantonController.getDescCantonByCodigo(decomiso.getCountrycode(), decomiso.getProvincecode(), decomiso.getCantoncode());
|
|
ciudad = CityController.getDescCiudadByCodigo(decomiso.getCountrycode(), decomiso.getProvincecode(), decomiso.getCantoncode(), decomiso.getCitycode());
|
|
parroquia = ParroquiaController.getDescParroquiaByCodigo(decomiso.getCountrycode(), decomiso.getProvincecode(), decomiso.getCantoncode(), decomiso.getParroquiacode());
|
|
gradoCatalogDatail = CatalogDetailController.findxCodigoCodcatalogo(decomiso.getGradofuncionario(), decomiso.getGradofuncionariocode());
|
|
TarmCentroControl centroControl = CentroControlArmasController.findPorCodigo(decomiso.getCcentrocontrol());
|
|
unidadCatalogDatail = CatalogDetailController.findxCodigoCodcatalogo(centroControl.getNombreinstitucion(), centroControl.getNombreinstitucioncodigo());
|
|
|
|
tramite=new TarmTramite();
|
|
documentoHabilitanteController.setRecord(null);
|
|
sancion=null;
|
|
regarma=null;
|
|
cdocumentohabilitanteaut=0;
|
|
sancionRecomendacionController.clearAll();
|
|
autorizacion= new ArrayList<TarmDocumentoHabilitante>();
|
|
|
|
//arma actual
|
|
armaactual=armar;
|
|
reporte=Boolean.FALSE;
|
|
//registro del arma obtiene el codigo del propietario del arma
|
|
regarma= RegistroArmController.findByCodigo(armar.getCregistro().toString());
|
|
tipoarmaexplosivo = (TarmTipoArmaExplosivo) armar.getModifiedData().get("tipoarmaexplosivos");
|
|
//clase del arma
|
|
clasearma = CatalogDetailController.findxCodigoCodcatalogo(tipoarmaexplosivo.getClase(), tipoarmaexplosivo.getClasecodigo()).getDescription();
|
|
//tsancion=(List<TarmTipoSancion>) armar.getModifiedData().get("tsancion");
|
|
//documento habilitante por codigo del arma y codigo de la persona
|
|
System.out.println("codigo de la persona: "+armaactual.getModifiedData().get("persona")+" - codigo arma: "+ armaactual.getCodigoarma());
|
|
TarmDocumentoHabilitante permiso=null;
|
|
if(armaactual.getModifiedData().get("persona")!=null && armaactual.getCodigoarma()!=null){
|
|
permiso = DocumentoHabilitanteController.findxarma(armaactual.getCodigoarma(),armaactual.getModifiedData().get("persona").toString());
|
|
}
|
|
//lista de documentos habilitantes por codigo de la persona (lista las autorizaciones para el combo del dialog) 1 TIPOAUTORIZACION 0 AUTORIZACION
|
|
if(armaactual.getModifiedData().get("persona")!=null && permiso==null){
|
|
autorizacion=DocumentoHabilitanteController.findPorPersoncodeaut(armaactual.getModifiedData().get("persona").toString());
|
|
}
|
|
try {
|
|
//se crea la sancion
|
|
sancionDecomisoController.create();
|
|
sancionDecomisoController.getRecord().setFechainicio(new java.sql.Date(new Date().getTime()));
|
|
//no tiene documents
|
|
if(permiso==null && autorizacion.isEmpty()){
|
|
MessageHelper.setMessageInfo(MsgControlArmas.getProperty("msg_nopermiso"));
|
|
//no tiene documentos la sancion va por default
|
|
sancion=DatosParaSancionesController.findxPk("0");
|
|
sancion.getModifiedData().put("nfalta", null);
|
|
sancion.getModifiedData().put("ntipoFalta", null);
|
|
|
|
btnEnviar="true";
|
|
aut=Boolean.FALSE;
|
|
tipsancion="AUTORIZACION";
|
|
//ltramite="1";
|
|
isExistDocHabilitante = Boolean.FALSE;
|
|
}
|
|
else if(permiso!=null) {
|
|
aut=Boolean.FALSE;
|
|
sancion=new TarmTipoSancion();
|
|
// permiso.setEstado("SAN");
|
|
documentoHabilitanteController.setRecord(permiso);
|
|
//consulta el tramite
|
|
tramite=TarmTramiteController.find(documentoHabilitanteController.getRecord().getCtramite().toString());
|
|
sancionDecomisoController.getRecord().setCdocumento(documentoHabilitanteController.getRecord().getPk());
|
|
tipsancion="PERMISO";
|
|
//ltramite="6";
|
|
isExistDocHabilitante=Boolean.TRUE;
|
|
//limpiamos la list
|
|
autorizacion=new ArrayList<TarmDocumentoHabilitante>();
|
|
}else{
|
|
//no tiene documentos la sancion va por default
|
|
sancion=DatosParaSancionesController.findxPk("0");
|
|
sancion.getModifiedData().put("nfalta", null);
|
|
sancion.getModifiedData().put("ntipoFalta", null);
|
|
//documentoHabilitanteController.setRecord(new TarmDocumentoHabilitante());
|
|
|
|
isExistDocHabilitante = Boolean.FALSE;
|
|
//ltramite="1";
|
|
aut=Boolean.TRUE;
|
|
// isExistDocHabilitante=Boolean.TRUE;
|
|
}
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Carga los datos de la sancion dentro del lrecord
|
|
*/
|
|
public void actualizarSancion(){
|
|
if(sancion==null){
|
|
MessageHelper.setMessageError(MsgControlArmas.getProperty("msg_ingresesancion"));
|
|
return;
|
|
}
|
|
try {
|
|
TgeneCatalogDetail tiempo= CatalogDetailController.findxCodigoCodcatalogo(sancion.getTiempo(), sancion.getTiempocodigo());
|
|
Calendar calendario = Calendar.getInstance();
|
|
if(sancionDecomisoController.getRecord()==null){
|
|
MessageHelper.setMessageError(MsgControlArmas.getProperty("msg_ingresesancion"));
|
|
return;
|
|
}
|
|
try{
|
|
calendario.add(Calendar.DAY_OF_YEAR,Integer.parseInt(tiempo.getDescription()));
|
|
}
|
|
catch(Exception e){
|
|
e.printStackTrace();
|
|
MessageHelper.setMessageError("EL CATALOGO SE ENCUENTRA MAL PARAMETRIZADO");
|
|
return;
|
|
}
|
|
Date fechalaboral=calendario.getTime();
|
|
sancionDecomisoController.getRecord().setCtiposancion(sancion.getPk());
|
|
sancionDecomisoController.getRecord().getPk().setCdecomiso(decomiso.getPk());
|
|
// PENDIENTE CFPH LINEA SUPERIOS COMENTADA
|
|
sancionDecomisoController.getRecord().setPersoncode(regarma.getPersoncode());
|
|
sancionDecomisoController.getRecord().setFechafinal(new java.sql.Date(fechalaboral.getTime()));
|
|
sancionDecomisoController.getRecord().setCarma(armaactual.getPk());
|
|
if(documentoHabilitanteController!=null && documentoHabilitanteController.getRecord()!=null && documentoHabilitanteController.getRecord().getPk()!=null){
|
|
sancionDecomisoController.getRecord().setCdocumento(documentoHabilitanteController.getRecord().getPk());
|
|
//documento
|
|
if(documentoHabilitanteController!=null){
|
|
if(sancion.getSancion()=="1" || sancion.getSancion()=="1")
|
|
documentoHabilitanteController.getRecord().setEstado("CAN");
|
|
else{
|
|
documentoHabilitanteController.getRecord().setEstado("SUS");
|
|
}
|
|
}
|
|
documentoHabilitanteController.update();
|
|
}
|
|
//seteamos el ARMA DECOMISADA
|
|
sancionDecomisoController.getRecord().getModifiedData().put("arma", armaactual);
|
|
//lista de las RECOMENDACIONES
|
|
sancionDecomisoController.getRecord().getModifiedData().put("recomendaciones", sancionRecomendacionController.getLrecord());
|
|
sancionDecomisoController.update();
|
|
|
|
sanc=true;
|
|
//graba la sancion
|
|
save();
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Crea una nueva recomendacion
|
|
*/
|
|
public void createRecomendacion(){
|
|
try {
|
|
sancionRecomendacionController.create();
|
|
sancionRecomendacionController.getRecord().setPersoncode(personaUsuario.getPk().getPersoncode());
|
|
sancionRecomendacionController.getRecord().getModifiedData().put("usuario", personaUsuario.getName());
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Guarda la recomendacion en el lrecord de sanciones
|
|
*/
|
|
public void actualizarRecomendacion(){
|
|
try {
|
|
sancionRecomendacionController.update();
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Obtiene los datos del lov de sancion
|
|
* @param event
|
|
* @throws Exception
|
|
*/
|
|
public void onReturnSancionLov(SelectEvent event) throws Exception{
|
|
sancion=(TarmTipoSancion) event.getObject();
|
|
|
|
}
|
|
|
|
/**
|
|
* Abre el Lov de Sanciones
|
|
*/
|
|
public void openSancionarLov() {
|
|
if(tramite==null || tramite.getTipoautorizacion()==null){
|
|
MessageHelper.setMessageError("DOCUMENTO SIN SIN TRAMITE");
|
|
return;
|
|
}
|
|
if(tipoarmaexplosivo==null || tipoarmaexplosivo.getClase()==null){
|
|
MessageHelper.setMessageError("ARMA SIN CLASE");
|
|
return;
|
|
}
|
|
Map<String, List<String>> params = new HashMap<>();
|
|
|
|
List<String> tramitePa = new ArrayList<String>();
|
|
tramitePa.add(tramite.getTipoautorizacion());
|
|
params.put("tramite", tramitePa);
|
|
List<String> clasePa = new ArrayList<String>();
|
|
clasePa.add(tipoarmaexplosivo.getClase());
|
|
params.put("clase", clasePa);
|
|
System.out.println("Tramite: "+tramite.getTipoautorizacion()+" clase arma: "+tipoarmaexplosivo.getClase());
|
|
SancionarLovController.openLov(params);//, tipoarmaexplosivo, tsancion,
|
|
}
|
|
|
|
public void reporteSancion(){
|
|
String gradoUsuario ="";
|
|
|
|
Calendar fechaActualCldr = Calendar.getInstance();
|
|
String path = "armas/reports/sancionReporte";
|
|
String filename="Sancion";
|
|
|
|
//Fija parametros del report.
|
|
HashMap<String, Object> parameters = new HashMap<>();
|
|
parameters.put("pathLogoIzquierda", "repo:/maia/1/image/comandoconjunto");
|
|
parameters.put("pathLogoDerecha", "repo:/maia/1/image/selloarmas");
|
|
try {
|
|
String nombreUsuario;
|
|
if(userDetail.getPk().getPersoncode()!=null){
|
|
nombreUsuario = PersonDetailController.find(userDetail.getPk().getPersoncode().toString()).getName();
|
|
}
|
|
else{
|
|
nombreUsuario = "";
|
|
}
|
|
parameters.put("usuario", nombreUsuario);
|
|
//Fecha actual
|
|
StringBuilder fechaActualSB = new StringBuilder();
|
|
fechaActualSB = fechaActualSB.append((fechaActualCldr.get(Calendar.DAY_OF_MONTH)) <= 9 ? "0" + (fechaActualCldr.get(Calendar.DAY_OF_MONTH)) : (fechaActualCldr.get(Calendar.DAY_OF_MONTH)));
|
|
fechaActualSB = fechaActualSB.append("-").append((fechaActualCldr.get(Calendar.MONTH)+1) <= 9 ? "0" + (fechaActualCldr.get(Calendar.MONTH) + 1) : (fechaActualCldr.get(Calendar.MONTH)+1));
|
|
fechaActualSB = fechaActualSB.append("-").append(fechaActualCldr.get(Calendar.YEAR));
|
|
fechaActualSB = fechaActualSB.append(" ").append(fechaActualCldr.get(Calendar.HOUR_OF_DAY));
|
|
fechaActualSB = fechaActualSB.append(":").append((fechaActualCldr.get(Calendar.MINUTE)) <= 9 ? "0" + (fechaActualCldr.get(Calendar.MINUTE)) : (fechaActualCldr.get(Calendar.MINUTE)));
|
|
parameters.put("lugarFecha", fechaActualSB.toString());
|
|
// parameters.put("transaccion",numeroTransaccionEnvioConvertido);
|
|
String format="pdf";
|
|
|
|
InputStream file =this.reportController.jaspertoInputstream(path, parameters, format, filename, this.getLoginController());
|
|
String xpathflujo = generarXpath();
|
|
|
|
alfrescoController.uploadFile(file,filename+".pdf",xpathflujo);
|
|
// iniciarFlujo(xpathflujo+"/cm:"+numeroTransaccionEnvioConvertido+ ".pdf");//="cm:Decomiso/cm:A-2014/cm:M-10/cm:ENV-000000319/cm:ENV-000000319.pdf"
|
|
} catch (Exception ex) {
|
|
MessageHelper.setMessageError(ex);
|
|
}
|
|
finally{
|
|
reporte=Boolean.FALSE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Metodo para generar la ruta del alfresco
|
|
* @return
|
|
*/
|
|
public String generarXpath(){
|
|
Calendar calendar = Calendar.getInstance();
|
|
calendar.setTime(new Date());
|
|
StringBuilder ruta=new StringBuilder("cm:Decomiso");
|
|
String centrocontrol=institucionCentroControl.replaceAll("\\s+", "_");
|
|
ruta = ruta.append("/cm:").append(centrocontrol);
|
|
ruta = ruta.append("/cm:A-").append(calendar.get(Calendar.YEAR));
|
|
ruta = ruta.append("/cm:M-").append((calendar.get(Calendar.MONTH)+1) <= 9 ? "0" + (calendar.get(Calendar.MONTH) + 1) : (calendar.get(Calendar.MONTH)+1));
|
|
|
|
return ruta.toString();
|
|
}
|
|
|
|
/* (non-Javadoc)
|
|
* @see com.fp.frontend.controller.AbstractController#save()
|
|
*/
|
|
@Override
|
|
public void save() {
|
|
if(sancionDecomisoController.getLrecord()==null || sancionDecomisoController.getLrecord().isEmpty()){
|
|
MessageHelper.setMessageInfo(MsgControlArmas.getProperty("msg_realiceunasancion"));
|
|
return;
|
|
}
|
|
try {
|
|
Request request = this.callerhelper.getRequest();
|
|
HashMap<String, DtoSave> msave = new HashMap<String, DtoSave>();
|
|
//cargado las sanciones
|
|
DtoSave dtosaveSancionDecomiso = sancionDecomisoController.getDtoSave();
|
|
dtosaveSancionDecomiso.setPosition(1);
|
|
msave.put(this.sancionDecomisoController.getBeanalias(), dtosaveSancionDecomiso);
|
|
|
|
//cargado las recomendaciones
|
|
DtoSave dtosaveSancionRecomend = sancionRecomendacionController.getDtoSave();
|
|
dtosaveSancionRecomend.setPosition(2);
|
|
msave.put(this.sancionRecomendacionController.getBeanalias(), dtosaveSancionRecomend);
|
|
|
|
//cargado para actualizarse
|
|
DtoSave dtosaveDocumentoHabilitante= documentoHabilitanteController.getDtoSave();
|
|
dtosaveDocumentoHabilitante.setPosition(3);
|
|
msave.put(this.documentoHabilitanteController.getBeanalias(), dtosaveDocumentoHabilitante);
|
|
|
|
//decomiso del arma(vacio)
|
|
DtoSave dtosaveDecomisoArma= decomisoArmaController.getDtoSave();
|
|
dtosaveDecomisoArma.setPosition(4);
|
|
msave.put(this.decomisoArmaController.getBeanalias(), dtosaveDecomisoArma);
|
|
|
|
//arma(vacio)
|
|
DtoSave dtosaveArmasController= armasController.getDtoSave();
|
|
dtosaveArmasController.setPosition(5);
|
|
msave.put(this.armasController.getBeanalias(), dtosaveArmasController);
|
|
|
|
request.setSaveTables(msave);
|
|
// query transaction Sancionar
|
|
Response resp = this.callerhelper.executeSave(request);
|
|
if (resp.getResponseCode().compareTo(Response.RESPONSE_OK) == 0) {
|
|
this.sancionDecomisoController.postCommit(resp);
|
|
sancionDecomisoController.clearAll();
|
|
this.sancionRecomendacionController.postCommit(resp);
|
|
sancionRecomendacionController.clearAll();
|
|
this.documentoHabilitanteController.postCommit(resp);
|
|
this.decomisoArmaController.postCommit(resp);
|
|
this.armasController.postCommit(resp);
|
|
MessageHelper.setMessageInfo(resp);
|
|
reporte=Boolean.TRUE;
|
|
//cambio a sancionada el arma
|
|
for(TarmArmas arma:larmas){
|
|
if(arma.getPk().equals(armaactual.getPk())){
|
|
arma.getModifiedData().put("sancionada", "true");
|
|
}
|
|
}
|
|
checkenviar();
|
|
//reporteSancion();
|
|
} else {
|
|
MessageHelper.setMessageError(resp);
|
|
}
|
|
} catch (Throwable e) {
|
|
MessageHelper.setMessageError(e);
|
|
}
|
|
finally{
|
|
btnEnviar="true";
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void postCommit(Response response) throws Exception {
|
|
super.postCommitGeneric(response, beanalias);
|
|
}
|
|
|
|
/**
|
|
* Metodo para finalizar la tarea del flujo
|
|
*/
|
|
public void completarTarea() {
|
|
|
|
try {
|
|
Request request = callerhelper.getRequest();
|
|
// limpiar request para finalizar la tarea.
|
|
super.cleanRequest(request);
|
|
// request.modifiedData().put("cdecomiso",cDecomiso);
|
|
request.modifiedData().put("TID", tid);
|
|
request.modifiedData().put("isnew", "Y");
|
|
request.modifiedData().put("BPMStatus", bpmDataStatus == null ? "A" : bpmDataStatus); // A,D,R
|
|
request.modifiedData().put("BPMObs",bpmDataComment == null ? "OK" : bpmDataComment);
|
|
Response resp = callerhelper.executeSave(request);
|
|
|
|
if (resp.getResponseCode().compareTo(Response.RESPONSE_OK) == 0) {
|
|
MessageHelper.setMessageInfo(resp);
|
|
btnEnviar=null;
|
|
isEnableEnviar = Boolean.FALSE;
|
|
RequestContext.getCurrentInstance().execute("Maia.refreshusertasks()");
|
|
} else {
|
|
MessageHelper.setMessageError(resp);
|
|
}
|
|
} catch (Throwable e) {
|
|
MessageHelper.setMessageError(e);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Seleccionar Arma para sancionarla
|
|
* @param event
|
|
*/
|
|
public void seleccionarArma1212(AjaxBehaviorEvent event){
|
|
try {
|
|
SelectBooleanCheckbox booleanCheckbox = (SelectBooleanCheckbox) event.getComponent();
|
|
decomisoArmaObj = (TarmDecomisoArma) booleanCheckbox.getAttributes().get("armaDecomisadaObj");
|
|
boolean checked = (Boolean) booleanCheckbox.getValue();
|
|
if (checked) {
|
|
decomisoArmaObj.setEnbodega("Y");
|
|
}else{
|
|
decomisoArmaObj.setEnbodega(null);
|
|
}
|
|
decomisoArmaController.update(decomisoArmaObj);
|
|
} catch (Exception e) {
|
|
// TODO Auto-generated catch block
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sancion Para la autorizacion
|
|
* @param pCdocumento
|
|
*/
|
|
public void sancionarAutorizaciona121212(Long pCdocumento){
|
|
try {
|
|
sancionDecomisoController.create();
|
|
sancionDecomisoController.getRecord().setCdocumento(pCdocumento);
|
|
tipsancion="AUTORIZACION";
|
|
} catch (Exception e) {
|
|
// TODO Auto-generated catch block
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Busca la sancion
|
|
*/
|
|
public void changeType1212(){
|
|
sancion=DatosParaSancionesController.findxPk(sancion.getPk());
|
|
}
|
|
|
|
public DecomisoArmaController getDecomisoArmaController() {
|
|
return decomisoArmaController;
|
|
}
|
|
|
|
public void setDecomisoArmaController(
|
|
DecomisoArmaController decomisoArmaController) {
|
|
this.decomisoArmaController = decomisoArmaController;
|
|
}
|
|
|
|
public TarmDecomiso getDecomiso() {
|
|
return decomiso;
|
|
}
|
|
|
|
public void setDecomiso(TarmDecomiso decomiso) {
|
|
this.decomiso = decomiso;
|
|
}
|
|
|
|
public String getProvincia() {
|
|
return provincia;
|
|
}
|
|
|
|
public void setProvincia(String provincia) {
|
|
this.provincia = provincia;
|
|
}
|
|
|
|
public String getCanton() {
|
|
return canton;
|
|
}
|
|
|
|
public void setCanton(String canton) {
|
|
this.canton = canton;
|
|
}
|
|
|
|
public String getCiudad() {
|
|
return ciudad;
|
|
}
|
|
|
|
public void setCiudad(String ciudad) {
|
|
this.ciudad = ciudad;
|
|
}
|
|
|
|
public String getParroquia() {
|
|
return parroquia;
|
|
}
|
|
|
|
public void setParroquia(String parroquia) {
|
|
this.parroquia = parroquia;
|
|
}
|
|
|
|
public TgeneCatalogDetail getGradoCatalogDatail() {
|
|
return gradoCatalogDatail;
|
|
}
|
|
|
|
public void setGradoCatalogDatail(TgeneCatalogDetail gradoCatalogDatail) {
|
|
this.gradoCatalogDatail = gradoCatalogDatail;
|
|
}
|
|
|
|
public TgeneCatalogDetail getUnidadCatalogDatail() {
|
|
return unidadCatalogDatail;
|
|
}
|
|
|
|
public void setUnidadCatalogDatail(TgeneCatalogDetail unidadCatalogDatail) {
|
|
this.unidadCatalogDatail = unidadCatalogDatail;
|
|
}
|
|
|
|
|
|
|
|
public TarmDecomisoArma getDecomisoArmaObj() {
|
|
return decomisoArmaObj;
|
|
}
|
|
|
|
public void setDecomisoArmaObj(TarmDecomisoArma decomisoArmaObj) {
|
|
this.decomisoArmaObj = decomisoArmaObj;
|
|
}
|
|
|
|
|
|
|
|
public SancionDecomisoController getSancionDecomisoController() {
|
|
return sancionDecomisoController;
|
|
}
|
|
|
|
public void setSancionDecomisoController(
|
|
SancionDecomisoController sancionDecomisoController) {
|
|
this.sancionDecomisoController = sancionDecomisoController;
|
|
}
|
|
|
|
public SancionRecomendacionController getSancionRecomendacionController() {
|
|
return sancionRecomendacionController;
|
|
}
|
|
|
|
public void setSancionRecomendacionController(
|
|
SancionRecomendacionController sancionRecomendacionController) {
|
|
this.sancionRecomendacionController = sancionRecomendacionController;
|
|
}
|
|
|
|
public String getClasearma() {
|
|
return clasearma;
|
|
}
|
|
|
|
public void setClasearma(String clasearma) {
|
|
this.clasearma = clasearma;
|
|
}
|
|
|
|
// public List<TarmTipoSancion> getTsancion() {
|
|
// return tsancion;
|
|
// }
|
|
//
|
|
// public void setTsancion(List<TarmTipoSancion> tsancion) {
|
|
// this.tsancion = tsancion;
|
|
// }
|
|
|
|
public TarmTipoSancion getSancion() {
|
|
return sancion;
|
|
}
|
|
|
|
public void setSancion(TarmTipoSancion sancion) {
|
|
this.sancion = sancion;
|
|
}
|
|
|
|
public String getSanciontipo() {
|
|
return sanciontipo;
|
|
}
|
|
|
|
public void setSanciontipo(String sanciontipo) {
|
|
this.sanciontipo = sanciontipo;
|
|
}
|
|
|
|
public Boolean getGrillaAut() {
|
|
return grillaAut;
|
|
}
|
|
|
|
public void setGrillaAut(Boolean grillaAut) {
|
|
this.grillaAut = grillaAut;
|
|
}
|
|
|
|
// public Long getcDecomiso() {
|
|
// return cDecomiso;
|
|
// }
|
|
//
|
|
// public void setcDecomiso(Long cDecomiso) {
|
|
// this.cDecomiso = cDecomiso;
|
|
// }
|
|
|
|
public String getBtnEnviar() {
|
|
return btnEnviar;
|
|
}
|
|
|
|
public Long getcTransaccion() {
|
|
return cTransaccion;
|
|
}
|
|
|
|
public void setcTransaccion(Long cTransaccion) {
|
|
this.cTransaccion = cTransaccion;
|
|
}
|
|
|
|
public void setBtnEnviar(String btnEnviar) {
|
|
this.btnEnviar = btnEnviar;
|
|
}
|
|
|
|
public List<TarmDocumentoHabilitante> getDocumentos() {
|
|
return documentos;
|
|
}
|
|
|
|
public void setDocumentos(List<TarmDocumentoHabilitante> documentos) {
|
|
this.documentos = documentos;
|
|
}
|
|
|
|
|
|
public String getTipsancion() {
|
|
return tipsancion;
|
|
}
|
|
|
|
public void setTipsancion(String tipsancion) {
|
|
this.tipsancion = tipsancion;
|
|
}
|
|
|
|
public Boolean getSanc() {
|
|
return sanc;
|
|
}
|
|
|
|
public void setSanc(Boolean sanc) {
|
|
this.sanc = sanc;
|
|
}
|
|
|
|
public Boolean getIsExistDocHabilitante() {
|
|
return isExistDocHabilitante;
|
|
}
|
|
|
|
public void setIsExistDocHabilitante(Boolean isExistDocHabilitante) {
|
|
this.isExistDocHabilitante = isExistDocHabilitante;
|
|
}
|
|
|
|
public Boolean getIsEnableGrabar() {
|
|
return isEnableGrabar;
|
|
}
|
|
|
|
public void setIsEnableGrabar(Boolean isEnableGrabar) {
|
|
this.isEnableGrabar = isEnableGrabar;
|
|
}
|
|
|
|
public Boolean getIsEnableEnviar() {
|
|
return isEnableEnviar;
|
|
}
|
|
|
|
public void setIsEnableEnviar(Boolean isEnableEnviar) {
|
|
this.isEnableEnviar = isEnableEnviar;
|
|
}
|
|
|
|
public List<TarmArmas> getLarmas() {
|
|
return larmas;
|
|
}
|
|
|
|
public void setLarmas(List<TarmArmas> larmas) {
|
|
this.larmas = larmas;
|
|
}
|
|
|
|
public TarmRegistroArmas getRegarma() {
|
|
return regarma;
|
|
}
|
|
|
|
public void setRegarma(TarmRegistroArmas regarma) {
|
|
this.regarma = regarma;
|
|
}
|
|
|
|
public TarmArmas getArmaactual() {
|
|
return armaactual;
|
|
}
|
|
|
|
public void setArmaactual(TarmArmas armaactual) {
|
|
this.armaactual = armaactual;
|
|
}
|
|
|
|
public List<TarmDocumentoHabilitante> getAutorizacion() {
|
|
return autorizacion;
|
|
}
|
|
|
|
public void setAutorizacion(List<TarmDocumentoHabilitante> autorizacion) {
|
|
this.autorizacion = autorizacion;
|
|
}
|
|
|
|
public long getCdocumentohabilitanteaut() {
|
|
return cdocumentohabilitanteaut;
|
|
}
|
|
|
|
public void setCdocumentohabilitanteaut(long cdocumentohabilitanteaut) {
|
|
this.cdocumentohabilitanteaut = cdocumentohabilitanteaut;
|
|
}
|
|
|
|
public Boolean getAut() {
|
|
return aut;
|
|
}
|
|
|
|
public void setAut(Boolean aut) {
|
|
this.aut = aut;
|
|
}
|
|
|
|
public TarmCentroControl getCentrocontrol() {
|
|
return centroControl;
|
|
}
|
|
|
|
public void setCentrocontrol(TarmCentroControl centrocontrol) {
|
|
this.centroControl = centrocontrol;
|
|
}
|
|
|
|
public Boolean getReporte() {
|
|
return reporte;
|
|
}
|
|
|
|
public void setReporte(Boolean reporte) {
|
|
this.reporte = reporte;
|
|
}
|
|
|
|
public AlfrescoController getAlfrescoController() {
|
|
return alfrescoController;
|
|
}
|
|
|
|
public void setAlfrescoController(AlfrescoController alfrescoController) {
|
|
this.alfrescoController = alfrescoController;
|
|
}
|
|
|
|
public TarmTipoArmaExplosivo getTipoarmaexplosivo() {
|
|
return tipoarmaexplosivo;
|
|
}
|
|
|
|
public void setTipoarmaexplosivo(TarmTipoArmaExplosivo tipoarmaexplosivo) {
|
|
this.tipoarmaexplosivo = tipoarmaexplosivo;
|
|
}
|
|
|
|
public TarmCentroControl getCentroControl() {
|
|
return centroControl;
|
|
}
|
|
|
|
public void setCentroControl(TarmCentroControl centroControl) {
|
|
this.centroControl = centroControl;
|
|
}
|
|
|
|
public String getInstitucionCentroControl() {
|
|
return institucionCentroControl;
|
|
}
|
|
|
|
public void setInstitucionCentroControl(String institucionCentroControl) {
|
|
this.institucionCentroControl = institucionCentroControl;
|
|
}
|
|
|
|
public TcustPersonDetail getResponsableCentroControl() {
|
|
return responsableCentroControl;
|
|
}
|
|
|
|
public void setResponsableCentroControl(
|
|
TcustPersonDetail responsableCentroControl) {
|
|
this.responsableCentroControl = responsableCentroControl;
|
|
}
|
|
|
|
public TarmTramite getTramite() {
|
|
return tramite;
|
|
}
|
|
|
|
public void setTramite(TarmTramite tramite) {
|
|
this.tramite = tramite;
|
|
}
|
|
public void setReportController(ReportController reportController) {
|
|
this.reportController = reportController;
|
|
}
|
|
|
|
public TsafeUserDetail getUserDetail() {
|
|
return userDetail;
|
|
}
|
|
|
|
public void setUserDetail(TsafeUserDetail userDetail) {
|
|
this.userDetail = userDetail;
|
|
}
|
|
public ReportController getReportController() {
|
|
return reportController;
|
|
}
|
|
|
|
public ArmasController getArmasController() {
|
|
return armasController;
|
|
}
|
|
|
|
public void setArmasController(ArmasController armasController) {
|
|
this.armasController = armasController;
|
|
}
|
|
|
|
public TcustPersonDetail getPersonaUsuario() {
|
|
return personaUsuario;
|
|
}
|
|
|
|
public void setPersonaUsuario(TcustPersonDetail personaUsuario) {
|
|
this.personaUsuario = personaUsuario;
|
|
}
|
|
public DocumentoHabilitanteController getDocumentoHabilitanteController() {
|
|
return documentoHabilitanteController;
|
|
}
|
|
}
|