Die Beziehung zwischen drei Spalten in Laravel: Rollen, Teams und Projekte.

Question

In Laravel habe ich eine Beziehung zwischen Teams, Projekten, Benutzern, Rollen und Berechtigungen.

Benutzer können mehrere Teams haben, ein Team kann mehrere Projekte haben und Benutzer können Benutzerrollen, Teamrollen und Projektrollen haben. Ich möchte wissen, wie ich die Berechtigungen eines Benutzers pro Projekt, pro Team und nur für den Benutzer erhalten kann.

Benutzertabelle

• Id
• Name
• aktuelle_Projekt_ID
• current_team_id
• role_id
• etc

Mannschaftstabelle

• id
• Name

Projekttabelle

• id
• Name
• Beschreibung

Rollentabelle

• id
• Name
• type(Benutzer,Projekt,Team)

Berechtigungstabelle

• id
• Name

Rollenberechtigungstabelle

• permission_id
• role_id

project_user-Tabelle

• Projekt_ID
• user_id
• role_id

team_user-Tabelle

• team_id
• user_id
• role_id

Ein Benutzer kann nur eine Rolle in einem Projekt, nur eine Rolle in einem Team haben und ein Benutzer selbst kann nur eine Rolle haben, die ein Administrator oder ein normaler Benutzer sein kann.

Ich versuche, die Projektrolle des Benutzers zu ermitteln, und habe den Code des Teams übersprungen, da ich denke, dass er dem Code des Projekts sehr ähnlich ist.

class Benutzer erweitert Authenticatable
{
    öffentliche Funktion projectRole()
    {
        //Ich kann die Möglichkeit, project_id wie in where einzufügen, nicht finden, da current_project_id beim Booten null ist
        return $this->belongsToMany(Role::class, 'project_user')->where('project_id', '=', $this->current_project_id)->first();
    }

    öffentliche Funktion projectPermissions()
    {
        return $this->projectRole()->permissions;
    }

    öffentliche Funktionsberechtigungen()
    {
        //Ich kann nicht die Möglichkeit finden, alle Teamberechtigungen, Projektberechtigungen und Benutzerberechtigungen zu erhalten
    }

    öffentliche Funktion role() : BelongsTo
    {
        //Kann nur die Rolle „Benutzer“, „Administrator“ oder „Support“ sein
        return $this->belongsTo(Role::class);
    }

    öffentliche Funktion userPermissions()
    {
        return $this->role->permissions;
    }
}

Die Klassenrolle erweitert das Modell
{
    öffentliche Funktionsberechtigungen()
    {
        return $this->belongsToMany(Permission::class);
    }
}

Ich möchte Berechtigungen als Schwelle für die Übergabe an das Inertia-Frontend verwenden. Ich versuche so etwas.

Gate::before(function ($user, $permission) {
            return $user->projectPermissions($user->currentProject)->contains($permission) || user->teamPermissions($user->currentTeam)->contains($permission)
            ||. $user->userPermissions()->contains($permission);
        });

Answer 1

根据您的解释，我按照以下方式进行操作：

表格 *************

project_user 表：

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

permission_role 表：

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

role_user 表:

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

Models *************

用户模型：

/**
 * 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');
}

团队模型：

/**
 * 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);
}

项目模型：

/**
 * 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);
}

角色模型：

/**
 * 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');
}

权限模型：

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

首先，我们创建我们期望的角色。例如：

角色1：名称=超级管理员，类型=用户

角色2：名称=团队主管，类型=团队

角色3：名称=项目开发者，类型=项目

现在，我们将期望的角色分配给我们的用户。这些角色存储在role_user表中。

然后，根据这些角色，您可以确定每个用户在每个项目和团队中的职责。