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