it.cnr.contab.missioni00.comp.AnticipoComponent Maven / Gradle / Ivy
/*
* Copyright (C) 2019 Consiglio Nazionale delle Ricerche
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see Configurazione_cnrComponentSession
* che serve per leggere i parametri di configurazione del CNR
*/
private Configurazione_cnrComponentSession createConfigurazioneCnrComponentSession() throws ComponentException
{
try
{
return (Configurazione_cnrComponentSession)EJBCommonServices.createEJB("CNRCONFIG00_EJB_Configurazione_cnrComponentSession");
}
catch ( Exception e )
{
throw handleException( e ) ;
}
}
/**
* Cancellazione logica anticipo
*
* Pre-post-conditions:
*
* Nome: cancellazione logica anticipo
* Pre: L'utente ha selezionato elimina anticipo
* Post: Il sistema cancella logicamente l' anticipo e se l'anticipo risulta
* contabilizzato in Coge/Coan riporto i relativi stati ad "R"
*
* @param userContext lo UserContext che ha generato la richiesta
* @param bulk l' AnticipoBulk da cancellare
*
*/
private void deleteLogically(UserContext userContext,AnticipoBulk anticipo) throws ComponentException
{
try
{
anticipo.setToBeUpdated();
// ************
// Se l'esercizio di scrivania e' diverso da quello solare
// inizializzo la data di cancellazione al 31/12/esercizio anticipo
java.sql.Timestamp tsOdierno = ((AnticipoHome) getHome(userContext, anticipo)).getServerDate();
GregorianCalendar tsOdiernoGregorian = (GregorianCalendar) anticipo.getGregorianCalendar(tsOdierno);
java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("dd/MM/yyyy");
if(tsOdiernoGregorian.get(GregorianCalendar.YEAR) != it.cnr.contab.utenze00.bp.CNRUserContext.getEsercizio(userContext).intValue())
anticipo.setDt_cancellazione(new java.sql.Timestamp(sdf.parse("31/12/"+anticipo.getEsercizio().intValue()).getTime()));
else
{
String currentDate = Integer.toString(tsOdiernoGregorian.get(GregorianCalendar.DAY_OF_MONTH)) + "/" +
Integer.toString(tsOdiernoGregorian.get(GregorianCalendar.MONTH)) + "/" +
Integer.toString(tsOdiernoGregorian.get(GregorianCalendar.YEAR));
anticipo.setDt_cancellazione(new java.sql.Timestamp(sdf.parse(currentDate).getTime()));
}
// ************
anticipo.setStato_cofi(AnticipoBulk.STATO_ANNULLATO);
if(AnticipoBulk.STATO_CONTABILIZZATO_COAN.equals(anticipo.getStato_coan()))
anticipo.setStato_coan(AnticipoBulk.STATO_RICONTABILIZZARE_COAN);
if(AnticipoBulk.STATO_CONTABILIZZATO_COGE.equals(anticipo.getStato_coge()))
anticipo.setStato_coge(AnticipoBulk.STATO_RICONTABILIZZARE_COGE);
updateBulk(userContext, anticipo);
}
catch (Throwable e)
{
throw handleException(e);
}
}
/**
* Cancellazione anticipo
*
* Pre-post-conditions:
*
* Nome: cancellazione anticipo
* Pre: L'utente vuole eliminare un anticipo
* Post: Il sistema scollega la scadenza di obbligazione dell'anticipo azzerandone
* l'importo associato a documento amministrativo
*
* Nome: cancellazione fisica anticipo
* Pre: L'utente vuole eliminare un anticipo non associato a mandato, non contabilizzato in Coge/Coan e
* la cui obbligazione non e' stata riportata
* Post: Il sistema consente l'eliminazione fisica dell'anticipo
*
* Nome: cancellazione logica anticipo
* Pre: L'utente vuole eliminare un anticipo o associato a mandato o contabilizzato in Coge/Coan o la cui
* obbligazione e' stata riportata
* Post: Il sistema consente l'eliminazione logica dell'anticipo
*
* @param userContext lo UserContext che ha generato la richiesta
* @param bulk l' AnticipoBulk da cancellare
*
*/
public void eliminaConBulk (UserContext aUC,OggettoBulk bulk) throws ComponentException
{
AnticipoBulk anticipo = (AnticipoBulk)bulk;
try
{
// Controllo dello stato dell'es COEP prec. per compensi riportati Da ese. prec. (isRiportataInScrivania())
validateEsercizioCOEP(aUC, anticipo);
// Salvo temporaneamente l'hash map dei saldi
PrimaryKeyHashMap aTempDiffSaldi=new PrimaryKeyHashMap();
if (anticipo.getDefferredSaldi() != null)
aTempDiffSaldi=(PrimaryKeyHashMap)anticipo.getDefferredSaldi().clone();
// Scollego la scadenza di obbligazione dell'anticipo
Obbligazione_scadenzarioBulk scadenza = anticipo.getScadenza_obbligazione();
if(scadenza !=null)
{
scadenza.setIm_associato_doc_amm(new BigDecimal(0));
updateImportoAssociatoDocAmm(aUC, scadenza);
}
// Cancello logicamente/fisicamente l'anticipo
if( anticipo.STATO_INIZIALE_MANREV.equals(anticipo.getTi_associato_manrev()) &&
anticipo.STATO_INIZIALE_COGE.equals(anticipo.getStato_coge()) &&
anticipo.STATO_INIZIALE_COAN.equals(anticipo.getStato_coan()) &&
!anticipo.isRiportata())
super.eliminaConBulk(aUC, anticipo);
else
deleteLogically(aUC, anticipo);
// Restore dell'hash map dei saldi
if (anticipo.getDefferredSaldi() != null)
anticipo.getDefferredSaldi().putAll(aTempDiffSaldi);
aggiornaCogeCoanDocAmm(aUC, anticipo);
if (!verificaStatoEsercizio(aUC, new it.cnr.contab.config00.esercizio.bulk.EsercizioBulk( anticipo.getCd_cds(), ((it.cnr.contab.utenze00.bp.CNRUserContext)aUC).getEsercizio())))
throw new it.cnr.jada.comp.ApplicationException("Impossibile eliminare un documento per un esercizio non aperto!");
}
catch (Throwable e)
{
throw handleException(e);
}
}
/**
* Carica i dati relativi al cambio
*
* Pre-post-conditions:
*
* Nome: Carica cambio
* Pre: E' stata generata una richiesta di caricamento di un cambio associato ad una certa divisa e valido
* in una certa data
* Post: Il sistema restituisce il cambio valido per la divisa data
*
* @param uc lo UserContext che ha generato la richiesta
* @param divisa la DivisaBulk per cui ricercare il cambio
* @param dataCambio la data per cui il cambio deve essere valido
*
* @return il CambioBulk trovato oppure null se non esiste nessun cambio valido per quella divisa in quella data
*/
private CambioBulk findCambio(UserContext uc, DivisaBulk divisa, java.sql.Timestamp dataCambio) throws ComponentException, it.cnr.jada.persistency.PersistencyException
{
CambioHome cambioHome = (CambioHome)getHome(uc, CambioBulk.class);
CambioBulk aCambio = cambioHome.getCambio(divisa, dataCambio);
if(aCambio == null)
return null;
return aCambio;
}
/**
* Carica i dati relativi alla divisa di default
*
* Pre-post-conditions:
*
* Nome: Carica divisa
* Pre: E' stata generata una richiesta di caricamento della divisa di default (EURO)
* Post: Il sistema restituisce la divisa di default
*
* @param uc lo UserContext che ha generato la richiesta
*
* @return la DivisaBulk di default oppure null se non esiste nessuna divisa di default
*/
private DivisaBulk findDivisaDefault(UserContext aUC) throws it.cnr.jada.comp.ComponentException, javax.ejb.EJBException, it.cnr.jada.persistency.PersistencyException, RemoteException
{
DivisaHome divisaHome = (DivisaHome)getHome(aUC, DivisaBulk.class);
DivisaBulk divisaDefault = divisaHome.getDivisaDefault(aUC);
return divisaDefault;
}
/**
* Carica i dati relativi alle coordinate bancarie
*
* Pre-post-conditions:
*
* Nome: Carica banche
* Pre: E' stata generata una richiesta di caricamento delle coordinate bancarie relative al terzo dell'anticipo
* Post: Il sistema restituisce la lista delle coordinate bancarie relative al terzo dell'anticipo
*
* @param uc lo UserContext che ha generato la richiesta
* @param anticipo l' AnticipoBulk da cui ricavare il terzo per cui selezionare le coordinate bancarie
*
* @return la collezione di istanze di tipo BancaBulk
*/
public java.util.Collection findListabanche(UserContext aUC, AnticipoBulk anticipo) throws ComponentException,it.cnr.jada.persistency.PersistencyException
{
if(anticipo.getV_terzo() == null)
return null;
return getHome(aUC, BancaBulk.class).fetchAll(selectBancaByClause(aUC, anticipo, null, null));
}
/**
* Carica i dati relativi alle modalità di pagamento
*
* Pre-post-conditions:
*
* Nome: Carica modalita
* Pre: E' stata generata una richiesta di caricamento delle modalità di pagamento relative al terzo dell'anticipo
* Post: Il sistema restituisce la lista delle modalità di pagamento relative al terzo dell'anticipo
*
* @param uc lo UserContext che ha generato la richiesta
* @param bulk l' AnticipoBulk da cui ricavare il terzo per cui selezionare le modalità di pagamento
*
* @return la collezione di istanze di tipo Rif_modalita_pagamentoBulk
*/
public java.util.Collection findModalita(UserContext userContext, OggettoBulk bulk) throws ComponentException
{
try
{
AnticipoBulk anticipo = (AnticipoBulk) bulk;
if((anticipo.getTerzo() == null))
return null;
TerzoHome terzoHome = (TerzoHome)getHome(userContext,TerzoBulk.class);
return terzoHome.findRif_modalita_pagamento(anticipo.getTerzo());
}
catch (it.cnr.jada.persistency.PersistencyException ex)
{
throw handleException(bulk, ex);
}
catch (it.cnr.jada.persistency.IntrospectionException ex)
{
throw handleException(bulk, ex);
}
}
/**
* Carica i dati relativi ai termini di pagamento
*
* Pre-post-conditions:
*
* Nome: Carica termini
* Pre: E' stata generata una richiesta di caricamento dei termini di pagamento relativi al terzo dell'anticipo
* Post: Il sistema restituisce la lista dei termini di pagamento relativi al terzo dell'anticipo
*
* @param uc lo UserContext che ha generato la richiesta
* @param bulk l' AnticipoBulk da cui ricavare il terzo per cui selezionare i termini di pagamento
*
* @return la collezione di istanze di tipo Rif_termini_pagamentoBulk
*/
public java.util.Collection findTermini(UserContext userContext, OggettoBulk bulk) throws ComponentException
{
try
{
AnticipoBulk anticipo = (AnticipoBulk) bulk;
if((anticipo.getTerzo() == null))
return null;
TerzoHome terzoHome = (TerzoHome)getHome(userContext,TerzoBulk.class);
return terzoHome.findRif_termini_pagamento(anticipo.getTerzo());
}
catch (it.cnr.jada.persistency.PersistencyException ex)
{
throw handleException(bulk, ex);
}
catch (it.cnr.jada.persistency.IntrospectionException ex)
{
throw handleException(bulk, ex);
}
}
/**
* Cambio data data registrazione
*
* Pre-post-conditions:
*
* Nome: cambio data - ok
* Pre: L'utente ha modificato la data di registrazione dell'anticipo
* La nuova data supera la validazione ( metodo 'validaDataRegistrazione')
* Post: Il sistema inizializza la divisa di default e il cambio relativo a
* tale divisa e valido alla data di registrazione
*
* Nome: cambio data - errore
* Pre: L'utente ha modificato la data di registrazione dell'anticipo
* La nuova data non supera la validazione ( metodo 'validaDataRegistrazione')
* Post: Il sistema segnala all'utente che la nuova data non ha superato la validazione
*
* @param aUC lo UserContext che ha generato la richiesta
* @param anticipo l' AnticipoBulk per cui gestire la nuova data di registrazioen
*
* @return l'AnticipoBulk con caricato il cambio relativo alla divisa per la nuova data di registrazione
*/
public AnticipoBulk gestisciCambioDataRegistrazione(UserContext aUC, AnticipoBulk anticipo) throws ComponentException, it.cnr.jada.persistency.PersistencyException, java.sql.SQLException
{
// Verifico l'eleggibilita della data di registrazione
validaDataRegistrazione(aUC, anticipo );
try
{
if(anticipo.getCd_divisa() == null)
anticipo.setDivisa(findDivisaDefault(aUC));
}
catch ( RemoteException e )
{
throw handleException(anticipo, e);
}
catch ( javax.ejb.EJBException e )
{
throw handleException(anticipo, e);
}
// Ricerco il cambio alla data
CambioBulk cambio = findCambio(aUC, anticipo.getDivisa(), anticipo.getDt_registrazione());
if(cambio != null)
anticipo.setCambio(cambio.getCambio());
return anticipo;
}
/**
* Pre: L'esercizio di scrivania è antecedente a quello corrente
* Post: La data restituita viene inizializzata al 31/12/esercizio scrivania
*
* Pre: L'esercizio di scrivania NON è antecedente a quello corrente
* Post: La data restituita viene inizializzata alla data odierna
*
* @param aUC lo UserContext che ha generato la richiesta
* @param bulk L' AnticipoBulk la cui data deve essere inizializzata.
*
* @return La data correttamente inizializzata
*/
private Timestamp getDataPerInizializzazioni(UserContext userContext,OggettoBulk bulk) throws ComponentException, it.cnr.jada.persistency.PersistencyException, java.text.ParseException
{
AnticipoBulk anticipo = (AnticipoBulk) bulk;
java.sql.Timestamp tsOdierno = ((AnticipoHome) getHome(userContext, anticipo)).getServerDate();
java.util.GregorianCalendar tsOdiernoGregorian = anticipo.getGregorianCalendar(tsOdierno);
if (tsOdiernoGregorian.get(java.util.GregorianCalendar.YEAR) > anticipo.getEsercizio().intValue())
{
java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("dd/MM/yyyy");
return(new java.sql.Timestamp(sdf.parse("31/12/"+anticipo.getEsercizio().intValue()).getTime()));
}
return tsOdierno;
}
private it.cnr.jada.bulk.PrimaryKeyHashtable getDocumentiContabiliNonTemporanei(
UserContext userContext,
java.util.Enumeration scadenze) throws ComponentException {
it.cnr.jada.bulk.PrimaryKeyHashtable documentiContabiliNonTemporanei = new it.cnr.jada.bulk.PrimaryKeyHashtable();
if (scadenze != null)
while (scadenze.hasMoreElements()) {
IScadenzaDocumentoContabileBulk scadenza = (IScadenzaDocumentoContabileBulk)scadenze.nextElement();
if (!scadenza.getFather().isTemporaneo()) {
if (!documentiContabiliNonTemporanei.containsKey(scadenza.getFather())) {
Vector allInstances = new java.util.Vector();
allInstances.addElement(scadenza.getFather());
documentiContabiliNonTemporanei.put(scadenza.getFather(), allInstances);
} else {
((Vector)documentiContabiliNonTemporanei.get(scadenza.getFather())).add(scadenza.getFather());
}
}
}
return documentiContabiliNonTemporanei;
}
/**
* Pre: Il sistema carica in modifica un anticipo con obbligazione riportata all'esercizio successivo
* Post: Viene restituita la stringa 'R'
*
* Pre: Il sistema carica in modifica un anticipo con obbligazione non riportata all'esercizio successivo
* Post: Viene restituita la stringa 'N'
*
* @param aUC lo UserContext che ha generato la richiesta
* @param bulk L' AnticipoBulk caricato in modifica.
*
* @return Lo stato del documento contabile associato all'anticipo
*/
private String getStatoRiporto(UserContext context, AnticipoBulk anticipo)throws ComponentException
{
try
{
RiportoDocAmmComponentSession session = (RiportoDocAmmComponentSession)it.cnr.jada.util.ejb.EJBCommonServices.createEJB("CNRDOCAMM00_EJB_RiportoDocAmmComponentSession",RiportoDocAmmComponentSession.class);
return session.getStatoRiporto(context, anticipo);
}
catch (Throwable t)
{
throw handleException(anticipo, t);
}
}
/**
* Pre: Il sistema carica in modifica un anticipo con una obbligazione riportata all'esercizio di scrivania
* Post: Viene restituita la stringa 'R'
*
* Pre: Il sistema carica in modifica un anticipo con nessuna obbligazione riportata all'esercizio di scrivania
* Post: Viene restituita la stringa 'N'
*
* @param aUC lo UserContext che ha generato la richiesta
* @param bulk L' AnticipoBulk caricato in modifica.
*
* @return Lo stato del documento contabile associato all'anticipo
*/
private String getStatoRiportoInScrivania(UserContext context, AnticipoBulk anticipo)throws ComponentException
{
try
{
RiportoDocAmmComponentSession session = (RiportoDocAmmComponentSession)it.cnr.jada.util.ejb.EJBCommonServices.createEJB("CNRDOCAMM00_EJB_RiportoDocAmmComponentSession",RiportoDocAmmComponentSession.class);
return session.getStatoRiportoInScrivania(context, anticipo);
}
catch (Throwable t)
{
throw handleException(anticipo, t);
}
}
/**
* Pre: Il sistema carica in modifica unrimborso con accertamento riportato all'esercizio successivo
* Post: La procedura restitusce la stringa 'R'
*
* Pre: Il sistema carica in modifica un rimborso con accertamento non riportato all'esercizio successivo
* Post: La procedura restitusce la stringa 'N'
*
* @param aUC lo UserContext che ha generato la richiesta
* @param bulk il RimborsoBulk caricato in modifica.
*
* @return Lo stato del documento contabile associato al rimborso
*/
private String getStatoRiportoRimborso(UserContext context, RimborsoBulk rimborso)throws ComponentException
{
LoggableStatement cs = null;
String status = null;
try
{
try
{
cs = new LoggableStatement(getConnection(context),
"{ ? = call " +
it.cnr.jada.util.ejb.EJBCommonServices.getDefaultSchema() +
"CNRCTB105.getStatoRiportato(?, ?, ?, ?, ?, ?) }",false,this.getClass());
cs.registerOutParameter( 1, java.sql.Types.VARCHAR);
cs.setString(2, rimborso.getCd_cds());
cs.setString(3, rimborso.getCd_unita_organizzativa());
cs.setInt(4, rimborso.getEsercizio().intValue());
cs.setLong(5, rimborso.getPg_rimborso().longValue());
cs.setString(6, Numerazione_doc_ammBulk.TIPO_RIMBORSO);
cs.setInt(7, it.cnr.contab.utenze00.bp.CNRUserContext.getEsercizio(context).intValue());
cs.executeQuery();
status = new String(cs.getString(1));
} catch (Throwable e) {
throw handleException(e);
} finally {
if (cs != null) cs.close();
}
}
catch (java.sql.SQLException ex)
{
throw handleException(ex);
}
return status;
}
/**
* Pre: Il sistema carica in modifica unrimborso con accertamento riportato all'esercizio successivo
* Post: La procedura restitusce la stringa 'R'
*
* Pre: Il sistema carica in modifica un rimborso con accertamento non riportato all'esercizio successivo
* Post: La procedura restitusce la stringa 'N'
*
* @param aUC lo UserContext che ha generato la richiesta
* @param bulk il RimborsoBulk caricato in modifica.
*
* @return Lo stato del documento contabile associato al rimborso
*/
private String getStatoRiportoRimborsoInScrivania(UserContext context, RimborsoBulk rimborso)throws ComponentException
{
LoggableStatement cs = null;
String status = null;
try
{
try
{
cs = new LoggableStatement(getConnection(context),
"{ ? = call " +
it.cnr.jada.util.ejb.EJBCommonServices.getDefaultSchema() +
"CNRCTB105.getStatoRiportatoInScrivania(?, ?, ?, ?, ?, ?) }",false,this.getClass());
cs.registerOutParameter( 1, java.sql.Types.VARCHAR);
cs.setString(2, rimborso.getCd_cds());
cs.setString(3, rimborso.getCd_unita_organizzativa());
cs.setInt(4, rimborso.getEsercizio().intValue());
cs.setLong(5, rimborso.getPg_rimborso().longValue());
cs.setString(6, Numerazione_doc_ammBulk.TIPO_RIMBORSO);
cs.setInt(7, it.cnr.contab.utenze00.bp.CNRUserContext.getEsercizio(context).intValue());
cs.executeQuery();
status = new String(cs.getString(1));
} catch (Throwable e) {
throw handleException(e);
} finally {
if (cs != null) cs.close();
}
}
catch (java.sql.SQLException ex)
{
throw handleException(ex);
}
return status;
}
/**
* Tipo di Cancellazione
*
* Pre-post-conditions:
*
* Nome: Tipo di Cancellazione
* Pre: L'utente ha richiesto la cancellazione dell'anticipo
* Post: Il sistema richiama la stored procedure che stabilisce se la cancellazione
* dell'anticipo deve essere logica o fisica
*
* @param userContext lo UserContext che ha generato la richiesta
* @param missione l' AnticipoBulk da cancellare
*
* @return il tipo di cancellazione (NULL = non cancellabile; F = cancellazione
* fisica; L = cancellazione logica)
*/
private Character getTipoCancellazione (UserContext aUC, OggettoBulk bulk) throws ComponentException
{
AnticipoBulk anticipo = (AnticipoBulk)bulk;
Character rc = null;
LoggableStatement cs = null ;
try
{
try
{
cs = new LoggableStatement(getConnection(aUC), "{call "+it.cnr.jada.util.ejb.EJBCommonServices.getDefaultSchema()+"CNRCTB505.eseguiDelMissione(?,?,?,?,?)}",false,this.getClass());
cs.setObject( 1, anticipo.getCd_cds() );
cs.setObject( 2, anticipo.getCd_unita_organizzativa() );
cs.setObject( 3, anticipo.getEsercizio() );
cs.setObject( 4, anticipo.getPg_anticipo() );
cs.setNull( 5, java.sql.Types.CHAR);
cs.registerOutParameter(5,java.sql.Types.CHAR);
cs.executeQuery();
rc = (Character)cs.getObject(5);
}
finally
{
cs.close();
}
return rc;
}
catch (java.sql.SQLException e)
{
throw handleException(anticipo, e);
}
}
/**
* Inizializzazione dell'anticipo per la creazione
*
* Esercizio non aperto
* PreCondition: L'esercizio di scrivania e' in uno stato diverso da APERTO
* PostCondition: Il metodo utilizza un Throw Exception per comunicare che non e' possibile creare missioni.
*
* Esercizio aperto
* PreCondition: L'esercizio di scrivania e' in stato APERTO
* PostCondition: e' possibile procedere con la creazione dell' anticipo
*
* Inizializzazione data registrazione e data competenza coge da/a
* PreCondition: Inizializzazione della data registrazione e della data competenza coge da/a
* PostCondition: Il sistema inizializza la data registrazione e la data competenza coge da/a
*
* @param aUC lo user context
* @param bulk l'istanza di AnticipoBulk che si sta creando
* @return l'istanza di AnticipoBulk
*
**/
public OggettoBulk inizializzaBulkPerInserimento (UserContext aUC,OggettoBulk bulk) throws ComponentException
{
AnticipoBulk anticipo = (AnticipoBulk) bulk;
try
{
// Verifico che l'esercizio dell'anticipo (scrivania) sia aperto
if (!verificaStatoEsercizio(aUC, new it.cnr.contab.config00.esercizio.bulk.EsercizioBulk( anticipo.getCd_cds(), ((it.cnr.contab.utenze00.bp.CNRUserContext)aUC).getEsercizio())))
throw new it.cnr.jada.comp.ApplicationException("Impossibile inserire un anticipo per un esercizio non aperto!");
// Inizializzazione e controlli della data di registrazione
anticipo.setDt_registrazione(getDataPerInizializzazioni(aUC, bulk));
anticipo.setDt_a_competenza_coge(anticipo.getDt_registrazione());
anticipo.setDt_da_competenza_coge(anticipo.getDt_registrazione());
gestisciCambioDataRegistrazione(aUC, anticipo);
return super.inizializzaBulkPerInserimento(aUC, anticipo );
}
catch (Throwable e)
{
throw handleException(e);
}
}
/**
* Inizializzazione dell'anticipo per la modifica
*
* Pre-post-conditions:
*
* Nome: esercizio non valorizzato
* Pre: L'anticipo da caricare non ha valorizzato l'esercizio
* Post: Il metodo utilizza un Throw Exception per comunicare che non e' possibile procedere.
*
* Nome: esercizio anticipo maggiore di quello di scrivania
* Pre: L'utente ha selezionato un anticipo con esercizio maggiore a quello di scrivania
* Post: Il metodo utilizza un Throw Exception per comunicare che non e' possibile procedere.
*
* Nome: inizializzazione anticipo
* Pre: inizializzazione anticipo per modifica
* Post: Il sistema inizializza l'anticipo con i dati relativi al terzo, all'eventuale rimborso e missione collegata
* e verifica se il documento contabile associato all'anticipo e' stato riportato
*
* @param aUC lo UserContext che ha generato la richiesta
* @param bulk l' AnticipoBulk da inizializzare
*
* @return l'AnticipoBulk inizializzato
*/
public OggettoBulk inizializzaBulkPerModifica(UserContext userContext,OggettoBulk bulk) throws ComponentException
{
if(bulk == null)
return null;
AnticipoBulk anticipo = (AnticipoBulk) bulk;
try
{
if (anticipo.getEsercizio() == null)
throw new it.cnr.jada.comp.ApplicationException("L'esercizio del documento non è valorizzato! Impossibile proseguire.");
if (anticipo.getEsercizio().intValue() > it.cnr.contab.utenze00.bp.CNRUserContext.getEsercizio(userContext).intValue())
throw new it.cnr.jada.comp.ApplicationException("Il documento deve appartenere o all'esercizio di scrivania o ad esercizi precedenti per essere aperto in modifica!");
anticipo = (AnticipoBulk) super.inizializzaBulkPerModifica(userContext, anticipo);
caricaTerzoInModificaAnticipo(userContext, anticipo);
// Serve nella lettura delle scadenze eleggibili (per poter riselezionare la scadenza
// associata all' anticipo che si sta modificando)
if(anticipo.getScadenza_obbligazione() != null)
{
anticipo.setScadenza_obbligazioneClone(new Obbligazione_scadenzarioBulk());
anticipo.getScadenza_obbligazioneClone().setEsercizio_originale(anticipo.getEsercizio_ori_obbligazione());
anticipo.getScadenza_obbligazioneClone().setPg_obbligazione(anticipo.getPg_obbligazione());
anticipo.getScadenza_obbligazioneClone().setPg_obbligazione_scadenzario(anticipo.getPg_obbligazione_scadenzario());
anticipo.getScadenza_obbligazioneClone().setEsercizio(anticipo.getScadenza_obbligazione().getEsercizio());
anticipo.getScadenza_obbligazioneClone().setCd_cds(anticipo.getScadenza_obbligazione().getCd_cds());
}
// In base allo stato di riporto dell'obbligazione dell'anticipo
// inizializzo la variabile 'riportata' dell'anticipo
anticipo.setRiportata(getStatoRiporto(userContext, anticipo));
/**
* Gennaro Borriello - (02/11/2004 15.04.39)
* Aggiunta gestione dell Stato Riportato all'esercizio di scrivania.
*/
anticipo.setRiportataInScrivania(getStatoRiportoInScrivania(userContext, anticipo));
anticipo = inizializzaRimborso( userContext, anticipo );
if(anticipo.isAnticipoConMissione())
loadMissione(userContext, anticipo);
}
catch (Throwable e)
{
throw handleException(e);
}
return anticipo;
}
/**
* Inizializzazione rimborso
*
* Pre-post-conditions:
*
* Nome: Inizializzazione rimborso
* Pre: L'utente ha selezionato un anticipo per modificarlo. L'anticipo e' stato rimborsato
* Post: Il sistema verifica se il documento contabile associato al rimborso e' stato riportato o meno e
* restituisce l'anticipo con impostati tutti i dati relativi al rimborso
*
* @param aUC lo UserContext che ha generato la richiesta
* @param bulk l' AnticipoBulk da inizializzare
*
* @return l'AnticipoBulk inizializzato
*/
private AnticipoBulk inizializzaRimborso(UserContext userContext,AnticipoBulk anticipo) throws ComponentException
{
try
{
SQLBuilder sql = getHome( userContext, RimborsoBulk.class ).createSQLBuilder();
sql.addClause( "AND", "esercizio_anticipo", sql.EQUALS, anticipo.getEsercizio());
sql.addClause( "AND", "cd_cds_anticipo", sql.EQUALS, anticipo.getCd_cds());
sql.addClause( "AND", "cd_uo_anticipo", sql.EQUALS, anticipo.getCd_unita_organizzativa());
sql.addClause( "AND", "pg_anticipo", sql.EQUALS, anticipo.getPg_anticipo());
List result = getHome( userContext, RimborsoBulk.class ).fetchAll( sql );
if ( result.size() > 1 )
throw new ApplicationException("Attenzione esiste piu' di un rimborso associato all'anticipo");
if ( result.size() == 1 )
anticipo.setRimborso( (RimborsoBulk)result.get(0));
// In base allo stato di riporto dell'obbligazione dell'rimborso
// inizializzo la variabile 'riportata' del rimborso
if(anticipo.hasRimborso()){
anticipo.getRimborso().setRiportata(getStatoRiportoRimborso(userContext, anticipo.getRimborso()));
/**
* Gennaro Borriello - (02/11/2004 15.04.39)
* Aggiunta gestione dell Stato Riportato all'esercizio di scrivania.
*/
anticipo.getRimborso().setRiportataInScrivania(getStatoRiportoRimborsoInScrivania(userContext, anticipo.getRimborso()));
}
return anticipo;
}
catch (Throwable e)
{
throw handleException(e);
}
}
/**
* Verifica annullamento anticipo
*
* Pre-post-conditions
*
* Nome: Verifica stato_cofi anticipo
* Pre: Viene richiesto se l'anticipo e' annullato o meno
* Post: Il sistema esegue una query per verificare lo stato cofi dell'anticipo.
* stato_cofi = A --> il metodo ritorna (anticipo annullato)
* stato_cofi <> A --> il metodo ritorna (anticipo non annullato)
*
* @param userContext lo UserContext che ha generato la richiesta
* @param anticipo L'anticipo da controllare
* @return vero se l'anticipo è anullato falso altrimenti
*
**/
public boolean isAnticipoAnnullato(UserContext userContext, AnticipoBulk anticipo) throws ComponentException
{
try
{
java.sql.ResultSet rs;
String stato = null;
String str = "SELECT STATO_COFI FROM " +
it.cnr.jada.util.ejb.EJBCommonServices.getDefaultSchema() +
"ANTICIPO " +
"WHERE " +
"CD_CDS = ? AND " +
"CD_UNITA_ORGANIZZATIVA = ? AND " +
"ESERCIZIO = ? AND " +
"PG_ANTICIPO = ?";
LoggableStatement ps = new LoggableStatement(getConnection(userContext),str,true,this.getClass());
try
{
ps.setObject( 1, anticipo.getCd_cds());
ps.setObject( 2, anticipo.getCd_unita_organizzativa());
ps.setObject( 3, anticipo.getEsercizio());
ps.setObject( 4, anticipo.getPg_anticipo());
rs = ps.executeQuery();
try
{
if (rs.next() )
stato = rs.getString( 1 );
}
finally
{
try{rs.close();}catch( java.sql.SQLException e ){};
}
}
finally
{
try{ps.close();}catch( java.sql.SQLException e ){};
}
return(anticipo.STATO_ANNULLATO.equals(stato));
}
catch(java.sql.SQLException ex)
{
throw handleException(anticipo, ex);
}
}
/**
* Carica missione
*
* Pre-post-conditions:
*
* Nome: Carica missione
* Pre: Il sistema inizializza un anticipo legato a missione per la modifica
* Post: Il sistema esegue una query per caricare la missione
*
* Nome: Carica missione
* Pre: L'anticipo risulta legato a missione ma il sistema non trova la missione associata
* Post: Il metodo utilizza un Throw Exception per comunicare che non e' possibile procedere.
*
* @param userContext lo UserContext che ha generato la richiesta
* @param anticipo l' AnticipoBulk per cui caricare la missione
*
* @return l' AnticipoBulk con la missione caricata
*/
private AnticipoBulk loadMissione(UserContext userContext, AnticipoBulk anticipo) throws ComponentException
{
try
{
MissioneHome missioneHome = (MissioneHome)getHome( userContext, MissioneBulk.class );
MissioneBulk missione = missioneHome.loadMissione(userContext,anticipo);
anticipo.setMissione(missione);
if(missione == null)
throw new ApplicationException("Impossibile trovare la missione associata all' anticipo !");
}
catch (Throwable e)
{
throw handleException(e);
}
return anticipo;
}
/**
* Modifica l'anticipo
*
* Pre-post-conditions:
*
* Nome: Modifica anticipo
* Pre: L'utente ha completato le modifiche dei dati dell'anticipo e ne chiede il salvataggio
* Post: Il sistema rende persistente le modifiche dell'anticipo
*
* @param userContext lo UserContext che ha generato la richiesta
* @param bulk l'AnticipoBulk per cui e' stato richiesta la modifica
*
* @return l'AnticipoBulk salvato
*/
public OggettoBulk modificaConBulk(it.cnr.jada.UserContext userContext,OggettoBulk bulk) throws it.cnr.jada.comp.ComponentException
{
return modificaConBulk(userContext, bulk, null);
}
/**
* Modifica l'anticipo
*
* Pre-post-conditions:
*
* Nome: Validazione della scadenza di obbligazione associata all'anticipo
* Pre: La scadenza legata all'anticipo passa la validazione
* Post: Il sistema prosegue con la modifica dell'anticipo
*
* Nome: Modifica anticipo con obbligazione appena creata
* Pre: L'obbligazione associata all'anticipo modificato e' appena stata creata
* Post: Il sistema aggiorna l'obbligazione associata all'anticipo e i suoi saldi
*
* Nome: Modifica anticipo con obbligazione gia' esistente
* Pre: L'obbligazione associata all'anticipo modificato gia' esisteva
* Post: Il sistema aggiorna l'importo associato a documento amministrativo della relativa scadenza
*
* Nome: Modifica anticipo
* Pre: E' stata tolta l'associazione dell'anticipo con l'obbligazione originaria
* Post: Il sistema aggiorna tale obbligazione azzerando l'importo associato a documento amministrativo
* della relativa scadenza
*
* Nome: Modifica anticipo
* Pre: In fase di modifica dell'anticipo l'utente ha creato una obbligazione che poi non ha associato all'anticipo
* Post: Il sistema rende persistente tale obbligazione ed aggiorna i saldi
*
* Nome: Modifica anticipo
* Pre: Gli aggiornamenti delle obbligazioni e scadenze sono andati a buon fine
* Post: Il sistema rende persistente le modifiche dell'anticipo
*
* @param userContext lo UserContext che ha generato la richiesta
* @param bulk l'AnticipoBulk per cui e' stato richiesta la modifica
* @param status serve per gestire l'eccezione lanciata dall'obbligazione
* nel caso non ci sia disponibilita' di cassa
*
* @return l'AnticipoBulk salvato
*/
public OggettoBulk modificaConBulk(it.cnr.jada.UserContext userContext,OggettoBulk bulk, OptionRequestParameter status) throws it.cnr.jada.comp.ComponentException
{
AnticipoBulk anticipo = (AnticipoBulk)bulk;
// Salvo temporaneamente l'hash map dei saldi
PrimaryKeyHashMap aTempDiffSaldi=new PrimaryKeyHashMap();
aTempDiffSaldi=(PrimaryKeyHashMap)anticipo.getDefferredSaldi().clone();
validaObbligazione(userContext,anticipo.getScadenza_obbligazione(),anticipo);
aggiornaObbligazione(userContext, anticipo, status);
anticipo = (AnticipoBulk)super.modificaConBulk(userContext, anticipo);
// Restore dell'hash map dei saldi
if (anticipo.getDefferredSaldi() != null)
anticipo.getDefferredSaldi().putAll(aTempDiffSaldi);
//Aggiornamenti degli stati COGE e COAN
boolean aggiornaStatoCoge = false;
try {
AnticipoBulk anticipoDB = (AnticipoBulk)getTempHome(userContext, AnticipoBulk.class).findByPrimaryKey(anticipo);
if (!Utility.equalsNull(anticipo.getStato_pagamento_fondo_eco(),anticipoDB.getStato_pagamento_fondo_eco())||
!Utility.equalsNull(anticipo.getCd_terzo(),anticipoDB.getCd_terzo())||
!Utility.equalsNull(anticipo.getDt_da_competenza_coge(),anticipoDB.getDt_da_competenza_coge())||
!Utility.equalsNull(anticipo.getDt_a_competenza_coge(),anticipoDB.getDt_a_competenza_coge())||
!Utility.equalsNull(anticipo.getIm_anticipo_divisa(),anticipoDB.getIm_anticipo_divisa().setScale(2))||
!Utility.equalsNull(anticipo.getIm_anticipo(),anticipoDB.getIm_anticipo().setScale(2))||
!Utility.equalsBulkNull(anticipo.getScadenza_obbligazione(),anticipoDB.getScadenza_obbligazione())
)
aggiornaStatoCoge = true;
} catch (PersistencyException e) {
throw new ComponentException(e);
}
if (aggiornaStatoCoge){
if (AnticipoBulk.STATO_CONTABILIZZATO_COAN.equalsIgnoreCase(anticipo.getStato_coan())) {
anticipo.setStato_coan(AnticipoBulk.STATO_RICONTABILIZZARE_COAN);
anticipo.setToBeUpdated();
}
if (AnticipoBulk.STATO_CONTABILIZZATO_COGE.equalsIgnoreCase(anticipo.getStato_coge())) {
anticipo.setStato_coge(AnticipoBulk.STATO_RICONTABILIZZARE_COGE);
anticipo.setToBeUpdated();
}
}
// Aggiornamenti degli stati COGE e COAN sui rimborsi
boolean aggiornaStatoCogeRimborsi = false;
if (anticipo.getRimborso()!= null){
RimborsoBulk rimborso = anticipo.getRimborso();
try {
RimborsoBulk rimborsoDB = (RimborsoBulk)getTempHome(userContext, RimborsoBulk.class).findByPrimaryKey(rimborso);
if (!Utility.equalsNull(rimborso.getIm_rimborso(),rimborso.getIm_rimborso())||
!Utility.equalsNull(rimborso.getCd_terzo(),rimborsoDB.getCd_terzo())||
!Utility.equalsNull(rimborso.getDt_da_competenza_coge(),rimborsoDB.getDt_da_competenza_coge())||
!Utility.equalsNull(rimborso.getDt_a_competenza_coge(),rimborsoDB.getDt_a_competenza_coge())||
!Utility.equalsNull(rimborso.getEsercizio_accertamento(),rimborsoDB.getEsercizio_accertamento())||
!Utility.equalsNull(rimborso.getCd_cds_accertamento(),rimborsoDB.getCd_cds_accertamento())||
!Utility.equalsNull(rimborso.getPg_accertamento(),rimborsoDB.getPg_accertamento())||
!Utility.equalsNull(rimborso.getPg_accertamento_scadenzario(),rimborsoDB.getPg_accertamento_scadenzario())
)
aggiornaStatoCogeRimborsi = true;
} catch (PersistencyException e) {
throw new ComponentException(e);
}
if (aggiornaStatoCogeRimborsi){
if (AnticipoBulk.STATO_CONTABILIZZATO_COAN.equalsIgnoreCase(rimborso.getStato_coan())) {
rimborso.setStato_coan(AnticipoBulk.STATO_RICONTABILIZZARE_COAN);
anticipo.setToBeUpdated();
}
if (AnticipoBulk.STATO_CONTABILIZZATO_COGE.equalsIgnoreCase(rimborso.getStato_coge())) {
rimborso.setStato_coge(AnticipoBulk.STATO_RICONTABILIZZARE_COGE);
anticipo.setToBeUpdated();
}
}
}
if (!verificaStatoEsercizio(userContext, new it.cnr.contab.config00.esercizio.bulk.EsercizioBulk( anticipo.getCd_cds(), ((it.cnr.contab.utenze00.bp.CNRUserContext)userContext).getEsercizio())))
throw new it.cnr.jada.comp.ApplicationException("Impossibile salvare un documento per un esercizio non aperto!");
return anticipo;
}
/**
* Riporto ad esercizio successivo dell'accertamento
*
* Pre-post-conditions:
*
* Nome: Riporto ad esercizio successivo dell'accertamento del rimborso
* Pre: L'utente ha richiesto il riporto in avanti del documento contabile associato al rimborso
* Post: Il sistema chiama la procedura che gestisce il riporto in avanti
*
* @param userContext lo UserContext che ha generato la richiesta
* @param bulk l'AnticipoBulk rimborsato
*
* @return l'AnticipoBulk rimborsato
*/
public AnticipoBulk riportaRimborsoAvanti(UserContext userContext, AnticipoBulk anticipo) throws ComponentException
{
LoggableStatement cs = null;
try
{
cs = new LoggableStatement(getConnection(userContext),
"{ call " +
it.cnr.jada.util.ejb.EJBCommonServices.getDefaultSchema() +
"CNRCTB046.riportoEsNextDocAmm(?, ?, ?, ?, ?, ?, ?) }",false,this.getClass());
cs.setInt(1, it.cnr.contab.utenze00.bp.CNRUserContext.getEsercizio(userContext).intValue());
cs.setString(2, Numerazione_doc_ammBulk.TIPO_RIMBORSO);
cs.setString(3, anticipo.getRimborso().getCd_cds());
cs.setInt(4, anticipo.getRimborso().getEsercizio().intValue());
cs.setString(5, anticipo.getRimborso().getCd_unita_organizzativa());
cs.setLong(6, anticipo.getRimborso().getPg_rimborso().longValue());
cs.setString(7, it.cnr.contab.utenze00.bp.CNRUserContext.getUser(userContext));
cs.executeQuery();
} catch (Throwable e) {
throw handleException(e);
} finally {
try {
if (cs != null) cs.close();
} catch (java.sql.SQLException e) {
throw handleException(e);
}
}
return anticipo;
}
public AnticipoBulk riportaRimborsoIndietro(UserContext userContext, AnticipoBulk anticipo)throws ComponentException
{
LoggableStatement cs = null;
try
{
cs = new LoggableStatement(getConnection(userContext),
"{ call "
+ it.cnr.jada.util.ejb.EJBCommonServices.getDefaultSchema()
+ "CNRCTB046.deriportoEsNextDocAmm(?, ?, ?, ?, ?, ?, ?) }",false,this.getClass());
cs.setInt(1, it.cnr.contab.utenze00.bp.CNRUserContext.getEsercizio(userContext).intValue());
cs.setString(2, Numerazione_doc_ammBulk.TIPO_RIMBORSO);
cs.setString(3, anticipo.getRimborso().getCd_cds());
cs.setInt(4, anticipo.getRimborso().getEsercizio().intValue());
cs.setString(5, anticipo.getRimborso().getCd_unita_organizzativa());
cs.setLong(6, anticipo.getRimborso().getPg_rimborso().longValue());
cs.setString(7, it.cnr.contab.utenze00.bp.CNRUserContext.getUser(userContext));
cs.executeQuery();
}
catch (Throwable e)
{
throw handleException(e);
}
finally
{
try {
if (cs != null)
cs.close();
} catch (java.sql.SQLException e) {
throw handleException(e);
}
}
return anticipo;
}
/**
* Annulla le modifiche apportate all'anticipo e ritorna al savepoint impostato in precedenza
*
* Pre-post-conditions:
*
* Nome: Rollback to savePoint
* Pre: Una richiesta di annullare tutte le modifiche apportate e di ritornare al savepoint e' stata generata
* Post: Tutte le modifiche effettuate sull'anticipo da quando si e' impostato il savepoint vengono annullate
* @param uc lo UserContext che ha generato la richiesta
*/
public void rollbackToSavePoint(UserContext userContext, String savePointName) throws ComponentException
{
try
{
rollbackToSavepoint(userContext, savePointName);
}
catch (java.sql.SQLException e)
{
if (e.getErrorCode() != 1086)
throw handleException(e);
}
}
/**
* Ricerca anticipo
*
* Pre-post-conditions:
*
* Nome: Ricerca
* Pre: L'utente ha richiesto una ricerca di anticipi
* Post: Il sistema restitusce il SQLBuilder con le clausole specificate dall'utente e in aggiunta con le clausole che
* l'anticipo abbia cds, unità organizzativa uguali a quello di scrivania
*
* @param userContext lo UserContext che ha generato la richiesta
* @param clauses le clausole speicificate dall'utene
* @param bulk l'AnticipoBulk da ricercare
*
* @return il SQLBuilder con tutte le clausole
*/
public Query select(UserContext userContext,it.cnr.jada.persistency.sql.CompoundFindClause clauses,OggettoBulk bulk) throws ComponentException, it.cnr.jada.persistency.PersistencyException
{
SQLBuilder sql = (SQLBuilder) super.select( userContext, clauses, bulk );
AnticipoBulk anticipo = (AnticipoBulk) bulk;
sql.addClause("AND", "cd_cds", SQLBuilder.EQUALS, anticipo.getCd_cds());
sql.addClause("AND", "cd_unita_organizzativa", SQLBuilder.EQUALS, anticipo.getCd_unita_organizzativa());
sql.addTableToHeader("TERZO");
sql.addSQLJoin("ANTICIPO.CD_TERZO", "TERZO.CD_TERZO");
sql.addSQLClause("AND","TERZO.CD_PRECEDENTE", SQLBuilder.EQUALS, anticipo.getV_terzo().getCd_terzo_precedente());
return sql;
}
/**
* Ricerca banca
*
* Pre-post-conditions:
*
* Nome: Ricerca
* Pre: L'utente ha richiesto una ricerca delle coordinate bancarie del terzo associato all'anticipo
* Post: Il sistema restitusce il SQLBuilder con le clausole specificate dall'utente e in aggiunta con le clausole che
* le coordinate bancarie siano valide (non cancellate), siano associate al terzo dell'anticipo a abbiano un tipo uguale
* a quello selezionato dall'utente (bancario, postale, etc.)
*
* @param userContext lo UserContext che ha generato la richiesta
* @param anticipo l'AnticipoBulk da cui ricavare il terzo e il tipo di pagamento
* @param banca la BancaBulk da ricercare
* @param clauses le clausole specificate dall'utente
*
* @return il SQLBuilder con tutte le clausole
*/
public SQLBuilder selectBancaByClause(UserContext aUC, AnticipoBulk anticipo, BancaBulk banca, CompoundFindClause clauses) throws ComponentException
{
BancaHome bancaHome = (BancaHome)getHome(aUC, BancaBulk.class);
return bancaHome.selectBancaFor(
anticipo.getModalita_pagamento(),
anticipo.getCd_terzo());
}
/**
*
* Pre-post-conditions:
*
* Nome: Seleziona linee attività
* Pre: Una richiesta di listare le linee di attività da cui selezionare quella da utilizzare
* per la creazione del rimborso e' stata generata
* Post: Viene restituito il SQLBuilder con le clausole specificate dall'utente e le clausole aggiuntive che
* la linea di attività sia di Entrata e il Cdr della Linea di attività appartenga all'Uo di scrivania
*
* @param uc lo UserContext che ha generato la richiesta
* @param anticipo l' AnticipoBulk per cui selezionare la linea di attività
* @param latt la Linea_attivitaBulk da ricercare
* @param clauses le clausole specificate dall'utente
* @return il SQLBuilder con tutte le clausole
*
*/
public SQLBuilder selectLattPerRimborsoByClause(UserContext aUC,AnticipoBulk anticipo, it.cnr.contab.config00.latt.bulk.WorkpackageBulk latt, CompoundFindClause clauses) throws ComponentException, RemoteException
{
Configurazione_cnrBulk config = createConfigurazioneCnrComponentSession().getConfigurazione( aUC, ((CNRUserContext)aUC).getEsercizio(), null, "ELEMENTO_VOCE_SPECIALE", "RIMBORSO_ANTICIPO" );
if ( config == null )
throw new ApplicationException("Configurazione CNR: manca la definizione dell'ELEMENTO VOCE per RIMBORSO ANTICIPO");
if ( config.getVal01() == null )
throw new ApplicationException("Configurazione CNR: manca il CODICE dell'ELEMENTO VOCE per RIMBORSO ANTICIPO");
SQLBuilder sql = getHome( aUC,latt.getClass(), "V_LINEA_ATTIVITA_VALIDA").createSQLBuilder();
sql.addClause( clauses );
sql.addSQLClause( "AND", "esercizio", sql.EQUALS, anticipo.getEsercizio() );
sql.addClause( "AND", "cd_centro_responsabilita", sql.LIKE, anticipo.getCd_unita_organizzativa() + ".%" );
sql.addClause( "AND", "ti_gestione", sql.EQUALS, it.cnr.contab.config00.latt.bulk.WorkpackageBulk.TI_GESTIONE_ENTRATE );
sql.addSQLClause( " AND ", "CD_NATURA IN ( SELECT CD_NATURA FROM " +
it.cnr.jada.util.ejb.EJBCommonServices.getDefaultSchema() + "ASS_EV_EV " +
"WHERE ASS_EV_EV.esercizio = ? and" +
" ASS_EV_EV.cd_elemento_voce = ? " +
" and ASS_EV_EV.ti_appartenenza = ? " +
" and ASS_EV_EV.ti_gestione = ?)");
sql.addParameter( ((CNRUserContext)aUC).getEsercizio(), Types.INTEGER, 0);
sql.addParameter( config.getVal01(), Types.CHAR, 0);
sql.addParameter( it.cnr.contab.config00.pdcfin.bulk.Elemento_voceHome.APPARTENENZA_CNR, Types.CHAR, 0);
sql.addParameter( it.cnr.contab.config00.pdcfin.bulk.Elemento_voceHome.GESTIONE_ENTRATE, Types.CHAR, 0);
return sql;
}
/**
*
* Pre-post-conditions:
*
* Nome: Seleziona scadenza di obbligazione
* Pre: Una richiesta di listare le scadenze di obbligazione da cui selezionare quella da utilizzare
* per la creazione dell'anticipo e' stata generata
* Post: Viene restituito il SQLBuilder con le clausole specificate dall'utente e le seguenti clausole aggiuntive:
* - obbligazione definitiva non annullata
* - obbligazione con cds e esercizio uguali a quelli di scrivania
* - obbligazione con terzo uguale a quello specificato per l'anticipo
* - scadenza con data maggiore o uguale a quella di registrazione dell'anticipo
* - scadenza con importo associato a doc. amministrativo uguale a 0
*
* @param aUC lo UserContext che ha generato la richiesta
* @param anticipo l'AnticipoBulk per cui selezionare la scadenza di obbligazione
* @param scadenza l'Obbligazione_scadenzarioBulk da ricercare
* @param clauses le clausole specificate dall'utente
* @return il SQLBuilder con tutte le clausole
*
*/
public SQLBuilder selectScadenza_obbligazioneByClause(UserContext aUC, AnticipoBulk anticipo, Obbligazione_scadenzarioBulk scadenza, CompoundFindClause clauses) throws ComponentException
{
Obbligazione_scadenzarioHome scadenzaHome = (Obbligazione_scadenzarioHome)getHome(aUC, Obbligazione_scadenzarioBulk.class);
SQLBuilder sql = scadenzaHome.createSQLBuilder();
GregorianCalendar ggRegistrazione = (GregorianCalendar)anticipo.getGregorianCalendar(anticipo.getDt_registrazione()).clone();
ggRegistrazione.set(GregorianCalendar.HOUR_OF_DAY, 0);
ggRegistrazione.set(GregorianCalendar.MINUTE, 0);
ggRegistrazione.set(GregorianCalendar.SECOND, 0);
java.sql.Timestamp dataRegistrazione = new java.sql.Timestamp(ggRegistrazione.getTime().getTime());
sql.setDistinctClause(true);
sql.addTableToHeader("OBBLIGAZIONE");
sql.addSQLJoin("OBBLIGAZIONE_SCADENZARIO.CD_CDS","OBBLIGAZIONE.CD_CDS");
sql.addSQLJoin("OBBLIGAZIONE_SCADENZARIO.ESERCIZIO","OBBLIGAZIONE.ESERCIZIO");
sql.addSQLJoin("OBBLIGAZIONE_SCADENZARIO.ESERCIZIO_ORIGINALE","OBBLIGAZIONE.ESERCIZIO_ORIGINALE");
sql.addSQLJoin("OBBLIGAZIONE_SCADENZARIO.PG_OBBLIGAZIONE","OBBLIGAZIONE.PG_OBBLIGAZIONE");
sql.addSQLClause("AND","OBBLIGAZIONE.ESERCIZIO", sql.EQUALS, anticipo.getEsercizio());
sql.addSQLClause("AND","OBBLIGAZIONE.CD_CDS", sql.EQUALS, anticipo.getCd_cds());
sql.addSQLClause("AND","OBBLIGAZIONE.STATO_OBBLIGAZIONE", sql.EQUALS, "D");
sql.addSQLClause("AND","OBBLIGAZIONE.DT_CANCELLAZIONE", sql.ISNULL, null);
sql.addSQLClause("AND","OBBLIGAZIONE.CD_TERZO",sql.EQUALS, anticipo.getCd_terzo());
sql.addSQLClause("AND","OBBLIGAZIONE.FL_PGIRO",sql.NOT_EQUALS, "Y");
sql.addSQLClause("AND","OBBLIGAZIONE.RIPORTATO",sql.EQUALS, "N");
sql.addSQLClause("AND","OBBLIGAZIONE_SCADENZARIO.DT_SCADENZA",sql.GREATER_EQUALS, dataRegistrazione);
sql.addSQLClause("AND","OBBLIGAZIONE_SCADENZARIO.IM_ASSOCIATO_DOC_AMM = ? OR OBBLIGAZIONE_SCADENZARIO.IM_ASSOCIATO_DOC_AMM IS NULL");
sql.addParameter(new java.math.BigDecimal(0).setScale(2, java.math.BigDecimal.ROUND_HALF_UP),java.sql.Types.DECIMAL,2);
sql.addSQLClause("AND","OBBLIGAZIONE_SCADENZARIO.IM_ASSOCIATO_DOC_CONTABILE = ? OR OBBLIGAZIONE_SCADENZARIO.IM_ASSOCIATO_DOC_CONTABILE IS NULL");
sql.addParameter(new java.math.BigDecimal(0).setScale(2, java.math.BigDecimal.ROUND_HALF_UP),java.sql.Types.DECIMAL,2);
if(clauses != null)
sql.addClause(clauses);
return sql;
}
/**
*
* Pre-post-conditions:
*
* Nome: Seleziona terzo
* Pre: Una richiesta di listare i terzi da cui selezionare quello da utilizzare
* per la creazione dell'anticipo e' stata generata
* Post: Viene restituito il SQLBuilder con le clausole specificate dall'utente e la clausola aggiuntiva che il
* tipo anagrafico (dipendente/altro) sia uguale a quello specificato per l'anticipo
*
* @param aUC lo UserContext che ha generato la richiesta
* @param anticipo l'AnticipoBulk per cui selezionare il terzo
* @param aTerzo il V_terzo_per_compensoBulk da ricercare
* @param clauses le clausole specificate dall'utente
* @return il SQLBuilder con tutte le clausole
*
*/
public SQLBuilder selectV_terzoByClause(UserContext aUC,AnticipoBulk anticipo, V_terzo_per_compensoBulk aTerzo, CompoundFindClause clauses) throws ComponentException
{
// Faccio una select DISTINCT perche' altrimenti seleziono tanti terzi
// quanti sono i tipi rapporto
SQLBuilder sql = getHome(aUC,V_terzo_per_compensoBulk.class,"DISTINCT_TERZO").createSQLBuilder();
sql.addClause(clauses);
sql.setDistinctClause(true);
sql.addSQLClause("AND","TI_DIPENDENTE_ALTRO",sql.EQUALS,anticipo.getTi_anagrafico());
sql.addSQLClause("AND","CD_TERZO",sql.EQUALS, anticipo.getCd_terzo());
// Validita del terzo
CompoundFindClause clause = CompoundFindClause.or(
new SimpleFindClause("dt_fine_validita_terzo",sql.GREATER_EQUALS, anticipo.getDt_registrazione()),
new SimpleFindClause("dt_fine_validita_terzo",sql.ISNULL, null));
sql.addClause(clause);
return sql;
}
/**
* Imposta un savepoint che consente di salvare le modifiche apportate al doc. amministrativo
* fino a quel momento
* Pre-post-conditions:
*
* Nome: Imposta savePoint
* Pre: Una richiesta di impostare un savepoint e' stata generata
* Post: Un savepoint e' stato impostato in modo che le modifiche apportate al doc. amministrativo vengono consolidate
*
* @param uc lo UserContext che ha generato la richiesta
*/
public void setSavePoint(UserContext userContext, String savePointName) throws ComponentException
{
try
{
setSavepoint(userContext, savePointName);
}
catch (java.sql.SQLException e)
{
throw handleException(e);
}
}
/**
* Aggiorna importo associato a doc.amm. della scadenza
*
* Pre-post-conditions:
*
* Nome: aggiorna
* Pre: L'utente ha selezionato una scadenza di obbligazione per contabilizzare l'anticipo
* Post: Il sistema aggiorna l'importo associato a documenti amministrativi della scadenza dell'obbligazione su cui+
* l'anticipo e' stato contabilizzato
*
* @param userContext lo UserContext che ha generato la richiesta
* @param scadenza l'Obbligazione_scadenzarioBulk per cui modificare l'importo associato a doc.amm.
*
* @return l'Obbligazione_scadenzarioBulk con l'importo aggiornato
*
*/
//
// Aggiorno l'importo "IM_ASSOCIATO_DOC_AMM" della scadenza di obbligazione legata all'anticipo
//
private IScadenzaDocumentoContabileBulk updateImportoAssociatoDocAmm(UserContext userContext, IScadenzaDocumentoContabileBulk scadenza) throws ComponentException
{
try
{
((IScadenzaDocumentoContabileHome)getHome(userContext, scadenza.getClass())).aggiornaImportoAssociatoADocAmm(userContext,scadenza);
}
catch (it.cnr.jada.persistency.PersistencyException exc){throw handleException((OggettoBulk)scadenza, exc);}
catch (it.cnr.jada.bulk.BusyResourceException exc) {throw handleException((OggettoBulk)scadenza, exc);}
catch (it.cnr.jada.bulk.OutdatedResourceException exc) {throw handleException((OggettoBulk)scadenza, exc);}
return scadenza;
}
/**
* Verifica data registrazione
*
* Pre-post-conditions:
*
* Nome: valida data - ok
* Pre: L'utente ha modificato la data di registrazione dell'anticipo
* La nuova data e' uguale o successiva alla data dell'ultimo anticipo inserito
* Post: Il sistema valida la nuova data
*
* Nome: valida data - errore
* Pre: L'utente ha modificato la data di registrazione dell'anticipo
* La nuova data e' antecedente alla data dell'ultimo anticipo inserito
* Post: Il sistema segnala con un errore all'utente la non validazione della data inserita
*
* @param uc lo UserContext che ha generato la richiesta
* @param anticipo l'AnticipoBulk per cui validare la data di registrazione
*
*/
private void validaDataRegistrazione(UserContext userContext, AnticipoBulk anticipo ) throws it.cnr.jada.persistency.PersistencyException, ComponentException, it.cnr.jada.comp.ApplicationException, java.sql.SQLException
{
java.sql.Timestamp dtUltimoAnticipo = ((AnticipoHome) getHome( userContext, AnticipoBulk.class )).findDataRegistrazioneUltimoAnticipo( anticipo );
if((dtUltimoAnticipo != null) && (dtUltimoAnticipo.after(anticipo.getDt_registrazione())))
throw new it.cnr.jada.comp.ApplicationException( "Non è possibile inserire un'Anticipo con data anteriore a " + java.text.DateFormat.getDateInstance().format(dtUltimoAnticipo));
}
/**
* Viene richiesta la validazione dell'obbligazione associata all'anticipo
*
* Pre-post-conditions
*
* Nome: Scadenza non selezionata
* Pre: Non e' stata selezionata la scadenza da associare all'anticipo
* Post: Non viene consentita l'associazione della scadenza con l'anticipo
* Generata una ApplicationException con il messaggio: "Nessuna obbligazione associata!"
*
* Nome: Importi obbligazione/scadenza NULLI
* Pre: L'importo della obbligazione e/o della scadenza è nullo
* Post: Non viene consentita l'associazione della scadenza con l'anticipo
* Generata una ApplicationException con il messaggio:
* "L'importo dell'obbligazione/scadenza è un dato obbligatorio"
*
* Nome: Importo scadenza diverso da quello dell'anticipo
* Pre: L'importo della scadenza è diverso da quello dell' anticipo
* Post: Non viene consentita l'associazione della scadenza con l'anticipo
* Generata una ApplicationException con il messaggio:
* "La scadenza di obbligazione associata ha un importo diverso da quello dell'anticipo!"
*
* Nome: Data scadenza NON valida
* Pre: La scadenza selezionata ha una data minore della data di registrazione dell'anticipo
* Post: Non viene consentita l'associazione della scadenza con l'anticipo
* Generata una ApplicationException con il messaggio:
* "La data della scadenza dell'obbligazione deve essere successiva alla data di registrazione dell' anticipo!"
*
* Nome: Terzo selezionato NON valido
* Pre: Il terzo selezionato è diverso dal terzo dell'anticipo oppure il tipo entità NON è DIVERSI
* Post: Non viene consentita l'associazione della scadenza con l'anticipo
* Generata una ApplicationException con il messaggio:
* "L'obbligazione deve avere un creditore valido!"
*
* Nome: Tutte le validazioni precedenti superate
* Pre: L'obbligazione supera tutte le validazioni precedenti
* Post: Viene validata l'associazione dell'anticipo con la scadenza di obbligazione
*
* @param userContext lo UserContext che genera la richiesta
* @param scadenza la scadenza da validare
*
**/
public void validaObbligazione(UserContext userContext, Obbligazione_scadenzarioBulk scadenza, OggettoBulk bulk) throws ComponentException
{
AnticipoBulk anticipo = (AnticipoBulk)bulk;
ObbligazioneBulk obbligazione = scadenza.getObbligazione();
if (scadenza==null)
throw new it.cnr.jada.comp.ApplicationException("Nessun impegno associato!");
if (obbligazione.getIm_obbligazione()==null)
throw new it.cnr.jada.comp.ApplicationException("L'importo dell'impegno è un dato obbligatorio");
if (scadenza.getIm_scadenza()==null)
throw new it.cnr.jada.comp.ApplicationException("L'importo della scadenza è un dato obbligatorio");
if (scadenza.getIm_scadenza().compareTo(anticipo.getIm_anticipo_divisa())!=0)
throw new it.cnr.jada.comp.ApplicationException("La scadenza dell'impegno associato ha un importo diverso da quello dell'anticipo!");
GregorianCalendar gcRegistrazione = (GregorianCalendar)anticipo.getGregorianCalendar(anticipo.getDt_registrazione()).clone();
gcRegistrazione.set(java.util.GregorianCalendar.HOUR_OF_DAY, 0);
gcRegistrazione.set(java.util.GregorianCalendar.MINUTE, 0);
gcRegistrazione.set(java.util.GregorianCalendar.SECOND, 0);
if(gcRegistrazione.getTime().compareTo(scadenza.getDt_scadenza())>=0)
throw new it.cnr.jada.comp.ApplicationException("La data della scadenza dell'impegno deve essere successiva alla data di registrazione dell' anticipo!");
validaTerzoObbligazione(userContext, anticipo, obbligazione);
}
/**
* Validazione del Anticipo per Esercizio COEP precedente
*
* Gennaro Borriello/Luisa Farinella - (05/11/2004 18.11.25)
* Aggiunto controllo per i documenti RIPORTATI, in base all'esercizio COEP precedente
* all'es. di scrivania.
*
*/
private void validateEsercizioCOEP(it.cnr.jada.UserContext userContext, AnticipoBulk anticipo) throws ComponentException{
LoggableStatement cs = null;
String status = null;
try{
if (anticipo.isRiportataInScrivania() ){
Integer es_prec = new Integer(it.cnr.contab.utenze00.bp.CNRUserContext.getEsercizio(userContext).intValue()-1);
cs = new LoggableStatement(getConnection(userContext), "{ ? = call " + it.cnr.jada.util.ejb.EJBCommonServices.getDefaultSchema() + "CNRCTB200.isChiusuraCoepDef(?,?)}",false,this.getClass());
cs.registerOutParameter( 1, java.sql.Types.VARCHAR);
cs.setObject( 2, es_prec);
cs.setObject( 3, anticipo.getCd_cds());
cs.executeQuery();
status = new String(cs.getString(1));
if (status.compareTo("Y")!=0){
throw new it.cnr.jada.comp.ApplicationException("Attenzione: non è possibile eliminare il documento, poichè l'esercizio economico precedente non è chiuso.");
}
}
} catch(java.sql.SQLException ex){
throw new it.cnr.jada.comp.ComponentException(ex);
} finally {
try{
if (cs != null)
cs.close();
} catch (Throwable t){
throw new it.cnr.jada.comp.ComponentException(t);
}
}
}
/**
* Viene controllato che il terzo selezionato nell'anticipo corrisponda con al terzo selezionato
* nell'obbligazione
*
* Pre-post-conditions
*
* Nome: Terzo obbligazione non valido
* Pre: Non è stato selezionato il terzo nell'obbligazione
* Post: Ritorna un ApplicationException con la descrizione dell'errore
*
* Nome: Terzo obbligazione uguale al terzo dell'anticipo
* Pre: Il terzo selezionato nell'obbligazione corrisponde al terzo dell'anticipo
* Post: Viene validato il terzo
*
* Nome: L'anagrafica dell'obbligazione ha tipo entita DIVERSI
* Pre: L'anagafica associata al terzo dell'obbligazione ha come tipo entita DIVERSI
* Post: Viene validato il terzo
*
* Nome: Nessuna delle due condizioni precedenti è verificata
* Pre: Il terzo selezionato NON corrisponde al terzo dell'anticipo e
* l'anagrafica associata NON ha tipo entita DIVERSI
* Post: Ritorna un ApplicationException con la descrizione dell'errore
*
* @param userContext lo UserContext che genera la richiesta
* @param compenso l'anticipo di cui validare il terzo
* @param obblig l'obbligazione di cui validare il terzo
*
**/
private void validaTerzoObbligazione(UserContext userContext, AnticipoBulk anticipo, ObbligazioneBulk obbligazione) throws ComponentException
{
try
{
TerzoBulk creditore = obbligazione.getCreditore();
TerzoHome terzoHome = (TerzoHome)getHome(userContext, TerzoBulk.class);
creditore = (TerzoBulk)terzoHome.findByPrimaryKey(obbligazione.getCreditore());
if (creditore==null || creditore.getCd_terzo()==null)
throw new it.cnr.jada.comp.ApplicationException("L'impegno deve avere un creditore valido!");
getHomeCache(userContext).fetchAll(userContext);
AnagraficoHome anaHome = (AnagraficoHome)getHome(userContext, AnagraficoBulk.class);
AnagraficoBulk anagrafico = (AnagraficoBulk)anaHome.findByPrimaryKey(creditore.getAnagrafico());
if (!anticipo.getTerzo().equalsByPrimaryKey(creditore) && !AnagraficoBulk.DIVERSI.equalsIgnoreCase(anagrafico.getTi_entita()))
throw new it.cnr.jada.comp.ApplicationException("La scadenza selezionata deve appartenere ad un'obbligazione che ha come creditore il fornitore dell'anticipo!");
}
catch(it.cnr.jada.persistency.PersistencyException ex)
{
throw handleException(ex);
}
}
public boolean verificaStatoEsercizio(UserContext userContext,it.cnr.contab.config00.esercizio.bulk.EsercizioBulk anEsercizio) throws ComponentException
{
try
{
it.cnr.contab.config00.esercizio.bulk.EsercizioHome eHome = (it.cnr.contab.config00.esercizio.bulk.EsercizioHome)getHome(userContext, it.cnr.contab.config00.esercizio.bulk.EsercizioBulk.class);
return !eHome.isEsercizioChiuso(userContext, anEsercizio.getEsercizio(), anEsercizio.getCd_cds());
}
catch (it.cnr.jada.persistency.PersistencyException e)
{
throw handleException(e);
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy