ErroriCooperazione.java

/*
 * GovWay - A customizable API Gateway 
 * https://govway.org
 * 
 * Copyright (c) 2005-2025 Link.it srl (https://link.it).
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 3, as published by
 * the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
package org.openspcoop2.protocol.sdk.constants;

/**
*
* @author Poli Andrea (apoli@link.it)
* @author $Author$
* @version $Rev$, $Date$
*/
public enum ErroriCooperazione {

    MITTENTE_SCONOSCIUTO("Il Mittente non risulta registrato nel Registro dei Servizi",
            CodiceErroreCooperazione.MITTENTE_SCONOSCIUTO),
    MITTENTE_NON_VALIDO("Il Mittente presente nella busta non è valido",
            CodiceErroreCooperazione.MITTENTE_NON_VALIDO),
            
    TIPO_MITTENTE_NON_VALIDO("Il Tipo del mittente presente nella busta non è valido",
            CodiceErroreCooperazione.TIPO_MITTENTE_NON_VALIDO),
    
    DESTINATARIO_SCONOSCIUTO("Il Destinatario non risulta registrato nel Registro dei Servizi",
            CodiceErroreCooperazione.DESTINATARIO_SCONOSCIUTO),
    DESTINATARIO_NON_VALIDO("Il Destinatario presente nella busta non è valido",
            CodiceErroreCooperazione.DESTINATARIO_NON_VALIDO),
            
    TIPO_DESTINATARIO_NON_VALIDO("Il Tipo del destinatario presente nella busta non è valido",
            CodiceErroreCooperazione.TIPO_DESTINATARIO_NON_VALIDO),
                    
    SERVIZIO_SCONOSCIUTO("Il Servizio non risulta registrato nel Registro dei Servizi",
            CodiceErroreCooperazione.SERVIZIO_SCONOSCIUTO),
    SERVIZIO_NON_VALIDO("Il Servizio presente nella busta non è valido",
            CodiceErroreCooperazione.SERVIZIO_NON_VALIDO),
            
    TIPO_SERVIZIO_NON_VALIDO("Il Tipo del servizio presente nella busta non è valido",
            CodiceErroreCooperazione.TIPO_SERVIZIO_NON_VALIDO),
    
    VERSIONE_SERVIZIO_NON_VALIDO("La versione del servizio presente nella busta non è valido",
            CodiceErroreCooperazione.VERSIONE_SERVIZIO_NON_VALIDO),
    
    AZIONE_NON_VALIDA("L'azione presente nella busta non è valida",
            CodiceErroreCooperazione.AZIONE_NON_VALIDA),        
            
    IDENTIFICATIVO_MESSAGGIO_GIA_PROCESSATO("La busta presenta un identificativo già processato in precedenza",
            CodiceErroreCooperazione.IDENTIFICATIVO_MESSAGGIO_GIA_PROCESSATO),
            
    RIFERIMENTO_MESSAGGIO_NON_PRESENTE("La busta non contiene un RiferimentoMessaggio alla precedente busta a cui è correlata logicamente come richiede il profilo",
            CodiceErroreCooperazione.RIFERIMENTO_MESSAGGIO_NON_PRESENTE),
    RIFERIMENTO_MESSAGGIO_NON_VALIDO("IdentificativoBusta presente nel RiferimentoMessaggio non è valido",
            CodiceErroreCooperazione.RIFERIMENTO_MESSAGGIO_NON_VALIDO),
    
    MESSAGGIO_SCADUTO("Messaggio scaduto",
            CodiceErroreCooperazione.MESSAGGIO_SCADUTO),
    
    PROFILO_COLLABORAZIONE_SCONOSCIUTO("Busta con profilo di collaborazione sconosciuto",
            CodiceErroreCooperazione.PROFILO_COLLABORAZIONE_SCONOSCIUTO),
    PROFILO_COLLABORAZIONE_NON_VALIDO("Busta con profilo di collaborazione non valido rispetto al tipo di cooperazione in corso",
            CodiceErroreCooperazione.PROFILO_COLLABORAZIONE_NON_VALIDO),
            
    COLLABORAZIONE_NON_VALIDA("La collaborazione presente nella busta non è valida",
            CodiceErroreCooperazione.COLLABORAZIONE_NON_VALIDA),
    
    COLLABORAZIONE_SCONOSCIUTA("La collaborazione presente nella busta non appartiene a nessuna sessione valida",
            CodiceErroreCooperazione.COLLABORAZIONE_SCONOSCIUTA),
    
    PROFILO_TRASMISSIONE_CONFERMA_RICEZIONE_NON_PRESENTE("La busta non contiene una richiesta di 'conferma ricezione', nonostante il servizio indicato richieda, tramite la definizione dell'accordo nel registro, una consegna affidabile",
            CodiceErroreCooperazione.PROFILO_TRASMISSIONE_CONFERMA_RICEZIONE_NON_PRESENTE),
        
    CONSEGNA_IN_ORDINE_NON_GESTIBILE("La busta non contiene una richiesta di 'consegna in ordine', nonostante il servizio indicato richieda, tramite la definizione dell'accordo nel registro, un ordinamento",
            CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_NON_GESTIBILE),
    
    CONSEGNA_IN_ORDINE_FUORI_SEQUENZA("Riscontrato numero di sequenza diverso da 1, in una busta capostipite di una sequenza",
            CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_FUORI_SEQUENZA),
    
    CONSEGNA_IN_ORDINE_TIPO_MITTENTE_NON_VALIDO("Il tipo di mittente non rispetta quello atteso nella gestione della collaborazione con consegna in ordine",
            CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_TIPO_MITTENTE_NON_VALIDO),
    
    CONSEGNA_IN_ORDINE_MITTENTE_NON_VALIDO("Il nome del mittente non rispetta quello atteso nella gestione della collaborazione con consegna in ordine",
            CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_MITTENTE_NON_VALIDO),
    
    CONSEGNA_IN_ORDINE_TIPO_DESTINATARIO_NON_VALIDO("Il tipo di destinatario non rispetta quello atteso nella gestione della collaborazione con consegna in ordine",
            CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_TIPO_DESTINATARIO_NON_VALIDO),
    
    CONSEGNA_IN_ORDINE_DESTINATARIO_NON_VALIDO("Il nome del destinatario non rispetta quello atteso nella gestione della collaborazione con consegna in ordine",
            CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_DESTINATARIO_NON_VALIDO),
    
    CONSEGNA_IN_ORDINE_TIPO_SERVIZIO_NON_VALIDO("Il tipo di servizio non rispetta quello atteso nella gestione della collaborazione con consegna in ordine",
            CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_TIPO_SERVIZIO_NON_VALIDO),
    
    CONSEGNA_IN_ORDINE_SERVIZIO_NON_VALIDO("Il nome del servizio non rispetta quello atteso nella gestione della collaborazione con consegna in ordine",
            CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_SERVIZIO_NON_VALIDO),
    
    CONSEGNA_IN_ORDINE_AZIONE_NON_VALIDA("Il nome dell'azione non rispetta quello atteso nella gestione della collaborazione con consegna in ordine",
            CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_AZIONE_NON_VALIDA),
    
    CONSEGNA_IN_ORDINE_COLLABORAZIONE_IN_BUSTA_NON_CAPOSTIPITE_SCONOSCIUTA("Busta non capostipite che richiede funzionalità di consegna in ordine presenta una collaborazione non registrata per le funzioni di consegna in ordine",
            CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_COLLABORAZIONE_IN_BUSTA_NON_CAPOSTIPITE_SCONOSCIUTA),
    
    CONSEGNA_IN_ORDINE_NON_SUPPORTATA("Funzionalità di consegna in ordine non supportata",
            CodiceErroreCooperazione.CONSEGNA_IN_ORDINE_NON_SUPPORTATA),
            
    MESSAGE_SECURITY("E' occorso un errore durante la gestione della Sicurezza sul Messaggio",
            null),
            
    AUTENTICAZIONE_FALLITA_CREDENZIALI_NON_FORNITE(CostantiProtocollo.PREFISSO_AUTENTICAZIONE_FALLITA+CostantiProtocollo.CREDENZIALI_NON_FORNITE,
            CodiceErroreCooperazione.MITTENTE_NON_VALORIZZATO),
    
    AUTENTICAZIONE_FALLITA_CREDENZIALI_FORNITE_NON_CORRETTE(CostantiProtocollo.PREFISSO_AUTENTICAZIONE_FALLITA+CostantiProtocollo.CREDENZIALI_FORNITE_NON_CORRETTE,
            CodiceErroreCooperazione.MITTENTE_SCONOSCIUTO),
    
    AUTORIZZAZIONE_FALLITA("Il Mittente non è autorizzato a fruire del servizio richiesto",
            null),
            
    ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO("E' occorso un errore durante il processamento del messaggio",
            CodiceErroreCooperazione.ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO),
            
    ERRORE_GENERICO_PROTOCOLLO_NON_CORRETTO("E' stato rilevata una violazione per quanto concerne le informazioni richieste del protocollo in gestione",
            CodiceErroreCooperazione.FORMATO_NON_CORRETTO),
    
    TOKEN_NON_PRESENTE("Token non presente",
            CodiceErroreCooperazione.SICUREZZA_TOKEN_NON_PRESENTE),
    
    TOKEN_NON_VALIDO("Token non valido",
            CodiceErroreCooperazione.SICUREZZA_TOKEN_NON_VALIDO),
    
    TOKEN_AUTORIZZAZIONE_FALLITA("La richiesta presenta un token non sufficiente per fruire del servizio richiesto",
            CodiceErroreCooperazione.SICUREZZA_TOKEN_AUTORIZZAZIONE_FALLITA),
    
    TOKEN_PRESENTE_PIU_VOLTE("Token presente più volte",
            CodiceErroreCooperazione.SICUREZZA_TOKEN_PRESENTE_PIU_VOLTE);
    
    private final String descrizione;
    private final CodiceErroreCooperazione codiceErrore;

    ErroriCooperazione(String descrizione,CodiceErroreCooperazione codiceErrore){
        this.descrizione = descrizione;
        this.codiceErrore = codiceErrore;
    }
    
    @Override
    public String toString(){
        return this.newErroreCooperazione().toString();
    }
    
    private ErroreCooperazione newErroreCooperazione(){
        return newErroreCooperazione(this.descrizione, this.codiceErrore);
    }
    private ErroreCooperazione newErroreCooperazione(String descrizioneParam){
        return newErroreCooperazione(descrizioneParam, this.codiceErrore);
    }
    @SuppressWarnings("unused")
    private ErroreCooperazione newErroreCooperazione(CodiceErroreCooperazione codiceParam){
        return newErroreCooperazione(this.descrizione, codiceParam);
    }
    private ErroreCooperazione newErroreCooperazione(String descrizioneParam,CodiceErroreCooperazione codiceParam){
        String newDescrizione = new String(descrizioneParam);
        return new ErroreCooperazione(newDescrizione, codiceParam);
    }
    
    public ErroreCooperazione getErroreCooperazione() {
        return getErroreCooperazione(null);
    }
    public ErroreCooperazione getErroreCooperazione(String descrizione) {
        if(this.equals(MESSAGE_SECURITY) ||
            this.equals(AUTORIZZAZIONE_FALLITA)){
            throw new RuntimeException("Il metodo non può essere utilizzato con il messaggio "+this.name());
        }
        if(descrizione!=null){
            return newErroreCooperazione(descrizione);
        }
        else{
            return newErroreCooperazione();
        }
    }
    
    public ErroreCooperazione getErroreProfiloCollaborazioneSconosciuto(String profiloCollaborazione) {
        if(this.equals(PROFILO_COLLABORAZIONE_SCONOSCIUTO)){
            if(profiloCollaborazione==null){
                return newErroreCooperazione("Busta senza Profilo di Collaborazione");  
            }else{
                return newErroreCooperazione("Busta con profilo di collaborazione non gestito ["+profiloCollaborazione+"]");    
            }   
        }else{
            throw new RuntimeException("Il metodo può essere utilizzato solo con il messaggio "+PROFILO_COLLABORAZIONE_SCONOSCIUTO.name());
        }
    }
    
    public ErroreCooperazione getErroreProfiloCollaborazioneNonValido(String descrizione) {
        if(this.equals(PROFILO_COLLABORAZIONE_NON_VALIDO)){
            return newErroreCooperazione(descrizione);
        }else{
            throw new RuntimeException("Il metodo può essere utilizzato solo con il messaggio "+PROFILO_COLLABORAZIONE_NON_VALIDO.name());
        }
    }
        
    public ErroreCooperazione getErroreMessageSecurity(String descrizione,CodiceErroreCooperazione codiceErrore) {
        if(this.equals(MESSAGE_SECURITY)){
            if(CodiceErroreCooperazione.isEccezioneMessageSecurity(codiceErrore)==false &&
                    CodiceErroreCooperazione.isEccezioneSicurezzaAutorizzazione(codiceErrore)==false &&
                    CodiceErroreCooperazione.isEccezioneSicurezzaToken(codiceErrore)==false){ //messageSecurity internamente possiede anche un engine di autorizzazione
                throw new RuntimeException("Il metodo può essere utilizzato solo con codici associati alla sicurezza, relativamente ad errori di messageSecurity, token o erroreAutorizzazione, codice fornito: "+codiceErrore);
            }
            return newErroreCooperazione(descrizione, codiceErrore);    
        }else{
            throw new RuntimeException("Il metodo può essere utilizzato solo con il messaggio "+MESSAGE_SECURITY.name());
        }
    }
    
    public ErroreCooperazione getErroreAutorizzazione(String descrizione,CodiceErroreCooperazione codiceErrore) {
        if(this.equals(AUTORIZZAZIONE_FALLITA)){
            if(CodiceErroreCooperazione.isEccezioneSicurezzaAutorizzazione(codiceErrore)==false){
                throw new RuntimeException("Il metodo può essere utilizzato solo con codici associati alla sicurezza, relativamente a fallimenti di autorizzazione, codice fornito: "+codiceErrore);
            }
            return newErroreCooperazione(descrizione, codiceErrore);    
        }else{
            throw new RuntimeException("Il metodo può essere utilizzato solo con il messaggio "+AUTORIZZAZIONE_FALLITA.name());
        }
    }
        
    public ErroreCooperazione getErroreProcessamento(String descrizione) {
        if(this.equals(ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO)){
            return newErroreCooperazione(descrizione);
        }else{
            throw new RuntimeException("Il metodo può essere utilizzato solo con il messaggio "+ERRORE_GENERICO_PROCESSAMENTO_MESSAGGIO.name());
        }
    }
    
    public ErroreCooperazione getErroreGestioneProtocollo(String descrizione) {
        if(this.equals(ERRORE_GENERICO_PROTOCOLLO_NON_CORRETTO)){
            return newErroreCooperazione(descrizione);
        }else{
            throw new RuntimeException("Il metodo può essere utilizzato solo con il messaggio "+ERRORE_GENERICO_PROTOCOLLO_NON_CORRETTO.name());
        }
    }
    
    public ErroreCooperazione getErroreCredenzialiForniteNonCorrette(String errore) {
        if(this.equals(AUTENTICAZIONE_FALLITA_CREDENZIALI_FORNITE_NON_CORRETTE)){
            return newErroreCooperazione(CostantiProtocollo.PREFISSO_AUTENTICAZIONE_FALLITA+CostantiProtocollo.CREDENZIALI_FORNITE_NON_CORRETTE+": "+errore, CodiceErroreCooperazione.MITTENTE_SCONOSCIUTO);
        }else{
            throw new RuntimeException("Il metodo può essere utilizzato solo con il messaggio "+AUTENTICAZIONE_FALLITA_CREDENZIALI_FORNITE_NON_CORRETTE.name());
        }
    }
}