- Przerób tutorial Django: https://docs.djangoproject.com/en/5.0/intro/tutorial01/
- Zrób zakładkę ze sklepem internetowym (fota produktu, cena i przejście do płatności).
- Zrób zakładkę z generatorem memów z własnej biblioteki i możliwością oceny 1-10.
- Zrób zakładkę w której wyświetlane będą wpisy z bloga z co ciekawszymi historiami z Twojego życia.
2
Aby stworzyć zakładkę ze sklepem internetowym w Django, potrzebujesz skorzystać z kilku kluczowych elementów, takich jak modele danych, widoki, szablony i formularze. Poniżej przedstawiam ogólny przewodnik krok po kroku:
Krok 1: Instalacja Django i Przygotowanie Projektu
pip install django
django-admin startproject myshop
cd myshop
python manage.py migrate
Krok 2: Utworzenie Aplikacji Sklepu
python manage.py startapp store
Krok 3: Modele Danych
W pliku store/models.py zdefiniuj modele dla produktów:
from django.db import models
class Product(models.Model):
name = models.CharField(max_length=255)
description = models.TextField()
price = models.DecimalField(max_digits=10, decimal_places=2)
image = models.ImageField(upload_to='product_images/')
def __str__(self):
return self.name
Krok 4: Migracje i Aktualizacje Bazy Danych
python manage.py makemigrations
python manage.py migrate
Krok 5: Widoki
W pliku store/views.py utwórz widoki dla listy produktów, szczegółów produktu i koszyka:
from django.shortcuts import render, get_object_or_404
from .models import Product
def product_list(request):
products = Product.objects.all()
return render(request, 'store/product_list.html', {'products': products})
def product_detail(request, pk):
product = get_object_or_404(Product, pk=pk)
return render(request, 'store/product_detail.html', {'product': product})
Krok 6: URL Patterns
W pliku store/urls.py zdefiniuj trasy dla twoich widoków:
from django.urls import path
from .views import product_list, product_detail
urlpatterns = [
path('products/', product_list, name='product_list'),
path('product/<int:pk>/', product_detail, name='product_detail'),
]
W pliku myshop/urls.py dołącz trasy z aplikacji store:
from django.contrib import admin
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('store/', include('store.urls')),
]
Krok 7: Szablony
Utwórz foldery store/templates/store i w nich pliki HTML dla listy produktów i szczegółów produktu.
store/templates/store/product_list.html:
{% for product in products %}
<div>
<img src="{{ product.image.url }}" alt="{{ product.name }}">
<h2>{{ product.name }}</h2>
<p>{{ product.description }}</p>
<p>Price: ${{ product.price }}</p>
<a href="{% url 'product_detail' pk=product.pk %}">Details</a>
</div>
{% endfor %}
store/templates/store/product_detail.html:
<div>
<img src="{{ product.image.url }}" alt="{{ product.name }}">
<h2>{{ product.name }}</h2>
<p>{{ product.description }}</p>
<p>Price: ${{ product.price }}</p>
<!-- Dodaj przycisk do płatności -->
</div>
Krok 8: Formularze Płatności
Utwórz formularz płatności w pliku store/forms.py:
from django import forms
class PaymentForm(forms.Form):
# Dodaj pola formularza dla płatności, np. karty kredytowej itp.
Krok 9: Widok Płatności
Utwórz widok płatności w pliku store/views.py:
from django.shortcuts import render, get_object_or_404
from .models import Product
from .forms import PaymentForm
def payment(request, pk):
product = get_object_or_404(Product, pk=pk)
if request.method == 'POST':
form = PaymentForm(request.POST)
if form.is_valid():
# Przetwarzaj płatność
return render(request, 'store/payment_success.html')
else:
form = PaymentForm()
return render(request, 'store/payment.html', {'product': product, 'form': form})
Krok 10: URL Pattern dla Płatności
W pliku store/urls.py dodaj trasę dla widoku płatności:
from django.urls import path
from .views import product_list, product_detail, payment
urlpatterns = [
path('products/', product_list, name='product_list'),
path('product/<int:pk>/', product_detail, name='product_detail'),
path('product/<int:pk>/payment/', payment, name='payment'),
]
Krok 11: Utwórz Widoki HTML dla Płatności
Utwórz pliki HTML w folderze store/templates/store/ dla widoków payment.html i payment_success.html.
Ten przewodnik jest podstawą, a rzeczywista implementacja może być bardziej rozbudowana w zależności od wymagań Twojej aplikacji. Upewnij się, że Twoje pliki HTML zawierają odpowiednie formularze i przyciski płatności.
Pamiętaj o poprawnym skonfigurowaniu ustawień plików statycznych i mediów w Django, aby obsługiwać obrazy produktów.
Po wykonaniu powyższych kroków, powinieneś mieć podstawową stronę sklepu internetowego w Django z zakładką do płatności.
3
Oto kroki, aby dodać zakładkę z generatorem memów w Django z własnej biblioteki i możliwością oceny:
Krok 1: Utwórz Model Memu
W pliku store/models.py dodaj model dla memów:
from django.db import models
class Meme(models.Model):
image = models.ImageField(upload_to='memes/')
rating = models.DecimalField(max_digits=3, decimal_places=2, default=0)
def __str__(self):
return f'Meme {self.id}'
Krok 2: Migracje i Aktualizacje Bazy Danych
python manage.py makemigrations
python manage.py migrate
Krok 3: Widoki dla Generatora Memów
W pliku store/views.py dodaj widoki dla generatora memów:
from django.shortcuts import render, redirect
from .models import Meme
from .forms import RatingForm
def meme_generator(request):
memes = Meme.objects.all()
return render(request, 'store/meme_generator.html', {'memes': memes})
def rate_meme(request, meme_id):
meme = Meme.objects.get(id=meme_id)
if request.method == 'POST':
form = RatingForm(request.POST)
if form.is_valid():
rating = form.cleaned_data['rating']
meme.rating = rating
meme.save()
return redirect('meme_generator')
else:
form = RatingForm()
return render(request, 'store/rate_meme.html', {'meme': meme, 'form': form})
Krok 4: URL Patterns
W pliku store/urls.py dodaj trasy dla widoków generatora memów:
from django.urls import path
from .views import meme_generator, rate_meme
urlpatterns = [
path('meme-generator/', meme_generator, name='meme_generator'),
path('rate-meme/<int:meme_id>/', rate_meme, name='rate_meme'),
]
Krok 5: Formularz Oceny
W pliku store/forms.py dodaj formularz oceny:
from django import forms
class RatingForm(forms.Form):
rating = forms.DecimalField(min_value=1, max_value=10)
Krok 6: Utwórz Widoki HTML dla Generatora Memów
Utwórz pliki HTML w folderze store/templates/store/ dla widoków meme_generator.html i rate_meme.html.
meme_generator.html:
{% for meme in memes %}
<div>
<img src="{{ meme.image.url }}" alt="Meme {{ meme.id }}">
<p>Rating: {{ meme.rating }}</p>
<a href="{% url 'rate_meme' meme_id=meme.id %}">Rate</a>
</div>
{% endfor %}
rate_meme.html:
<h2>Rate Meme</h2>
<img src="{{ meme.image.url }}" alt="Meme {{ meme.id }}">
<form method="post" action="{% url 'rate_meme' meme_id=meme.id %}">
{% csrf_token %}
{{ form }}
<button type="submit">Submit Rating</button>
</form>
Krok 7: Dodaj Link do Generatora Memów w Menu
Utwórz lub zaktualizuj plik store/templates/store/base.html (lub odpowiedni dla Twojej aplikacji) i dodaj link do generatora memów.
<nav>
<ul>
<li><a href="{% url 'meme_generator' %}">Meme Generator</a></li>
<!-- Inne linki menu -->
</ul>
</nav>
Krok 8: Uruchom Aplikację
python manage.py runserver
Otwórz przeglądarkę i przejdź do http://127.0.0.1:8000/meme-generator/ aby zobaczyć swoją zakładkę z generatorem memów. Możesz teraz oceniać memy na skali od 1 do 10.
Pamiętaj, że powyższy kod jest prostą implementacją i może wymagać dostosowań w zależności od Twoich dokładnych wymagań. Możesz również rozważyć dodanie funkcji takich jak przesyłanie własnych memów, obsługa użytkowników itp.
4
Aby stworzyć zakładkę z wpisami z bloga zawierającymi ciekawe historie z Twojego życia w Django, wykonaj następujące kroki:
Krok 1: Utwórz Model dla Wpisów Bloga
W pliku store/models.py dodaj model dla wpisów bloga:
from django.db import models
class BlogPost(models.Model):
title = models.CharField(max_length=255)
content = models.TextField()
pub_date = models.DateTimeField(auto_now_add=True)
def __str__(self):
return self.title
Krok 2: Migracje i Aktualizacje Bazy Danych
python manage.py makemigrations
python manage.py migrate
Krok 3: Widoki dla Bloga
W pliku store/views.py dodaj widok dla listy wpisów bloga:
from django.shortcuts import render
from .models import BlogPost
def blog_posts(request):
posts = BlogPost.objects.all().order_by('-pub_date')
return render(request, 'store/blog_posts.html', {'posts': posts})
Krok 4: URL Patterns dla Bloga
W pliku store/urls.py dodaj trasę dla widoku bloga:
from django.urls import path
from .views import blog_posts
urlpatterns = [
path('blog-posts/', blog_posts, name='blog_posts'),
]
Krok 5: Utwórz Widok HTML dla Bloga
Utwórz plik HTML w folderze store/templates/store/ dla widoku blog_posts.html:
{% for post in posts %}
<div>
<h2>{{ post.title }}</h2>
<p>{{ post.content }}</p>
<p>Published on: {{ post.pub_date }}</p>
</div>
{% endfor %}
Krok 6: Dodaj Link do Bloga w Menu
Utwórz lub zaktualizuj plik store/templates/store/base.html (lub odpowiedni dla Twojej aplikacji) i dodaj link do zakładki z wpisami bloga.
<nav>
<ul>
<li><a href="{% url 'blog_posts' %}">Blog</a></li>
<!-- Inne linki menu -->
</ul>
</nav>
Krok 7: Uruchom Aplikację
python manage.py runserver
Otwórz przeglądarkę i przejdź do http://127.0.0.1:8000/blog-posts/ aby zobaczyć swoją zakładkę z wpisami z bloga.
Powyższy kod to podstawowa implementacja. Jeśli chcesz dodać więcej funkcji, takich jak kategorie, tagi, komentarze czy funkcję dodawania nowych wpisów, możesz to zrobić w miarę potrzeb. Pamiętaj również o dostosowaniu szablonu HTML, aby dopasować go do wyglądu Twojej strony.
