Tytuł oryginału: Node.js, MongoDB, and AngularJS Web Development
Tłumaczenie: Piotr Pilch
ISBN: 978-83-283-0111-5
Authorized translation from the English language edition, entitled: NODE.JS, MONGODB, AND ANGULARJS WEB DEVELOPMENT; ISBN 0321995783; by Brad Dayley; published by Pearson Education, Inc, publishing as Addison Wesley.Copyright © 2014 Pearson Education, Inc.
All rights reserved. No part of this book may by reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from Pearson Education, Inc.
Polish language edition published by HELION S.A. Copyright © 2015.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie bierze jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Wydawnictwo HELION nie ponosi również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce.
Wydawnictwo HELIONul. Kościuszki 1c, 44-100 GLIWICEtel. 32 231 22 19, 32 230 98 63e-mail: [email protected]: http://helion.pl (księgarnia internetowa, katalog książek)
Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/nodekw.zip
Drogi Czytelniku!Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/nodekwMożesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Printed in Poland.
• Kup książkę• Poleć książkę • Oceń książkę
• Księgarnia internetowa• Lubię to! » Nasza społeczność
Spis treści
O autorze ..........................................................................13
Cz I Wprowadzenie ....................................................15 Wprowadzenie ...................................................................17
Kto powinien przeczyta t ksi k ? ...............................................17Dlaczego nale y przeczyta t ksi k ? ...........................................17Czego si dowiesz z tej ksi ki? .....................................................18Czym jest rodowisko Node.js? ......................................................19Czym jest komponent MongoDB? ...................................................20Czym jest komponent AngularJS? ...................................................20Jaka jest struktura tej ksi ki? .......................................................21Uzyskiwanie przyk adowych kodów ..................................................22Uwagi ko cowe .............................................................................22
Rozdzia 1 Podstawowe informacje o stosie Node.js-AngularJS .............23Podstawowe rodowisko projektowania aplikacji internetowych .........23Komponenty stosu Node.js-AngularJS .............................................27Podsumowanie .............................................................................31W nast pnym rozdziale ..................................................................32
Rozdzia 2 Wprowadzenie do j zyka JavaScript ....................................33Definiowanie zmiennych .................................................................33Typy danych j zyka JavaScript ........................................................34U ycie operatorów .........................................................................35Implementowanie p tli ..................................................................39Tworzenie funkcji ...........................................................................42Zasi g zmiennych ..........................................................................44U ycie obiektów j zyka JavaScript ...................................................45Przetwarzanie a cuchów ...............................................................48Korzystanie z tablic .......................................................................51Dodawanie obs ugi b dów .............................................................53Podsumowanie .............................................................................56W nast pnym rozdziale ..................................................................56
Kup książkę Poleć książkę
6 Node.js, MongoDB, AngularJS. Kompendium wiedzy
Cz II rodowisko Node.js ............................................57
Rozdzia 3 Wprowadzenie do rodowiska Node.js .................................59rodowisko Node.js ......................................................................59
Instalowanie rodowiska Node.js ....................................................60Praca z pakietami Node.js .............................................................62Tworzenie aplikacji Node.js ............................................................68Zapisywanie danych do konsoli ......................................................72Podsumowanie .............................................................................74W nast pnym rozdziale ..................................................................74
Rozdzia 4 U ycie zdarze , procesów nas uchiwania, licznikówi wywo a zwrotnych w rodowisku Node.js ........................75Model zdarze rodowiska Node.js .................................................75Dodawanie zada do kolejki zdarze ...............................................79Implementowanie wywo a zwrotnych ..............................................88Podsumowanie .............................................................................92W nast pnym rozdziale ..................................................................93
Rozdzia 5 Obs uga danych wej cia-wyj cia w rodowisku Node.js .......95Praca z danymi JSON .....................................................................95U ycie modu u Buffer do buforowania danych ..................................97U ycie modu u Stream do strumieniowania danych ........................104Podsumowanie ...........................................................................118W nast pnym rozdziale ................................................................118
Rozdzia 6 Uzyskiwanie dost pu do systemu plikówze rodowiska Node.js ......................................................119Porównanie synchronicznych
i asynchronicznych wywo a systemu plików ................................119Otwieranie i zamykanie plików ......................................................120Zapisywanie plików .....................................................................122Odczytywanie plików ....................................................................127Inne zadania zwi zane z systemem plików ....................................133Podsumowanie ...........................................................................140W nast pnym rozdziale ................................................................140
Rozdzia 7 Implementowanie us ug HTTP w rodowisku Node.js .........141Przetwarzanie adresów URL .........................................................141Przetwarzanie a cuchów zapytania i parametrów formularza ..........144Obiekty dania, odpowiedzi i serwera ..........................................145Implementowanie klientów i serwerów HTTP w rodowisku Node.js .....153Implementowanie serwerów i klientów HTTPS ................................162Podsumowanie ...........................................................................165W nast pnym rozdziale ................................................................166
Kup książkę Poleć książkę
Spis tre ci 7
Rozdzia 8 Implementowanie us ug gniazd w rodowisku Node.js .......167Gniazda sieciowe ........................................................................167Obiekty Server i Socket protoko u TCP ..........................................168Implementowanie klientów i serwerów gniazd TCP .........................176Implementowanie serwerów i klientów TLS ....................................181Podsumowanie ...........................................................................186W nast pnym rozdziale ................................................................186
Rozdzia 9 Skalowanie aplikacji przy u yciu wielu procesoróww rodowisku Node.js ......................................................187Modu process ............................................................................187Implementowanie procesów podrz dnych ......................................192Implementowanie klastrów procesów ............................................203Podsumowanie ...........................................................................208W nast pnym rozdziale ................................................................209
Rozdzia 10 U ycie dodatkowych modu ów rodowiska Node.js ............211U ycie modu u os ........................................................................211U ycie modu u util .......................................................................213Podsumowanie ...........................................................................219W nast pnym rozdziale ................................................................220
Cz III Komponent MongoDB ......................................221Rozdzia 11 Baza danych NoSQL i komponent MongoDB ......................223
Dlaczego baza danych NoSQL? ....................................................223Komponent MongoDB ..................................................................224Typy danych bazy danych MongoDB ..............................................226Planowanie modelu danych ..........................................................227Podsumowanie ...........................................................................233W nast pnym rozdziale ................................................................234
Rozdzia 12 Wprowadzenie do korzystania z komponentu MongoDB .....235Tworzenie rodowiska komponentu MongoDB ...............................235Administrowanie kontami u ytkowników ........................................241Konfigurowanie kontroli dost pu ..................................................245Administrowanie bazami danych ...................................................247Zarz dzanie kolekcjami ................................................................250Podsumowanie ...........................................................................256W nast pnym rozdziale ................................................................256
Rozdzia 13 Wprowadzenie do wspó pracy komponentu MongoDBi rodowiska Node.js ........................................................257Dodawanie sterownika komponentu MongoDB
do rodowiska Node.js ..............................................................257Nawi zywanie po czenia z komponentem MongoDB
ze rodowiska Node.js ..............................................................258
Kup książkę Poleć książkę
8 Node.js, MongoDB, AngularJS. Kompendium wiedzy
Obiekty u ywane w sterowniku rodowiska Node.jsdla komponentu MongoDB .........................................................265
Uzyskiwanie dost pu do baz danych i modyfikowanie ich ................273Uzyskiwanie dost pu do kolekcji i modyfikowanie ich .....................276Podsumowanie ...........................................................................280W nast pnym rozdziale ................................................................280
Rozdzia 14 Modyfikowanie dokumentów bazy danych MongoDBw rodowisku Node.js ......................................................281Opcje wprowadzania zmian w bazach danych .................................281Operatory aktualizowania baz danych ............................................283Dodawanie dokumentów do kolekcji .............................................283Uzyskiwanie dokumentów z kolekcji ..............................................286Aktualizowanie dokumentów w kolekcji .........................................287Niepodzielne modyfikowanie dokumentów w kolekcji ......................290Zapisywanie dokumentów w kolekcji .............................................291U ycie opcji upsert do wstawiania dokumentów do kolekcji .............293Usuwanie dokumentów z kolekcji .................................................294Usuwanie pojedynczego dokumentu z kolekcji ...............................296Podsumowanie ...........................................................................297W nast pnym rozdziale ................................................................297
Rozdzia 15 Uzyskiwanie dost pu do dokumentów bazy danychMongoDB w rodowisku Node.js .......................................299Podstawowe informacje na temat zestawu danych .........................299Obiekty query ..............................................................................300Obiekty options zapyta ...............................................................302Znajdowanie konkretnych zestawów dokumentów ..........................304Okre lanie liczby dokumentów ......................................................306Ograniczanie zestawów wynikowych ..............................................308Sortowanie zestawów wynikowych ................................................313Znajdowanie ró nych warto ci pola ...............................................315Grupowanie wyników ...................................................................316Korzystanie ze rodowiska MapReduce
podczas agregowania wyników ...................................................319Podsumowanie ...........................................................................324W nast pnym rozdziale ................................................................324
Rozdzia 16 U ycie biblioteki Mongoose dla schematu ze strukturi do sprawdzania poprawno ci ..........................................325Biblioteka Mongoose ...................................................................326Nawi zywanie po czenia z baz danych MongoDB
za pomoc biblioteki Mongoose .................................................327Definiowanie schematu ...............................................................328Kompilowanie modelu .................................................................332
Kup książkę Poleć książkę
Spis tre ci 9
Obiekt Query ...............................................................................333Obiekt Document ........................................................................339Znajdowanie dokumentów za pomoc biblioteki Mongoose .............340Dodawanie dokumentów za pomoc biblioteki Mongoose ...............343Aktualizowanie dokumentów za pomoc biblioteki Mongoose .........344Usuwanie dokumentów za pomoc biblioteki Mongoose .................349Agregowanie dokumentów za pomoc biblioteki Mongoose .............351U ycie rodowiska sprawdzania poprawno ci .................................354Implementowanie funkcji po rednich ............................................356Podsumowanie ...........................................................................359W nast pnym rozdziale ................................................................359
Rozdzia 17 Zaawansowane zagadnieniazwi zane z baz danych MongoDB ....................................361Dodawanie indeksów ...................................................................361U ycie ograniczonych kolekcji .......................................................364Stosowanie replikacji ...................................................................365Implementowanie tworzenia segmentów danych ...............................369Implementowanie magazynu GridFS ..............................................377Naprawianie bazy danych MongoDB ..............................................383Tworzenie kopii zapasowej bazy danych MongoDB .........................384Podsumowanie ...........................................................................385W nast pnym rozdziale ................................................................385
Cz IV U ycie modu u Express do usprawnienia pracy .....387
Rozdzia 18 Implementacja komponentu Expressw rodowisku Node.js ......................................................389Wprowadzenie do komponentu Express ........................................389Konfigurowanie tras ....................................................................392U ycie obiektów Request .............................................................397U ycie obiektów Response ...........................................................398Implementowanie mechanizmu szablonów ....................................406Podsumowanie ...........................................................................411W nast pnym rozdziale ................................................................411
Rozdzia 19 Implementacja funkcji po rednich komponentu Express ....413Funkcje po rednie .......................................................................413U ycie funkcji po redniej query .....................................................416Udost pnianie plików statycznych .................................................416Obs uga danych tre ci dania POST ............................................418Wysy anie i odbieranie informacji cookie .......................................419Implementowanie sesji ................................................................421Stosowanie podstawowego uwierzytelniania HTTP .............................423
Kup książkę Poleć książkę
10 Node.js, MongoDB, AngularJS. Kompendium wiedzy
Implementowanie uwierzytelniania sesji ........................................424Tworzenie niestandardowych funkcji po rednich ..............................427Podsumowanie ...........................................................................428W nast pnym rozdziale ................................................................428
Cz V Komponent AngularJS ......................................429
Rozdzia 20 Wprowadzenie do komponentu AngularJS .........................431Dlaczego komponent AngularJS? ..................................................431Komponent AngularJS .................................................................433Przegl d cyklu ycia aplikacji AngularJS .........................................436Integrowanie komponentu AngularJS
z istniej cym kodem JavaScript i jQuery ......................................437Dodawanie komponentu AngularJS do rodowiska Node.js .............438Inicjowanie komponentu AngularJS w dokumencie HTML ................438U ycie globalnych interfejsów API .................................................439Tworzenie prostej aplikacji AngularJS ............................................441Podsumowanie ...........................................................................445W nast pnym rozdziale ................................................................445
Rozdzia 21 Modu y komponentu AngularJS i wstrzykiwanie zale no ci .....447Przegl d modu ów i wstrzykiwania zale no ci .................................447Definiowanie modu ów AngularJS .................................................448Implementowanie wstrzykiwania zale no ci ...................................452Podsumowanie ...........................................................................454W nast pnym rozdziale ................................................................454
Rozdzia 22 Implementowanie zasi gu jako modelu danych .................455Zasi gi .......................................................................................455Implementowanie hierarchii zasi gów ...........................................461Emitowanie i rozg aszanie zdarze ................................................463Podsumowanie ...........................................................................467W nast pnym rozdziale ................................................................468
Rozdzia 23 Tworzenie widoków za pomoc szablonów rodowiskaAngularJS ........................................................................469Szablony ....................................................................................469U ycie wyra e ............................................................................470U ycie filtrów ..............................................................................473Tworzenie filtrów niestandardowych ..............................................479Podsumowanie ...........................................................................482W nast pnym rozdziale ................................................................483
Kup książkę Poleć książkę
Spis tre ci 11
Rozdzia 24 Implementowanie dyrektyww widokach aplikacji AngularJS ........................................485Dyrektywy ...................................................................................485U ycie wbudowanych dyrektyw ......................................................486Tworzenie w asnych dyrektyw do rozszerzania kodu HTML ...............500Podsumowanie ...........................................................................509W nast pnym rozdziale ................................................................509
Rozdzia 25 Implementowanie us ug rodowiska AngularJSw aplikacjach internetowych ............................................511Us ugi rodowiska AngularJS ........................................................511U ycie wbudowanych us ug ..........................................................512Tworzenie us ug niestandardowych ...............................................527Podsumowanie ...........................................................................529W nast pnym rozdziale ................................................................529
Cz VI Tworzenie praktycznych komponentówaplikacji internetowych ....................................531
Rozdzia 26 Dodawanie kont u ytkowników do witryny internetowej .....533U ywane biblioteki .......................................................................533Struktura katalogowa projektu ......................................................534Definiowanie modelu u ytkowników ..............................................535Tworzenie serwera ......................................................................535Implementowanie tras .................................................................537Implementowanie tras kontrolera u ytkowników .............................538Implementowanie widoków u ytkownika i uwierzytelniania ..............543Implementowanie modu u i kontrolera rodowiska AngularJS ..........549U ycie kont spo eczno ciowych jako róde uwierzytelniania ............549Podsumowanie ...........................................................................555W nast pnym rozdziale ................................................................556
Rozdzia 27 Dodawanie w tków komentarzy do stron ..........................557U ywane biblioteki .......................................................................557Struktura katalogowa projektu ......................................................558Definiowanie modeli komentarzy, odpowiedzi, zdj i stron .............559Tworzenie serwera komentarzy .....................................................561Implementowanie tras do obs ugi wy wietlania
i dodawania komentarzy ............................................................563Implementowanie tras kontrolerów opartych na modelu .................563Implementowanie widoków komentarzy i zdj ...............................569Implementowanie modu u i kontrolerów rodowiska AngularJS
do obs ugi widoków komentarzy .................................................576Inicjowanie aplikacji ....................................................................581Podsumowanie ...........................................................................583W nast pnym rozdziale ................................................................583
Kup książkę Poleć książkę
12 Node.js, MongoDB, AngularJS. Kompendium wiedzy
Rozdzia 28 Tworzenie w asnego koszyka zakupów ..............................585Opis projektu ..............................................................................585U ywane biblioteki .......................................................................586Struktura katalogowa projektu ......................................................586Definiowanie modeli klientów, produktów i zamówie .....................588Tworzenie serwera koszyka zakupów .............................................592Implementowanie tras do obs ugi da
dotycz cych produktów, koszyka i zamówie ...............................593Implementowanie tras kontrolera opartego na modelu ...................594Implementowanie widoków kasy i koszyka zakupów .......................598Implementowanie modu u i kontrolera rodowiska AngularJS
do obs ugi widoków koszyka zakupów .........................................611Inicjowanie aplikacji ....................................................................619Podsumowanie ...........................................................................621W nast pnym rozdziale ................................................................621
Rozdzia 29 Tworzenie interaktywnych komponentówaplikacji Web 2.0 .............................................................623Opis projektu ..............................................................................623U ywane biblioteki .......................................................................624Struktura katalogowa projektu ......................................................624Definiowanie modelu projektu ......................................................626Tworzenie serwera aplikacji ..........................................................626Implementowanie tras do obs ugi widoków ....................................627Implementowanie widoku z kartami ..............................................628Implementowanie widoku us ugi pogodowej ...................................633Implementowanie elementów, które mo na przeci ga ...................637Implementowanie dost pu do danych dynamicznych ......................641Inicjowanie aplikacji ....................................................................646Podsumowanie ...........................................................................648
Skorowidz ........................................................................651
Kup książkę Poleć książkę
27Dodawanie wątków
komentarzy do stron
tym rozdziale zamieszczono praktyczny przykład implementowania pełnego stosuNode.js-MongoDB-AngularJS. Dowiesz się, jak umożliwić użytkownikom
dodawanie zagnieżdżonych komentarzy do jednego lub większej liczby obszarów stronyinternetowej. Opcja dodawania komentarzy stanowi typowy element wielu witryninternetowych. Wiąże się z tym kilka trudności.
Przykład zaprezentowany w tym rozdziale prezentuje pojedynczą stronę internetową,która umożliwia komentowanie całej strony, a także poszczególnych zdjęć ładowanychna stronie. Kod jest prosty i łatwy do prześledzenia.
Aby było Ci jeszcze łatwiej go prześledzić, nie uwzględniono w nim zarządzaniaużytkownikami, uwierzytelnianiem i sesjami. Jeśli chcesz przypomnieć sobie tezagadnienia, wróć do rozdziału 26. Przykład prezentowany w tym rozdziale zawieraniewielką funkcję, która symuluje użycie nazwy użytkownika w sesji w celu zezwolenia nawyświetlenie komentarzy wielu użytkowników.
U ywane bibliotekiW projekcie omawianym w tym rozdziale używane są dodatkowe moduły NPM środowiskaNode.js. Aby przejść dalej, musisz je zainstalować w katalogu projektu. Oto one:
express. Używany jako główny serwer WWW projektu. body-parser. Zapewnia obsługę treści JSON na potrzeby żądań POST.
ejs. Używany do renderowania szablonów HTML. mongodb. Używany do uzyskiwania dostępu do bazy danych MongoDB. mongoose. Używany do zapewniania modelu danych strukturyzowanych.
Kod w tym rozdziale wymaga również dostępności biblioteki AngularJS.
W
Kup książkę Poleć książkę
558 Rozdzia 27. Dodawanie w tków komentarzy do stron
Struktura katalogowa projektuProjekt zorganizowano w ramach następującej struktury katalogowej:
./. Zawiera podstawowe pliki aplikacji i foldery pomocnicze. Jest to głównykatalog projektu.
../node_modules. Jest tworzony po zainstalowaniu w systemiewyszczególnionych wcześniej modułów NPM.
./controllers. Zawiera kontrolery tras komponentu Express, które zapewniająinterakcję między trasami i zmianami w bazie danych MongoDB.
./models. Zawiera definicje modelu biblioteki Mongoose dla obiektów w baziedanych.
./static. Zawiera wszystkie pliki statyczne, które należy wysłać (np. kod CSSi kod aplikacji AngularJS).
./views. Zawiera szablony HTML, które będą renderowane przez mechanizm EJS.
UwagaJest to tylko jedna z metod organizowania kodu. Cho nie musisz korzysta z takiejstruktury katalogowej, pami taj o tym, e struktura powinna stanowi czogólnej koncepcji projektów, aby atwiejsze by o znalezienie szukanego kodu.
Oprócz struktury katalogowej do projektu dołączane są poniższe pliki z kodem.Następująca lista ma na celu ułatwienie Ci zorientowania się w funkcjonalności każdego pliku:
./comment_init.js. Zapewnia autonomiczny kod inicjalizacji. W celuprzeprowadzenia inicjalizacji projektu kod dodaje do bazy danych MongoDBobiekt strony początkowej i kilka zdjęć.
./comment_server.js. Ładuje niezbędne biblioteki, tworzy połączenie z baządanych MongoDB i uruchamia serwer Express. Jest to główny plik aplikacji.
./comment_routes.js. Definiuje trasy dla serwera Express. Plik ten obsługujefunkcje, które nie dotyczą bazy danych.
./controllers/comments_controller.js. Definiuje funkcje dla tras, które wymagająinterakcji z bazą danych MongoDB w celu pobierania i aktualizowaniakomentarzy.
./controllers/pages_controller.js. Definiuje funkcje dla tras, które wymagająinterakcji z bazą danych MongoDB w celu pobierania obiektów strony.
./controllers/photos_controller.js. Definiuje funkcje dla tras, które wymagająinterakcji z bazą danych MongoDB w celu pobierania jednego lub wszystkichobiektów zdjęć.
./models/comments_model.js. Definiuje model obiektów komentarzy.
./models/page_model.js. Definiuje model stron komentarzy. ./models/photo_model.js. Definiuje model zdjęć komentarzy.
Kup książkę Poleć książkę
Definiowanie modeli komentarzy, odpowiedzi, zdj i stron 559
./views/photos.html. Zapewnia dla aplikacji główną stronę zdjęć, która umożliwiużytkownikom wybranie zdjęć i dodanie komentarzy do strony lub wybranegozdjęcia.
./static/comment.html. Umożliwia wyświetlenie zagnieżdżonych komentarzyprzy użyciu dyrektywy ng-repeat. Jest to częściowy szablon środowiska AngularJS.
./static/comment_thread.html. Udostępnia środowisko do dodawania wątkukomentarzy w różnych miejscach na stronie internetowej. Jest to częściowyszablon środowiska AngularJS.
./static/js/comment_app.js. Zapewnia definicje kontrolerów i modułów środowiskaAngularJS w celu obsługi pobierania obiektów stron, zdjęć i komentarzy z serwerów,a także zapisywania nowych komentarzy.
./static/css/comment_styles.css. Udostępnia style CSS dla stron HTMLśrodowiska AngularJS.
../images. Zawiera obrazy używane w przykładzie. Odpowiada folderowi dla tegorozdziału, który wchodzi w skład archiwum kodów książki.
../lib. Zawiera niezbędne pliki biblioteki AngularJS, które są używane w omawianymprzykładzie. Odpowiada folderowi dla tego rozdziału, który wchodzi w składarchiwum kodów książki.
Definiowanie modeli komentarzy, odpowiedzi,zdj i stronPierwszym krokiem procesu implementowania aplikacji zawsze powinno być przyjrzeniesię wymaganiom modelu obiektów. W omawianym przykładzie celem jest umożliwienieużytkownikom dodawania komentarzy do stron internetowych. Aby to zrobić, musisznajpierw zidentyfikować obiekty, do których użytkownicy mogą dodawać komentarze.Przykład prezentuje stronę internetową zawierającą kilka zdjęć. By zezwolić użytkownikomna dołączanie komentarzy zarówno do witryny internetowej, jak i do poszczególnych zdjęć,wykorzystasz możliwość wielokrotnego użycia. Aby zapewnić obiekty, do którychzostaną dołączone komentarze, niezbędny jest model dla stron i zdjęć. W dalszej częścirozdziału omówiono projekty schematów modeli.
Definiowanie modelu PageKod z listingu 27.1 implementuje schemat modelu Page dla aplikacji. Schemat jest bardzoprosty. Zawiera jedynie pola name i commentId. Zauważ, że pole name skonfigurowano jakounikalne, co jest niezbędne, by było możliwe wyszukiwanie strony według nazwy.Głównym zadaniem modelu Page jest udostępnienie miejsca, w którym będzie możnapowiązać stronę internetową z wątkiem komentarzy.
Kup książkę Poleć książkę
560 Rozdzia 27. Dodawanie w tków komentarzy do stron
Listing 27.1. Plik page_model.js: implementowanie modelu Page dla biblioteki Mongoose
01 var mongoose = require('mongoose'),02 Schema = mongoose.Schema;03 var PageSchema = new Schema({04 name: {type: String, unique: true},05 commentId: Schema.ObjectId06 });07 mongoose.model('Page', PageSchema);
Definiowanie modelu PhotoKod z listingu 27.2 implementuje schemat modelu Photo dla aplikacji. Ten schematrównież jest bardzo prosty. Zawiera pola title, filename, timestamp i commentId. PolecommentId ma takie samo przeznaczenie jak pole commentId w modelu Page. To wielokrotnieużywane pole ułatwia późniejsze dodawanie komentarzy do dowolnych dodatkowychmodeli stron lub obiektów, które mają zostać dołączone do aplikacji.
Listing 27.2. Plik photo_model.js: implementowanie modelu Photo dla biblioteki Mongoose
01 var mongoose = require('mongoose'),02 Schema = mongoose.Schema;03 var PhotoSchema = new Schema({04 title: String,05 filename: String,06 timestamp: { type: Date, default: Date.now },07 commentId: Schema.ObjectId08 });09 mongoose.model('Photo', PhotoSchema);
Definiowanie modelu CommentThreadModel komentarzy ma za zadanie obsługiwanie zagnieżdżonych komentarzy.W komponencie MongoDB dostępne są dwie różne metody, które to umożliwiają.Możesz zapisać każdy komentarz jako pojedynczy dokument i zapewnić odsyłaczdo obiektów nadrzędnych, ale możesz też zapamiętać wszystkie komentarze wątkuw jednym dokumencie. Obie metody działają, wiążą się z nimi jednak bardzo odmienneimplementacje i konsekwencje.
Przechowywanie drzewa komentarzy w jednym dokumencie ułatwia i przyspieszaładowanie danych z bazy MongoDB. Mankamentem jest to, że z powodu braku ustalonejgłębokości dla komentarzy po dodaniu nowych komentarzy wymagane jest zapisaniecałej struktury odpowiedzi. Ponadto musisz pobrać cały dokument, aby uzyskać dowolnyz komentarzy.
Przechowywanie komentarzy jako pojedynczych dokumentów oznacza łatwośćwyszukiwania wybranego dokumentu, a także zapisywania dowolnych dodatkowychkomentarzy/odpowiedzi, gdyż są one odrębnymi dokumentami. Aby jednak załadować
Kup książkę Poleć książkę
Tworzenie serwera komentarzy 561
całe drzewo komentarzy, musisz zaimplementować złożoną funkcję agregacji lubprzeprowadzić wiele wyszukiwań w celu zbudowania drzewa. Oba rozwiązania sąznacznie mniej efektywne niż załadowanie pojedynczego dokumentu.
Ze względu na to, że komentarze są bardzo często wczytywane, lecz rzadko tworzone,dobrą opcją jest zapisanie struktury zagnieżdżonych komentarzy/odpowiedzi w pojedynczymdokumencie bazy danych MongoDB, a następnie zaktualizowanie całej struktury po dodaniunowego komentarza.
Kod z listingu 27.3 implementuje schematy modeli CommentThread i Reply. Schematmodelu CommentThread pełni rolę głównego dokumentu dla komentarzy dotyczącychdanego obiektu. Schemat modelu Reply służy do przechowywania komentarzy/odpowiedzidodanych do strony lub zdjęcia. Zauważ, że pole replies obiektów Reply i CommentThreadto tablica obiektów schematu odpowiedzi:replies:[ReplySchema]
Listing 27.3. Plik comments_model.js: implementowanie modelu CommentThread dla bibliotekiMongoose
01 var mongoose = require('mongoose'),02 Schema = mongoose.Schema;03 var ReplySchema = new Schema({04 username: String,05 subject: String,06 timestamp: { type: Date, default: Date.now },07 body: String,08 replies:[ReplySchema]09 }, { _id: true });10 var CommentThreadSchema = new Schema({11 title: String,12 replies:[ReplySchema]13 });14 mongoose.model('Reply', ReplySchema);15 mongoose.model('CommentThread', CommentThreadSchema);
Taka konfiguracja umożliwia wzajemne zagnieżdżanie komentarzy wewnątrz siebiei tworzenie na tym samym poziomie wielu komentarzy. Na rysunku 27.1 pokazanozagnieżdżoną strukturę w rzeczywistym dokumencie przechowywanym w bazie danychMongoDB.
Tworzenie serwera komentarzyPo zdefiniowaniu modelu możesz rozpocząć implementowanie serwera komentarzy.Kod z listingu 27.4 implementuje serwer Express dla aplikacji obsługującej komentarze.Kod powinien wyglądać znajomo. Zawiera on biblioteki express i mongoose, a ponadtonawiązuje połączenie z bazą danych MongoDB za pośrednictwem biblioteki Mongoose.
Kup książkę Poleć książkę
562 Rozdzia 27. Dodawanie w tków komentarzy do stron
Rysunek 27.1. Obiekt CommentThread z zagnie d onymi odpowiedziami przechowywanymiw bazie danych MongoDB
Listing 27.4. Plik comments_server.js: implementowanie serwera aplikacji komentarzyza pomoc serwera Express i przez nawi zywanie po czenia z baz danych MongoDB
01 var express = require('express');02 var bodyParser = require('body-parser');03 var mongoose = require('mongoose');04 var db = mongoose.connect('mongodb://localhost/comments');05 require('./models/comments_model.js');06 require('./models/photo_model.js');07 require('./models/page_model.js');08 var app = express();09 app.engine('.html', require('ejs').__express);10 app.set('views', __dirname + '/views');11 app.set('view engine', 'html');12 app.use(bodyParser());13 require('./comment_routes')(app);14 app.listen(80);
Zauważ, że dla każdej definicji modelu występuje instrukcja require. Służy onado tworzenia obiektu Schema w obrębie biblioteki Mongoose. Ponadto dołączono plik./comment_routes w celu zainicjowania tras dla serwera przed rozpoczęciemnasłuchiwania na porcie 80.
Kup książkę Poleć książkę
Implementowanie tras do obs ugi wy wietlania i dodawania komentarzy 563
Implementowanie tras do obs ugi wy wietlaniai dodawania komentarzyW ramach konfiguracji serwera Express ładowany jest plik ./comment_routes.js (listing 27.4).Kod z listingu 27.5 zapewnia trasy niezbędne do pobrania strony, zdjęcia i danychkomentarza, a także dodania komentarzy do zdjęć lub stron.
Listing 27.5. Plik comments_routes.js: implementowanie tras serwera aplikacji komentarzydla serwera Express
01 var express = require('express');02 module.exports = function(app) {03 var photos = require('./controllers/photos_controller');04 var comments = require('./controllers/comments_controller');05 var pages = require('./controllers/pages_controller');06 app.use('/static', express.static( './static')).07 use('/images', express.static( '../images')).08 use('/lib', express.static( '../lib')09 );10 app.get('/', function(req, res){11 res.render('photos');12 });13 app.get('/photos', photos.getPhotos);14 app.get('/photo', photos.getPhoto);15 app.get('/page', pages.getPage);16 app.get('/comments/get', comments.getComment);17 app.post('/comments/add', comments.addComment);18 }
W wierszach od 6. do 9. implementowane są trasy statyczne do obsługi pobieraniakodu CSS, kodu JavaScript, obrazów i częściowych szablonów środowiska AngularJS,które są wykorzystywane w omawianym przykładzie. Obrazy i foldery lib środowiskaAngularJS znajdują się w głównym katalogu projektów. Inne pliki statyczne są umieszczonew folderze ./static w obrębie projektu.
Zauważ, że gdy użytkownik uzyska dostęp do głównej lokalizacji witryny, w wierszu 9.renderowany jest szablon photos.html. Wszystkie trasy w wierszach od 13. do 17. prowadząinterakcję z bazą danych MongoDB, a ponadto są obsługiwane w procedurach obsługikontrolera opisanych w następnym podrozdziale.
Implementowanie tras kontrolerówopartych na modeluOprócz implementowania standardowej obsługi tras wymagane jest również zastosowanieobsługi tras do interakcji z bazą danych. Aby zachować przejrzystość kodu i zapewnićodpowiedni podział zakresu odpowiedzialności, takie procedury obsługi tras zostanąwydzielone ze standardowego pliku comment_route.js do ich własnych plików(dla każdego modelu).
Kup książkę Poleć książkę
564 Rozdzia 27. Dodawanie w tków komentarzy do stron
W kolejnych punktach omówiono implementację kontrolerów specyficznychdla modeli Page, Photo i CommentThread.
Implementowanie kontrolera modelu PageKod z listingu 27.6 implementuje kod obsługi tras dla modelu Page. Występuje tu tylkojedna trasa getPage(), która znajduje stronę na podstawie pola name i zwraca błąd lubpostać łańcuchową JSON obiektu. Nazwa strony do znalezienia trafia do parametrupageName w łańcuchu zapytania GET.
Listing 27.6. Plik pages_controller.js: implementowanie trasy getPage dla serwera Express
01 var mongoose = require('mongoose'),02 Page = mongoose.model('Page');03 exports.getPage = function(req, res) {04 Page.findOne({ name: req.query.pageName })05 .exec(function(err, page) {06 if (!page){07 res.json(404, {msg: 'Nie znaleziono strony.'});08 } else {09 res.json(page);10 }11 });12 };
Implementowanie kontrolera modelu PhotoKod z listingu 27.7 implementuje kod obsługi tras dla modelu Photo. Obsługiwane sądwie trasy. Procedura obsługi trasy getPhoto() wyszukuje pojedynczy dokument Photona podstawie pola _id przekazanego jako parametr photoId w łańcuchu zapytania GET.Procedura obsługi trasy getPhotos() pobiera wszystkie dokumenty Photo. Obie proceduryzwracają postać łańcuchową JSON wyników.
Listing 27.7. Plik photos_controller.js: implementowanie tras getPhoto i getPhotos na serwerzeExpress w celu pobierania zdj
01 var mongoose = require('mongoose'),02 Photo = mongoose.model('Photo');03 exports.getPhoto = function(req, res) {04 Photo.findOne({ _id: req.query.photoId })05 .exec(function(err, photo) {06 if (!photo){07 res.json(404, {msg: 'Nie znaleziono zdj cia.'});08 } else {09 res.json(photo);10 }11 });12 };13 exports.getPhotos = function(req, res) {14 Photo.find()
Kup książkę Poleć książkę
Implementowanie tras kontrolerów opartych na modelu 565
15 .exec(function(err, photos) {16 if (!photos){17 res.json(404, {msg: 'Nie znaleziono zdj .'});18 } else {19 res.json(photos);20 }21 });22 };
Implementowanie kontrolera modelu CommentThreadKod z listingu 27.8 implementuje kod obsługi tras dla modelu CommentThread. Obsługiwane sądwie trasy: getComment() i addComment(). Ze względu na wielkość pliku w kolejnychpunktach rozdzielono kod dla tych dwóch tras.
Listing 27.8. Plik comments_controller.js (getComment): implementowanie trasy do uzyskaniaw tków komentarzy dla serwera Express
04 exports.getComment = function(req, res) {05 CommentThread.findOne({ _id: req.query.commentId })06 .exec(function(err, comment) {07 if (!comment){08 res.json(404, {msg: 'Nie znaleziono modelu CommentThread.'});09 } else {10 res.json(comment);11 }12 });13 };
Implementowanie procedury obs ugi trasy getComment()Procedura obsługi trasy getComment() wyszukuje pojedynczy dokument CommentThreadna podstawie pola _id przekazanego jako parametr commentId w łańcuchu zapytaniażądania GET.
Implementowanie procedury obs ugi trasy addComment()Procedura obsługi trasy addComment(), której kod widać na listingu 27.9, jest trochębardziej złożona niż procedura getComment(), a ponadto uwzględnia łańcuch funkcjiobsługujących aktualizowanie zagnieżdżonych komentarzy. Przebieg procesu dodawanianowych komentarzy jest następujący:
1. Klient wysyła żądanie zawierające identyfikator CommentThread, identyfikatorkomentarza nadrzędnego, do którego ma zostać dodany nowy komentarz,oraz obiekt JSON reprezentujący nowy komentarz.
2. Procedura obsługi trasy /comment/add wywołuje procedurę addComment().
3. Obiekt CommentThread jest lokalizowany przy użyciu wartościreq.body.rootCommentId z danych żądania POST.
Kup książkę Poleć książkę
566 Rozdzia 27. Dodawanie w tków komentarzy do stron
4. Nowy obiekt Reply o nazwie newComment jest tworzony przy użyciu wartościreq.body.newComment z danych żądania POST.
5. Procedura obsługi addComment() jest uruchamiana rekurencyjnie w celuprzeszukiwania zagnieżdżonych komentarzy do momentu znalezieniakomentarza, który jest zgodny z wartością req.body.parentCommentIdprzekazaną z treści żądania POST.
6. Nowy komentarz jest umieszczany w tablicy replies komentarza nadrzędnego.
7. Metoda updateCommentThread() używa następującej operacji update(), abyzaktualizować pole replies w dokumencie CommentThread za pomocą pola,które zawiera teraz zaktualizowany komentarz:CommentThread.update({ _id: commentThread.id }, {$set:{replies:commentThread.replies}}).exec();
8. Odpowiedź informująca o powodzeniu lub niepowodzeniu jest odsyłana do klienta.
Listing 27.9. Plik comments_controller.js: implementowanie procedury obs ugi trasyaddComment() dla serwera Express
14 exports.addComment = function(req, res) {15 CommentThread.findOne({ _id: req.body.rootCommentId })16 .exec(function(err, commentThread) {17 if (!commentThread){18 res.json(404, {msg: 'Nie znaleziono modelu CommentThread.'});19 } else {20 var newComment = Reply(req.body.newComment);21 newComment.username = generateRandomUsername();22 addComment(req, res, commentThread, commentThread,23 req.body.parentCommentId, newComment);24 }25 });26 };27 function addComment(req, res, commentThread, currentComment,28 parentId, newComment){29 if (commentThread.id == parentId){30 commentThread.replies.push(newComment);31 updateCommentThread(req, res, commentThread);32 } else {33 for(var i=0; i< currentComment.replies.length; i++){34 var c = currentComment.replies[i];35 if (c._id == parentId){36 c.replies.push(newComment);37 var replyThread = commentThread.replies.toObject();38 updateCommentThread(req, res, commentThread);39 break;40 } else {41 addComment(req, res, commentThread, c,42 parentId, newComment);43 }44 }
Kup książkę Poleć książkę
Implementowanie tras kontrolerów opartych na modelu 567
45 }46 };47 function updateCommentThread(req, res, commentThread){48 CommentThread.update({ _id: commentThread.id },49 {$set:{replies:commentThread.replies}})50 .exec(function(err, savedComment){51 if (err){52 res.json(404, {msg: 'Nie zaktualizowano modelu CommentThread.'});53 } else {54 res.json({msg: "Powodzenie"});55 }56 });57 }
Analiza procedury obs ugi tras modelu CommentListing 27.10 prezentuje pełną implementację pliku comments_controller.js, któryzapewnia obsługę tras dotyczącą modelu Comment. Kod tej procedury ładuje schemat dlamodeli CommentThread i Reply. Model CommentThread zapewnia możliwość wyszukiwaniadokumentów, a także aktualizowania ich po dodaniu nowych komentarzy. Model Replytworzy obiekt Reply w momencie dodania nowego komentarza.
Listing 27.10. Plik comments_controller.js: pe na implementacja procedur obs ugi tras modeluComment dla serwera Express
01 var mongoose = require('mongoose'),02 CommentThread = mongoose.model('CommentThread'),03 Reply = mongoose.model('Reply');04 exports.getComment = function(req, res) {05 CommentThread.findOne({ _id: req.query.commentId })06 .exec(function(err, comment) {07 if (!comment){08 res.json(404, {msg: 'Nie znaleziono modelu CommentThread.'});09 } else {10 res.json(comment);11 }12 });13 };14 exports.addComment = function(req, res) {15 CommentThread.findOne({ _id: req.body.rootCommentId })16 .exec(function(err, commentThread) {17 if (!commentThread){18 res.json(404, {msg: 'Nie znaleziono modelu CommentThread.'});19 } else {20 var newComment = Reply(req.body.newComment);21 newComment.username = generateRandomUsername();22 addComment(req, res, commentThread, commentThread,23 req.body.parentCommentId, newComment);24 }25 });26 };
Kup książkę Poleć książkę
568 Rozdzia 27. Dodawanie w tków komentarzy do stron
27 function addComment(req, res, commentThread, currentComment,28 parentId, newComment){29 if (commentThread.id == parentId){30 commentThread.replies.push(newComment);31 updateCommentThread(req, res, commentThread);32 } else {33 for(var i=0; i< currentComment.replies.length; i++){34 var c = currentComment.replies[i];35 if (c._id == parentId){36 c.replies.push(newComment);37 var replyThread = commentThread.replies.toObject();38 updateCommentThread(req, res, commentThread);39 break;40 } else {41 addComment(req, res, commentThread, c,42 parentId, newComment);43 }44 }45 }46 };47 function updateCommentThread(req, res, commentThread){48 CommentThread.update({ _id: commentThread.id },49 {$set:{replies:commentThread.replies}})50 .exec(function(err, savedComment){51 if (err){52 res.json(404, {msg: 'Nie zaktualizowano modelu CommentThread.'});53 } else {54 res.json({msg: "Powodzenie"});55 }56 });57 }58 function generateRandomUsername(){59 // nazwa u ytkownika b dzie zwykle pochodzi z uwierzytelnionej sesji60 var users=['Dawid', 'Karol', 'Bartek', 'Janek', 'Adam', 'Tomek'];61 return users[Math.floor((Math.random()*5))];62 }
Kod kontrolera komentarzy udostępnia funkcję, która losowo generuje nazwęużytkowników do celów testowych:
function generateRandomUsername(){ //nazwa u ytkownika b dzie zwykle pochodzi z uwierzytelnionej sesji var users=['Dawid', 'Karol', 'Bartek', 'Janek', 'Adam', 'Tomek']; return users[Math.floor((Math.random()*6))];}
Choć nazwa użytkownika będzie zwykle pochodzić z sesji w obiekcie Request, w tymmiejscu pominięto kod sesji, aby ułatwić Ci przeanalizowanie przykładu.
Kup książkę Poleć książkę
Implementowanie widoków komentarzy i zdj 569
Implementowanie widoków komentarzy i zdjPo utworzeniu i skonfigurowaniu tras możesz rozpocząć implementowanie widokówrenderowanych przez trasy i szablony AngularJS. W kolejnych punktach omówionowidok photos.html renderowany przez mechanizm EJS, a także częściowe widokicomment.html i comment_thread.html, które są udostępniane statycznie.
Implementowanie widoku zdjWidok zdjęć zaprezentowany na listingu 27.11 to główny widok aplikacji w omawianymprzykładzie. Widok jest ładowany w głównej trasie /. Nagłówek widoku rejestrujeelement <html> w aplikacji AngularJS i ładuje plik comment_styles.css. Element <body>jest rozdzielany na dwie podstawowe sekcje.
Listing 27.11. Plik photos.html: implementowanie kodu g ównego szablonu AngularJS stronyze zdj ciami
01 <!doctype html>02 <html ng-app="myApp">03 <head>04 <title>Komentarze</title>05 <link rel="stylesheet" type="text/css"06 href="/static/css/comment_styles.css" />07 </head>08 <body>09 <h2>Przyk ad komentarzy</h2>10 <div ng-controller="photoController">11 <div id="photosContainer">12 <div class="photoItem" ng-repeat="photo in photos">13 <img class="listPhoto" ng-click="setPhoto(photo._id)"14 ng-src="../images/{{photo.filename}}" />15 </div>16 </div>17 <div>18 <div id="photoContainer">19 <p class="imageTitle">{{photo.title}}</p>20 <img class="mainPhoto"21 ng-src="../images/{{photo.filename}}" />22 </div>23 <div id="photoComments"24 ng-init="addComment=false;replySubject='';replyBody=''">25 <div class="comment"26 ng-include="'/static/comment_thread.html'"></div>27 </div>28 </div>29 </div>30 <div ng-controller="pageController">31 <div id="pageComments"32 ng-init="addComment=false;replySubject='';replyBody=''">33 <div class="comment"34 ng-include="'/static/comment_thread.html'"></div>
Kup książkę Poleć książkę
570 Rozdzia 27. Dodawanie w tków komentarzy do stron
35 </div>36 </div>37 <script src="http://code.angularjs.org/1.2.9/angular.min.js"></script>38 <script src="/static/js/comment_app.js"></script>39 </body>40 </html>
W górnej sekcji inicjowany jest kontroler ng-controller="photoController"środowiska AngularJS w celu zapewnienia funkcji umożliwiających interakcję zezdjęciami z serwera WWW, w tym z dotyczącymi ich komentarzami. W dolnej sekcjiinicjowany jest kontroler ng-controller="pageController", aby udostępnić funkcjepozwalające na interakcję z komentarzami na stronie internetowej. Oba kontrolery służądo izolowania zasięgu, ponieważ implementują sekcje komentarzy.
Następujący kod definiuje szablon AngularJS, który renderuje tablicę dokumentówPhoto przechowywaną w obiekcie $scope.photos modelu przy użyciu dyrektywy ng-repeat:
<div id="photosContainer"> <div class="photoItem" ng-repeat="photo in photos"> <img class="listPhoto" ng-click="setPhoto(photo._id)" ng-src="../images/{{photo.filename}}" /> </div></div>
Zauważ, że w celu ustawienia bieżącego zdjęcia w kodzie kontrolera dla dyrektywyng-click ustawiono metodę setPhoto(). Na rysunku 27.2 pokazano elementwyrenderowany na stronach.
Rysunek 27.2. Zdj cia renderowane w przegl darce jako elementy <img>
Następujący kod szablonu wyświetla na ekranie bieżący obiekt $scope.photo przyużyciu właściwości photo.title. Ponadto za pomocą właściwości photo.filename kodustawia dla atrybutu src element <img>:
<div id="photoContainer"> <p class="imageTitle">{{photo.title}}</p> <img class="mainPhoto" ng-src="../images/{{photo.filename}}" /></div>
Na rysunku 27.3 pokazano wyświetloną część strony ze zdjęciem.
Kup książkę Poleć książkę
Implementowanie widoków komentarzy i zdj 571
Rysunek 27.3. Wi kszy widok zdj cia i tytu u wy wietlony w przegl darce
Część strony internetowej z komentarzami dodajesz za pomocą poniższego kodu,który używa dyrektywy ng-init do inicjowania wartości addComment, replySubjecti replyBody w bieżącym zasięgu, a następnie korzysta z dyrektywy ng-include, aby dołączyćkod częściowego szablonu comment_thread.html opisanego w następnym punkcie.
<div id="photoComments" ng-init="addComment=false;replySubject='';replyBody=''"> <div class="comment" ng-include="'/static/comment_thread.html'"></div></div>
Sekcja podobna do powyższej jest dodawana do części strony ze zdjęciami, a także nadole strony. Umożliwia to wstawianie komentarzy w obu miejscach. Wartość addCommentjest używana w szablonie comment_thread.html do określenia, czy komentarze majązostać włączone, czy wyłączone.
Na rysunku 27.4 pokazano pełną aplikację z komentarzami w sekcji zdjęć oraz nadole strony.
Implementowanie widoku w tku komentarzyJak wspomniano w poprzednim punkcie, sekcja zdjęć i sekcja głównego obrazu stronyze zdjęciami korzystają z dyrektywy ng-include, aby dołączyć szablon częściowycomment_thread.html, który został zaprezentowany na listingu 27.12. Szablon ten zostałwydzielony, aby łatwiej było go w późniejszym czasie dołączyć do innych stron, a nawetdodatkowych sekcji tej samej strony.
Kup książkę Poleć książkę
572 Rozdzia 27. Dodawanie w tków komentarzy do stron
Rysunek 27.4. Wy wietlona strona zdj z komentarzami w obszarze zdj i na dole strony
Listing 27.12. Plik comment_thread.html: implementowanie cz ciowego szablonu w tku komentarzy
01 <span class="commentTitle">{{commentThread.title}}</span>02 <input type="button" ng-show="addComment==false"03 value="Dodaj komentarz" ng-click="addComment=true"></input>04 <form ng-show="addComment==true">05 <label>Temat</label>06 <input type="text" ng-model="replySubject")></input>07 <label>Komentarz</label>08 <textarea ng-model="replyBody"></textarea>09 <input type="button" value="Wy lij"10 ng-click=11 "addComment=false; addReply(commentThread._id,replySubject,replyBody)"12 ></input>13 </form>14 <input type="button" ng-show="addComment==true"15 value="Anuluj" ng-click="addComment=false;"></input>16 <div ng-repeat="comment in commentThread.replies"17 ng-init="reply=false;replySubject='';replyBody=''">18 <div class="comment" ng-include="'/static/comment.html'"></div>19 </div>
Szablon częściowy uwzględnia tytuł CommentThread przy użyciu kodu{{commentThread.title}}. Przycisk elementu <input> przełącza atrybut addCommentna wartość true, umożliwiając wyświetlenie formularza odpowiedzi (aktualnie ukryto goza pomocą dyrektywy ng-show). W obrębie tego formularza definiowany jest element<input> wraz z treścią komentarza <textarea> (rysunek 27.5). Przycisk Dodaj komentarz
Kup książkę Poleć książkę
Implementowanie widoków komentarzy i zdj 573
powoduje wykonanie metody addReply() w zasięgu i przekazanie kontrolerowi wartościcommentThread._id, replySubject i replyBody w celu wysłania do serwera żądaniadodania komentarza.
Rysunek 27.5. Obszar w tku komentarzy z przyciskiem Dodaj komentarzi formularz s u cy do dodania komentarza
Na rysunku 27.5 pokazano widok wątku komentarzy wyrenderowany przedkliknięciem przycisku Dodaj komentarz oraz formularz odpowiedzi, który zostanieotwarty po kliknięciu tego przycisku.
Na dole szablonu wątku komentarzy w poniższych wierszach kodu używana jestdyrektywa ng-repeat do załadowania szablonu częściowego comment.html, któryrenderuje komentarz za pomocą dyrektywy ng-include. Zauważ też, że inicjowane sąwartości reply, replySubject i replyBody. Są one używane w szablonie komentarzydo wyświetlania/ukrywania formularza odpowiedzi, a także do przekazywania danychdo funkcji addReply():
<div ng-repeat="comment in commentThread.replies" ng-init="reply=false;replySubject='';replyBody=''"> <div class="comment" ng-include="'/static/comment.html'"></div></div>
Implementowanie widoku komentarzyJak wspomniano w poprzednim punkcie, sekcja wątku komentarzy strony używa dyrektywyng-include do dołączenia szablonu częściowego comment.html (jego kod zostałzaprezentowany na listingu 27.13) dla każdej odpowiedzi w tablicy replies obiektukomentarzy.
Listing 27.13. Plik comment_thread.html: implementowanie cz ciowego szablonu komentarzy
01 <span class="username">{{comment.username}}</span>:02 <span class="subject">{{comment.subject}}</span>03 <p class="timestamp"04 >posted {{comment.timestamp|date:"MMMM d yyyy H:mm"}}</p>
Kup książkę Poleć książkę
574 Rozdzia 27. Dodawanie w tków komentarzy do stron
05 <p class="commentBody">{{comment.body}}</p>06 <input type="button" ng-show="reply==false"07 value="Odpowiedz" ng-click="reply=true"></input>08 <form ng-if="reply">09 <label>Temat</label>10 <input type="text" ng-model="replySubject")></input>11 <label>Komentarz</label>12 <textarea ng-model="replyBody"></textarea>13 <input type="button" value="Wy lij"14 ng-click="addReply(comment._id,replySubject,replyBody)" />15 </form>16 <input type="button" ng-show="reply==true"17 value="Anuluj" ng-click="reply=false;"></input>18 <div ng-repeat="comment in comment.replies"19 ng-init="reply=false;replySubject='';replyBody=''">20 <div class="comment" ng-include="'/static/comment.html'"></div>21 </div>
Korzystając na tym etapie z szablonu częściowego, możesz zagnieżdżać odpowiedziw innych odpowiedziach po prostu przez wczytanie tego samego bloku (zostało to pokazaneponiżej) do przeprowadzenia iteracji odpowiedzi za pomocą dyrektywy ng-repeat.Do dołączenia tego samego formularza stosowana jest też dyrektywa ng-include.
<div ng-repeat="comment in comment.replies" ng-init="reply=false;replySubject='';replyBody=''"> <div class="comment" ng-include="'/static/comment.html'"></div></div>
Szablon częściowy comment.html zawiera nazwę użytkownika, temat, znacznik czasui treść komentarza. Przycisk elementu <input> przełącza atrybut reply na wartość true,umożliwiając wyświetlenie formularza odpowiedzi (aktualnie ukryto go za pomocądyrektywy ng-show). Formularz odpowiedzi widoczny na rysunku 27.6 przypominaformularz służący do dodania pierwszego komentarza. Przycisk Odpowiedz powodujewykonanie metody addReply() w zasięgu i przekazanie kontrolerowi wartości comment._id,replySubject i replyBody w celu wysłania do serwera żądania dodania komentarza.
Na rysunku 27.6 pokazano widok wątku odpowiedzi wyrenderowany przedkliknięciem przycisku Odpowiedz oraz formularz odpowiedzi, który zostanie otwartypo kliknięciu tego przycisku.
Dodawanie kodu CSS w celu okre lenia stylówwidokówListing 27.14 prezentuje kod CSS używany do określenia stylów dla elementów widokuzdjęć, a także szablonów częściowych AngularJS.
Kup książkę Poleć książkę
Implementowanie widoków komentarzy i zdj 575
Rysunek 27.6. Udzielanie odpowiedzi na komentarz znajduj cy si w w tku
Listing 27.14. Plik comment_styles.css: implementowanie stylów CSS dla plików HTML widoków
01 div#photosContainer{02 background:black; color: white;03 border: 4px ridge blue; width:800px;04 }05 div.photoItem{ display:inline-block; width:120px; }06 div#photoContainer,07 div#photoComments{08 background:black; color: white; width: 400px; height:450px;09 display: inline-block; float:left; border: 2px ridge blue;10 }11 div#photoComments{ background:white; color: black;12 max-height:500px; overflow-y:scroll;13 }14 div#pageComments{ margin:0px; clear:both; width:810px; }15 div.comment{ border: 2px ridge blue; padding:10px;16 border-radius: 5px;17 }18 img.listPhoto{ width:100px; }19 img.mainPhoto{ width:400px; }20 .commentBody{ background-color:lightgray;21 border-radius: 5px; padding: 5px; margin:0;22 }23 .imageTitle{ font-size: 28px; font-weight: bold;24 text-align: center; margin:025 }26 .commentTitle{ font-size: 18px; font-weight: bold;}27 .username{ font-style: italic; color:blue; }28 .subject{ font-weight: bold;}29 .timestamp{ color:#555555; font-style: italic;30 font-size: 12px; text-align: right; margin:0;31 }32 input[type="text"],33 textarea{ border: 2px ridge blue; border-radius: 5px;34 padding:3px; width:95%;
Kup książkę Poleć książkę
576 Rozdzia 27. Dodawanie w tków komentarzy do stron
35 }36 input[type="button"]{ background-color:blue;color:white;37 border-radius: 5px;38 }
Implementowanie modu u i kontrolerówrodowiska AngularJS do obs ugi widoków
komentarzyImplementowanie modu u i kontrolerów AngularJS do obs ugi widoków komentarzy
Po zakończeniu tworzenia widoków niezbędne jest zaimplementowanie kodu kontroleraśrodowiska AngularJS do ich obsługi. Widoki wymagają możliwości uzyskania strony,zdjęć i komentarzy, a ponadto dodania nowych komentarzy.
Należy udostępnić dwa kontrolery: po jednym dla komentarzy dotyczących zdjęći komentarzy na pełnej stronie. Ponieważ istnieje wiele kontrolerów, które wymagająinterakcji z serwerem w celu pobierania i dodawania komentarzy, dobrym pomysłem jestteż utworzenie usługi obsługującej te dwie operacje. W dalszej części rozdziału opisanoproces tworzenia kompletnego kodu aplikacji AngularJS, który został zaprezentowanyna listingu 27.18.
Tworzenie us ugi komentarzyZe względu na to, że do obsługi pobierania i dodawania komentarzy niezbędna będzieusługa komentarzy, w pierwszej kolejności musisz ją dodać. Kod z listingu 27.15implementuje usługę komentarzy, która korzysta z metody usługi. Konieczne jestutworzenie definicji funkcji o nazwie CommentObj. Jako jedyny parametr funkcjakonstruktora akceptuje usługę $http.
Listing 27.15. Plik comment_app.js (commentSrv): implementowanie us ugi AngularJS,która zapewnia funkcje wielokrotnego u ycia s u ce do pobierania komentarzy z serweraoraz dodawania na nim nowych komentarzy
02 function CommentObj($http) {03 this.getComment = function(commentId, callback){04 $http.get('/comments/get', {params: {commentId: commentId}})05 .success(function(data, status, headers, config) {06 callback(null, data);07 })08 .error(function(data, status, headers, config) {09 callback(data, {});10 });11 };12 this.addComment = function(rootCommentId, parentId,13 newComment, callback){14 $http.post('/comments/add', { rootCommentId: rootCommentId,15 parentCommentId: parentId,16 newComment: newComment })
Kup książkę Poleć książkę
Implementowanie modu u i kontrolerów AngularJS do obs ugi widoków komentarzy 577
17 .success(function(data, status, headers, config) {18 callback(null, data);19 })20 .error(function(data, status, headers, config) {21 });22 };23 }24 app.service('commentSrv', ['$http', CommentObj]);
Definiowana jest funkcja getComment(), która akceptuje parametr commentId,a następnie kieruje żądanie GET do trasy /comment/get w celu pobrania danych całegokomentarza. Zauważ, że funkcja akceptuje też funkcję wywołania zwrotnego. Zwracaona błąd (jeśli zostanie zgłoszony przez usługę $http) lub dane komentarza z serwera.
Funkcja addComment() akceptuje parametr rootCommentId dla wątku komentarzy,parametr parentId dla komentarza nadrzędnego i parametr newComment, który jestobiektem JavaScript z właściwościami subject i body. Funkcja kieruje żądanie POSTdo trasy /comment/add w celu dodania nowego komentarza do bazy danych MongoDB.Podobnie jak w przypadku funkcji getComment(), wykonywana jest funkcja wywołaniazwrotnego i zwracane są wyniki. Przy użyciu następującego wiersza tworzona jestnastępnie usługa commentSrv w celu wstrzyknięcia usługi $http:
app.service('commentSrv', ['$http', CommentObj]);
Możliwe jest teraz wstrzyknięcie usługi commentSrv do używanych kontrolerów.
Implementowanie kontrolera zdjW dalszej kolejności konieczne jest zaimplementowanie kontrolera do obsługi częścistrony powiązanej ze zdjęciami. Listing 27.16 prezentuje kod kontrolera photoController.Zauważ, że do kontrolera jest wstrzykiwana usługa commentSrv wraz z usługą $http.
Listing 27.16. Plik comment_app.js (photoController): implementowanie kontrolera rodowiskaAngularJS, który obs uguje cz ci widoku powi zane ze zdj ciami i dotycz cymi ich komentarzami
25 app.controller('photoController', ['$scope', '$http', 'commentSrv',26 function($scope, $http, commentSrv) {27 $http.get('/photos')28 .success(function(data, status, headers, config) {29 $scope.photos = data;30 $scope.photo = $scope.photos[0];31 $scope.loadComments();32 })33 .error(function(data, status, headers, config) {34 $scope.photos = [];35 });36 $scope.loadComments = function(){37 commentSrv.getComment($scope.photo.commentId,38 function(err, comment){39 if(err){
Kup książkę Poleć książkę
578 Rozdzia 27. Dodawanie w tków komentarzy do stron
40 $scope.commentThread = {};41 } else {42 $scope.commentThread = comment;43 }44 });45 };46 $scope.addReply = function(parentCommentId, subject, body){47 var newComment = {subject:subject, body:body};48 commentSrv.addComment($scope.commentThread._id,49 parentCommentId,50 newComment, function(err, comment){51 $scope.loadComments();52 });53 };54 $scope.setPhoto = function(photoId){55 $http.get('/photo', {params: {photoId: photoId}})56 .success(function(data, status, headers, config) {57 $scope.photo = data;58 $scope.loadComments();59 })60 .error(function(data, status, headers, config) {61 $scope.photo = {};62 });63 };64 }]);
Kontroler inicjuje obiekty $scope.photos i $scope.photo przy użyciu żądania GETusługi $http kierowanego do trasy /photos. Funkcja $scope.loadComments() używafunkcji commentSrv.getComment() do pobrania komentarzy dla bieżącego zdjęciaprzez przekazanie parametru $scope.photo.commentId. Funkcja wywołania zwrotnegopo prostu ustawia wartość $commentThread używaną w widoku.
Metoda $scope.addReply() jest wywoływana po kliknięciu przez użytkownikaprzycisku Wyślij dla odpowiedzi do komentarza w szablonie. Zauważ, że metoda generujenajpierw obiekt newComment z tematem i treścią przekazywanymi z widoku, a następniekorzysta z metody commentSrv.addComment(), aby wysłać aktualizację do serwera.
Funkcja $setPhoto() akceptuje wartość photoID z interfejsu użytkownika, po czymkieruje żądanie GET usługi $http do trasy /photo w celu pobrania obiektu zdjęcia. Obiekt$scope.photo jest aktualizowany przy użyciu danych, a następnie wywoływana jestfunkcja $scope.loadComments() do załadowania komentarzy dla nowego folderu.
Implementowanie kontrolera rodowiska AngularJSdla stronyNastępnym wymaganym krokiem jest implementacja kontrolera do obsługi komentarzyna stronie internetowej. Kod z listingu 27.17 zawiera kod kontrolera pageController.Zauważ, że do tego kontrolera również jest wstrzykiwana usługa commentSrv wrazz usługą $http.
Kup książkę Poleć książkę
Implementowanie modu u i kontrolerów AngularJS do obs ugi widoków komentarzy 579
Listing 27.17. Plik comment_app.js (pageController): implementowanie kontrolera rodowiskaAngularJS, który obs uguje cz widoku zwi zan z komentarzami na stronie
65 app.controller('pageController', ['$scope', '$http','commentSrv',66 function($scope, $http, commentSrv) {67 $http.get('/page', {params:{pageName:"Strona ze zdj ciami"}})68 .success(function(data, status, headers, config) {69 $scope.page = data;70 $scope.loadComments();71 })72 .error(function(data, status, headers, config) {73 $scope.Page = {};74 });75 $scope.addReply = function(parentCommentId, subject, body){76 var newComment = {subject:subject, body:body};77 commentSrv.addComment($scope.commentThread._id,78 parentCommentId,79 newComment, function(err, comment){80 $scope.loadComments();81 });82 };83 $scope.loadComments = function(){84 commentSrv.getComment($scope.page.commentId,85 function(err, comment){86 if(err){87 $scope.commentThread = {};88 } else {89 $scope.commentThread = comment;90 }91 });92 };93 }]);
Kontroler inicjuje wartość $scope.page, tworzy żądanie GET usługi $http kierowanedo trasy /pages i przekazuje jako parametr umieszczoną na stałe w kodzie nazwę "Stronaze zdj ciami". Funkcja $scope.loadComments() wywołuje funkcję commentSrv.getComment(),aby pobrać komentarze dla strony przy użyciu wartości $scope.page.commentId. Funkcjawywołania zwrotnego ustawia po prostu wartość $commentThread używaną w widoku.
Metoda $scope.addReply() jest wywoływana po kliknięciu przez użytkownikaprzycisku Wyślij w szablonie komentarzy na stronie. Zauważ, że metoda generujenajpierw obiekt newComment z tematem i treścią przekazanymi z widoku, a następnieużywa metody commentSrv.addComment() do wysłania aktualizacji do serwera.
Kompletna aplikacja AngularJSListing 27.18 prezentuje w całości kod kompletnej aplikacji AngularJS. Zauważ,że w wierszu 1. definiowana jest aplikacja, a następnie w dalszych wierszach kodudodawana jest usługa commentSrv oraz kontrolery photoController i pageController.
Kup książkę Poleć książkę
580 Rozdzia 27. Dodawanie w tków komentarzy do stron
Listing 27.18. Plik comment_app.js: implementowanie aplikacji AngularJS obs uguj cejkomentarze na stronach internetowych
01 var app = angular.module('myApp', []);02 function CommentObj($http) {03 this.getComment = function(commentId, callback){04 $http.get('/comments/get', {params: {commentId: commentId}})05 .success(function(data, status, headers, config) {06 callback(null, data);07 })08 .error(function(data, status, headers, config) {09 callback(data, {});10 });11 };12 this.addComment = function(rootCommentId, parentId,13 newComment, callback){14 $http.post('/comments/add', { rootCommentId: rootCommentId,15 parentCommentId: parentId,16 newComment: newComment })17 .success(function(data, status, headers, config) {18 callback(null, data);19 })20 .error(function(data, status, headers, config) {21 });22 };23 }24 app.service('commentSrv', ['$http', CommentObj]);25 app.controller('photoController', ['$scope', '$http', 'commentSrv',26 function($scope, $http, commentSrv) {27 $http.get('/photos')28 .success(function(data, status, headers, config) {29 $scope.photos = data;30 $scope.photo = $scope.photos[0];31 $scope.loadComments();32 })33 .error(function(data, status, headers, config) {34 $scope.photos = [];35 });36 $scope.loadComments = function(){37 commentSrv.getComment($scope.photo.commentId,38 function(err, comment){39 if(err){40 $srope.commentThread = {};41 } else {42 $scope.commentThread = comment;43 }44 });45 };46 $scope.addReply = function(parentCommentId, subject, body){47 var newComment = {subject:subject, body:body};48 commentSrv.addComment($scope.commentThread._id,49 parentCommentId,50 newComment, function(err, comment){51 $scope.loadComments();
Kup książkę Poleć książkę
Inicjowanie aplikacji 581
52 });53 };54 $scope.setPhoto = function(photoId){55 $http.get('/photo', {params: {photoId: photoId}})56 .success(function(data, status, headers, config) {57 $scope.photo = data;58 $scope.loadComments();59 })60 .error(function(data, status, headers, config) {61 $scope.photo = {};62 });63 };64 }]);65 app.controller('pageController', ['$scope', '$http','commentSrv',66 function($scope, $http, commentSrv) {67 $http.get('/page', {params:{pageName:"Strona ze zdj ciami"}})68 .success(function(data, status, headers, config) {69 $scope.page = data;70 $scope.loadComments();71 })72 .error(function(data, status, headers, config) {73 $scope.Page = {};74 });75 $scope.addReply = function(parentCommentId, subject, body){76 var newComment = {subject:subject, body:body};77 commentSrv.addComment($scope.commentThread._id,78 parentCommentId,79 newComment, function(err, comment){80 $scope.loadComments();81 });82 };83 $scope.loadComments = function(){84 commentSrv.getComment($scope.page.commentId,85 function(err, comment){86 if(err){87 $srope.commentThread = {};88 } else {89 $scope.commentThread = comment;90 }91 });92 };93 }]);
Inicjowanie aplikacjiPo utworzeniu aplikacji konieczne jest też utworzenie dokumentów Page i Photo w baziedanych. Można to zrobić na kilka różnych sposobów. Na przykład możesz dodać takąopcję bezpośrednio do aplikacji. Jest to dobry wariant, jeśli te dokumenty okażą się niezbędnew późniejszym czasie. Innym rozwiązaniem jest użycie bezpośrednio w powłoce bazydanych MongoDB skryptu JavaScript, który zawiera polecenia służące do utworzenia
Kup książkę Poleć książkę
582 Rozdzia 27. Dodawanie w tków komentarzy do stron
wymienionych dokumentów. Możliwe jest również napisanie prostego skryptu w środowiskuNode.js lub za pomocą innego języka, który zapewnia dostęp do bazy danych MongoDB.
Listing 27.19 prezentuje podstawowy skrypt, który tworzy dokument Page i dodajekilka dokumentów Photo. Każdy dokument Page i Photo zawiera też dokumentCommentThread utworzony i powiązany z odwołaniem commentId.
Listing 27.19. Plik comment_init.js: implementowanie skryptu Node.js, który inicjuje dane dla aplikacji
01 var mongoose = require('mongoose');02 var db = mongoose.connect('mongodb://localhost/comments');03 require('./models/comments_model.js');04 require('./models/photo_model.js');05 require('./models/page_model.js');06 var CommentThread = mongoose.model('CommentThread');07 var Reply = mongoose.model('Reply');08 var Photo = mongoose.model('Photo');09 var Page = mongoose.model('Page');10 function addPhoto(title, filename){11 var comment = new CommentThread({title: "Komentarze dla: " + title});12 comment.save(function(err, comment){13 var photo = new Photo({title:title, filename:filename});14 photo.commentId = comment.id;15 photo.save(function(){16 console.log("Zapisano: " + title);17 });18 });19 }20 CommentThread.remove().exec(function(){21 Photo.remove().exec(function(){22 Page.remove().exec(function(){23 var comment = new CommentThread({title:"Komentarze strony ze zdj ciami"});24 comment.save(function(err, comment){25 var page = new Page({name:"Strona ze zdj ciami"});26 page.commentId = comment.id;27 page.save();28 });29 addPhoto('Wytrzyma o ', 'arch.jpg');30 addPhoto('Si a', 'pyramid.jpg');31 addPhoto('Pi kno', 'flower.jpg');32 addPhoto('Zamy lony', 'boy.jpg');33 addPhoto('Letnia zabawa', 'boy2.jpg');34 addPhoto('Zachody s o ca', 'jump.jpg');35 });36 });37 });;
Kup książkę Poleć książkę
Podsumowanie 583
PodsumowanieW tym rozdziale wyjaśniono, jak zdefiniować model do przechowywania i pobieraniazagnieżdżonych komentarzy. Opisany tu model przechowuje pełny wątek komentarzyjako pojedynczy dokument zamiast osobnych dokumentów dla każdego komentarza.Ułatwia to wczytanie całego wątku.
W rozdziale zaimplementowano też podstawowy model dla strony internetoweji zdjęć. Ponadto zintegrowano wiele modeli z procedurami obsługi tras serwera Express,szablonami AngularJS i aplikacją AngularJS.
W nast pnym rozdzialeW następnym rozdziale zajmiesz się kolejnym praktycznym przykładem dodawaniaproduktów i koszyka zakupów do witryny internetowej.
Kup książkę Poleć książkę
584 Rozdzia 27. Dodawanie w tków komentarzy do stron
Kup książkę Poleć książkę
Skorowidz
Aadministrator
baz danych, 247użytkowników, 245
adres URL, 25, 141agregowanie
danych, 353, 354dokumentów, 351wyników, 319
aktualizowaniedokumentów, 287, 289,
344–348obiektów, 283
analizadanych JSON, 414procedury obsługi tras,
567łańcucha adresu URL,
143AngularJS, 20, 31, 431
cykl życia aplikacji, 436definiowanie modułów,
448dodawanie do Node.js,
438dodawanie dostawców,
450dyrektywy, 485filtry, 477implementowanie
dyrektyw, 485implementowanie usług,
511
inicjowaniew dokumencie HTML,438
integrowaniekomponentu, 437
kod wielokrotnegoużycia, 21
konfiguracja modułu,449
kontrolery, 434model danych, 433moduły, 433, 447, 448przejrzystość, 21, 31rozszerzalność, 21, 31tworzenie aplikacji, 441tworzenie widoków, 469uruchamianie modułu,
450usługi, 435wiązanie danych, 21, 31,
434wielokrotne
wykorzystanie kodu,31
wstrzykiwaniezależności, 435, 448,452
wyrażenia, 434zakresy
odpowiedzialności, 435zasięg, 433, 455zgodność, 21, 31
animacja, 522, 523animacja jQuery, 525
API, 439aplikacja
AngularJS, 579myApp, 616
aplikacje RIA, 623asynchroniczna metoda
odczytu, 130asynchroniczne
strumieniowaniedanych, 126, 131
wywołania, 120atak
CSRF, 414typu man-in-the-middle,
163, 181atrybuty, 492atrybuty obiektów Stats, 134
Bbaza danych
dodawanie indeksów,361
kopia zapasowa, 384kopiowanie, 249MongoDB, 20, 361naprawianie, 383NoSQL, 223operatory
aktualizowania, 283replikacje, 365tworzenie, 248, 274usuwanie, 249, 274wprowadzanie zmian, 281
Kup książkę Poleć książkę
652 Node.js, MongoDB, AngularJS. Kompendium wiedzy
bazowanie na dokumentach,30
bibliotekaangular.js, 438, 439, 443jQuery, 431, 524Mongoose, 326, 341,
536, 560agregowanie
dokumentów, 351aktualizowanie
dokumentów,344–347
dodawaniedokumentów, 343
funkcje pośrednie, 356sprawdzanie
poprawności, 354usuwanie
dokumentów, 349,350
znajdowaniedokumentów, 341
OpenSSL, 182blok
konfiguracji, 449try/catch, 54uruchamiania, 450
blokujące wejście-wyjście, 77błędy, 53, 355bufor
dzielenie na segmenty,102
kopiowanie, 101metody kodowania, 97metody odczytywania,
100metody zapisywania, 98określanie długości, 101złączanie, 104
buforowanie danych, 97
CCDN, Content Delivery
Network, 438
certyfikat samopodpisany,182
CSS, 523cykl życia
aplikacjifaza inicjowania, 436faza kompilacji, 436faza wiązania danych,
437danych, 232zasięgu
faza mutacji modelu,461
faza obserwowaniamutacji, 461
faza rejestrowaniaelementumonitorującego, 460
faza tworzenia, 460faza usuwania zasięgu,
461
Ddane, 26
binarne, 97buforowane, 97HTML, 492JSON, 95, 402pogodowe, 635zaplecza, 459
definiowaniefunkcji, 42głównego elementu, 443kontrolera usługi
pogodowej, 634mechanizmu szablonów,
406modelu, 588
CommentThread, 560komentarzy, 559Page, 559Photo, 560projektu, 626użytkowników, 535
modułów AngularJS,448
operatorów zapytania,337
schematu, 328, 331adresów, 589ilości, 590klientów, 591produktów, 590rachunków, 589zamówień, 590
szablonukart, 629panelu, 628widoku, 501
zmiennych, 33dekompresowanie
buforów, 115danych, 115strumieni, 117
denormalizowanie danych,229
deserializacja, 551deskryptor pliku, 121diagram komponentów, 24długość
bufora, 101łańcucha, 48
dodawaniedokumentów, 283, 343elementów do tablicy, 53indeksów, 361kodu CSS, 548, 574, 610komentarzy, 563kont użytkowników, 533kontrolera do
dyrektywy, 505kontrolera do szablonu,
444modułu passport, 550obiektu locals, 407obsługi błędów, 53produktów do koszyka,
612segmentów danych, 375
Kup książkę Poleć książkę
Skorowidz 653
serializacjii deserializacji, 551
strategiiuwierzytelniania, 550
wątków komentarzy, 557zadań, 79zdarzeń
niestandardowych, 85dokonywanie
płatności, 614zakupu, 616
dokumenty, 224DOM, Document Object
Model, 25domknięcie, 89dostawca
filtru, 474obiektów komponentu
AngularJS, 451usług, 451
dostęp dobaz danych, 245, 273,
299, 459danych dynamicznych,
641kolekcji, 276MongoDB, 238, 257plików, 135serwera WWW, 155systemów zewnętrznych,
160systemu plików, 119trasy, 422właściwości obiektu
Request, 398zasięgu, 471
drzewo, 25dynamiczny serwer WWW,
155dyrektywa, 433, 470, 485
a, 488form, 489input, 489input.checkbox, 489
input.email, 489input.number, 489input.radio, 490input.text, 490input.url, 490myDirective, 503ngApp, 486ngBind, 492ngBindHtml, 493ngBindTemplate, 493ngBlur, 497ngChange, 497ngChecked, 497ngClass, 493, 522ngClassEven, 493ngClassOdd, 493ngClick, 497ngCloak, 486ngController, 486ngCookies, 519ngCopy, 497ngCut, 497ngDblclick, 497ngDisabled, 493ngFocus, 497ngHide, 493, 522ngHref, 486ngIf, 494, 522ngInclude, 487, 522ngInit, 494ngKeydown, 498ngKeypress, 498ngKeyup, 498ngList, 487ngModel, 494ngMousedown, 498ngMouseenter, 498ngMouseleave, 498ngMousemove, 498ngMouseover, 498ngMouseup, 498ngNonBindable, 487ngOpen, 487ngOptions, 490
ngPaste, 498ngPluralize, 487ngReadonly, 487ngRepeat, 494, 522ngRequired, 487ngSelected, 488ngShow, 493, 522ngSrc, 488ngSrcset, 488ngStyle, 495ngSubmit, 498ngSwipeLeft, 498ngSwipeRight, 498ngSwitch, 495, 522ngTransclude, 488, 501ngValue, 495ngView, 488, 522script, 488select, 490richTabs, 631
dyrektywyautomatycznie usuwane,
523niestandardowe, 506,
630obsługujące funkcje
szablonu, 486–488połączone z danymi, 517rozszerzające elementy
formularza, 488w package.json, 67wbudowane, 486wiązania danych, 495,
497wiążące model
z elementami, 491wiążące zdarzenia z
kontrolerami, 496własne, 500
dziedziczeniefunkcji, 216prototypów, 216
dzielenie buforów, 102
Kup książkę Poleć książkę
654 Node.js, MongoDB, AngularJS. Kompendium wiedzy
Eefekty przejścia, 526EJS, Embedded JavaScript,
406elementy
łańcucha połączenia, 264monitorujące, 460
emiter zdarzeń, 85, 87, 463Express, 30
funkcje pośrednie, 413,414
implementowanie tras,392
informacje cookie, 30integracja, 30konfigurowanie
ustawień, 390obsługa błędów, 30sesje, 30uruchamianie serwera,
391zarządzanie pamięcią
podręczną, 30zarządzanie trasami, 30
Ffiltr, 470, 473
currency, 474, 476date, 475, 476filter, 474json, 476limitTo, 475, 476lowercase, 475number, 475orderBy, 475, 479uppercase, 470, 475
filtrowanieelementów, 479elementów
dynamicznych, 478filtry
niestandardowe, 479wbudowane, 474
formatBig Endian, 97BSON, 226JSON, 95, 401Little Endian, 97XML, 95
formatowanie łańcuchów,213
formularz, 144funkcja, 42
.addListener(), 86
.listeners(), 86
.on(), 86
.once(), 86
.removeListener(), 86
.setMaxListeners(), 86addCity(), 636addComment(), 577addToCart(), 601addValues(), 457, 458cartTotal(), 612changeName(), 466checkout(), 614combine(), 472deleteFromCart(), 602,
613emit(), 85exec(), 194execFile(), 195, 196fitlerText(), 481fork(), 200fs.openSync(), 122fs.write(), 125fs.writeSync(), 123getComment(), 577getSortObj(), 642getWeather(), 161, 635getWords(), 643GridFS, 361hasPW(), 426inspect(), 216link(), 505makePurchase(), 616mkdirSync(), 138nextTick(), 84
open(), 125, 131openSync(), 123, 131parseWeather(), 633pipe(), 114pośrednia
basic-auth-connect, 423pośrednia body-parser,
418, 426pośrednia cookie-parser,
421pośrednia cookie-
session, 421pośrednia query, 416pośrednia static, 416Query(), 76read(), 131readdirSync(), 136regenerate(), 426req.param(), 395rmdirSync(), 138Send(), 76setFilter(), 479setImmediate(), 83setInterval(), 81setProduct(), 600setShipping(), 615setSort(), 479setTimeout(), 80simpleTimeout(), 80spawn(), 197, 198truncateSync(), 137unlinkSync(), 136unref(), 83updateMessage(), 444verifyBilling(), 606, 615WalkDirs(), 136writeFruit(), 126
funkcjeanonimowe, 44, 89modułu console, 73, 74opakowujące, 90pomocnicze, 612pośrednie, 356, 357, 414pośrednie komponentu
Express, 413
Kup książkę Poleć książkę
Skorowidz 655
pośrednieniestandardowe, 427
przekazywaniezmiennych, 43
zasięgu, 457zwracanie wartości, 43
Gglobalne interfejsy API, 439gniazda
sieciowe, 167TLS, 182
grupowaniedokumentów, 317, 324wyników, 316
Hhierarchia
kontrolerów, 463zasięgów, 461, 466
Iimplementowanie
AngularJS, 438agregacji, 323alertów przeglądarki,
518animacji, 522animacji CSS, 524częściowego szablonu,
572, 600domknięcia, 89dostępu do danych, 641dyrektyw, 485
niestandardowych,506, 630
zagnieżdżonych, 507zdarzeń, 499, 508
emiterów zdarzeń, 85, 87funkcji pomocniczych,
612funkcji pośrednich, 356,
551
funkcji rachunku, 615funkcji wysyłki, 615funkcji zakupu, 616hierarchii kontrolerów,
464hierarchii zasięgów, 461,
462klastra HTTP, 206klastrów procesów, 203klientów gniazd TCP,
176klientów i serwerów
HTTP, 153klientów TLS, 181komponentu Express,
389kontrolera, 457, 490
modeluCommentThread,565
modelu klientów, 596modelu Page, 564modelu Photo, 564modelu produktów,
594modelu zamówień,
595kontrolera zdjęć, 577
liczników czasu, 80, 521łańcucha wywołań
zwrotnych, 136magazynu GridFS, 377mechanizmu szablonów,
406modelu
CommentThread, 561obiektu User, 535Page, 560Photo, 560zasięgu, 444
modułu AngularJS, 453modułu i kontrolera, 549niestandardowej funkcji
pośredniej, 427
obiektuClientRequest, 146Grid, 377GridStore, 379, 383strumienia Duplex,
111strumienia Readable,
107strumienia Transform,
113strumienia Writable,
109operatorów wyrażeń
agregacji, 321parametrów trasy, 393,
397pętli, 39podrzędnych rozwidleń,
200procedur obsługi tras,
566, 567procesów nasłuchiwania
zdarzeń, 85, 87procesów podrzędnych,
192schematu, 331serwera
aplikacji, 627arbitra, 366Express, 515gniazd TCP, 178HTTP, 158HTTPS, 162, 391komentarzy, 561koszyka zakupów, 592TLS, 181WWW, 153, 155
serwerów żądań GET,154
serwerów żądań POST,157
sesji, 414, 421skryptu Node.js, 582strumienia Readable,
132
Kup książkę Poleć książkę
656 Node.js, MongoDB, AngularJS. Kompendium wiedzy
implementowaniestrumienia Writable, 127stylów CSS, 548, 575,
633, 637szablonów, 410szablonu koszyka, 602szablonu wysyłek, 603tras, 392, 537, 552, 563,
593, 627getPage, 564getPhoto, 564kontrolera
użytkowników, 538kontrolerów, 563
trasyaktualizacji
użytkownika, 540logowania
użytkowników, 539rejestrowania
użytkowników, 538usuwania
użytkownika, 541uzyskiwania profilu
użytkownika, 540tworzenia segmentów
danych, 369unikalnych pól, 330usług, 511usług gniazd, 167usług HTTP, 141usługi
$animation, 526$cacheFactory, 518$cookieStore, 521$http, 517Google, 553internetowej, 160pogodowej, 633
uwierzytelniania, 423–425,550
widoków użytkownika, 543widoku
index, 545komentarzy, 573
koszyka, 602login, 546podsumowania, 607produktów, 599rachunku, 604signup, 543strony produktu, 601user, 547usługi pogodowej, 633wątku komentarzy,
571wysyłek, 603z kartami, 628, 629zakupów, 598zamówień, 608zdjęć, 569
wstrzykiwaniazależności, 452, 453
wywołań blokujących, 84wywołań zwrotnych, 82,
88zasięgu, 455zestawu replik, 366
indeksowanie, 232indeksowanie pól, 361informacje
cookie, 30, 419, 519o kolekcji, 279o pliku, 134o procesie, 190, 191o repozytorium, 70o usłudze Google, 555o użytkowniku, 408, 409o wysyłce, 615
inicjowanieaplikacji, 581, 619, 646bazy danych, 646
instalowaniemodułów NPM, 64MongoDB, 236środowiska Node.js, 60
instrukcjaif, 38switch, 39throw, 55
integrowaniekomponentu AngularJS,
437usług w module, 528
interakcjaz użytkownikiem, 26z zewnętrznymi
źródłami, 160interfejs API, 439interwał, 81iteracja w obrębie tablic, 52
JJavaScript, 33JSON, JavaScript Object
Notation, 95JSONP, 403
Kkatalog, 534, 558, 586, 624
node_modules, 61, 258klasa
EventEmitter, 87fadeClass, 524fadeOut, 526
klaster, 374klastry procesów, 203klient
gniazd TCP, 176HTTP, 153, 159HTTPS, 162, 163TLS, 181, 182WWW, 154, 156
kluczprywatny, 165publiczny, 165segmentu danych, 371złożony, 371
kodCSS, 548, 574, 631, 639do wielokrotnego
wykorzystania, 31
Kup książkę Poleć książkę
Skorowidz 657
JavaScript, 29szablonu HTML, 458,
463, 466kodowanie UTF8, 100kolejka zdarzeń, 78, 79kolekcja, 224, 250
db.system.users, 241nebulae, 285word_stats, 331
kolekcjeaktualizowanie
dokumentów, 254, 287dodawanie
dokumentów, 253, 283niepodzielne
modyfikowaniedokumentów, 290
ograniczone, 229, 365tworzenie, 250, 278usuwanie, 251, 278usuwanie dokumentów,
253, 294usuwanie pojedynczego
dokumentu, 296uzyskiwanie
dokumentów, 286wstawianie
dokumentów, 293zapisywanie
dokumentów, 291znajdowanie
dokumentów, 252komentarze, 559kompilator środowiska
AngularJS, 485kompilowanie
modelu, 332szablonu AngularJS, 470
komponentAngularJS, 20, 429, 431Express, 389MongoDB, 20, 221, 223
komponentyinteraktywne, 623podstawowe, 23
stosu Node.js-AngularJS,27
kompresowaniebuforów, 115danych, 115strumieni, 117
komunikacja międzyprzeglądarką i serwerem,25
konfigurowaniemodułu AngularJS, 449komponentu Express,
390kontroli dostępu, 245tras, 392zasięgu dyrektywy, 503
konstruktor, 216konto
administratora bazdanych, 247
administratoraużytkowników, 245
użytkownika, 241kontroler, 434, 456
do obsługi komentarzy,578
modeluCommentThread, 565klientów, 596Page, 564Photo, 564produktów, 594zamówień, 595
shoppingController, 611SimpleTemplate, 458,
459tableController, 642, 643usługi pogodowej, 634
kontrolowanie procesu, 189konwersacja, 78kopiowanie
baz danych, 249buforów, 101
koszyk zakupów, 585
Lliczba, 34
dokumentów, 306kolekcji, 232tras, 393zestawów replik, 367
licznik czasu, 80interwału, 81natychmiastowy, 83
limit czasu, 80lista
baz danych, 247, 273kolekcji, 250, 277użytkowników, 241
literał obiektowy, 35
Łładowanie biblioteki, 443łańcuch, 34, 48, 50, 213
JSON, 96połączenia, 263zapytania, 144, 393
łączeniebuforów, 104łańcuchów, 50strumieni, 114tablic, 51wywołań zwrotnych, 91,
92
Mmagazyn GridFS, 377mechanizm
EJS, 406, 407Jade, 406, 409
metadane klastra, 374metoda
$broadcast(), 464$destroy(), 461$digest(), 461$emit(), 464$on(), 464
Kup książkę Poleć książkę
658 Node.js, MongoDB, AngularJS. Kompendium wiedzy
metoda$scope.addReply(), 578_flush(), 112_transform(), 112abort(), 147, 189acceptsCharset(), 398addObject(), 285address(), 171, 175addTrailers(), 149addUser(), 243, 267, 269admin(), 266aggregate(), 319, 335all(), 339angular.module(), 449animate(), 524app.all(), 393app.engine(), 407app.listen(), 391app.render(), 410, 411append(), 352arch(), 212attachment(), 400authenticate(), 267, 268Buffer.byteLength(), 101buffer.fill(), 98buffer.toString(), 100buffer.write(), 98child_process.fork(), 175chunkCollection(), 380close(), 152, 175, 380collection(), 266, 380collectionInfo(), 266collectionNames(), 266collections(), 267comment(), 337concat(), 104config(), 449connect(), 263controller(), 456count(), 271, 307, 335cpus(), 212create(), 335, 343createCollection(), 250,
267createServer(), 152, 156
db(), 266db.getSiblingDB(), 248deserializeUser(), 552destroy(), 171directive(), 500disconnect(), 194, 206displayWords(), 304distinct(), 271, 315, 335doAsyn(), 357drop(), 271dropCollection(), 267dropDatabase(), 249, 267each(), 272, 287elemMatch(), 339end(), 109, 147, 149, 154,
158, 171endianness(), 212ensureIndex(), 364eof(), 381EOL, 212error(), 515exec(), 352exists(), 338exit(), 189find(), 252, 286, 304, 335findAndModify(), 271,
290findAndRemove(), 271,
296findOne(), 271, 286, 335findOneAndRemove(),
335findOneAndUpdate(),
335freemem(), 212fs.exists(), 133fs.existsSync(), 133fs.readFile(), 154fsStatsSync(), 134get(), 339, 398getc(), 381getConnections(), 174getgid(), 191getgroups(), 191getHeader(), 149
getuid(), 191GridStore.exist(), 381GridStore.list(), 381GridStore.read(), 381GridStore.readlines(),
382GridStore.unlink(), 382group(), 316, 352gt(), 337gte(), 337hint(), 337hostname(), 212hrtime(), 191http.createServer(), 391http.request(), 145, 164https.createServer(), 164https.request(), 164in(), 338index(), 364inherits(), 110, 216initgroups(), 191initialize(), 551insert(), 253, 269invalidate(), 340isArray(), 214isClosed(), 273isDate(), 214isError(), 214isInit(), 340isModified(), 340isRegExp(), 214isSelected(), 340json(), 402JSON.parse(), 96JSON.stringify(), 96jsonp(), 402kill(), 189, 194limit(), 336, 352listDatabases(), 268listen(), 152, 174loadavg(), 212location(), 400logout(), 267, 268lookup(), 217lt(), 338
Kup książkę Poleć książkę
Skorowidz 659
lte(), 338markModified(), 340match(), 352memoryUsage(), 190mod(), 338modifiedPaths(), 340mongoose.connect(),
332ne(), 338net.connect(), 168, 177net.createConnection(),
168net.createServer(), 175,
179networkInterfaces(), 212next(), 357nextObject(), 272nin(), 338open(), 266, 380parse(), 144passport.authenticate(),
552pause(), 106, 171ping(), 268pipe(), 106platform(), 212project(), 352put(), 378puts(), 381queryRemover(), 428querystring.parse(), 161read(), 106, 336, 352, 380readFile(), 128readInt16BE(), 100readInt16LE(), 100readInt8(), 100readlines(), 380readUInt32BE(), 100ref(), 171, 175regex(), 338release(), 212remove(), 253, 294, 349removeHeader(), 149removeUser(), 244, 267rename(), 270
renameCollection(), 267req.isAuthenticated(),
553req.login(), 552req.logout(), 552require(), 536res.cookie(), 420res.download(), 405res.end(), 154res.redirect(), 405res.render(), 410res.send(), 394, 395resetDays(), 516resolve(), 218resume(), 106, 171rewind(), 272, 380run(), 450safe(), 336save(), 254, 270, 344seek(), 380select(), 336send(), 194, 205, 400sendfile(), 403serializeUser(), 552serverStatus(), 268, 276set(), 339, 400setEncoding(), 106, 170setgid(), 191setgroups(), 191setHeader(), 149setImmediate(), 84setKeepAlive(), 171setNoDelay(), 148, 171setOptions(), 336setSocketKeepAlive(),
148setTimeout(), 147, 171setuid(), 191sh.addShard(), 375skip(), 336, 352slice(), 102snapshot(), 336sort(), 273, 336, 353stats(), 271, 279status(), 399
stream(), 381stringDecoder.write(),
100success(), 515tell(), 380tls.connect(), 183tls.createServer(), 184tmpdir(), 212toArray(), 272, 286toJSON(), 340toObject(), 340toString(), 99, 340totalmem(), 212type(), 212, 400unlink(), 380unpipe(), 106unref(), 171, 175unwind(), 353update(), 254, 270, 291,
335, 346uptime(), 191, 212url.format(), 142url.pars(), 154url.parse(), 142, 143url.resolve(), 143use(), 415util.format(), 214util.inherits(), 216util.inspect(), 215validate(), 340, 354where(), 337write(), 108, 147, 171,
381writeContinue(), 149writeFile(), 380writeHead(), 149writeInt16BE(), 98writeInt16LE(), 98writeInt8(), 98
metodykodowania, 97kopiowania, 102modułu cluster, 204modułu dns, 217modułu os, 212
Kup książkę Poleć książkę
660 Node.js, MongoDB, AngularJS. Kompendium wiedzy
metodymodułu process, 190obiektu
Admin, 268, 269Aggregate, 352Array, 52, 54ChildProcess, 194ClientRequest, 147Collection, 269, 271Cursor, 272Db, 266Document, 339GridStore, 380HTTP Request, 397Model, 335, 336net.Server, 174Query, 335–338req.session, 425Readable, 106Response, 400ServerResponse, 149,
150Socket, 170Stats, 134String, 49Worker, 205Writable, 109
odczytu, 100odczytywania obiektów
Buffer, 100powłoki MongoDB, 239tworzenia obiektów, 98zapisywania danych, 98,
99migawka systemu plików, 385model
Comment, 567CommentThread, 560DOM, 25, 432Page, 559Photo, 560wątkowości, 76wywołań zwrotnych
zdarzeń, 76zdarzeń, 75
moduł, 62connect-mongo, 533ejs, 533express, 533mongodb, 533mongoose, 533Buffer, 97child_process, 192cluster, 203, 206connect, 414console, 73, 74dns, 211, 217express, 65, 389Express, 30, 387fs, 119http, 141mongoose, 252, 258, 325,
341net, 167os, 211, 213passport, 550, 552process, 187, 189, 191
kontrolowanieprocesu, 189
metody i właściwości,190
potoki wejścia-wyjściaprocesów, 187
sygnały procesów, 188uzyskiwanie
informacji, 190querystring, 144static, 416Stream, 104util, 213–216zlib, 115–117
moduły NPM, 533modyfikowanie
baz danych, 273, 281kolekcji, 276danych, 477dokumentów, 290modelu DOM, 504
MongoDB, 20, 29administrowanie
kontami, 241
bazowanie nadokumentach, 20, 30
dokumenty, 224dostępność, 20, 30kolekcje, 224kontrola dostępu, 245optymalizacja
wydajności, 231planowanie modelu
danych, 227skalowalność, 20, 30skrypty dla powłoki, 240środowisko GridFS, 377środowisko
komponentu, 235środowisko MapReduce,
319typy danych, 226wydajność, 20, 30
monitorowanie pliku, 139MVC, Model View
Controller, 431
Nnagłówek Content-Type, 399nagłówki HTTP, 26naprawianie bazy danych,
383narzędzia globalnych
interfejsów API, 440, 441nasłuchiwanie, 85
połączeń, 152zdarzeń, 79, 86
nawiasy klamrowe, 458niepodzielne operacje
zapisu, 231niezawodność zapisu, 258Node.js, 19, 28, 57, 59
aplikacje, 68dodawanie sterownika
MongoDB, 257dostęp do MongoDB, 257dostęp do systemu
plików, 119
Kup książkę Poleć książkę
Skorowidz 661
instalowanie, 60instalowanie modułów,
64konfiguracja, 29lokalizacja instalacji, 61model zdarzeń, 75moduły, 62moduły dodatkowe, 211Node Package Registry,
62obsługa danych
wejścia-wyjścia, 95obsługa JavaScript, 19,
29pliki wykonywalne, 61połączenie z MongoDB,
258publikowanie modułu,
69rozszerzalność, 19, 29skalowalność, 19, 29, 187tworzenie modułu, 68usługi gniazd, 167usługi HTTP, 141wybór IDE, 61wyszukiwanie modułów,
63normalizacja, 470normalizowanie danych, 227NoSQL, Not Only SQL, 223
Oobcinanie plików, 137obiekt, 45
Account, 87Admin, 268, 275Agent, 164Array, 51Buffer, 98ChildProcess, 193Collection, 269, 315Connection, 327Cursor, 272Customer, 599
Db, 266, 364Document, 326, 330, 339error, 355, 378Event, 464, 498EventEmitter, 86, 216Grid, 377GridStore, 379http.ClientRequest, 145http.IncomingMessage,
149http.ServerResponse, 148locals, 407Model, 333Module, 449, 450MongoClient, 260, 261net.Server, 173net.Socket, 168options, 302Query, 300, 333, 336
metody, 335, 338opcje operacji
bazodanowych, 336operacje bazodanowe,
334operatory, 337
Request, 395, 397Response, 395, 398, 401Schema, 326, 331, 332Server, 150, 259String, 48, 49StringDecoder, 99update, 283URL, 142User, 535Worker, 205
obiekty niestandardowe, 46obsługa
animacji, 522błędów, 30, 53danych wejścia-wyjścia,
95dodawania produktów,
613dyrektyw, 495funkcji szablonu, 458
kodu CSS3, 524komentarzy, 578, 580parametrów żądania
POST, 418sesji, 414, 421, 422szablonu, 442tras modelu Comment,
567trasy addComment(), 565trasy getComment(), 565trasy /words, 641usuwania produktów,
613widoków, 627widoków komentarzy,
576widoków koszyka
zakupów, 611wyświetlania, 563zdarzeń, 499żądań, 593
odczytywanieasynchroniczne z pliku,
130informacji cookie, 414plików, 121, 128synchroniczne pliku, 128z buforów, 99
oddzielanie zakresówodpowiedzialności, 435
ODM, Object DocumentModel, 325
odporność na błędy, 367ograniczanie
działania dyrektyw, 502liczby dokumentów
zwracanych, 310liczby pól, 310pól zwracanych, 309wyników według
wielkości, 308zestawów wynikowych,
308zestawu dokumentów,
309
Kup książkę Poleć książkę
662 Node.js, MongoDB, AngularJS. Kompendium wiedzy
ograniczone kolekcje, 229,364
określanieliczby dokumentów, 306,
307stylów CSS, 548, 639stylów widoków, 610
opcjaprocess.nextTick, 80upsert, 293
opcjefunkcji
exec(), 195fork(), 201spawn(), 198, 199
metodyhttps.createServer(),
164https.request(), 164res.cookie(), 420tls.connect(), 183tls.createServer(), 184
modułu static, 416obiektu
ClientRequest, 146Module, 449options, 303query, 333Schema, 329Server, 173, 259
operacji bazodanowych,336
polecenia npm, 64połączenia z bazą
danych, 261operator, 300
$group, 320, 321$gt, 301$sort, 324
operatoryagregacji, 319–321aktualizowania baz
danych, 283arytmetyczne, 36, 322łańcuchowe, 322
obiektu Query, 301, 337obiektu update, 284porównania, 36, 37przypisania, 36warunkowe, 36
opóźnianie pracy, 80optymalizacja wydajności
bazy, 231otwieranie plików, 120
Ppakiety NPM, 62parametry
formularza, 144metody POST, 393polecenia mongod, 237w trasach, 393zdefiniowane, 393, 395
partycjonowanie, 372pętla, 39
do/while, 40for, 40for/in, 41while, 39zdarzeń, 83
planowanie modelu danych,227
plikangular_expressions.html,
472angular_expressions.js,
472angular_filter_custom.
html, 481angular_filter_customer.js,
481angular_filter_sort.html,
479angular_filter_sort.js, 478angular_filters.html, 477angular_filters.js, 476animate.css, 526auth_server.js, 535billing.html, 605
buffer_concat.js, 104buffer_copy.js, 102buffer_read.js, 100buffer_slice.js, 103buffer_write.js, 99callback_chain.js, 92callback_closure.js, 90callback_parameter.js,
89cart.html, 602cart_app.js, 611–617cart_init.js, 619cart_model.js, 589, 590,
591cart_routes.js, 593cart_server.js, 592cart_styles.css, 598, 610censortext.js, 68chef.js, 202child_fork.js, 201child_process_exec.js,
195child_process_exec_file.
js, 197child_process_spawn.js,
199cluster_client.js, 207cluster_server.js, 206cluster_worker.js, 207collection_create_list_
delete.js, 278collection_stats.js, 279comment_app.js,
576–580comment_init.js, 582comment_styles.css, 575comment_thread.html,
572, 573comments_controller.js,
565–567comments_model.js, 561comments_routes.js, 563comments_server.js, 562customers_controller.js,
596
Kup książkę Poleć książkę
Skorowidz 663
db_connect_object.js, 262db_connect_string.js, 264db_create_list_delete.js,
274db_status.js, 276directive_bind.html, 495directive_bind.js, 495directive_custom.html,
507directive_custom.js, 506directive_event.html, 499directive_event.js, 499directive_form.html, 491directive_form.js, 490dns_lookup.js, 219doc_aggregate.js, 323doc_count.js, 307doc_delete.js, 295doc_delete_one.js, 296doc_distinct.js, 315doc_fields.js, 310doc_find.js, 287doc_group.js, 317doc_insert.js, 285doc_limit.js, 309doc_modify.js, 290doc_paging.js, 312doc_query.js, 305doc_save.js, 292doc_sort.js, 313doc_update.js, 289doc_upsert.js, 293draggable.html, 639draggable_styles.css, 640emitter_listener.js, 87express_auth.js, 423express_auth_one.js, 424express_auth_session.js,
425express_cookies.js, 420express_http_https.js, 391express_middleware.js,
427express_post.js, 418express_redirect.js, 405
express_request.js, 398express_routes.js, 396express_send.js, 401express_send_file.js, 404express_send_json.js, 402express_session.js, 422express_static.js, 417express_templates.js, 410file_read.js, 128file_read_async.js, 130file_read_stream.js, 132file_read_sync.js, 129file_readdir.js, 136file_stats.js, 135file_write.js, 122file_write_async.js, 125file_write_stream.js, 127file_write_sync.js, 124first.html, 441first.js, 442google_auth.js, 553grid_fs.js, 378gridstore_fs.js, 382http_client_get.js, 156http_client_static.js, 154http_server_external.js,
160http_server_get.js, 155http_server_post.js, 158,
159http_server_static.js, 153index.html, 545info.html, 555injector.html, 453injector.js, 453login.html, 546, 554main_jade.jade, 409mongoose_aggregate.js,
353mongoose_connect.js,
327mongoose_create.js, 343mongoose_find.js, 341mongoose_middleware.
js, 357
mongoose_remove_many.js, 350
mongoose_remove_one.js, 349
mongoose_save.js, 345mongoose_update_
many.js, 348mongoose_update_one.js,
346mongoose_validation.js,
355my_app.js, 549my_photos.html, 508nexttick.js, 84node, 61node_server.js, 441, 515orders.html, 609orders_controller.js, 595os_info.js, 213package.json, 66, 69, 70page_model.js, 560pages_controller.js, 564photo_model.js, 560photos.html, 569photos_controller.js, 564process_info.js, 191product.html, 601products.html, 600plik
products_controller.js,594
review.html, 607rich_pane.html, 628rich_tabs.html, 629rich_ui.html, 630rich_ui_app.js, 630, 634,
638, 642rich_ui_routes.js, 627rich_ui_server.js, 627rich_ui_styles.css, 633routes.js, 537scope_controller.js, 457scope_events.html, 466scope_events.js, 465
Kup książkę Poleć książkę
664 Node.js, MongoDB, AngularJS. Kompendium wiedzy
scope_hierarchy.html,463
scope_hierarchy.js, 462scope_template.html,
458scope_template.js, 458service_animate.html,
525service_animate.js, 525service_cache.js, 518service_cookie.html, 520service_cookies.js, 520service_custom.js, 528service_http.html, 517service_http.js, 516shipping.html, 603shopping.html, 598signup.html, 544simple_interval.js, 82simple_timer.js, 81socket_client.js, 176socket_server.js, 178stream_duplex.js, 111stream_piped.js, 114stream_read.js, 107stream_transform.js, 113stream_write.js, 109styles.css, 548table_styles.css, 646tables.html, 644user.html, 547user_ejs.html, 408user_jade.jade, 409users_controller.js,
538–541users_model.js, 535util_inherit.js, 216weather.html, 635weather_controller.js,
633weather_styles.css, 637word_init.js, 646word_model.js, 626word_schema.js, 331
words_controller.js, 641zlib_buffers.js, 116zlib_file.js, 117
plikiCSS, 26HTML, 26monitorowanie zmian,
139multimedialne, 26obcinanie, 137odczytywanie, 127statyczne, 153, 416, 441tryby otwierania, 121usuwanie, 136uzyskiwanie informacji,
134zapisywanie, 122zmiana nazwy, 139
pobieranie komentarzy, 576podział łańcucha, 50pola wymagane, 330polecenia powłoki
MongoDB, 239polecenie
db.repairDatabase, 383mongod, 237, 375, 383mongodump, 385npm, 258
połączenie z MongoDBbiblioteka Mongoose,
327łańcuch połączenia, 263Node.js, 258obiekt MongoClient, 260
porównanie kolekcji, 232porządkowanie elementów,
478–480potok, 114potoki wejścia-wyjścia
procesów, 187powłoka MongoDB, 238,
240praca
natychmiastowa, 83okresowa, 81
procesgłówny, 206mongod, 374mongos, 374, 375nadrzędny, 201nasłuchiwania, 85–87podrzędny, 192, 201, 202roboczy, 207
programGzip, 414Node Package Manager,
63protokół
HTTP, 25, 162HTTPS, 25, 162SSL, 165TCP, 167TLS, 181
prototyp, 47przechowywanie
danych, 378pliku, 382
przeciąganie elementów, 637przeglądarka, 25przekazywanie
parametrów, 88zmiennych, 43
przekierowywanieodpowiedzi, 405żądań, 405
przekształcaniedanych JSON, 96obiektów JavaScript, 96obiektów w łańcuchy,
215tablicy, 53
przerywanie pętli, 41przetwarzanie
adresów URL, 141łańcuchów, 48obiektów Array, 52obiektów String, 49
przyciski przełącznika, 520przydatność danych, 233
Kup książkę Poleć książkę
Skorowidz 665
przypisywanie funkcjipośrednich, 415
publikowanie modułu, 69
Rrejestr Node Package
Registry, 62relacja między zasięgami
i kontrolerami, 456i szablonami, 457i aplikacjami, 455i danymi serwera, 459
renderowanie szablonów,409, 411
replikacje, 232, 365liczba serwerów, 367liczba zestawów, 367serwer arbitra, 365serwer dodatkowy, 365serwer główny, 365
RIA, Rich InternetApplications, 623
rola, 242, 243clusterAdmin, 244dbAdmin, 244dbAdminAnyDatabase,
244read, 244readAnyDatabase, 244readWrite, 244readWriteAnyDatabase,
244userAdmin, 244userAdminAnyDatabase
, 244router zapytań, 370, 374rozgłaszanie zdarzeń, 463rozszerzalność, 29, 31rozszerzanie kodu HTML,
500rozwidlenia, 200
Sschemat, 328, 329
AddressSchema, 589CustomerSchema, 591OrderSchema, 590ProductQantitySchema,
590ProductSchema, 590
schematydodawanie indeksów,
330dodawanie metod, 331
segment, 102segmentowanie danych, 370
dla kolekcji, 376na podstawie wartości
mieszającej, 372na podstawie zakresu,
372w bazie danych, 375
serializacja, 551serwer
Apache, 28aplikacji, 626arbitra, 365dodatkowy, 365Express, 391główny, 365gniazd TCP, 176, 178HTTP, 153HTTPS, 162, 165komentarzy, 561konfiguracji, 371, 374koszyka zakupów, 592routera zapytań, 374TLS, 181, 183WWW, 25, 27, 155, 441
skalowalność sterowanazdarzeniami, 19, 29
składnia obiektów, 45skrypt, 26
serwerowy, 27styles.css, 548
słowo kluczowefinally, 55new, 98
sortowanie wyników, 313sprawdzanie
poprawności, 354poprawności
dokumentów, 355typów obiektów, 214
SSL, Secure Sockets Layer,181
statusHTTP, 399serwera, 276serwera MongoDB, 275
statyczny serwer WWW, 441sterownik dla MongoDB,
257, 265, 276stos Node.js-AngularJS, 23,
27stosowanie
funkcji wywołaniazwrotnego, 395
parametrów trasyłańcuchy zapytania,
394wyrażenia regularne,
394, 470zdefiniowane
parametry, 395strategia
replikacji, 367uwierzytelniania, 550
stronicowanie wyników,311, 312, 643
strukturadrzewa, 25katalogowa projektu,
534, 558, 586, 624strumienie
Duplex, 110Readable, 105Transform, 112Writable, 108
Kup książkę Poleć książkę
666 Node.js, MongoDB, AngularJS. Kompendium wiedzy
strumieniowaniedanych, 104odczytu z pliku, 131zapisu do pliku, 126żądań GET, 414
styleCSS, 467widoków, 574, 610widoku danych
pogodowych, 637widoku tabel, 646widoku z kartami, 631
superkonstruktor, 216sygnały procesów, 188synchroniczne wywołania,
120synchroniczny zapis danych,
215system plików, 119szablon, 406, 433, 457, 469
AngularJS, 459, 472, 481,491, 495
częściowy, 571–574dyrektyw, 502kart, 629mechanizmu EJS, 408mechanizmu Jade, 409panelu, 628widoku dyrektyw, 501
Śścieżka, 133, 328
bezwzględna, 138root, 404względna, 138
śledzenie żądań, 414środowisko
agregacji, 320IDE, 61MapReduce, 319MVC, 431Node.js, 19, 57, 59sprawdzania
poprawności, 354
Ttablica, 35, 51–53
$scope.content, 611$scope.words, 643customer.cart, 613
TCP, Transmission ControlProtocol, 167
technologia AngularJS, 20testowanie serwera, 207TLS, Transport Layer
Security, 181transkluzja zasięgów
zewnętrznych, 503trasa, 392
/images, 441/login, 426/logout, 426/remove/day, 516/reset/days, 515/static, 441/static/css, 441/static/js, 441/words, 641addComment(), 565addOrder(), 596deleteUser, 541getComment(), 565getUserProfile, 540login, 539signup, 538updateBilling(), 597updateUser, 540
trasy statyczne, 417tryby otwierania pliku, 121TTL, time-to-live, 363tworzenie
aplikacji, 581aplikacji AngularJS, 441aplikacji Node.js, 68baz danych, 248, 274,
374buforów, 98certyfikatu, 182definicji schematu, 329
dokumentów, 343, 344dyrektywy
niestandardowej, 506filtrów
niestandardowych, 479funkcji, 42funkcji anonimowej, 89funkcji opakowującej, 90instancji partycji, 232interaktywnych
komponentów, 623katalogów, 138klastra, 203klienta gniazd, 177klienta gniazd TLS, 182klienta HTTPS, 163kolekcji, 250, 278komponentów
praktycznych, 531kont użytkowników, 242konta administratora
baz danych, 247konta administratora
użytkowników, 245kontrolera tras, 641kopii zapasowej bazy,
384koszyka zakupów, 585modułu, 68niestandardowego
obiektu, 87niestandardowych
funkcji pośrednich, 427obiektów, 46
Buffer, 98ClientRequest, 146Module, 449Server, 173, 259Socket, 169
potoku, 114procesu, 197procesu w procesie, 199prototypów, 47segmentów danych, 102,
369
Kup książkę Poleć książkę
Skorowidz 667
klucz segmentudanych, 371
typy serwerów, 370serwera, 535
aplikacji, 626gniazd TLS, 183HTTPS, 165komentarzy, 561koszyka zakupów, 592
skryptów, 240szablonów, 408środowiska MongoDB,
235usług, 512usług niestandardowych,
527usługi komentarzy, 576usługi pogodowej, 633widoków, 469własnych dyrektyw, 500własnych emiterów
zdarzeń, 80wywołania, 79zasięgu, 472, 476, 478
typydanych, 34, 225, 328filtrów, 477funkcji pośredniej, 356indeksów, 362, 363
Uudostępnianie plików
statycznych, 153, 416URL, Uniform Resource
Locator, 141uruchamianie MongoDB, 236usługa, 435
$animate, 512, 522$animation, 525$cacheFactory, 512, 518$compile, 512$cookie, 519$cookies, 512$cookieStore, 519
$document, 512$http, 512, 513$interval, 512, 521$locale, 512$location, 512$resource, 512$rootElement, 512$rootScope, 455, 512$route, 513$sce, 513$scope, 456$templateCache, 513$timeout, 513, 521$window, 513, 518constant, 527factory, 527Google, 553–555komentarzy, 576pogodowa zaplecza, 633service, 528value, 527
usługiHTTP, 141niestandardowe, 527środowiska AngularJS,
511wbudowane, 512, 513zaplecza, 27
ustawianienagłówków, 399operacji bazodanowych,
334statusu, 399
usuwaniebaz danych, 249, 274dokumentów, 294–296,
349, 350katalogów, 138kolekcji, 251, 278odniesień, 83plików, 136procesów nasłuchiwania,
86produktów z koszyka, 613użytkowników, 244
uwierzytelnianie, 246, 543dzięki usłudze Google,
553HTTP, 423implementowanie tras,
552poprzez konta
społecznościowe, 549strategie, 550sesji, 424
uzyskiwanie dokumentów,286
użyciemodułu w aplikacji, 71obiektów, 45operatorów, 35
użytkownicy, 24
Wwartość
boolowska, 34elementu formularza,
491null, 35
wątek pętli zdarzeń, 78wczytywanie pliku łańcucha,
128wdrażanie
klastra MongoDB, 373zestawu replik, 368
Web 2.0, 623weryfikowanie
istnienia ścieżki, 133rachunku, 615
wiązanie danych, 31, 434widoczność elementu, 492widok, 433
danych pogodowych,635–637
index, 545koszyka, 602, 603login, 546podsumowania, 607, 608produktów, 599, 600
Kup książkę Poleć książkę
668 Node.js, MongoDB, AngularJS. Kompendium wiedzy
widokrachunku, 604, 606signup, 543strony produktu, 601szablonu kart, 629szablonu panelu, 628tabel, 644, 645umożliwiający
przeciąganie, 639user, 547usługi pogodowej, 633wysyłek, 603, 604z kartami, 628, 629, 632zakupów, 598zamówień, 608, 609
wielkość dokumentów, 231właściwości
modułu cluster, 204modułu process, 190obiektów ChildProcess,
194obiektów Document,
339obiektów
ServerResponse, 148,150
obiektów Socket, 172obiektów Worker, 205obiektu event, 464obiektu HTTP Request,
397obiektu URL, 143usługi $http, 514
włączaniesegmentowania danych,
375uwierzytelniania, 246
wstawianie dokumentów,293
wstrzykiwaniekodu SQL, 20zależności, 435, 447–452,
457
wybieranie metodypartycjonowania, 372
wyjątki, 55wymuszanie wymaganych
pól, 330wyrażenia, 434, 469, 470
AngularJS, 471aplikacji, 473JavaScript, 471regularne, 393
wysyłaniedanych JSON, 402danych JSONP, 403odpowiedzi, 400, 405odpowiedzi JSON, 401plików, 403, 404
wyszukiwaniemodułów NPM, 63odwrotne, 219podłańcucha, 50
wyświetlanielisty baz danych, 247,
273, 274listy kolekcji, 250, 277listy plików, 135listy użytkowników, 241,
242statusu serwera, 276statystyk, 279widoku, 25
wywołania systemu plikówasynchroniczne, 120synchroniczne, 120
wywołania zwrotne, 88implementowanie
domknięcia, 89łączenie, 91przekazywanie
parametrów, 88wywołanie zwrotne
authenticate(), 262checkGoal(), 88
wzorzec obiektowy, 47
Zzakres znaczników segmentu
danych, 376zamykanie plików, 120zapisywanie
asynchroniczne, 125asynchroniczne w pliku,
122, 124danych do konsoli, 72dokumentów, 291, 345łańcucha JSON, 122pliku, 121synchroniczne, 124, 215synchroniczne w pliku,
123w buforach, 98
zarządzaniekolekcjami, 250pamięcią podręczną, 30sesjami, 425trasami, 30
zasięg, 455aplikacji do zakupów,
611dyrektywy, 503, 504główny, 455nadrzędny, 462zmiennych, 44
zastępowanieelementu szablonu, 502słowa, 50
zatrzymywanie działaniaMongoDB, 236
zdarzeniamodułu cluster, 203niestandardowe, 85obiektów
ChildProcess, 193ClientResponse, 147Server, 151, 185ServerResponse, 148,
150
Kup książkę Poleć książkę
Skorowidz 669
Socket, 170, 174Worker, 205
wysyłane do procesów,188
zdarzenie$broadcast(), 465$destroy, 505animacji, 522balanceChanged, 87CharacterDeleted, 466checkContinue, 151clientError, 151, 185close, 148, 151, 170, 193connect, 147, 151, 170connection, 151, 174, 180continue, 147data, 170disconnect, 193, 204, 205drain, 108, 170, 177end, 170error, 170, 174, 193, 205exit, 193, 204, 205finish, 108fork, 203listening, 174, 203message, 193, 205mousedown, 638newSession, 185online, 203pipe, 108request, 151response, 147
resumeSession, 185secureConnection, 185setup, 204SIGBREAK, 188SIGHUP, 188SIGINT, 188SIGKILL, 189SIGPIPE, 188SIGSTOP, 189SIGTERM, 188SIGUSR1, 188SIGWINCH, 188socket, 147timeout, 170unpipe, 108upgrade, 147, 151
zestawdanych, 299, 300dokumentów, 304replik, 366wynikowy, 308, 313
zgłaszanie własnych błędów,55
złączanie buforów, 104zmiana
bazy danych, 248nazwy plików, 139
zmienna, 33znacznik
<div>, 444<html>, 438<img>, 570
<input>, 444<script>, 438<select>, 644<tr>, 644
znajdowaniedokumentów, 287, 341różnych wartości pola,
315zestawów dokumentów,
304znak $, 320znaki specjalne, 48zwracanie wartości, 43
Źźródła uwierzytelniania, 549
Żżądania HTTP, 144, 513żądanie
AJAX, 25Connect, 76GET, 25, 154, 398, 579GetData, 76GetFile, 76POST, 25, 158, 418, 516
Kup książkę Poleć książkę
670 Node.js, MongoDB, AngularJS. Kompendium wiedzy
Kup książkę Poleć książkę