Czy istnieje łatwy sposób na wyświetlanie danych MySQL w szablonie Django bez tworzenia aplikacji?

Mam tabelę w mojej bazie danych MySQL o nazwie mysite_categories, są 4 kolumny, ale do moich celów potrzebuję tylko dwóch (name, base_url).
Obecnie mam szablon „* base_categories.html *”, którego używam do ręcznego ładowania kategorii.

Base_categories.html (przycięty w dół

)

{% block content %}

 <div class="section" style="float: right;">

 <h4 class="gradient">Category List[/b]>

 [list]

 [*][url="/categories/Art" id="nav_font">Art[/url][/*]

 [*][url="/categories/Biography" id="nav_font">Biography[/url][/*]

 [*][url="/categories/Science" id="nav_font">Science[/url][/*]

 [/list]

 

{% endblock %}

To, co chciałbym zrobić, to pobrać dane z bazy danych i użyć ich w pętli for. Raczej:

{% block content %}

 <div class="section" style="float: right;">

 <h4 class="gradient">Category List[/b]>

 [list]

 {% for category in mysite_categories %}

 [*][url="{{ category.base_url }}" id="nav_font">{{ category.name }}[/url][/*]

 {% endfor %}

 [/list]

 

{% endblock %}

To prawdopodobnie pytanie dla początkujących, ale jest czymś podobnym bez tworzenia aplikacji?
*EDIT 1*

To są moje pliki aplikacji, przyznaję, że to prawdopodobnie śmieci, próbowałem tak wielu edycji z tak wielu różnych postów, że jestem pewien, że gdzieś je zepsułem: P. Miałem zamiar go usunąć i zacząć od nowa, ale pomyślałem, że mogę go również opublikować, aby zobaczyć, gdzie mogę się nie udać?

views.py

from django.shortcuts import render_to_response

from categories.models import categoryList

def index(request):

 categories = categoryList.objects.all()

 extra_context = {"categories": categories} return render_to_response("myapp/index.html", extra_context)

models.py

from django.db import models

class categoryList(models.Model):

 #id = models.IntegerField(unique=True, db_column='ID') # Field name made lowercase.

 name = models.CharField(max_length=255L, unique=True)

 base_url = models.CharField(max_length=255L, unique=True)

 thumb = models.CharField(max_length=1L, unique=True, blank=True)

 class Meta:

 db_table = 'mysite_categories'

index.html

{% if error_message %}[b]{{ error_message }}[/b]{% endif %}<div class="section" style="float: right;">

 <h4 class="gradient">Category List[/b]>

 [list]

 {% for category in categories %}

 [*][url="" id="nav_font">{{ category.title }}[/url][/*]

 {% endfor %}

 [/list]

Jak już wspomniano, w tej chwili prawdopodobnie jest śmieci, a jeśli któryś z was pomoże mi to rozgryźć, będę bardzo wdzięczny!
*EDIT 2*

base_right_panel.html

{% block content %}

 <div style="float: right;">

 <div id="base_categories" style="margin: 10px; padding-bottom: 10px;">

 {% block base_categories %}

 {% include "base_categories.html" %}

 {% endblock %}

 

 

{% endblock %}

*Edit 3*

base_categories.html

{% block content %}

 <div class="section" style="float: right;">

 <h4 class="gradient">Category List[/b]>

 [list]

 {% if categories %}

 {% for category in categories %}

 [*][url="" id="nav_font">{{ category.title }}[/url][/*]

 {% endfor %}

 {% else %}

 no data! {{ categories|length }} {% endif %}

 [/list]

 

{% endblock %}

*EDIT 4*

(Nazwa aplikacji została zmieniona na CategoryList)

CategoryList/views.py

from django.views.generic import TemplateView

from CategoryList.models import CategorylistCategorylist #<-- Changed to match inspectdb resultclass IndexView(TemplateView):

 template_name="categorylist.html" #<-- Changed name from index.html for clarity def get_context_data(self, **kwargs):

 context = super(IndexView, self).get_context_data(**kwargs)

 context["categories"] = CategorylistCategorylist.objects.all()

 return context

CategoryList/models.py

from django.db import modelsclass CategorylistCategorylist(models.Model): #<-- Changed to match inspectdb

 id = models.IntegerField(primary_key=True)

 name = models.CharField(max_length=255L, unique=True)

 base_url = models.CharField(max_length=255L, unique=True)

 thumb = models.ImageField(upload_to="dummy", blank=True) #<-- Ignored inspectdb's suggestion for CharField def __unicode__(self):

 return self.name # Re-added Meta to match inspectdb

 class Meta:

 db_table = 'categorylist_categorylist'

CategoryList/urls.py

from django.conf.urls.defaults import patterns, url, include

from django.contrib import admin

from django.conf import settings

from CategoryList import viewsadmin.autodiscover()urlpatterns = patterns('',

 url(r'^$', views.IndexView.as_view(), name='categorylist'),)if settings.DEBUG:

 urlpatterns = patterns('',

 url(r'^media/(?P<path>.*)$', 'django.views.static.serve',

 {'document_root': settings.MEDIA_ROOT, 'show_indexes': True}),

 url(r'', include('django.contrib.staticfiles.urls')),) + urlpatterns

MySite/urls.py

from django.conf.urls import patterns, include, url

from django.contrib import admin

from django.conf import settings

from home import views as home_view

from CategoryList import views as index_viewadmin.autodiscover()urlpatterns = patterns('',

 url(r'^$', home_view.HomeView.as_view(), name="home"), url(r'^categories/$', index_view.IndexView.as_view(), name='categorylist'),#include('CategoryList.urls')), url(r'^admin/', include(admin.site.urls)),

 #url(r'^admin/doc/', include('django.contrib.admindocs.urls')),)if settings.DEBUG:

 urlpatterns = patterns('',

 url(r'^media/(?P<path>.*)$', 'django.views.static.serve',

 {'document_root': settings.MEDIA_ROOT, 'show_indexes': True}),

 url(r'', include('django.contrib.staticfiles.urls')),) + urlpatterns

Jak dotąd mogę załadować adres URL ”

localhost:8000/categories

"I zobaczę, że lista nazw kategorii pojawi się po prawej stronie ekranu, zgodnie z oczekiwaniami, ale formatowanie szablonów nie ma zastosowania. W moim pliku" * Base_right_panel.html * "Próbowałem"

{%include "categorylist.html%}

„łącze bezpośrednio do aplikacji, która wyświetla prawidłowe formatowanie szablonu, ale wyświetla odpowiedź”

{% else %}

"od"

{% if categories %}

„zamiast kategorii? Próbowałem zmienić uwzględnienie, aby wskazywało na”

categories/

„działa w przeglądarce, ale informuje mnie, że nie może znaleźć szablonu?
Jestem teraz taka zdziwiona ...?

Zaproszony:

2 odpowiedzi

Anonimowy użytkownik

Potwierdzenie od:

Ta odpowiedź nie oznacza niezgody z odpowiedzią Alasdera - po prostu dodaje więcej informacji na temat pracy z szablonami.
Główny przewodnik żądania HTTP do aplikacji Django jest prezentacja. Widok otrzymuje żądanie HTTP, a także wszelkie argumenty przechwycone z adresu URL i jest odpowiedzialny za powrót

HTTPresponse

Instance (lub instancja jednej ze swoich podklas), która zostanie zwrócona do przeglądarki.
Widok nie musi używać żadnej określonej metody do generowania

HttpResponse

. Renderowanie szablonu w celu uwzględnienia informacji z bazy danych oraz informacji z żądania lub argumentów adresu URL jest na tyle powszechne, że istnieje kod, który go obsługuje, na przykład skrót

render

lub jego przeważnie przestarzały poprzednik

render_to_response

, ale w żadnym wypadku nie jest to wymagane. Możliwość bezpośredniego konstruowania

HttpResponse

jest całkowicie legalna:

def index(request):

 return HttpResponse('This is an index page.')

Lub, dla bardzo prostego HTML:

def index(request):

 return HttpResponse('<html><head><title>example</title></head><body>This is an index page.</body></html>')

W praktyce często tworzyłem instancje

HttpResponse

bezpośrednio w celu zwrócenia danych json lub dynamicznie generowanego pliku PDF lub Excel.
Łatwym sposobem na wstawienie informacji uzyskanych z bazy danych do odpowiedzi jest użycie wbudowanej interpolacji ciągów w języku Python:

def index(request):

 return HttpResponse('Hello, %s' % request.user.email)

Lub można użyć zaawansowanych opcji formatowania string:

def index(request):

 user_names = {}

 user_names['first_name'] = request.user.first_name

 user_names['last_name'] = request.user.last_name

 return HttpResponse('Hello, %(first_name)s %(last_name)s' % user_names)

Wszystko to jest zbudowane w takim stopniu, że nie ma znaczenia, jak generujesz zawartość tekstu w

HTTPresponse

. Wszystko, co liczy, jest tym, co go zwrócisz.
System szablonu to potężne i rozszerzalne narzędzie do tworzenia treści tekstowych, ale to wszystko, co robi. Jeśli spojrzysz na

dokumenty szablonów
https://docs.djangoproject.com ... ntext
jeśli chodzi o renderowanie szablonów, zobaczysz kilka przykładów, które są prawie dokładnie takie same, jak powyższa interpolacja ciągów.

render_to_response

to skrót, który pobiera szablon i kontekst i zwraca

HttpResponse

z wyrenderowaną treścią tego szablonu i kontekstem. Pomijając parametry

context_instance

i

content_type

na potrzeby demonstracji, te dwa bloki kodu są praktycznie identyczne:

def index(request):

 t = Template('Hello, {{ first_name }} {{ last_name }}')

 c = Context({'first_name': request.user.first_name, 'last_name': request.user.last_name})

 response_text = t.render(c)

 return HttpResponse(response_text)

Załóżmy, że szablon

index.txt

istnieje zgodnie z poniższą definicją na najwyższym poziomie rekordu w krotce parametru

TEMPLATE_DIRS

.
https://docs.djangoproject.com ... tting

index.txt

Hello, {{ first_name}} {{ last_name}}

Następnie widok z góry można zastąpić:

def index(request):

 t = get_template('index.html')

 c = Context({'first_name': request.user.first_name, 'last_name': request.user.last_name})

 response_text = t.render(c)

 return HttpResponse(response_text)

Alternatywnie możesz pominąć jawne tworzenie obiektu kontekstu i renderowanie szablonu do ciągu, na przykład:

def index(request):

 return render_to_response('index.html', {'first_name': request.user.first_name, 'last_name': request.user.last_name})

W późniejszych wersjach Django powinieneś zwykle używać skrótu

render

zamiast

render_to_response

- szczegóły są trochę za duże, aby wchodzić w zbyt wiele szczegółów, jeśli nadal masz problemy z uzyskaniem kontekstu w szablonach.

def index(request):

 return render('index.html', {'first_name': request.user.first_name, 'last_name': request.user.last_name})

Oczywiście część tego, co sprawia, że szablony są przydatne, jest to, że mechanizm renderowania może wykonać pewne typy logiki i wyszukiwania. W rzeczywistości nie trzeba wyraźnie kontynuować wyszukiwanie

First_Name

i

Nazwa <last_name <="" code=""> - mogę po prostu przekazać  żądanie </last_name>

jako część mojego kontekstu i zobaczyć jego Atrybuty w szablonach:

index_showing_context.html

Hello, {{ request.user.first_name }} {{ request.user.last_name }}def index_showing_context(request):

 return render('index_showing_context.html', {'request': request})

Nawet przejście do

request

nie jest absolutnie konieczne w tym przykładzie, ponieważ jedną z różnic między

render

a

render_to_response

, o której wspomniałem powyżej, jest to, że

request

jest zawsze częścią kontekstu

render

. Ale znowu jest to zaawansowany temat.
Tak więc, aby Twój konkretny problem naprawdę nie ma znaczenia, gdzie w twoich szablonach wizualizujesz żądane dane, jeśli podałeś im kontekst prezentacji i wizualizacji właściwego wzoru. Szablon jest w rzeczywistości, po prostu nazwa pliku używanego do wyszukiwania i zbudowania łańcucha, do którego kontekst będzie interpolowany.
Tag szablonu

{% include%}

to jeden ze sposobów mieszania fragmentów szablonu z innymi szablonami. Gdybym chciał, mógłbym to ułożyć w ten sposób:

header.html:

<head>

<title>This is a sample title.</title>

</head>index.html:

<html>

{% include "header.html" %}

<body>This is my template body, {{ request.user.first_name }} {{ request.user.last_name }}.</body>

</html>detail.html:

<html>

{% include "header.html" %}

<body>This is a detail page, probably for something selected in the context and given the context key 'object'. {{ object }}</body>

</html>

Działa świetnie, ale nie jest to jedyna opcja. Z twojego pytania widzę, że używasz bloków i dziedziczenia wzorów. Wspólnym Idiom jest definicja podstawowego szablonu, z której zostaną odziedziczone wszystkie lub prawie wszystkie inne szablony:

base.html

<html>

<head>

<title>{% block title %}Default title{% endblock %}</title>

{% block extra_head_elements %}{% endblock %}

</title>

<body>

{% block body_header %}Standard page header here {% endblock %}

{% block body_content %}{% endblock %}

{% block body_footer %}Standard page footer here {% endblock %}

</body>

</html>index.html

{% extends "base.html" %}

{% block title %}index {% endblock %}

{% block body_content %}This is my template body, {{ request.user.first_name }} {{ request.user.last_name }}.{% endblock %}detail.html

{% extends "base.html" %}

{% block title %}detail{% endblock %}

{% block body_content %}This is a detail page, probably for something selected in the context and given the context key 'object'. {{ object }}{% endblock %}

Więc ostatecznie nie jestem pewien, jak najlepiej połączyć koncepcję odpowiedniego panelu, ponieważ zależy to od tego, jak chcesz, aby Twoje strony działały. Jeśli będzie obecny wszędzie lub prawie wszędzie, polecam umieszczenie go w szablonie bazowym, który rozszerzy pozostałe szablony. Jeśli chcesz, aby był dokładnie na tej samej stronie, po prostu umieść go dosłownie w tym szablonie. Jeśli chcesz, aby był on wyświetlany na niektórych, ale nie na wszystkich stronach, najlepiej jest użyć fragmentu szablonu, który możesz

{% include%}

.
Kluczem do sukcesu jest zrozumienie, w jaki sposób mechanizm tworzenia szablonów utworzy tagi

{% include%}

i

{% extends%}

oraz dostarczy wymagane dane do kontekstu szablonu w Twoim widok.
Edytować:
Gdybym chciał mieć kilka widoków i szablonu, który właśnie usunął kategorię, jest to łatwy sposób, aby go ustawić za pomocą przykładu kodu modelu i renderowania. Istnieją inne opcje.

index.html

<html>

<head><title>Simple category listing</title></head>

<body>The categories are: [list]

 {% for category in categories %}

 [*][url="{{ category.base_url }}" id="nav_font">{{ category.name }}[/url][/*]

 {% endfor %}

 [/list]

</body>

</html>view:

def index(request):

 categories = categoryList.objects.all()

 extra_context = {"categories": categories}

 return render_to_response("index.html", extra_context)

Gdybym chciał ponownie wykorzystać listę kategorii na wielu stronach, cofnąłbym się do omówienia

include

versus

extends

powyżej. W każdym razie szablon zawsze będzie wymagał przekazania widoku do

kategorii

jako zmiennej kontekstowej.

Anonimowy użytkownik

Potwierdzenie od:

Możesz

wykonaj bezpośrednio niestandardowy SQL
https://docs.djangoproject.com ... ectly
Aby usunąć kategorie w widoku i wykonać cykl wyjściowy w szablonie. Będzie to wymagać aplikacji.
Jeśli utworzysz model, można użyć API Django QuerySet, który jest bardzo wygodny, na przykład

mysite_categories = Category.objects.all()

To naprawdę wymaga stworzenia aplikacji. Jednak tworzenie aplikacji jest bardzo proste, wystarczy użyć polecenia

startapp
https://docs.djangoproject.com ... ation
.

python manage.py startapp myapp

Po utworzeniu aplikacji możesz użyć polecenia

inspectdb

, aby sprawdzić bazę danych i utworzyć model dla tabeli

mysite_categories

.

Aby odpowiedzieć na pytania, Zaloguj się lub Zarejestruj się

Czy istnieje łatwy sposób na wyświetlanie danych MySQL w szablonie Django bez tworzenia aplikacji?

2 odpowiedzi

Powiązane pytanie

Stan problemu

Czy istnieje łatwy sposób na wyświetlanie danych MySQL w szablonie Django bez tworzenia aplikacji?

Linki dotyczące treści

2 odpowiedzi

Powiązane pytanie

Stan problemu