JoinedTeamUser devient Membership

app/controllers/api/v1/joined_team_users_controller.rb

-class Api::V1::JoinedTeamUsersController < ApplicationController
-  before_action :set_joinedTeamUsers, only: %i[show update destroy]
-  before_action :check_login
-
-  def index
-    render json: JoinedTeamUserSerializer.new(JoinedTeamUser.all).serializable_hash.to_json
-  end
-
-  def show
-    render json: JoinedTeamUserSerializer.new(@joinedTeamUser).serializable_hash.to_json
-  end
-
-  def create
-    userId = User.find_by(username: params[:joinedTeamUser][:username]).id
-    teamId = Team.find_by(name: params[:joinedTeamUser][:team_name]).id
-    jtu = JoinedTeamUser.new(team_id: teamId, user_id: userId, can_edit: false)
-    
-    if jtu.save
-      render json: JoinedTeamUserSerializer.new(jtu).serializable_hash.to_json, status: :created
-    else
-      render json: { errors: jtu.errors }, status: :unprocessable_entity
-    end
-  end
-
-  private
-
-  def joinedTeamUsers_params
-    params.require(:joinedTeamUser).permit(:team_id, :user_id, :can_edit, :created_at, :updated_at)
-  end
-  
-  def set_joinedTeamUsers
-    @joinedTeamUser = JoinedTeamUser.find(params[:id])
-  end
-
-end

app/controllers/api/v1/memberships_controller.rb

+class Api::V1::MembershipsController < ApplicationController
+  before_action :set_memberships, only: %i[show update destroy]
+  before_action :check_login
+
+  def index
+    render json: MembershipSerializer.new(Membership.all).serializable_hash.to_json
+  end
+
+  def show
+    render json: MembershipSerializer.new(@membership).serializable_hash.to_json
+  end
+
+  def create
+    userId = User.find_by(username: params[:membership][:username]).id
+    teamId = Team.find_by(name: params[:membership][:team_name]).id
+    jtu = Membership.new(team_id: teamId, user_id: userId, can_edit: false)
+    
+    if jtu.save
+      render json: MembershipSerializer.new(jtu).serializable_hash.to_json, status: :created
+    else
+      render json: { errors: jtu.errors }, status: :unprocessable_entity
+    end
+  end
+
+  private
+
+  def memberships_params
+    params.require(:membership).permit(:team_id, :user_id, :can_edit, :created_at, :updated_at)
+  end
+  
+  def set_memberships
+    @membership = Membership.find(params[:id])
+  end
+
+end

app/controllers/api/v1/teams_controller.rb

 
     if team.save 
       if current_user&.is_admin === false
-        JoinedTeamUser.create!(
+        Membership.create!(
           user_id: current_user.id,
           team_id: team.id,
           can_edit: true
   end
 
   def can_edit?
-    head :forbidden unless JoinedTeamUser.where(:team_id => params[:id]).where(:user_id => current_user.id)[0].can_edit
+    head :forbidden unless Membership.where(:team_id => params[:id]).where(:user_id => current_user.id)[0].can_edit
   end
 end

app/models/joined_team_user.rb

-class JoinedTeamUser < ApplicationRecord
-  # validates_associated :team, on: :create
-  # validates_associated :user, on: :create
-  validates_uniqueness_of :user_id, scope: :team_id, message: "user already part of this team"
-
-  belongs_to :user
-  belongs_to :team
-end

app/models/membership.rb

+class Membership < ApplicationRecord
+  validates :member_id, presence: :true
+  validates :team_id, presence: :true
+  validates_uniqueness_of :member_id, scope: :team_id, message: "user already part of this team"
+
+  belongs_to :member, class_name: 'User'
+  belongs_to :team
+end

app/models/team.rb

 class Team < ApplicationRecord
     validates :name, uniqueness: true, presence: true
 
-    has_many :joined_team_users
-    has_many :users, through: :joined_team_users
+    has_many :memberships
+    has_many :users, through: :memberships
 end

app/models/user.rb

 
   has_many :tasks
   
-  has_many :joined_team_users
-  has_many :teams, through: :joined_team_users
+  has_many :memberships, foreign_key: :member_id
+  has_many :teams, through: :memberships
   
   has_secure_password
 end

app/serializers/joined_team_user_serializer.rb → app/serializers/membership_serializer.rb

-class JoinedTeamUserSerializer
+class MembershipSerializer
   include JSONAPI::Serializer
   attributes :team_id, :user_id, :can_edit
   

config/routes.rb

       resources :users
       resources :tokens, only: %i[create]
       resources :teams
-      resources :joined_team_users
+      resources :memberships
       resources :activities do
         resources :tasks
       end

db/migrate/20210803152520_create_joined_team_users.rb

-class CreateJoinedTeamUsers < ActiveRecord::Migration[6.1]
-  def change
-    create_table :joined_team_users do |t|
-      t.references :user
-      t.references :team
-      t.boolean :can_edit, default: false 
-
-      t.timestamps
-    end
-  end
-end

db/migrate/20210803152520_create_memberships.rb

+class CreateMemberships < ActiveRecord::Migration[6.1]
+  def change
+    create_table :memberships do |t|
+      t.references :member
+      t.references :team
+      t.boolean :can_edit, default: false 
+
+      t.timestamps
+    end
+  end
+end

db/schema.rb

     t.index ["name"], name: "index_activities_on_name"
   end
 
-  create_table "joined_team_users", force: :cascade do |t|
-    t.bigint "user_id"
-    t.bigint "team_id"
-    t.boolean "can_edit", default: false
-    t.datetime "created_at", precision: 6, null: false
-    t.datetime "updated_at", precision: 6, null: false
-    t.index ["team_id"], name: "index_joined_team_users_on_team_id"
-    t.index ["user_id"], name: "index_joined_team_users_on_user_id"
-  end
-
   create_table "joined_user_activities", force: :cascade do |t|
     t.bigint "user_id"
     t.bigint "activity_id"
     t.index ["user_id"], name: "index_joined_user_activities_on_user_id"
   end
 
+  create_table "memberships", force: :cascade do |t|
+    t.bigint "member_id"
+    t.bigint "team_id"
+    t.boolean "can_edit", default: false
+    t.datetime "created_at", precision: 6, null: false
+    t.datetime "updated_at", precision: 6, null: false
+    t.index ["member_id"], name: "index_memberships_on_member_id"
+    t.index ["team_id"], name: "index_memberships_on_team_id"
+  end
+
   create_table "tasks", force: :cascade do |t|
     t.string "name", null: false
     t.text "description"

db/seeds.rb

 Task.reset_pk_sequence
 Team.delete_all
 Team.reset_pk_sequence
-JoinedTeamUser.delete_all
-JoinedTeamUser.reset_pk_sequence
+Membership.delete_all
+Membership.reset_pk_sequence
 
 3.times do |i|
   team = Team.create(name: Faker::Company.name, description: Faker::Company.catch_phrase)
 
 10.times do |i|
   name = Faker::Name.first_name.downcase
-  user = User.create! username: "#{name}", email: "#{name}@email.com", password: "azerty"
+  user = User.create(username: "#{name}", email: "#{name}@email.com", password: "azerty")
   puts "Created USER ##{i+1} - #{user.username}"
   
   2.times do
-    activity = Activity.create!(
+    activity = Activity.create(
       name: Faker::Science.element,
       client: Faker::Company.name,
       description: Faker::Company.catch_phrase,
     )
     puts "Created ACTIVITY \"#{activity.name}\" for #{activity.client}"
 
-    joined_user_activity = JoinedUserActivity.create!(
+    joined_user_activity = JoinedUserActivity.create(
       user_id: user.id,
       activity_id: activity.id
     )
     puts "Created ASSOCIATION ##{joined_user_activity.id}"
   end
   
-  joined_team_users = JoinedTeamUser.create!(
-    user_id: user.id,
+  memberships = Membership.create(
+    member_id: user.id,
     team_id: Team.all.sample.id,
     can_edit: true
   )
-  # puts "USER ##{joined_team_users.user_id} joined TEAM ##{joined_team_users.team_id}"
+  # puts "USER ##{memberships.user_id} joined TEAM ##{memberships.team_id}"
 end
 
-User.create! username: "admin", email: "admin@email.com", password: "azerty", is_admin: true
+User.create(username: "admin", email: "admin@email.com", password: "azerty", is_admin: true)
 puts "Created Admin"
 
 30.times do |i|

test/controllers/api/v1/joined_team_users_controller_test.rb

-require "test_helper"
-
-class Api::V1::JoinedTeamUsersControllerTest < ActionDispatch::IntegrationTest
-  setup do
-    @joinedTeamUser = joined_team_users(:one)
-    @user = users(:one)
-    @team = teams(:one)
-  end
-
-  # INDEX
-  test "should access JoinedTeamUser index" do
-    get api_v1_joined_team_users_url,
-    headers: { Authorization: JsonWebToken.encode(user_id: @user.id) }, 
-    as: :json
-    assert_response :success
-  end
-
-  test "should forbid JoinedTeamUser index" do
-    get api_v1_joined_team_users_url,
-    as: :json
-    assert_response :forbidden
-  end
-
-  # SHOW
-  test "should show JoinedTeamUser" do
-    get api_v1_joined_team_users_url(@joinedTeamUser),
-    headers: { Authorization: JsonWebToken.encode(user_id: @user.id) }, 
-    as: :json
-    assert_response :success
-  end
-
-  test "should forbid show JoinedTeamUser" do
-    get api_v1_joined_team_users_url(@joinedTeamUser),
-    as: :json
-    assert_response :forbidden
-  end
-
-  # CREATE
-  test "should create joinedTeamUser" do
-    assert_difference("JoinedTeamUser.count") do
-    post api_v1_joined_team_users_url,
-    params: { joinedTeamUser: { team_id: @team.id, user_id: @user.id, can_edit: false } },
-    headers: { Authorization: JsonWebToken.encode(user_id: @user.id) }, 
-    as: :json
-    end
-    assert_response :created
-  end
-
-  test "should forbid create joinedTeamUser" do
-    assert_no_difference("JoinedTeamUser.count") do
-      post api_v1_joined_team_users_url,
-      params: { joinedTeamUser: { team_id: @team.id, user_id: @user.id, can_edit: false } },
-      as: :json
-    end
-    assert_response :forbidden
-  end
-  
-
-end

test/controllers/api/v1/memberships_controller_test.rb

+require "test_helper"
+
+class Api::V1::MembershipsControllerTest < ActionDispatch::IntegrationTest
+  setup do
+    @membership = memberships(:one)
+    @user = users(:one)
+    @team = teams(:one)
+  end
+
+  # INDEX
+  test "should access Membership index" do
+    get api_v1_memberships_url,
+    headers: { Authorization: JsonWebToken.encode(user_id: @user.id) }, 
+    as: :json
+    assert_response :success
+  end
+
+  test "should forbid Membership index" do
+    get api_v1_memberships_url,
+    as: :json
+    assert_response :forbidden
+  end
+
+  # SHOW
+  test "should show Membership" do
+    get api_v1_memberships_url(@membership),
+    headers: { Authorization: JsonWebToken.encode(user_id: @user.id) }, 
+    as: :json
+    assert_response :success
+  end
+
+  test "should forbid show Membership" do
+    get api_v1_memberships_url(@membership),
+    as: :json
+    assert_response :forbidden
+  end
+
+  # CREATE
+  test "should create membership" do
+    assert_difference("Membership.count") do
+    post api_v1_memberships_url,
+    params: { membership: { team_id: @team.id, user_id: @user.id, can_edit: false } },
+    headers: { Authorization: JsonWebToken.encode(user_id: @user.id) }, 
+    as: :json
+    end
+    assert_response :created
+  end
+
+  test "should forbid create membership" do
+    assert_no_difference("Membership.count") do
+      post api_v1_memberships_url,
+      params: { membership: { team_id: @team.id, user_id: @user.id, can_edit: false } },
+      as: :json
+    end
+    assert_response :forbidden
+  end
+  
+
+end

test/controllers/api/v1/teams_controller_test.rb

     assert_response :forbidden
   end
 
-  # Ajouter un test pour vérifier le statut de "current_user.can_edit" dans le modèle JoinedTeamUser
+  # Ajouter un test pour vérifier le statut de "current_user.can_edit" dans le modèle Membership
 
   # DESTROY
   test "should destroy team" do
     end
     assert_response :forbidden
   end
-  # Ajouter un test pour vérifier le statut de "current_user.can_edit" dans le modèle JoinedTeamUser
+  # Ajouter un test pour vérifier le statut de "current_user.can_edit" dans le modèle Membership
 
 end

test/models/joined_team_user_test.rb

-require "test_helper"
-
-class JoinedTeamUserTest < ActiveSupport::TestCase
-
-end

test/models/membership_test.rb

+require "test_helper"
+
+class MembershipTest < ActiveSupport::TestCase
+
+end