示例#1
0
def getUserInbox(user):
	access_token = user.access_token
	facebook = OpenFacebook(access_token)
	inbox = facebook.get('/me/inbox')
	inbox2 = facebook.get(inbox['paging']['next'].split("v2.0")[1])
	
	return breadthlooper(inbox,user, facebook)
示例#2
0
def recursive_graph_call(graph_id, *args, **kwargs):

    '''
        response = recursive_graph_call('147863265269488_588392457883231/likes', limit=500)
    '''
    graph = OpenFacebook(settings.FACEBOOK_API_ACCESS_TOKEN)

    if 'limit' not in kwargs:
        kwargs['limit'] = 100

    response = {}

    while True:
        r = graph.get(graph_id, *args, **kwargs)

        if not response: # first call
            response = r
        else:
            response['data'] += r['data']

        if 'paging' in r:
            kwargs['after'] = r['paging']['cursors']['after']
        else:
            break

    return response
    def is_authenticated(self, request, **kwargs):
		print "Authentication starting..."
        # Make sure user supplied access token in request
		try:
			if request.method == 'GET':
				access_token = request.GET['access_token']
			elif request.method == 'POST':
				access_token = request.POST['access_token']
		except KeyError:
			return self._unauthorized()

        # Authenticate with facebook
		from open_facebook import OpenFacebook
		from django_facebook.connect import connect_user
		
		print "Authentication token found. Verifying..."
		facebook = OpenFacebook(access_token)
		
		print "Connection to Facebook server in progress..."
		try:
			if not facebook or not facebook.is_authenticated():
				return self._unauthorized()
		except:
			return self._unauthorized()
		
		print "Connection established. Authentication successful."
        # Facebook authenticated, now associate
        # with own internal user, Creating a new user if 
        # necessary.
        #action, user = connect_user(request, access_token, facebook)
		user = facebook.get('me')
		return user
示例#4
0
def recursive_graph_call(graph_id, *args, **kwargs):
    '''
        response = recursive_graph_call('147863265269488_588392457883231/likes', limit=500)
    '''
    graph = OpenFacebook(settings.FACEBOOK_API_ACCESS_TOKEN)

    if 'limit' not in kwargs:
        kwargs['limit'] = 100

    response = {}

    while True:
        r = graph.get(graph_id, *args, **kwargs)

        if not response:  # first call
            response = r
        else:
            response['data'] += r['data']

        if 'paging' in r:
            kwargs['after'] = r['paging']['cursors']['after']
        else:
            break

    return response
    def handle(self, app_id, app_secret, facebook_page_id, user_token, *args, **options):

        # To generate a user_token use https://developers.facebook.com/tools/explorer/
        #   Select your application and Get Access Token
        #   manage_pages in Extended Permissions must be enabled for this token

        # facebook_page_id can also be obtained from https://developers.facebook.com/tools/explorer/
        # Query for 'me/accounts' and look for the id of your facebook page
        # Another way to find the id is using http://findmyfacebookid.com/
        # There you will only have to enter the url of your page to get the page id

        h = httplib2.Http("")
        resp, content = h.request("https://graph.facebook.com/oauth/access_token?client_id"
                                  "="+app_id+"&client_secret="+app_secret+"&grant_type=fb_excha"
                                  "nge_token&fb_exchange_token="+user_token, "POST")
        
        user_token_extended = content[13:]

        graph = OpenFacebook(user_token_extended)

        accounts = graph.get('me/accounts')

        page = filter(lambda page: page['id'] == facebook_page_id, accounts["data"])[0]

        not_expiring_token = page["access_token"]

        print not_expiring_token
    def is_authenticated(self, request, **kwargs):
        print "Authentication starting..."
        # Make sure user supplied access token in request
        try:
            if request.method == 'GET':
                access_token = request.GET['access_token']
            elif request.method == 'POST':
                access_token = request.POST['access_token']
        except KeyError:
            return self._unauthorized()

    # Authenticate with facebook
        from open_facebook import OpenFacebook
        from django_facebook.connect import connect_user

        print "Authentication token found. Verifying..."
        facebook = OpenFacebook(access_token)

        print "Connection to Facebook server in progress..."
        try:
            if not facebook or not facebook.is_authenticated():
                return self._unauthorized()
        except:
            return self._unauthorized()

        print "Connection established. Authentication successful."
        # Facebook authenticated, now associate
        # with own internal user, Creating a new user if
        # necessary.
        #action, user = connect_user(request, access_token, facebook)
        user = facebook.get('me')
        return user
示例#7
0
文件: models.py 项目: ibaguio/pinder
    def get_user_from_id(cls, fb_id, token):
        print "received post", fb_id, token
        fb = OpenFacebook(token)

        data = fb.get("me")
        print data

        cls.create(data, token)
示例#8
0
 def get_context_data(self, **kwargs):
     fb_user = FacebookCustomUserActive.objects.get(id=self.request.user.id)
     if fb_user.facebook_id and fb_user.access_token:
         facebook = OpenFacebook(fb_user.access_token)
         data = facebook.get('me/photos/uploaded', fields='picture')['data']
     else:
         data = {}
     kwargs['facebook_photos'] = data
     return super(CreateFacebookPhoto, self).get_context_data(**kwargs)
示例#9
0
def post_new(request):
    if request.method == "POST":
        form = PostForm(request.POST)
        if form.is_valid():
            post = form.save(commit=False)
            user = SocialAccount.objects.get(user=request.user)
            access_token = SocialToken.objects.get(account_id=user, account__provider='facebook')
            idUser = user.uid
            graph = OpenFacebook(access_token=access_token)

            if graph.is_authenticated():

                idPages = (graph.get('me/accounts/'))
                id_Pages_List = [id['id'] for id in idPages['data']]
                id_Pages_List = ", ".join(id_Pages_List)


                id_Page_Access_Token = (graph.get(id_Pages_List, fields='access_token'))
                id_Page_Access_Token = (id_Page_Access_Token['access_token'])


                graph = OpenFacebook(access_token=id_Page_Access_Token)

                feed_url = 'https://graph.facebook.com/'+id_Pages_List+'/feed?message='+post.text+'&access_token='+id_Page_Access_Token
                feed_Request = requests.post(feed_url)

                print(feed_Request.status_code)

                if(feed_Request.status_code == 200):
                    return render(request, 'blog/home.html', {'user': request.user,'access_token': id_Page_Access_Token,'page_id': id_Pages_List })
                else:
                    return HttpResponse(feed_Request)
                    print('bad')
                return render(request, 'blog/loginFacebook.html', {'access_token': access_token, 'idUser': idUser})
            else:
               print('bad')
            return render(request, 'blog/loginFacebook.html')


    else:
        form = PostForm()
    return render(request, 'blog/add_new_post.html', {'form': form})
示例#10
0
    def set_page_token(self):
        token = FacebookAdminToken.objects.last()
        auth_token = token.access_token

        graph = OpenFacebook(auth_token)
        result = graph.get('me/accounts')
        for row in result['data']:
            if row['id'] == settings.PAGE_ID:
                self.page_token = row['access_token']
                print('Page Token: ', self.page_token, ' ***')
                break
示例#11
0
文件: models.py 项目: ibaguio/pinder
    def populate_likes(self):
        assert self.token

        try:
            fb = OpenFacebook(self.token)
            likes = fb.get("me/likes")['data']

            for like in likes:
                Interest.get_or_create(like, self)
        except Exception, e:
            logging.exception(e)
示例#12
0
def get_all_of_users_facebook_friends_on_yapster(user, facebook_access_token):
    facebook = OpenFacebook(facebook_access_token)
    if user.settings.facebook_connection_flag == True:
        facebook_friends = facebook.get('me/friends', fields="id")['data']
        this_users_facebook_friends_on_yapster = [
            friend_facebook_id['id'] for friend_facebook_id in facebook_friends
            if Settings.objects.filter(
                is_active=True,
                facebook_account_id=friend_facebook_id['id']).exists() == True
        ]
        return this_users_facebook_friends_on_yapster
示例#13
0
def main():
    social_datas = Social_Data.objects.filter(active=True)
    for social_data in social_datas:
        if social_data.account_type == '0':  #facebook
            graph = OpenFacebook(social_data.account_token)
            profile = graph.get('me')
            profile_id = profile['id']
            friends = graph.get('me/friends')
            total_follower = int(friends['summary']['total_count'])
            social_data.total_follower = total_follower
            social_data.save()
        elif social_data.account_type == '1':  #twitter
            api = twitter.Api(
                consumer_key='zsqVde4f4vkRNopoj8zGvVM7x',
                consumer_secret=
                '3pcD1MNmQNyHAZrDjmNQmHdnUNfZywbA4Lbomh3ofxqzO3e6o8',
                access_token_key=social_data.account_id,
                access_token_secret=social_data.account_token)
            social_data.total_follower = api.VerifyCredentials(
            ).followers_count
            social_data.save()
示例#14
0
def create_default_photo(sender, instance, created, **kwargs):
    if created:
        logger.info('create_default_photo triggered by {} {}'.format(
            sender, instance
        ))
        facebook = OpenFacebook(instance.user.access_token)
        data = facebook.get('me', fields='picture.hight(1000).width(1000)')
        image_url = data.get('picture', {}).get('data', {}).get('url', {})
        FacebookPhoto.objects.get_or_create(
            photo=image_url,
            order=0,
            user=instance.user
        )
示例#15
0
def get_playlists(client, username, request):

    if len(username) > 1:
        username = username
    else:
        print "Whoops, need your username!"
        print "usage: python user_playlists.py [username]"
        sys.exit()

    token = util.prompt_for_user_token(username)

    if token:
        
        sp = spotipy.Spotify(auth=token)
        
        playlists = sp.user_playlists(username)
        print playlists
        #playlist = sp.user_playlist(username, playlist_id=playlist, fields=None)
        #print playlist
        #print playlist['tracks']['total']
        limit = 100
        #playlist = sp.user_playlist_tracks(username, playlist_id=playlist, fields=None, limit=limit, offset=100)
        #print playlist
        #print playlist['next']
        i=1
        print "Access Token:"
        me = request.user
        print me
        #graph = get_persistent_graph(user2)
        graph = me.get_offline_graph()
        print graph
        access_token = me.access_token
        print access_token
        facebook = OpenFacebook(access_token)
        me = facebook.get('me', fields ='third_party_id')
        print me
        print 'got it!'
        '''
        for track in playlist['items']:
            print str(i) + ' ' + track['track']['name'] + ' ' + track['track']['uri']
            if i == limit:
                print playlist['next']
                
                
                
                return
            i += 1
        '''

    else:
        print "Can't get token for", username
示例#16
0
def get_admin_access_token_complete(request):
    code = request.GET['code']

    graph = OpenFacebook()
    params = {
        'code': code,
        'client_id': settings.SOCIAL_AUTH_FACEBOOK_APP_KEY,
        'client_secret': settings.SOCIAL_AUTH_FACEBOOK_SECRET,
        'redirect_uri': request.build_absolute_uri(reverse('get_admin_access_token_complete'))
    }
    resp = graph.get('oauth/access_token', **params)

    FacebookAdminToken(access_token=resp['access_token']).save()
    return HttpResponseRedirect('/admin/')
示例#17
0
def get_posts_impressions(request):
    """Get the number of impressions for a post id.

    Receives the post id as a GET parameter and uses Facebook api to get lifetime impressions. Returns JSON for total
    lifetime impressions for a post id.
    """
    post_id = request.GET['post_id']
    # call facebook api using OpenFacebook api
    facebook = OpenFacebook(request.user.access_token)
    impressions = facebook.get('%s/insights/post_impressions_unique' %
                               (post_id))

    try:  # try getting the impressions from json and return N/A if not found
        num_impression = impressions['data'][0]['values'][0]['value']
    except:
        num_impression = 'N/A'

    return JsonResponse({"impressions": num_impression})
示例#18
0
def renew_facebook_admin_token():
    current_token = FacebookAdminToken.objects.last()

    if current_token.obtained > (timezone.now() - timezone.timedelta(days=14)):
        return

    # obtained two weeks ago, time to renew

    params = {
        'grant_type': 'fb_exchange_token',
        'client_id': settings.SOCIAL_AUTH_FACEBOOK_APP_KEY,
        'client_secret': settings.SOCIAL_AUTH_FACEBOOK_SECRET,
        'fb_exchange_token': current_token.access_token
    }

    graph = OpenFacebook()
    resp = graph.get('oauth/access_token', **params)

    FacebookAdminToken(resp['access_token']).save()
示例#19
0
def _PostToFB(message):
    token = getattr(settings, 'FACEBOOK_AUTHENTICATION_TOKEN', "")
    page = str(getattr(settings, 'FACEBOOK_PAGE_ID', 123))

    user_account = OpenFacebook(token)
    accounts = user_account.get('me/accounts')
    for x in accounts['data']:
        if x['id'] == page:
            page = x
            break
    else:
        # page not found
        print "Page not found with corresponding ID"
        return

    page_graph = OpenFacebook(page['access_token'])
    result = page_graph.set('me/feed', message=message)

    print "FB post result:", result
示例#20
0
def _PostToFB(message):
    token = getattr(settings, 'FACEBOOK_AUTHENTICATION_TOKEN', "")
    page  = str(getattr(settings, 'FACEBOOK_PAGE_ID', 123))

    user_account = OpenFacebook(token)
    accounts = user_account.get('me/accounts')
    for x in accounts['data']:
        if x['id'] == page:
            page = x
            break
    else:
        # page not found
        print "Page not found with corresponding ID"
        return

    page_graph = OpenFacebook(page['access_token'])
    result = page_graph.set('me/feed', message=message)

    print "FB post result:", result
示例#21
0
文件: views.py 项目: ewianda/cpcbali
def get_facebook_access_token(request):
    me = []
    if request.method == 'GET':
        code = request.GET.get('code',None)
        redirect_uri = "http://localhost:8000%s"  % reverse('facebook-access')      
        
        response=FacebookAuthorization.convert_code(code,redirect_uri =redirect_uri)
        
        access_token=response.get('access_token',None)
        expire  = response.get('expires',None)
        expiration = datetime.datetime.now() + datetime.timedelta(seconds=int(expire))
        try:
            stored_token = FaceBookAcessToken.objects.all()[0]
            stored_token.access_token=access_token
            stored_token.expiration=expiration
        except:
             stored_token = FaceBookAcessToken(access_token=access_token,expiration=expiration)
        stored_token.save()    
        facebook=OpenFacebook(access_token)
        me =facebook.get('me')
    return render(request,"facebook_access/facebook_access.html", {"me":me,})
示例#22
0
def page_listing(request):
    """Fetches the pages managed by a user and shows it on listing.html page.

    Uses Facebook API to get the pages for  a uset.
    """
    facebook = OpenFacebook(request.user.access_token)
    details = facebook.get('me/accounts')
    details_dict = details

    page_info_list = []  # list containing details of all the pages
    for entry in details_dict.get('data'):
        temp_dict = {
            'name': entry['name'],
            'id': entry['id'],
            'category': entry['category']
        }
        page_info_list.append(temp_dict)

    # render to template
    return render_to_response('listing.html', locals(),
                              RequestContext(request))
示例#23
0
def userListens(access_token, client_username):
  # Form has username info to get access_token from Spotify
  username = client_username
  token = util.prompt_for_user_token(username)

  sp = spotipy.Spotify(auth=token)
  graph = OpenFacebook(access_token)
  if access_token is not None:
    listen_data = graph.get('me/music.listens')
    user_listens = []
    listens = listen_data['data']
    for listen in listens:
      tmp = []
      song_name = listen['data']['song']['title']
      client_url = listen['data']['song']['url']
      client_unique = re.search('track\/(.*)', client_url).group(1)
      print client_unique
      
      # Get tuneboss track if it exists, othewise create it.
      try:
        tb_track = Track.objects.get(client_unique=client_unique)
      except Track.DoesNotExist:
        sp_track = sp.track(client_unique)
        client = Client.objects.get(client_name='Spotify')
        tb_track = create_track(sp_track, client, username)



      artist_name = tb_track.artist_name
      
      tmp.append(client_unique)
      tmp.append(song_name)
      tmp.append(artist_name)
      if listen['data'].get('playlist'):
        playlist = listen['data']['playlist']['title']
        tmp.append(playlist)
      user_listens.append(tmp)

      print(json.dumps(song_name, sort_keys=True, indent=4, separators=(',', ': ')))
  return user_listens
示例#24
0
def save_post(request):
    """Saves the post(both published and unpublished) for a specific page.

    Receives page id, message and a publish-unpublish flag as parameters. Then finds out the page access token for the
    page and uses it to post as the page.
    """
    if request.POST.get('publish-check'):
        published = True
    else:
        published = False
    message = request.POST['post-message']
    page_id = request.POST['page_id_post']

    user_facebook = OpenFacebook(request.user.access_token)
    response = user_facebook.get('me/accounts')
    # get page access token
    for entry in response['data']:
        if entry['id'] == page_id:
            page_access_token = entry['access_token']
            break
    facebook = OpenFacebook(page_access_token)
    facebook.set('%s/feed' % (page_id), message=message, published=published)

    return redirect('page-posts', page_id)
示例#25
0
文件: views.py 项目: pratz/fphoto
def dash(request):
    """ Show user pics in dashboard """
    context = RequestContext(request,
            {'user': request.user})

    # access token from user profile
    # will be used to access fb
    user_profile = request.user.get_profile()
    facebook = OpenFacebook(user_profile.access_token)

    # get all user uploaded pics from fb
    photos = facebook.get("me/photos/uploaded", fields='images,album')

    # logic to get the smallest image
    # single image and album will be displayed
    display_photos = []
    for photo in photos['data']:
        sorted_images = sorted(photo['images'])
        thumbnail = sorted_images[0]
        large = sorted_images[-1]
        display_photos.append((photo['album'], thumbnail, large))

    context['display_photos'] = display_photos
    return render_to_response('dash.html', context_instance=context)
示例#26
0
def get_all_of_users_facebook_friends(user, facebook_access_token):
    facebook = OpenFacebook(facebook_access_token)
    if user.settings.facebook_connection_flag == True:
        facebook_friends = facebook.get('me/friends',
                                        fields="id,name,picture")['data']
        return facebook_friends
示例#27
0
def get_spotify_username(request):
    me = request.user
    context = {}
    if me.id is not None:
      access_token = me.access_token
      print access_token
      graph = OpenFacebook(access_token)
      if access_token is not None:
        listen_data = graph.get('me/music.listens')
        user_listens = []
        listens = listen_data['data']
        for listen in listens:
          tmp = []
          song_name = listen['data']['song']['title']
          client_url = listen['data']['song']['url']
          client_unique = re.search('track\/(.*)', client_url).group(1)
          tmp.append(song_name)
          tmp.append(client_unique)
          user_listens.append(tmp)

          print(json.dumps(song_name, sort_keys=True, indent=4, separators=(',', ': ')))
        context['user_listens'] = user_listens


    current_user = request.user
    print 'something'
    if current_user.id is not None:
      
      clientProfiles = current_user.clients.all()
      if clientProfiles:
        print clientProfiles
      else:
        print "clientProfiles"

    # if this is a POST request we need to process the form data
    if request.method == 'POST':
        # create a form instance and populate it with data from the request:
        form = ClientUsernameForm(request.POST)
        # check whether it's valid:
        if form.is_valid():
            # process the data in form.cleaned_data as required
            # ...
            # redirect to a new URL:
            
            # Get information from username form
            username = form.cleaned_data["username"]
            client_name = form.cleaned_data["client"]

            # Client object and ID based on client chosen by user
            client = Client.objects.get(client_name=client_name)
            client_id = client.id

            # Check if the user has this a profile for this client, if not create it.
            try:
              client = current_user.clients.get(id=client_id)
              
            except client.DoesNotExist:
              new_client_profile = ClientProfile(user=current_user, client=client, username=username)
              new_client_profile.save()


            # Get user's playlists - Inside this helper function we will decide whether the data needs to be added to TuneBoss, updated or is already present.
            playlists = update_user_playlists(client, username, request)
            
            context = {}
            if current_user.id is not None:
              context['user_clientlists'] = current_user.member_clientlists.all()
            return render(request, 'home.html', context)

    # if a GET (or any other method) we'll create a blank form
    else: 
        form = ClientUsernameForm()

    
    
    if current_user.id is not None:
      print "current_user " + str(current_user.email)
      context['user_clientlists'] = current_user.member_clientlists.all()
    context['form'] = form
    return render(request, 'home.html', context)
示例#28
0
def registered_facebook(request):
    global token
    social_account = None
    username = ''
    try:
        token = request.POST.get('access_token')
        long_access_token = FacebookAuthorization.extend_access_token(token)['access_token']
        print 'long is generated'
        print long_access_token
    except Exception as e:
        print e
        print "register 1"
        long_access_token = token
        print long_access_token

    try:
        graph = OpenFacebook(long_access_token)
        profile = graph.get('me')
        profile_id = profile['id']
        # profile_email = profile['email']
        profile_first_name = profile['first_name']
        profile_last_name = profile['last_name']

        profile_gender = profile['gender']
        if profile_gender == 'male':
            sex = True
        else:
            sex = False
    except Exception as e:
        print '%s (%s)' % (e.message, type(e))
        return HttpResponseRedirect('/sorry/')

    try:
        print "1212122asas"
        social_account = SocialData.objects.filter(account_id=str(profile_id)).all()
        print social_account
        print "1"
    except Exception as e:
        print "HATA" + e

    try:
        print "sss"
        print "r4"
        if social_account:
            print "hesap var"
            user = User.objects.get(id=social_account[0].user.id)
            social_network = SocialData.objects.get(user=user.id)
            username = str(user.username)
            password = str(user.password)
            social_network.account_token = long_access_token
            print username
            print password
            print "sss"
        else:
            print "Hesap yok"
            user_auth = User.objects.create_user(profile_id, 'sss', profile_id)
            user_auth.first_name = profile_first_name
            user_auth.last_name = profile_last_name
            print "sss"
            user_auth.email = ""
            user_auth.is_staff = False
            user_auth.is_active = True
            user_auth.save()
            print "user kayit oldu"
            au = Audience.objects.get(id=1)
            users = Users.objects.create(user_id=user_auth.id, gender=sex, been_id=1, lives_in_id=1)
            users.save()
            print "users kayit oldu"
            social_network = SocialData(user=user_auth, account_type=0, account_id=profile_id,
                                        account_token=long_access_token)
            username = profile_id
        social_network.save()
        dada = authenticate(username=username, password=username)
        if dada is not None:
            print "ac"
            if dada.is_active:
                print "ba"
                auth_login(request, dada)
                print "you are login !!!" + "hello " + request.user.username
                return HttpResponse("true", content_type='application/json')
        else:
            print "b"
        print "a"
        print "social_network kayıt oldu"
        return "false"
    except Exception as e:
        print e
        print "register4"
        return HttpResponseRedirect('/login/')
class FacebookApiExplorer(SocialApi):

    def get_data(self):
        self.graph = OpenFacebook(self.credentials['access_token'])

        feed = self.graph.get('me/posts')

        self.contents = feed["data"]

    def process_contents(self):

            for post in self.contents:

                post_id = post["id"]
                identification = re.split("_", post_id)
                account_id = identification[0]
                post_id = identification[1]

                published_at = post["created_time"]
                published_at = datetime.strptime(published_at[0:10]+' '+published_at[11:19], '%Y-%m-%d %H:%M:%S')
                published_at = timezone.make_aware(published_at, timezone.get_fixed_timezone(0))
                if "link" in post.keys():
                    original_url = post["link"]
                else:
                    original_url = "https://www.facebook.com/"+account_id+"/posts/"+post_id

                def search(parameter):
                    try:
                        return post[parameter]
                    except KeyError:
                        return ""

                def amount(parameter):
                    try:
                        return self.graph.get(post['id']+'/'+parameter, summary='1')['summary']['total_count']
                    except KeyError:
                        return 0

                text = search("message")
                video_url = search("source")
                image_url = search("picture")
                image_id = search("object_id")
                post_type = search("type")
                number_of_likes = amount("likes")
                number_of_comments = amount("comments")

                if image_url and image_id:

                    feed = self.graph.get(image_id)
                    try:
                        if post_type == 'video':
                            image_url = sorted(feed['format'], key=lambda k: k['width'], reverse=True)[0]['picture']

                        else:
                            image_url = sorted(feed['images'], key=lambda k: k['width'], reverse=True)[0]['source']
                    except KeyError:
                        #Error finding image_url
                        pass

                new_content = FacebookContent(identifier=post_id, text=text, published_at=published_at,
                                              image_url=image_url, original_url=original_url,
                                              number_of_comments=number_of_comments, number_of_likes=number_of_likes,
                                              video_url=video_url)

                try:
                    if (text or video_url or image_url) and post_type != 'link':
                        self.update_content(new_content)
                except Exception as err:
                    print 'Could not save content %s: %s' % (new_content, err)
示例#30
0
文件: views.py 项目: reparadocs/Page
def news(request):
   if request.method == 'GET':
      graph = OpenFacebook(request.user.access_token)
      likes_response = graph.get('me/likes', limit=50000)
      likes = likes_response and likes_response.get('data')
      return HttpResponse(likes)
示例#31
0
文件: views.py 项目: ibaguio/pinder
def fb_auth_handler(request):
    # Retrieve oAuth response
    response = urlparse(request.get_full_path())
    query = parse_qs(response.query)

    # Handle oAuth initial request error
    if "error" in query and "access_denied" in query["error"] and \
            "user_denied" in query["error_reason"]:
        try:
            logger.warning("Facebook returned error: %s" % query["error"])
        except KeyError:
            err_msg = "Please login and allow Facebook to continue."
            return HttpResponse(json.dumps({"status": "fail",
                                            "message": err_msg}))

    # Recreate the redirect_uri
    redir_path = request.get_full_path()

    logger.info("exchanging code for accesstoken...")

    redirect_uri = request.META['wsgi.url_scheme'] + "://" +\
                   request.get_host() + reverse("fb_auth_handler")

    payload = {
        "client_id": settings.FACEBOOK_APP_ID,
        "redirect_uri": redirect_uri,
        "client_secret": settings.FACEBOOK_APP_SECRET,
        "code": query["code"][0]
    }
    xrequest = requests.get("https://graph.facebook.com/oauth/access_token",
                            params=payload)

    # Handle oAuth secondary request error
    fbresponse = parse_qs(xrequest.text)

    if "error" in fbresponse or not len(fbresponse):
        # TODO: Error handling
        if "error" in fbresponse:
            err_msg = "FB returned error: %s" % fbresponse["error"]
            logger.warning(err_msg)

        else:
            err_msg = "User fb token expired."
            logger.warning(err_msg)

        return HttpResponse(json.dumps({"status": "fail",
                                        "message": err_msg}))

    # Acquire accesstoken
    accesstoken = fbresponse["access_token"][0]
    # Acquire userinfo
    graph = OpenFacebook(accesstoken)
    user_data = graph.get('me')

    user = User.create(user_data, token=accesstoken)

    if user:
        request.session['me'] = user.fb_id
        return redirect("/nearby/")
        # return HttpResponse(json.dumps({"status": "success",
        #                                 "data": dict(user)}))
    else:
        return HttpResponse(json.dumps({"status": "fail"}))
示例#32
0
def get_page_posts(request):
    """ Gets the posts for a given page id.

    -- This view is called by the datatable as an ajax call to get the next set of posts(both published and unpublished).
    -- Receives page id and next urls for published and unpublished posts as get parameter. If next urls are passed,
     calls them to get the next set of posts. Else calls the default urls.
     -- As post impressions are not known through the same api, we pass a hidden field with value as post id for that
     column. Once all the rows are loaded, a different ajax call is made to populate that field.
     -- Merges the result of published and unpublished posts and returns as a JSON to be populated in datatable.
    """

    page_id = request.GET['page_id']
    next_url = request.GET['next_url']
    unpublished_url = request.GET['unpublished_next_url']
    # this represents if all unpublished posts have been received
    skip_unpublished = request.GET.get('skip_unpublished', 'False')

    facebook = OpenFacebook(request.user.access_token)
    # placeholder for main data. Represents a list of lists where each inner list corresponds to a row in table.
    return_list = []

    unpublished_next_url = unpublished_url
    if skip_unpublished == 'False':  # means we should call the unpublished api also
        try:
            if unpublished_url:  # next url is passed as GET parameter. use this to get the posts.
                unpublished_post = facebook.get(
                    unpublished_url.replace('https://graph.facebook.com/v2.8/',
                                            ''))
            else:
                unpublished_post = facebook.get('%s/promotable_posts/' %
                                                (page_id),
                                                is_published=False)

            # update the next url for next call
            unpublished_next_url = unpublished_post['paging']['next']

            # populate return list in specific format. Each inner row represents a row.
            for post in unpublished_post['data']:
                if unpublished_url:  # if next url was called, the first result is repeated. Ignore the first row.
                    unpublished_url = None
                    continue
                # populate the result list.
                return_list.append([
                    post.get('message',
                             post.get('story')), post['created_time'][:-5],
                    '<input type="hidden" name="post_id" value="%s"/>' %
                    (post['id']), "UnPublished"
                ])
        except:
            unpublished_next_url = unpublished_url
            skip_unpublished = 'True'

    # now get the published posts
    try:
        if next_url:  # next url is passed as GET parameter. use this to get the posts.
            feed_details = facebook.get(
                next_url.replace('https://graph.facebook.com/v2.8/', ''))
        else:
            feed_details = facebook.get('%s/posts/' % (page_id), limit=10)

        for element in feed_details['data']:
            if next_url:  # if next url was called, the first result is repeated. Ignore the first row.
                next_url = None
                continue
            # populate the result list.
            return_list.append([
                element.get('message', element.get('story')),
                element['created_time'][:-5],
                '<input type="hidden" name="post_id" value="%s"/>' %
                (element['id']), "Published"
            ])
        # get the next url for published posts
        new_next_url = feed_details['paging']['next']

        # create a json to be consumed by the datatable. The json follows predefined format. The main data is passed as
        # aaData which is consumed by datatable to create the rows.
        return JsonResponse({
            "sEcho": request.GET['sEcho'],
            "iTotalRecords": 100000,
            "iTotalDisplayRecords": 1000000,
            "aaData": return_list,
            "next": new_next_url,
            "unpublished_next": unpublished_next_url,
            "skip_unpublished": skip_unpublished
        })
    except:
        return JsonResponse({
            "sEcho": request.GET['sEcho'],
            "iTotalRecords": 100000,
            "iTotalDisplayRecords": 1,
            "aaData": [],
            "next": '',
            "unpublished_next": unpublished_next_url,
            "skip_unpublished": skip_unpublished
        })
示例#33
0
def get_all_of_users_facebook_friends(user,facebook_access_token):
	facebook = OpenFacebook(facebook_access_token)
	if user.settings.facebook_connection_flag == True:
		facebook_friends = facebook.get('me/friends',fields="id,name,picture")['data']
		return facebook_friends
示例#34
0
def get_all_of_users_facebook_friends_on_yapster(user,facebook_access_token):
	facebook = OpenFacebook(facebook_access_token)
	if user.settings.facebook_connection_flag == True:
		facebook_friends = facebook.get('me/friends',fields="id")['data']
		this_users_facebook_friends_on_yapster = [friend_facebook_id['id'] for friend_facebook_id in facebook_friends if Settings.objects.filter(is_active=True,facebook_account_id=friend_facebook_id['id']).exists() == True]
		return this_users_facebook_friends_on_yapster
示例#35
0
#import settings as facebook_settings
from django.conf import settings
settings.configure()
from django_facebook import settings as facebook_settings
from open_facebook import OpenFacebook
from open_facebook.api import FacebookAuthorization
import json

facebook_settings.FACEBOOK_APP_ID = '611406969009887'
facebook_settings.FACEBOOK_APP_SECRET = '6be22272c73f9a90f8ded333fbb0ff4d'
access_token = FacebookAuthorization.get_app_access_token()
graph = OpenFacebook(access_token)
print access_token
fb_name = 'HongKongPoliceForce'
target = graph.get(fb_name)
#fields='id,from,message,created_time,updated_time,reactions.limit(5),comments.limit(5){id,from,message,created_time,comments,likes}'
fields = 'reactions.limit(100){id,name,type}'
#dict={}
#posts=graph.get(target['id']+'/posts',limit=2, fields=fields,version='v2.6')
#fields=created_time,id,from,comment_count,message,like_count,likes,comments{parent,message,from,id}&limit=100
#fields=comments.limit(20){from,id,created_time,message,likes,comments},id,created_time,from,message,reactions,updated_time&limit=10

id = target['id']
print id
contents = graph.get(id + '/posts', limit=50, fields=fields, version='v2.6')
print contents


def getUrl(url):
    if '\\' in url:
        url = eval('u' + "'" + url + "'")
示例#36
0
# -*- coding: utf-8 -*-
import requests
from django.conf import settings
settings.configure()
from django_facebook import settings as facebook_settings
from open_facebook import OpenFacebook
from open_facebook.api import FacebookAuthorization
import json

facebook_settings.FACEBOOK_APP_ID ='611406969009887'
facebook_settings.FACEBOOK_APP_SECRET ='6be22272c73f9a90f8ded333fbb0ff4d'
access_token=FacebookAuthorization.get_app_access_token()
graph=OpenFacebook(access_token)

fb_name='HongKongPoliceForce'
target=graph.get(fb_name)
fields='reactions.limit(100){id,name,type},comments.limit(100){id,name}'
id=target['id']

print id
posts=graph.get(id+'/posts',limit=100,fields=fields,version='v2.6')



def getUrl(url):
	if '\\' in url:
		url=eval('u'+"'"+url+"'")
		url=url.replace('\\','')
	return url

示例#37
0
    def get_fb(links):
        from open_facebook import OpenFacebook
        graph = OpenFacebook(settings.FACEBOOK_API_ACCESS_TOKEN)

        rows = []

        for link in links:
            # https://www.facebook.com/Beelinerus/posts/588392457883231
            matches = re.match(r'^https?://www.facebook.com/(.*?)/posts/(\d+)$', link)
            link = '<a href="{0}">{0}</a>'.format(link)
            if matches:
                company_slug = matches.group(1)
                post_id = matches.group(2)

                try:
                    company = graph.get(company_slug, fields='id,likes,talking_about_count')
                except OpenFacebookException as e:
                    rows.append({
                        'status': 'error',
                        'data': [
                            link,
                            'Company not found',
                        ]
                    })
                    continue

                post_graph_id = '%s_%s' % (company['id'], post_id)
                try:
                    post = graph.get(post_graph_id, fields='comments.limit(0).summary(true),likes.limit(0).summary(true),shares.limit(0).summary(true)')
                except OpenFacebookException as e:
                    rows.append({
                        'status': 'error',
                        'data': [
                            link,
                            'Post not found',
                        ]
                    })
                    continue

                likes = ''
                shares = ''
                comments = ''

                if 'likes' in post:
                    likes = post['likes']['summary']['total_count']
                if 'shares' in post:
                    shares = post['shares']['count']
                if 'comments' in post:
                    comments = post['comments']['summary']['total_count']

                rows.append({
                    'status': 'ok',
                    'data': [
                        link,
                        company['likes'],
                        company['talking_about_count'],
                        likes,
                        shares,
                        comments,
                    ]
                })

            else:
                rows.append({
                    'status': 'error',
                    'data': [
                        link,
                        'Incorrect url',
                    ]
                })


        return rows
示例#38
0
def main():
    consumer_key = 'zsqVde4f4vkRNopoj8zGvVM7x',
    consumer_secret = '3pcD1MNmQNyHAZrDjmNQmHdnUNfZywbA4Lbomh3ofxqzO3e6o8'
    published_adverts = Published_Adverts.objects.filter(active=True)
    for published_advert in published_adverts:
        if published_advert.campaign.campaign_type == '0':
            account = Social_Data.objects.get(
                publisher=published_advert.social_data.publisher,
                account_type='1')
            api = twitter.Api(
                consumer_key='zsqVde4f4vkRNopoj8zGvVM7x',
                consumer_secret=
                '3pcD1MNmQNyHAZrDjmNQmHdnUNfZywbA4Lbomh3ofxqzO3e6o8',
                access_token_key=account.account_id,
                access_token_secret=account.account_token)
            try:
                if api.GetRetweets(statusid=published_advert.message_link,
                                   count=1)[0].retweeted == False:
                    is_message_none(published_advert.social_data.publisher)
            except Exception as e:
                print e
        elif published_advert.campaign.campaign_type == '1':
            account = Social_Data.objects.get(
                publisher=published_advert.social_data.publisher,
                account_type='1')
            api = twitter.Api(
                consumer_key='zsqVde4f4vkRNopoj8zGvVM7x',
                consumer_secret=
                '3pcD1MNmQNyHAZrDjmNQmHdnUNfZywbA4Lbomh3ofxqzO3e6o8',
                access_token_key=account.account_id,
                access_token_secret=account.account_token)
            print api.GetStatus(id='565490400102985729').user.id
            try:
                if api.GetStatus(id='565490400102985729'
                                 ).user.id == api.VerifyCredentials().id:
                    pass
                else:
                    is_message_none(published_advert.social_data.publisher)
            except Exception as e:
                print e
        elif published_advert.campaign.campaign_type == '2':
            pass
        elif published_advert.campaign.campaign_type == '3':
            account = Social_Data.objects.get(
                publisher=published_advert.social_data.publisher,
                account_type='0')
            print account.account_token

            facebook = OpenFacebook(account.account_token)
            print facebook.get('deadspace/')['id']
            print facebook.get('me/likes/18523496657')
            if facebook.get('me/likes/' +
                            str(published_advert.message_link))['data'] == []:
                is_message_none(published_advert.social_data.publisher)
        else:
            account = Social_Data.objects.get(
                publisher=published_advert.social_data.publisher,
                account_type='1')
            api = twitter.Api(
                consumer_key='zsqVde4f4vkRNopoj8zGvVM7x',
                consumer_secret=
                '3pcD1MNmQNyHAZrDjmNQmHdnUNfZywbA4Lbomh3ofxqzO3e6o8',
                access_token_key=account.account_id,
                access_token_secret=account.account_token)
            id_list = api.GetFollowerIDs(user_id=published_advert.message_link)
            try:
                if not api.VerifyCredentials().id in id_list:
                    is_message_none(published_advert.social_data.publisher)
            except Exception as e:
                print e
示例#39
0
    def get_fb(links):
        from open_facebook import OpenFacebook
        graph = OpenFacebook(settings.FACEBOOK_API_ACCESS_TOKEN)

        rows = []

        for link in links:
            # https://www.facebook.com/Beelinerus/posts/588392457883231
            matches = re.match(
                r'^https?://www.facebook.com/(.*?)/posts/(\d+)$', link)
            link = '<a href="{0}">{0}</a>'.format(link)
            if matches:
                company_slug = matches.group(1)
                post_id = matches.group(2)

                try:
                    company = graph.get(company_slug,
                                        fields='id,likes,talking_about_count')
                except OpenFacebookException as e:
                    rows.append({
                        'status': 'error',
                        'data': [
                            link,
                            'Company not found',
                        ]
                    })
                    continue

                post_graph_id = '%s_%s' % (company['id'], post_id)
                try:
                    post = graph.get(
                        post_graph_id,
                        fields=
                        'comments.limit(0).summary(true),likes.limit(0).summary(true),shares.limit(0).summary(true)'
                    )
                except OpenFacebookException as e:
                    rows.append({
                        'status': 'error',
                        'data': [
                            link,
                            'Post not found',
                        ]
                    })
                    continue

                likes = ''
                shares = ''
                comments = ''

                if 'likes' in post:
                    likes = post['likes']['summary']['total_count']
                if 'shares' in post:
                    shares = post['shares']['count']
                if 'comments' in post:
                    comments = post['comments']['summary']['total_count']

                rows.append({
                    'status':
                    'ok',
                    'data': [
                        link,
                        company['likes'],
                        company['talking_about_count'],
                        likes,
                        shares,
                        comments,
                    ]
                })

            else:
                rows.append({
                    'status': 'error',
                    'data': [
                        link,
                        'Incorrect url',
                    ]
                })

        return rows
示例#40
0
    def get_fb(self, links):
        from open_facebook import OpenFacebook
        from . utils import recursive_graph_call

        graph = OpenFacebook(settings.FACEBOOK_API_ACCESS_TOKEN)

        ids = set()

        for link in links:
            matches = re.match(r'^https?://www.facebook.com/(.*?)/posts/(\d+)$', link)
            if matches:
                company_slug = matches.group(1)
                post_id = matches.group(2)

                try:
                    company = graph.get(company_slug, fields='id')
                except OpenFacebookException as e:
                    continue

                # check
                post_graph_id = '%s_%s' % (company['id'], post_id)
                try:
                    post = graph.get(post_graph_id, fields='id')
                except OpenFacebookException as e:
                    continue

                # getting likes
                response = recursive_graph_call(post_graph_id + '/likes', limit=500)

                for user in response['data']:
                    ids.add(user['id'])
                    # u = self.fb_user(user)
                    # u['like'] = 1
                    # rows[user['id']] = u

                # getting shares
                response = recursive_graph_call(post_graph_id + '/sharedposts', fields='from', limit=500)

                for share in response['data']:
                    user = share['from']
                    ids.add(user['id'])

                    # if user['id'] not in rows:
                    #     u = self.fb_user(user)
                    #     u['share'] = 1
                    #     rows[user['id']] = u
                    # else:
                    #     rows[user['id']]['share'] = 1

                # getting comments
                response = recursive_graph_call(post_graph_id + '/comments', fields='from', limit=500)

                for comment in response['data']:
                    user = comment['from']
                    ids.add(user['id'])

                    # if user['id'] not in rows:
                    #     u = self.fb_user(user)
                    #     u['comment'] += 1
                    #     rows[user['id']] = u
                    # else:
                    #     rows[user['id']]['comment'] += 1
            # else:
            #     rows['errors'] = 'Invalid post link'

        return ids
示例#41
0
    def get_fb(self, links):
        from open_facebook import OpenFacebook
        from .utils import recursive_graph_call

        graph = OpenFacebook(settings.FACEBOOK_API_ACCESS_TOKEN)

        ids = set()

        for link in links:
            matches = re.match(
                r'^https?://www.facebook.com/(.*?)/posts/(\d+)$', link)
            if matches:
                company_slug = matches.group(1)
                post_id = matches.group(2)

                try:
                    company = graph.get(company_slug, fields='id')
                except OpenFacebookException as e:
                    continue

                # check
                post_graph_id = '%s_%s' % (company['id'], post_id)
                try:
                    post = graph.get(post_graph_id, fields='id')
                except OpenFacebookException as e:
                    continue

                # getting likes
                response = recursive_graph_call(post_graph_id + '/likes',
                                                limit=500)

                for user in response['data']:
                    ids.add(user['id'])
                    # u = self.fb_user(user)
                    # u['like'] = 1
                    # rows[user['id']] = u

                # getting shares
                response = recursive_graph_call(post_graph_id + '/sharedposts',
                                                fields='from',
                                                limit=500)

                for share in response['data']:
                    user = share['from']
                    ids.add(user['id'])

                    # if user['id'] not in rows:
                    #     u = self.fb_user(user)
                    #     u['share'] = 1
                    #     rows[user['id']] = u
                    # else:
                    #     rows[user['id']]['share'] = 1

                # getting comments
                response = recursive_graph_call(post_graph_id + '/comments',
                                                fields='from',
                                                limit=500)

                for comment in response['data']:
                    user = comment['from']
                    ids.add(user['id'])

                    # if user['id'] not in rows:
                    #     u = self.fb_user(user)
                    #     u['comment'] += 1
                    #     rows[user['id']] = u
                    # else:
                    #     rows[user['id']]['comment'] += 1
            # else:
            #     rows['errors'] = 'Invalid post link'

        return ids