Yii Framework [PDF]

Zitiervorschau

---

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 biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Redaktor prowadzący: Ewelina Burska Projekt okładki: Studio Gravite/Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: [email protected] WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/yiifra_ebook Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Materiały do książki można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/yiifra.zip ISBN: 978-83-246-8869-2

Copyright © Helion 2013 Printed in Poland.  Poleć książkę na Facebook.com

 Księgarnia internetowa

 Kup w wersji papierowej

 Lubię to! » Nasza społeczność

 Oceń książkę

Spis treści Wstęp .............................................................................................. 7 Rozdział 1. Pobieranie ....................................................................................... 9 Wymagania frameworku ................................................................................................ 10

Rozdział 2. Instalacja ....................................................................................... 13 Dodawanie ścieżki dostępu w systemie Windows .......................................................... 13 Dodawanie ścieżki dostępu w systemie Linux ............................................................... 14 Uruchomienie frameworku ............................................................................................. 14 Plik htaccess .................................................................................................................. 16 „Tyle pracy, aby wygenerować jedną stronę!” ............................................................... 17

Rozdział 3. Model, widok, kontroler .................................................................. 19 Wzorzec model – widok – kontroler ............................................................................... 19 Kontroler ........................................................................................................................ 19 Parametry akcji ......................................................................................................... 21 Model ............................................................................................................................. 22 Baza danych ............................................................................................................. 23 DAO ......................................................................................................................... 24 Przekazywanie danych ............................................................................................. 26 Parametry w zapytaniu ............................................................................................. 29 Połączenie z wieloma bazami danych ...................................................................... 30 ActiveRecord ............................................................................................................ 32 Porównanie ActiveRecord, SQL i Query Builder ..................................................... 43 Widok ............................................................................................................................. 43

Rozdział 4. Tworzenie formularzy ...................................................................... 47 Budowa formularza ........................................................................................................ 47 Model ....................................................................................................................... 48 Widok ....................................................................................................................... 49 Kontroler .................................................................................................................. 50 Elementy formularza ...................................................................................................... 52 Pole tekstowe — text ................................................................................................ 52 Pole z ukrytą treścią — password ............................................................................. 54 Wielowierszowe pole tekstowe — textarea .............................................................. 55 Pole listy rozwijanej — select .................................................................................. 56 Pole opcji (przełącznik) — radio .............................................................................. 58 Pole wyboru — checkbox ........................................................................................ 59

4

Yii Framework Selektor plików — file ............................................................................................. 61 Pole ukryte — hidden ............................................................................................... 63 Przycisk — button .................................................................................................... 64 Przycisk wysłania formularza — submit .................................................................. 65 Przycisk przywracania danych domyślnych formularza — reset ............................. 67 Walidacja danych ........................................................................................................... 68 Puste pola ................................................................................................................. 70 Porównywanie .......................................................................................................... 71 Poprawność adresu e-mail ........................................................................................ 73 Format daty i czasu .................................................................................................. 73 Domyślna wartość pola ............................................................................................ 74 Wartości istniejące w tabeli ...................................................................................... 75 Konwertowanie otrzymanych danych ...................................................................... 76 Dozwolone ciągi znakowe ........................................................................................ 77 Dozwolona liczba wpisanych znaków ...................................................................... 78 Dozwolone wartości liczb ........................................................................................ 79 Sprawdzanie typu zmiennej ...................................................................................... 80 Wartość unikalna ...................................................................................................... 81 Walidacja adresu URL ............................................................................................. 81 Sprawdzanie wartości pola w zależności od scenariusza .......................................... 82

Rozdział 5. Zaawansowana konfiguracja ........................................................... 87 Zmiana adresu URL ....................................................................................................... 87 Zmiana tytułu ................................................................................................................. 87 Ładowanie bibliotek i komponentów .............................................................................. 88 Błędy aplikacji ................................................................................................................ 90 Dzienniki systemowe ...................................................................................................... 90 Tworzenie łączy .............................................................................................................. 94 Usuwanie nazwy pliku index.php z adresu URL ............................................................ 98 Zmiana ścieżki dostępu Yii ............................................................................................ 99 Własne dane konfiguracyjne ......................................................................................... 100 Strony statyczne ........................................................................................................... 101 Przekierowania ............................................................................................................. 103 Dodawanie komunikatów w sesji ................................................................................. 103 Korzystanie z szablonów .............................................................................................. 105 Przygotowanie aplikacji do opublikowania .................................................................. 108

Rozdział 6. Gii ............................................................................................... 109 Uruchomienie Gii ......................................................................................................... 109 Połączenie z bazą danych ............................................................................................. 110 Tabela w bazie danych ................................................................................................. 110 Logowanie do Gii ......................................................................................................... 111 Tworzenie modeli ......................................................................................................... 112 Tworzenie kontrolerów ................................................................................................. 114 Tworzenie formularzy .................................................................................................. 116 Tworzenie systemu CRUD ........................................................................................... 118

Rozdział 7. Zaawansowane możliwości Yii ...................................................... 125 Automatyczne dzielenie na strony ................................................................................ 125 Sortowanie danych ....................................................................................................... 128 CAPTCHA w formularzach ......................................................................................... 130 Zapisywanie plików na serwerze poprzez formularz .................................................... 134

Spis treści

5

Rozdział 8. Zii ............................................................................................... 137 Rozszerzenia Zii ........................................................................................................... 137 CMenu .......................................................................................................................... 137 CListView .................................................................................................................... 138 CDetailView ................................................................................................................. 140 CBreadcrumbs .............................................................................................................. 141 CGridView ................................................................................................................... 143

Rozdział 9. Budujemy blog — interfejs AR ...................................................... 145 Baza danych ................................................................................................................. 145 Tworzenie aplikacji ...................................................................................................... 152 Główny plik aplikacji ............................................................................................. 153 Główny plik konfiguracyjny ................................................................................... 153 Plik htaccess .......................................................................................................... 154 Arkusz styli ............................................................................................................ 155 Główny plik szablonu strony .................................................................................. 155 Model dla tabeli blog_kategorie ............................................................................. 156 Model dla tabeli blog_komentarze ......................................................................... 158 Model dla tabeli blog_uzytkownicy ....................................................................... 159 Model dla tabeli blog_wpisy .................................................................................. 161 Model do obsługi zmiany hasła .............................................................................. 162 Kontroler bloga ...................................................................................................... 163 Kontroler logowania ............................................................................................... 167 Kontroler panelu administratora ............................................................................. 170 Widok logowania ................................................................................................... 179 Widok bloga — strona główna ............................................................................... 181 Widok bloga — kategoria ...................................................................................... 182 Widok bloga — wpis .............................................................................................. 184 Widok panelu — kategorie ..................................................................................... 186 Widok panelu — aktualizacja kategorii ................................................................. 189 Widok panelu — komentarze ................................................................................. 190 Widok panelu — wpisy .......................................................................................... 191 Widok panelu — aktualizacja wpisu ...................................................................... 193 Widok panelu — zmiana hasła ............................................................................... 196 Słowo końcowe ...................................................................................................... 198

Rozdział 10. Budujemy blog — zapytania SQL .................................................. 199 Baza danych ................................................................................................................. 199 Utworzenie aplikacji ..................................................................................................... 199 Główny plik aplikacji ............................................................................................. 200 Główny plik konfiguracyjny ................................................................................... 200 Plik htaccess .......................................................................................................... 201 Arkusz styli ............................................................................................................ 201 Główny plik szablonu strony .................................................................................. 202 Model dla tabeli blog_kategorie ............................................................................. 203 Model dla tabeli blog_komentarze ......................................................................... 205 Model dla tabeli blog_uzytkownicy ....................................................................... 208 Model dla tabeli blog_wpisy .................................................................................. 209 Model do obsługi zmiany hasła .............................................................................. 212 Kontroler bloga ...................................................................................................... 214 Kontroler logowania ............................................................................................... 218 Kontroler panelu administratora ............................................................................. 220 Widok bloga — strona główna ............................................................................... 229 Widok bloga — kategoria ...................................................................................... 231

6

Yii Framework Widok bloga — wpis .............................................................................................. 231 Widok logowania ................................................................................................... 234 Widok panelu — kategorie ..................................................................................... 236 Widok panelu — aktualizacja kategorii ................................................................. 238 Widok panelu — komentarze ................................................................................. 240 Widok panelu — wpisy .......................................................................................... 241 Widok panelu — aktualizacja wpisu ...................................................................... 245 Widok panelu — zmiana hasła ............................................................................... 247 Słowo końcowe ...................................................................................................... 249

Rozdział 11. Debugowanie aplikacji .................................................................. 251 Co pracuje szybciej: AR czy SQL? .............................................................................. 254 Opcje debugera ............................................................................................................. 255

Podsumowanie ............................................................................. 257 Skorowidz .................................................................................... 259

Wstęp Yii można nazwać frameworkiem na miarę XXI wieku. Przede wszystkim charakteryzuje go wyjątkowa szybkość generowania napisanych za jego pomocą stron. Jest to program bardzo złożony, o prawie nieograniczonych możliwościach i wyjątkowej funkcjonalności, z bardzo rozbudowanym interfejsem dostępu do bazy danych. Zapytania można wykonywać, posługując się językiem SQL, wzorcem ActiveRecord bądź narzędziem Query Builder. W niniejszej książce opiszę jedynie dwa najbardziej przydatne sposoby — konstruktor zapytań SQL i interfejs ActiveRecord. Zaletą interfejsu ActiveRecord jest łatwość wykorzystania: aby wybierać rekordy oraz dodawać, edytować bądź usuwać dane, wystarczy wywołać odpowiednią metodę. Nie trzeba zabezpieczać danych otrzymanych od użytkownika. Wadą tego rozwiązania jest jednak bardzo duża ilość pamięci wymaganej przez system do obsłużenia żądania oraz wydłużenie czasu generowania strony. Drugim rozwiązaniem jest wykorzystanie konstruktora zapytań SQL — w tym przypadku należy jednak pamiętać o zabezpieczeniu danych otrzymywanych od użytkownika, co ma na celu uniknięcie możliwych zagrożeń. Interfejs ten wymaga od programisty większego nakładu pracy, lecz umożliwia o wiele oszczędniejsze wykorzystywanie zasobów serwera. Framework Yii zawiera bardzo dobre biblioteki, przydatne w budowaniu formularzy czy też do walidacji danych przekazywanych w tych formularzach. W ten sposób można całkowicie zapomnieć o żmudnym budowaniu kolejnych instrukcji warunkowych i sprawdzaniu każdej zmiennej z osobna. Wraz z systemem programista otrzymuje dodatek Gii — wyśmienite narzędzie przeznaczone do budowy modułów, modeli, kontrolerów, a nawet całych systemów CRUD1. Dzięki nim można w bardzo prosty sposób utworzyć panel administratora dla budowanej aplikacji.

1

z ang. create, read, update, delete — skrótowiec stosowany do określania relacyjnych baz danych, obiektowych baz danych, ale również w odniesieniu do interfejsu użytkownika, jeśli umożliwia on operacje na danych — przyp. red.

8

Yii Framework

Warto też wspomnieć o Zii — specjalnych bibliotekach, które pozwalają umieszczać dane na stronie w sposób niezmiernie prosty: wystarczy wczytać odpowiednie rozszerzenie, a następnie podać niezbędne dane — i gotowe. Po prostu niesamowite rozwiązanie. Yii oferuje również efektywne zarządzanie aktualizacjami oprogramowania: jest to możliwe dzięki kilku stronom odpowiednio zorganizowanego kodu. Ponadto program Yii zawiera wbudowany język polski. Dzięki temu po pobraniu samego frameworku nie trzeba wyszukiwać, pobierać ani instalować żadnych dodatkowych rozszerzeń.

10

Yii Framework

oprogramowanie 7-Zip1 o możliwościach bardzo zbliżonych do tych, jakie oferuje płatny program WinZip.

Wymagania frameworku Yii należy rozpakować do katalogu, który będzie dostępny poprzez WWW. Można też skorzystać z własnego, lokalnego serwera. Po rozpakowaniu archiwum od razu możemy sprawdzić, czy nasz serwer spełnia wymagania stawiane przez framework. Korzystam z systemu Windows, więc w moim przypadku oprogramowanie znalazło się w katalogu C:\xampp\htdocs\yii. W przypadku Twojego systemu może to być zupełnie inna lokalizacja. Jednak jeżeli korzystasz z Windowsa, wówczas najlepiej pobierz sobie pakiet XAMPP, który zainstaluje w systemie serwer WWW Apache, serwer baz danych MySQL oraz interpreter PHP, a następnie automatycznie skonfiguruje oprogramowanie. Teraz sprawdź, czy na serwerze znalazły się wszystkie wymagane komponenty. W tym celu w przeglądarce internetowej uruchom specjalną stronę zawierającą skrypty sprawdzające. Strona taka została Ci dostarczona wraz z frameworkiem. Wystarczy w przeglądarce wpisać adres http://localhost/yii/requirements/. Dzięki temu zabiegowi możemy uzyskać informację, czy Yii będzie działał na naszym komputerze. Można też sprawdzić, które z jego składników pozostaną wyłączone bądź nie będzie można z nich skorzystać (rysunek 1.2). Do prawidłowego uruchamiania aplikacji utworzonych za pomocą Yii jest potrzebny interpreter PHP w wersji co najmniej 5.1.0. Ważna jest także możliwość pobierania zmiennych z tablicy SERVER, jak również dostęp do specjalnej klasy służącej do operacji na obiektach oraz do rozszerzeń PCRE i SPL. Wszystkie wymagane opcje są dodatkowo opisane w kolumnach z prawej strony. Znajdują się tam informacje o klasach lub akcjach, które potrzebują tych opcji do działania. Informacja, czy dany element jest dostępny na serwerze, jest wyświetlona w kolumnie Rezultat. Zielony kolor w tym polu wskazuje, że dane rozszerzenie jest dostępne i działa poprawnie. Kolor żółty oznacza, iż rozszerzenie to działa, jednak nie wszystkie funkcje (metody) lub zmienne są dostępne. Natomiast kolor czerwony informuje, że oprogramowanie PHP nie zawiera danej funkcji czy biblioteki. W przypadku systemu Linux, jeśli brakuje jakiejś dodatkowej funkcjonalności, wystarczy doinstalować odpowiednią bibliotekę2. Natomiast w systemie Windows problem jest nieco większy, najpierw bowiem trzeba pobrać z internetu odpowiednią bibliotekę, a następnie zainstalować i ręcznie edytować plik php.ini, aby uruchomić dane rozszerzenie. 1

http://7-zip.org.pl/ — przyp. aut.

2

W systemie SUSE i openSUSE służy do tego celu narzędzie YAST — przyp. aut.

Rozdział 1.  Pobieranie Rysunek 1.2. Wymagania Yii

11

12

Yii Framework

Rozdział 2.

Instalacja Za pomocą Yii można w bardzo prosty i efektywny sposób tworzyć złożone aplikacje internetowe, nawet te, które muszą obsłużyć bardzo wielu użytkowników. Aby rozpocząć instalację frameworku, należy wskazać lokalizację interpretera PHP na swoim komputerze. W przypadku systemu Windows można dodać odpowiednią ścieżkę dostępu. Jeżeli korzystasz z systemu Linux bądź Unix, instalowanie interpretera PHP i dokonanie niezbędnych wpisów odbędzie się automatycznie.

Dodawanie ścieżki dostępu w systemie Windows Aby dodać ścieżkę dostępu do PHP w systemie Windows, kliknij prawym przyciskiem myszy ikonę Komputer. Ikonę tę prawdopodobnie znajdziesz na pulpicie. Z menu kontekstowego należy wybrać opcję Właściwości, a potem kliknąć łącze Zaawansowane ustawienia systemu. Następnie trzeba wybrać zakładkę Zaawansowane i kliknąć przycisk Zmienne środowiskowe (rysunek 2.1). Następnie w zakładce Zmienne systemowe trzeba odnaleźć zmienną o nazwie Path. Należy ją zaznaczyć i wybrać przycisk Edytuj… W polu Wartość zmiennej znajdują się wszystkie ścieżki dostępu niezbędne do prawidłowego działania poleceń wywołanych między innymi w trybie MS-DOS. Ustawiamy kursor na samym końcu definicji zmiennej, najlepiej poprzez kliknięcie myszą w polu Wartość zmiennej i przyciśnięcie przycisku End na klawiaturze. Teraz można już wpisać własną ścieżkę dostępu poprzedzoną znakiem średnika: ;C:\xampp\php (rysunek 2.2). Klikamy przycisk OK. W ten sposób wywołanie polecenia PHP spowoduje odwołanie się do tego miejsca. Bardzo ważną sprawą jest, aby nie zmieniać ani nie kasować żadnych wpisów w polu Wartość zmiennej dla zmiennej Path. Jeżeli wprowadziłeś jakiekolwiek zmiany poza dodaniem omawianej ścieżki dostępu, najlepiej anuluj całą operację. Zapisane są tutaj ścieżki systemowe i zmiana jakiegokolwiek znaku spowoduje problemy z systemem Windows! Aby opisane zmiany odniosły skutek, trzeba ponownie uruchomić komputer.

14

Yii Framework

Rysunek 2.1. Okno Właściwości systemu

Rysunek 2.2. Dodawanie obsługi poleceń PHP w systemie Windows

Dodawanie ścieżki dostępu w systemie Linux Linux jest systemem, który stworzono z myślą o instalacji i obsłudze serwerów, dlatego też nie trzeba dodawać ścieżki dostępu do PHP. Każde uruchomione z konsoli polecenie z prefiksem php zostanie automatycznie przesłane do interpretera.

Uruchomienie frameworku Jeśli ścieżka dostępu do interpretera PHP istnieje w konfiguracji systemu, możemy przystąpić do uruchomienia frameworku i utworzyć nową aplikację. Umieścimy ją w folderze test, który utworzymy w katalogu yii, obok folderu zawierającego cały zestaw bibliotek.

Rozdział 2.  Instalacja

15

W tym celu należy uruchomić powłokę (Linux) lub wiersz polecenia (Windows) i przejść do katalogu, w którym znajduje się nasz framework (rysunek 2.3), a następnie wywołać polecenie z listingu 2.1. Listing 2.1. Tworzenie nowej aplikacji php framework/yiic.php webapp test

Rysunek 2.3. Wywołanie polecenia tworzącego nową aplikację

Polecenie z listingu 2.1 powoduje uruchomienie interpretera PHP (php) i wykonanie pliku (framework/yiic.php), do którego przekazano polecenie utworzenia aplikacji (webapp). Parametr (test) określa jej nazwę. Nasza aplikacja zostanie utworzona w katalogu test, znajdującym się w głównym folderze Yii. Po wpisaniu polecenia system wyświetli zapytanie, czy ma utworzyć aplikację we wskazanym katalogu. Wpisz wartość y, a następnie naciśnij Enter (rysunek 2.4).

Rysunek 2.4. Tworzenie nowej aplikacji

Teraz możemy już zajrzeć do katalogu test i przejrzeć pliki nowo utworzonej aplikacji.

Rozdział 2.  Instalacja

17

Listing 2.3. Definicja właściwości rules komponentu aplikacji urlManager po usunięciu znaków komentarza w pliku main.php 'urlManager'=>array( 'urlFormat'=>'path', 'rules'=>array( '/'=>'/view', '//'=>'/', '/'=>'/', ), ),

„Tyle pracy, aby wygenerować jedną stronę!” Zapewne masz ochotę powiedzieć mi, że przecież są inne, lepsze frameworki. Na przykład taki CodeIgniter1: wystarczy zapisać pliki na serwerze i wszystko działa, i to bez większego wysiłku programisty. Owszem, tak właśnie jest. Zauważ jednak, że CodeIgniter jest przeznaczony do tworzenia aplikacji dla małych i średnich serwisów internetowych, natomiast Yii służy do generowania stron, które mają działać w warunkach bardzo dużego obciążenia. Na przykład w Yii ładowanie obiektu następuje tuż przed jego wykorzystaniem, natomiast w przypadku innych frameworków inicjalizowanie klasy ma miejsce dużo wcześniej. Yii zapewnia zatem ogromne oszczędności w użyciu pamięci operacyjnej i procesora. Wszystkie biblioteki niezbędne do działania naszej aplikacji znajdują się w katalogu framework. Dzięki temu możesz poprawić bezpieczeństwo serwisu i umieścić ten folder na swoim serwerze w miejscu niedostępnym dla użytkowników sieci. Takie działanie zmniejszy podatność aplikacji na różnego rodzaju exploity — programy, które dzięki wykorzystaniu błędów w oprogramowania umożliwiają przejęcie kontroli nad systemem.

1

Oficjalna strona CodeIgnitera: http://ellislab.com/codeigniter — przyp. red.

18

Yii Framework

Rozdział 3.

Model, widok, kontroler Wzorzec model – widok – kontroler Framework Yii umożliwia budowanie oprogramowania zgodnie z wzorcem projektowym MVC (ang. Model – View – Controller), co pozwala rozdzielić od siebie logikę aplikacji, sposób jej prezentacji oraz logikę sterowania. Trzema podstawowymi elementami tej koncepcji są: model, widok i kontroler. Model — Ta warstwa dotyczy logiki aplikacji, zapewnia też dostęp do danych, które mogą być na przykład pobrane z bazy danych. Umożliwia więc wykonywanie zapytań w języku SQL, dzięki czemu można operować na poszczególnych rekordach, dodawać, usuwać i aktualizować pola czy w końcu tworzyć i usuwać całe tabele. Model może również umożliwiać transakcyjne przetwarzanie danych za pomocą specjalnych metod. Widok — Jest to warstwa obsługi wyświetlania strony za pomocą wygenerowanego szablonu. Może zawierać wyrażenia PHP, ale zaleca się, aby te wyrażenia nie zmieniały danych modelu — zgodnie z ideą rozdzielania warstwy logiki od warstwy prezentacji. Kod przetwarzający dane powinien znaleźć się w kontrolerze lub w modelu. Kontroler — Warstwa ta reprezentuje działanie aplikacji: przyjmuje dane wejściowe użytkownika i reaguje na jego poczynania. Jej zasadniczą funkcją jest wywoływanie właściwej akcji lub widoku. Zgodnie z założeniami modelu MVC każdy programista, nawet jeśli nie zna dobrze aplikacji napisanej przez inną osobę, powinien móc ją bez problemu zmodyfikować. Drugim interesującym postulatem jest całkowite oddzielenie od siebie poszczególnych sfer tworzenia aplikacji WWW.

Kontroler Nazwa pliku zaczyna się wielką literą, z tym że po nazwie nadanej przez programistę należy dodać słowo „Controller”, także pisane wielką literą. Nazwa pliku jest wykorzystywana w adresie URL.

20

Yii Framework

Kontrolery stanowią główne elementy aplikacji, od których zależy działanie całego skryptu. Są wywoływane po wysłaniu adresu URL przez użytkownika. Najczęściej kontroler jest klasą rozszerzoną CController, a jego nazwa musi być dokładnie taka sama jak nazwa pliku bez rozszerzenia. Teraz możesz napisać swój pierwszy skrypt w Yii. Utwórz plik StronaController.php (listing 3.1) w katalogu protected\controllers. Rozpocznij od deklaracji klasy StronaController. Pamiętaj, że nazwa klasy musi być taka sama jak nazwa pliku. Następnie zadeklaruj, że jest to klasa rozszerzona klasy CController. Nazwa klasy musi zawierać ciąg znaków Controller, dzięki czemu interpreter PHP, przetwarzając wywołany URL, będzie mógł z tego pliku skorzystać. Pamiętaj również, że wszystkie metody wywoływane przez adres URL powinny się zaczynać od deklaracji action, po której następuje nazwa tej metody. Domyślną akcją jest Index. Listing 3.1. Ogólna budowa kontrolera

Wywoływanie kontrolera następuje poprzez adres URL. Wpisanie w przeglądarce adresu http://localhost/yii/test/strona/ spowoduje zatem wywołanie metody actionIndex() z kontrolera, gdyż adres nie zawiera nazwy akcji, która miałaby zostać wykonana (rysunek 3.1). Natomiast wpisanie adresu http://localhost/yii/test/strona/pokaz/ spowoduje wywołanie metody actionPokaz() (rysunek 3.2). Rysunek 3.1. Wywołanie akcji Index

Rysunek 3.2. Wywołanie akcji Pokaz

Rozdział 3.  Model, widok, kontroler

21

Parametry akcji Podobnie jak inne frameworki, Yii umożliwia przekazywanie parametrów do akcji (metody) za pomocą metody GET (czyli w adresie URL). Każdy parametr zdefiniowany w wywołaniu akcji musi zostać zapisany w URL, w przeciwnym razie otrzymamy komunikat o błędzie. Aby się przekonać, jak to działa, zmodyfikujmy nasz kontroler. Dodamy do niego nową akcję o nazwie actionPolicz(), która będzie przyjmowała dwa parametry — dwie wartości liczbowe (listing 3.2). Listing 3.2. Kontroler przyjmujący parametry w adresie URL

Teraz wpisz w przeglądarce internetowej następujący adres: http://localhost/yii/test/ strona/policz/?liczba1=2&liczba2=5. W efekcie wywołania takiego URL skrypt pobierze parametry, czyli nazwę kontrolera, nazwę akcji (metody), którą ma wywołać w tym kontrolerze, jak również dwie zmienne. Zauważ, że na końcu adresu znalazły się zarówno nazwy, jak i wartości tych zmiennych. Bardzo ważne jest, aby nazwy zmiennych w adresie URL były dokładnie takie same jak w kodzie metody. W innym przypadku niezgodność nazw spowoduje błąd aplikacji. Parametry metod można też przekazywać do skryptu nieco inaczej, tak aby adres URL stał się nieco prostszy. Będzie to ułatwienie nie tylko dla użytkowników aplikacji, ale także dla wyszukiwarek — lepsze zaindeksowanie strony w zasobach wyszukiwarki przekłada się na większą liczbę odwiedzin zainteresowanych osób. W tym celu otwórz plik main.php z katalogu protected/config w trybie edycji. Odnajdź w pliku linię urlManager i dopisz wartość jednego klucza (listing 3.3).

22

Yii Framework

Listing 3.3. Modyfikacja głównego pliku z konfiguracją systemu 'urlManager'=>array( 'urlFormat'=>'path', 'rules'=>array( '/'=>'/view', '//'=>'/', '/'=>'/', 'strona/policz//'=>'strona/policz/', ), ),

W jaki sposób działa dopisany fragment kodu? Jeżeli wywołany URL nie będzie zawierał dodatkowych parametrów dodanych za pomocą bezpośredniego przekazania zmiennych, skrypt będzie działał tak samo jak poprzednio. Jeśli natomiast kontroler strona i metoda policz zostaną wywołane wraz z dwoma parametrami liczba1 i liczba2, wówczas program przekieruje to żądanie do akcji policz w kontrolerze strona. Zostaną również przekazane parametry znajdujące się w adresie URL. Po wprowadzeniu powyższej modyfikacji można posłużyć się znacznie czytelniejszym adresem strony: http://localhost/yii/test/strona/policz/2/5/. Zauważ, że parametry są przekazywane podobnie jak ścieżka dostępu (rysunek 3.3). Rysunek 3.3. Wywołanie adresu ze zdefiniowanymi parametrami

Model Nazwa pliku zaczyna się wielką literą.

We frameworku Yii możemy wyróżnić dwa rodzaje modeli. Pierwszym z nich jest model rekordu aktywnego, który służy do obsługi bazy danych, drugi zaś to model formularza, który jest szczególnie przydatny do odbierania i przetwarzania danych wprowadzanych przez użytkownika. Właśnie w tym drugim modelu określa się warunki walidacji otrzymanych danych. Zanim lepiej się zapoznasz z działaniem opisywanych modeli, skonfiguruj połączenie z bazą danych. Otwórz do edycji plik main.php z katalogu protected/config, aby zdefiniować dane dostępowe. W tym celu znajdź klucz o nazwie components i z linii oznaczonej kluczem db (listing 3.4) usuń znaki komentarza.

Rozdział 3.  Model, widok, kontroler

23

Listing 3.4. Definicja danych dostępowych do bazy danych 'db'=>array( 'connectionString' => 'mysql:host=localhost;dbname=testdrive', 'emulatePrepare' => true, 'username' => 'root', 'password' => '', 'charset' => 'utf8', ),

W kluczu db wpisz odpowiednie dane do swojego serwera bazy danych. Zakładam, że korzystasz z oprogramowania XAMPP. W kluczu connectionString wpisz, z jakiego rodzaju bazą danych masz zamiar się łączyć (w moim przypadku: mysql), następnie po słowie host zdefiniuj adres, pod którym dostępna jest baza danych, a po dbname określ jej nazwę. W kluczu username należy podać nazwę użytkownika, w kluczu password — jego hasło. Należy także ustawić kodowanie charset na utf8, standard pozwalający na zapisywanie znaków diakrytycznych różnych języków. Gotowy fragment pliku znajduje się na listingu 3.5. Listing 3.5. Skonfigurowany dostęp do bazy danych 'db'=>array( 'connectionString' => 'mysql:host=localhost;dbname=aplikacjatest, 'emulatePrepare' => true, 'username' => 'root', 'password' => '', 'charset' => 'utf8', ),

Baza danych Pozostało nam jeszcze utworzenie bazy danych. Wykorzystamy do tego celu oprogramowanie phpMyAdmin, narzędzie dostarczane razem z pakietem XAMPP. Wpisz więc w przeglądarce adres http://localhost/phpmyadmin/. W górnym menu wybierz pozycję Bazy danych. Otworzy się strona zawierająca formularz Utwórz bazę danych. W pierwszym polu należy wpisać nazwę nowej bazy: aplikacjatest, a w drugim wybrać domyślny system kodowania znaków. Wybierz opcję utf8_general_ci i kliknij przycisk Utwórz (rysunek 3.4). Rysunek 3.4. Dodawanie nowej bazy danych

Po utworzeniu bazy danych kliknij menu Struktura znajdujące się na górze strony i wypełnij formularz Utwórz tabelę. W polu Nazwa wpisz nazwę nowej tabeli: osoby. Następnie w polu Liczba kolumn wpisz wartość 3, jako że tabela będzie się składać z trzech pól. Kliknij przycisk Wykonaj.

24

Yii Framework

W następnym kroku zdefiniuj pola tabeli. Pierwszym będzie pole typu INT o nazwie id. Dodatkowo ustaw wartość Index na PRIMARY oraz zaznacz pole AUTO_INCREMENT. Drugie pole nazwij imie, nadaj typ VARCHAR i określ długość na 35 znaków. Trzecie pole, również typu VARCHAR, nazwij nazwisko i określ długość na 45 znaków. Po wypełnieniu pól kliknij przycisk Zachowaj. W ten sposób utworzyłeś nową tabelę. Wypełnij ją jeszcze danymi. W tym celu kliknij łącze Dodaj w menu w górnej części strony i wypełnij danymi w polach imie oraz nazwisko, zatwierdzając zmiany przyciskiem Wykonaj. Jeżeli nie są Ci obce podstawy obsługi baz danych, możesz przeanalizować kod SQL, który umieściłem na listingu 3.6. Kod ten utworzy tabelę, a następnie wypełni ją danymi. Listing 3.6. Tworzenie tabeli i wypełnienie jej danymi w języku SQL CREATE TABLE IF NOT EXISTS 'osoby' ( 'id' int(11) NOT NULL AUTO_INCREMENT, 'imie' varchar(35) COLLATE utf8_unicode_ci NOT NULL, 'nazwisko' varchar(45) COLLATE utf8_unicode_ci NOT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=4 ; INSERT INTO `osoby` (`id`, `imie`, `nazwisko`) VALUES (1, 'Łukasz', 'Sosna'), (2, 'Rafał', 'Myślenica'), (3, 'Michał', 'Kowalski');

DAO Dzięki interfejsowi DAO (z ang. Data Access Object — jest to jednolity interfejs do komunikacji między aplikacją a źródłem danych, który umożliwia oddzielenie dostępu do danych od logiki biznesowej i warstwy prezentacji) możemy bez problemu korzystać z różnych typów baz danych. W tym celu wystarczy dokonać konfiguracji w głównym pliku aplikacji. Zastosowanie interfejsu DAO uniezależnia programistę od specjalnych plików dla modeli. Potrzebne instrukcje można z łatwością umieścić w kontrolerze. Aby sprawdzić, jak to działa, utworzymy plik BazadanychController.php w katalogu protected/controllers. Wpiszemy do niego klasę kontrolera rozszerzoną przez klasę nadrzędną. W metodzie actionIndex() (przypomnę, że klasa ta jest wywoływana domyślnie, jeśli pożądana akcja nie zostanie wskazana wprost) zadeklarujemy instancję klasy do połączenia się z bazą danych i przypiszemy jej wartość do zmiennej. Następnie za pomocą metody createCommand() zdefiniujemy potrzebne zapytanie. Dzięki metodzie query() po wykonaniu zapytania w bazie danych otrzymamy uchwyt, z którego będzie można pobrać wyniki. Posłużymy się w tym celu pętlą while, dla której warunkiem ukończenia będzie wartość rekordu równa false (listing 3.7). Skrypt wywołuje się poprzez wpisanie w pasku adresu przeglądarki: http://localhost/yii/test/bazadanych. Efekt wykonania skryptu, czyli wyświetlenie wszystkich rekordów z tabeli osoby, pokazałem na rysunku 3.5.

Rozdział 3.  Model, widok, kontroler

25

Listing 3.7. Kontroler z obsługą bazy danych

Rysunek 3.5. Dane pobrane z tabeli w wyniku wykonania połączenia z bazą danych

Zasadniczo istnieją dwa sposoby wykonywania zapytań na bazie danych. W powyższym przykładzie zastosowaliśmy metodę query(), która idealnie się nadaje dla zapytania SELECT. Natomiast w przypadku zapytań, dzięki którym nie otrzymujemy żadnych danych, a jedynie liczbę zmodyfikowanych rekordów (tzn. zapytań DELETE, UPDATE, INSERT), lepszym rozwiązaniem będzie metoda execute(). A zatem teraz zadeklarujemy nową metodę actionDodaj() w kontrolerze, w którym wczytujemy instancję bazy danych. Następnie zdefiniujemy zapytanie INSERT INTO i wykonamy je na bazie danych za pomocą metody execute() (listing 3.8). Adres URL do naszej nowej akcji wygląda następująco: http://localhost/yii/test/bazadanych/dodaj. Listing 3.8. Dodawanie nowego rekordu do bazy danych

Po wywołaniu adresu otwórz poprzednią stronę. Sprawdź, czy nowy rekord został poprawnie dodany.

Przekazywanie danych Framework Yii udostępnia metody umożliwiające różne sposoby wyświetlania danych. Bardzo to ułatwia pracę z systemem. Oprócz omówionych już metod query() i execute() mamy do dyspozycji jeszcze cztery inne metody pozwalające uzyskiwać dane w postaci tablicy bądź zwykłego tekstu. Aby przetestować ich działanie, utwórz nowy kontroler TypwynikowController.php w katalogu protected/controllers, a następnie wpisz do niego cztery akcje (listing 3.9). Listing 3.9. Kontroler wraz z zapytaniami przekazującymi dane wynikowe na różne sposoby

Przeanalizujmy plik zapisany na powyższym listingu. W pierwszej akcji użyliśmy metody queryAll(), która przekaże wszystkie wyniki z zapytania w postaci tablicy (rysunek 3.6). Druga akcja polega na zastosowaniu metody queryRow(). Tym razem otrzymamy tylko pierwszy rekord z tabeli w postaci tablicy (rysunek 3.7). Trzecia metoda, queryColumn(), umieszczona w akcji actionZapytanie3(), przekaże zawartość pierwszej kolumny w postaci tablicy (rysunek 3.8). Ostatnią metodą w powyższym pliku jest queryScalar(), dzięki której otrzymamy wartość z pierwszej kolumny i pierwszego pola (rysunek 3.9). Wynik będzie zapisany w formie tekstowej.

28 Rysunek 3.6. Zapytanie przekazujące wszystkie dane z tabeli

Rysunek 3.7. Zapytanie przekazujące dane z pierwszego rekordu tabeli

Rysunek 3.8. Zapytanie przekazujące dane tylko z pierwszego pola tabeli

Rysunek 3.9. Zapytanie przekazujące wartość zawartą w pierwszym polu pierwszego rekordu

Yii Framework

Rozdział 3.  Model, widok, kontroler

29

Parametry w zapytaniu Umożliwienie użytkownikowi wysyłania formularzy z danymi w celu ich bezpośredniego zapisania w bazie danych może być bardzo niebezpieczne dla aplikacji. Należy więc przyjąć i przestrzegać zasadę mówiącą o obowiązku zabezpieczania wszystkich danych, które będą przekazywane do aplikacji. Jeśli piszesz skrypty bez użycia frameworku, możesz zastosować funkcję addslashes(), jednak w oprogramowaniu Yii ten problem został rozwiązany w znacznie lepszy sposób. Utwórz więc nowy kontroler o nazwie FormularzdaneController.php w katalogu protected/controllers. Jego zadaniem będzie pobieranie danych i umieszczanie ich w tabeli. Następnie trzeba zdefiniować domyślnie wywoływaną metodę actionIndex(). Wewnątrz umieścimy instrukcję warunkową, dzięki której się dowiemy, czy wysłana metodą POST zmienna wyslano ma wartość tak. Następnym krokiem jest inicjalizacja interfejsu połączenia z bazą danych. Teraz tworzymy zapytanie, w którym zamiast wartości wpisujemy nazwy pseudozmiennych, rozpoczynając je od znaku dwukropka. Wartości przypisujemy za pomocą metody bindParam(), której parametrami są kolejno: nazwa pseudozmiennej, wartość tej zmiennej i rodzaj wartości. W naszym przypadku będzie to ciąg znaków PDO::PARAM_STR. Teraz po powiązaniu parametrów możemy wywołać metodę, która wykona nasze zapytanie, a następnie wyświetlić odpowiedni komunikat. Po zakończeniu instrukcji warunkowej deklarujemy formularz służący do wprowadzania danych. Omówiony kod znajduje się na listingu 3.10. Listing 3.10. Kontroler, który dodaje dane do bazy danych z wykorzystaniem PDO

Aby przetestować kod, w pasku adresu przeglądarki wpisz adres http://localhost/yii/ test/formularzdane (rysunek 3.10). Wypełnij formularz: w polu Imię wpisz: Małgorzata, a w polu Nazwisko — Nowak. Kliknij przycisk Dodaj. Efektem tego działania jest dodanie do bazy danych nowego rekordu. Rysunek 3.10. Strona z komunikatem o dodaniu nowego rekordu

Połączenie z wieloma bazami danych Dzięki frameworkowi możesz ustanawiać połączenia z praktycznie dowolną liczbą baz danych. W tym podrozdziale ograniczę się jednak do pokazania sposobu łączenia się z dwoma bazami. Najpierw musimy utworzyć nową bazę danych aplikacjatest2, zdefiniować w niej tabelę zawody oraz wypełnić ją danymi (listing 3.11). Listing 3.11. Struktura i dane tabeli zawody CREATE TABLE IF NOT EXISTS zawody ( id int(11) NOT NULL AUTO_INCREMENT, nazwa varchar(35) COLLATE utf8_unicode_ci NOT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=5 ; INSERT INTO zawody (id, nazwa) VALUES (1, 'kasjer'), (2, 'sekretarka'), (3, 'informatyk'), (4, 'krawiec');

Następnie otwórzmy plik main.php z katalogu protected/config i dodajmy nowy klucz z definicją bazy danych aplikacjatest2 (listing 3.12). Klucz nazwiemy db2. Posłuży on do ustanawiania połączeń z tą bazą danych. Ważne jest, aby użyć klucza class i w nim zdefiniować wartość CDbConnection. W ten sposób informacje umieszczone w tym miejscu zostaną wykorzystane do łączenia się z bazą danych. Listing 3.12. Część pliku z konfiguracją systemu 'db'=>array( 'connectionString' => 'mysql:host=localhost;dbname=aplikacjatest', 'emulatePrepare' => true,

Rozdział 3.  Model, widok, kontroler

31

'username' => 'root', 'password' => '', 'charset' => 'utf8', ), 'db2'=>array( 'class'=>'CDbConnection', 'connectionString' => 'mysql:host=localhost;dbname=aplikacjatest2', 'emulatePrepare' => true, 'username' => 'root', 'password' => '', 'charset' => 'utf8', ),

Utwórzmy jeszcze kontroler o nazwie DwieBazyController.php w katalogu protected/controllers. Zdefiniujemy tu połączenie z pierwszą bazą danych i umieścimy kod, który wykona zapytanie i obsłuży dane otrzymane z bazy. Następnie dodamy definicję połączenia z drugą bazą danych i wpiszemy kod, który wykona te same operacje co w przypadku pierwszej bazy danych. Do inicjalizacji wykorzystujemy klucze z pliku main.php: dla pierwszej bazy danych db, a dla drugiej db2. Dzięki tej prostej metodzie można korzystać z połączeń z dowolną liczbą baz danych (listing 3.13). Listing 3.13. Kontroler, który pobiera i wyświetla dane z dwóch baz

Aby sprawdzić powyższy kod, w przeglądarce wpisz adres http://localhost/yii/test/ dwiebazy. Powinieneś zobaczyć wyświetlone dane pochodzące z dwóch różnych baz (rysunek 3.11). Rysunek 3.11. Informacje pochodzące z dwóch baz danych

ActiveRecord ActiveRecord jest techniką, która umożliwia łatwiejszą komunikację z bazą danych. Dzięki specjalnie przygotowanym metodom większość operacji bazodanowych staje się bardzo prosta. Najpierw należy przygotować plik z modelem. Aby ułatwić sobie pracę z wieloma plikami, przyjmijmy, że nazwa pliku z modelem będzie dokładnie taka sama jak odpowiadającej mu tabeli. A zatem tworzymy plik o nazwie Osoby.php i umieszczamy go w katalogu protected/models (listing 3.14). Listing 3.14. Plik modelu dla tabeli osoby

Najpierw należy zdefiniować nazwę klasy, która musi być taka sama jak nazwa pliku. Jest to klasa rozszerzająca CActiveRecord. Pierwsza metoda musi zawierać odwołanie do modelu nadrzędnego, dzięki czemu odziedziczy wszystkie jego właściwości.

Rozdział 3.  Model, widok, kontroler

33

Dodawanie rekordu Aby sprawdzić, czy tak zbudowany model będzie działał, potrzebujemy jeszcze kontrolera, który umożliwi dodawanie danych do bazy. Teraz więc w katalogu protected/controllers zapisujemy plik FormularzarController.php. Otwieramy go i w metodzie actionDodaj() ładujemy nowo utworzony model za pomocą polecenia new, po którym wpisujemy nazwę pliku. To wystarczy, aby Yii dołączył do kontrolera odpowiedni plik. Następnie definiujemy we właściwościach obiektu dane nowego rekordu: powinny być zgodne z nazwami pól w tabeli. Teraz wywołujemy metodę save(), którą model osoby odziedziczył po swoim modelu nadrzędnym. Na końcu wystarczy jeszcze wyświetlić komunikat o umieszczeniu rekordu w tabeli (listing 3.15). Listing 3.15. Dodawanie nowego rekordu za pomocą AR

Aby sprawdzić działanie skryptu, w przeglądarce wpisujemy adres http://localhost/yii/ test/formularzar/dodaj. Jeśli wszystko przeprowadziliśmy poprawnie, nowy rekord został dodany do bazy danych. Prawda, że proste? To dopiero początek możliwości techniki ActiveRecord.

Wyświetlanie wyników Oprogramowanie Yii udostępnia wiele różnych metod służących do pozyskiwania danych z bazy. Najważniejszymi z nich są: find(), findByPk(), findByAttributes(), findBySql(). Wszystkie te metody są dostępne z klasy modelu będącej rozszerzeniem ActiveRecord. Aby wypróbować działanie tych metod, zaczniemy od utworzenia nowego pliku FormularzDodajController.php w katalogu protected/controllers. Otwórz ten plik i zapisz w nim nową akcję actionSzukaj1(). Tutaj posłużymy się metodą find(), dzięki której można

34

Yii Framework

wybierać z bazy danych dane spełniające określone kryteria. W tym przypadku chodzi o odnalezienie nazwiska osoby, której imię jest nam znane. Następnie trzeba zainicjalizować ActiveRecord poprzez wywołanie klasy modelu i przypisanie jej instancji do zmiennej, która będzie zawierała obiekt. Następnie do zmiennej $Wynik (która będzie przechowywała rezultat zapytania) przypisujemy nazwę klasy. Z klasy tej odwołujemy się do metody model(), a z niej do metody find(). Metoda find() przyjmuje dwa parametry. Pierwszy to definicja warunku. W tym przypadku będzie to wartość pola imie. Drugim parametrem jest tablica zawierająca pseudozmienne, które znalazły się w pierwszym parametrze. Efektem działania metody find() ma być rekord, którego pole imie jest równe Ola. Następnie trzeba wyświetlić wynik wykonania zapytania. Wszystkie wartości znajdują się w obiekcie $Wynik i mają nazwy pól tabeli (listing 3.16). Listing 3.16. Wybieranie rekordu spełniającego określone kryteria

Teraz możemy przetestować skrypt i wpisać do przeglądarki adres http://localhost/yii/ test/formularzdodaj/szukaj1. Powinieneś otrzymać wynik taki jak na rysunku 3.12. Rysunek 3.12. Poszukiwanie nazwiska osoby o określonym imieniu

Z kolei do przeszukiwania bazy danych według klucza głównego (PRIMARY KEY) możesz wykorzystać metodę findByPK(). Jest to prosta i efektywna metoda wyszukiwania określonych rekordów, na przykład w celu ich edycji. Definicja tej funkcji wygląda podobnie jak metody find(), z tą różnicą, że jako pierwszy parametr należy podać wartość klucza głównego (listing 3.17). Wspomnę jeszcze, że metoda findByPK() przyjmuje także dwa kolejne, opcjonalne parametry: definicję instrukcji warunkowej i wartości przekazywane do tej definicji.

Rozdział 3.  Model, widok, kontroler

35

Listing 3.17. Wyszukiwanie według klucza głównego

Aby przetestować skrypt, należy w pasku adresu przeglądarki wpisać URL http://localhost/ yii/test/formularzdodaj/szukaj2. Z kolei metoda findByAttributes() pozwala na przeszukiwanie tabeli z wykorzystaniem różnych warunków, które w tym przypadku nazywają się atrybutami. Na przykład zapytanie może wymagać porównania wartości w kilku kolumnach. Atrybuty deklaruje się w tablicy, którą należy przekazać do metody findByAttributes(). Wszystkie definicje warunków muszą zgadzać się z nazwami pól w tabeli. Na listingu 3.18 przedstawiłem odpowiedni, choć bardzo prosty przykład. Podobnie jak wcześniej opisane metody, także i findByAttributes() przyjmuje dodatkowe parametry: definicję warunku i pseudozmienne. Jednak moim zdaniem, jeśli przeszukujemy tabelę według wartości atrybutu, wprowadzanie dodatkowych parametrów jest niezbyt potrzebne. Listing 3.18. Wyszukiwanie według wartości atrybutu

36

Yii Framework

Wynik wykonania skryptu zostanie wyświetlony po wpisaniu w przeglądarce adresu http://localhost/yii/test/formularzdodaj/szukaj3. Opiszę tu jeszcze jedną metodę służącą do wyszukiwania danych w tabeli, a mianowicie findBySql(). Funkcja ta przyjmuje zapytanie SQL, dla którego w drugim parametrze podaje się wartość pseudozmiennych (listing 3.19). Jeśli przedstawione wcześniej metody nie gwarantują funkcjonalności odpowiedniej dla Twojej aplikacji, powinieneś poradzić sobie za pomocą findBySql(). Listing 3.19. Wybieranie danych za pomocą zapytania SQL wprowadzonego jako parametr metody findBySql()

Podobnie jak we wcześniejszych przypadkach, tak i tutaj uruchomienie skryptu następuje po wpisaniu do przeglądarki adresu http://localhost/yii/test/formularzdodaj/szukaj4. Otrzymane wyniki powinny być takie, jak w przypadku wyszukiwania za pomocą zwykłego zapytania SQL. Jeśli wynikiem wykonania zapytania może być większa ilość danych (z większej liczby rekordów), możesz się posłużyć metodą findAll(). Baza danych przekazuje do aplikacji dane w taki sposób, że dane z każdego rekordu są zapisywane w osobnym kluczu. Dostęp do tych danych można uzyskać za pomocą pętli. Jak dokładnie to wygląda? Najpierw inicjalizujemy obiekt zawierający model, który umożliwi dostęp do tabeli osoby. Potem wykonujemy metodę findAll() bez podania parametrów. W ten sposób baza danych przekaże wszystkie dane z tabeli. Następnie deklarujemy pętlę for. Warunkiem zakończenia działania pętli jest przetworzenie wszystkich pobranych z bazy rekordów, co można sprawdzić za pomocą funkcji count(). W ten sposób pętla for umożliwia wyświetlanie danych z każdego rekordu po kolei, podobnie jak w przypadku wyświetlania tylko jednego wyniku. Trzeba tylko pamiętać o podaniu przynależnego do obiektu $Wynik licznika pętli ($i). Skrypt zaprezentowany jest na listingu 3.20.

Rozdział 3.  Model, widok, kontroler

37

Listing 3.20. Wyświetlanie danych pochodzących z wszystkich wierszy tabeli

Aby uruchomić skrypt, wpisz w pasku adresu przeglądarki: http://localhost/yii/test/ formularzdodaj/szukaj5. Rezultat wykonania programu został zaprezentowany na rysunku 3.13. Rysunek 3.13. Wyświetlenie danych ze wszystkich wierszy tabeli

Aktualizacja rekordu Aby w bardzo łatwy sposób zaktualizować dane w tabeli, można się posłużyć metodą find() lub jej pochodnymi. Teraz pokażę, w jaki sposób zaktualizować dane z rekordu wybranego za pomocą metody findByPk(). Przede wszystkim utwórzmy w katalogu protected/controllers plik AktualizujController.php. Teraz trzeba zainicjalizować obiekt zapewniający dostęp do bazy danych (model). Następnie za pomocą metody findByPk() wybierzemy rekord o indeksie równym 3. Teraz można wyświetlić dane albo je zaktualizować. Jeśli chcesz je zaktualizować, do pola imie należy przypisać nową wartość, a następnie wywołać metodę save() (listing 3.21). Metoda save() może służyć zarówno do aktualizowania, jak i do wstawiania nowych rekordów w tabeli. Wstawienie nowego rekordu wymagałoby utworzenia instancji odpowiedniej klasy AR za pomocą operatora new. Można też posłużyć się już istniejącą instancją bez wybierania rekordu. W omawianym przypadku wywołaliśmy metodę findByPk(), więc wywołanie save() spowoduje zaktualizowanie istniejącego wiersza w tabeli.

38

Yii Framework

Listing 3.21. Aktualizacja rekordu w tabeli

Aby przetestować powyższy kod, w przeglądarce należy wpisać adres http://localhost/ yii/test/aktualizuj. Aktualizacja danych jest możliwa także za pomocą metody updateByPk(). Pierwszym parametrem tej metody jest wartość klucza głównego (PRIMARY KEY) modyfikowanego rekordu, natomiast w drugim należy zadeklarować tablicę zawierającą nazwy i wartości aktualizowanych pól (listing 3.22). Istnieje także możliwość podania dodatkowych parametrów, podobnie jak w przypadku metod z rodzaju find(). Na przykład mogą to być dodatkowe kryteria wyszukiwania czy deklaracja pseudozmiennych. Listing 3.22. Aktualizowanie rekordów wybranych za pomocą wartości klucza głównego

Aby uruchomić skrypt, wpisz w przeglądarce internetowej adres http://localhost/yii/ test/aktualizuj/aktualizuj2/.

Rozdział 3.  Model, widok, kontroler

39

Framework Yii pozwala także aktualizować wszystkie rekordy spełniające wybrane kryteria. Służy do tego metoda updateAll(), która przyjmuje trzy parametry. Pierwszym z nich jest tablica wartości kolumn określanych przez ich nazwy, drugi to deklaracja warunku zapytania, a trzeci — wykorzystane w warunku zapytania pseudozmienne (listing 3.23). Listing 3.23. Aktualizacja rekordu według ustalonych kryteriów

Aby przetestować skrypt, wpisz w przeglądarce adres http://localhost/yii/test/aktualizuj/ aktualizuj3.

Usuwanie rekordu Istnieje kilka sposobów usuwania rekordów z tabeli. Podobnie jak w przypadku aktualizacji danych w tabeli, można najpierw wybrać rekord za pomocą metody find(), a następnie go po prostu usunąć za pomocą metody delete(). A zatem tworzymy plik UsunController.php w katalogu protected/controllers. Inicjalizujemy obiekt, wybieramy dane z tabeli, ustawiając wartość klucza PRIMARY KEY na 4. Następnie wywołujemy metodę delete() wobec obiektu, w którym znalazły się wybrane z tabeli dane (listing 3.24). Listing 3.24. Usuwanie wybranego rekordu

Aby uruchomić skrypt, w przeglądarce wpisujemy adres http://localhost/yii/test/usun. Istnieje oczywiście prostszy sposób usuwania rekordów o wskazanej wartości klucza głównego: wystarczy wywołać metodę deleteByPK(). Pierwszym parametrem metody jest wartość klucza głównego (listing 3.25). Można jeszcze podać dwa opcjonalne parametry (dokładnie tak samo jak w metodzie find() i podobnych), a są to warunki wyszukiwania i definicja pseudozmiennych. Listing 3.25. Usuwanie rekordu według wartości klucza głównego

Skrypt wywołujemy poprzez wpisanie w pasku adresu przeglądarki: http://localhost/yii/ test/usun/usun2. Istnieje także możliwość usuwania rekordów spełniających odpowiednie warunki. W tym celu stosuje się metodę deleteAll(). Pierwszym jej parametrem jest definicja warunków wyszukiwania rekordów, a drugim — definicja pseudozmiennych użytych podczas wyszukiwania (listing 3.26). Listing 3.26. Usuwanie rekordów spełniających zadany warunek

Aby uruchomić skrypt, wpisz w przeglądarce internetowej adres http://localhost/yii/ test/usun/usun3.

Zliczanie rekordów w tabeli Opisałem już, w jaki sposób można wybierać dane, umieszczać je w tabeli, aktualizować i usuwać. Dobrze jest jednak także wiedzieć, ile rekordów znajduje się w tabeli — taką informację można wyświetlić użytkownikowi, można też łatwiej podzielić większą ilość danych na kilka stron. A więc tworzymy plik PoliczController.php w katalogu protected/controllers. Inicjalizujemy obiekt (model), który umożliwi nam operacje na bazie danych. Następnie wywołujemy metodę count(). Pierwszym jej parametrem jest określenie, jakie warunki muszą spełniać zliczane pola w tabeli. Drugim parametrem jest deklaracja pseudozmiennych wraz z ich wartościami. Teraz wystarczy już tylko wyświetlić wynik zliczania rekordów (listing 3.27). Listing 3.27. Wyświetlanie liczby rekordów spełniających zadane warunki

Aby uruchomić skrypt, wystarczy posłużyć się adresem http://localhost/yii/test/policz.

42

Yii Framework

Zliczanie rekordów jest możliwe również za pomocą metody wykorzystującej zapytanie SQL: countBySql(). Pierwszym parametrem tej metody jest właśnie zapytanie w języku SQL. Bardzo ważne jest, aby w tym zapytaniu znalazła się klauzula count(). W przypadku braku tej klauzuli metoda po prostu zliczy wszystkie rekordy w tabeli. Drugim parametrem jest deklaracja pseudozmiennych wraz z ich wartościami (listing 3.28). Listing 3.28. Zliczanie rekordów tabeli za pomocą zapytania SQL

Aby sprawdzić działanie programu, w pasku adresu przeglądarki wpisujemy: http:// localhost/yii/test/policz/policz2. Przykładowy wynik wykonania skryptu został zaprezentowany na rysunku 3.14. Rysunek 3.14. Zliczanie rekordów przy użyciu zapytania SQL

Kilka gorzkich słów o ActiveRecord Oczywistą jest sprawą, że podczas tworzenia aplikacji trzeba zwracać szczególną uwagę na ilość zajmowanej pamięci RAM i obciążenie procesora. Niestety, ActiveRecord pochłania bardzo, ale to bardzo dużo pamięci. Wykonywanie zapytań za pomocą tej klasy wymaga aż trzy razy więcej pamięci niż potrzebują zwykłe zapytania SQL. Wynika z tego, że zanim zaczniesz projektować aplikację, musisz oszacować liczbę jej użytkowników. Jeśli nie będzie ich zbyt wielu, na przykład w przypadku aplikacji wykorzystywanej w ramach firmy, możesz bez wielkiego ryzyka wykorzystać ActiveRecord. Jednak jeżeli planujesz tworzyć aplikacje internetowe, gdzie musisz się liczyć ze znacznie większą liczbą użytkowników, najlepiej pozostań przy zwykłych zapytaniach SQL. Dzięki temu Twoja aplikacja sprawnie obsłuży nawet ogromną rzeszę użytkowników.

Rozdział 3.  Model, widok, kontroler

43

Porównanie ActiveRecord, SQL i Query Builder Framework Yii oferuje kilka różnych sposobów uzyskiwania dostępu do bazy danych. Zapewne pamiętasz, że wspomniałem o ActiveRecord, o zwykłych zapytaniach SQL oraz o Query Builder. Każda z tych metod ma zarówno zalety, jak i wady.  ActiveRecord buduje zapytania bez większego wysiłku ze strony programisty,

tak że nie musisz znać języka SQL. Gii umożliwia automatyczne generowanie modeli tabel powiązanych relacjami. Wadą tego rozwiązania jest zużywanie ogromnych ilości pamięci. Poza tym ActiveRecord działa wolniej w porównaniu do zapytań SQL. Wspomnę jeszcze, że szczególnie przydatny jest do testowania aplikacji.  Query Builder charakteryzuje się łatwym do opanowania interfejsem.

Dane z tabel przekazuje w postaci surowej. Problemy mogą wystąpić przy konstruowaniu bardziej złożonych zapytań — aby sobie z tym poradzić, musisz dokładnie poznać API. Niestety, niektóre zapytania mogą się okazać trudne do odczytania.  Zwykłe zapytania SQL stanowią najbardziej polecaną metodę wykonywania

zapytań na bazie danych. Zaletami tej metody są oszczędne korzystanie z zasobów i szybkie działanie. Dane otrzymane po wykonaniu zapytania są przekazywane w postaci surowej. Wadą tej metody jest natomiast konieczność znajomości języka SQL.

Widok Nazwa pliku zapisana wyłącznie małymi literami. Pliki powinny się znajdować w katalogu o takiej samej nazwie jaką ma kontroler.

Widoki można określić jako rodzaje szablonów służących do prezentacji treści. Budowa widoku jest bardzo prosta, co pozwala szybko zmodyfikować wygląd strony nawet osobie nieznającej języka PHP. W widokach powinny znaleźć się jedynie elementy w języku HTML i proste skrypty do prezentacji danych. Zaraz pokażę, na czym to polega. Najpierw utwórzmy nowy kontroler, który będzie korzystał z naszego widoku. Plik WidokController.php zapiszemy w katalogu protected/ controllers. W domyślnej akcji actionIndex() wywołamy metodę render(), która służy do generowania widoków z plików znajdujących się w folderze protected/views. Pierwszym parametrem jest nazwa wczytywanego pliku bez rozszerzenia, natomiast w drugim parametrze podajemy tablicę z wartościami zmiennych, których użyjemy w pliku z widokiem (listing 3.29).

44

Yii Framework

Listing 3.29. Kontroler wraz ze zmiennymi przekazywanymi do widoku

Teraz utworzymy plik z widokiem, czyli szablonem strony. Najpierw w folderze protected\views utworzymy katalog o nazwie kontrolera widok. W katalogu tym zapiszemy plik pierwszywidok.php. W widoku wszystkie przypisane elementy tablicy są zmiennymi o nazwie takiej samej jak ich klucze. Można je bez problemu wyświetlić przy użyciu funkcji echo (listing 3.30). Listing 3.30. Widok wyświetlający zmienne przekazane jako parametry

Teraz możemy w przeglądarce internetowej wpisać adres http://localhost/yii/test/widok. Powinniśmy zobaczyć, że na stronie znalazły się treści, które zostały przekazane do widoku z kontrolera (rysunek 3.15).

Rozdział 3.  Model, widok, kontroler

45

Rysunek 3.15. Gotowa strona generowana z widoku

Zapewne zauważyłeś, że w pliku widoku nie ma typowych dla HTML znaczników określających poszczególne części strony. Yii zawiera system szablonów, dzięki czemu my możemy zająć się jedynie generowaniem treści strony. Wygląd poszczególnych elementów stron został zdefiniowany w odpowiednich plikach, które znajdują się w katalogu protected\views\layouts.

46

Yii Framework

Rozdział 4.

Tworzenie formularzy Framework Yii udostępnia specjalną klasę służącą do tworzenia formularzy — CForm. Klasa ta znacząco ułatwia pracę programiście. Pozwala również na wielokrotne wykorzystywanie kodu oraz upraszcza dostosowywanie tworzonych formularzy do potrzeb i modyfikację właściwości poszczególnych pól. Ponadto, począwszy od wydania 1.1.1, można korzystać z klasy CActiveForm. Zapewnia ona zestaw metod, które bardzo ułatwiają budowę złożonych formularzy HTML powiązanych z modelami. W tym rozdziale pokażę, w jaki sposób wykorzystać możliwości klasy CActiveForm.

Budowa formularza Metody udostępnione we frameworku umożliwiają budowę formularzy w prosty sposób. Dzięki temu bez problemów napiszesz aplikację, która pobierze informacje wprowadzone przez użytkownika, sprawdzi ich poprawność, a następnie umieści czy też zaktualizuje je w bazie danych. Aby móc wykorzystać te obiecujące możliwości, formularz napisany za pomocą Yii powinien składać się z trzech elementów: pierwszy to model, w którym znajdzie się informacja o potrzebnych polach formularza, drugim jest kontroler zawierający odpowiednią akcję, natomiast trzecim — widok wraz z definicjami pól. Przed rozpoczęciem tworzenia formularza warto zdefiniować język, w jakim będziemy pisać aplikację. W ten sposób zapewnimy sobie wyświetlanie wszystkich komunikatów w pożądanym języku. W tym celu należy otworzyć do edycji plik konfiguracyjny main.php w katalogu protected/config, wyszukać główną tablicę zawierającą konfigurację aplikacji i wpisać tam klucz o nazwie language z przypisaną wartością pl (listing 4.1). Od tej pory interfejs aplikacji będzie wyświetlany w języku polskim. Nie musisz wyszukiwać, pobierać i instalować potrzebnej wersji językowej — wystarczy ją wskazać w pliku konfiguracyjnym aplikacji.

48

Yii Framework

Listing 4.1. Ustawienie języka polskiego w pliku main.php […] return array( 'basePath'=>dirname(__FILE__).DIRECTORY_SEPARATOR.'..', 'name'=>'My Web Application', 'language'=>'pl', // preloading 'log' component 'preload'=>array('log'), […]

Model Tworzenie nowego formularza rozpoczynamy od napisania modelu — będzie nam on bezwzględnie potrzebny. A zatem tworzymy plik o nazwie OsobyFormularz.php w katalogu protected/models. Aby uprościć proces zapisywania informacji do bazy danych, zadeklarujemy klasę OsobyFormularz jako rozszerzenie klasy CActiveRecord. Następnie zadeklarujemy jako publiczne zmienne nazwy pól tabeli osoby. W tym przypadku trzeba tak potraktować wszystkie pola tabeli. Teraz zadeklarujemy metodę model, która będzie dziedziczyła wszystkie właściwości klasy nadrzędnej. Bardzo ważna jest tu metoda tableName(),

która przekazuje nazwę tabeli w bazie danych. Możemy też zapewnić, aby nazwy pól w formularzu były wyświetlane w języku polskim. W tym celu zdefiniujemy metodę attributeLabels(). Metoda ta przekaże tablicę, w której kluczami są wcześniej określone nazwy pól tabeli, a wartościami — ich nazwy zapisane w języku polskim. Na końcu wreszcie zdefiniujemy kolejną metodę, rules(), która określi sposób walidacji danych wprowadzanych przez użytkownika. Cały plik modelu pokazałem na listingu 4.2. W pliku OsobyFormularz.php uwzględniłem bardzo skromną weryfikację danych użytkownika. W rzeczywistości Yii ma dużo szersze możliwości w tym zakresie. Jeśli interesują Cię dokładniejsze informacje o tej funkcjonalności frameworku, możesz o nich przeczytać w dalszej części tego rozdziału. Listing 4.2. Model z obsługą formularza

Widok Teraz możemy przystąpić do zbudowania pliku widoku. W tym celu w lokalizacji protected/views tworzymy katalog o nazwie formularz, a w nim zapisujemy plik formularz.php. Tworzenie każdego formularza rozpoczynamy od wczytania wtyczki CActiveForm, którą ładujemy za pomocą metody beginWidget(). Metoda przyjmuje dwa parametry: pierwszym jest nazwa włączanego dodatku, w drugim parametrze zaś ustawiamy dodatkowe opcje wtyczki. Następnie ustawiamy identyfikator id formularza na osoby-formularz i określamy, iż obsługa wysyłania i walidacji formularza nie będzie się odbywała poprzez Ajax. Następnie za pomocą instrukcji warunkowej sprawdzamy wartość przesłanej do widoku zmiennej $Zapisano. W zależności od otrzymanej wartości zostanie lub nie zostanie wyświetlony odpowiedni komunikat. Teraz można zaprogramować wyświetlanie informacji o błędach walidacji formularza. Służy do tego metoda errorSummary(), która jako parametr przyjmuje model formularza. Komunikaty o błędach są wyświetlane w uporządkowany sposób w blokach pól formularza. Każdy taki blok definiuje się za pomocą trzech metod. Najpierw wywołujemy metodę labelEx() i przekazujemy do niej, jako parametry, model i nazwę pola tabeli odpowiadającego zawartości sprawdzanego elementu formularza. Te same parametry należy przekazać do drugiej i trzeciej metody. Druga metoda ma wyświetlić pole wejściowe dla określonego atrybutu modelu. W naszym przypadku będzie to textField(), dzięki czemu będziemy wprowadzali wartość w jednej linii. Trzecią metodą jest error(). Jej zadaniem jest wyświetlenie komunikatu o błędzie walidacji dla danego elementu formularza. Zostało nam jeszcze wyświetlenie przycisku typu submit. Do tego celu posłużymy się metodą submitButton(), która w pierwszym parametrze przyjmuje tekst wyświetlany na przycisku. Na samym końcu zamykamy wtyczkę za pomocą metody endWidget().

50

Yii Framework

Cały plik widoku z formularzem przedstawiłem na listingu 4.3. Listing 4.3. Plik widoku z formularzem

Pola oznaczone * są wymagane.

Kontroler Skoro mamy już model i widok, do skonstruowania pozostało nam serce całej aplikacji, czyli kontroler. Tworzymy więc plik FormularzController.php i zapisujemy go w katalogu protected/controllers. Zapewne pamiętasz, że metoda actionIndex() jest metodą domyślnie wywoływaną po uruchomieniu kontrolera. Tym razem actionIndex() rozpoczyna się od inicjalizacji modelu OsobyFormularz. Następnie zapisujemy instrukcję warunkową sprawdzającą, czy za pomocą metody POST została wysłana zmienna OsobyFormularz. W tym miejscu

Rozdział 4.  Tworzenie formularzy

51

powinienem wyjaśnić, że wszystkie formularze tworzone na podstawie modelu zawierają ukryte pole o nazwie takiej samej jak nazwa modelu. Pole to pozwala na rozpoznawanie modelu właściwego dla danego formularza. Dane z formularza trafiają do odpowiedniego modelu poprzez pole attributes, w którym są zapisywane zmienne przesłane w tablicy POST. Kolejną fazą jest przeprowadzenie walidacji danych. W tym celu wywołujemy metodę validate(). Metoda ta przekazuje wartość TRUE w przypadku pomyślnego wyniku sprawdzenia danych bądź FALSE w przypadku wystąpienia choćby jednego błędu. Wartość przekazana przez metodę validate() decyduje o wykonaniu instrukcji warunkowej if: jeśli jest nią TRUE, dane przekazane przez użytkownika są zapisywane w bazie, a wartość zmiennej $Zapisano zostaje ustawiona na TRUE. Umożliwia to wyświetlenie na stronie formularza informacji o poprawnym dodaniu danych do bazy. Ostatnim elementem kontrolera jest wywołanie metody render(), za pomocą której wczytujemy nazwę pliku. Metoda render() przyjmuje dwa parametry: model i informację o wykonaniu akcji. Podobnie jak poprzednio, na listingu 4.4 znalazł się plik kontrolera. Listing 4.4. Kontroler wraz z akcją przetwarzającą dane z formularza

52

Yii Framework

Aby sprawdzić, jak działa nasz formularz, w przeglądarce internetowej wpisz adres http://localhost/yii/test/formularz. Powinieneś zobaczyć wyświetlony formularz. Jeżeli klikniesz przycisk Dodaj bez uprzedniego wypełnienia pól formularza, wyświetli się komunikat o konieczności uzupełnienia informacji — tak jak na rysunku 4.1. Jeśli natomiast wypełnisz obydwa pola, otrzymasz informację o poprawnym zapisaniu danych (rysunek 4.2).

Rysunek 4.1. Wysłanie formularza bez wypełnienia pól Rysunek 4.2. Formularz z komunikatem o zapisaniu danych w bazie

Jeśli tworzenie formularzy w Yii wydaje Ci się skomplikowane, zapewne ucieszy Cię możliwość skorzystania z małego, ale jakże sprawnego dodatku zwanego Gii, który automatycznie generuje wszystkie właściwości pól wraz z metodą kontrolera.

Elementy formularza Zapewne wiesz, że formularz oglądany przez użytkownika w oknie przeglądarki może się składać z szeregu pól. Framework Yii udostępnia metody, dzięki którym można w łatwy sposób wykorzystywać różne pola i tworzyć formularze dostosowane do potrzeb aplikacji.

Pole tekstowe — text Pole tekstowe jednoliniowe deklaruje się za pomocą metody textField(), która przyjmuje trzy parametry. Pierwszym parametrem jest nazwa modelu, w którym dane pole zostało zadeklarowane. Następnym parametrem jest nazwa pola; musi ona być

Rozdział 4.  Tworzenie formularzy

53

dokładnie taka, jak nazwa pola zdefiniowana w modelu. Ostatnim, trzecim parametrem jest tablica ze zdefiniowanymi opcjami, które zostaną dodane jako atrybuty i wartości w języku HTML; w tej tablicy opcje należy zdefiniować jako pary klucz – wartość. Plik widoku zawierający jednoliniowe pole tekstowe nazywamy formularz1.php i zapisujemy w katalogu protected/views/formularztypy (listing 4.5). Listing 4.5. Formularz z polem tekstowym wraz z określeniem jego parametrów







Będzie nam także potrzebny plik kontrolera, który będzie się nazywał FormularzTypyController.php (listing 4.6). Umieścimy go w katalogu protected/controllers. Aby przetestować skrypt, w pasku adresu przeglądarki wpisz: http://localhost/yii/test/formularztypy/ tekst. Listing 4.6. Kontroler pola tekstowego

Pole z ukrytą treścią — password Kontrolka tego typu stanowi zmodyfikowaną wersję pola tekstowego i bardzo podobnie się zachowuje. Różnica polega na tym, że znaki wpisywane do tego pola są wyświetlane jako gwiazdki, co utrudnia odczytanie wpisanego tekstu przez ewentualne osoby postronne. Pole typu password często służy do wpisywania haseł na stronach WWW. Pole z ukrytą treścią deklaruje się za pomocą metody passwordField(). Jako parametry metoda ta przyjmuje kolejno nazwę modelu, następnie nazwę pola, która musi być taka sama jak nazwa zdefiniowana w modelu, a na koniec tablicę zawierającą zdefiniowane atrybuty HTML. W tej tablicy nazwy atrybutów i ich wartości należy zapisać jako pary klucz – wartość. Teraz utwórzmy w katalogu protected/views/formularztypy plik formularz2.php (listing 4.7). Listing 4.7. Widok zawierający zdefiniowane pole tekstowe typu password







Potrzebny jeszcze będzie plik kontrolera, w którym należy dodać metodę actionHaslo(). Metoda ta załaduje widok, który utworzyliśmy przed chwilą. Kod kontrolera znajduje się na listingu 4.8. Aby obejrzeć gotową stronę, w przeglądarce wpisujemy adres http://localhost/yii/test/formularztypy/haslo.

Rozdział 4.  Tworzenie formularzy

55

Listing 4.8. Kontroler pola typu password

Wielowierszowe pole tekstowe — textarea Wielowierszowe pole tekstowe jest przeznaczone do wprowadzania nieco większej ilości tekstu, który mieści się w kilku liniach. Taką kontrolkę deklaruje się za pomocą metody textArea(). Metoda ta przyjmuje trzy parametry, którymi są kolejno: nazwa modelu, nazwa pola zgodna z nazwą zapisaną w modelu oraz atrybuty HTML zdefiniowane w postaci tablicy, w której nazwy atrybutów i ich wartości są zapisane jako pary klucz – wartość. W przypadku wielowierszowego pola tekstowego ważne jest zdefiniowanie treści, która domyślnie zostanie w tym polu wyświetlona. W tym celu należy ustawić parametr o nazwie value. Nie jest to parametr metody, a jego zawartość znajduje się pomiędzy następującymi znacznikami HTML wielowierszowego pola tekstowego: i . Przykładowym widokiem dla wielowierszowego pola tekstowego jest plik formularz3.php w katalogu protected/views/formularztypy (listing 4.9). Listing 4.9. Widok dla pola typu textarea







W pliku kontrolera należy jeszcze wywołać metodę actionTekstwieloliniowy(), która obsłuży utworzony przed chwilą widok (listing 4.10). Efekt możemy sprawdzić pod adresem http://localhost/yii/test/formularztypy/tekstwieloliniowy. Listing 4.10. Kontroler pola typu textarea

Pole listy rozwijanej — select Pole listy rozwijanej typu select pozwala użytkownikowi na dokonanie wyboru spośród wcześniej określonych opcji. W zależności od potrzeb można użytkownikowi udostępnić tylko jedną wartość (tzn. listę zawierającą tylko jeden element) bądź kilka opcji do wyboru. Listę rozwijaną deklarujemy za pomocą metody dropDownList(). Przyjmuje ona cztery parametry. Pierwszym jest nazwa modelu, drugim nazwa pola dokładnie taka sama jak nazwa pola w modelu, jako trzeci parametr przekazuje się tablicę atrybutów, w której nazwy atrybutów i ich wartości są zapisane jako pary klucz – wartość, a jako ostatni, czwarty argument podaje się opcje HTML, także w formie tablicy. Przykładowym plikiem widoku dla omawianego elementu formularza będzie plik formularz4.php, który należy zapisać w katalogu protected/views/formularztypy (listing 4.11).

Rozdział 4.  Tworzenie formularzy

57

Listing 4.11. Widok dla pola typu select







Zapewne zauważyłeś, że w czwartym argumencie metody dropDownList() podałem klucz options. W ten sposób definiuje się wartość wybieraną domyślnie. Wartość ta jest wyświetlana na liście rozwijanej jako z góry zaznaczona. W kluczu options deklaruje się kolejną tablicę, której nazwą jest nazwa klucza. W tym przypadku jest to Mariusz. Przypisujemy do niego kolejną tablicę z opcją selected ustawioną na wartość selected. W pliku kontrolera musimy wywołać metodę actionListarozwijana(), która zapewni wczytanie widoku (listing 4.12). Aby obejrzeć gotowy formularz, wpisz w przeglądarce internetowej adres http://localhost/yii/test/formularztypy/listarozwijana. Listing 4.12. Kontroler pola typu select

Pole opcji (przełącznik) — radio Pole opcji, zwane również przełącznikiem czy przyciskiem typu radio, ma wygląd okrągłego pola, które można zaznaczać kliknięciem myszy. Jeśli zgrupujesz więcej takich przełączników poprzez nadanie im takiej samej nazwy, to w danym momencie zaznaczone może być tylko jedno pole — użytkownik może wybrać tylko jedną z kilku opcji. Aby zdefiniować pole opcji, wywołujemy metodę radioButton(). Przyjmuje ona trzy parametry. Podobnie jak w poprzednich przypadkach, pierwszym argumentem metody jest nazwa modelu, drugim nazwa pola zgodna z nazwą podaną w modelu, a ostatni parametr stanowią opcje HTML zapisane w formie tablicy, w której nazwy atrybutów i ich wartości są podane jako pary klucz – wartość. Przykład zadeklarowanego pola opcji znajduje się w pliku formularz5.php w katalogu protected/views/formularztypy (listing 4.13). Listing 4.13. Widok dla pól typu radio

Łukasz

Mariusz

Jan





W kontrolerze należy zadeklarować dodatkową metodę, actionPojedynczywybor(), która zapewni wczytanie pliku widoku (listing 4.14). Gotową stronę wywołujemy, podając adres http://localhost/yii/test/formularztypy/ pojedynczywybor. Listing 4.14. Kontroler pola typu radio

Pole wyboru — checkbox Pole wyboru jest wyświetlane w postaci kwadratu, który można zaznaczać i odznaczać, klikając myszą. Deklaruje się je za pomocą metody checkBox(). Przyjmuje ona trzy parametry: pierwszym jest nazwa modelu, drugim nazwa pola, a ostatni, trzeci parametr umożliwia określenie dodatkowych atrybutów HTML i definiujemy go w postaci tablicy klucz – wartość, gdzie kluczem jest nazwa atrybutu, a wartością — wartość atrybutu. Przykładowy widok ze zdefiniowanym polem typu checkbox znajduje się w pliku formularz6.php w katalogu protected/views/formularztypy (listing 4.15).

60

Yii Framework

Listing 4.15. Widok dla pola typu checkbox

Łukasz

Mariusz

Jan





W pliku kontrolera należy uwzględnić metodę actionWielokrotnywybor(), która umożliwi wygenerowanie formularza (listing 4.16). Gotową stronę otwieramy poprzez wpisanie adresu http://localhost/yii/test/formularztypy/ wielokrotnywybor. Listing 4.16. Kontroler pola typu checkbox

Selektor plików — file Selektor plików (file) umożliwia użytkownikowi dołączenie do wysyłanego formularza pliku z własnego komputera. Pole to definiujemy za pomocą metody fileField(), która przyjmuje trzy parametry. Pierwszy to nazwa modelu, drugim jest nazwa pola taka sama jak zapisana w modelu, a trzecim, ostatnim są atrybuty HTML. Podobnie jak w poprzednich przypadkach, definiujemy je w postaci tablicy, w której nazwy atrybutów i ich wartości są zapisane jako pary klucz – wartość. W przypadku selektora plików deklarowanie dodatkowych atrybutów jest zasadniczo niepożądane, co wynika z różnych sposobów działania w poszczególnych przeglądarkach internetowych. Oczywiście walidacja przesłanego pliku jest niezbędna, najlepiej jednak zrealizować tę funkcjonalność na serwerze. Przykładowy widok zawierający selektor plików znajduje się w pliku formularz7.php, który zapisałem w katalogu protected/views/formularztypy (listing 4.17). Listing 4.17. Widok dla pola typu file







62

Yii Framework

Przy tworzeniu widoku należy pamiętać o jeszcze jednej sprawie. Jeśli spróbujesz wysłać plik za pomocą formularza w takiej formie, jak na listingu 4.17, okaże się, że nie będzie można w ogóle odebrać pliku z przeglądarki. Aby zapewnić tę funkcjonalność, musisz jeszcze zadeklarować we wtyczce z definicją formularza, dokładniej w tablicy htmlOptions określającej właściwości całego formularza, ważny atrybut: enctype. Atrybut ten określa, w jaki sposób zostaną przekazane dane wysyłanego formularza. Domyślnie dane te są wysyłane jako dane tekstowe, co uniemożliwia poprawne odebranie pliku dołączanego do formularza. Rozwiązaniem problemu jest ustawienie atrybutu enctype na wartość multipart (listing 4.18). Listing 4.18. Opcja pozwalająca na wysyłanie plików

W kontrolerze widoku należy jeszcze zadeklarować metodę, która pozwoli na załadowanie pliku widoku (listing 4.19). Listing 4.19. Kontroler pola typu file

Okazuje się, że wysyłanie plików za pomocą formularza jest nieco bardziej skomplikowane. Warto więc sprawdzić, czy całość działa poprawnie, w przeglądarce internetowej wpisując adres http://localhost/yii/test/formularztypy/plik.

Rozdział 4.  Tworzenie formularzy

63

Pole ukryte — hidden Pole ukryte typu hidden umożliwia definiowanie wartości, które można później wykorzystać do różnych celów, ale które nie będą wyświetlane w przeglądarce. Niemniej należy mieć świadomość, że pole takie nie jest w żaden sposób ukryte przed użytkownikiem: zaglądając do źródła strony, można zobaczyć wszystkie pola formularza, również te ukryte. Pole ukryte definiuje się za pomocą metody hiddenField(). Przyjmuje ona trzy parametry. Pierwszy to nazwa modelu, drugim jest nazwa pola zgodna z nazwą zawartą w modelu, a w trzecim, ostatnim parametrze przekazujemy opcje HTML. Podobnie jak w poprzednich przypadkach, należy je zadeklarować w postaci par klucz – wartość. Utworzymy więc plik formularz8.php w katalogu protected/views/formularztypy (listing 4.20). Listing 4.20. Widok dla pola typu hidden







Następnie musimy w kontrolerze wywołać metodę, która będzie wczytywała widok z polem ukrytym (listing 4.21). Listing 4.21. Kontroler pola ukrytego

Aby przejrzeć gotową stronę, w pasku adresu przeglądarki wpisz: http://localhost/yii/ test/formularztypy/ukryte. Zgodnie z tym, o czym wspomniałem przed chwilą, aby zobaczyć pole ukryte formularza, należy zajrzeć do kodu źródłowego naszej strony. Dla przypomnienia: w przypadku najbardziej popularnych przeglądarek należy użyć następujących poleceń:  Google Chrome: Menu (ikona w prawym górnym rogu, z prawej strony paska

adresu), następnie Narzędzia i Wyświetl źródło.  Mozilla Firefox: Firefox (lub menu Narzędzia), następnie Dla twórców witryn

i Źródło strony.  MS Internet Explorer: Narzędzia, następnie Narzędzia deweloperskie.

W przypadku wszystkich tych przeglądarek można po prostu kliknąć na oglądanej stronie prawym przyciskiem myszy i wybrać z menu kontekstowego odpowiednią opcję.

Przycisk — button Przycisk ogólnego zastosowania (button) jako taki nie ma przypisanych żadnych akcji. Aby jego naciśnięcie spowodowało jakąś reakcję, trzeba ją po prostu zaprogramować. Aby zdefiniować pole przycisku, użyjemy metody htmlButton(), jednak tym razem musimy skorzystać z klasy pomocniczej o nazwie CHtml. Omawiana kontrolka formularza znalazła się w tej bibliotece, ponieważ do przycisku użytkownik nie może wprowadzić żadnych danych. Metoda htmlButton() przyjmuje dwa parametry: pierwszy to nazwa przycisku, a drugim jest tablica zawierająca opcje HTML zapisane w postaci par klucz – wartość, gdzie kluczem jest nazwa atrybutu, a wartość — wartością atrybutu. Plik widoku formularz9.php należy zapisać w katalogu protected/views/formularztypy (listing 4.22). Listing 4.22. Plik widoku z elementem button







Należy jeszcze w kontrolerze zdefiniować metodę umożliwiającą wyświetlenie pliku widoku (listing 4.23). Skrypt wywołujemy poprzez wpisanie w przeglądarce adresu http://localhost/yii/test/formularztypy/przycisk. Listing 4.23. Kontroler obsługujący element button

Przycisk wysłania formularza — submit Najważniejszym chyba polem w formularzu jest przycisk, który umożliwia wysłanie formularza od klienta do serwera, czyli przycisk typu submit. Tworzymy go za pomocą metody submitButton() z klasy pomocniczej CHtml. Podobnie jak w przypadku innych przycisków, definicja przycisku wysłania formularza nie znajduje się we wtyczce

66

Yii Framework CActiveForm. Jest tak, ponieważ do przycisku użytkownik nie może wprowadzić wartości. Metoda submitButton() przyjmuje dwa parametry: pierwszym jest nazwa przycisku, natomiast drugi pozwala na wprowadzenie dodatkowych atrybutów HTML. Podobnie jak w poprzednich przypadkach, wszystkie atrybuty definiujemy w postaci tablicy, w której klucz jest nazwą atrybutu, a wartość klucza — wartością atrybutu.

Plik widoku zawierający pole wysłania formularza formularz10.php zapiszmy w katalogu protected/views/formularztypy (listing 4.24). Listing 4.24. Plik widoku z przyciskiem typu submit





Musimy jeszcze w kontrolerze utworzyć metodę actionWyslij(), za pomocą której wczytamy zapisany wcześniej plik widoku (listing 4.25). Stronę zobaczymy po wprowadzeniu do paska adresu przeglądarki: http://localhost/yii/test/formularztypy/wyslij. Listing 4.25. Kontroler z przyciskiem typu submit

Rozdział 4.  Tworzenie formularzy

67

Przycisk przywracania danych domyślnych formularza — reset Przycisk przywracania danych domyślnych formularza, zwany też przyciskiem czyszczenia czy resetowania formularza, umożliwia przywrócenie poszczególnym polom wartości, jakie miały, zanim użytkownik rozpoczął wpisywanie danych. Przycisk typu reset tworzymy za pomocą metody resetButton() z klasy pomocniczej CHtml. Metoda ta przyjmuje dwa parametry: pierwszym jest nazwa przycisku, a w drugim można przekazać opcje HTML zdefiniowane w tablicy, w której klucz stanowi nazwę atrybutu, a wartość — wartość atrybutu. Plik zawierający definicję przycisku przywracania danych formularz11.php tworzymy w katalogu protected/views/formularztypy (listing 4.26). Listing 4.26. Plik widoku z przyciskiem typu reset







Należy jeszcze pamiętać o dodaniu do kontrolera metody actionWyczysc(), której zadaniem będzie ładowanie modelu i wczytywanie widoku (listing 4.27). Teraz możemy sprawdzić, jak wygląda nasza nowa strona. W tym celu w przeglądarce wpisujemy adres http://localhost/yii/test/formularztypy/wyczysc. Listing 4.27. Kontroler przycisku typu reset

Walidacja danych Proste tworzenie złożonych formularzy nie jest jedynym ułatwieniem, jakie daje nam korzystanie z frameworku. Kolejnym jest umożliwienie walidacji danych bez większego wysiłku ze strony programisty — nie trzeba już pisać samodzielnie specjalnych funkcji, które sprawdzałyby, czy zawartość każdego pola jest zgodna z zamierzeniem twórcy aplikacji. Przede wszystkim należy utworzyć specjalny model, który zapewni sprawdzanie danych wprowadzanych przez użytkownika do formularza. W katalogu protected/models tworzymy plik o nazwie WalidacjaFormularz.php (listing 4.28). Zwróć uwagę na zadeklarowaną w modelu metodę rules(): sprawdzanie danych przebiega za pomocą reguł zdefiniowanych w postaci tablicy. Konkretne przykłady definicji takich reguł znajdziesz w dalszej części tego podrozdziału. Listing 4.28. Model przeznaczony do walidacji danych

Teraz możemy utworzyć kontroler, który zapewni współdziałanie poszczególnych elementów aplikacji. W katalogu protected/controllers zapisujemy plik o nazwie WalidacjaController.php (listing 4.29). Listing 4.29. Kontroler do sprawdzania poprawności danych wprowadzonych przez użytkownika

70

Yii Framework

Musimy jeszcze dla sprawdzanego formularza napisać widok, którego zadaniem będzie przesyłanie danych. W katalogu protected/views utwórz nowy folder o nazwie zgodnej z nazwą kontrolera: walidacja. W tym katalogu powinien się znaleźć plik walidacja1.php (listing 4.30). Listing 4.30. Widok formularza z walidatorami









Powinieneś zauważyć, że w widoku znalazły się dwie nowe metody. Pierwszą jest errorSummary(). Do metody errorSummary() będziemy ładować model, który służy do sprawdzania pól w formularzu. Drugą nową metodą jest error(). Zapewnia ona wyświetlanie komunikatu o błędzie dla jednego tylko pola. Jako parametry metoda error()przyjmuje model walidacji danych oraz — w drugim parametrze — nazwę pola, którego ma dotyczyć wyświetlona informacja o wyniku sprawdzenia.

Puste pola Często stosowanym rodzajem walidacji jest sprawdzanie, czy dane pole nie pozostało puste. W tym celu w modelu, właśnie w metodzie rules(), określamy regułę sprawdzania zawierającą słowo required. Definiujemy więc nową tablicę, w której w pierwszym parametrze podajemy nazwę sprawdzanego pola, a w następnym — słowo required. W poniższym przykładzie pole imie określiłem jako pole wymagane (listing 4.31).

Rozdział 4.  Tworzenie formularzy

71

Listing 4.31. Model sprawdzający, czy pole wymagane zostało wypełnione

Możesz sprawdzić, jak to działa: wyświetl w przeglądarce formularz znajdujący się pod adresem http://localhost/yii/test/walidacja i wyślij go bez wpisywania czegokolwiek w pole tekstowe. W efekcie otrzymasz komunikat o błędzie (rysunek 4.3).

Rysunek 4.3. Rezultat wysłania formularza z pustym polem

Porównywanie Yii umożliwia także sprawdzanie, czy wartość przesłana w formularzu mieści się w ustalonych wcześniej granicach. Innymi słowy: możemy porównać wartość wpisaną przez użytkownika zgodnie z określonymi założeniami. W tym celu w metodzie rules() dopiszemy kolejny element głównej tablicy, którym będzie tablica zawierająca kolejno: nazwę pola, słowo określające rodzaj walidacji compare, a następnie klucz compareValue. Klucz compareValue służy do zdefiniowania wartości rozpoznawanej przez metodę rules() jako poprawną. W modelu z listingu 4.32 jedyną prawidłową wartością pola imie będzie Łukasz. Listing 4.32. Sprawdzanie, czy użytkownik wprowadził prawidłową wartość w formularzu

Domyślnym zachowaniem metody jest sprawdzanie, czy wprowadzony przez użytkownika ciąg znaków jest dokładnie taki, jak ten zapisany w kluczu compareValue. Jeśli jednak zastosujemy odpowiedni operator, można zmodyfikować ten sposób działania. W tabeli 4.1 przedstawiłem różne operatory umożliwiające porównywanie danych wprowadzonych przez użytkownika z wartościami zapisanymi w kluczu compareValue. Tabela 4.1. Operatory porównania Operator

Znaczenie

= lub ==

Sprawdzenie, czy obie wartości są sobie równe

!=

Sprawdzenie, czy obie wartości są różne

>

Sprawdzenie, czy wartość jest większa

>=

Sprawdzenie, czy wartość jest większa lub równa


'pokaz') (listing 4.49). Listing 4.49. Model ze scenariuszem

Należy jeszcze napisać odpowiedni widok. Nazwiemy go walidacja.php i zapiszemy w folderze protected/views/walidacjapol (listing 4.50). Listing 4.50. Widok formularza sprawdzanego z wykorzystaniem scenariuszy









Teraz możemy sprawdzić, jak działa nasz nowy skrypt. Najpierw wpisz w przeglądarce adres http://localhost/yii/test/walidacjapol/, pozostaw puste pole Imię i kliknij przycisk Dodaj. Mimo że w polu nie wpisałeś ani jednego znaku, zobaczysz komunikat, że dane zostały zapisane (rysunek 4.4). Teraz w pasku adresu przeglądarki wpisz: http://localhost/yii/test/walidacjapol/pokaz. W ten sposób w formularzu został uruchomiony scenariusz pokaz. Spróbuj ponownie pozostawić puste pole i kliknąć przycisk Dodaj. Otrzymasz komunikat o błędzie, mówiący, że pole Imię powinno zostać wypełnione (rysunek 4.5). Rysunek 4.4. Wysłanie pustego formularza — scenariusz nie ma zastosowania

Rysunek 4.5. Wysłanie pustego formularza — tym razem zgodnie ze scenariuszem walidacji danych

86

Yii Framework

Rozdział 5.

Zaawansowana konfiguracja Zmiana adresu URL Aby framework Yii mógł działać prawidłowo, musi być odpowiednio skonfigurowany. Przede wszystkim należy ustawić ścieżkę do głównej strony aplikacji. W tym celu trzeba otworzyć plik main.php z katalogu protected/config i odnaleźć klucz basePath. Wartością właśnie tej właściwości jest ścieżka do głównego katalogu aplikacji, a ściślej rzecz ujmując, do głównej strony WWW. Najczęściej jest to adres katalogu według ścieżki lokalnej na serwerze (listing 5.1). Listing 5.1. Główna ścieżka systemu