source: extensions/jiwigo-ws-api/src/main/java/fr/mael/jiwigo/transverse/session/SessionManager.java @ 9879

package fr.mael.jiwigo.transverse.session;

import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;

import org.apache.commons.httpclient.Credentials;
import org.apache.commons.httpclient.HostConfiguration;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.MultiThreadedHttpConnectionManager;
import org.apache.commons.httpclient.UsernamePasswordCredentials;
import org.apache.commons.httpclient.auth.AuthScope;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.lang.StringUtils;
import org.jdom.Document;
import org.jdom.JDOMException;

import fr.mael.jiwigo.transverse.enumeration.MethodsEnum;
import fr.mael.jiwigo.transverse.exception.ProxyAuthenticationException;
import fr.mael.jiwigo.transverse.util.Tools;

/*
 *  jiwigo-ws-api Piwigo webservice access Api
 *  Copyright (c) 2010-2011 Mael mael@le-guevel.com
 *                All Rights Reserved
 *
 *  This library is free software. It comes without any warranty, to
 *  the extent permitted by applicable law. You can redistribute it
 *  and/or modify it under the terms of the Do What The Fuck You Want
 *  To Public License, Version 2, as published by Sam Hocevar. See
 *  http://sam.zoy.org/wtfpl/COPYING for more details.
 */
/**

 * @author mael
 * Gestionnaire de connexion
 */
public class SessionManager {

    /**
     * Logger
     */
    public static final org.apache.commons.logging.Log LOG = org.apache.commons.logging.LogFactory
            .getLog(SessionManager.class);
    /**
     * the entered login
     */
    private String login;
    /**
     * the entered password
     */
    private String password;
    /**
     * the url of the site
     */
    private String url;
    /**
     * the http client
     */
    private HttpClient client;

    /**
     * defines if the user uses a proxy
     */
    private boolean usesProxy;

    /**
     * url of the proxy
     */
    private String urlProxy;

    /**
     * port of the proxy
     */
    private int portProxy;

    /**
     * login for the proxy
     */
    private String loginProxy;

    /**
     * pass for the proxy
     */
    private String passProxy;

    /**
     * true : an error was found for the proxy
     */
    private boolean proxyError;

    /**
     * Constructor
     * @param login the login
     * @param password the password
     * @param url the url of the site
     */
    public SessionManager(String login, String password, String url) {
        this.login = login;
        this.password = password;
        this.url = url + "/ws.php";
        MultiThreadedHttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager();
        client = new HttpClient(connectionManager);
        //Using of a Linux user agent. cause... it's better 8)
        client.getParams().setParameter("http.useragent",
                "Mozilla/5.0 (X11; U; Linux i686; fr; rv:1.9.1.1) Gecko/20090715 Firefox/3.5.1");

    }

    /**
     * Connection method
     *
     * @return 0 if Ok, 1 if not Ok (reason not specified), 2 if proxy error
     *
     *
     */
    public int processLogin() {
        Document doc;
        //configures the proxy
        if (usesProxy) {
            HostConfiguration config = client.getHostConfiguration();
            config.setProxy(urlProxy, portProxy);
            if (!StringUtils.isEmpty(loginProxy) && !StringUtils.isEmpty(passProxy)) {
                Credentials credentials = new UsernamePasswordCredentials(loginProxy, passProxy);
                AuthScope authScope = new AuthScope(urlProxy, portProxy);
                client.getState().setProxyCredentials(authScope, credentials);
            }
        }
        //      try {
        try {
            doc = executeReturnDocument(MethodsEnum.LOGIN.getLabel(), "username", login, "password", password);
            return (Tools.checkOk(doc) ? 0 : 1);
        } catch (IOException e) {
            LOG.debug(Tools.getStackTrace(e));
            return 1;
        } catch (ProxyAuthenticationException e) {
            LOG.debug(Tools.getStackTrace(e));
            return 2;
        } catch (Exception e) {
            LOG.debug(Tools.getStackTrace(e));
            return 1;
        }

    }

    /**
     * Executes a method on the webservice and returns the result as a string
     * @param methode the method to execute
     * @param parametres the parameters of the method. Must be even : the name of the parameter followed by its value
     * @return the result
     * @throws UnsupportedEncodingException
     * @throws ProxyAuthenticationException
     */
    public String executeReturnString(String methode, String... parametres) throws UnsupportedEncodingException,
            ProxyAuthenticationException {
        if (parametres.length % 2 != 0 && !(parametres == null)) {
            try {
                throw new Exception("Le nombre de parametres doit etre pair");
            } catch (Exception e) {
                LOG.error(Tools.getStackTrace(e));
                return null;
            }
        }
        PostMethod method = new PostMethod(url);
        method.addParameter("method", methode);
        for (int i = 0; i < parametres.length; i += 2) {
            //      System.out.println(parametres[i] + " -> " + parametres[i + 1]);
            method.addParameter(parametres[i], parametres[i + 1]);

        }
        //begin bug:0001833
        method.setRequestHeader("Content-Type", "application/x-www-form-urlencoded; charset=utf-8");
        //end
        try {
            int test = client.executeMethod(method);
            if (test == 407) {
                throw new ProxyAuthenticationException("Proxy configuration exception. Check username and password");
            }
            InputStream streamResponse = method.getResponseBodyAsStream();
            //      System.out.println(Outil.readInputStreamAsString(streamResponse));
            //      String toReturn = method.getResponseBodyAsString();
            String toReturn = Tools.readInputStreamAsString(streamResponse);
            LOG.debug(toReturn);
            return toReturn;
        } catch (IOException e) {

        }
        return null;

    }

    /**
     * Executes a method on the webservice and returns the result as a Dom document
     * @param methode the method to execute
     * @param parametres the parameters of the method. Must be even : the name of the parameter followed by its value
     * @return the result
     * @throws IOException
     * @throws ProxyAuthenticationException
     */
    public Document executeReturnDocument(String methode, String... parametres) throws IOException,
            ProxyAuthenticationException {
        try {
            String returnedString = executeReturnString(methode, parametres);
            return Tools.stringToDocument(returnedString);
        } catch (JDOMException e) {
            // TODO Auto-generated catch block
            LOG.error(Tools.getStackTrace(e));
        }
        return null;

    }

    /**
     * Executes a method on the webservice and returns the result as a Dom document
     * @param methode the method to execute
     * @return the result
     * @throws ProxyAuthenticationException
     */
    public Document executeReturnDocument(String methode) throws ProxyAuthenticationException {
        try {
            return Tools.stringToDocument(executeReturnString(methode));
        } catch (JDOMException e) {
            // TODO Auto-generated catch block
            LOG.error(Tools.getStackTrace(e));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            LOG.error(Tools.getStackTrace(e));
        }
        return null;

    }

    /**
     * @return the login
     */
    public String getLogin() {
        return login;
    }

    /**
     * @param login the login to set
     */
    public void setLogin(String login) {
        this.login = login;
    }

    /**
     * @return the url
     */
    public String getUrl() {
        return url;
    }

    /**
     * @param url the url to set
     */
    public void setUrl(String url) {
        this.url = url;
    }

    /**
     * @param usesProxy the usesProxy to set
     */
    public void setUsesProxy(boolean usesProxy) {
        this.usesProxy = usesProxy;
    }

    /**
     * @param urlProxy the urlProxy to set
     */
    public void setUrlProxy(String urlProxy) {
        this.urlProxy = urlProxy;
    }

    /**
     * @param portProxy the portProxy to set
     */
    public void setPortProxy(int portProxy) {
        this.portProxy = portProxy;
    }

    /**
     * @param loginProxy the loginProxy to set
     */
    public void setLoginProxy(String loginProxy) {
        this.loginProxy = loginProxy;
    }

    /**
     * @param passProxy the passProxy to set
     */
    public void setPassProxy(String passProxy) {
        this.passProxy = passProxy;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public boolean isProxyError() {
        return proxyError;
    }

    public void setProxyError(boolean proxyError) {
        this.proxyError = proxyError;
    }

}