First Commit from Source Code Reply

gnpdev/dbcfx/src/it/valueteam/gnp/controller/DoppioDonatingController.java

@@ -0,0 +1,514 @@
+package it.valueteam.gnp.controller;
+
+import it.valueteam.gnp.dao.db.hb.GnpDoppioDonatingOloBridge;
+import it.valueteam.gnp.dao.db.hb.GnpDoppioDonatingOloBridgeDAO;
+import it.valueteam.gnp.dao.db.hb.GnpOloRichiesteIn;
+import it.valueteam.gnp.dao.db.hb.GnpPitagoraA375In;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteRec;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteRecDAO;
+import it.valueteam.gnp.dao.db.hb.crm.AbstractGnpCrmInRec;
+import it.valueteam.gnp.exception.StateTransitionNotPossibleException;
+import it.valueteam.gnp.jms.MessageHandler;
+import it.valueteam.gnp.log.Loggable;
+import it.valueteam.gnp.log.ProcessLogger;
+import it.valueteam.gnp.manager.RequestDoppioDonatingManager;
+import it.valueteam.gnp.manager.RequestManagerRec;
+import it.valueteam.gnp.obj.ApplicationCostants;
+import it.valueteam.gnp.obj.CRMMap;
+import it.valueteam.gnp.obj.LogInfo;
+import it.valueteam.gnp.obj.LogProcess;
+import it.valueteam.gnp.obj.StatoRichiestaDoppioDonating;
+import it.valueteam.gnp.obj.StatoRichiestaRec;
+import it.valueteam.gnp.obj.jms.NotificationMessage;
+import it.valueteam.gnp.obj.jms.NotificationMessageIF;
+import it.valueteam.gnp.obj.jms.UniqueIdNotificationMessage;
+import it.valueteam.gnp.systemcontroller.ControllerFactory;
+import it.valueteam.gnp.systemcontroller.SystemController;
+import it.valueteam.gnp.systemcontroller.SystemControllerIF;
+import it.valueteam.gnp.systemcontroller.crm.SistemaCrmIF;
+import it.valueteam.gnp.systemcontroller.formatcontroller.doppiodonating.DoppioDonatingFormatController;
+import it.valueteam.gnp.systemcontroller.formatcontroller.pitagora.WSPitagoraFormatController;
+import it.valueteam.gnp.systemcontroller.pitagora.WSPitagoraController;
+import it.valueteam.gnp.utility.Func;
+import it.valueteam.gnp.utility.Resources;
+/**
+ * <p>
+ * Title: DoppioDonatingController
+ * Description: kit X5 2009: gestisce le richieste di tipo doppio donating 
+ * Copyright: Copyright (c) 2009
+ * Company: Value team
+ * </p>
+ * 
+ * @author Danilo Del Fio
+ * @version 1.0
+ * @version 2.0 20180717 corretta gestione richiesta duale null
+ */
+public class DoppioDonatingController extends SystemController implements Loggable {
+
+	protected ProcessLogger log;
+	protected String codiceProcesso = "YB";
+	protected final static String versione = "1.0.0";
+	private GnpDoppioDonatingOloBridgeDAO richiesteDDDAO;
+	private static DoppioDonatingController onlyInstance;
+
+	private final static String TIPO_SERVIZIO_FONIA = "F";
+
+
+	protected DoppioDonatingController() throws Exception {
+		try {
+			LogProcess logProcess = new LogProcess();
+			logProcess.setCodice(codiceProcesso);
+			logProcess.setProcess(this);
+			log = new ProcessLogger(logProcess);
+			richiesteDDDAO= new GnpDoppioDonatingOloBridgeDAO();
+		} catch (Exception ex) {
+			System.out.println("Errore nella creazione del ProcessLogger");
+			throw ex;
+		}
+	}
+
+	/**
+	 * Utilizzato per ottenere l'istanza del controller
+	 * @throws Exception
+	 * @return DoppioDonatingController
+	 */
+	public static DoppioDonatingController getInstance() throws Exception {
+		if (onlyInstance == null) {
+			synchronized (DoppioDonatingController.class) {
+				if (onlyInstance == null)
+					onlyInstance = new DoppioDonatingController();
+			}
+		}
+		return onlyInstance;
+	}
+
+
+	public LogInfo getLogInfo() throws Exception {
+		LogInfo logInfo = new LogInfo();
+		logInfo.setProcess(getClass().getName());
+		logInfo.setLogPath(Resources.getLogPath());
+		logInfo.setTypeInfo(Resources.getTypeInfo());
+		logInfo.setTypeDebug(Resources.getTypeDebug());
+		logInfo.setTypeError(Resources.getTypeError());
+		return logInfo;
+	}
+
+
+	public void handleMessage(NotificationMessage messaggio) throws Exception {
+
+		int notificationtype = messaggio.getNotificationType();		
+
+		// 0004 N - INIZIO TRATTAMENTO MESSAGGIO
+		log.write("0004", this.getVersione() + "TIPO_NOTIFICA = ["+ messaggio.getNotificationType() + "]");
+
+		try
+		{
+			switch (notificationtype) {
+			case NotificationMessageIF.NotificationType_DOPPIO_DONATING_OUT:	
+				handleOutgoingMessages(messaggio);
+				break;
+			default:
+				log.write("9999", "NOTIFICATION TYPE SCONOSCIUTO" + Func.getFieldDescription(messaggio));
+			break;		
+			}
+
+			// Log 0006 (N) = 'FINE TRATTAMENTO MESSAGGIO'
+			log.write("0006", "TIPO_NOTIFICA = [" + messaggio.getNotificationType() + "]");
+		} catch (Exception ex) {
+			log.write("0007", "TIPO_NOTIFICA = [" + messaggio.getNotificationType() + "] -" +ex.toString()+" - tracciato:"+Func.getFieldDescription(messaggio));
+			ex.printStackTrace();
+			throw ex;
+		} catch (Throwable th) {
+			th.printStackTrace();
+
+			// *******************************************************************************************
+
+			log.write("0007", "TIPO_NOTIFICA = [" + messaggio.getNotificationType() + "] -" +th.toString()+" - tracciato:"+Func.getFieldDescription(messaggio));
+			throw new Exception(th.toString()); // in ogni caso faccio
+			// tornare il msg in coda
+			// ********************************************************************************************
+		}
+	}
+
+
+	/**
+	 * Il metodo inserisce in coda un messaggio di notifica doppio donating
+	 * @param gestioneRec GnpRichiesteRec
+	 */
+	public void notificaRichiestaDoppioDonating(GnpRichiesteRec richiestaRec) throws Exception {	
+		NotificationMessage messaggioOut = null;			  
+		messaggioOut= creaNotificationMessageDoppioDonatingOut(richiestaRec.getIdRichiesta(),richiestaRec.getProcesso());
+		if(messaggioOut!=null) {
+			inserisciMessaggioInCoda(messaggioOut);
+		}	    
+	}
+
+	public void elaboraRispostaOLO(GnpDoppioDonatingOloBridge richiestaDoppioDonating, GnpOloRichiesteIn oloRichiestaIn) throws Exception {
+		try
+		{
+			boolean changedState = false;	// Flag che indica che la richiesta ha cambiato stato
+		
+			
+			if (oloRichiestaIn.getTipoComunicazione().intValue() == ApplicationCostants.OLO_TIPO_COMUNICAZIONE_VER_FORMALI) {
+				if (oloRichiestaIn.getStatoRichiesta().intValue() == ApplicationCostants.OLO_STATO_RICHIESTA_KO) {
+					int codiceCausale = Integer.parseInt((oloRichiestaIn.getCodiceMotivoRifiuto()));		
+					gestisciKoOLO(oloRichiestaIn.getTipoComunicazione().intValue(),codiceCausale, richiestaDoppioDonating);				
+				} else {
+					RequestDoppioDonatingManager.avanzaStatoInAccettata(richiestaDoppioDonating,oloRichiestaIn.getCodiceSessione(), log);					
+				}
+				
+				changedState = true;
+			} 
+			else if (oloRichiestaIn.getTipoComunicazione().intValue() == ApplicationCostants.OLO_TIPO_COMUNICAZIONE_VER_GESTIONALI) {
+				if (oloRichiestaIn.getStatoRichiesta().intValue() == ApplicationCostants.OLO_STATO_RICHIESTA_KO) {
+					int codiceCausale = Integer.parseInt((oloRichiestaIn.getCodiceMotivoRifiuto()));					
+					gestisciKoOLO(oloRichiestaIn.getTipoComunicazione().intValue(), codiceCausale,richiestaDoppioDonating);					
+				} else {
+					RequestDoppioDonatingManager.avanzaStatoInValidata(richiestaDoppioDonating, log);
+				}
+				
+				changedState = true;
+			} else if (oloRichiestaIn.getTipoComunicazione().intValue() == ApplicationCostants.OLO_TIPO_COMUNICAZIONE_MUTATA_VOLONTA) {
+				// aggiorno la richiesta e la salvo
+				updateMutataVolonta(richiestaDoppioDonating);
+
+				log.write("9999", "ACQUISITA TIPO COMUNICAZIONE MUTATA VOLONTA' PER ID_RICHIESTA : " + richiestaDoppioDonating.getUniqueId());
+			} else {
+				log.write("9999", "TIPO COMUNICAZIONE:" + oloRichiestaIn.getTipoComunicazione().intValue()
+						+ " NON SUPPORTATO PER LA RICHIESTA CON ID_ESIGENZA: " + oloRichiestaIn.getCodiceOrdineRecipient());
+			}
+
+			if(changedState)
+				modificaRichiestaBusinessPerOLOIn(richiestaDoppioDonating, oloRichiestaIn);
+		}
+		catch (StateTransitionNotPossibleException e) {
+			log.write("9999", "RICHIESTA DI TRANSIZIONE DI STATO INCONSISTENTE SU ID_RICHIESTA=" + richiestaDoppioDonating.getUniqueId());
+			throw e;
+		}
+	}
+	
+	private void updateMutataVolonta(GnpDoppioDonatingOloBridge richiestaDoppioDonating) {
+		GnpRichiesteRecDAO daoBusiness = new GnpRichiesteRecDAO();
+		GnpRichiesteRec richiestaRec = daoBusiness.findById(richiestaDoppioDonating.getIdRichiesta());
+
+		richiestaRec.setMutataVolonta(new Long(1));
+		daoBusiness.merge(richiestaRec);
+		
+	}
+
+	public void verificaA375(GnpRichiesteRec richiestaRec,GnpPitagoraA375In pitagoraA375In, boolean isSpeciale, boolean isInbound,boolean isFlagDichiarazioneChecked) throws Exception{
+		// verifico la tipologia del processo che stiamo gestendo
+		if (pitagoraA375In.getTipoProcesso().equals(WSPitagoraFormatController.TIPO_PROCESSO_RIENTRO)) {
+			// FONIA
+			if(pitagoraA375In.getStato().equals(WSPitagoraController.ESITO_OK)) { // ESITO = OK
+				// FONIA OK !!!
+				WSPitagoraController.getInstance().gestisciRichiestaDaInviareAlWS(richiestaRec); 
+			} else {// ESITO = KO
+				if (pitagoraA375In.getCodiceKo().equals(WSPitagoraController.ESITO_KO_A375)) { // esito KO = A1
+					if (isSpeciale || (isInbound && isFlagDichiarazioneChecked)) {
+						GnpRichiesteRecDAO richRecDAO = new GnpRichiesteRecDAO();
+						richiestaRec.setVerificataA375(WSPitagoraFormatController.VERIFICATA_A375);
+						richRecDAO.merge(richiestaRec);
+						// inserisco nella richiesta i valori che identificano una richiesta dati
+						// verificare il tipo_processo e tipo_atterraggio
+						WSPitagoraController.getInstance().gestisciRichiestaDaInviareAlWS(richiestaRec); 
+					} else {
+						RequestManagerRec.avanzaStatoInVerificataKO(richiestaRec, WSPitagoraController.ESITO_KO_A375, log);
+					}					
+				} else { // esito KO <> A1
+					RequestManagerRec.avanzaStatoInRifiutataPitagora(richiestaRec, pitagoraA375In.getCodiceKo(), pitagoraA375In.getDescrizioneKo(), true, CRMMap.NOTIFICA_RIFIUTATAPITAGORA_A375, log);
+				}
+			}
+		} else {
+			// DATI
+			if(pitagoraA375In.getStato().equals(WSPitagoraController.ESITO_OK)) { // ESITO = OK
+				// DATI OK !!!
+				if(richiestaRec.getVerificataA375().equals(WSPitagoraFormatController.VERIFICATA_A375)) {
+					// INVIO NOTIFICA A CRM CON TIPO_EVENTO=VALIDAZIONE_ANTITRUST ED ESITO=OK
+					SistemaCrmIF crmController = ControllerFactory.getSistemaCrmFromPiattaformaProvenienza(richiestaRec.getPiattaformaProvenienza());
+	            	crmController.notificaCRM(richiestaRec.getIdRichiesta(), CRMMap.NOTIFICA_VALIDATAPITAGORA_A375);	
+				}
+				RequestManagerRec.avanzaStatoInVerificataOK(richiestaRec, WSPitagoraController.ESITO_OK,true, log);
+			} else {// ESITO = KO
+				if (pitagoraA375In.getCodiceKo().equals(WSPitagoraController.ESITO_KO_A375)) { // esito KO = A1
+					if (isSpeciale || (isInbound && isFlagDichiarazioneChecked)) {
+						GnpRichiesteRecDAO richRecDAO = new GnpRichiesteRecDAO();
+						richiestaRec.setVerificataA375(WSPitagoraFormatController.VERIFICATA_A375);
+						richRecDAO.merge(richiestaRec);
+						// INVIO NOTIFICA A CRM CON TIPO_EVENTO=VALIDAZIONE_ANTITRUST ED ESITO=OK
+						SistemaCrmIF crmController = ControllerFactory.getSistemaCrmFromPiattaformaProvenienza(richiestaRec.getPiattaformaProvenienza());
+		            	crmController.notificaCRM(richiestaRec.getIdRichiesta(), CRMMap.NOTIFICA_VALIDATAPITAGORA_A375);	
+					} else {
+						RequestManagerRec.avanzaStatoInVerificataKO(richiestaRec, WSPitagoraController.ESITO_KO_A375, log);
+						// INVIO NOTIFICA A CRM CON TIPO_EVENTO=VALIDAZIONE_ANTITRUST, ESITO=KO e CAUSALE=A1
+						SistemaCrmIF crmController = ControllerFactory.getSistemaCrmFromPiattaformaProvenienza(richiestaRec.getPiattaformaProvenienza());
+		            	crmController.notificaCRM(richiestaRec.getIdRichiesta(), CRMMap.NOTIFICA_RIFIUTATAPITAGORA_A375);	
+					}
+				} 
+			}
+		}
+		
+		
+	}
+
+	private void gestisciKoOLO(int tipoCom, int codiceCausale,GnpDoppioDonatingOloBridge richiestaDoppioDonating) throws Exception{	
+		switch(tipoCom){		 
+		case ApplicationCostants.OLO_TIPO_COMUNICAZIONE_VER_FORMALI:
+			if(codiceCausale==ApplicationCostants.KO_SUPERMENTO_SOGLIA_VER_FORMALI){					
+				RequestDoppioDonatingManager.avanzaStatoInDaReinviare(richiestaDoppioDonating,codiceCausale, log);
+			}else{				
+				RequestDoppioDonatingManager.avanzaStatoInAccettataKO(richiestaDoppioDonating, codiceCausale,log);
+			}			 
+			break;			 
+			//ST 2018-BU-71554 Ottimizzazione gestione KO Fase 2
+			/*
+			 * Cambiare eventualmente gestione risottomissione nel caso di richiesta
+			 * appartenente al CRMB. In questo caso avanzare la richiesta direttamente in rifiutataOLO
+			 */
+		case ApplicationCostants.OLO_TIPO_COMUNICAZIONE_VER_GESTIONALI:
+			if(codiceCausale==ApplicationCostants.KO_TRASLOCO_VER_GESTIONALI){
+				int numKoTrasloco = richiestaDoppioDonating.getNumKoTraslocoOlo() == null ? 0 : richiestaDoppioDonating.getNumKoTraslocoOlo().intValue()+1;					
+				if(numKoTrasloco<ApplicationCostants.MAX_KO_TRASLOCO_OLO){						
+					RequestDoppioDonatingManager.avanzaStatoInDaReinviare(richiestaDoppioDonating,codiceCausale, log);
+				}else{
+					log.write("9999", "RAGGIUNTO NUMERO MASSIMO DI KO PER RICHIESTA DOPPIO DONATING CON CODICE :"+ApplicationCostants.KO_TRASLOCO_VER_GESTIONALI+", ID_RICHIESTA : "+richiestaDoppioDonating.getUniqueId());
+					RequestDoppioDonatingManager.avanzaStatoInRifiutata(richiestaDoppioDonating, codiceCausale,log);
+				}
+			}else{
+				RequestDoppioDonatingManager.avanzaStatoInRifiutata(richiestaDoppioDonating, codiceCausale, log);
+			}		
+			break;
+		default:
+			throw new Exception("Tipo Comunicazione sconosciuto durante la gestione del KO da OLO PER RICHIESTA DOPPIO DONATING");
+
+		}
+	}
+
+	/**
+	 * Determina e applica le modifiche alla richiesta di business all'arrivo della notifica da OLO
+	 * 
+	 * @param richiestaDD
+	 * @param richiestaIn
+	 * @version 2.0 20180717 corretta gestione richiesta duale null
+	 */
+	private void modificaRichiestaBusinessPerOLOIn(GnpDoppioDonatingOloBridge richiestaDD, GnpOloRichiesteIn richiestaIn)
+	throws Exception
+	{
+		GnpDoppioDonatingOloBridgeDAO dao = new GnpDoppioDonatingOloBridgeDAO();
+		GnpDoppioDonatingOloBridge richDuale = dao.findRichiestaDuale(richiestaDD);
+		GnpRichiesteRecDAO daoBusiness = new GnpRichiesteRecDAO();
+		GnpRichiesteRec richBusiness = daoBusiness.findById(richiestaDD.getIdRichiesta());
+
+		boolean richOlo1 = richiestaDD.getTipoServizio().equals(TIPO_SERVIZIO_FONIA);
+		
+		// version 2.0 20180717 BEGIN
+		Long stato_OLO1 = richOlo1 ? richiestaDD.getStato() : ( null == richDuale ? null : richDuale.getStato() );
+		//Long stato_OLO1 = richOlo1 ? richiestaDD.getStato() : richDuale.getStato();
+		
+		Long stato_OLO2 = richOlo1 ? ( null == richDuale ? null : richDuale.getStato() ) : richiestaDD.getStato() ;
+		//Long stato_OLO2 = !richOlo1 ? richiestaDD.getStato() : (richDuale != null ? richDuale.getStato() : null);
+		// version 2.0 20180717 END
+
+		int codiceCausaleKoOLO = 0;
+
+		Long statoRichBusiness = StatoRichiestaDoppioDonating.checkTransizioneRichiestaBase(stato_OLO1, stato_OLO2, richBusiness.getStato(), richOlo1);
+		
+		if(statoRichBusiness != null)
+		{
+			switch(statoRichBusiness.intValue())
+			{
+			case StatoRichiestaRec.ACCETTATA:
+				// Avverti che non deve notificare a OLO!
+				RequestManagerRec.avanzaStatoInAccettata(richBusiness, richiestaIn.getCodiceSessione(), !richOlo1, false, log);
+				break;
+
+			case StatoRichiestaRec.INVIOOLO:
+				RequestManagerRec.avanzaStatoInInvioOlo(richBusiness, log);
+				break;
+
+			case StatoRichiestaRec.ACCETTATAKO:
+				codiceCausaleKoOLO = Integer.parseInt((richiestaIn.getCodiceMotivoRifiuto()));
+				// Avverti che non deve notificare a OLO!
+				RequestManagerRec.avanzaStatoInAccettataKO(richBusiness, codiceCausaleKoOLO, false, log);
+				break;
+
+			case StatoRichiestaRec.RIFIUTATA_OLO:
+				codiceCausaleKoOLO = Integer.parseInt((richiestaIn.getCodiceMotivoRifiuto()));
+				// Avverti che non deve notificare a OLO!
+				RequestManagerRec.avanzaStatoInRifiutataOlo(richBusiness, codiceCausaleKoOLO, false, log);
+				break;
+			}
+		}
+		
+		switch(richiestaDD.getStato().intValue())
+		{
+		case StatoRichiestaDoppioDonating.ACCETTATA:
+			// Imposta codice sessione
+			if(richOlo1) {
+				richBusiness.setCodiceSessioneOlo(richiestaIn.getCodiceSessione());
+			} else {
+				richBusiness.setCodiceSessioneOlo2(richiestaIn.getCodiceSessione());
+			}
+			break;
+
+		case StatoRichiestaDoppioDonating.DA_REINVIARE:
+			// Se si tratta di un KO per trasloco...
+			if(richiestaIn.getTipoComunicazione().intValue() == ApplicationCostants.OLO_TIPO_COMUNICAZIONE_VER_GESTIONALI)
+			{
+				codiceCausaleKoOLO = Integer.parseInt((richiestaIn.getCodiceMotivoRifiuto()));
+				if(richOlo1) {
+					richBusiness.setCodiceRifiutoOloValidazione(new Long(codiceCausaleKoOLO));
+				} else {
+					richBusiness.setCodiceRifiutoOlo2Validaz(new Long(codiceCausaleKoOLO));
+				}
+			}
+			else
+			{
+				// altrimenti solo il codice rifiuto OLO
+				codiceCausaleKoOLO = Integer.parseInt((richiestaIn.getCodiceMotivoRifiuto()));
+				if(richOlo1) {
+					richBusiness.setCodiceRifiutoOloAccett(new Long(codiceCausaleKoOLO));
+				} else {
+					richBusiness.setCodiceRifiutoOlo2Accett(new Long(codiceCausaleKoOLO));
+				}						
+			}
+			break;
+
+		case StatoRichiestaDoppioDonating.ACCETTATAKO:
+			codiceCausaleKoOLO = Integer.parseInt((richiestaIn.getCodiceMotivoRifiuto()));
+			if(richOlo1) {
+				richBusiness.setCodiceRifiutoOloAccett(new Long(codiceCausaleKoOLO));
+			} else {
+				richBusiness.setCodiceRifiutoOlo2Accett(new Long(codiceCausaleKoOLO));
+			}
+			break;
+
+		case StatoRichiestaDoppioDonating.RIFIUTATA:
+			codiceCausaleKoOLO = Integer.parseInt((richiestaIn.getCodiceMotivoRifiuto()));
+			if(richOlo1) {
+				richBusiness.setCodiceRifiutoOloValidazione(new Long(codiceCausaleKoOLO));
+			} else {
+				richBusiness.setCodiceRifiutoOlo2Validaz(new Long(codiceCausaleKoOLO));
+			}
+
+			break;
+		}
+	}
+
+	private void handleOutgoingMessages(NotificationMessage msg) throws Exception {
+		//recupero la richiesta di doppio donating dalla tabella di business		
+		UniqueIdNotificationMessage messaggio = (UniqueIdNotificationMessage)msg;
+		GnpRichiesteRecDAO richiesteDao= new GnpRichiesteRecDAO();
+		GnpRichiesteRec richiestaRec= richiesteDao.findById(messaggio.getUnique_id());
+		DoppioDonatingFormatController formatController = new DoppioDonatingFormatController();
+
+		// salvo sicuramente la prima richiesta indirizzata all'olo 1
+		GnpDoppioDonatingOloBridge richDD= formatController.createDoubleDonatingRequest(richiestaRec, true);
+		richiesteDDDAO.save(richDD);
+		// verifico che i due COW siano diversi
+		if(!richiestaRec.getCow().equals(richiestaRec.getCow2())) {
+			//il flag per la creazione della richiesta da salvare, serve per definire se si tratta
+			//della richiesta da inviare ad OLO1 (true) o OLO2 (false)
+			richDD= formatController.createDoubleDonatingRequest(richiestaRec, false);
+			richiesteDDDAO.save(richDD);
+		}
+
+		RequestManagerRec.avanzaStatoInInvioOlo(richiestaRec, log);
+	}
+
+	protected String getVersione() {
+		return versione;
+	}
+
+	@Override
+	protected int getSystemControllerProvider() {
+		return SystemControllerIF.SystemProvider_DOPPIO_DONATING;
+	}
+
+	/**
+	 * Metodo che inserisce in coda un messagio deve essere sempre chiamato in
+	 * ****TRANSAZIONE*****
+	 * 
+	 * @throws Exception
+	 */
+	protected void inserisciMessaggioInCoda(NotificationMessage messaggio) throws Exception {
+		MessageHandler messageH = null;
+		messageH = MessageHandler.getInstance();
+		messageH.insertQueue(messaggio);
+	}
+
+	/**
+	 * Crea il NotificationMessage da inserire nella coda di uscita
+	 *
+	 * @param uniqueId String
+	 * @return NotificationMessage
+	 */
+	protected NotificationMessage creaNotificationMessageDoppioDonatingIn(Long uniqueId, String tipoServizio) {
+		UniqueIdNotificationMessage messaggio = new UniqueIdNotificationMessage();
+		messaggio.setUnique_id(uniqueId);
+		messaggio.setNotificationType(NotificationMessageIF.NotificationType_DOPPIO_DONATING_IN);
+		// to do verificare il tipo processo se da inserire
+		//DA VERIFICARE ANCHE SE TIPO SERVIZIO NEL NOSTRO CASO COINCIDE COL TIPO PROCESSO
+		messaggio.setProcessType(tipoServizio);
+		messaggio.setSystemProvider(NotificationMessageIF.SystemProvider_DOPPIO_DONATING);
+		return messaggio;
+	}
+
+	/**
+	 * Crea il NotificationMessage da inserire nella coda di uscita
+	 *
+	 * @param uniqueId String
+	 * @return NotificationMessage
+	 */
+	protected NotificationMessage creaNotificationMessageDoppioDonatingOut(Long uniqueId, String tipoServizio) {
+		UniqueIdNotificationMessage messaggio = new UniqueIdNotificationMessage();
+		messaggio.setUnique_id(uniqueId);
+		messaggio.setNotificationType(NotificationMessageIF.NotificationType_DOPPIO_DONATING_OUT);
+		// to do verificare il tipo processo se da inserire
+		//DA VERIFICARE ANCHE SE TIPO SERVIZIO NEL NOSTRO CASO COINCIDE COL TIPO PROCESSO
+		messaggio.setProcessType(tipoServizio);
+		messaggio.setSystemProvider(NotificationMessageIF.SystemProvider_DOPPIO_DONATING);
+		return messaggio;
+	}
+
+	public void gestisciDisdetta(GnpRichiesteRec richiestaRec, String tipoDisdetta, String tipoEvento) throws Exception {
+		// Se la disdetta e' di FONIA va fatto l'avanzamento di stato della richiesta di business e delle singole richieste
+		if ("F".equals(tipoDisdetta)) {
+			GnpDoppioDonatingOloBridge ddFonia = richiesteDDDAO.findRichiestaFonia(richiestaRec.getIdRichiesta());
+			if (ddFonia != null) {
+				RequestDoppioDonatingManager.avanzaStatoInDisdetta(ddFonia, log);
+			}
+			GnpDoppioDonatingOloBridge ddDati = richiesteDDDAO.findRichiestaDuale(ddFonia);
+			if (ddDati != null) {
+				RequestDoppioDonatingManager.avanzaStatoInDisdetta(ddDati, log);
+			}
+			RequestManagerRec.avanzaStatoInDisdetta(richiestaRec, tipoEvento);
+		} else {
+			// Se la disdetta e' di DATI la richiesta di business non subisce avanzamenti di stato, ma solamente
+			// quella duale
+			GnpDoppioDonatingOloBridge richiestaDD = richiesteDDDAO.findRichiestaDati(richiestaRec.getIdRichiesta());
+			if (richiestaDD != null) {
+				RequestDoppioDonatingManager.avanzaStatoInDisdetta(richiestaDD, log);
+				// In questo caso il codice sessione 2 va azzerato per non inviarlo a Pitagora
+				richiestaRec.setCodiceSessioneOlo2("");
+			}
+		}
+	}
+
+	public void gestisciEmissione(GnpRichiesteRec richiestaRec)
+	throws Exception
+	{
+		// Se l'emissione arriva prima della Fase III deve essere inviata disdetta a OLO2
+		switch(richiestaRec.getStato().intValue())
+		{
+			case StatoRichiestaRec.INVIOOLO:
+			case StatoRichiestaRec.ACCETTATA:
+			case StatoRichiestaRec.VALIDATING:
+				GnpDoppioDonatingOloBridge ddDati = richiesteDDDAO.findRichiestaDati(richiestaRec.getIdRichiesta());
+				if(ddDati != null)
+					RequestDoppioDonatingManager.avanzaStatoInDisdetta(ddDati, log);
+				break;
+		}
+	}
+
+}

gnpdev/dbcfx/src/it/valueteam/gnp/controller/RequestControllerCsNpg103.java

@@ -0,0 +1,158 @@
+package it.valueteam.gnp.controller;
+
+import it.valueteam.crontab.processexecutor.ProcessIF;
+import it.valueteam.gnp.dao.db.hb.*;
+import it.valueteam.gnp.log.Loggable;
+import it.valueteam.gnp.log.ProcessLogger;
+import it.valueteam.gnp.manager.RequestManagerCSNPg103;
+import it.valueteam.gnp.manager.RequestManagerDonNatOlo103;
+import it.valueteam.gnp.obj.*;
+import it.valueteam.gnp.systemcontroller.ControllerFactory;
+import it.valueteam.gnp.systemcontroller.crm.SistemaCrmIF;
+import it.valueteam.gnp.utility.Resources;
+import it.valueteam.gnp.utility.UserTransactionUtility;
+
+import javax.transaction.UserTransaction;
+import java.util.ArrayList;
+import java.util.List;
+
+public class RequestControllerCsNpg103 implements Loggable, ProcessIF {
+
+    protected ProcessLogger log;
+    protected String codiceProcesso = "ZX";
+    protected final static String versione = "1.0.0";
+    protected final static String PARAM_TIPO_COMM_5 = "TC5";
+
+    public RequestControllerCsNpg103() throws Exception{
+
+        try {
+            LogProcess logProcess = new LogProcess();
+            logProcess.setCodice(codiceProcesso);
+            logProcess.setProcess(this);
+            log = new ProcessLogger(logProcess);
+        } catch (Exception ex) {
+            System.out.println("Errore nella creazione del ProcessLogger");
+            throw ex;
+        }
+
+    }
+
+    public LogInfo getLogInfo() throws Exception {
+        LogInfo logInfo = new LogInfo();
+        logInfo.setProcess(getClass().getName());
+        logInfo.setLogPath(Resources.getLogPath());
+        logInfo.setTypeInfo(Resources.getTypeInfo());
+        logInfo.setTypeDebug(Resources.getTypeDebug());
+        logInfo.setTypeError(Resources.getTypeError());
+        return logInfo;
+    }
+
+    @Override
+    public void execute(String[] args) throws Exception {
+        try {
+            //0001 N - INIZIO PROCESSO
+            log.write("0001", " versione " + RequestControllerRec.versione);
+            if ((args==null) || (args.length==0))
+                throw new UnsupportedOperationException("Introdurre parametro di esecuzione ");
+            else {
+                if (args[0].equalsIgnoreCase(PARAM_TIPO_COMM_5)) {
+                    checkTipoComm5inKO();
+                }
+                else {
+                    log.write("9999 "," Parametro non riconosciuto: " + args[0]);
+                    throw new UnsupportedOperationException("Parametro di esecuzione non riconosciuto ");
+                }
+            }
+            //0002 N - PROCESSO TERMINATO CORRETTAMENTE
+            log.write("0002","");
+        }
+        catch (Exception ex) {
+            //0003 C - PROCESSO TERMINATO CON ECCEZIONI
+            log.write("0003", "" + ex.toString());
+            log.write("9999", "ECCEZIONE RILEVATA : "+ex.toString());
+            ex.printStackTrace();
+            //Termino l'esecuzione ritornando un errore a chi mi ha eseguito
+            throw ex;
+        }
+    }
+
+    public boolean requiredTX() {
+        return false;
+    }
+
+    // 152248 - 227248
+    /**
+     * checkTipoComm5 in KO
+     * Effettua il controllo se ci sono KO in data odierna per
+     * tutte le richieste legate ad IdCorrelazione andato in KO
+     * e scarta tutte le richieste del medesimo pacchetto
+     * (con stesso IdCorrelazione)
+     */
+    private void checkTipoComm5inKO() throws Exception {
+
+        UserTransaction uTX = null;
+        GnpRichiesteCsNpg103DAO daoD103 = new GnpRichiesteCsNpg103DAO();
+        GnpFenpRichiesteOutDAO daoFenpOut = new GnpFenpRichiesteOutDAO();
+        List richiesteinKOoggi = daoFenpOut.getRichiesteInKoOggi();
+        List<GnpFenpRichiesteOut> distinctValues = new ArrayList<GnpFenpRichiesteOut>();
+        GnpRichiesteCsNpg103 richiestaCs = null;
+
+        if (richiesteinKOoggi!= null && !richiesteinKOoggi.isEmpty()) {
+            for (Object o : richiesteinKOoggi) {
+                GnpFenpRichiesteOut rich = (GnpFenpRichiesteOut) o;
+                if (!duplicatedElement(distinctValues, rich)) {
+                    distinctValues.add(rich);
+                }
+            }
+            if (!distinctValues.isEmpty()) {
+                log.write("9999", "ID_CORRELAZIONE IN ERRORE OGGI:" + distinctValues.size());
+                for (GnpFenpRichiesteOut rich : distinctValues) {
+                    try {
+                        String idCorrelazione = rich.getIdCorrelazione();
+                        log.write("9999", "ID_CORRELAZIONE IN ERRORE OGGI:" + idCorrelazione);
+
+                        List richiesteDaScartare = daoD103.getRichiesteInOKOggi(idCorrelazione);
+
+                        if (richiesteDaScartare != null && !richiesteDaScartare.isEmpty()) {
+                            for (Object o : richiesteDaScartare) {
+                                richiestaCs = (GnpRichiesteCsNpg103) o;
+                                //ogni singola richiesta e' inserita in tx
+                                uTX = UserTransactionUtility.beginUserTransaction();
+                                if (richiestaCs.getProcesso().equals(ProcessMapper.proc_CS_NPg103)) {
+                                    RequestManagerCSNPg103.avanzaStatoInRifiutata(richiestaCs, log, ApplicationCostants.PROCESSO_DONOR.FENP_OUT_COM5.COD_MOTIVO_28);
+                                } else {
+                                    RequestManagerDonNatOlo103.avanzaStatoInRifiutata(richiestaCs, log, ApplicationCostants.PROCESSO_DONOR.FENP_OUT_COM5.COD_MOTIVO_28);
+                                }
+                                SistemaCrmIF crmController = ControllerFactory.getSistemaCrmFromPiattaformaProvenienza(CRMMap.PIATTAFORMA_B);
+                                crmController.notificaCRM(richiestaCs, new GnpFenpRichiesteIn(), CRMMap.NOTIFICA_ANNULLAMENTO);
+                                UserTransactionUtility.endUserTransaction(uTX, true);
+                            }
+                        }
+
+                    } catch (Exception ex) {
+                        ex.printStackTrace();
+                        //rollback della tx corrente
+                        if(uTX != null) {
+                            UserTransactionUtility.endUserTransaction(uTX, false);
+                        }
+                        if(richiestaCs != null) {
+                            log.write("9999", "Errore durante l'avanzamento di stato per la richiesta: "
+                                    + richiestaCs.getIdRichiesta() + " - " + ex.toString());
+                            //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+                            log.write("0010", " RICHIESTA " + richiestaCs.getIdRichiesta());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private boolean duplicatedElement(List<GnpFenpRichiesteOut> distinctValues, GnpFenpRichiesteOut rich) {
+        for(GnpFenpRichiesteOut d : distinctValues) {
+            if(rich.getIdCorrelazione().equals(d.getIdCorrelazione()) && rich.getIdRichiesta().equals(d.getIdRichiesta())) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

gnpdev/dbcfx/src/it/valueteam/gnp/controller/RequestControllerDonNatOlo.java

@@ -0,0 +1,160 @@
+package it.valueteam.gnp.controller;
+
+import java.util.Date;
+import java.util.List;
+
+import javax.naming.NamingException;
+import javax.transaction.UserTransaction;
+
+import it.valueteam.crontab.processexecutor.*;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteDonNatOlo;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteDonNatOloDAO;
+import it.valueteam.gnp.dao.db.hb.GnpScartiVerificaCs;
+import it.valueteam.gnp.dao.db.hb.GnpScartiVerificaCsDAO;
+import it.valueteam.gnp.log.*;
+import it.valueteam.gnp.manager.RequestManagerDonNatOlo;
+import it.valueteam.gnp.obj.*;
+import it.valueteam.gnp.utility.*;
+
+
+/**
+ * <p>Title: RequestControllerDonNatOlo</p>
+ * <p>Description: </p>
+ * <p>Copyright: Copyright (c) 2011</p>
+ * <p>Company: NCI</p>
+ * @author B.C.
+ * @version 1.0
+ */
+public class RequestControllerDonNatOlo  implements Loggable, ProcessIF {
+
+  protected ProcessLogger log;
+  protected String codiceProcesso = "ZH";
+  protected final static String versione = "1.0.0";
+  protected final static String PARAM_DATA_SILENZIO_ASSENSO = "s";
+  
+  public static final Long ESITO_VERIFICA_CS=new Long(3);
+  public static final String ESITO_VERIFICA_CS_KO="VERIFICA_CODICE_SEGRETO_SILENZIO ASSENSO_CRM";
+
+  
+  public RequestControllerDonNatOlo() throws Exception {
+    try {
+      LogProcess logProcess = new LogProcess();
+      logProcess.setCodice(codiceProcesso);
+      logProcess.setProcess(this);
+      log = new ProcessLogger(logProcess);
+    }
+    catch (Exception ex) {
+      System.out.println("Errore nella creazione del ProcessLogger");
+      throw ex;
+    }
+  }
+
+  public LogInfo getLogInfo() throws Exception {
+    LogInfo logInfo = new LogInfo();
+    logInfo.setProcess(getClass().getName());
+    logInfo.setLogPath(Resources.getLogPath());
+    logInfo.setTypeInfo(Resources.getTypeInfo());
+    logInfo.setTypeDebug(Resources.getTypeDebug());
+    logInfo.setTypeError(Resources.getTypeError());
+    return logInfo;
+  }
+
+
+  /**
+   * requiredTX
+   *
+   * @return boolean
+   */
+  public boolean requiredTX() {
+    return false;
+  }
+
+
+public void execute(String[] args) throws Exception {
+    try {
+      //0001 N - INIZIO PROCESSO
+      log.write("0001", " versione " + RequestControllerRec.versione);
+      if ((args==null) || (args.length==0))
+        throw new UnsupportedOperationException("Introdurre parametro di esecuzione ");
+      else {
+        if (args[0].equalsIgnoreCase(RequestControllerDonNatOlo.PARAM_DATA_SILENZIO_ASSENSO)) {
+         checkSilenzioAssenso();
+        }
+        else {
+          log.write("9999 "," Paramentro non riconosciuto: " + args[0]);
+          throw new UnsupportedOperationException("Parametro di esecuzione non riconosciuto ");
+        }
+      }
+      //0002 N - PROCESSO TERMINATO CORRETTAMENTE
+      log.write("0002","");
+      }
+    catch (Exception ex) {
+      //0003 C - PROCESSO TERMINATO CON ECCEZIONI
+      log.write("0003", "" + ex.toString());
+      log.write("9999", "ECCEZIONE RILEVATA : "+ex.toString());
+      ex.printStackTrace();
+      //Termino l'esecuzione ritornando un errore a chi mi ha eseguito
+      throw ex;
+    }
+}
+/**
+ * checkSilenzioAssenso
+ * Effettua il controllo se data silenzio assenso è uguale alla data odierna per
+ * tutte le richieste in stato ATTESAVERIFICA o ACQUISITA
+ * ed esegue l'avanzamento di stato in ESPLETATA
+ *
+ */
+private void checkSilenzioAssenso() throws NamingException, Exception {
+
+  UserTransaction uTX = null;
+  GnpRichiesteDonNatOloDAO donNatOloDAO = new GnpRichiesteDonNatOloDAO();
+  List silenzioAssenso = donNatOloDAO.getRichiesteSilenzioAssenso();
+  
+  if (silenzioAssenso!= null && silenzioAssenso.size()!= 0){
+    log.write("9999","RICHIESTE DONOR NATIVI OLO DA ELABORARE PER SILENZIO ASSENSO:"+silenzioAssenso.size());
+    for (int i = 0; i < silenzioAssenso.size(); i++) {
+    	GnpRichiesteDonNatOlo rich = null;
+      try {
+    	  rich = (GnpRichiesteDonNatOlo) silenzioAssenso.get(i);
+          //ogni singola richiesta è inserita in tx
+          uTX = UserTransactionUtility.beginUserTransaction();
+          RequestManagerDonNatOlo.avanzaStatoInEspletata(rich,log);
+          buildScartiVerificaCsDonorNatOlo(rich,ESITO_VERIFICA_CS_KO,"TIMEOUT CRM",log);
+          UserTransactionUtility.endUserTransaction(uTX, true);
+      }
+      catch (Exception ex) {
+        //rollback della tx corrente
+        UserTransactionUtility.endUserTransaction(uTX, false);
+        ex.printStackTrace();
+        log.write("9999", "Errore durante l'avanzamento di stato per la richiesta: " + rich.getIdRichiesta()+" - "+ex.toString());
+        //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+        log.write("0010", " RICHIESTA "+rich.getIdRichiesta()+" - "+ex.toString());
+      }
+    }
+  }
+  else
+    log.write("9999","NESSUNA RICHIESTA DONOR DA ELABORARE");
+}
+
+private static void buildScartiVerificaCsDonorNatOlo(GnpRichiesteDonNatOlo richiesta,String tipoAnomalia,String descrizioneAnomalia,ProcessLogger log) {
+	log.write("9999","START buildScartiVerificaCs  DN: " + richiesta.getDn()+"Idrichiesta: "+richiesta.getIdRichiesta());
+	
+	GnpScartiVerificaCsDAO scartiVerificaCsDao=new GnpScartiVerificaCsDAO();
+    GnpScartiVerificaCs scartiVerificaCs=new GnpScartiVerificaCs();
+    
+    scartiVerificaCs.setIdRichiesta(richiesta.getIdRichiesta());
+    scartiVerificaCs.setDn(richiesta.getDn());
+    scartiVerificaCs.setTipoAnomalia(tipoAnomalia);
+    scartiVerificaCs.setDescrizioneAnomalia(descrizioneAnomalia);
+    scartiVerificaCs.setTipoComunicazione(ESITO_VERIFICA_CS);
+    scartiVerificaCs.setCodiceSegreto(richiesta.getCodiceSegreto());
+    scartiVerificaCs.setDataInserimento(new Date());
+
+    
+    scartiVerificaCsDao.merge(scartiVerificaCs);
+    
+    log.write("9999","END buildScartiVerificaCs  DN: " + richiesta.getDn()+"Idrichiesta: "+richiesta.getIdRichiesta());
+}  
+	  
+
+}

gnpdev/dbcfx/src/it/valueteam/gnp/controller/RequestControllerDonor.java

@@ -0,0 +1,226 @@
+package it.valueteam.gnp.controller;
+
+import java.util.*;
+
+import javax.transaction.*;
+import javax.naming.*;
+
+import it.valueteam.crontab.processexecutor.*;
+import it.valueteam.gnp.log.*;
+import it.valueteam.gnp.obj.*;
+import it.valueteam.gnp.utility.*;
+import it.valueteam.gnp.dao.db.hb.*;
+import it.valueteam.gnp.manager.*;
+
+/**
+ * <p>Title: RequestControllerDonor</p>
+ * <p>Description: </p>
+ * <p>Copyright: Copyright (c) 2009</p>
+ * <p>Company: </p>
+ * @author unascribed
+ * @version 1.0
+ */
+public class RequestControllerDonor implements Loggable, ProcessIF {
+
+  protected ProcessLogger log;
+  protected String codiceProcesso = "CB";
+  protected final static String versione = "1.0.0";
+  private final static String PARAM_CHECK_FINE_WAIT_OLO = "f";
+  private final static String PARAM_CHECK_CHIUSURA_RICHIESTA_MIGRAZIONE = "m";
+
+
+  public RequestControllerDonor() throws Exception {
+    try {
+      LogProcess logProcess = new LogProcess();
+      logProcess.setCodice(codiceProcesso);
+      logProcess.setProcess(this);
+      log = new ProcessLogger(logProcess);
+    }
+    catch (Exception ex) {
+      System.out.println("Errore nella creazione del ProcessLogger");
+      throw ex;
+    }
+  }
+
+  public LogInfo getLogInfo() throws Exception {
+    LogInfo logInfo = new LogInfo();
+    logInfo.setProcess(getClass().getName());
+    logInfo.setLogPath(Resources.getLogPath());
+    logInfo.setTypeInfo(Resources.getTypeInfo());
+    logInfo.setTypeDebug(Resources.getTypeDebug());
+    logInfo.setTypeError(Resources.getTypeError());
+    return logInfo;
+  }
+
+
+  /**
+   * requiredTX
+   *
+   * @return boolean
+   */
+  public boolean requiredTX() {
+    return false;
+  }
+
+
+public void execute(String[] args) throws Exception {
+    try {
+      //0001 N - INIZIO PROCESSO
+      log.write("0001", " versione " + RequestControllerDonor.versione);
+      if ((args==null) || (args.length==0))
+        throw new UnsupportedOperationException("Introdurre parametro di esecuzione ");
+      else {
+        if (args[0].equalsIgnoreCase(RequestControllerDonor.PARAM_CHECK_FINE_WAIT_OLO)) {
+          checkFineWaitOlo();
+        } else if (args[0].equalsIgnoreCase(RequestControllerDonor.PARAM_CHECK_CHIUSURA_RICHIESTA_MIGRAZIONE)){
+          checkChiusuraRichiestaMigrazione();
+          checkChiusuraRichiestaMigrazione82();
+        }
+        else {
+          log.write("9999 "," Paramentro non riconosciuto: " + args[0]);
+          throw new UnsupportedOperationException("Parametro di esecuzione non riconosciuto ");
+        }
+      }
+      //0002 N - PROCESSO TERMINATO CORRETTAMENTE
+      log.write("0002","");
+      }
+    catch (Exception ex) {
+      //0003 C - PROCESSO TERMINATO CON ECCEZIONI
+      log.write("0003", "" + ex.toString());
+      log.write("9999", "ECCEZIONE RILEVATA : "+ex.toString());
+      ex.printStackTrace();
+      //Termino l'esecuzione ritornando un errore a chi mi ha eseguito
+      throw ex;
+    }
+}
+
+  /**
+   * CeckFineDataWaitOLO
+   * Effettua il controllo se waitOLO è uguale alla data odierna per
+   * tutte le rcihieste in stato INVIATA e VALIDATAOLO
+   * ed esegue l'avanzamento di stato
+   *
+   */
+  private void checkFineWaitOlo() throws NamingException, Exception {
+
+    UserTransaction uTX = null;
+    GnpRichiesteDonorDAO daoRichDonor = new GnpRichiesteDonorDAO();
+    List fineWaitOlo = daoRichDonor.getRichiesteFineWaitScaduto();
+    
+    if (fineWaitOlo!= null && fineWaitOlo.size()!= 0){
+      log.write("9999","RICHIESTE DONOR FINE WAIT SCADUTO DA ELABORARE:"+fineWaitOlo.size());
+      for (int i = 0; i < fineWaitOlo.size(); i++) {
+        GnpRichiesteDonor gnpRichiesteDonor = null;
+        try {
+        	gnpRichiesteDonor = (GnpRichiesteDonor) fineWaitOlo.get(i);
+            //ogni singola richiesta è inserita in tx
+            uTX = UserTransactionUtility.beginUserTransaction();
+            
+            RequestManagerDonor.avanzaStatoInAccettata(gnpRichiesteDonor,log);
+            
+            //TUTTE LE RICHIESTE PROCESSATE PER SILENZIO ASSENSO VENGONO NOTIFICATE COME EVENTO ANOMALO C6 DI-MARIA
+            buildScartiVerificaCs(gnpRichiesteDonor,"RICHIESTA ELABORATA PER FINE WAIT","Richiesta processata per silenzio assenso",log);
+            
+            UserTransactionUtility.endUserTransaction(uTX, true);
+        }
+        catch (Exception ex) {
+          //rollback della tx corrente
+          UserTransactionUtility.endUserTransaction(uTX, false);
+          ex.printStackTrace();
+          log.write("9999", "Errore durante l'avanzamento di stato per la richiesta: " + gnpRichiesteDonor.getIdRichiesta()+" - "+ex.toString());
+          //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+          log.write("0010", " RICHIESTA "+gnpRichiesteDonor.getIdRichiesta());
+        }
+      }
+    }
+    else
+      log.write("9999","NESSUNA RICHIESTA DONOR DA ELABORARE");
+  }
+  
+  private static void buildScartiVerificaCs(GnpRichiesteDonor richiestaDon,String tipoAnomalia,String descrizioneAnomalia,ProcessLogger log) {
+	  log.write("9999","START buildScartiVerificaCs  DN: " + richiestaDon.getDn()+"Idrichiesta: "+richiestaDon.getIdRichiesta());
+
+	  GnpScartiVerificaCsDAO scartiVerificaCsDao=new GnpScartiVerificaCsDAO();
+	  GnpScartiVerificaCs scartiVerificaCs=new GnpScartiVerificaCs();
+
+	  scartiVerificaCs.setIdRichiesta(richiestaDon.getIdRichiesta());
+	  scartiVerificaCs.setDn(richiestaDon.getDn());
+	  scartiVerificaCs.setTipoAnomalia(tipoAnomalia);
+	  scartiVerificaCs.setDescrizioneAnomalia(descrizioneAnomalia);
+	  scartiVerificaCs.setCodiceSegreto(richiestaDon.getCowDonating());
+	  scartiVerificaCs.setDataInserimento(new Date());
+
+
+	  scartiVerificaCsDao.merge(scartiVerificaCs);
+
+	  log.write("9999","END buildScartiVerificaCs  DN: " + richiestaDon.getDn()+"Idrichiesta: "+richiestaDon.getIdRichiesta());
+  }
+  /**
+   * CheckChiusuraRichiestaMigrazione
+   * Esegue il passaggio di stato di tutte le richieste
+   * con stato attivo e data_scadenza precedente alla 
+   * data odierna
+   */
+  private void checkChiusuraRichiestaMigrazione() throws NamingException, Exception {
+
+    UserTransaction uTX = null;
+    GnpRichiesteDonorDAO daoRichDonor = new GnpRichiesteDonorDAO();
+    List richiesteAttive = daoRichDonor.getRichiesteScaduteConStatoAttivo();
+    
+    if (richiesteAttive!= null && richiesteAttive.size()!= 0){
+      log.write("9999","RICHIESTE ATTIVE SCADUTE :"+richiesteAttive.size());
+      for (int i = 0; i < richiesteAttive.size(); i++) {
+        GnpRichiesteDonor gnpRichiesteDonor = null;
+        try {
+        	gnpRichiesteDonor = (GnpRichiesteDonor) richiesteAttive.get(i);
+            //ogni singola richiesta è inserita in tx
+            uTX = UserTransactionUtility.beginUserTransaction();
+            RequestManagerDonor.passaggioStatoScaduta(gnpRichiesteDonor,log);
+            UserTransactionUtility.endUserTransaction(uTX, true);
+        }
+        catch (Exception ex) {
+          //rollback della tx corrente
+          UserTransactionUtility.endUserTransaction(uTX, false);
+          ex.printStackTrace();
+          log.write("9999", "Errore durante la chiusura migrazione per la richiesta: " + gnpRichiesteDonor.getIdRichiesta()+ " - "+ex.toString());
+          //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+          log.write("0010", " RICHIESTA "+gnpRichiesteDonor.getIdRichiesta());
+        }
+      }
+    }
+    else
+      log.write("9999","NESSUNA RICHIESTA DONOR DA ELABORARE");
+  }
+
+  private void checkChiusuraRichiestaMigrazione82() throws NamingException, Exception {
+
+    UserTransaction uTX = null;
+    GnpRichiesteDonor82DAO daoRichDonor = new GnpRichiesteDonor82DAO();
+    List richiesteAttive = daoRichDonor.getRichiesteScaduteConStatoAttivo();
+
+    if (richiesteAttive!= null && richiesteAttive.size()!= 0){
+      log.write("9999","RICHIESTE ATTIVE SCADUTE :"+richiesteAttive.size());
+      for (int i = 0; i < richiesteAttive.size(); i++) {
+        GnpRichiesteDonor82 gnpRichiesteDonor = null;
+        try {
+          gnpRichiesteDonor = (GnpRichiesteDonor82) richiesteAttive.get(i);
+          //ogni singola richiesta è inserita in tx
+          uTX = UserTransactionUtility.beginUserTransaction();
+          RequestManagerDonor82.passaggioStatoScaduta(gnpRichiesteDonor,log);
+          UserTransactionUtility.endUserTransaction(uTX, true);
+        }
+        catch (Exception ex) {
+          //rollback della tx corrente
+          UserTransactionUtility.endUserTransaction(uTX, false);
+          ex.printStackTrace();
+          log.write("9999", "Errore durante la chiusura migrazione per la richiesta: " + gnpRichiesteDonor.getIdRichiesta()+ " - "+ex.toString());
+          //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+          log.write("0010", " RICHIESTA "+gnpRichiesteDonor.getIdRichiesta());
+        }
+      }
+    }
+    else
+      log.write("9999","NESSUNA RICHIESTA DONOR DA ELABORARE");
+  }
+
+    }

gnpdev/dbcfx/src/it/valueteam/gnp/controller/RequestControllerNngDon.java

@@ -0,0 +1,86 @@
+package it.valueteam.gnp.controller;
+
+import it.valueteam.crontab.processexecutor.ProcessIF;
+import it.valueteam.gnp.dao.db.hb.*;
+import it.valueteam.gnp.log.Loggable;
+import it.valueteam.gnp.log.ProcessLogger;
+import it.valueteam.gnp.manager.RequestManagerCSNPg103;
+import it.valueteam.gnp.manager.RequestManagerDonNatOlo103;
+import it.valueteam.gnp.manager.RequestManagerNPg103;
+import it.valueteam.gnp.obj.LogInfo;
+import it.valueteam.gnp.obj.LogProcess;
+import it.valueteam.gnp.obj.ProcessMapper;
+import it.valueteam.gnp.utility.Resources;
+import it.valueteam.gnp.utility.UserTransactionUtility;
+
+import javax.naming.NamingException;
+import javax.transaction.UserTransaction;
+import java.util.Date;
+import java.util.List;
+
+public class RequestControllerNngDon implements Loggable, ProcessIF {
+
+    protected ProcessLogger log;
+    protected String codiceProcesso = "ZF";
+    protected final static String versione = "1.0.0";
+    protected final static String PARAM_DATA_SILENZIO_ASSENSO = "s";
+    protected final static String PARAM_DATA_SILENZIO_ASSENSO_CS = "sCS";
+
+    public RequestControllerNngDon() throws Exception{
+
+        try {
+            LogProcess logProcess = new LogProcess();
+            logProcess.setCodice(codiceProcesso);
+            logProcess.setProcess(this);
+            log = new ProcessLogger(logProcess);
+        } catch (Exception ex) {
+            System.out.println("Errore nella creazione del ProcessLogger");
+            throw ex;
+        }
+
+    }
+
+    public LogInfo getLogInfo() throws Exception {
+        LogInfo logInfo = new LogInfo();
+        logInfo.setProcess(getClass().getName());
+        logInfo.setLogPath(Resources.getLogPath());
+        logInfo.setTypeInfo(Resources.getTypeInfo());
+        logInfo.setTypeDebug(Resources.getTypeDebug());
+        logInfo.setTypeError(Resources.getTypeError());
+        return logInfo;
+    }
+
+    @Override
+    public void execute(String[] args) throws Exception {
+        try {
+            //0001 N - INIZIO PROCESSO
+            log.write("0001", " versione " + RequestControllerRec.versione);
+            if ((args==null) || (args.length==0))
+                throw new UnsupportedOperationException("Introdurre parametro di esecuzione ");
+            else {
+                if (args[0].equalsIgnoreCase(PARAM_DATA_SILENZIO_ASSENSO)) {
+                } else if (args[0].equalsIgnoreCase(PARAM_DATA_SILENZIO_ASSENSO_CS)) {
+                } else {
+                    log.write("9999 "," Parametro non riconosciuto: " + args[0]);
+                    throw new UnsupportedOperationException("Parametro di esecuzione non riconosciuto ");
+                }
+            }
+            //0002 N - PROCESSO TERMINATO CORRETTAMENTE
+            log.write("0002","");
+        }
+        catch (Exception ex) {
+            //0003 C - PROCESSO TERMINATO CON ECCEZIONI
+            log.write("0003", "" + ex.toString());
+            log.write("9999", "ECCEZIONE RILEVATA : "+ex.toString());
+            ex.printStackTrace();
+            //Termino l'esecuzione ritornando un errore a chi mi ha eseguito
+            throw ex;
+        }
+    }
+
+    public boolean requiredTX() {
+        return false;
+    }
+
+
+}

gnpdev/dbcfx/src/it/valueteam/gnp/controller/RequestControllerNngRec.java

@@ -0,0 +1,75 @@
+package it.valueteam.gnp.controller;
+
+import it.valueteam.crontab.processexecutor.ProcessIF;
+import it.valueteam.gnp.log.Loggable;
+import it.valueteam.gnp.log.ProcessLogger;
+import it.valueteam.gnp.obj.LogInfo;
+import it.valueteam.gnp.obj.LogProcess;
+import it.valueteam.gnp.utility.Resources;
+
+public class RequestControllerNngRec implements Loggable, ProcessIF {
+
+    protected ProcessLogger log;
+    protected String codiceProcesso = "ZF";
+    protected final static String versione = "1.0.0";
+    protected final static String PARAM_DATA_SILENZIO_ASSENSO = "s";
+    protected final static String PARAM_DATA_SILENZIO_ASSENSO_CS = "sCS";
+
+    public RequestControllerNngRec() throws Exception{
+
+        try {
+            LogProcess logProcess = new LogProcess();
+            logProcess.setCodice(codiceProcesso);
+            logProcess.setProcess(this);
+            log = new ProcessLogger(logProcess);
+        } catch (Exception ex) {
+            System.out.println("Errore nella creazione del ProcessLogger");
+            throw ex;
+        }
+
+    }
+
+    public LogInfo getLogInfo() throws Exception {
+        LogInfo logInfo = new LogInfo();
+        logInfo.setProcess(getClass().getName());
+        logInfo.setLogPath(Resources.getLogPath());
+        logInfo.setTypeInfo(Resources.getTypeInfo());
+        logInfo.setTypeDebug(Resources.getTypeDebug());
+        logInfo.setTypeError(Resources.getTypeError());
+        return logInfo;
+    }
+
+    @Override
+    public void execute(String[] args) throws Exception {
+        try {
+            //0001 N - INIZIO PROCESSO
+            log.write("0001", " versione " + RequestControllerRec.versione);
+            if ((args==null) || (args.length==0))
+                throw new UnsupportedOperationException("Introdurre parametro di esecuzione ");
+            else {
+                if (args[0].equalsIgnoreCase(PARAM_DATA_SILENZIO_ASSENSO)) {
+                } else if (args[0].equalsIgnoreCase(PARAM_DATA_SILENZIO_ASSENSO_CS)) {
+                } else {
+                    log.write("9999 "," Parametro non riconosciuto: " + args[0]);
+                    throw new UnsupportedOperationException("Parametro di esecuzione non riconosciuto ");
+                }
+            }
+            //0002 N - PROCESSO TERMINATO CORRETTAMENTE
+            log.write("0002","");
+        }
+        catch (Exception ex) {
+            //0003 C - PROCESSO TERMINATO CON ECCEZIONI
+            log.write("0003", "" + ex.toString());
+            log.write("9999", "ECCEZIONE RILEVATA : "+ex.toString());
+            ex.printStackTrace();
+            //Termino l'esecuzione ritornando un errore a chi mi ha eseguito
+            throw ex;
+        }
+    }
+
+    public boolean requiredTX() {
+        return false;
+    }
+
+
+}

gnpdev/dbcfx/src/it/valueteam/gnp/controller/RequestControllerNpg103.java

@@ -0,0 +1,183 @@
+package it.valueteam.gnp.controller;
+
+import it.valueteam.crontab.processexecutor.ProcessIF;
+import it.valueteam.gnp.dao.db.hb.*;
+import it.valueteam.gnp.log.Loggable;
+import it.valueteam.gnp.log.ProcessLogger;
+import it.valueteam.gnp.manager.*;
+import it.valueteam.gnp.obj.LogInfo;
+import it.valueteam.gnp.obj.LogProcess;
+import it.valueteam.gnp.obj.ProcessMapper;
+import it.valueteam.gnp.utility.Resources;
+import it.valueteam.gnp.utility.UserTransactionUtility;
+
+import javax.naming.NamingException;
+import javax.transaction.UserTransaction;
+import java.util.Date;
+import java.util.List;
+
+public class RequestControllerNpg103 implements Loggable, ProcessIF {
+
+    protected ProcessLogger log;
+    protected String codiceProcesso = "ZF";
+    protected final static String versione = "1.0.0";
+    protected final static String PARAM_DATA_SILENZIO_ASSENSO = "s";
+    protected final static String PARAM_DATA_SILENZIO_ASSENSO_CS = "sCS";
+    public static final String ESITO_SILENZIO_ASSENSO_VERIFICA_CS="ESITO VERIFICA CS";
+
+    public RequestControllerNpg103() throws Exception{
+
+        try {
+            LogProcess logProcess = new LogProcess();
+            logProcess.setCodice(codiceProcesso);
+            logProcess.setProcess(this);
+            log = new ProcessLogger(logProcess);
+        } catch (Exception ex) {
+            System.out.println("Errore nella creazione del ProcessLogger");
+            throw ex;
+        }
+
+    }
+
+    public LogInfo getLogInfo() throws Exception {
+        LogInfo logInfo = new LogInfo();
+        logInfo.setProcess(getClass().getName());
+        logInfo.setLogPath(Resources.getLogPath());
+        logInfo.setTypeInfo(Resources.getTypeInfo());
+        logInfo.setTypeDebug(Resources.getTypeDebug());
+        logInfo.setTypeError(Resources.getTypeError());
+        return logInfo;
+    }
+
+    @Override
+    public void execute(String[] args) throws Exception {
+        try {
+            //0001 N - INIZIO PROCESSO
+            log.write("0001", " versione " + RequestControllerRec.versione);
+            if ((args==null) || (args.length==0))
+                throw new UnsupportedOperationException("Introdurre parametro di esecuzione ");
+            else {
+                if (args[0].equalsIgnoreCase(PARAM_DATA_SILENZIO_ASSENSO)) {
+                    checkSilenzioAssenso();
+                } else if (args[0].equalsIgnoreCase(PARAM_DATA_SILENZIO_ASSENSO_CS)) {
+                    checkSilenzioAssensoCsNpg103();
+                } else {
+                    log.write("9999 "," Parametro non riconosciuto: " + args[0]);
+                    throw new UnsupportedOperationException("Parametro di esecuzione non riconosciuto ");
+                }
+            }
+            //0002 N - PROCESSO TERMINATO CORRETTAMENTE
+            log.write("0002","");
+        }
+        catch (Exception ex) {
+            //0003 C - PROCESSO TERMINATO CON ECCEZIONI
+            log.write("0003", "" + ex.toString());
+            log.write("9999", "ECCEZIONE RILEVATA : "+ex.toString());
+            ex.printStackTrace();
+            //Termino l'esecuzione ritornando un errore a chi mi ha eseguito
+            throw ex;
+        }
+    }
+
+    public boolean requiredTX() {
+        return false;
+    }
+
+    // 152248 checkSilenzioAssenso completata!
+    /**
+     * checkSilenzioAssenso
+     * Effettua il controllo se data silenzio assenso e' uguale alla data odierna per
+     * tutte le rcihieste in stato INVIATA_FENP  e VERIFICATA_FENP
+     * ed esegue l'avanzamento di stato in ACCETTATA
+     *
+     */
+    private void checkSilenzioAssenso() throws NamingException, Exception {
+
+        UserTransaction uTX = null;
+        GnpRichiesteNpg103DAO daoD103 = new GnpRichiesteNpg103DAO();
+        List silenzioAssenso = daoD103.getRichiesteSilenzioAssenso();
+
+        if (silenzioAssenso!= null && !silenzioAssenso.isEmpty()) {
+            log.write("9999", "RICHIESTE D103 DA ELABORARE PER SILENZIO ASSENSO:" + silenzioAssenso.size());
+
+            for (int i = 0; i < silenzioAssenso.size(); i++) {
+                GnpRichiesteNpg103 richD103 = null;
+                try {
+                    richD103 = (GnpRichiesteNpg103) silenzioAssenso.get(i);
+                    //ogni singola richiesta e' inserita in tx
+                    uTX = UserTransactionUtility.beginUserTransaction();
+                    RequestManagerNPg103.avanzaStatoInAccettata(new Date(),richD103,log);
+                    UserTransactionUtility.endUserTransaction(uTX, true);
+
+                } catch (Exception ex) {
+                    ex.printStackTrace();
+                    //rollback della tx corrente
+                    UserTransactionUtility.endUserTransaction(uTX, false);
+                    log.write("9999", "Errore durante l'avanzamento di stato per la richiesta: " + richD103.getIdRichiesta()+" - "+ex.toString());
+                    //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+                    log.write("0010", " RICHIESTA "+richD103.getIdRichiesta());
+                }
+            }
+        }
+    }
+
+    //152248 - 227248 ma serve?
+    private void checkSilenzioAssensoCsNpg103() throws Exception {
+
+        UserTransaction uTX = null;
+
+        GnpRichiesteCsNpg103DAO daoCsNpg103 = new GnpRichiesteCsNpg103DAO();
+
+        List silenzioAssenso = daoCsNpg103.getRichiesteSilenzioAssenso();
+
+        if (silenzioAssenso!= null && !silenzioAssenso.isEmpty()){
+            log.write("9999","RICHIESTE CS-NPg103 DA ELABORARE PER SILENZIO ASSENSO:"+silenzioAssenso.size());
+            for (int i = 0; i < silenzioAssenso.size(); i++) {
+                GnpRichiesteCsNpg103 richCsNpg103 = null;
+                try {
+                    richCsNpg103 = (GnpRichiesteCsNpg103) silenzioAssenso.get(i);
+                    //ogni singola richiesta e' inserita in tx
+                    uTX = UserTransactionUtility.beginUserTransaction();
+                    if (richCsNpg103.getProcesso().equals(ProcessMapper.proc_CS_NPg103)){
+                        RequestManagerCSNPg103.avanzaStatoInEspletata(richCsNpg103, log);
+                    } else {
+                        RequestManagerDonNatOlo103.avanzaStatoInEspletata(richCsNpg103, log);
+                    }
+
+                    buildScartiVerificaCsNpg103(richCsNpg103,ESITO_SILENZIO_ASSENSO_VERIFICA_CS,"TIMEOUT DI RISPOSTA VERIFICA CS",log);
+
+                    UserTransactionUtility.endUserTransaction(uTX, true);
+                }
+                catch (Exception ex) {
+                    //rollback della tx corrente
+                    UserTransactionUtility.endUserTransaction(uTX, false);
+                    ex.printStackTrace();
+                    log.write("9999", "Errore durante l'avanzamento di stato per la richiesta: " + richCsNpg103.getIdRichiesta()+" - "+ex.toString());
+                    //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+                    log.write("0010", " RICHIESTA "+richCsNpg103.getIdRichiesta());
+                }
+            }
+        }
+        else
+            log.write("9999","NESSUNA RICHIESTA DONOR DA ELABORARE");
+    }
+
+    private static void buildScartiVerificaCsNpg103(GnpRichiesteCsNpg103 richiestaCs,String tipoAnomalia,String descrizioneAnomalia,ProcessLogger log) {
+        log.write("9999","START buildScartiVerificaCs  DN: " + richiestaCs.getDn()+"Idrichiesta: "+richiestaCs.getIdRichiesta());
+
+        GnpScartiVerificaCsDAO scartiVerificaCsDao=new GnpScartiVerificaCsDAO();
+        GnpScartiVerificaCs scartiVerificaCs=new GnpScartiVerificaCs();
+
+        scartiVerificaCs.setIdRichiesta(richiestaCs.getIdRichiesta());
+        scartiVerificaCs.setDn(richiestaCs.getDn());
+        scartiVerificaCs.setTipoAnomalia(tipoAnomalia);
+        scartiVerificaCs.setDescrizioneAnomalia(descrizioneAnomalia);
+        scartiVerificaCs.setCodiceSegreto(richiestaCs.getCodiceSegreto());
+        scartiVerificaCs.setDataInserimento(new Date());
+
+
+        scartiVerificaCsDao.merge(scartiVerificaCs);
+
+        log.write("9999","END buildScartiVerificaCs  DN: " + richiestaCs.getDn()+"Idrichiesta: "+richiestaCs.getIdRichiesta());
+    }
+}

gnpdev/dbcfx/src/it/valueteam/gnp/controller/RequestControllerNpg35.java

@@ -0,0 +1,220 @@
+package it.valueteam.gnp.controller;
+
+import java.util.Date;
+import java.util.List;
+
+import javax.naming.NamingException;
+import javax.transaction.UserTransaction;
+
+import it.valueteam.crontab.processexecutor.*;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteCsNpg35;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteCsNpg35DAO;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteNpg35;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteNpg35DAO;
+import it.valueteam.gnp.dao.db.hb.GnpScartiVerificaCs;
+import it.valueteam.gnp.dao.db.hb.GnpScartiVerificaCsDAO;
+import it.valueteam.gnp.log.*;
+import it.valueteam.gnp.manager.RequestManagerCSNPg35;
+import it.valueteam.gnp.manager.RequestManagerNPg35;
+import it.valueteam.gnp.obj.*;
+import it.valueteam.gnp.utility.*;
+
+
+/**
+ * <p>Title: RequestControllerRec</p>
+ * <p>Description: </p>
+ * <p>Copyright: Copyright (c) 2002</p>
+ * <p>Company: </p>
+ * @author unascribed
+ * @version 1.0
+ */
+public class RequestControllerNpg35  implements Loggable, ProcessIF {
+
+  protected ProcessLogger log;
+  protected String codiceProcesso = "ZD";
+  protected final static String versione = "1.0.0";
+  protected final static String PARAM_DATA_SILENZIO_ASSENSO = "s";
+  protected final static String PARAM_DATA_SILENZIO_ASSENSO_CS = "sCS";
+  public static final String ESITO_SILENSIO_ASSENSO_VERIFICA_CS="ESITO VERIFICA CS";
+
+  public RequestControllerNpg35() throws Exception {
+    try {
+      LogProcess logProcess = new LogProcess();
+      logProcess.setCodice(codiceProcesso);
+      logProcess.setProcess(this);
+      log = new ProcessLogger(logProcess);
+    }
+    catch (Exception ex) {
+      System.out.println("Errore nella creazione del ProcessLogger");
+      throw ex;
+    }
+  }
+
+  public LogInfo getLogInfo() throws Exception {
+    LogInfo logInfo = new LogInfo();
+    logInfo.setProcess(getClass().getName());
+    logInfo.setLogPath(Resources.getLogPath());
+    logInfo.setTypeInfo(Resources.getTypeInfo());
+    logInfo.setTypeDebug(Resources.getTypeDebug());
+    logInfo.setTypeError(Resources.getTypeError());
+    return logInfo;
+  }
+
+
+  /**
+   * requiredTX
+   *
+   * @return boolean
+   */
+  public boolean requiredTX() {
+    return false;
+  }
+
+
+public void execute(String[] args) throws Exception {
+    try {
+      //0001 N - INIZIO PROCESSO
+      log.write("0001", " versione " + RequestControllerRec.versione);
+      if ((args==null) || (args.length==0))
+        throw new UnsupportedOperationException("Introdurre parametro di esecuzione ");
+      else {
+        if (args[0].equalsIgnoreCase(RequestControllerNpg35.PARAM_DATA_SILENZIO_ASSENSO)) {
+         checkSilenzioAssenso();
+        }
+        else if (args[0].equalsIgnoreCase(RequestControllerNpg35.PARAM_DATA_SILENZIO_ASSENSO_CS)) {
+             checkSilenzioAssensoCsNpg35();
+            }
+        else {
+          log.write("9999 "," Paramentro non riconosciuto: " + args[0]);
+          throw new UnsupportedOperationException("Parametro di esecuzione non riconosciuto ");
+        }
+      }
+      //0002 N - PROCESSO TERMINATO CORRETTAMENTE
+      log.write("0002","");
+      }
+    catch (Exception ex) {
+      //0003 C - PROCESSO TERMINATO CON ECCEZIONI
+      log.write("0003", "" + ex.toString());
+      log.write("9999", "ECCEZIONE RILEVATA : "+ex.toString());
+      ex.printStackTrace();
+      //Termino l'esecuzione ritornando un errore a chi mi ha eseguito
+      throw ex;
+    }
+}
+
+/**
+ * checkSilenzioAssenso
+ * Effettua il controllo se data silenzio assenso e' uguale alla data odierna per
+ * tutte le rcihieste in stato INVIATA_FENP  e VERIFICATA_FENP
+ * ed esegue l'avanzamento di stato in ACCETTATA
+ *
+ */
+private void checkSilenzioAssensoCsNpg35() throws NamingException, Exception {
+
+  UserTransaction uTX = null;
+  
+  GnpRichiesteCsNpg35DAO daoCsNpg35 = new GnpRichiesteCsNpg35DAO();
+  String timeout=Resources.getTIMEOUT_SILENZIO_ASSENSO_NPG35();
+  
+  //Analisi Doppia Fatturazione - Cluster A08A09 (MDC)  verifica codice segreto piattaforma errata  Portabilite'  Del.35 - aperta segnalazione DBCFX_SM_478.
+  //Passaggio parametro di timeout
+  List silenzioAssenso = daoCsNpg35.getRichiesteSilenzioAssenso(timeout);
+  
+  if (silenzioAssenso!= null && silenzioAssenso.size()!= 0){
+    log.write("9999","RICHIESTE CS-NPg35 DA ELABORARE PER SILENZIO ASSENSO:"+silenzioAssenso.size());
+    for (int i = 0; i < silenzioAssenso.size(); i++) {
+    	GnpRichiesteCsNpg35 richCsNpg35 = null;
+      try {
+    	  richCsNpg35 = (GnpRichiesteCsNpg35) silenzioAssenso.get(i);
+          //ogni singola richiesta e' inserita in tx
+          uTX = UserTransactionUtility.beginUserTransaction();
+          /*
+           * PROBLEMA DOPPIA COMMERCIALIZZAZIONE
+           * non passare la richiesta in espletata,ma effettuare un ulteriore verifica con questa logica:
+           * Se ho già invocato entrambi i CRM, riprovo su quello che non mi ha risposto
+           * Se è ancora il primo, passo al secondo
+           * 
+           *
+          */
+          RequestManagerCSNPg35.avanzaStatoInEspletata(richCsNpg35, log);
+          
+          buildScartiVerificaCsNpg35(richCsNpg35,ESITO_SILENSIO_ASSENSO_VERIFICA_CS,"TIMEOUT DI RISPOSTA VERIFICA CS",log);
+          
+          UserTransactionUtility.endUserTransaction(uTX, true);
+      }
+      catch (Exception ex) {
+        //rollback della tx corrente
+        UserTransactionUtility.endUserTransaction(uTX, false);
+        ex.printStackTrace();
+        log.write("9999", "Errore durante l'avanzamento di stato per la richiesta: " + richCsNpg35.getIdRichiesta()+" - "+ex.toString());
+        //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+        log.write("0010", " RICHIESTA "+richCsNpg35.getIdRichiesta());
+      }
+    }
+  }
+  else
+    log.write("9999","NESSUNA RICHIESTA DONOR DA ELABORARE");
+}
+
+private static void buildScartiVerificaCsNpg35(GnpRichiesteCsNpg35 richiestaCs,String tipoAnomalia,String descrizioneAnomalia,ProcessLogger log) {
+	log.write("9999","START buildScartiVerificaCs  DN: " + richiestaCs.getDn()+"Idrichiesta: "+richiestaCs.getIdRichiesta());
+	
+	GnpScartiVerificaCsDAO scartiVerificaCsDao=new GnpScartiVerificaCsDAO();
+    GnpScartiVerificaCs scartiVerificaCs=new GnpScartiVerificaCs();
+    
+    scartiVerificaCs.setIdRichiesta(richiestaCs.getIdRichiesta());
+    scartiVerificaCs.setDn(richiestaCs.getDn());
+    scartiVerificaCs.setTipoAnomalia(tipoAnomalia);
+    scartiVerificaCs.setDescrizioneAnomalia(descrizioneAnomalia);
+    scartiVerificaCs.setCodiceSegreto(richiestaCs.getCodiceSegreto());
+    scartiVerificaCs.setDataInserimento(new Date());
+
+    
+    scartiVerificaCsDao.merge(scartiVerificaCs);
+    
+    log.write("9999","END buildScartiVerificaCs  DN: " + richiestaCs.getDn()+"Idrichiesta: "+richiestaCs.getIdRichiesta());
+}
+
+/**
+ * checkSilenzioAssenso
+ * Effettua il controllo se data silenzio assenso e' uguale alla data odierna per
+ * tutte le rcihieste in stato INVIATA_FENP  e VERIFICATA_FENP
+ * ed esegue l'avanzamento di stato in ACCETTATA
+ *
+ */
+private void checkSilenzioAssenso() throws NamingException, Exception {
+
+  UserTransaction uTX = null;
+  GnpRichiesteNpg35DAO daoNpg35 = new GnpRichiesteNpg35DAO();
+  List silenzioAssenso = daoNpg35.getRichiesteSilenzioAssenso();
+  log.write("9999", "Inizia check silenzio assenso");
+  
+  if (silenzioAssenso!= null && silenzioAssenso.size()!= 0){
+    log.write("9999","RICHIESTE NPg35 DA ELABORARE PER SILENZIO ASSENSO:"+silenzioAssenso.size());
+    for (int i = 0; i < silenzioAssenso.size(); i++) {
+    	GnpRichiesteNpg35 richNpg35 = null;
+      try {
+    	  richNpg35 = (GnpRichiesteNpg35) silenzioAssenso.get(i);
+          //ogni singola richiesta e' inserita in tx
+          uTX = UserTransactionUtility.beginUserTransaction();
+          RequestManagerNPg35.avanzaStatoInAccettata(new Date(),richNpg35,log);
+          UserTransactionUtility.endUserTransaction(uTX, true);
+      }
+      catch (Exception ex) {
+        ex.printStackTrace();
+        //rollback della tx corrente
+        UserTransactionUtility.endUserTransaction(uTX, false);
+        log.write("9999", "Errore durante l'avanzamento di stato per la richiesta: " + richNpg35.getIdRichiesta()+" - "+ex.toString());
+        //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+        log.write("0010", " RICHIESTA "+richNpg35.getIdRichiesta());
+      }
+    }
+  }
+  else
+    log.write("9999","NESSUNA RICHIESTA DONOR DA ELABORARE");
+}
+
+  
+	  
+
+}

gnpdev/dbcfx/src/it/valueteam/gnp/controller/RequestControllerOlo103MN.java

@@ -0,0 +1,112 @@
+package it.valueteam.gnp.controller;
+
+import it.valueteam.crontab.processexecutor.ProcessIF;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteOlo103mn;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteOlo103mnDAO;
+import it.valueteam.gnp.log.Loggable;
+import it.valueteam.gnp.log.ProcessLogger;
+import it.valueteam.gnp.manager.RequestManagerOlo103MN;
+import it.valueteam.gnp.obj.LogInfo;
+import it.valueteam.gnp.obj.LogProcess;
+import it.valueteam.gnp.utility.Resources;
+import it.valueteam.gnp.utility.UserTransactionUtility;
+
+import javax.naming.NamingException;
+import javax.transaction.UserTransaction;
+import java.util.List;
+
+public class RequestControllerOlo103MN implements Loggable, ProcessIF {
+
+	  protected ProcessLogger log;
+	  protected String codiceProcesso = "ZG";
+	  protected final static String versione = "1.0.0";
+	  protected final static String PARAM_DATA_SILENZIO_ASSENSO = "s";
+
+	  public RequestControllerOlo103MN() throws Exception {
+		    try {
+		      LogProcess logProcess = new LogProcess();
+		      logProcess.setCodice(codiceProcesso);
+		      logProcess.setProcess(this);
+		      log = new ProcessLogger(logProcess);
+		    }
+		    catch (Exception ex) {
+		      System.out.println("Errore nella creazione del ProcessLogger");
+		      throw ex;
+		    }
+		  }
+	  
+	  public LogInfo getLogInfo() throws Exception {
+		    LogInfo logInfo = new LogInfo();
+		    logInfo.setProcess(getClass().getName());
+		    logInfo.setLogPath(Resources.getLogPath());
+		    logInfo.setTypeInfo(Resources.getTypeInfo());
+		    logInfo.setTypeDebug(Resources.getTypeDebug());
+		    logInfo.setTypeError(Resources.getTypeError());
+		    return logInfo;
+		  }
+	  /**
+	   * requiredTX
+	   *
+	   * @return boolean
+	   */
+	  public boolean requiredTX() {
+	    return false;
+	  }
+
+	  public void execute(String[] args) throws Exception {
+		    try {
+		        //0001 N - INIZIO PROCESSO
+		        log.write("0001", " versione " + RequestControllerRec.versione);
+		        if ((args==null) || (args.length==0)){
+		            throw new UnsupportedOperationException("Introdurre parametro di esecuzione ");
+		        }
+		        else {
+		        	  if (args[0].equalsIgnoreCase(RequestControllerNpg103.PARAM_DATA_SILENZIO_ASSENSO)) {
+		            	checkSilenzioAssenso();
+		            	}
+		        	}
+		        } catch (Exception ex) {
+		            //0003 C - PROCESSO TERMINATO CON ECCEZIONI
+		            log.write("0003", "" + ex.toString());
+		            log.write("9999", "ECCEZIONE RILEVATA : "+ex.toString());
+		            ex.printStackTrace();
+		            //Termino l'esecuzione ritornando un errore a chi mi ha eseguito
+		            throw ex;
+		          }
+	  }
+	  
+	  /**
+	   * checkSilenzioAssenso
+	   * Effettua il controllo se data silenzio assenso è uguale alla data odierna per
+	   * tutte le rcihieste in stato INVIATA_FENP  e VERIFICATA_FENP
+	   * ed esegue l'avanzamento di stato in ACCETTATA
+	   *
+	   */
+	  private void checkSilenzioAssenso() throws NamingException, Exception {
+		  UserTransaction uTX = null;
+		  GnpRichiesteOlo103mnDAO olo103Dao=new GnpRichiesteOlo103mnDAO();
+		  List silenzioAssenso = olo103Dao.getRichiesteSilenzioAssenso();
+		  for (int i = 0; i < silenzioAssenso.size(); i++) {
+		  if (silenzioAssenso!= null && silenzioAssenso.size()!= 0){
+			  log.write("9999","RICHIESTE OLONPg103MN DA ELABORARE PER SILENZIO ASSENSO:"+silenzioAssenso.size());
+			  GnpRichiesteOlo103mn olo103Mn = null;
+		      try {
+		    	  olo103Mn = (GnpRichiesteOlo103mn) silenzioAssenso.get(i);
+		          //ogni singola richiesta è inserita in tx
+		          uTX = UserTransactionUtility.beginUserTransaction();
+		          RequestManagerOlo103MN.avanzaStatoInAccettata(olo103Mn,log);
+		          UserTransactionUtility.endUserTransaction(uTX, true);
+		      }
+		      catch (Exception ex) {
+		        //rollback della tx corrente
+		        UserTransactionUtility.endUserTransaction(uTX, false);
+		        ex.printStackTrace();
+		        log.write("9999", "Errore durante l'avanzamento di stato per la richiesta: " + olo103Mn.getIdRichiesta()+" - "+ex.toString());
+		        //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+		        log.write("0010", " RICHIESTA "+olo103Mn.getIdRichiesta());
+		      }
+		  }
+		 }
+		  
+	  }
+}

gnpdev/dbcfx/src/it/valueteam/gnp/controller/RequestControllerOlo35MN.java

@@ -0,0 +1,115 @@
+package it.valueteam.gnp.controller;
+
+import java.util.List;
+
+import javax.naming.NamingException;
+import javax.transaction.UserTransaction;
+
+import it.valueteam.crontab.processexecutor.ProcessIF;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteNpg35;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteOlo35mn;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteOlo35mnDAO;
+import it.valueteam.gnp.log.Loggable;
+import it.valueteam.gnp.log.ProcessLogger;
+import it.valueteam.gnp.manager.RequestManagerNPg35;
+import it.valueteam.gnp.manager.RequestManagerOlo35MN;
+import it.valueteam.gnp.obj.LogInfo;
+import it.valueteam.gnp.obj.LogProcess;
+import it.valueteam.gnp.utility.Resources;
+import it.valueteam.gnp.utility.UserTransactionUtility;
+
+public class RequestControllerOlo35MN implements Loggable, ProcessIF {
+
+	  protected ProcessLogger log;
+	  protected String codiceProcesso = "ZM";
+	  protected final static String versione = "1.0.0";
+	  protected final static String PARAM_DATA_SILENZIO_ASSENSO = "s";
+	  
+	  public RequestControllerOlo35MN() throws Exception {
+		    try {
+		      LogProcess logProcess = new LogProcess();
+		      logProcess.setCodice(codiceProcesso);
+		      logProcess.setProcess(this);
+		      log = new ProcessLogger(logProcess);
+		    }
+		    catch (Exception ex) {
+		      System.out.println("Errore nella creazione del ProcessLogger");
+		      throw ex;
+		    }
+		  }
+	  
+	  public LogInfo getLogInfo() throws Exception {
+		    LogInfo logInfo = new LogInfo();
+		    logInfo.setProcess(getClass().getName());
+		    logInfo.setLogPath(Resources.getLogPath());
+		    logInfo.setTypeInfo(Resources.getTypeInfo());
+		    logInfo.setTypeDebug(Resources.getTypeDebug());
+		    logInfo.setTypeError(Resources.getTypeError());
+		    return logInfo;
+		  }
+	  /**
+	   * requiredTX
+	   *
+	   * @return boolean
+	   */
+	  public boolean requiredTX() {
+	    return false;
+	  }
+
+	  public void execute(String[] args) throws Exception {
+		    try {
+		        //0001 N - INIZIO PROCESSO
+		        log.write("0001", " versione " + RequestControllerRec.versione);
+		        if ((args==null) || (args.length==0)){
+		            throw new UnsupportedOperationException("Introdurre parametro di esecuzione ");
+		        }
+		        else {
+		        	  if (args[0].equalsIgnoreCase(RequestControllerNpg35.PARAM_DATA_SILENZIO_ASSENSO)) {
+		            	checkSilenzioAssenso();
+		            	}
+		        	}
+		        } catch (Exception ex) {
+		            //0003 C - PROCESSO TERMINATO CON ECCEZIONI
+		            log.write("0003", "" + ex.toString());
+		            log.write("9999", "ECCEZIONE RILEVATA : "+ex.toString());
+		            ex.printStackTrace();
+		            //Termino l'esecuzione ritornando un errore a chi mi ha eseguito
+		            throw ex;
+		          }
+	  }
+	  
+	  /**
+	   * checkSilenzioAssenso
+	   * Effettua il controllo se data silenzio assenso è uguale alla data odierna per
+	   * tutte le rcihieste in stato INVIATA_FENP  e VERIFICATA_FENP
+	   * ed esegue l'avanzamento di stato in ACCETTATA
+	   *
+	   */
+	  private void checkSilenzioAssenso() throws NamingException, Exception {
+		  UserTransaction uTX = null;
+		  GnpRichiesteOlo35mnDAO olo35Dao=new GnpRichiesteOlo35mnDAO();
+		  List silenzioAssenso = olo35Dao.getRichiesteSilenzioAssenso();
+		  for (int i = 0; i < silenzioAssenso.size(); i++) {
+		  if (silenzioAssenso!= null && silenzioAssenso.size()!= 0){
+			  log.write("9999","RICHIESTE OLONPg35MN DA ELABORARE PER SILENZIO ASSENSO:"+silenzioAssenso.size());
+			  GnpRichiesteOlo35mn olo35Mn = null;
+		      try {
+		    	  olo35Mn = (GnpRichiesteOlo35mn) silenzioAssenso.get(i);
+		          //ogni singola richiesta è inserita in tx
+		          uTX = UserTransactionUtility.beginUserTransaction();
+		          RequestManagerOlo35MN.avanzaStatoInAccettata(olo35Mn,log);
+		          UserTransactionUtility.endUserTransaction(uTX, true);
+		      }
+		      catch (Exception ex) {
+		        //rollback della tx corrente
+		        UserTransactionUtility.endUserTransaction(uTX, false);
+		        ex.printStackTrace();
+		        log.write("9999", "Errore durante l'avanzamento di stato per la richiesta: " + olo35Mn.getIdRichiesta()+" - "+ex.toString());
+		        //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+		        log.write("0010", " RICHIESTA "+olo35Mn.getIdRichiesta());
+		      }
+		  }
+		 }
+		  
+	  }
+}

gnpdev/dbcfx/src/it/valueteam/gnp/controller/RequestControllerRec.java

@@ -0,0 +1,218 @@
+package it.valueteam.gnp.controller;
+
+import java.util.*;
+
+import javax.transaction.*;
+import javax.naming.*;
+
+import it.valueteam.crontab.processexecutor.*;
+import it.valueteam.gnp.log.*;
+import it.valueteam.gnp.obj.*;
+import it.valueteam.gnp.utility.*;
+import it.valueteam.gnp.dao.RichiestaRecipientLoader;
+import it.valueteam.gnp.dao.db.hb.*;
+import it.valueteam.gnp.exception.StateTransitionNotPossibleException;
+import it.valueteam.gnp.manager.*;
+
+
+/**
+ * <p>Title: RequestControllerRec</p>
+ * <p>Description: </p>
+ * <p>Copyright: Copyright (c) 2002</p>
+ * <p>Company: </p>
+ * @author unascribed
+ * @version 1.0
+ */
+public class RequestControllerRec  implements Loggable, ProcessIF {
+
+  protected ProcessLogger log;
+  protected String codiceProcesso = "CA";
+  protected final static String versione = "1.0.0";
+  protected final static String PARAM_CHECK_DATA_WAIT_OLO = "c";
+
+
+  public RequestControllerRec() throws Exception {
+    try {
+      LogProcess logProcess = new LogProcess();
+      logProcess.setCodice(codiceProcesso);
+      logProcess.setProcess(this);
+      log = new ProcessLogger(logProcess);
+    }
+    catch (Exception ex) {
+      System.out.println("Errore nella creazione del ProcessLogger");
+      throw ex;
+    }
+  }
+
+  public LogInfo getLogInfo() throws Exception {
+    LogInfo logInfo = new LogInfo();
+    logInfo.setProcess(getClass().getName());
+    logInfo.setLogPath(Resources.getLogPath());
+    logInfo.setTypeInfo(Resources.getTypeInfo());
+    logInfo.setTypeDebug(Resources.getTypeDebug());
+    logInfo.setTypeError(Resources.getTypeError());
+    return logInfo;
+  }
+
+
+  /**
+   * requiredTX
+   *
+   * @return boolean
+   */
+  public boolean requiredTX() {
+    return false;
+  }
+
+
+public void execute(String[] args) throws Exception {
+    try {
+      //0001 N - INIZIO PROCESSO
+      log.write("0001", " versione " + RequestControllerRec.versione);
+      if ((args==null) || (args.length==0))
+        throw new UnsupportedOperationException("Introdurre parametro di esecuzione ");
+      else {
+    	  //ANALISI DFW
+        if (args[0].equalsIgnoreCase(RequestControllerRec.PARAM_CHECK_DATA_WAIT_OLO)) {
+          checkFineDataWaitOLOStandardRequest();
+          checkFineDataWaitOLOMultilineaRequest();
+        }
+        else {
+          log.write("9999 "," Paramentro non riconosciuto: " + args[0]);
+          throw new UnsupportedOperationException("Parametro di esecuzione non riconosciuto ");
+        }
+      }
+      //0002 N - PROCESSO TERMINATO CORRETTAMENTE
+      log.write("0002","");
+      }
+    catch (Exception ex) {
+      //0003 C - PROCESSO TERMINATO CON ECCEZIONI
+      log.write("0003", "" + ex.toString());
+      log.write("9999", "ECCEZIONE RILEVATA : "+ex.toString());
+      ex.printStackTrace();
+      //Termino l'esecuzione ritornando un errore a chi mi ha eseguito
+      throw ex;
+    }
+}
+
+  /**
+   * CeckFineDataWaitOLO
+   * Effettua il controllo se waitOLO è uguale alla data odierna per
+   * tutte le rcihieste in stato INVIATA e VALIDATAOLO
+   * ed esegue l'avanzamento di stato
+   *
+   */
+  private void checkFineDataWaitOLOStandardRequest() throws NamingException, Exception {
+
+    UserTransaction uTX = null;
+    List listaWaitOlo = RichiestaRecipientLoader.getRequestFineWaitOLOStandard();
+    
+    if (listaWaitOlo!= null && listaWaitOlo.size()!= 0){
+      log.write("9999","RICHIESTE STANDARD DA ELABORARE:"+listaWaitOlo.size());
+      for (int i = 0; i < listaWaitOlo.size(); i++) {
+        GnpRichiesteRec gnpRichiesteRec = null;
+        try {
+          gnpRichiesteRec = (GnpRichiesteRec) listaWaitOlo.get(i);
+          //ogni singola richiesta è inserita in tx
+          uTX = UserTransactionUtility.beginUserTransaction();
+          //sfilo la richiesta dal pacchetto multilinea facendola diventare una richiesta standard
+          //perchè alla data di fine wait del pacchetto l'olo non ha ancora risposto con l'accettazione
+          //oppure perchè sono ancora in attesa reinvio
+	          RequestManagerRec.avanzaStatoInValidating(gnpRichiesteRec, log);
+	          UserTransactionUtility.endUserTransaction(uTX, true);
+          
+        }catch(StateTransitionNotPossibleException stex){
+        	 UserTransactionUtility.endUserTransaction(uTX, false);
+        }
+        catch (Exception ex) {
+          //rollback della tx corrente
+          UserTransactionUtility.endUserTransaction(uTX, false);
+          ex.printStackTrace();
+          log.write("9999", "Errore durante l'avanzamento di stato per la richiesta: " + gnpRichiesteRec.getIdRichiesta()+" - "+ex.toString());
+          //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+          log.write("0010", " RICHIESTA "+gnpRichiesteRec.getIdRichiesta());
+        }
+      }
+    }
+    else
+      log.write("9999","NESSUNA RICHIESTA DA ELABORARE");
+  }
+
+  /**
+   * CaricaListaWaitOlo
+   *
+   * @return List
+   */
+  private void aggiornaPacchettoMultilinea(String codiceCorrelazione) throws Exception{
+
+    List richieste=null;
+    GnpRichiesteRecDAO dao = new GnpRichiesteRecDAO();
+
+    List states = new ArrayList();
+	states.add(new Long(StatoRichiestaRec.ATTESAREINVIO));
+	states.add(new Long(StatoRichiestaRec.INVIATA));
+	richieste = RichiestaRecipientLoader.getRequestByCriteria(states, codiceCorrelazione, true);
+	for(int i=0; i<richieste.size(); i++){
+		GnpRichiesteRec rec = (GnpRichiesteRec)richieste.get(i);
+		rec.setPrjMlMs(new Long(0));
+		dao.merge(rec);
+		log.write("9999", "LA RICHIESTA ID_RICHIESTA: " +rec.getIdRichiesta()+" " +
+    	  		"E' STATA SFILATA DAL PACCHETTO MULTILINEA CON CODICE CORRELAZIONE :" +rec.getCodCorrelazione());
+	}
+
+  }
+  
+  private void checkFineDataWaitOLOMultilineaRequest() throws NamingException, Exception {
+
+	    UserTransaction uTX = null;
+	    Map waitOloMap = RichiestaRecipientLoader.getRequestFineWaitOLOMultilinea();
+	    log.write("9999","PACCHETTI MULTILINEA DA ELABORARE :"+waitOloMap.size());
+	    
+	    if (waitOloMap!= null && waitOloMap.size()> 0){
+	    	
+	    	List multilineaRichiesteRec = null;
+	    	Set multilineaKeySet = waitOloMap.keySet();
+	    	
+	    		Iterator iter = multilineaKeySet.iterator();
+	    		GnpMlineaMsede gnpMlineaMsedeDto = null;
+		    	while(iter.hasNext()) {
+		    		try{
+		    			uTX = UserTransactionUtility.beginUserTransaction();
+		    			gnpMlineaMsedeDto  = (GnpMlineaMsede)iter.next();
+		    			log.write("9999", "ESEGUO L'AVANZAMENTO DI STATO IN VALIDATING PER LE RICHIESTE DEL PACCHETTO MULTILINEA : " +
+		    					"" + gnpMlineaMsedeDto.getIdCorrelazione());		    			
+		    			multilineaRichiesteRec = (List)waitOloMap.get(gnpMlineaMsedeDto);
+		    				
+		    			for(int i =0; i<multilineaRichiesteRec.size(); i++){
+		    				GnpRichiesteRec richiesteRec=(GnpRichiesteRec)multilineaRichiesteRec.get(i);		    			
+		    				RequestManagerRec.avanzaStatoInValidating(richiesteRec, log);
+		    			}
+		    			//sfilo dal pacchetto multilinea le richieste che sono rimaste indietro
+		    			aggiornaPacchettoMultilinea(gnpMlineaMsedeDto.getIdCorrelazione());
+		    			UserTransactionUtility.endUserTransaction(uTX, true);
+		    			log.write("9999", "AVANZAMENTO DI STATO IN VALIDATING PER LE RICHIESTE DEL PACCHETTO MULTILINEA : " +
+		    					"" + gnpMlineaMsedeDto.getIdCorrelazione() + " ESEGUITO CON SUCCESSO");
+		    		}catch(StateTransitionNotPossibleException stex){
+		    			 UserTransactionUtility.endUserTransaction(uTX, false);
+		    			 log.write("9999", "AVANZAMENTO DI STATO IN VALIDATING PER LE RICHIESTE DEL PACCHETTO MULTILINEA : " +
+			    					"" + gnpMlineaMsedeDto.getIdCorrelazione() + " NON ESEGUITO !!");
+		    		}catch(Exception ex){
+		    			 //rollback della tx corrente
+		  	          UserTransactionUtility.endUserTransaction(uTX, false);
+		  	          ex.printStackTrace();
+		  	          log.write("9999", "ERRORE DURANTE GLI AVANZAMENTI DI STATO DELLE RICHIESTE DEL PACHETTO MULTILINEA " +
+		  	          		": " + gnpMlineaMsedeDto.getIdCorrelazione()+ " - "
+		  	          		+ex.toString());
+		    			
+		    		}
+		    	}
+	    }else{
+	    	 log.write("9999","NESSUN PACCHETTO MULTILINEA DA ELABORARE");
+	    }
+  }
+	    	
+	      
+	     
+	  
+
+}

gnpdev/dbcfx/src/it/valueteam/gnp/controller/RequestControllerVoip103.java

@@ -0,0 +1,105 @@
+package it.valueteam.gnp.controller;
+
+import it.valueteam.crontab.processexecutor.ProcessIF;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteVoip103;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteVoip103DAO;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteVoip103;
+import it.valueteam.gnp.log.Loggable;
+import it.valueteam.gnp.log.ProcessLogger;
+import it.valueteam.gnp.manager.RequestManagerVOIP103;
+import it.valueteam.gnp.obj.LogInfo;
+import it.valueteam.gnp.obj.LogProcess;
+import it.valueteam.gnp.utility.Resources;
+import it.valueteam.gnp.utility.UserTransactionUtility;
+
+import javax.transaction.UserTransaction;
+import java.util.List;
+
+public class RequestControllerVoip103 implements Loggable, ProcessIF {
+
+    protected final static String versione = "1.0.0";
+    protected final static String PARAM_DATA_SILENZIO_ASSENSO = "s";
+    protected ProcessLogger log;
+    protected String codiceProcesso = "ZS";
+
+    public RequestControllerVoip103() throws Exception {
+        try {
+            LogProcess logProcess = new LogProcess();
+            logProcess.setCodice(codiceProcesso);
+            logProcess.setProcess(this);
+            log = new ProcessLogger(logProcess);
+        } catch (Exception ex) {
+            System.out.println("Errore nella creazione del ProcessLogger");
+            throw ex;
+        }
+    }
+
+    @Override
+    public void execute(String[] args) throws Exception {
+        try {
+            //0001 N - INIZIO PROCESSO
+            log.write("0001", " versione " + RequestControllerVoip103.versione);
+            if ((args == null) || (args.length == 0)) {
+                throw new UnsupportedOperationException("Introdurre parametro di esecuzione ");
+            } else {
+                if (args[0].equalsIgnoreCase(RequestControllerVoip103.PARAM_DATA_SILENZIO_ASSENSO)) {
+                    checkSilenzioAssenso();
+                }
+            }
+        } catch (Exception ex) {
+            //0003 C - PROCESSO TERMINATO CON ECCEZIONI
+            log.write("0003", "" + ex.toString());
+            log.write("9999", "ECCEZIONE RILEVATA : " + ex.toString());
+            ex.printStackTrace();
+            //Termino l'esecuzione ritornando un errore a chi mi ha eseguito
+            throw ex;
+        }
+    }
+
+    /**
+     * checkSilenzioAssenso
+     * Effettua il controllo se data silenzio assenso e' uguale alla data odierna per
+     * tutte le richieste in stato INVIATA_FENP e VERIFICATA_FENP
+     * ed esegue l'avanzamento di stato in ACCETTATA
+     */
+    private void checkSilenzioAssenso() throws Exception{
+        UserTransaction uTX = null;
+        GnpRichiesteVoip103DAO voip103Dao = new GnpRichiesteVoip103DAO();
+        List<GnpRichiesteVoip103> silenzioAssenso = voip103Dao.getRichiesteSilenzioAssenso();
+        for (GnpRichiesteVoip103 gnpRichiesteVoip103 : silenzioAssenso) {
+            log.write("9999", "RICHIESTE VOIP103 DA ELABORARE PER SILENZIO ASSENSO:" + silenzioAssenso.size());
+            try {
+                //ogni singola richiesta e' inserita in tx
+                uTX = UserTransactionUtility.beginUserTransaction();
+                // refresh object to current transaction
+                voip103Dao.getSession().update(gnpRichiesteVoip103);
+
+                RequestManagerVOIP103.avanzaStatoInAccettata(gnpRichiesteVoip103, log);
+                UserTransactionUtility.endUserTransaction(uTX, true);
+            } catch (Exception ex) {
+                //rollback della tx corrente
+                if (uTX != null) UserTransactionUtility.endUserTransaction(uTX, false);
+                ex.printStackTrace();
+                log.write("9999", "Errore durante l'avanzamento di stato per la richiesta: " + gnpRichiesteVoip103.getIdRichiesta() + " - " + ex.toString());
+                //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+                log.write("0010", " RICHIESTA " + gnpRichiesteVoip103.getIdRichiesta());
+            }
+        }
+    }
+
+    @Override
+    public boolean requiredTX() {
+        return false;
+    }
+
+    @Override
+    public LogInfo getLogInfo() throws Exception {
+        LogInfo logInfo = new LogInfo();
+        logInfo.setProcess(getClass().getName());
+        logInfo.setLogPath(Resources.getLogPath());
+        logInfo.setTypeInfo(Resources.getTypeInfo());
+        logInfo.setTypeDebug(Resources.getTypeDebug());
+        logInfo.setTypeError(Resources.getTypeError());
+        return logInfo;
+    }
+}

gnpdev/dbcfx/src/it/valueteam/gnp/controller/RequestControllerVoip35.java

@@ -0,0 +1,106 @@
+package it.valueteam.gnp.controller;
+
+import it.valueteam.crontab.processexecutor.ProcessIF;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteVoip35;
+import it.valueteam.gnp.dao.db.hb.GnpRichiesteVoip35DAO;
+import it.valueteam.gnp.log.Loggable;
+import it.valueteam.gnp.log.ProcessLogger;
+import it.valueteam.gnp.manager.RequestManagerVOIP35;
+import it.valueteam.gnp.obj.LogInfo;
+import it.valueteam.gnp.obj.LogProcess;
+import it.valueteam.gnp.utility.Resources;
+import it.valueteam.gnp.utility.UserTransactionUtility;
+
+import javax.transaction.UserTransaction;
+import java.util.List;
+
+public class RequestControllerVoip35 implements Loggable, ProcessIF {
+
+    protected final static String versione = "1.0.0";
+    protected final static String PARAM_DATA_SILENZIO_ASSENSO = "s";
+    protected ProcessLogger log;
+    protected String codiceProcesso = "ZP";
+
+    public RequestControllerVoip35() throws Exception {
+        try {
+            LogProcess logProcess = new LogProcess();
+            logProcess.setCodice(codiceProcesso);
+            logProcess.setProcess(this);
+            log = new ProcessLogger(logProcess);
+        } catch (Exception ex) {
+            System.out.println("Errore nella creazione del ProcessLogger");
+            throw ex;
+        }
+    }
+
+    public LogInfo getLogInfo() throws Exception {
+        LogInfo logInfo = new LogInfo();
+        logInfo.setProcess(getClass().getName());
+        logInfo.setLogPath(Resources.getLogPath());
+        logInfo.setTypeInfo(Resources.getTypeInfo());
+        logInfo.setTypeDebug(Resources.getTypeDebug());
+        logInfo.setTypeError(Resources.getTypeError());
+        return logInfo;
+    }
+
+    /**
+     * requiredTX
+     *
+     * @return boolean
+     */
+    public boolean requiredTX() {
+        return false;
+    }
+
+    public void execute(String[] args) throws Exception {
+        try {
+            //0001 N - INIZIO PROCESSO
+            log.write("0001", " versione " + RequestControllerVoip35.versione);
+            if ((args == null) || (args.length == 0)) {
+                throw new UnsupportedOperationException("Introdurre parametro di esecuzione ");
+            } else {
+                if (args[0].equalsIgnoreCase(RequestControllerVoip35.PARAM_DATA_SILENZIO_ASSENSO)) {
+                    checkSilenzioAssenso();
+                }
+            }
+        } catch (Exception ex) {
+            //0003 C - PROCESSO TERMINATO CON ECCEZIONI
+            log.write("0003", "" + ex.toString());
+            log.write("9999", "ECCEZIONE RILEVATA : " + ex.toString());
+            ex.printStackTrace();
+            //Termino l'esecuzione ritornando un errore a chi mi ha eseguito
+            throw ex;
+        }
+    }
+
+    /**
+     * checkSilenzioAssenso
+     * Effettua il controllo se data silenzio assenso e' uguale alla data odierna per
+     * tutte le richieste in stato INVIATA_FENP e VERIFICATA_FENP
+     * ed esegue l'avanzamento di stato in ACCETTATA
+     */
+    private void checkSilenzioAssenso() throws Exception {
+        UserTransaction uTX = null;
+        GnpRichiesteVoip35DAO voip35Dao = new GnpRichiesteVoip35DAO();
+        List<GnpRichiesteVoip35> silenzioAssenso = voip35Dao.getRichiesteSilenzioAssenso();
+        for (GnpRichiesteVoip35 gnpRichiesteVoip35 : silenzioAssenso) {
+            log.write("9999", "RICHIESTE VOIP35 DA ELABORARE PER SILENZIO ASSENSO:" + silenzioAssenso.size());
+            try {
+                //ogni singola richiesta e' inserita in tx
+                uTX = UserTransactionUtility.beginUserTransaction();
+                // refresh object to current transaction
+                voip35Dao.getSession().update(gnpRichiesteVoip35);
+
+                RequestManagerVOIP35.avanzaStatoInAccettata(gnpRichiesteVoip35, log);
+                UserTransactionUtility.endUserTransaction(uTX, true);
+            } catch (Exception ex) {
+                //rollback della tx corrente
+                if (uTX != null) UserTransactionUtility.endUserTransaction(uTX, false);
+                ex.printStackTrace();
+                log.write("9999", "Errore durante l'avanzamento di stato per la richiesta: " + gnpRichiesteVoip35.getIdRichiesta() + " - " + ex.toString());
+                //0010 C - ERRORE DURANTE L''ELABORAZIONE:
+                log.write("0010", " RICHIESTA " + gnpRichiesteVoip35.getIdRichiesta());
+            }
+        }
+    }
+}