intégration LinkedIn - Mettre en place un requestToken

Question

Je développe (essayer pour l'instant) portlet qui sera intégré avec LinkedIn.

Suite à la documentation à ce sujet: http://developer.linkedin.com/docs/DOC-1008 -> La première étape pour autoriser un membre de LinkedIn sollicite un requestToken. Cette demande est faite avec un HTTP POST. Pour l'étape requestToken, les composants suivants doivent être présents dans votre chaîne à signer:

* HTTP Method (POST)
* Request URI (https://api.linkedin.com/uas/oauth/requestToken)
* oauth_callback
* oauth_consumer_key
* oauth_nonce
* oauth_signature_method
* oauth_timestamp
* oauth_version

Je l'ai déjà API (c'est oauth_consumer_key ) et je dois générer chaîne d'URL spécifique. Avoir suivant le code java pour cette connexion URL et HTTP:

private void processAuthentication() {

    Calendar cal = Calendar.getInstance();
    Long ms = cal.getTimeInMillis();
    Long timestamp = ms / 1000;

    Random r = new Random();
    Long nonce = r.nextLong();

    String prefixUrl = "https://api.linkedin.com/uas/oauth/requestToken";
    String oauthCallback = "oauth_callback=http://localhost/";
    String oauthConsumerKey =
            "&oauth_consumer_key=my_consumer_key";
    String oauthNonce = "&oauth_nonce=" + nonce.toString();
    String oauthSignatureMethod = "&oauth_signature_method=HMAC-SHA1";
    String oauthTimestamp = "&oauth_timestamp=" + timestamp.toString();
    String oauthVersion = "&oauth_version=1.0";

    String mainUrl =
            oauthCallback + oauthConsumerKey + oauthNonce + oauthSignatureMethod
                    + oauthTimestamp + oauthVersion;

    try {
        prefixUrl =
                URLEncoder.encode(prefixUrl, "UTF-8") + "&"
                        + URLEncoder.encode(mainUrl, "UTF-8");

        URL url = new URL(prefixUrl);

        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("POST");
        String msg = connection.getResponseMessage();
    } catch (MalformedURLException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

}

La question est la suivante, pour ceux qui avaient été confrontés à ce problème: Comment devrait vraiment regarder la chaîne d'URL pour la connexion et la façon dont la réponse est reçue?

Pour URL, il se intéresse l'exemple d'URL, vous avez généré. Et pour une réponse intéressée, la méthode pour l'obtenir. Si je comprends bien, après la connexion HTTP été établie, cette réponse est:

connection.getResponseMessage();

Answer 1

Vous pouvez essayer les bibliothèques OAuth pour gérer la connexion: http://code.google. com / p / oauth /

Answer 2

@sergionni J'ai trouvé réponse à votre question de linkedin-développeur

Comme vous le savez La première étape pour autoriser un membre de Linked-In sollicite un requestToken. Cette demande se fait avec un HTTP POST.

Votre chaîne de base devrait finir par quelque chose comme ça si vous utilisez un rappel:

  

POST & https% 3A% 2F% 2Fapi.linkedin.com% 2Fuas% 2Foauth% 2FrequestToken   & Oauth_callback% 3Dhttp% 253A% 252F% 252Flocalhost% 252Foauth_callback% 26o   auth_consumer_key% 3DABCDEFGHIJKLMNOPQRSTUVWXYZ% 26   oauth_nonce% 3DoqwgSYFUD87MHmJJDv7bQqOF2EPnVus7Wkqj5duNByU% 26   oauth_signature_method% 3DHMAC-SHA1% 26oauth_timestamp% 3D1259178158% 26   oauth_version% 3D1.0

Vous signez alors cette chaîne de base avec votre consumer_secret, le calcul d'une signature. Dans ce cas, si votre secret était 1234567890, la signature serait TLQXuUzM7omwDbtXimn6bLDvfF8 =.

Maintenant, vous prenez la signature que vous avez généré, avec oauth_nonce, oauth_callback, oauth_signature_method, oauth_timestamp, oauth_consumer_key et oauth_version et créer un en-tête d'autorisation HTTP. Pour cette demande, cet en-tête HTTP ressemblerait à ceci:

  

Autorisation: OAuth   oauth_nonce = "oqwgSYFUD87MHmJJDv7bQqOF2EPnVus7Wkqj5duNByU",   oauth_callback = "http% 3A% 2F% 2Flocalhost% 2Foauth_callback",   oauth_signature_method = "HMAC-SHA1",   oauth_timestamp = "1259178158",   oauth_consumer_key = "ABCDEFGHIJKLMNOPQRSTUVWXYZ",   oauth_signature = "TLQXuUzM7omwDbtXimn6bLDvfF8 =",   oauth_version = "1.0"

S'il vous plaît noter que l'en-tête HTTP est un en-tête unique - pas un en-tête HTTP pour chaque composant. Vous pouvez fournir en option un realm = "http://api.linkedin.com".

En réponse à votre demande de requestToken, votre requestToken sera dans le domaine de la réponse « oauth_token », une validation que nous avons reconnu votre rappel avec le champ « oauth_callback_confirmed », un oauth_token_secret et un oauth_expires_in, et quelques autres valeurs.

(us Votre answaer) réponse ressemblerait à ceci:

  

oauth_token = 94ab03c4-ae2c-45e4-8732-0e6c4899db63   & Oauth_token_secret = be6ccb24-bf0a-4ea8-a4b1-0a70508e452b   & Oauth_callback_confirmed = true & oauth_expires_in = 599

Answer 3

J'ai créé un plugin pour cadre de lecture facilement intégré avec OAuth LinkedIn: geeks.aretotally.in/projects/play-framework-linkedin-module. Espérons que cela peut aider. Vous devriez vérifier def Play, très très cool cadre de Java.

Answer 4

corps de portlet:

public class LinkedInPortlet extends GenericPortlet {

    public static final String PAGE_PIN = "pin";

    public static final String PAGE_EDIT = "edit";

    public static final String PAGE_PROFILE = "profile";

    public static final String PAGE_CONNECTIONS = "connections";

    public static final String FORM_LINKEDIN_PREFERENCES = "preferencesLinkedInForm";

    public static final String PAGE_VIEW_MY_PROFILE = "/WEB-INF/portlets/linkedin/myProfile.jsp";

    public static final String PAGE_VIEW_MY_CONNECTIONS =
            "/WEB-INF/portlets/linkedin/myConnections.jsp";

    public static final String PAGE_PREFERENCES = "/WEB-INF/portlets/linkedin/edit.jsp";

    public void doView(RenderRequest request, RenderResponse response) throws PortletException,
        IOException {

        String view = PAGE_VIEW_MY_PROFILE;

        String page =
                (String) request.getPortletSession().getAttribute(
                        "page_" + getPortletIdentifier(request), PortletSession.PORTLET_SCOPE);

        String accessTokenToken =
                getStringConfiguration(request, LinkedInPreferencesForm.PARAM_ACCESS_TOKEN_TOKEN);
        String accessTokenSecret =
                getStringConfiguration(request, LinkedInPreferencesForm.PARAM_ACCESS_TOKEN_SECRET);

        LinkedInContact profile = new LinkedInContact();
        List<LinkedInContact> contacts = new ArrayList<LinkedInContact>();

        if (PAGE_PIN.equals(page)) {
            view = PAGE_PREFERENCES;
        } else if (PAGE_EDIT.equals(page)) {
            view = PAGE_PREFERENCES;
        } else if (PAGE_CONNECTIONS.equals(page)) {
            try {
                contacts =
                        ServiceResolver.getResolver().getLinkedInService().getConnections(
                                accessTokenToken, accessTokenSecret);
            } catch (ServiceException se) {
                view = PAGE_PREFERENCES;
                handleException(request, se);
            }
            view = PAGE_VIEW_MY_CONNECTIONS;
        } else {
            try {
                profile =
                        ServiceResolver.getResolver().getLinkedInService().getProfile(
                                accessTokenToken, accessTokenSecret);
            } catch (ServiceException se) {
                view = PAGE_PREFERENCES;
                handleException(request, se);
            }

            view = PAGE_VIEW_MY_PROFILE;
        }

        request.setAttribute("profile", profile);
        request.setAttribute("contacts", contacts);

        response.setContentType(request.getResponseContentType());
        PortletRequestDispatcher rd = getPortletContext().getRequestDispatcher(view);
        rd.include(request, response);

    }

    public void processAction(ActionRequest request, ActionResponse response)
        throws PortletException, IOException {

        String action;

        action = (String) request.getParameter("action");

        String page = request.getParameter("page");

        if (page == null) {
            page = PAGE_PROFILE;
        } else if ("auth".equals(action)) {
            request.getPortletSession().setAttribute(
                    "requestToken_" + getPortletIdentifier(request),
                    ServiceResolver.getResolver().getLinkedInService().getRequestToken(),
                    PortletSession.APPLICATION_SCOPE);
            LinkedInPreferencesForm form = new LinkedInPreferencesForm(request);
            request.getPortletSession().setAttribute(
                    FORM_LINKEDIN_PREFERENCES + getPortletIdentifier(request), form,
                    PortletSession.APPLICATION_SCOPE);
            response.setPortletMode(PortletMode.EDIT);
        } else if ("save".equals(action)) {
            try {
                try {
                    savePreferences(request, response);
                } catch (ServiceException e) {
                    handleException(request, e);
                }
            } catch (PortletModeException e) {
                handleException(request, e);
            }
        } else if ("myProfile".equals(action)) {
            page = PAGE_PROFILE;
        } else if ("myConnections".equals(action)) {
            page = PAGE_CONNECTIONS;
        }

        if (page != null) {
            request.getPortletSession().setAttribute("page_" + getPortletIdentifier(request), page,
                    PortletSession.PORTLET_SCOPE);
        }
    }

    private void savePreferences(ActionRequest request, ActionResponse response)
        throws PortletModeException, ServiceException {

        LinkedInPreferencesForm form = new LinkedInPreferencesForm(request);

        if (validateForm(request, form)) {

            LinkedInRequestToken requestToken =
                    (LinkedInRequestToken) request.getPortletSession().getAttribute(
                            "requestToken_" + getPortletIdentifier(request),
                            PortletSession.APPLICATION_SCOPE);

            String pin = request.getParameter("pinCode");

            LinkedInAccessToken accessToken;

            try {
                accessToken =
                        ServiceResolver.getResolver().getLinkedInService().getAccessToken(
                                requestToken, pin);
            } catch (LinkedInOAuthServiceException ase) {
                response.setPortletMode(PortletMode.EDIT);
                throw new ServiceException("linkedin.authentication.failed");

            }

            String tokenToken = requestToken.getToken();
            String secret = requestToken.getTokenSecret();
            String tokenURL = requestToken.getAuthorizationUrl();

            Properties configuration = new Properties();
            configuration.setProperty(LinkedInPreferencesForm.PARAM_PIN, form.getPin());
            configuration
                    .setProperty(LinkedInPreferencesForm.PARAM_REQUEST_TOKEN_TOKEN, tokenToken);
            configuration.setProperty(LinkedInPreferencesForm.PARAM_REQUEST_TOKEN_SECRET, secret);
            configuration.setProperty(LinkedInPreferencesForm.PARAM_REQUEST_TOKEN_URL, tokenURL);
            configuration.setProperty(LinkedInPreferencesForm.PARAM_ACCESS_TOKEN_TOKEN, accessToken
                    .getToken());

            configuration.setProperty(LinkedInPreferencesForm.PARAM_ACCESS_TOKEN_SECRET,
                    accessToken.getTokenSecret());
            ServiceResolver.getResolver().getPortalService().savePortletConfiguration(request,
                    configuration);

            resetSessionForm(request, FORM_LINKEDIN_PREFERENCES);
            response.setPortletMode(PortletMode.VIEW);

        } else {
            // store in session
            request.getPortletSession().setAttribute(
                    FORM_LINKEDIN_PREFERENCES + getPortletIdentifier(request), form,
                    PortletSession.APPLICATION_SCOPE);
            response.setPortletMode(PortletMode.EDIT);
            logger.debug(FORM_LINKEDIN_PREFERENCES + " is in edit mode");
        }
    }

    @Override
    protected void addConfiguration(MessageSource messageSource, Locale locale,
        Map<String, String> result) {
        result.put(LinkedInPreferencesForm.PARAM_PIN, messageSource.getMessage(
                "linkedIn.preferences.pin", null, locale));
        result.put(LinkedInPreferencesForm.PARAM_REQUEST_TOKEN_TOKEN, messageSource.getMessage(
                "linkedIn.preferences.requestTokenToken", null, locale));
        result.put(LinkedInPreferencesForm.PARAM_REQUEST_TOKEN_SECRET, messageSource.getMessage(
                "linkedIn.preferences.requestTokenSecret", null, locale));
        result.put(LinkedInPreferencesForm.PARAM_REQUEST_TOKEN_URL, messageSource.getMessage(
                "linkedIn.preferences.requestTokenURL", null, locale));
        result.put(LinkedInPreferencesForm.PARAM_ACCESS_TOKEN_TOKEN, messageSource.getMessage(
                "linkedIn.preferences.accessToken", null, locale));
        result.put(LinkedInPreferencesForm.PARAM_ACCESS_TOKEN_SECRET, messageSource.getMessage(
                "linkedIn.preferences.accessTokenSecret", null, locale));
    }

    @Override
    protected void addPreference(MessageSource messageSource, Locale locale,
        Map<String, String> result) {
    }

    @Override
    public String getAsyncTitle(RenderRequest request) {
        return this.getTitle(request);
    }

    protected boolean validateForm(ActionRequest request, LinkedInPreferencesForm form) {
        return form.validate();
    }

    protected String myEdit(RenderRequest request, RenderResponse response)
        throws PortletException, IOException {

        LinkedInPreferencesForm form = new LinkedInPreferencesForm();

        form.setPin(getStringConfiguration(request, LinkedInPreferencesForm.PARAM_PIN));
        form.setRequestTokenToken(getStringConfiguration(request,
                LinkedInPreferencesForm.PARAM_REQUEST_TOKEN_TOKEN));
        form.setRequestTokenSecret(getStringConfiguration(request,
                LinkedInPreferencesForm.PARAM_REQUEST_TOKEN_SECRET));
        form.setRequestTokenURL(getStringConfiguration(request,
                LinkedInPreferencesForm.PARAM_REQUEST_TOKEN_URL));

        registerSessionForm(request, FORM_LINKEDIN_PREFERENCES, form);

        LinkedInRequestToken requestToken;

        requestToken =
                (LinkedInRequestToken) request.getPortletSession().getAttribute(
                        "requestToken_" + getPortletIdentifier(request),
                        PortletSession.APPLICATION_SCOPE);

        if (requestToken == null) {
            requestToken =
                    new LinkedInRequestToken(form.getRequestTokenToken(), form
                            .getRequestTokenSecret());
            requestToken.setAuthorizationUrl(form.getRequestTokenURL());
        }

        request.setAttribute("requestToken", requestToken);

        return PAGE_PREFERENCES;

    }
}