def invite_em(file):
site = Site.objects.get_current()
total = newly_added = 0
reader = csv.DictReader(file, delimiter=";")
results = StringIO()
writer = csv.DictWriter(results,
fieldnames=[
"first_name", "last_name", "email_address_1",
"invite_code"
])
writer.writeheader()
for item in reader:
total += 1
email = item['email_address_1']
first_name = item['first_name']
last_name = item['last_name']
try:
code = SignupCode.objects.get(email=email)
except SignupCode.DoesNotExist:
code = SignupCode(email=email,
code=uuid4().hex[:20],
max_uses=1,
sent=datetime.utcnow(),
expiry=datetime.utcnow() + timedelta(days=14))
newly_added += 1
code.save()
EmailMessage(
'Dein Einladungscode zur DiB Abstimmungsplattform',
render_to_string('initadmin/email_invite.txt',
context=dict(domain=site.domain,
code=code,
first_name=first_name)),
settings.DEFAULT_FROM_EMAIL, [email]).send()
writer.writerow({
"first_name": first_name,
"last_name": last_name,
"email_address_1": email,
"invite_code": code.code
})
InviteBatch(payload=results.getvalue(),
total_found=total,
new_added=newly_added).save()
return total, newly_added
def cohort_member_add(request, pk):
cohort = Cohort.objects.get(pk=pk)
if "invite_next" in request.POST:
try:
N = int(request.POST["invite_next"])
except ValueError:
return redirect("waitinglist_cohort_detail", cohort.id)
# people who are NOT invited or on the site already
waiting_list = WaitingListEntry.objects.exclude(
email__in=SignupCode.objects.values("email")).exclude(
email__in=User.objects.values("email"))
emails = waiting_list.values_list("email", flat=True)[:N]
else:
email = request.POST["email"].strip()
if email:
emails = [email]
else:
emails = []
for email in emails:
if not SignupCode.objects.filter(email=email).exists():
signup_code = SignupCode.create(email=email,
max_uses=1,
expiry=730)
signup_code.save()
SignupCodeCohort.objects.create(signup_code=signup_code,
cohort=cohort)
return redirect("waitinglist_cohort_detail", cohort.id)
def cohort_member_add(request, pk):
if not request.user.is_staff:
raise Http404()
cohort = Cohort.objects.get(pk=pk)
if "invite_next" in request.POST:
try:
N = int(request.POST["invite_next"])
except ValueError:
return redirect("waitinglist_cohort_detail", cohort.id)
# people who are NOT invited or on the site already
waiting_list = WaitingListEntry.objects.exclude(
email__in=SignupCode.objects.values("email")
).exclude(
email__in=User.objects.values("email")
)
emails = waiting_list.values_list("email", flat=True)[:N]
else:
email = request.POST["email"].strip()
if email:
emails = [email]
else:
emails = []
for email in emails:
if not SignupCode.objects.filter(email=email).exists():
signup_code = SignupCode.create(email=email, max_uses=1, expiry=730)
signup_code.save()
SignupCodeCohort.objects.create(signup_code=signup_code, cohort=cohort)
return redirect("waitinglist_cohort_detail", cohort.id)
def invite(cls, from_user, to_email, message=None, send=True):
if not from_user.invitationstat.can_send():
raise NotEnoughInvitationsError()
signup_code = SignupCode.create(
email=to_email,
inviter=from_user,
expiry=settings.PINAX_INVITATIONS_DEFAULT_EXPIRATION,
check_exists=
False # before we are called caller must check for existence
)
signup_code.save()
join = cls.objects.create(from_user=from_user,
message=message,
status=JoinInvitation.STATUS_SENT,
signup_code=signup_code)
def send_invite(*args, **kwargs):
signup_code.send(*args, **kwargs)
InvitationStat.objects.filter(user=from_user).update(
invites_sent=models.F("invites_sent") + 1)
invite_sent.send(sender=cls, invitation=join)
if send:
send_invite()
else:
join.send_invite = send_invite
return join
def invite(cls, from_user, to_email, message=None, send=True):
if not from_user.invitationstat.can_send():
raise NotEnoughInvitationsError()
signup_code = SignupCode.create(
email=to_email,
inviter=from_user,
expiry=settings.PINAX_INVITATIONS_DEFAULT_EXPIRATION,
check_exists=False # before we are called caller must check for existence
)
signup_code.save()
join = cls.objects.create(
from_user=from_user,
message=message,
status=JoinInvitation.STATUS_SENT,
signup_code=signup_code
)
def send_invite(*args, **kwargs):
signup_code.send(*args, **kwargs)
InvitationStat.objects.filter(user=from_user).update(
invites_sent=models.F("invites_sent") + 1
)
invite_sent.send(sender=cls, invitation=join)
if send:
send_invite()
else:
join.send_invite = send_invite
return join
def test_exists_no_match(self):
code = SignupCode(email='*****@*****.**', code='FOOFOO')
code.save()
self.assertFalse(SignupCode.exists(code='BARBAR'))
self.assertFalse(SignupCode.exists(email='*****@*****.**'))
self.assertFalse(
SignupCode.exists(email='*****@*****.**', code='BARBAR'))
self.assertFalse(SignupCode.exists())
def setUp(self):
self.to_user = User.objects.create(username="******")
self.from_user = User.objects.create(username="******")
self.signup_code = SignupCode.create(email="*****@*****.**")
self.signup_code.save()
self.status = JoinInvitation.STATUS_ACCEPTED
self.invitation = JoinInvitation.objects.create(
from_user=self.from_user, status=self.status, signup_code=self.signup_code
)
def handle(self, *args, **options):
site = Site.objects.get_current()
expiry = int(args[2]) if len(args) > 2 else 768
with open(args[1], mode="w") as fh:
for i in range(int(args[0])):
signup = SignupCode.create(max_uses=1, expiry=expiry, check_exists=False)
fh.write("http://{0}{1}?code={2},".format(site.domain,
urlresolvers.reverse('account_signup'),
signup.code))
signup.save()
def is_open(self):
code = self.request.REQUEST.get('code')
if code:
try:
self.signup_code = SignupCode.check(code)
except SignupCode.InvalidCode:
return settings.ACCOUNT_OPEN_SIGNUP
else:
return True
else:
return settings.ACCOUNT_OPEN_SIGNUP
def setup_signup_code(self):
code = self.get_code()
if code:
try:
self.signup_code = SignupCode.check_code(code)
except SignupCode.InvalidCode:
self.signup_code = None
self.signup_code_present = True
else:
self.signup_code = None
self.signup_code_present = False
def setUp(self):
self.to_user = User.objects.create(username='******')
self.from_user = User.objects.create(username='******')
self.signup_code = SignupCode.create(email="*****@*****.**")
self.signup_code.save()
self.status = JoinInvitation.STATUS_ACCEPTED
self.invitation = JoinInvitation.objects.create(
from_user=self.from_user,
status=self.status,
signup_code=self.signup_code,
)
def setup_signup_code(self):
code = self.get_code()
if code:
try:
self.signup_code = SignupCode.check_code(code)
except SignupCode.InvalidCode:
self.signup_code = None
self.signup_code_present = True
else:
self.signup_code = None
self.signup_code_present = False
def clean_code(self):
try:
signup_code = SignupCode.check(self.cleaned_data.get("code"))
except SignupCode.InvalidCode:
if not settings.ACCOUNT_OPEN_SIGNUP:
raise forms.ValidationError(_("Signup code is invalid."))
else:
return None
else:
if not settings.ACCOUNT_OPEN_SIGNUP and signup_code is None:
raise forms.ValidationError(_("Code is required to signup."))
return signup_code
def test_exists_code_only_match(self):
code = SignupCode(email='*****@*****.**', code='FOOFOO')
code.save()
self.assertTrue(SignupCode.exists(code='FOOFOO'))
self.assertTrue(
SignupCode.exists(email='*****@*****.**', code='FOOFOO'))
def test_valid_code(self):
signup_code = SignupCode.create()
signup_code.save()
with self.settings(ACCOUNT_OPEN_SIGNUP=False):
data = {
"username": "******",
"password": "******",
"password_confirm": "bar",
"email": "*****@*****.**",
"code": signup_code.code,
}
response = self.client.post(reverse("account_signup"), data)
self.assertEqual(response.status_code, 302)
def test_valid_code(self):
signup_code = SignupCode.create()
signup_code.save()
with self.settings(ACCOUNT_OPEN_SIGNUP=False):
data = {
"username": "******",
"password": "******",
"password_confirm": "bar",
"email": "*****@*****.**",
"code": signup_code.code,
}
response = self.client.post(reverse("account_signup"), data)
self.assertEqual(response.status_code, 302)
def test_register_with_moderation(self):
signup_code = SignupCode.create()
signup_code.save()
with self.settings(ACCOUNT_OPEN_SIGNUP=True, ACCOUNT_APPROVAL_REQUIRED=True):
data = {
"username": "******",
"password": "******",
"password_confirm": "bar",
"email": "*****@*****.**",
"code": signup_code.code,
}
response = self.client.post(reverse("account_signup"), data)
self.assertEqual(response.status_code, 200)
self.assertFalse(self.client.session.get('_auth_user_id'))
u = User.objects.get(username=data['username'])
self.assertFalse(u.is_active)
def is_open(self):
code = self.request.REQUEST.get("code")
if code:
try:
self.signup_code = SignupCode.check(code)
except SignupCode.InvalidCode:
if self.messages.get("invalid_signup_code"):
messages.add_message(
self.request,
self.messages["invalid_signup_code"]["level"],
self.messages["invalid_signup_code"]["text"] %
{"code": code})
return settings.ACCOUNT_OPEN_SIGNUP
else:
return True
else:
return settings.ACCOUNT_OPEN_SIGNUP
def test_register_with_moderation(self):
signup_code = SignupCode.create()
signup_code.save()
with self.settings(ACCOUNT_OPEN_SIGNUP=True,
ACCOUNT_APPROVAL_REQUIRED=True):
data = {
"username": "******",
"password": "******",
"password_confirm": "bar",
"email": "*****@*****.**",
"code": signup_code.code,
}
response = self.client.post(reverse("account_signup"), data)
self.assertEqual(response.status_code, 200)
self.assertFalse(self.client.session.get('_auth_user_id'))
u = User.objects.get(username=data['username'])
self.assertFalse(u.is_active)
def is_open(self):
code = self.request.REQUEST.get("code")
if code:
try:
self.signup_code = SignupCode.check(code)
except SignupCode.InvalidCode:
if self.messages.get("invalid_signup_code"):
messages.add_message(
self.request,
self.messages["invalid_signup_code"]["level"],
self.messages["invalid_signup_code"]["text"] % {
"code": code
}
)
return settings.ACCOUNT_OPEN_SIGNUP
else:
return True
else:
return settings.ACCOUNT_OPEN_SIGNUP
def is_open(self):
code = self.request.REQUEST.get('code')
if code:
try:
self.signup_code = SignupCode.check(code)
except SignupCode.InvalidCode:
if self.messages.get('invalid_signup_code'):
messages.add_message(
self.request,
self.messages['invalid_signup_code']['level'],
self.messages['invalid_signup_code']['text'].format(**{
'code': code
})
)
return settings.ACCOUNT_OPEN_SIGNUP
else:
return True
else:
return settings.ACCOUNT_OPEN_SIGNUP
def get(self, *args, **kwargs):
if self.request.user.is_authenticated():
return redirect(default_redirect(self.request, settings.ACCOUNT_LOGIN_REDIRECT_URL))
code = self.request.GET.get("code")
try:
self.signup_code = SignupCode.check(code)
except SignupCode.InvalidCode:
if not settings.ACCOUNT_OPEN_SIGNUP:
return self.closed(code=code)
else:
if self.messages.get("invalid_signup_code"):
messages.add_message(
self.request,
self.messages["invalid_signup_code"]["level"],
self.messages["invalid_signup_code"]["text"] % {
"code": code
}
)
if not settings.ACCOUNT_OPEN_SIGNUP and self.signup_code is None:
return self.closed()
return super(SignupView, self).get(*args, **kwargs)
def invite(cls, from_user, to_email, message=None):
if not from_user.invitationstat.can_send():
raise NotEnoughInvitationsError()
signup_code = SignupCode.create(
email=to_email,
inviter=from_user,
expiry=DEFAULT_INVITE_EXPIRATION,
check_exists=
False # before we are called caller must check for existence
)
signup_code.save()
join = cls.objects.create(from_user=from_user,
message=message,
status=JoinInvitation.STATUS_SENT,
signup_code=signup_code)
signup_code.send()
stat = from_user.invitationstat
stat.invites_sent += 1
stat.save()
invite_sent.send(sender=cls, invitation=join)
return join
def invite(cls, from_user, to_email, message=None):
if not from_user.invitationstat.can_send():
raise NotEnoughInvitationsError()
signup_code = SignupCode.create(
email=to_email,
inviter=from_user,
expiry=DEFAULT_INVITE_EXPIRATION,
check_exists=False # before we are called caller must check for existence
)
signup_code.save()
join = cls.objects.create(
from_user=from_user,
message=message,
status=JoinInvitation.STATUS_SENT,
signup_code=signup_code
)
signup_code.send()
stat = from_user.invitationstat
stat.invites_sent += 1
stat.save()
invite_sent.send(sender=cls, invitation=join)
return join
def test_exists_email_match_code_mismatch(self):
code = SignupCode(email='*****@*****.**', code='FOOFOO')
code.save()
self.assertTrue(
SignupCode.exists(email='*****@*****.**', code='BARBAR'))
