def create_user(backend, details, response, uid, username, user=None, *args, **kwargs): """Create user. Depends on get_username pipeline.""" if user: return {'user': user} if not username: return None warn_setting('SOCIAL_AUTH_CREATE_USERS', 'create_user') if not setting('SOCIAL_AUTH_CREATE_USERS', True): # Send signal for cases where tracking failed registering is useful. socialauth_not_registered.send(sender=backend.__class__, uid=uid, response=response, details=details) return None email = details.get('email') if email: user = User.objects.filter(email=email) if user: user = user[0] else: user = User.objects.create_user(username=username, email=email) else: user = User.objects.create_user(username=username, email=email) return { 'user': user, 'is_new': True }
def create_user(backend, details, response, uid, username, user=None, *args, **kwargs): """Create user. Depends on get_username pipeline.""" if user: return {'user': user} if not username: return None warn_setting('SOCIAL_AUTH_CREATE_USERS', 'create_user') request = kwargs.get('request') is_mobile = request.mobile if is_mobile: socialauth_not_registered.send(sender=backend.__class__, uid=uid, response=response, details=details) raise ValueError('Registration is not possible on mobile') if not getattr(settings, 'SOCIAL_AUTH_CREATE_USERS', True): # Send signal for cases where tracking failed registering is useful. socialauth_not_registered.send(sender=backend.__class__, uid=uid, response=response, details=details) raise ValueError('Registration is currently closed') email = details.get('email') return { 'user': User.objects.create_user(username=username, email=email), 'is_new': True }
def create_user(backend, details, response, uid, username, user=None, *args, **kwargs): """Create user. Depends on get_username pipeline.""" if user: return {"user": user} if not username: return None warn_setting("SOCIAL_AUTH_CREATE_USERS", "create_user") if not setting("SOCIAL_AUTH_CREATE_USERS", True): # Send signal for cases where tracking failed registering is useful. socialauth_not_registered.send(sender=backend.__class__, uid=uid, response=response, details=details) return None email = details.get("email") if EmailAddress.objects.filter(email=email): # TODO - Make this fail gracefully back to sign up message = ( "The email address provided by the external " "service is already associated with another account. Please " "log in to that account first and associate your account." ) raise AuthException(backend, message) else: user = User.objects.create_user(username=username, email=email) return { "user": user, "is_new": True }
def create_user(backend, details, response, uid, username, user=None, *args, **kwargs): """Create user. Depends on get_username pipeline.""" if user: return {'user': user} if not username: return None warn_setting('SOCIAL_AUTH_CREATE_USERS', 'create_user') if not getattr(settings, 'SOCIAL_AUTH_CREATE_USERS', True): # Send signal for cases where tracking failed registering is useful. socialauth_not_registered.send(sender=backend.__class__, uid=uid, response=response, details=details) return None email = details.get('email') return { 'user': User.objects.create_user(username=username, email=email), 'is_new': True }
def create_user(backend, details, response, uid, username, email, password, user=None, *args, **kwargs): if user: return {'user': user} if not username or not email or not password: return None warn_setting('SOCIAL_AUTH_CREATE_USERS', 'create_user') if not setting('SOCIAL_AUTH_CREATE_USERS', True): # Send signal for cases where tracking failed registering is useful. socialauth_not_registered.send(sender=backend.__class__, uid=uid, response=response, details=details) return None return { 'user': User.objects.create_user(username=username, email=email, password=password), 'is_new': True }
def create_user(backend, details, response, uid, username, user=None, *args, **kwargs): """Create user. Depends on get_username pipeline.""" if user: return {'user': user} if not username: return None warn_setting('SOCIAL_AUTH_CREATE_USERS', 'create_user') if not setting('SOCIAL_AUTH_CREATE_USERS', True): # Send signal for cases where tracking failed registering is useful. socialauth_not_registered.send(sender=backend.__class__, uid=uid, response=response, details=details) return None email = details.get('email') request = kwargs["request"] user = User.objects.create_user(username=username, email=email) Account.create(request=request, user=user) EmailAddress.objects.add_email(user, user.email, primary=True) return {'user': user, 'is_new': True}
def create_user(backend, details, response, uid, username, user=None, *args, **kwargs): """Create user. Depends on get_username pipeline.""" if user: return {'user': user} if not username: return None warn_setting('SOCIAL_AUTH_CREATE_USERS', 'create_user') if not setting('SOCIAL_AUTH_CREATE_USERS', True): # Send signal for cases where tracking failed registering is useful. socialauth_not_registered.send(sender=backend.__class__, uid=uid, response=response, details=details) return None email = details.get('email') request = kwargs["request"] user = User.objects.create_user(username=username, email=email) Account.create(request=request, user=user) EmailAddress.objects.add_email(user, user.email, primary=True) return { 'user': user, 'is_new': True }
def create_user(backend, details, response, uid, username, user=None, *args, **kwargs): """Create user. Depends on get_username pipeline.""" if user: return {'user': user} if not username: return None warn_setting('SOCIAL_AUTH_CREATE_USERS', 'create_user') if not setting('SOCIAL_AUTH_CREATE_USERS', True): # Send signal for cases where tracking failed registering is useful. socialauth_not_registered.send(sender=backend.__class__, uid=uid, response=response, details=details) return None email = details.get('email') from lfsp.config.middleware import REQUEST_VARS user = User(network=REQUEST_VARS.domain_config.network, username=username) user.preferences.email = email user.save() return { 'user': user, 'is_new': True }
def load_extra_data(backend, details, response, social_user, uid, user, *args, **kwargs): """Load extra data from provider and store it on current UserSocialAuth extra_data field. """ warn_setting('SOCIAL_AUTH_EXTRA_DATA', 'load_extra_data') if setting('SOCIAL_AUTH_EXTRA_DATA', True): extra_data = backend.extra_data(user, uid, response, details) if extra_data and social_user.extra_data != extra_data: social_user.extra_data = extra_data social_user.save()
def update_user_details(backend, details, response, user, is_new=False, *args, **kwargs): """Update user details using data from provider.""" changed = False # flag to track changes warn_setting('SOCIAL_AUTH_CHANGE_SIGNAL_ONLY', 'update_user_details') # check if values update should be left to signals handlers only if not setting('SOCIAL_AUTH_CHANGE_SIGNAL_ONLY'): for name, value in details.iteritems(): # do not update username, it was already generated # do not update configured fields if user already existed if name in (USERNAME, 'id', 'pk') or (not is_new and name in setting( 'SOCIAL_AUTH_PROTECTED_USER_FIELDS', [])): continue if value and value != getattr(user, name, None): setattr(user, name, value) changed = True # Fire a pre-update signal sending current backend instance, # user instance (created or retrieved from database), service # response and processed details. # # Also fire socialauth_registered signal for newly registered # users. # # Signal handlers must return True or False to signal instance # changes. Send method returns a list of tuples with receiver # and it's response. signal_response = lambda (receiver, response): response signal_kwargs = { 'sender': backend.__class__, 'user': user, 'response': response, 'details': details } changed |= any(filter(signal_response, pre_update.send(**signal_kwargs))) # Fire socialauth_registered signal on new user registration if is_new: changed |= any( filter(signal_response, socialauth_registered.send(**signal_kwargs))) if changed: user.save()
def associate_by_email(details, *args, **kwargs): """Return user entry with same email address as one returned on details.""" email = details.get('email') warn_setting('SOCIAL_AUTH_ASSOCIATE_BY_MAIL', 'associate_by_email') if email and setting('SOCIAL_AUTH_ASSOCIATE_BY_MAIL'): # try to associate accounts registered with the same email address, # only if it's a single object. ValueError is raised if multiple # objects are returned try: return {'user': User.objects.get(email=email)} except MultipleObjectsReturned: raise ValueError('Not unique email address.') except User.DoesNotExist: pass
def create_user(backend, details, response, uid, username, user=None, *args, **kwargs): """Create user. Depends on get_username pipeline.""" if user: return {"user": user} if not username: return None warn_setting("SOCIAL_AUTH_CREATE_USERS", "create_user") if not getattr(settings, "SOCIAL_AUTH_CREATE_USERS", True): # Send signal for cases where tracking failed registering is useful. socialauth_not_registered.send(sender=backend.__class__, uid=uid, response=response, details=details) return None email = details.get("email") return {"user": User.objects.create_user(username=username, email=email), "is_new": True}
def get_username(details, user=None, *args, **kwargs): """Return an username for new user. Return current user username if user was given. """ if user: return {'username': user.username} warn_setting('SOCIAL_AUTH_FORCE_RANDOM_USERNAME', 'get_username') warn_setting('SOCIAL_AUTH_DEFAULT_USERNAME', 'get_username') warn_setting('SOCIAL_AUTH_UUID_LENGTH', 'get_username') warn_setting('SOCIAL_AUTH_USERNAME_FIXER', 'get_username') warn_setting('SOCIAL_AUTH_USERNAME_STRICT', 'get_username') if getattr(settings, 'SOCIAL_AUTH_FORCE_RANDOM_USERNAME', False): username = uuid4().get_hex() elif details.get(USERNAME): username = details[USERNAME] elif hasattr(settings, 'SOCIAL_AUTH_DEFAULT_USERNAME'): username = settings.SOCIAL_AUTH_DEFAULT_USERNAME if callable(username): username = username() elif hasattr(settings, 'SOCIAL_AUTH_USERNAME_STRICT', False): username = uuid4().get_hex() else: raise ValueError('Invalid username.') uuid_lenght = getattr(settings, 'SOCIAL_AUTH_UUID_LENGTH', 16) username_fixer = getattr(settings, 'SOCIAL_AUTH_USERNAME_FIXER', lambda u: u) short_username = username[:USERNAME_MAX_LENGTH - uuid_lenght] final_username = None while True: final_username = username_fixer(username)[:USERNAME_MAX_LENGTH] try: User.objects.get(username=final_username) except User.DoesNotExist: break else: # User with same username already exists, generate a unique # username for current user using username as base but adding # a unique hash at the end. Original username is cut to avoid # the field max_length. username = short_username + uuid4().get_hex()[:uuid_lenght] return {'username': final_username}
def get_username(details, user=None, *args, **kwargs): """Return an username for new user. Return current user username if user was given. """ if user: return {"username": user.username} warn_setting("SOCIAL_AUTH_FORCE_RANDOM_USERNAME", "get_username") warn_setting("SOCIAL_AUTH_DEFAULT_USERNAME", "get_username") warn_setting("SOCIAL_AUTH_UUID_LENGTH", "get_username") warn_setting("SOCIAL_AUTH_USERNAME_FIXER", "get_username") warn_setting("SOCIAL_AUTH_USERNAME_STRICT", "get_username") if getattr(settings, "SOCIAL_AUTH_FORCE_RANDOM_USERNAME", False): username = uuid4().get_hex() elif details.get(USERNAME): username = details[USERNAME] elif hasattr(settings, "SOCIAL_AUTH_DEFAULT_USERNAME"): username = settings.SOCIAL_AUTH_DEFAULT_USERNAME if callable(username): username = username() elif hasattr(settings, "SOCIAL_AUTH_USERNAME_STRICT", False): username = uuid4().get_hex() else: raise ValueError("Invalid username.") uuid_lenght = getattr(settings, "SOCIAL_AUTH_UUID_LENGTH", 16) username_fixer = getattr(settings, "SOCIAL_AUTH_USERNAME_FIXER", lambda u: u) short_username = username[: USERNAME_MAX_LENGTH - uuid_lenght] final_username = None while True: final_username = username_fixer(username)[:USERNAME_MAX_LENGTH] try: User.objects.get(username=final_username) except User.DoesNotExist: break else: # User with same username already exists, generate a unique # username for current user using username as base but adding # a unique hash at the end. Original username is cut to avoid # the field max_length. username = short_username + uuid4().get_hex()[:uuid_lenght] return {"username": final_username}
def associate_by_email(details, *args, **kwargs): """Return user entry with same email address as one returned on details.""" email = details.get('email') warn_setting('SOCIAL_AUTH_ASSOCIATE_BY_MAIL', 'associate_by_email') if email and setting('SOCIAL_AUTH_ASSOCIATE_BY_MAIL', True): # try to associate accounts registered with the same email address, # only if it's a single object. AuthException is raised if multiple # objects are returned try: address = EmailAddress.objects.filter(email=email, verified=True).select_related("user").get() return {"user": address.user} except MultipleObjectsReturned: raise AuthException(kwargs['backend'], 'Not unique email address.') except EmailAddress.DoesNotExist: pass
def create_user(backend, details, response, uid, username, user=None, *args, **kwargs): """Create user. Depends on get_username pipeline.""" if user: return {'user': user} if not username: return None warn_setting('SOCIAL_AUTH_CREATE_USERS', 'create_user') if not getattr(settings, 'SOCIAL_AUTH_CREATE_USERS', True): ################################################################ #Added by brianmckinney to allow us to only invite manly users ############################################################### from invite.models import Invitation invite_key = kwargs['request'].session.get('invite', "").strip() if invite_key: try: invite = Invitation.objects.get(key=invite_key) email = details.get('email') from invite.views import notify_admins, update_invite #Notify admins that we have a new user #notify_admins(username) #Update date accepted, invite status user = User.objects.create_user(username=username, email=email) update_invite(invite_key, username) return { 'user': user, 'is_new': True } except Invitation.DoesNotExist: pass ############## End edit ################################### # Send signal for cases where tracking failed registering is useful. socialauth_not_registered.send(sender=backend.__class__, uid=uid, response=response, details=details) return None email = details.get('email') return { 'user': User.objects.create_user(username=username, email=email), 'is_new': True }
def update_user_details(backend, details, response, user, is_new=False, *args, **kwargs): """Update user details using data from provider.""" changed = False # flag to track changes warn_setting('SOCIAL_AUTH_CHANGE_SIGNAL_ONLY', 'update_user_details') # check if values update should be left to signals handlers only if not setting('SOCIAL_AUTH_CHANGE_SIGNAL_ONLY'): do_not_update_email = setting('SOCIAL_AUTH_DO_NOT_UPDATE_EMAIL') == True for name, value in details.iteritems(): # do not update username, it was already generated if name in (USERNAME, 'id', 'pk'): continue if do_not_update_email and name == 'email' and not user.email: continue if value and value != getattr(user, name, None): setattr(user, name, value) changed = True # Fire a pre-update signal sending current backend instance, # user instance (created or retrieved from database), service # response and processed details. # # Also fire socialauth_registered signal for newly registered # users. # # Signal handlers must return True or False to signal instance # changes. Send method returns a list of tuples with receiver # and it's response. signal_response = lambda (receiver, response): response signal_kwargs = {'sender': backend.__class__, 'user': user, 'response': response, 'details': details} changed |= any(filter(signal_response, pre_update.send(**signal_kwargs))) # Fire socialauth_registered signal on new user registration if is_new: changed |= any(filter(signal_response, socialauth_registered.send(**signal_kwargs))) if changed: user.save()
def associate_by_email(details, user=None, *args, **kwargs): """Return user entry with same email address as one returned on details.""" if user: return None email = details.get('email') warn_setting('SOCIAL_AUTH_ASSOCIATE_BY_MAIL', 'associate_by_email') if email and setting('SOCIAL_AUTH_ASSOCIATE_BY_MAIL', False): # try to associate accounts registered with the same email address, # only if it's a single object. AuthException is raised if multiple # objects are returned try: return {'user': UserSocialAuth.get_user_by_email(email=email)} except MultipleObjectsReturned: raise AuthException(kwargs['backend'], 'Not unique email address.') except ObjectDoesNotExist: pass
def create_user (backend, details, response, uid, username, email, password, user = None, *args, **kwargs): if user: return {'user':user} if not username or not email or not password: return None warn_setting ('SOCIAL_AUTH_CREATE_USERS', 'create_user') if not setting('SOCIAL_AUTH_CREATE_USERS', True): # Send signal for cases where tracking failed registering is useful. socialauth_not_registered.send(sender=backend.__class__, uid=uid, response=response, details=details) return None return { 'user': User.objects.create_user(username=username, email=email, password=password), 'is_new': True }
def update_user_details(backend, details, response, user, is_new=False, *args, **kwargs): """Update user details using data from provider.""" changed = False # flag to track changes warn_setting("SOCIAL_AUTH_CHANGE_SIGNAL_ONLY", "update_user_details") # check if values update should be left to signals handlers only if not getattr(settings, "SOCIAL_AUTH_CHANGE_SIGNAL_ONLY", False): for name, value in details.iteritems(): # do not update username, it was already generated if name == USERNAME: continue if value and value != getattr(user, name, None): setattr(user, name, value) changed = True # Fire a pre-update signal sending current backend instance, # user instance (created or retrieved from database), service # response and processed details. # # Also fire socialauth_registered signal for newly registered # users. # # Signal handlers must return True or False to signal instance # changes. Send method returns a list of tuples with receiver # and it's response. signal_response = lambda (receiver, response): response signal_kwargs = {"sender": backend.__class__, "user": user, "response": response, "details": details} changed |= any(filter(signal_response, pre_update.send(**signal_kwargs))) # Fire socialauth_registered signal on new user registration if is_new: changed |= any(filter(signal_response, socialauth_registered.send(**signal_kwargs))) if changed: user.save()
def __call__(self, details, user=None, *args, **kwargs): """Get a new username. We check for existing usernames in a case-insensitive way. """ if user: return {'username': user.username} warn_setting('SOCIAL_AUTH_FORCE_RANDOM_USERNAME', 'get_username') warn_setting('SOCIAL_AUTH_DEFAULT_USERNAME', 'get_username') warn_setting('SOCIAL_AUTH_UUID_LENGTH', 'get_username') warn_setting('SOCIAL_AUTH_USERNAME_FIXER', 'get_username') if getattr(settings, 'SOCIAL_AUTH_FORCE_RANDOM_USERNAME', False): username = uuid4().get_hex() elif details.get(USERNAME): username = details[USERNAME] elif settings.hasattr('SOCIAL_AUTH_DEFAULT_USERNAME'): username = settings.SOCIAL_AUTH_DEFAULT_USERNAME if callable(username): username = username() else: username = uuid4().get_hex() uuid_lenght = getattr(settings, 'SOCIAL_AUTH_UUID_LENGTH', 16) username_fixer = getattr(settings, 'SOCIAL_AUTH_USERNAME_FIXER', lambda u: u) short_username = username[:USERNAME_MAX_LENGTH - uuid_lenght] final_username = None while True: final_username = username_fixer(username)[:USERNAME_MAX_LENGTH] try: User.objects.get(username__iexact=final_username) except User.DoesNotExist: break else: # User with same username already exists, generate a unique # username for current user using username as base but adding # a unique hash at the end. Original username is cut to avoid # the field max_length. username = short_username + uuid4().get_hex()[:uuid_lenght] return {'username': final_username}
def get_username(details, user=None, user_exists=simple_user_exists, *args, **kwargs): """Return an username for new user. Return current user username if user was given. """ if user: return {'username': user.username} warn_setting('SOCIAL_AUTH_FORCE_RANDOM_USERNAME', 'get_username') warn_setting('SOCIAL_AUTH_DEFAULT_USERNAME', 'get_username') warn_setting('SOCIAL_AUTH_UUID_LENGTH', 'get_username') warn_setting('SOCIAL_AUTH_USERNAME_FIXER', 'get_username') if setting('SOCIAL_AUTH_FORCE_RANDOM_USERNAME'): username = uuid4().get_hex() elif details.get(USERNAME): username = unicode(details[USERNAME]) elif setting('SOCIAL_AUTH_DEFAULT_USERNAME'): username = setting('SOCIAL_AUTH_DEFAULT_USERNAME') if callable(username): username = username() else: username = uuid4().get_hex() uuid_length = setting('SOCIAL_AUTH_UUID_LENGTH', 16) username_fixer = setting('SOCIAL_AUTH_USERNAME_FIXER', lambda u: u) short_username = username[:USERNAME_MAX_LENGTH - uuid_length] final_username = username_fixer(username)[:USERNAME_MAX_LENGTH] # Generate a unique username for current user using username # as base but adding a unique hash at the end. Original # username is cut to avoid any field max_length. while user_exists(username=final_username): username = short_username + uuid4().get_hex()[:uuid_length] final_username = username_fixer(username)[:USERNAME_MAX_LENGTH] return {'username': final_username}
def get_username(details, user=None, user_exists=simple_user_exists, *args, **kwargs): """Return an username for new user. Return current user username if user was given. """ if user: return {'username': user.username} warn_setting('SOCIAL_AUTH_FORCE_RANDOM_USERNAME', 'get_username') warn_setting('SOCIAL_AUTH_DEFAULT_USERNAME', 'get_username') warn_setting('SOCIAL_AUTH_UUID_LENGTH', 'get_username') warn_setting('SOCIAL_AUTH_USERNAME_FIXER', 'get_username') if setting('SOCIAL_AUTH_FORCE_RANDOM_USERNAME'): username = uuid4().get_hex() elif details.get(USERNAME): username = details[USERNAME] elif details.get("first_name"): username = details["first_name"] elif setting('SOCIAL_AUTH_DEFAULT_USERNAME'): username = setting('SOCIAL_AUTH_DEFAULT_USERNAME') if callable(username): username = username() else: username = uuid4().get_hex() uuid_lenght = setting('SOCIAL_AUTH_UUID_LENGTH', 16) username_fixer = setting('SOCIAL_AUTH_USERNAME_FIXER', lambda u: u) short_username = username[:USERNAME_MAX_LENGTH - uuid_lenght] final_username = username_fixer(username)[:USERNAME_MAX_LENGTH] # Generate a unique username for current user using username # as base but adding a unique hash at the end. Original # username is cut to avoid any field max_length. while user_exists(username=final_username): username = short_username + uuid4().get_hex()[:uuid_lenght] final_username = username_fixer(username)[:USERNAME_MAX_LENGTH] return {'username': final_username}
def __call__(self, details, user=None, *args, **kwargs): """Return an username for new user. Return current user username if user was given. """ if user: return {'username': user.username} warn_setting('SOCIAL_AUTH_FORCE_RANDOM_USERNAME', 'get_username') warn_setting('SOCIAL_AUTH_DEFAULT_USERNAME', 'get_username') warn_setting('SOCIAL_AUTH_UUID_LENGTH', 'get_username') warn_setting('SOCIAL_AUTH_USERNAME_FIXER', 'get_username') if setting('SOCIAL_AUTH_FORCE_RANDOM_USERNAME'): username = uuid4().get_hex() elif details.get(USERNAME): username = details[USERNAME] elif setting('SOCIAL_AUTH_DEFAULT_USERNAME'): username = setting('SOCIAL_AUTH_DEFAULT_USERNAME') if callable(username): username = username() else: username = uuid4().get_hex() uuid_length = setting('SOCIAL_AUTH_UUID_LENGTH', 16) username_fixer = setting('SOCIAL_AUTH_USERNAME_FIXER', lambda u: u) short_username = username[:USERNAME_MAX_LENGTH - uuid_length] final_username = None while True: final_username = username_fixer(username)[:USERNAME_MAX_LENGTH] if self.username_exists(final_username): # User with same username already exists, generate a unique # username for current user using username as base but adding # a unique hash at the end. Original username is cut to avoid # the field max_length. username = short_username + uuid4().get_hex()[:uuid_length] else: return {'username': final_username}