def form_valid(self, form):
first_name, last_name = form.cleaned_data['name']
email = form.cleaned_data['email']
if 'clients' in form.fields:
clients = form.cleaned_data['clients']
else:
# if the manager has only one client, the form doen't have the
# clients field, we must set it separated
clients = self.request.user.managed_clients.all()
try:
# avoids double registration by trying to use an already existant
# user and filters his attached clients from the manager choices
teacher_user = User.objects.get(email=email)
password = None
clients = clients.exclude(teachers=teacher_user)
except User.DoesNotExist:
teacher_user = User(first_name=first_name,
last_name=last_name,
username=id_as_username('teacher'),
email=email)
password = generate_random_passwords(1, flat=True)
teacher_user.set_password(password)
teacher_user.save()
self.warn_user_create(teacher_user, password, clients)
for client in clients:
teacher_user.teacher_set.create(client=client)
return redirect('manager:teacher-detail', pk=teacher_user.pk)
def create_managers(self, form):
"""
Creates specified managers, reusing then if already exists.
Sets a random password for the just created users and sends an
invitation email for each manager, reused or created (in this case,
with his password).
"""
for f in form:
user = f.save(commit=False)
if not user.username:
user.username = id_as_username(prefix='user')
if not user.pk:
password = generate_random_passwords(1, flat=True)
user.set_password(password)
else:
password = None
user.save()
self.demonstration.client.managers.add(user)
# warn each user that he was invited as a manager
email = EmailFromTemplate(
subject=_('Welcome to Mainiti'),
from_email=settings.DEFAULT_FROM_EMAIL,
to=[user.email],
template_name='demonstrations/purchase/manager_created_email',
context={
'user': user,
'password': password,
'client': self.demonstration.client
},
)
email.send()
def reset_passwords(self, students):
password_list = generate_random_passwords(len(students))
pw_list = {}
for student in students:
password = password_list.pop(0)
student.set_password(password)
student.save()
pw_list[student.get_full_name()] = password
klass_pw_list = {self.klass.pk: pw_list}
try:
self.request.session['password_list'].update(klass_pw_list)
except KeyError:
self.request.session['password_list'] = klass_pw_list
def form_valid(self, form):
self.object.password_list_printed_at = None
self.object.save()
# reather than update the students list, use the students list to reset
# their passwords
users = form.cleaned_data['students']
passwords = generate_random_passwords(len(users))
users_passwords = []
for user, passwd in zip(users, passwords):
user.set_password(passwd)
user.save()
users_passwords.append((user.pk, passwd))
# saves the pair user
password_list = self.request.session.get('password_list', {})
password_list[str(self.object.pk)] = users_passwords
self.request.session['password_list'] = password_list
return self.get_success_url()
def create_students(self, students, **kwargs):
passwords = generate_random_passwords(len(students))
users = []
for i, (first_name, last_name) in enumerate(students):
user = User(
username=id_as_username('student'),
first_name=first_name,
last_name=last_name,
)
user.set_password(passwords[i])
user.save()
self.klass.students.add(user)
users.append(user.pk)
# saves the pair user
users_passwords = self.request.session.get('password_list', {})
users_passwords[self.klass.pk] = zip(users, passwords)
self.request.session['password_list'] = users_passwords
def create_teacher(self, name, email):
"""
Creates and returns users not found by email, otherwise, reuse them.
Returns the user instance and the password used when created, or None
if the password wasn't set because the user already exists.
"""
try:
user = User.objects.get(email=email)
password = None
except User.DoesNotExist:
first_name, last_name = split_name(name)
user = User(username=id_as_username(prefix='teacher'),
first_name=first_name,
last_name=last_name,
email=email)
password = generate_random_passwords(1, flat=True)
user.set_password(password)
user.save()
return user, password
def generate_klass_key(sender, instance, **kwargs):
if not instance.key:
keys = generate_random_passwords(1, length=4)
instance.key = keys[0]