Problems with form data in CreateView view - Django

I'm the one who inspired you to delve deeper into this question hehe, I already found a solution that seems to be more verbose that works for me:

class ReservaCreate(CreateView):
    model = Reserva
    fields = ['cliente']
    success_url = reverse_lazy('home')

    def form_valid(self, form):
        reserva = form.save(commit=False)
        reserva.empleado_de_turno = self.request.user
        reserva.save()
        return redirect(self.success_url)

big greeting!!

@Marcelo says the following in his answer (thanks to him I was able to find the answer):

Trying to replicate your problem I arrived at this method (referring to the method get_form_kwargs), it only accepts the fields that you declare in the view, this case will only be client:

(which is not true, the "that does not accept the fields" is the form, not the method or the view).

What caught my attention was that it said "only accept the fields that you declare in the view" as a consequence I began to investigate the source code of the view CreateView, but I did not find anything about what it said, as it had to do with the attribute fields(as I mentioned), then it had to do more with the forms, the case is to investigate the source code of the BaseModelForm.

(It should be noted that if we do not define the attribute form_classin the view, with the form, the method get_form_class, of the view, is responsible for creating it automatically, just passing the attribute fieldsdefined in the view, to the form)

And I found the answer to "Why does the error happen?" , then I will explain in more depth how this happens and why the problem occurs:

Everything starts when the method is executed is_validin the view (specifically in the postview method), said method calls the method Form.full_clean, which in turn calls the following methods (to do the respective validations):

• _clean_fields
• _clean_form
• _post_clean

When the method is called _post_clean, in one part it is responsible for validating the instance, where you can see how it calls Model.full_cleanthe instance method, passing it the fields excluded from the method _get_validation_exclusions:

def _post_clean(self):
    opts = self._meta

    exclude = self._get_validation_exclusions()

    ...

    try:
        self.instance.full_clean(exclude=exclude, validate_unique=False)
    except ValidationError as e:
        self._update_errors(e)

    ...

What does the method do _get_validation_exclusions?

Said method is in charge of collecting the fields that are going to be excluded according to certain validations, adding the names of said fields to a variable called exclude, to later return it.

Here is a code snippet, where it adds the names of the fields that are not in the fieldsform attribute to the variable exclude(this is the specific reason why the instance was not saved):

...
for f in self.instance._meta.fields:
    field = f.name
    # Exclude fields that aren't on the form. The developer may be
    # adding these values to the model after form validation.
    if field not in self.fields:
        exclude.append(f.name)
...

Once Model.full_cleanthe instance method is called, it calls Model.clean_fieldsthe instance method (among others), passing the excluded fields as parameters, in this way the method Model.clean_fieldsonly creates the valid attributes, not the excluded ones :

def clean_fields(self, exclude=None):
    """
    Clean all fields and raise a ValidationError containing a dict
    of all validation errors if any occur.
    """
    if exclude is None:
        exclude = []

    errors = {}
    for f in self._meta.fields:
        if f.name in exclude:
            continue
        # Skip validation for empty fields with blank=True. The developer
        # is responsible for making sure they have a valid value.
        raw_value = getattr(self, f.attname)
        if f.blank and raw_value in f.empty_values:
            continue
        try:
            setattr(self, f.attname, f.clean(raw_value, self)) # <---
        except ValidationError as e:
            errors[f.name] = e.error_list

    ...

And that's it, the method is_validreturns True(but they have already done the respective validations), and proceed to create the instance in the method ModelForm.save:

def save(self, commit=True):
    ...
    if commit:
        # If committing, save the instance and the m2m data immediately.
        self.instance.save()
        self._save_m2m()
    else:
        # If not committing, add a method to the form to allow deferred
        # saving of m2m data.
        self.save_m2m = self._save_m2m
    return self.instance

But since the validations were executed, the attribute is not created empleado_de_turno_iddespite having added it in the POST data and as a consequence the error occurs, preventing the creation of the instance when form_validthe view method tries to create it.

Trying to replicate your problem I came to this method, it only accepts the fields that you declare in the view, this case will only be client:

def get_form_kwargs(self):
    """Return the keyword arguments for instantiating the form."""
    kwargs = super().get_form_kwargs()
    if hasattr(self, 'object'):
        kwargs.update({'instance': self.object})
    return kwargs

You can verify this with this:

class ReservaCreateView(CreateView):
    model = Reserva
    template_name = 'reservas/create.html'
    fields = ['cliente']

    def get_form_kwargs(self):
        form_kwargs = super().get_form_kwargs()
        if form_kwargs.get('data'):
            user = User.objects.get(username=self.request.user)
            form_kwargs['empleado_de_turno'] = str(user.pk)
        return form_kwargs

    def form_valid(self, form):
        print(form.data)
        print(form.cleaned_data)
        return super().form_valid(form)

You will get the following error:

TypeError: __init__() got an unexpected keyword argument 'empleado_de_turno'

When you use:

def get_form_kwargs(self):
    form_kwargs = super().get_form_kwargs()
    if form_kwargs.get('data'):
        user = User.objects.get(username = self.request.user)
        post = self.request.POST.copy()
        post['empleado_de_turno'] = str(user.pk)
        form_kwargs['data'] = post
    return form_kwargs

This method simply overrides form_kwargsand ignores empleado_de_turno, the same thing happens in form_validthat it will only validate what you declared in fields.

That's why I recommend you use what the documentation points out :

class ReservaCreate(CreateView):
    model = Reserva
    fields = ['cliente']
    success_url = reverse_lazy('home')

    def form_valid(self, form):
        form.instance.empleado_de_turno = self.request.user
        return super().form_valid(form)