def __init__(self, *args, **kwargs): super(UpdateEmailingForm, self).__init__(*args, **kwargs) subscription_choices = [ (subs_type.id, subs_type.name) for subs_type in SubscriptionType.objects.all() ] self.fields["subscription_type"].widget = forms.Select( choices=subscription_choices) newsletter_choices = [(newsletter.id, newsletter.subject) for newsletter in Newsletter.objects.all()] self.fields["newsletter"].widget = forms.Select( choices=newsletter_choices, attrs={'class': 'form-control'}) if not getattr(settings, 'BALAFON_EMAILING_SENDER_CHOICES', None): self.fields["from_email"].widget = forms.HiddenInput() else: self.fields["from_email"].widget = forms.Select( choices=settings.BALAFON_EMAILING_SENDER_CHOICES) if not getattr(settings, 'LANGUAGES', None) or len(settings.LANGUAGES) < 2: self.fields["lang"].widget = forms.HiddenInput() else: language_choices = crm_settings.get_language_choices( _("Favorite language of the contact")) self.fields["lang"].widget = forms.Select( choices=language_choices, attrs={'class': 'form-control'})
def render(self, name, value=None, attrs=None, choices=()): pb, pb_desc = None, None juris_widget = None jurisdictions = Jurisdiction.objects.get_visible() if value is not None: try: pb = PublicBody.objects.get(pk=int(value)) pb_desc = pb.get_label() except (ValueError, PublicBody.DoesNotExist): pass if len(jurisdictions) > 1: attrs = { "id": "id_juris_%s" % name, "class": "search-public_bodies-jurisdiction" } choices = [(j.name, j.name) for j in jurisdictions] juris_widget = forms.Select(choices=choices, attrs=attrs) if pb is None: juris_widget = juris_widget.render('jurisdiction', self.initial_jurisdiction) else: juris_widget = juris_widget.render('jurisdiction', pb.jurisdiction.name) juris_widget = mark_safe(juris_widget) return render_to_string( 'publicbody/_chooser.html', { 'name': name, 'value': value, 'value_label': pb_desc, 'search': self.initial_search, 'juris_widget': juris_widget, 'STATIC_URL': settings.STATIC_URL })
class FiltroPorValorForm(forms.Form): CHOICES_EM_CONDOMINIO = ((True, "Apenas em condomínio fechado"), ("", "Indiferente")) CHOICES_MOBILIADO = (("mobiliado", "Mobiliado"), ("nao_mobiliado", "Não Mobiliado"), ("", "Indiferente")) CHOICES_STATUS = (("publicado", "Publicado"), ("arquivado", "Arquivado")) valor_min = CustomInteger() valor_max = CustomInteger() min_quarto = CustomInteger(initial=3) min_vaga = CustomInteger(initial=2) min_banheiro = CustomInteger(initial=1) min_suite = CustomInteger(initial=1) area_min = CustomInteger(initial=180) codigo_referencia = MultipleInteger(label="Código Referência", required=False) bairros = forms.MultipleChoiceField(required=False) em_condominio = forms.ChoiceField(choices=CHOICES_EM_CONDOMINIO, widget=forms.RadioSelect(), initial=CHOICES_EM_CONDOMINIO[-1], label="Condomínio Fechado?", required=False) mobiliado = forms.ChoiceField(choices=CHOICES_MOBILIADO, widget=forms.RadioSelect(), initial=CHOICES_MOBILIADO[-1], label="Mobília", required=False) status = forms.ChoiceField(choices=CHOICES_STATUS, widget=forms.RadioSelect(), initial=CHOICES_STATUS[0], label="Status", required=False) condominio = forms.ChoiceField(widget=forms.Select(), label="Condomínio", required=False) def __init__(self, tipo_imovel=None, tipo_interesse=None, cidade=None, *args, **kwargs): super(FiltroPorValorForm, self).__init__(*args, **kwargs) qs = BairroComImoveis.objects.filter( tipo_imovel=tipo_imovel, cidade__nome=cidade).select_related('cidade', 'bairro' ) if tipo_interesse == 'comprar': qs = qs.filter(contador_venda__gt=0) self.fields["valor_min"].initial = 160000 self.fields["valor_max"].initial = 600000 else: self.fields["valor_min"].initial = 700 self.fields["valor_max"].initial = 2500 qs = qs.filter(contador_locacao__gt=0) bairro_list = [(bairro.bairro.id, bairro) for bairro in qs] bairro_list = sorted(bairro_list, key = lambda tup: tup[1].bairro.descricao) condominio_list = [('', '---------------')] condominio_list += [(condominio.id, condominio.nome) for condominio in Condominio.objects.filter(cidade__nome=cidade).select_related('cidade', )] self.fields['bairros'].widget = BairroComImoveisCheckboxSelectMultiple( attrs={'tipo_interesse': tipo_interesse}) self.fields["condominio"].choices = condominio_list self.fields["condominio"].initial = condominio_list[0] self.fields['bairros'].choices = bairro_list
def __init__(self, *args, **kwargs): super(BetterBsModelForm, self).__init__(*args, **kwargs) self._bs_patch_field_class() for field in self.fields.values(): if field.widget.__class__.__name__ == forms.Select( ).__class__.__name__: css_class = field.widget.attrs.get("class", "") if "chosen-select" not in css_class: field.widget.attrs["class"] = css_class + " chosen-select"
def __init__(self, foirequest, *args, **kwargs): super(FoiRequestStatusForm, self).__init__(*args, **kwargs) self.foirequest = foirequest self.fields['refusal_reason'] = forms.ChoiceField( label=_("Refusal Reason"), choices=[('', _('No or other reason given'))] + (foirequest.law.get_refusal_reason_choices()), required=False, widget=forms.Select(attrs={'class': 'form-control'}), help_text= _('When you are (partially) denied access to information, the Public Body should always state the reason.' ))
def __init__(self, *args, **kwargs): initial = kwargs.get('initial') initial_contacts = '' if initial and 'contacts' in initial: initial_contacts = ';'.join( ['{0}'.format(contact.id) for contact in initial['contacts']]) initial.pop('contacts') super(NewEmailingForm, self).__init__(*args, **kwargs) if initial_contacts: self.fields['contacts'].initial = initial_contacts newsletter_choices = [(0, ugettext('-- New --'))] + [ (newsletter.id, newsletter.subject) for newsletter in Newsletter.objects.all().order_by('-id') ] self.fields["newsletter"].widget = forms.Select( choices=newsletter_choices, attrs={'class': 'form-control'}) subscription_choices = [ (subscription.id, subscription.name) for subscription in SubscriptionType.objects.all() ] self.fields["subscription_type"].widget = forms.Select( choices=subscription_choices, attrs={'class': 'form-control'}) if not getattr(settings, 'LANGUAGES', None) or len(settings.LANGUAGES) < 2: self.fields["lang"].widget = forms.HiddenInput() else: language_choices = crm_settings.get_language_choices( _("Favorite language of the contact")) self.fields["lang"].widget = forms.Select( choices=language_choices, attrs={'class': 'form-control'}) if getattr(settings, 'BALAFON_EMAILING_SENDER_CHOICES', None): self.fields['from_email'].widget = forms.Select( choices=settings.BALAFON_EMAILING_SENDER_CHOICES, attrs={'class': 'form-control'}) else: self.fields['from_email'].widget = forms.HiddenInput()
def __init__(self, *args, **kwargs): choices = kwargs.pop('choices', None) super(SelectContactForm, self).__init__(*args, **kwargs) if choices: widget = forms.Select(choices=[(x.id, x.fullname) for x in choices]) self.fields["contact"] = forms.IntegerField(label=_("Contact"), widget=widget) else: widget = ContactAutoComplete( attrs={ 'placeholder': _('Enter the name of a contact'), 'size': '50', 'class': 'colorbox' }) self.fields["contact"] = forms.CharField(label=_("Contact"), widget=widget)
def __init__(self, contact, *args, **kwargs): super(SameAsForm, self).__init__(*args, **kwargs) potential_contacts = get_suggested_same_as_contacts( contact_id=contact.id, lastname=contact.lastname, firstname=contact.firstname, email=contact.email) if contact.same_as: # Do not propose again current SameAs potential_contacts = potential_contacts.exclude( same_as=contact.same_as) self._same_as = [(same_as_contact.id, "{0}".format(same_as_contact)) for same_as_contact in potential_contacts] if len(self._same_as): self.fields["contact"].widget = forms.Select(choices=self._same_as) else: self.fields["contact"].widget = forms.HiddenInput()
def __init__(self, instance, *args, **kwargs): super(CustomFieldForm, self).__init__(*args, **kwargs) self._instance = instance model_type = self._get_model_type() custom_fields = models.CustomField.objects.filter(model=model_type) for field in custom_fields: self.fields[field.name] = forms.CharField(required=False, label=field.label or field.name) if field.choices.count(): choices = [('', '')] + [(choice.value, choice.label) for choice in field.choices.all()] self.fields[field.name].widget = forms.Select(choices=choices) self.fields[field.name].widget.attrs = {'class': 'form-control'} if field.widget: self.fields[field.name].widget.attrs['class'] += ' ' + field.widget # No Post if len(args) == 0: self.fields[field.name].initial = getattr(instance, 'custom_field_' + field.name, '')
def __init__(self, contact1, *args, **kwargs): super(AddRelationshipForm, self).__init__(*args, **kwargs) self.reversed_relation = False self.contact1 = contact1 relationship_types = [] for relationship_type in models.RelationshipType.objects.all(): relationship_types.append( (relationship_type.id, relationship_type.name)) if relationship_type.reverse: relationship_types.append( (-relationship_type.id, relationship_type.reverse)) self.fields["relationship_type"].widget = forms.Select( choices=relationship_types) widget = ContactAutoComplete( attrs={ 'placeholder': _('Enter the name of a contact'), 'size': '50', 'class': 'colorbox' }) self.fields["contact2"] = forms.CharField(label=_("Contact"), widget=widget)
def __init__(self, *args, **kwargs): super(custom_form_class, self).__init__(*args, **kwargs) self.fields['favorite_language'].widget = forms.Select( choices=get_language_choices())
class BaseCaseForm(mtforms.NonFieldErrorsClassFormMixin, forms.Form): """ Base form for all test case/version forms. Provides self.user, tags and status fields, and non-field-errors-class mixin. """ status = forms.CharField( widget=forms.Select(choices=model.CaseVersion.STATUS), initial=model.CaseVersion._meta.get_field("status").default, ) add_tags = forms.CharField( widget=mtforms.AutocompleteInput( url=lambda: reverse("manage_tags_autocomplete")), required=False) idprefix = forms.CharField(max_length=200, required=False) priority = mtforms.MTChoiceField( choices=Choices("------", 1, 2, 3, 4), required=False ) def __init__(self, *args, **kwargs): """Initialize form; pull out user from kwargs, set up data-allow-new.""" self.user = kwargs.pop("user", None) super(BaseCaseForm, self).__init__(*args, **kwargs) self.fields["add_tags"].widget.attrs["data-allow-new"] = ( "true" if (self.user and self.user.has_perm("tags.manage_tags")) else "false" ) def clean(self): """Can't create new tags without appropriate permissions.""" if (self.data.get("tag-newtag") and not (self.user and self.user.has_perm("tags.manage_tags"))): raise forms.ValidationError( "You do not have permission to create new tags.") return self.cleaned_data def save_new_tags(self, product=None): """Save new tags and add them to the list of tags to assign.""" tags = self.cleaned_data.setdefault("tags", set()) tags.update([int(tid) for tid in self.data.getlist("tag-tag")]) new_tags = self.data.getlist("tag-newtag") for name in new_tags: # @@@ should pass in user here, need MTQuerySet.get_or_create t, created = model.Tag.objects.get_or_create( name=name, product=product) tags.add(t.id) def save_tags(self, caseversion): """Update set of tags assigned to ``caseversion``.""" tags = self.cleaned_data.get("tags", set()) current_tags = set([t.id for t in caseversion.tags.all()]) caseversion.tags.add(*tags.difference(current_tags)) caseversion.tags.remove(*current_tags.difference(tags))
class NewEmailingForm(BsForm): """Form for creating a new emailing""" subscription_type = forms.IntegerField(label=_("Subscription Type")) newsletter = forms.IntegerField(label=_("Newsletter")) subject = forms.CharField( label=_("Subject"), required=False, widget=forms.TextInput( attrs={'placeholder': _('Subject of the newsletter')})) contacts = forms.CharField(widget=forms.HiddenInput()) lang = forms.CharField(required=False, label=_("Language"), widget=forms.Select(choices=[('', _('Default'))] + list(settings.LANGUAGES))) from_email = forms.CharField(required=False, label=_("Sent from")) def __init__(self, *args, **kwargs): initial = kwargs.get('initial') initial_contacts = '' if initial and 'contacts' in initial: initial_contacts = ';'.join( ['{0}'.format(contact.id) for contact in initial['contacts']]) initial.pop('contacts') super(NewEmailingForm, self).__init__(*args, **kwargs) if initial_contacts: self.fields['contacts'].initial = initial_contacts newsletter_choices = [(0, ugettext('-- New --'))] + [ (newsletter.id, newsletter.subject) for newsletter in Newsletter.objects.all().order_by('-id') ] self.fields["newsletter"].widget = forms.Select( choices=newsletter_choices, attrs={'class': 'form-control'}) subscription_choices = [ (subscription.id, subscription.name) for subscription in SubscriptionType.objects.all() ] self.fields["subscription_type"].widget = forms.Select( choices=subscription_choices, attrs={'class': 'form-control'}) if not getattr(settings, 'LANGUAGES', None) or len(settings.LANGUAGES) < 2: self.fields["lang"].widget = forms.HiddenInput() else: language_choices = crm_settings.get_language_choices( _("Favorite language of the contact")) self.fields["lang"].widget = forms.Select( choices=language_choices, attrs={'class': 'form-control'}) if getattr(settings, 'BALAFON_EMAILING_SENDER_CHOICES', None): self.fields['from_email'].widget = forms.Select( choices=settings.BALAFON_EMAILING_SENDER_CHOICES, attrs={'class': 'form-control'}) else: self.fields['from_email'].widget = forms.HiddenInput() def get_contacts(self): """get the list of contacts stored by ids""" ids = self.cleaned_data["contacts"].split(";") return models.Contact.objects.filter(id__in=ids) def clean_subject(self): """subject validation""" newsletter_id = int(self.cleaned_data['newsletter']) subject = self.cleaned_data['subject'] if newsletter_id == 0 and not subject: raise ValidationError( ugettext("Please enter a subject for the newsletter")) return subject def clean_subscription_type(self): """validation of subscription type. Return the subscription type object""" try: subscription_type = int(self.cleaned_data['subscription_type']) return SubscriptionType.objects.get(id=subscription_type) except (ValueError, KeyError, SubscriptionType.DoesNotExist): raise ValidationError( ugettext("Please select a valid subscription"))
def __init__(self, *args, **kwargs): # Configure the fieldset with dynamic fields fieldset_fields = self.Meta.fieldsets[-2][1]["fields"] for subscription_type in models.SubscriptionType.objects.all(): field_name = "subscription_{0}".format(subscription_type.id) if field_name not in fieldset_fields: fieldset_fields.append(field_name) has_data = len(args) > 0 super(ContactForm, self).__init__(*args, **kwargs) try: if self.instance and self.instance.entity and self.instance.entity.is_single_contact: self.fields['has_left'].widget = forms.HiddenInput() except models.Entity.DoesNotExist: pass self.fields["role"].help_text = _( "Select the roles played by the contact in his entity") if 'balafon.Profile' not in settings.INSTALLED_APPS: self.fields["accept_notifications"].widget = forms.HiddenInput() if has_data: self.fields.pop("email_verified") else: self.fields["email_verified"].widget.attrs['disabled'] = "disabled" # define the allowed gender gender_choices = [ (models.Contact.GENDER_NOT_SET, '-------'), (models.Contact.GENDER_MALE, ugettext('Mr')), (models.Contact.GENDER_FEMALE, ugettext('Mrs')), ] if ALLOW_COUPLE_GENDER: gender_choices += [(models.Contact.GENDER_COUPLE, ugettext('Mrs and Mr'))] self.fields['gender'].choices = gender_choices # create the dynamic fields for subscription_type in models.SubscriptionType.objects.all(): field_name = "subscription_{0}".format(subscription_type.id) field = self.fields[field_name] = forms.BooleanField( label=subscription_type.name, required=False) if self.instance and self.instance.id: try: subscription = models.Subscription.objects.get( subscription_type=subscription_type, contact=self.instance) field.initial = subscription.accept_subscription except models.Subscription.DoesNotExist: field.initial = False else: field.initial = get_subscription_default_value() if has_language_choices(): self.fields['favorite_language'].widget = forms.Select( choices=get_language_choices(), attrs={'class': 'form-control'}) else: self.fields['favorite_language'].widget = forms.HiddenInput() if not self.instance or not any([ self.instance.lastname, self.instance.firstname, self.instance.email ]): # If the contact has not been created of not filled pass # keep the widget if len(args): # The form has been posted; we must initialize the list with allowed values contact_id = self.instance.id if self.instance else None post_data = args[0] lastname = post_data.get('lastname', '') firstname = post_data.get('firstname', '') email = post_data.get('email', '') same_as_contacts = get_suggested_same_as_contacts( contact_id=contact_id, lastname=lastname, firstname=firstname, email=email) self.fields['same_as_suggestions'].choices = [ (contact.id, '{0}'.format(contact)) for contact in same_as_contacts ] else: # hide the field self.fields['same_as_suggestions'].widget = forms.HiddenInput()
class ContactForm(FormWithFieldsetMixin, ModelFormWithAddress): """Edit contact form""" same_as_suggestions = forms.ChoiceField( label=_('Same-as contacts'), choices=[], required=False, help_text= _('If this is a new contact for an existing person, you can link the different contacts between them' ), widget=forms.Select( attrs={ 'class': 'chosen-select', 'data-placeholder': _('Select same-as contacts'), 'style': "width: 100%;" })) 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') }), ] def __init__(self, *args, **kwargs): # Configure the fieldset with dynamic fields fieldset_fields = self.Meta.fieldsets[-2][1]["fields"] for subscription_type in models.SubscriptionType.objects.all(): field_name = "subscription_{0}".format(subscription_type.id) if field_name not in fieldset_fields: fieldset_fields.append(field_name) has_data = len(args) > 0 super(ContactForm, self).__init__(*args, **kwargs) try: if self.instance and self.instance.entity and self.instance.entity.is_single_contact: self.fields['has_left'].widget = forms.HiddenInput() except models.Entity.DoesNotExist: pass self.fields["role"].help_text = _( "Select the roles played by the contact in his entity") if 'balafon.Profile' not in settings.INSTALLED_APPS: self.fields["accept_notifications"].widget = forms.HiddenInput() if has_data: self.fields.pop("email_verified") else: self.fields["email_verified"].widget.attrs['disabled'] = "disabled" # define the allowed gender gender_choices = [ (models.Contact.GENDER_NOT_SET, '-------'), (models.Contact.GENDER_MALE, ugettext('Mr')), (models.Contact.GENDER_FEMALE, ugettext('Mrs')), ] if ALLOW_COUPLE_GENDER: gender_choices += [(models.Contact.GENDER_COUPLE, ugettext('Mrs and Mr'))] self.fields['gender'].choices = gender_choices # create the dynamic fields for subscription_type in models.SubscriptionType.objects.all(): field_name = "subscription_{0}".format(subscription_type.id) field = self.fields[field_name] = forms.BooleanField( label=subscription_type.name, required=False) if self.instance and self.instance.id: try: subscription = models.Subscription.objects.get( subscription_type=subscription_type, contact=self.instance) field.initial = subscription.accept_subscription except models.Subscription.DoesNotExist: field.initial = False else: field.initial = get_subscription_default_value() if has_language_choices(): self.fields['favorite_language'].widget = forms.Select( choices=get_language_choices(), attrs={'class': 'form-control'}) else: self.fields['favorite_language'].widget = forms.HiddenInput() if not self.instance or not any([ self.instance.lastname, self.instance.firstname, self.instance.email ]): # If the contact has not been created of not filled pass # keep the widget if len(args): # The form has been posted; we must initialize the list with allowed values contact_id = self.instance.id if self.instance else None post_data = args[0] lastname = post_data.get('lastname', '') firstname = post_data.get('firstname', '') email = post_data.get('email', '') same_as_contacts = get_suggested_same_as_contacts( contact_id=contact_id, lastname=lastname, firstname=firstname, email=email) self.fields['same_as_suggestions'].choices = [ (contact.id, '{0}'.format(contact)) for contact in same_as_contacts ] else: # hide the field self.fields['same_as_suggestions'].widget = forms.HiddenInput() def get_fieldsets(self): """return the list of fieldsets""" for fieldset in self.Meta.fieldsets: if fieldset[0] == 'billing_address' and not show_billing_address(): # Ignore 'Billing address' tab if disable in settings continue yield fieldset def clean_photo(self): """photo validation""" photo = self.cleaned_data["photo"] instance = self.instance if not instance: instance = "" try: instance.id = models.Contact.objects.latest('id').id except models.Contact.DoesNotExist: instance.id = 1 target_name = models.get_contact_photo_dir(instance, photo) if len(target_name) >= models.Contact._meta.get_field( 'photo').max_length: raise ValidationError(ugettext("The file name is too long")) return photo def save_contact_subscriptions(self, contact): """save contact subscriptions""" for subscription_type in models.SubscriptionType.objects.all(): field_name = "subscription_{0}".format(subscription_type.id) accept_subscription = self.cleaned_data[field_name] try: subscription = models.Subscription.objects.get( contact=contact, subscription_type=subscription_type) if subscription.accept_subscription != accept_subscription: subscription.accept_subscription = accept_subscription subscription.save() except models.Subscription.DoesNotExist: if accept_subscription: models.Subscription.objects.create( contact=contact, subscription_type=subscription_type, accept_subscription=True) def clean_same_as_suggestions(self): contact_id = self.cleaned_data.get('same_as_suggestions', '') if contact_id: try: contact = models.Contact.objects.get(id=contact_id) return contact except models.Contact.DoesNotExist: raise ValidationError(ugettext("Contact does'nt exist")) def save_same_as(self, this_contact): contact = self.cleaned_data['same_as_suggestions'] if contact: # if not found create one if not contact.same_as: this_contact.same_as = models.SameAs.objects.create() this_contact.same_as_priority = 2 contact.same_as = this_contact.same_as contact.same_as_priority = 1 contact.save() else: this_contact.same_as = contact.same_as this_contact.same_as_priority = contact.same_as.contact_set.count( ) + 1 this_contact.save() def save(self, *args, **kwargs): """save""" contact = super(ContactForm, self).save(*args, **kwargs) if kwargs.get('commit', True): self.save_contact_subscriptions(contact) self.save_same_as(contact) return contact
class Meta(MessageForm.Meta): widgets = { 'messageType': forms.Select(), 'category': forms.CheckboxSelectMultiple(), }
def __init__(self, *args, **kwargs): super(custom_form_class, self).__init__(*args, **kwargs) self.fields['lang'].widget = forms.Select( choices=crm_settings.get_language_choices())
class FoiRequestStatusForm(forms.Form): def __init__(self, foirequest, *args, **kwargs): super(FoiRequestStatusForm, self).__init__(*args, **kwargs) self.foirequest = foirequest self.fields['refusal_reason'] = forms.ChoiceField( label=_("Refusal Reason"), choices=[('', _('No or other reason given'))] + (foirequest.law.get_refusal_reason_choices()), required=False, widget=forms.Select(attrs={'class': 'form-control'}), help_text= _('When you are (partially) denied access to information, the Public Body should always state the reason.' )) status = forms.ChoiceField( label=_("Status"), widget=forms.RadioSelect, choices=[ ('awaiting_response', _('This request is still ongoing.')), ('resolved', _('This request is finished.')), # ('request_redirected', _('This request has been redirected to a different public body.')) ]) resolution = forms.ChoiceField( label=_('Resolution'), choices=[('', _('No outcome yet'))] + FoiRequest.RESOLUTION_FIELD_CHOICES, required=False, widget=forms.Select(attrs={'class': 'form-control'}), help_text=_( 'How would you describe the current outcome of this request?')) redirected = forms.IntegerField( label=_("Redirected to"), required=False, widget=PublicBodySelect, help_text= _('If your message is redirected to a different Public Body, please specify the new Public Body' )) if payment_possible: costs = forms.FloatField( label=_("Costs"), required=False, min_value=0.0, localize=True, widget=PriceInput, help_text= _('Please specify what the Public Body charges for the information.' )) def clean_costs(self): costs = self.cleaned_data['costs'] if costs is None: return 0.0 return costs def clean(self): pk = self.cleaned_data.get('redirected', None) status = self.cleaned_data.get('status', None) if status == "request_redirected": if pk is None: raise forms.ValidationError( _("Provide the redirected public body!")) try: self._redirected_public_body = PublicBody.objects.get(id=pk) except PublicBody.DoesNotExist: raise forms.ValidationError(_("Invalid value")) if status == 'resolved': if not self.cleaned_data.get('resolution', ''): raise forms.ValidationError( _('Please give a resolution to this request')) # if resolution is successful or partially_successful, set status to resolved if self.cleaned_data.get('resolution', '') in ('successful', 'partially_successful'): self.cleaned_data['status'] = 'resolved' return self.cleaned_data def set_status(self): data = self.cleaned_data status = data['status'] resolution = data['resolution'] foirequest = self.foirequest message = foirequest.message_needs_status() if message: message.status = status message.save() if status == "request_redirected": foirequest.due_date = foirequest.law.calculate_due_date() foirequest.public_body = self._redirected_public_body status = 'awaiting_response' foirequest.status = status foirequest.resolution = resolution foirequest.costs = data['costs'] if resolution == "refused" or resolution == "partially_successful": foirequest.refusal_reason = data['refusal_reason'] else: foirequest.refusal_reason = u"" foirequest.save() status = data.pop("status") if status == 'resolved': foirequest.status_changed.send(sender=foirequest, status=resolution, data=data)
class UserRegistrationForm(ModelFormWithCity, SubscriptionTypeFormMixin): """A form for creating a new account on a website""" email = EmailField(required=True, label=_("Email"), widget=forms.TextInput()) password1 = forms.CharField(required=True, widget=forms.PasswordInput(), label=_("Password")) password2 = forms.CharField(required=True, widget=forms.PasswordInput(), label=_("Repeat your password")) 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) accept_termofuse = forms.BooleanField( label=_('Accept terms of use'), help_text=_("Check for accepting the terms of use")) city = forms.CharField( required=False, label=_('City'), widget=CityAutoComplete(attrs={ 'placeholder': _('Enter a city'), 'size': '80' })) class Meta: model = ContactProfile fields = ('email', 'password1', 'password2', 'entity_type', 'entity', 'gender', 'firstname', 'lastname', 'phone', 'mobile', 'address', 'zip_code', 'city', 'cedex', 'country', 'groups', 'accept_termofuse') def __init__(self, *args, **kwargs): super(UserRegistrationForm, self).__init__(*args, **kwargs) if 'gender' in self.fields: # do not display Mrs and Mr self.fields['gender'].choices = [ (Contact.GENDER_NOT_SET, _('Gender')), (Contact.GENDER_MALE, ugettext('Mr')), (Contact.GENDER_FEMALE, ugettext('Mrs')), ] if 'entity_type' in self.fields: self.fields['entity_type'].choices = [ (0, ugettext('Individual')) ] + [(et.id, et.name) for et in EntityType.objects.filter(subscribe_form=True)] if not has_entity_on_registration_form(): self.fields['entity_type'].inital = 0 self.fields['entity_type'].widget = forms.HiddenInput() self.fields['entity'].widget = forms.HiddenInput() termsofuse_url = get_registration_accept_terms_of_use_link() if 'accept_termofuse' in self.fields and termsofuse_url: self.fields['accept_termofuse'].label = mark_safe( ugettext('Accept <a href="{0}">terms of use</a>').format( termsofuse_url)) self._add_subscription_types_field() def clean_entity(self, ): entity_type = self.cleaned_data.get('entity_type', None) entity = self.cleaned_data['entity'] if entity_type: if not entity: raise ValidationError( _("{0}: Please enter a name".format(entity_type))) return entity def clean_entity_type(self): try: entity_type_id = int(self.cleaned_data['entity_type'] or 0) except ValueError: raise ValidationError(ugettext('Invalid entity type')) if entity_type_id: try: return EntityType.objects.get(id=entity_type_id) except EntityType.DoesNotExist: raise ValidationError(ugettext('Unknown entity type')) return None def clean(self, *args, **kwargs): password1 = self.cleaned_data.get('password1', "") password2 = self.cleaned_data.get('password2', "") if password1 and (password1 != password2): raise forms.ValidationError(ugettext('Passwords are not the same')) return super(UserRegistrationForm, self).clean(*args, **kwargs) def save(self, commit=True): if get_registration_version() >= "2.0.0": # Django registration 2.0 # The registration form should return a user email = self.cleaned_data["email"] username = email[:30] user = User.objects.create(username=username, email=email, is_active=False) password = self.cleaned_data.get('password1', "") user.set_password(password) return user else: # Django registration 1.0 return super(UserRegistrationForm, self).save(commit)
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