Python connect.connect函数代码示例

 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)

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')

    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')

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')

    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')

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')

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')

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')

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')

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')

    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')

        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')

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')

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')

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')