def get_formset(self):
_widgets = {}
for f in self.model_to_add._meta.fields:
foreign_model = self.model_to_add._meta.get_field(
f.name).related_model
if foreign_model and issubclass(foreign_model, _concept):
_widgets.update({
f.name:
widgets.ConceptAutocompleteSelect(model=foreign_model)
})
for f in self.model_to_add._meta.many_to_many:
foreign_model = self.model_to_add._meta.get_field(
f.name).related_model
if foreign_model and issubclass(foreign_model, _concept):
_widgets.update({
f.name:
widgets.ConceptAutocompleteSelectMultiple(
model=foreign_model)
})
from aristotle_mdr.contrib.generic.forms import HiddenOrderModelFormSet
return modelformset_factory(
self.model_to_add,
formset=HiddenOrderModelFormSet,
can_order=True, # we assign this back to the ordering field
can_delete=True,
exclude=[self.model_to_add_field, self.ordering_field],
# fields='__all__',
extra=1,
widgets=_widgets)
def get_aristotle_widgets(model, ordering_field=None):
_widgets = {}
for f in model._meta.fields:
foreign_model = model._meta.get_field(f.name).related_model
if foreign_model and issubclass(foreign_model, _concept):
_widgets.update({
f.name: widgets.ConceptAutocompleteSelect(
model=foreign_model
)
})
if isinstance(model._meta.get_field(f.name), DateField):
_widgets.update({
f.name: BootstrapDateTimePicker(options=datePickerOptions)
})
if ordering_field is not None and f.name == ordering_field:
_widgets.update({
ordering_field: forms.HiddenInput()
})
for f in model._meta.many_to_many:
foreign_model = model._meta.get_field(f.name).related_model
if foreign_model and issubclass(foreign_model, _concept):
_widgets.update({
f.name: widgets.ConceptAutocompleteSelectMultiple(
model=foreign_model
)
})
return _widgets
class M2MForm(forms.Form):
items_to_add = forms.ModelMultipleChoiceField(
queryset=self.model_to_add.objects.visible(self.request.user),
label="Attach",
required=False,
widget=widgets.ConceptAutocompleteSelectMultiple(
model=self.model_to_add))
class DeprecateForm(forms.Form):
olderItems = forms.ModelMultipleChoiceField(
queryset=MDR._concept.objects.all(),
label="Supersede older items",
required=False,
widget=widgets.ConceptAutocompleteSelectMultiple())
def __init__(self, *args, **kwargs):
self.item = kwargs.pop('item')
self.qs = kwargs.pop('qs')
self.user = kwargs.pop('user')
super(DeprecateForm, self).__init__(*args, **kwargs)
self.fields['olderItems'] = forms.ModelMultipleChoiceField(
queryset=self.qs,
label=_("Supersede older items"),
required=False,
initial=self.item.supersedes.all(),
widget=widgets.ConceptAutocompleteSelectMultiple(
model=self.item._meta.model))
def clean_olderItems(self):
olderItems = self.cleaned_data['olderItems']
if self.item in olderItems:
raise forms.ValidationError("An item may not supersede itself")
for i in olderItems:
if not user_can_edit(self.user, i):
raise forms.ValidationError(
"You cannot supersede an item that you do not have permission to edit"
)
return olderItems
def get_aristotle_widgets(model, ordering_field=None):
_widgets = {}
for f in model._meta.fields:
foreign_model = model._meta.get_field(f.name).related_model
widget = None
if foreign_model and issubclass(foreign_model, _concept):
widget = widgets.ConceptAutocompleteSelect(
model=foreign_model, attrs={"style": "max-width:250px"})
elif foreign_model:
widget = forms.Select(attrs={"class": "form-control"})
if isinstance(model._meta.get_field(f.name), DateField):
widget = BootstrapDateTimePicker(
options=datePickerOptions, attrs={"style": "min-width:150px"})
if ordering_field is not None and f.name == ordering_field:
widget = forms.HiddenInput()
if widget is not None:
_widgets[f.name] = widget
for f in model._meta.many_to_many:
foreign_model = model._meta.get_field(f.name).related_model
if foreign_model and issubclass(foreign_model, _concept):
_widgets.update({
f.name:
widgets.ConceptAutocompleteSelectMultiple(model=foreign_model)
})
return _widgets
class EditPostForm(forms.ModelForm):
relatedItems = forms.ModelMultipleChoiceField(
queryset=MDR._concept.objects.all(),
label="Related items",
required=False,
widget=widgets.ConceptAutocompleteSelectMultiple())
class Meta:
model = MDR.DiscussionPost
exclude = ['author', 'workgroup', 'closed']
def __init__(self, *args, **kwargs):
self.qs = kwargs.pop('qs')
self.dss = kwargs.pop('dss')
self.user = kwargs.pop('user')
super(AddClustersToDSSForm, self).__init__(*args, **kwargs)
self.fields['clusters'] = forms.ModelMultipleChoiceField(
queryset=self.qs,
label="Add Clusters",
widget=widgets.ConceptAutocompleteSelectMultiple(
model=models.DataSetSpecification))
def __init__(self, *args, **kwargs):
self.qs = kwargs.pop('qs')
self.dss = kwargs.pop('dss')
self.user = kwargs.pop('user')
super(AddDataElementsToDSSForm, self).__init__(*args, **kwargs)
from aristotle_mdr.models import DataElement
self.fields['dataElements'] = forms.ModelMultipleChoiceField(
queryset=self.qs,
label="Add Data Elements",
widget=widgets.ConceptAutocompleteSelectMultiple(
model=DataElement))
def __init__(self, *args, **kwargs):
self.item = kwargs.pop('item')
self.qs = kwargs.pop('qs')
self.user = kwargs.pop('user')
super(DeprecateForm, self).__init__(*args, **kwargs)
self.fields['olderItems'] = forms.ModelMultipleChoiceField(
queryset=self.qs,
label=_("Supersede older items"),
required=False,
initial=self.item.supersedes.all(),
widget=widgets.ConceptAutocompleteSelectMultiple(
model=self.item._meta.model))
class CollectionForm(BootstrapableMixin, UserAwareFormMixin, forms.ModelForm):
metadata = forms.ModelMultipleChoiceField(
queryset=MDR._concept.objects.all(),
label="Included metadata",
required=False,
widget=widgets.ConceptAutocompleteSelectMultiple())
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['metadata'].queryset = MDR._concept.objects.visible(
self.user)
class Meta:
model = Collection
fields = ['name', 'parent_collection', 'description', 'metadata']
def __init__(self, roles, *args, **kwargs):
self.roles = roles
super(LinkEndEditorBase, self).__init__(*args, **kwargs)
for role in self.roles:
if role.multiplicity == 1:
self.fields['role_' + str(role.pk)] = forms.ModelChoiceField(
queryset=MDR._concept.objects.all().visible(self.user),
label=role.name,
widget=widgets.ConceptAutocompleteSelect(model=MDR._concept),
)
else:
self.fields['role_' + str(role.pk)] = forms.ModelMultipleChoiceField(
queryset=MDR._concept.objects.all().visible(self.user),
label=role.name,
widget=widgets.ConceptAutocompleteSelectMultiple(model=MDR._concept),
)
def __init__(self, form, *args, **kwargs):
initial_items = kwargs.pop('items', [])
self.request = kwargs.pop('request')
if 'user' in kwargs.keys():
self.user = kwargs.get('user', None)
queryset = MDR._concept.objects.visible(self.user)
else:
queryset = MDR._concept.objects.public()
super(BulkActionForm, self).__init__(form, *args, **kwargs)
self.fields['items'] = ForbiddenAllowedModelMultipleChoiceField(
label=self.items_label,
validate_queryset=MDR._concept.objects.all(),
queryset=queryset,
initial=initial_items,
required=False,
widget=widgets.ConceptAutocompleteSelectMultiple())
def one_to_many_formset_factory(model_to_add,
model_to_add_field,
ordering_field,
extra_excludes=[]):
# creates a one to many formset
# model_to_add is weak entity class, model_to_add_field is the foriegn key field name
_widgets = {}
exclude_fields = [model_to_add_field, ordering_field]
exclude_fields += extra_excludes
for f in model_to_add._meta.fields:
foreign_model = model_to_add._meta.get_field(f.name).related_model
if foreign_model and issubclass(foreign_model, _concept):
_widgets.update({
f.name:
widgets.ConceptAutocompleteSelect(model=foreign_model)
})
if isinstance(model_to_add._meta.get_field(f.name), DateField):
_widgets.update(
{f.name: BootstrapDateTimePicker(options=datePickerOptions)})
for f in model_to_add._meta.many_to_many:
foreign_model = model_to_add._meta.get_field(f.name).related_model
if foreign_model and issubclass(foreign_model, _concept):
_widgets.update({
f.name:
widgets.ConceptAutocompleteSelectMultiple(model=foreign_model)
})
return modelformset_factory(
model_to_add,
formset=HiddenOrderModelFormSet,
can_order=True, # we assign this back to the ordering field
can_delete=True,
exclude=exclude_fields,
# fields='__all__',
extra=1,
widgets=_widgets)
def __init__(self, form, *args, **kwargs):
self.initial_items = kwargs.pop('items', [])
self.request = kwargs.pop('request')
if 'user' in kwargs.keys():
self.user = kwargs.get('user', None)
queryset = MDR._concept.objects.visible(self.user)
else:
queryset = MDR._concept.objects.public()
if 'data' not in kwargs:
super().__init__(form, *args, **kwargs)
else:
super().__init__(*args, **kwargs)
self.fields['items'] = ForbiddenAllowedModelMultipleChoiceField(
label="Items",
help_text=self.items_help_text,
queryset=queryset,
validate_queryset=MDR._concept.objects.all(),
required=False,
initial=self.initial_items,
widget=widgets.ConceptAutocompleteSelectMultiple())
class NewPostForm(forms.ModelForm):
relatedItems = forms.ModelMultipleChoiceField(
queryset=MDR._concept.objects.all(),
label="Related items",
required=False,
widget=widgets.ConceptAutocompleteSelectMultiple())
class Meta:
model = MDR.DiscussionPost
fields = ['title', 'body', 'workgroup', 'relatedItems']
def __init__(self, *args, **kwargs):
self.user = kwargs.pop('user', None)
super(NewPostForm, self).__init__(*args, **kwargs)
self.fields['workgroup'].queryset = self.user.profile.myWorkgroups
def clean_relatedItems(self):
"""
Attempting to add items you don't have permission to will silently fail.
Its unlikely to happen in normal use.
"""
relatedItems = self.cleaned_data['relatedItems']
relatedItems = [i for i in relatedItems if user_can_view(self.user, i)]
return relatedItems
