Inhoudsopgave
Voordat we een winkelwagentje kunnen bouwen zodat een gebruiker producten kan selecteren, moeten we leren om de sessies binnenin Ruby op rails; Wanneer een gebruiker door onze virtuele winkel bladert, zal hij mogelijk producten selecteren. Wat normaal gesproken voor dit soort toepassingen wordt gebruikt, is dat we het uploaden naar een virtueel winkelwagentje, waar we het product, de prijs, de totale kosten van de aankoop en de hoeveelheid van de producten, dit totdat er een uiteindelijke kassa is, dat is wanneer de gebruiker besluit om de aankoop te doen.
Om hieraan te voldoen dat we voorstellen, moeten we de producten behouden die de gebruiker in onze applicatie kiest, hiervoor zullen we de sessies, met deze implementatie dat doet rails We kunnen de gegevens beschikbaar houden zonder ze in databases op te slaan en ze zullen toegankelijk zijn voor de gebruiker die ze heeft gestart vanuit de browser die de verbinding tot stand brengt met de applicatie, waarmee de combinaties sleuteleen waarde Ze worden opgeslagen en we zullen ze beschikbaar hebben.
Laten we een voorbeeld bekijken van hoe deze code eruit ziet, laten we een nieuwe methode maken in onze applicatie in de winkelcontroller:
privé def find_cart session [: cart] || = Cart.new end
Ondanks dat het ongeveer 4 regels code zijn, brengen deze een vrij hoge complexiteit met zich mee, eerst maken we de private methode, op deze manier voorkomen we dat rails deze beschikbaar maakt als een actie in de controller, dan zien we dat we de conditionele toewijzingsoperator gebruiken | | =.
Deze operator in de methode waarmee we de volgende functionaliteit kunnen uitvoeren, als er een sessiehash is die overeenkomt met de sleutel: winkelwagen dan retourneren we de inhoud, anders bouwen we een nieuw Cart-object en wijzen het toe aan de sessionn, dat is wanneer we de waarde ervan retourneren.
Nu we het theoretische deel van de aanpak een beetje onder de knie hebben, gaan we wat dieper in op de functionaliteit die we moeten bouwen, zodra we ons winkelwagentje hebben gemaakt, weten we dat elke verkoop die wordt gedaan de prijs moet behouden waarvoor het is gemaakt voor wat we een tafel gaan maken genaamd line_items, Wat dit zal doen, is de regel van de selectie van de koper opslaan, laten we de code bekijken die we in onze database moeten plaatsen:
laat de tabel vallen als deze bestaat line_items; maak tabel line_items (id int product_id int hoeveelheid int eenheidsprijs decimaal (10,2) beperking fk_items_product primaire sleutel (id)); niet null auto_increment, niet null, niet null standaard 0, niet null, refererende sleutel (product_id) verwijst naar producten (id), primaire sleutel (id));
Zoals we in deze definitie van onze nieuwe tabel kunnen zien, hebben we een referentie toegevoegd voor a vreemde sleutel dat het veld product_id associeert met het veld id van de producttabel, deze relatie zal ons helpen wanneer we het model genereren.
Omdat we de tabel hebben, kunnen we ermee communiceren, hiervoor moeten we een nieuw model genereren zodat we het binnen onze applicatie kunnen gebruiken. We zullen de volgende opdracht van onze opdrachtconsole gebruiken: Ruby op rails.
depot> ruby script / model genereren LineItem Zodra ons model is gegenereerd, gaan we er het volgende aan toevoegen: [i] app / models / line_item.rb [/ i], omdat niet alle databases rails-relaties ondersteunen, van hen is expliciet. class LineItem <ActiveRecord :: Base behoort_to: product end
Nadat we ons model en de tabellen voor onze applicatie hebben gemaakt, hebben we alleen deel 2 ervan om de ontwikkeling ervan af te ronden en om een functionele winkelwagen te hebben die als springplank dient om naar veel geavanceerdere applicaties te springen.
We gaan verder met de constructie van de winkelwagen voor onze applicatie, in Ruby op railsLaten we om dit te doen verder kijken naar het model dat we hebben gebouwd en een beetje de uitleg achter het probleem bekijken. Rails behandelt een conventie waarmee u kunt afleiden hoe relaties tussen tabellen moeten worden behandeld zodra we ze expliciet hebben verklaard, door te vertellen dat ons LineItem-model deze regel code heeft: behoort_bij: product, weet de rails-engine al dat er in de tabel een veld moet zijn met de naam product_id.
Nu gaan we de benodigde code genereren om onze winkelwagen te bouwen, eerst moeten we de methode implementeren in de controller van onze winkel om artikelen aan de winkelwagen toe te voegen. We zullen eerst deze controller lokaliseren: app / controllers / store_controller.rb en binnen zullen we de methode maken Voeg toe aan winkelmandje met de volgende code erin.
def add_to_cart product = Product.find (params [: id]) @cart = find_cart @ cart.add_product (product) redirect_to (: action => 'display_cart') end
Nu moeten we onze Cart-klasse genereren, deze specifieke klasse is niet gebonden aan het model ActiveRecord Omdat het geen interactie heeft met de database, gaan we het om het ons gemakkelijker te maken handmatig genereren in onze directory app / modellen, daar zullen we het bestand maken winkelwagen.rb.
In ons nieuwe bestand zullen we het volgende plaatsen:
class Winkelwagen 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
Nu dit voltooid is, gaan we naar ons LineItem-model en plaatsen wat we missen:
class LineItem <ActiveRecord :: Base hoort bij: product def self.for_product (product) item = self.new item.quantity = 1 item.product = product item.unit_price = product.price item end end
Laten we een korte samenvatting geven van wat we tot nu toe hebben. We hebben al de methode waarmee we een artikel aan de winkelwagen kunnen toevoegen, dit is Voeg toe aan winkelmandje, dan hebben we de inhoud van onze klas Winkelwagen waarmee we een product kunnen toevoegen en als laatste in onze klas kunnen Regelitem we kunnen de waarden extraheren van die producten die we toevoegen. We hoeven nog maar een paar elementen te implementeren zodat onze applicatie werkt, eerst moeten we een actie toevoegen waarmee we de weergave kunnen tonen en, als dat niet lukt, om deze te genereren, hiervoor zullen we het volgende toevoegen:
def display_cart @cart = find_cart @items = @ cart.items end
Deze methode gaat naar onze mening nu in onze controller: app / weergaven / winkel, we zullen een bestand maken display_cart.rhtml en binnen zullen we de volgende code plaatsen:
Uw winkelwagen bevat dingen.
Natuurlijk werkt dit nog steeds niet, we moeten nog een laatste stap toevoegen en dit is om onze nieuwe modellen te definiëren binnen de context van de applicatie hiervoor gaan we naar app / controllers en we zullen een bestand zien met de naam toepassing.rb waarin we het volgende moeten plaatsen:
class ApplicationController <ActionController :: Basismodel: wagenmodel: line_item end
Hiermee hadden we al onze Winkelwagen basis, maar dat brengt ons dichter bij de implementatie van een eindproduct met volledig uitgebreide functionaliteit. Hiermee maken we deze tutorial van Ruby op rails en het is belangrijk om te vermelden dat we de code die we hebben geplaatst zorgvuldig moeten analyseren om de reden te begrijpen waarom het werkt en op deze manier kwaliteitskennis te genereren.Vond je deze Tutorial leuk en heb je eraan geholpen?Je kunt de auteur belonen door op deze knop te drukken om hem een positief punt te geven
