Python connect Examples

Example #1

File: tests.py Project: simkaur00/django-socialregistration-with-google-apps

 def test_connecting_should_send_the_connect_signal(self):
     counter = self.get_counter()
     
     user = self.create_user()
     self.login()
     
     def handler(sender, **kwargs):
         counter.counter += 1
         self.assertEqual(self.profile, sender)
     
     connect.connect(handler, sender=self.profile, dispatch_uid='socialreg.test.connect')
     
     self.flow()
     
     self.assertEqual(1, counter.counter)

Example #2

File: models.py Project: SimpleTax/django-social-registration

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.foursquare)
        except User.DoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(foursquare=self.foursquare)


class FoursquareAccessToken(models.Model):
    profile = models.OneToOneField(FoursquareProfile,
                                   related_name='access_token')
    access_token = models.CharField(max_length=255)


def save_foursquare_token(sender, user, profile, client, **kwargs):
    try:
        FoursquareAccessToken.objects.get(profile=profile).delete()
    except FoursquareAccessToken.DoesNotExist:
        pass

    FoursquareAccessToken.objects.create(
        access_token=client.get_access_token(), profile=profile)


connect.connect(save_foursquare_token,
                sender=FoursquareProfile,
                dispatch_uid='socialregistration_foursquare_token')

Example #3

File: models.py Project: cpinto/django-socialregistration

class SapoRequestToken(models.Model):
    profile = models.OneToOneField(SapoProfile, related_name='request_token')
    oauth_token = models.CharField(max_length=512)
    oauth_token_secret = models.CharField(max_length=80)

class SapoAccessToken(models.Model):
    profile = models.OneToOneField(SapoProfile, related_name='access_token')
    oauth_token = models.CharField(max_length=512)
    oauth_token_secret = models.CharField(max_length=80)

def save_sapo_token(sender, user, profile, client, **kwargs):
    try:
        SapoRequestToken.objects.get(profile=profile).delete()
    except SapoRequestToken.DoesNotExist:
        pass
    try:
        SapoAccessToken.objects.get(profile=profile).delete()
    except SapoAccessToken.DoesNotExist:
        pass
    
    SapoRequestToken.objects.create(profile=profile,
        oauth_token=client.get_request_token().key,
        oauth_token_secret=client.get_request_token().secret)
    
    SapoAccessToken.objects.create(profile=profile,
        oauth_token=client.get_access_token().key,
        oauth_token_secret=client.get_access_token().secret)

connect.connect(save_sapo_token, sender=SapoProfile,
    dispatch_uid='socialregistration_sapo_token')

Example #4

File: models.py Project: kippt/django-socialregistration

class GoogleProfile(models.Model):
    user = models.ForeignKey(User, unique=True)
    site = models.ForeignKey(Site, default=Site.objects.get_current)
    google_id = models.CharField(max_length = 255)

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.google_id)
        except User.DoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(id=self.google_id)

class GoogleAccessToken(models.Model):
    profile = models.OneToOneField(GoogleProfile, related_name='access_token')
    access_token = models.CharField(max_length=255)

def save_google_token(sender, user, profile, client, **kwargs):
    try:
        GoogleAccessToken.objects.get(profile=profile).delete()
    except GoogleAccessToken.DoesNotExist:
        pass
    
    GoogleAccessToken.objects.create(access_token = client.get_access_token(),
        profile = profile)


connect.connect(save_google_token, sender=GoogleProfile,
    dispatch_uid='socialregistration_google_token')

Example #5

File: models.py Project: SimpleTax/django-social-registration

    github = models.CharField(max_length=255)

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.github)
        except User.DoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(github=self.github)


class GithubAccessToken(models.Model):
    profile = models.OneToOneField(GithubProfile, related_name='access_token')
    access_token = models.CharField(max_length=255)


def save_github_token(sender, user, profile, client, **kwargs):
    try:
        GithubAccessToken.objects.get(profile=profile).delete()
    except GithubAccessToken.DoesNotExist:
        pass

    GithubAccessToken.objects.create(access_token=client.get_access_token(),
                                     profile=profile)


connect.connect(save_github_token,
                sender=GithubProfile,
                dispatch_uid='socialregistration_github_token')

Example #6

File: models.py Project: CheckiO/django-socialregistration

    site = models.ForeignKey(Site, default=Site.objects.get_current)
    uid = models.CharField(max_length=255, blank=False, null=False)

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.uid)
        except models.ObjectDoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(uid=self.uid)

class FacebookAccessToken(models.Model):
    profile = models.OneToOneField(FacebookProfile, related_name='access_token')
    access_token = models.CharField(max_length=255)


def save_facebook_token(sender, user, profile, client, **kwargs):
    try:
        FacebookAccessToken.objects.get(profile=profile).delete()
    except FacebookAccessToken.DoesNotExist:
        pass

    FacebookAccessToken.objects.create(profile=profile,
        access_token=client.graph.access_token)

connect.connect(save_facebook_token, sender=FacebookProfile,
    dispatch_uid='socialregistration.facebook.connect')
login.connect(save_facebook_token, sender = FacebookProfile,
    dispatch_uid = 'socialregistration.facebook.login')

Example #7

File: models.py Project: CheckiO/django-socialregistration

class GithubProfile(models.Model):
    user = models.ForeignKey(AUTH_USER_MODEL, unique=True)
    site = models.ForeignKey(Site, default=Site.objects.get_current)
    github = models.CharField(max_length = 255)

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.github)
        except models.ObjectDoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(github=self.github)

class GithubAccessToken(models.Model):
    profile = models.OneToOneField(GithubProfile, related_name='access_token')
    access_token = models.CharField(max_length=255)

def save_github_token(sender, user, profile, client, **kwargs):
    try:
        GithubAccessToken.objects.get(profile=profile).delete()
    except GithubAccessToken.DoesNotExist:
        pass

    GithubAccessToken.objects.create(access_token = client.get_access_token(),
        profile = profile)


connect.connect(save_github_token, sender=GithubProfile,
    dispatch_uid='socialregistration_github_token')

Example #8

File: models.py Project: simkaur00/django-socialregistration-with-google-apps

            return u'%s: %s' % (self.user, self.uid)
        except models.ObjectDoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(uid=self.uid)


class FacebookAccessToken(models.Model):
    profile = models.OneToOneField(FacebookProfile,
                                   related_name='access_token')
    access_token = models.CharField(max_length=255)


def save_facebook_token(sender, user, profile, client, **kwargs):
    try:
        FacebookAccessToken.objects.get(profile=profile).delete()
    except FacebookAccessToken.DoesNotExist:
        pass

    FacebookAccessToken.objects.create(profile=profile,
                                       access_token=client.graph.access_token)


connect.connect(save_facebook_token,
                sender=FacebookProfile,
                dispatch_uid='socialregistration.facebook.connect')
login.connect(save_facebook_token,
              sender=FacebookProfile,
              dispatch_uid='socialregistration.facebook.login')

Example #9

File: models.py Project: SimpleTax/django-social-registration

class SapoAccessToken(models.Model):
    profile = models.OneToOneField(SapoProfile, related_name='access_token')
    oauth_token = models.CharField(max_length=512)
    oauth_token_secret = models.CharField(max_length=80)


def save_sapo_token(sender, user, profile, client, **kwargs):
    try:
        SapoRequestToken.objects.get(profile=profile).delete()
    except SapoRequestToken.DoesNotExist:
        pass
    try:
        SapoAccessToken.objects.get(profile=profile).delete()
    except SapoAccessToken.DoesNotExist:
        pass

    SapoRequestToken.objects.create(
        profile=profile,
        oauth_token=client.get_request_token().key,
        oauth_token_secret=client.get_request_token().secret)

    SapoAccessToken.objects.create(
        profile=profile,
        oauth_token=client.get_access_token().key,
        oauth_token_secret=client.get_access_token().secret)


connect.connect(save_sapo_token,
                sender=SapoProfile,
                dispatch_uid='socialregistration_sapo_token')

Example #10

class TumblrAccessToken(models.Model):
    profile = models.OneToOneField(TumblrProfile, related_name='access_token')
    oauth_token = models.CharField(max_length=80)
    oauth_token_secret = models.CharField(max_length=80)


def save_tumblr_token(sender, user, profile, client, **kwargs):
    try:
        TumblrRequestToken.objects.get(profile=profile).delete()
    except TumblrRequestToken.DoesNotExist:
        pass
    try:
        TumblrAccessToken.objects.get(profile=profile).delete()
    except TumblrAccessToken.DoesNotExist:
        pass

    TumblrRequestToken.objects.create(
        profile=profile,
        oauth_token=client.get_request_token().key,
        oauth_token_secret=client.get_request_token().secret)

    TumblrAccessToken.objects.create(
        profile=profile,
        oauth_token=client.get_access_token().key,
        oauth_token_secret=client.get_access_token().secret)


connect.connect(save_tumblr_token,
                sender=TumblrProfile,
                dispatch_uid='socialregistration_tumblr_token')

Example #11

    buffer_user = models.CharField(max_length=255)

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.buffer_user)
        except User.DoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(buffer_user=self.buffer_user)


class BufferAccessToken(models.Model):
    profile = models.OneToOneField(BufferProfile, related_name='access_token')
    access_token = models.CharField(max_length=255)


def save_buffer_token(sender, user, profile, client, **kwargs):
    try:
        BufferAccessToken.objects.get(profile=profile).delete()
    except BufferAccessToken.DoesNotExist:
        pass

    BufferAccessToken.objects.create(access_token=client.get_access_token(),
                                     profile=profile)


connect.connect(save_buffer_token,
                sender=BufferProfile,
                dispatch_uid='socialregistration_buffer_token')

Example #12

File: models.py Project: jablko/django-socialregistration

        oauth_token_secret = client.request_token['oauth_token_secret'])
    
    TwitterAccessToken.objects.create(profile=profile,
        oauth_token = client.access_token['oauth_token'],
        oauth_token_secret = client.access_token['oauth_token_secret'])
    
def save_linkedin_token(sender, user, profile, client, **kwargs):
    try:
        LinkedInRequestToken.objects.get(profile=profile).delete()
    except LinkedInRequestToken.DoesNotExist:
        pass
    try:
        LinkedInAccessToken.objects.get(profile=profile).delete()
    except LinkedInAccessToken.DoesNotExist:
        pass
    
    LinkedInRequestToken.objects.create(profile=profile, 
        oauth_token = client.request_token['oauth_token'],
        oauth_token_secret = client.request_token['oauth_token_secret'])
    
    LinkedInAccessToken.objects.create(profile=profile,
        oauth_token = client.access_token['oauth_token'],
        oauth_token_secret = client.access_token['oauth_token_secret'])
    
connect.connect(save_facebook_token, sender = FacebookProfile, 
    dispatch_uid = 'socialregistration_facebook_token')
connect.connect(save_twitter_token, sender = TwitterProfile, 
    dispatch_uid = 'socialregistration_twitter_token')
connect.connect(save_linkedin_token, sender = LinkedInProfile, 
    dispatch_uid = 'socialregistration_linkedin_token')

Example #13

File: models.py Project: systemsoverload/django-socialregistration

class InstagramProfile(models.Model):
    user = models.ForeignKey(AUTH_USER_MODEL, unique=True)
    site = models.ForeignKey(Site, default=get_default_site)
    instagram = models.CharField(max_length = 255)

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.instagram)
        except models.ObjectDoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(instagram=self.instagram)

class InstagramAccessToken(models.Model):
    profile = models.OneToOneField(InstagramProfile, related_name='access_token')
    access_token = models.CharField(max_length=255)

def save_instagram_token(sender, user, profile, client, **kwargs):
    try:
        InstagramAccessToken.objects.get(profile=profile).delete()
    except InstagramAccessToken.DoesNotExist:
        pass

    InstagramAccessToken.objects.create(access_token = client.get_access_token(),
        profile = profile)


connect.connect(save_instagram_token, sender=InstagramProfile,
    dispatch_uid='socialregistration_instagram_token')

Example #14

File: models.py Project: kippt/django-socialregistration

class AppdotnetProfile(models.Model):
    user = models.ForeignKey(User, unique=True)
    site = models.ForeignKey(Site, default=Site.objects.get_current)
    appdotnet_user = models.CharField(max_length = 255)

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.appdotnet_user)
        except User.DoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(buffer_user=self.buffer_user)

class AppdotnetAccessToken(models.Model):
    profile = models.OneToOneField(AppdotnetProfile, related_name='access_token')
    access_token = models.CharField(max_length=255)
    
def save_appdotnet_token(sender, user, profile, client, **kwargs):
    try:
        AppdotnetAccessToken.objects.get(profile=profile).delete()
    except AppdotnetAccessToken.DoesNotExist:
        pass
    
    AppdotnetAccessToken.objects.create(access_token = client.get_access_token(),
        profile = profile)


connect.connect(save_appdotnet_token, sender=AppdotnetProfile,
    dispatch_uid='socialregistration_appdotnet_token')

Example #15

File: models.py Project: simeonk/django-socialregistration

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.appdotnet_user)
        except User.DoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(buffer_user=self.buffer_user)


class AppdotnetAccessToken(models.Model):
    profile = models.OneToOneField(AppdotnetProfile,
                                   related_name='access_token')
    access_token = models.CharField(max_length=255)


def save_appdotnet_token(sender, user, profile, client, **kwargs):
    try:
        AppdotnetAccessToken.objects.get(profile=profile).delete()
    except AppdotnetAccessToken.DoesNotExist:
        pass

    AppdotnetAccessToken.objects.create(access_token=client.get_access_token(),
                                        profile=profile)


connect.connect(save_appdotnet_token,
                sender=AppdotnetProfile,
                dispatch_uid='socialregistration_appdotnet_token')

Example #16

File: models.py Project: MarcusFulbright/kegbot

class UntappdProfile(models.Model):
  user = models.ForeignKey(User, unique=True)
  site = models.ForeignKey(Site, default=Site.objects.get_current)
  untappd = models.CharField(max_length=255)

  def __unicode__(self):
    try:
      return u'%s: %s' % (self.user, self.untappd)
    except User.DoesNotExist:
      return u'None'

  def authenticate(self):
    return authenticate(untappd=self.untappd)

class UntappdAccessToken(models.Model):
  profile = models.OneToOneField(UntappdProfile, related_name='access_token')
  access_token = models.CharField(max_length=255)

def save_untappd_token(sender, user, profile, client, **kwargs):
  try:
    UntappdAccessToken.objects.get(profile=profile).delete()
  except UntappdAccessToken.DoesNotExist:
    pass

  UntappdAccessToken.objects.create(access_token=client.get_access_token(),
      profile=profile)

connect.connect(save_untappd_token, sender=UntappdProfile,
    dispatch_uid='pykeg_connect_untappd_token')

Example #17

File: models.py Project: brodie/django-socialregistration

class FoursquareProfile(models.Model):
    user = models.OneToOneField(AUTH_USER_MODEL)
    site = models.ForeignKey(Site, default=get_default_site)
    foursquare = models.CharField(max_length=255)

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.foursquare)
        except models.ObjectDoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(foursquare=self.foursquare)

class FoursquareAccessToken(models.Model):
    profile = models.OneToOneField(FoursquareProfile, related_name='access_token')
    access_token = models.CharField(max_length=255)

def save_foursquare_token(sender, user, profile, client, **kwargs):
    try:
        FoursquareAccessToken.objects.get(profile=profile).delete()
    except FoursquareAccessToken.DoesNotExist:
        pass

    FoursquareAccessToken.objects.create(access_token=client.get_access_token(),
        profile=profile)


connect.connect(save_foursquare_token, sender=FoursquareProfile,
    dispatch_uid='socialregistration_foursquare_token')

Example #18

File: models.py Project: GeoRemindMe/GeoRemindMe_Platform

    oauth_token = models.CharField(max_length=80)
    oauth_token_secret = models.CharField(max_length=80)

class LinkedInAccessToken(models.Model):
    profile = models.OneToOneField(LinkedInProfile, related_name='access_token')
    oauth_token = models.CharField(max_length=80)
    oauth_token_secret = models.CharField(max_length=80)


def save_linkedin_token(sender, user, profile, client, **kwargs):
    try:
        LinkedInRequestToken.objects.get(profile=profile).delete()
    except LinkedInRequestToken.DoesNotExist:
        pass
    try:
        LinkedInAccessToken.objects.get(profile=profile).delete()
    except LinkedInAccessToken.DoesNotExist:
        pass
    
    LinkedInRequestToken.objects.create(profile=profile,
        oauth_token=client.get_request_token().key,
        oauth_token_secret=client.get_request_token().secret)
    
    LinkedInAccessToken.objects.create(profile=profile,
        oauth_token=client.get_access_token().key,
        oauth_token_secret=client.get_access_token().secret)


connect.connect(save_linkedin_token, sender=LinkedInProfile,
    dispatch_uid='socialregistration_linkedin_token')

Example #19

File: models.py Project: InsiderNine/django-socialregistration

class TwitterRequestToken(models.Model):
    profile = models.OneToOneField(TwitterProfile, related_name='request_token')
    oauth_token = models.CharField(max_length=80)
    oauth_token_secret = models.CharField(max_length=80)

class TwitterAccessToken(models.Model):
    profile = models.OneToOneField(TwitterProfile, related_name='access_token')
    oauth_token = models.CharField(max_length=80)
    oauth_token_secret = models.CharField(max_length=80)
    
def save_twitter_token(sender, user, profile, client, **kwargs):
    try:
        TwitterRequestToken.objects.get(profile=profile).delete()
    except TwitterRequestToken.DoesNotExist:
        pass
    try:
        TwitterAccessToken.objects.get(profile=profile).delete()
    except TwitterAccessToken.DoesNotExist:
        pass
    
    TwitterRequestToken.objects.create(profile=profile,
        oauth_token=client.get_request_token().key,
        oauth_token_secret=client.get_request_token().secret)
    
    TwitterAccessToken.objects.create(profile=profile,
        oauth_token=client.get_access_token().key,
        oauth_token_secret=client.get_access_token().secret)
    
connect.connect(save_twitter_token, sender=TwitterProfile,
    dispatch_uid='socialregistration_twitter_token')

Example #20

File: models.py Project: jaylett/django-socialregistration

def save_linkedin_token(sender, user, profile, client, **kwargs):
    try:
        LinkedInRequestToken.objects.get(profile=profile).delete()
    except LinkedInRequestToken.DoesNotExist:
        pass
    try:
        LinkedInAccessToken.objects.get(profile=profile).delete()
    except LinkedInAccessToken.DoesNotExist:
        pass

    LinkedInRequestToken.objects.create(
        profile=profile,
        oauth_token=client.request_token['oauth_token'],
        oauth_token_secret=client.request_token['oauth_token_secret'])

    LinkedInAccessToken.objects.create(
        profile=profile,
        oauth_token=client.access_token['oauth_token'],
        oauth_token_secret=client.access_token['oauth_token_secret'])


connect.connect(save_facebook_token,
                sender=FacebookProfile,
                dispatch_uid='socialregistration_facebook_token')
connect.connect(save_twitter_token,
                sender=TwitterProfile,
                dispatch_uid='socialregistration_twitter_token')
connect.connect(save_linkedin_token,
                sender=LinkedInProfile,
                dispatch_uid='socialregistration_linkedin_token')

Example #21

File: models.py Project: SimpleTax/django-social-registration

class TwitterAccessToken(models.Model):
    profile = models.OneToOneField(TwitterProfile, related_name='access_token')
    oauth_token = models.CharField(max_length=80)
    oauth_token_secret = models.CharField(max_length=80)


def save_twitter_token(sender, user, profile, client, **kwargs):
    try:
        TwitterRequestToken.objects.get(profile=profile).delete()
    except TwitterRequestToken.DoesNotExist:
        pass
    try:
        TwitterAccessToken.objects.get(profile=profile).delete()
    except TwitterAccessToken.DoesNotExist:
        pass

    TwitterRequestToken.objects.create(
        profile=profile,
        oauth_token=client.get_request_token().key,
        oauth_token_secret=client.get_request_token().secret)

    TwitterAccessToken.objects.create(
        profile=profile,
        oauth_token=client.get_access_token().key,
        oauth_token_secret=client.get_access_token().secret)


connect.connect(save_twitter_token,
                sender=TwitterProfile,
                dispatch_uid='socialregistration_twitter_token')

Example #22

    google_id = models.CharField(max_length=255)

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.google_id)
        except User.DoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(id=self.google_id)


class GoogleAccessToken(models.Model):
    profile = models.OneToOneField(GoogleProfile, related_name='access_token')
    access_token = models.CharField(max_length=255)


def save_google_token(sender, user, profile, client, **kwargs):
    try:
        GoogleAccessToken.objects.get(profile=profile).delete()
    except GoogleAccessToken.DoesNotExist:
        pass

    GoogleAccessToken.objects.create(access_token=client.get_access_token(),
                                     profile=profile)


connect.connect(save_google_token,
                sender=GoogleProfile,
                dispatch_uid='socialregistration_google_token')

Example #23

File: models.py Project: kippt/django-socialregistration

class BufferProfile(models.Model):
    user = models.ForeignKey(User, unique=True)
    site = models.ForeignKey(Site, default=Site.objects.get_current)
    buffer_user = models.CharField(max_length = 255)

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.buffer_user)
        except User.DoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(buffer_user=self.buffer_user)

class BufferAccessToken(models.Model):
    profile = models.OneToOneField(BufferProfile, related_name='access_token')
    access_token = models.CharField(max_length=255)
    
def save_buffer_token(sender, user, profile, client, **kwargs):
    try:
        BufferAccessToken.objects.get(profile=profile).delete()
    except BufferAccessToken.DoesNotExist:
        pass
    
    BufferAccessToken.objects.create(access_token = client.get_access_token(),
        profile = profile)


connect.connect(save_buffer_token, sender=BufferProfile,
    dispatch_uid='socialregistration_buffer_token')

Example #24

    profile = models.OneToOneField(LinkedInProfile,
                                   related_name='access_token')
    oauth_token = models.CharField(max_length=80)
    oauth_token_secret = models.CharField(max_length=80)


def save_linkedin_token(sender, user, profile, client, **kwargs):
    try:
        LinkedInRequestToken.objects.get(profile=profile).delete()
    except LinkedInRequestToken.DoesNotExist:
        pass
    try:
        LinkedInAccessToken.objects.get(profile=profile).delete()
    except LinkedInAccessToken.DoesNotExist:
        pass

    LinkedInRequestToken.objects.create(
        profile=profile,
        oauth_token=client.get_request_token().key,
        oauth_token_secret=client.get_request_token().secret)

    LinkedInAccessToken.objects.create(
        profile=profile,
        oauth_token=client.get_access_token().key,
        oauth_token_secret=client.get_access_token().secret)


connect.connect(save_linkedin_token,
                sender=LinkedInProfile,
                dispatch_uid='socialregistration_linkedin_token')

Example #25

File: models.py Project: hoongun/django-socialregistration

    vk_uid = models.CharField(max_length=255, blank=False, null=False)

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.vk_uid)
        except models.DoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(vk_uid=self.vk_uid)


class VkontakteAccessToken(models.Model):
    profile = models.OneToOneField(VkontakteProfile, related_name='access_token')
    access_token = models.CharField(max_length=255)


def save_vkontakte_token(sender, user, profile, client, **kwargs):
    try:
        VkontakteAccessToken.objects.get(profile=profile).delete()
    except VkontakteAccessToken.DoesNotExist:
        pass

    VkontakteAccessToken.objects.create(profile=profile,
        access_token=client._access_token)

connect.connect(save_vkontakte_token, sender=VkontakteProfile,
    dispatch_uid='socialregistration.vkontakte.connect')
login.connect(save_vkontakte_token, sender=VkontakteProfile,
    dispatch_uid='socialregistration.vkontakte.login')

Example #26

File: models.py Project: brodie/django-socialregistration

class TumblrRequestToken(models.Model):
    profile = models.OneToOneField(TumblrProfile, related_name='request_token')
    oauth_token = models.CharField(max_length=80)
    oauth_token_secret = models.CharField(max_length=80)

class TumblrAccessToken(models.Model):
    profile = models.OneToOneField(TumblrProfile, related_name='access_token')
    oauth_token = models.CharField(max_length=80)
    oauth_token_secret = models.CharField(max_length=80)

def save_tumblr_token(sender, user, profile, client, **kwargs):
    try:
        TumblrRequestToken.objects.get(profile=profile).delete()
    except TumblrRequestToken.DoesNotExist:
        pass
    try:
        TumblrAccessToken.objects.get(profile=profile).delete()
    except TumblrAccessToken.DoesNotExist:
        pass

    TumblrRequestToken.objects.create(profile=profile,
        oauth_token=client.get_request_token().key,
        oauth_token_secret=client.get_request_token().secret)

    TumblrAccessToken.objects.create(profile=profile,
        oauth_token=client.get_access_token().key,
        oauth_token_secret=client.get_access_token().secret)

connect.connect(save_tumblr_token, sender=TumblrProfile,
    dispatch_uid='socialregistration_tumblr_token')

Example #27

File: models.py Project: jimpurbrick/django-socialregistration

    def __unicode__(self):
        try:
            return u'%s: %s' % (self.user, self.instagram)
        except User.DoesNotExist:
            return u'None'

    def authenticate(self):
        return authenticate(instagram=self.instagram)


class InstagramAccessToken(models.Model):
    profile = models.OneToOneField(InstagramProfile,
                                   related_name='access_token')
    access_token = models.CharField(max_length=255)


def save_instagram_token(sender, user, profile, client, **kwargs):
    try:
        InstagramAccessToken.objects.get(profile=profile).delete()
    except InstagramAccessToken.DoesNotExist:
        pass

    InstagramAccessToken.objects.create(access_token=client.get_access_token(),
                                        profile=profile)


connect.connect(save_instagram_token,
                sender=InstagramProfile,
                dispatch_uid='socialregistration_instagram_token')

Example #28

File: _social_registration_userena.py Project: andreyshipilov/wknd_django

    userenaSignup = UserenaSignup.objects.get_or_create(user=user)

    # Create profile for user
    try:
        new_profile = Profile.objects.get(user=user)
    except:
        new_profile = Profile.objects.create(user=user)

    # Set some minimal permissions
    for perm in PERMISSIONS['profile']:
        assign(perm, new_profile.user, new_profile)

    for perm in PERMISSIONS['user']:
        assign(perm, new_profile.user, new_profile.user)

profile_connect.connect(social_connect_callback)






""""""""""""""""""""""""""""""""""""""""""

from socialregistration.signals import connect as profile_connect
from userena.managers import ASSIGNED_PERMISSIONS

@receiver(socialregistration_signals.connect, sender = FacebookProfile, dispatch_uid = 'facebook.connect')
def social_connect_callback(sender, user, profile, client, **kwargs):
    """
    Create a profile for this user after connecting