def validate_username(request, user=None): try: validators.validate_username(request.POST['username'], exclude=user) return _("Entered username is valid.") except KeyError: raise ValidationError(_('Enter username.'))
def create_user(self, username, email, password=None, set_default_avatar=False, **extra_fields): from misago.users.validators import (validate_email, validate_password, validate_username) with transaction.atomic(): if not email: raise ValueError(_("User must have an email address.")) if not password: raise ValueError(_("User must have a password.")) validate_username(username) validate_email(email) validate_password(password) if not 'joined_from_ip' in extra_fields: extra_fields['joined_from_ip'] = '127.0.0.1' if not 'timezone' in extra_fields: extra_fields['timezone'] = settings.default_timezone WATCH_DICT = { 'no': AUTO_SUBSCRIBE_NONE, 'watch': AUTO_SUBSCRIBE_WATCH, 'watch_email': AUTO_SUBSCRIBE_WATCH_AND_EMAIL, } if not 'subscribe_to_started_threads' in extra_fields: new_value = WATCH_DICT[settings.subscribe_start] extra_fields['subscribe_to_started_threads'] = new_value if not 'subscribe_to_replied_threads' in extra_fields: new_value = WATCH_DICT[settings.subscribe_reply] extra_fields['subscribe_to_replied_threads'] = new_value now = timezone.now() user = self.model(is_staff=False, is_superuser=False, last_login=now, joined_on=now, **extra_fields) user.set_username(username) user.set_email(email) user.set_password(password) if not 'rank' in extra_fields: user.rank = Rank.objects.get_default() user.save(using=self._db) if set_default_avatar: avatars.set_default_avatar(user) authenticated_role = Role.objects.get(special_role='authenticated') if authenticated_role not in user.roles.all(): user.roles.add(authenticated_role) user.update_acl_key() user.save(update_fields=['acl_key']) return user
def clean_username(self): validate_username(self.cleaned_data['username'], self.request.settings) new_user = User.objects.get_blank_user() new_user.set_username(self.cleaned_data['username']) try: new_user.full_clean() except ValidationError as e: new_user.is_username_valid(e) return self.cleaned_data['username']
def create_user(self, username, email, password=None, set_default_avatar=False, **extra_fields): from misago.users.validators import validate_email, validate_password, validate_username with transaction.atomic(): if not email: raise ValueError(_("User must have an email address.")) if not password: raise ValueError(_("User must have a password.")) validate_username(username) validate_email(email) validate_password(password) if not "joined_from_ip" in extra_fields: extra_fields["joined_from_ip"] = "127.0.0.1" WATCH_DICT = { "no": AUTO_SUBSCRIBE_NONE, "watch": AUTO_SUBSCRIBE_WATCH, "watch_email": AUTO_SUBSCRIBE_WATCH_AND_EMAIL, } if not "subscribe_to_started_threads" in extra_fields: new_value = WATCH_DICT[settings.subscribe_start] extra_fields["subscribe_to_started_threads"] = new_value if not "subscribe_to_replied_threads" in extra_fields: new_value = WATCH_DICT[settings.subscribe_reply] extra_fields["subscribe_to_replied_threads"] = new_value now = timezone.now() user = self.model(is_staff=False, is_superuser=False, last_login=now, joined_on=now, **extra_fields) user.set_username(username) user.set_email(email) user.set_password(password) if not "rank" in extra_fields: user.rank = Rank.objects.get_default() user.save(using=self._db) if set_default_avatar: avatars.set_default_avatar(user) user.avatar_hash = avatars.get_avatar_hash(user) else: user.avatar_hash = "abcdef01" authenticated_role = Role.objects.get(special_role="authenticated") if authenticated_role not in user.roles.all(): user.roles.add(authenticated_role) user.update_acl_key() user.save(update_fields=["avatar_hash", "acl_key"]) return user
def clean_username(self): org_username = self.user.username validate_username(self.cleaned_data['username'], self.request.settings) self.user.set_username(self.cleaned_data['username']) try: self.user.full_clean() except ValidationError as e: self.user.is_username_valid(e) self.user.set_username(org_username) return self.cleaned_data['username']
def clean_username(self): org_username = self.request.user.username if org_username == self.cleaned_data['username']: raise ValidationError(_("Your new username is same as current one.")) validate_username(self.cleaned_data['username'], self.request.settings) self.request.user.set_username(self.cleaned_data['username']) try: self.request.user.full_clean() except ValidationError as e: self.request.user.is_username_valid(e) self.request.user.set_username(org_username) return self.cleaned_data['username']
def validate(self, data): username = data.get('username') if not username: raise serializers.ValidationError(_("Enter new username.")) if username == self.context['user'].username: raise serializers.ValidationError(_("New username is same as current one.")) validate_username(username) return data
def clean(self): data = super(ChangeUsernameForm, self).clean() username = data.get('username') if not username: raise forms.ValidationError(_("Enter new username.")) if username == self.user.username: message = _("New username is same as current one.") raise forms.ValidationError(message) validate_username(username, exclude=self.user) return data
def get_username(strategy, details, backend, user=None, *args, **kwargs): """Resolve valid username for use in new account""" if user: return None username = perpare_username(details.get('username', '')) full_name = perpare_username(details.get('full_name', '')) first_name = perpare_username(details.get('first_name', '')) last_name = perpare_username(details.get('last_name', '')) names_to_try = [ username, first_name, ] if username: names_to_try.append(username) if first_name: names_to_try.append(first_name) if last_name: # if first name is taken, try first name + first char of last name names_to_try.append(first_name + last_name[0]) if full_name: names_to_try.append(full_name) username_length_max = settings.username_length_max for name in names_to_try: if len(name) > username_length_max: names_to_try.append(name[:username_length_max]) for name in filter(bool, names_to_try): try: validate_username(name) return {'clean_username': name} except ValidationError: pass
def create_user( self, username, email, password=None, set_default_avatar=False, **extra_fields ): from misago.users.validators import validate_email, validate_username email = self.normalize_email(email) username = self.model.normalize_username(username) if not email: raise ValueError(_("User must have an email address.")) if not password: raise ValueError(_("User must have a password.")) if not 'joined_from_ip' in extra_fields: extra_fields['joined_from_ip'] = '127.0.0.1' WATCH_DICT = { 'no': self.model.SUBSCRIBE_NONE, 'watch': self.model.SUBSCRIBE_NOTIFY, 'watch_email': self.model.SUBSCRIBE_ALL, } if not 'subscribe_to_started_threads' in extra_fields: new_value = WATCH_DICT[settings.subscribe_start] extra_fields['subscribe_to_started_threads'] = new_value if not 'subscribe_to_replied_threads' in extra_fields: new_value = WATCH_DICT[settings.subscribe_reply] extra_fields['subscribe_to_replied_threads'] = new_value extra_fields.update({'is_staff': False, 'is_superuser': False}) now = timezone.now() user = self.model(last_login=now, joined_on=now, **extra_fields) user.set_username(username) user.set_email(email) user.set_password(password) validate_username(username) validate_email(email) validate_password(password, user=user) if not 'rank' in extra_fields: user.rank = Rank.objects.get_default() user.save(using=self._db) if set_default_avatar: avatars.set_default_avatar( user, settings.default_avatar, settings.default_gravatar_fallback ) else: # just for test purposes user.avatars = [{'size': 400, 'url': '/placekitten.com/400/400'}] authenticated_role = Role.objects.get(special_role='authenticated') if authenticated_role not in user.roles.all(): user.roles.add(authenticated_role) user.update_acl_key() user.save(update_fields=['avatars', 'acl_key']) # populate online tracker with default value Online.objects.create( user=user, current_ip=extra_fields['joined_from_ip'], last_click=now, ) return user
def handle(self, *args, **options): username = options.get('username') email = options.get('email') password = options.get('password') interactive = options.get('interactive') verbosity = int(options.get('verbosity', 1)) # Validate initial inputs if username is not None: try: username = username.strip() validate_username(username) except ValidationError as e: self.stderr.write(e.messages[0]) username = None if email is not None: try: email = email.strip() validate_email(email) except ValidationError as e: self.stderr.write(e.messages[0]) email = None if password is not None: try: password = password.strip() validate_password(password) except ValidationError as e: self.stderr.write(e.messages[0]) password = None if not interactive: if username and email and password: # Call User manager's create_superuser using our wrapper self.create_superuser(username, email, password, verbosity) else: try: if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException("Not running in a TTY") # Prompt for username/password, and any other required fields. # Enclose this whole thing in a try/except to trap for a # keyboard interrupt and exit gracefully. while not username: try: message = force_str("Enter displayed username: "******"Enter E-mail address: ").strip() validate_email(raw_value) email = raw_value except ValidationError as e: self.stderr.write(e.messages[0]) while not password: try: raw_value = getpass("Enter password: "******"Repeat password: "******"Entered passwords are different.") password = raw_value except ValidationError as e: self.stderr.write(e.messages[0]) # Call User manager's create_superuser using our wrapper self.create_superuser(username, email, password, verbosity) except KeyboardInterrupt: self.stderr.write("\nOperation cancelled.") sys.exit(1) except NotRunningInTTYException: self.stdout.write( "Superuser creation skipped due to not running in a TTY. " "You can run `manage.py createsuperuser` in your project " "to create one manually.")
def create_user(self, username, email, password, timezone=False, ip='127.0.0.1', agent='', no_roles=False, activation=0, request=False): token = '' if activation > 0: token = get_random_string(12) try: db_settings = request.settings except AttributeError: db_settings = DBSettings() if timezone == False: timezone = db_settings['default_timezone'] # Get first rank try: from misago.ranks.models import Rank default_rank = Rank.objects.filter(special=0).order_by('order')[0] except IndexError: default_rank = None # Store user in database new_user = User( last_sync=tz_util.now(), join_date=tz_util.now(), join_ip=ip, join_agent=agent, activation=activation, token=token, timezone=timezone, rank=default_rank, subscribe_start=db_settings['subscribe_start'], subscribe_reply=db_settings['subscribe_reply'], ) validate_username(username, db_settings) validate_password(password, db_settings) new_user.set_username(username) new_user.set_email(email) new_user.set_password(password) new_user.full_clean() new_user.default_avatar(db_settings) new_user.save(force_insert=True) # Set user roles? if not no_roles: from misago.roles.models import Role new_user.roles.add(Role.objects.get(token='registered')) new_user.make_acl_key() new_user.save(force_update=True) # Load monitor try: monitor = request.monitor except AttributeError: monitor = Monitor() # Update forum stats if activation == 0: monitor['users'] = int(monitor['users']) + 1 monitor['last_user'] = new_user.pk monitor['last_user_name'] = new_user.username monitor['last_user_slug'] = new_user.username_slug else: monitor['users_inactive'] = int(monitor['users_inactive']) + 1 # Return new user return new_user
def clean_username(self): data = self.cleaned_data['username'] validate_username(data, exclude=self.instance) return data
def test_validate_username(self): """validate_username has no crashes""" validate_username('LeBob') with self.assertRaises(ValidationError): validate_username('*')
def handle(self, *args, **options): username = options.get('username') email = options.get('email') password = options.get('password') interactive = options.get('interactive') verbosity = int(options.get('verbosity', 1)) # Validate initial inputs if username is not None: try: username = username.strip() validate_username(username) except ValidationError as e: self.stderr.write(u'\n'.join(e.messages)) username = None if email is not None: try: email = email.strip() validate_email(email) except ValidationError as e: self.stderr.write(u'\n'.join(e.messages)) email = None if password is not None: password = password.strip() if password == '': self.stderr.write("Error: Blank passwords aren't allowed.") if not interactive: if username and email and password: # Call User manager's create_superuser using our wrapper self.create_superuser(username, email, password, verbosity) else: try: if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException("Not running in a TTY") # Prompt for username/password, and any other required fields. # Enclose this whole thing in a try/except to trap for a # keyboard interrupt and exit gracefully. while not username: try: message = force_str("Enter displayed username: "******"Enter e-mail address: ").strip() validate_email(raw_value) email = raw_value except ValidationError as e: self.stderr.write(u'\n'.join(e.messages)) while not password: raw_value = getpass("Enter password: "******"Repeat password:"******"Error: Your passwords didn't match.") # Don't validate passwords that don't match. continue if raw_value.strip() == '': self.stderr.write( "Error: Blank passwords aren't allowed.") # Don't validate blank passwords. continue try: validate_password(raw_value, user=UserModel(username=username, email=email)) except ValidationError as e: self.stderr.write(u'\n'.join(e.messages)) response = input( 'Bypass password validation and create user anyway? [y/N]: ' ) if response.lower() != 'y': continue password = raw_value # Call User manager's create_superuser using our wrapper self.create_superuser(username, email, password, verbosity) except KeyboardInterrupt: self.stderr.write("\nOperation cancelled.") sys.exit(1) except NotRunningInTTYException: self.stdout.write( "Superuser creation skipped due to not running in a TTY. " "You can run `manage.py createsuperuser` in your project " "to create one manually.")
def validate_username(self, username): if username == self.context['user'].username: raise serializers.ValidationError( _("New username is same as current one.")) validate_username(username) return username
def create_user(self, username, email, password=None, set_default_avatar=False, **extra_fields): from misago.users.validators import (validate_email, validate_password, validate_username) with transaction.atomic(): if not email: raise ValueError(_("User must have an email address.")) if not password: raise ValueError(_("User must have a password.")) validate_username(username) validate_email(email) validate_password(password) if not 'joined_from_ip' in extra_fields: extra_fields['joined_from_ip'] = '127.0.0.1' WATCH_DICT = { 'no': AUTO_SUBSCRIBE_NONE, 'watch': AUTO_SUBSCRIBE_WATCH, 'watch_email': AUTO_SUBSCRIBE_WATCH_AND_EMAIL, } if not 'subscribe_to_started_threads' in extra_fields: new_value = WATCH_DICT[settings.subscribe_start] extra_fields['subscribe_to_started_threads'] = new_value if not 'subscribe_to_replied_threads' in extra_fields: new_value = WATCH_DICT[settings.subscribe_reply] extra_fields['subscribe_to_replied_threads'] = new_value now = timezone.now() user = self.model(is_staff=False, is_superuser=False, last_login=now, joined_on=now, **extra_fields) user.set_username(username) user.set_email(email) user.set_password(password) if not 'rank' in extra_fields: user.rank = Rank.objects.get_default() user.save(using=self._db) if set_default_avatar: avatars.set_default_avatar(user) user.avatar_hash = avatars.get_avatar_hash(user) else: user.avatar_hash = 'abcdef01' authenticated_role = Role.objects.get(special_role='authenticated') if authenticated_role not in user.roles.all(): user.roles.add(authenticated_role) user.update_acl_key() user.save(update_fields=['avatar_hash', 'acl_key']) return user
def create_user(self, username, email, password=None, set_default_avatar=False, **extra_fields): from misago.users.validators import validate_email, validate_username email = self.normalize_email(email) username = self.model.normalize_username(username) if not email: raise ValueError(_("User must have an email address.")) if not password: raise ValueError(_("User must have a password.")) if not 'joined_from_ip' in extra_fields: extra_fields['joined_from_ip'] = '127.0.0.1' WATCH_DICT = { 'no': self.model.SUBSCRIBE_NONE, 'watch': self.model.SUBSCRIBE_NOTIFY, 'watch_email': self.model.SUBSCRIBE_ALL, } if not 'subscribe_to_started_threads' in extra_fields: new_value = WATCH_DICT[settings.subscribe_start] extra_fields['subscribe_to_started_threads'] = new_value if not 'subscribe_to_replied_threads' in extra_fields: new_value = WATCH_DICT[settings.subscribe_reply] extra_fields['subscribe_to_replied_threads'] = new_value extra_fields.update({'is_staff': False, 'is_superuser': False}) now = timezone.now() user = self.model(last_login=now, joined_on=now, **extra_fields) user.set_username(username) user.set_email(email) user.set_password(password) validate_username(username) validate_email(email) validate_password(password, user=user) if not 'rank' in extra_fields: user.rank = Rank.objects.get_default() user.save(using=self._db) if set_default_avatar: avatars.set_default_avatar(user, settings.default_avatar, settings.default_gravatar_fallback) else: # just for test purposes user.avatars = [{'size': 400, 'url': '/placekitten.com/400/400'}] authenticated_role = Role.objects.get(special_role='authenticated') if authenticated_role not in user.roles.all(): user.roles.add(authenticated_role) user.update_acl_key() user.save(update_fields=['avatars', 'acl_key']) # populate online tracker with default value Online.objects.create( user=user, current_ip=extra_fields['joined_from_ip'], last_click=now, ) return user
def handle(self, *args, **options): username = options.get('username') email = options.get('email') password = options.get('password') interactive = options.get('interactive') verbosity = int(options.get('verbosity', 1)) # Validate initial inputs if username is not None: try: username = username.strip() validate_username(username) except ValidationError as e: self.stderr.write(e.messages[0]) username = None if email is not None: try: email = email.strip() validate_email(email) except ValidationError as e: self.stderr.write(e.messages[0]) email = None if password is not None: try: password = password.strip() validate_password(password) except ValidationError as e: self.stderr.write(e.messages[0]) password = None if not interactive: if username and email and password: # Call User manager's create_superuser using our wrapper self.create_superuser(username, email, password, verbosity) else: try: if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException("Not running in a TTY") # Prompt for username/password, and any other required fields. # Enclose this whole thing in a try/except to trap for a # keyboard interrupt and exit gracefully. while not username: try: message = force_str("Enter displayed username: "******"Enter E-mail address: ").strip() validate_email(raw_value) email = raw_value except ValidationError as e: self.stderr.write(e.messages[0]) while not password: try: raw_value = getpass("Enter password: "******"Repeat password: "******"Entered passwords are different.") password = raw_value except ValidationError as e: self.stderr.write(e.messages[0]) # Call User manager's create_superuser using our wrapper self.create_superuser(username, email, password, verbosity) except KeyboardInterrupt: self.stderr.write("\nOperation cancelled.") sys.exit(1) except NotRunningInTTYException: self.stdout.write( "Superuser creation skipped due to not running in a TTY. " "You can run `manage.py createsuperuser` in your project " "to create one manually." )