Effektive Methoden zur Implementierung verschachtelter Ressourcen in Ruby on Rails

Entdecken Sie in unserem Tutorial, wie Sie mithilfe von Ruby on Rails verschachtelte Ressourcen für Ihre Anwendung erstellen können. Schritt für Schritt führen wir Sie durch den Prozess – von der Modellerstellung bis zur Controlleranpassung. Optimieren Sie Rails-Anwendung noch heute für eine effizientere Datenverwaltung und eine verbesserte Benutzererfahrung!

Ruby on Rails ist ein Web-Framework, das in Ruby geschrieben ist und Entwicklern einen bestimmten Ansatz für die Anwendungsentwicklung bietet. Die Arbeit mit Rails bietet Entwicklern:

1. Konventionen für die Handhabung von Dingen wie Routing, zustandsbehafteten Daten und Asset-Verwaltung.
2. Eine solide Basis im modell-view-controller (MVC)-Architekturmuster, das die Logik einer Anwendung, die sich in Modellen befindet, von der Präsentation und dem Routing von Anwendungsinformationen trennt.

Wenn Sie die Komplexität Ihrer Rails-Anwendungen erhöhen, arbeiten Sie wahrscheinlich mit mehreren Modellen, die die Geschäftslogik Ihrer Anwendung darstellen und mit Ihrer Datenbank interagieren. Das Hinzufügen von verwandten Modellen bedeutet, sinnvolle Beziehungen zwischen ihnen herzustellen, die dann beeinflussen, wie Informationen durch die Controller Ihrer Anwendung übermittelt werden und wie sie Benutzern durch Ansichten erfasst und zurückgegeben werden.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie:

• Einen lokalen Rechner oder einen Entwicklungsserver mit Ubuntu 18.04. Ihre Entwicklungsmaschine sollte einen nicht-root-Benutzer mit Administratorrechten und eine Firewall konfiguriert mit ufw haben.
• Node.js und npm auf Ihrem lokalen Rechner oder Entwicklungsserver installiert. Dieses Tutorial verwendet Node.js-Version 10.16.3 und npm-Version 6.9.0.
• Ruby, rbenv und Rails auf Ihrem lokalen Rechner oder Entwicklungsserver installiert.
• SQLite installiert und eine grundlegende Anwendung für Haifischinformationen erstellt.

Schritt 1: Verschachteltes Modell erstellen

Unsere Anwendung wird die Active Record-Beziehungen nutzen, um eine Beziehung zwischen Shark- und Post-Modellen aufzubauen: Beiträge werden zu bestimmten Haien gehören, und jeder Hai kann mehrere Beiträge haben. Unsere Shark- und Post-Modelle werden daher durch belongs_to- und has_many-Beziehungen verbunden sein.

Der erste Schritt zum Aufbau der Anwendung auf diese Weise besteht darin, ein Post-Modell und zugehörige Ressourcen zu erstellen. Hierfür können wir den Befehl `rails generate scaffold` verwenden, der uns ein Modell, eine Datenbankmigration zur Änderung des Datenbankschemas, einen Controller, einen vollständigen Satz von Ansichten zur Verwaltung standardmäßiger CRUD-Operationen und Vorlagen für Teile, Helfer und Tests gibt.

rails generate scaffold Post body:text shark:references

Sobald Sie den Befehl ausgeführt haben, sehen Sie eine Ausgabe, die die Ressourcen bestätigt, die Rails für die Anwendung generiert hat. Bevor Sie fortfahren, können Sie Ihre Datenbankmigrationdatei überprüfen, um die Beziehung zu überprüfen, die jetzt zwischen Ihren Modellen und Datenbanktabellen besteht.

class CreatePosts < ActiveRecord::Migration[5.2]

def change

create_table :posts do |t|

t.text :body

t.references :shark, foreign_key: true

t.timestamps

end

end

end

Schritt 2: Spezifizieren von verschachtelten Routen und Beziehungen für das übergeordnete Modell

Rails hat bereits die belongs_to-Beziehung in unserem Post-Modell festgelegt, dank des :references-Schlüsselworts im `rails generate scaffold`-Befehl. Aber damit diese Beziehung ordnungsgemäß funktioniert, müssen wir auch eine has_many-Beziehung in unserem Shark-Modell angeben. Wir müssen außerdem Änderungen am Standardrouting vornehmen, das uns Rails gegeben hat, um Postressourcen zu den Untergeordneten von Hairessourcen zu machen.

class Shark < ApplicationRecord

has_many :posts , dependent: :destroy

validates :name, presence: true, uniqueness: true

validates :facts, presence: true

end

Rails.application.routes.draw do

resources :sharks do

resources :posts

end

root ’sharks#index‘

end

Schritt 3: Aktualisierung des Post-Controllers

Die Assoziation zwischen unseren Modellen gibt uns Methoden, die wir verwenden können, um neue Postinstanzen zu erstellen, die mit bestimmten Haien verknüpft sind. Um diese Methoden zu verwenden, müssen wir sie unserem Post-Controller hinzufügen.

class PostsController < ApplicationController

before_action :get_shark

before_action :set_post, only: [:show, :edit, :update, :destroy]

def index

@posts = @shark.posts

end
def new

@post = @shark.posts.build

end
def create

@post = @shark.posts.build(post_params)

respond_to do |format|

if @post.save

format.html { redirect_to shark_posts_path(@shark), notice: ‚Post was successfully created.‘ }

format.json { render :show, status: :created, location: @post }

else

format.html { render :new }

format.json { render json: @post.errors, status: :unprocessable_entity }

end

end

end
def update

respond_to do |format|

if @post.update(post_params)

format.html { redirect_to shark_post_path(@shark), notice: ‚Post was successfully updated.‘ }

format.json { render :show, status: :ok, location: @post }

else

format.html { render :edit }

format.json { render json: @post.errors, status: :unprocessable_entity }

end

end

end
def destroy

@post.destroy

respond_to do |format|

format.html { redirect_to shark_posts_path(@shark), notice: ‚Post was successfully destroyed.‘ }

format.json { head :no_content }

end

end
private

def get_shark

@shark = Shark.find(params[:shark_id])
end
def set_post

@post = @shark.posts.find(params[:id])

end
def post_params

params.require(:post).permit(:body)

end

end

Schritt 4: Anpassung der Ansichten

In diesem Schritt werden wir unsere Ansichtsvorlagen ändern, um Beiträge und ihre zugehörigen Haie besser darzustellen. Wir beginnen mit der Überarbeitung des Formulars für unsere Beiträge und passen dann die Indexansicht an, um die Beiträge in Verbindung mit bestimmten Haien anzuzeigen.

Formular für Beiträge

Unser Formular `_form.html.erb`, das über mehrere Beitragstemplates wiederverwendet wird, benötigt einige Änderungen. Anstatt nur das Post-Modell an den `form_with`-Helper zu übergeben, werden wir sowohl das Shark- als auch das Post-Modell übergeben und Post als untergeordnete Ressource festlegen.

<%= form_with(model: [@shark, post], local: true) do |form| %>

# Weitere Änderungen am Formular

<% end %>

Indexansicht für Beiträge

Die Indexansicht zeigt die Beiträge in Verbindung mit einem bestimmten Hai. Wir werden einige Updates vornehmen, um die Anzeige zu verbessern und die Navigation zu erleichtern.

<% @posts.each do |post| %>
<%= post.body %><%= post.shark.name %><%= link_to ‚Show Shark‘, [@shark] %><%= link_to ‚Edit Post‘, edit_shark_post_path(@shark, post) %><%= link_to ‚Destroy Post‘, [@shark, post], method: :delete, data: { confirm: ‚Are you sure?‘ } %>

<% end %>

Weitere Anpassungen

Wir werden auch andere Vorlagen aktualisieren, um die Änderungen in unserem Formular zu berücksichtigen. Dazu gehören die `new.html.erb` und `edit.html.erb` Vorlagen für Beiträge sowie die `show.html.erb` Vorlage für Haie.

Neue Beiträge und Bearbeitung

Die Verweise in den Vorlagen für neue Beiträge und Bearbeitungen werden entsprechend aktualisiert.

Anzeige von Haien

Die `show.html.erb` Vorlage für Haie wird um eine Abschnitt für Beiträge und einen Link zum Hinzufügen neuer Beiträge erweitert.

Schritt 5: Hinzufügen von Validierungen und Testen der Anwendung

Abschließend fügen wir Validierungen zum Post-Modell hinzu, um die Konsistenz der Daten sicherzustellen. Nachdem die Validierungen hinzugefügt wurden, können wir die Anwendung testen, um sicherzustellen, dass alles reibungslos funktioniert.

Mit diesen letzten Änderungen sind Sie bereit, Ihre Migrationen durchzuführen und die Anwendung zu testen.

Fazit

Mit den durchgeführten Anpassungen haben Sie Ihre Rails-Anwendung verbessert und für zukünftige Entwicklungen vorbereitet. Wenn Sie mehr über Routing und verschachtelte Ressourcen erfahren möchten, bietet die Rails-Dokumentation eine ausgezeichnete Informationsquelle. Effektive Methoden zur Implementierung verschachtelter Ressourcen in Ruby on Rails