def test_with_database(self): User.objects.create(username="******") management.get_system_username = lambda: "joe" self.assertEqual(management.get_default_username(), "") self.assertEqual(management.get_default_username(database="other"), "joe") User.objects.using("other").create(username="******") self.assertEqual(management.get_default_username(database="other"), "")
def test_with_database(self): User.objects.create(username='******') management.get_system_username = lambda: 'joe' self.assertEqual(management.get_default_username(), '') self.assertEqual(management.get_default_username(database='other'), 'joe') User.objects.using('other').create(username='******') self.assertEqual(management.get_default_username(database='other'), '')
def test_createsuperuser_command_suggested_username_with_database_option(self): default_username = get_default_username(database='other') qs = User.objects.using('other') @mock_inputs({'password': '******', 'username': '', 'email': ''}) def test_other_create_with_suggested_username(self): call_command( 'createsuperuser', interactive=True, stdin=MockTTY(), verbosity=0, database='other', ) self.assertIs(qs.filter(username=default_username).exists(), True) test_other_create_with_suggested_username(self) @mock_inputs({'password': '******', 'Username: '******'other', 'email': ''}) def test_other_no_suggestion(self): call_command( 'createsuperuser', interactive=True, stdin=MockTTY(), verbosity=0, database='other', ) self.assertIs(qs.filter(username='******').exists(), True) test_other_no_suggestion(self)
def handle(self, *args, **options): username = options[self.UserModel.USERNAME_FIELD] database = options['database'] user_data = {} verbose_field_name = self.username_field.verbose_name if not options['all']: username = None default_username = get_default_username() while username is None: message = self._get_input_message(self.username_field, default_username) username = self.get_input_data(self.username_field, message, default_username) if username: error_message = self._validate_username( username, verbose_field_name, database) if error_message: self.stderr.write(error_message) username = None user_data[self.UserModel.USERNAME_FIELD] = username users = self.UserModel.objects.filter( username=user_data[self.UserModel.USERNAME_FIELD], is_staff=True) for user in users: user.delete() else: users = self.UserModel.objects.filter(is_staff=True) for user in users: user.delete()
def test_createsuperuser_command_suggested_username_with_database_option(self): default_username = get_default_username(database="other") qs = User.objects.using("other") @mock_inputs({"password": "******", "username": "", "email": ""}) def test_other_create_with_suggested_username(self): call_command( "createsuperuser", interactive=True, stdin=MockTTY(), verbosity=0, database="other", ) self.assertIs(qs.filter(username=default_username).exists(), True) test_other_create_with_suggested_username(self) @mock_inputs({"password": "******", "Username: "******"other", "email": ""}) def test_other_no_suggestion(self): call_command( "createsuperuser", interactive=True, stdin=MockTTY(), verbosity=0, database="other", ) self.assertIs(qs.filter(username="******").exists(), True) test_other_no_suggestion(self)
def test_non_ascii_verbose_name(self): @mock_inputs( { "password": "******", "Uživatel (leave blank to use '%s'): " % get_default_username(): "foo", # username (cz) "email": "*****@*****.**", } ) def test(self): username_field = User._meta.get_field("username") old_verbose_name = username_field.verbose_name username_field.verbose_name = _("u\u017eivatel") new_io = StringIO() try: call_command( "createsuperuser", interactive=True, stdout=new_io, stdin=MockTTY(), ) finally: username_field.verbose_name = old_verbose_name command_output = new_io.getvalue().strip() self.assertEqual(command_output, "Superuser created successfully.") test(self)
def test_default_username(self): """createsuperuser uses a default username when one isn't provided.""" # Get the default username before creating a user. default_username = get_default_username() new_io = StringIO() entered_passwords = ["password", "password"] def return_passwords(): return entered_passwords.pop(0) @mock_inputs({"password": return_passwords, "username": "", "email": ""}) def test(self): call_command( "createsuperuser", interactive=True, stdin=MockTTY(), stdout=new_io, stderr=new_io, ) self.assertEqual( new_io.getvalue().strip(), "Superuser created successfully." ) self.assertTrue(User.objects.filter(username=default_username).exists()) test(self)
def test_non_ascii_verbose_name(self): @mock_inputs({ 'password': "******", "Uživatel (leave blank to use '%s'): " % get_default_username(): 'foo', # username (cz) 'email': '*****@*****.**', }) def test(self): username_field = User._meta.get_field('username') old_verbose_name = username_field.verbose_name username_field.verbose_name = _('u\u017eivatel') new_io = StringIO() try: call_command( "createsuperuser", interactive=True, stdout=new_io, stdin=MockTTY(), ) finally: username_field.verbose_name = old_verbose_name command_output = new_io.getvalue().strip() self.assertEqual(command_output, 'Superuser created successfully.') test(self)
def test_unknown_encoding(self): import locale try: origin = locale.getdefaultlocale locale.getdefaultlocale = lambda: ("en_US", "x-mac-simp-chinese") self.assertEqual(management.get_default_username(), '') finally: locale.getdefaultlocale = origin
def create_superuser(site): """Create an initial superuser for the site. This will ask for a username, password, and e-mail address for the initial superuser account. If a superuser already exists (due to re-running this script on an existing database), it will be displayed for reference, and the user will be instructed on how to create a new one. Args: site (reviewboard.cmdline.rbsite.Site): The site to create the superuser on. """ from django.contrib.auth.management import get_default_username from django.contrib.auth.models import User console.header('Set up an administrator account') admins = list( User.objects.filter(is_superuser=True).values_list('username', flat=True)) if admins: console.print('Existing admin account(s) were found: %(admins)s' '\n' 'To create a new one, run:' % { 'admins': ', '.join(admins), }) console.print() console.print(' ./reviewboard/manage.py createsuperuser', wrap=False) else: console.print("Now you'll need to set up a superuser (an admin " "account). This will be used to log in and configure " "Review Board.") site.admin_user = console.prompt_input('Username', default=get_default_username() or 'admin') site.admin_password = console.prompt_input( 'Password', prompt_type=console.PROMPT_TYPE_PASSWORD) while True: confirmed_password = console.prompt_input( 'Confirm Password', prompt_type=console.PROMPT_TYPE_PASSWORD) if confirmed_password == site.admin_password: break console.error('Passwords must match.') site.admin_email = console.prompt_input('E-Mail Address') site.create_admin_user()
def create_superuser(site): """Create an initial superuser for the site. This will ask for a username, password, and e-mail address for the initial superuser account. If a superuser already exists (due to re-running this script on an existing database), it will be displayed for reference, and the user will be instructed on how to create a new one. Args: site (reviewboard.cmdline.rbsite.Site): The site to create the superuser on. """ from django.contrib.auth.management import get_default_username from django.contrib.auth.models import User page = ui.page('Set up a superuser account') admins = list( User.objects.filter(is_superuser=True) .values_list('username', flat=True) ) if admins: ui.text(page, 'Existing admin account(s) were found: %s' % ', '.join(admins)) ui.text(page, 'To create a new one, run `./reviewboard/manage.py ' 'createsuperuser`') else: ui.text(page, "Now you'll need to set up a superuser (an admin account). " "This will be used to log in and configure Review Board.") ui.prompt_input(page, 'Username', default=get_default_username() or 'admin', save_obj=site, save_var='admin_user') ui.prompt_input(page, 'Password', password=True, save_obj=site, save_var='admin_password') ui.prompt_input(page, 'Confirm Password', password=True, save_obj=site, save_var='reenter_admin_password') ui.prompt_input(page, 'E-Mail Address', save_obj=site, save_var='admin_email') site.create_admin_user()
def handle(self, *args, **options): username = options[self.UserModel.USERNAME_FIELD] database = options['database'] # If not provided, create the user with an unusable password password = None user_data = {} # Same as user_data but with foreign keys as fake model instances # instead of raw IDs. fake_user_data = {} # Do quick and dirty validation if --noinput if not options['interactive']: try: if not username: raise CommandError("You must use --%s with --noinput." % self.UserModel.USERNAME_FIELD) username = self.username_field.clean(username, None) for field_name in self.UserModel.REQUIRED_FIELDS: if options[field_name]: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean(options[field_name], None) else: raise CommandError("You must use --%s with --noinput." % field_name) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) else: # Prompt for username/password, and any other required fields. # Enclose this whole thing in a try/except to catch # KeyboardInterrupt and exit gracefully. default_username = get_default_username() try: if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException("Not running in a TTY") # Get a username verbose_field_name = self.username_field.verbose_name while username is None: input_msg = capfirst(verbose_field_name) if default_username: input_msg += " (leave blank to use '%s')" % default_username username_rel = self.username_field.remote_field
def test_default_username(self): """createsuperuser uses a default username when one isn't provided.""" # Get the default username before creating a user. default_username = get_default_username() new_io = StringIO() entered_passwords = ['password', 'password'] def return_passwords(): return entered_passwords.pop(0) @mock_inputs({'password': return_passwords, 'username': '', 'email': ''}) def test(self): call_command( 'createsuperuser', interactive=True, stdin=MockTTY(), stdout=new_io, stderr=new_io, ) self.assertEqual(new_io.getvalue().strip(), 'Superuser created successfully.') self.assertTrue(User.objects.filter(username=default_username).exists()) test(self)
def handle(self, *args, **options): database = options.get('database', DEFAULT_DB_ALIAS) username = options.get(User.USERNAME_FIELD) user_type = options.get('type', None) password = None user_data = {} fake_user_data = {} default_username = get_default_username() try: # Get a username verbose_field_name = self.username_field.verbose_name while username is None: input_msg = capfirst(verbose_field_name) if default_username: input_msg += " (leave blank to use '%s')" % default_username username_rel = self.username_field.rel input_msg = force_str('%s%s: ' % ( input_msg, ' (%s.%s)' % ( username_rel.to._meta.object_name, username_rel.field_name ) if username_rel else '') ) username = self.get_input_data(self.username_field, input_msg, default_username) if not username: continue try: User._default_manager.db_manager(database).get_by_natural_key(username) except User.DoesNotExist: pass else: self.stderr.write("Error: That %s is already taken." % verbose_field_name) username = None user_type_choises = copy.deepcopy(USER_TYPE_CHOICES) user_type_choises.sort(key=lambda tup: tup[0]) types = [('%s:%s' % tp) for tp in user_type_choises] msg = 'Type (%s):' % (' '.join(types)) while not user_type or not UserType.is_valid_type(user_type): user_type = self.get_input_data('user_type', msg) if not user_type: continue user_type = int(user_type) if not UserType.is_valid_type(user_type): self.stderr.write("Error: Invalid user type") user_type = False manager_id = 0 if user_type in [UserType.VISITOR, UserType.MANAGER]: while not manager_id: raw_value = input('Manager id: ') try: manager_id = int(raw_value) manager = User.objects.get(id=manager_id) if not manager.user_type in [UserType.STAFF]: raise Exception('Only staff can doing this, type = '+str(manager.user_type)) except Exception as pe: if user_type == UserType.MANAGER: print ("No manager set: "+str(pe)) #not required break else: self.stderr.write("Error: Invalid manager id: "+str(pe)) manager_id = 0 for field_name in User.REQUIRED_FIELDS: field = User._meta.get_field(field_name) user_data[field_name] = options.get(field_name) while user_data[field_name] is None: message = force_str('%s%s: ' % ( capfirst(field.verbose_name), ' (%s.%s)' % ( field.remote_field.model._meta.object_name, field.remote_field.field_name, ) if field.remote_field else '', )) input_value = self.get_input_data(field, message) user_data[field_name] = input_value fake_user_data[field_name] = input_value if field.remote_field: fake_user_data[field_name] = field.remote_field.model(input_value) profile = {} if user_type in [UserType.SUPERUSER, UserType.STAFF]: profile = { 'gender': 1, 'dob': '1988-12-12' } for field_name in ['gender', 'dob']: field = UserProfile._meta.get_field(field_name) while profile.get(field_name, None) is None: message = force_str('%s%s: ' % ( capfirst(field.verbose_name), ' (%s.%s)' % ( field.remote_field.model._meta.object_name, field.remote_field.field_name, ) if field.remote_field else '', )) input_value = self.get_input_data(field, message) profile[field_name] = input_value while password is None: password = getpass.getpass() password2 = getpass.getpass(force_str('Password (again): ')) if password != password2: self.stderr.write("Error: Your passwords didn't match.") password = None continue except KeyboardInterrupt: self.stderr.write("\nOperation cancelled.") sys.exit(1) if username: if user_type == UserType.SUPERUSER: user_data['is_superuser'] = True user_data['is_staff'] = True user_data['is_active'] = True if user_type == UserType.STAFF: user_data['is_staff'] = True user_data['is_active'] = True user_data['manager_id'] = manager_id user_data[User.USERNAME_FIELD] = username user_data['password'] = password user_data['manager_id'] = int(manager_id) user_data['user_type'] = user_type user_data['profile'] = profile UserService.save(user_data) if options['verbosity'] >= 1: self.stdout.write("User created successfully.")
def handle(self, *args, **options): username = options.get(self.UserModel.USERNAME_FIELD) database = options.get('database') # If not provided, create the user with an unusable password password = None user_data = {} # Same as user_data but with foreign keys as fake model instances # instead of raw IDs. fake_user_data = {} # Do quick and dirty validation if --noinput if not options['interactive']: try: if not username: raise CommandError("You must use --%s with --noinput." % self.UserModel.USERNAME_FIELD) username = self.username_field.clean(username, None) for field_name in self.UserModel.REQUIRED_FIELDS: if options.get(field_name): field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean(options[field_name], None) else: raise CommandError("You must use --%s with --noinput." % field_name) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) else: # Prompt for username/password, and any other required fields. # Enclose this whole thing in a try/except to catch # KeyboardInterrupt and exit gracefully. default_username = get_default_username() try: if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException("Not running in a TTY") # Get a username verbose_field_name = self.username_field.verbose_name while username is None: input_msg = capfirst(verbose_field_name) if default_username: input_msg += " (leave blank to use '%s')" % default_username username_rel = self.username_field.remote_field input_msg = force_str('%s%s: ' % ( input_msg, ' (%s.%s)' % ( username_rel.model._meta.object_name, username_rel.field_name ) if username_rel else '') ) username = self.get_input_data(self.username_field, input_msg, default_username) if not username: continue if self.username_field.unique: try: self.UserModel._default_manager.db_manager(database).get_by_natural_key(username) except self.UserModel.DoesNotExist: pass else: self.stderr.write("Error: That %s is already taken." % verbose_field_name) username = None for field_name in self.UserModel.REQUIRED_FIELDS: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = options.get(field_name) while user_data[field_name] is None: message = force_str('%s%s: ' % ( capfirst(field.verbose_name), ' (%s.%s)' % ( field.remote_field.model._meta.object_name, field.remote_field.field_name, ) if field.remote_field else '', )) input_value = self.get_input_data(field, message) user_data[field_name] = input_value fake_user_data[field_name] = input_value # Wrap any foreign keys in fake model instances if field.remote_field: fake_user_data[field_name] = field.remote_field.model(input_value) # Get a password while password is None: password = getpass.getpass() password2 = getpass.getpass(force_str('Password (again): ')) if password != password2: self.stderr.write("Error: Your passwords didn't match.") password = None # Don't validate passwords that don't match. continue if password.strip() == '': self.stderr.write("Error: Blank passwords aren't allowed.") password = None # Don't validate blank passwords. continue try: validate_password(password2, self.UserModel(**fake_user_data)) except exceptions.ValidationError as err: self.stderr.write('\n'.join(err.messages)) password = None 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." ) if username: user_data[self.UserModel.USERNAME_FIELD] = username user_data['password'] = password self.UserModel._default_manager.db_manager(database).create_superuser(**user_data) if options['verbosity'] >= 1: self.stdout.write("Superuser created successfully.")
def handle(self, *args, **options): username = options[self.UserModel.USERNAME_FIELD] database = options['database'] # If not provided, create the user with an unusable password password = None user_data = {} # Same as user_data but with foreign keys as fake model instances # instead of raw IDs. fake_user_data = {} verbose_field_name = self.username_field.verbose_name try: if options['interactive']: if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException default_username = get_default_username() if username: error_msg = self._validate_username( username, verbose_field_name, database) if error_msg: self.stderr.write(error_msg) username = None elif username == '': raise CommandError('%s cannot be blank.' % capfirst(verbose_field_name)) # Prompt for username. while username is None: input_msg = capfirst(verbose_field_name) if default_username: input_msg += " (leave blank to use '%s')" % default_username username_rel = self.username_field.remote_field input_msg = '%s%s: ' % ( input_msg, ' (%s.%s)' % (username_rel.model._meta.object_name, username_rel.field_name) if username_rel else '') username = self.get_input_data(self.username_field, input_msg, default_username) if username: error_msg = self._validate_username( username, verbose_field_name, database) if error_msg: self.stderr.write(error_msg) username = None continue else: if username is None: raise CommandError('You must use --%s with --noinput.' % self.UserModel.USERNAME_FIELD) else: error_msg = self._validate_username( username, verbose_field_name, database) if error_msg: raise CommandError(error_msg) # Prompt for required fields. for field_name in self.UserModel.REQUIRED_FIELDS: if not options['interactive']: if options[field_name]: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean( options[field_name], None) else: raise CommandError( 'You must use --%s with --noinput.' % field_name) else: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = options[field_name] while user_data[field_name] is None: message = '%s%s: ' % ( capfirst(field.verbose_name), ' (%s.%s)' % ( field.remote_field.model._meta.object_name, field.remote_field.field_name, ) if field.remote_field else '', ) input_value = self.get_input_data(field, message) user_data[field_name] = input_value fake_user_data[field_name] = input_value # Wrap any foreign keys in fake model instances if field.remote_field: fake_user_data[ field_name] = field.remote_field.model( input_value) # Prompt for a password. while password is None: password = getpass.getpass() password2 = getpass.getpass('Password (again): ') if password != password2: self.stderr.write( "Error: Your passwords didn't match.") password = None # Don't validate passwords that don't match. continue if password.strip() == '': self.stderr.write( "Error: Blank passwords aren't allowed.") password = None # Don't validate blank passwords. continue try: validate_password(password2, self.UserModel(**fake_user_data)) except exceptions.ValidationError as err: self.stderr.write('\n'.join(err.messages)) response = input( 'Bypass password validation and create user anyway? [y/N]: ' ) if response.lower() != 'y': password = None except KeyboardInterrupt: self.stderr.write('\nOperation cancelled.') sys.exit(1) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) 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.') if username: user_data[self.UserModel.USERNAME_FIELD] = username user_data['password'] = password self.UserModel._default_manager.db_manager( database).create_superuser(**user_data) if options['verbosity'] >= 1: self.stdout.write("Superuser created successfully.")
def handle(self, *args, **options): username = options[self.UserModel.USERNAME_FIELD] database = options['database'] user_data = {} verbose_field_name = self.username_field.verbose_name try: if options['interactive']: # Same as user_data but without many to many fields and with # foreign keys as fake model instances instead of raw IDs. fake_user_data = {} if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException default_username = get_default_username() if username: error_msg = self._validate_username( username, verbose_field_name, database) if error_msg: self.stderr.write(error_msg) username = None elif username == '': raise CommandError('%s cannot be blank.' % capfirst(verbose_field_name)) # Prompt for username. while username is None: message = self._get_input_message(self.username_field, default_username) username = self.get_input_data(self.username_field, message, default_username) if username: error_msg = self._validate_username( username, verbose_field_name, database) if error_msg: self.stderr.write(error_msg) username = None continue user_data[self.UserModel.USERNAME_FIELD] = username fake_user_data[self.UserModel.USERNAME_FIELD] = ( self.username_field.remote_field.model(username) if self.username_field.remote_field else username) # Prompt for required fields. for field_name in self.UserModel.REQUIRED_FIELDS: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = options[field_name] while user_data[field_name] is None: message = self._get_input_message(field) input_value = self.get_input_data(field, message) user_data[field_name] = input_value if field.many_to_many and input_value: if not input_value.strip(): user_data[field_name] = None self.stderr.write( 'Error: This field cannot be blank.') continue user_data[field_name] = [ pk.strip() for pk in input_value.split(',') ] if not field.many_to_many: fake_user_data[field_name] = input_value # Wrap any foreign keys in fake model instances if field.many_to_one: fake_user_data[ field_name] = field.remote_field.model( input_value) else: # Non-interactive mode. # Use username from environment variable, if not provided in # options. if username is None: username = os.environ.get( 'DJANGO_SUPERUSER_' + self.UserModel.USERNAME_FIELD.upper()) if username is None: raise CommandError('You must use --%s with --noinput.' % self.UserModel.USERNAME_FIELD) else: error_msg = self._validate_username( username, verbose_field_name, database) if error_msg: raise CommandError(error_msg) user_data[self.UserModel.USERNAME_FIELD] = username for field_name in self.UserModel.REQUIRED_FIELDS: env_var = 'DJANGO_SUPERUSER_' + field_name.upper() value = options[field_name] or os.environ.get(env_var) if not value: raise CommandError( 'You must use --%s with --noinput.' % field_name) field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean(value, None) self.UserModel._default_manager.db_manager( database).create_superuser(**user_data) if options['verbosity'] >= 1: self.stdout.write("Superuser created successfully.") except KeyboardInterrupt: self.stderr.write('\nOperation cancelled.') sys.exit(1) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) 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 test_existing(self): models.User.objects.create(username='******') management.get_system_username = lambda: 'joe' self.assertEqual(management.get_default_username(), '') self.assertEqual( management.get_default_username(check_db=False), 'joe')
"""
def handle(self, *args, **options): username = options.get(self.UserModel.USERNAME_FIELD, None) interactive = options.get('interactive') verbosity = int(options.get('verbosity', 1)) database = options.get('database') # If not provided, create the user with an unusable password password = options.get('password') user_data = {} # Do quick and dirty validation if --noinput if not interactive: try: if not username: raise CommandError("You must use --%s with --noinput." % self.UserModel.USERNAME_FIELD) username = self.username_field.clean(username, None) for field_name in self.UserModel.REQUIRED_FIELDS: if options.get(field_name): field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean( options[field_name], None) else: raise CommandError( "You must use --%s with --noinput." % field_name) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) else: # 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. default_username = get_default_username() try: # Get a username verbose_field_name = force_text( self.username_field.verbose_name) while username is None: if not username: input_msg = capfirst(verbose_field_name) if default_username: input_msg = "%s (leave blank to use '%s')" % ( input_msg, default_username) raw_value = input(force_str('%s: ' % input_msg)) if default_username and raw_value == '': raw_value = default_username try: username = self.username_field.clean(raw_value, None) except exceptions.ValidationError as e: self.stderr.write("Error: %s" % '; '.join(e.messages)) username = None continue try: self.UserModel._default_manager.db_manager( database).get_by_natural_key(username) except self.UserModel.DoesNotExist: pass else: self.stderr.write("Error: That %s is already taken." % verbose_field_name) username = None for field_name in self.UserModel.REQUIRED_FIELDS: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = options.get(field_name) while user_data[field_name] is None: raw_value = input( force_str( '%s: ' % capfirst(force_text(field.verbose_name)))) try: user_data[field_name] = field.clean( raw_value, None) except exceptions.ValidationError as e: self.stderr.write("Error: %s" % '; '.join(e.messages)) user_data[field_name] = None # Get a password while password is None: if not password: password = getpass.getpass() password2 = getpass.getpass( force_str('Password (again): ')) if password != password2: self.stderr.write( "Error: Your passwords didn't match.") password = None continue if password.strip() == '': self.stderr.write( "Error: Blank passwords aren't allowed.") password = None continue except KeyboardInterrupt: self.stderr.write("\nOperation cancelled.") sys.exit(1) user_data[self.UserModel.USERNAME_FIELD] = username user_data['password'] = password self.UserModel._default_manager.db_manager(database).create_superuser( **user_data) if verbosity >= 1: self.stdout.write("Superuser created successfully.")
def test_existing(self): models.User.objects.create(username='******') management.get_system_username = lambda: 'joe' self.assertEqual(management.get_default_username(), '') self.assertEqual( management.get_default_username(check_db=False), 'joe')
def handle(self, *args, **options): username = options.get('username', None) interactive = options.get('interactive') verbosity = int(options.get('verbosity', 1)) database = options.get('database') UserModel = get_user_model() username_field = UserModel._meta.get_field(getattr(UserModel, 'USERNAME_FIELD', 'username')) other_fields = UserModel.REQUIRED_FIELDS # If not provided, create the user with an unusable password password = None other_data = {} # Do quick and dirty validation if --noinput if not interactive: try: if not username: raise CommandError("You must use --username with --noinput.") username = username_field.clean(username, None) for field_name in other_fields: if options.get(field_name): field = UserModel._meta.get_field(field_name) other_data[field_name] = field.clean(options[field_name], None) else: raise CommandError("You must use --%s with --noinput." % field_name) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) else: # 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. default_username = get_default_username() try: # Get a username while username is None: username_field = UserModel._meta.get_field(getattr(UserModel, 'USERNAME_FIELD', 'username')) if not username: input_msg = capfirst(username_field.verbose_name) if default_username: input_msg += ' (leave blank to use %r)' % default_username raw_value = input(input_msg + ': ') if default_username and raw_value == '': username = default_username try: username = username_field.clean(raw_value, None) except exceptions.ValidationError as e: self.stderr.write("Error: %s" % '; '.join(e.messages)) username = None continue try: UserModel.objects.using(database).get(**{ getattr(UserModel, 'USERNAME_FIELD', 'username'): username }) except UserModel.DoesNotExist: pass else: self.stderr.write("Error: That username is already taken.") username = None for field_name in other_fields: field = UserModel._meta.get_field(field_name) other_data[field_name] = options.get(field_name) while other_data[field_name] is None: raw_value = input(capfirst(field.verbose_name + ': ')) try: other_data[field_name] = field.clean(raw_value, None) except exceptions.ValidationError as e: self.stderr.write("Error: %s" % '; '.join(e.messages)) other_data[field_name] = None # Get a password while password is None: if not password: password = getpass.getpass() password2 = getpass.getpass('Password (again): ') if password != password2: self.stderr.write("Error: Your passwords didn't match.") password = None continue if password.strip() == '': self.stderr.write("Error: Blank passwords aren't allowed.") password = None continue except KeyboardInterrupt: self.stderr.write("\nOperation cancelled.") sys.exit(1) UserModel.objects.db_manager(database).create_superuser(username=username, password=password, **other_data) if verbosity >= 1: self.stdout.write("Superuser created successfully.")
def handle(self, *args, **options): """ Check the parameters and do the job. """ from django.conf import settings translation.activate(settings.LANGUAGE_CODE) username = options.get(self.UserModel.USERNAME_FIELD, None) interactive = options.get('interactive') verbosity = int(options.get('verbosity', 1)) database = options.get('database') # If not provided, create the user with an unusable password password = None user_data = {} # Do quick and dirty validation if --noinput if not interactive: try: if not username: raise CommandError( 'You must use --%s with --noinput.' % self.UserModel.USERNAME_FIELD) username = self.username_field.clean(username, None) for field_name in self.UserModel.REQUIRED_FIELDS: if options.get(field_name): field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean( options[field_name], None) else: raise CommandError( "You must use --%s with --noinput." % field_name) except exceptions.ValidationError as validation_error: raise CommandError('; '.join(validation_error.messages)) else: # 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. default_username = get_default_username() try: if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException("Not running in a TTY") # Get a username verbose_field_name = self.username_field.verbose_name while username is None: if not username: input_msg = capfirst(verbose_field_name) if default_username: input_msg = ( "%s (leave blank to use '%s'" ")" % (input_msg, default_username)) raw_value = input(force_str('%s: ' % input_msg)) if default_username and raw_value == '': raw_value = default_username try: username = self.username_field.clean(raw_value, None) except exceptions.ValidationError as validation_error: self.stderr.write("Error: %s" % '; '.join( validation_error.messages)) username = None continue try: self.UserModel._default_manager.db_manager( database).get_by_natural_key(username) except self.UserModel.DoesNotExist: pass else: self.stderr.write( "Error: That %s is already taken, please select " "another." % verbose_field_name) username = None # Retrieve required parameters and check them for field_name in self.UserModel.REQUIRED_FIELDS: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = options.get(field_name) while user_data[field_name] is None: if field.choices: choices = force_str( '%s choices:' '\n' % capfirst(field.verbose_name)) index = 0 for key, value in field.choices: index += 1 choices += '\n'.join( [' %s --> %s (%s)\n' % ( index, value, key)]) val = input('%s %s: ' % ( force_str(choices), capfirst(field.verbose_name))) if val == '': self.stderr.write( "Invalid choice: empty value. Select a " "valid choice.") user_data[field_name] = None continue try: if (int(val) < 1 or int(val) > len(field.choices)): self.stderr.write( "Invalid choice: select a valid " "choice between 1 and %d. \'%s\' in " "not one of the available choices" "." % (len(field.choices), val)) user_data[field_name] = None continue raw_value = field.choices[(int(val) - 1)][0] except (ValueError, IndexError): self.stderr.write( "Invalid choice: select a valid choice. " "\'%s\' in not one of the available " "choices." % val) user_data[field_name] = None continue else: raw_value = input(force_str( '%s: ' % capfirst(field.verbose_name))) try: user_data[field_name] = field.clean( raw_value, None) except exceptions.ValidationError as validation_error: self.stderr.write( "Error: %s" % '; '.join( validation_error.messages)) user_data[field_name] = None continue if field.unique: if field_name == 'email': try: ( self.UserModel._default_manager. db_manager(database). get(email=raw_value)) except self.UserModel.DoesNotExist: pass else: self.stderr.write( "Error: That %s is already taken, " "please select " "another." % field.verbose_name) user_data[field_name] = None else: self.stderr.write( "Error: That %s hasn't specific " "validation." % verbose_field_name) user_data[field_name] = None # Get a password while password is None: if not password: password = getpass.getpass() password2 = getpass.getpass( force_str('Password (again): ')) if password != password2: self.stderr.write( "Error: Your passwords didn't match.") password = None continue if password.strip() == '': self.stderr.write( "Error: Blank passwords aren't allowed.") password = None continue except KeyboardInterrupt: self.stderr.write("\nOperation cancelled.") sys.exit(1) except NotRunningInTTYException: self.stderr.write( "OSCM superuser creation skipped due to not running in a " "TTY. You can run `manage.py createoscmsuperuser` in " "your project to create one manually." ) if username: user_data[self.UserModel.USERNAME_FIELD] = username user_data['password'] = password self.UserModel._default_manager.db_manager( database).create_superuser(**user_data) if verbosity >= 1: self.stdout.write("OSCM superuser created successfully.") translation.deactivate()
from django.db import migrations from django.test import TestCase, override_settings from django.utils.translation import gettext_lazy as _ from .models import ( CustomUser, CustomUserNonUniqueUsername, CustomUserWithFK, Email, UserProxy, ) MOCK_INPUT_KEY_TO_PROMPTS = { # @mock_inputs dict key: [expected prompt messages], 'bypass': ['Bypass password validation and create user anyway? [y/N]: '], 'email': ['Email address: '], 'date_of_birth': ['Date of birth: '], 'first_name': ['First name: '], 'username': ['Username: '******'%s'): " % get_default_username()], } def mock_inputs(inputs): """ Decorator to temporarily replace input/getpass to allow interactive createsuperuser. """ def inner(test_func): def wrapped(*args): class mock_getpass: @staticmethod def getpass(prompt=b'Password: '******'password']): return inputs['password']()
def handle(self, *args, **options): username = options[self.UserModel.USERNAME_FIELD] database = options['database'] # If not provided, create the user with an unusable password password = None user_data = {} # Same as user_data but with foreign keys as fake model instances # instead of raw IDs. fake_user_data = {} verbose_field_name = self.username_field.verbose_name # Do quick and dirty validation if --noinput if not options['interactive']: try: if not username: raise CommandError("You must use --%s with --noinput." % self.UserModel.USERNAME_FIELD) username = self.username_field.clean(username, None) for field_name in self.UserModel.REQUIRED_FIELDS: if options[field_name]: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean( options[field_name], None) else: raise CommandError( "You must use --%s with --noinput." % field_name) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) else: # Prompt for username/password, and any other required fields. # Enclose this whole thing in a try/except to catch # KeyboardInterrupt and exit gracefully. default_username = get_default_username() try: if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException("Not running in a TTY") # Get a username while username is None: input_msg = capfirst(verbose_field_name) if default_username: input_msg += " (leave blank to use '%s')" % default_username username_rel = self.username_field.remote_field input_msg = '%s%s: ' % ( input_msg, ' (%s.%s)' % (username_rel.model._meta.object_name, username_rel.field_name) if username_rel else '') username = self.get_input_data(self.username_field, input_msg, default_username) if not username: continue if self.username_field.unique: try: self.UserModel._default_manager.db_manager( database).get_by_natural_key(username) except self.UserModel.DoesNotExist: pass else: self.stderr.write( "Error: That %s is already taken." % verbose_field_name) username = None if not username: raise CommandError('%s cannot be blank.' % capfirst(verbose_field_name)) for field_name in self.UserModel.REQUIRED_FIELDS: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = options[field_name] while user_data[field_name] is None: message = '%s%s: ' % ( capfirst(field.verbose_name), ' (%s.%s)' % ( field.remote_field.model._meta.object_name, field.remote_field.field_name, ) if field.remote_field else '', ) input_value = self.get_input_data(field, message) user_data[field_name] = input_value fake_user_data[field_name] = input_value # Wrap any foreign keys in fake model instances if field.remote_field: fake_user_data[ field_name] = field.remote_field.model( input_value) # Get a password while password is None: password = getpass.getpass() password2 = getpass.getpass('Password (again): ') if password != password2: self.stderr.write( "Error: Your passwords didn't match.") password = None # Don't validate passwords that don't match. continue if password.strip() == '': self.stderr.write( "Error: Blank passwords aren't allowed.") password = None # Don't validate blank passwords. continue try: validate_password(password2, self.UserModel(**fake_user_data)) except exceptions.ValidationError as err: self.stderr.write('\n'.join(err.messages)) response = input( 'Bypass password validation and create user anyway? [y/N]: ' ) if response.lower() != 'y': password = None 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.") if username: user_data[self.UserModel.USERNAME_FIELD] = username user_data['password'] = password self.UserModel._default_manager.db_manager( database).create_superuser(**user_data) if options['verbosity'] >= 1: # Added to create corresponding player profile. u = User.objects.get_or_create(username=username)[0] while u.first_name is "": u.first_name = input("First name: ") while u.last_name is "": u.last_name = input("Last name: ") u.save() p = Player.objects.get_or_create(user=u)[0] p.gender = 1 p.host_rating = 0 p.num_host_ratings = 0 p.punctuality = 0 p.likeability = 0 p.skill = 0 p.num_player_ratings = 0 p.save() self.stdout.write("Superuser created successfully.") self.stdout.write( "A basic player profile has been added. If you wish to edit the details, please visit the admin page." )
def handle(self, *args, **options): username = options.get('username', None) interactive = options.get('interactive') verbosity = int(options.get('verbosity', 1)) database = options.get('database') UserModel = get_user_model() username_field = UserModel._meta.get_field( getattr(UserModel, 'USERNAME_FIELD', 'username')) other_fields = UserModel.REQUIRED_FIELDS # If not provided, create the user with an unusable password password = None other_data = {} # Do quick and dirty validation if --noinput if not interactive: try: if not username: raise CommandError( "You must use --username with --noinput.") username = username_field.clean(username, None) for field_name in other_fields: if options.get(field_name): field = UserModel._meta.get_field(field_name) other_data[field_name] = field.clean( options[field_name], None) else: raise CommandError( "You must use --%s with --noinput." % field_name) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) else: # 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. default_username = get_default_username() try: # Get a username while username is None: username_field = UserModel._meta.get_field( getattr(UserModel, 'USERNAME_FIELD', 'username')) if not username: input_msg = capfirst(username_field.verbose_name) if default_username: input_msg += ' (leave blank to use %r)' % default_username raw_value = input(input_msg + ': ') if default_username and raw_value == '': username = default_username try: username = username_field.clean(raw_value, None) except exceptions.ValidationError as e: self.stderr.write("Error: %s" % '; '.join(e.messages)) username = None continue try: UserModel.objects.using(database).get( **{ getattr(UserModel, 'USERNAME_FIELD', 'username'): username }) except UserModel.DoesNotExist: pass else: self.stderr.write( "Error: That username is already taken.") username = None for field_name in other_fields: field = UserModel._meta.get_field(field_name) other_data[field_name] = options.get(field_name) while other_data[field_name] is None: raw_value = input(capfirst(field.verbose_name + ': ')) try: other_data[field_name] = field.clean( raw_value, None) except exceptions.ValidationError as e: self.stderr.write("Error: %s" % '; '.join(e.messages)) other_data[field_name] = None # Get a password while password is None: if not password: password = getpass.getpass() password2 = getpass.getpass('Password (again): ') if password != password2: self.stderr.write( "Error: Your passwords didn't match.") password = None continue if password.strip() == '': self.stderr.write( "Error: Blank passwords aren't allowed.") password = None continue except KeyboardInterrupt: self.stderr.write("\nOperation cancelled.") sys.exit(1) UserModel.objects.db_manager(database).create_superuser( username=username, password=password, **other_data) if verbosity >= 1: self.stdout.write("Superuser created successfully.")
def handle(self, *args, **options): username = options[self.UserModel.USERNAME_FIELD] database = options['database'] user_data = {} verbose_field_name = self.username_field.verbose_name try: self.UserModel._meta.get_field(PASSWORD_FIELD) except exceptions.FieldDoesNotExist: pass else: # If not provided, create the user with an unusable password. user_data[PASSWORD_FIELD] = None try: if options['interactive']: # Same as user_data but with foreign keys as fake model # instances instead of raw IDs. fake_user_data = {} if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException default_username = get_default_username() if username: error_msg = self._validate_username(username, verbose_field_name, database) if error_msg: self.stderr.write(error_msg) username = None elif username == '': raise CommandError('%s cannot be blank.' % capfirst(verbose_field_name)) # Prompt for username. while username is None: message = self._get_input_message(self.username_field, default_username) username = self.get_input_data(self.username_field, message, default_username) if username: error_msg = self._validate_username(username, verbose_field_name, database) if error_msg: self.stderr.write(error_msg) username = None continue user_data[self.UserModel.USERNAME_FIELD] = username fake_user_data[self.UserModel.USERNAME_FIELD] = ( self.username_field.remote_field.model(username) if self.username_field.remote_field else username ) # Prompt for required fields. for field_name in self.UserModel.REQUIRED_FIELDS: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = options[field_name] while user_data[field_name] is None: message = self._get_input_message(field) input_value = self.get_input_data(field, message) user_data[field_name] = input_value fake_user_data[field_name] = input_value # Wrap any foreign keys in fake model instances if field.remote_field: fake_user_data[field_name] = field.remote_field.model(input_value) # Prompt for a password if the model has one. while PASSWORD_FIELD in user_data and user_data[PASSWORD_FIELD] is None: password = getpass.getpass() password2 = getpass.getpass('Password (again): ') if password != password2: self.stderr.write("Error: Your passwords didn't match.") # Don't validate passwords that don't match. continue if password.strip() == '': self.stderr.write("Error: Blank passwords aren't allowed.") # Don't validate blank passwords. continue user_data[PASSWORD_FIELD] = password else: # Non-interactive mode. if username is None: raise CommandError('You must use --%s with --noinput.' % self.UserModel.USERNAME_FIELD) else: error_msg = self._validate_username(username, verbose_field_name, database) if error_msg: raise CommandError(error_msg) user_data[self.UserModel.USERNAME_FIELD] = username for field_name in self.UserModel.REQUIRED_FIELDS: if options[field_name]: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean(options[field_name], None) else: raise CommandError('You must use --%s with --noinput.' % field_name) self.UserModel._default_manager.db_manager(database).create_superuser(**user_data) if options['verbosity'] >= 1: self.stdout.write("Superuser created successfully.") except KeyboardInterrupt: self.stderr.write('\nOperation cancelled.') sys.exit(1) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) 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 handle(self, *args, **options): username = options.get(self.UserModel.USERNAME_FIELD, None) interactive = options.get('interactive') verbosity = int(options.get('verbosity', 1)) database = options.get('database') # If not provided, create the user with an unusable password user_data = {} # Do quick and dirty validation if --noinput if not interactive: try: if not username: raise CommandError("You must use --%s with --noinput." % self.UserModel.USERNAME_FIELD) username = self.username_field.clean(username, None) for field_name in self.UserModel.REQUIRED_FIELDS: if options.get(field_name): field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean(options[field_name], None) else: raise CommandError("You must use --%s with --noinput." % field_name) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) else: # 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. default_username = get_default_username() try: if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException("Not running in a TTY") # Get a username verbose_field_name = self.username_field.verbose_name while username is None: if not username: input_msg = capfirst(verbose_field_name) if default_username: input_msg = "%s (leave blank to use '%s')" % ( input_msg, default_username) raw_value = input(force_str('%s: ' % input_msg)) if default_username and raw_value == '': raw_value = default_username try: username = self.username_field.clean(raw_value, None) except exceptions.ValidationError as e: self.stderr.write("Error: %s" % '; '.join(e.messages)) username = None continue try: self.UserModel._default_manager.db_manager(database).get_by_natural_key(username) except self.UserModel.DoesNotExist: pass else: self.stderr.write("Error: That %s is already taken." % verbose_field_name) username = None for field_name in self.UserModel.REQUIRED_FIELDS: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = options.get(field_name) while user_data[field_name] is None: raw_value = input(force_str('%s: ' % capfirst(field.verbose_name))) try: user_data[field_name] = field.clean(raw_value, None) except exceptions.ValidationError as e: self.stderr.write("Error: %s" % '; '.join(e.messages)) user_data[field_name] = None 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." ) if username: user_data[self.UserModel.USERNAME_FIELD] = username self.UserModel._default_manager.db_manager(database).create_superuser(**user_data) if verbosity >= 1: self.stdout.write("Superuser created successfully.")
def handle(self, *args, **options): username = options.get(self.UserModel.USERNAME_FIELD, None) interactive = options.get('interactive') verbosity = int(options.get('verbosity', 1)) database = options.get('database') # If not provided, create the user with an unusable password user_data = {} # Do quick and dirty validation if --noinput if not interactive: try: if not username: raise CommandError("You must use --%s with --noinput." % self.UserModel.USERNAME_FIELD) username = self.username_field.clean(username, None) for field_name in self.UserModel.REQUIRED_FIELDS: if options.get(field_name): field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean( options[field_name], None) else: raise CommandError( "You must use --%s with --noinput." % field_name) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) else: # 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. default_username = get_default_username() try: if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException("Not running in a TTY") # Get a username verbose_field_name = self.username_field.verbose_name while username is None: if not username: input_msg = capfirst(verbose_field_name) if default_username: input_msg = "%s (leave blank to use '%s')" % ( input_msg, default_username) raw_value = input(force_str('%s: ' % input_msg)) if default_username and raw_value == '': raw_value = default_username try: username = self.username_field.clean(raw_value, None) except exceptions.ValidationError as e: self.stderr.write("Error: %s" % '; '.join(e.messages)) username = None continue try: self.UserModel._default_manager.db_manager( database).get_by_natural_key(username) except self.UserModel.DoesNotExist: pass else: self.stderr.write("Error: That %s is already taken." % verbose_field_name) username = None for field_name in self.UserModel.REQUIRED_FIELDS: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = options.get(field_name) while user_data[field_name] is None: raw_value = input( force_str('%s: ' % capfirst(field.verbose_name))) try: user_data[field_name] = field.clean( raw_value, None) except exceptions.ValidationError as e: self.stderr.write("Error: %s" % '; '.join(e.messages)) user_data[field_name] = None 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.") if username: user_data[self.UserModel.USERNAME_FIELD] = username self.UserModel._default_manager.db_manager( database).create_superuser(**user_data) if verbosity >= 1: self.stdout.write("Superuser created successfully.")
def handle(self, *args, **options): username = options[self.UserModel.USERNAME_FIELD] password = options['password'] database = options['database'] user_data = {} verbose_field_name = self.username_field.verbose_name try: self.UserModel._meta.get_field(PASSWORD_FIELD) except exceptions.FieldDoesNotExist: pass else: # If not provided, create the user with an unusable password. user_data[PASSWORD_FIELD] = None try: if options['interactive']: # Same as user_data but with foreign keys as fake model # instances instead of raw IDs. fake_user_data = {} if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException default_username = get_default_username() if username: error_msg = self._validate_username( username, verbose_field_name, database) if error_msg: self.stderr.write(error_msg) username = None elif username == '': raise CommandError('%s cannot be blank.' % capfirst(verbose_field_name)) # Prompt for username. while username is None: message = self._get_input_message(self.username_field, default_username) username = self.get_input_data(self.username_field, message, default_username) if username: error_msg = self._validate_username( username, verbose_field_name, database) if error_msg: self.stderr.write(error_msg) username = None continue user_data[self.UserModel.USERNAME_FIELD] = username fake_user_data[self.UserModel.USERNAME_FIELD] = ( self.username_field.remote_field.model(username) if self.username_field.remote_field else username) # Prompt for required fields. for field_name in self.UserModel.REQUIRED_FIELDS: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = options[field_name] while user_data[field_name] is None: message = self._get_input_message(field) input_value = self.get_input_data(field, message) user_data[field_name] = input_value fake_user_data[field_name] = input_value # Wrap any foreign keys in fake model instances if field.remote_field: fake_user_data[ field_name] = field.remote_field.model( input_value) # Prompt for a password if the model has one. while PASSWORD_FIELD in user_data and user_data[ PASSWORD_FIELD] is None: password = getpass.getpass() password2 = getpass.getpass('Password (again): ') if password != password2: self.stderr.write( "Error: Your passwords didn't match.") # Don't validate passwords that don't match. continue if password.strip() == '': self.stderr.write( "Error: Blank passwords aren't allowed.") # Don't validate blank passwords. continue try: validate_password(password2, self.UserModel(**fake_user_data)) except exceptions.ValidationError as err: self.stderr.write('\n'.join(err.messages)) response = input( 'Bypass password validation and create user anyway? [y/N]: ' ) if response.lower() != 'y': continue user_data[PASSWORD_FIELD] = password else: # Non-interactive mode. if username is None: raise CommandError('You must use --%s with --noinput.' % self.UserModel.USERNAME_FIELD) else: error_msg = self._validate_username( username, verbose_field_name, database) if error_msg: raise CommandError(error_msg) if password and not username: raise CommandError( "--username is required if you wanto to specify --password" ) if password: user_data[PASSWORD_FIELD] = password user_data[self.UserModel.USERNAME_FIELD] = username for field_name in self.UserModel.REQUIRED_FIELDS: if options[field_name]: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean( options[field_name], None) else: raise CommandError( 'You must use --%s with --noinput.' % field_name) self.UserModel._default_manager.db_manager( database).create_superuser(**user_data) res = db.social.find_one({'name': 'admin', '@type': 'WG'}) if res == None: idWg = db.social.insert_one({ 'name': 'admin', '@type': 'WG', 'acl': { 'r': [], 'w': [], 'o': [] }, 'users': [user_data[self.UserModel.USERNAME_FIELD]] }).inserted_id else: idWg = res['_id'] db.social.update_one({'_id': idWg}, { '$addToSet': { 'users': user_data[self.UserModel.USERNAME_FIELD], 'acl.w': idWg } }) adminProfile = { '_id': user_data[self.UserModel.USERNAME_FIELD], '@type': 'Person', 'perm': { 'w': {}, 'b': {} }, 'acl': { 'r': [], 'w': [idWg], 'o': [] } } db.user.insert_one(adminProfile) if options['verbosity'] >= 1: self.stdout.write("Superuser created successfully.") except KeyboardInterrupt: self.stderr.write('\nOperation cancelled.') sys.exit(1) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) 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 handle(self, *args, **options): from tendenci.apps.profiles.models import Profile username = options.get('username', None) email = options.get('email', None) interactive = options.get('interactive') verbosity = int(options.get('verbosity', 1)) database = options.get('database') # Do quick and dirty validation if --noinput if not interactive: if not username or not email: raise CommandError("You must use --username and --email with --noinput.") if not RE_VALID_USERNAME.match(username): raise CommandError("Invalid username. Use only letters, digits, and underscores") try: is_valid_email(email) except exceptions.ValidationError: raise CommandError("Invalid email address.") # If not provided, create the user with an unusable password password = None # Prompt for username/email/password. Enclose this whole thing in a # try/except to trap for a keyboard interrupt and exit gracefully. if interactive: default_username = get_default_username() try: # Get a username while 1: if not username: input_msg = 'Username' if default_username: input_msg += ' (leave blank to use %r)' % default_username username = raw_input(input_msg + ': ') if default_username and username == '': username = default_username if not RE_VALID_USERNAME.match(username): sys.stderr.write("Error: That username is invalid. Use only letters, digits and underscores.\n") username = None continue try: User.objects.using(database).get(username=username) except User.DoesNotExist: break else: sys.stderr.write("Error: That username is already taken.\n") username = None # Get an email while 1: if not email: email = raw_input('E-mail address: ') try: is_valid_email(email) except exceptions.ValidationError: sys.stderr.write("Error: That e-mail address is invalid.\n") email = None else: break # Get a password while 1: if not password: password = getpass.getpass() password2 = getpass.getpass('Password (again): ') if password != password2: sys.stderr.write("Error: Your passwords didn't match.\n") password = None continue if password.strip() == '': sys.stderr.write("Error: Blank passwords aren't allowed.\n") password = None continue break except KeyboardInterrupt: sys.stderr.write("\nOperation cancelled.\n") sys.exit(1) user = User.objects.db_manager(database).create_user(username, email, password) Profile.objects.create_profile(user) if verbosity >= 1: print 'User %s (%s) created successfully' % (user.username, user.pk)
def handle(self, *args, **options): username = options[self.UserModel.USERNAME_FIELD] database = options['database'] user_data = {} verbose_field_name = self.username_field.verbose_name try: self.UserModel._meta.get_field(PASSWORD_FIELD) except exceptions.FieldDoesNotExist: pass else: # If not provided, create the user with an unusable password. user_data[PASSWORD_FIELD] = None try: if options['interactive']: # Same as user_data but with foreign keys as fake model # instances instead of raw IDs. fake_user_data = {} if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException default_username = get_default_username() if username: error_msg = self._validate_username(username, verbose_field_name, database) if error_msg: self.stderr.write(error_msg) username = None elif username == '': raise CommandError('%s cannot be blank.' % capfirst(verbose_field_name)) # Prompt for username. while username is None: message = self._get_input_message(self.username_field, default_username) username = self.get_input_data(self.username_field, message, default_username) if username: error_msg = self._validate_username(username, verbose_field_name, database) if error_msg: self.stderr.write(error_msg) username = None continue user_data[self.UserModel.USERNAME_FIELD] = username fake_user_data[self.UserModel.USERNAME_FIELD] = ( self.username_field.remote_field.model(username) if self.username_field.remote_field else username ) # Prompt for required fields. for field_name in self.UserModel.REQUIRED_FIELDS: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = options[field_name] while user_data[field_name] is None: message = self._get_input_message(field) input_value = self.get_input_data(field, message) user_data[field_name] = input_value fake_user_data[field_name] = input_value # Wrap any foreign keys in fake model instances if field.remote_field: fake_user_data[field_name] = field.remote_field.model(input_value) # Prompt for a password if the model has one. while PASSWORD_FIELD in user_data and user_data[PASSWORD_FIELD] is None: password = getpass.getpass() password2 = getpass.getpass('Password (again): ') if password != password2: self.stderr.write("Error: Your passwords didn't match.") # Don't validate passwords that don't match. continue if password.strip() == '': self.stderr.write("Error: Blank passwords aren't allowed.") # Don't validate blank passwords. continue try: validate_password(password2, self.UserModel(**fake_user_data)) except exceptions.ValidationError as err: self.stderr.write('\n'.join(err.messages)) response = input('Bypass password validation and create user anyway? [y/N]: ') if response.lower() != 'y': continue user_data[PASSWORD_FIELD] = password else: # Non-interactive mode. if username is None: raise CommandError('You must use --%s with --noinput.' % self.UserModel.USERNAME_FIELD) else: error_msg = self._validate_username(username, verbose_field_name, database) if error_msg: raise CommandError(error_msg) user_data[self.UserModel.USERNAME_FIELD] = username for field_name in self.UserModel.REQUIRED_FIELDS: if options[field_name]: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean(options[field_name], None) else: raise CommandError('You must use --%s with --noinput.' % field_name) self.UserModel._default_manager.db_manager(database).create_superuser(**user_data) if options['verbosity'] >= 1: self.stdout.write("Superuser created successfully.") except KeyboardInterrupt: self.stderr.write('\nOperation cancelled.') sys.exit(1) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) 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 handle(self, *args, **options): username = options.get(self.UserModel.USERNAME_FIELD, None) interactive = options.get('interactive') verbosity = int(options.get('verbosity', 1)) database = options.get('database') # If not provided, create the user with an unusable password password = None user_data = {} # Do quick and dirty validation if --noinput if not interactive: try: if not username: raise CommandError("You must use --%s with --noinput." % self.UserModel.USERNAME_FIELD) username = self.username_field.clean(username, None) for field_name in self.UserModel.REQUIRED_FIELDS: if options.get(field_name): field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean(options[field_name], None) else: raise CommandError("You must use --%s with --noinput." % field_name) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) else: # 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. default_username = get_default_username() try: # Get a username verbose_field_name = self.username_field.verbose_name while username is None: if not username: input_msg = capfirst(verbose_field_name) if default_username: input_msg = "%s (leave blank to use '%s')" % ( input_msg, default_username) raw_value = input(force_str('%s: ' % input_msg)) if default_username and raw_value == '': raw_value = default_username try: username = self.username_field.clean(raw_value, None) except exceptions.ValidationError as e: self.stderr.write("Error: %s" % '; '.join(e.messages)) username = None continue try: self.UserModel._default_manager.db_manager(database).get_by_natural_key(username) except self.UserModel.DoesNotExist: pass else: self.stderr.write("Error: That %s is already taken." % verbose_field_name) username = None for field_name in self.UserModel.REQUIRED_FIELDS: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = options.get(field_name) while user_data[field_name] is None: raw_value = input(force_str('%s: ' % capfirst(field.verbose_name))) try: user_data[field_name] = field.clean(raw_value, None) except exceptions.ValidationError as e: self.stderr.write("Error: %s" % '; '.join(e.messages)) user_data[field_name] = None # Get a password while password is None: if not password: password = getpass.getpass() password2 = getpass.getpass('Password (again): ') if password != password2: self.stderr.write("Error: Your passwords didn't match.") password = None continue if password.strip() == '': self.stderr.write("Error: Blank passwords aren't allowed.") password = None continue except KeyboardInterrupt: self.stderr.write("\nOperation cancelled.") sys.exit(1) user_data[self.UserModel.USERNAME_FIELD] = username user_data['password'] = password self.UserModel._default_manager.db_manager(database).create_superuser(**user_data) if verbosity >= 1: self.stdout.write("Superuser created successfully.")
def handle(self, *args, **options): username = options[self.UserModel.USERNAME_FIELD] database = options['database'] user_data = {} verbose_field_name = self.username_field.verbose_name try: self.UserModel._meta.get_field(PASSWORD_FIELD) except exceptions.FieldDoesNotExist: pass else: # If not provided, create the user with an unusable password. user_data[PASSWORD_FIELD] = None try: if options['interactive']: # Same as user_data but without many to many fields and with # foreign keys as fake model instances instead of raw IDs. fake_user_data = {} if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException default_username = get_default_username() if username: error_msg = self._validate_username( username, verbose_field_name, database) if error_msg: self.stderr.write(error_msg) username = None elif username == '': raise CommandError('%s cannot be blank.' % capfirst(verbose_field_name)) # Prompt for username. while username is None: message = self._get_input_message(self.username_field, default_username) username = self.get_input_data(self.username_field, message, default_username) if username: error_msg = self._validate_username( username, verbose_field_name, database) if error_msg: self.stderr.write(error_msg) username = None continue user_data[self.UserModel.USERNAME_FIELD] = username fake_user_data[self.UserModel.USERNAME_FIELD] = ( self.username_field.remote_field.model(username) if self.username_field.remote_field else username) # Prompt for required fields. for field_name in self.UserModel.REQUIRED_FIELDS: field = self.UserModel._meta.get_field(field_name) user_data[field_name] = options[field_name] while user_data[field_name] is None: message = self._get_input_message(field) input_value = self.get_input_data(field, message) user_data[field_name] = input_value if field.many_to_many and input_value: if not input_value.strip(): user_data[field_name] = None self.stderr.write( 'Error: This field cannot be blank.') continue user_data[field_name] = [ pk.strip() for pk in input_value.split(',') ] if not field.many_to_many: fake_user_data[field_name] = input_value # Wrap any foreign keys in fake model instances if field.many_to_one: fake_user_data[ field_name] = field.remote_field.model( input_value) # Prompt for a password if the model has one. while PASSWORD_FIELD in user_data and user_data[ PASSWORD_FIELD] is None: password = getpass.getpass() password2 = getpass.getpass('Password (again): ') if password != password2: self.stderr.write( "Error: Your passwords didn't match.") # Don't validate passwords that don't match. continue if password.strip() == '': self.stderr.write( "Error: Blank passwords aren't allowed.") # Don't validate blank passwords. continue try: validate_password(password2, self.UserModel(**fake_user_data)) except exceptions.ValidationError as err: self.stderr.write('\n'.join(err.messages)) response = input( 'Bypass password validation and create user anyway? [y/N]: ' ) if response.lower() != 'y': continue user_data[PASSWORD_FIELD] = password else: # Non-interactive mode. # Use password from environment variable, if provided. if PASSWORD_FIELD in user_data and 'DJANGO_SUPERUSER_PASSWORD' in os.environ: user_data[PASSWORD_FIELD] = os.environ[ 'DJANGO_SUPERUSER_PASSWORD'] # Use username from environment variable, if not provided in # options. if username is None: username = os.environ.get( 'DJANGO_SUPERUSER_' + self.UserModel.USERNAME_FIELD.upper()) if username is None: raise CommandError('You must use --%s with --noinput.' % self.UserModel.USERNAME_FIELD) else: error_msg = self._validate_username( username, verbose_field_name, database) if error_msg: raise CommandError(error_msg) user_data[self.UserModel.USERNAME_FIELD] = username for field_name in self.UserModel.REQUIRED_FIELDS: env_var = 'DJANGO_SUPERUSER_' + field_name.upper() value = options[field_name] or os.environ.get(env_var) if not value: raise CommandError( 'You must use --%s with --noinput.' % field_name) field = self.UserModel._meta.get_field(field_name) user_data[field_name] = field.clean(value, None) self.UserModel._default_manager.db_manager( database).create_superuser(**user_data) if options['verbosity'] >= 1: self.stdout.write("Superuser created successfully.") except KeyboardInterrupt: self.stderr.write('\nOperation cancelled.') sys.exit(1) except exceptions.ValidationError as e: raise CommandError('; '.join(e.messages)) 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 handle(self, *args, **options): from tendenci.apps.profiles.models import Profile username = options.get('username', None) email = options.get('email', None) interactive = options.get('interactive') verbosity = int(options.get('verbosity', 1)) database = options.get('database') # Do quick and dirty validation if --noinput if not interactive: if not username or not email: raise CommandError( "You must use --username and --email with --noinput.") if not RE_VALID_USERNAME.match(username): raise CommandError( "Invalid username. Use only letters, digits, and underscores" ) try: is_valid_email(email) except exceptions.ValidationError: raise CommandError("Invalid email address.") # If not provided, create the user with an unusable password password = None # Prompt for username/email/password. Enclose this whole thing in a # try/except to trap for a keyboard interrupt and exit gracefully. if interactive: default_username = get_default_username() try: # Get a username while 1: if not username: input_msg = 'Username' if default_username: input_msg += ' (leave blank to use %r)' % default_username username = input(input_msg + ': ') if default_username and username == '': username = default_username if not RE_VALID_USERNAME.match(username): sys.stderr.write( "Error: That username is invalid. Use only letters, digits and underscores.\n" ) username = None continue try: User.objects.using(database).get(username=username) except User.DoesNotExist: break else: sys.stderr.write( "Error: That username is already taken.\n") username = None # Get an email while 1: if not email: email = input('E-mail address: ') try: is_valid_email(email) except exceptions.ValidationError: sys.stderr.write( "Error: That e-mail address is invalid.\n") email = None else: break # Get a password while 1: if not password: password = getpass.getpass() password2 = getpass.getpass('Password (again): ') if password != password2: sys.stderr.write( "Error: Your passwords didn't match.\n") password = None continue if password.strip() == '': sys.stderr.write( "Error: Blank passwords aren't allowed.\n") password = None continue break except KeyboardInterrupt: sys.stderr.write("\nOperation cancelled.\n") sys.exit(1) user = User.objects.db_manager(database).create_user( username, email, password) Profile.objects.create_profile(user) if verbosity >= 1: print('User %s (%s) created successfully' % (user.username, user.pk))
def test_simple(self): management.get_system_username = lambda: 'joe' self.assertEqual(management.get_default_username(), 'joe')
CustomUserWithFK, CustomUserWithM2M, Email, Organization, UserProxy, ) MOCK_INPUT_KEY_TO_PROMPTS = { # @mock_inputs dict key: [expected prompt messages], "bypass": ["Bypass password validation and create user anyway? [y/N]: "], "email": ["Email address: "], "date_of_birth": ["Date of birth: "], "first_name": ["First name: "], "username": [ "Username: "******"Username (leave blank to use '%s'): " % get_default_username(), ], } def mock_inputs(inputs): """ Decorator to temporarily replace input/getpass to allow interactive createsuperuser. """ def inner(test_func): def wrapped(*args): class mock_getpass: @staticmethod def getpass(prompt=b"Password: ", stream=None):
def test_i18n(self): # 'Julia' with accented 'u': management.get_system_username = lambda: 'J\xfalia' self.assertEqual(management.get_default_username(), 'julia')
def test_existing(self): User.objects.create(username="******") management.get_system_username = lambda: "joe" self.assertEqual(management.get_default_username(), "") self.assertEqual(management.get_default_username(check_db=False), "joe")
def test_simple(self): management.get_system_username = lambda: 'joe' self.assertEqual(management.get_default_username(), 'joe')
from django.db import migrations from django.test import TestCase, override_settings from django.utils.translation import gettext_lazy as _ from .models import ( CustomUser, CustomUserNonUniqueUsername, CustomUserWithFK, CustomUserWithM2M, Email, Organization, UserProxy, ) MOCK_INPUT_KEY_TO_PROMPTS = { # @mock_inputs dict key: [expected prompt messages], 'bypass': ['Bypass password validation and create user anyway? [y/N]: '], 'email': ['Email address: '], 'date_of_birth': ['Date of birth: '], 'first_name': ['First name: '], 'username': ['Username: '******'%s'): " % get_default_username()], } def mock_inputs(inputs): """ Decorator to temporarily replace input/getpass to allow interactive createsuperuser. """ def inner(test_func): def wrapped(*args): class mock_getpass: @staticmethod def getpass(prompt=b'Password: '******'password']): return inputs['password']()
def test_i18n(self): # 'Julia' with accented 'u': management.get_system_username = lambda: 'J\xfalia' self.assertEqual(management.get_default_username(), 'julia')
def handle(self, *args, **options): username = options[self.username] password = None user_data = {} # Do quick and dirty validation if --noinput if not options['interactive']: if not username: raise CommandError("You must use --%s with --noinput." % self.username) else: # Prompt for username and password # Enclose this whole thing in a try/except to catch # KeyboardInterrupt and exit gracefully. default_username = get_default_username() try: if hasattr(self.stdin, 'isatty') and not self.stdin.isatty(): raise NotRunningInTTYException("Not running in a TTY") # Get a username verbose_field_name = "Username: "******" (leave blank to use '%s')" % default_username username = self.get_input_data(self.username_field, input_msg, default_username) self.User = settings.USER_CLASS(username) if not username: continue self.User.username = username if self.User and self.User.is_valid(): self.stderr.write("Error: That %s is already taken." % verbose_field_name) username = None # Get a password while password is None: password = getpass.getpass() password2 = getpass.getpass(force_str('Password (again): ')) if password != password2: self.stderr.write("Error: Your passwords didn't match.") password = None # Don't validate passwords that don't match. continue if password.strip() == '': self.stderr.write("Error: Blank passwords aren't allowed.") password = None # Don't validate blank passwords. continue except KeyboardInterrupt: self.stderr.write("\nOperation cancelled.") sys.exit(1) except NotRunningInTTYException: self.stdout.write( "User creation skipped due to not running in a TTY. " "You can run `manage.py createuser` in your project " "to create one manually." ) if username: self.User = settings.USER_CLASS(username) user_data['password'] = password if not self.User.create(**user_data): raise UserCreationFailed("User creation failed....") if options['verbosity'] >= 1: self.stdout.write("User created successfully.")