2724 lines
91 KiB
PHP
2724 lines
91 KiB
PHP
<?php
|
|
// http://code.google.com/p/simple-linkedinphp/
|
|
// 3.2.0 - November 29, 2011
|
|
// hacked into the code to handel new scope (r_basicprofile+r_emailaddress) - until Paul update linkedinphp library!
|
|
// Facyla note 20131219 : this in fact should not be hacked, as Linkedin lets developpers define the wanted scope
|
|
// in Linkedin application settings, when creating the (required) application and API access
|
|
|
|
/**
|
|
* This file defines the 'LinkedIn' class. This class is designed to be a
|
|
* simple, stand-alone implementation of the LinkedIn API functions.
|
|
*
|
|
* COPYRIGHT:
|
|
*
|
|
* Copyright (C) 2011, fiftyMission Inc.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
* IN THE SOFTWARE.
|
|
*
|
|
* SOURCE CODE LOCATION:
|
|
*
|
|
* http://code.google.com/p/simple-linkedinphp/
|
|
*
|
|
* REQUIREMENTS:
|
|
*
|
|
* 1. You must have cURL installed on the server and available to PHP.
|
|
* 2. You must be running PHP 5+.
|
|
*
|
|
* QUICK START:
|
|
*
|
|
* There are two files needed to enable LinkedIn API functionality from PHP; the
|
|
* stand-alone OAuth library, and this LinkedIn class. The latest version of
|
|
* the stand-alone OAuth library can be found on Google Code:
|
|
*
|
|
* http://code.google.com/p/oauth/
|
|
*
|
|
* Install these two files on your server in a location that is accessible to
|
|
* the scripts you wish to use them in. Make sure to change the file
|
|
* permissions such that your web server can read the files.
|
|
*
|
|
* Next, make sure the path to the OAuth library is correct (you can change this
|
|
* as needed, depending on your file organization scheme, etc).
|
|
*
|
|
* Finally, test the class by attempting to connect to LinkedIn using the
|
|
* associated demo.php page, also located at the Google Code location
|
|
* referenced above.
|
|
*
|
|
* RESOURCES:
|
|
*
|
|
* REST API Documentation: http://developer.linkedin.com/rest
|
|
*
|
|
* @version 3.2.0 - November 8, 2011
|
|
* @author Paul Mennega <paul@fiftymission.net>
|
|
* @copyright Copyright 2011, fiftyMission Inc.
|
|
* @license http://www.opensource.org/licenses/mit-license.php The MIT License
|
|
*/
|
|
|
|
/**
|
|
* 'LinkedInException' class declaration.
|
|
*
|
|
* This class extends the base 'Exception' class.
|
|
*
|
|
* @access public
|
|
* @package classpackage
|
|
*/
|
|
class LinkedInException extends Exception {}
|
|
|
|
/**
|
|
* 'LinkedIn' class declaration.
|
|
*
|
|
* This class provides generalized LinkedIn oauth functionality.
|
|
*
|
|
* @access public
|
|
* @package classpackage
|
|
*/
|
|
class LinkedIn {
|
|
// api/oauth settings
|
|
const _API_OAUTH_REALM = 'http://api.linkedin.com';
|
|
const _API_OAUTH_VERSION = '1.0';
|
|
|
|
// the default response format from LinkedIn
|
|
const _DEFAULT_RESPONSE_FORMAT = 'xml';
|
|
|
|
// helper constants used to standardize LinkedIn <-> API communication. See demo page for usage.
|
|
const _GET_RESPONSE = 'lResponse';
|
|
const _GET_TYPE = 'lType';
|
|
|
|
// Invitation API constants.
|
|
const _INV_SUBJECT = 'Invitation to connect';
|
|
const _INV_BODY_LENGTH = 200;
|
|
|
|
// API methods
|
|
const _METHOD_TOKENS = 'POST';
|
|
|
|
// Network API constants.
|
|
const _NETWORK_LENGTH = 1000;
|
|
const _NETWORK_HTML = '<a>';
|
|
|
|
// response format type constants, see http://developer.linkedin.com/docs/DOC-1203
|
|
const _RESPONSE_JSON = 'JSON';
|
|
const _RESPONSE_JSONP = 'JSONP';
|
|
const _RESPONSE_XML = 'XML';
|
|
|
|
// Share API constants
|
|
const _SHARE_COMMENT_LENGTH = 700;
|
|
const _SHARE_CONTENT_TITLE_LENGTH = 200;
|
|
const _SHARE_CONTENT_DESC_LENGTH = 400;
|
|
|
|
// LinkedIn API end-points
|
|
const _URL_ACCESS = 'https://api.linkedin.com/uas/oauth/accessToken';
|
|
const _URL_API = 'https://api.linkedin.com';
|
|
const _URL_AUTH = 'https://www.linkedin.com/uas/oauth/authenticate?oauth_token=';
|
|
const _URL_REQUEST = 'https://api.linkedin.com/uas/oauth/requestToken';
|
|
// const _URL_REQUEST = 'https://api.linkedin.com/uas/oauth/requestToken?scope=r_basicprofile+r_emailaddress+rw_nus+r_network';
|
|
const _URL_REVOKE = 'https://api.linkedin.com/uas/oauth/invalidateToken';
|
|
|
|
// Library version
|
|
const _VERSION = '3.2.0';
|
|
|
|
// oauth properties
|
|
protected $callback;
|
|
protected $token = null;
|
|
|
|
// application properties
|
|
protected $application_key,
|
|
$application_secret;
|
|
|
|
// the format of the data to return
|
|
protected $response_format = self::_DEFAULT_RESPONSE_FORMAT;
|
|
|
|
// last request fields
|
|
public $last_request_headers,
|
|
$last_request_url;
|
|
|
|
/**
|
|
* Create a LinkedIn object, used for OAuth-based authentication and
|
|
* communication with the LinkedIn API.
|
|
*
|
|
* @param arr $config
|
|
* The 'start-up' object properties:
|
|
* - appKey => The application's API key
|
|
* - appSecret => The application's secret key
|
|
* - callbackUrl => [OPTIONAL] the callback URL
|
|
*
|
|
* @return obj
|
|
* A new LinkedIn object.
|
|
*/
|
|
public function __construct($config) {
|
|
if(!is_array($config)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->__construct(): bad data passed, $config must be of type array.');
|
|
}
|
|
$this->setApplicationKey($config['appKey']);
|
|
$this->setApplicationSecret($config['appSecret']);
|
|
$this->setCallbackUrl($config['callbackUrl']);
|
|
}
|
|
|
|
/**
|
|
* The class destructor.
|
|
*
|
|
* Explicitly clears LinkedIn object from memory upon destruction.
|
|
*/
|
|
public function __destruct() {
|
|
unset($this);
|
|
}
|
|
|
|
/**
|
|
* Bookmark a job.
|
|
*
|
|
* Calling this method causes the current user to add a bookmark for the
|
|
* specified job:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1323
|
|
*
|
|
* @param str $jid
|
|
* Job ID you want to bookmark.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function bookmarkJob($jid) {
|
|
// check passed data
|
|
if(!is_string($jid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->bookmarkJob(): bad data passed, $jid must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/job-bookmarks';
|
|
$response = $this->fetch('POST', $query, '<job-bookmark><job><id>' . trim($jid) . '</id></job></job-bookmark>');
|
|
|
|
/**
|
|
* Check for successful request (a 201 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(201, $response);
|
|
}
|
|
|
|
/**
|
|
* Get list of jobs you have bookmarked.
|
|
*
|
|
* Returns a list of jobs the current user has bookmarked, per:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1323
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function bookmarkedJobs() {
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/job-bookmarks';
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Custom addition to make code compatible with PHP 5.2
|
|
*/
|
|
private function intWalker($value, $key) {
|
|
if(!is_int($value)) {
|
|
throw new LinkedInException('LinkedIn->checkResponse(): $http_code_required must be an integer or an array of integer values');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Used to check whether a response LinkedIn object has the required http_code or not and
|
|
* returns an appropriate LinkedIn object.
|
|
*
|
|
* @param var $http_code_required
|
|
* The required http response from LinkedIn, passed in either as an integer,
|
|
* or an array of integers representing the expected values.
|
|
* @param arr $response
|
|
* An array containing a LinkedIn response.
|
|
*
|
|
* @return boolean
|
|
* true or false depending on if the passed LinkedIn response matches the expected response.
|
|
*/
|
|
private function checkResponse($http_code_required, $response) {
|
|
// check passed data
|
|
if(is_array($http_code_required)) {
|
|
array_walk($http_code_required, array($this, 'intWalker'));
|
|
} else {
|
|
if(!is_int($http_code_required)) {
|
|
throw new LinkedInException('LinkedIn->checkResponse(): $http_code_required must be an integer or an array of integer values');
|
|
} else {
|
|
$http_code_required = array($http_code_required);
|
|
}
|
|
}
|
|
if(!is_array($response)) {
|
|
throw new LinkedInException('LinkedIn->checkResponse(): $response must be an array');
|
|
}
|
|
|
|
// check for a match
|
|
if(in_array($response['info']['http_code'], $http_code_required)) {
|
|
// response found
|
|
$response['success'] = true;
|
|
} else {
|
|
// response not found
|
|
$response['success'] = false;
|
|
$response['error'] = 'HTTP response from LinkedIn end-point was not code ' . implode(', ', $http_code_required);
|
|
}
|
|
return $response;
|
|
}
|
|
|
|
/**
|
|
* Close a job.
|
|
*
|
|
* Calling this method causes the passed job to be closed, per:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1151
|
|
*
|
|
* @param str $jid
|
|
* Job ID you want to close.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function closeJob($jid) {
|
|
// check passed data
|
|
if(!is_string($jid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->closeJob(): bad data passed, $jid must be of string value.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/jobs/partner-job-id=' . trim($jid);
|
|
$response = $this->fetch('DELETE', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 204 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(204, $response);
|
|
}
|
|
|
|
/**
|
|
* Share comment posting method.
|
|
*
|
|
* Post a comment on an existing connections shared content. API details can
|
|
* be found here:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1043
|
|
*
|
|
* @param str $uid
|
|
* The LinkedIn update ID.
|
|
* @param str $comment
|
|
* The share comment to be posted.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function comment($uid, $comment) {
|
|
// check passed data
|
|
if(!is_string($uid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->comment(): bad data passed, $uid must be of type string.');
|
|
}
|
|
if(!is_string($comment)) {
|
|
// nothing/non-string passed, raise an exception
|
|
throw new LinkedInException('LinkedIn->comment(): bad data passed, $comment must be a non-zero length string.');
|
|
}
|
|
|
|
/**
|
|
* Share comment rules:
|
|
*
|
|
* 1) No HTML permitted.
|
|
* 2) Comment cannot be longer than 700 characters.
|
|
*/
|
|
$comment = substr(trim(htmlspecialchars(strip_tags($comment))), 0, self::_SHARE_COMMENT_LENGTH);
|
|
$data = '<?xml version="1.0" encoding="UTF-8"?>
|
|
<update-comment>
|
|
<comment>' . $comment . '</comment>
|
|
</update-comment>';
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/network/updates/key=' . $uid . '/update-comments';
|
|
$response = $this->fetch('POST', $query, $data);
|
|
|
|
/**
|
|
* Check for successful request (a 201 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(201, $response);
|
|
}
|
|
|
|
/**
|
|
* Share comment retrieval.
|
|
*
|
|
* Return all comments associated with a given network update:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1043
|
|
*
|
|
* @param str $uid
|
|
* The LinkedIn update ID.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function comments($uid) {
|
|
// check passed data
|
|
if(!is_string($uid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->comments(): bad data passed, $uid must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/network/updates/key=' . $uid . '/update-comments';
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Company profile retrieval function.
|
|
*
|
|
* Takes a string of parameters as input and requests company profile data
|
|
* from the LinkedIn Company Profile API. See the official documentation for
|
|
* $options 'field selector' formatting:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1014
|
|
* http://developer.linkedin.com/docs/DOC-1259
|
|
*
|
|
* @param str $options
|
|
* Data retrieval options.
|
|
* @param bool $by_email
|
|
* [OPTIONAL] Search by email domain?
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function company($options, $by_email = false) {
|
|
// check passed data
|
|
if(!is_string($options)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->company(): bad data passed, $options must be of type string.');
|
|
}
|
|
if(!is_bool($by_email)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->company(): bad data passed, $by_email must be of type boolean.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/companies' . ($by_email ? '' : '/') . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Company products and their associated recommendations.
|
|
*
|
|
* The product data type contains details about a company's product or
|
|
* service, including recommendations from LinkedIn members, and replies from
|
|
* company representatives.
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1327
|
|
*
|
|
* @param str $cid
|
|
* Company ID you want the product for.
|
|
* @param str $options
|
|
* [OPTIONAL] Data retrieval options.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function companyProducts($cid, $options = '') {
|
|
// check passed data
|
|
if(!is_string($cid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->companyProducts(): bad data passed, $cid must be of type string.');
|
|
}
|
|
if(!is_string($options)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->companyProducts(): bad data passed, $options must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/companies/' . trim($cid) . '/products' . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Connection retrieval function.
|
|
*
|
|
* Takes a string of parameters as input and requests connection-related data
|
|
* from the Linkedin Connections API. See the official documentation for
|
|
* $options 'field selector' formatting:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1014
|
|
*
|
|
* @param str $options
|
|
* [OPTIONAL] Data retrieval options.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function connections($options = '~/connections') {
|
|
// check passed data
|
|
if(!is_string($options)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->connections(): bad data passed, $options must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/' . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* This creates a post in the specified group with the specified title and specified summary.
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $gid
|
|
* The group id.
|
|
* @param str $title
|
|
* The title of the post. This must be non-empty.
|
|
* @param str $summary
|
|
* [OPTIONAL] The content or summary of the post. This can be empty.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function createPost($gid, $title, $summary = '') {
|
|
if(!is_string($gid)) {
|
|
throw new LinkedInException('LinkedIn->createPost(): bad data passed, $gid must be of type string.');
|
|
}
|
|
if(!is_string($title) || empty($title)) {
|
|
throw new LinkedInException('LinkedIn->createPost(): bad data passed, $title must be a non-empty string.');
|
|
}
|
|
if(!is_string($summary)) {
|
|
throw new LinkedInException('LinkedIn->createPost(): bad data passed, $summary must be of type string.');
|
|
}
|
|
|
|
// construct the XML
|
|
$data = '<?xml version="1.0" encoding="UTF-8"?>
|
|
<post>
|
|
<title>'. $title . '</title>
|
|
<summary>' . $summary . '</summary>
|
|
</post>';
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/groups/' . trim($gid) . '/posts';
|
|
$response = $this->fetch('POST', $query, $data);
|
|
|
|
/**
|
|
* Check for successful request (a 201 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(201, $response);
|
|
}
|
|
|
|
/**
|
|
* This deletes the specified post if you are the owner or moderator that post.
|
|
* Otherwise, it just flags the post as inappropriate.
|
|
*
|
|
* https://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $pid
|
|
* The post id.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function deletePost($pid) {
|
|
if(!is_string($pid)) {
|
|
throw new LinkedInException('LinkedIn->deletePost(): bad data passed, $pid must be of type string');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/posts/' . trim($pid);
|
|
$response = $this->fetch('DELETE', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 204 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(204, $response);
|
|
}
|
|
|
|
/**
|
|
* Edit a job.
|
|
*
|
|
* Calling this method causes the passed job to be edited, with the passed
|
|
* XML instructing which fields to change, per:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1154
|
|
* http://developer.linkedin.com/docs/DOC-1142
|
|
*
|
|
* @param str $jid
|
|
* Job ID you want to renew.
|
|
* @param str $xml
|
|
* The XML containing the job fields to edit.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function editJob($jid, $xml) {
|
|
// check passed data
|
|
if(!is_string($jid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->editJob(): bad data passed, $jid must be of string value.');
|
|
}
|
|
if(is_string($xml)) {
|
|
$xml = trim(stripslashes($xml));
|
|
} else {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->editJob(): bad data passed, $xml must be of string value.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/jobs/partner-job-id=' . trim($jid);
|
|
$response = $this->fetch('PUT', $query, $xml);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* General data send/request method.
|
|
*
|
|
* @param str $method
|
|
* The data communication method.
|
|
* @param str $url
|
|
* The Linkedin API endpoint to connect with.
|
|
* @param str $data
|
|
* [OPTIONAL] The data to send to LinkedIn.
|
|
* @param arr $parameters
|
|
* [OPTIONAL] Addition OAuth parameters to send to LinkedIn.
|
|
*
|
|
* @return arr
|
|
* array containing:
|
|
*
|
|
* array(
|
|
* 'info' => Connection information,
|
|
* 'linkedin' => LinkedIn response,
|
|
* 'oauth' => The OAuth request string that was sent to LinkedIn
|
|
* )
|
|
*/
|
|
protected function fetch($method, $url, $data = null, $parameters = array()) {
|
|
// check for cURL
|
|
if(!extension_loaded('curl')) {
|
|
// cURL not present
|
|
throw new LinkedInException('LinkedIn->fetch(): PHP cURL extension does not appear to be loaded/present.');
|
|
}
|
|
|
|
try {
|
|
// generate OAuth values
|
|
$oauth_consumer = new OAuthConsumer($this->getApplicationKey(), $this->getApplicationSecret(), $this->getCallbackUrl());
|
|
$oauth_token = $this->getToken();
|
|
$oauth_token = (!is_null($oauth_token)) ? new OAuthToken($oauth_token['oauth_token'], $oauth_token['oauth_token_secret']) : null;
|
|
$defaults = array(
|
|
'oauth_version' => self::_API_OAUTH_VERSION
|
|
);
|
|
$parameters = array_merge($defaults, $parameters);
|
|
|
|
// generate OAuth request
|
|
$oauth_req = OAuthRequest::from_consumer_and_token($oauth_consumer, $oauth_token, $method, $url, $parameters);
|
|
$oauth_req->sign_request(new OAuthSignatureMethod_HMAC_SHA1(), $oauth_consumer, $oauth_token);
|
|
|
|
// start cURL, checking for a successful initiation
|
|
if(!$handle = curl_init()) {
|
|
// cURL failed to start
|
|
throw new LinkedInException('LinkedIn->fetch(): cURL did not initialize properly.');
|
|
}
|
|
|
|
// set cURL options, based on parameters passed
|
|
curl_setopt($handle, CURLOPT_CUSTOMREQUEST, $method);
|
|
curl_setopt($handle, CURLOPT_RETURNTRANSFER, true);
|
|
curl_setopt($handle, CURLOPT_SSL_VERIFYPEER, false);
|
|
curl_setopt($handle, CURLOPT_URL, $url);
|
|
curl_setopt($handle, CURLOPT_VERBOSE, false);
|
|
|
|
// Restrict the request timeout to 5 seconds. Linkedin is sometimes very
|
|
// slow and we don't want to trigger a PHP timeout on our end.
|
|
curl_setopt($handle, CURLOPT_TIMEOUT, 5);
|
|
|
|
if ( isset ( Hybrid_Auth::$config["proxy"] ) ) {
|
|
curl_setopt($handle, CURLOPT_PROXY, Hybrid_Auth::$config["proxy"]);
|
|
}
|
|
|
|
// configure the header we are sending to LinkedIn - http://developer.linkedin.com/docs/DOC-1203
|
|
$header = array($oauth_req->to_header(self::_API_OAUTH_REALM));
|
|
if(is_null($data)) {
|
|
// not sending data, identify the content type
|
|
$header[] = 'Content-Type: text/plain; charset=UTF-8';
|
|
switch($this->getResponseFormat()) {
|
|
case self::_RESPONSE_JSON:
|
|
$header[] = 'x-li-format: json';
|
|
break;
|
|
case self::_RESPONSE_JSONP:
|
|
$header[] = 'x-li-format: jsonp';
|
|
break;
|
|
}
|
|
} else {
|
|
$header[] = 'Content-Type: text/xml; charset=UTF-8';
|
|
curl_setopt($handle, CURLOPT_POSTFIELDS, $data);
|
|
}
|
|
curl_setopt($handle, CURLOPT_HTTPHEADER, $header);
|
|
|
|
// set the last url, headers
|
|
$this->last_request_url = $url;
|
|
$this->last_request_headers = $header;
|
|
|
|
// gather the response
|
|
$return_data['linkedin'] = curl_exec($handle);
|
|
if( $return_data['linkedin'] === false ) {
|
|
Hybrid_Logger::error( "LinkedIn::fetch(). curl_exec error: ", curl_error($handle) );
|
|
}
|
|
$return_data['info'] = curl_getinfo($handle);
|
|
$return_data['oauth']['header'] = $oauth_req->to_header(self::_API_OAUTH_REALM);
|
|
$return_data['oauth']['string'] = $oauth_req->base_string;
|
|
|
|
// check for throttling
|
|
if(self::isThrottled($return_data['linkedin'])) {
|
|
throw new LinkedInException('LinkedIn->fetch(): throttling limit for this user/application has been reached for LinkedIn resource - ' . $url);
|
|
}
|
|
|
|
//TODO - add check for NO response (http_code = 0) from cURL
|
|
|
|
// close cURL connection
|
|
curl_close($handle);
|
|
|
|
// no exceptions thrown, return the data
|
|
return $return_data;
|
|
} catch(OAuthException $e) {
|
|
// oauth exception raised
|
|
throw new LinkedInException('OAuth exception caught: ' . $e->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This flags a specified post as specified by type.
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $pid
|
|
* The post id.
|
|
* @param str $type
|
|
* The type to flag the post as.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function flagPost($pid, $type) {
|
|
if(!is_string($pid)) {
|
|
throw new LinkedInException('LinkedIn->flagPost(): bad data passed, $pid must be of type string');
|
|
}
|
|
if(!is_string($type)) {
|
|
throw new LinkedInException('LinkedIn->flagPost(): bad data passed, $like must be of type string');
|
|
}
|
|
//Constructing the xml
|
|
$data = '<?xml version="1.0" encoding="UTF-8"?>';
|
|
switch($type) {
|
|
case 'promotion':
|
|
$data .= '<code>promotion</code>';
|
|
break;
|
|
case 'job':
|
|
$data .= '<code>job</code>';
|
|
break;
|
|
default:
|
|
throw new LinkedInException('LinkedIn->flagPost(): invalid value for $type, must be one of: "promotion", "job"');
|
|
break;
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/posts/' . $pid . '/category/code';
|
|
$response = $this->fetch('PUT', $query, $data);
|
|
|
|
/**
|
|
* Check for successful request (a 204 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(204, $response);
|
|
}
|
|
|
|
/**
|
|
* Follow a company.
|
|
*
|
|
* Calling this method causes the current user to start following the
|
|
* specified company, per:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1324
|
|
*
|
|
* @param str $cid
|
|
* Company ID you want to follow.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function followCompany($cid) {
|
|
// check passed data
|
|
if(!is_string($cid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->followCompany(): bad data passed, $cid must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/following/companies';
|
|
$response = $this->fetch('POST', $query, '<company><id>' . trim($cid) . '</id></company>');
|
|
|
|
/**
|
|
* Check for successful request (a 201 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(201, $response);
|
|
}
|
|
|
|
/**
|
|
* Follows/Unfollows the specified post.
|
|
*
|
|
* https://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $pid
|
|
* The post id.
|
|
* @param bool $follow
|
|
* Determines whether to follow or unfollow the post. true = follow, false = unfollow
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
|
|
public function followPost($pid, $follow) {
|
|
if(!is_string($pid)) {
|
|
throw new LinkedInException('LinkedIn->followPost(): bad data passed, $pid must be of type string');
|
|
}
|
|
if(!($follow === true || $follow === false)) {
|
|
throw new LinkedInException('LinkedIn->followPost(): bad data passed, $follow must be of type boolean');
|
|
}
|
|
|
|
// construct the XML
|
|
$data = '<?xml version="1.0" encoding="UTF-8"?>
|
|
<is-following>'. (($follow) ? 'true' : 'false'). '</is-following>';
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/posts/' . trim($pid) . '/relation-to-viewer/is-following';
|
|
$response = $this->fetch('PUT', $query, $data);
|
|
|
|
/**
|
|
* Check for successful request (a 204 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(204, $response);
|
|
}
|
|
|
|
/**
|
|
* Get list of companies you follow.
|
|
*
|
|
* Returns a list of companies the current user is currently following, per:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1324
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function followedCompanies() {
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/following/companies';
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Get the application_key property.
|
|
*
|
|
* @return str
|
|
* The application key.
|
|
*/
|
|
public function getApplicationKey() {
|
|
return $this->application_key;
|
|
}
|
|
|
|
/**
|
|
* Get the application_secret property.
|
|
*
|
|
* @return str
|
|
* The application secret.
|
|
*/
|
|
public function getApplicationSecret() {
|
|
return $this->application_secret;
|
|
}
|
|
|
|
/**
|
|
* Get the callback property.
|
|
*
|
|
* @return str
|
|
* The callback url.
|
|
*/
|
|
public function getCallbackUrl() {
|
|
return $this->callback;
|
|
}
|
|
|
|
/**
|
|
* Get the response_format property.
|
|
*
|
|
* @return str
|
|
* The response format.
|
|
*/
|
|
public function getResponseFormat() {
|
|
return $this->response_format;
|
|
}
|
|
|
|
/**
|
|
* Get the token_access property.
|
|
*
|
|
* @return arr
|
|
* The access token.
|
|
*/
|
|
public function getToken() {
|
|
return $this->token;
|
|
}
|
|
|
|
/**
|
|
* [DEPRECATED] Get the token_access property.
|
|
*
|
|
* @return arr
|
|
* The access token.
|
|
*/
|
|
public function getTokenAccess() {
|
|
return $this->getToken();
|
|
}
|
|
|
|
/**
|
|
*
|
|
* Get information about a specific group.
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $gid
|
|
* The group id.
|
|
*
|
|
* @param str $options
|
|
* [OPTIONAL] Field selectors for the group.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
|
|
public function group($gid, $options = '') {
|
|
if(!is_string($gid)){
|
|
throw new LinkedInException('LinkedIn->group(): bad data passed, $gid must be of type string.');
|
|
}
|
|
if(!is_string($options)) {
|
|
throw new LinkedInException('LinkedIn->group(): bad data passed, $options must be of type string');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/groups/' . trim($gid) . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* This returns all the groups the user is a member of.
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $options
|
|
* [OPTIONAL] Field selectors for the groups.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function groupMemberships($options = '') {
|
|
if(!is_string($options)) {
|
|
throw new LinkedInException('LinkedIn->groupMemberships(): bad data passed, $options must be of type string');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/group-memberships' . trim($options) . '?membership-state=member';
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* This gets a specified post made within a group.
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $pid
|
|
* The post id.
|
|
* @param str $options
|
|
* [OPTIONAL] Field selectors for the post.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function groupPost($pid, $options = '') {
|
|
if(!is_string($pid)) {
|
|
throw new LinkedInException('LinkedIn->groupPost(): bad data passed, $pid must be of type string.');
|
|
}
|
|
if(!is_string($options)) {
|
|
throw new LinkedInException('LinkedIn->groupPost(): bad data passed, $options must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/posts/' . trim($pid) . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* This returns all the comments made on the specified post within a group.
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $pid
|
|
* The post id.
|
|
* @param str $options
|
|
* [OPTIONAL] Field selectors for the post comments.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function groupPostComments($pid, $options = ''){
|
|
if(!is_string($pid)){
|
|
throw new LinkedInException('LinkedIn->groupPostComments(): bad data passed, $pid must be of type string.');
|
|
}
|
|
if(!is_string($options)) {
|
|
throw new LinkedInException('LinkedIn->groupPostComments(): bad data passed, $options must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/posts/' . trim($pid) . '/comments' . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* This returns all the posts within a group.
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $gid
|
|
* The group id.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function groupPosts($gid, $options = '') {
|
|
if(!is_string($gid)){
|
|
throw new LinkedInException('LinkedIn->groupPosts(): bad data passed, $gid must be of type string');
|
|
}
|
|
if(!is_string($options)){
|
|
throw new LinkedInException('LinkedIn->groupPosts(): bad data passed, $options must be of type string');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/groups/' . trim($gid) .'/posts' . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* This returns the group settings of the specified group
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $gid
|
|
* The group id.
|
|
* @param str $options
|
|
* [OPTIONAL] Field selectors for the group.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function groupSettings($gid, $options = '') {
|
|
if(!is_string($gid)) {
|
|
throw new LinkedInException('LinkedIn->groupSettings(): bad data passed, $gid must be of type string');
|
|
}
|
|
if(!is_string($options)) {
|
|
throw new LinkedInException('LinkedIn->groupSettings(): bad data passed, $options must be of type string');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/group-memberships/' . trim($gid) . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Send connection invitations.
|
|
*
|
|
* Send an invitation to connect to your network, either by email address or
|
|
* by LinkedIn ID. Details on the API here:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1012
|
|
*
|
|
* @param str $method
|
|
* The invitation method to process.
|
|
* @param str $recipient
|
|
* The email/id to send the invitation to.
|
|
* @param str $subject
|
|
* The subject of the invitation to send.
|
|
* @param str $body
|
|
* The body of the invitation to send.
|
|
* @param str $type
|
|
* [OPTIONAL] The invitation request type (only friend is supported at this time by the Invite API).
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function invite($method, $recipient, $subject, $body, $type = 'friend') {
|
|
/**
|
|
* Clean up the passed data per these rules:
|
|
*
|
|
* 1) Message must be sent to one recipient (only a single recipient permitted for the Invitation API)
|
|
* 2) No HTML permitted
|
|
* 3) 200 characters max in the invitation subject
|
|
* 4) Only able to connect as a friend at this point
|
|
*/
|
|
// check passed data
|
|
if(empty($recipient)) {
|
|
throw new LinkedInException('LinkedIn->invite(): you must provide an invitation recipient.');
|
|
}
|
|
switch($method) {
|
|
case 'email':
|
|
if(is_array($recipient)) {
|
|
$recipient = array_map('trim', $recipient);
|
|
} else {
|
|
// bad format for recipient for email method
|
|
throw new LinkedInException('LinkedIn->invite(): invitation recipient email/name array is malformed.');
|
|
}
|
|
break;
|
|
case 'id':
|
|
$recipient = trim($recipient);
|
|
if(!self::isId($recipient)) {
|
|
// bad format for recipient for id method
|
|
throw new LinkedInException('LinkedIn->invite(): invitation recipient ID does not match LinkedIn format.');
|
|
}
|
|
break;
|
|
default:
|
|
throw new LinkedInException('LinkedIn->invite(): bad invitation method, must be one of: email, id.');
|
|
break;
|
|
}
|
|
if(!empty($subject)) {
|
|
$subject = trim(htmlspecialchars(strip_tags(stripslashes($subject))));
|
|
} else {
|
|
throw new LinkedInException('LinkedIn->invite(): message subject is empty.');
|
|
}
|
|
if(!empty($body)) {
|
|
$body = trim(htmlspecialchars(strip_tags(stripslashes($body))));
|
|
if(strlen($body) > self::_INV_BODY_LENGTH) {
|
|
throw new LinkedInException('LinkedIn->invite(): message body length is too long - max length is ' . self::_INV_BODY_LENGTH . ' characters.');
|
|
}
|
|
} else {
|
|
throw new LinkedInException('LinkedIn->invite(): message body is empty.');
|
|
}
|
|
switch($type) {
|
|
case 'friend':
|
|
break;
|
|
default:
|
|
throw new LinkedInException('LinkedIn->invite(): bad invitation type, must be one of: friend.');
|
|
break;
|
|
}
|
|
|
|
// construct the xml data
|
|
$data = '<?xml version="1.0" encoding="UTF-8"?>
|
|
<mailbox-item>
|
|
<recipients>
|
|
<recipient>';
|
|
switch($method) {
|
|
case 'email':
|
|
// email-based invitation
|
|
$data .= '<person path="/people/email=' . $recipient['email'] . '">
|
|
<first-name>' . htmlspecialchars($recipient['first-name']) . '</first-name>
|
|
<last-name>' . htmlspecialchars($recipient['last-name']) . '</last-name>
|
|
</person>';
|
|
break;
|
|
case 'id':
|
|
// id-based invitation
|
|
$data .= '<person path="/people/id=' . $recipient . '"/>';
|
|
break;
|
|
}
|
|
$data .= ' </recipient>
|
|
</recipients>
|
|
<subject>' . $subject . '</subject>
|
|
<body>' . $body . '</body>
|
|
<item-content>
|
|
<invitation-request>
|
|
<connect-type>';
|
|
switch($type) {
|
|
case 'friend':
|
|
$data .= 'friend';
|
|
break;
|
|
}
|
|
$data .= ' </connect-type>';
|
|
switch($method) {
|
|
case 'id':
|
|
// id-based invitation, we need to get the authorization information
|
|
$query = 'id=' . $recipient . ':(api-standard-profile-request)';
|
|
$response = self::profile($query);
|
|
if($response['info']['http_code'] == 200) {
|
|
$response['linkedin'] = self::xmlToarray($response['linkedin']);
|
|
if($response['linkedin'] === false) {
|
|
// bad XML data
|
|
throw new LinkedInException('LinkedIn->invite(): LinkedIn returned bad XML data.');
|
|
}
|
|
$authentication = explode(':', $response['linkedin']['person']['children']['api-standard-profile-request']['children']['headers']['children']['http-header']['children']['value']['content']);
|
|
|
|
// complete the xml
|
|
$data .= '<authorization>
|
|
<name>' . $authentication[0] . '</name>
|
|
<value>' . $authentication[1] . '</value>
|
|
</authorization>';
|
|
} else {
|
|
// bad response from the profile request, not a valid ID?
|
|
throw new LinkedInException('LinkedIn->invite(): could not send invitation, LinkedIn says: ' . print_r($response['linkedin'], true));
|
|
}
|
|
break;
|
|
}
|
|
$data .= ' </invitation-request>
|
|
</item-content>
|
|
</mailbox-item>';
|
|
|
|
// send request
|
|
$query = self::_URL_API . '/v1/people/~/mailbox';
|
|
$response = $this->fetch('POST', $query, $data);
|
|
|
|
/**
|
|
* Check for successful request (a 201 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(201, $response);
|
|
}
|
|
|
|
/**
|
|
* LinkedIn ID validation.
|
|
*
|
|
* Checks the passed string $id to see if it has a valid LinkedIn ID format,
|
|
* which is, as of October 15th, 2010:
|
|
*
|
|
* 10 alpha-numeric mixed-case characters, plus underscores and dashes.
|
|
*
|
|
* @param str $id
|
|
* A possible LinkedIn ID.
|
|
*
|
|
* @return bool
|
|
* true/false depending on valid ID format determination.
|
|
*/
|
|
public static function isId($id) {
|
|
// check passed data
|
|
if(!is_string($id)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->isId(): bad data passed, $id must be of type string.');
|
|
}
|
|
|
|
$pattern = '/^[a-z0-9_\-]{10}$/i';
|
|
if($match = preg_match($pattern, $id)) {
|
|
// we have a match
|
|
$return_data = true;
|
|
} else {
|
|
// no match
|
|
$return_data = false;
|
|
}
|
|
return $return_data;
|
|
}
|
|
|
|
/**
|
|
* Throttling check.
|
|
*
|
|
* Checks the passed LinkedIn response to see if we have hit a throttling
|
|
* limit:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1112
|
|
*
|
|
* @param arr $response
|
|
* The LinkedIn response.
|
|
*
|
|
* @return bool
|
|
* true/false depending on content of response.
|
|
*/
|
|
public static function isThrottled($response) {
|
|
$return_data = false;
|
|
|
|
// check the variable
|
|
if(!empty($response) && is_string($response)) {
|
|
// we have an array and have a properly formatted LinkedIn response
|
|
|
|
// store the response in a temp variable
|
|
$temp_response = self::xmlToarray($response);
|
|
if($temp_response !== false) {
|
|
// check to see if we have an error
|
|
if(array_key_exists('error', $temp_response) && ($temp_response['error']['children']['status']['content'] == 403) && preg_match('/throttle/i', $temp_response['error']['children']['message']['content'])) {
|
|
// we have an error, it is 403 and we have hit a throttle limit
|
|
$return_data = true;
|
|
}
|
|
}
|
|
}
|
|
return $return_data;
|
|
}
|
|
|
|
/**
|
|
* Job posting detail info retrieval function.
|
|
*
|
|
* The Jobs API returns detailed information about job postings on LinkedIn.
|
|
* Find the job summary, description, location, and apply our professional graph
|
|
* to present the relationship between the current member and the job poster or
|
|
* hiring manager.
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1322
|
|
*
|
|
* @param str $jid
|
|
* ID of the job you want to look up.
|
|
* @param str $options
|
|
* [OPTIONAL] Data retrieval options.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function job($jid, $options = '') {
|
|
// check passed data
|
|
if(!is_string($jid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->job(): bad data passed, $jid must be of type string.');
|
|
}
|
|
if(!is_string($options)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->job(): bad data passed, $options must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/jobs/' . trim($jid) . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Join the specified group, per:
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $gid
|
|
* The group id.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function joinGroup($gid) {
|
|
if(!is_string($gid)) {
|
|
throw new LinkedInException('LinkedIn->joinGroup(): bad data passed, $gid must be of type string.');
|
|
}
|
|
|
|
// constructing the XML
|
|
$data = '<?xml version="1.0" encoding="UTF-8"?>
|
|
<group-membership>
|
|
<membership-state>
|
|
<code>member</code>
|
|
</membership-state>
|
|
</group-membership>';
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/group-memberships/' . trim($gid);
|
|
$response = $this->fetch('PUT', $query, $data);
|
|
|
|
/**
|
|
* Check for successful request (a 200 or 201 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(array(200, 201), $response);
|
|
}
|
|
|
|
/**
|
|
* Returns the last request header from the previous call to the
|
|
* LinkedIn API.
|
|
*
|
|
* @returns str
|
|
* The header, in string format.
|
|
*/
|
|
public function lastRequestHeader() {
|
|
return $this->last_request_headers;
|
|
}
|
|
|
|
/**
|
|
* Returns the last request url from the previous call to the
|
|
* LinkedIn API.
|
|
*
|
|
* @returns str
|
|
* The url, in string format.
|
|
*/
|
|
public function lastRequestUrl() {
|
|
return $this->last_request_url;
|
|
}
|
|
|
|
/**
|
|
* Leave the specified group, per:.
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $gid
|
|
* The group id.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function leaveGroup($gid){
|
|
if(!is_string($gid)) {
|
|
throw new LinkedInException('LinkedIn->leaveGroup(): bad data passed, $gid must be of type string');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/group-memberships/' .trim($gid);
|
|
$response = $this->fetch('DELETE', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 204 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(204, $response);
|
|
}
|
|
|
|
/**
|
|
* Like another user's network update, per:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1043
|
|
*
|
|
* @param str $uid
|
|
* The LinkedIn update ID.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function like($uid) {
|
|
// check passed data
|
|
if(!is_string($uid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->like(): bad data passed, $uid must be of type string.');
|
|
}
|
|
|
|
// construct the XML
|
|
$data = '<?xml version="1.0" encoding="UTF-8"?>
|
|
<is-liked>true</is-liked>';
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/network/updates/key=' . $uid . '/is-liked';
|
|
$response = $this->fetch('PUT', $query, $data);
|
|
|
|
/**
|
|
* Check for successful request (a 201 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(201, $response);
|
|
}
|
|
|
|
/**
|
|
* Likes/unlikes the specified post, per:
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $pid
|
|
* The post id.
|
|
* @param bool $like
|
|
* Determines whether to like or unlike. true = like, false = unlike.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function likePost($pid, $like) {
|
|
if(!is_string($pid)) {
|
|
throw new LinkedInException ('LinkedIn->likePost(): bad data passed, $pid must be of type string');
|
|
}
|
|
if(!($like === true || $like === false)) {
|
|
throw new LinkedInException('LinkedIn->likePost(): bad data passed, $like must be of type boolean');
|
|
}
|
|
|
|
// construct the XML
|
|
$data = '<?xml version="1.0" encoding="UTF-8"?>
|
|
<is-liked>'.(($like) ? 'true': 'false').'</is-liked>';
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/posts/' . trim($pid) . '/relation-to-viewer/is-liked';
|
|
$response = $this->fetch('PUT', $query, $data);
|
|
|
|
/**
|
|
* Check for successful request (a 204 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(204, $response);
|
|
}
|
|
|
|
/**
|
|
* Retrieve network update likes.
|
|
*
|
|
* Return all likes associated with a given network update:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1043
|
|
*
|
|
* @param str $uid
|
|
* The LinkedIn update ID.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function likes($uid) {
|
|
// check passed data
|
|
if(!is_string($uid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->likes(): bad data passed, $uid must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/network/updates/key=' . $uid . '/likes';
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Connection messaging method.
|
|
*
|
|
* Send a message to your network connection(s), optionally copying yourself.
|
|
* Full details from LinkedIn on this functionality can be found here:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1044
|
|
*
|
|
* @param arr $recipients
|
|
* The connection(s) to send the message to.
|
|
* @param str $subject
|
|
* The subject of the message to send.
|
|
* @param str $body
|
|
* The body of the message to send.
|
|
* @param bool $copy_self
|
|
* [OPTIONAL] Also update the teathered Twitter account.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function message($recipients, $subject, $body, $copy_self = false) {
|
|
/**
|
|
* Clean up the passed data per these rules:
|
|
*
|
|
* 1) Message must be sent to at least one recipient
|
|
* 2) No HTML permitted
|
|
*/
|
|
if(!empty($subject) && is_string($subject)) {
|
|
$subject = trim(strip_tags(stripslashes($subject)));
|
|
} else {
|
|
throw new LinkedInException('LinkedIn->message(): bad data passed, $subject must be of type string.');
|
|
}
|
|
if(!empty($body) && is_string($body)) {
|
|
$body = trim(strip_tags(stripslashes($body)));
|
|
} else {
|
|
throw new LinkedInException('LinkedIn->message(): bad data passed, $body must be of type string.');
|
|
}
|
|
if(!is_array($recipients) || count($recipients) < 1) {
|
|
// no recipients, and/or bad data
|
|
throw new LinkedInException('LinkedIn->message(): at least one message recipient required.');
|
|
}
|
|
|
|
// construct the xml data
|
|
$data = '<?xml version="1.0" encoding="UTF-8"?>
|
|
<mailbox-item>
|
|
<recipients>';
|
|
$data .= ($copy_self) ? '<recipient><person path="/people/~"/></recipient>' : '';
|
|
for($i = 0; $i < count($recipients); $i++) {
|
|
if(is_string($recipients[$i])) {
|
|
$data .= '<recipient><person path="/people/' . trim($recipients[$i]) . '"/></recipient>';
|
|
} else {
|
|
throw new LinkedInException ('LinkedIn->message(): bad data passed, $recipients must be an array of type string.');
|
|
}
|
|
}
|
|
$data .= ' </recipients>
|
|
<subject>' . htmlspecialchars($subject) . '</subject>
|
|
<body>' . htmlspecialchars($body) . '</body>
|
|
</mailbox-item>';
|
|
|
|
// send request
|
|
$query = self::_URL_API . '/v1/people/~/mailbox';
|
|
$response = $this->fetch('POST', $query, $data);
|
|
|
|
/**
|
|
* Check for successful request (a 201 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(201, $response);
|
|
}
|
|
|
|
/**
|
|
* Job posting method.
|
|
*
|
|
* Post a job to LinkedIn, assuming that you have access to this feature.
|
|
* Full details from LinkedIn on this functionality can be found here:
|
|
*
|
|
* http://developer.linkedin.com/community/jobs?view=documents
|
|
*
|
|
* @param str $xml
|
|
* The XML defining a job to post.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function postJob($xml) {
|
|
// check passed data
|
|
if(is_string($xml)) {
|
|
$xml = trim(stripslashes($xml));
|
|
} else {
|
|
throw new LinkedInException('LinkedIn->postJob(): bad data passed, $xml must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/jobs';
|
|
$response = $this->fetch('POST', $query, $xml);
|
|
|
|
/**
|
|
* Check for successful request (a 201 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(201, $response);
|
|
}
|
|
|
|
/**
|
|
* General profile retrieval function.
|
|
*
|
|
* Takes a string of parameters as input and requests profile data from the
|
|
* Linkedin Profile API. See the official documentation for $options
|
|
* 'field selector' formatting:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1014
|
|
* http://developer.linkedin.com/docs/DOC-1002
|
|
*
|
|
* @param str $options
|
|
* [OPTIONAL] Data retrieval options.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function profile($options = '~') {
|
|
// check passed data
|
|
if(!is_string($options)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->profile(): bad data passed, $options must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/' . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Send a message
|
|
*
|
|
* Send a message to another member or members
|
|
*
|
|
* @author @timersys
|
|
*
|
|
* @param array $recipients
|
|
* The id or ids to send the message to.
|
|
* @param str $subject
|
|
* The subject of the invitation to send.
|
|
* @param str $body
|
|
* The body of the invitation to send.
|
|
*
|
|
* @return arr array
|
|
* Containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function send_msg($recipients, $subject, $body) {
|
|
/**
|
|
* Clean up the passed data per these rules:
|
|
*
|
|
* 1) No HTML permitted
|
|
* 2) 200 characters max in the invitation subject
|
|
* 3) Only able to connect as a friend at this point
|
|
*/
|
|
|
|
// check passed data
|
|
if(empty($recipients)) {
|
|
throw new LinkedInException('LinkedIn->send_msg(): you must provide an invitation recipient.');
|
|
}
|
|
if(!empty($subject)) {
|
|
$subject = trim(htmlspecialchars(strip_tags(stripslashes($subject))));
|
|
} else {
|
|
throw new LinkedInException('LinkedIn->send_msg(): message subject is empty.');
|
|
}
|
|
if(!empty($body)) {
|
|
$body = trim(htmlspecialchars(strip_tags(stripslashes($body))));
|
|
|
|
if(strlen($body) > self::_INV_BODY_LENGTH) {
|
|
throw new LinkedInException('LinkedIn->send_msg(): message body length is too long - max length is ' . self::_INV_BODY_LENGTH . ' characters.');
|
|
}
|
|
} else {
|
|
throw new LinkedInException('LinkedIn->send_msg(): message body is empty.');
|
|
}
|
|
|
|
// construct the xml data
|
|
$data = '<?xml version="1.0" encoding="UTF-8"?>
|
|
<mailbox-item>
|
|
<recipients>';
|
|
|
|
foreach( $recipients as $recipient )
|
|
{
|
|
$data .= '<recipient>';
|
|
$data .= '<person path="/people/'. $recipient . '"/>';
|
|
$data .= '</recipient>';
|
|
}
|
|
$data .= ' </recipients>
|
|
<subject>' . $subject . '</subject>
|
|
<body>' . $body . '</body>
|
|
</mailbox-item>';
|
|
// send request
|
|
$query = self::_URL_API . '/v1/people/~/mailbox';
|
|
$response = $this->fetch('POST', $query, $data);
|
|
|
|
/**
|
|
* Check for successful request (a 201 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(201, $response);
|
|
}
|
|
|
|
/**
|
|
* Manual API call method, allowing for support for un-implemented API
|
|
* functionality to be supported.
|
|
*
|
|
* @param str $method
|
|
* The data communication method.
|
|
* @param str $url
|
|
* The Linkedin API endpoint to connect with - should NOT include the
|
|
* leading https://api.linkedin.com/v1.
|
|
* @param str $body
|
|
* [OPTIONAL] The URL-encoded body data to send to LinkedIn with the request.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval information, LinkedIn response. Note that you
|
|
* must manually check the return code and compare this to the expected
|
|
* API response to determine if the raw call was successful.
|
|
*/
|
|
public function raw($method, $url, $body = null) {
|
|
if(!is_string($method)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->raw(): bad data passed, $method must be of string value.');
|
|
}
|
|
if(!is_string($url)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->raw(): bad data passed, $url must be of string value.');
|
|
}
|
|
if(!is_null($body) && !is_string($url)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->raw(): bad data passed, $body must be of string value.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1' . trim($url);
|
|
return $this->fetch($method, $query, $body);
|
|
}
|
|
|
|
/**
|
|
* This removes the specified group from the group suggestions, per:
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $gid
|
|
* The group id.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function removeSuggestedGroup($gid) {
|
|
if(!is_string($gid)) {
|
|
throw new LinkedInException('LinkedIn->removeSuggestedGroup(): bad data passed, $gid must be of type string');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/suggestions/groups/' .trim($gid);
|
|
$response = $this->fetch('DELETE', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 204 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(204, $response);
|
|
}
|
|
|
|
/**
|
|
* Renew a job.
|
|
*
|
|
* Calling this method causes the passed job to be renewed, per:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1154
|
|
*
|
|
* @param str $jid
|
|
* Job ID you want to renew.
|
|
* @param str $cid
|
|
* Contract ID that covers the passed Job ID.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function renewJob($jid, $cid) {
|
|
// check passed data
|
|
if(!is_string($jid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->renewJob(): bad data passed, $jid must be of string value.');
|
|
}
|
|
if(!is_string($cid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->renewJob(): bad data passed, $cid must be of string value.');
|
|
}
|
|
|
|
// construct the xml data
|
|
$data = '<?xml version="1.0" encoding="UTF-8"?>
|
|
<job>
|
|
<contract-id>' . trim($cid) . '</contract-id>
|
|
<renewal/>
|
|
</job>';
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/jobs/partner-job-id=' . trim($jid);
|
|
$response = $this->fetch('PUT', $query, $data);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Access token retrieval.
|
|
*
|
|
* Request the user's access token from the Linkedin API.
|
|
*
|
|
* @param str $token
|
|
* The token returned from the user authorization stage.
|
|
* @param str $secret
|
|
* The secret returned from the request token stage.
|
|
* @param str $verifier
|
|
* The verification value from LinkedIn.
|
|
*
|
|
* @return arr
|
|
* The Linkedin OAuth/http response, in array format.
|
|
*/
|
|
public function retrieveTokenAccess($token, $secret, $verifier) {
|
|
// check passed data
|
|
if(!is_string($token) || !is_string($secret) || !is_string($verifier)) {
|
|
// nothing passed, raise an exception
|
|
throw new LinkedInException('LinkedIn->retrieveTokenAccess(): bad data passed, string type is required for $token, $secret and $verifier.');
|
|
}
|
|
|
|
// start retrieval process
|
|
$this->setToken(array('oauth_token' => $token, 'oauth_token_secret' => $secret));
|
|
$parameters = array(
|
|
'oauth_verifier' => $verifier
|
|
);
|
|
$response = $this->fetch(self::_METHOD_TOKENS, self::_URL_ACCESS, null, $parameters);
|
|
parse_str($response['linkedin'], $response['linkedin']);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
if($response['info']['http_code'] == 200) {
|
|
// tokens retrieved
|
|
$this->setToken($response['linkedin']);
|
|
|
|
// set the response
|
|
$return_data = $response;
|
|
$return_data['success'] = true;
|
|
} else {
|
|
// error getting the request tokens
|
|
$this->setToken(null);
|
|
|
|
// set the response
|
|
$return_data = $response;
|
|
$return_data['error'] = 'HTTP response from LinkedIn end-point was not code 200';
|
|
$return_data['success'] = false;
|
|
}
|
|
return $return_data;
|
|
}
|
|
|
|
/**
|
|
* Request token retrieval.
|
|
*
|
|
* Get the request token from the Linkedin API.
|
|
*
|
|
* @return arr
|
|
* The Linkedin OAuth/http response, in array format.
|
|
*/
|
|
public function retrieveTokenRequest() {
|
|
$parameters = array(
|
|
'oauth_callback' => $this->getCallbackUrl()
|
|
);
|
|
$response = $this->fetch(self::_METHOD_TOKENS, self::_URL_REQUEST, null, $parameters);
|
|
parse_str($response['linkedin'], $response['linkedin']);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
if(($response['info']['http_code'] == 200) && (array_key_exists('oauth_callback_confirmed', $response['linkedin'])) && ($response['linkedin']['oauth_callback_confirmed'] == 'true')) {
|
|
// tokens retrieved
|
|
$this->setToken($response['linkedin']);
|
|
|
|
// set the response
|
|
$return_data = $response;
|
|
$return_data['success'] = true;
|
|
} else {
|
|
// error getting the request tokens
|
|
$this->setToken(null);
|
|
|
|
// set the response
|
|
$return_data = $response;
|
|
if((array_key_exists('oauth_callback_confirmed', $response['linkedin'])) && ($response['linkedin']['oauth_callback_confirmed'] == 'true')) {
|
|
$return_data['error'] = 'HTTP response from LinkedIn end-point was not code 200';
|
|
} else {
|
|
$return_data['error'] = 'OAuth callback URL was not confirmed by the LinkedIn end-point';
|
|
}
|
|
$return_data['success'] = false;
|
|
}
|
|
return $return_data;
|
|
}
|
|
|
|
/**
|
|
* User authorization revocation.
|
|
*
|
|
* Revoke the current user's access token, clear the access token's from
|
|
* current LinkedIn object. The current documentation for this feature is
|
|
* found in a blog entry from April 29th, 2010:
|
|
*
|
|
* http://developer.linkedin.com/community/apis/blog/2010/04/29/oauth--now-for-authentication
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function revoke() {
|
|
// construct and send the request
|
|
$response = $this->fetch('GET', self::_URL_REVOKE);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* [DEPRECATED] General people search function.
|
|
*
|
|
* Takes a string of parameters as input and requests profile data from the
|
|
* Linkedin People Search API. See the official documentation for $options
|
|
* querystring formatting:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1191
|
|
*
|
|
* @param str $options
|
|
* [OPTIONAL] Data retrieval options.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function search($options = null) {
|
|
return searchPeople($options);
|
|
}
|
|
|
|
/**
|
|
* Company search.
|
|
*
|
|
* Uses the Company Search API to find companies using keywords, industry,
|
|
* location, or some other criteria. It returns a collection of matching
|
|
* companies.
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1325
|
|
*
|
|
* @param str $options
|
|
* [OPTIONAL] Search options.
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function searchCompanies($options = '') {
|
|
// check passed data
|
|
if(!is_string($options)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->searchCompanies(): bad data passed, $options must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/company-search' . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Jobs search.
|
|
*
|
|
* Use the Job Search API to find jobs using keywords, company, location,
|
|
* or some other criteria. It returns a collection of matching jobs. Each
|
|
* entry can contain much of the information available on the job listing.
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1321
|
|
*
|
|
* @param str $options
|
|
* [OPTIONAL] Data retrieval options.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function searchJobs($options = '') {
|
|
// check passed data
|
|
if(!is_string($options)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->jobsSearch(): bad data passed, $options must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/job-search' . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* General people search function.
|
|
*
|
|
* Takes a string of parameters as input and requests profile data from the
|
|
* Linkedin People Search API. See the official documentation for $options
|
|
* querystring formatting:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1191
|
|
*
|
|
* @param str $options
|
|
* [OPTIONAL] Data retrieval options.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function searchPeople($options = null) {
|
|
// check passed data
|
|
if(!is_null($options) && !is_string($options)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->search(): bad data passed, $options must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people-search' . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Set the application_key property.
|
|
*
|
|
* @param str $key
|
|
* The application key.
|
|
*/
|
|
public function setApplicationKey($key) {
|
|
$this->application_key = $key;
|
|
}
|
|
|
|
/**
|
|
* Set the application_secret property.
|
|
*
|
|
* @param str $secret
|
|
* The application secret.
|
|
*/
|
|
public function setApplicationSecret($secret) {
|
|
$this->application_secret = $secret;
|
|
}
|
|
|
|
/**
|
|
* Set the callback property.
|
|
*
|
|
* @param str $url
|
|
* The callback url.
|
|
*/
|
|
public function setCallbackUrl($url) {
|
|
$this->callback = $url;
|
|
}
|
|
|
|
/**
|
|
* This sets the group settings of the specified group.
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @param str $gid
|
|
* The group id.
|
|
* @param str $xml
|
|
* The group settings to set. The settings are:
|
|
* -<show-group-logo-in-profile>
|
|
* -<contact-email>
|
|
* -<email-digest-frequency>
|
|
* -<email-announcements-from-managers>
|
|
* -<allow-messages-from-members>
|
|
* -<email-for-every-new-post>
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function setGroupSettings($gid, $xml) {
|
|
if(!is_string ($gid)) {
|
|
throw new LinkedInException('LinkedIn->setGroupSettings(): bad data passed, $token_access should be in array format.');
|
|
}
|
|
if(!is_string ($xml)) {
|
|
throw new LinkedInException('LinkedIn->setGroupSettings(): bad data passed, $token_access should be in array format.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/group-memberships/' . trim($gid);
|
|
$response = $this->fetch('PUT', $query, $xml);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Set the response_format property.
|
|
*
|
|
* @param str $format
|
|
* [OPTIONAL] The response format to specify to LinkedIn.
|
|
*/
|
|
public function setResponseFormat($format = self::_DEFAULT_RESPONSE_FORMAT) {
|
|
$this->response_format = $format;
|
|
}
|
|
|
|
/**
|
|
* Set the token property.
|
|
*
|
|
* @return arr $token
|
|
* The LinkedIn OAuth token.
|
|
*/
|
|
public function setToken($token) {
|
|
// check passed data
|
|
if(!is_null($token) && !is_array($token)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->setToken(): bad data passed, $token_access should be in array format.');
|
|
}
|
|
|
|
// set token
|
|
$this->token = $token;
|
|
}
|
|
|
|
/**
|
|
* [DEPRECATED] Set the token_access property.
|
|
*
|
|
* @return arr $token_access
|
|
* [OPTIONAL] The LinkedIn OAuth access token.
|
|
*/
|
|
public function setTokenAccess($token_access) {
|
|
$this->setToken($token_access);
|
|
}
|
|
|
|
/**
|
|
* Post a share.
|
|
*
|
|
* Create a new or reshare another user's shared content. Full details from
|
|
* LinkedIn on this functionality can be found here:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1212
|
|
*
|
|
* $action values: ('new', 'reshare')
|
|
* $content format:
|
|
* $action = 'new'; $content => ('comment' => 'xxx', 'title' => 'xxx', 'submitted-url' => 'xxx', 'submitted-image-url' => 'xxx', 'description' => 'xxx')
|
|
* $action = 'reshare'; $content => ('comment' => 'xxx', 'id' => 'xxx')
|
|
*
|
|
* @param str $action
|
|
* The sharing action to perform.
|
|
* @param str $content
|
|
* The share content.
|
|
* @param bool $private
|
|
* [OPTIONAL] Should we restrict this shared item to connections only?
|
|
* @param bool $twitter
|
|
* [OPTIONAL] Also update the teathered Twitter account.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function share($action, $content, $private = true, $twitter = false) {
|
|
// check the status itself
|
|
if(!empty($action) && !empty($content)) {
|
|
/**
|
|
* Status is not empty, wrap a cleaned version of it in xml. Status
|
|
* rules:
|
|
*
|
|
* 1) Comments are 700 chars max (if this changes, change _SHARE_COMMENT_LENGTH constant)
|
|
* 2) Content/title 200 chars max (if this changes, change _SHARE_CONTENT_TITLE_LENGTH constant)
|
|
* 3) Content/description 400 chars max (if this changes, change _SHARE_CONTENT_DESC_LENGTH constant)
|
|
* 4a) New shares must contain a comment and/or (content/title and content/submitted-url)
|
|
* 4b) Reshared content must contain an attribution id.
|
|
* 4c) Reshared content must contain actual content, not just a comment.
|
|
* 5) No HTML permitted in comment, content/title, content/description.
|
|
*/
|
|
|
|
// prepare the share data per the rules above
|
|
$share_flag = false;
|
|
$content_xml = null;
|
|
switch($action) {
|
|
case 'new':
|
|
// share can be an article
|
|
if(array_key_exists('title', $content) && array_key_exists('submitted-url', $content)) {
|
|
// we have shared content, format it as needed per rules above
|
|
$content_title = trim(htmlspecialchars(strip_tags(stripslashes($content['title']))));
|
|
if(strlen($content_title) > self::_SHARE_CONTENT_TITLE_LENGTH) {
|
|
throw new LinkedInException('LinkedIn->share(): title length is too long - max length is ' . self::_SHARE_CONTENT_TITLE_LENGTH . ' characters.');
|
|
}
|
|
$content_xml .= '<content>
|
|
<title>' . $content_title . '</title>
|
|
<submitted-url>' . trim(htmlspecialchars($content['submitted-url'])) . '</submitted-url>';
|
|
if(array_key_exists('submitted-image-url', $content)) {
|
|
$content_xml .= '<submitted-image-url>' . trim(htmlspecialchars($content['submitted-image-url'])) . '</submitted-image-url>';
|
|
}
|
|
if(array_key_exists('description', $content)) {
|
|
$content_desc = trim(htmlspecialchars(strip_tags(stripslashes($content['description']))));
|
|
if(strlen($content_desc) > self::_SHARE_CONTENT_DESC_LENGTH) {
|
|
throw new LinkedInException('LinkedIn->share(): description length is too long - max length is ' . self::_SHARE_CONTENT_DESC_LENGTH . ' characters.');
|
|
}
|
|
$content_xml .= '<description>' . $content_desc . '</description>';
|
|
}
|
|
$content_xml .= '</content>';
|
|
|
|
$share_flag = true;
|
|
}
|
|
|
|
// share can be just a comment
|
|
if(array_key_exists('comment', $content)) {
|
|
// comment located
|
|
$comment = htmlspecialchars(trim(strip_tags(stripslashes($content['comment']))));
|
|
if(strlen($comment) > self::_SHARE_COMMENT_LENGTH) {
|
|
throw new LinkedInException('LinkedIn->share(): comment length is too long - max length is ' . self::_SHARE_COMMENT_LENGTH . ' characters.');
|
|
}
|
|
$content_xml .= '<comment>' . $comment . '</comment>';
|
|
|
|
$share_flag = true;
|
|
}
|
|
break;
|
|
case 'reshare':
|
|
if(array_key_exists('id', $content)) {
|
|
// put together the re-share attribution XML
|
|
$content_xml .= '<attribution>
|
|
<share>
|
|
<id>' . trim($content['id']) . '</id>
|
|
</share>
|
|
</attribution>';
|
|
|
|
// optional additional comment
|
|
if(array_key_exists('comment', $content)) {
|
|
// comment located
|
|
$comment = htmlspecialchars(trim(strip_tags(stripslashes($content['comment']))));
|
|
if(strlen($comment) > self::_SHARE_COMMENT_LENGTH) {
|
|
throw new LinkedInException('LinkedIn->share(): comment length is too long - max length is ' . self::_SHARE_COMMENT_LENGTH . ' characters.');
|
|
}
|
|
$content_xml .= '<comment>' . $comment . '</comment>';
|
|
}
|
|
|
|
$share_flag = true;
|
|
}
|
|
break;
|
|
default:
|
|
// bad action passed
|
|
throw new LinkedInException('LinkedIn->share(): share action is an invalid value, must be one of: share, reshare.');
|
|
break;
|
|
}
|
|
|
|
// should we proceed?
|
|
if($share_flag) {
|
|
// put all of the xml together
|
|
$visibility = ($private) ? 'connections-only' : 'anyone';
|
|
$data = '<?xml version="1.0" encoding="UTF-8"?>
|
|
<share>
|
|
' . $content_xml . '
|
|
<visibility>
|
|
<code>' . $visibility . '</code>
|
|
</visibility>
|
|
</share>';
|
|
|
|
// create the proper url
|
|
$share_url = self::_URL_API . '/v1/people/~/shares';
|
|
if($twitter) {
|
|
// update twitter as well
|
|
$share_url .= '?twitter-post=true';
|
|
}
|
|
|
|
// send request
|
|
$response = $this->fetch('POST', $share_url, $data);
|
|
} else {
|
|
// data constraints/rules not met, raise an exception
|
|
throw new LinkedInException('LinkedIn->share(): sharing data constraints not met; check that you have supplied valid content and combinations of content to share.');
|
|
}
|
|
} else {
|
|
// data missing, raise an exception
|
|
throw new LinkedInException('LinkedIn->share(): sharing action or shared content is missing.');
|
|
}
|
|
|
|
/**
|
|
* Check for successful request (a 201 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(201, $response);
|
|
}
|
|
|
|
/**
|
|
* Network statistics.
|
|
*
|
|
* General network statistics retrieval function, returns the number of connections,
|
|
* second-connections an authenticated user has. More information here:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1006
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function statistics() {
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/network/network-stats';
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Companies you may want to follow.
|
|
*
|
|
* Returns a list of companies the current user may want to follow, per:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1324
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function suggestedCompanies() {
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/suggestions/to-follow/companies';
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Retrieves suggested groups for the user, per:
|
|
*
|
|
* http://developer.linkedin.com/documents/groups-api
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function suggestedGroups() {
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/suggestions/groups:(id,name,is-open-to-non-members)';
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse (200, $response);
|
|
}
|
|
|
|
/**
|
|
* Jobs you may be interested in.
|
|
*
|
|
* Returns a list of jobs the current user may be interested in, per:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1323
|
|
*
|
|
* @param str $options
|
|
* [OPTIONAL] Data retrieval options.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function suggestedJobs($options = ':(jobs)') {
|
|
// check passed data
|
|
if(!is_string($options)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->suggestedJobs(): bad data passed, $options must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/suggestions/job-suggestions' . trim($options);
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Unbookmark a job.
|
|
*
|
|
* Calling this method causes the current user to remove a bookmark for the
|
|
* specified job:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1323
|
|
*
|
|
* @param str $jid
|
|
* Job ID you want to unbookmark.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function unbookmarkJob($jid) {
|
|
// check passed data
|
|
if(!is_string($jid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->unbookmarkJob(): bad data passed, $jid must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/job-bookmarks/' . trim($jid);
|
|
$response = $this->fetch('DELETE', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 204 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(204, $response);
|
|
}
|
|
|
|
/**
|
|
* Unfollow a company.
|
|
*
|
|
* Calling this method causes the current user to stop following the specified
|
|
* company, per:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1324
|
|
*
|
|
* @param str $cid
|
|
* Company ID you want to unfollow.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function unfollowCompany($cid) {
|
|
// check passed data
|
|
if(!is_string($cid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->unfollowCompany(): bad data passed, $cid must be of string value.');
|
|
}
|
|
|
|
// construct and send the request
|
|
$query = self::_URL_API . '/v1/people/~/following/companies/id=' . trim($cid);
|
|
$response = $this->fetch('DELETE', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 204 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(204, $response);
|
|
}
|
|
|
|
/**
|
|
* Unlike a network update.
|
|
*
|
|
* Unlike another user's network update:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1043
|
|
*
|
|
* @param str $uid
|
|
* The LinkedIn update ID.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function unlike($uid) {
|
|
// check passed data
|
|
if(!is_string($uid)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->unlike(): bad data passed, $uid must be of type string.');
|
|
}
|
|
|
|
// construct the xml data
|
|
$data = '<?xml version="1.0" encoding="UTF-8"?>
|
|
<is-liked>false</is-liked>';
|
|
|
|
// send request
|
|
$query = self::_URL_API . '/v1/people/~/network/updates/key=' . $uid . '/is-liked';
|
|
$response = $this->fetch('PUT', $query, $data);
|
|
|
|
/**
|
|
* Check for successful request (a 201 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(201, $response);
|
|
}
|
|
|
|
/**
|
|
* Post network update.
|
|
*
|
|
* Update the user's Linkedin network status. Full details from LinkedIn
|
|
* on this functionality can be found here:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1009
|
|
* http://developer.linkedin.com/docs/DOC-1009#comment-1077
|
|
*
|
|
* @param str $update
|
|
* The network update.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function updateNetwork($update) {
|
|
// check passed data
|
|
if(!is_string($update)) {
|
|
// nothing/non-string passed, raise an exception
|
|
throw new LinkedInException('LinkedIn->updateNetwork(): bad data passed, $update must be a non-zero length string.');
|
|
}
|
|
|
|
/**
|
|
* Network update is not empty, wrap a cleaned version of it in xml.
|
|
* Network update rules:
|
|
*
|
|
* 1) No HTML permitted except those found in _NETWORK_HTML constant
|
|
* 2) Update cannot be longer than 140 characters.
|
|
*/
|
|
// get the user data
|
|
$response = self::profile('~:(first-name,last-name,site-standard-profile-request)');
|
|
if($response['success'] === true) {
|
|
/**
|
|
* We are converting response to usable data. I'd use SimpleXML here, but
|
|
* to keep the class self-contained, we will use a portable XML parsing
|
|
* routine, self::xmlToarray.
|
|
*/
|
|
$person = self::xmlToarray($response['linkedin']);
|
|
if($person === false) {
|
|
// bad xml data
|
|
throw new LinkedInException('LinkedIn->updateNetwork(): LinkedIn returned bad XML data.');
|
|
}
|
|
$fields = $person['person']['children'];
|
|
|
|
// prepare user data
|
|
$first_name = trim($fields['first-name']['content']);
|
|
$last_name = trim($fields['last-name']['content']);
|
|
$profile_url = trim($fields['site-standard-profile-request']['children']['url']['content']);
|
|
|
|
// create the network update
|
|
$update = trim(htmlspecialchars(strip_tags($update, self::_NETWORK_HTML)));
|
|
if(strlen($update) > self::_NETWORK_LENGTH) {
|
|
throw new LinkedInException('LinkedIn->share(): update length is too long - max length is ' . self::_NETWORK_LENGTH . ' characters.');
|
|
}
|
|
$user = htmlspecialchars('<a href="' . $profile_url . '">' . $first_name . ' ' . $last_name . '</a>');
|
|
$data = '<activity locale="en_US">
|
|
<content-type>linkedin-html</content-type>
|
|
<body>' . $user . ' ' . $update . '</body>
|
|
</activity>';
|
|
|
|
// send request
|
|
$query = self::_URL_API . '/v1/people/~/person-activities';
|
|
$response = $this->fetch('POST', $query, $data);
|
|
|
|
/**
|
|
* Check for successful request (a 201 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(201, $response);
|
|
} else {
|
|
// profile retrieval failed
|
|
throw new LinkedInException('LinkedIn->updateNetwork(): profile data could not be retrieved.');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* General network update retrieval function.
|
|
*
|
|
* Takes a string of parameters as input and requests update-related data
|
|
* from the Linkedin Network Updates API. See the official documentation for
|
|
* $options parameter formatting:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1006
|
|
*
|
|
* For getting more comments, likes, etc, see here:
|
|
*
|
|
* http://developer.linkedin.com/docs/DOC-1043
|
|
*
|
|
* @param str $options
|
|
* [OPTIONAL] Data retrieval options.
|
|
* @param str $id
|
|
* [OPTIONAL] The LinkedIn ID to restrict the updates for.
|
|
*
|
|
* @return arr
|
|
* array containing retrieval success, LinkedIn response.
|
|
*/
|
|
public function updates($options = null, $id = null) {
|
|
// check passed data
|
|
if(!is_null($options) && !is_string($options)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->updates(): bad data passed, $options must be of type string.');
|
|
}
|
|
if(!is_null($id) && !is_string($id)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->updates(): bad data passed, $id must be of type string.');
|
|
}
|
|
|
|
// construct and send the request
|
|
if(!is_null($id) && self::isId($id)) {
|
|
$query = self::_URL_API . '/v1/people/' . $id . '/network/updates' . trim($options);
|
|
} else {
|
|
$query = self::_URL_API . '/v1/people/~/network/updates' . trim($options);
|
|
}
|
|
$response = $this->fetch('GET', $query);
|
|
|
|
/**
|
|
* Check for successful request (a 200 response from LinkedIn server)
|
|
* per the documentation linked in method comments above.
|
|
*/
|
|
return $this->checkResponse(200, $response);
|
|
}
|
|
|
|
/**
|
|
* Converts passed XML data to an array.
|
|
*
|
|
* @param str $xml
|
|
* The XML to convert to an array.
|
|
*
|
|
* @return arr
|
|
* array containing the XML data.
|
|
* @return bool
|
|
* false if passed data cannot be parsed to an array.
|
|
*/
|
|
public static function xmlToarray($xml) {
|
|
// check passed data
|
|
if(!is_string($xml)) {
|
|
// bad data passed
|
|
throw new LinkedInException('LinkedIn->xmlToarray(): bad data passed, $xml must be a non-zero length string.');
|
|
}
|
|
|
|
$parser = xml_parser_create();
|
|
xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
|
|
xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);
|
|
if(xml_parse_into_struct($parser, $xml, $tags)) {
|
|
$elements = array();
|
|
$stack = array();
|
|
foreach($tags as $tag) {
|
|
$index = count($elements);
|
|
if($tag['type'] == 'complete' || $tag['type'] == 'open') {
|
|
$elements[$tag['tag']] = array();
|
|
$elements[$tag['tag']]['attributes'] = (array_key_exists('attributes', $tag)) ? $tag['attributes'] : null;
|
|
$elements[$tag['tag']]['content'] = (array_key_exists('value', $tag)) ? $tag['value'] : null;
|
|
if($tag['type'] == 'open') {
|
|
$elements[$tag['tag']]['children'] = array();
|
|
$stack[count($stack)] = &$elements;
|
|
$elements = &$elements[$tag['tag']]['children'];
|
|
}
|
|
}
|
|
if($tag['type'] == 'close') {
|
|
$elements = &$stack[count($stack) - 1];
|
|
unset($stack[count($stack) - 1]);
|
|
}
|
|
}
|
|
$return_data = $elements;
|
|
} else {
|
|
// not valid xml data
|
|
$return_data = false;
|
|
}
|
|
xml_parser_free($parser);
|
|
return $return_data;
|
|
}
|
|
}
|