To manage teams in multi-tenant apps in Laravel, you can use a package like Laravel Teamwork to handle team-based permissions, team ownership, and switching between teams.
Step 1: Install Laravel Teamwork Package
First, install the Laravel Teamwork package via Composer:
bash
|
1 |
composer require mpociot/teamwork |
Step 2: Publish Configuration and Migration Files
Publish the configuration file and migration files using the following command:
bash
|
1 |
php artisan vendor:publish --provider="Mpociot\Teamwork\TeamworkServiceProvider" |
This will publish the necessary configuration file config/teamwork.php and the migration files to create teams and team-user relationships.
Step 3: Run Migrations
Run the migration to create the required tables for managing teams:
bash
|
1 |
php artisan migrate |
This will create the following tables:
teams: Stores team details (name, owner, etc.)team_user: Pivot table for many-to-many relationship between users and teamsinvitations: Stores team invitations for users who are invited to join a team
Step 4: Add the Teamwork Trait to the User Model
To enable team functionality, add the Teamwork trait to your User model. Open app/Models/User.php and update it as follows:
php
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
<?php namespace App\Models; use Illuminate\Foundation\Auth\User as Authenticatable; use Mpociot\Teamwork\Traits\UserHasTeams; class User extends Authenticatable { use UserHasTeams; // Other model methods and properties... } |
This will allow users to join teams, switch teams, and manage team relationships.
Step 5: Create a Team Model
Next, you need to create a Team model to represent the teams in your application. Run the following Artisan command to create the Team model:
bash
|
1 |
php artisan make:model Team |
In app/Models/Team.php, add the following code to define the team relationships:
php
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
<?php namespace App\Models; use Illuminate\Database\Eloquent\Model; use Mpociot\Teamwork\TeamworkTeam; class Team extends Model { use TeamworkTeam; protected $fillable = ['name', 'owner_id']; // A team has many users public function users() { return $this->belongsToMany(User::class); } // A team belongs to an owner (User) public function owner() { return $this->belongsTo(User::class, 'owner_id'); } } |
Step 6: Create Teams and Assign Users
You can now create teams and assign users to them using the provided methods.
Example: Creating a Team
To create a team and assign a user as the owner:
php
|
1 2 3 4 5 6 7 8 9 10 11 12 |
use App\Models\User; use App\Models\Team; $user = User::find(1); // Find the user who will own the team $team = Team::create([ 'name' => 'Development Team', 'owner_id' => $user->id, ]); // Assign the user to the team $user->attachTeam($team); |
Example: Add User to a Team
To add another user to the team:
php
|
1 2 3 4 |
$team = Team::find(1); // Find the team $user = User::find(2); // Find the user to be added to the team $team->users()->attach($user->id); |
Step 7: Handle Team Invitations (Optional)
The Laravel Teamwork package provides a built-in way to handle team invitations. To invite a user to a team, you can use the Teamwork::inviteToTeam() method.
Example: Inviting a User to a Team
php
|
1 2 3 4 5 6 7 8 9 10 |
use Mpociot\Teamwork\Facades\Teamwork; use App\Models\Team; $team = Team::find(1); // Find the team $email = 'invitee@example.com'; // Email of the user to invite Teamwork::inviteToTeam($email, $team, function ($invite) { // Handle the invitation (e.g., send email to the user) Mail::to($invite->email)->send(new TeamInvitation($invite)); }); |
Example: Accepting an Invitation
Once a user receives the invitation, they can accept it by following a link (usually embedded in the invitation email). Here’s how you can handle invitation acceptance:
php
|
1 2 3 4 |
use Mpociot\Teamwork\TeamInvite; $invite = TeamInvite::where('token', $request->token)->first(); $invite->accept(); |
Step 8: Switching Between Teams
Since a user can belong to multiple teams, Laravel Teamwork provides methods to switch between teams easily.
Example: Switch Team
To switch the current team for a user:
php
|
1 2 3 4 |
$user = Auth::user(); $team = Team::find(1); // The team the user wants to switch to $user->switchTeam($team); |
This will set the current active team for the user in the session.
Step 9: Middleware for Team-based Authorization
You can use the team-based middleware provided by Laravel Teamwork to restrict access to certain routes or resources based on the user’s current team.
Example: Middleware to Ensure User Belongs to a Team
In your routes/web.php file, you can apply the team middleware:
php
|
1 2 3 4 5 |
Route::middleware(['auth', 'team'])->group(function () { Route::get('/dashboard', function () { return view('dashboard'); }); }); |
You can customize the middleware to ensure that users have the right roles within a team or access to specific teams.
Step 10: Displaying Teams and Users in Views
You can display the teams a user belongs to, their current team, and allow them to switch teams in your views.
Example: Display User’s Teams
php
|
1 2 3 |
@foreach(Auth::user()->teams as $team) <li>{{ $team->name }}</li> @endforeach |
Example: Show Current Team
php
|
1 2 3 |
@if(Auth::user()->currentTeam) <p>Current Team: {{ Auth::user()->currentTeam->name }}</p> @endif |
Example: Switch Team Form
You can create a simple form to allow users to switch teams:
php
|
1 2 3 4 5 6 7 8 9 |
<form action="{{ route('teams.switch') }}" method="POST"> @csrf <select name="team_id"> @foreach(Auth::user()->teams as $team) <option value="{{ $team->id }}">{{ $team->name }}</option> @endforeach </select> <button type="submit">Switch Team</button> </form> |
In your controller, handle the team switch logic:
php
|
1 2 3 4 5 6 7 |
public function switchTeam(Request $request) { $team = Team::find($request->team_id); Auth::user()->switchTeam($team); return redirect()->back(); } |
Step 11: Customize Teamwork Configuration (Optional)
You can customize how teams work in your application by editing the config/teamwork.php file, which was published earlier. You can adjust the model names, table names, and other team-related settings.
Summary
With Laravel Teamwork, you can efficiently manage teams within your multi-tenant application, allowing users to belong to multiple teams, switch teams, and handle team-based permissions. Here’s a quick recap of the steps:
- Install Laravel Teamwork via Composer.
- Run migrations to create the necessary tables.
- Add the Teamwork trait to the User model.
- Create teams and assign users.
- Handle team invitations.
- Allow users to switch between teams.
- Use middleware to enforce team-based authorization.