LinkedIn -Integration - Stellen Sie eine RequestToken fest

Question

Ich entwickle das Portlet (vorerst versuche), das in LinkedIn integriert wird.

Befolgen Sie die Dokumentation darüber:http://developer.linkedin.com/docs/doc-1008 -> Der erste Schritt zur Autorisierung eines LinkedIn-Mitglieds ist ein Antrag. Diese Anfrage erfolgt mit einem HTTP -Post. Für den anforderten Schritt sollten die folgenden Komponenten in Ihrer Zeichenfolge vorhanden sein, um zu unterschreiben:

* 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

Ich habe bereits API (es ist oAuth_consumer_key) Schlüssel und ich müssen eine bestimmte URL -Zeichenfolge generieren. Haben Sie den nächsten Java -Code für diese URL- und HTTP -Verbindung:

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

}

Die Frage ist als nächstes für diejenigen, die diesem Problem konfrontiert waren:Wie sollte wirklich URL -Zeichenfolge für die Verbindung aussehen und wie die Antwort empfangen wird?

Für die URL ist das Beispiel für die URL interessiert, die Sie generiert haben. Und für Interessierte die Methode, um es zu bekommen. Wie ich verstehe, ist diese Antwort nach der Festlegung der HTTP -Verbindung:

connection.getResponseMessage();

Answer 1

Sie können die OAuth -Bibliotheken ausprobieren, um die Verbindung zu verarbeiten: http://code.google.com/p/oauth/

Answer 2

@Sergionni Ich fand die Antwort auf Ihre Frage von LinkedIn-Entwickler

Wie Sie wissen, ist der erste Schritt zur Autorisierung eines verknüpften Mitglieds ein Antrag. Diese Anfrage erfolgt mit einem HTTP -Post.

Ihre Basiszeichenfolge sollte am Ende so aussehen, wenn Sie einen Rückruf verwenden:

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

Anschließend unterschreiben Sie diese Basiszeichenfolge mit Ihrem Consumer_secret und berechnen eine Signatur. In diesem Fall wäre die Signatur, wenn Ihr Geheimnis 1234567890 wäre, tlqxuuzm7omwdBtimnn6BlDVFF8 =.

Jetzt nehmen Sie die von Ihnen generierte Signatur zusammen mit oAuth_nonce, oAuth_callback, oAuth_signature_method, oAuth_timestamp, oAuth_consumer_key und oAuth_version und erstellen einen HTTP -Autorisierungs -Header. Für diese Anfrage würde dieser HTTP -Header wie:

Authorization: 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"

Bitte beachten Sie, dass der HTTP -Header ein einzelner Header ist - kein HTTP -Header für jede Komponente. Sie können optional ein Realm = "http://api.linkedin.com" angeben.

Als Antwort auf Ihre Anfrage nach einem RequestToken befindet sich Ihr Antrag im Antwortfeld "OAuth_Token", eine Bestätigung, die wir Ihren Rückruf mit dem Feld "oAuth_Callback_Conbirmed", ein OAuth_Token_Secret und ein OAUTH_EXPIRES_IN sowie einige andere Werte bestätigt haben.

(Hier wir Ihre Antwort) Die Antwort würde aussehen wie:

OAuth_Token = 94AB03C4-AE2C-45E4-8732-0E6C4899DB63 & OAuth_Token_Secret = BE6CCB24-BF0A-4EA8-A4B1-0A70508E452B & OATH_CALLBALLBAUMDE = TRUE & ORAUTH_INISS_INGES_INGAW_CALLBAGE_CONBAIRDE = TRUE & OHAUTH_EXPRICES_INS_INGES_INGRAGES_INGAW_CALLBAUMDE = TRUE & OAUTH_EXPRICES_INS_INGASE_INGAUSPRAGE = ERWEIS.

Answer 3

Ich habe ein Plugin für Play-Framework erstellt, um einfach in LinkedIn's OAuth zu integrieren: Geeks.aretotally.in/projects/play-framework-linkedin-module. Hoffentlich kann es helfen. Sie sollten sich auf jeden Fall Play ansehen, sehr, sehr cooles Java -Framework.

Answer 4

Portlet -Körper:

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;

    }
}