def user_get_token(): # # GET AN AUTH CODE # CLIENT_ID = os.environ.get("LINKEDIN_CLIENT_ID", "OOPS") CLIENT_SECRET = os.environ.get("LINKEDIN_CLIENT_SECRET", "OOPS") REDIRECT_URL = os.environ.get("LINKEDIN_REDIRECT_URL", "http://localhost:8000") #print(CLIENT_ID, CLIENT_SECRET, REDIRECT_URL) auth = linkedin.LinkedInAuthentication(CLIENT_ID, CLIENT_SECRET, REDIRECT_URL, PERMISSIONS) #print(type(auth)) #> <class 'linkedin_v2.linkedin.LinkedInAuthentication'> #print(auth.authorization_url) webbrowser.open_new(auth.authorization_url) # login, grant permissions, then you'll be redirected to a localhost url. # ... observe the "code" parameter, and enter it below # ... making sure to remove the "state" parameter part of the url, which might come at the end auth_code = input("The auth code was:") auth.authorization_code = auth_code # # GET AN ACCESS TOKEN # access_token = auth.get_access_token() # this is an AccessToken object with a access_token property, which should be stored in the env var return access_token
def linkedAuthenticateAs(permissions): auth = linkedin.LinkedInAuthentication( keys.LINKEDIN_CLIENT_ID, keys.LINKEDIN_CLIENT_SECRET, keys.LINKEDIN_CALLBACK, permissions=["w_member_social", "r_liteprofile"]) auth.state = f"{hex(random.getrandbits(128))}" session["linkedin-hash"] = auth.state return redirect(auth.authorization_url)
def convert_v2(source, crossrefQuery='', token=''): global application if token == '': authentication = linkedin.LinkedInAuthentication( API_KEY, API_SECRET, RETURN_URL, PERMISSIONS.enums.values()) authorization_url = authentication.authorization_url authorization_url = authorization_url.replace( '%20r_fullprofile', '').replace('%20rw_groups', '').replace( '%20w_messages', '').replace('%20r_contactinfo', '').replace('%20r_network', '').replace('%20rw_nus', '%20w_share') #print authorization_url cmd = 'open "' + authorization_url + '"' print cmd msg = subprocess.check_output(cmd, shell=True) else: authentication = linkedin.LinkedInAuthentication( API_KEY, API_SECRET, RETURN_URL, PERMISSIONS.enums.values()) authentication.authorization_code = token access_token = authentication.get_access_token() print access_token[0] application = linkedin.LinkedInApplication( authentication=authentication, token=access_token[0]) if application != None: print application.get_profile() #print application.get_profile(member_id='%5B%2213609%22%5D') return ''
def save_linkedin_token(request): authentication = linkedin.LinkedInAuthentication(LINKEDIN_API_KEY, LINKEDIN_API_SECRET, LINKEDIN_RETURN_URL, LINKEDIN_PERMISSIONS) authentication.authorization_code = request.GET['code'] token = authentication.get_access_token() Channel.objects.filter(source='linkedin').update( user_secret=authentication.authorization_code, user_token=token.access_token) messages.success(request, _('LinkedIn Channel Token updated successfully')) return redirect('admin:socialfeedsparser_channel_changelist')
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
def get_auth_url(): API_KEY_1 = '771xglr54lroll' API_KEY_2 = '779u3cu8a069wz' API_SECRET_1 = '4najxXcpYZmwVIJT' API_SECRET_2 = 'bcDwGS7N3GxcuiYD' RETURN_URL_1 = 'http://kinglife.best/api.php' RETURN_URL_2 = 'http://localhost:8000/code' authentication = lin.LinkedInAuthentication( API_KEY_2, API_SECRET_2, RETURN_URL_2, permissions=["r_liteprofile", 'r_emailaddress', 'w_member_social']) return authentication.authorization_url
def authenticate(): creds = getCreds() API_KEY = creds["client_id"] API_SECRET = creds["client_secret"] RETURN_URL = 'http://localhost:8000' authentication = linkedin.LinkedInAuthentication(API_KEY, API_SECRET, RETURN_URL,["r_liteprofile"]) print(authentication.authorization_url) # open this url on your browser authentication.authorization_code = "AQTiVEHx5potAMyle43UKPKU8ObWt2z2tUI75E72b1RMgRwvs2ZJ97kC97hEKyX56Eostp7FxhRzbcXhugSfkUK28czXIuunoyIj6mo_hT-aYbWeUocBcCkeVQmEhznbIpgENQl3yj6h2FuIFPcXFqo737bZVEyyiZfgkYPV1IExCgRBo0xHzrtmzljw_A" token = authentication.get_access_token() token_str = "AQVIe5jsla4VrGMRDNCuEcWkZYZxD5e93TSEwZZXNpKANy74NgGctVaLKUG3UcGrAI1tM_aUBxga91jx301sXCA7ahR3yOgLBB_LvZf9NaEAXAEQfi_0CUVoNf8JUPcyr9jcNZXvFYQZ8Hv-lp0JPlUTwOHcaVFple8g58LUHA5hQpAlQHar97yIk6zLU6D6fr8-czngg0fuOJ2cYBehqJ-DrTJKvE3Q3FmJbTmdlujhYVm-9X0WLFdRL2gAchJhhxubRo-ilNDAvYRPUHfDa2st2eJ_5w5woiS4qjJcTwBlyOewLFoXpaAxLrKbEdO83m_vz9NiaayC3EdxzNflq4HomaKyZg" application = linkedin.LinkedInApplication(token=authentication.authorization_code) application. application.get_profile()
def LinkedAuthURL(request, id): from django.conf import settings from linkedin_v2 import linkedin try: return_url = 'http://localhost:8000/api/linkedin/callback/' authentication = linkedin.LinkedInAuthentication(settings.LINKEDIN_API_KEY, settings.LINKEDIN_API_SECRET, return_url, [linkedin.PERMISSIONS.BASIC_PROFILE]) authentication.state = authentication._make_new_state() url = authentication.authorization_url candidate = Candidate.objects.get(id=id) candidate.temporal_state = authentication.state candidate.save() return HttpResponseRedirect(url) except: return HttpResponse("Problems with LinkedinAPI", status=400)
def loginToLinkedInCallback(): code = request.args.get("code") csrf_state = request.args.get("state") error = request.args.get("error") if session["linkedin-hash"] != csrf_state: raise InvalidUsage("401 Unauthorized") if error is not None: raise InvalidUsage("Error occured") auth = linkedin.LinkedInAuthentication( keys.LINKEDIN_CLIENT_ID, keys.LINKEDIN_CLIENT_SECRET, keys.LINKEDIN_CALLBACK, permissions=["w_member_social", "r_liteprofile"]) print(keys.LINKEDIN_CALLBACK) auth.state = csrf_state auth.authorization_code = code session["linkedin-access-token"] = auth.get_access_token() return redirect("/")
def LinkedCallback(request): from django.conf import settings from linkedin_v2 import linkedin try: authentication = linkedin.LinkedInAuthentication(settings.LINKEDIN_API_KEY, settings.LINKEDIN_API_SECRET, 'http://localhost:8000/api/linkedin/callback/', [linkedin.PERMISSIONS.BASIC_PROFILE]) authentication.authorization_code = request.GET.get('code', '') accessToken = authentication.get_access_token() candidate = Candidate.objects.get(temporal_state=request.GET.get('state', 'dsdsds')) LinkedInProfile.objects.filter(candidate=candidate).delete() LinkedInProfile.objects.create(candidate=candidate, access_token=accessToken.access_token, expires_in=accessToken.expires_in) return HttpResponse('Todo fino', status=200) except Exception as error: return HttpResponse("Problems with LinkedinAPI" + repr(error), status=500)
def __init__(self): self.RETURN_URL = 'http://localhost:8000' self.ID = '78089tqwivmp7p' self.secret = '2BFAmePySISPl6qz' url = requests.Request( 'GET', 'https://www.linkedin.com/oauth/v2/authorization', params={ 'response_type': 'code', 'client_id': self.ID, 'redirect_uri': self.RETURN_URL, 'state': secrets.token_hex(8).upper(), 'scope': '%20'.join( ['r_liteprofile', 'r_emailaddress', 'w_member_social']), }, ).prepare().url self.auth = linkedin.LinkedInAuthentication( self.ID, self.secret, self.RETURN_URL, linkedin.PERMISSIONS.enums.values()) self.app = linkedin.LinkedInApplication(self.auth) print(url) resp = requests.get(url).content if url.find('code=') != -1: code_str = url[url.find('code=') + 5:url.find('&state=')] self.auth.authorization_code = code_str self.token = self.auth.get_access_token() self.app = linkedin.LinkedInApplication( token=self.token.access_token) print( self.app.search_profile(params={'keywords': 'Damian Rusinek'}))
import random from datetime import datetime from io import BytesIO import yaml import PyPDF2 from django.core.mail import send_mail from linkedin_v2 import linkedin from linkedin_v2.linkedin import LinkedInApplication from OpenAlumni import settings from OpenAlumni.settings import LINKEDIN_API_KEY, LINKEDIN_RETURN_URL, LINKEDIN_API_SECRET, DOMAIN_APPLI, DOMAIN_SERVER, \ APPNAME, EMAIL_HOST_USER, STATIC_ROOT, EMAIL_TESTER,MYDICT authentication = linkedin.LinkedInAuthentication(LINKEDIN_API_KEY, LINKEDIN_API_SECRET, LINKEDIN_RETURN_URL, permissions="r_basicprofil") print(authentication.authorization_url) LinkedInApplication(authentication) def to_xml(df, row_separator="row"): def row_to_xml(row): xml = ['<' + row_separator + '>'] for i, col_name in enumerate(row.index): val = html.escape(str(row.iloc[i])) if len(col_name) > 0: xml.append('<field name="{0}">{1}</field>'.format( col_name, val)) else:
def linkedInContentPostVideo(): if "linkedin-access-token" not in session or session[ "linkedin-access-token"] is None: return redirect("/loginToLinkedInAsUser") auth = linkedin.LinkedInAuthentication( keys.LINKEDIN_CLIENT_ID, keys.LINKEDIN_CLIENT_SECRET, keys.LINKEDIN_CALLBACK, permissions=["w_member_social", "r_liteprofile"]) print(keys.LINKEDIN_CALLBACK) auth.token = linkedin.AccessToken(session["linkedin-access-token"][0], session["linkedin-access-token"][1]) app = linkedin.LinkedInApplication(auth) # Get User ID response = app.make_request("GET", "https://api.linkedin.com/v2/me", params={"fields": "id"}) user_id = response.json()['id'] owner_urn = f"urn:li:person:{user_id}" upload_response_context = [] for file in request.files.getlist("file"): if linkedin_utils.linkedInMediaFilterLogic( file, keys.LINKEDIN_ALLOWED_VIDEO_EXTENSION): response, asset_urn = linkedin_utils.uploadVideoToLinkedIn( app, owner=owner_urn, data=file.read()) # Check if error occured in response response.raise_for_status() upload_response_context.append((response, asset_urn)) # Make sure video content is uploaded and ready to serve # remaining_request = upload_response_context.copy() # remaining_request_next = [] # while (len(remaining_request) > 0) : # for response, asset_urn in remaining_request: # status_response = app.make_request("GET", f"https://api.linkedin.com/v2/assets/{asset_urn}") # status_response.raise_for_status() # status_response = status_response.json() # upload_status = status_response["recipes"]["status"] # if upload_status == "AVAILABLE": # continue # elif upload_status == "PROCESSING" or upload_status == "NEW" or upload_status == "MUTATING" or upload_status == "WAITING_UPLOAD" or : # remaining_request_next.append((response, asset_urn)) # else: # raise InvalidUsage("Upload Error Occured") # remaining_request = remaining_request_next.copy() # remaining_request_next = [] # time.sleep(5) text = "VIDEO UPLOAD WORK2222!" context = { "author": owner_urn, "lifecycleState": "PUBLISHED", "specificContent": { "com.linkedin.ugc.ShareContent": { "media": [{ "media": assert_urn, "status": "READY", "title": { "attributes": [], "text": "Sample Video Create" } } for upload_response, assert_urn in upload_response_context], "shareCommentary": { "attributes": [], "text": text }, "shareMediaCategory": "VIDEO" } }, "visibility": { "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC" } } response = app.make_request("POST", "https://api.linkedin.com/v2/ugcPosts", data=json.dumps(context)) print(f"{response} {response.headers} {response.json()}") return "Post-Content-2"
def linkedInContentPost(): if session["linkedin-access-token"] is None: return redirect("loginToLinkedInAsUser") # Set up linkedin applicatiom auth = linkedin.LinkedInAuthentication( keys.LINKEDIN_CLIENT_ID, keys.LINKEDIN_CLIENT_SECRET, keys.LINKEDIN_CALLBACK, permissions=["w_member_social", "r_liteprofile"]) print(keys.LINKEDIN_CALLBACK) auth.token = linkedin.AccessToken(session["linkedin-access-token"][0], session["linkedin-access-token"][1]) app = linkedin.LinkedInApplication(auth) # Get User ID response = app.make_request("GET", "https://api.linkedin.com/v2/me", params={"fields": "id"}) user_id = response.json()['id'] owner_urn = f"urn:li:person:{user_id}" def filter_logic(file): filename = secure_filename(file.filename) if filename == "": return False _, extension = os.path.splitext(filename) if extension not in keys.LINKEDIN_ALLOWED_EXTENSION: return False return True upload_response_context = [] for file in request.files.getlist("file"): if linkedin_utils.linkedInMediaFilterLogic( file, keys.LINKEDIN_ALLOWED_IMAGE_EXTENSION): data = file.read() upload_response_context.append( linkedin_utils.uploadImageToLinkedIn( app, owner_urn=owner_urn, data=data, access_token=auth.token.access_token)) text = request.form["message"] context = { "owner": owner_urn, "text": { "text": text }, "content": { "contentEntities": [ # Iterate through the media contents here { "entity": f"{asset_urn}" } for (upload_response, asset_urn) in upload_response_context ], # Add media category here for it to work! "shareMediaCategory": "IMAGE" }, } response = app.make_request("POST", "https://api.linkedin.com/v2/shares", data=json.dumps(context)) return str(200)
from linkedin_v2 import linkedin as lin # from hackzurich.settings import LINKEDIN_ID, LINKEDIN_SECRET LINKEDIN_ID = '779u3cu8a069wz' LINKEDIN_SECRET = 'bcDwGS7N3GxcuiYD' authentication = lin.LinkedInAuthentication(LINKEDIN_ID, LINKEDIN_SECRET, 'http://localhost:8080/code') print(authentication.authorization_url) application = lin.LinkedInApplication(authentication) # print(authentication.get_access_token())
# Print the results with gender, age, and bounding box #print("Faces in the remote image: ") #if (len(detect_faces_results_remote.faces) == 0): # print("No faces detected.") #else: # for face in detect_faces_results_remote.faces: # print("'{}' of age {} at location {}, {}, {}, {}".format(face.gender, face.age, \ # face.face_rectangle.left, face.face_rectangle.top, \ # face.face_rectangle.left + face.face_rectangle.width, \ # face.face_rectangle.top + face.face_rectangle.height)) API_KEY = '86mf11anljqsfe' API_SECRET = 'g0rxpjazY6gsH41v' RETURN_URL = 'https://api-university.com' authentication = linkedin.LinkedInAuthentication(API_KEY, API_SECRET, RETURN_URL, linkedin.PERMISSIONS.enums.values()) # 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' print (authentication.authorization_url) # open this url on your browser application = linkedin.LinkedInApplication(authentication) #bikram's authentication code authentication.authentication_code = 'AQRiRMpG1XfjaRF4bqC9oncAVknCanLCuov-5gZgfuiNRUUbqlbI3lgP8Se34gWRMRxxiurBD6_HQ-MWdJknW2K0Vv081jwllVpAmEGzVieh-QFFbNqTgwkWxJbzulBsgCboR-54lsJnDo5YZB0zZVn2gGsQeyT1Lh9V01_pqnvERFzCX0QvDVTCisjeVg' #hitesh's authentication code #authentication.authentication_code = 'AQQdLTIKgEtdQoQvUBd7n90e5zhLisrLitXfrFOR11dZKEk3RiUj2ctNHgRtWczM3RwMVQLfTMjY7Jk9ROiYA2usl-oTTT3or4c8qKiEinnx2_AYJwgp3mrB-5482N2sPGm5dcUB0GUHCtmdANaPDfk2KDwzH3gcJNBpSE4FlrBlrgwbWtk1E24E5QtoKQ' #bikram's access token application = linkedin.LinkedInApplication(token='AQWXUgHMAwl_htHJ_NareR8thl_Z-_1cAOMg65dS9dkpikMnVxgZjiipk8Uuv2w3f0O_5awiGzA_xiq64nSQBwcmPygphqtC4-rTpVJmmnyMKTTTW1micVfnVQ4A6uT0gGrNlbR4DLYDmEgQIbMOVbjjm9tsYjBEMFj3snVTIll6FuAs-s0IW-CITfhsm2-_1VYo0hiBTz2FyZphPcAR2H7kDqeHifvrrfZ-BSpwvZXHCRUMDjx-59v9wEleM7VkOQorBpwpFoUs3WLbEeatKQbQ8kjA80W2vX1nnKzo1uy6Hi6-COoI47v0IbOCCKHT2Iu-bl6BltI0M5N-64EPcjEuj4ndQg') #print(application) data = application.get_profile() #print(data)