コード例 #1
0
ファイル: test.py プロジェクト: Fandekasp/Django-facebook
 def test_double_username(self):
     '''
     This used to give an error with duplicate usernames with different capitalization
     '''
     facebook = get_facebook_graph(access_token='short_username')
     action, user = connect_user(self.request, facebook_graph=facebook)
     user.username = '******'
     user.save()
     self.request.user = AnonymousUser()
     facebook = get_facebook_graph(access_token='same_username')
     action, new_user = connect_user(self.request, facebook_graph=facebook)
     assert user.username != new_user.username and user.id != new_user.id
コード例 #2
0
    def test_login_with_Facebook2(self):
        graph = get_facebook_graph(access_token='short_username')
        action, user = connect_user(self.request, facebook_graph=graph)
        user.save()
        self.request.user = AnonymousUser()
        graph = get_facebook_graph(access_token='same_username')
        action, new_user = connect_user(self.request, facebook_graph=graph)

        self.request.GET._mutable = True
        self.request.GET['testing'] = 'True'
        response = views.index(self.request)
        print response.content
コード例 #3
0
 def test_double_username(self):
     '''
     This used to give an error with duplicate usernames with different capitalization
     '''
     facebook = get_facebook_graph(access_token='short_username')
     action, user = connect_user(self.request, facebook_graph=facebook)
     user.username = '******'
     user.save()
     self.request.user = AnonymousUser()
     facebook = get_facebook_graph(access_token='same_username')
     action, new_user = connect_user(self.request, facebook_graph=facebook)
     assert user.username != new_user.username and user.id != new_user.id
コード例 #4
0
    def test_login_with_Facebook2(self):
        graph = get_facebook_graph(access_token='short_username')
        action, user = connect_user(self.request, facebook_graph=graph)
        user.save()
        self.request.user = AnonymousUser()
        graph = get_facebook_graph(access_token='same_username')
        action, new_user = connect_user(self.request, facebook_graph=graph)


        self.request.GET._mutable = True
        self.request.GET['testing'] = 'True'
        response = views.index(self.request)
        print response.content
コード例 #5
0
 def test_double_username(self):
     """
     This used to give an error with duplicate usernames
     with different capitalization
     """
     facebook = get_facebook_graph(access_token="short_username")
     action, user = connect_user(self.request, facebook_graph=facebook)
     user.username = "******"
     user.save()
     self.request.user = AnonymousUser()
     facebook = get_facebook_graph(access_token="same_username")
     action, new_user = connect_user(self.request, facebook_graph=facebook)
     self.assertNotEqual(user.username, new_user.username)
     self.assertNotEqual(user.id, new_user.id)
コード例 #6
0
def home(request):
    if (not request.user.pk is None
        ) and request.user.userprofile.terms_conditions:
        # Get the graph from the FB API
        if not 'num_friends' in request.session or not 'friends' in request.session:
            graph = get_facebook_graph(request=request)

            friends = graph.get('me/friends', fields='')['data']
            friends = [f['name'] for f in friends]
            request.session['friends'] = friends
            request.session['num_friends'] = len(friends)

        user_list = UserProfile.objects.exclude(
            pk=-1).order_by('-score_global')
        count = 0
        for u in user_list:
            count += 1
            if u.user.id == request.user.id:
                rank = count
                break

        context = RequestContext(request)
        context_dict = {'user': request.user, 'rank': rank}

        return render_to_response('home.html',
                                  context_dict,
                                  context_instance=context)
    else:
        return HttpResponseRedirect('/canvas/terms/')
コード例 #7
0
    def test_anon_user_loads_index(self):
        graph = get_facebook_graph(access_token='new_user')
        action, user = connect_user(self.request, facebook_graph=graph)

        self.request.user = AnonymousUser()
        response = views.index(self.request)
        print response.cookies
コード例 #8
0
    def test_anon_user_loads_index(self):
        graph = get_facebook_graph(access_token='new_user')
        action, user = connect_user(self.request, facebook_graph=graph)

        self.request.user = AnonymousUser()
        response = views.index(self.request)
        print response.cookies
コード例 #9
0
    def test_check_connect_facebook(self):
        graph = get_facebook_graph(access_token='new_user')
        facebook = FacebookUserConverter(graph)
        data = facebook.facebook_registration_data()
        self.assertEqual(data['gender'], 'm')

        response = self.client.get(reverse('login:index'))
コード例 #10
0
ファイル: test.py プロジェクト: WoLpH/Django-facebook
 def test_graph_fql(self):
     from django_facebook.api import get_app_access_token
     token = get_app_access_token()
     facebook = get_facebook_graph(access_token=token, persistent_token=False)
     query = 'SELECT name FROM user WHERE uid = me()'
     result = facebook.fql(query)
     assert result == []
コード例 #11
0
    def test_check_connect_facebook(self):
        graph = get_facebook_graph(access_token='new_user')
        facebook = FacebookUserConverter(graph)
        data = facebook.facebook_registration_data()
        self.assertEqual(data['gender'], 'm')

        response = self.client.get(reverse('login:index'))
コード例 #12
0
    def test_parallel_register(self):
        '''
        Adding some testing for the case when one person tries to register
        multiple times in the same second
        '''
        graph = get_facebook_graph(access_token='short_username')
        FacebookUserConverter(graph)
        action, user = connect_user(self.request, facebook_graph=graph)
        self.assertEqual(action, CONNECT_ACTIONS.REGISTER)

        self.request.user.is_authenticated = lambda: False
        with patch('django_facebook.connect.authenticate') as patched:
            return_sequence = [user, None]

            def side(*args, **kwargs):
                value = return_sequence.pop()
                return value

            patched.side_effect = side
            with patch('django_facebook.connect._register_user'
                       ) as patched_register:
                patched_register.side_effect = facebook_exceptions.AlreadyRegistered(
                    'testing parallel registers')
                action, user = connect_user(self.request, facebook_graph=graph)
                self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
コード例 #13
0
ファイル: utils.py プロジェクト: Chodex/djangodash2013
def get_facebook_friends(request):
    open_graph = get_facebook_graph(request)
    converter = FacebookUserConverter(open_graph)
    friends = converter.open_facebook.fql(
        u"SELECT uid, name, birthday, sex FROM user WHERE uid IN (SELECT uid2 FROM friend WHERE uid1 = me())"
    )
    return friends
コード例 #14
0
ファイル: views.py プロジェクト: jonandkelly/dsz
def downsize(request):
    user = request.user
    saving_category_list = SavingCategory.objects.all()
    ds_saving_types_list = Saving.objects.filter(ds_suggested=True)
    ds_saving_points_list = []
    for saving in ds_saving_types_list:
        try:
            ds_saving_points_list.append(SavingRelationship.objects.get(userprofile=user.userprofile, saving=saving).saving_points)
        except:
            ds_saving_points_list.append(0)
    ds_zipped = zip(ds_saving_types_list, ds_saving_points_list)
    crowd_saving_types_list = Saving.objects.filter(ds_suggested=False)
    crowd_saving_points_list = []
    for saving in crowd_saving_types_list:
        try:
            crowd_saving_points_list.append(SavingRelationship.objects.get(userprofile=user.userprofile, saving=saving).saving_points)
        except:
            crowd_saving_points_list.append(0)
    crowd_zipped = zip(crowd_saving_types_list, crowd_saving_points_list)
    if request.method == 'POST':
        form = DownsizeForm(user, request.POST)
        downsize = form.save()
        downsize = CreateDownsize(downsize, user)
        #facebook_user = get_user_from_cookie(request.COOKIES, FACEBOOK_API_KEY, FACEBOOK_APP_SECRET)
        graph = get_facebook_graph(request=request)
        downsize_amount = str(downsize.downsize_amount)
        saving = str(downsize.saving)
        post_string = "I downsized $" + downsize_amount + " by " + saving
        graph.put_wall_post(post_string)
        return HttpResponseRedirect('../dashboard')
    else:
        form = DownsizeForm(user)
    return render_to_response('goals/downsize.html', {'form': form, 'user': user, 'ds_zipped': ds_zipped, 'crowd_zipped': crowd_zipped, 'saving_category_list': saving_category_list}, context_instance=RequestContext(request))
コード例 #15
0
ファイル: tests.py プロジェクト: duduklein/django-facebook
    def test_user_registered_signal(self):
        # Ensure user registered, pre update and post update signals fire

        def user_registered(sender, user, facebook_data, **kwargs):
            user.registered_signal = True

        def pre_update(sender, user, profile, facebook_data, **kwargs):
            user.pre_update_signal = True

        def post_update(sender, user, profile, facebook_data, **kwargs):
            user.post_update_signal = True

        Profile = get_profile_model()
        user_model = get_user_model()
        signals.facebook_user_registered.connect(
            user_registered, sender=user_model)
        signals.facebook_pre_update.connect(pre_update, sender=user_model)
        signals.facebook_post_update.connect(post_update, sender=user_model)

        graph = get_facebook_graph(access_token='short_username')
        facebook = FacebookUserConverter(graph)
        user = _register_user(self.request, facebook)
        self.assertEqual(hasattr(user, 'registered_signal'), True)
        self.assertEqual(hasattr(user, 'pre_update_signal'), True)
        self.assertEqual(hasattr(user, 'post_update_signal'), True)
コード例 #16
0
    def test_user_registered_signal(self):
        # Ensure user registered, pre update and post update signals fire

        def user_registered(sender, user, facebook_data, **kwargs):
            user.registered_signal = True

        def pre_update(sender, user, profile, facebook_data, **kwargs):
            user.pre_update_signal = True

        def post_update(sender, user, profile, facebook_data, **kwargs):
            user.post_update_signal = True

        Profile = get_profile_model()
        user_model = get_user_model()
        signals.facebook_user_registered.connect(user_registered,
                                                 sender=user_model)
        signals.facebook_pre_update.connect(pre_update, sender=user_model)
        signals.facebook_post_update.connect(post_update, sender=user_model)

        graph = get_facebook_graph(access_token='short_username')
        facebook = FacebookUserConverter(graph)
        user = _register_user(self.request, facebook)
        self.assertEqual(hasattr(user, 'registered_signal'), True)
        self.assertEqual(hasattr(user, 'pre_update_signal'), True)
        self.assertEqual(hasattr(user, 'post_update_signal'), True)
コード例 #17
0
def stats(request):
    if (not request.user.pk is None
        ) and request.user.facebookprofile.facebook_id:
        # Get the graph from the FB API
        graph = get_facebook_graph(request=request)
        request.user.facebookprofile.facebook_id = graph.get('me',
                                                             fields='id')['id']
        request.user.facebookprofile.save()

    if (not request.user.pk is None
        ) and request.user.facebookprofile.facebook_id in SUPERUSER_ID:
        context = RequestContext(request)
        static_stats_path = Base.STATICFILES_DIRS[0] + '/static/stats/'

        # Get Data Base
        usr = list(UserProfile.objects.all().order_by('user__date_joined'))
        img = list(Picture.objects.all().order_by('date'))
        vte = list(Votes.objects.all().order_by('date'))
        rpt = list(Report.objects.all().order_by('date'))

        plot_stats(usr, img, vte, rpt, static_stats_path)

        context_dict = {
            'num_usr': len(usr),
            'num_img': len(img),
            'num_vte': len(vte),
            'num_rpt': len(rpt),
        }

        return render_to_response('stats.html',
                                  context_dict,
                                  context_instance=context)
    else:
        return HttpResponseRedirect('/canvas/terms/')
コード例 #18
0
ファイル: connect.py プロジェクト: cid2105/greek_gavel
def connect_user(request, access_token=None, facebook_graph=None):
    '''
    Given a request either
    
    - (if authenticated) connect the user
    - login
    - register
    '''
    #TODO, instead of using access_token this should probably accept a facebook_graph as well
    user = None
    facebook = facebook_graph or get_facebook_graph(request, access_token)
    assert facebook.is_authenticated()
    facebook_data = facebook.facebook_profile_data()
    force_registration = request.REQUEST.get('force_registration') or request.REQUEST.get('force_registration_hard')
    
    logger.debug('force registration is set to %s', force_registration)
    if request.user.is_authenticated() and not force_registration:
        action = CONNECT_ACTIONS.CONNECT
        user = _connect_user(request, facebook)
    else:
        email = facebook_data.get('email', False)
        email_verified = facebook_data.get('verified', False)
        kwargs = {}
        if email and email_verified:
            kwargs = {'facebook_email': email}
        authenticated_user = authenticate(facebook_id=facebook_data['id'], **kwargs)
        if authenticated_user and not force_registration:
            action = CONNECT_ACTIONS.LOGIN

            ## Has the user registered without Facebook, using the verified FB email address?
            # It is after all quite common to use email addresses for usernames
            if not authenticated_user.get_profile().facebook_id:
                update = True
            else:
                update = getattr(authenticated_user, 'fb_update_required', False)
            user = _login_user(request, facebook, authenticated_user, update=update)
        else:
            action = CONNECT_ACTIONS.REGISTER
            user = _register_user(request, facebook)
            
    #store likes and friends if configured
    
    sid = transaction.savepoint()
    try:
        if facebook_settings.FACEBOOK_STORE_LIKES:
            likes = facebook.get_likes()
            facebook.store_likes(user, likes)
        if facebook_settings.FACEBOOK_STORE_FRIENDS:
            friends = facebook.get_friends()
            facebook.store_friends(user, friends)
        transaction.savepoint_commit(sid)
    except IntegrityError, e:
        logger.warn(u'Integrity error encountered during registration, probably a double submission %s' % e, 
            exc_info=sys.exc_info(), extra={
            'request': request,
            'data': {
                 'body': unicode(e),
             }
        })
        transaction.savepoint_rollback(sid)
コード例 #19
0
ファイル: views.py プロジェクト: AlfiyaZi/Django-facebook
def connect(request):
    '''
    Handles the view logic around connect user
    - (if authenticated) connect the user
    - login
    - register
    
    '''
    context = RequestContext(request)
    facebook_login = bool(int(request.REQUEST.get('facebook_login', 0)))
    
    if facebook_login:
        facebook = get_facebook_graph(request)
        if facebook.is_authenticated():
            facebook_data = facebook.facebook_profile_data()
            #either, login register or connect the user
            try:
                action, user = connect_user(request)
            except facebook_exceptions.IncompleteProfileError, e:
                logger.error(unicode(e))
                messages.error(request, _("Please allow the request for permission in order to log in."))
                return next_redirect(request)
                
            if action is CONNECT_ACTIONS.CONNECT:
                messages.info(request, _("You have connected your account to %s's facebook profile") % facebook_data['name'])
            elif action is CONNECT_ACTIONS.REGISTER:
                member_overview_url = user.get_profile().url['overview']
                response = HttpResponseRedirect(member_overview_url)
                response.set_cookie('fresh_registration', user.id)
                return response
        else:
            return next_redirect(request, additional_params=dict(fb_error_or_cancel=1))
            
        return next_redirect(request)
コード例 #20
0
ファイル: connect.py プロジェクト: AlfiyaZi/Django-facebook
def connect_user(request, access_token=None):
    '''
    Given a request either
    
    - (if authenticated) connect the user
    - login
    - register
    '''
    user = None
    facebook = get_facebook_graph(request, access_token)
    assert facebook.is_authenticated()
    facebook_data = facebook.facebook_profile_data()
    force_registration = request.REQUEST.get('force_registration') or request.REQUEST.get('force_registration_hard')
    
    logger.debug('force registration is set to %s', force_registration)
    if request.user.is_authenticated() and not force_registration:
        action = CONNECT_ACTIONS.CONNECT
        user = _connect_user(request, facebook)
    else:
        email = facebook_data.get('email', False)
        email_verified = facebook_data.get('verified', False)
        kwargs = {}
        if email and email_verified:
            kwargs = {'facebook_email': email}
        authenticated_user = authenticate(facebook_id=facebook_data['id'], **kwargs)
        if authenticated_user and not force_registration:
            action = CONNECT_ACTIONS.LOGIN
            user = _login_user(request, facebook, authenticated_user, update=getattr(authenticated_user, 'fb_update_required', False))
        else:
            action = CONNECT_ACTIONS.REGISTER
            user = _register_user(request, facebook)
            
    return action, user
コード例 #21
0
ファイル: views.py プロジェクト: timothykoh/dogechat
def login_success(request):
    graph = get_facebook_graph(request)
    facebook_me = graph.get("me")
    print facebook_me
    name = facebook_me["name"]
    email = facebook_me["email"]
    facebook_id = facebook_me["id"]

    try:
        curUser = DogeUser.objects.get(facebook_id=facebook_id)
    except ObjectDoesNotExist:
        curUser = DogeUser.objects.create_user(email,name,facebook_id)
    
    primary_id = curUser.id
        
    user_info = {
                    "name" : name,
                    "email" : email,
                    "facebook_id" : facebook_id,
                    "primary_id" : primary_id
    }

    request.session["user_info"] = user_info

    return HttpResponseRedirect(reverse("index"))
コード例 #22
0
def my_style(request):
    context = RequestContext(request)

    context['auth_url'] = generate_oauth_url()
    context['facebook'] = fb = get_facebook_graph(request)

    return render_to_response('django_facebook/my_style.html', context)
コード例 #23
0
ファイル: threads.py プロジェクト: dylan-wu/unishared
    def run(self):
        try:
            access_token = UserSocialAuth.objects.get(user=self.user, provider='facebook').extra_data['access_token']
            self.graph = get_facebook_graph(access_token=access_token)
            if self.graph:
                for n in range(0, 5):
                    try:
                        url = None
                        try:
                            if u'class' in self.params:
                                url = self.params[u'class']
                            elif u'link' in self.params:
                                url = self.params[u'link']
                            if url:
                                self.graph.set(u'/', {'ids' : url, 'scrape' : 'true'})
                        except OAuthException:
                            LoggingHelper.getDebugLogger().debug(u'Error while scraping {0}'.format(url), exc_info=1)

                        return self.graph.set(u'{0}/{1}'.format(self.facebook_id, self.action), self.params)
                    except PermissionException:
                        LoggingHelper.getDebugLogger().debug(u'Permission not granted (facebook_id : {0}, action {1}, params {2})'.format(self.facebook_id, self.action, self.params), exc_info=1)
                    except OAuthException:
                        LoggingHelper.getDebugLogger().debug(u'Refreshing token (facebook_id : {0}, action {1}, params {2})'.format(self.facebook_id, self.action, self.params), exc_info=1)
                        self.refresh_token()
                    except OpenFacebookException:
                        LoggingHelper.getErrorLogger().error(u'Error while posting on Facebook (facebook_id : {0}, action {1}, params {2})'.format(self.facebook_id, self.action, self.params), exc_info=1)
                        time.sleep((2 ** n) + (random.randint(0, 1000) / 1000))
        except UserSocialAuth.DoesNotExist:
            LoggingHelper.getDebugLogger().debug('No access token')
コード例 #24
0
ファイル: views.py プロジェクト: simplegeo/Django-facebook
def my_style(request):
    context = RequestContext(request)
    
    context['auth_url'] = generate_oauth_url()
    context['facebook'] = fb = get_facebook_graph(request)
    
    return render_to_response('django_facebook/my_style.html', context)
コード例 #25
0
ファイル: tasks.py プロジェクト: dylan-wu/unishared
def facebook_task(user, facebook_id, action, params):
    try:
        user_social = UserSocialAuth.objects.get(user=user,
                                                 provider='facebook')
        access_token = user_social.extra_data['access_token']
        graph = get_facebook_graph(access_token=access_token)
        if graph:
            for n in range(0, 5):
                try:
                    url = None
                    try:
                        if u'class' in params:
                            url = params[u'class']
                        elif u'link' in params:
                            url = params[u'link']
                        if url:
                            graph.set(u'/', {'ids': url, 'scrape': 'true'})
                    except OAuthException:
                        LoggingHelper.getDebugLogger().debug(
                            u'Error while scraping {0}'.format(url),
                            exc_info=1)
                    return graph.set(u'{0}/{1}'.format(facebook_id, action),
                                     params)
                except PermissionException:
                    LoggingHelper.getDebugLogger().debug(
                        u'Permission not granted (facebook_id : {0}, action {1}, params {2})'
                        .format(facebook_id, action, params),
                        exc_info=1)
                except OAuthException:
                    LoggingHelper.getDebugLogger().debug(
                        u'Refreshing token (facebook_id : {0}, action {1}, params {2})'
                        .format(facebook_id, action, params),
                        exc_info=1)
                    try:
                        user_social.refresh_token()
                    except Exception:
                        pass
                except OpenFacebookException:
                    LoggingHelper.getErrorLogger().error(
                        u'Error while posting on Facebook (facebook_id : {0}, action {1}, params {2})'
                        .format(facebook_id, action, params),
                        exc_info=1)
                    time.sleep((2**n) + (random.randint(0, 1000) / 1000))

                    if action in [
                            '{0}:invite_participate'.format(
                                settings.FACEBOOK_OPEN_GRAPH_ROOT_NAME),
                            '{0}:invite_cowrite'.format(
                                settings.FACEBOOK_OPEN_GRAPH_ROOT_NAME)
                    ]:
                        facebook_task.apply_async([
                            user, facebook_id, '{0}:{1}'.format(
                                settings.FACEBOOK_OPEN_GRAPH_ROOT_NAME,
                                'cowrite'), params
                        ])
                        break

    except UserSocialAuth.DoesNotExist:
        LoggingHelper.getDebugLogger().debug('No access token')
コード例 #26
0
ファイル: connect.py プロジェクト: Fandekasp/Django-facebook
def connect_user(request, access_token=None, facebook_graph=None):
    """
    Given a request either

    - (if authenticated) connect the user
    - login
    - register
    """
    user = None
    graph = facebook_graph or get_facebook_graph(request, access_token)
    facebook = FacebookUserConverter(graph)

    assert facebook.is_authenticated()
    facebook_data = facebook.facebook_profile_data()
    force_registration = request.REQUEST.get("force_registration") or request.REQUEST.get("force_registration_hard")

    logger.debug("force registration is set to %s", force_registration)
    if request.user.is_authenticated() and not force_registration:
        action = CONNECT_ACTIONS.CONNECT
        user = _connect_user(request, facebook)
    else:
        email = facebook_data.get("email", False)
        email_verified = facebook_data.get("verified", False)
        kwargs = {}
        if email and email_verified:
            kwargs = {"facebook_email": email}
        auth_user = authenticate(facebook_id=facebook_data["id"], **kwargs)
        if auth_user and not force_registration:
            action = CONNECT_ACTIONS.LOGIN

            # Has the user registered without Facebook, using the verified FB
            # email address?
            # It is after all quite common to use email addresses for usernames
            if not auth_user.get_profile().facebook_id:
                update = True
            else:
                update = getattr(auth_user, "fb_update_required", False)
            user = _login_user(request, facebook, auth_user, update=update)
        else:
            action = CONNECT_ACTIONS.REGISTER
            user = _register_user(request, facebook)

    # store likes and friends if configured
    sid = transaction.savepoint()
    try:
        if facebook_settings.FACEBOOK_STORE_LIKES:
            likes = facebook.get_likes()
            facebook.store_likes(user, likes)
        if facebook_settings.FACEBOOK_STORE_FRIENDS:
            friends = facebook.get_friends()
            facebook.store_friends(user, friends)
        transaction.savepoint_commit(sid)
    except IntegrityError, e:
        logger.warn(
            u"Integrity error encountered during registration, " "probably a double submission %s" % e,
            exc_info=sys.exc_info(),
            extra={"request": request, "data": {"body": unicode(e)}},
        )
        transaction.savepoint_rollback(sid)
コード例 #27
0
ファイル: connect.py プロジェクト: mfelsche/Django-facebook
def connect_user(request, access_token=None, facebook_graph=None):
    '''
    Given a request either

    - (if authenticated) connect the user
    - login
    - register
    '''
    user = None
    graph = facebook_graph or get_facebook_graph(request, access_token)

    converter = get_instance_for('user_conversion', graph)

    assert converter.is_authenticated()
    facebook_data = converter.facebook_profile_data()
    force_registration = request.REQUEST.get('force_registration') or\
        request.REQUEST.get('force_registration_hard')

    connect_facebook = to_bool(request.REQUEST.get('connect_facebook'))

    logger.debug('force registration is set to %s', force_registration)
    if connect_facebook and request.user.is_authenticated() and not force_registration:
        # we should only allow connect if users indicate they really want to connect
        # only when the request.CONNECT_FACEBOOK = 1
        # if this isn't present we just do a login
        action = CONNECT_ACTIONS.CONNECT
        user = _connect_user(request, converter)
    else:
        email = facebook_data.get('email', False)
        email_verified = facebook_data.get('verified', False)
        kwargs = {}
        if email and email_verified:
            kwargs = {'facebook_email': email}
        auth_user = authenticate(facebook_id=facebook_data['id'], **kwargs)
        if auth_user and not force_registration:
            action = CONNECT_ACTIONS.LOGIN

            # Has the user registered without Facebook, using the verified FB
            # email address?
            # It is after all quite common to use email addresses for usernames
            update = getattr(auth_user, 'fb_update_required', False)
            if not auth_user.get_profile().facebook_id:
                update = True
            # login the user
            user = _login_user(request, converter, auth_user, update=update)
        else:
            action = CONNECT_ACTIONS.REGISTER
            # when force registration is active we should remove the old profile
            try:
                user = _register_user(request, converter,
                                      remove_old_connections=force_registration)
            except facebook_exceptions.AlreadyRegistered, e:
                # in Multithreaded environments it's possible someone beats us to
                # the punch, in that case just login
                logger.info('parallel register encountered, slower thread is doing a login')
                auth_user = authenticate(
                    facebook_id=facebook_data['id'], **kwargs)
                action = CONNECT_ACTIONS.LOGIN
                user = _login_user(request, converter, auth_user, update=False)
コード例 #28
0
ファイル: connect.py プロジェクト: NahimNasser/Creeply
def connect_user(request, access_token=None, facebook_graph=None):
    '''
    Given a request either

    - (if authenticated) connect the user
    - login
    - register
    '''
    user = None
    graph = facebook_graph or get_facebook_graph(request, access_token)
    facebook = FacebookUserConverter(graph)

    assert facebook.is_authenticated()
    facebook_data = facebook.facebook_profile_data()
    force_registration = request.REQUEST.get('force_registration') or\
        request.REQUEST.get('force_registration_hard')

    connect_facebook = bool(int(request.REQUEST.get('connect_facebook', 0)))

    logger.debug('force registration is set to %s', force_registration)
    if connect_facebook and request.user.is_authenticated(
    ) and not force_registration:
        #we should only allow connect if users indicate they really want to connect
        #only when the request.CONNECT_FACEBOOK = 1
        #if this isn't present we just do a login
        action = CONNECT_ACTIONS.CONNECT
        user = _connect_user(request, facebook)
    else:
        email = facebook_data.get('email', False)
        email_verified = facebook_data.get('verified', False)
        kwargs = {}
        if email and email_verified:
            kwargs = {'facebook_email': email}
        auth_user = authenticate(facebook_id=facebook_data['id'], **kwargs)
        if auth_user and not force_registration:
            action = CONNECT_ACTIONS.LOGIN

            # Has the user registered without Facebook, using the verified FB
            # email address?
            # It is after all quite common to use email addresses for usernames
            if not auth_user.get_profile().facebook_id:
                update = True
            else:
                update = getattr(auth_user, 'fb_update_required', False)
            user = _login_user(request, facebook, auth_user, update=update)
        else:
            action = CONNECT_ACTIONS.REGISTER
            # when force registration is active we should clearout
            # the old profile
            user = _register_user(request,
                                  facebook,
                                  remove_old_connections=force_registration)

    _update_likes_and_friends(request, user, facebook)

    _update_access_token(user, graph)

    return action, user
コード例 #29
0
ファイル: connect.py プロジェクト: ESBerkeley/CalClassified
def connect_user(request, access_token=None, facebook_graph=None):
    '''
    Given a request either

    - (if authenticated) connect the user
    - login
    - register
    '''
    user = None
    graph = facebook_graph or get_facebook_graph(request, access_token)
    facebook = FacebookUserConverter(graph)

    assert facebook.is_authenticated()
    facebook_data = facebook.facebook_profile_data()
    force_registration = request.REQUEST.get('force_registration') or\
        request.REQUEST.get('force_registration_hard')

    connect_facebook = to_bool(request.REQUEST.get('connect_facebook'))

    logger.debug('force registration is set to %s', force_registration)
    if connect_facebook and request.user.is_authenticated() and not force_registration:
        #we should only allow connect if users indicate they really want to connect
        #only when the request.CONNECT_FACEBOOK = 1
        #if this isn't present we just do a login
        action = CONNECT_ACTIONS.CONNECT
        user = _connect_user(request, facebook)
    else:
        email = facebook_data.get('email', False)
        email_verified = facebook_data.get('verified', False)
        kwargs = {}
        if email and email_verified:
            kwargs = {'facebook_email': email}
        auth_user = authenticate(facebook_id=facebook_data['id'], **kwargs)
        if auth_user and not force_registration:
            action = CONNECT_ACTIONS.LOGIN

            # Has the user registered without Facebook, using the verified FB
            # email address?
            # It is after all quite common to use email addresses for usernames
            update = getattr(auth_user, 'fb_update_required', False)
            if not auth_user.get_profile().facebook_id:
                update = True
            #login the user
            user = _login_user(request, facebook, auth_user, update=update)
        else:
            action = CONNECT_ACTIONS.REGISTER
            # when force registration is active we should remove the old profile
            try:
                user = _register_user(request, facebook,
                                      remove_old_connections=force_registration)
            except facebook_exceptions.AlreadyRegistered, e:
                #in Multithreaded environments it's possible someone beats us to
                #the punch, in that case just login
                logger.info('parallel register encountered, slower thread is doing a login')
                auth_user = authenticate(
                    facebook_id=facebook_data['id'], **kwargs)
                action = CONNECT_ACTIONS.LOGIN
                user = _login_user(request, facebook, auth_user, update=False)
コード例 #30
0
ファイル: tests.py プロジェクト: binichda/Django-facebook
 def test_registration_form(self):
     '''
     Django_facebook should use user supplied registration form if given
     '''
     facebook_settings.FACEBOOK_REGISTRATION_FORM = 'django_facebook.test_utils.forms.SignupForm'
     facebook = get_facebook_graph(access_token='short_username')
     action, user = connect_user(self.request, facebook_graph=facebook)
     # The test form always sets username to test form
     self.assertEqual(user.username, 'Test form')
コード例 #31
0
ファイル: tests.py プロジェクト: duduklein/django-facebook
    def test_persistent_graph(self):
        request = RequestMock().get('/')
        request.session = {}
        request.user = AnonymousUser()

        graph = get_facebook_graph(access_token='short_username')
        FacebookUserConverter(graph)
        action, user = connect_user(self.request, facebook_graph=graph)
        self.assertEqual(action, CONNECT_ACTIONS.REGISTER)
コード例 #32
0
ファイル: connect.py プロジェクト: ducolares/Django-facebook
def connect_user(request, access_token=None, facebook_graph=None):
    '''
    Given a request either

    - (if authenticated) connect the user
    - login
    - register
    '''
    user = None
    graph = facebook_graph or get_facebook_graph(request, access_token)
    facebook = FacebookUserConverter(graph)

    assert facebook.is_authenticated()
    facebook_data = facebook.facebook_profile_data()
    force_registration = request.REQUEST.get('force_registration') or\
        request.REQUEST.get('force_registration_hard')
        
    connect_facebook = bool(int(request.REQUEST.get('connect_facebook', 0)))

    logger.debug('force registration is set to %s', force_registration)
    if connect_facebook and request.user.is_authenticated() and not force_registration:
        #we should only allow connect if users indicate they really want to connect
        #only when the request.CONNECT_FACEBOOK = 1
        #if this isn't present we just do a login   
        action = CONNECT_ACTIONS.CONNECT
        user = _connect_user(request, facebook)
    else:
        email = facebook_data.get('email', False)
        email_verified = facebook_data.get('verified', False)
        kwargs = {}
        if email and email_verified:
            kwargs = {'facebook_email': email}
        auth_user = authenticate(facebook_id=facebook_data['id'], **kwargs)
        if auth_user and not force_registration:
            action = CONNECT_ACTIONS.LOGIN
            

            # Has the user registered without Facebook, using the verified FB
            # email address?
            # It is after all quite common to use email addresses for usernames
            if not auth_user.get_profile().facebook_id:
                update = True
            else:
                update = getattr(auth_user, 'fb_update_required', False)
            user = _login_user(request, facebook, auth_user, update=update)
        else:
            action = CONNECT_ACTIONS.REGISTER
            # when force registration is active we should clearout
            # the old profile
            user = _register_user(request, facebook,
                                  remove_old_connections=force_registration)
            
    _update_likes_and_friends(request, user, facebook)

    _update_access_token(user, graph)
    
    return action, user
コード例 #33
0
    def test_persistent_graph(self):
        request = RequestMock().get('/')
        request.session = {}
        request.user = AnonymousUser()

        graph = get_facebook_graph(access_token='short_username')
        FacebookUserConverter(graph)
        action, user = connect_user(self.request, facebook_graph=graph)
        self.assertEqual(action, CONNECT_ACTIONS.REGISTER)
コード例 #34
0
ファイル: views.py プロジェクト: dany431/cityfusion
def refresh_facebook_graph(request):
    request.facebook, success = None, False
    access_token = request.POST.get('access_token', None)
    graph = get_facebook_graph(request, access_token=access_token)
    if graph is not None and graph.access_token:
        request.session['graph_dict'] = graph.__getstate__()
        success = True

    return HttpResponse(json.dumps({'success': success}), mimetype='application/json')
コード例 #35
0
ファイル: test.py プロジェクト: WoLpH/Django-facebook
 def test_photo_put(self):
     from django_facebook.api import get_app_access_token
     token = get_app_access_token()
     graph = get_facebook_graph(access_token=token, persistent_token=False)
     tags = simplejson.dumps([{'x':50, 'y':50, 'tag_uid':12345}, {'x':10, 'y':60, 'tag_text':'a turtle'}])
     try:
         graph.put_photo('img.jpg', 'Look at this cool photo!', None, tags=tags)
     except GraphAPIError, e:
         assert 'An active access token must be used to query information' in unicode(e)
コード例 #36
0
 def test_registration_form(self):
     '''
     Django_facebook should use user supplied registration form if given
     '''
     facebook_settings.FACEBOOK_REGISTRATION_FORM = 'django_facebook.tests_utils.forms.SignupForm'
     facebook = get_facebook_graph(access_token='short_username')
     action, user = connect_user(self.request, facebook_graph=facebook)
     # The test form always sets username to test form
     self.assertEqual(user.username, 'Test form')
コード例 #37
0
def connect(request):
    '''
    Handles the view logic around connect user
    - (if authenticated) connect the user
    - login
    - register
    '''
    #test code time to remove
    uri = 'http://%s%s?facebook_login=1' % (request.META['HTTP_HOST'],
            request.path)
    if request.GET.get('redirect'):
        return facebook_login_required(uri, scope='read_stream')
    context = RequestContext(request)

    assert context.get('FACEBOOK_APP_ID'), 'Please specify a facebook app id '\
        'and ensure the context processor is enabled'
    facebook_login = bool(int(request.REQUEST.get('facebook_login', 0)))

    if facebook_login:
        graph = get_facebook_graph(request)
        if graph:
            facebook = FacebookUserConverter(graph)
            if facebook.is_authenticated():
                facebook_data = facebook.facebook_profile_data()
                #either, login register or connect the user
                try:
                    action, user = connect_user(request)
                except facebook_exceptions.IncompleteProfileError, e:
                    warn_message = u'Incomplete profile data encountered '\
                        'with error %s' % e
                    logger.warn(warn_message,
                        exc_info=sys.exc_info(), extra={
                        'request': request,
                        'data': {
                             'username': request.user.username,
                             'facebook_data': facebook.facebook_profile_data(),
                             'body': unicode(e),
                         }
                    })

                    context['facebook_mode'] = True
                    context['form'] = e.form
                    return render_to_response(
                        'registration/registration_form.html',
                        context_instance=context,
                    )

                if action is CONNECT_ACTIONS.CONNECT:
                    messages.info(request, _("You have connected your account "
                        "to %s's facebook profile") % facebook_data['name'])
                elif action is CONNECT_ACTIONS.REGISTER:
                    return user.get_profile().post_facebook_registration(request)
        else:
            return next_redirect(request, next_key=['error_next', 'next'],
                additional_params=dict(fb_error_or_cancel=1))

        return next_redirect(request)
コード例 #38
0
ファイル: views.py プロジェクト: smjenning/Django-facebook
def connect(request):
    '''
    Handles the view logic around connect user
    - (if authenticated) connect the user
    - login
    - register
    
    '''
    context = RequestContext(request)

    assert context.get(
        'FACEBOOK_APP_ID'
    ), 'Please specify a facebook app id and ensure the context processor is enabled'
    facebook_login = bool(int(request.REQUEST.get('facebook_login', 0)))

    if facebook_login:
        facebook = get_facebook_graph(request)
        if facebook.is_authenticated():
            facebook_data = facebook.facebook_profile_data()
            #either, login register or connect the user
            try:
                action, user = connect_user(request)
            except facebook_exceptions.IncompleteProfileError, e:
                logger.error(unicode(e),
                             exc_info=sys.exc_info(),
                             extra={
                                 'request': request,
                                 'data': {
                                     'username':
                                     request.user.username,
                                     'facebook_data':
                                     facebook.facebook_profile_data(),
                                     'body':
                                     unicode(e),
                                 }
                             })

                context['facebook_mode'] = True
                context['form'] = e.form
                return render_to_response(
                    'registration/registration_form.html', context)

            if action is CONNECT_ACTIONS.CONNECT:
                messages.info(
                    request,
                    _("You have connected your account to %s's facebook profile"
                      ) % facebook_data['name'])
            elif action is CONNECT_ACTIONS.REGISTER:
                response = user.get_profile().post_facebook_registration()
                return response
        else:
            return next_redirect(request,
                                 additional_params=dict(fb_error_or_cancel=1),
                                 next_key=['error_next', 'next'])

        return next_redirect(request)
コード例 #39
0
 def create(self, request, **kwargs):
     user = None
     access_token = request.DATA.get('access_token', None)
     graph = get_facebook_graph(request, access_token)
     facebook = FacebookUserConverter(graph)
     try:
         assert facebook.is_authenticated()
     except OAuthException, ex:
         return Response({"error": ex.message},
                         status=status.HTTP_401_UNAUTHORIZED)
コード例 #40
0
ファイル: test.py プロジェクト: WoLpH/Django-facebook
 def test_full_connect(self):
     #going for a register, connect and login
     facebook = get_facebook_graph(access_token='short_username', persistent_token=False)
     action, user = connect_user(self.request, facebook_graph=facebook)
     assert action == CONNECT_ACTIONS.REGISTER
     action, user = connect_user(self.request, facebook_graph=facebook)
     assert action == CONNECT_ACTIONS.CONNECT
     self.request.user = AnonymousUser()
     action, user = connect_user(self.request, facebook_graph=facebook)
     assert action == CONNECT_ACTIONS.LOGIN
コード例 #41
0
ファイル: views.py プロジェクト: dany431/cityfusion
def refresh_facebook_graph(request):
    request.facebook, success = None, False
    access_token = request.POST.get('access_token', None)
    graph = get_facebook_graph(request, access_token=access_token)
    if graph is not None and graph.access_token:
        request.session['graph_dict'] = graph.__getstate__()
        success = True

    return HttpResponse(json.dumps({'success': success}),
                        mimetype='application/json')
コード例 #42
0
ファイル: tests.py プロジェクト: MechanisM/Django-facebook
 def test_full_connect(self):
     #going for a register, connect and login
     graph = get_facebook_graph(access_token='short_username')
     FacebookUserConverter(graph)
     action, user = connect_user(self.request, facebook_graph=graph)
     self.assertEqual(action, CONNECT_ACTIONS.REGISTER)
     action, user = connect_user(self.request, facebook_graph=graph)
     self.assertEqual(action, CONNECT_ACTIONS.CONNECT)
     self.request.user = AnonymousUser()
     action, user = connect_user(self.request, facebook_graph=graph)
     self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
コード例 #43
0
def canvas(request):
    context = RequestContext(request)

    context['auth_url'] = generate_oauth_url()
    context['facebook'] = fb = get_facebook_graph(request)

    if fb.is_authenticated():
        likes = context['facebook'].get_connections("me", "likes", limit=3)
        logger.info('found these likes %s', likes)

    return render_to_response('django_facebook/canvas.html', context)
コード例 #44
0
ファイル: views.py プロジェクト: simplegeo/Django-facebook
def canvas(request):
    context = RequestContext(request)
    
    context['auth_url'] = generate_oauth_url()
    context['facebook'] = fb = get_facebook_graph(request)
    
    if fb.is_authenticated():
        likes = context['facebook'].get_connections("me", "likes", limit=3)
        logger.info('found these likes %s', likes)
    
    return render_to_response('django_facebook/canvas.html', context)
コード例 #45
0
 def test_full_connect(self):
     #going for a register, connect and login
     graph = get_facebook_graph(access_token='short_username')
     FacebookUserConverter(graph)
     action, user = connect_user(self.request, facebook_graph=graph)
     self.assertEqual(action, CONNECT_ACTIONS.REGISTER)
     action, user = connect_user(self.request, facebook_graph=graph)
     self.assertEqual(action, CONNECT_ACTIONS.CONNECT)
     self.request.user = AnonymousUser()
     action, user = connect_user(self.request, facebook_graph=graph)
     self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
コード例 #46
0
ファイル: views.py プロジェクト: NahimNasser/Creeply
def fblogin(request):
        # we store the place to redirct to in state

        graph = get_facebook_graph(request, redirect_uri=settings.FACEBOOOK_REDIRECT_URI)
        action, user = connect_user(request, facebook_graph=graph)
        user.save()
        LinkedInProfile.objects.get_or_create(user=user)
        graph = get_facebook_graph(access_token=user.get_profile().access_token)
        graph_data = graph.get('/me')
        t = loader.get_template("profile.html")
        liApi = linkedin.LinkedIn('d4sg4uq23heb', 'CECqmTcwYr9GZod5', 'http://creeply.dev:8000/linkedin/login')
        result = liApi.request_token()
        if result:
            graph_data['liUrl'] = liApi.get_authorize_url()
            user.liProfile.request_token = liApi._request_token
            user.liProfile.request_token_secret = liApi._request_token_secret
            user.liProfile.save()
        graph_data['img'] = 'https://graph.facebook.com/%s/picture?type=large' % user.get_profile().facebook_id
        c = Context(graph_data)
        return HttpResponse(t.render(c))
コード例 #47
0
def test_graphapi(request):
    graph = get_facebook_graph(request)
    friends = graph.get("/me/friends")
    friends = friends['data']
    flikes = {}
    i = 0
    for fr in friends:
        fr_id = str(fr['id'])
        t = Thread(target=myfunc, args=((fr_id, graph, i), ))
        t.start()
        i += 1
    return HttpResponse("Done")
コード例 #48
0
ファイル: testcode.py プロジェクト: amit-sharma/popcore
def test_graphapi(request):
    graph = get_facebook_graph(request)
    friends = graph.get("/me/friends")
    friends = friends['data']
    flikes = {}
    i=0
    for fr in friends:
        fr_id = str(fr['id'])
        t = Thread(target=myfunc, args=((fr_id,graph,i),))
        t.start()
        i += 1
    return HttpResponse("Done")
コード例 #49
0
ファイル: utils.py プロジェクト: Chodex/djangodash2013
def get_friends_pics(request):
    from core.tasks import make_mosaic

    Mosaic.objects.filter(user=request.user).delete()
    open_graph = get_facebook_graph(request)
    converter = FacebookUserConverter(open_graph)
    pics_raw = converter.open_facebook.fql(
        u"SELECT pic FROM user WHERE uid IN (SELECT uid2 FROM friend WHERE uid1 = me())"
    )
    pics = [x["pic"] for x in pics_raw]
    make_mosaic.apply_async(kwargs=dict(user=request.user, pics_urls=pics))
    return
コード例 #50
0
ファイル: realtime.py プロジェクト: amit-sharma/popcore
def setupFBUpdates(request):
    graph = get_facebook_graph(request)
    #get app's access token
    access_token = FacebookAuthorization.get_app_access_token()    
    params = {'access_token': access_token}
    postdata = {'object': 'user', 'fields': "friends,music,books,movies,tv,likes", 'callback_url':"http://www.popcore.me/realtime/receive_fb_updates", 'verify_token':VERIFY_TOKEN }
    url = '%s%s?%s' % ("https://graph.facebook.com/", FACEBOOK_APP_ID + "/subscriptions", urllib.urlencode(params))
    res= graph._request(url, post_data=postdata)
    #now check the new update configuration
   
    #import pprint
    response = graph._request(url)
    return HttpResponse(pprint.pformat(response))
コード例 #51
0
def fblogin(request):
    # we store the place to redirct to in state

    graph = get_facebook_graph(request,
                               redirect_uri=settings.FACEBOOOK_REDIRECT_URI)
    action, user = connect_user(request, facebook_graph=graph)
    user.save()
    LinkedInProfile.objects.get_or_create(user=user)
    graph = get_facebook_graph(access_token=user.get_profile().access_token)
    graph_data = graph.get('/me')
    t = loader.get_template("profile.html")
    liApi = linkedin.LinkedIn('d4sg4uq23heb', 'CECqmTcwYr9GZod5',
                              'http://creeply.dev:8000/linkedin/login')
    result = liApi.request_token()
    if result:
        graph_data['liUrl'] = liApi.get_authorize_url()
        user.liProfile.request_token = liApi._request_token
        user.liProfile.request_token_secret = liApi._request_token_secret
        user.liProfile.save()
    graph_data[
        'img'] = 'https://graph.facebook.com/%s/picture?type=large' % user.get_profile(
        ).facebook_id
    c = Context(graph_data)
    return HttpResponse(t.render(c))
コード例 #52
0
def ranking(request):
    if (not request.user.pk is None
        ) and request.user.userprofile.terms_conditions:
        context = RequestContext(request)

        # Get the graph from the FB API
        if not 'friends' in request.session:
            graph = get_facebook_graph(request=request)

            friends = graph.get('me/friends', fields='')['data']
            friends = [f['name'] for f in friends]
            request.session['friends'] = friends

        friends = request.session['friends']

        # Load users ordered by global score
        user_list = UserProfile.objects.exclude(
            pk=-1).order_by('-score_global')

        count = 0
        rank = -1
        for u in user_list:
            count += 1
            if u.user.id == request.user.id:
                rank = count
                break

        user_list = user_list[:50]
        user_rank = rank if rank > 50 else -1

        friends_user_list = UserProfile.objects.filter(
            user__facebookprofile__facebook_name__in=friends)
        friends_user_list = friends_user_list | UserProfile.objects.filter(
            user=request.user)
        friends_user_list = friends_user_list.order_by('-score_global')

        context_dict = {
            'users': user_list,
            'user': request.user,
            'rank': user_rank,
            'friends': friends_user_list
        }

        return render_to_response('ranking.html',
                                  context_dict,
                                  context_instance=context)
    else:
        return HttpResponseRedirect('/canvas/terms/')
コード例 #53
0
 def test_auth_backend(self):
     backend = FacebookBackend()
     facebook = get_facebook_graph(access_token='new_user')
     action, user = connect_user(self.request, facebook_graph=facebook)
     facebook_email = user.email
     facebook_id = user.get_profile().facebook_id
     auth_user = backend.authenticate(facebook_email=facebook_email)
     assert auth_user == user
     
     auth_user = backend.authenticate(facebook_id=facebook_id)
     assert auth_user == user
     
     auth_user = backend.authenticate(facebook_id=facebook_id, facebook_email=facebook_email)
     assert auth_user == user
     
     auth_user = backend.authenticate()
     assert not auth_user
コード例 #54
0
    def test_fb_update_required(self):
        def pre_update(sender, profile, facebook_data, **kwargs):
            profile.pre_update_signal = True

        Profile = get_profile_class()
        signals.facebook_pre_update.connect(pre_update, sender=Profile)
        facebook = get_facebook_graph(access_token='tschellenbach')

        facebook_settings.FACEBOOK_FORCE_PROFILE_UPDATE_ON_LOGIN = True
        action, user = connect_user(self.request, facebook_graph=facebook)
        self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
        self.assertTrue(hasattr(user.get_profile(), 'pre_update_signal'))

        facebook_settings.FACEBOOK_FORCE_PROFILE_UPDATE_ON_LOGIN = False
        action, user = connect_user(self.request, facebook_graph=facebook)
        self.assertEqual(action, CONNECT_ACTIONS.LOGIN)
        self.assertFalse(hasattr(user.get_profile(), 'pre_update_signal'))
コード例 #55
0
    def test_registration_form(self):
        '''
        Django_facebook should use user supplied registration form if given
        '''
        from django.conf import settings
        if settings.MODE == 'userena':
            return

        test_form = 'django_facebook.test_utils.forms.SignupForm'
        old_setting = facebook_settings.FACEBOOK_REGISTRATION_FORM
        facebook_settings.FACEBOOK_REGISTRATION_FORM = test_form
        try:
            facebook = get_facebook_graph(access_token='short_username')
            action, user = connect_user(self.request, facebook_graph=facebook)
            # The test form always sets username to test form
            self.assertEqual(user.username, 'Test form')
        finally:
            facebook_settings.FACEBOOK_REGISTRATION_FORM = old_setting