from social_auth.backends.facebook import FacebookBackend from .models import MyProfile as Profile def user_update(profile_instance, new_username, new_fullname): new_firstname = new_fullname.split()[0] new_lastname = new_fullname.split()[1] if not profile_instance.username: profile_instance.username = slugify(new_username) if not profile_instance.first_name: profile_instance.first_name = new_firstname if not profile_instance.last_name: profile_instance.last_name = new_lastname. profile_instance.save() return True def twitter_user_update(sender, user, response, details, **kwargs): profile_instance, created = Profile.objects.get_or_create(user=user) profile_instance.twitter_username = details['username'] user_update(profile_instance, details['username'], details['fullname']) return True pre_update.connect(twitter_user_update, sender=TwitterBackend) def facebook_user_update(sender, user, response, details, **kwargs): profile_instance, created = Profile.objects.get_or_create(user=user) profile_instance.fb_username = details['username'] user_update(profile_instance, details['username'], details['fullname']) return True pre_update.connect(facebook_user_update, sender=FacebookBackend)
# Define a custom User class to work with django-social-auth from django.db import models class CustomUserManager(models.Manager): def create_user(self, username, email): return self.model._default_manager.create(username=username) class CustomUser(models.Model): username = models.CharField(max_length=128) last_login = models.DateTimeField(blank=True, null=True) objects = CustomUserManager() def is_authenticated(self): return True from social_auth.signals import pre_update from social_auth.backends.facebook import FacebookBackend def facebook_extra_values(sender, user, response, details, **kwargs): return False pre_update.connect(facebook_extra_values, sender=FacebookBackend)
from django.core.files.base import ContentFile try: url = None if sender == FacebookBackend: url = "http://graph.facebook.com/%s/picture?type=large" \ % response["id"] elif sender == google.GoogleOAuth2Backend and "picture" in response: url = response["picture"] elif sender == TwitterBackend: url = response["profile_image_url"] if url: avatar = urlopen(url) photo = Photo(author=user, is_avatar=True) photo.picture.save(slugify(user.username + " social") + '.jpg', ContentFile(avatar.read())) photo.save() except HTTPError: pass result = True return result pre_update.connect(social_extra_values, sender=None)
class Brewer(AbstractUser): """ New in Dj 1.5: https://docs.djangoproject.com/en/dev/topics/auth/#auth-custom-user """ objects = BrewerManager() ### profile #proficiencies = [('newbie', 'First Timer'), # ('novice', 'Novice'), # ('intermediate', 'Intermediate'), # ('expert', 'Expert'), # ('brewmaster', 'Brewmaster'), # ] #bio = models.TextField(null=False, blank=True) #age = models.IntegerField(null=False, blank=True, default=21) birthday = models.DateField(null=True) age = models.IntegerField(null=True) #proficiency = models.CharField(blank=False, null=False, choices=proficiencies, max_length=50) # quasi- permissions show_facebook = models.BooleanField(default=False) show_email = models.BooleanField(default=False) # signal handlers related to this model def _facebook_extra_values(sender, user, response, details, **kwargs): birthday = response.get('birthday') # response.get('birthday') user.birthday = datetime.datetime.strptime(birthday, '%m/%d/%Y') user.age = int( (datetime.datetime.now() - user.birthday).days / 365.2425) user.save() return True pre_update.connect(_facebook_extra_values, sender=FacebookBackend) def _new_user_handler(sender, user, response, details, **kwargs): #user.age = response.get('birthday') return True socialauth_registered.connect(_new_user_handler, sender=None) ### attributes # contributed_cash is the amount of money contributed # outstanding_fees are fees that have not yet been paid or charged against deposit contributed_cash = models.FloatField(null=False, blank=False, default=0.0) outstanding_fees = models.FloatField(null=False, blank=False, default=0.0) ### reverse relationships # equipment contributed # equipment borrowed # vouchers offered & active ### properties def _has_outstanding_fees(self): """ A member can only borrow when they owe no late charges """ if self.outstanding_fees > 0: return True return False has_outstanding_fees = property(_has_outstanding_fees) def _contributed_equipment_value(self): """ Cash value of contributed equipment """ return 44.4 # FIXME contributed_equipment_value = property(_contributed_equipment_value) def _contributed_equipment_and_cash_value(self): """ Cash value of contributed equipment and cash deposits """ return self.contributed_cash + self.contributed_equipment_value deposit = property(_contributed_equipment_and_cash_value) def _sum_of_vouchers(self): """ Cash value of committed vouchers currently outstanding """ return 33.2 # FIXME sum_of_vouchers = property(_sum_of_vouchers) def _accrued_primary_late_charges(self): """ Cash value of late charges accrued against PRIMARY active loans """ return 12 # FIXME accrued_primary_late_charges = property(_accrued_primary_late_charges) def _accrued_secondary_late_charges(self): """ Cash value of late charges accrued against SECONDARY active loans """ return 11 # FIXME accrued_secondary_late_charges = property(_accrued_secondary_late_charges) def _available_deposit(self): ret = self.deposit \ - self.sum_of_vouchers \ - self.accrued_primary_late_charges \ - self.accrued_secondary_late_charges return ret available_deposit = property(_available_deposit) def _active_days_delinquent(self): """" Number of days deliquent on outstanding, active equipment loans """ return 0 # FIXME active_days_delinquent = property(_active_days_delinquent) def _historical_days_delinquent(self): """ Number of days delinquent on all active and inactive equipment loans """ return 0 # FIXME historical_days_delinquent = property(_historical_days_delinquent) def _full_name(self): if self.first_name or self.last_name: return "%s %s" % (self.first_name, self.last_name) return "" full_name = property(_full_name) def __unicode__(self): if self.full_name: return self.full_name return self.username def _username_link(self): return "<a href=\"%s\">%s</a>" % (reverse( 'brewer-profile', args=[str(self.id)]), self.__unicode__()) username_link = property(_username_link) def _profile_link(self): return "<a href=\"%s\">View Profile</a>" % reverse('brewer-profile', args=[str(self.id)]) profile_link = property(_profile_link) def _facebook_uid(self): if not self.show_facebook: return None facebook_uid = None try: facebook_uid = self.social_auth.filter( provider='facebook').get().uid except: pass return facebook_uid facebook_uid = property(_facebook_uid) def _facebook_link(self): fbid = self.facebook_uid if fbid: return """ <a href="https://www.facebook.com/%s" target="_blank">Facebook Brewer</a> """ % fbid return "" facebook_link = property(_facebook_link) def _facebook_link_inline(self): fbid = self.facebook_uid if fbid: return """ [<a href="https://www.facebook.com/%s" target="_blank">FB</a>] """ % fbid return "" facebook_link_inline = property(_facebook_link_inline) def _email_link(self): if self.show_email: return """ <a href="mailto:%s" target="_blank">Email Brewer</a> """ % self.email return "" email_link = property(_email_link) def _email_link_inline(self): if self.show_email: return """ [<a href="mailto:%s" target="_blank">@</a>] """ % self.email return "" email_link_inline = property(_email_link_inline) def _equipment_count(self): return self.equipment_set.filter(contributed=False).count() equipment_count = property(_equipment_count)
continue yield field def inclusive_fields(inmodel, except_fields=[]): ''' Returns a generator that yields the fields that belong to the given model descendant or any of its ancestors ``except_fields`` is a list that allows to skip some fields based on theirs names ''' for field, model in inmodel._meta.get_fields_with_model(): # Field relates to the parent of the model it's on if isinstance(field, OneToOneField): # Passed model if (model is None) and (field.rel.to in inmodel.__bases__): continue # Ancestor model if (model is not None) and (field.rel.to in model.__bases__): continue if field.name in except_fields: continue yield field # Signal Registration import listeners post_save.connect(listeners.add_user_to_registered_group, sender=User) pre_update.connect(listeners.twitter_profile_values, sender=TwitterBackend) pre_update.connect(listeners.linkedin_profile_values, sender=LinkedinBackend)
if network == 'facebook': profile.network_url = response['link'] profile.photo_url = 'https://graph.facebook.com/'+response['id']+'/picture' if network == 'twitter': profile.network_url = 'https://twitter.com/#!/'+response['screen_name'] profile.photo_url = response['profile_image_url'] if not user.email: user.email = details.get('email','') user.save() profile.save() return True pre_update.connect(user_update) #@login_required def update(request, template_name="update.html"): data = {} profile = None if request.user.is_authenticated(): profile = request.user.get_profile() data = { 'email': profile.user.email, 'fullname': profile.fullname, 'bio': profile.bio, 'expect': profile.expect }
value = dateutil.parser.parse(value) except ValueError: pass if value: setattr(user, fieldname, value) # Image username = details['username'] url = 'http://graph.facebook.com/%s/picture' % username tempfile = urlretrieve(url) user.image.save('%s.jpg' % username, File(open(tempfile[0]))) return True pre_update.connect(facebook_extra_values, sender=FacebookBackend) def twitter_extra_values(sender, user, response, details, **kwargs): # Image username = details['username'] url = 'https://api.twitter.com/1/users/profile_image/%s?size=bigger' % username tempfile = urlretrieve(url) user.image.save('%s.jpg' % username, File(open(tempfile[0]))) return True pre_update.connect(twitter_extra_values, sender=TwitterBackend)
UserFriend.objects.get_or_create( user = user, friend = friend) UserFriend.objects.get_or_create( user = friend, friend = user) return True def fix_username(sender, user, response, details, **kwargs): uid = response['id'] username = "******" % (uid, slugify(user.first_name),slugify(user.last_name)) user.username = username[:30] user.save() return True def make_derek_superuser(sender, user, response, details, **kwargs): uid = response.get('id') if uid == "616834": user.is_superuser = True user.is_staff = True user.save() return True # This fires when a user logs in for the first time pre_update.connect(facebook_signed_up, sender=FacebookBackend) pre_update.connect(fix_username, sender=FacebookBackend) pre_update.connect(make_derek_superuser, sender=FacebookBackend)
extra_user.delete() social_user.user = user social_user.save() user = social_user.user if user.secret_key: if user.email_term is None: # test email has not been sent send_test_email(user, request.build_absolute_uri) elif user.email_term < datetime.date.today(): # no repsonse after 7 days user.delete() return {'social_user':None, 'user':None} return {'social_user': social_user, 'user':user} def on_new_user(sender, user, response, details, **kwargs): user.is_active = False user.is_new = True user.first_name = details.get('first_name') user.last_name = details.get('last_name') user.email = details.get('email') return True # necessary user.save() def on_user_change(sender, user, response, details, **kwargs): for so in UserSocialAuth.objects.filter(user=user, provider='twitter'): user.tw = so.provider + so.uid + repr(so.extra_data) for so in UserSocialAuth.objects.filter(user=user, provider='facebook'): user.fb = so.provider + so.uid + repr(so.extra_data) return True # necessary user.save() from social_auth.signals import socialauth_registered, pre_update socialauth_registered.connect(on_new_user) pre_update.connect(on_user_change)
tags = models.TextField(null=True, blank=True) # XXX TODO make this GeoDjango aware location = models.TextField(null=True, blank=True) def get_absolute_url(self): return reverse('instagram-photo', kwargs={ 'username': self.license_info.instagram_username, 'photo_id': self.id }) def instagram_user_init(sender, user, response, details, **kwargs): if InstagramInfo.objects.filter(user=user, end_date__gte=datetime.now()): info = InstagramInfo.objects.filter(user=user).order_by('-end_date')[0] # Partially-filled-out form from before elif InstagramInfo.objects.filter(user=user, start_date=None): info = InstagramInfo.objects.filter(user=user, start_date=None)[0] else: # Create a new instance because their previous one expired info = InstagramInfo(user=user) info.instagram_username = details['username'] info.instagram_id = details['user_id'] info.website = details.get('website', None) info.avatar_url = details['avatar_url'] # Full name stored as first_name by InstagramBackend info.full_name = details['first_name'].strip() or details['username'] info.save() return True pre_update.connect(instagram_user_init, sender=InstagramBackend)
min_balls = models.IntegerField(verbose_name=u'От') max_balls = models.IntegerField(verbose_name=u'До') class UserProfile(models.Model): user = models.OneToOneField(User) avatar = models.CharField(max_length=300) nickname = models.CharField(max_length=100) from social_auth.signals import pre_update from social_auth.backends.contrib.vkontakte import VKontakteOAuth2Backend def facebook_extra_values(sender, user, response, details, **kwargs): user.first_name = response.get('first_name') user.last_name = response.get('last_name') profile,created = UserProfile.objects.get_or_create(user=user) profile.avatar = response.get('photo') profile.nickname = response.get('nickname') profile.save() return True pre_update.connect(facebook_extra_values, sender=VKontakteOAuth2Backend)
def update_profile(sender, user, response, *args, **kwargs): try: profile = user.get_profile() profile.copy_facebook(response) facebook = Graph(user) if 'friends' in settings.MANIFEST_FACEBOOK_SYNC: friends = profile.copy_friends(facebook.get('friends')) if 'likes' in settings.MANIFEST_FACEBOOK_SYNC: likes = profile.copy_likes(facebook.get('likes')) except: pass def register_profile(sender, user, response, *args, **kwargs): try: try: profile = user.get_profile() except: create_user_account(user) profile = user.get_profile() profile.copy_facebook(response) facebook = Graph(user) if settings.MANIFEST_FACEBOOK_FRIENDS: friends = profile.copy_friends(facebook.get('friends')) if settings.MANIFEST_FACEBOOK_LIKES: likes = profile.copy_likes(facebook.get('likes')) except: pass pre_update.connect(update_profile, sender=FacebookBackend) socialauth_registered.connect(register_profile, sender=FacebookBackend)
avatar = response['profile_image_url'] service = "twitter" try: cah_profile = user.get_profile() except: cah_profile = None if cah_profile is None: cah_profile = CAHProfile(user=user, avatar=avatar, service=service) cah_profile.save() else: cah_profile.avatar = avatar cah_profile.service = service cah_profile.save() return True pre_update.connect(associate_profile) class FavoriteItem(models.Model): user = models.ForeignKey(User) content_type = models.ForeignKey(ContentType) object_id = models.PositiveIntegerField() content_object = generic.GenericForeignKey('content_type', 'object_id') def __unicode__(self): return u'Favorited Item'
blank=True, related_name="broadcast_blogparentcategory_deal", null=True) expiry_date = models.DateField(_("expiry_date"), default=datetime_.date.today) objects = BroadcastDealManager() def get_absolute_url(self): return ('view_deal', [self.id]) get_absolute_url = models.permalink(get_absolute_url) class Meta: db_table = "broadcastdeal" User.profile = property(lambda u: UserProfile.objects.get_or_create(user=u)[0]) pre_update.connect(new_users_handler, sender=FacebookBackend) pre_update.connect(new_users_handler, sender=TwitterBackend) pre_update.connect(new_users_handler, sender=GoogleOAuth2Backend) utils.register(GenericWish) utils.register(BroadcastWish) utils.register(BroadcastDeal) def comment_action(sender, comment=None, target=None, **kwargs): if comment.user: if isinstance(comment.content_object, BlogPost): action.send(comment.user, verb=settings.REVIEW_POST_VERB, action_object=comment.content_object, target=comment) Follow.objects.get_or_create(comment.user, comment) actions.follow(comment.user, comment, send_action=False, actor_only=False)
if created: from photos.tasks import fetch_photos_for_flickr_user from flickr.tasks import fetch_contacts_for_flickr_user from flickr.tasks import process_new_flickr_user fetch_photos_for_flickr_user.delay(None, flickr_user.nsid) fetch_contacts_for_flickr_user.delay(flickr_user.nsid) process_new_flickr_user.delay(flickr_user.nsid) else: flickr_user.username = api_user['username']['_content'] flickr_user.iconserver = api_user['iconserver'] flickr_user.iconfarm = api_user['iconfarm'] try: flickr_user.realname = api_user['realname']['_content'] except KeyError: flickr_user.realname = None try: flickr_user.path_alias = api_user['path_alias'] except KeyError: flickr_user.path_alias = None flickr_user.save() return True pre_update.connect(flickr_extra_values, sender=FlickrBackend)
profile.usertype = 1 if profile.added_source == 0: #First time logging in profile.added_source = 3 profile.mota = 1 if not profile.photo: profile.photo = get_facebook_photo(response) profile.save() #username in facebook users... user.username = slugify(user.username) user.save() return True pre_update.connect(facebook_extra_values, sender=FacebookBackend) def twitter_extra_values(sender, user, response, details, **kwargs): """ """ model = get_profile_model() profile,new = model._default_manager.get_or_create(user=user) if not profile.photo: profile.photo = get_twitter_photo(response) profile.twitter_id = response.get('screen_name','') if profile.usertype == 0: profile.usertype = 1 if profile.added_source == 0: profile.added_source = 2
service = "twitter" try: cah_profile = user.get_profile() except: cah_profile = None if cah_profile is None: cah_profile = CAHProfile( user = user, avatar = avatar, service = service ) cah_profile.save() else: cah_profile.avatar = avatar cah_profile.service = service cah_profile.save() return True pre_update.connect(associate_profile) class FavoriteItem(models.Model): user = models.ForeignKey(User) content_type = models.ForeignKey(ContentType) object_id = models.PositiveIntegerField() content_object = generic.GenericForeignKey('content_type', 'object_id') def __unicode__(self): return u'Favorited Item'
('image_url', 'avatar_url'), # ('blog_url', 'blog_url'), # ('github_url', 'html_url'), # ('location': 'location'), ] ] return True def on_twitter_pre_update(sender, user, response, details, **kwargs): #logger.debug('on_twitter_pre_update signal') user.extras = [ ( 'nick', response.get('screen_name')), ( 'image_url', response.get('profile_image_url')), ##( 'created_at', datetime.strftime('%a %b %d %H:%M:%S %z %Y', response.get('created_at'))), ] return True def on_pre_update(sender, user, response, details, **kwargs): logger.debug('on_pre_update signal') logger.debug(response) return True def on_socialauth_registration(sender, user, response, details, **kwargs): logger.debug('on_socialauth_registration signal') user.is_new = True return False pre_update.connect(on_twitter_pre_update, sender=TwitterBackend) pre_update.connect(on_github_pre_update, sender=GithubBackend) pre_update.connect(on_pre_update, sender=None) socialauth_registered.connect(on_socialauth_registration, sender=None)
username = basename = unicode(sub('[^0-9a-zA-Z\.]+', '', username).strip().lower()) counter = 1 while True: try: found = User.objects.get(username=username) if found.id == id: return username except User.DoesNotExist: break username = '******' % (basename, counter) counter += 1 return username slugify.is_safe = True slugify = stringfilter(slugify) # Note that since we are defining a custom User model, import and handler # registration MUST be done after model definition to avoid circular import issues. from social_auth.signals import pre_update def compose_username(sender, user, response, details, **kwargs): saved = user.username fullname = ''.join([user.first_name, user.last_name]) user.username = response.get('username', slugify(fullname, user.id)) return saved == user.username pre_update.connect(compose_username, sender=None)
try: url = None if sender == FacebookBackend: url = "http://graph.facebook.com/%s/picture?type=large" \ % response["id"] elif sender == google.GoogleOAuth2Backend and "picture" in response: url = response["picture"] if url: avatar = urlopen(url) profile = UserProfile.objects.get(user=user) #profile = user.get_profile() if sender == FacebookBackend: profile.image_url = 'https://graph.facebook.com/' + user.username+ '/picture' #profile.profile_photo.save(slugify(user.username + " social") + '.jpg', ContentFile(avatar.read())) profile.save() except HTTPError: pass return False User.profile = property(lambda u: UserProfile.objects.get_or_create(user=u)[0]) pre_update.connect(new_users_handler, sender=FacebookBackend)
from social_auth.signals import pre_update, socialauth_registered from social_auth.backends.contrib.github import GithubBackend from django.contrib.auth.models import User from django.db import models from tastypie.models import create_api_key try: from .models import UserProfile except ImportError: pass def github_extra_values(sender, user, response, details, **kwargs): profile = UserProfile.objects.get_or_create(user=user)[0] profile.github_access_token = response.get('access_token') profile.save() return True pre_update.connect(github_extra_values, sender=GithubBackend) def new_users_handler(sender, user, response, details, **kwargs): UserProfile.objects.get_or_create(user=user) return True socialauth_registered.connect(new_users_handler, sender=None) models.signals.post_save.connect(create_api_key, sender=User)
account.avatar_url = response.get('profile_image_url', '') token = oauth.Token.from_string(response['access_token']) account.authinfo = ':'.join((token.key, token.secret)) # Reset any error it may have had. account.error = False account.save() if new_connection: from friendstream.tasks import poll_account poll_account.delay(account.pk) return True pre_update.connect(update_twitter_account, sender=TwitterBackend) def update_facebook_account(sender, user, response, details, **kwargs): ident = response['id'] logging.getLogger(__name__).debug('Making facebook account with ident %r', ident) account, created = Account.objects.get_or_create(service='facebook.com', ident=ident) new_connection = True if not account.user or account.user.pk != user.pk else False account.user = user account.display_name = details['fullname'] account.permalink_url = response.get('link', '') account.avatar_url = '' account.authinfo = response['access_token']
name = models.CharField(max_length=100) ord = models.PositiveSmallIntegerField() def __unicode__(self): return self.name class EmailTemplate(models.Model): name = models.CharField(max_length=100) subject = models.CharField(max_length=100) message = models.TextField() def __unicode__(self): return self.name ### END of traditional models definition. Should this be moved to __init__.py? # Listen for new accounts/updates via social auth and update the FdProfile from social_auth.signals import pre_update from social_auth.backends.contrib.linkedin import LinkedinBackend def linkedin_extra_values(sender, user, response, details, **kwargs): """ print "response=", response print "details=", details response= {'last-name': 'Sullivan', 'headline': 'VP of Technology at Krux Digital', 'first-name': 'Nick', 'access_token': 'oauth_token_secret=xxxxx', 'site-standard-profile-request': {'url': 'http://www.linkedin.com/profile?viewProfile=&key=732523&authToken=u2nf&authType=name&trk=api*a101448*s101448*'}, 'id': '732523'} details= {'first_name': 'Nick', 'last_name': 'Sullivan', 'email': ''} """ return True pre_update.connect(linkedin_extra_values, sender=LinkedinBackend)
class Project(models.Model): title = models.CharField(max_length=100) description = models.TextField() creator = models.ForeignKey(User, related_name='created_projects') event = models.ForeignKey(Hackathon) hackers = models.ManyToManyField(User, related_name='joined_projects') deleted = models.BooleanField(default=False) def __unicode__(self): return u'%s' % self.title # Signals for models def create_user_profile(sender, instance, created, **kwargs): if created: UserProfile.objects.create(user=instance) post_save.connect(create_user_profile, sender=User) def google_extra_values(sender, user, response, details, **kwargs): profile = user.get_profile() profile.google_id = response.get('id') profile.full_name = response.get('name') profile.picture = response.get('picture') profile.profile = response.get('link') pprint(vars(profile)) profile.save() return True pre_update.connect(google_extra_values, sender=GoogleProfileBackend)
def __unicode__(self): return self.name class EmailTemplate(models.Model): name = models.CharField(max_length=100) subject = models.CharField(max_length=100) message = models.TextField() def __unicode__(self): return self.name ### END of traditional models definition. Should this be moved to __init__.py? # Listen for new accounts/updates via social auth and update the FdProfile from social_auth.signals import pre_update from social_auth.backends.contrib.linkedin import LinkedinBackend def linkedin_extra_values(sender, user, response, details, **kwargs): """ print "response=", response print "details=", details response= {'last-name': 'Sullivan', 'headline': 'VP of Technology at Krux Digital', 'first-name': 'Nick', 'access_token': 'oauth_token_secret=xxxxx', 'site-standard-profile-request': {'url': 'http://www.linkedin.com/profile?viewProfile=&key=732523&authToken=u2nf&authType=name&trk=api*a101448*s101448*'}, 'id': '732523'} details= {'first_name': 'Nick', 'last_name': 'Sullivan', 'email': ''} """ return True pre_update.connect(linkedin_extra_values, sender=LinkedinBackend)
if profile_instance.image_social == None: img_obj = DateaImage(user=user) img_obj.image.save(slugify(user.username + "_tw") + '.jpg', ContentFile(img.read())) img_obj.save() profile_instance.image_social = img_obj else: profile_instance.image_social.image.save(slugify(user.username + "_tw") + '.jpg', ContentFile(img.read())) profile_instance.image_social.save() except HTTPError: pass profile_instance.save() return True pre_update.connect(twitter_user_update, sender=TwitterBackend) #++++++++++++++++++++ # Update Facebook user and profile data with oauth values def facebook_user_update(sender, user, response, details, **kwargs): profile_instance, created = DateaProfile.objects.get_or_create(user=user) f = open("/tmp/debug.txt", "w") f.write("details username: "******"\n") f.write("user username: "******"\n") f.close() uname = slugify(details['username']) if uname != user.username: user.username = make_social_username(details['username'])
helper.form_class = "profile-edit-form" helper.layout = Layout( Fieldset( '', HTML(github_account), 'bitbucket_url', 'google_code_url', ), ButtonHolder( Submit('edit', 'Edit', css_class="awesome forestgreen"), ) ) return render(request, template_name, { "profile": profile, "form": form, "helper": helper, }) def github_user_update(sender, user, response, details, **kwargs): profile_instance, created = Profile.objects.get_or_create(user=user) profile_instance.github_account = details['username'] profile_instance.email = details['email'] profile_instance.save() return True pre_update.connect(github_user_update, sender=GithubBackend)
""" A spell player chosen to cast """ spell = models.ForeignKey(Spell, related_name='casts_in_process') target_unit = models.ForeignKey(Unit, related_name='target_of_spells', null=True, default=None) target_hero = models.ForeignKey(Hero, related_name='target_of_spells', null=True, default=None) target_param = models.CharField(max_length=50, default='') def social_auth_update_user(sender, user, response, details, **kwargs): try: hero = Hero.objects.get(user=user) created = False except Exception: hero = Hero(user=user) created = True hero.update_from_response(response) hero.save() if created: hero.update_army() hero.update_race() hero.save() return True pre_update.connect(social_auth_update_user, sender=GithubBackend)
profile.loginwithfb = True profile.loginwithtwitter = False url = "http://graph.facebook.com/%s/picture?type=large" % response['id'] avatar = urllib.urlopen(url).read() fout = open( settings.STATIC_ROOT + "/avatar/" + response['first_name'] + '_' + response['last_name'] + '_' + response['id'], "wb") fout.write(avatar) fout.close() profile.avatar = "avatar/" + response['first_name'] + '_' + response[ 'last_name'] + '_' + response['id'] profile.save() return True pre_update.connect(facebook_extra_values, sender=FacebookBackend) from social_auth.backends.twitter import TwitterBackend def twitter_user_update(sender, user, response, details, **kwargs): profile, create = UserProfile.objects.get_or_create(user=user) try: first_name, last_name = response['name'].split(' ', 1) except: first_name = response['name'] last_name = '' profile.firstname = first_name profile.lastname = last_name profile.loginwithfb = False profile.loginwithtwitter = True
email = models.BooleanField(default=False) phone = models.BooleanField(default=False) from social_auth.signals import pre_update from social_auth.backends.google import GoogleOAuth2Backend def google_extra_values(sender, user, response, details, **kwargs): #print sender #print user gmail.get_messages('imap.googlemail.com', response['id_token']) #print details return True from social_auth.signals import pre_update from social_auth.backends.facebook import FacebookBackend def facebook_extra_values(sender, user, response, details, **kwargs): obj, created = ContactAccount.objects.get_or_create( service=5, user=user, account_id=response.get('id')) if created: obj.save() return True pre_update.connect(facebook_extra_values, sender=FacebookBackend) pre_update.connect(google_extra_values, sender=GoogleOAuth2Backend)
from social_auth.signals import pre_update, socialauth_registered from social_auth.backends.facebook import FacebookBackend from social_auth.backends.contrib.linkedin import LinkedinBackend from social_auth.backends.google import GoogleBackend def facebook_extra_values(sender, user, response, details, **kwargs): #can do extra things in here return True pre_update.connect(facebook_extra_values, sender=FacebookBackend) def google_extra_values(sender, user, response, details, **kwargs): #can do extra things in here return True pre_update.connect(google_extra_values, sender=GoogleBackend) def linkedin_extra_values(sender, user, response, details, **kwargs): #can do extra things in here return True pre_update.connect(linkedin_extra_values, sender=LinkedinBackend) def new_users_handler(sender, user, response, details, **kwargs): #can do extra things in here return False socialauth_registered.connect(new_users_handler, sender=None)