class Meta:
model = Course
fields = [
'id',
'course_code',
'name',
'materials',
'teachers',
'updated_associations',
'updated_teacher',
'calendar_year',
'coordinator',
'period',
*(['study_year'] if course_id is None else []),
]
widgets = {
'id':
HiddenInput(),
"materials":
AddAnotherWidgetWrapper(
ModelSelect2MultipleWidget(
queryset=MSP.objects.all(),
search_fields=[
"mspline__materials__name__icontains",
"mspline__materials__book__ISBN__icontains",
"mspline__materials__book__author__icontains",
"mspline__materials__book__year_of_publishing__icontains",
"mspline__materials__scientificarticle__DOI__icontains",
"mspline__materials__scientificarticle__author__icontains",
"mspline__materials__scientificarticle__year_of_publishing__icontains",
]),
reverse_lazy('boecie:msp.create',
kwargs={'course': course_id}))
if course_id else MultipleHiddenInput(),
'teachers':
AddAnotherWidgetWrapper(
ModelSelect2MultipleWidget(model=Teacher,
search_fields=[
'titles__icontains',
'initials__icontains',
'first_name__icontains',
'surname_prefix__icontains',
'last_name__icontains',
'email__icontains'
]),
reverse_lazy('boecie:teacher.create')),
'coordinator':
AddAnotherWidgetWrapper(
ModelSelect2Widget(model=Teacher,
search_fields=[
'titles__icontains',
'initials__icontains',
'first_name__icontains',
'surname_prefix__icontains',
'last_name__icontains',
'email__icontains'
]),
reverse_lazy('boecie:teacher.create')),
}
class LibraryFilterForm(forms.Form):
q = forms.CharField(
max_length=50,
widget=forms.TextInput(attrs={"style": "width: 100%;",
"class": "select2-lookalike"}),
required=False,
label="Search"
)
platforms = forms.MultipleChoiceField(
widget=Select2MultipleWidget(
attrs={'data-width': '100%',
'data-close-on-select': 'false',
'data-placeholder': '',
'data-minimum-input-length': 2}
),
required=False,
)
genres = forms.ModelMultipleChoiceField(
queryset=models.Genre.objects.all(),
widget=ModelSelect2MultipleWidget(
model=models.Genre,
search_fields=['name__icontains'],
attrs={'data-width': '100%',
'data-close-on-select': 'false',
'data-placeholder': '',
'data-minimum-input-length': 3}
),
required=False,
)
companies = forms.ModelMultipleChoiceField(
queryset=models.Company.objects.all(),
widget=ModelSelect2MultipleWidget(
model=models.Company,
search_fields=['name__icontains'],
attrs={'data-width': '100%',
'data-close-on-select': 'false',
'data-placeholder': '',
'data-minimum-input-length': 3}
),
required=False
)
years = forms.MultipleChoiceField(
choices=[(i, i) for i in range(date.today().year, 1970, -1)],
widget=Select2MultipleWidget(attrs={'data-width': '100%',
'data-close-on-select': 'false',
'data-placeholder': ''}),
required=False
)
flags = forms.MultipleChoiceField(
choices=models.Game.GAME_FLAGS,
widget=BitFieldCheckboxSelectMultiple,
required=False,
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['platforms'].choices = (models.Platform.objects.values_list('pk', 'name'))
class Date_precision_form(forms.ModelForm):
'''
Crispy form for publication create/update(edit).
Added field with buttons for inline add. Is almost the same as PublicationForm but has a submit button.
'''
authors_birth_date = forms.ModelMultipleChoiceField(widget=ModelSelect2MultipleWidget(
model=Author,
search_fields=['author_name__icontains', ],
attrs={'data-minimum-input-length': 0},
), queryset=Author.objects.all(), required=False)
authors_death_date = forms.ModelMultipleChoiceField(widget=ModelSelect2MultipleWidget(
model=Author,
search_fields=['author_name__icontains', ],
attrs={'data-minimum-input-length': 0},
), queryset=Author.objects.all())
works_date_list = forms.ModelMultipleChoiceField(widget=ModelSelect2MultipleWidget(
model=Works,
search_fields=['title__icontains', ],
attrs={'data-minimum-input-length': 0},
), queryset=Works.objects.all())
location_times_date_precision = forms.ModelMultipleChoiceField(widget=ModelSelect2MultipleWidget(
model=Location_time,
search_fields=['geo_location_name__icontains', ],
attrs={'data-minimum-input-length': 0},
), queryset=Location_time.objects.all())
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.helper = FormHelper()
self.fields['date_precision'].required = False
self.fields['authors_birth_date'].required = False
self.fields['authors_death_date'].required = False
self.fields['works_date_list'].required = False
self.fields['location_times_date_precision'].required = False
self.helper.layout = Layout(
'date_precision',
'authors_birth_date',
'authors_death_date',
'works_date_list',
'location_times_date_precision',
ButtonHolder(
Submit('save_add_another', 'Save and add another', css_class='btn-save btn-danger'),
Submit('save_and_continue_editing', 'Save and continue editing', css_class='btn-save btn-danger'),
Submit('save', 'Save', css_class='btn-save btn-danger'),
)
)
# do unsubscribe
class Meta:
model = Date_precision
# See note here: https://docs.djangoproject.com/en/1.10/ref/contrib/admin/#django.contrib.admin.ModelAdmin.form
fields = ('date_precision',)
class ArtistModelSelect2MultipleWidgetForm(forms.Form):
title = forms.CharField(max_length=50)
genres = forms.ModelMultipleChoiceField(widget=ModelSelect2MultipleWidget(
queryset=models.Genre.objects.all(),
search_fields=['title__icontains'],
), queryset=models.Genre.objects.all(), required=True)
featured_artists = forms.ModelMultipleChoiceField(widget=ModelSelect2MultipleWidget(
queryset=models.Artist.objects.all(),
search_fields=['title__icontains'],
), queryset=models.Artist.objects.all(), required=False)
class Meta:
model = Problem
exclude = [
"superadmin", "is_checked", "created_time", "last_updated_time",
"desc"
]
widgets = {
'groups':
ModelSelect2MultipleWidget(search_fields=[
'name__icontains',
'nickname__icontains',
]),
'tags':
ModelSelect2MultipleWidget(search_fields=['name__icontains'])
}
class Meta:
model = Clientes
fields = [
'nombre',
'estado',
'tipo_identifcacion',
'numero_identificacion',
'clasificacion',
'departamento',
'ciudad',
'direccion',
'responsable_tecnico',
'telefono_tecnico',
'email_tecnico',
'responsable_comercial',
'telefono_comercial',
'email_comercial',
'responsable_contabilidad',
'telefono_contabilidad',
'email_contabilidad',
'responsable_administrativo',
'telefono_administrativo',
'email_administrativo',
]
widgets = {
'clasificacion':
ModelSelect2MultipleWidget(model=Clientes,
search_fields=['nombre__icontains'],
attrs={
'class':
'select2_demo_2 form-control',
'multiple': 'multiple'
})
}
class ProblemForm(forms.ModelForm):
is_spj = forms.NullBooleanField(widget=forms.CheckboxInput(),
initial=False)
tags = forms.ModelMultipleChoiceField(
required=False,
queryset=ProblemTag.objects.all(),
widget=ModelSelect2MultipleWidget(search_fields=[
'name__icontains',
'nickname__icontains',
]))
class Meta:
model = Problem
exclude = [
"superadmin", "is_checked", "created_time", "last_updated_time",
"desc"
]
widgets = {
'groups':
ModelSelect2MultipleWidget(search_fields=[
'name__icontains',
'nickname__icontains',
]),
'tags':
ModelSelect2MultipleWidget(search_fields=['name__icontains'])
}
class ExpirePasswords(forms.Form):
users = forms.ModelMultipleChoiceField(widget=ModelSelect2MultipleWidget(
queryset=User.objects.all(), search_fields=['last_name__icontains']),
queryset=User.objects.all(),
required=False)
exp_date = forms.IntegerField(required=True)
if_mail = forms.BooleanField(required=False)
class VagaForm(forms.ModelForm):
beneficios = forms.MultipleChoiceField(
choices=BENEFICIOS,
widget=forms.CheckboxSelectMultiple,
)
competencia = forms.ModelMultipleChoiceField(
queryset=Competencia.objects.all(),
required=True,
widget=ModelSelect2MultipleWidget(model=Competencia,
search_fields=[
'nome__icontains',
]))
class Meta:
model = Vaga
fields = [
'id_vaga', 'nome_vaga', 'qtd_vaga', 'categoria', 'cidade',
'competencia', 'horario_trab', 'descricao', 'exp_requerida',
'status'
]
def __init__(self, *args, **kwargs):
super(VagaForm, self).__init__(*args, **kwargs)
self.fields['id_vaga'].widget.attrs['placeholder'] = '2020/001'
class SearchForm(forms.Form):
objective = forms.CharField(
label="Key term:",
max_length=100,
required=False,
widget=forms.TextInput(attrs={"class": "form-control"}))
industry = forms.ModelChoiceField(
label="Industry:",
queryset=Industry.objects.all(),
required=False,
widget=forms.Select(attrs={"class": "form-control"}))
region = forms.ModelMultipleChoiceField(
label="Choose regions to include in your search:",
widget=ModelSelect2MultipleWidget(
queryset=Region.objects.filter(
code__in=Organisation.objects.exclude(
regionCode__code__isnull=True).values_list(
'regionCode').distinct()),
search_fields=['description__icontains'],
attrs={
"class": "form-control",
"data-placeholder": "Choose regions"
}),
queryset=Region.objects.all(),
required=False)
class Meta:
exclude = []
widgets = {
'tags':
ModelSelect2MultipleWidget(attrs={'style': 'width:20em'},
search_fields=('title', )),
'collections':
ModelSelect2MultipleWidget(attrs={'style': 'width:20em'},
search_fields=('title', )),
'type':
ModelSelect2Widget(attrs={'style': 'width:20em'},
search_fields=('title', )),
'vendor':
ModelSelect2Widget(attrs={'style': 'width:20em'},
search_fields=('title', ))
}
class Meta(BaseForm.Meta):
model = SynchronousFlow
widgets = {
'subfunc_flow': ModelSelect2Widget(queryset=SubFuncFlow.objects.filter(
status__in=('On going', 'Released')).all(), search_fields=['name__icontains', ]),
'servers': ModelSelect2MultipleWidget(queryset=Server.objects.none(), search_fields=['name__icontains', ])
}
class GroupForm(forms.ModelForm):
admins = forms.ModelMultipleChoiceField(
queryset=User.objects.all(),
widget=ModelSelect2MultipleWidget(queryset=User.objects.all(),
search_fields=[
'username__icontains',
]),
)
def __init__(self, *args, **kwargs):
super(GroupForm, self).__init__(*args, **kwargs)
if self.instance.pk:
print "instance user_set============="
print self.instance.user_set.all()
self.fields['admins'].initial = self.instance.user_set.all()
def save(self, commit=True):
instance = super(GroupForm, self).save(commit=False)
instance.user_set.clear()
for admin in self.cleaned_data['admins']:
instance.user_set.add(admin)
if commit:
instance.save()
return instance
class Meta:
model = Group
# fields = '__all__'
fields = [
'admins',
]
class Meta:
model = MSPLine
fields = [
"type",
"msp",
"materials",
"comment",
]
widgets = {
"msp": HiddenInput(),
"type": HiddenInput(),
"materials": AddAnotherWidgetWrapper(ModelSelect2MultipleWidget(
queryset=StudyMaterialEdition.objects.all(),
search_fields=[
"name__icontains",
"book__ISBN__icontains",
"book__author__icontains",
"book__year_of_publishing__icontains",
"scientificarticle__DOI__icontains",
"scientificarticle__author__icontains",
"scientificarticle__year_of_publishing__icontains",
]
), reverse_lazy('material_management:material.create')),
# TODO: Convert this to a teacher:book.create view when it exists.
}
class Meta:
model = Group
exclude = []
widgets = {
"members":
ModelSelect2MultipleWidget(
search_fields=[
"first_name__icontains",
"last_name__icontains",
"short_name__icontains",
],
attrs={
"data-minimum-input-length": 0,
"class": "browser-default"
},
),
"owners":
ModelSelect2MultipleWidget(
search_fields=[
"first_name__icontains",
"last_name__icontains",
"short_name__icontains",
],
attrs={
"data-minimum-input-length": 0,
"class": "browser-default"
},
),
"parent_groups":
ModelSelect2MultipleWidget(
search_fields=["name__icontains", "short_name__icontains"],
attrs={
"data-minimum-input-length": 0,
"class": "browser-default"
},
),
"additional_fields":
ModelSelect2MultipleWidget(
search_fields=[
"title__icontains",
],
attrs={
"data-minimum-input-length": 0,
"class": "browser-default"
},
),
}
class Meta:
model = ItemWorkRelation
fields = ['work']
widgets = {
'work':
ModelSelect2MultipleWidget(model=Work,
search_fields=['title__icontains'])
}
class Meta:
model = ItemItemTypeRelation
fields = ['type']
widgets = {
'type':
ModelSelect2MultipleWidget(model=ItemType,
search_fields=['name__icontains'])
}
class BoxForm(forms.Form):
shipped = forms.BooleanField(required=False)
books = forms.ModelMultipleChoiceField(widget=ModelSelect2MultipleWidget(
queryset=Book.objects.all(),
search_fields=['title__icontains'],
attrs={'data-placeholder': 'Search for Book titles', 'data-width': '20em' }
), queryset=Book.objects.all(), required=True)
tracking_code = forms.CharField(required=False)
class Meta(BaseForm.Meta):
model = Environment
widgets = {
'application': ModelSelect2Widget(queryset=Application.objects.filter(
status__in=('On going', 'Released')).all(), search_fields=['name__icontains', ]),
'servers': ModelSelect2MultipleWidget(queryset=Server.objects.filter(
status__in=('On going', 'Released')).all(), search_fields=['name__icontains', ])
}
class Meta:
model = TaggedEntity
fields = ['tag']
widgets = {
'tag':
ModelSelect2MultipleWidget(model=Tag,
search_fields=['name__icontains'])
}
def add_material_details_field(self):
material_details = forms.ModelMultipleChoiceField(
widget=ModelSelect2MultipleWidget(model=MaterialDetails,
search_fields=['description']),
queryset=MaterialDetails.objects.all(),
required=False,
initial=MaterialDetails.objects.filter(items__item=self.instance))
self.fields['material_details'] = material_details
class OrganizationSearchMultiField(forms.ModelMultipleChoiceField):
widget = ModelSelect2MultipleWidget(model=Organization,
attrs={'style': 'width: 75%'},
search_fields=('name__icontains', ))
def __init__(self, *args, **kwargs):
kwargs['queryset'] = Organization.objects.all()
kwargs['help_text'] = 'Select field and begin typing to search'
super().__init__(*args, **kwargs)
def add_itemtype_field(self):
itemtypes = forms.ModelMultipleChoiceField(
widget=ModelSelect2MultipleWidget(model=ItemType,
search_fields=['name']),
queryset=ItemType.objects.all(),
required=False,
initial=ItemType.objects.filter(
itemitemtyperelation__item=self.instance))
self.fields['item_type'] = itemtypes
class Meta:
model = ItemMaterialDetailsRelation
fields = ['material_details']
widgets = {
'material_details':
ModelSelect2MultipleWidget(
model=MaterialDetails,
search_fields=['description__icontains'])
}
class Meta:
model = StudyGroup
fields = ('groupName', )
widgets = {
'groupName':
ModelSelect2MultipleWidget(queryset=StudyGroup.objects.all(),
search_fields=['groupName__icontains'])
}
labels = {'groupName': 'Группы'}
class Meta:
model = Paquete
fields = ('nombre', 'estilos')
widgets = {
'estilos':
ModelSelect2MultipleWidget(
model=Estilos,
search_fields=['nombre__icontains'],
)
}
class Meta:
widgets = {
'country':
Select2Widget(attrs={'style': 'width:20em'}),
'notes':
forms.Textarea(attrs={'rows': 4}),
'tags':
ModelSelect2MultipleWidget(attrs={'style': 'width:20em'},
search_fields=('title', ))
}
def add_types_field(self):
types = forms.ModelMultipleChoiceField(
widget=ModelSelect2MultipleWidget(
model=CollectionType,
search_fields=['name__icontains'],
),
queryset=CollectionType.objects.all(),
required=False,
initial=CollectionType.objects.filter(
collectioncollectiontyperelation__collection=self.instance))
self.fields['types'] = types
class Meta:
model = Combo
fields = '__all__'
widgets = {
'productos':
ModelSelect2MultipleWidget(
model=Ingrediente,
search_fields=['nombre__icontains'],
)
}
def get_talk_speaker_form_class(site):
fields = [
'name', 'email', 'twitter', 'linkedin', 'github', 'website',
'facebook', 'mastodon', 'phone_number'
]
widget = ModelSelect2MultipleWidget(
model=Participant,
queryset=Participant.objects.filter(site=site),
search_fields=['%s__icontains' % field for field in fields])
return modelform_factory(Talk,
form=TalkStaffForm,
widgets={'speakers': widget})
