Des associations dans Rails pour une application Books de base ?

Je crée une application de base pour la communauté en ligne incel en pleine croissance, les reliant à divers ouvrages qu'ils pourraient trouver utiles, utiles et guidant. Je sais que ça a l'air fou, mais que dois-je faire d'autre pendant que je suis en cure de désintoxication. Pour aller au fond des choses ou mieux mettre le sujet de la question, j'ai du mal à créer des associations appropriées. Je sais que je suis un lâche, mais connaître ces informations sera essentiel si je veux me plonger dans le domaine du génie logiciel en mettant l'accent sur le développement Web.

J'ai plusieurs modèles:

Utilisateur: user.rb, un modèle d'utilisateur pour voir, commenter et aimer des livres.

like: like.rb, comme modèle pour attribuer des likes aux livres.

comment: comment.rb, modèle de commentaire pour commenter les modèles de livres (via un utilisateur).

livre : book.rb, modèle pour les livres, acheminera/affichera les fichiers PDF vers le serveur hôte.

bookshares: book_share.rb, sera une table de jointure reliant les utilisateurs aux likes aux commentaires aux livres et ainsi de suite et vice versa.

godmodel: modèle hypothétique non encore implémenté pour relier le tout de manière globale.

Donc, je veux que les utilisateurs puissent être créés avec un nom d'utilisateur et puissent voir, aimer et commenter des livres sur le "site Web" qui seront éventuellement migrés vers une application Android. Je sais que mes associations sont étranges et si vous me dites de botter des rochers et de lire plus, je l'apprécierai, retournez dans ma chambre et réessayez jusqu'à ce que je comprenne cela, mais s'il vous plaît, ne votez pas contre moi. Voici mon code abyssal:

class BookShare < ApplicationRecord
 
 validates:book_id, presence: true, uniqueness: true
 validates:viewer_id, presence: true, uniqueness: true 
 
 belongs_to:user 
 belongs_to:book
 belongs_to:comment
end

class Book < ApplicationRecord
 validates:title, presence: true 
 validates:author, presence: true 
 validates:user_id, presence: true 
 validates:isbn, presence: true 
 validates:title, presence: true 
 has_many:book_shares
 has_many:users, through::book_shares
 has_many:likes, through::book_shares
 has_many:comments, through::book_shares
end

class Comment < ApplicationRecord
 
 validates:user_id, presence: true, uniqueness: true
 validates:book_id, presence: true, uniqueness: true 
 validates:title, presence: true 
 has_many:book_shares
 has_many:books, through::book_shares
 
end 

class GodModel < ApplicationRecord
 has_many:books 
 has_many:users
 has_many:comments 
 #has_many:likes 
 has_many:topics 
 has_many:book_shares
end

class Like < ApplicationRecord
 # not fully implemented yet. 
 validates:user_id, presence: true 
 
 belongs_to:user 
end

class User < ApplicationRecord
 validates:username, presence: true, uniqueness: true
 has_many:book_shares
 has_many:comments, through::book_shares
 has_many:books, through::book_shares
end

class Topic < ApplicationRecord
 # not implemented yet 
end

Voici mon schéma:

ActiveRecord::Schema[7.0].define(version: 2022_04_12_145402) do
 # These are extensions that must be enabled in order to support this database
 enable_extension "plpgsql"
 create_table "book_shares", force::cascade do |t|
 t.integer "book_id", null: false
 t.integer "viewer_id", null: false
 t.datetime "created_at", null: false
 t.datetime "updated_at", null: false
 t.index ["book_id", "viewer_id"], name: "index_book_shares_on_book_id_and_viewer_id", unique: true
 t.index ["book_id"], name: "index_book_shares_on_book_id"
 t.index ["viewer_id"], name: "index_book_shares_on_viewer_id"
 end
 create_table "books", force::cascade do |t|
 t.string "title", null: false
 t.string "author", null: false
 t.integer "user_id", null: false
 t.text "body_info"
 t.integer "isbn", null: false
 t.binary "photo"
 t.binary "r_data"
 t.datetime "created_at", null: false
 t.datetime "updated_at", null: false
 t.index ["user_id"], name: "index_books_on_user_id"
 end
 create_table "comments", force::cascade do |t|
 t.integer "user_id", null: false
 t.integer "book_id", null: false
 t.text "body_txt"
 t.string "title"
 t.binary "photo"
 t.datetime "created_at", null: false
 t.datetime "updated_at", null: false
 t.index ["book_id"], name: "index_comments_on_book_id"
 t.index ["user_id"], name: "index_comments_on_user_id"
 end
 create_table "god_models", force::cascade do |t|
 t.string "title"
 t.integer "user_id"
 t.integer "comment_id"
 t.integer "book_share_id"
 t.integer "book_id"
 t.integer "like"
 t.integer "topic"
 t.binary "data_x"
 t.date "today"
 t.binary "title2"
 t.boolean "nullfy"
 t.float "nums"
 t.text "body"
 t.datetime "create_at_"
 t.datetime "created_at", null: false
 t.datetime "updated_at", null: false
 t.index ["body"], name: "index_god_models_on_body"
 t.index ["book_id"], name: "index_god_models_on_book_id"
 t.index ["book_share_id"], name: "index_god_models_on_book_share_id"
 t.index ["comment_id"], name: "index_god_models_on_comment_id"
 t.index ["data_x"], name: "index_god_models_on_data_x"
 t.index ["like"], name: "index_god_models_on_like"
 t.index ["nullfy"], name: "index_god_models_on_nullfy"
 t.index ["nums"], name: "index_god_models_on_nums"
 t.index ["title2"], name: "index_god_models_on_title2"
 t.index ["today"], name: "index_god_models_on_today"
 t.index ["topic"], name: "index_god_models_on_topic"
 t.index ["user_id"], name: "index_god_models_on_user_id"
 end
 create_table "likes", force::cascade do |t|
 t.integer "user_id"
 t.string "likeable_type"
 t.bigint "likeable_id"
 t.datetime "created_at", null: false
 t.datetime "updated_at", null: false
 t.index ["likeable_type", "likeable_id"], name: "index_likes_on_likeable"
 t.index ["user_id", "likeable_type", "likeable_id"], name: "index_likes_on_user_id_and_likeable_type_and_likeable_id", unique: true
 end
 create_table "users", force::cascade do |t|
 t.string "username", null: false
 t.string "email"
 t.datetime "created_at", null: false
 t.datetime "updated_at", null: false
 t.index ["username"], name: "index_users_on_username", unique: true
 end
end

Exemple de contrôleur :

class UsersController < ApplicationController
 
 def index 
 render plain: 'index' 
 end
 def show 
 render plain: 'show'
 end
 def new 
 render plain: 'new'
 end
 def destroy 
 render plain: 'destroy'
 end
 def update 
 redner update: 'update'
 end
 private 
 def usershare_param 
 params.require(:user).permit(:username)
 end
end

Maintenant, je sais que j'aurais dû rouler l'intérieur de la grosse jambe de ma mère avant ma naissance, mais c'est ce que j'ai produit jusqu'à présent. Je suis capable de créer l'objet modèle, de les enregistrer je pense et de remplir leurs champs mais je ne pense pas que mes modèles fonctionnent avec les associations données.

J'ai essayé d'utiliser erd mais cela ne fonctionne pas. Compte tenu de l'utilisation de mon application, les modèles/associations sont-ils correctement réalisés? Je veux avoir un utilisateur qui peut voir/commenter/aimer les livres d'intérêt. Un livre peut avoir de nombreux likes et commentaires, les livres peuvent être consultés par de nombreux utilisateurs, les utilisateurs peuvent aimer et commenter de nombreux livres, topcis sera implémenté plus tard pour assortir les livres. L'ensemble du mécanisme d'aimer/commenter/visualiser via un ou plusieurs utilisateurs sera mis en œuvre via une table de jointures appelée bookshares. Je veux écrire correctement mes associations avant de passer à la partie vue/routes de la mini-protection.

Cela dit, je voudrais remercier quiconque à l'avance de m'avoir aidé, mais si ma question n'améliore pas la communauté, faites-le moi savoir et je ferai tout ce qui est en mon pouvoir pour améliorer ma question afin qu'elle soit propice à l'esprit d'apprendre que est ce site ; finalement écrire ce que j'ai appris ici et comment je l'ai mis en œuvre avec l'application complétée suivante comme réponse/lien.

Solution du problème

Avec 4 tables, books, users, commentset likes. Vous pouvez implémenter la conception donnée.

un livre peut avoir de nombreux likers (utilisateurs), un utilisateur peut aimer de nombreux livres, forme une relation plusieurs à plusieurs entre les utilisateurs et les livres. Créez likesune table de jointure.

De même, un livre a de nombreux commentaires, un utilisateur peut écrire de nombreux commentaires. Créez commentsune table de jointure entre les utilisateurs et les livres avec des champs supplémentaires spécifiques aux commentaires.

 # app/models/book.rb
 has_many:likes, dependent::destroy 
 has_many:comments, dependent::destroy 
 has_many:lovers, through::likes, source::user
 has_many:commentors, through::comments, source::user

 # app/models/user.rb
 has_many:likes, dependent::destroy
 has_many:comments, dependent::destroy
 has_many:fav_books, through::likes, source::book

 # app/models/like.rb
 belongs_to:book
 belongs_to:user 

 # app/models/comment.rb
 belongs_to:book 
 belongs_to:user

Vous pouvez consulter ce guide pour explorer les sujets plus en profondeur.