[RUBY] Implémentation de la fonction DM

Je vais le préparer moi-même.

Table obligatoire

users Table des utilisateurs

rooms Un endroit pour avoir une salle de chat

entries Une table qui gère les utilisateurs entrant dans la salle de chat

messages Table pour gérer les messages

la mise en oeuvre

La modélisation

$ 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

Création de contrôleur

$ 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_Rechercher un utilisateur dans la table Entrées
    @currentUserEntry = Entry.where(user_id: current_user.id)
    #Trouvez l'utilisateur pour envoyer des DM à partir du tableau Entrées
    @userEntry = Entry.where(user_id: @user.id)

    if @user.id != current_user.id
      #avec currentUser@Retirez les entrées de chaque utilisateur une par une et vérifiez si les deux salles existent déjà
      @currentUserEntry.each do |cu|
        @userEntry.each do |u|
          #Si une chambre pour 2 personnes existe déjà
          if cu.room_id == u.room_id
            @isRoom = true
            #room_Extraire l'identifiant
            @roomId = cu.room_id
          end
        end
      end

      #S'il n'y a pas de place pour 2 personnes
      unless @isRoom
        #Créer une nouvelle pièce et une nouvelle entrée
        @room = Room.new
        @entry = Entry.new
      end
    end
  end
end

ruby:users/show.html.slim

  - if @user.id != current_user.id

    #Doit se suivre
    - if (current_user.following? @user) && (@user.following? current_user)

      #Si vous avez déjà une chambre (vous avez déjà échangé des DM)
      - if @isRoom == true
         #Entrez dans la pièce
         =link_to room_path(@roomId) do
           i.fas.fa-envelope

      #S'il n'y a pas de place (nouveau DM)
      - else
        #Envoyer des données à deux modèles, pièce et entrée
        = form_with @room, local: true do |f|
          = fields_for @entry do |e|
            #L'entrée est l'utilisateur_Parce que vous devez envoyer l'[email protected]écifiez l'identifiant
            = e.hidden_field :user_id, value: @user.id
          #Cette fois, nous utilisons un bouton pour le lien_Utilisez une balise. Normalement f.OK avec soumettre
          = button_tag type: 'submit' do
            i.fas.fa-envelope

rooms_controller

class RoomsController < ApplicationController

  def create
    @room = Room.create
    # current_Entrée utilisateur
    @entry1 = Entry.create(room_id: @room.id, user_id: current_user.id)
    #Entrée (utilisateurs) du côté récepteur du DM/utilisateur en spectacle_la salle est passée car l'identifiant est passé_Je prends l'identifiant et le fusionne)
    @entry2 = Entry.create((entry_params).merge(room_id: @room.id))
    redirect_to room_path(@room)
  end

  def show
    @room = Room.find(params[:id])
    #courant dans le tableau des entrées_user.Vérifiez s'il existe un salon de discussion associé à l'identifiant
    if Entry.where(user_id: current_user.id,room_id: @room.id).present?
      @messages = @room.messages
      @message = Message.new
      #Substitut pour afficher les informations utilisateur de la salle de chat
      @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>
    #Afficher la liste s'il y a un message
    - if @messages.present?
      - @messages.each do |message|
        .row.balloon5
          #Cette fois, je veux afficher mon message sur le côté droit, donc la branche conditionnelle suivante
          - 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
Il n'y a pas de messages p.

    .row
      .col-lg-2
      .col-lg-8.text-center
        = form_with model: @message, local: true do |f|
          = f.text_field :content, placeholder: "Veuillez saisir un message" , size: 50
          = f.hidden_field :room_id, value: @room.id
          = f.submit "Publier", class: 'btn btn-outline-secondary btn-sm ml-2'

messages_controller.rb

class MessagesController < ApplicationController

  def create
    #chambre envoyée sous forme_id et courant_user.Vérifiez si les données avec identifiant sont dans Entry
    if Entry.where(user_id: current_user.id, room_id: params[:message][:room_id]).present?
      #contenu et salle_Étant donné que l'identifiant est envoyé sous forme, l'utilisateur_Fusionner les identifiants pour rédiger un nouveau message
      @message = Message.create((message_params).merge(user_id: current_user.id))
      redirect_back(fallback_location: root_path)
    else
      flash[:alert] = "Échec de l'envoi du message."
      redirect_back(fallback_location: root_path)
    end
  end

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

end

**Achevée! ** **