Пример #1
0
    def test_registration_social(self):
        """Verify the registration process works with the social flow.

        When a user logs in for the first time using an unknown social
        account, she has to fill out the registration form before she is
        let in.
        """
        response = self.social_testing_login()
        # A registration form is displayed to the user.
        self.assertRedirects(response, '/account/register/')
        # The registration form is supposed to be filled in with values
        # retrieved from the auth provider.
        self.assertContains(
            response,
            b'<input id="id_username" maxlength="30" name="username" type="text" value="koniiiik" />',
            html=True,
        )
        self.assertContains(
            response,
            b'<input id="id_first_name" maxlength="30" name="first_name" type="text" value="Colleague" />',
            html=True,
        )
        self.assertContains(
            response,
            b'<input id="id_last_name" maxlength="30" name="last_name" type="text" value="Knuk" />',
            html=True,
        )
        # The type of an EmailInput has changed in 1.6, which means we
        # need to render it manually here. Also, EmailField.max_length
        # changed in 1.8.
        expected = EmailField().widget.render('email', '*****@*****.**', {
            'maxlength': models.EmailField().max_length,
            'id': 'id_email'
        })
        self.assertContains(
            response,
            expected.encode('utf-8'),
            html=True,
        )
        # Submit the registration form...
        data = {
            'username': '******',
            'email': '*****@*****.**',
            'first_name': 'Colleague',
            'last_name': 'Knuk',
        }
        response = self.client.post('/account/register/', data,
                                    follow=True)
        # The redirect chain continues through the social:complete view
        # and lands at the LOGIN_URL destination.
        self.assertIn(tuple(response.redirect_chain),
                      [(('http://testserver/account/complete/test1/', 302),
                        ('http://testserver/account/', 302)),
                       (('/account/complete/test1/', 302),
                        ('/account/', 302))])
        # The resulting page shows the user logged in and with a social
        # association.
        self.assertIn(b'Logged in as', response.content)
        self.assertIn(b'<a href="/account/" class="navbar-link">koniiiik</a>', response.content)
        self.assertIn(b'Testing UID #1', response.content)
Пример #2
0
 def is_valid(self, email):
     """ Renvoyer si une adresse email a un format valide """
     field = EmailField()
     try:
         field.clean(email)
         return True
     except ValidationError:
         return False
Пример #3
0
    def test_registration_social(self):
        """Verify the registration process works with the social flow.

        When a user logs in for the first time using an unknown social
        account, she has to fill out the registration form before she is
        let in.
        """
        response = self.social_testing_login()
        # A registration form is displayed to the user.
        self.assertRedirects(response, '/account/register/')
        # The registration form is supposed to be filled in with values
        # retrieved from the auth provider.
        self.assertContains(
            response,
            b'<input id="id_username" maxlength="30" name="username" type="text" value="koniiiik" />',
            html=True,
        )
        self.assertContains(
            response,
            b'<input id="id_first_name" maxlength="30" name="first_name" type="text" value="Colleague" />',
            html=True,
        )
        self.assertContains(
            response,
            b'<input id="id_last_name" maxlength="30" name="last_name" type="text" value="Knuk" />',
            html=True,
        )
        # The type of an EmailInput has changed in 1.6, which means we
        # need to render it manually here.
        expected = EmailField().widget.render('email', '*****@*****.**', {
            'maxlength': 75,
            'id': 'id_email'
        })
        self.assertContains(
            response,
            expected.encode('utf-8'),
            html=True,
        )
        # Submit the registration form...
        data = {
            'username': '******',
            'email': '*****@*****.**',
            'first_name': 'Colleague',
            'last_name': 'Knuk',
        }
        response = self.client.post('/account/register/', data, follow=True)
        # The redirect chain continues through the social:complete view
        # and lands at the LOGIN_URL destination.
        self.assertEqual(response.redirect_chain,
                         [('http://testserver/account/complete/test1/', 302),
                          ('http://testserver/account/', 302)])
        # The resulting page shows the user logged in and with a social
        # association.
        self.assertIn(b'Logged in as', response.content)
        self.assertIn(b'<a href="/account/" class="navbar-link">koniiiik</a>',
                      response.content)
        self.assertIn(b'Testing UID #1', response.content)
Пример #4
0
class RegForm(forms.Form):
    name = CharField(max_length=30, required=False)
    username = CharField(
        min_length=2,
        max_length=30,
        help_text=
        "30 characters or fewer. Alphanumeric characters only (letters, digits and underscores)",
        widget=TextInput(
            attrs={
                "onfocus": "showRegHelp('username');",
                "onblur": "hideRegHelp('username');return checkUsername();"
            }))
    email = EmailField()
    password = CharField(widget=PasswordInput)
    confirm_password = CharField(widget=PasswordInput)
    next = CharField(widget=HiddenInput(), required=False)
    imghash = CharField(widget=HiddenInput(), required=True)
    imgtext = CharField(
        required=True,
        help_text="Please be case sensitive.  'A' is not the same as 'a'.",
        widget=TextInput(
            attrs={
                "onfocus": "showRegHelp('captcha');",
                "onblur": "hideRegHelp('captcha')"
            }))
    agree_to_terms = BooleanField(required=True)
Пример #5
0
class CreateUserForm(UserCreationForm):

    error_messages = {
        'password_mismatch': _('您輸入的兩個密碼並不相符,請再試一次。'),
    }

    username = EmailField(
        label='',
        widget=EmailInput(attrs={
            'placeholder': 'Email',
            'input_prepend_icon': 'cil-user'
        }),
    )
    password1 = CharField(
        label='',
        widget=PasswordInput(attrs={
            'placeholder': 'Password',
            'input_prepend_icon': 'cil-lock-locked'
        }),
    )
    password2 = CharField(
        label='',
        widget=PasswordInput(
            attrs={
                'placeholder': 'Repeat password',
                'input_prepend_icon': 'cil-lock-locked'
            }),
    )
Пример #6
0
class ClientFilterForm(forms.Form):
    model = Clients
    q = forms.CharField(required=False,
                        widget=forms.TextInput(attrs={'class': 'TinputText'}),
                        label='Search')

    id = forms.IntegerField(required=False, label='Id')

    email = EmailField(required=False, label='Email')

    first_name = forms.IntegerField(required=False, label='First Name')

    status = forms.MultipleChoiceField(required=False,
                                       widget=forms.CheckboxSelectMultiple(),
                                       label='Status')

    phone_number = forms.IntegerField(required=False, label='Phone Number')

    groups = FilterChoiceField(
        required=False,
        queryset=Group.objects.annotate(filter_count=Count('clients')),
        widget=forms.CheckboxSelectMultiple(),
        label='Groups',
    )

    class Meta:
        model = Clients
        fields = []
Пример #7
0
class AppScaffoldingForm(Form):
    name = CharField(max_length=80,
                     label=_('App name'),
                     validators=[validate_id],
                     help_text=_('The app name must be camel case e.g. MyApp'))
    platform = ChoiceField(choices=lazy(get_versions, list),
                           required=True,
                           label=_('Nextcloud version'))
    author_name = CharField(max_length=80, label=_('Author\'s full name'))
    author_email = EmailField(label=_('Author\'s e-mail'))
    author_homepage = URLField(label=_('Author\'s homepage'), required=False)
    issue_tracker = URLField(label=_('Issue tracker URL'),
                             required=True,
                             help_text=_('Bug reports and feature requests'))
    categories = MultipleChoiceField(required=True,
                                     label=_('Categories'),
                                     choices=lazy(get_categories, list),
                                     help_text=_('Hold down CTRL and click to '
                                                 'select multiple entries'))
    summary = CharField(
        max_length=256,
        label=_('Summary'),
        help_text=
        _('Short description of your app that will be rendered as short teaser'
          ))
    description = CharField(widget=Textarea,
                            label=_('Description'),
                            help_text=_('Full description of what your app '
                                        'does. Can contain Markdown.'))
Пример #8
0
class Address(SoColissimoSchema):
    """
    Address schema, shared by sender and recipient
    """
    soap_type_name = "AddressVO"
    COUNTRIES = [('FR', 'France'), ('MC', 'Monaco')]
    CIVILITIES = ['M', 'Mlle', 'Mme']

    Name = CharField(required=False, help_text='Nom')
    Surname = CharField(required=False, help_text='Prénom')
    email = EmailField(required=False)
    line2 = CharField(required=True, help_text='Numéro et libellé de voie')
    countryCode = ChoiceField(required=True, choices=COUNTRIES)
    city = CharField(required=True)
    postalCode = CharField(required=True)

    companyName = CharField(required=False)
    Civility = ChoiceField(required=False,
                           choices=[(c, c) for c in CIVILITIES])
    line0 = CharField(required=False,
                      help_text='Etage, couloir, escalier, n° d’appartement')
    line1 = CharField(required=False,
                      help_text='Entrée, bâtiment, immeuble, résidence')
    line3 = CharField(required=False,
                      help_text='Lieu dit ou autre mention spéciale')
    phone = CharField(required=False)
    MobileNumber = CharField(required=False)
    DoorCode1 = CharField(required=False)
    DoorCode2 = CharField(required=False)
    Interphone = CharField(required=False)
Пример #9
0
class UserForm(forms.Form):
    """
    A form to validate User resources
    """
    username = CharField(min_length=3, required=True)
    email = EmailField(min_length=3, required=True)
    password = CharField(widget=forms.PasswordInput())

    def __init__(self, user_object=None, **kwargs):
        super(UserForm, self).__init__(**kwargs)
Пример #10
0
class MainForm(Form):
    """A form for the email and location, with the locations sorted alphabetically"""
    email = EmailField(widget=EmailInput())
    location = ChoiceField()

    def __init__(self, *args, **kwargs):
        super(MainForm, self).__init__(*args, **kwargs)
        locations = sorted(
            '{}, {}'.format(model.city, model.state)
            for index, model in enumerate(WeatherModel.objects.all()))
        self.fields['location'].choices = (
            (index, location) for index, location in enumerate(locations))
Пример #11
0
class SignupForm(Form):
    first_name = CharField(max_length=255,
                           required=True,
                           widget=TextInput,
                           label=_('First Name'))
    last_name = CharField(max_length=255,
                          required=True,
                          widget=TextInput,
                          label=_('Last Name'))
    user_name = CharField(max_length=255,
                          required=False,
                          widget=TextInput,
                          label=_('User Name'))
    email = EmailField(max_length=255,
                       required=True,
                       widget=EmailInput,
                       label=_('E-mail Address'))
    password = CharField(min_length=8,
                         max_length=255,
                         required=True,
                         widget=PasswordInput,
                         label=_('Password'))

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        for field in self.fields.values():
            field.widget.attrs["class"] = "form-control"

    def create_user(self):
        first_name = self.cleaned_data.get('first_name')
        last_name = self.cleaned_data.get('last_name')
        user_name = self.cleaned_data.get('user_name')
        email = self.cleaned_data['email']
        password = self.cleaned_data['password']
        user = None
        try:
            user = User.objects.create_user(
                email,
                password,
                first_name=first_name,
                last_name=last_name,
                user_name=user_name,
            )
        except:
            self.add_error(None, 'Error')
        return user

    def clean_email(self):
        email = self.cleaned_data['email']
        if User.objects.filter(email=email).count() > 0:
            self.add_error('email', _('E-mail Address is already being used.'))
        return email
Пример #12
0
class FacebookConnectForm(forms.Form):
    username = CharField(
        min_length=2,
        max_length=30,
        help_text=
        "30 characters or fewer. Alphanumeric characters only (letters, digits and underscores)",
        widget=TextInput(
            attrs={
                "onfocus": "showRegHelp('username');",
                "onblur": "hideRegHelp('username');return checkUsername();",
                "onkeyup": "return checkUsername();"
            }))
    email = EmailField()
Пример #13
0
class ContactsForm(Form):
    name = CharField(
        label="Nimesi",
        required=False
    )

    email = EmailField(
        label="Sähköpostiosoitteesi",
        required=False
    )

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        fields = list(self.fields.keys())[2:] + ['name', 'email']
        self.fields = OrderedDict((k, self.fields[k]) for k in fields)
Пример #14
0
class RegisterForm(Form):
    """
    username/password/confirm login form.
    """

    username = UsernameField()
    email = EmailField()
    password = CharField(widget=PasswordInput)
    password_confirm = CharField(widget=PasswordInput)

    def clean(self):
        cleaned_data = super().clean()
        if cleaned_data['password'] != cleaned_data['password_confirm']:
            raise ValidationError("Passwords do not match")
        return cleaned_data
Пример #15
0
 def __init__(self, request=None, *args, **kwargs):
     self.request = request
     self.user_cache = None
     super(OrigAuthenticationForm, self).__init__(*args, **kwargs)
     # Set the max length and label for the "username" field.
     self.username_field = EmailField(label="email", help_text="Email address")
     self.username_field.verbose_name = 'Email'
     username_max_length = 255
     self.fields['username'].max_length = username_max_length
     self.fields['username'].widget.attrs['maxlength'] = username_max_length
     self.fields['username'].widget.attrs['class'] = 'form-control'
     self.fields['username'].widget.attrs['placeholder'] = 'Email or username'
     self.fields['username'].label = 'Email'
     self.fields['password'].widget.attrs['class'] = 'form-control'
     self.fields['password'].widget.attrs['placeholder'] = 'Password'
Пример #16
0
class CustomPasswordResetForm(PasswordResetForm):
    email = EmailField(label=_('Email'),
                       max_length=254,
                       widget=EmailInput(
                           attrs={
                               'class': 'form-control',
                               'autocomplete': 'email',
                               'placeholder': 'Email'
                           }))

    def save(self, request, from_email, **kwargs):
        super().save(
            from_email=from_email,
            subject_template_name='includes/emails/password_reset_subject.txt',
            email_template_name='includes/emails/password_reset_email.html',
            request=request,
            **kwargs)
Пример #17
0
    def __init__(self, request=None, *args, **kwargs):
        super().__init__(request, *args, **kwargs)

        self.fields['username'] = EmailField(
            label='',
            widget=EmailInput(attrs={
                'placeholder': 'Email',
                'input_prepend_icon': 'cil-user'
            }),
        )
        self.fields['password'] = CharField(
            label='',
            widget=PasswordInput(attrs={
                'placeholder': 'Password',
                'input_prepend_icon': 'cil-lock-locked'
            }),
        )
Пример #18
0
class BeginPasswordResetForm(PasswordResetForm):
    email = EmailField(
        label='Email',
        max_length=254,
        widget=EmailInput(
            attrs={
                'autocomplete':
                'email',
                'class':
                'border border-gray-400 rounded-full focus:border-blue-500 focus:outline-none w-88 h-10 pl-3'
            }))

    def clean_email(self):
        data = self.cleaned_data['email']
        if not User.objects.filter(email=data).all():
            raise ValidationError(
                "We couldn't find your account with that information.")
        return data

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
Пример #19
0
class SignupForm(BootstrapFormMixin, Form):
    # icon = models.ImageField(upload_to=icon_file_path, null=True, blank=True)
    name = CharField(max_length=256,
                     required=True,
                     widget=TextInput(attrs={'placeholder': 'ユーザーネーム'}))
    email = EmailField(max_length=256,
                       required=True,
                       widget=TextInput(attrs={'placeholder': 'メールアドレス'}))
    password = CharField(
        min_length=8,
        max_length=256,
        required=True,
        widget=PasswordInput(attrs={'placeholder': 'パスワード(8文字以上)'}))

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

    def create_user(self):
        if 'name' in self.cleaned_data:
            name = self.cleaned_data['name']
        else:
            name = None
        email = self.cleaned_data['email']
        password = self.cleaned_data['password']
        user = None
        try:
            if name:
                user = User.objects.create_user(email, password, name=name)
            else:
                user = User.objects.create_user(email, password)
        except:
            self.add_error('password', 'ユーザーの作成に失敗しました.')
        return user

    def clean_email(self):
        email = self.cleaned_data['email']
        if User.objects.filter(email=email).count() > 0:
            self.add_error('email', 'そのメールアドレスは既に使われています.')
        return email
Пример #20
0
class UnsubscribeForm(Form):
    email = EmailField(label=_('email address'))

    def clean(self):
        email = self.cleaned_data.get('email')
        try:
            subscription = Subscription.objects.get(email=email)
        except Subscription.DoesNotExist:
            raise ValidationError(ugettext(u'Email address not found.'))
        self.cleaned_data['subscription'] = subscription

    def save(self):
        subscription = self.cleaned_data['subscription']
        subscription.active = False
        subscription.save()

        context = {'subscription': subscription}
        # refactor to send_noreply_mail
        send_noreply_mail(
            ugettext(u'Unsubscribe from Wolne Lektury\'s newsletter.'),
            render_to_string('newsletter/unsubscribe_email.html', context),
            [subscription.email], fail_silently=True)
Пример #21
0
 def __init__(
         self,
         required=True,
         widget=None,
         max_length=None,
         fieldsetup_id=None,
         email_attrs=None,
         code_attrs=None,
         email_label=_('e-mail'),
         send_label=_('send verification code to given e-mail address'),
         sent_message=_(
             'The verification code has been sent to you e-mail address. '
             'You wil receive it within several minutes. Please, also check your SPAM folder.'
         ),
         code_label=_('verification code'),
         **kwargs):
     self.fieldsetup_id = fieldsetup_id or str(abs(hash(self)))
     self.fieldsetup = fieldsetups.setdefault(
         self.fieldsetup_id, VerifiedEmailFieldSetup(**kwargs))
     self.widget = widget or VerifiedEmailWidget(
         email_attrs=email_attrs,
         code_attrs=code_attrs,
         email_label=email_label,
         send_label=send_label,
         send_url=reverse_lazy('verified-email-field:send',
                               args=(self.fieldsetup_id, )),
         sent_message=sent_message,
         code_label=code_label,
         fieldsetup_id=self.fieldsetup_id,
     )
     super(VerifiedEmailField, self).__init__((
         EmailField(label=email_label, required=required),
         VerificationCodeField(label=code_label,
                               required=False,
                               length=self.fieldsetup.code_length),
     ),
                                              require_all_fields=False,
                                              **kwargs)
Пример #22
0
class SigninForm(BootstrapFormMixin, Form):
    email = EmailField(
        max_length=256,
        required=True,
        widget=TextInput(attrs={'placeholder': 'メールアドレス'}))
    password = CharField(
        max_length=256,
        required=True,
        widget=PasswordInput(attrs={'placeholder': 'パスワード'}))

    def clean_email(self):
        email = self.cleaned_data['email']
        if User.objects.filter(email=email).count() == 0:
            self.add_error('password', 'メールアドレスかパスワードが正しくありません。')
        return email

    def get_authenticated_user(self):
        user = authenticate(
            username=self.cleaned_data['email'],
            password=self.cleaned_data['password'])
        if user is None:
            self.add_error('password', 'メールアドレスかパスワードが正しくありません。')
        return user
Пример #23
0
class LoginForm(forms.Form):
    email = EmailField(
        widget=forms.TextInput(attrs={'autofocus': True}),
    )
    password = forms.CharField(
        strip=False,
        widget=forms.PasswordInput,
    )

    def __init__(self, request=None, *args, **kwargs):
        # Basically a copy of from django.contrib.auth.forms.AuthenticationForm
        self.request = request
        self.user_cache = None
        super(LoginForm, self).__init__(*args, **kwargs)

    def clean(self):
        username = self.cleaned_data.get('email')
        if username:
            username = username.lower()
        password = self.cleaned_data.get('password')

        if username is not None and password:
            self.user_cache = authenticate(self.request, username=username, password=password)
            if self.user_cache is None:
                raise ValidationError("Please enter a correct email and password.", code='invalid_login')
            elif not self.user_cache.is_active:
                raise ValidationError("This account is inactive.", code='inactive')

        return self.cleaned_data

    def get_user_id(self):
        if self.user_cache:
            return self.user_cache.id
        return None

    def get_user(self):
        return self.user_cache
Пример #24
0
 def __init__(self,
              required=True,
              fieldsetup_id=None,
              max_length=None,
              email_label=_('e-mail'),
              send_label=_('send verification code'),
              code_label=_('verification code'),
              **kwargs):
     self.fieldsetup_id = fieldsetup_id or str(hash(self))
     self.fieldsetup = fieldsetups.setdefault(
         self.fieldsetup_id, VerifiedEmailFieldSetup(**kwargs))
     self.widget = VerifiedEmailWidget(
         send_label=send_label,
         fieldsetup_id=self.fieldsetup_id,
         email_attrs={'placeholder': email_label},
         code_attrs={'placeholder': code_label},
     )
     super(VerifiedEmailField, self).__init__((
         EmailField(label=email_label, required=required),
         VerificationCodeField(label=code_label,
                               length=self.fieldsetup.code_length),
     ),
                                              require_all_fields=False,
                                              **kwargs)
Пример #25
0
 def before_import_row(self, row, **kwargs):
     EmailField().run_validators(row.get('email'))
     PhoneNumberField().run_validators(row.get('phone'))
Пример #26
0
class EntityEmailForm(base_forms.CremeModelForm):
    """Mails are related to the selected contacts/organisations & the 'current' entity.
    Mails are send to selected contacts/organisations.
    """
    sender = EmailField(label=_('Sender'))

    c_recipients = MultiCreatorEntityField(label=_('Contacts'),
                                           required=False,
                                           model=Contact,
                                           q_filter={'email__gt': ''})
    o_recipients = MultiCreatorEntityField(label=_('Organisations'),
                                           required=False,
                                           model=Organisation,
                                           q_filter={'email__gt': ''})

    send_me = BooleanField(label=_('Send me a copy of this mail'),
                           required=False)

    error_messages = {
        'no_person': _('Select at least a Contact or an Organisation'),
    }

    blocks = base_forms.FieldBlockManager(
        ('recipients', _('Who'),
         ['user', 'sender', 'send_me', 'c_recipients', 'o_recipients']),
        ('content', _('What'), ['subject', 'body', 'body_html']),
        ('extra', _('With'), ['signature', 'attachments']),
    )

    class Meta:
        model = EntityEmail
        fields = ('user', 'sender', 'subject', 'body', 'body_html',
                  'signature', 'attachments')

    def __init__(self, entity, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.entity = entity

        if isinstance(entity, (Contact, Organisation)):
            fn, msg = ('c_recipients', _('Beware: the contact «{}» has no email address!')) \
                      if isinstance(entity, Contact) else \
                      ('o_recipients', _('Beware: the organisation «{}» has no email address!'))
            field = self.fields[fn]

            if entity.email:
                field.initial = [entity.pk]
            else:
                field.help_text = msg.format(entity)

        self.user_contact = contact = self.user.linked_contact

        if contact.email:
            self.fields['sender'].initial = contact.email

        def finalize_recipient_field(name, model):
            if FieldsConfig.get_4_model(model).is_fieldname_hidden('email'):
                self.fields[name] = CharField(
                    label=self.fields[name].label,
                    required=False,
                    widget=Label,
                    initial=gettext(
                        'Beware: the field «Email address» is hidden ;'
                        ' please contact your administrator.'),
                )

        finalize_recipient_field('c_recipients', Contact)
        finalize_recipient_field('o_recipients', Organisation)

    def _clean_recipients(self, field_name):
        if isinstance(self.fields[field_name].widget, Label):
            return []

        recipients = self.cleaned_data.get(field_name) or []
        bad_entities = []

        for entity in recipients:
            try:
                validate_email(entity.email)
            except ValidationError:
                bad_entities.append(entity)

        if bad_entities:
            msg_format = gettext('The email address for {} is invalid')
            user = self.user

            for entity in bad_entities:
                self.add_error(field_name,
                               msg_format.format(entity.allowed_str(user)))

        return recipients

    def clean_c_recipients(self):
        return self._clean_recipients('c_recipients')

    def clean_o_recipients(self):
        return self._clean_recipients('o_recipients')

    def clean(self):
        cdata = super().clean()

        if not self._errors and not cdata['c_recipients'] and not cdata[
                'o_recipients']:
            raise ValidationError(self.error_messages['no_person'],
                                  code='no_person')

        return cdata

    def save(self):
        cdata = self.cleaned_data
        get_data = cdata.get

        sender = get_data('sender')
        subject = get_data('subject')
        body = get_data('body')
        body_html = get_data('body_html')
        signature = get_data('signature')
        attachments = get_data('attachments')
        user = get_data('user')

        sending_error = False

        def create_n_send_mail(recipient_address):
            nonlocal sending_error

            email = EntityEmail.create_n_send_mail(
                sender=sender,
                recipient=recipient_address,
                subject=subject,
                user=user,
                body=body,
                body_html=body_html,
                signature=signature,
                attachments=attachments,
            )

            if email.status == MAIL_STATUS_SENDINGERROR:
                sending_error = True

            return email

        with atomic():
            if get_data('send_me'):
                create_n_send_mail(sender)

            user_contact = self.user_contact
            create_relation = partial(Relation.objects.create, user=user)

            for recipient in chain(cdata['c_recipients'],
                                   cdata['o_recipients']):
                email = create_n_send_mail(recipient.email)

                create_relation(subject_entity=email,
                                type_id=REL_SUB_MAIL_SENDED,
                                object_entity=user_contact)
                create_relation(subject_entity=email,
                                type_id=REL_SUB_MAIL_RECEIVED,
                                object_entity=recipient)

        if sending_error:
            entity_emails_send_type.refresh_job()
Пример #27
0
class EnrollForm(Form):
    email = EmailField(required=True, label='邮箱')
    course_id = IntegerField(required=True,
                             validators=[validate_enroll],
                             label='课程')
Пример #28
0
class LogInForm(AuthenticationForm):
    username = EmailField()
Пример #29
0
class SignInForm(UserCreationForm):
    email = EmailField(label=_('Email address'))

    class Meta(UserCreationForm.Meta):
        model = User
        fields = ['username', 'email', 'password1', 'password2']
def check(email):
    field = EmailField()
    return field.clean(email.strip())
Пример #31
0
class _MockRegistrationForm(Form):

    full_name = CharField(max_length=255)

    email_address = EmailField(max_length=255)
Пример #32
0
class ReporterRegistrationForm(Form):
    required_css_class = 'required'

    name = RegexField(regex="[^0-9.,\s@#$%&*~]*", max_length=80,
                      error_message=_("Please enter a valid value containing only letters a-z or A-Z or symbols '`- "),
                      label=_("Name"), required=False)
    telephone_number = PhoneNumberField(required=True, label=_("Mobile Number"),
                                        error_message=_("Please enter a valid phone number."))
    geo_code = CharField(max_length=30, required=False, label=_("GPS Coordinates"))

    location = CharField(max_length=500, required=False, label=_("Name"))
    project_id = CharField(required=False, widget=HiddenInput())

    DEVICE_CHOICES = (('sms', mark_safe('<img src="/media/images/mini_mobile.png" /> <span>SMS</span>')), (
        'web', mark_safe('<img src="/media/images/mini_computer.png" /> <span>Web</span>' + smartphone_icon())))
    devices = MultipleChoiceField(label=_('Device'), widget=CheckboxSelectMultiple(), choices=DEVICE_CHOICES,
                                  initial=['sms'], required=False, )
    email = EmailField(required=False, widget=TextInput(attrs=dict({'class': 'required'},
                                                                   maxlength=75)),
                       label=_("E-Mail"),
                       error_messages={
                           'invalid': _('Enter a valid email address. Example:[email protected]')})

    short_code = CharField(required=False, max_length=12, label=_("ID"),
                           widget=TextInput(attrs=dict({'class': 'subject_field'})))
    generated_id = BooleanField(required=False, initial=True)

    # Needed for telephone number validation
    org_id = None

    def __init__(self, org_id=None, *args, **kwargs):
        self.org_id = org_id
        super(ReporterRegistrationForm, self).__init__(*args, **kwargs)

    def _is_int(self, s):
        try:
            int(s)
            return True
        except ValueError:
            return False


    def _geo_code_format_validations(self, lat_long, msg):
        if len(lat_long) != 2:
            self._errors['geo_code'] = self.error_class([msg])
        else:
            try:
                if not (-90 < float(lat_long[0]) < 90 and -180 < float(lat_long[1]) < 180):
                    self._errors['geo_code'] = self.error_class([msg])
            except Exception:
                self._errors['geo_code'] = self.error_class([msg])

    def _geo_code_validations(self):
        geo_code = self.cleaned_data.get("geo_code").strip()

        if not bool(geo_code):
            return

        msg = _(
            "Incorrect GPS format. The GPS coordinates must be in the following format: xx.xxxx,yy.yyyy. Example -18.8665,47.5315")

        geo_code_string = geo_code.strip()
        geo_code_string = geo_code_string.replace(",", " ")
        geo_code_string = re.sub(' +', ' ', geo_code_string)
        if not is_empty(geo_code_string):
            lat_long = geo_code_string.split(" ")
            self._geo_code_format_validations(lat_long, msg)
            self.cleaned_data['geo_code'] = geo_code_string

    def clean(self):
        self.convert_email_to_lowercase()
        if not self.cleaned_data.get('generated_id') and not self.cleaned_data.get('short_code'):
            msg = _('This field is required.')
            self.errors['short_code'] = self.error_class([msg])

        self._geo_code_validations()
        if not self.cleaned_data.get('project_id'):
            self.cleaned_data['is_data_sender'] = False
        else:
            self.cleaned_data['is_data_sender'] = 'True'

        return self.cleaned_data

    def clean_short_code(self):
        short_code = self.cleaned_data.get('short_code')

        if short_code:
            if len(short_code) > 12:
                msg = _("Unique ID should be less than 12 characters")
                self.errors['short_code'] = self.error_class([msg])

            if not re.match("^[a-zA-Z0-9]+$", short_code):
                msg = _("Only letters and numbers are valid")
                self.errors['short_code'] = self.error_class([msg])

        return short_code

    def clean_telephone_number(self):
        """
        Validate telephone number. This expects the dbm to be set on the form before trying to clean.
        """

        organization = Organization.objects.get(org_id=self.org_id)
        mobile_number = self.cleaned_data.get('telephone_number')
        if organization.in_trial_mode:
            datasender_filter = DataSenderOnTrialAccount.objects.filter(mobile_number=(mobile_number))
            if datasender_filter.exclude(organization=organization).exists():
                self._errors['telephone_number'] = self.error_class(
                    [_(u"Sorry, this number has already been used for a different DataWinners Basic account.")])
        return mobile_number


    def clean_email(self):
        """
        Validate that the supplied email address is unique for the
        site.

        """
        email = self.cleaned_data.get('email')
        if not email:
            return email

        if datasender_count_with(email) > 0:
            raise forms.ValidationError(
                _("This email address is already in use. Please supply a different email address."))
        return self.cleaned_data['email']

    def convert_email_to_lowercase(self):
        email = self.cleaned_data.get('email')
        if email is not None:
            self.cleaned_data['email'] = email.lower()

    def requires_web_access(self):
        return self.cleaned_data.get('email')

    def update_errors(self, validation_errors):
        mapper = {MOBILE_NUMBER_FIELD_CODE: 'telephone_number',
                  GEO_CODE: GEO_CODE_FIELD_NAME}
        for field_code, error in validation_errors.iteritems():
            self._errors[mapper.get(field_code)] = self.error_class([_(error)])