Spisie treści
Zanim zbudujemy koszyk, aby użytkownik mógł wybierać produkty, musimy nauczyć się korzystać z sesje w Ruby on Rails; Kiedy użytkownik przegląda nasz wirtualny sklep, prawdopodobnie wybierze produkty, co zwykle stosuje się do tego typu aplikacji, że wrzucamy go do wirtualnego koszyka, gdzie będziemy przechowywać produkt, cenę, całkowity koszt zakup i ilość produktów, aż do ostatecznej kasy, kiedy użytkownik zdecyduje się dokonać zakupu.
Aby spełnić to, co proponujemy, musimy utrzymywać produkty wybrane przez użytkownika w naszej aplikacji, w tym celu użyjemy sesje, z tą implementacją, która nie szyny Możemy zachować dane dostępne bez konieczności przechowywania ich w bazach danych i będą dostępne dla użytkownika, który je uruchomił z przeglądarki, która nawiązuje połączenie z aplikacją, z którą kombinacje kluczwartość Będą przechowywane, a my będziemy je mieć do dyspozycji.
Zobaczmy przykład jak wygląda ten kod, stwórzmy nową metodę w naszej aplikacji w kontrolerze sklepu:
private def find_cart session [: koszyk] || = Koszyk.nowy koniec
Pomimo tego, że są to około 4 wiersze kodu, są one dość skomplikowane, najpierw tworzymy metodę prywatną, w ten sposób uniemożliwiamy railsowi udostępnienie jej jako akcji w kontrolerze, a następnie widzimy, że używamy operatora przypisania warunkowego | |=.
Ten operator w metodzie, która pozwala nam wykonać następującą funkcjonalność, jeśli istnieje hash sesji, który odpowiada klucz: koszyk następnie zwracamy jego zawartość, w przeciwnym razie budujemy nowy obiekt Cart i przypisujemy go do sesji, wtedy zwracamy jego wartość.
Teraz, gdy już trochę opanowaliśmy teoretyczną część tego podejścia, zamierzamy nieco bardziej zagłębić się w funkcjonalność, którą musimy zbudować, po utworzeniu koszyka wiemy, że każda dokonana sprzedaż musi utrzymać cenę przy którym został stworzony do czego mamy zamiar stworzyć stół o nazwie line_items, To, co to zrobi, to zapisanie linii wyboru kupującego, zobaczmy kod, który musimy umieścić w naszej bazie danych:
upuść tabelę, jeśli istnieje line_items; utwórz tabelę line_items (id int product_id int ilość int unit_price dziesiętna (10,2) ograniczenie fk_items_product klucz podstawowy (id)); not null auto_increment, not null, not null default 0, not null, klucz obcy (product_id) odwołuje się do produktów (id), klucza podstawowego (id));
Jak widzimy w tej definicji naszej nowej tabeli, dodaliśmy odniesienie do a klucz obcy która kojarzy pole product_id z polem id tabeli product, ta relacja posłuży nam podczas generowania modelu.
Ponieważ mamy tabelę, z którą możemy wchodzić w interakcje, w tym celu musimy wygenerować nowy model, abyśmy mogli go używać w naszej aplikacji. Użyjemy następującego polecenia z naszej konsoli poleceń Ruby on Rails.
depot > skrypt ruby / generuj model LineItem Po wygenerowaniu naszego modelu dodamy do niego: [i] app / modele / line_item.rb [/ i], ponieważ nie wszystkie bazy obsługują relacje rails, obsługa z nich jest wyraźnie. class LineItem <ActiveRecord :: Base należy_do: koniec produktu
Po stworzeniu naszego modelu i tabel dla naszej aplikacji, pozostała nam tylko część 2, aby zakończyć jego rozwój i mieć funkcjonalny koszyk, który służy jako trampolina do przechodzenia do znacznie bardziej zaawansowanych aplikacji.
Kontynuujemy budowę koszyka na zakupy do naszej aplikacji, w Ruby on RailsAby to zrobić, przyjrzyjmy się dalej modelowi, który zbudowaliśmy i zapoznajmy się z wyjaśnieniem problemu. Szyny obsługuje konwencję, która pozwala wywnioskować, jak traktować relacje między tabelami po ich jawnym zadeklarowaniu, mówiąc, że nasz model LineItem ma następujący wiersz kodu: należy_do: produkt, silnik rails już wie, że w tabeli musi znajdować się pole o nazwie product_id.
Teraz wygenerujemy kod niezbędny do zbudowania naszego koszyka, najpierw musimy zaimplementować w sterowniku naszego sklepu metodę dodawania towarów do koszyka. Najpierw zlokalizujemy ten kontroler: aplikacja / kontrolery / store_controller.rb a w środku stworzymy metodę Dodaj do koszyka z następującym kodem w nim.
def add_to_cart product = Product.find (params [: id]) @cart = find_cart @ cart.add_product (product) redirect_to (: action => 'display_cart') end
Teraz musimy wygenerować naszą klasę Cart, ta konkretna klasa nie jest powiązana z modelem Aktywny rekord Ponieważ nie wchodzi w interakcję z bazą danych, aby ułatwić nam pracę, wygenerujemy ją ręcznie w naszym katalogu aplikacja / modele, tam utworzymy plik koszyk.rb.
W naszym nowym pliku umieścimy:
class Koszyk attr_reader: items attr_reader: total_price def zainicjuj @items = [] @total_price = 0.0 end def add_product (product) @items << LineItem.for_product (product) @total_price + = product.price end end
Teraz, po zakończeniu, przejdźmy do naszego modelu LineItem i umieść to, czego nam brakuje:
class LineItem <ActiveRecord :: Base among_to: product def self.for_product (product) item = self.new item.quantity = 1 item.product = product item.unit_price = product.price item end end
Zróbmy krótkie podsumowanie tego, co mamy do tej pory. Mamy już metodę, która pozwala nam dodać towar do koszyka, to jest Dodaj do koszyka, wtedy mamy treść naszej klasy Wózek co pozwala nam dodać produkt i pozostać w naszej klasie Pozycja możemy wydobyć wartości tych produktów, które dodamy. Musimy tylko zaimplementować kilka dodatkowych elementów, aby nasza aplikacja działała, najpierw musimy dodać akcję, która pozwoli nam pokazać widok, a jeśli to się nie uda, wygenerować go, do tego dodamy:
def display_cart @cart = znajdź_cart @items = @ cart.items end
Ta metoda trafi do naszego kontrolera, teraz naszym zdaniem: aplikacja / widoki / sklep, utworzymy plik display_cart.rhtml a w środku umieścimy następujący kod:
Twój koszyk zawiera rzeczy.
Oczywiście to nadal nie działa, ale musimy dodać ostatni krok i jest to zdefiniowanie naszych nowych modeli w kontekście aplikacji, do której przejdziemy aplikacja / kontrolery i zobaczymy plik o nazwie aplikacja.rb w którym musimy umieścić:
class ApplicationController <ActionController :: Model podstawowy: model koszyka: line_item end
Dzięki temu mielibyśmy już nasze Wózek sklepowy podstawowe, ale to przybliży nas do wdrożenia finalnego produktu o w pełni rozszerzonej funkcjonalności. Na tym kończymy ten samouczek z Ruby on Rails i należy wspomnieć, że musimy dokładnie przeanalizować kod, który umieściliśmy, aby zrozumieć przyczynę jego działania i w ten sposób wygenerować wiedzę wysokiej jakości.Podobał Ci się i pomógł ten samouczek?Możesz nagrodzić autora, naciskając ten przycisk, aby dać mu pozytywny punkt
