def create(num, course_key):
"""Create num users, enrolling them in course_key if it's not None"""
for __ in range(num):
(user, _, _) = _do_create_account(make_random_form())
if course_key is not None:
CourseEnrollment.enroll(user, course_key)
print('Created user {}'.format(user.username))
def _register(post_vars, is_active=True, use_phone_number=False,
use_email=True, request=None):
ret = _do_create_account(post_vars, is_active,
use_phone_number=use_phone_number, use_email=use_email,
request=request)
# if there was an error then return that
# 转化为对应错误码
if isinstance(ret, HttpResponse):
result = json.loads(ret.content)
value = result.get('value')
field = result.get('field')
err_code = error.REGISTER_FAILED
if field == 'username':
if RE_USERNAME_EXIST.match(value):
err_code = error.USERNAME_EXIST
elif RE_USERNAME_CANT_ALL_NUMBER(value):
err_code = error.USERNAME_CANT_ALL_NUMBER
elif field == 'phone_number':
if RE_PHONE_NUMBER_EXIST.match(value):
error_code = error.PHONE_NUMBER_EXIST
elif field == 'email':
if RE_EMAIL_EXIST.match(value):
err_code = error.EMAIL_EXIST
raise error.Error(err_code, value)
else:
return ret
def create(num, course_key):
"""Create num users, enrolling them in course_key if it's not None"""
for __ in range(num):
(user, _, _) = _do_create_account(make_random_form())
if course_key is not None:
CourseEnrollment.enroll(user, course_key)
print('Created user {}'.format(user.username))
def authenticate(self, request=None, token=None):
post_data = {'ticketid':token}
result = requests.get(settings.WIND_VALIDATION, params=post_data)
content_array = result.text.split()
if (content_array[0] == 'yes'):
try:
user = User.objects.prefetch_related("groups").get(email=content_array[1]+'@columbia.edu')
except User.DoesNotExist:
post_override = dict()
post_override['email'] = content_array[1]+'@columbia.edu'
post_override['name'] = content_array[1]
post_override['username'] = content_array[1]
post_override['password'] = ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for x in range(20))
post_override['terms_of_service'] = 'true'
post_override['honor_code'] = 'true'
#create_account(request, post_override)
ret = _do_create_account(post_override)
if isinstance(ret, HttpResponse):
raise Exception("Account creation failed")
(user, profile, registration) = ret
user.is_active = True;
user.save()
return user
else:
logging.error("Bad WIND ticket! Ticket value was: %s" % token)
return None
def authenticate(self, user_email=None, first=None, last=None, token=None, username=None):
if user_email is None or first is None or last is None or token is None:
return None
cursor = connections['cvn_php'].cursor()
# Data retrieval operation - no commit required
cursor.execute("SELECT unix_timestamp(created), email, token FROM django_auth_hack WHERE email=%s AND token=%s", [user_email, token])
row = cursor.fetchone()
if row is not None and row[0] > int(time.time())-86400:
#if token has been found in database and was created less than 1 day ago
try:
user = User.objects.prefetch_related("groups").get(email=user_email)
except User.DoesNotExist:
post_override = dict()
post_override['email'] = user_email
post_override['name'] = first + ' ' + last
post_override['username'] = user_email
post_override['password'] = ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for x in range(20))
post_override['terms_of_service'] = 'true'
post_override['honor_code'] = 'true'
#create_account(request, post_override)
ret = _do_create_account(post_override)
if isinstance(ret, HttpResponse): # if there was an error then return that
return ret
(user, profile, registration) = ret
user.is_active = True;
user.save()
return user
return None
def create(n, course_id):
"""Create n users, enrolling them in course_id if it's not None"""
for i in range(n):
(user, user_profile, _) = _do_create_account(
get_random_post_override())
if course_id is not None:
CourseEnrollment.objects.create(user=user, course_id=course_id)
def handle(self, *args, **options):
username = options['username']
name = options['name']
if not username:
username = options['email'].split('@')[0]
if not name:
name = options['email'].split('@')[0]
post_data = {
'username': username,
'email': options['email'],
'password': options['password'],
'name': name,
'honor_code': u'true',
'terms_of_service': u'true',
}
try:
user, profile, reg = _do_create_account(post_data)
if options['staff']:
user.is_staff = True
user.save()
reg.activate()
reg.save()
create_comments_service_user(user)
except AccountValidationError as e:
print e.message
user = User.objects.get(email=options['email'])
if options['course']:
CourseEnrollment.enroll(user, options['course'], mode=options['mode'])
def create_user(self, access_token):
from student.views import _do_create_account
data = self.user_data(access_token)
data = self.change_user_data(data)
try:
user = User.objects.get(email=data["email"])
except User.DoesNotExist:
form = AccountCreationForm(
data=data,
extra_fields={},
extended_profile_fields={},
enforce_username_neq_password=False,
enforce_password_policy=False,
tos_required=False,
)
(user, profile, registration) = _do_create_account(form)
user.first_name = data['firstname']
user.last_name = data['lastname']
user.is_active = True
user.set_unusable_password()
user.save()
self.enroll_user(user.username, access_token)
return user
def handle(self, *args, **options):
username = options['username']
name = options['name']
if not username:
username = options['email'].split('@')[0]
if not name:
name = options['email'].split('@')[0]
post_data = {
'username': username,
'email': options['email'],
'password': options['password'],
'name': name,
'honor_code': u'true',
'terms_of_service': u'true',
}
# django.utils.translation.get_language() will be used to set the new
# user's preferred language. This line ensures that the result will
# match this installation's default locale. Otherwise, inside a
# management command, it will always return "en-us".
translation.activate(settings.LANGUAGE_CODE)
try:
user, profile, reg = _do_create_account(post_data)
if options['staff']:
user.is_staff = True
user.save()
reg.activate()
reg.save()
create_comments_service_user(user)
except AccountValidationError as e:
print e.message
user = User.objects.get(email=options['email'])
if options['course']:
CourseEnrollment.enroll(user, options['course'], mode=options['mode'])
translation.deactivate()
def handle(self, *args, **options):
username = options['username']
name = options['name']
if not username:
username = options['email'].split('@')[0]
if not name:
name = options['email'].split('@')[0]
post_data = {
'username': username,
'email': options['email'],
'password': options['password'],
'name': name,
'honor_code': u'true',
'terms_of_service': u'true',
}
create_account = _do_create_account(post_data)
if isinstance(create_account, tuple):
user = create_account[0]
if options['staff']:
user.is_staff = True
user.save()
reg = Registration.objects.get(user=user)
reg.activate()
reg.save()
else:
print create_account
user = User.objects.get(email=options['email'])
if options['course']:
CourseEnrollment.enroll(user, options['course'], mode=options['mode'])
def create_user_account(request, params):
params = dict(params.items())
params["password"] = pipeline.make_random_password()
form = AccountCreationForm(
data=params, enforce_username_neq_password=True, enforce_password_policy=False, tos_required=False
)
with transaction.commit_on_success():
# first, create the account
(user, profile, registration) = _do_create_account(form)
uid = params["uid"]
# associate the user with azuread
associate_user(request.backend, uid, user)
# Perform operations that are non-critical parts of account creation
preferences_api.set_user_preference(user, LANGUAGE_KEY, get_language())
# create_comments_service_user(user)
registration.activate()
return {"username": user.username, "email": user.email}
def handle(self, *args, **options):
username = options['username']
name = options['name']
if not username:
username = options['email'].split('@')[0]
if not name:
name = options['email'].split('@')[0]
post_data = {
'username': username,
'email': options['email'],
'password': options['password'],
'name': name,
'honor_code': u'true',
'terms_of_service': u'true',
}
try:
user, profile, reg = _do_create_account(post_data)
if options['staff']:
user.is_staff = True
user.save()
reg.activate()
reg.save()
create_comments_service_user(user)
except AccountValidationError as e:
print e.message
user = User.objects.get(email=options['email'])
if options['course']:
CourseEnrollment.enroll(user,
options['course'],
mode=options['mode'])
def create_user(self, access_token):
from student.views import _do_create_account
data = self.user_data(access_token)
data = self.change_user_data(data)
try:
user = User.objects.get(email=data["email"])
except User.DoesNotExist:
form = AccountCreationForm(
data=data,
extra_fields={},
extended_profile_fields={},
enforce_username_neq_password=False,
enforce_password_policy=False,
tos_required=False,
)
(user, profile, registration) = _do_create_account(form)
user.first_name = data['firstname']
user.last_name = data['lastname']
user.is_active = True
user.set_unusable_password()
user.save()
self.enroll_user(user.username, access_token)
return user
def authenticate(self, request=None, token=None):
post_data = {'ticketid': token}
result = requests.get(settings.WIND_VALIDATION, params=post_data)
content_array = result.text.split()
if (content_array[0] == 'yes'):
try:
user = User.objects.prefetch_related("groups").get(
email=content_array[1] + '@columbia.edu')
except User.DoesNotExist:
post_override = dict()
post_override['email'] = content_array[1] + '@columbia.edu'
post_override['name'] = content_array[1]
post_override['username'] = content_array[1]
post_override['password'] = ''.join(
random.choice(string.ascii_uppercase +
string.ascii_lowercase + string.digits)
for x in range(20))
post_override['terms_of_service'] = 'true'
post_override['honor_code'] = 'true'
#create_account(request, post_override)
ret = _do_create_account(post_override)
if isinstance(ret, HttpResponse):
raise Exception("Account creation failed")
(user, profile, registration) = ret
user.is_active = True
user.save()
return user
else:
logging.error("Bad WIND ticket! Ticket value was: %s" % token)
return None
def handle(self, *args, **options):
username = options['username']
name = options['name']
if not username:
username = options['email'].split('@')[0]
if not name:
name = options['email'].split('@')[0]
post_data = {
'username': username,
'email': options['email'],
'password': options['password'],
'name': name,
'honor_code': u'true',
'terms_of_service': u'true',
}
create_account = _do_create_account(post_data)
if isinstance(create_account, tuple):
user = create_account[0]
if options['staff']:
user.is_staff = True
user.save()
reg = Registration.objects.get(user=user)
reg.activate()
reg.save()
else:
print create_account
user = User.objects.get(email=options['email'])
if options['course']:
CourseEnrollment.enroll(user,
options['course'],
mode=options['mode'])
def create(n, course_key):
"""Create n users, enrolling them in course_key if it's not None"""
for i in range(n):
(user, user_profile,
_) = _do_create_account(get_random_post_override())
if course_key is not None:
CourseEnrollment.enroll(user, course_key)
def create_user(username, password, email, name):
form = AccountCreationForm(data={
'username': username,
'email': email,
'password': password,
'name': name,
},
tos_required=False)
try:
user, _, reg = _do_create_account(form)
reg.activate()
reg.save()
#create_comments_service_user(user) #这会促发网络请求
return user
except AccountValidationError as e:
print e.message
def handle(self, *args, **options):
username = options['username']
name = options['name']
if not username:
username = options['email'].split('@')[0]
if not name:
name = options['email'].split('@')[0]
# parse out the course into a coursekey
if options['course']:
try:
course = CourseKey.from_string(options['course'])
# if it's not a new-style course key, parse it from an old-style
# course key
except InvalidKeyError:
course = SlashSeparatedCourseKey.from_deprecated_string(options['course'])
form = AccountCreationForm(
data={
'username': username,
'email': options['email'],
'password': options['password'],
'name': name,
},
tos_required=False
)
# django.utils.translation.get_language() will be used to set the new
# user's preferred language. This line ensures that the result will
# match this installation's default locale. Otherwise, inside a
# management command, it will always return "en-us".
translation.activate(settings.LANGUAGE_CODE)
try:
user, _, reg = _do_create_account(form)
if options['staff']:
user.is_staff = True
user.save()
reg.activate()
reg.save()
create_comments_service_user(user)
except AccountValidationError as e:
print e.message
user = User.objects.get(email=options['email'])
if options['course']:
CourseEnrollment.enroll(user, course, mode=options['mode'])
translation.deactivate()
def authenticate(self,
user_email=None,
first=None,
last=None,
token=None,
username=None):
if user_email is None or first is None or last is None or token is None:
return None
cursor = connections['cvn_php'].cursor()
# Data retrieval operation - no commit required
cursor.execute(
"SELECT unix_timestamp(created), email, token FROM django_auth_hack WHERE email=%s AND token=%s",
[user_email, token])
row = cursor.fetchone()
if row is not None and row[0] > int(time.time()) - 86400:
#if token has been found in database and was created less than 1 day ago
try:
user = User.objects.prefetch_related("groups").get(
email=user_email)
except User.DoesNotExist:
post_override = dict()
post_override['email'] = user_email
post_override['name'] = first + ' ' + last
post_override['username'] = user_email
post_override['password'] = ''.join(
random.choice(string.ascii_uppercase +
string.ascii_lowercase + string.digits)
for x in range(20))
post_override['terms_of_service'] = 'true'
post_override['honor_code'] = 'true'
#create_account(request, post_override)
ret = _do_create_account(post_override)
if isinstance(ret, HttpResponse
): # if there was an error then return that
return ret
(user, profile, registration) = ret
user.is_active = True
user.save()
return user
return None
def cm_create_new_user(request):
response_format = request.REQUEST.get('format','html')
if response_format == 'json' or 'application/json' in request.META.get('HTTP/ACCEPT','application/json'):
if request.method == 'POST':
if validate_token(request.body, request) is False:
return HttpResponse('Unauthorized', status=401)
try:
form = AccountCreationForm(
data=request.json,
tos_required=False
)
ret = _do_create_account(form)
if isinstance(ret, HttpResponse):
response_body = json.loads(ret.content)
content = {'errors':response_body['value']}
status_code = 422
elif isinstance(ret, tuple):
created_user = User.objects.get(email=ret[0].email)
created_user.is_active = True
created_user.save()
content = {'id':ret[0].email}
status_code = 200
except AccountValidationError:
user = User.objects.get(email=request.json.get('email'))
content = {'id': user.email}
status_code = 200
except:
content = {'errors':'Bad Request'}
status_code = 400
return HttpResponse(content = json.dumps(content), \
content_type = 'application/json', \
status = status_code)
else:
return HttpResponse(content=json.dumps({}), status=404, content_type='application/json')
else:
return HttpResponse(content=json.dumps({}), status=404, content_type='application/json')
def create(num, course_key):
"""Create num users, enrolling them in course_key if it's not None"""
for idx in range(num):
(user, _, _) = _do_create_account(make_random_form())
if course_key is not None:
CourseEnrollment.enroll(user, course_key)
if not extended_profile:
extended_profile = {}
extended_profile[field] = post_vars[field]
# Make sure that password and username fields do not match
username = post_vars['username']
password = post_vars['password']
if username == password:
js['value'] = _("Username and password fields cannot match")
js['field'] = 'username'
return JsonResponse(js, status=400)
# Ok, looks like everything is legit. Create the account.
try:
with transaction.commit_on_success():
ret = _do_create_account(post_vars, extended_profile)
except AccountValidationError as e:
return JsonResponse(
{
'success': False,
'value': e.message,
'field': e.field
},
status=400)
(user, profile, registration) = ret
dog_stats_api.increment("common.student.account_created")
email = post_vars['email']
def create(num, course_key):
"""Create num users, enrolling them in course_key if it's not None"""
for idx in range(num):
(user, _, _) = _do_create_account(make_random_form())
if course_key is not None:
CourseEnrollment.enroll(user, course_key)
def post(self, request, format=None):
"""
"""
# Gather all the request data
username = request.POST.get('username')
email = request.POST.get('email')
password = request.POST.get('password')
contact_name = request.POST.get('contact_name')
activate = request.POST.get('activate', False)
org_manager = request.POST.get('org_manager', False)
send_email = request.POST.get('send_email', False)
language = request.POST.get('language', 'en')
conflicts = check_account_exists(email=email, username=username)
if conflicts:
return JsonResponse({'conflict_on_fields': conflicts}, status=409)
data = {
'username': username,
'email': email,
'password': password,
'name': contact_name,
}
# Go ahead and create the new user
with transaction.commit_on_success():
form = AccountCreationForm(
data=data,
tos_required=False,
)
(user, profile, registration) = _do_create_account(form)
create_comments_service_user(user)
if send_email:
with override_language(language):
context = {
'name': profile.name,
'key': registration.activation_key,
}
# composes activation email
subject = render_to_string('emails/activation_email_subject.txt', context)
subject = ''.join(subject.splitlines())
message = render_to_string('emails/activation_email.txt', context)
message_html = None
if (settings.FEATURES.get('ENABLE_MULTIPART_EMAIL')):
message_html = render_to_string('emails/html/activation_email.html', context)
from_address = microsite.get_value(
'email_from_address',
settings.DEFAULT_FROM_EMAIL
)
try:
mail.send_mail(subject, message, from_address, [user.email], html_message=message_html)
except Exception: # pylint: disable=broad-except
log.error(u'Unable to send activation email to remotely created user from "%s"', from_address, exc_info=True)
# Assing the user to the org management roles
if org_manager:
# We have to make them active for the roles to stick
user.is_active = True
user.save()
creator_role = OrgCourseCreatorRole(org_manager)
creator_role.add_users(user)
rerun_role = OrgRerunCreatorRole(org_manager)
rerun_role.add_users(user)
user.is_active = False
user.save()
if activate:
registration.activate()
return JsonResponse({"success": True}, status=201)
def create(num, course_key):
"""Create num users, enrolling them in course_key if it's not None"""
for idx in range(num):
(user, user_profile, __) = _do_create_account(get_random_post_override())
if course_key is not None:
CourseEnrollment.enroll(user, course_key)
def post(self, request, format=None):
post_vars = json.loads(request.POST.keys()[0])
required_post_vars = ['email', 'username', 'password']
err = {}
# Confirm we have a properly formed request
for k in required_post_vars:
if k not in post_vars:
err['err_type'] = 'MissingParameter'
err['err_msg'] = "Missing Parameter %s" % k
return Response(err, status=status.HTTP_400_BAD_REQUEST)
# Check paremeters
for k in required_post_vars:
if len(post_vars[k]) < 2:
error_str = {
'username': _('Username must be minimum of two characters long.'),
'email': _('A properly formatted e-mail is required.'),
'password': _('A valid password is required.')
}
err['err_type'] = 'InvalidParameter'
err['err_msg'] = error_str[k]
return Response(err, status=status.HTTP_400_BAD_REQUEST)
# Validate email
try:
validate_email(post_vars['email'])
except ValidationError:
err['err_type'] = 'InvalidParameter'
err['err_msg'] = _("Valid e-mail is required.")
return Response(err, status=status.HTTP_400_BAD_REQUEST)
# Validate username
if string_len(post_vars['username']) > 16:
error_str = {
'username': _('Username must be maximum of eight characters long.'),
}
err['err_type'] = 'InvalidParameter'
err['err_msg'] = error_str['username']
return Response(err, status=status.HTTP_400_BAD_REQUEST)
if ALL_NUMBER_RE.match(post_vars['username']):
err['err_type'] = 'InvalidParameter'
err['err_msg'] = _('Username cannot be all Numbers.')
return Response(err, status=status.HTTP_400_BAD_REQUEST)
if not USERNAME_RE.match(post_vars['username']):
err['err_type'] = 'InvalidParameter'
err['err_msg'] = _('Username should only consist of A-Z and 0-9 and chinese character and "_" and "-", with no spaces.')
return Response(err, status=status.HTTP_400_BAD_REQUEST)
# Ok, looks like everything is legit. Create the account.
post_vars['name'] = ''
ret = _do_create_account(post_vars, True, request=request)
# if there was an error then return that
if isinstance(ret, HttpResponse):
json_obj = json.loads(ret.content)
err['err_type'] = '%sAlreadyExists' % json_obj.get('field').capitalize()
err['err_msg'] = json_obj.get('value')
return Response(err, status=status.HTTP_400_BAD_REQUEST)
user, profile, registration = ret
server_track(request, 'api.user.register', {
'uid': user.id,
'username': user.username,
})
return Response()
