Debian Codegraph @

django/contrib/auth/management/commands/createsuperuser.py

raw
1 """
2 Management utility to create superusers.
3 """
4
5 import getpass
6 import os
7 import sys
8
9 from django.contrib.auth import get_user_model
10 from django.contrib.auth.management import get_default_username
11 from django.contrib.auth.password_validation import validate_password
12 from django.core import exceptions
13 from django.core.management.base import BaseCommand, CommandError
14 from django.db import DEFAULT_DB_ALIAS, connections
15 from django.utils.functional import cached_property
16 from django.utils.text import capfirst
17
18
19 class NotRunningInTTYException(Exception):
20 pass
21
22
23 PASSWORD_FIELD = "password"
24
25
26 class Command(BaseCommand):
27 help = "Used to create a superuser."
28 requires_migrations_checks = True
29 stealth_options = ("stdin",)
30
31 def __init__(self, *args, **kwargs):
32 super().__init__(*args, **kwargs)
33 self.UserModel = get_user_model()
34 self.username_field = self.UserModel._meta.get_field(
35 self.UserModel.USERNAME_FIELD
36 )
37
38 def add_arguments(self, parser):
39 parser.add_argument(
40 "--%s" % self.UserModel.USERNAME_FIELD,
41 help="Specifies the login for the superuser.",
42 )
43 parser.add_argument(
44 "--noinput",
45 "--no-input",
46 action="store_false",
47 dest="interactive",
48 help=(
49 "Tells Django to NOT prompt the user for input of any kind. "
50 "You must use --%s with --noinput, along with an option for "
51 "any other required field. Superusers created with --noinput will "
52 "not be able to log in until they're given a valid password."
53 % self.UserModel.USERNAME_FIELD
54 ),
55 )
56 parser.add_argument(
57 "--database",
58 default=DEFAULT_DB_ALIAS,
59 choices=tuple(connections),
60 help='Specifies the database to use. Default is "default".',
61 )
62 for field_name in self.UserModel.REQUIRED_FIELDS:
63 field = self.UserModel._meta.get_field(field_name)
64 if field.many_to_many:
65 if (
66 field.remote_field.through
67 and not field.remote_field.through._meta.auto_created
68 ):
69 raise CommandError(
70 "Required field '%s' specifies a many-to-many "
71 "relation through model, which is not supported." % field_name
72 )
73 else:
74 parser.add_argument(
75 "--%s" % field_name,
76 action="append",
77 help=(
78 "Specifies the %s for the superuser. Can be used "
79 "multiple times." % field_name,
80 ),
81 )
82 else:
83 parser.add_argument(
84 "--%s" % field_name,
85 help="Specifies the %s for the superuser." % field_name,
86 )
87
88 def execute(self, *args, **options):
89 self.stdin = options.get("stdin", sys.stdin) # Used for testing
90 return super().execute(*args, **options)
91
92 def handle(self, *args, **options):
93 username = options[self.UserModel.USERNAME_FIELD]
94 database = options["database"]
95 user_data = {}
96 verbose_field_name = self.username_field.verbose_name
97 try:
98 self.UserModel._meta.get_field(PASSWORD_FIELD)
99 except exceptions.FieldDoesNotExist:
100 pass
101 else:
102 # If not provided, create the user with an unusable password.
103 user_data[PASSWORD_FIELD] = None
104 try:
105 if options["interactive"]:
106 # Same as user_data but without many to many fields and with
107 # foreign keys as fake model instances instead of raw IDs.
108 fake_user_data = {}
109 if hasattr(self.stdin, "isatty") and not self.stdin.isatty():
110 raise NotRunningInTTYException
111 default_username = get_default_username(database=database)
112 if username:
113 error_msg = self._validate_username(
114 username, verbose_field_name, database
115 )
116 if error_msg:
117 self.stderr.write(error_msg)
118 username = None
119 elif username == "":
120 raise CommandError(
121 "%s cannot be blank." % capfirst(verbose_field_name)
122 )
123 # Prompt for username.
124 while username is None:
125 message = self._get_input_message(
126 self.username_field, default_username
127 )
128 username = self.get_input_data(
129 self.username_field, message, default_username
130 )
131 if username:
132 error_msg = self._validate_username(
133 username, verbose_field_name, database
134 )
135 if error_msg:
136 self.stderr.write(error_msg)
137 username = None
138 continue
139 user_data[self.UserModel.USERNAME_FIELD] = username
140 fake_user_data[self.UserModel.USERNAME_FIELD] = (
141 self.username_field.remote_field.model(username)
142 if self.username_field.remote_field
143 else username
144 )
145 # Prompt for required fields.
146 for field_name in self.UserModel.REQUIRED_FIELDS:
147 field = self.UserModel._meta.get_field(field_name)
148 user_data[field_name] = options[field_name]
149 if user_data[field_name] is not None:
150 user_data[field_name] = field.clean(user_data[field_name], None)
151 while user_data[field_name] is None:
152 message = self._get_input_message(field)
153 input_value = self.get_input_data(field, message)
154 user_data[field_name] = input_value
155 if field.many_to_many and input_value:
156 if not input_value.strip():
157 user_data[field_name] = None
158 self.stderr.write("Error: This field cannot be blank.")
159 continue
160 user_data[field_name] = [
161 pk.strip() for pk in input_value.split(",")
162 ]
163
164 if not field.many_to_many:
165 fake_user_data[field_name] = user_data[field_name]
166 # Wrap any foreign keys in fake model instances.
167 if field.many_to_one:
168 fake_user_data[field_name] = field.remote_field.model(
169 user_data[field_name]
170 )
171
172 # Prompt for a password if the model has one.
173 while PASSWORD_FIELD in user_data and user_data[PASSWORD_FIELD] is None:
174 password = getpass.getpass()
175 password2 = getpass.getpass("Password (again): ")
176 if password != password2:
177 self.stderr.write("Error: Your passwords didn't match.")
178 # Don't validate passwords that don't match.
179 continue
180 if password.strip() == "":
181 self.stderr.write("Error: Blank passwords aren't allowed.")
182 # Don't validate blank passwords.
183 continue
184 try:
185 validate_password(password2, self.UserModel(**fake_user_data))
186 except exceptions.ValidationError as err:
187 self.stderr.write("\n".join(err.messages))
188 response = input(
189 "Bypass password validation and create user anyway? [y/N]: "
190 )
191 if response.lower() != "y":
192 continue
193 user_data[PASSWORD_FIELD] = password
194 else:
195 # Non-interactive mode.
196 # Use password from environment variable, if provided.
197 if (
198 PASSWORD_FIELD in user_data
199 and "DJANGO_SUPERUSER_PASSWORD" in os.environ
200 ):
201 user_data[PASSWORD_FIELD] = os.environ["DJANGO_SUPERUSER_PASSWORD"]
202 # Use username from environment variable, if not provided in
203 # options.
204 if username is None:
205 username = os.environ.get(
206 "DJANGO_SUPERUSER_" + self.UserModel.USERNAME_FIELD.upper()
207 )
208 if username is None:
209 raise CommandError(
210 "You must use --%s with --noinput."
211 % self.UserModel.USERNAME_FIELD
212 )
213 else:
214 error_msg = self._validate_username(
215 username, verbose_field_name, database
216 )
217 if error_msg:
218 raise CommandError(error_msg)
219
220 user_data[self.UserModel.USERNAME_FIELD] = username
221 for field_name in self.UserModel.REQUIRED_FIELDS:
222 env_var = "DJANGO_SUPERUSER_" + field_name.upper()
223 value = options[field_name] or os.environ.get(env_var)
224 field = self.UserModel._meta.get_field(field_name)
225 if not value:
226 if field.blank and (
227 options[field_name] == "" or os.environ.get(env_var) == ""
228 ):
229 continue
230 raise CommandError(
231 "You must use --%s with --noinput." % field_name
232 )
233 user_data[field_name] = field.clean(value, None)
234 if field.many_to_many and isinstance(user_data[field_name], str):
235 user_data[field_name] = [
236 pk.strip() for pk in user_data[field_name].split(",")
237 ]
238
239 self.UserModel._default_manager.db_manager(database).create_superuser(
240 **user_data
241 )
242 if options["verbosity"] >= 1:
243 self.stdout.write("Superuser created successfully.")
244 except KeyboardInterrupt:
245 self.stderr.write("\nOperation cancelled.")
246 sys.exit(1)
247 except exceptions.ValidationError as e:
248 raise CommandError("; ".join(e.messages))
249 except NotRunningInTTYException:
250 self.stdout.write(
251 "Superuser creation skipped due to not running in a TTY. "
252 "You can run `manage.py createsuperuser` in your project "
253 "to create one manually."
254 )
255
256 def get_input_data(self, field, message, default=None):
257 """
258 Override this method if you want to customize data inputs or
259 validation exceptions.
260 """
261 raw_value = input(message)
262 if default and raw_value == "":
263 raw_value = default
264 try:
265 val = field.clean(raw_value, None)
266 except exceptions.ValidationError as e:
267 self.stderr.write("Error: %s" % "; ".join(e.messages))
268 val = None
269
270 return val
271
272 def _get_input_message(self, field, default=None):
273 return "%s%s%s: " % (
274 capfirst(field.verbose_name),
275 " (leave blank to use '%s')" % default if default else "",
276 (
277 " (%s.%s)"
278 % (
279 field.remote_field.model._meta.object_name,
280 (
281 field.m2m_target_field_name()
282 if field.many_to_many
283 else field.remote_field.field_name
284 ),
285 )
286 if field.remote_field
287 else ""
288 ),
289 )
290
291 @cached_property
292 def username_is_unique(self):
293 if self.username_field.unique:
294 return True
295 return any(
296 len(unique_constraint.fields) == 1
297 and unique_constraint.fields[0] == self.username_field.name
298 for unique_constraint in self.UserModel._meta.total_unique_constraints
299 )
300
301 def _validate_username(self, username, verbose_field_name, database):
302 """Validate username. If invalid, return a string error message."""
303 if self.username_is_unique:
304 try:
305 self.UserModel._default_manager.db_manager(database).get_by_natural_key(
306 username
307 )
308 except self.UserModel.DoesNotExist:
309 pass
310 else:
311 return "Error: That %s is already taken." % verbose_field_name
312 if not username:
313 return "%s cannot be blank." % capfirst(verbose_field_name)
314 try:
315 self.username_field.clean(username, None)
316 except exceptions.ValidationError as e:
317 return "; ".join(e.messages)