Historial de página

package es.um.atica.apium.security.authentication;

import static org.jboss.seam.ScopeType.SESSION;
import static org.jboss.seam.annotations.Install.FRAMEWORK;

import java.io.Serializable;
import java.util.MissingResourceException;
import java.util.ResourceBundle;

import javax.faces.model.SelectItem;

import org.jboss.seam.Component;
import org.jboss.seam.annotations.Install;
import org.jboss.seam.annotations.Name;
import org.jboss.seam.annotations.Observer;
import org.jboss.seam.annotations.Scope;
import org.jboss.seam.annotations.Startup;
import org.jboss.seam.annotations.intercept.BypassInterceptors;
import org.jboss.seam.contexts.Contexts;
import org.jboss.seam.core.SeamResourceBundle;
import org.jboss.seam.log.Log;
import org.jboss.seam.log.Logging;

import es.um.atica.apium.security.authentication.ws.AuthenticationFactoryCorreo;
import es.um.atica.seam.security.CredentialsAdapter;
import es.um.atica.seam.security.UmuIdentity;
import es.um.atica.seam.security.authentication.AbstractAuthenticationManagerBean;
import es.um.atica.seam.security.authentication.credentials.CredentialsUmu;
import es.um.atica.seam.security.authentication.factories.AuthenticationFactory;
import es.um.atica.seam.security.authentication.method.AuthenticationMethod;

@Name( "authenticationManagerBean" )
@Scope( SESSION )
@Install( precedence = FRAMEWORK )
@BypassInterceptors
@Startup
public class AuthenticationManagerBean extends AbstractAuthenticationManagerBean implements Serializable {

	/**
	 * serialVersionUID generado automaticamente
	 */
	private static final long serialVersionUID = -6064182119922723132L;

	/** Logger de la clase */
	private static final Log LOG = Logging.getLog( AuthenticationManagerBean.class );

	protected SelectItem[] selectItemsAutentication;

	/** Credencial actual */
	protected CredentialsAdapter credentialsAdapter;

	protected AuthenticationType authenticationType;

	public enum AuthenticationType {
		CORREO( null, null SSO),
	}

	private static final String ERROR_FIRMA = "0";

	public AuthenticationManagerBean() { // Por defecto CORREO
		this.credentialsAdapter = ( CredentialsAdapter ) this.getCredentials();
		this.authenticationType = AuthenticationType.CORREO;
		this.activateCredentialsUmu();
		int idx = 0;
		selectItemsAutentication = new SelectItem[AuthenticationType.values().length];
		for ( AuthenticationType type : AuthenticationType.values()SSO( "LdapAuthenticationHandler", null, "label.authentication.type.correoum" ),
		SSO_CLAVE( "ClientAuthenticationHandler", "Cl@ve", "label.authentication.type.clave" ),
		// SSO_CMN( "ClientCredential", "CMN", "label.authentication.type.cmn" ),
		SSO_CERT( "ClientAuthenticationHandler", "Cert", "label.authentication.type.cert" );

		private String authenticationMethod;
		private String clientName;
		private String descKey;

		AuthenticationType( String authenticationMethod, String clientName ) {
			selectItemsAutentication[idx++]this.authenticationMethod = new SelectItem( type.name(), getAuthenticationTypeLabel( type ) )authenticationMethod;
		}
		this.clientName = clientName;
		}

	public void activateCredentialsUmu(	AuthenticationType( String authenticationMethod, String clientName, String descKey ) {
			LOG.infothis( "Entrar en activateCredentialsUmu: #0", this.authenticationType.name()authenticationMethod, clientName );
			this.credentialsAdapter.setCredentialsUmu( getFactoria( this.authenticationType ).createCredentials() );
descKey = descKey;
		}

	/**
	public *String Metodo para activar una credencial.<br />
	 * Si la que se desea activar, es la que est� actualmente, no se hace nada y se devuelve false. En otro caso se
	 * devolver� true.
	 * 
	 * @param credencial
	 *                   Clase de Credencial a activar.
	 * @return Si => se creo una nueva credencial. No => ya estaba esa misma credencial activa.
	 */
	public boolean activateCredentialsUmu( AuthenticationType authenticationType getAuthenticationMethod() {
			return authenticationMethod;
		}

		public String getClientName() {
			return clientName;
		}

		public String getDescKey() {
			return descKey;
		}

	}

	public AuthenticationType[] getAuthenticationTypes() {
		return AuthenticationType.values();
	}

	private static final String ERROR_FIRMA = "0";

	public AuthenticationManagerBean() { // Por defecto CORREO
		this.credentialsAdapter = ( CredentialsAdapter ) this.getCredentials();
		this.authenticationType = AuthenticationType.CORREO;
		this.activateCredentialsUmu();
		int idx = 0;
		selectItemsAutentication = new SelectItem[AuthenticationType.values().length];
		for ( AuthenticationType type : AuthenticationType.values() ) {
			selectItemsAutentication[idx++] = new SelectItem( type.name(), getAuthenticationTypeLabel( type ) );
		}
	}

	public void activateCredentialsUmu() {
		LOG.info( "Entrar en activateCredentialsUmu: #0",
				( authenticationType != null ? authenticationType. this.authenticationType.name() : "" ) );
		if ( ( this.getCredentialsUmucredentialsAdapter.setCredentialsUmu() != null ) &&  getFactoria( this.authenticationType == authenticationType ) ) {
			if ( LOG.isDebugEnabled.createCredentials() ) {;
	}

			LOG.debug( "La credencial actual y la pedida son iguales, luego/**
	 * Metodo para activar una credencial.<br />
	 * Si la que se desea activar, es la que est� actualmente, no se hace crear�nada y unase nueva:devuelve #0.",
						this.authenticationType );
			}
			return false;
		}
		if ( authenticationType != null ) {
			this.setAuthenticationType( authenticationType );
		} else { // Por defecto CORREO
			this.setAuthenticationType( AuthenticationType.CORREO );
		}
		this.credentialsAdapter.setCredentialsUmu( getFactoria( this.authenticationType ).createCredentials() );
		return true;
	}

	public AuthenticationMethod getAuthenticationMethod() {
		return this.getFactoria( this.authenticationType ).createAuthenticationMethod();
	}

	/**
	 * @param authenticationType
	 *                           - parametro de Seam por defecto
	 * @return
	 */
	protected AuthenticationFactory getFactoria( AuthenticationType authenticationType ) {false. En otro caso se
	 * devolver� true.
	 * 
	 * @param credencial
	 *                   Clase de Credencial a activar.
	 * @return Si => se creo una nueva credencial. No => ya estaba esa misma credencial activa.
	 */
	public boolean activateCredentialsUmu( AuthenticationType authenticationType ) {
		LOG.info( "Entrar en activateCredentialsUmu: #0",
				( authenticationType != null ? authenticationType.name() : "" ) );
		if ( ( this.authenticationTypegetCredentialsUmu() =!= null ) {
			activateCredentialsUmu&& ( AuthenticationType.CORREO );this.authenticationType == authenticationType ) ) {
		}
		switchif ( thisLOG.authenticationTypeisDebugEnabled() ) {
			case SSO: // case SSO	LOG.debug( "La credencial actual y la pedida son iguales, luego no se crear� una nueva: #0.",
				return new es.um.atica.apium.security.authentication.AuthenticationFactorySSO()		this.authenticationType );
			case CORREO: // case CORREO}
				return new AuthenticationFactoryCorreo()false;
			default:}
				return new es.um.atica.apium.security.authentication.AuthenticationFactoryRadius();
		}
	}

	protected String getAuthenticationTypeLabel( AuthenticationType authenticationType if ( authenticationType != null ) {
		ResourceBundle srb = SeamResourceBundle.getBundle(	this.setAuthenticationType( authenticationType );

		try} else {
			switch ( authenticationType ) { // Por defecto CORREO
				case CORREO:this.setAuthenticationType( AuthenticationType.CORREO );
		}
			return srb.getString( "label.tipo_acceso_correo"this.credentialsAdapter.setCredentialsUmu( getFactoria( this.authenticationType ).createCredentials() );
				case SSO:return true;
	}

	public AuthenticationMethod getAuthenticationMethod() {
			return srbthis.getStringgetFactoria( "label.tipo_acceso_sso" this.authenticationType ).createAuthenticationMethod();
	}

			default:
					return srb.getString( "tipo no identificado" );
			}
		} catch ( MissingResourceException mre ) {
			LOG.error( "Error al obtener las etiquetas para los tipos de autenticacion.", mre );
		}
		return "";
	}

	/**
	 * Obtiene la credencial actual./**
	 * @param authenticationType
	 *                           - parametro de Seam por defecto
	 * @return
	 */
	publicprotected CredentialsUmuAuthenticationFactory getCredentialsUmugetFactoria( AuthenticationType authenticationType ) {
		returnif ( this.credentialsAdapter.getCredentialsUmu();
	}

	public AuthenticationType getAuthenticationType(authenticationType == null ) {
		return authenticationType	activateCredentialsUmu( AuthenticationType.CORREO );
		}

		public voidswitch setAuthenticationType( AuthenticationType this.authenticationType ) {
		LOG.debug( "Entra en setAuthenticationType: #0 - #1", authenticationType.hashCode(),	case SSO: // case SSO
				authenticationType.name() return new es.um.atica.apium.security.authentication.AuthenticationFactorySSO();
		this.authenticationType = authenticationType;
	}

	public boolean isCorreoAuthentication() {
		return this.authenticationType == AuthenticationType.CORREO;
	}

	public boolean isSsoAuthentication(	case CORREO: // case CORREO
				return new AuthenticationFactoryCorreo();
			default:
				return new es.um.atica.apium.security.authentication.AuthenticationFactoryRadius();
		}
	}

	protected String getAuthenticationTypeLabel( AuthenticationType authenticationType ) {
		returnResourceBundle this.authenticationTypesrb == AuthenticationTypeSeamResourceBundle.SSOgetBundle();

	}

	public SelectItem[] getSelectItemsAutentication(	try {
			switch ( authenticationType ) {
		return selectItemsAutentication;
	}

	@Observer( UmuIdentity.EVENT_AUTHENTICATING_BY_CAS )
	public void activarAuthenticacionSSO() {
		LOG.debug( "Entra en activarAuthenticacionSSO		case CORREO:
					return srb.getString( "label.tipo_acceso_correo" );
				case SSO:
					return srb.getString( "label.tipo_acceso_sso" );
		this.authenticationType = AuthenticationType.SSO;
		this.activateCredentialsUmu(		default:
					return srb.getString( "tipo no identificado" );
			}

	/*
	} *catch (non-Javadoc)
	 * @see es.um.atica.util.FundeWebManager#getLog()
	 */
	@Override
	protected Log getLog() {
		return LOG MissingResourceException mre ) {
			LOG.error( "Error al obtener las etiquetas para los tipos de autenticacion.", mre );
		}
		return "";
	}

	public static AuthenticationManagerBean instance() {
		if ( !Contexts.isSessionContextActive() ) /**
	 * Obtiene la credencial actual.
	 */
	public CredentialsUmu getCredentialsUmu() {
			throw new IllegalStateException( "no session context active" return this.credentialsAdapter.getCredentialsUmu();
		}

		returnpublic AuthenticationType getAuthenticationType( AuthenticationManagerBean ) Component.getInstance( AuthenticationManagerBean.class ){
		return authenticationType;
	}

	public void setAuthenticationType( staticAuthenticationType StringauthenticationType getErrorfirma() {
		return ERROR_FIRMA;
	}
}

	public static AuthenticationManagerBean instance() {
		if ( !Contexts.isSessionContextActive() ) {
			throw new IllegalStateException( "no session context active" );
		}
		return ( AuthenticationManagerBean ) Component.getInstance( AuthenticationManagerBean.class );
	}

	public static String getErrorfirma() {
		return ERROR_FIRMA;
	}
}