def post_init(self, all_classes=False): """init""" try: instance_fragment_type = self.instance.type except FragmentType.DoesNotExist: instance_fragment_type = None if instance_fragment_type or all_classes: if instance_fragment_type: css_classes = instance_fragment_type.allowed_css_classes.split( ',') else: css_classes = [] for fragment_type in FragmentType.objects.all(): fragment_classes = fragment_type.allowed_css_classes.split( ',') for css_class in fragment_classes: if css_class not in css_classes: css_classes.append(css_class) if css_classes: choices = [('', '')] + [(x, x) for x in css_classes] self.fields['css_class'].widget = floppyforms.SelectMultiple( choices=choices, attrs={ "class": "chosen-select", "data-placeholder": _("Select CSS classes to apply") }) else: self.fields['css_class'].widget = floppyforms.HiddenInput() else: self.fields['css_class'].widget = floppyforms.HiddenInput()
def add_fields(self, form, index): super(BaseBackendInlineFormSet, self).add_fields(form, index) if self.order_field and self.order_field in form.fields: form.fields[self.order_field].widget = forms.HiddenInput() if self.can_delete: form.fields['DELETE'].widget = forms.HiddenInput()
class Meta: model = Poll exclude = ['status', 'status_changed'] widgets = { 'poll_type': forms.HiddenInput(), 'create_user': forms.HiddenInput() }
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()
class Meta: model = PurchaseAccept fields = '__all__' widgets = { 'poll': forms.HiddenInput(), 'create_user': forms.HiddenInput() }
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'})
class Meta: model = Item fields = '__all__' error_messages = { NON_FIELD_ERRORS: { 'unique_together': "Jogo já indicado por um associado.", } } widgets = { 'poll': forms.HiddenInput(), 'create_user': forms.HiddenInput() }
def __init__(self, *args, **kwargs): self.instance = kwargs.get('instance') super(EditGroupForm, self).__init__(*args, **kwargs) self.fields['entities'] = forms.CharField( widget=forms.HiddenInput(), initial=[elt.id for elt in self.instance.entities.all()] if self.instance.id else [], required=False, ) self.fields['contacts'] = forms.CharField( widget=forms.HiddenInput(), initial=[elt.id for elt in self.instance.contacts.all()] if self.instance.id else [], required=False)
class ThreadForm(MessageForm): """ Formulaire de fil de discussion """ # Constantes SUBJECT_LENGTH_MIN = 1 # Champs supplémentaires subject = forms.CharField(max_length=48, required=False, widget=forms.TextInput()) recipient = forms.IntegerField(required=True, widget=forms.HiddenInput()) # Validation def clean_subject(self): """ Valider et renvoyer les données du champ sujet """ subject = self.data['subject'] if len(subject) < ThreadForm.SUBJECT_LENGTH_MIN: raise forms.ValidationError( _("Your subject must be at least {} characters long.").format( ThreadForm.SUBJECT_LENGTH_MIN)) return subject def clean_recipient(self): """ Valider et renvoyer les données du champ destinataire """ recipient = int(self.data['recipient']) if get_user_model().objects.get_or_none(id=recipient) is None: raise forms.ValidationError(_("The recipient does not exist.")) return get_user_model().objects.get(id=recipient)
class Meta: """form from model""" model = models.Action fields = ['done'] widgets = { 'done': forms.HiddenInput(), }
def __init__(self, *args, **kwargs): self.subscription_type = kwargs.pop('subscription_type', None) super(EmailSubscribeForm, self).__init__(*args, **kwargs) self.fields['favorite_language'].widget = forms.HiddenInput() if crm_settings.has_language_choices(): self.fields['favorite_language'].initial = get_language()
def __init__(self, *args, **kwargs): super(MinimalUserRegistrationForm, self).__init__(*args, **kwargs) for hidden_field in ('entity', 'entity_type', 'zip_code', 'city', 'country', 'groups_ids'): self.fields[hidden_field].widget = forms.HiddenInput() for required_field in ('firstname', 'lastname'): self.fields[required_field].required = True
class SearchActionForm(BsForm, SearchActionBaseMixin): """Base class for any views which needs to get extra information for handling results""" contacts = forms.CharField(widget=forms.HiddenInput()) def __init__(self, *args, **kwargs): initial_contacts = self._pre_init(*args, **kwargs) super(SearchActionForm, self).__init__(*args, **kwargs) self._post_init(initial_contacts)
def __init__(self, *args, **kwargs): super(NewNewsletterForm, self).__init__(*args, **kwargs) self.source_content = "" self.allow_url_sources = getattr(settings, 'BALAFON_NEWSLETTER_SOURCES', ()) if not self.allow_url_sources: self.fields['source_url'].widget = forms.HiddenInput()
class PdfTemplateForm(SearchActionForm): """Form for Pdf generation""" search_dict = forms.CharField(widget=forms.HiddenInput()) def __init__(self, *args, **kwargs): super(PdfTemplateForm, self).__init__(*args, **kwargs) if getattr(settings, 'BALAFON_PDF_TEMPLATES', None): choices = settings.BALAFON_PDF_TEMPLATES else: choices = ( ('pdf/labels_24.html', _('etiquettes 24')), ('pdf/labels_21.html', _('etiquettes 21')), ('pdf/agipa_21.html', _('Agipa 21')), ('pdf/labels_16.html', _('etiquettes 16')), ('pdf/address_strip.html', _('bande adresse')), ) self.fields['template'] = forms.ChoiceField( choices=choices, required=True, label=_('template'), help_text=_('Select the type of document to generate')) self.fields['template'].widget.attrs.update({'class': 'form-control'}) extra_fields = getattr(settings, 'BALAFON_PDF_FORM_EXTRA_FIELDS', None) if extra_fields: for field_name, field_label, initial_value in extra_fields: self.fields[field_name] = forms.CharField( label=field_label, initial=initial_value) self.fields[field_name].widget.attrs.update( {'class': 'form-control'}) def patch_context(self, context): """ add to data from external function in context It can be used for example for adding blank labels in labels generation """ template = self.cleaned_data['template'] extra_data = self._get_extra_data() context.update(extra_data) hooks = getattr(settings, 'BALAFON_PDF_FORM_CONTEXT_HOOKS', {}) if hooks and template in hooks: context = hooks[template](template, context) return context def _get_extra_data(self): """ This extra_data comes from additional fields defined in BALAFON_PDF_FORM_EXTRA_FIELDS settings These values are passed to the template """ extra_data = dict(self.cleaned_data) for field in ('template', 'contacts', 'search_dict'): extra_data.pop(field) return extra_data
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, ])
def __init__(self, *args, **kwargs): super(StoreManagementActionTypeAdminForm, self).__init__(*args, **kwargs) if self.instance and self.instance.id and self.instance.action_type: self.initial_show_amount_as_pre_tax = self.instance.show_amount_as_pre_tax self.fields[ 'readonly_status'].queryset = self.instance.action_type.allowed_status else: self.fields[ 'readonly_status'].queryset = ActionStatus.objects.none() self.fields['readonly_status'].widget = forms.HiddenInput()
def __init__(self, *args, **kwargs): """ Reduce available options for non staff members, as they are not easy to understand. """ super().__init__(*args, **kwargs) if not kwargs['instance'].user.is_staff: self.fields['subscription'].choices = [ settings.NOTIFICATIONS_EMAIL_SUBSCRIPTIONS[0], settings.NOTIFICATIONS_EMAIL_SUBSCRIPTIONS[2] ] self.fields['wanted_actions'].widget = forms.HiddenInput()
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): instance = kwargs.get('instance', None) if instance: prefix = " ".join([ instance.street_number, instance.street_type.name if instance.street_type else '', ]).strip() instance.address = instance.address.replace(prefix, '', 1).strip() billing_prefix = " ".join([ instance.billing_street_number, instance.billing_street_type.name if instance.billing_street_type else '', ]).strip() instance.billing_address = instance.billing_address.replace( billing_prefix, '', 1).strip() super(ModelFormWithAddress, self).__init__(*args, **kwargs) if not models.StreetType.objects.count(): self.fields['street_number'].widget = forms.HiddenInput() self.fields['street_type'].widget = forms.HiddenInput() self.fields['billing_street_number'].widget = forms.HiddenInput() self.fields['billing_street_type'].widget = forms.HiddenInput()
class Meta: model = TurtleObservation exclude = ( 'uid', 'email_uid', ) widgets = { 'point': GoogleLeafletWidget(), 'point_accuracy': forms.HiddenInput(), } labels = { 'observer': _("Your Name"), 'email': _("Your Email"), 'phone': _("Your Phone"), }
class SelectContactOrEntityForm(forms.Form): """Select a contact or entity""" object_id = forms.IntegerField(widget=forms.HiddenInput(), required=True) object_type = forms.CharField(widget=forms.HiddenInput(), required=True) name = forms.CharField(required=True, label=_('Name')) def clean_name(self): """validation""" object_id = self.cleaned_data.get('object_id', '') object_type = self.cleaned_data.get('object_type', '') object_class = { 'contact': models.Contact, 'entity': models.Entity, }.get(object_type, None) if not object_class: raise ValidationError( ugettext("Invalid type '{0}'").format(object_type)) try: object_id = int(object_id) return object_class.objects.get(id=object_id) except (ValueError, object_class.DoesNotExist): raise ValidationError(ugettext("Does'nt exist"))
class SearchNameForm(forms.Form): """Save search form""" search_id = forms.IntegerField(required=False, widget=forms.HiddenInput()) name = forms.CharField(required=True, label=_("Name")) search_fields = forms.CharField(required=True, widget=forms.HiddenInput()) def clean_name(self): """validate name""" search_id = self.cleaned_data["search_id"] name = self.cleaned_data["name"] if not name: raise ValidationError(_("This field is required")) queryset = models.Search.objects.filter(name=name) if search_id: queryset = queryset.exclude(id=search_id) if queryset.count() > 0: raise ValidationError(_("This name is already used")) if search_id: search = models.Search.objects.get(id=search_id) if search.name != name: search.name = name search.save() else: search = models.Search(name=name) return search def clean_search_fields(self): """validate search fields""" search_fields = self.cleaned_data["search_fields"] data = json.loads(search_fields) for key in ('csrfmiddlewaretoken', 'excluded', 'name', 'field_choice'): data.pop(key, None) return data
def __init__(self, action_type, *args, **kwargs): super(CloneActionForm, self).__init__(*args, **kwargs) choices = [(action_type.id, action_type.name) for action_type in action_type.next_action_types.all().order_by('order_index')] self.fields['action_type'].choices = choices # If only 1 choice = change it to a confirmation if len(choices) == 1: self.fields['action_type'].initial = choices[0][0] self.fields['action_type'].widget = forms.HiddenInput() self.single_choice = True self.action_type_name = choices[0][1] else: self.single_choice = False self.action_type_name = ''
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()
class Meta(): model = Message fields = ( 'title', 'message', 'messageType', 'category', 'address', 'location', 'is_anonymous', 'allow_feedback', 'is_virtual', ) widgets = { 'messageType': forms.HiddenInput(), 'category': forms.CheckboxSelectMultiple(), 'location': LeafletWidget(), }
class ActionForContactsForm(forms.ModelForm): """Create action for contacts""" date = forms.DateField(label=_("planned date"), required=False, widget=forms.TextInput()) time = forms.TimeField(label=_("planned time"), required=False) contacts = forms.CharField(widget=forms.HiddenInput()) class Meta: """create form from model""" model = Action fields = ('date', 'time', 'type', 'subject', 'in_charge', 'detail', 'planned_date', 'contacts', 'opportunity') def __init__(self, *args, **kwargs): initial = kwargs.get('initial') initial_contacts = '' if initial and 'contacts' in initial: initial_contacts = ';'.join( ['{0}'.format(c.id) for c in initial['contacts']]) initial.pop('contacts') super(ActionForContactsForm, self).__init__(*args, **kwargs) if initial_contacts: self.fields['contacts'].initial = initial_contacts self.fields['opportunity'].widget = OpportunityAutoComplete( attrs={ 'placeholder': _('Enter the name of an opportunity'), 'size': '80', 'class': 'colorbox' }) def get_contacts(self): """return contacts""" contact_ids = self.cleaned_data["contacts"].split(";") return Contact.objects.filter(id__in=contact_ids) def clean_planned_date(self): """validate planned date""" the_date = self.cleaned_data["date"] the_time = self.cleaned_data.get("time", None) if the_date: return datetime.combine(the_date, the_time or datetime.min.time()) return None
class GroupForContactsForm(forms.Form): """Add contacts to group""" contacts = forms.CharField(widget=forms.HiddenInput()) groups = HidableModelMultipleChoiceField(queryset=Group.objects.all()) on_contact = forms.BooleanField( label=_("Group on contact"), required=False, initial=True, help_text=_("Define if the group is added on the contact itself or on his entity") ) class Media: """media files""" css = { 'all': ('chosen/chosen.css',) } js = ( 'chosen/chosen.jquery.js', ) 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(GroupForContactsForm, self).__init__(*args, **kwargs) if initial_contacts: self.fields['contacts'].initial = initial_contacts self.fields['groups'].widget.attrs = { 'class': 'chzn-select', 'data-placeholder': _('Select groups'), 'style': "width:350px;" } self.fields['groups'].help_text = '' def get_contacts(self): """get contacts""" contact_ids = self.cleaned_data["contacts"].split(";") return Contact.objects.filter(id__in=contact_ids)
class SortableNewsletterForm(NewsletterForm): """Example of newsletter form""" # cleaned_data = None sortable = forms.CharField(required=False, widget=forms.HiddenInput()) class Media(NewsletterForm.Media): js = NewsletterForm.Media.js + ('js/jquery.sortElements.js', ) def save(self, *args, **kwargs): """override save""" ret = super(SortableNewsletterForm, self).save(*args, **kwargs) order = self.cleaned_data['sortable'] if order: order = [int(x) for x in order.split(';')] for art_id in order: section = ArticleCategory.objects.get(id=art_id) section.ordering = order.index(art_id) + 1 section.save() return ret
def __init__(self, *args, **kwargs): instance = kwargs.get('instance', None) super(UpdateActionStatusForm, self).__init__(*args, **kwargs) if instance and instance.id and instance.type and instance.type.allowed_status.count(): # let javascript disable the blank value if default_status allowed_status = instance.type.allowed_status.all() if instance.frozen: allowed_status = allowed_status.filter(allowed_on_frozen=True) self.fields['status'].choices = [ (status.id, status.name) for status in allowed_status ] if instance and instance.id and instance.type and instance.type.allowed_status2.count(): # let javascript disable the blank value if default_status2 allowed_status2 = instance.type.allowed_status2.all() if instance.frozen: allowed_status2 = allowed_status2.filter(allowed_on_frozen=True) self.fields['status2'].choices = [ (status.id, status.name) for status in allowed_status2 ] else: self.fields['status2'].widget = forms.HiddenInput()