Application: gvSIG desktop

/*

 * gvSIG. Desktop Geographic Information System.

 * 

 * Copyright (C) 2007-2020 gvSIG Association.

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU 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 <https://www.gnu.org/licenses/>. 

 * 

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.downloader.swing.scribejava.keycloak;

import com.github.scribejava.core.builder.ServiceBuilder;

import com.github.scribejava.core.model.OAuth2AccessToken;

import com.github.scribejava.core.model.OAuth2AccessTokenErrorResponse;

import com.github.scribejava.core.model.OAuthRequest;

import com.github.scribejava.core.model.Response;

import com.github.scribejava.core.model.Verb;

import com.github.scribejava.core.oauth.OAuth20Service;

import java.awt.Frame;

import java.awt.Toolkit;

import java.io.IOException;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.UUID;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.Executor;

import javax.json.JsonObject;

import javax.swing.JOptionPane;

import org.apache.commons.codec.net.URLCodec;

import org.apache.commons.lang.StringUtils;

import org.gvsig.desktopopen.DesktopOpen;

import org.gvsig.downloader.DownloaderAuthenticationRequester;

import org.gvsig.downloader.DownloaderLocator;

import org.gvsig.downloader.DownloaderManager;

import org.gvsig.downloader.spi.AbstractDownloaderAuthenticationRequester;

import org.gvsig.downloader.swing.scribejava.keycloak.callbacks.CallbackAuthorizationHandler;

import org.gvsig.downloader.swing.scribejava.keycloak.callbacks.CallbackLogoutHandler;

import org.gvsig.json.Json;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.swing.api.threadsafedialogs.ThreadSafeDialogsManager;

import org.gvsig.tools.util.ToolsUtilLocator;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class DownloaderAuthenticationKeycloakRequester

        extends AbstractDownloaderAuthenticationRequester

        implements DownloaderAuthenticationRequester {

    private static final Logger LOGGER = LoggerFactory.getLogger(DownloaderAuthenticationKeycloakRequester.class);

    private final Object monitor = new Object();

    private boolean stopedWaitingForResponse = false;

    private boolean userCancelledWaitingForResponse = false;

    private DownloaderKeycloakCredentials credentials = null;

    public DownloaderAuthenticationKeycloakRequester(DownloaderAuthenticationKeycloakConfig config) {

        super(config);

        this.credentials = null;

    }

    @Override

    public DownloaderAuthenticationKeycloakConfig getConfig() {

        return (DownloaderAuthenticationKeycloakConfig) this.config;

    }

    @Override

    public boolean requestAuthorization(Executor executorUI) {

        try {

            String requestId = StringUtils.remove(UUID.randomUUID().toString(), "-");

            String authCallback = "http://localhost:" + this.getConfig().getLocalPort() + "/auth_" + requestId;

            OAuth20Service service = createService(authCallback);

            DownloaderKeycloakCredentials theCredentials =  this.retrieveCredentials();

            if( theCredentials != null ) {

                if( theCredentials.isAccessTokenExpired() ) {

                    if( !theCredentials.isRefreshTokenExpired() ) {

                        OAuth2AccessToken token = theCredentials.getToken();

                        try {

                            token = service.refreshAccessToken(token.getRefreshToken());

                            if( token!=null ) {

                                System.out.println("ACCESS TOKEN UPDATED");

                                this.setCredentials(

                                        new DownloaderKeycloakCredentials(

                                                this.getConfig(),

                                                token, 

                                                theCredentials.getUserid(), 

                                                System.currentTimeMillis()

                                        )

                                );

                                return true;

                            }

                        } catch(OAuth2AccessTokenErrorResponse ex) {

                            LOGGER.debug("Refresh access token failed", ex);

                        }

                    }

                    // Si llega aqui asumo que el token de refresco a caducado,

                    // lo borro y intento una autenticacion normal.

                    this.removeCredetials();

                } else {

                    this.setCredentials(theCredentials);

                    return true;

                }

            }

            return this.requestIdentification2(requestId, authCallback, service);

        } catch (Exception ex) {

            LOGGER.warn("Can't request authorization", ex);

            return false;

        }

    }

    private boolean requestIdentification2(String requestId, String authCallback, OAuth20Service service) {

        try {

//            if (!SwingUtilities.isEventDispatchThread()) {

//                try {

//                    MutableBoolean r = new MutableBoolean();

//                    SwingUtilities.invokeAndWait(() -> {

//                        r.setValue(requestIdentification2(requestId, authCallback, service));

//                    });

//                    return r.booleanValue();

//                } catch (Exception ex) {

//                    return false;

//                }

//            }

            logout(service, requestId);

            if( !this.isUserCancelledWaitingForResponse() ) {

                authorize(service, requestId);

            }

            applicationToFront();

            return this.credentials!=null;

        } catch (Exception ex) {

            LOGGER.warn("Can't request authorization", ex);

            return false;

        }

    }

    private void applicationToFront() {

        try {

            java.awt.Window[] windows = Frame.getOwnerlessWindows();            

            if( windows != null ) {

                for (java.awt.Window window : windows) {

                    try {

                        window.toFront();

                    } catch(Exception ex) {

                        // Do nothing

                        LOGGER.debug("Can't bring to from "+window.toString());

                    }

                }

            }

        } catch(Exception e) {

            // Do nothing

            LOGGER.debug("Can't bring to from application");

        }

    }

    private OAuth20Service createService(String authCallback) {

        final String baseUrl = this.getConfig().getBaseurl();

        final String realm = this.getConfig().getRealm();

        final String scope = this.getConfig().getScope(); //"offline_access";

        final OAuth20Service service = new ServiceBuilder(getConfig().getClientid())

                .apiSecretIsEmptyStringUnsafe()

                .defaultScope(scope)

                .callback(authCallback)

                .build(KeycloakApi2.instance(baseUrl, realm));

        return service;

    }

    private void authorize(OAuth20Service service, String requestId) throws IOException, URISyntaxException {

        DownloaderAuthenticationKeycloakFactory factory = this.getConfig().getFactory();

        String contextPath = "/auth_" + requestId;

        CallbackAuthorizationHandler callbackHandler = new CallbackAuthorizationHandler(this, service, contextPath);

//        LOGGER.info("authorize "+requestId);

        try {

            factory.addCallback(getConfig(), contextPath, callbackHandler);

            final String authorizationUrl = service.getAuthorizationUrl();

            browse(authorizationUrl);

            this.waitForResponse();

        } catch(Exception e) {

            LOGGER.warn("Can't authorize",e);

        } finally {

//            LOGGER.info("authorize finally2 "+requestId);

            callbackHandler.remove();

//            LOGGER.info("authorize finally2 "+requestId);

        }

    }

    private void logout(OAuth20Service service, String requestId) throws URISyntaxException, IOException {

        KeycloakApi2 api = (KeycloakApi2) service.getApi();

        DownloaderAuthenticationKeycloakFactory factory = this.getConfig().getFactory();

        String contextPath = "/logout_" + requestId;

        CallbackLogoutHandler callbackHandler = new CallbackLogoutHandler(this, service, contextPath);

//        LOGGER.info("logout "+requestId);

        try {

            URLCodec urlcodec = new URLCodec();

            String redirect_uri = urlcodec.encode("http://localhost:" + getConfig().getLocalPort() + "/logout_"+requestId);

            String client_id = getConfig().getClientid();

            factory.addCallback(getConfig(), contextPath, callbackHandler);

            String logoutEndpoint = api.getLogoutEndpoint(client_id, redirect_uri);

            browse(logoutEndpoint);

            this.waitForResponse();

        } catch(Exception e) {

            LOGGER.warn("Can't logout",e);

        } finally {

//            LOGGER.info("logout finally1 "+requestId);

            callbackHandler.remove();

//            LOGGER.info("logout finally2 "+requestId);

        }

    }

    private void browse(String url) throws URISyntaxException, IOException {

//        Desktop.getDesktop().browse(new URI(url));

        DesktopOpen desktop = ToolsUtilLocator.getToolsUtilManager().createDesktopOpen();

        System.out.println("BROWSE : " + url);

        Toolkit defaultToolkit = Toolkit.getDefaultToolkit();

        desktop.browse(new URI(url));

    }

    public JsonObject  userInfo(OAuth20Service service) throws InterruptedException, IOException, ExecutionException {

//        LOGGER.info("userInfo");

        KeycloakApi2 api = (KeycloakApi2) service.getApi();

        final String userInfoEndpoint = api.getUserInfoEndpoint();

        System.out.println("userInfoEndpoint: "+userInfoEndpoint);

        final OAuthRequest request = new OAuthRequest(Verb.GET, userInfoEndpoint);

        service.signRequest(this.getCredentials().getToken(), request);

        try (final Response response = service.execute(request)) {

            System.out.println("userInfo-response: "+response.toString());

            if (response.getCode() == 200) {

                JsonObject userinfo = Json.createObject(response.getBody());

//                    System.out.println("userid: " + userinfo.getString("preferred_username", null);

//                    System.out.println("name: " + userinfo.getString("name", null));

//                    System.out.println("email: " + userinfo.getString("email", null));

//                    System.out.println("roles: " + userinfo.get("gvsigol_roles").toString());

//                    System.out.println("grupos: " + userinfo.get("groups").toString());

                return userinfo;

            }

        }

        return null;

    }

    public void waitForResponse() {

//        LOGGER.info("waitForTheResponse");

        synchronized (this.monitor) {

            ThreadSafeDialogsManager dialogs = ToolsSwingLocator.getThreadSafeDialogsManager();

            I18nManager i18n = ToolsLocator.getI18nManager();

            try {

                this.stopedWaitingForResponse = false;

                this.userCancelledWaitingForResponse = false;

                while( !this.userCancelledWaitingForResponse && !this.stopedWaitingForResponse) {

                    this.monitor.wait(20 * 1000);

                    if( !this.stopedWaitingForResponse ) {

                        int n = dialogs.confirmDialog(

                                i18n.getTranslation("_Do_you_want_to_continue_waiting_for_the_authentication_to_complete"), 

                                i18n.getTranslation("_Authentication"), 

                                JOptionPane.YES_NO_OPTION, 

                                JOptionPane.QUESTION_MESSAGE

                        );

                        if( n == JOptionPane.NO_OPTION ) {

                            this.userCancelledWaitingForResponse = true;

                        }

                    }

                }

            } catch (InterruptedException ex) {

            }

        }

//        LOGGER.info("waitForTheResponse exit");

    }

    public void stopWaitingForResponse() {

//        LOGGER.info("stopWaitingForResponse");

        synchronized (this.monitor) {

            this.stopedWaitingForResponse = true;

            this.monitor.notifyAll();

        }

//        LOGGER.info("stopWaitingForResponse exit");

    }

    private boolean isUserCancelledWaitingForResponse() {

        return this.userCancelledWaitingForResponse;

    }

    public DownloaderKeycloakCredentials getCredentials() {

        return credentials;

    }

    public void setCredentials(DownloaderKeycloakCredentials credentials) {

        this.saveCredetials(credentials);

        this.credentials = credentials;

    }

    private DownloaderKeycloakCredentials retrieveCredentials() {

        DownloaderManager manager = DownloaderLocator.getDownloaderManager();

        try {

            return (DownloaderKeycloakCredentials) manager.getCredentials(this.config.getServiceUrl());

        } catch(Exception ex) {

            return null;

        }

    }

    private void removeCredetials() {

        DownloaderManager manager = DownloaderLocator.getDownloaderManager();

        manager.removeCredentials(credentials);

    }

    private void saveCredetials(DownloaderKeycloakCredentials credentials) {

        DownloaderManager manager = DownloaderLocator.getDownloaderManager();

        manager.addOrReplaceCredentials(credentials);

    }

//    public static void main(String... args) throws Exception {

//        new DefaultLibrariesInitializer().fullInitialize();

//

//        UserIdentificationKeycloakFactory factory = new UserIdentificationKeycloakFactory();

//

////        UserIdentificationKeycloakConfig conf = factory.create("https://devel.gvsigonline.com/gvsigonline");

////        conf.setBaseurl("https://keycloak.scolab.eu/auth/realms");

////        conf.setRealm("joaquin");

////        conf.setClientid("gvsigdesktop");

//

//        DownloaderAuthenticationKeycloakConfig conf = factory.create("https://catastrord.gvsig-services.com/gvsigonline");

//        conf.setBaseurl("https://keycloak.gvsig-services.com/realms");

//        conf.setRealm("catastrord");

//        conf.setClientid("gvsigdesktop");

//        

//        OnlineUserIdentificationRequester requester = conf.createUserIdentificationRequester();

//

//        if (requester.requestIdentification()) {

//            System.out.println("Identificacion concluida.");

//            System.out.println("Credentials: " + requester.getCredentials());

//        } else {

//            System.out.println("Identificacion fallida.");

//        }

//

//        Thread.sleep(4000);

//

//        if (requester.requestIdentification()) {

//            System.out.println("Identificacion concluida.");

//            System.out.println("Credentials: " + requester.getCredentials());

//        } else {

//            System.out.println("Identificacion fallida.");

//        }

//

//        factory.stopHttpServer(1);

//    }

}