Use self in ModelForm fields - django

I have a Formview and pass the pk to the ModelForm. In the ModelForm i am not able to use self.pk in the queryset i define for the field:
views.py
[...]
def get_form_kwargs(self):
# Pass extra kwargs to DetailProductForm
kwargs = super(DetailProduct, self).get_form_kwargs()
kwargs.update({'pk': self.kwargs['pk']})
return kwargs
forms.py
class DetailProductForm(forms.ModelForm):
def __init__(self, *args, **kwargs):
# get the pk from the FormView at set it as self.pk
self.pk = kwargs.pop('pk', None)
super(DetailProductForm, self).__init__(*args, **kwargs)
# use self.pk in my queryset (there are more fields who use self.pk, this is just one as an example)
field = forms.ModelChoiceField(queryset=Configuration.objects.filter(product__pk=self.pk), widget=forms.RadioSelect)
class Meta:
model = Configuration
fields = ['field']
NameError: name 'self' is not defined
How can i use self.pk for the fields?

Found a solution. I actually do not even need a ModelForm anymore.
class DetailProductForm(forms.Form):
field = forms.ModelChoiceField(queryset=None, widget=forms.RadioSelect)
def __init__(self, *args, **kwargs):
self.pk = kwargs.pop('pk', None)
super().__init__(*args, **kwargs)
self.fields['field'].queryset = Configuration.objects.filter(product__pk=self.pk))

Related

Django: Passing url slugs to formset queryset

I am trying to change the queryset of my formset with this 'alternative approach':
Alternatively, you can create a subclass that sets self.queryset in
init:
from django.forms import BaseModelFormSet from myapp.models import Author
class BaseAuthorFormSet(BaseModelFormSet):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = Author.objects.filter(name__startswith='O')
Now my problem is, that I have to pass variables into this queryset. Therefore I tried to adjust BaseAuthorFormSet in my forms.py like that:
class BaseAssignAttendeeFormSet(BaseModelFormSet):
def __init__(self, order_reference, access_key, *args, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = Attendee.objects.filter(
order__order_reference=order_reference,
order__access_key=access_key,
)
My function-based-view in views.py starts like that: def assign_attendee(request, order_reference, access_key): order_reference and access_key are slugs that come from the url.
Anyone knows the way to pass these two to my queryset?
You can pass arguments during formset initializing in the view:
MyFormSet = modelformset_factory(MyModel, fields=('name', 'title'), formset=BaseAssignAttendeeFormSet)
formset = MyFormSet(order_reference, access_key, #Other orguments here)
In formset you need to call superclass's __init__ method:
class BaseAssignAttendeeFormSet(BaseModelFormSet):
def __init__(self, order_reference, access_key, *args, **kwargs):
super().__init__(*args, **kwargs)
self.queryset = Attendee.objects.filter(
order__order_reference=order_reference,
order__access_key=access_key,
)

How do I filter values in Django CreateView, UpdateView

I am trying to use CreateView and UpdateView to modify records. My problem is that the ForeignKey dropdown lists values (Psa.number) for all companies instead only those of the company to which the user belongs.
class Psa(models.Model):
owner = models.ForeignKey(Employer)
number = models.PositiveIntegerField(unique=True...
type = models.CharField(max_length=6 ...
class Employer(models.Model):
employer_name = models.CharField(max_length=100, unique=True)
The form:
class PsaCreateForm(forms.ModelForm):
class Meta:
model = Psa
fields = [
'number',
'type',
]
What is the best way to solve this? I've got several other conditions that use the same company foreignkey relationship so is there a way to create a method on the model that I can reuse?
You need get_form_kwargs(self) in CreateView and UpdateView:
forms.py:
class PsaCreateForm(forms.ModelForm):
model = Psa
fields = [
'number',
'type',
]
def __init__(self, *args, **kwargs):
self.current_user = kwargs.pop('user')
super(PsaCreateForm, self).__init__(*args, **kwargs)
if self.current_user:
self.fields['number'].queryset = Psa.objects.filter(owner=self.current_user)
views.py
class PsaCreate(CreateView):
model = Psa
template_name = 'form.html'
form_class = PsaCreateFrom
def get_form_kwargs(self):
kwargs = super(PsaCreate, self).get_form_kwargs()
kwargs['user'] = self.request.user
return kwargs
Also a good idea. Set def dispatch(self, request, *args, **kwargs): in your Views.
def dispatch(self, request, *args, **kwargs):
obj = self.get_object()
if obj.owner != self.request.user:
return HttpResponseRedirect(reverse('home'))
return super(PsaUpdate, self).dispatch(request, *args, **kwargs)

Django querystring/slug inside of formclass

Is it possibe to get the id slug inside of the get_form_class? Any advice?
class Create(Merchant_Services_Editor_Mixin, CreateView):
template_name = 'secure/shared/editor.html'
def get_form_class(self):
if (self.request.GET.get("id") == 1):
return _Merchant_Services_Form.StripeEditor
else:
return _Merchant_Services_Form.BraintreeEditor
You can pass your id slug to your form using get_form_kwargs:
class MyView(CreateView):
def get_form_kwargs(self, **kwargs):
kwargs = super(MyView, self).get_form_kwargs(**kwargs)
kwargs['id'] = self.request.GET.get('id')
return kwargs
Then you'll have to update your form class to handle this new parameter. You can retrieve it from kwargs:
class MyForm(forms.Form):
def __init__(self, *args, **kwargs):
self.id = kwargs.pop('id', None)
super(MyForm, self).__init__(*args, **kwargs)

django: how to access current request user in ModelForm?

In my implementation of ModelForm, I would like to perform different types of validation checks based on whether current user is superuser. How can I access the current request user?
If you're using Class Based Views (CBVs) then passing an extra argument in the form constructor (e.g. in get_forms_class) or in form_class will not work, as <form> object is not callable will be shown.
The solution for CBVs is to use get_form_kwargs(), e.g.:
views.py:
class MyUpdateView(UpdateView):
model = MyModel
form_class = MyForm
# Sending user object to the form, to verify which fields to display/remove (depending on group)
def get_form_kwargs(self):
kwargs = super(MyUpdateView, self).get_form_kwargs()
kwargs.update({'user': self.request.user})
return kwargs
forms.py:
class MyForm(forms.ModelForm):
def __init__(self, *args, **kwargs):
self.user = kwargs.pop('user') # To get request.user. Do not use kwargs.pop('user', None) due to potential security hole
super(MyForm, self).__init__(*args, **kwargs)
# If the user does not belong to a certain group, remove the field
if not self.user.groups.filter(name__iexact='mygroup').exists():
del self.fields['confidential']
you can pass the user object as an extra argument in the form constructor.
e.g.
f = MyForm(user=request.user)
and the constructor will look like:
class MyForm(forms.ModelForm):
def __init__(self, *args, **kwargs):
self.user = kwargs.pop('user',None)
super(MyForm, self).__init__(*args, **kwargs)
and then use user in the clean_XX forms as you wish
My small addition,
I had a requirement where one of the model choice fields of the form is dependent on the request.user, and it took a while to take my head around.
The idea is that
you need to have a __init__ method in the model form class,
and you access the request or other parameters from the arguments of the __init__ method,
then you need to call the super constructor to new up the form class
and then you set the queryset of the required field
code sample
class CsvUploadForm(forms.Form):
def __init__(self, *args, **kwargs):
user = kwargs.pop('user')
super(CsvUploadForm, self).__init__(*args, **kwargs)
self.fields['lists'].queryset = List.objects.filter(user=user)
lists = forms.ModelChoiceField(queryset=None, widget=forms.Select, required=True)
as you can see, the lists variable is dependent on the current user, which is available via request object, so we set the queryset of the field as null, and its assigned dynamically from the constructor later.
Take a look into the order of the statements in the above code
you can pass the user variable like this from the view file
form = CsvUploadForm(user=request.user)
or with other POST, FILE data like below
form = CsvUploadForm(request.POST, request.FILES, user=request.user)
You may reference the user object using the instance attribute within the instance it self.
Ex; self.instance.user
class StatusForm(ModelForm):
# def __init__(self, *args, **kwargs):
# self.user = kwargs.pop('user', None)
# super(StatusForm, self).__init__(*args, **kwargs)
class Meta:
model = Status
fields = [
'user',
'content',
'image'
]
def clean_content(self):
content = self.cleaned_data.get("content", None)
if len(content) > 240:
raise ValidationError(f"Hey {self.instance.user.username}, the content is too long")
return content
This worked for me, when I am not sending form in context explicitly in get_context_data:
views.py
class MyView(FormView):
model = MyModel
form_class = MyForm
def get_form_kwargs(self):
kwargs = super(MyView, self).get_form_kwargs()
kwargs.update({'user': self.request.user})
return kwargs
form.py
class MyForm(forms.ModelForm):
def __init__(self, *args, **kwargs):
self.user = kwargs.pop('user')
super(MyForm, self).__init__(*args, **kwargs)
if not self.user.groups.filter(name__iexact='t1_group').exists():
del self.fields['test_obj']
When sending form explicitly in get_context_data we can use and this is forms.Form :
views.py
class MyView(FormView):
model = MyModel
form_class = MyForm
def get_context_data(self, **kwargs):
context = super(MyView, self).get_context_data(**kwargs)
context['form'] = self.form_class(self.request.user)
return context
forms.py
class MyForm(forms.Form):
def __init__(self, user,*args, **kwargs):
super(MyForm, self).__init__(*args, **kwargs)
if not user.groups.filter(name__iexact='t1_group').exists():
del self.fields['test_obj']

User current user on new Django class views forms

I am using the django 1.3 on trunk, and start learning about class views.
I had this:
class Project(models.Model):
title = models.CharField(max_length=90)
slug = models.CharField(max_length=90)
description = models.TextField()
owner = models.ForeignKey(User)
class ProjectForm(ModelForm):
class Meta:
model = Project
exclude = ('owner',)
widgets = {
'description': Textarea(attrs={'cols': 40, 'rows': 20}),
}
class ProjectCreateView(CreateView):
model = Project
form_class = ProjectForm
def get(self, request, *args, **kwargs):
return super(ProjectCreateView, self).get(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
return super(ProjectCreateView, self).post(request, *args, **kwargs)
I am trying, to get a form using model forms from django excluding the owner field, to get the field value after with the request.user property.
The form as it is, works. But how can make sure the ModelForm use request.user for the Project.owner field?
My first guess, was to override get_form_kwargs method from the view
class ProjectCreateView(CreateView):
# .....
def get_form_kwargs(self, **kwargs):
self.initial['owner': self.request.user})
kwargs = super(ProjectCreateView, self).get_form_kwargs(**kwargs)
return kwargs
But seem to have no effect on the data used by the model form
get_form_kwargs is supposed to return a dict of arguments for your form - you set self.initial, but you didn't attach it to kwargs:
def get_form_kwargs(self, **kwargs):
kwargs = super(ProjectCreateView, self).get_form_kwargs(**kwargs)
kwargs['initial']['owner'] = self.request.user
return kwargs