La sortie de Django Modèle de Table

J'ai une définition de la vue qui (tente de) sorties d'un modèle sous forme d'un tableau. C'est ce que j'ai à ce jour:

def output_table(request):
    output = My_Model()
    return render_to_response('outputtable.html', {'output': output})

Voici le code HTML outputtable.html:

<html>
<table>
    {{ output.as_table }}
</table>
</html>

Ce que je fais mal? Il ne fonctionne pas. Maintenant, c'est en passant le modèle correctement, parce que si je change My_Model() pour My_Model.objets.tous les() et ensuite de sortie comme {{ sortie }} ensuite, il me montre ce que je vois dans le Django shell.

OriginalL'auteur Reznor | 2010-02-17

2

Donc ce que vous devez faire est le suivant:

1) ajouter

from django.forms import ModelForm à votre models.py

2) ajouter
```
class My_Model_Form(ModelForm):  
           class Meta:  
               model = My_Model 
```
3) dans votre views.py, changement output = My_Model() à output = My_Model_Form()

Maintenant vous êtes tous ensemble. Donc, l'astuce est d'hériter de votre Forme de votre modèle d'origine.

Si vous effectuez le rendu d'un modèle existant exemple, ne output = My_Model_Form(instance=my_model)

OriginalL'auteur DrDee

La models.Model classe ne dispose pas d'une méthode as_table() comme le forms.ModelForm classe.

Ma solution a été d'utiliser des balises de modèle. Je suis allé avec une l'inclusion de la balise.

myapp/templatetags/model_helpers.py

from django import template
register = template.Library()


@register.inclusion_tag('myapp/model_table.html', takes_context=True)
def model_as_table(context, model_key=None, model_table_attrs_key=None):

    if model_key is None:
        model_key = 'object'

    if model_table_attrs_key is None:
        model_table_attrs_key = 'model_table_attrs'

    try:
        attrs = context[model_table_attrs_key]
    except KeyError:
        attrs = context[model_key]._meta.get_all_field_names()

    table_context = {'rows': []}
    for attr in attrs:
        try:
            value = str(getattr(context[model_key], attr))
            if value:
                table_context['rows'].append({'attr': attr,
                                              'value': context[model_key][attr]})
        except AttributeError:
            pass
        # Needs a way to display many_to_many fields.
        except StopIteration:
            pass

    return table_context

myapp/templates/myapp/model_table.html

{% for row in rows %}
    <tr>
        <td class="name">{{ row.attr }}</td>
        <td class="field">{{ row.value }}</td>
    </tr>
{% endfor %}

myapp/templates/myapp/outputtable.html

{% load model_helpers %}

<table>
    {% model_as_table %}
</table>

Avec cette application, vous pouvez passer le modèle des attributs que vous voulez afficher et dans quel ordre.

myapp/views.py

def output_table(request):
    output = My_Model()
    return render_to_response('outputtable.html',
                              {'output': output, 'model_table_attrs': ['attr1', 'attr2']})

J'aime aussi cette séparer proprement html et le code python.

OriginalL'auteur cjav

0

Il n'existe pas de méthode as_table sur une instance du modèle (MyModel())ou sur Querysets (MyModel.objects.all()). Vous avez peut-être vu as_table comme les formes de la méthode as_table. Vous n'avez pas de formulaire.

Si vous souhaitez imprimer un modèle d'exemple/un queryset comme un tableau, vous aurez à concevoir vous-même.

OriginalL'auteur stefanw
0

Si vous cherchez juste à la sortie d'un modèle spécifique, de modifier votre modèle de quelque chose comme
```
<tr>
  <td>Name:</td>
  <td>{{ output.name}}</td>
</tr>
```
pour tous les champs qui vous intéressent. Si c'est quelque chose que vous voulez être en mesure de le faire pour n'importe quel modèle dans votre application, jetez un oeil à ce extrait de. Que serait pour vous une collection de champs en boucle.

OriginalL'auteur Tom
0

OMG c'est vieux, mais Générique Vues semble être une bonne solution pour ce problème, du moins pour moi. Une Liste de la vue de détail devrait m'aider à courir plus vite. 🙂

OriginalL'auteur brokenthorn
0

Je suis venu avec une solution qui a fonctionné pour mon besoin spécifique qui rend toute simple du modèle de données dans les lignes de la table. Ajouter le filtre suivant dans templatetags/your_tags_file.py (n'oubliez pas l' __init__.py fichier dans le templatetags dossier):
```
from django import template
register = template.Library()

@register.filter()
def as_table(model):
    ret = ""
    for name in model._meta.get_all_field_names():
        try:
            field = str(getattr(model, name))
            if field:
                ret += '<tr><td class="name">'+name+'</td><td class="field">'+field+'</td></td>'
        except AttributeError:
            pass
    return ret
```
Dans le modèle de maintenant, vous pouvez simplement faire:
```
{% load your_tags_file %}
<table>
    {{output|as_table|safe}}
</table>
```
Cela rendra le modèle dans un tableau simple pour vous. Vous pouvez facilement ajouter n'importe souhaité thead et tbody logique que vous voyez l'ajustement par la modification de la logique de la façon dont ret est généré. Espérons que cela aide quelqu'un.

OriginalL'auteur Fydo

Vous devez vous connecter pour publier un commentaire.