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 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 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 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 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 clean_username(self):
data = self.cleaned_data['username']
validate_username(data, exclude=self.instance)
return data
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."
)
