[RUBY] Implementieren Sie die Anwendungsfunktion in Rails

Ich werde erklären, wie die Post-Application-Funktion implementiert und die Funktion mit Rails abgebrochen wird.

Es wird davon ausgegangen, dass die Benutzerfunktion und die Buchungsfunktion bereits implementiert wurden.

Implementierungsablauf

Als grobe Strömung werden wir es durch das folgende Verfahren implementieren.

Erstellen Sie eine Zwischentabelle zwischen Stellen und Bewerbern
Verknüpfen Sie Modelle miteinander
Routing definieren
Definieren Sie die Anwendungsfunktion und die Abbruchfunktion in der Steuerung
Erstellen Sie eine Ansicht der Anwendungsschaltfläche

Erstellen Sie eine Zwischentabelle zwischen Stellen und Bewerbern

Beiträge können mehrere Bewerber haben, und Benutzer können mehrere Beiträge abonnieren. Infolgedessen haben Posts und Benutzer eine Viele-zu-Viele-Beziehung und benötigen eine Zwischentabelle.

Auch hier definieren wir den Antragsteller als "Abnehmer", um zwischen dem Poster und dem Antragsteller auch innerhalb desselben Benutzers zu unterscheiden. Wenn der Modellname des Beitrags "Beitrag" lautet, sollten Sie eine Zwischentabelle mit dem Namen "post_takers" erstellen.

Um eine Zwischentabelle zu erstellen, geben Sie zunächst den folgenden Befehl in das Terminal ein, um ein Modell zu erstellen.

$ rails g model PostTaker

Öffnen Sie die fertige Migrationsdatei und schreiben Sie wie folgt.

`2020XXXXXXXXXX_create_post_takers.rb`


class CreatePostTakers < ActiveRecord::Migration[6.0]
  def change
    create_table :post_takers do |t|
      t.references :post, foreign_key: true
      t.references :taker, foreign_key: {to_table: :users} 
      t.timestamps
    end
  end
end

Der Punkt hier ist der Teil von t.references: taker, Foreign_key: {to_table :: users}. Wenn Sie so schreiben, können Sie auf die Benutzertabelle verweisen, während Sie den Namen des Antragstellers "Abnehmer" als externen Schlüssel der Zwischentabelle definieren. Referenzartikel: https://qiita.com/publichtml/items/1fba15d8071fab66d043

Verknüpfen Sie Modelle miteinander

Schreiben Sie als Nächstes die Zuordnung in das Modell.

`user.rb`


class User < ApplicationRecord
  has_many :post_takers, foreign_key: "taker_id", dependent: :destroy
end

`post.rb`


class Post < ApplicationRecord
  has_many :post_takers, dependent: :destroy
  has_many :takers, through: :post_takers, dependent: :destroy
end

`post_taker.rb`


class PostTaker < ApplicationRecord
  belongs_to :taker, class_name: 'User', foreign_key: 'taker_id'
  validates_uniqueness_of :post_id, scope: :taker_id
end

`Gehört zu: Taker, Klassenname: 'Benutzer', Fremdschlüssel: 'Taker_ID' in post_taker.rb ist Wenn Sie auf diese Weise schreiben, können Sie dem Antragsteller das Benutzermodell zuordnen. Referenzartikel: https://qiita.com/gyu_outputs/items/421cc1cd2eb5b39e20ad

Außerdem lautet validates_uniqueness_of: post_id, scope :: taker_id Wir haben eine solche Validierung geschrieben, um zu verhindern, dass mehr als eine Kombination aus Post und Bewerber registriert wird.

Routing definieren

Beschreiben Sie die Aktion zum Anwenden als "Nehmen" und die Aktion zum Abbrechen als "Abbrechen" im Routing wie folgt.

`routes.rb`


Rails.application.routes.draw do
  resources :posts do
    member do
      get 'take'
      get 'cancel'
    end
  end
end

Oben wird das Mitglied verwendet, um die ID des Beitrags in den Pfad aufzunehmen. Referenzartikel: https://qiita.com/hirokihello/items/fa82863ab10a3052d2ff

Anwendungsfunktion definieren und Funktion in der Steuerung abbrechen

Fügen Sie dem Controller die folgende Beschreibung hinzu.

Dieser Abschnitt basiert auf der Annahme, dass die Anwendungsschaltfläche auf der Seite mit den Beitragsdetails angezeigt wird. Schreiben Sie sie jedoch je nach Situation neu.

`posts_controller.rb`


class PostsController < ApplicationController
  before_action :set_post

  def show
    @user = @post.user
  end

  def take
    #Erstellen Sie einen Datensatz der Zwischentabelle zwischen dem Beitrag und dem angemeldeten Benutzer
    PostTaker.create(post_id: @post.id, taker_id: current_user.id)
    #Flash-Nachricht anzeigen (Wenn Sie die Flash-Nachricht nicht anzeigen möchten, müssen Sie sie nicht schreiben.)
    flash[:notice] = 'Der Antrag ist vollständig.'
    #Weiterleiten, um Detailseite zu posten
    redirect_to action: "show"
  end

  def cancel
    #Extrahieren Sie Datensätze des entsprechenden Beitrags und des angemeldeten Benutzers aus der Zwischentabelle
    post_taker = PostTaker.find_by(post_g_id: @post.id, taker_id: current_user.id)
    post_taker.destroy
    flash[:notice] = 'Die Stornierung ist abgeschlossen.'
    redirect_to action: "show"
  end

  private

  def set_post
    @post = Post.find(params[:id])
  end
end

Erstellen Sie eine Ansicht der Anwendungsschaltfläche

Erstellen Sie zum Schluss eine Ansicht der Anwendungsschaltfläche und fertig! Der folgende Code ist in haml geschrieben.

`show.html.haml`


-#Schaltfläche "Anzeigen" nur, wenn das Poster und der angemeldete Benutzer nicht übereinstimmen
- if @user.id != current_user.id
  -#Fälle werden danach klassifiziert, ob der angemeldete Benutzer in den Bewerbern für die betreffende Stelle enthalten ist oder nicht.
  - if @post.taker_ids.include?(current_user.id)
    = link_to "Anwendung abbrechen", cancel_posts_path(@post.id), data: { confirm: "Möchten Sie die Bewerbung für diesen Beitrag stornieren?" }
  - else
    = link_to "Anwenden", take_posts_path(@post.id), data: { confirm: "Möchten Sie sich für diese Stelle bewerben?" }