class EscalationMessageForm(forms.Form): subject = forms.CharField( label=_("Subject"), max_length=230, widget=forms.TextInput(attrs={"class": "form-control"})) message = forms.CharField( widget=forms.Textarea(attrs={"class": "form-control"}), label=_("Your message"), ) def __init__(self, foirequest, *args, **kwargs): super(EscalationMessageForm, self).__init__(*args, **kwargs) self.foirequest = foirequest def clean_message(self): message = self.cleaned_data['message'] message = message.replace('\r\n', '\n').strip() empty_form = self.foirequest.get_escalation_message_form() if message == empty_form.initial['message'].strip(): raise forms.ValidationError( _('You need to fill in the blanks in the template!')) return message def clean(self): throttle_message = check_throttle(self.foirequest.user, FoiMessage) if throttle_message: raise forms.ValidationError(throttle_message) def save(self): self.foirequest.add_escalation_message(**self.cleaned_data)
def __init__(self, *args, **kwargs): super(OpportunityForm, self).__init__(*args, **kwargs) self.fields['detail'].widget = forms.Textarea( attrs={ 'placeholder': _('enter details'), 'cols': '72' })
def __init__(self, *args, **kwargs): super(RoleForm, self).__init__(*args, **kwargs) # import ipdb; ipdb.set_trace() try: initial = self.instance.description.text except models.GroupDescription.DoesNotExist: initial = "" self.fields['description'] = forms.CharField(initial=initial, widget=forms.Textarea(), required=False)
class QuestionForm(forms.ModelForm): text = forms.CharField(required=True, widget=forms.Textarea( attrs={'rows': 2, 'placeholder': 'Enter your Question.'}), max_length=4000, help_text='The max length of the question is 4000.') class Meta: model = TmaQuestion fields = ('text',)
class ContatarAnuncianteForm(forms.Form): imovel_ref = forms.CharField(widget=forms.HiddenInput()) email = forms.EmailField( widget=forms.TextInput(attrs={'placeholder': 'Digite seu email'}), label='E-mail') telefone = forms.CharField( widget=forms.TextInput(attrs={'placeholder': 'Digite seu telefone'})) nome = forms.CharField( widget=forms.TextInput(attrs={'placeholder': 'Digite seu nome'}), label='Nome') sobrenome = forms.CharField( widget=forms.TextInput(attrs={'placeholder': 'Digite seu sobrenome'}), label='Sobrenome') mensagem = forms.CharField( widget=forms.Textarea(attrs={'rows': 3, 'cols': 45, 'placeholder': 'Precisa mais informações do imóvel ou gostaria de agendar uma visita?'}, ), label='Mensagem', required=False) def __init__(self, *args, **kwargs): super(ContatarAnuncianteForm, self).__init__(*args, **kwargs) def clean_telefone(self): telefone = self.cleaned_data['telefone'] # not re.match(r'^(\(\d{2}\)) ?(\d{5}-\d{4}|\d{9}|\d{4}-\d{4}|\d{8})$', # telefone) if len(telefone) < 9: raise forms.ValidationError("Digite um telefone válido.") return telefone def envia_email(self): sender = MagicEmail("{0}".format(settings.DEFAULT_FROM_EMAIL)) current_site = Site.objects.get_current() subject = "[SJC Vale Imóveis] Novo Contato: Ref: {0} ".format( self.cleaned_data['imovel_ref']) data = {'domain': current_site.domain, 'body': subject, 'imovel_ref': self.cleaned_data['imovel_ref'], 'email': self.cleaned_data['email'], 'telefone': self.cleaned_data['telefone'], 'nome': self.cleaned_data['nome'], 'sobrenome': self.cleaned_data['sobrenome'], 'mensagem': self.cleaned_data['mensagem'], 'url': reverse('buscador.lista.imovel_referencia', args=[self.cleaned_data['imovel_ref'], ]), } email_contato = preferences.ImobiliariaPreferences.email_contato sender.using_template( "contato_cliente_imovel", data) \ .with_subject(subject) \ .reply_to(self.cleaned_data['email']) \ .send_to([email_contato, ])
class Meta(object): model = Kv15Scenario exclude = ['dataownercode'] widgets = { 'description': forms.Textarea(attrs={ 'cols': 40, 'rows': 4, 'class': 'col-lg-6' }), }
class Meta: model = Step fields = ('text', ) widgets = { 'text': forms.Textarea(attrs={ 'rows': 3, 'cols': 140, 'style': 'resize: none;' }) }
class ExamQuestionForm(forms.ModelForm): type = forms.ChoiceField(required=True, choices=TYPES, widget=forms.RadioSelect) text = forms.CharField(required=True, widget=forms.Textarea( attrs={'rows': 2, 'placeholder': 'Enter your Question.'}), max_length=4000, help_text='The max length of the question is 4000.') class Meta: model = ExamQuestion fields = ('text', 'type')
class Meta: model = Post fields = [ 'message', ] widgets = { 'message': forms.Textarea(attrs={ 'rows': 5, 'placeholder': 'Enter your Question.' }) }
class Meta: model = ExpertReportAnnotation fields = ('tiger_certainty_category', 'aegypti_certainty_category', 'tiger_certainty_notes', 'site_certainty_category', 'site_certainty_notes', 'status', 'linked_id', 'edited_user_notes', 'message_for_user', 'best_photo', 'revise', 'validation_complete', 'tags') widgets = { 'tiger_certainty_category': forms.HiddenInput, 'aegypti_certainty_category': forms.HiddenInput, 'best_photo': forms.HiddenInput, 'revise': forms.HiddenInput, 'tiger_certainty_notes': forms.Textarea(attrs={'rows': 4}), 'site_certainty_notes': forms.Textarea(attrs={'rows': 4}), #'edited_user_notes': forms.Textarea(attrs={'rows': 4}), # Public Note 'edited_user_notes': forms.HiddenInput, #'message_for_user': forms.Textarea(attrs={'rows': 4}), 'message_for_user': forms.HiddenInput, 'tags': forms.HiddenInput, }
class MessageForm(forms.Form): """A form for sending a message to web site owner""" message = forms.CharField( required=True, widget=forms.Textarea(attrs={ 'placeholder': _("Your message"), })) def clean_message(self): message = self.cleaned_data['message'] if len(message) > 10000: raise forms.ValidationError(ugettext('Message is too long')) return message
class UserChangeForm(forms.Form): email = forms.EmailField( required=False, widget=forms.EmailInput(attrs={ 'placeholder': _('*****@*****.**'), 'class': 'form-control' }), label=_('Your email address')) address = forms.CharField( max_length=300, label=_('Your mailing address'), help_text=_('Your address will never be displayed publicly.'), widget=forms.Textarea(attrs={ 'placeholder': _('Street, Post Code, City'), 'class': 'form-control' })) field_order = ['email', 'newsletter', 'address'] def __init__(self, user, *args, **kwargs): super(UserChangeForm, self).__init__(*args, **kwargs) self.user = user self.fields['address'].initial = self.user.address self.fields['email'].initial = self.user.email if HAVE_NEWSLETTER(): self.fields['newsletter'] = forms.BooleanField( required=False, label=_("Newsletter")) self.fields['newsletter'].initial = self.user.newsletter self.order_fields(self.field_order) def clean_email(self): email = self.cleaned_data['email'].lower() if (self.user.email != email and get_user_model().objects.filter(email=email).exists()): raise forms.ValidationError( _('Another user with that email address already exists!')) return email def save(self): self.user.address = self.cleaned_data['address'] if HAVE_NEWSLETTER(): self.user.newsletter = self.cleaned_data['newsletter'] self.user.save()
def __init__(self, *args, **kwargs): kwargs.pop('entity', None) instance = kwargs.get('instance', None) action_type = kwargs.pop('action_type', None) super(ActionForm, self).__init__(*args, **kwargs) self.title = u"" if instance: action_type = instance.type self.action_type = action_type is_amount_calculated = False if action_type: is_amount_calculated = action_type.is_amount_calculated self.calculated_amount = Decimal("0") for fieldset_name, fieldset_attrs in self.Meta.fieldsets: if fieldset_name == 'type': fieldset_attrs['legend'] = action_type.name break self.fields['type'].widget = forms.HiddenInput() self.fields['type'].initial = action_type if instance: self.title = ugettext(u"Edition {0}").format(action_type.name) else: self.title = ugettext(u"Creation {0}").format(action_type.name) else: self.title = ugettext(u"Edit action") if instance else ugettext(u"Create action") is_auto_generated = (action_type and action_type.number_auto_generated) or \ (instance and instance.type and instance.type.number_auto_generated) if is_auto_generated: self.fields['number'].widget.attrs['disabled'] = 'disabled' self.fields['number'].required = False self.fields['amount'].widget.attrs['step'] = 'any' if is_amount_calculated: self.fields['amount'].widget.attrs['disabled'] = 'disabled' self.is_amount_calculated = is_amount_calculated if action_type and action_type.allowed_status.count(): # let javascript disable the blank value if default_status choices = [('', "---------")] allowed_status = action_type.allowed_status.all() if instance and instance.frozen: allowed_status = allowed_status.filter(allowed_on_frozen=True) self.fields['status'].choices = choices + [ (status.id, status.name) for status in allowed_status ] if action_type.default_status: self.fields['status'].initial = action_type.default_status.id else: self.fields['status'].initial = '' if action_type and action_type.allowed_status2.count(): # let javascript disable the blank value if default_status2 allowed_status2 = action_type.allowed_status2.all() if instance and instance.frozen: allowed_status2 = allowed_status2.filter(allowed_on_frozen=True) choices = [('', "---------")] self.fields['status2'].choices = choices + [ (status.id, status.name) for status in allowed_status2 ] if action_type.default_status2: self.fields['status2'].initial = action_type.default_status2.id else: self.fields['status2'].initial = '' else: self.fields['status2'].widget = forms.HiddenInput() self.fields['opportunity'].widget = forms.HiddenInput() self.fields['detail'].widget = forms.Textarea(attrs={'placeholder': _('enter details'), 'cols': '72'}) self._init_dt_field("planned_date", "date", "time") self._init_dt_field("end_datetime", "end_date", "end_time")
class ContactForm(forms.Form): """ Contact Form """ name = forms.CharField(required=True, max_length=100, label='Ihr Name', widget=forms.TextInput(attrs={ 'placeholder': 'Name', 'autofocus': 'autofocus' })) email = forms.EmailField( required=True, max_length=100, label='Ihre Email', widget=forms.TextInput(attrs={'placeholder': 'Email'})) message = forms.CharField( required=True, label='Ihre Nachricht', widget=forms.Textarea(attrs={'placeholder': 'Nachricht'})) OUTGOING = u'Kontakt: Bestätigungsmail an den Kunden' INTERNAL = u'Weiterleitung Kontaktanfrage, bitte beantworten!' CONTACT_EMAIL = settings.MENTOKI_INFO_EMAIL def __init__(self, *args, **kwargs): super(ContactForm, self).__init__(*args, **kwargs) def send_email_visitor(self): # send email to requesting email # this method is called with cleaned from data subject = "Ihre Nachricht an mentoki" to = [self.cleaned_data['email']] from_mail = '*****@*****.**' # prepare template context = { 'name': self.cleaned_data['name'], 'email': self.cleaned_data['email'], 'message': self.cleaned_data['message'], 'betreff': "Ihre Nachricht", } message = get_template('email/contact/to_customer.html').render( Context(context)) to_customer = MailerMessage() to_customer.subject = "Ihre Nachricht an mentoki" to_customer.to_address = self.cleaned_data['email'] to_customer.from_address = ContactForm.CONTACT_EMAIL to_customer.content = ContactForm.OUTGOING to_customer.html_content = message to_customer.reply_to = ContactForm.CONTACT_EMAIL to_customer.app = self.__module__ to_customer.save() def send_email_self(self): """ email is send to mentoki """ context = { 'name': self.cleaned_data['name'], 'email': self.cleaned_data['email'], 'message': self.cleaned_data['message'], 'betreff': "Nachricht an mentoki", } message = get_template('email/contact/to_mentoki.html').render( Context(context)) to_mentoki = MailerMessage() to_mentoki.subject = "Kontaktanfrage an mentoki" to_mentoki.to_address = ContactForm.CONTACT_EMAIL to_mentoki.from_address = self.cleaned_data['email'] to_mentoki.content = ContactForm.INTERNAL to_mentoki.html_content = message to_mentoki.reply_to = self.cleaned_data['email'] to_mentoki.app = self.__module__ to_mentoki.save()
class NewUserBaseForm(forms.Form): first_name = forms.CharField( max_length=30, label=_('First name'), widget=forms.TextInput(attrs={ 'placeholder': _('First Name'), 'class': 'form-control' })) last_name = forms.CharField( max_length=30, label=_('Last name'), widget=forms.TextInput(attrs={ 'placeholder': _('Last Name'), 'class': 'form-control' })) address = forms.CharField( max_length=300, required=False, label=_('Mailing Address'), help_text= _('Optional. Your address will not be displayed publicly and is only needed in case a public body needs to send you paper.' ), widget=forms.Textarea( attrs={ 'rows': '3', 'class': 'form-control', 'placeholder': _('Street, Post Code, City'), })) user_email = forms.EmailField( label=_('Email address'), max_length=75, help_text=_('Not public. The given address will ' 'need to be confirmed.'), widget=forms.EmailInput(attrs={ 'placeholder': _('*****@*****.**'), 'class': 'form-control' })) if HAVE_ORGANIZATION: organization = forms.CharField( required=False, label=_("Organization"), help_text=_( 'Optional. Affiliation will be shown next to your name'), widget=forms.TextInput(attrs={ 'placeholder': _('Organization'), 'class': 'form-control' })) if USER_CAN_HIDE_WEB: private = forms.BooleanField( required=False, label=_("Hide my name on the web"), help_text=mark_safe( _("If you check this, your name will still appear in requests to public bodies, but we will do our best to not display it publicly. However, we cannot guarantee your anonymity" ))) def __init__(self, *args, **kwargs): super(NewUserBaseForm, self).__init__(*args, **kwargs) if ALLOW_PSEUDONYM: self.fields["last_name"].help_text = mark_safe( _('<a target="_blank" href="{url}">You may use a pseudonym if you don\'t need to receive postal messages</a>.' ).format(url=reverse("help-privacy") + '#pseudonym')) def clean_first_name(self): return self.cleaned_data['first_name'].strip() def clean_last_name(self): return self.cleaned_data['last_name'].strip() def clean_user_email(self): email = self.cleaned_data['user_email'] user_model = get_user_model() try: user = user_model.objects.get(email=email) except user_model.DoesNotExist: pass else: if user.is_active: raise forms.ValidationError( mark_safe( _('This email address already has an account. <a href="%(url)s?simple&email=%(email)s" class="btn btn-warning target-small">Click here to login using that email address.</a>' ) % { 'url': reverse("account-login"), 'email': email })) else: raise forms.ValidationError( _('This email address is already registered, but not yet confirmed! Please click on the confirmation link in the mail we send you.' )) return email
class PostalBaseForm(AttachmentSaverMixin, forms.Form): scan_help_text = mark_safe( _("Uploaded scans can be PDF, JPG or PNG. Please make sure to <strong>redact/black out all private information concerning you</strong>." )) public_body = forms.ModelChoiceField(label=_('Public body'), queryset=PublicBody.objects.all(), widget=PublicBodySelect) date = forms.DateField( widget=forms.TextInput(attrs={ "class": "form-control", "placeholder": _('mm/dd/YYYY') }), label=_("Send Date"), help_text=_("Please give the date the reply was sent."), localize=True) subject = forms.CharField( label=_("Subject"), required=False, max_length=230, widget=forms.TextInput(attrs={ "class": "form-control", "placeholder": _("Subject") })) text = forms.CharField( label=_("Letter"), widget=forms.Textarea(attrs={ "placeholder": _("Letter text"), "class": "form-control" }), required=False, help_text= _("The text can be left empty, instead you can upload scanned documents." )) files = forms.FileField(label=_("Scanned Letter"), required=False, validators=[validate_upload_document], help_text=scan_help_text, widget=forms.FileInput(attrs={'multiple': True})) FIELD_ORDER = ['public_body', 'date', 'subject', 'text', 'files'] def __init__(self, *args, **kwargs): self.foirequest = kwargs.pop('foirequest') super(PostalBaseForm, self).__init__(*args, **kwargs) self.fields['public_body'].label = self.PUBLIC_BODY_LABEL self.fields['public_body'].initial = self.foirequest.public_body self.order_fields(self.FIELD_ORDER) def clean_date(self): date = self.cleaned_data['date'] now = timezone.now().date() if date > now: raise forms.ValidationError( _("Your reply date is in the future, that is not possible.")) return date def clean_files(self): if 'files' not in self.files: return self.cleaned_data['files'] files = self.files.getlist('files') names = set() for file in files: validate_upload_document(file) name = self.make_filename(file.name) if name in names: # FIXME: dont make this a requirement raise forms.ValidationError( _('Upload files must have distinct names')) names.add(name) return self.cleaned_data['files'] def clean(self): cleaned_data = self.cleaned_data text = cleaned_data.get("text") if 'files' in self.files: files = self.files.getlist('files') else: files = None if not (text or files): raise forms.ValidationError( _("You need to provide either the letter text or a scanned document." )) return cleaned_data def save(self): foirequest = self.foirequest message = FoiMessage( request=foirequest, is_postal=True, ) # TODO: Check if timezone support is correct date = datetime.datetime.combine(self.cleaned_data['date'], datetime.time()) message.timestamp = timezone.get_current_timezone().localize(date) message.subject = self.cleaned_data.get('subject', '') message.subject_redacted = message.redact_subject()[:250] message.plaintext = "" if self.cleaned_data.get('text'): message.plaintext = self.cleaned_data.get('text') message.plaintext_redacted = message.get_content() message = self.contribute_to_message(message) message.save() foirequest.last_message = message.timestamp foirequest.status = 'awaiting_classification' foirequest.save() foirequest.add_postal_reply.send(sender=foirequest) if self.cleaned_data.get('files'): self.save_attachments(self.files.getlist('files'), message) return message
class Meta: """form is defined from model""" model = models.Contact fields = ('gender', 'gender_title', 'lastname', 'firstname', 'birth_date', 'title', 'role', 'job', 'email', 'phone', 'mobile', 'favorite_language', 'street_number', 'street_type', 'address', 'address2', 'address3', 'zip_code', 'city', 'cedex', 'country', 'main_contact', 'email_verified', 'has_left', 'accept_notifications', 'photo', 'billing_street_number', 'billing_street_type', 'billing_address', 'billing_address2', 'billing_address3', 'billing_zip_code', 'billing_city', 'billing_cedex', 'billing_country', 'same_as_suggestions') widgets = { 'notes': forms.Textarea(attrs={ 'placeholder': _('enter notes about the contact'), 'cols': '72' }), 'role': forms.SelectMultiple( attrs={ 'class': 'chosen-select', 'data-placeholder': _('Select roles'), 'style': "width: 100%;" }), } fieldsets = [ ('name', { 'fields': [ 'gender', 'gender_title', 'lastname', 'firstname', 'email', 'same_as_suggestions', 'phone', 'mobile' ], 'legend': _('Name') }), ('web', { 'fields': [ 'birth_date', 'title', 'role', 'job', 'favorite_language', ], 'legend': _('Contact details') }), ('address', { 'fields': [ 'street_number', 'street_type', 'address', 'address2', 'address3', 'zip_code', 'city', 'cedex', 'country' ], 'legend': _('Address') }), ('billing_address', { 'fields': [ 'billing_street_number', 'billing_street_type', 'billing_address', 'billing_address2', 'billing_address3', 'billing_zip_code', 'billing_city', 'billing_cedex', 'billing_country' ], 'legend': _('Billing address') }), ('relationship', { 'fields': [ 'main_contact', 'email_verified', 'has_left', 'accept_notifications' ], 'legend': _('Options') }), ('photo', { 'fields': ['photo'], 'legend': _('Photo') }), ]
class Meta(object): model = Kv15ScenarioMessage exclude = ['dataownercode'] widgets = { 'scenario': forms.HiddenInput, 'messagecontent': forms.Textarea(attrs={ 'cols': 40, 'rows': 4, 'class': 'col-lg-6' }), 'reasoncontent': forms.Textarea(attrs={ 'cols': 40, 'rows': 4, 'class': 'col-lg-6' }), 'effectcontent': forms.Textarea(attrs={ 'cols': 40, 'rows': 4, 'class': 'col-lg-6' }), 'measurecontent': forms.Textarea(attrs={ 'cols': 40, 'rows': 4, 'class': 'col-lg-6' }), 'advicecontent': forms.Textarea(attrs={ 'cols': 40, 'rows': 4, 'class': 'col-lg-6' }), # This is awful, but is neccesary because otherwise we don't get nice bootstrappy widgets 'messagepriority': forms.RadioSelect, 'messagetype': forms.RadioSelect, 'messagedurationtype': forms.RadioSelect, 'messagestarttime': forms.DateTimeInput, 'messageendtime': forms.DateTimeInput, 'reasontype': forms.RadioSelect, 'subreasontype': forms.Select, 'effecttype': forms.RadioSelect, 'subeffecttype': forms.Select, 'measuretype': forms.RadioSelect, 'submeasuretype': forms.Select, 'advicetype': forms.RadioSelect, 'subadvicetype': forms.Select }
class RequestForm(forms.Form): public_body = forms.CharField( widget=PublicBodySelect, label=_("Search for a topic or a public body:"), required=False) subject = forms.CharField( label=_("Subject"), max_length=230, widget=forms.TextInput(attrs={ 'placeholder': _("Subject"), "class": "form-control" })) body = forms.CharField( label=_("Body"), widget=forms.Textarea( attrs={ 'placeholder': _("Specify your request here..."), "class": "form-control" })) full_text = forms.BooleanField( required=False, initial=False, label=_("Don't wrap in template"), widget=forms.CheckboxInput(attrs={'tabindex': '-1'})) public = forms.BooleanField( required=False, initial=True, label=_("This request is public."), help_text=_( "If you don't want your request to be public right now," " uncheck this. You can always decide to make it public later.")) reference = forms.CharField(widget=forms.HiddenInput, required=False) redirect_url = forms.CharField(widget=forms.HiddenInput, required=False) hide_public = forms.BooleanField(widget=forms.HiddenInput, initial=False, required=False) hide_similar = forms.BooleanField(widget=forms.HiddenInput, initial=False, required=False) def __init__(self, user=None, list_of_laws=(), default_law=None, hide_law_widgets=True, **kwargs): super(RequestForm, self).__init__(**kwargs) self.user = user self.list_of_laws = list_of_laws self.indexed_laws = dict([(l.pk, l) for l in self.list_of_laws]) self.default_law = default_law self.fields["public_body"].widget.set_initial_jurisdiction( kwargs.get('initial', {}).pop('jurisdiction', None)) self.fields["public_body"].widget.set_initial_search( kwargs.get('initial', {}).pop('public_body_search', None)) self.fields["law"] = forms.ChoiceField( label=_("Information Law"), required=False, widget=forms.Select if not hide_law_widgets else forms.HiddenInput, initial=default_law.pk, choices=((l.pk, l.name) for l in list_of_laws)) def laws_to_json(self): return json.dumps( dict([(l.id, l.as_dict()) for l in self.list_of_laws])) def clean_public_body(self): pb = self.cleaned_data['public_body'] if pb == "new": if not new_publicbody_allowed: raise forms.ValidationError( _("You are not allowed to create a new public body")) elif pb == "": if not publicbody_empty: raise forms.ValidationError( _("You must specify a public body")) pb = None else: try: pb_pk = int(pb) except ValueError: raise forms.ValidationError(_("Invalid value")) try: public_body = PublicBody.objects.get(pk=pb_pk) except PublicBody.DoesNotExist: raise forms.ValidationError(_("Invalid value")) self.public_body_object = public_body self.foi_law_object = public_body.default_law return pb public_body_object = None def clean_reference(self): ref = self.cleaned_data['reference'] if not ref: return '' try: kind, value = ref.split(':', 1) except ValueError: return '' try: return '%s:%s' % (kind, value) except ValueError: return '' def clean_law_for_public_body(self, public_body): law = self.clean_law_without_public_body() if law is None: return None if law.jurisdiction.id != public_body.jurisdiction.id: self._errors["law"] = self.error_class( [_("Invalid Information Law")]) return None return law def clean_law_without_public_body(self): try: law = self.cleaned_data['law'] law = self.indexed_laws[int(law)] except (ValueError, KeyError): self._errors["law"] = self.error_class( [_("Invalid Information Law")]) return None return law def clean(self): cleaned = self.cleaned_data public_body = cleaned.get("public_body") if public_body is not None and (public_body != "new" and public_body != ""): self.foi_law = self.clean_law_for_public_body( self.public_body_object) else: self.foi_law = self.clean_law_without_public_body() throttle_message = check_throttle(self.user, FoiRequest) if throttle_message: raise forms.ValidationError(throttle_message) return cleaned
class SendMessageForm(forms.Form): to = forms.TypedChoiceField( label=_("To"), choices=[], coerce=int, required=True, widget=forms.RadioSelect(attrs={"class": "form-control"})) subject = forms.CharField( label=_("Subject"), max_length=230, widget=forms.TextInput(attrs={"class": "form-control"})) message = forms.CharField( widget=forms.Textarea(attrs={"class": "form-control"}), label=_("Your message")) def __init__(self, foirequest, *args, **kwargs): super(SendMessageForm, self).__init__(*args, **kwargs) self.foirequest = foirequest choices = [(0, _("Default address of %(publicbody)s") % { "publicbody": foirequest.public_body.name })] choices.extend([ (m.id, m.reply_address_entry) for k, m in foirequest.possible_reply_addresses().items() ]) self.fields['to'].choices = choices if foirequest.law and foirequest.law.email_only: self.fields['send_address'] = forms.BooleanField( label=_("Send physical address"), help_text=(_( 'If the public body is asking for your post ' 'address, check this and we will append it to your message.' )), required=False) def clean(self): throttle_message = check_throttle(self.foirequest.user, FoiMessage) if throttle_message: raise forms.ValidationError(throttle_message) def save(self, user): if self.cleaned_data["to"] == 0: recipient_name = self.foirequest.public_body.name recipient_email = self.foirequest.public_body.email recipient_pb = self.foirequest.public_body else: message = list( filter(lambda x: x.id == self.cleaned_data["to"], list(self.foirequest.messages)))[0] recipient_name = message.sender_name recipient_email = message.sender_email recipient_pb = message.sender_public_body return self.foirequest.add_message(user, recipient_name, recipient_email, self.cleaned_data["subject"], self.cleaned_data['message'], recipient_pb=recipient_pb, send_address=self.cleaned_data.get( 'send_address', True))
class Meta(object): model = Kv15Stopmessage exclude = [ 'messagecodenumber', 'status', 'stops', 'messagecodedate', 'isdeleted', 'id', 'dataownercode', 'user' ] widgets = { 'messagecontent': forms.Textarea(attrs={ 'cols': 50, 'rows': 6, 'class': 'col-lg-6', 'maxlength': 255 }), 'reasoncontent': forms.Textarea(attrs={ 'cols': 40, 'rows': 4, 'class': 'col-lg-6' }), 'effectcontent': forms.Textarea(attrs={ 'cols': 40, 'rows': 4, 'class': 'col-lg-6' }), 'measurecontent': forms.Textarea(attrs={ 'cols': 40, 'rows': 4, 'class': 'col-lg-6' }), 'advicecontent': forms.Textarea(attrs={ 'cols': 40, 'rows': 4, 'class': 'col-lg-6' }), # This is awful, but is neccesary because otherwise we don't get nice bootstrappy widgets 'messagepriority': forms.RadioSelect, 'messagedurationtype': forms.RadioSelect, 'messagetype': forms.RadioSelect, 'messagestarttime': forms.DateTimeInput, 'messageendtime': forms.DateTimeInput, 'reasontype': forms.RadioSelect, 'subreasontype': forms.Select, 'effecttype': forms.RadioSelect, 'subeffecttype': forms.Select, 'measuretype': forms.RadioSelect, 'submeasuretype': forms.Select, 'advicetype': forms.RadioSelect, 'subadvicetype': forms.Select, 'messagetimestamp': forms.DateTimeInput }
class Kv17ChangeForm(forms.ModelForm): # This is duplication, but should work operatingday = forms.ChoiceField(label=_("Datum"), required=True) begintime_part = forms.TimeField(label=_('Ingangstijd'), required=False, widget=forms.TimeInput(format='%H:%M:%S')) endtime_part = forms.TimeField(label=_('Eindtijd'), required=False, widget=forms.TimeInput(format='%H:%M:%S')) reasontype = forms.ChoiceField(choices=REASONTYPE, label=_("Type oorzaak"), required=False) subreasontype = forms.ChoiceField(choices=SUBREASONTYPE, label=_("Oorzaak"), required=False) reasoncontent = forms.CharField(max_length=255, label=_("Uitleg oorzaak"), required=False, widget=forms.Textarea(attrs={ 'cols': 40, 'rows': 4, 'class': 'col-lg-6' })) advicetype = forms.ChoiceField(choices=ADVICETYPE, label=_("Type advies"), required=False) subadvicetype = forms.ChoiceField(choices=SUBADVICETYPE, label=_("Advies"), required=False) advicecontent = forms.CharField(max_length=255, label=_("Uitleg advies"), required=False, widget=forms.Textarea(attrs={ 'cols': 40, 'rows': 4, 'class': 'col-lg-6' })) def clean(self): cleaned_data = super(Kv17ChangeForm, self).clean() operatingday = parse_date(self.data['operatingday']) if operatingday is None: raise ValidationError(_("Er staan geen ritten in de database")) if 'journeys' not in self.data: raise ValidationError( _("Een of meer geselecteerde ritten zijn ongeldig")) if self.data['begintime_part'] != '': hh, mm = self.data['begintime_part'].split(':') begintime = make_aware( datetime.combine(operatingday, time(int(hh), int(mm)))) else: begintime = None if self.data['endtime_part'] != '': hh_e, mm_e = self.data['endtime_part'].split(':') endtime = make_aware( datetime.combine(operatingday, time(int(hh_e), int(mm_e)))) if begintime: if begintime > endtime: # if endtime before begintime endtime = endtime + timedelta( days=1) # endtime is next day if endtime.time() >= time( 6, 0): # and after 6 am: validation error raise ValidationError( _("Eindtijd valt op volgende operationele dag")) else: endtime = None dataownercode = self.user.userprofile.company if 'Alle ritten' in self.data['journeys']: valid_journeys = self.clean_all_journeys(operatingday, dataownercode, begintime, endtime) elif 'Hele vervoerder' in self.data['lines']: valid_journeys = self.clean_all_lines(operatingday, dataownercode, begintime, endtime) else: valid_journeys = self.clean_journeys(operatingday, dataownercode) if valid_journeys == 0: raise ValidationError( _("Er zijn geen ritten geselecteerd om op te heffen")) return cleaned_data def clean_journeys(self, operatingday, dataownercode): valid_journeys = 0 if self.data['journeys'] != '': for journey in self.data['journeys'].split(',')[0:-1]: journey_qry = Kv1Journey.objects.filter( dataownercode=dataownercode, pk=journey, dates__date=operatingday) if journey_qry.count() == 0: raise ValidationError( _("Een of meer geselecteerde ritten zijn ongeldig")) # delete recovered if query is the same. Kv17Change.objects.filter(dataownercode=dataownercode, journey__pk=journey, line=journey_qry[0].line, operatingday=operatingday, is_recovered=True).delete() else: raise ValidationError(_("Er werd geen rit geselecteerd.")) valid_journeys += 1 return valid_journeys def clean_all_journeys(self, operatingday, dataownercode, begintime, endtime): valid_journeys = 0 if 'lines' in self.data: if self.data['lines'] != '': for line in self.data['lines'].split(',')[0:-1]: line_qry = Kv1Line.objects.filter(pk=line) if line_qry.count() == 0: raise ValidationError(_("Geen lijn gevonden.")) database_alljourneys = Kv17Change.objects.filter( dataownercode=dataownercode, is_alljourneysofline=True, line=line_qry[0], operatingday=operatingday, is_recovered=False) database_alllines = Kv17Change.objects.filter( dataownercode=dataownercode, is_alllines=True, operatingday=operatingday, is_recovered=False) # delete recovered if query is the same. Kv17Change.objects.filter(dataownercode=dataownercode, is_alljourneysofline=True, line=line_qry[0], operatingday=operatingday, begintime=begintime, endtime=endtime, is_recovered=True).delete() if operatingday == datetime.today().date(): begintime = make_aware( datetime.now()) if begintime is None else begintime else: begintime = make_aware(datetime.combine(operatingday, time((int(4))))) \ if begintime is None else begintime if database_alllines: if database_alllines.filter( Q(endtime__gt=begintime) | Q(endtime=None), Q(begintime__lte=begintime) | Q(begintime=None)): raise ValidationError( _("De gehele vervoerder is al aangepast voor de aangegeven ingangstijd." )) elif database_alljourneys: if database_alljourneys.filter( Q(endtime__gt=begintime) | Q(endtime=None), Q(begintime__lte=begintime) | Q(begintime=None)): raise ValidationError( _("Een of meer geselecteerde lijnen zijn al aangepast voor de aangegeven ingangstijd." )) else: raise ValidationError(_("Geen geldige lijn geselecteerd")) valid_journeys += 1 return valid_journeys def clean_all_lines(self, operatingday, dataownercode, begintime, endtime): valid_journeys = 0 database_alllines = Kv17Change.objects.filter( dataownercode=dataownercode, is_alllines=True, operatingday=operatingday, is_recovered=False) # delete recovered if query is the same. Kv17Change.objects.filter(dataownercode=dataownercode, is_alllines=True, is_recovered=True, operatingday=operatingday, begintime=begintime, endtime=endtime).delete() if database_alllines: if operatingday == datetime.today().date(): begintime = make_aware( datetime.now()) if begintime is None else begintime else: begintime = make_aware(datetime.combine(operatingday, time((int(4))))) \ if begintime is None else begintime if database_alllines.filter( Q(endtime__gt=begintime) | Q(endtime=None), Q(begintime__lte=begintime) | Q(begintime=None)): raise ValidationError( _("De ingangstijd valt al binnen een geplande operatie.")) valid_journeys += 1 return valid_journeys def save(self, force_insert=False, force_update=False, commit=True): ''' Save each of the journeys in the model. This is a disaster, we return the XML TODO: Figure out a better solution fo this! ''' operatingday = parse_date(self.data['operatingday']) if self.data['begintime_part'] != '': hh, mm = self.data['begintime_part'].split(':') begintime = make_aware( datetime.combine(operatingday, time(int(hh), int(mm)))) else: begintime = None if self.data['endtime_part'] != '': hh_end, mm_end = self.data['endtime_part'].split(':') # if begintime is set and endtime is earlier than begintime add 1 day to operatingday of endtime if begintime and time(int(hh_end), int(mm_end)) < time( int(hh), int(mm)): if time(0, 0) <= time(int(hh_end), int(mm_end)) < time(6, 0): operatingday_endtime = operatingday + timedelta(days=1) endtime = make_aware( datetime.combine(operatingday_endtime, time(int(hh_end), int(mm_end)))) # else, operatingday is given day else: endtime = make_aware( datetime.combine(operatingday, time(int(hh_end), int(mm_end)))) else: endtime = None if 'Alle ritten' in self.data['journeys']: xml_output = self.save_all_journeys(operatingday, begintime, endtime) elif 'Hele vervoerder' in self.data['lines']: xml_output = self.save_all_lines(operatingday, begintime, endtime) else: xml_output = self.save_journeys(operatingday) return xml_output def save_all_journeys(self, operatingday, begintime, endtime): xml_output = [] for line in self.data['lines'].split(',')[0:-1]: qry = Kv1Line.objects.filter(id=line) if qry.count() == 1: self.instance.pk = None self.instance.is_alljourneysofline = True self.instance.line = qry[0] self.instance.operatingday = operatingday self.instance.begintime = begintime self.instance.endtime = endtime self.instance.is_cancel = True # Unfortunately, we can't place this any earlier, because we don't have the dataownercode there if self.instance.line.dataownercode == self.instance.dataownercode: self.instance.save() # Add details if self.data['reasontype'] != '0' or self.data[ 'advicetype'] != '0': Kv17JourneyChange( change=self.instance, reasontype=self.data['reasontype'], subreasontype=self.data['subreasontype'], reasoncontent=self.data['reasoncontent'], advicetype=self.data['advicetype'], subadvicetype=self.data['subadvicetype'], advicecontent=self.data['advicecontent']).save() xml_output.append(self.instance.to_xml()) else: log.error( "Oops! mismatch between dataownercode of line (%s) and of user (%s) when saving journey cancel" % (self.instance.line.dataownercode, self.instance.dataownercode)) else: log.error("Failed to find line %s" % line) return xml_output def save_journeys(self, operatingday): xml_output = [] for journey in self.data['journeys'].split(',')[0:-1]: qry = Kv1Journey.objects.filter(id=journey, dates__date=operatingday) if qry.count() == 1: self.instance.pk = None self.instance.journey = qry[0] self.instance.line = qry[0].line self.instance.operatingday = operatingday self.instance.is_cancel = True # Shouldn't be necessary, but just in case: self.instance.begintime = None self.instance.endtime = None # Unfortunately, we can't place this any earlier, because we don't have the dataownercode there if self.instance.journey.dataownercode == self.instance.dataownercode: self.instance.save() # Add details if self.data['reasontype'] != '0' or self.data[ 'advicetype'] != '0': Kv17JourneyChange( change=self.instance, reasontype=self.data['reasontype'], subreasontype=self.data['subreasontype'], reasoncontent=self.data['reasoncontent'], advicetype=self.data['advicetype'], subadvicetype=self.data['subadvicetype'], advicecontent=self.data['advicecontent']).save() xml_output.append(self.instance.to_xml()) else: log.error( "Oops! mismatch between dataownercode of line (%s) and of user (%s) when saving journey cancel" % (self.instance.journey.dataownercode, self.instance.dataownercode)) else: log.error("Failed to find journey %s" % journey) return xml_output def save_all_lines(self, operatingday, begintime, endtime): xml_output = [] self.instance.pk = None self.instance.is_alllines = True self.instance.operatingday = operatingday self.instance.begintime = begintime self.instance.endtime = endtime self.instance.is_cancel = True # Unfortunately, we can't place this any earlier, because we don't have the dataownercode there if self.instance.dataownercode == self.user.userprofile.company: self.instance.save() # Add details if self.data['reasontype'] != '0' or self.data['advicetype'] != '0': Kv17JourneyChange( change=self.instance, reasontype=self.data['reasontype'], subreasontype=self.data['subreasontype'], reasoncontent=self.data['reasoncontent'], advicetype=self.data['advicetype'], subadvicetype=self.data['subadvicetype'], advicecontent=self.data['advicecontent']).save() xml_output.append(self.instance.to_xml()) else: log.error( "Oops! mismatch between dataownercode of line (%s) and of user (%s) when saving journey cancel" % (self.instance.line.dataownercode, self.instance.dataownercode)) return xml_output class Meta(object): model = Kv17Change exclude = [ 'dataownercode', 'line', 'journey', 'is_recovered', 'reinforcement' ] def __init__(self, *args, **kwargs): self.user = kwargs.pop('user', None) super(Kv17ChangeForm, self).__init__(*args, **kwargs) days = [[ str(d['date'].strftime('%Y-%m-%d')), str(d['date'].strftime('%d-%m-%Y')) ] for d in Kv1JourneyDate.objects.all().filter( date__gte=datetime.today() - timedelta(days=1)).values('date').distinct('date').order_by('date') ] operating_day = days[((datetime.now().hour < 4) * -1) + 1] if len(days) > 1 else None self.fields['operatingday'].choices = days self.fields['operatingday'].initial = operating_day self.helper = FormHelper() self.helper.form_tag = False self.helper.layout = Layout( Accordion( AccordionGroup(_('Datum en tijd'), 'operatingday', 'begintime_part', 'endtime_part'), AccordionGroup(_('Oorzaak'), 'reasontype', 'subreasontype', 'reasoncontent'), AccordionGroup(_('Advies'), 'advicetype', 'subadvicetype', 'advicecontent')))
class PeriodForm(forms.ModelForm): comment = forms.CharField(widget=forms.Textarea(attrs={'rows': 3})) class Meta: model = period_models.FlowEvent exclude = ['user']
class SubscribeForm(ModelFormWithCity, SubscriptionTypeFormMixin): """Subscribe to emailing""" city = forms.CharField( required=False, label=_('City'), widget=CityAutoComplete(attrs={ 'placeholder': _('Enter a city'), 'size': '80' })) entity_type = forms.ChoiceField(required=False, widget=forms.Select()) entity = forms.CharField( required=False, widget=forms.TextInput(attrs={'placeholder': _('Name of the entity')})) groups = forms.MultipleChoiceField(widget=forms.CheckboxSelectMultiple(), label='', required=False) action_types = forms.MultipleChoiceField( widget=forms.CheckboxSelectMultiple(), label='', required=False) message = forms.CharField(required=False, widget=forms.Textarea(attrs={ 'placeholder': _('Message'), 'cols': '90' })) captcha = get_captcha_field() favorite_language = forms.CharField(required=False, widget=forms.HiddenInput()) class Meta: model = Contact fields = ('gender', 'firstname', 'lastname', 'phone', 'mobile', 'email', 'address', 'address2', 'address3', 'zip_code') widgets = { 'lastname': forms.TextInput(attrs={ 'placeholder': _('Lastname'), 'required': 'required' }), 'firstname': forms.TextInput(attrs={'placeholder': _('Firstname')}), 'phone': forms.TextInput(attrs={'placeholder': _('Phone')}), 'email': forms.TextInput(attrs={ 'placeholder': _('Email'), 'required': 'required' }), 'zip_code': forms.TextInput(attrs={'placeholder': _('zip code')}), } def __init__(self, *args, **kwargs): super(SubscribeForm, self).__init__(*args, **kwargs) self.fields['email'].required = True # Do not display (Mrs and M) gender on subscribe form self.fields['gender'].choices = [ (models.Contact.GENDER_NOT_SET, _('')), (models.Contact.GENDER_MALE, ugettext('Mr')), (models.Contact.GENDER_FEMALE, ugettext('Mrs')), ] entity_types_choices = [] if crm_settings.ALLOW_SINGLE_CONTACT: entity_types_choices.append((0, _('Individual'))) else: entity_types_choices.append((0, '')) entity_types_choices.extend([ (et.id, et.name) for et in EntityType.objects.filter(subscribe_form=True) ]) self.fields['entity_type'].choices = entity_types_choices self.fields['groups'].choices = [ (group.id, group.name) for group in Group.objects.filter(subscribe_form=True) ] self.fields['action_types'].choices = [ (action_type.id, action_type.name) for action_type in ActionType.objects.filter(subscribe_form=True) ] self._add_subscription_types_field() if crm_settings.has_language_choices(): self.fields['favorite_language'].initial = get_language() def clean_entity_type(self): """validation""" try: entity_type = int(self.cleaned_data['entity_type']) if entity_type: return EntityType.objects.get(id=entity_type) return None except (ValueError, EntityType.DoesNotExist): raise ValidationError(ugettext("Invalid entity type")) def get_entity(self): """get entity from form""" entity_type = self.cleaned_data.get('entity_type', None) entity = self.cleaned_data['entity'] if entity_type: if entity: return Entity.objects.create(name=entity, type=entity_type) else: if crm_settings.ALLOW_SINGLE_CONTACT: return Entity.objects.create(name=entity, type=None, is_single_contact=True) else: et_id = getattr(settings, 'BALAFON_INDIVIDUAL_ENTITY_ID', 1) entity_type = EntityType.objects.get(id=et_id) entity_name = "{0} {1}".format(self.cleaned_data['lastname'], self.cleaned_data['firstname']) return Entity.objects.create(name=entity_name, type=entity_type) def clean_entity(self): """validation""" entity_type = self.cleaned_data.get('entity_type', None) entity = self._dehtmled_field("entity") if entity_type: if not entity: raise ValidationError("{0}: {1}".format( entity_type.name, ugettext("Please enter a name"))) else: data = [self.cleaned_data[x] for x in ('lastname', 'firstname')] entity = ' '.join([x for x in data if x]).strip().upper() return entity def _dehtmled_field(self, fieldname, **kwargs): """html to text for a field content""" value = self.cleaned_data[fieldname] return dehtml(value, **kwargs) def clean_lastname(self): """validate lastname""" return self._dehtmled_field("lastname") def clean_firstname(self): """validate firstname""" return self._dehtmled_field("firstname") def clean_phone(self): """validate phone""" return self._dehtmled_field("phone") def clean_mobile(self): """validate mobile phone""" return self._dehtmled_field("mobile") def clean_address(self): """validate address""" return self._dehtmled_field("address") def clean_address2(self): """valiadate address line 2""" return self._dehtmled_field("address2") def clean_address3(self): """validate address line 3""" return self._dehtmled_field("address3") def clean_message(self): """validate message""" message = self._dehtmled_field("message", allow_spaces=True) if len(message) > 10000: raise ValidationError(ugettext("Your message is too long")) return message def clean_groups(self): """validate groups""" try: groups = [ Group.objects.get(id=group_id) for group_id in self.cleaned_data['groups'] ] except Group.DoesNotExist: raise ValidationError(ugettext("Invalid group")) return groups def clean_action_types(self): """validate action types""" try: action_types = [ ActionType.objects.get(id=at_id) for at_id in self.cleaned_data['action_types'] ] except ActionType.DoesNotExist: raise ValidationError(ugettext("Invalid action type")) return action_types def save(self, request=None): """save""" contact = super(SubscribeForm, self).save(commit=False) contact.entity = self.get_entity() contact.city = self.cleaned_data['city'] contact.favorite_language = self.cleaned_data.get( 'favorite_language', '') contact.save() # delete unknown contacts for the current entity contact.entity.contact_set.filter( lastname='', firstname='').exclude(id=contact.id).delete() # force also the city on the entity contact.entity.city = contact.city groups = self.cleaned_data['groups'] for group in groups: contact.entity.group_set.add(group) contact.entity.save() subscriptions = self._save_subscription_types(contact) message = self.cleaned_data["message"] if message: action_type = ActionType.objects.get_or_create( name=ugettext("Message"))[0] action = Action.objects.create( subject=ugettext("Message from web site"), type=action_type, planned_date=datetime.now(), detail=message, display_on_board=True) action.contacts.add(contact) action.save() if subscriptions: create_subscription_action(contact, subscriptions) action_types = self.cleaned_data['action_types'] actions = [] for action_type in action_types: action = Action.objects.create(subject=ugettext("Contact"), type=action_type, planned_date=datetime.now(), display_on_board=True) action.contacts.add(contact) action.save() actions.append(action) # send an email send_notification_email(request, contact, actions, message) return contact