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()
)
