def __init__(self, *args, **kwargs):
super(ChosenAdminForm, self).__init__(*args, **kwargs)
for field in self.fields:
# Set help text for all fields
f = self.instance._meta.get_field(field)
self.fields[field].help_text = f.help_text
if self.fields[field].__class__.__name__ in [
'ChoiceField', 'TypedChoiceField', 'MultipleChoiceField'
]:
self.fields[field].widget = widgets.ChosenSelect(
choices=self.fields[field].choices)
elif self.fields[field].__class__.__name__ in 'ModelChoiceField':
self.fields[field].widget = RelatedFieldWidgetWrapper(
widgets.ChosenSelect(choices=self.fields[field].choices),
self.instance._meta.get_field(field).rel, self.admin_site)
elif self.fields[
field].__class__.__name__ is 'ModelMultipleChoiceField':
self.fields[field].widget = RelatedFieldWidgetWrapper(
widgets.ChosenSelectMultiple(
choices=self.fields[field].choices),
self.instance._meta.get_field(field).rel, self.admin_site)
elif isinstance(self.fields[field], fields.ChosenAjaxField):
self.fields[field].widget = RelatedFieldWidgetWrapper(
widgets.ChosenAjax(),
self.instance._meta.get_field(field).rel, self.admin_site)
# Set attrs onto the widget so that we can pass it to the view for the queryset.
attrs = {
'data-model':
self.fields[field].queryset.model._meta.module_name,
'data-app':
self.fields[field].queryset.model._meta.app_label,
'data-fields': self.fields[field].search_fields
}
self.fields[field].widget.attrs.update(attrs)
def __init__(self, *args, **kwargs):
super(AttributetypeAdminForm, self).__init__(*args, **kwargs)
prior = ManyToManyRel(Nodetype, 'id')
post = ManyToManyRel(Nodetype, 'id')
self.fields['priornodes'].widget = RelatedFieldWidgetWrapper(
self.fields['priornodes'].widget, prior, self.admin_site)
self.fields['posteriornodes'].widget = RelatedFieldWidgetWrapper(
self.fields['posteriornodes'].widget, post, self.admin_site)
def get_form(self, form_class):
form = super(periodictaskupdate, self).get_form(form_class)
rel_model = form.Meta.model
rel = rel_model._meta.get_field('crontab').rel
irel = rel_model._meta.get_field('interval').rel
form.fields['crontab'].widget = RelatedFieldWidgetWrapper(form.fields['crontab'].widget, rel,
admin.site, can_add_related=True, can_change_related=True)
form.fields['interval'].widget = RelatedFieldWidgetWrapper(form.fields['interval'].widget, irel,
admin.site, can_add_related=True, can_change_related=True)
return form
def __init__(self, *args, **kwargs):
super(ObjecttypeAdminForm, self).__init__(*args, **kwargs)
meta = ManyToManyRel(Metatype, 'id')
prior = ManyToManyRel(Nodetype, 'id')
post = ManyToManyRel(Nodetype, 'id')
self.fields['metatypes'].widget = RelatedFieldWidgetWrapper(
self.fields['metatypes'].widget, meta, self.admin_site)
self.fields['priornodes'].widget = RelatedFieldWidgetWrapper(
self.fields['priornodes'].widget, prior, self.admin_site)
self.fields['posteriornodes'].widget = RelatedFieldWidgetWrapper(
self.fields['posteriornodes'].widget, post, self.admin_site)
self.fields['sites'].initial = [Site.objects.get_current()]
def __init__(self, *args, **kwargs):
super(ResourceEntryAdminForm, self).__init__(*args, **kwargs)
self.fields['topics'].widget = RelatedFieldWidgetWrapper(
self.fields['topics'].widget,
ResourceEntry.topics.field.rel,
self.admin_site)
self.fields['types'].widget = RelatedFieldWidgetWrapper(
self.fields['types'].widget,
ResourceEntry.types.field.rel,
self.admin_site)
self.fields['industries'].widget = RelatedFieldWidgetWrapper(
self.fields['industries'].widget,
ResourceEntry.industries.field.rel,
self.admin_site)
def __init__(self, *args, **kwargs):
super(ProcesstypeAdminForm, self).__init__(*args, **kwargs)
prior = ManyToManyRel(Nodetype, 'id')
post = ManyToManyRel(Nodetype, 'id')
atype = ManyToManyRel(Attributetype, 'id')
rtype = ManyToManyRel(Relationtype, 'id')
self.fields['priornodes'].widget = RelatedFieldWidgetWrapper(
self.fields['priornodes'].widget, prior, self.admin_site)
self.fields['posteriornodes'].widget = RelatedFieldWidgetWrapper(
self.fields['posteriornodes'].widget, post, self.admin_site)
self.fields['attributetype_set'].widget = RelatedFieldWidgetWrapper(
self.fields['attributetype_set'].widget, atype, self.admin_site)
self.fields['relationtype_set'].widget = RelatedFieldWidgetWrapper(
self.fields['relationtype_set'].widget, rtype, self.admin_site)
def __init__(self, *args, **kwargs):
super(PlayerForm, self).__init__(*args, **kwargs)
if self.instance.pk:
#if this is not a new object, we load related games
self.initial['games'] = self.instance.games.values_list('pk', flat=True)
rel = ManyToManyRel(Game)
self.fields['games'].widget = RelatedFieldWidgetWrapper(self.fields['games'].widget, rel, admin.site)
class Meta:
model = Subvencion
fields = '__all__'
widgets = {
'inicio':
forms.DateInput(format='%Y-%m-%d', attrs={'type': 'date'}),
'fin':
forms.DateInput(format='%Y-%m-%d', attrs={'type': 'date'}),
'diputacion':
RelatedFieldWidgetWrapper(
Subvencion._meta.get_field('diputacion').formfield().widget,
Subvencion._meta.get_field('diputacion').rel,
my_admin_site,
can_add_related=True),
'generalitat':
RelatedFieldWidgetWrapper(
Subvencion._meta.get_field('generalitat').formfield().widget,
Subvencion._meta.get_field('generalitat').rel,
my_admin_site,
can_add_related=True),
'gobierno':
RelatedFieldWidgetWrapper(
Subvencion._meta.get_field('gobierno').formfield().widget,
Subvencion._meta.get_field('gobierno').rel,
my_admin_site,
can_add_related=True),
'estado':
RelatedFieldWidgetWrapper(
Subvencion._meta.get_field('estado').formfield().widget,
Subvencion._meta.get_field('estado').rel,
my_admin_site,
can_add_related=True),
'responsable':
RelatedFieldWidgetWrapper(
Subvencion._meta.get_field('responsable').formfield().widget,
Subvencion._meta.get_field('responsable').rel,
my_admin_site,
can_add_related=True),
'se_relaciona_con':
forms.CheckboxSelectMultiple(),
'responsable':
forms.CheckboxSelectMultiple(),
'colectivo':
forms.CheckboxSelectMultiple(),
}
exclude = ('slug', 'users_like', 'user')
def __init__(self, *args, **kwargs):
super(GbobjectAdminForm, self).__init__(*args, **kwargs)
rel = ManyToManyRel(Objecttype, 'id')
self.fields['objecttypes'].widget = RelatedFieldWidgetWrapper(
self.fields['objecttypes'].widget, rel, self.admin_site)
self.fields['sites'].initial = [Site.objects.get_current()]
def add_related_field_wrapper(form, col_name):
rel_model = form.Meta.model
rel = rel_model._meta.get_field(col_name).rel
form.fields[col_name].widget = RelatedFieldWidgetWrapper(
form.fields[col_name].widget,
rel,
admin.site,
can_add_related=True,
can_change_related=True)
def __init__(self, *args, **kwargs):
super(CategoryAdminForm, self).__init__(*args, **kwargs)
import django
if django.VERSION >= (1, 6, 0):
rel = ManyToOneRel(None, Category, 'id')
else:
rel = ManyToOneRel(Category, 'id')
self.fields['parent'].widget = RelatedFieldWidgetWrapper(
self.fields['parent'].widget, rel, self.admin_site)
def __init__(self, *args, **kwargs):
self.admin_site = kwargs.pop('admin_site', None)
super(StyleForm, self).__init__(*args, **kwargs)
self.fields['styleclasses'].widget = RelatedFieldWidgetWrapper(
FilteredSelectMultiple('Classes', True),
Style._meta.get_field('styleclasses').rel,
self.admin_site,
can_change_related=True)
self.fields['styleclasses'].queryset = StyleClass.objects.all()
class BookForm(forms.ModelForm):
author = Book._meta.get_field('author').formfield(
widget=RelatedFieldWidgetWrapper(Book._meta.get_field(
'author').formfield().widget,
Book._meta.get_field('author').rel,
booksite,
can_add_related=True))
class Meta:
model = Book
def wrap_with_related_field_widget(self, field, widget=ModelChoiceField, can_change_related=True):
return widget(
required=self.fields[field].required,
queryset=self.fields[field].queryset,
widget=RelatedFieldWidgetWrapper(
self.fields[field].widget,
self._meta.model._meta.get_field(field).remote_field,
self.admin_site,
can_change_related=can_change_related
)
)
def __init__(self, *args, **kwargs):
super(ContactForm, self).__init__(*args, **kwargs)
location_rel = Contact._meta.get_field_by_name('location')[0].rel
medium_rel = Contact._meta.get_field_by_name(
'contact_medium')[0].rel
self.fields['location'].widget = AutoComboboxSelectEditWidget(
location_rel, admin_site, LocationLookup)
if pks is not None:
self.fields['location'].widget.update_query_parameters(
{'pks': ','.join(map(str, pks))})
self.fields['location'].widget.choices = None
self.fields['location'].widget = RelatedFieldWidgetWrapper(
self.fields['location'].widget,
location_rel,
admin_site,
can_add_related=False)
self.fields['contact_medium'].widget = RelatedFieldWidgetWrapper(
self.fields['contact_medium'].widget,
medium_rel,
admin_site,
can_add_related=False)
def __init__(self, *args, **kwargs):
super(SeriesAdminForm, self).__init__(*args, **kwargs)
# Series have registration enabled by default
self.fields['status'].initial = Event.RegStatus.enabled
# Locations are required for Series even though they are not for all events.
self.fields['location'].required = True
# Allow adding additional rooms from a popup on Location, but not a popup on Room
self.fields['room'].widget.can_add_related = False
self.fields['room'].widget.can_change_related = False
self.fields['classDescription'] = ModelChoiceField(
queryset=ClassDescription.objects.all(),
widget=RelatedFieldWidgetWrapper(
autocomplete.ModelSelect2(
url='autocompleteClassDescription',
attrs={
# This will set the input placeholder attribute:
'data-placeholder':
_('Enter an existing class series title or description'
),
# This will set the yourlabs.Autocomplete.minimumCharacters
# options, the naming conversion is handled by jQuery
'data-minimum-input-length':
2,
'data-max-results':
10,
'class':
'modern-style',
},
),
rel=Series._meta.get_field('classDescription').remote_field,
admin_site=self.admin_site,
can_add_related=True,
can_change_related=True,
))
# Impose restrictions on new records, but not on existing ones.
if not kwargs.get('instance', None):
# Filter out former locations for new records
self.fields['location'].queryset = Location.objects.exclude(
status=Location.StatusChoices.former)
# Filter out Pricing Tiers that are expired (i.e. no longer in use)
self.fields['pricingTier'].queryset = PricingTier.objects.filter(
expired=False)
# Set initial values for capacity here because they will automatically update if the
# constant is changed. Through Javascript, this should also change when the Location is changed.
self.fields['capacity'].initial = getConstant(
name='registration__defaultEventCapacity')
def __init__(self, *args, **kwargs):
super(CategoryAdminForm, self).__init__(*args, **kwargs)
if is_before_1_6:
rel = ManyToOneRel(Category, 'id')
else:
#This may or may not be the correct fix.
#This really ought to be thrown out and replaced with something
#actually a part of the API.
rel = ManyToOneRel(Category._meta.get_field('tree_id'), Category,
'id')
self.fields['parent'].widget = RelatedFieldWidgetWrapper(
self.fields['parent'].widget, rel, self.admin_site)
def get_category_widget(formfield, user):
dbfield = AliasModel._meta.get_field('category')
return RelatedFieldWidgetWrapper(
formfield.widget,
dbfield.remote_field,
admin_site=admin.site,
can_add_related=user.has_perm(
get_model_permission_codename(Category, 'add'), ),
can_change_related=user.has_perm(
get_model_permission_codename(Category, 'change'), ),
can_delete_related=user.has_perm(
get_model_permission_codename(Category, 'delete'), ),
)
class AddClassRoomForm(forms.ModelForm):
room_number = forms.CharField(widget=forms.TextInput(
attrs={'class': 'form-control'}))
section = forms.CharField(widget=forms.TextInput(
attrs={'class': 'form-control'}))
student_capacity = forms.IntegerField(
widget=forms.NumberInput(attrs={'class': 'form-control'}), min_value=0)
level = ClassRoom._meta.get_field('level').formfield(
widget=RelatedFieldWidgetWrapper(
ClassRoom._meta.get_field('level').formfield().widget,
ClassRoom._meta.get_field('level').remote_field,
campus_admin_site,
can_add_related=True,
))
incharge = ClassRoom._meta.get_field('incharge').formfield(
widget=RelatedFieldWidgetWrapper(
ClassRoom._meta.get_field('incharge').formfield().widget,
ClassRoom._meta.get_field('incharge').remote_field,
campus_admin_site,
can_add_related=True,
))
def __init__(self, *args, **kwargs):
super(AddClassRoomForm, self).__init__(*args, **kwargs)
self.fields['level'].widget.attrs.update({'class': 'custom-select-sm'})
self.fields['incharge'].widget.attrs.update(
{'class': 'custom-select-sm'})
class Meta:
model = ClassRoom
fields = '__all__'
def clean_room_number(self):
room_number = self.cleaned_data.get('room_number')
qs = ClassRoom.objects.filter(room_number=room_number)
if qs.exists():
raise forms.ValidationError('Room ' + str(room_number) +
' is taken')
return room_number
def set_category_widget(self, request):
related_modeladmin = admin.site._registry.get(Category)
dbfield = ModulePlugin._meta.get_field('module_category')
formfield = self.fields['category']
formfield.widget = RelatedFieldWidgetWrapper(
formfield.widget,
dbfield.rel if hasattr(dbfield, 'rel') else dbfield.remote_field,
admin_site=admin.site,
can_add_related=related_modeladmin.has_add_permission(request),
can_change_related=related_modeladmin.has_change_permission(
request),
can_delete_related=related_modeladmin.has_delete_permission(
request),
)
def get_form(self, form_class=None):
form = super(DynamicFormUpdate, self).get_form(form_class)
rel_model = form.Meta.model
#Automaticlly handle ForeignKey
for field in rel_model._meta.get_fields():
if isinstance(rel_model._meta.get_field(field.name),
models.ForeignKey):
rel = field.rel
form.fields[field.name].widget = RelatedFieldWidgetWrapper(
form.fields[field.name].widget,
rel,
admin.site,
can_add_related=True,
can_change_related=True)
return form
def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
initial=None, error_class=ErrorList, label_suffix=':',
empty_permitted=False, instance=None):
super(EquipamentoAdminForm, self).__init__(data, files, auto_id, prefix, initial,
error_class, label_suffix, empty_permitted, instance)
# Configurando a relação entre Equipamento e Entidade para aparecer o botão de +
# O self.admin_site foi declarado no admin.py
if django.VERSION[0:2] >= (1, 6):
rel = ManyToOneRel(field=Equipamento._meta.get_field('entidade_fabricante'), to=Entidade, field_name='id') # @UndefinedVariable
else:
rel = ManyToOneRel(Entidade, 'id')
self.fields['entidade_fabricante'].widget = RelatedFieldWidgetWrapper(self.fields['entidade_fabricante'].widget,
rel, self.admin_site)
def __init__(self, *args, **kwargs):
super(RoleForm, self).__init__(*args, **kwargs)
if self.instance.pk is None:
unassigned_users = models.Role.objects.filter(user_id__isnull=False).values_list('user_id', flat=True)
self.fields['user'].queryset = User.objects.exclude(id__in=unassigned_users)
# noinspection PyProtectedMember
relation = ManyToOneRel(User._meta.get_field('id'), User, 'id')
self.fields['user'].widget = RelatedFieldWidgetWrapper(self.fields['user'].widget, relation, admin.site)
self.fields['user_selected'].widget = forms.HiddenInput()
else:
self.fields['user'].widget = forms.HiddenInput()
self.fields['user_selected'].initial = self.instance.user.username
self.fields['first_name'].initial = self.instance.user.first_name
self.fields['last_name'].initial = self.instance.user.last_name
self.fields['email'].initial = self.instance.user.email
self.fields['is_active'].initial = self.instance.user.is_active
def formfield_for_dbfield(self, db_field, *args, **kwargs):
"""
Remove popup add/edit/delete icons by default for relation fields.
"""
if db_field.is_relation:
rel = db_field.related_model
wrapped_widget = RelatedFieldWidgetWrapper(
db_field.formfield().widget,
rel,
admin.site,
can_add_related=False,
can_change_related=False,
can_delete_related=False)
db_field.formfield().widget = wrapped_widget
return db_field.formfield()
return super(OrderItemInline,
self).formfield_for_dbfield(db_field, **kwargs)
def get(self, request, fsmmodel, pk=None):
print("============= Armar el get fsm model!!", fsmmodel, pk)
model = getattr(models, fsmmodel)
if pk is None:
instance_form = None
current_state = None
else:
instance = model.objects.get(pk=pk)
current_state = instance.state
form_class = model_forms.modelform_factory(model, fields='__all__')
instance_form = form_class(instance=instance)
for field_value in instance_form.fields.values():
field_value.widget.attrs['disabled'] = True
# hack
for field_name, field_value in instance_form.fields.items():
print("=========== revisando", field_name, type(field_name))
if field_name == 'invoice': # FIXME: horrible hack
print("============= always new!!!")
from core.models import Income
from core.admin import admin
rel = OneToOneRel(Income.invoice, 'id', 'invoice')
instance_form.fields[
field_name] = RelatedFieldWidgetWrapper(
field_value.widget, rel, admin.admin_site)
steps = model.get_steps(current_state,
request.user.profile.security_clearance)
context = {'instance_form': instance_form}
context['forms'] = []
for step in steps:
form_class = model_forms.modelform_factory(model,
fields=step.fields)
form = form_class()
print("====== form fields", form)
#for field in form.fields:
# field['required'] = True
context['forms'].append(form)
if pk is None:
template = 'core/createform.html'
else:
template = 'core/updateform.html'
return render(request, template, context=context)
def get_form(self, form_class=None):
form = super(DynamicFormCreate, self).get_form(form_class)
rel_model = form.Meta.model
#Automaticlly handle ForeignKey
for field in rel_model._meta.get_fields():
if isinstance(rel_model._meta.get_field(field.name),
models.ForeignKey):
rel = field.rel
form.fields[field.name].widget = RelatedFieldWidgetWrapper(
form.fields[field.name].widget,
rel,
admin.site,
can_add_related=True,
can_change_related=True)
elif isinstance(rel_model._meta.get_field(field.name),
models.GenericIPAddressField):
form.fields[field.name].widget = forms.TextInput(
attrs={"data-inputmask": "'alias': 'ip'"})
return form
def get(self, request, *args, **kwargs):
self._validate_args(request, *args)
tags = Tag.objects.all().values_list('id', 'tag')
tags_list = SelectMultiple(choices=tags)
voter_opts = Voter._meta
tag_field = voter_opts.many_to_many[0]
model_admin = site._registry[Voter]
admin_tags_list = RelatedFieldWidgetWrapper(tags_list,
tag_field.remote_field,
site, True, False, False)
media = model_admin.media
kwargs['media'] = media
kwargs['tags_related'] = admin_tags_list.render('tags',
None,
attrs={
'id': 'id_tags',
})
return super().get(request, *args, **kwargs)
class StudentProfileForm(ProfileForm):
guardian = Student._meta.get_field('guardian').formfield(
widget=RelatedFieldWidgetWrapper(
Student._meta.get_field('guardian').formfield().widget,
Student._meta.get_field('guardian').remote_field,
accounts_admin_site,
can_add_related=True,
))
def __init__(self, *args, **kwargs):
super(StudentProfileForm, self).__init__(*args, **kwargs)
self.fields['guardian'].widget.attrs.update(
{'class': 'custom-select-sm'})
class Meta:
model = Student
exclude = [
'user', 'guardian', 'salary', 'date_left', 'contact_number',
'status', 'reg_number', 'roll_number'
]
def __init__(self, *args, **kwargs):
super(One2ManyModelForm, self).__init__(*args, **kwargs)
admin_site = getattr(self, 'admin_site', admin.site)
for field in self.related_one2manyfields:
related_model = field.related_model
related_name = field.name
fake_manytoone_rel = ManyToOneRel(field, related_model,
related_model._meta.pk.name)
try:
self.fields[related_name].initial = getattr(
self.instance, related_name, None)
except Exception:
pass
self.fields[related_name].widget = RelatedFieldWidgetWrapper(
self.fields[related_name].widget,
fake_manytoone_rel,
admin_site,
can_change_related=True)
def __init__(self, *args, **kwargs):
super(MetatypeAdminForm, self).__init__(*args, **kwargs)
rel = ManyToOneRel(Metatype, 'id')
self.fields['parent'].widget = RelatedFieldWidgetWrapper(
self.fields['parent'].widget, rel, self.admin_site)
