Django. Praktyczne tworzenie aplikacji sieciowych

Django to bardzo przydatne narzędzie ułatwiające pisanie aplikacji sieciowych w języku Python. Jest uważane za framework, który łączy wielkie możliwości z prostotą użytkowania. Pozwala na szybkie tworzenie oprogramowania na podstawie przejrzystych i praktycznych projektów. To atrakcyjne rozwiązanie dla programistów zarówno początkujących, jak i doświadczonych.

Książka, którą trzymasz w rękach, jest znakomitym podręcznikiem pisania aplikacji sieciowych w Django. Krok po kroku pokazano tu pełny proces tworzenia profesjonalnego oprogramowania, a przykładami, na których oparto poszczególne rozdziały, są rzeczywiste projekty aplikacji.

Dzięki takiemu podejściu można bardzo szybko zapoznać się z frameworkiem, nauczyć się rozwiązywania często występujących problemów i w naturalny sposób stosować najlepsze praktyki programistyczne. Autorzy pokazali również, w jaki sposób w projektach Django stosować kilka popularnych technologii związanych z aplikacjami sieciowymi.

Najważniejsze zagadnienia omówione w książce:
• przygotowanie środowiska i wprowadzenie do frameworka,
• tworzenie praktycznego projektu aplikacji umożliwiającego dalsze modyfikacje i rozbudowę,
• implementacja zaawansowanych funkcjonalności aplikacji sieciowych,
• praca z bazami danych Redis i innymi technologiami (w tym Celery, Solr i Memcached),
• tłumaczenie aplikacji na wiele języków,
• API typu RESTful.

Django - framework dla perfekcjonistów, którzy muszą przestrzegać terminów.

Spis treści:

Rozdział 1. Utworzenie aplikacji bloga (21)

• Instalacja Django (22)
  • Utworzenie odizolowanego środowiska Pythona (22)
  • Instalacja Django za pomocą pip (23)
• Utworzenie pierwszego projektu (24)
  • Uruchomienie serwera programistycznego (25)
  • Ustawienia projektu (27)
  • Projekty i aplikacje (28)
  • Utworzenie aplikacji (28)
• Projekt schematu danych dla bloga (29)
  • Aktywacja aplikacji (31)
  • Utworzenie i zastosowanie migracji (31)
• Utworzenie witryny administracyjnej dla modeli (33)
  • Utworzenie superużytkownika (33)
  • Witryna administracyjna Django (33)
  • Dodanie modeli do witryny administracyjnej (34)
  • Zmiana sposobu wyświetlania modeli (36)
• Praca z obiektami QuerySet i menedżerami (38)
  • Tworzenie obiektów (38)
  • Uaktualnianie obiektów (39)
  • Pobieranie obiektów (40)
  • Usunięcie obiektu (41)
  • Kiedy następuje określenie zawartości kolekcji QuerySet? (41)
  • Utworzenie menedżerów modelu (42)
• Przygotowanie widoków listy i szczegółów (42)
  • Utworzenie widoków listy i szczegółów (43)
  • Dodanie wzorców adresów URL do widoków (44)
  • Kanoniczne adresy URL dla modeli (45)
• Utworzenie szablonów dla widoków (46)
• Dodanie stronicowania (49)
• Użycie widoków opartych na klasach (51)
• Podsumowanie (52)

Rozdział 2. Usprawnienie bloga za pomocą funkcji zaawansowanych (53)

• Współdzielenie postów przy użyciu wiadomości e-mail (53)
  • Tworzenie formularzy w Django (54)
  • Obsługa formularzy w widokach (55)
  • Wysyłanie wiadomości e-mail w Django (57)
  • Generowanie formularza w szablonie (59)
• Utworzenie systemu komentarzy (62)
  • Utworzenie formularza na podstawie modelu (64)
  • Obsługa klasy ModelForm w widoku (65)
  • Dodanie komentarzy do szablonu szczegółów posta (67)
• Dodanie funkcjonalności tagów (70)
• Pobieranie podobnych postów (75)
• Podsumowanie (77)

Rozdział 3. Rozbudowa aplikacji bloga (79)

• Utworzenie własnych filtrów i znaczników szablonu (79)
  • Utworzenie własnych znaczników szablonu (80)
  • Utworzenie własnych filtrów szablonu (84)
• Dodanie mapy witryny (87)
• Utworzenie kanału wiadomości dla postów bloga (90)
• Implementacja silnika wyszukiwania z użyciem Solr i Haystack (92)
  • Instalacja Solr (92)
  • Utworzenie Solr core (94)
  • Instalacja Haystack (96)
  • Utworzenie indeksów (97)
  • Indeksowanie danych (99)
  • Utworzenie widoku wyszukiwania (100)
• Podsumowanie (103)

Rozdział 4. Utworzenie witryny społecznościowej (105)

• Utworzenie projektu witryny społecznościowej (106)
  • Rozpoczęcie pracy nad aplikacją społecznościową (106)
• Użycie frameworka uwierzytelniania w Django (107)
  • Utworzenie widoku logowania (108)
  • Użycie widoków uwierzytelniania w Django (113)
  • Widoki logowania i wylogowania (114)
  • Widoki zmiany hasła (119)
  • Widoki zerowania hasła (121)
• Rejestracja użytkownika i profil użytkownika (126)
  • Rejestracja użytkownika (126)
  • Rozbudowa modelu User (130)
  • Użycie frameworka komunikatów (135)
• Implementacja własnego mechanizmu uwierzytelniania (137)
• Dodanie do witryny uwierzytelnienia za pomocą innej witryny społecznościowej (139)
  • Uwierzytelnienie za pomocą serwisu Facebook (141)
  • Uwierzytelnienie za pomocą serwisu Twitter (143)
  • Uwierzytelnienie za pomocą serwisu Google (145)
• Podsumowanie (148)

Rozdział 5. Udostępnianie treści w witrynie internetowej (149)

• Utworzenie witryny internetowej do kolekcjonowania obrazów (150)
  • Utworzenie modelu Image (150)
  • Zdefiniowanie związku typu "wiele do wielu" (152)
  • Rejestracja modelu Image w witrynie administracyjnej (153)
• Umieszczanie treści pochodzącej z innych witryn internetowych (153)
  • Usunięcie zawartości pól formularza (154)
  • Nadpisanie metody save() egzemplarza ModelForm (155)
  • Utworzenie bookmarkletu za pomocą jQuery (158)
• Utworzenie widoku szczegółowego obrazu (165)
• Utworzenie miniatury za pomocą sorl-thumbnail (167)
• Dodanie akcji AJAX za pomocą jQuery (168)
  • Wczytanie jQuery (170)
  • CSRF w żądaniach AJAX (171)
  • Wykonywanie żądań AJAX za pomocą jQuery (172)
• Utworzenie własnego dekoratora dla widoków (175)
• Dodanie stronicowania AJAX do listy widoków (176)
• Podsumowanie (181)

Rozdział 6. Śledzenie działań użytkownika (183)

• Utworzenie systemu obserwacji (184)
  • Utworzenie związku typu "wiele do wielu" za pomocą modelu pośredniego (184)
  • Utworzenie widoków listy i szczegółowego dla profilu użytkownika (187)
  • Utworzenie widoku AJAX pozwalającego na obserwację użytkowników (191)
• Budowa ogólnego strumienia aktywności aplikacji (193)
  • Użycie frameworka contenttypes (194)
  • Dodanie ogólnego związku do modelu (195)
  • Uniknięcie powielonych akcji w strumieniu aktywności (198)
  • Dodanie akcji użytkownika do strumienia aktywności (199)
  • Wyświetlanie strumienia aktywności (200)
  • Optymalizacja kolekcji QuerySet dotyczącej powiązanych obiektów (201)
  • Tworzenie szablonów dla akcji (202)
• Użycie sygnałów dla denormalizowanych zliczeń (204)
  • Praca z sygnałami (204)
  • Definiowanie klas konfiguracyjnych aplikacji (207)
• Użycie bazy danych Redis do przechowywania różnych elementów widoków (208)
  • Instalacja bazy danych Redis (209)
  • Użycie bazy danych Redis z Pythonem (210)
  • Przechowywanie różnych elementów widoków w bazie danych Redis (211)
  • Przechowywanie rankingu w bazie danych Redis (213)
  • Kolejne kroki z bazą danych Redis (215)
• Podsumowanie (216)

Rozdział 7. Utworzenie sklepu internetowego (217)

• Utworzenie projektu sklepu internetowego (218)
  • Utworzenie modeli katalogu produktów (219)
  • Rejestracja modeli katalogu w witrynie administracyjnej (221)
  • Utworzenie widoków katalogu (222)
  • Utworzenie szablonów katalogu (224)
• Utworzenie koszyka na zakupy (228)
  • Użycie sesji Django (228)
  • Ustawienia sesji (229)
  • Wygaśnięcie sesji (230)
  • Przechowywanie koszyka na zakupy w sesji (231)
  • Utworzenie widoków koszyka na zakupy (235)
  • Utworzenie procesora kontekstu dla bieżącego koszyka na zakupy (241)
• Rejestracja zamówienia klienta (244)
  • Utworzenie modeli zamówienia (244)
  • Dołączenie modeli zamówienia w witrynie administracyjnej (246)
  • Utworzenie zamówienia klienta (247)
• Wykonywanie zadań asynchronicznych za pomocą Celery (251)
  • Instalacja Celery (251)
  • Instalacja RabbitMQ (251)
  • Dodanie Celery do projektu (252)
  • Dodanie zadania asynchronicznego do aplikacji (253)
  • Monitorowanie Celery (255)
• Podsumowanie (255)

Rozdział 8. Zarządzanie płatnościami i zamówieniami (257)

• Integracja bramki płatności (258)
  • Utworzenie konta PayPal (258)
  • Instalacja django-paypal (259)
  • Dodanie bramki płatności (260)
  • Użycie środowiska sandbox w PayPal (264)
  • Otrzymywanie powiadomień o płatnościach (267)
  • Konfiguracja aplikacji (269)
  • Przetestowanie powiadomień o dokonanej płatności (269)
• Eksport zamówienia do pliku CSV (271)
  • Dodanie własnych akcji do witryny administracyjnej (271)
• Rozbudowa witryny administracyjnej za pomocą własnych widoków (274)
• Dynamiczne generowanie rachunków w formacie PDF (278)
  • Instalacja WeasyPrint (279)
  • Utworzenie szablonu PDF (279)
  • Generowanie pliku w formacie PDF (280)
  • Wysyłanie dokumentów PDF za pomocą wiadomości e-mail (283)
• Podsumowanie (284)

Rozdział 9. Rozbudowa sklepu internetowego (285)

• Utworzenie systemu kuponów (285)
  • Utworzenie modeli kuponu (286)
  • Zastosowanie kuponu w koszyku na zakupy (288)
  • Zastosowanie kuponu w zamówieniu (294)
• Internacjonalizacja i lokalizacja projektu (296)
  • Internacjonalizacja za pomocą Django (296)
  • Przygotowanie projektu do internacjonalizacji (299)
  • Tłumaczenie kodu Pythona (300)
  • Tłumaczenie szablonów (305)
  • Użycie interfejsu do tłumaczeń o nazwie Rosetta (309)
  • Opcja fuzzy (312)
  • Wzorce adresów URL dla internacjonalizacji (312)
  • Umożliwienie użytkownikowi zmiany języka (315)
  • Tłumaczenie modeli za pomocą django-parler (316)
  • Format lokalizacji (326)
  • Użycie modułu django-localflavor do weryfikacji pól formularza (327)
• Utworzenie silnika rekomendacji produktu (328)
  • Rekomendacja produktu na podstawie wcześniejszych transakcji (329)
• Podsumowanie (336)

Rozdział 10. Budowa platformy e-learningu (337)

• Utworzenie platformy e-learningu (338)
• Utworzenie modeli kursu (339)
  • Rejestracja modeli w witrynie administracyjnej (341)
  • Dostarczenie danych początkowych dla modeli (341)
• Utworzenie modeli dla zróżnicowanej treści (344)
  • Wykorzystanie dziedziczenia modelu (345)
  • Utworzenie modeli treści (347)
• Utworzenie własnych kolumn modelu (349)
• Utworzenie systemu zarządzania treścią (354)
  • Dodanie systemu uwierzytelniania (354)
  • Utworzenie szablonów uwierzytelniania (355)
  • Utworzenie widoków opartych na klasach (357)
  • Użycie domieszek w widokach opartych na klasach (358)
  • Praca z grupami i uprawnieniami (360)
  • Użycie zbioru formularzy (367)
  • Dodanie treści do modułów kursów (372)
  • Zarządzanie modułami i treścią (376)
  • Zmiana kolejności modułów i treści (380)
• Podsumowanie (383)

Rozdział 11. Buforowanie treści (385)

• Wyświetlanie kursów (385)
• Dodanie rejestracji uczestnika (390)
  • Utworzenie widoku rejestracji uczestnika (390)
  • Zapisanie się na kurs (393)
• Uzyskanie dostępu do treści kursu (396)
  • Generowanie różnych rodzajów treści (399)
• Użycie frameworka buforowania (401)
  • Dostępne mechanizmy buforowania (402)
  • Instalacja Memcached (403)
  • Ustawienia bufora (403)
  • Dodanie Memcached do projektu (404)
  • Poziomy buforowania (405)
  • Użycie działającego na niskim poziomie API buforowania (405)
  • Buforowanie fragmentów szablonu (409)
  • Buforowanie widoków (410)
• Podsumowanie (412)

Rozdział 12. Utworzenie API (413)

• Utworzenie API typu RESTful (413)
  • Instalacja Django Rest Framework (414)
  • Definiowanie serializacji (415)
  • Poznajemy analizator składni i generatory do określonych formatów (416)
  • Utworzenie widoków listy i szczegółowego (417)
  • Serializacja zagnieżdżona (419)
  • Utworzenie własnych widoków (421)
  • Obsługa uwierzytelnienia (422)
  • Określenie uprawnień do widoków (423)
  • Utworzenie kolekcji widoku i routerów (424)
  • Dołączenie dodatkowych akcji do kolekcji widoku (425)
  • Tworzenie własnych uprawnień (426)
  • Serializacja treści kursu (427)
• Podsumowanie (429)

Rozdział 13. Wdrożenie (431)

• Wdrożenie w środowisku produkcyjnym (431)
  • Zarządzanie ustawieniami dla wielu środowisk (431)
  • Instalacja PostgreSQL (434)
  • Sprawdzenie projektu (435)
  • Udostępnianie Django za pomocą WSGI (436)
  • Instalacja uWSGI (436)
  • Konfiguracja uWSGI (436)
  • Instalacja Nginx (438)
  • Środowisko produkcyjne (439)
  • Konfiguracja Nginx (440)
  • Udostępnianie zasobów statycznych i multimedialnych (441)
  • Ochrona połączeń za pomocą SSL (442)
• Utworzenie własnego oprogramowania pośredniczącego (445)
  • Utworzenie oprogramowania pośredniczącego do obsługi subdomeny (447)
  • Obsługa wielu subdomen za pomocą Nginx (448)
• Implementacja własnych poleceń administracyjnych (448)
• Podsumowanie (451)