package com.fitbank.common; import com.fitbank.common.conectivity.HbSession; import com.fitbank.common.conectivity.HbSessionAuxiliar; import com.fitbank.common.exception.FitbankException; import com.fitbank.common.hb.AbstractExpire; import com.fitbank.common.hb.AbstractId; import com.fitbank.common.hb.ManejaHistory; import com.fitbank.common.helper.FormatDates; import com.fitbank.common.logger.CallerFinder; import com.fitbank.common.logger.FitbankLogger; import com.fitbank.dto.management.Detail; import com.fitbank.common.properties.PropertiesHandler; import com.fitbank.hb.persistence.sec.Tsequencebase; import java.sql.Blob; import java.sql.Clob; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.Timestamp; import java.sql.CallableStatement; import java.sql.Connection; import java.sql.SQLException; import java.io.Serializable; import java.util.List; import org.apache.commons.configuration.Configuration; import org.apache.commons.lang.StringUtils; import org.apache.log4j.Logger; import org.hibernate.Criteria; import org.hibernate.Hibernate; import org.hibernate.LockMode; import org.hibernate.LockOptions; import org.hibernate.NonUniqueObjectException; import org.hibernate.SQLQuery; import org.hibernate.Session; import org.hibernate.Transaction; import org.hibernate.criterion.ProjectionList; import org.hibernate.criterion.Projections; import org.hibernate.criterion.Restrictions; import org.hibernate.dialect.Dialect; import org.hibernate.dialect.SQLServerDialect; import org.hibernate.internal.SessionFactoryImpl; import org.hibernate.internal.SessionImpl; import org.hibernate.transform.Transformers; /** * Helper que almacena Threads de session, transaccion, y FinancialSession * utilizadas en el proceso de transacciones * financieras. * * @author Fitbank * @version 2.0 */ public final class Helper { /** * Almacena una session de Hibernate. */ private static ThreadLocal threadSession = new ThreadLocal(); /** * Almacena una session de Hibernate auxiliar. */ private static ThreadLocal threadAuxiliarSession = new ThreadLocal(); /** * Almacena una transaccion de Hibernate. */ private static ThreadLocal threadTransaction = new ThreadLocal(); private static ThreadLocal context = new ThreadLocal(); /** * Notifica si la información de la sesión actual ya fue rastreada o no. */ private static ThreadLocal threadTraced = new ThreadLocal(); private static final Logger LOGGER = FitbankLogger.getLogger(); private static final String FDESDE = "fdesde"; private static final String FHASTA = "pk.fhasta"; private static Exception commonException = new Exception("Excepción genérica Helper"); private static final Configuration CONFIG = PropertiesHandler.getConfig("persistence"); /** * Permite establecer los datos que se asignaran a la sesion */ private static boolean developerMode = CONFIG.getBoolean("com.fitbank.common.DEVELOPER_MODE", false); private Helper() { } /** * Inicia el proceso de una transaccion de hibernate.. */ public static void beginTransaction() { Transaction tx = Helper.threadTransaction.get(); if (tx == null) { tx = Helper.getSession().beginTransaction(); Helper.threadTransaction.set(tx); LOGGER.debug("BeginTransaction ejecutado desde " + CallerFinder.getCallerName()); } } /** * Cierra una session de base de datos. */ public static void closeAuxiliarSession() { Session s = Helper.threadAuxiliarSession.get(); if (s != null) { try { s.clear(); s.close(); LOGGER.debug("CloseAuxiliarSession ejecutado desde " + CallerFinder.getCallerName()); } catch (Exception ex) { LOGGER.debug("No se pudo cerrar la sesion", ex); } finally { Helper.threadAuxiliarSession.set(null); } } } /** * Cierra una session de base de datos. */ public static void closeSession() { Session s = Helper.threadSession.get(); if (s != null) { try { s.clear(); s.close(); HbSession.getInstance().updateStatsValue(HbSession.CLOSED); HbSession.getInstance().traceStatistics("Sesion cerrada"); LOGGER.debug("CloseSession ejecutado desde " + CallerFinder.getCallerName()); } catch (Exception ex) { LOGGER.debug("No se pudo cerrar la sesion", ex); } finally { Helper.threadTransaction.set(null); Helper.threadSession.set(null); } } } /** * Graba los dml que estan en la transaccion. */ public static void commitTransaction() { Transaction tx = Helper.threadTransaction.get(); if (tx == null) { tx = getSession().getTransaction(); } boolean successfulCommit = false; try { if (tx == null) { throw new FitbankException("HB003", "NO EXISTE UNA TRANSACCION INICIADA"); } else if(tx.wasCommitted()) { throw new FitbankException("HB003", "TRANSACCION YA APLICADA"); } else if(tx.wasRolledBack()) { throw new FitbankException("HB003", "TRANSACCION YA APLICADO ROLLBACK"); } else { if (tx.isActive() || tx.isParticipating()) { tx.commit(); } Helper.getSession().clear(); successfulCommit = true; LOGGER.debug("Commit ejecutado desde " + CallerFinder.getCallerName()); } } finally { if (successfulCommit) { Helper.threadTransaction.set(null); } } } /** * Completa la compañía para los beans que al hacer update o save el valor * de la compañía llega en null desde el formulario. * * @param pBean Bean a verificar el valor de la compañía. */ public static void completeCompany(TransportBean pBean) { try { Object cia = BeanManager.getBeanAttributeValue(pBean, "pk.cpersona_compania"); if (cia == null) { BeanManager.setBeanAttributeValue(pBean, "pk.cpersona_compania", RequestData.getDetail().getCompany()); } } catch (Exception ex) { LOGGER.debug("Bean " + pBean.getClass().getName() + " no tiene compañía"); } } public static SQLQuery createSQLQuery(String pSQL) { return Helper.createSQLQuery(Helper.getSession(), pSQL); } /** * @param s * @param pSQL * * @return */ public static SQLQuery createSQLQuery(Session s, String pSQL) { SessionFactoryImpl imp = (SessionFactoryImpl) s.getSessionFactory(); Dialect dialect = imp.getDialect(); if (dialect instanceof SQLServerDialect) { pSQL = pSQL.replaceAll("\\|\\|", "+"); } return s.createSQLQuery(pSQL); } /** * Elimina un registro en la base de datos. * * @param pClassName Nombre de la clase que maneja la persistencia de una * tabla. * @param pBean Bean a actualiar. */ public static void delete(String pClassName, TransportBean pBean) { Session s = Helper.getSession(); s.delete(pClassName, pBean); LOGGER.debug("Delete ejecutado desde " + CallerFinder.getCallerName()); } /** * Elimina un registro en la base de datos. * * @param pBean Bean a actualiar. */ public static void delete(TransportBean pBean) { Session s = Helper.getSession(); s.delete(pBean); LOGGER.debug("Delete ejecutado desde " + CallerFinder.getCallerName()); } /** * Caduca registro persistente. * * @param currentBean Bean a caducar. * * @throws Exception */ public static void expire(TransportBean currentBean) throws Exception { Session s = Helper.getSession(); if (Helper.hasChildRecords(currentBean)) { throw new FitbankException("HB016", "EXISTEN REGISTROS DEPENDIENTES. " + "NO SE PUEDE CADUCAR", commonException); } Object pk = BeanManager.getBeanAttributeValue(currentBean, "pk"); if (pk instanceof ManejaHistory && currentBean instanceof AbstractExpire) { AbstractExpire expiredBean = (AbstractExpire) currentBean.cloneMe(); Timestamp expireTimestamp = ApplicationDates.getDBTimestamp(); BeanManager.setBeanAttributeValue(expiredBean, FHASTA, expireTimestamp); try { BeanManager.setBeanAttributeValue(expiredBean, "pk.fparticion", FormatDates.formatFPartition(expireTimestamp)); } catch (Exception e1) { //Si no tiene el campo fparticion, no hacer nada. } Helper.saveHistory(expiredBean); } s.delete(currentBean); LOGGER.debug("Expire ejecutado desde " + CallerFinder.getCallerName()); } /** * @param s Contenido del clob * @return Un clob */ public static Clob createClob(String s) { return Hibernate.getLobCreator(getSession()).createClob(s); } /** * @param bytes Contenido del blob * @return un Blob */ public static Blob createBlob(byte[] bytes) { return Hibernate.getLobCreator(getSession()).createBlob(bytes); } /** * Metodo que verifica si un registro tiene registros secundarios * * @param pBean Bean a verificar * @return true si tienes childRecords false caso contrario. */ public static boolean hasChildRecords(TransportBean pBean) { if (!(pBean instanceof AbstractId)) { return false; } boolean doControl = CONFIG.getBoolean(Helper.class.getName() + ".CHILD_RECORDS_CONTROL"); if (!doControl) { return false; } List tablesToIgnore = CONFIG.getList(Helper.class.getName() + ".CHILD_RECORDS_TABLE_TO_IGNORE"); String tableName = HbSession.getInstance().getTableName(pBean.getClass()); if (!tablesToIgnore.isEmpty() && tablesToIgnore.contains(tableName)) { LOGGER.debug("Ignorando tabla " + tableName + " para el control de registros secundarios"); return false; } boolean hasChildRecords = false; Session s = HbSession.getInstance().forceOpenSession(); Transaction tr = s.beginTransaction(); LOGGER.debug("Verificando existencia de registros secundarios antes de caducar..."); Helper.completeCompany(pBean); try { //Carga la clase ID Class idClass = Class.forName(pBean.getClass().getName() + "id"); TransportBean tb = (TransportBean) idClass.newInstance(); //Armar el objeto de la clase ID con los valores PK del bean Object id = tb.createInstance(); List l = HbSession.getInstance().getFieldsPrimaryKey(idClass); if (l.size() == 1) { Object value = BeanManager.getBeanAttributeValue(pBean, "pk." + l.get(0).toLowerCase()); BeanManager.setBeanAttributeValue(id, "pk", value); } else { for (String pkField : l) { Object value = BeanManager.getBeanAttributeValue(pBean, "pk." + pkField.toLowerCase()); BeanManager.setBeanAttributeValue(id, "pk." + pkField.toLowerCase(), value); } } //Carga el beanID de la sesion Object obj = null; try { obj = s.get(idClass, (Serializable) BeanManager. getBeanAttributeValue(id, "pk")); } catch (Exception ex) { LOGGER.error("Error obteniendo objeto de la clase ID", ex); } //Si el beanID existe, intentar eliminarlo para la verificacion if (obj != null) { //Eliminar primero los valores de la tabla principal String delHql = "delete from " + pBean.getClass().getName() + " o where"; boolean first = true; for (String pkField : l) { pkField = pkField.toLowerCase(); if ("fhasta".equals(pkField)) { continue; } Object value = BeanManager.getBeanAttributeValue(pBean, "pk." + pkField); if (first) { delHql = delHql.concat(" o.pk." + pkField + "=\'" + value + "\'"); first = false; } else { delHql = delHql.concat(" and o.pk." + pkField + "=\'" + value + "\'"); } } s.createQuery(delHql).executeUpdate(); //Intentar eliminar el PK del beanID s.delete(obj); //Esta sentencia deberia lanzar una excepcion, si el PK tiene registros secundarios s.flush(); } } catch (ClassNotFoundException e) { LOGGER.debug("El bean " + pBean.getClass().getName() + " no posee un BeanId"); } catch (IllegalAccessException e) { LOGGER.error("Errores al crear el objeto BeanId", e); } catch (Exception e) { hasChildRecords = doControl; commonException = e; LOGGER.error("Registros secundarios encontrados en " + pBean.getClass().getName(), e); } finally { tr.rollback(); s.clear(); s.close(); } return hasChildRecords; } /** * Graba los dml que estan en la transaccion. */ public static void flushTransaction() { Helper.getSession().flush(); LOGGER.debug("FlushTransaction ejecutado desde " + CallerFinder.getCallerName()); } public static Session getAuxiliarSession() { LOGGER.debug("Obteniendo sesión auxiliar, llamado desde " + CallerFinder.getCallerName()); Session s = Helper.threadAuxiliarSession.get(); if (s == null) { throw new FitbankException("HB002", "NO EXISTE UNA SESION AUXILIAR ABIERTA PARA EL THREAD ACTUAL"); } //Si la sesion no esta abierta para el thread actual, abrir una nueva if (!s.isOpen()) { try { Helper.threadAuxiliarSession.set(null); s = HbSessionAuxiliar.getInstance().openSession(); Helper.threadAuxiliarSession.set(s); } catch (Exception e) { throw new FitbankException("HB002", "NO EXISTE UNA SESION AUXILIAR ABIERTA PARA EL THREAD ACTUAL", e); } } return s; } /** * Obtiene una referencia a un determinado Bean dado su PK * * @param Tipo de bean a devolver * @param pType tipo de Bean * @param pPk Referencia a la clave Primaria. * @param proyecciones Campos que se consultarán en forma parcial, en caso de no especificar se consultarán todos. * * @return Bean Requerido */ @SuppressWarnings("unchecked") public static T getBean(Class pType, Serializable pPk, String... proyecciones) { if (proyecciones.length > 0) { Criteria criteria = Helper.getSession().createCriteria(pType).add(Restrictions.eq("pk", pPk)); ProjectionList projectionList = Projections.projectionList(); for (String proyeccion : proyecciones) { // Para evitar mantener beanes parciales if ("versioncontrol".equalsIgnoreCase(proyeccion)) { throw new FitbankException("HB009", "NO SE PUEDE CONSULTAR VERSIONCONTROL"); } projectionList.add(Projections.property(proyeccion), proyeccion); } criteria.setProjection(projectionList).setResultTransformer(Transformers.aliasToBean(pType)); return (T) criteria.uniqueResult(); } else { return (T) Helper.getSession().get(pType, pPk); } } /** * Obtiene una referencia a un determinado Bean dado su PK * * @param Tipo de bean a devolver * @param pType tipo de Bean * @param pPk Referencia a la clave Primaria. * * @return Bean Requerido */ public static T getBean(Class pType, Serializable pPk) { return (T) Helper.getSession().get(pType, pPk); } /** * Obtiene una referencia a un determinado Bean dado su PK Permitiendo la * Opcion de bloquear la cuenta * * @param Tipo de bean a devolver * @param pType tipo de Bean * @param pPk Referencia a la clave Primaria * @param pLockMode tipo de bloqueo del Registro * * @return Bean Requerido */ @SuppressWarnings("unchecked") public static T getBean(Class pType, Serializable pPk, LockMode pLockMode) { return (T) Helper.getSession().get(pType, pPk, new LockOptions(pLockMode)); } public static Object getContext() { return Helper.context.get(); } /** * Retorna una session de hibernate. * * @return s */ public static Session getSession() { LOGGER.debug("Obteniendo sesión, llamado desde " + CallerFinder.getCallerName()); Session s = Helper.threadSession.get(); if (s == null) { throw new FitbankException("HB002", "NO EXISTE UNA SESION ABIERTA PARA EL THREAD ACTUAL"); } //Si la sesion no esta abierta para el thread actual, abrir una nueva if (!s.isOpen()) { Helper.threadSession.set(null); s = HbSession.getInstance().openSession(); Helper.threadSession.set(s); } return s; } /** * Retorna la conexion JDBC asociada a una sesion. * @param pSession * @return */ public static Connection getConnection(Session pSession) { LOGGER.debug("Obteniendo conexión mediante una sesión, llamado desde " + CallerFinder.getCallerName()); return ((SessionImpl) pSession).connection(); } /** * Retorna la conexion JDBC asociada a la sesion actual. * @return */ public static Connection getConnection() { LOGGER.debug("Obteniendo conexión, llamado desde " + CallerFinder.getCallerName()); return ((SessionImpl) Helper.getSession()).connection(); } /** * Retorna verdadero si a la transacci�n se dio un commit; * * @return boolean */ public static boolean isCommitted() { Transaction tx = Helper.threadTransaction.get(); return tx != null && tx.wasCommitted(); } /** * Retorna verdadero si a la transacci�n se dio un rollback; * * @return boolean */ public static boolean isRolledBack() { Transaction tx = Helper.threadTransaction.get(); return tx != null && tx.wasRolledBack(); } /** * Retorna verdadero si la sesion aun tiene una transaccion activa * * @return boolean */ public static boolean isTransactionActive() { Transaction tx = Helper.threadTransaction.get(); if (tx == null) { tx = Helper.getSession().getTransaction(); } return tx != null && (tx.isActive() || tx.isParticipating()); } /** * Retorna verdadero si existe una sesion abierta en el thread actual * * @return boolean */ public static boolean isSessionOpened() { boolean isSessionOpened; try { isSessionOpened = Helper.getSession().isOpen() && Helper.getSession().isConnected(); } catch (Exception e) { //Sesion no abierta en el thread actual isSessionOpened = false; } return isSessionOpened; } /** * Manejo de historia de registros, inserta un registro con los valores * anteriores y actualiza el registro vigente * con los valores nuevos. * * @param pBean Bean a crear historia. * @param caducar Indica si se caduca un registro o se maneja como historia. * * @return bean a insertar, actualizar o eliminar. * * @throws Exception */ private static TransportBean manageHistory(TransportBean pBean) throws Exception { return manageHistory(pBean, null); } /** * Manejo de historia de registros, inserta un registro con los valores * anteriores y actualiza el registro vigente * con los valores nuevos. * * @param pBean Bean a crear historia. * @param old El bean antiguo o null para consultarlo de la base de datos. * * @return bean a insertar, actualizar o eliminar. * * @throws Exception */ private static TransportBean manageHistory(TransportBean pBean, AbstractExpire old) throws Exception { Session s = Helper.getSession(); Object id = BeanManager.getBeanAttributeValue(pBean, "pk"); if (!(id instanceof ManejaHistory) || !(pBean instanceof AbstractExpire)) { return pBean; } s.evict(pBean); TransportBean bean = (TransportBean) pBean.cloneMe(); AbstractExpire cad = (AbstractExpire) pBean.cloneMe(); if (s.contains(cad)) { s.evict(cad); } if (old == null) { old = (AbstractExpire) s.get(pBean.getClass(), (Serializable) ((AbstractExpire) pBean).getId()); } if (old != null) { s.evict(old); } Timestamp t = ApplicationDates.getDBTimestamp(); BeanManager.setBeanAttributeValue(bean, Helper.FDESDE, t); if (old == null) { BeanManager.setBeanAttributeValue(bean, Helper.FHASTA, ApplicationDates.DEFAULT_EXPIRY_TIMESTAMP); } else if (!BeanManager.compareObject(bean, old)) { ManejaHistory pk = (ManejaHistory) old.getId(); pk.setFhasta(t); try { BeanManager.setBeanAttributeValue(pk, "fparticion", FormatDates.formatFPartition(t)); } catch (Exception e1) { //Si no existe el campo fparticion, no hacer nada. } try { Helper.saveHistory(old); } catch (NonUniqueObjectException e) { t = ApplicationDates.getDBTimestamp(); pk = (ManejaHistory) old.getId(); pk.setFhasta(t); Helper.saveHistory(old); } } else { return null; } return bean; } private static void saveHistory(AbstractExpire transport) throws Exception { Session s = Helper.getSession(); if (Helper.getContext() == null) { s.save(transport); } else { s.persist(transport); } } private static void manageIdTables(TransportBean pBean) throws Exception { LOGGER.debug(pBean.getClass()); if (pBean instanceof AbstractId) { Class idClass = Class.forName(pBean.getClass().getName() + "id"); TransportBean tb = (TransportBean) idClass.newInstance(); Object id = tb.createInstance(); List l = HbSession.getInstance().getFieldsPrimaryKey(idClass); if (l.size() == 1) { BeanManager.setBeanAttributeValue(id, "pk", BeanManager.getBeanAttributeValue(pBean, "pk." + l.get(0).toLowerCase())); } else { for (String pkField : l) { pkField = pkField.toLowerCase(); BeanManager.setBeanAttributeValue(id, "pk." + pkField, BeanManager.getBeanAttributeValue(pBean, "pk." + pkField)); } } Session s = Helper.getSession(); Object obj = s.get(idClass, (Serializable) BeanManager. getBeanAttributeValue(id, "pk")); if (obj == null) { if (Helper.getContext() == null) { s.save(id); } else { s.persist(id); } } } } /** * @param pSecuence * * @return * * @throws Exception */ public static Integer nextValue(String pSecuence) throws Exception { return Helper.nextValue(pSecuence, null).intValue(); } /** * @param pSecuence * * @return * * @throws Exception */ public static Long nextLongValue(String pSecuence) throws Exception { return Helper.nextValue(pSecuence, null); } /** * M�todo que obtiene el valor siguiente de una secuencia * * @param pSecuence - Nombre de la Secuencia * * @return Valor de la secuencia * * @throws java.lang.Exception */ private static Long nextValue(String pSecuence, Session pSession) throws Exception { HbSession hb = HbSession.getInstance(); Dialect dialect = hb.getDialect(); if (dialect instanceof SQLServerDialect) { return Helper.sqlServerSequence(pSecuence); } String sSql = dialect.getSequenceNextValString(pSecuence); if ((sSql.indexOf("nextval") > -1) && (sSql.indexOf('.') < 0)) { sSql = "select nextval for " + pSecuence + " from sysibm.sysdummy1"; } Session session = pSession != null ? pSession : Helper.getSession(); PreparedStatement sql = Helper.getConnection(session).prepareStatement(sSql); ResultSet rst = null; long val = 0l; try { rst = sql.executeQuery(); if (rst.next()) { val = rst.getLong(1); } } finally { if (rst != null) { rst.close(); } sql.close(); } return val; } /** * M�todo que obtiene informaci�n de la tabla TSECUENCIASBASE para obetener * el valor de una secuencia * * @param pSequence - Nombre de la secuencia * * @return - Valor de la Secuencia * * @throws java.lang.Exception */ private static Long sqlServerSequence(String pSequence) throws Exception { Session s = HbSession.getInstance().openSession(); try { Transaction trn = s.beginTransaction(); Tsequencebase sequence = (Tsequencebase) s.get(Tsequencebase.class, pSequence, LockOptions.UPGRADE); if (sequence == null) { throw new FitbankException("BDD", "LA SECUENCIA {0} NO EXISTE", pSequence); } Long value = sequence.getConsecutivo(); if (value == sequence.getNumeromaximo()) { if (sequence.getCiclica().compareTo("1") == 0) { value = sequence.getNumeroinicial(); } else { throw new FitbankException("BDD", "LA SECUENCIA {0} HA ALCANZADO SU VALOR MAXIMO", pSequence); } } sequence.setConsecutivo(value + sequence.getIncremento()); s.saveOrUpdate(sequence); trn.commit(); LOGGER.debug("Commit ejecutado desde " + CallerFinder.getCallerName()); return value.longValue(); } finally { s.close(); } } /** * Obtiene el bean correspondiente al anterior al registro vigente, siempre * y cuando el bean maneje historia o sea * un bean de identificaci�n * * @param pBean TransportBean * * @return TransportBean * * @throws Exception */ public static TransportBean previousBean(TransportBean pBean) throws Exception { TransportBean cloneBean = (TransportBean) pBean.cloneMe(); TransportBean previousBean = null; Object id = BeanManager.getBeanAttributeValue(cloneBean, "pk"); if ((id instanceof ManejaHistory) && (cloneBean instanceof AbstractExpire)) { try { BeanManager.setBeanAttributeValue(cloneBean, Helper.FHASTA, BeanManager.getBeanAttributeValue(cloneBean, Helper.FDESDE)); Session s = Helper.getSession(); previousBean = (TransportBean) s.get(cloneBean.getClass(), (Serializable) id); } catch (Exception e) { LOGGER.debug("Errores al obtener el registro anterior de un bean", e); } } return previousBean; } /** * Rollback de los dml que estan dentro de la transaccion. */ public static void rollbackTransaction() { Transaction tx = Helper.threadTransaction.get(); if (tx == null) { tx = getSession().getTransaction(); } boolean rollbackSuccessful = false; try { if (tx == null) { throw new FitbankException("HB003", "NO EXISTE UNA TRANSACCION INICIADA"); } else if(tx.wasCommitted()) { throw new FitbankException("HB003", "TRANSACCION YA APLICADA"); } else if(tx.wasRolledBack()) { throw new FitbankException("HB003", "TRANSACCION YA APLICADO ROLLBACK"); } else { if (tx.isActive() || tx.isParticipating()) { tx.rollback(); } Helper.getSession().clear(); rollbackSuccessful = true; LOGGER.debug("Rollback ejecutado desde " + CallerFinder.getCallerName()); } } finally { if (rollbackSuccessful) { Helper.threadTransaction.set(null); } } } /** * Inserta un registro en la base de datos. * * @param pClassName Nombre de la clase que maneja la persistencia de una * tabla. * @param pBean Bean a insertar. * * @throws Exception */ public static void save(String pClassName, TransportBean pBean) throws Exception { Session s = Helper.getSession(); Object id = BeanManager.getBeanAttributeValue(pBean, "pk"); if ((id instanceof ManejaHistory) && (pBean instanceof AbstractExpire)) { s.evict(pBean); Timestamp t = ApplicationDates.getDBTimestamp(); BeanManager.setBeanAttributeValue(pBean, Helper.FDESDE, t); t = ApplicationDates.DEFAULT_EXPIRY_TIMESTAMP; BeanManager.setBeanAttributeValue(pBean, Helper.FHASTA, t); } Helper.completeCompany(pBean); Helper.manageIdTables(pBean); if (Helper.getContext() == null) { s.save(pClassName, pBean); } else { s.persist(pClassName, pBean); } LOGGER.debug("Save ejecutado desde " + CallerFinder.getCallerName() + " " + pClassName + " " + pBean); } public static void save(TransportBean pBean) throws Exception { Session s = Helper.getSession(); Object id = BeanManager.getBeanAttributeValue(pBean, "pk"); if ((id instanceof ManejaHistory) && (pBean instanceof AbstractExpire)) { s.evict(pBean); Timestamp t = ApplicationDates.getDBTimestamp(); BeanManager.setBeanAttributeValue(pBean, Helper.FDESDE, t); t = ApplicationDates.DEFAULT_EXPIRY_TIMESTAMP; BeanManager.setBeanAttributeValue(pBean, Helper.FHASTA, t); } Helper.completeCompany(pBean); Helper.manageIdTables(pBean); s.save(pBean); LOGGER.debug("Save ejecutado desde " + CallerFinder.getCallerName() + " " + pBean.getClass().getName() + " " + pBean); } /** * Actualiza o inserta un registro en la base de datos. * * @param pClassName Nombre de la clase que maneja la persistencia de una * tabla. * @param pBean Bean a actualiar o insertar. * * @throws Exception */ public static void saveOrUpdate(String pClassName, TransportBean pBean) throws Exception { Session s = Helper.getSession(); TransportBean bean = Helper.manageHistory(pBean); if (bean != null) { Helper.completeCompany(pBean); Helper.manageIdTables(pBean); if (Helper.getContext() == null) { s.saveOrUpdate(pClassName, bean); } else { s.persist(pClassName, bean); } LOGGER.debug("SaveOrUpdate ejecutado desde " + CallerFinder. getCallerName() + " " + pClassName + " " + pBean); } } /** * Actualiza o inserta un registro en la base de datos. * * @param pBean Bean a actualiar o insertar. * * @throws Exception */ public static void saveOrUpdate(TransportBean pBean) throws Exception { Session s = Helper.getSession(); TransportBean bean = Helper.manageHistory(pBean); if (bean != null) { Helper.completeCompany(pBean); Helper.manageIdTables(pBean); if (Helper.getContext() == null) { s.saveOrUpdate(bean); } else { s.persist(bean); } LOGGER.debug("SaveOrUpdate ejecutado desde " + CallerFinder. getCallerName() + " " + pBean.getClass().getName() + " " + pBean); } } /** * Fija una session de hibernate. * * @param session */ public static void setAuxiliarSession(Session session) { Session currentAuxSession = Helper.threadAuxiliarSession.get(); if (currentAuxSession != null && currentAuxSession.isOpen()) { LOGGER.warn("Usando sesión auxiliar actual, cerrando la nueva sesión auxiliar"); session.close(); Helper.threadAuxiliarSession.set(currentAuxSession); } else { Helper.threadAuxiliarSession.set(session); } } public static void setContext(Object pCtx) { Helper.context.set(pCtx); } /** * Fija una session de hibernate. * * @param session */ public static void setSession(Session session) { Session currentSession = Helper.threadSession.get(); if (currentSession != null && currentSession.isOpen()) { LOGGER.warn("Usando sesión actual, cerrando la nueva sesión, " + "llamado desde " + CallerFinder.getCallerName()); session.close(); HbSession.getInstance().updateStatsValue(HbSession.CLOSED); Helper.threadSession.set(currentSession); } else { Helper.threadSession.set(session); } } /** * Actualiza un registro en la base de datos. * * @param pClassName Nombre de la clase que maneja la persistencia de una * tabla. * @param pBean Bean a actualiar. * * @throws Exception */ public static void update(String pClassName, TransportBean pBean) throws Exception { update(pClassName, pBean, null); } /** * Actualiza un registro en la base de datos. * * @param pClassName Nombre de la clase que maneja la persistencia de una * tabla. * @param pBean Bean a actualiar. * * @throws Exception */ public static void update(String pClassName, TransportBean pBean, AbstractExpire old) throws Exception { Session s = Helper.getSession(); TransportBean bean = Helper.manageHistory(pBean, old); if (bean != null) { if (Helper.getContext() == null) { s.update(pClassName, bean); } else { s.persist(pClassName, bean); } LOGGER.debug("Update ejecutado desde " + CallerFinder.getCallerName() + " " + pClassName + " " + pBean); } } /** * Metodo que agrega identificadores de una sesion, para procesos de trazabilidad * * @param session Sesion de base de datos * @param clientIdentifier Identificador del cliente * @param clientInfo Informacion del cliente conectado * @param module Modulo usado en la operacion * @param action Accion realizada */ public static void setSessionInfo(Session session, String clientIdentifier, String clientInfo, String module, String action) { if (!developerMode) { SessionFactoryImpl imp = (SessionFactoryImpl) session.getSessionFactory(); Dialect dialect = imp.getDialect(); if (!dialect.getClass().getSimpleName().startsWith("Oracle")) { LOGGER.warn("No se pueden establecer parametros de sesion a una sesion diferente de oracle"); return; } //Verificar que ningun campo este con valores nulos, en cuyo caso, poner un default //TODO: Cuando usemos commons-lang>=2.6, cambiar por StringUtils.defaultIsBlank clientIdentifier = StringUtils.defaultString(clientIdentifier, "Fitvank-V2.0"); clientInfo = StringUtils.defaultString(clientInfo, Thread.currentThread().getName()); module = StringUtils.defaultString(module, Thread.currentThread().getName()); action = StringUtils.defaultString(action, Thread.currentThread().getName()); try { Connection conn = ((SessionImpl) session).connection(); //Informacion del cliente que genera la accion CallableStatement cs = conn.prepareCall("{ call dbms_session.set_identifier(?) } "); cs.setString(1, clientIdentifier); cs.execute(); cs.close(); //Informacion del cliente que genera la accion como extra cs = conn.prepareCall("{ call dbms_application_info.set_client_info(?) } "); cs.setString(1, clientInfo); cs.execute(); cs.close(); //Informacion del modulo y la accion usada cs = conn.prepareCall("{ call sys.dbms_application_info.set_module(?, ?) }"); cs.setString(1, module); cs.setString(2, action); cs.execute(); cs.close(); } catch (SQLException e) { LOGGER.error("Problemas al agregar informacion de la sesion", e); } } } /** * Metodo que agrega identificadores de una sesion, para procesos de trazabilidad * * @param clientIdentifier Identificador del cliente * @param clientInfo Informacion del cliente conectado * @param module Modulo usado en la operacion * @param action Accion realizada */ public static void setSessionInfo(String clientIdentifier, String clientInfo, String module, String action) { Session session = null; try { session = Helper.getSession(); } catch (FitbankException fe) { //Esto indica que no existe aún una sesión abierta. //En este caso, aun no podemos establecer datos en la misma, se omite } if (session != null) { Helper.setSessionInfo(session, clientIdentifier, clientInfo, module, action); } } /** * Metodo que agrega identificadores de una sesion, para procesos de trazabilidad * * @param clientInfo Informacion del cliente conectado * @param module Modulo usado en la operacion * @param action Accion realizada */ public static void setSessionInfo(String clientInfo, String module, String action) { Helper.setSessionInfo(clientInfo, clientInfo, module, action); } /** * Metodo que agrega identificadores de una sesion, para procesos de trazabilidad * * @param module Modulo usado en la operacion * @param action Accion realizada */ public static void setSessionInfo(String module, String action) { Helper.setSessionInfo("Fitbank-V2.0", Thread.currentThread().getName(), module, action); } /** * Metodo que agrega identificadores de una sesion, para procesos de trazabilidad. * Se usa el detail del RequestData, en caso de haberlo. * @param detail Mensaje de entrada de la sesion en curso */ public static void setSessionInfo(Detail detail) { if (Helper.threadTraced.get() == null || !Helper.threadTraced.get()) { if (detail != null) { Helper.setSessionInfo(detail.getUser(), detail.getMessageId(), detail.getIpaddress(), detail.getSubsystem() .concat(detail.getTransaction())); Helper.threadTraced.set(Boolean.TRUE); } else { Helper.setSessionInfo("Fitbank-V2.0", Thread.currentThread().getName(), Thread.currentThread().getName(), Thread.currentThread().getName()); } } } /** * Metodo que agrega identificadores de una sesion, para procesos de trazabilidad. * Se usa el detail del RequestData, en caso de haberlo. */ public static void setSessionInfo() { Detail detail = RequestData.getDetail(); Helper.setSessionInfo(detail); } /** * Actualiza un registro en la base de datos. * * @param pBean Bean a actualiar. * * @throws Exception */ public static void update(TransportBean pBean) throws Exception { update(pBean, null); } /** * Actualiza un registro en la base de datos. * * @param pBean Bean a actualiar. * * @throws Exception */ public static void update(TransportBean pBean, AbstractExpire old) throws Exception { Session s = Helper.getSession(); TransportBean bean = Helper.manageHistory(pBean, old); if (bean != null) { if (Helper.getContext() == null) { s.update(bean); } else { s.persist(bean); } LOGGER.debug("Update ejecudado desde " + CallerFinder. getCallerName() + " " + pBean.getClass().getName() + " " + pBean); } } }