gvSIG projects pool

/*

 * 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.online.swing.scribejava.keycloak;

import com.github.scribejava.apis.KeycloakApi;

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

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.io.IOException;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.UUID;

import java.util.concurrent.ExecutionException;

import javax.json.JsonObject;

import javax.swing.JOptionPane;

import javax.swing.SwingUtilities;

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

import org.apache.commons.lang.StringUtils;

import org.apache.commons.lang3.mutable.MutableBoolean;

import org.gvsig.desktopopen.DesktopOpen;

import org.gvsig.json.Json;

import org.gvsig.online.lib.api.OnlineUserIdentificationRequester;

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.i18n.I18nManager;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

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 UserIdentificationKeycloak

        implements OnlineUserIdentificationRequester {

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

    private static final String GVSIGDESKTOP_APIKEY = "gvsigdesktop";

    private String userId;

    private String authorization;

    private final UserIdentificationKeycloakConfig config;

    private final Object monitor = new Object();

    private boolean stopedWaitingForResponse = false;

    private boolean userCancelledWaitingForResponse = false;

    public UserIdentificationKeycloak(UserIdentificationKeycloakConfig config) {

        this.config = config;

        this.userId = null;

        this.authorization = null;

    }

    public UserIdentificationKeycloakConfig getConfig() {

        return this.config;

    }

    @Override

    public boolean requestIdentification() {

        try {

            if (!SwingUtilities.isEventDispatchThread()) {

                try {

                    MutableBoolean r = new MutableBoolean();

                    SwingUtilities.invokeAndWait(() -> {

                        r.setValue(requestIdentification());

                    });

                    return r.booleanValue();

                } catch (Exception ex) {

                    return false;

                }

            }

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

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

            OAuth20Service service = createService(authCallback);

            logout(service, requestId);

            if( !this.isUserCancelledWaitingForResponse() ) {

                authorize(service, requestId);

            }

            applicationToFront();

            return StringUtils.isNotBlank(this.authorization);

        } 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 apiKey = GVSIGDESKTOP_APIKEY;

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

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

        final String scope = "openid";

        final OAuth20Service service = new ServiceBuilder(apiKey)

                .apiSecretIsEmptyStringUnsafe()

                .defaultScope(scope)

                .callback(authCallback)

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

        return service;

    }

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

        UserIdentificationKeycloakFactory factory = this.config.getFactory();

        String contextPath = "/auth_" + requestId;

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

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

        try {

            factory.addCallback(config, 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 {

        UserIdentificationKeycloakFactory factory = this.config.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:" + config.getLocalPort() + "/logout_"+requestId);

            String realm = urlcodec.encode(config.getRealm());

            String client_id = urlcodec.encode(GVSIGDESKTOP_APIKEY);

            factory.addCallback(config, contextPath, callbackHandler);

            String logoutUrl = String.format(

//                    "%s/auth/realms/%s/protocol/openid-connect/logout?post_logout_redirect_uri=%s&client_id=%s",

                    "%s/auth/realms/%s/protocol/openid-connect/logout?redirect_uri=%s&client_id=%s",

                    config.getBaseurl(),

                    realm,

                    redirect_uri,

                    client_id

            );

            browse(logoutUrl);

            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();

        desktop.browse(new URI(url));

    }

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

//        LOGGER.info("userInfo");

        final String protectedResourceUrl = config.getBaseurl() + "/auth/realms/" + config.getRealm() + "/protocol/openid-connect/userinfo";

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

        service.signRequest(this.getAuthorization(), request);

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

            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;

    }

    @Override

    public String getUserId() {

        return this.userId;

    }

    public void setUserId(String userId) {

        this.userId = userId;

    }

    @Override

    public String getAuthorization() {

        return this.authorization;

    }

    public void setAuthorization(String authorization) {

        this.authorization = authorization;

    }

    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.setLocalPort(8889);

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

        conf.setRealm("joaquin");

        OnlineUserIdentificationRequester requester = conf.createUserIdentificationRequester();

        if (requester.requestIdentification()) {

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

            System.out.println("Usuario: " + requester.getUserId());

            System.out.println("Token  : " + requester.getAuthorization());

        } else {

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

        }

        Thread.sleep(4000);

        if (requester.requestIdentification()) {

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

            System.out.println("Usuario: " + requester.getUserId());

            System.out.println("Token  : " + requester.getAuthorization());

        } else {

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

        }

        factory.stopHttpServer(1);

    }

}