[RUBY] Implementierung der DM-Funktion

Ich werde es für mich selbst zusammenstellen.

Erforderliche Tabelle

users Benutzertabelle

rooms Ein Ort, um einen Chatraum zu haben

entries Eine Tabelle, die Benutzer verwaltet, die den Chatraum betreten

messages Tabelle zum Verwalten von Nachrichten

Implementierung

Modellieren

$ rails g model room name:string
$ rails g model entry user:references room:references
$ rails g model message user:references room:references content:text
$ rails db:migrate

user.rb

class User < ApplicationRecord
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :trackable, :validatable
  has_many :messages, dependent: :destroy
  has_many :entries, dependent: :destroy
end

entry.rb

class Entry < ApplicationRecord
  belongs_to :user
  belongs_to :room
end

room.rb

class Room < ApplicationRecord
  has_many :messages, dependent: :destroy
  has_many :entries, dependent: :destroy
end

message.rb

class Message < ApplicationRecord
  belongs_to :user
  belongs_to :room
end

Controller-Erstellung

$ rails g controller users index show
$ rails g controller rooms
$ rails g controller messages

routes.rb

resources :users, only: [:show,:edit,:update]
resources :messages, only: [:create]
resources :rooms, only: [:create,:show]

users_controller.rb

class UsersController < ApplicationController
  def show
    @user = User.find(params[:id])
    # current_Suchen Sie den Benutzer in der Tabelle "Einträge"
    @currentUserEntry = Entry.where(user_id: current_user.id)
    #Suchen Sie den Benutzer, der DM senden soll, aus der Tabelle "Einträge"
    @userEntry = Entry.where(user_id: @user.id)

    if @user.id != current_user.id
      #mit currentUser@Nehmen Sie die Einträge jedes Benutzers einzeln heraus und prüfen Sie, ob die beiden Räume bereits vorhanden sind
      @currentUserEntry.each do |cu|
        @userEntry.each do |u|
          #Wenn bereits ein Raum für 2 Personen vorhanden ist
          if cu.room_id == u.room_id
            @isRoom = true
            #room_ID extrahieren
            @roomId = cu.room_id
          end
        end
      end

      #Wenn kein Platz für 2 Personen ist
      unless @isRoom
        #Neuen Raum und Eingang schaffen
        @room = Room.new
        @entry = Entry.new
      end
    end
  end
end

ruby:users/show.html.slim

  - if @user.id != current_user.id

    #Muss aufeinander folgen
    - if (current_user.following? @user) && (@user.following? current_user)

      #Wenn Sie bereits ein Zimmer haben (Sie haben zuvor DM ausgetauscht)
      - if @isRoom == true
         #Gehe in den Raum hinein
         =link_to room_path(@roomId) do
           i.fas.fa-envelope

      #Wenn kein Platz vorhanden ist (neue DM)
      - else
        #Senden Sie Daten an zwei Modelle, Raum und Eingang
        = form_with @room, local: true do |f|
          = fields_for @entry do |e|
            #Eintrag ist Benutzer_Weil Sie die ID senden mü[email protected] Sie die ID an
            = e.hidden_field :user_id, value: @user.id
          #Diesmal verwenden wir einen Button für den Link_Tag verwenden. Normalerweise f.OK mit senden
          = button_tag type: 'submit' do
            i.fas.fa-envelope

rooms_controller

class RoomsController < ApplicationController

  def create
    @room = Room.create
    # current_Benutzereintrag
    @entry1 = Entry.create(room_id: @room.id, user_id: current_user.id)
    #Eintrag (Benutzer) auf der Empfangsseite von DM/Benutzer in der Show_Raum wird übergeben, weil ID übergeben wird_Ich nehme den Ausweis und füge ihn zusammen.
    @entry2 = Entry.create((entry_params).merge(room_id: @room.id))
    redirect_to room_path(@room)
  end

  def show
    @room = Room.find(params[:id])
    #aktuell in der Eintragstabelle_user.Überprüfen Sie, ob der ID ein Chatraum zugeordnet ist
    if Entry.where(user_id: current_user.id,room_id: @room.id).present?
      @messages = @room.messages
      @message = Message.new
      #Ersetzen, um Benutzerinformationen des Chatrooms anzuzeigen
      @entries = @room.entries
    else
      redirect_back(fallback_location: root_path)
    end
  end

  private
    def entry_params
      params.require(:entry).permit(:user_id, :room_id)
    end

end

ruby:rooms/show.html.slim

.row
  .col-lg-2
  .col-lg-8.frame-notification
    <hr>
    #Liste anzeigen, wenn eine Nachricht vorliegt
    - if @messages.present?
      - @messages.each do |message|
        .row.balloon5
          #Dieses Mal möchte ich meine Nachricht auf der rechten Seite anzeigen, also den folgenden bedingten Zweig
          - if current_user.name == message.user.name
            .col-lg-12.text-right
              .chatting
                .say
                  = message.content
                <br>
                small= message.created_at.to_s(:datetime_jp)
          - else
            .col-lg-2.text-center
              = attachment_image_tag message.user, :image, format: 'jpeg', fallback: "noimage.png ", size: "50x40"
              small= link_to message.user.name, user_path(message.user), class: "d-block mt-1"
              <br>
            .col-lg-10.text-left
              .chatting
                .says
                  p= message.content
                <br>
                small= message.created_at.to_s(:datetime_jp)
        <hr>
    - else
Es gibt keine p-Nachrichten.

    .row
      .col-lg-2
      .col-lg-8.text-center
        = form_with model: @message, local: true do |f|
          = f.text_field :content, placeholder: "Bitte geben Sie eine Nachricht ein" , size: 50
          = f.hidden_field :room_id, value: @room.id
          = f.submit "Post", class: 'btn btn-outline-secondary btn-sm ml-2'

messages_controller.rb

class MessagesController < ApplicationController

  def create
    #Zimmer in Form gesendet_ID und Strom_user.Überprüfen Sie, ob sich die Daten mit der ID im Eintrag befinden
    if Entry.where(user_id: current_user.id, room_id: params[:message][:room_id]).present?
      #Inhalt und Raum_Da die ID in Form gesendet wird, Benutzer_IDs zusammenführen, um eine neue Nachricht zu erstellen
      @message = Message.create((message_params).merge(user_id: current_user.id))
      redirect_back(fallback_location: root_path)
    else
      flash[:alert] = "Fehler beim Senden der Nachricht."
      redirect_back(fallback_location: root_path)
    end
  end

  private
    def message_params
      params.require(:message).permit(:user_id, :content, :room_id)
    end

end

**Komplett! ** ** **