def save(self, *args, **kwargs):
kwargs["commit"] = False
user = super(AddUserForm, self).save(*args, **kwargs)
try:
self.cleaned_data["username"]
except KeyError:
if not self.instance.username:
username = "******" % self.cleaned_data
if not username.strip():
username = self.cleaned_data["email"].split("@")[0]
qs = User.objects.exclude(id=self.instance.id) # @UndefinedVariable PyDev limitation ("exclude")
user.username = unique_slug(qs, "username", slugify(username))
password = self.cleaned_data.get("password1")
if password:
user.set_password(password)
user.save()
# Save profile model.
ProfileFieldsForm(self.data, self.files, instance=user.profile).save()
settings.use_editable()
#if (settings.ACCOUNTS_VERIFICATION_REQUIRED or
# settings.ACCOUNTS_APPROVAL_REQUIRED):
# user.is_active = False
# user.save()
return user
def generate_unique_slug(self):
"""
Create a unique slug by passing the result of get_slug() to
utils.urls.unique_slug, which appends an index if necessary.
"""
# For custom content types, use the ``Page`` instance for
# slug lookup.
concrete_model = base_concrete_model(Slugged, self)
slug_qs = concrete_model.objects.exclude(id=self.id)
return unique_slug(slug_qs, "slug", self.get_slug())
def generate_unique_slug(self):
"""
Create a unique slug by passing the result of get_slug() to
utils.urls.unique_slug, which appends an index if necessary.
"""
# For custom content types, use the ``Page`` instance for
# slug lookup.
concrete_model = base_concrete_model(Slugged, self)
slug_qs = concrete_model.objects.exclude(id=self.id)
return unique_slug(slug_qs, "slug", self.get_slug())
def save(self, *args, **kwargs):
"""
Create the new user. If no username is supplied (may be hidden
via ``ACCOUNTS_PROFILE_FORM_EXCLUDE_FIELDS`` or
``ACCOUNTS_NO_USERNAME``), we generate a unique username, so
that if profile pages are enabled, we still have something to
use as the profile's slug.
"""
kwargs["commit"] = False
user = super(ProfileForm, self).save(*args, **kwargs)
try:
self.cleaned_data["username"]
except KeyError:
if not self.instance.username:
try:
username = ("%(first_name)s %(last_name)s" %
self.cleaned_data).strip()
except KeyError:
username = ""
if not username:
username = self.cleaned_data["email"].split("@")[0]
qs = User.objects.exclude(id=self.instance.id)
user.username = unique_slug(qs, "username", slugify(username))
password = self.cleaned_data.get("password1")
if password:
user.set_password(password)
elif self._signup:
try:
user.set_unusable_password()
except AttributeError:
# This could happen if using a custom user model that
# doesn't inherit from Django's AbstractBaseUser.
pass
user.save()
try:
profile = get_profile_for_user(user)
profile_form = self.get_profile_fields_form()
profile_form(self.data, self.files, instance=profile).save()
except ProfileNotConfigured:
pass
if self._signup:
settings.use_editable()
if (settings.ACCOUNTS_VERIFICATION_REQUIRED or
settings.ACCOUNTS_APPROVAL_REQUIRED):
user.is_active = False
user.save()
else:
token = default_token_generator.make_token(user)
user = authenticate(uidb36=int_to_base36(user.id),
token=token,
is_active=True)
return user
def save(self, *args, **kwargs):
"""
Create the new user. If no username is supplied (may be hidden
via ``ACCOUNTS_PROFILE_FORM_EXCLUDE_FIELDS`` or
``ACCOUNTS_NO_USERNAME``), we generate a unique username, so
that if profile pages are enabled, we still have something to
use as the profile's slug.
"""
kwargs["commit"] = False
user = super(ProfileForm, self).save(*args, **kwargs)
try:
self.cleaned_data["username"]
except KeyError:
if not self.instance.username:
try:
username = ("%(first_name)s %(last_name)s" %
self.cleaned_data).strip()
except KeyError:
username = ""
if not username:
username = self.cleaned_data["email"].split("@")[0]
qs = User.objects.exclude(id=self.instance.id)
user.username = unique_slug(qs, "username", slugify(username))
password = self.cleaned_data.get("password1")
if password:
user.set_password(password)
elif self._signup:
try:
user.set_unusable_password()
except AttributeError:
# This could happen if using a custom user model that
# doesn't inherit from Django's AbstractBaseUser.
pass
user.save()
try:
profile = get_profile_for_user(user)
profile_form = self.get_profile_fields_form()
profile_form(self.data, self.files, instance=profile).save()
except ProfileNotConfigured:
pass
if self._signup:
settings.use_editable()
if (settings.ACCOUNTS_VERIFICATION_REQUIRED
or settings.ACCOUNTS_APPROVAL_REQUIRED):
user.is_active = False
user.save()
else:
token = default_token_generator.make_token(user)
user = authenticate(uidb36=int_to_base36(user.id),
token=token,
is_active=True)
return user
def save(self, *args, **kwargs):
"""
Create a unique slug by appending an index.
"""
if not self.slug:
self.slug = self.get_slug()
# For custom content types, use the ``Page`` instance for
# slug lookup.
concrete_model = base_concrete_model(Slugged, self)
slug_qs = concrete_model.objects.exclude(id=self.id)
self.slug = unique_slug(slug_qs, "slug", self.slug)
super(Slugged, self).save(*args, **kwargs)
def save(self, *args, **kwargs):
"""
Create a unique slug by appending an index.
"""
if not self.slug:
self.slug = self.get_slug()
# For custom content types, use the ``Page`` instance for
# slug lookup.
concrete_model = base_concrete_model(Slugged, self)
slug_qs = concrete_model.objects.exclude(id=self.id)
self.slug = unique_slug(slug_qs, "slug", self.slug)
super(Slugged, self).save(*args, **kwargs)
def save(self, *args, **kwargs):
"""
Create the new user. If no username is supplied (may be hidden
via ``ACCOUNTS_PROFILE_FORM_EXCLUDE_FIELDS`` or
``ACCOUNTS_NO_USERNAME``), we generate a unique username, so
that if profile pages are enabled, we still have something to
use as the profile's slug.
"""
kwargs["commit"] = False
user = super(ProfileForm, self).save(*args, **kwargs)
try:
self.cleaned_data["username"]
except KeyError:
if not self.instance.username:
try:
username = ("%(first_name)s %(last_name)s" %
self.cleaned_data).strip()
except KeyError:
username = ""
if not username:
username = self.cleaned_data["email"].split("@")[0]
qs = User.objects.exclude(id=self.instance.id)
user.username = unique_slug(qs, "username", slugify(username))
password = self.cleaned_data.get("password1")
if password:
user.set_password(password)
elif self._signup:
user.set_unusable_password()
user.save()
# save profile
profile, created = Profile.objects.get_or_create(user=user)
profile_form = self.get_profile_fields_form()
profile_form(self.data, self.files, instance=profile).save()
# save lol account
lol_account, created = LolAccount.objects.get_or_create(user=user)
lolaccount_form = LolAccountFieldsForm
lolaccount_form(self.data, self.files, instance=lol_account).save()
if self._signup:
if (settings.ACCOUNTS_VERIFICATION_REQUIRED or
settings.ACCOUNTS_APPROVAL_REQUIRED):
user.is_active = False
user.save()
else:
token = default_token_generator.make_token(user)
user = authenticate(uidb36=int_to_base36(user.id),
token=token,
is_active=True)
return user
def save(self, *args, **kwargs):
"""
Create the new user. If no username is supplied (may be hidden
via ``ACCOUNTS_PROFILE_FORM_EXCLUDE_FIELDS`` or
``ACCOUNTS_NO_USERNAME``), we generate a unique username, so
that if profile pages are enabled, we still have something to
use as the profile's slug.
"""
kwargs["commit"] = False
user = super(ProfileForm, self).save(*args, **kwargs)
try:
self.cleaned_data["username"]
except KeyError:
if not self.instance.username:
username = "******" % self.cleaned_data
if not username.strip():
username = self.cleaned_data["email"].split("@")[0]
qs = User.objects.exclude(id=self.instance.id)
user.username = unique_slug(qs, "username", slugify(username))
password = self.cleaned_data.get("password1")
if password:
user.set_password(password)
user.save()
# Save profile model.
if self._has_profile:
try:
profile = user.get_profile()
except Profile.DoesNotExist:
profile = Profile(user=user)
profile_fields_form = self.get_profile_fields_form()
profile_fields_form(self.data, self.files, instance=profile).save()
if self._signup:
settings.use_editable()
if (settings.ACCOUNTS_VERIFICATION_REQUIRED
or settings.ACCOUNTS_APPROVAL_REQUIRED):
user.is_active = False
user.save()
else:
user = authenticate(username=user.username,
password=password,
is_active=True)
return user
def save(self, *args, **kwargs):
"""
Create the new user. If no username is supplied (may be hidden
via ``ACCOUNTS_PROFILE_FORM_EXCLUDE_FIELDS`` or
``ACCOUNTS_NO_USERNAME``), we generate a unique username, so
that if profile pages are enabled, we still have something to
use as the profile's slug.
"""
kwargs["commit"] = False
user = super(ProfileForm, self).save(*args, **kwargs)
try:
self.cleaned_data["username"]
except KeyError:
if not self.instance.username:
username = "******" % self.cleaned_data
if not username.strip():
username = self.cleaned_data["email"].split("@")[0]
qs = User.objects.exclude(id=self.instance.id)
user.username = unique_slug(qs, "username", slugify(username))
password = self.cleaned_data.get("password1")
if password:
user.set_password(password)
user.save()
# Save profile model.
if self._has_profile:
try:
profile = user.get_profile()
except Profile.DoesNotExist:
profile = Profile(user=user)
profile_fields_form = self.get_profile_fields_form()
profile_fields_form(self.data, self.files, instance=profile).save()
if self._signup:
settings.use_editable()
if (settings.ACCOUNTS_VERIFICATION_REQUIRED or
settings.ACCOUNTS_APPROVAL_REQUIRED):
user.is_active = False
user.save()
else:
user = authenticate(username=user.username,
password=password, is_active=True)
return user
def save(self, commit=True):
user = super(UserCreationForm, self).save(commit=False)
user.set_password(str(uuid4())[:10])
user.email = self.cleaned_data['email']
#user.clean_email()
user.first_name = self.cleaned_data['first_name']
user.last_name = self.cleaned_data['last_name']
email_slug = self.cleaned_data["email"].split('@')
username = slugify(email_slug[0] + '-' + email_slug[1])[:16]
qs = User.objects.exclude(id=self.instance.id)
user.username = unique_slug(qs, "username", slugify(username))
user.save()
profile = get_profile_for_user(user)
profile.membertype = self.cleaned_data['membertype']
profile.organisation = self.cleaned_data['organisation']
profile.save()
# if commit:
# user.save()
return user
def handle(self, *args, **options):
try:
with open('students2.json') as data_file:
data = json.load(data_file)
member_group = EmailGroup.objects.get_or_create(title='Standard Members')[0]
student_group = EmailGroup.objects.get_or_create(title='Students temporary')[0]
marketing_group = EmailGroup.objects.get_or_create(title='Marketing')[0]
for row in data:
print(row['name'])
user, created = User.objects.get_or_create(email=row['email'])
if created:
email_slug = row["email"].split('@')
username = slugify(email_slug[0] + '-' + email_slug[1])[:16]
qs = User.objects.exclude(id=user.id)
user.username = unique_slug(qs, "username", slugify(username))
split_name = row['name'].split(' ',1)
print(split_name)
user.first_name = split_name[0]
user.last_name = split_name[1]
#profile = get_profile_for_user(user)
user.profile.membertype = 'SM'
user.profile.paid = True
user.profile.paidfrom = timezone.now()
user.profile.expires = timezone.now() + timezone.timedelta(days=366)
user.profile.contacttype.add(member_group,student_group,marketing_group)
user.profile.save()
user.save()
else:
print('already in ', user)
except Exception as e:
print(e)
def save(self):
slug = "seminar/{}".format(slugify(self.last_name()))
slug_qs = Seminar.objects.exclude(id=self.id)
self.slug = unique_slug(slug_qs, "slug", slug)
super(Seminar, self).save()
def save(self, *args, **kwargs):
"""
Create the new user. If no username is supplied (may be hidden
via ``ACCOUNTS_PROFILE_FORM_EXCLUDE_FIELDS`` or
``ACCOUNTS_NO_USERNAME``), we generate a unique username, so
that if profile pages are enabled, we still have something to
use as the profile's slug.
"""
kwargs["commit"] = False
user = super(ModProfileForm, self).save(*args, **kwargs)
try:
self.cleaned_data["username"]
except KeyError:
if not self.instance.username:
try:
email_slug = self.cleaned_data["email"].split('@')
username = slugify(email_slug[0] + '-' + email_slug[1])[:16]
#username = self.cleaned_data["email"].split("@")[0]
except KeyError:
username = ""
if not username:
#username = self.cleaned_data["email"].split("@")[0]
email_slug = self.cleaned_data["email"].split('@')
username = slugify(email_slug[0] + '-' + email_slug[1])[:16]
qs = User.objects.exclude(id=self.instance.id)
user.username = unique_slug(qs, "username", slugify(username))
password = self.cleaned_data.get("password1")
if password:
user.set_password(password)
elif self._signup:
try:
user.set_unusable_password()
except AttributeError:
# This could happen if using a custom user model that
# doesn't inherit from Django's AbstractBaseUser.
pass
user.save()
try:
profile = get_profile_for_user(user)
profile_form = self.get_profile_fields_form()
profile_form(self.data, self.files, instance=profile).save()
except ProfileNotConfigured:
pass
if self._signup:
## create SubscriberEmailAddress object for the group "members"
## so we can keep email address on record in future
# g = EmailGroup.objects.get_or_create(title="Sign Ups")[0]
# sub = SubscriberEmailAddress(sub_email=g,
# email=self.cleaned_data["email"],
# firstname=self.cleaned_data["first_name"],
# lastname=self.cleaned_data["last_name"],
# source='Website'
# )
# sub.save()
profile.membertype = 'SU'
profile.save()
g = EmailGroup.objects.get_or_create(title='Sign Ups')[0]
profile.contacttype.add(g)
###############################################
if (settings.ACCOUNTS_VERIFICATION_REQUIRED or
settings.ACCOUNTS_APPROVAL_REQUIRED):
user.is_active = False
user.save()
else:
token = default_token_generator.make_token(user)
user = authenticate(uidb36=int_to_base36(user.id),
token=token,
is_active=True)
# else:
# if not user.is_staff:
# sub = SubscriberEmailAddress.objects.get(email=user.email)
# if self.cleaned_data["organisation"]:
# sub.organisation = self.cleaned_data["organisation"]
# if self.cleaned_data["nationality"]:
# sub.country = self.cleaned_data["nationality"]
# sub.save()
return user
