def formfield(self, **defaults): if self.filter_horizontal: widget = FilteredSelectMultiple(self.verbose_name, is_stacked=False) else: widget = forms.SelectMultiple() def _render(name, value, attrs=None, *args, **kwargs): value = parse_tag_input(value) return type(widget).render(widget, name, value, attrs, *args, **kwargs) widget.render = _render defaults['widget'] = widget choices = [ (str(t), str(t)) for t in Tag.objects.all() ] return TagSelectFormField(choices=choices, required=not self.blank, **defaults)
def formfield(self, **defaults): if not self.choices: # if no choices are specified, get all tags choices = [(str(t)) for t in Tag.objects.all()] else: # otherwise show only the tags passed in via choices choices = [(t[0]) for t in self.choices] if self.filter_horizontal: widget = FilteredSelectMultiple(self.verbose_name, is_stacked=False) else: widget = forms.SelectMultiple() def _render(name, value, attrs=None, *args, **kwargs): value = parse_tag_input(value) return type(widget).render(widget, name, value, attrs, *args, **kwargs) widget.render = _render defaults["widget"] = widget choices = [(str(t), str(t)) for t in choices] return TagSelectFormField(choices=choices, required=not self.blank, **defaults)
class QuizAdminForm(forms.ModelForm): class Meta: model = Quiz questions = forms.ModelMultipleChoiceField(queryset=Question.objects.all(), required=False, widget=FilteredSelectMultiple( verbose_name=('Questions'), is_stacked=False)) def __init__(self, *args, **kwargs): super(QuizAdminForm, self).__init__(*args, **kwargs) if self.instance.pk: self.fields['questions'].initial = self.instance.question_set.all() def save(self, commit=True): quiz = super(QuizAdminForm, self).save(commit=False) if commit: quiz.save() if quiz.pk: quiz.question_set = self.cleaned_data['questions'] self.save_m2m() return quiz
class TeamForm(forms.ModelForm): op_team = forms.ModelMultipleChoiceField(queryset=Operative.objects.all(), widget=FilteredSelectMultiple( "Operatives", is_stacked=False, attrs={'size': 7}, )) class Meta: model = AWTeam fields = [ 'awteam_name', 'op_team', ] #we list the field then override field's widget #https://docs.djangoproject.com/en/3.0/topics/forms/modelforms/#overriding-the-default-fields #https://docs.djangoproject.com/en/3.0/ref/forms/widgets/#selectmultiple # widgets = { # 'op_team': forms.SelectMultiple(attrs={'size': 7}) # } class Media: # Django also includes a few javascript files necessary # for the operation of this form element. You need to # include <script src="/admin/jsi18n"></script> or <script type="text/javascript" src="{% url 'admin:jsi18n' %}"></script> # in the template. #see https://stackoverflow.com/questions/24572289/how-to-properly-render-filteredselectmultiple #for what we need in templates css = { 'all': ( '/admin/css/widgets.css', '/admin/css/overrides.css', 'static/teamoperation/style3.css', ), } js = ('/admin/jquery.js', '/admin/jsi18n/')
class ProductInline(inlines.ProductInline): model = se_models.Product formfield_overrides = { django_models.ManyToManyField: { 'widget': FilteredSelectMultiple(verbose_name='Tags', is_stacked=False) }, } fieldsets = ((None, { 'classes': ('primary-chars', ), 'fields': ( ('name', 'id'), ('category', 'correct_category_id'), ('price', 'in_stock'), 'is_popular', ('purchase_price', 'wholesale_small'), ('wholesale_medium', 'wholesale_large'), 'tags', ) }), ) def formfield_for_dbfield(self, db_field, **kwargs): if db_field.name == 'category': kwargs['widget'] = ModelSelect2Widget( model=se_models.Category, search_fields=[ 'name__icontains', 'pk__startswith', ], ) return super(ProductInline, self).formfield_for_dbfield( db_field, **kwargs, )
class BaseScheduleForm(forms.ModelForm): events = forms.ModelMultipleChoiceField( label='Events', queryset=Event.objects.all(), required=False, widget=FilteredSelectMultiple( "events", is_stacked=False) ) weeks = CSIMultipleChoiceField( initial='1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18', choices=Term.all_weeks_choices(), required=False, label='Weeks' ) trainees = forms.ModelMultipleChoiceField( queryset=Trainee.objects.all(), label='Participating Trainees', required=False, widget=TraineeSelect2MultipleInput, ) def __init__(self, *args, **kwargs): super(BaseScheduleForm, self).__init__(*args, **kwargs) self.fields['trainees'].widget.attrs['class'] = 'select-fk' self.fields['parent_schedule'].widget.attrs['class'] = 'select-fk' self.fields['term'].widget.attrs['class'] = 'select-fk' self.fields['term'].initial = Term.current_term() self.fields['season'].initial = 'All' self.fields['trainee_select'].initial = 'MA' self.fields['query_filter'].widget.attrs['class'] = 'select-fk' class Meta: model = Schedule exclude = []
class BookingsForm(forms.ModelForm): allday = forms.BooleanField(label='Dia inteiro', required=False) title = forms.CharField(label='Titulo do agendamento') start = forms.DateTimeField(label='Inicia em...') end = forms.DateTimeField(label='Termina em...') #created_on = forms.DateTimeField(label='Criado em...') authorized = forms.BooleanField(label='Autorizado', required=False) editable = forms.BooleanField(label='Editavel', required=False) # ABAIXO, CHOICES NO FORMS VAI TER UMALISTAGEM NO TEMPLATE color = forms.ChoiceField(label='Cor', choices=(('blue', 'blue'), ('red', 'red'), ('green', 'green'), ('black', 'black'))) overlap = forms.BooleanField(label='Sobrepor?', required=False) holiday = forms.BooleanField(label='Feriado?', required=False) participants = forms.ModelMultipleChoiceField( label='Participantes', queryset=User.objects.all(), widget=FilteredSelectMultiple("Participantes", is_stacked=False, attrs={ 'class': 'material-ignore', 'multiple': 'True' })) class Meta: model = Booking exclude = ['created_on'] fields = '__all__' layout = Layout( Fieldset("Inclua uma agenda", Row('title', ), Row('start', 'end', 'color'), Row( Span6('holiday'), Span6('authorized'), ), Row(Span6('editable'), Span6('allday')), Row('overlap'), Row('participants')))
class ProjectForm(ModelForm): template_file_upload = FileField(label='HTML template file', required=False) worker_permissions = ModelMultipleChoiceField( label='Worker Groups with access to this Project', queryset=Group.objects.all(), required=False, widget=FilteredSelectMultiple('Worker Groups', False), ) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.fields['template_file_upload'].widget = CustomButtonFileWidget() # This hidden form field is updated by JavaScript code in the # customized admin template file: # turkle/templates/admin/turkle/project/change_form.html self.fields['filename'].widget = HiddenInput() self.fields['assignments_per_task'].label = 'Assignments per Task' self.fields['assignments_per_task'].help_text = 'This parameter sets the default ' + \ 'number of Assignments per Task for new Batches of Tasks. Changing this ' + \ 'parameter DOES NOT change the number of Assignments per Task for already ' + \ 'published batches of Tasks.' self.fields['custom_permissions'].label = 'Restrict access to specific Groups of Workers ' self.fields['html_template'].label = 'HTML template text' limit = str(get_turkle_template_limit()) self.fields['html_template'].help_text = 'You can edit the template text directly, ' + \ 'Drag-and-Drop a template file onto this window, ' + \ 'or use the "Choose File" button below. Maximum size is ' + limit + ' KB.' byte_limit = str(get_turkle_template_limit(True)) self.fields['html_template'].widget.attrs['data-parsley-maxlength'] = byte_limit self.fields['html_template'].widget.attrs['data-parsley-group'] = 'html_template' initial_ids = [str(id) for id in get_groups_with_perms(self.instance).values_list('id', flat=True)] self.fields['worker_permissions'].initial = initial_ids
class GroupAdminForm(forms.ModelForm): class Meta: model = Group exclude = [] # Add the users field. users = forms.ModelMultipleChoiceField( queryset=User.objects.all(), required=False, # Use the pretty 'filter_horizontal widget'. widget=FilteredSelectMultiple('users', False), label=_('Users'), ) def __init__(self, *args, **kwargs): # Do the normal form initialisation. super(GroupAdminForm, self).__init__(*args, **kwargs) # If it is an existing group (saved objects have a pk). if self.instance.pk: # Populate the users field with the current Group users. self.fields['users'].initial = self.instance.user_set.all() def save_m2m(self): # Add the users to the Group. # Deprecated in Django 1.10: Direct assignment to a reverse foreign key # or many-to-many relation if VERSION < (1, 9): self.instance.user_set = self.cleaned_data['users'] else: self.instance.user_set.set(self.cleaned_data['users']) def save(self, *args, **kwargs): # Default save instance = super(GroupAdminForm, self).save() # Save many-to-many data self.save_m2m() return instance
class BaseDatasetForm(AutoCompleteUserFieldsMixin, forms.ModelForm): type = forms.HiddenInput() eligibility_criteria = DynamicArrayField(base_field=forms.CharField(), required=False) authorized_users = forms.ModelMultipleChoiceField( required=False, widget=FilteredSelectMultiple("users", False), queryset=get_user_model().objects.filter().order_by("email"), ) # Invalid dataset type - must be overridden by the subclass. dataset_type = -1 can_change_user_permission_codename = None class Meta: model = DataSet fields = "__all__" widgets = {"type": forms.HiddenInput()} def __init__(self, *args, **kwargs): user = kwargs.pop("user") kwargs["initial"] = {"type": self.dataset_type} super().__init__(*args, **kwargs) is_instance = "instance" in kwargs and kwargs["instance"] self.fields["authorized_users"].initial = ( get_user_model().objects.filter( datasetuserpermission__dataset=kwargs["instance"]) if is_instance else get_user_model().objects.none()) if not user.is_superuser and not user.has_perm( self.can_change_user_permission_codename): self.fields["user_access_type"].disabled = True self.fields["authorized_users"].disabled = True self.fields["authorized_users"].widget = SelectMultiple(choices=( (user.id, user.email) for user in self.fields["authorized_users"].queryset.all()))
class GroupAdminForm(forms.ModelForm): """Custom form to group for the admin panel.""" class Meta(object): """Meta class override.""" model = Group exclude = [] # Add the users field. users = forms.ModelMultipleChoiceField( queryset=User.objects.all(), required=False, # Use the pretty 'filter_horizontal widget'. widget=FilteredSelectMultiple("users", is_stacked=False), ) def __init__(self, *args, **kwargs): """Constructor of the GroupAdminForm.""" # Do the normal form initialisation. super().__init__(*args, **kwargs) # If it is an existing group (saved objects have a pk). if self.instance.pk: # Populate the users field with the current Group users. self.fields["users"].initial = self.instance.user_set.all() def save_m2m(self): """Rewrited method to save many to many models.""" # Add the users to the Group. self.instance.user_set.set(self.cleaned_data["users"]) def save(self, *args, **kwargs): """Rewrited method to save model.""" # Default save instance = super().save() # Save many-to-many data self.save_m2m() return instance
class EmailAttendeesForm(forms.Form): # Set up form from_type = forms.ChoiceField(choices=((0, "Robogals"), (1, _("Chapter name")), (2, _("Your name"))), initial=1) subject = forms.CharField(max_length=256, required=False) body = forms.CharField(widget=TinyMCE(attrs={'cols': 70}), required=False) memberselect = EmailModelMultipleChoiceField( queryset=ConferenceAttendee.objects.none(), widget=FilteredSelectMultiple(_("Recipients"), False, attrs={'rows': 10}), required=False) def __init__(self, *args, **kwargs): # Grab params, clear scope user = kwargs['user'] del kwargs['user'] conf = kwargs['conference'] del kwargs['conference'] super(EmailAttendeesForm, self).__init__(*args, **kwargs) # "From" field self.fields['from_type'].choices = ((0, "Robogals <" + user.email + ">"), (1, user.chapter.name + " <" + user.email + ">"), (2, user.get_full_name() + " <" + user.email + ">")) # Using `ConferenceAttendee` self.fields[ 'memberselect'].queryset = ConferenceAttendee.objects.filter( conference=conf.id).order_by('last_name')
class PhysicalAccessExceptionAdminForm(forms.ModelForm): class Meta: model = PhysicalAccessException fields = "__all__" class Media: js = ("admin/time_options_override.js", ) physical_access_levels = forms.ModelMultipleChoiceField( queryset=PhysicalAccessLevel.objects.all(), required=False, widget=FilteredSelectMultiple(verbose_name="Physical Access Levels", is_stacked=False), ) def clean(self): if any(self.errors): return cleaned_data = super().clean() start_time = cleaned_data.get("start_time") end_time = cleaned_data.get("end_time") if end_time <= start_time: self.add_error("end_time", "The end time must be later than the start time")
class QuizAdminForm(forms.ModelForm): class Meta: model = Quiz exclude = [] # Check if the result is already cached questions_results = cache.get( 'questions_results') # Returns None if not cached earlier # If the result is None, then query the database and set the cache if questions_results is None: questions_results = Question.objects.all() try: cache.set('questions_results', questions_results) except: print("se ha producido exception en question_result") questions = forms.ModelMultipleChoiceField( queryset=questions_results, #Question.objects.all().select_subclasses(), required=False, label=_("Questions"), widget=FilteredSelectMultiple(verbose_name=_("Questions"), is_stacked=False)) def __init__(self, *args, **kwargs): super(QuizAdminForm, self).__init__(*args, **kwargs) if self.instance.pk: self.fields['questions'].initial =\ self.instance.question_set.all().select_subclasses() def save(self, commit=True): quiz = super(QuizAdminForm, self).save(commit=False) quiz.save() quiz.question_set.set(self.cleaned_data['questions']) self.save_m2m() return quiz
class DocumentTypeFieldCategoryForm(forms.ModelForm): class Meta: model = DocumentTypeFieldCategory fields = ['name', 'order'] type_fields = forms.ModelMultipleChoiceField( queryset=DocumentTypeField.objects.all(), label='Select Type Fields', required=False, widget=FilteredSelectMultiple('fields', False)) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if self.instance: self.fields['type_fields'].initial = self.instance.documenttypefield_set.all() def save(self, *args, **kwargs): # FIXME: 'commit' argument is not handled # TODO: Wrap reassignments into transaction # NOTE: Previously assigned DocumentTypeFieldCategory are silently reset instance = super().save(commit=False) self.fields['type_fields'].initial.update(category=None) self.cleaned_data['type_fields'].update(category=instance) return instance
class GroupRegisterForm(forms.Form): name = forms.CharField() info = forms.CharField(widget=forms.Textarea) display_image = forms.ImageField() location = forms.CharField() members = forms.ModelMultipleChoiceField(queryset=User.objects.all(), widget=FilteredSelectMultiple( "verbose name", is_stacked=False)) def save(self, user): group = GroupProfile() group.admin = user group.name = self.cleaned_data["name"] group.info = self.cleaned_data["info"] group.location_text = self.cleaned_data["location"] group.display_image = self.cleaned_data["display_image"] stats = GroupStats() stats.num_members = len(self.cleaned_data["members"]) stats.save() group.stats = stats group.save() group.members.add(*self.cleaned_data["members"]) group.save()
class Meta: model = Team fields = ("name", "slug", "desc", "wikipedia", "creators", "image") widgets = { "name": TextInput(attrs={"class": "input"}), "slug": TextInput(attrs={"class": "input"}), "desc": Textarea(attrs={"class": "textarea"}), "wikipedia": TextInput(attrs={"class": "input"}), "creators": FilteredSelectMultiple("Creators", attrs={"size": "6"}, is_stacked=False), "image": ClearableFileInput(), } help_texts = { "wikipedia": "If the description is from wikipedia, please supply that pages slug" + " so we can provide attribution to them." }
class GroupAdminForm(forms.ModelForm): """ ModelForm that adds an additional multiple select field for managing the users in the group. """ class Meta: model = Group exclude = [] # Add the users field. users = forms.ModelMultipleChoiceField( queryset=User.objects.all(), required=False, # Use the pretty 'filter_horizontal widget'. widget=FilteredSelectMultiple('users', False) ) def __init__(self, *args, **kwargs): # Do the normal form initialisation. super(GroupAdminForm, self).__init__(*args, **kwargs) # If it is an existing group (saved objects have a pk). if self.instance.pk: # Populate the users field with the current Group users. self.fields['users'].initial = self.instance.user_set.all() def save_many_to_many(self): # Add the users to the Group. self.instance.user_set.clear() self.instance.user_set.set(self.cleaned_data["users"]) def save(self, *args, **kwargs): # Default save instance = super(GroupAdminForm, self).save() kwargs["commit"] = True self.save_many_to_many() return instance
class ExperimentForm(forms.ModelForm): """ Provides the multi-select fields containing a list of all existing groups. """ class Meta: model = Experiment fields = '__all__' sharing_groups = forms.ModelMultipleChoiceField( queryset=Group.objects.all(), required=False, widget=FilteredSelectMultiple("groups", is_stacked=False)) def clean_sharing_groups(self): """ Checks that at least one group is selected when experiment is to be shared with groups. """ sharing_option = self.cleaned_data.get('sharing_option') groups = self.cleaned_data.get('sharing_groups') if sharing_option == 'GRP': if not groups: raise ValidationError('Please select at least one group.') return groups
class ProjectUpdateAdminForm(forms.ModelForm): comanage_pi_admins = forms.ModelMultipleChoiceField( queryset=NotaryServiceUser.objects.filter( roles__co_cou__name=os.getenv('ROLE_PI')).order_by('display_name'), widget=FilteredSelectMultiple("Administrators", is_stacked=False), required=False) class Media: extend = False css = {'all': ['admin/css/widgets.css']} js = ( 'js/django_global.js', 'admin/js/jquery.init.js', 'admin/js/core.js', 'admin/js/prepopulate_init.js', 'admin/js/prepopulate.js', 'admin/js/SelectBox.js', 'admin/js/SelectFilter2.js', 'admin/js/admin/RelatedObjectLookups.js', ) class Meta: model = Project fields = ['comanage_pi_admins']
class VisualisationCatalogueItemForm(forms.ModelForm): eligibility_criteria = DynamicArrayField( base_field=forms.CharField(), required=False ) requires_authorization = forms.BooleanField( label='Each user must be individually authorized to access the data', required=False, ) authorized_users = forms.ModelMultipleChoiceField( required=False, widget=FilteredSelectMultiple('users', False), queryset=get_user_model().objects.filter().order_by('email'), ) class Meta: model = VisualisationCatalogueItem fields = '__all__' widgets = {'type': forms.HiddenInput()} def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) is_instance = 'instance' in kwargs and kwargs['instance'] self.fields['requires_authorization'].initial = ( kwargs['instance'].user_access_type == 'REQUIRES_AUTHORIZATION' if is_instance else True ) self.fields['authorized_users'].initial = ( get_user_model().objects.filter( visualisationuserpermission__visualisation=kwargs['instance'] ) if is_instance else get_user_model().objects.none() )
class RolForm(ModelForm): permissions = ModelMultipleChoiceField(queryset=Permission.objects.filter(~Q(content_type=1),~Q(content_type=2),~Q(content_type=3),~Q(content_type=4),~Q(content_type=5), ~Q(content_type=6)), label=('Seleccionar permisos'), widget=FilteredSelectMultiple('Permisos', is_stacked=False),help_text='',) """ Formulario para la creacion de roles Hereda de forms.ModelForm y utiliza la clase Group para agregar ciertos campos a la hora de la creacion/modificacion/eliminacion """ class Meta: model = Group fields = ['name','permissions'] labels = { 'name': ('Nombre'), } class Media: css = {'all': ('admin/css/widgets.css','/static/css/filteredselectwidget.css'), } # jsi18n is required by the widget js = ('/admin/jsi18n',)
class GroupAdminForm(forms.ModelForm): """ https://stackoverflow.com/a/39648244/2144569 """ class Meta: model = Group exclude = [] # Add the users field. users = forms.ModelMultipleChoiceField( queryset=get_user_model().objects.all(), required=False, # Use the pretty 'filter_horizontal widget'. widget=FilteredSelectMultiple('users', False), ) def __init__(self, *args, **kwargs): # Do the normal form initialisation. super(GroupAdminForm, self).__init__(*args, **kwargs) self.fields['users'].queryset = get_user_model().objects.filter( is_active=True) # If it is an existing group (saved objects have a pk). if self.instance.pk: # Populate the users field with the current Group users. self.fields['users'].initial = self.instance.user_set.all() def save_m2m(self): # Add the users to the Group. self.instance.user_set.set(self.cleaned_data['users']) def save(self, *args, **kwargs): # Default save instance = super(GroupAdminForm, self).save() # Save many-to-many data self.save_m2m() return instance
class VideoForm(forms.ModelForm): tags = forms.ModelMultipleChoiceField( queryset=song_models.Tag.getQueryset(["video"]), widget=FilteredSelectMultiple(verbose_name="tags", is_stacked=False), required=False) #difficulty = forms.ChoiceField(choices=()) required_css_class = 'required font-bold' class Meta: model = video_models.Video exclude = [] class Media: css = { 'all': ['admin/css/widgets.css'], # 'css/uid-manage-form.css' } # Adding this javascript is crucial js = ['/admin/jsi18n/'] def __init__(self, *args, **kwargs): super(type(self), self).__init__(*args, **kwargs) for field in self.fields.values(): field.widget.attrs.update({'class': 'form-control'})
class GroupAdminForm(forms.ModelForm): users = forms.ModelMultipleChoiceField(queryset=User.objects.all(), required=False, widget=FilteredSelectMultiple( 'users', False)) class Meta: model = Group fields = ('name', 'users') def __init__(self, *args, **kwargs): super(GroupAdminForm, self).__init__(*args, **kwargs) if self.instance.pk: self.fields['users'].initial = self.instance.user_set.all() def save_m2m(self): self.instance.user_set.set(self.cleaned_data['users']) def save(self, *args, **kwargs): instance = super(GroupAdminForm, self).save() self.save_m2m() return instance
class VisualisationTemplateEditForm(forms.ModelForm): authorized_master_datasets = forms.ModelMultipleChoiceField( required=False, widget=FilteredSelectMultiple('master datasets', False), queryset=MasterDataset.objects.live().filter( user_access_type='REQUIRES_AUTHORIZATION').order_by('name'), ) class Meta: model = ApplicationTemplate fields = '__all__' def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) try: instance = kwargs['instance'] except KeyError: return self.fields[ 'authorized_master_datasets'].initial = MasterDataset.objects.live( ).filter(datasetapplicationtemplatepermission__application_template =instance)
class Meta: model = Zone fields = ( 'code', 'name', 'zonetype', 'pro_com', 'slug', 'short', 'description', 'geom', 'zones', 'web', ) widgets = { 'description': forms.CharField(required=False, widget=TinyMCE()), 'zones': FilteredSelectMultiple("Vicini:", False, attrs={'rows': 4}), 'web': forms.Textarea(attrs={ 'cols': 60, 'rows': 2 }), }
class Meta: model = Series exclude = ("edited_by", "slug") widgets = { "name": TextInput(attrs={"class": "input"}), "sort_name": TextInput(attrs={"class": "input"}), "volume": TextInput(attrs={"class": "input"}), "year_began": TextInput(attrs={"class": "input"}), "year_end": TextInput(attrs={"class": "input"}), "series_type": Select(), "publisher": Select(), "desc": Textarea(attrs={"class": "textarea"}), "associated": FilteredSelectMultiple("Associated Series", attrs={"size": "6"}, is_stacked=False), } help_texts = { "sort_name": """Most of the time it will be the same as the series name, but if the title starts with an article like 'The' it might be remove so that it is listed with like named series.""", "year_end": "Leave blank if a One-Shot, Annual, or Ongoing Series.", "associated": "Associate a series with another. For example, an annual with it's primary series.", } labels = {"associated": "Associated Series"}
class CIEditForm(forms.ModelForm): class Meta: model = models.CI widgets = { 'id': ReadOnlyWidget, 'uid' : ReadOnlyWidget, } fields = ( 'id', 'uid', 'name', 'type', 'state', 'status', 'layers', 'pci_scope', ) icons={ } layers = forms.ModelMultipleChoiceField( models.CILayer.objects.all(), widget = FilteredSelectMultiple("layers", False, attrs={'rows' : '10' } ) ) def __init__(self, *args, **kwargs): super(CIEditForm, self).__init__(*args, **kwargs) if self.data: self.data = self.data.copy() if self.initial.get('uid', None): self.data['uid'] = self.initial['uid'] if self.initial.get('id', None): self.data['id'] = self.initial['id'] if self.initial.get('name', None): self.data['name'] = self.initial['name']
class MediaFondsForm(ModelForm): queryset = MediaCorpus.objects.all() widget = FilteredSelectMultiple( "Corpus", True, ) children = forms.ModelMultipleChoiceField(widget=widget, queryset=queryset, label='Corpus') class Meta: model = MediaFonds exclude = ['description', 'public_access'] class Media: css = { 'all': [ '/static/admin/css/widgets.css', ], } js = [ '/admin/django/jsi18n/', ]
class myform(forms.ModelForm): class Meta: model = Quiz fields = '__all__' questions = forms.ModelMultipleChoiceField( queryset=Question.objects.all().select_subclasses(), required=False, label=_("Questions"), widget=FilteredSelectMultiple(verbose_name=_("Questions"), is_stacked=False)) def __init__(self, *args, **kwargs): super(myform, self).__init__(*args, **kwargs) if self.instance.pk: self.fields['questions'].initial = \ self.instance.question_set.all().select_subclasses() def save(self, commit=True): quiz = super(myform, self).save(commit=False) quiz.save() quiz.question_set.set(self.cleaned_data['questions']) self.save_m2m() return quiz
class GroupAdminForm(ModelForm): """Extended admin form to assign users to groups""" class Meta: model = Group exclude = [] users = ModelMultipleChoiceField( queryset=User.objects.all(), required=False, widget=FilteredSelectMultiple('users', False) ) def __init__(self, *args, **kwargs): super(GroupAdminForm, self).__init__(*args, **kwargs) if self.instance.pk: self.fields['users'].initial = self.instance.user_set.all() def save_m2m(self): self.instance.user_set.set(self.cleaned_data['users']) def save(self, *args, **kwargs): instance = super(GroupAdminForm, self).save() self.save_m2m() return instance
def test_stacked_render(self): w = FilteredSelectMultiple('test', True) self.assertEqual( conditional_escape(w.render('test', 'test')), '<select multiple="multiple" name="test" class="selectfilterstacked">\n</select><script type="text/javascript">addEvent(window, "load", function(e) {SelectFilter.init("id_test", "test", 1, "%(ADMIN_MEDIA_PREFIX)s"); });</script>\n' % {"ADMIN_MEDIA_PREFIX": settings.ADMIN_MEDIA_PREFIX} )
def test_render(self): w = FilteredSelectMultiple('test', False) self.assertEqual( conditional_escape(w.render('test', 'test')), '<select multiple="multiple" name="test" class="selectfilter">\n</select><script type="text/javascript">addEvent(window, "load", function(e) {SelectFilter.init("id_test", "test", 0, "%(ADMIN_MEDIA_PREFIX)s"); });</script>\n' % admin_media_prefix() )