Inhaltsverzeichnis
Bevor wir einen Einkaufswagen erstellen können, damit ein Benutzer Produkte auswählen kann, müssen wir lernen, die Sitzungen innerhalb Rubin auf Schienen; Wenn ein Benutzer unseren virtuellen Shop durchsucht, wählt er möglicherweise Produkte aus. Normalerweise wird für diese Art von Anwendung verwendet, dass wir ihn in einen virtuellen Warenkorb hochladen, in dem wir das Produkt, den Preis und die Gesamtkosten der Kauf und die Menge der Produkte, dies bis zu einer eventuellen Kasse, zu der der Benutzer sich für den Kauf entscheidet.
Um dem von uns vorgeschlagenen gerecht zu werden, müssen wir die Produkte, die der Benutzer in unserer Anwendung auswählt, beibehalten. Dazu verwenden wir die Sitzungen, mit dieser Implementierung, die das tut Schienen Wir können die Daten verfügbar halten, ohne sie in Datenbanken speichern zu müssen, und sie sind für den Benutzer, der sie gestartet hat, über den Browser zugänglich, der die Verbindung zur Anwendung herstellt, mit der die Kombinationen Schlüsselein Wert Sie werden gespeichert und von uns zur Verfügung gestellt.
Sehen wir uns ein Beispiel für diesen Code an. Erstellen wir eine neue Methode in unserer Anwendung im Store Controller:
private def find_cart session [: cart] || = Cart.new end
Obwohl es sich um ca. 4 Zeilen Code handelt, bringen diese eine ziemlich hohe Komplexität mit sich, zuerst machen wir die private Methode, auf diese Weise verhindern wir, dass Rails sie als Aktion im Controller zur Verfügung stellt, dann sehen wir, dass wir den bedingten Zuweisungsoperator | . verwenden | =.
Dieser Operator in der Methode, die es uns ermöglicht, die folgende Funktionalität auszuführen, wenn es einen Sitzungs-Hash gibt, der dem entspricht Schlüssel: Warenkorb dann geben wir seinen Inhalt zurück, ansonsten bauen wir ein neues Cart-Objekt und weisen es der sessionn zu, dann geben wir seinen Wert zurück.
Nachdem wir nun den theoretischen Teil des Ansatzes ein wenig gemeistert haben, werden wir die Funktionalität, die wir erstellen müssen, ein wenig vertiefen. Sobald wir unseren Einkaufswagen erstellt haben, wissen wir, dass jeder Verkauf den Preis halten muss an dem es gemacht wurde für das, was wir eine Tabelle namens erstellen werden line_items, Was dies tut, ist die Zeile der Käuferauswahl zu speichern, sehen wir uns den Code an, den wir in unsere Datenbank einfügen müssen:
Tabelle löschen, falls vorhanden line_items; Tabelle erstellen line_items (id int product_id int Menge int unit_price dezimal (10,2) Einschränkung fk_items_product Primärschlüssel (id)); not null auto_increment, not null, not null default 0, not null, Fremdschlüssel (product_id) verweist auf Produkte (id), Primärschlüssel (id));
Wie wir in dieser Definition unserer neuen Tabelle sehen können, haben wir eine Referenz für a . hinzugefügt Unbekannter Schlüssel die das product_id-Feld mit dem id-Feld der Produkttabelle verknüpft, dient uns diese Beziehung, wenn wir das Modell generieren.
Da wir die Tabelle haben, können wir mit ihr interagieren, dafür müssen wir ein neues Modell generieren, damit wir es in unserer Anwendung verwenden können. Wir werden den folgenden Befehl von unserer Befehlskonsole verwenden Rubin auf Schienen.
depot> ruby Skript / Modell generieren LineItem Sobald unser Modell generiert ist, werden wir Folgendes hinzufügen: [i] app / models / line_item.rb [/ i], da nicht alle Datenbanken Rails-Beziehungen unterstützen, Handhabung von ihnen ist ausdrücklich. class LineItem <ActiveRecord :: Basis gehört_zu: Produktende
Nachdem wir unser Modell und die Tabellen für unsere Anwendung erstellt haben, haben wir nur noch Teil 2 davon, um die Entwicklung abzuschließen und einen funktionalen Einkaufswagen zu haben, der als Sprungbrett zu viel fortgeschritteneren Anwendungen dient.
Wir fahren mit dem Aufbau des Warenkorbs für unsere Anwendung fort, in Rubin auf SchienenSchauen wir uns dazu das von uns gebaute Modell weiter an und sehen wir uns ein wenig die Erklärung hinter dem Problem an. Schienen behandelt eine Konvention, die es Ihnen ermöglicht, abzuleiten, wie Beziehungen zwischen Tabellen behandelt werden, nachdem wir sie explizit deklariert haben, indem Sie ihr mitteilen, dass unser LineItem-Modell diese Codezeile enthält: gehört_to: Produkt, weiß die Rails-Engine bereits, dass in der Tabelle ein Feld namens product_id vorhanden sein muss.
Jetzt werden wir den notwendigen Code generieren, um unseren Warenkorb zu erstellen. Zuerst müssen wir die Methode im Controller unseres Shops implementieren, um Artikel in den Warenkorb zu legen. Wir werden zuerst diesen Controller lokalisieren: App / Controller / store_controller.rb und drinnen werden wir die Methode erstellen in den Warenkorb legen mit folgendem Code drin.
def add_to_cart product = Product.find (params [: id]) @cart = find_cart @ cart.add_product (product) redirect_to (: action => 'display_cart') end
Jetzt müssen wir unsere Cart-Klasse generieren, diese spezielle Klasse ist nicht an das Modell gebunden Aktiver Rekord Da es nicht mit der Datenbank interagiert, werden wir es zur Vereinfachung manuell in unserem Verzeichnis erstellen App / Modelle, dort erstellen wir die Datei cart.rb.
In unserer neuen Datei werden wir Folgendes platzieren:
class Warenkorb attr_reader: items attr_reader: total_price def initialize @items = [] @total_price = 0.0 end def add_product (product) @items << LineItem.for_product (product) @total_price + = product.price end end
Nachdem dies nun abgeschlossen ist, gehen wir zu unserem LineItem-Modell und platzieren das, was wir vermissen:
class LineItem <ActiveRecord :: Basis gehört_zu: product def self.for_product (product) item = self.new item.quantity = 1 item.product = product item.unit_price = product.price item end end
Lassen Sie uns eine kurze Zusammenfassung dessen machen, was wir bisher haben. Wir haben bereits die Methode, mit der wir einen Artikel in den Warenkorb legen können in den Warenkorb legen, dann haben wir den Inhalt unserer Klasse Wagen was es uns ermöglicht, ein Produkt hinzuzufügen und in unserer Klasse zu bleiben Werbebuchung Wir können die Werte dieser Produkte extrahieren, die wir hinzufügen. Wir müssen nur noch ein paar weitere Elemente implementieren, damit unsere Anwendung funktioniert. Zuerst müssen wir eine Aktion hinzufügen, die es uns ermöglicht, die Ansicht anzuzeigen und andernfalls zu generieren, dazu fügen wir Folgendes hinzu:
def display_cart @cart = find_cart @items = @ cart.items end
Diese Methode wird aus unserer Sicht jetzt in unseren Controller gehen: App / Aufrufe / Store, wir erstellen eine Datei display_cart.rhtml und drinnen werden wir den folgenden Code platzieren:
Ihr Warenkorb enthält Dinge.
Natürlich funktioniert dies immer noch nicht, aber wir müssen einen letzten Schritt hinzufügen und dies ist die Definition unserer neuen Modelle im Rahmen der Bewerbung dafür, zu der wir gehen werden App / Controller und wir sehen eine Datei namens anwendung.rb in die wir folgendes einfügen müssen:
class ApplicationController <ActionController :: Basismodell: Warenkorbmodell: line_item end
Damit hätten wir schon unsere Einkaufswagen basic, aber das bringt uns der Implementierung eines Endprodukts mit vollständig erweiterter Funktionalität näher. Damit beenden wir dieses Tutorial von Rubin auf Schienen und es ist wichtig zu erwähnen, dass wir den von uns platzierten Code sorgfältig analysieren müssen, um den Grund seiner Funktionsweise zu verstehen und auf diese Weise qualitativ hochwertiges Wissen zu generieren.Hat dir dieses Tutorial gefallen und geholfen?Sie können den Autor belohnen, indem Sie diesen Knopf drücken, um ihm einen positiven Punkt zu geben
