Est-il possible d'utiliser create_object view pour créer un nouvel objet et automatiquement asign request.user en tant que clé étrangère?Définition du propriétaire de l'objet avec la vue générique create_object dans django
P.E:
class Post(models.Model):
text = models.TextField()
author = models.ForeignKey(User)
Ce que je veux est d'utiliser create_object et remplir auteur request.user.
À bien des égards, toutes les solutions à ce problème seront plus que ce qu'ils valent. Celui-ci se qualifie comme un hack. Il est possible qu'une mise à jour de django vous laisse haut et sec s'ils changent la façon dont create_update est implémenté. Par souci de simplicité, je vais supposer que vous essayez de définir un utilisateur par défaut, ne forcez pas en silence l'utilisateur à être l'utilisateur connecté.
Ecrire un processeur de contexte:
from django.views.generic.create_update import get_model_and_form_class
def form_user_default(request):
if request.method == 'GET':
model, custom_form = get_model_and_form_class(Post,None)
custom_form.author = request.user
return {'form':custom_form}
else: return {}
Qu'est-ce que cela va faire est passer outre l'objet de formulaire qui create_update passe au modèle. Ce qu'il fait techniquement est de recréer le formulaire après que la vue par défaut l'ait fait.
Ensuite, dans votre url conf:
url(r'pattern_to_match', 'django.views.generic.create_update.create_object', kwargs={'context_processors':form_user_default})
Encore une fois, je devais plonger dans le code source pour savoir comment faire. Il peut être préférable d'essayer d'écrire votre propre vue (mais incorporez autant d'objets personnalisés Django que possible). Il n'y a aucun moyen de le faire « par défaut simple », parce que dans les formes de paradigme django sont plus étroitement liés à la couche de modèle que de vues et vues seulement avoir une connaissance de l'objet de la demande.
Si un utilisateur est authentifié, son objet utilisateur est l'objet request.user.
Je ne suis pas familier avec create_object ... Je suis toujours un débutant pour django et je viens de commencer mon premier vrai projet avec.
Notez que vous devez vérifier que l'utilisateur est connecté avant de l'utiliser. Cela peut être fait avec request.user.is_authenticated().
Il n'y a pas de bonne façon de connecter le enregistrement d'un objet en utilisant les vues génériques actuelles de Django. Une fois qu'ils sont rewritten as classes, vous serez en mesure de sous-classer la vue et de se connecter à l'endroit approprié sans avoir à réécrire l'ensemble de la vue.
J'utilise déjà mes propres vues génériques basées sur les classes pour cette raison.
Je suggère de faire une enveloppe pour le create_object, comme cet auteur suggère http://www.b-list.org/weblog/2006/nov/16/django-tips-get-most-out-generic-views/ dans la vue que vous aurez accès à l'information de l'utilisateur. Ensuite, vous devrez utiliser le paramètre extra_context pour transmettre l'utilisateur au modèle. Enfin, au modèle, vous pouvez ajouter un champ caché avec les informations de l'utilisateur. Je ne l'ai pas essayé, mais j'y pense depuis pas mal de temps. J'espère que cette solution vous convient! ;) à la vôtre!
Vous pouvez envisager une fermeture.
from django.forms import ModelForm
from django.views.generic.create_update import create_object, update_object
def make_foo_form(request):
class FooForm(ModelForm):
class Meta:
model = Foo
fields = ['foo', 'bar']
def save(self, commit=True):
f = super(FooForm, self).save(commit=False)
if not f.pk: f.user = request.user
if commit: f.save()
return f
return FooForm
def create_foo(request):
FooForm = make_foo_form(request)
return create_object(form_class=FooForm)
Il y a une certaine inefficacité ici, puisque vous devez créer l'objet ModelForm sur chaque demande, mais il ne vous permet d'injecter la fonctionnalité dans la vue générique.
Vous devez décider si la complexité ajoutée pour la création de formulaire vaut la peine de maintenir la simplicité du côté de la vue.
Un avantage ici, cependant, est que cela fonctionne aussi avec le cas de mise à jour pratiquement sans effort supplémentaire:
def update_foo(request, object_id):
FooForm = make_foo_form(request)
return update_object(form_class=FooForm, object_id=object_id)
De toute évidence, vous pouvez utiliser cette approche pour les cas plus complexes aussi bien.
Je sais (merci quand même))). Ce que j'essaie de faire est d'utiliser une vue générique pour cela, donc je n'ai pas besoin d'écrire le code pour enregistrer le nouvel objet. Le code de Django est minutieusement testé, donc, quand c'est possible, je préfère l'utiliser à la place de mon propre code. –