La relation entre trois colonnes dans Laravel : Rôles, Équipes et Projets.

Question

Dans Laravel, j'ai une relation entre les équipes, les projets, les utilisateurs, les rôles et les autorisations.

Les utilisateurs peuvent avoir plusieurs équipes, une équipe peut avoir plusieurs projets et les utilisateurs peuvent avoir des rôles d'utilisateur, des rôles d'équipe et des rôles de projet. Je veux savoir comment obtenir les autorisations d'un utilisateur par projet, par équipe et uniquement pour l'utilisateur.

Tableau utilisateur

• Id
• nom
• current_project_id
• current_team_id
• role_id
• etc

Tableau des équipes

• id
• nom

Tableau des projets

• id
• nom
• description

Tableau des rôles

• id
• nom
• type(utilisateur,projet,équipe)

Tableau des autorisations

• id
• nom

Tableau des autorisations_rôles

• permission_id
• role_id

table project_user

• project_id
• id_utilisateur
• role_id

table team_user

• team_id
• id_utilisateur
• role_id

Un utilisateur ne peut avoir qu'un seul rôle dans un projet, un seul rôle dans une équipe, et un utilisateur lui-même ne peut avoir qu'un seul rôle, qui peut être un administrateur ou un utilisateur ordinaire.

J'essaie de trouver un moyen d'obtenir le rôle de l'utilisateur dans le projet et j'ai ignoré le code de l'équipe car je pense qu'il est très similaire au code du projet.

class L'utilisateur étend l'authentification
{
    fonction publique projectRole()
    {
        //Je ne trouve pas le moyen d'insérer project_id comme dans où, car current_project_id est nul au démarrage
        return $this->belongsToMany(Role::class, 'project_user')->where('project_id', '=', $this->current_project_id)->first();
    }

    fonction publique projectPermissions()
    {
        return $this->projectRole()->permissions;
    }

    autorisations de fonction publique()
    {
        //Je ne trouve pas le moyen d'obtenir toutes les autorisations de l'équipe, les autorisations du projet et les autorisations des utilisateurs
    }

    rôle de fonction publique () : appartient à
    {
        //Peut uniquement être un rôle d'utilisateur, d'administrateur ou de support.
        return $this->belongsTo(Role::class);
    }

    fonction publique userPermissions()
    {
        renvoyer $this->role->permissions ;
    }
}

Le rôle de classe étend le modèle
{
    autorisations de fonction publique()
    {
        return $this->belongsToMany(Permission::class);
    }
}
Je souhaite utiliser les autorisations comme seuil pour passer à l'interface Inertia, j'essaie quelque chose comme ça. 
Gate::before(function ($user, $permission) {
            return $user->projectPermissions($user->currentProject)->contains($permission) || $user->teamPermissions($user->currentTeam)->contains($permission) || user->teamPermissions($user->currentTeam)->contains($permission)
            || $user->userPermissions()->contient($permission);
        });

Answer 1

Sur la base de votre explication, je l'ai fait comme suit :

Table******************

table project_user :

Schema::create('project_user', function (Blueprint $table) {
    $table->unsignedBigInteger('project_id');
    $table->unsignedBigInteger('user_id');
});

permission_role table :

Schema::create('permission_role', function (Blueprint $table) {
    $table->unsignedBigInteger('permission_id');
    $table->unsignedBigInteger('role_id');
});

role_user table :

Schema::create('role_user', function (Blueprint $table) {
    $table->unsignedBigInteger('role_id');
    $table->unsignedBigInteger('user_id');
});

Modèles *************

Modèle d'utilisateur :

/**
 * Team Relationship
 *
 * @return BelongsToMany
 */
public function teams(): BelongsToMany
{
    return $this->belongsToMany(Team::class);
}

/**
 * Project Relationship
 *
 * @return BelongsToMany
 */
public function projects(): BelongsToMany
{
    return $this->belongsToMany(Project::class);
}

/**
 * Role Relationship
 *
 * @return BelongsToMany
 */
public function roles(): BelongsToMany
{
    return $this->belongsToMany(Role::class, 'role_user');
}

Modèle d'équipe :

/**
 * User Relationship
 *
 * @return BelongsToMany
 */
public function users(): BelongsToMany
{
    return $this->belongsToMany(User::class);
}

/**
 * Project Relationship
 *
 * @return HasMany
 */
public function projects(): HasMany
{
    return $this->hasMany(Project::class);
}

Modèle de projet :

/**
 * Team Relation
 *
 * @return BelongsTo
 */
public function team(): BelongsTo
{
    return $this->belongsTo(Team::class);
}

/**
 * User Relation
 *
 * @return BelongsToMany
 */
public function users(): BelongsToMany
{
    return $this->belongsToMany(User::class);
}

Modèle de rôle :

/**
 * Permission Relation
 *
 * @return BelongsToMany
 */
public function permissions(): BelongsToMany
{
    return $this->belongsToMany(Permission::class, 'permission_role');
}

/**
 * User Relation
 * 
 * @return BelongsToMany
 */
public function users(): BelongsToMany
{
    return $this->belongsToMany(User::class,'role_user');
}

Modèle d'autorisations :

/**
 * Role Relation
 *
 * @return BelongsToMany
 */
public function roles(): BelongsToMany
{
    return $this->belongsToMany(Role::class, 'permission_role');
}

Tout d'abord, nous créer notre rôle souhaité. Par exemple :

Rôle 1 : Nom = Super Administrateur, Type = Utilisateur

Rôle 2 : Nom = Chef d'équipe, Type = Équipe

Rôle 3 : Nom = Développeur de projet, Type = Projet

Maintenant, nous nous attendrons à des rôles attribués à nos utilisateurs. Ces rôles sont stockés dans la table role_user.

Ensuite, en fonction de ces rôles, vous pouvez déterminer les responsabilités de chaque utilisateur au sein de chaque projet et équipe.