def sign_in(request):
# Authenticate using the API key and Secret
RETURN_URL = "http://localhost:8000/sign_in/"
authentication = linkedin.LinkedInAuthentication(API_KEY, API_SECRET, RETURN_URL, linkedin.PERMISSIONS.enums.values())
authentication.authorization_code = request.GET.get('code')
application = linkedin.LinkedInApplication(authentication)
# Get the API access token
tok = authentication.get_access_token()
application = linkedin.LinkedInApplication(token=tok)
# Render the user's profile data as JSON
return render(request, 'sign_in.html', {'profile': application.get_profile()})
def get_resume_info(self, request, auth_code=None):
"""
Get full information from a resume and add theses information to the session cache
:param auth_code: the authentication code needed to request the linkedinAPI
:param request: the request
:param application: the application filled with access token
"""
# if 'auth_code' not in request.session:
self.authentication.authorization_code = auth_code
request.session['auth_code'] = auth_code
linked_authentication = self.authentication.get_access_token()
logger.debug("We have the TOKEN : " +
str(linked_authentication.access_token))
application = linkedin.LinkedInApplication(
token=linked_authentication.access_token)
data = application.get_profile()
logger.debug("resume Data : " + str(data))
request.session['firstName'] = data.get('firstName')
request.session['lastName'] = data.get('lastName')
request.session['headline'] = data.get('headline')
contact, created = Contact.objects.get_or_create(
first_name=data.get('firstName'),
last_name=data.get('lastName'),
headline=data.get('headline'))
if created:
contact.count = 1
else:
logger.debug("Not created :" + str(contact.count))
contact.count = contact.count + 1
logger.debug("New count :" + str(contact.count))
contact.save()
def __init__(self):
try:
f = open('token', 'r')
except IOError:
f = open('token', 'wb')
pickle.dump([], f)
f.close()
f = open('token', 'r')
tk = pickle.load(f)
f.close()
if not tk:
auth_token() # fetch authorization token
if ST != config.STATE:
print "CSRF Attack! Aborting.."
exit(1)
data = {
'grant_type': 'authorization_code',
'code': AT,
'redirect_uri': config.REDIRECT_URL,
'client_id': config.CLIENT_ID,
'client_secret': config.CLIENT_SECRET
}
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
r = post(config.ACCESS_URL, data=data,
headers=headers).text # fetch access token
r = json.loads(r)
token = r['access_token']
tk = list(token)
f = open('token', 'wb')
pickle.dump(tk, f)
f.close()
else:
token = ''.join(tk)
self.app = linkedin.LinkedInApplication(token=token)
def linkedin_view(request):
authentication = linkedin.LinkedInDeveloperAuthentication(
consumer_key=settings.LINKEDIN_CONSUMER_KEY,
consumer_secret=settings.LINKEDIN_CONSUMER_SECRET,
user_token=settings.LINKEDIN_USER_TOKEN,
user_secret=settings.LINKEDIN_USER_SECRET,
redirect_uri=settings.SITE_ROOT_URI,
permissions=linkedin.PERMISSIONS.enums.values())
application = linkedin.LinkedInApplication(authentication)
profile_data = application.get_profile(selectors=[
'id', 'first-name', 'last-name', 'headline', 'location',
'num-connections', 'skills', 'educations', 'picture-url',
'site-standard-profile-request', 'summary', 'positions', 'industry'
])
group_data = application.get_memberships()
network_updates_data = application.get_network_updates(
types=LINKEDIN_NETWORK_UPDATE_TYPES)
context = {
'profile': profile_data,
'groups': group_data,
'network_updates': network_updates_data
}
return HttpResponse(content=json.dumps(context),
status=200,
content_type='application/json')
def processLinkedInData(jobsite, searchstring, citytosearch, ziptosearch, lastDownloadedTime):
authentication = linkedin.LinkedInDeveloperAuthentication('75ph7mwmqazlp9', 'wauOWNOXgZqBKBWo', '4468dda6-1a33-4007-a175-0e03dc72282b', 'a9aee8ab-984b-4a3d-b8e9-a4e459c7d10f',
'http:\\jeevansgadgets.com\getjoblist', linkedin.PERMISSIONS.enums.values())
application = linkedin.LinkedInApplication(authentication)
filename = '%sjoblist.txt' % jobsite
joblistfile = open(filename, 'w')
totalcount = 0
loopcount = 20
while loopcount == 20:
print 'downloading %s-%s' % (totalcount, totalcount+20)
loopcount = 0
data = application.search_job(selectors=[{'jobs': ['id', 'customer-job-code', 'posting-date', 'active', 'company', 'position', 'site-job-url', 'location-description']}],
params={'active': 'true', 'facet': 'job-function,it', 'keywords': searchstring, 'count': 20, 'start': totalcount, 'postal-code': ziptosearch, 'country-code': 'US', 'distance': 50, 'sort': 'DD'})
#print data
if data["jobs"]["_total"] == 0:
continue
for job in data["jobs"]["values"]:
loopcount = loopcount + 1
totalcount = totalcount + 1
date = datetime.datetime.strptime(str(job["postingDate"]["month"]) + '-' + str(job["postingDate"]["day"]) + '-' + str(job["postingDate"]["year"]), '%m-%d-%Y')
url = job["siteJobUrl"].strip()
url = re.sub('&trk.*', '', url)
if date >= lastDownloadedTime:
joblistfile.write(job["position"]["title"].encode('ascii', 'ignore').strip() + '\t' + url + '\t' + job["company"]["name"].encode('ascii', 'ignore').strip() + '\t' + '' + '\t' + job["locationDescription"].strip() + '\t' + date.strftime('%Y-%m-%d') + '\n')
def sign_in(request):
# Get the authorization URL from Linkedin
RETURN_URL = "http://localhost:8000/sign_in/"
authentication = linkedin.LinkedInAuthentication(
API_KEY, API_SECRET, RETURN_URL, linkedin.PERMISSIONS.enums.values())
application = linkedin.LinkedInApplication(authentication)
return JsonResponse({'auth_url': authentication.authorization_url})
def share_post(channel_id, comment, title, submitted_url, submitted_image_url,
visibility_code):
"""
Publish a message on a linkedin channel,
:param channel_id: The id of the channel we want to publish to
:param comment: The description of the post
:param title: The title of the post
:param submitted_url: The link contained in the post
:param submitted_image_url: The image contained in the post
:param visibility_code: Describe who can see this post
:return: True if the message is published else False
"""
token = LinkedinTokens.get_token(LinkedinTokens, channel_id).__getitem__(0)
print('share_post token ', token)
application = linkedin.LinkedInApplication(token=token)
print('submitted_url', submitted_url)
if submitted_url is '':
submitted_url = None
if submitted_image_url is '':
submitted_image_url = None
application.submit_share(comment=comment,
title=title,
submitted_url=submitted_url,
submitted_image_url=submitted_image_url,
description="This is a sharing from Superform",
visibility_code=visibility_code)
return True
def post(access_token,
comment=None,
title=None,
description=None,
submitted_url=None,
submitted_image_url=None,
visibility_code='anyone'):
"""
Publishes the post using the python3-linkedin API
:param access_token: the access token which allows publishing
:param comment: the body of the article
:param title: the title of the related image or link
:param description:
:param submitted_url: the link
:param submitted_image_url: the image
:param visibility_code: visibility of the post on LinkedIn (on
'anyone' by default
:return: returns the link to the post just created or an exception
"""
import collections
AccessToken = collections.namedtuple('AccessToken',
['access_token', 'expires_in'])
authentication = get_linkedin_authentication()
authentication.token = AccessToken(access_token, "99999999")
application = linkedin.LinkedInApplication(authentication)
profile = application.get_profile()
print("User Profile", profile)
try:
resp = application.submit_share(comment, title, description,
submitted_url, submitted_image_url,
visibility_code)
return resp
except Exception as e:
print(e)
return False
def get_connection_values(response, **kwargs):
if not response:
return None
access_token = response['access_token']
auth = linkedin.LinkedInAuthentication(None, None, None, None)
auth.token = AccessToken(response['access_token'], response['expires_in'])
api = linkedin.LinkedInApplication(auth)
profile = api.get_profile(selectors=selectors)
profile_url = profile['siteStandardProfileRequest']['url']
image_url = profile['pictureUrl']
return dict(
provider_id=config['id'],
provider_user_id=profile['id'],
access_token=access_token,
secret=None,
display_name=profile['firstName'],
full_name='%s %s' % (profile['firstName'], profile['lastName']),
profile_url=profile_url,
image_url=image_url,
email=profile.get('emailAddress'),
)
def linkedinRedirection(request):
print "I was here!!!"
authentication = linkedin.LinkedInAuthentication(API_KEY, API_SECRET, RETURN_URL, perms)
code = request.GET.get('code')
authentication.authorization_code = code
at = authentication.get_access_token()
print at
application = linkedin.LinkedInApplication(token=at[0])
profile = application.get_profile(selectors=['id', 'first-name', 'siteStandardProfileRequest', 'last-name', 'location', 'distance', 'num-connections', 'skills', 'educations'])
print profile
# # Step 3. Lookup the user or create them if they don't exist.
# #firstname = profile['firstName']
# #lastname = profile['lastName']
# identifier = profile['id']
print request.user
page_user = get_object_or_404(User, username=request.user)
print page_user
#user = get_object_or_404(User, username=request.user)
identifier = profile['siteStandardProfileRequest']['url']
print identifier
LinkedInProfile.objects.get_or_create(identifier=identifier,
user=page_user)
page_user.profile.isLinkedinPresent = True
page_user.profile.linkedin_url = identifier
page_user.save()
return render(request, 'core/add_linkedIn.html')
def authenticate():
credentials = get_credentials()
authentication = linkedin.LinkedInDeveloperAuthentication(
credentials['consumer-key'], credentials['consumer-secret'],
credentials['user-token'], credentials['user-secret'],
credentials['return-url'], linkedin.PERMISSIONS.enums.values())
return linkedin.LinkedInApplication(authentication)
def redir():
authentication = linkedin.LinkedInAuthentication(
API_KEY, API_SECRET, RETURN_URL, linkedin.PERMISSIONS.enums.values())
application = linkedin.LinkedInApplication(authentication)
if request.args.get('code', '') != '':
authentication.authorization_code = request.args.get('code', '')
authentication.get_access_token()
profile = application.get_profile(selectors=[
'id', 'first-name', 'last-name', 'location', 'distance',
'num-connections', 'skills', 'educations', 'interests', 'courses',
'following', 'related-profile-views', 'job-bookmarks',
'certifications'
])
skills = get_skills(profile)
courses = get_courses(profile)
input_values = list(set(skills + courses))
# print input_values
github_input_values = [
'c', 'c++', 'java', 'data structures', 'algorithms'
]
github_input_values = input_values[:10]
stack_qn_recommendations = multilabelstack.query(input_values)
github_recommendations = git_crawler.query(github_input_values)
dump_json(stack_qn_recommendations, "linkedin/stackoverflow_qns.json")
dump_json(github_recommendations, "linkedin/git_repos.json")
return render_template('redir.html')
else:
print "No Auth Code\n"
return render_template('redir.html')
def __init__(self, token_set, who):
self.who = who
#################################
# Linked In keys #
#################################
CONSUMER_KEY = token_set['CONSUMER_KEY']
CONSUMER_SECRET = token_set['CONSUMER_SECRET']
USER_TOKEN = token_set['USER_TOKEN']
USER_SECRET = token_set['USER_SECRET']
print "Connecting to linkedIn."
auth = linkedin.LinkedInDeveloperAuthentication(
CONSUMER_KEY,
CONSUMER_SECRET,
USER_TOKEN,
USER_SECRET,
'http://localhost',
permissions=linkedin.PERMISSIONS.enums.values())
print "Authenticating."
self.lnk = linkedin.LinkedInApplication(auth)
print "Getting %s's connections." % self.who
self.load_linkedin_connections()
print "Processing list."
# load clean up mappings
self.cleanup_company = {}
self.cleanup_email = {}
f = open("cleanup_company.txt")
for line in f.readlines():
x = line.split(":")
self.cleanup_company[x[0]] = x[1]
self.cleanup_email[x[0]] = x[2].strip()
f.close()
def setup_linkedin_application(self, linkedin_client_id,
linkedin_client_secret):
"""
Sets up and returns a new LinkedInApplication that can be used to get data.
Ensure that the LinkedIn app dashboard for the given client ID and client secret have
the LINKEDIN_RETURN_URL at the top of this file in the 'Authorized Redurect URLs'
"""
authentication = linkedin.LinkedInAuthentication(linkedin_client_id, linkedin_client_secret, LINKEDIN_RETURN_URL, \
permissions=['r_basicprofile', \
'r_emailaddress', \
'rw_company_admin', \
'w_share'])
print(
"Open this URL in your browser and give permissions if necessary: "
+
authentication.authorization_url) # open this url on your browser
authentication.authorization_code = input(
"After you are redirected, copy the entire URL from your address bar and enter it here: "
).replace(LINKEDIN_RETURN_URL + "?code=", "").split("&state=")[0]
print("\n\n Your authorization code is: " +
authentication.authorization_code)
result = authentication.get_access_token()
print("Your new Access Token:", result.access_token)
print("Access Token Expires in (seconds):", result.expires_in)
return linkedin.LinkedInApplication(authentication)
def linkedin_extract(redirect_uri, return_url):
#assumes linkedin_url is correct if not empty
if redirect_uri == "":
print "Error: Invalid redirect_uri. redirect_uri is empty. Exiting"
return 0
query = urlparse.urlparse(redirect_uri).query #Parse uri
url_dict = urlparse.parse_qs(query)
if 'code' not in url_dict:
print "Error: Code not found in redirect uri. Exiting"
return 0
authentication_code = url_dict['code'] #Get code
authentication = linkedin.LinkedInAuthentication(
__API_KEY, __API_SECRET, return_url,
linkedin.PERMISSIONS.enums.values())
authentication.authorization_code = authentication_code #Set auth_code, lib does not do this smartly..
authentication.get_access_token() #Needed to access linkedin account info.
application = linkedin.LinkedInApplication(authentication) #Now get access
# Extract user information
# Only extract skills:
#fields = 'skills'
# Full extraction:
fields = ("id," + "first-name," + "last-name," + "headline," +
"picture-url," + "industry," + "summary," + "specialties," +
"positions:(" + "id," + "title," + "summary," + "start-date," +
"end-date," + "is-current," + "company:(" + "id," + "name," +
"type," + "size," + "industry," + "ticker)" + ")," +
"educations:(" + "id," + "school-name," + "field-of-study," +
"start-date," + "end-date," + "degree," + "activities," +
"notes)," + "associations," + "interests," +
"num-recommenders," + "date-of-birth," + "publications:(" +
"id," + "title," + "publisher:(name)," + "authors:(id,name)," +
"date," + "url," + "summary)," + "patents:(" + "id," + "title," +
"summary," + "number," + "status:(id,name)," + "office:(name)," +
"inventors:(id,name)," + "date," + "url)," + "languages:(" +
"id," + "language:(name)," + "proficiency:(level,name))," +
"skills:(" + "id," + "skill:(name))," + "certifications:(" +
"id," + "name," + "authority:(name)," + "number," +
"start-date," + "end-date)," + "courses:(" + "id," + "name," +
"number)," + "recommendations-received:(" + "id," +
"recommendation-type," + "recommendation-text," +
"recommender)," + "honors-awards," + "three-current-positions," +
"three-past-positions," + "volunteer")
data = application.get_profile(None, None, fields)
try:
with open(FILE_NAME, 'w') as outfile:
json.dump(data, outfile)
except IOError:
print 'Error: Cannot open or write to', FILE_NAME
return 0
return 1
def reinit_linkedin_repo(linkedin_email, linkedin_pass, api_key, api_secret):
browser = BrowserFactory.create()
auth_service = LinkedAuthorizationService(browser)
token = auth_service.refresh_token(api_key, api_secret, linkedin_email,
linkedin_pass)
browser.quit()
application = linkedin.LinkedInApplication(token=token)
return LinkedInRepository(application)
def get_api(connection, **kwargs):
auth = linkedin.LinkedInAuthentication(kwargs.get('consumer_key'),
kwargs.get('consumer_secret'), None,
linkedin.PERMISSIONS.enums.values())
auth.token = AccessToken(getattr(connection, 'access_token'),
getattr(connection, 'expires_in'))
api = linkedin.LinkedInApplication(auth)
return api
def linkedin_callback(request):
if request.method == "GET":
code = request.GET.get("code", None)
code = True
if code:
authentication = linkedin.LinkedInAuthentication(
API_KEY, API_SECRET, RETURN_URL,
linkedin.PERMISSIONS.enums.values())
#authentication.authorization_code =code
#token = authentication.get_access_token()
token = "AQUVIvgggNBTubY5GCb06liOZigFlQhRCMGvJvCa7WvenfwewKm-3zVrf0BR0c16hr0kUPcQBmE9_vbarWfyNlUy4fAhrjxeqAnkoKGM30wqV5yX0ZFm0F11jjbAN5YGVGA5qc60w5biQs2fJedZ6GLdXulm4nQN4lTUVUJ6fKzYkq-TcI0"
app = linkedin.LinkedInApplication(token=token)
alumnies = Alumni.objects.all()
if alumnies.count() > 0:
for alumni in alumnies.iterator():
first_name = alumni.first_name
last_name = alumni.last_name
params = {
"first-name": first_name,
"last-name": last_name,
"school-name": "University of Toronto"
}
profile = app.search_profile(selectors=[{
"people": [
"first-name", "email-address", "last-name",
"positions", "educations"
]
}],
params=params)
if profile['people']['_total'] == 0:
continue
if profile['people']['values'][0]['positions'][
'_total'] == 0:
if 'emailAddress' in profile['people']['values'][0]:
alumni.email = profile['people']['values'][0][
'emailAddress']
alumni.save()
continue
positions = profile['people']['values'][0]['positions'][
'values']
if len(positions) == 1:
alumni.position = positions[0]['title']
alumni.company = positions[0]['company']['name']
else:
for i in range(len(positions)):
if positions[i]['isCurrent'] == True:
alumni.position = positions[0]['title']
alumni.company = positions[0]['company'][
'name']
if 'emailAddress' in profile['people']['values'][0]:
alumni.email = profile['people']['values'][0][
'emailAddress']
alumni.save()
#alumni.company= profile['companies']
return redirect("/")
def get_from_linkedin_api(access_token_str):
application = linkedin.LinkedInApplication(token=access_token_str)
#Get own Profile
my_profile = application.get_profile(selectors=[
'id', 'first-name', 'last-name', 'location', 'industry',
'num-connections', 'summary'
])
print(my_profile)
def test(self):
"""
Main test method for testing the extractors.
"""
# Constants needed to test the extractor.
# NOTE: The test is using a fake LinkedIn profile we created.
# This means we know what names/skills should be returned and how many.
# API keys
CONSUMER_KEY = '77d39rnu0jgxhc'
CONSUMER_SECRET = 'SRjbrl5ajSwkbpMH'
USER_TOKEN = 'c87cfe99-0997-4393-bc8a-09bc60bbbaf4'
USER_SECRET = '1e37a040-934a-4047-8852-4fdc5c378b7c'
RETURN_URL = 'http://www.google.com'
# Skills we have entered for the profile.
NEEDEDSKILLS = [
"PHP", "Python", "Management", "Scrum", "People Skills",
"Synergies", "Love Of Learning", "Bearings", "Pipe", "COBOL",
"Brain Tumors", "Testing", "Debugging", "Entertainment",
"Enterprise Software"
]
# Authenticate and create an application.
authentication = linkedin.LinkedInDeveloperAuthentication(
CONSUMER_KEY, CONSUMER_SECRET, USER_TOKEN, USER_SECRET, RETURN_URL,
linkedin.PERMISSIONS.enums.values())
application = linkedin.LinkedInApplication(authentication)
# Extract the following fields from the profile.
fields = "first-name,last-name,skills"
data = application.get_profile(None, None, fields)
# Get the fields we need from the JSON.
firstname = data['firstName']
lastname = data['lastName']
skills = data['skills']
totalSkills = skills['_total']
skillList = skills['values']
# Check of the names are correct and that
# the correct number of skills was returned.
self.assertEqual(firstname, "test")
self.assertEqual(lastname, "profile")
self.assertEqual(totalSkills, 15)
# Loop through the skills and check that they are what we expect.
for skill in skillList:
skillstr = skill['skill']['name']
if not (skillstr in NEEDEDSKILLS):
self.fail("Unexpected skill:" + skillstr)
else:
NEEDEDSKILLS.remove(skillstr)
# Check that we did recieve all the expected skills.
self.assertEqual(len(NEEDEDSKILLS), 0)
def __init__(self, user, *args, **kwargs):
self.user = user
self.social_token = SocialToken.objects.filter(
app__provider='linkedin_oauth2',
account__provider='linkedin_oauth2',
account__user=user)
token = self.social_token.get()
self.linked_in = linkedin.LinkedInApplication(
token=linkedin.AccessToken(token.token, token.expires_at))
self.social_app = SocialApp.objects.filter(id=token.app.id)
def success(name):
API_KEY = '81mpzcy471ubsr'
API_SECRET = 'p1sGHyX2hM6EKdpb'
RETURN_URL = 'http://localhost:5000/success'
authentication = linkedin.LinkedInAuthentication(
API_KEY, API_SECRET, RETURN_URL, linkedin.PERMISSIONS.enums.values())
print authentication.authorization_url # open this url on your browser
application = linkedin.LinkedInApplication(authentication)
print application
return 'welcome %s' % name
def get_provider_user_id(response, **kwargs):
if response:
auth = linkedin.LinkedInAuthentication(None, None, None, None)
auth.token = AccessToken(response['access_token'],
response['expires_in'])
api = linkedin.LinkedInApplication(auth)
profile = api.get_profile(selectors=selectors)
return profile['id']
return None
def get_results(job_title, zip_code):
API_KEY = '75i3mk2maw6ogl'
SECRET_KEY = 'MDasUmDtjPbYa1I9'
USER_TOKEN = '8faba2a7-e3a6-4727-b06b-a291ebbf8032'
USER_SECRET = '99fde265-7fd3-4d53-8eb8-d0f6f979388c'
RETURN_URL = ''
authentication = linkedin.LinkedInDeveloperAuthentication(
API_KEY, SECRET_KEY, USER_TOKEN, USER_SECRET, RETURN_URL,
linkedin.PERMISSIONS.enums.values())
application = linkedin.LinkedInApplication(authentication)
selectors = [{
'people': [
'first-name', 'last-name', 'headline', 'picture-url',
'public-profile-url'
]
}]
params = {
'keywords': job_title,
'postal-code': zip_code,
'country-code': 'us'
}
linked = application.search_profile(selectors=selectors, params=params)
links = linked['people']['values']
results = []
#application = linkedin.LinkedInApplication(authentication)
#results = application.search_profile(selectors=[{'people': ['first-name', 'last-name', 'headline']}], params={'keywords': job_title})
#res = application.search_profile(selectors=[{'people': ['first-name', 'last-name']}], params={'keywords': 'Analyst'})
#print linkedin.LinkedInApplication.search_profile.url
#results = application.search_job(selectors=[{'jobs': ['id', 'customer-job-code', 'posting-date']}], params={'title': 'python', 'count': 2})
for link in links:
try:
results.append({
'title':
link['firstName'] + " " + link['lastName'],
'desc':
link['headline'],
'image':
link['pictureUrl'],
'url':
link['publicProfileUrl'],
'content_type':
'Meeting',
'id':
''
})
except:
a = 1
return results
def get_user_auth():
RETURN_URL = ''
auth = linkedin.LinkedInDeveloperAuthentication(
CONSUMER_KEY,
CONSUMER_SECRET,
USER_TOKEN,
USER_SECRET,
RETURN_URL,
permissions=linkedin.PERMISSIONS.enums.values())
print "(+) Authenticating to LinkedIN "
app = linkedin.LinkedInApplication(auth)
return app
def auth():
authentication = linkedin.LinkedInAuthentication(APPLICATON_KEY,
APPLICATON_SECRET,
RETURN_URL,
['r_basicprofile'])
auth_code = request.args.get('code', default=None, type=str)
authentication.authorization_code = auth_code
token = authentication.get_access_token().access_token
li_application = linkedin.LinkedInApplication(token=token)
print(li_application.get_profile())
return redirect('/user')
def linkedin_view(request):
application = linkedin.LinkedInApplication(token=settings.LINKEDIN_TOKEN)
profile_data = application.get_profile(selectors=['id', 'first-name', 'last-name', 'headline', 'location',
'num-connections', 'skills', 'educations', 'picture-url',
'site-standard-profile-request', 'summary', 'positions',
'industry'])
context = {'profile': profile_data}
return HttpResponse(content=json.dumps(context),
status=200,
content_type='application/json')
def __init__(self, user):
try:
if not user.is_social_network_enabled(network="linkedin"):
raise ValueError("User has not enabled Twitter")
else:
self.api = linkedin.LinkedInApplication(
token=user.linkedin_access_token)
self.baseurl = "https://www.feedcrunch.io/@" + user.username + "/redirect/"
except:
self.api = False
def __init__(self, config, testing):
'''
Initialize
:param config:
:param testing:
'''
self._config = config
if not testing:
self._linkedin = linkedin.LinkedInApplication(
token=config['authentication_token'])
self._visibility = config['visibility']
self.set_common_opts(config)
def token_renew_link(self):
ret = ''
if self.source == 'linkedin':
authentication = linkedin.LinkedInAuthentication(
LINKEDIN_API_KEY, LINKEDIN_API_SECRET, LINKEDIN_RETURN_URL,
LINKEDIN_PERMISSIONS)
# Optionally one can send custom "state" value that will be returned from OAuth server
# It can be used to track your user state or something else (it's up to you)
# Be aware that this value is sent to OAuth server AS IS - make sure to encode or hash it
# authorization.state = 'your_encoded_message'
ret = authentication.authorization_url # open this url on your browser
linkedin.LinkedInApplication(authentication)
return ret
