profile.save()
# send quick+dirty welcome email
message = 'Hey ' + user.first_name + ',\n\nWelcome to Polymath!\n\n'
message += 'We\'re working on building a central resource for the web\'s best educational content and the ultimate community-based online learning experience.\n\n'
message += 'Learn more here: http://beta.whatispolymath.com/howitworks/\n\n'
message += 'Looking forward to seeing you out there!\n\n'
message += 'Thanks,\nThe Polymath Team'
send_mail('Welcome to Polymath!', message, 'Polymath <*****@*****.**>', [user.email])
return False
socialauth_registered.connect(new_users_handler, sender=None)
class CourseCategory(models.Model):
name = models.CharField(max_length=100)
slug = models.SlugField(editable=False, unique=True)
def save(self, *args, **kwargs):
self.slug = slugify(self.name)
super(CourseCategory, self).save(*args, **kwargs)
def __unicode__(self):
return self.name
class Course(models.Model):
or '',
website=response.get('url') or '')
if response.get('profile_image_url'):
try:
cf = ContentFile(
urllib.urlopen(response['profile_image_url']).read())
except Exception:
pass
else:
cf.name = response['profile_image_url']
profile.logo = cf
profile.save()
socialauth_registered.connect(twitter_profile_data, sender=TwitterBackend)
def facebook_profile_data(sender, user, response, details, **kwargs):
get_profile_model().objects.create(user=user,
location=response.get('location') or '',
description=response.get('about_me')
or '',
website=response.get('url') or '')
socialauth_registered.connect(facebook_profile_data, sender=FacebookBackend)
### On creating a new user, if the user has an email address
### XXX If you make changes to the way users are auto-created on video import,
u'friends_count': 0,
u'location': None,
u'profile_link_color': u'0084B4',
u'profile_image_url': u'http://a1.twimg.com/sticky/default_profile_images/default_profile_2_normal.png',
u'following': False,
u'show_all_inline_media': False,
u'geo_enabled': False,
u'profile_background_image_url': u'http://a0.twimg.com/images/themes/theme1/bg.png',
u'name': u'Scamp Cat',
u'lang': u'en',
u'profile_background_tile': False,
u'favourites_count': 0,
u'screen_name': u'ScampCatApp',
u'notifications': False,
u'url': None,
u'created_at': u'Thu Jul 07 08:02:46 +0000 2011',
u'contributors_enabled': False,
u'time_zone': None,
'access_token': 'oauth_token_secret=Kqtl23h3KZuBEcvg4EGReVxJLtqB0fAoZpO37QzeE&oauth_token=330856703-cWwysmOmdlQG6EgtnuRWUvmKcmJpeENnrFzh1sVQ',
u'profile_sidebar_border_color': u'C0DEED',
u'default_profile': True,
u'is_translator': False}
"""
data = {'user': user,
'avatar_url': response['profile_image_url'],
'twitter_id': response['screen_name']}
UserProfile.objects.create(**data)
return False
socialauth_registered.connect(profile_creator, sender=None)
# ('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)
def create_user_profile(sender, instance, created, **kwargs):
if created:
UserProfile.objects.create(user=instance)
# country = Country.objects.get_or_create(name=)
#
post_save.connect(create_user_profile, sender=User)
def fill_user_profile(sender, user, response, details, **kwargs):
profile = user.get_profile()
try:
country = Country.objects.get_or_create(code=response['location']['country']['code'])
profile.country = country
except:
pass
try:
city = City.objects.get_or_create(name=response['location']['name'])
profile.city = city
except:
pass
profile.save()
if 'skills' in response and 'skill' in response['skills']:
for sk in response['skills']['skill']:
skill, was_created = Skill.objects.get_or_create(name=sk['skill']['name'])
profile.skills_offered.add(skill)
socialauth_registered.connect(fill_user_profile)
# if sender == FacebookBackend:
# url = "http://graph.facebook.com/%s/picture" % response["id"]
#
# if url:
# small_picture = urlopen(url, timeout=5)
# large_picture = urlopen(url+'?type=large', timeout=5)
# profile = UserProfile.objects.create(user=user)
# profile.picture_small.save(
# slugify(user_id)+u'.jpg',
# ContentFile(small_picture.read())
# )
# profile.picture_large.save(
# slugify(user_id)+u'_large.jpg',
# ContentFile(large_picture.read()),
# )
# except HttpError:
# pass
# Create following and follower relationships
signed_up = UserSocialAuth.objects.filter(uid__in=friend_ids).values_list(
'user_id',flat=True)
for friend in signed_up:
Following.objects.get_or_create(fb_user=user_id, follow=friend)
Following.objects.get_or_create(fb_user=friend, follow=user_id)
Follower.objects.get_or_create(fb_user=user_id, follow=friend)
Follower.objects.get_or_create(fb_user=friend, follow=user_id)
return False
socialauth_registered.connect(new_user_handler, sender=None)
user_profile = Profile.objects.create(user=instance)
def social_auth_new_users_handler(sender, user, response, details, **kwargs):
"""
social_auth_new_users_handler: is a signal that fires when a new user signs up using
social authentication. Currently it would do the following
1. send out an email for the user congratulating him for signing up
"""
html = get_template('accounts/email_template/social_auth_new_users.html')
txt = get_template('accounts/email_template/social_auth_new_users.txt')
c = Context({
'user': user.first_name,
})
Notification.objects.send_email(
send_to=user.email,
subject=_('Welcome to Garage'),
html_body=html.render(c),
text_body=txt.render(c)
)
return False
socialauth_registered.connect(social_auth_new_users_handler, sender=None,
dispatch_uid="accounts.social_auth_new_users_handler")
post_save.connect(create_user_profile, sender=User,
dispatch_uid="accounts.create.user.profile")
message = render_to_string('accounts/emails/activation_email_message.txt',
context)
send_mail(subject,
message,
settings.DEFAULT_FROM_EMAIL,
[self.user.email,])
if 'social_auth' in settings.INSTALLED_APPS:
from social_auth.signals import socialauth_registered
def create_user_account(sender, user, *args, **kwargs):
account = Account.objects.create_account(user=user)
user = Account.objects.activate_user(user.username, account.activation_key)
socialauth_registered.connect(create_user_account, sender=None)
"""
User profile base class
"""
def upload_to_picture(instance, filename):
"""
Uploads a picture for a user to the ``ACCOUNTS_GRAVATAR_PATH`` and saving it
under unique hash for the image. This is for privacy reasons so others
can't just browse through the picture directory.
"""
extension = filename.split('.')[-1].lower()
salt, hash = generate_sha1(instance.id)
return '%(path)s/%(hash)s.%(extension)s' % {'path': getattr(accounts_settings,
user.last_name = response.get('last_name', '')
user.first_name = response.get('first_name', '')
profile = user.social_profile
profile.gender = response.get('gender', '')
if response.get('username') is not None:
profile.image_url = 'https://graph.facebook.com/' + response.get('username') + '/picture'
profile.url = 'http://facebook.com/' + response.get('username')
profile.url = response.get('link', '')
if response.get('hometown') is not None:
profile.description = response.get('hometown').get('name')
profile.save()
return True
socialauth_registered.connect(facebook_extra_values, sender=FacebookBackend)
def google_extra_values(sender, user, response, details, **kwargs):
"""Populates a UserProfile Object when a new User is created via Google Auth"""
LOGGER.debug('socialprofile.models.google_extra_values')
user_info_url = "https://www.googleapis.com/oauth2/v1/userinfo"
data = {'access_token': response.get('access_token', ''), 'alt': 'json'}
params = urlencode(data)
try:
request = Request(user_info_url + '?' + params, headers={'Authorization': params})
result = simplejson.loads(urlopen(request).read())
user.last_name = result.get('family_name', '')
user.first_name = result.get('given_name', '')
profile = user.social_profile
value = models.IntegerField()
# Add some stuff to the admin interface.
admin.site.register(RegisLeague)
admin.site.register(RegisUser)
admin.site.register(QuestionTemplate)
admin.site.register(Question)
admin.site.register(QuestionHint)
admin.site.register(Answer)
admin.site.register(Guess)
admin.site.register(Suggestion)
# Social auth handlers.
from social_auth.signals import socialauth_registered
#from social_auth.backends.google import GoogleBackend
from social_auth.backends.facebook import FacebookBackend
#def google_extra_values(sender, user, response, details, **kwargs):
# return True
# TODO: This currently doesn't work. Not a big deal for us but would be nice to fix.
def facebook_extra_values(sender, user, response, details, **kwargs):
user.email = response.get('email')
return True
#socialauth_registered.connect(google_extra_values, sender=GoogleBackend)
socialauth_registered.connect(facebook_extra_values, sender=FacebookBackend)
return self.name
def get_absolute_url(self):
return (APP_NAME+"_user_profile", (), { 'username':self.user.username})
get_absolute_url = models.permalink(get_absolute_url)
class ProfilePic(models.Model):
"""
Model for a users profile pic.
"""
image = ThumbnailerImageField(upload_to='profilepic/%Y/%b/%d', blank=True)
user = models.OneToOneField(User, related_name="profile_pic")
valid = models.BooleanField(default=True)
class Meta:
unique_together = (('user', 'valid'),)
def __unicode__(self):
return _("%s %s's Profile Pic") % (self.user.first_name , self.user.last_name)
from registration.signals import user_activated
from social_auth.signals import socialauth_registered
def create_userprofile(sender, user, request, **kwargs):
profile = UserProfile.objects.create(user=user)
profile_pic = ProfilePic.objects.create(user=user)
user_activated.connect(create_userprofile)
socialauth_registered.connect(create_userprofile)
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)
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)
from urllib2 import urlopen, HTTPError
from django.template.defaultfilters import slugify
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:
profile = user.get_profile()
if not profile.image:
avatar = urlopen(url)
profile.image.save(slugify(user.username + " social") + '.jpg',
ContentFile(avatar.read()))
profile.save()
except HTTPError:
pass
result = True
return result
socialauth_registered.connect(social_extra_values, sender=None)
pre_update.connect(social_extra_values, sender=None)
user.last_name = response.get('last_name', '')
user.first_name = response.get('first_name', '')
profile = user.social_profile
profile.gender = response.get('gender', '')
if response.get('username') is not None:
profile.image_url = 'https://graph.facebook.com/' + response.get('username') + '/picture'
profile.url = 'http://facebook.com/' + response.get('username')
profile.url = response.get('link', '')
if response.get('hometown') is not None:
profile.description = response.get('hometown').get('name')
profile.save()
return True
socialauth_registered.connect(facebook_extra_values, sender=FacebookBackend)
def google_extra_values(sender, user, response, details, **kwargs):
"""Populates a UserProfile Object when a new User is created via Google Auth"""
LOGGER.debug('socialprofile.models.google_extra_values')
user_info_url = "https://www.googleapis.com/oauth2/v1/userinfo"
data = {'access_token': response.get('access_token', ''), 'alt': 'json'}
params = urlencode(data)
try:
request = Request(user_info_url + '?' + params, headers={'Authorization': params})
result = simplejson.loads(urlopen(request).read())
user.last_name = result.get('family_name', '')
user.first_name = result.get('given_name', '')
profile = user.social_profile
class Meta:
verbose_name = _('fees payment')
verbose_name_plural = _('fees payments')
user = models.ForeignKey(OrgMember)
year = models.IntegerField(_('year'), choices=YEAR_CHOICES, default=2012)
# ------------- facility for checking if there is already member user -----
# This can happen when we have already database of organization members
# without social-auth associations.
try:
from social_auth.signals import socialauth_registered, pre_update
from existing_member_checker import check_if_memberuser_already_exists, \
google_extra_values
socialauth_registered.connect(check_if_memberuser_already_exists,
sender=None)
pre_update.connect(google_extra_values, sender=GoogleBackend)
except ImportError:
pass
if not hasattr(settings, 'ORG_MEMBER_DEFAULT_MEMBER_GROUP'):
raise ImproperlyConfigured('You must define ORG_MEMBER_DEFAULT_MEMBER_GROUP in your settings')
if not hasattr(settings, 'ORG_MEMBER_ACCOUNT_NUMBER'):
raise ImproperlyConfigured('You must define ORG_MEMBER_ACCOUNT_NUMBER in your settings')
if not hasattr(settings, 'ORG_MEMBER_FEES'):
raise ImproperlyConfigured('You must define ORG_MEMBER_FEES in your settings')
elif not isinstance(settings.ORG_MEMBER_FEES, dict):
raise ImproperlyConfigured('ORG_MEMBER_FEES settings variable must be dictionary')
location=response.get('location') or '',
description=response.get('description') or '',
website=response.get('url') or '')
if response.get('profile_image_url'):
try:
cf = ContentFile(urllib.urlopen(response['profile_image_url']).read())
except Exception:
pass
else:
cf.name = response['profile_image_url']
profile.logo = cf
profile.save()
socialauth_registered.connect(twitter_profile_data, sender=TwitterBackend)
def facebook_profile_data(sender, user, response, details, **kwargs):
get_profile_model().objects.create(
user=user,
location=response.get('location') or '',
description=response.get('about_me') or '',
website=response.get('url') or '')
socialauth_registered.connect(facebook_profile_data, sender=FacebookBackend)
### On creating a new user, if the user has an email address
### XXX If you make changes to the way users are auto-created on video import,
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)
verbose_name_plural = 'Banned IP addresses'
@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, raw,**kwargs):
if created and not raw:
Member.objects.create(user=instance)
ReferralLink.objects.create(user=instance)
@receiver(user_logged_in)
def save_ip(sender, request, user, *args, **kwargs):
obj, created = IPAddress.objects.get_or_create(user=user,
IPAddress=request.META.get('X-Real-IP') or request.META.get('REMOTE_ADDR') or '127.0.0.1')
if not created:
obj.last_login = datetime.now()
obj.save()
def user_registered(sender, user, response, details, **kwargs):
profile = user.get_profile()
if not profile.verified:
profile.verified = True
# this is a place to get an avatar for profile
profile.points_amount += Member.rewards.associate
profile.save()
socialauth_registered.connect(user_registered, sender=twitter.TwitterBackend)
socialauth_registered.connect(user_registered, sender=facebook.FacebookBackend)
socialauth_registered.connect(user_registered, sender=google.GoogleBackend)
def facebook_extra_data(sender, user, response, details, **kwargs):
"""
This is triggered after a django_social_auth returns a user's data.
This should save data to the UserProfile object, including username and school
TODO: we may need to create schools based on what facebook returns
see: http://django-social-auth.readthedocs.org/en/latest/signals.html
"""
# TODO: This should live in util, on the UserProfile object or in a generic app
user_profile = user.get_profile()
user.email = response.get('email')
user.save()
user_profile.fb_id = response.get('id')
#user_profile.gravatar = hashlib.md5(user.email.lower()).hashdigest()
# take the user's school, save it to the UserProfile if found
# create a new School if not
# note this only takes the most recent school from a user's education history
# FIXME: add a selector for which ofschool from their education history to use
user_school = response.get('education')[-1]
fb_school_name = user_school['school']['name']
fb_school_id = user_school['school']['id']
user_profile.school, created = School.objects.get_or_create(
name=fb_school_name,
facebook_id=fb_school_id)
user_profile.save()
socialauth_registered.connect(facebook_extra_data, sender=FacebookBackend)
from social_auth.signals import pre_update, socialauth_registered, socialauth_not_registered
from social_auth.backends.facebook import FacebookBackend
from social_auth.models import UserSocialAuth
UserSocial = UserSocialAuth._meta.get_field('user').rel.to
def facebook_extra_values(sender, user, response, details, **kwargs):
user.gender = response.get('gender')
return True
def testy1(sender, user, response, details, **kwargs):
user.is_active = False
return True
def testy2(sender, uid, response, details, **kwargs):
print "k2"
return True
#def user_test(sender, response, details, **kwargs):
# name = sender.username(details)
# user = UserSocial.objects.create_user(username=name, email=details['email'])
# user.is_active = False
# kwargs['request'].session['social_auth_new_username'] = details['username']
# return user
pre_update.connect(facebook_extra_values, sender=FacebookBackend)
socialauth_registered.connect(testy1)
#socialauth_not_registered.connect(testy2)
import socialauth.avatars
def save(self, *args, **kwargs):
if not self.slug:
i = 0
self.slug = slugify(self.title)
while True:
if i > 0:
if i > 1:
self.slug = self.slug.rsplit("-", 1)[0]
self.slug = "%s-%s" % (self.slug, i)
try:
Drawing.objects.exclude(id=self.id).get(slug=self.slug)
except Drawing.DoesNotExist:
break
i += 1
super(Drawing, self).save(*args, **kwargs)
def create_profile(sender, user, response, details, **kwargs):
try:
# twitter
photo_url = response["profile_image_url"]
photo_url = "_reasonably_small".join(photo_url.rsplit("_normal", 1))
except KeyError:
# facebook
photo_url = "http://graph.facebook.com/%s/picture?type=large" % response["id"]
path = join(settings.MEDIA_ROOT, "photos")
if not exists(path):
mkdir(path)
urlretrieve(photo_url, join(path, str(user.id)))
socialauth_registered.connect(create_profile, sender=None)
@receiver(socialauth_registered, sender=GoogleOAuth2Backend)
def google_extra_values(sender, user, response, details, **kwargs):
"""Populates a UserProfile Object when a new User is created via Google Auth"""
LOGGER.debug('profile.models.google_extra_values')
user_info_url = "https://www.googleapis.com/oauth2/v1/userinfo"
data = {'access_token': response.get('access_token', ''), 'alt': 'json'}
params = urlencode(data)
try:
request = Request(user_info_url + '?' + params, headers={'Authorization': params})
result = simplejson.loads(urlopen(request).read())
user.last_name = result.get('family_name', '')
user.first_name = result.get('given_name', '')
profile = user.profile
profile.gender = result.get('gender', '')
profile.image_url = result.get('picture', '')
profile.url = result.get('link', '')
profile.save()
except:
pass
return True
socialauth_registered.connect(google_extra_values, sender=GoogleOAuth2Backend)
