README

A comprehensive Laravel package for team management with invitations and role-based access control.

Features

Team Management: Create, edit, and manage teams
Role-Based Access Control: Owner, Admin, and Member roles
Team Invitations: Send and manage team invitations
Team Switching: Switch between teams seamlessly
Livewire Components: Modern, reactive UI components
Soft Deletes: Safe team deletion with soft deletes
Pagination: Built-in pagination for team listings

Installation

Prerequisites

This package requires Flux UI Pro to be installed in your Laravel application. The views and components use Flux UI Pro components.

If you haven't installed Flux UI Pro yet, please install it first:

composer require flux-ui/flux-ui-pro

1. Install the package

composer require fox-run-holdings/laravel-teams

2. Publish the configuration and views

php artisan vendor:publish --provider="FoxRunHoldings\LaravelTeams\Providers\TeamsServiceProvider"

3. Run the migrations

php artisan migrate

4. Add team relationships to your User model

Add the following methods to your App\Models\User model:

<?php

namespace App\Models;

use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasMany;
use FoxRunHoldings\LaravelTeams\Models\Team;
use FoxRunHoldings\LaravelTeams\Models\TeamInvitation;

class User extends Authenticatable
{
    // ... existing code ...

    /**
     * Get the teams that the user belongs to.
     */
    public function teams(): BelongsToMany
    {
        return $this->belongsToMany(Team::class, 'team_user')
            ->withPivot('role')
            ->withTimestamps();
    }

    /**
     * Get the team invitations for the user.
     */
    public function Invitations(): HasMany
    {
        return $this->hasMany(TeamInvitation::class, 'email', 'email');
    }

    /**
     * Get the current team of the user.
     */
    public function currentTeam()
    {
        return $this->belongsTo(Team::class, 'current_team_id');
    }

    /**
     * Check if the user has teams.
     */
    public function HasTeams(): bool
    {
        return $this->teams()->exists();
    }

    /**
     * Get the user's role in a specific team.
     */
    public function role($team_id): string
    {
        $team = $this->teams()->where('team_id', $team_id)->first();
        return $team ? $team->pivot->role : 'member';
    }

    /**
     * Get the user's initials for avatar display.
     */
    public function initials(): string
    {
        $name = explode(' ', $this->name);
        $initials = '';
        
        if (count($name) >= 2) {
            $initials = strtoupper(substr($name[0], 0, 1) . substr($name[1], 0, 1));
        } else {
            $initials = strtoupper(substr($this->name, 0, 2));
        }
        
        return $initials;
    }
}

Usage

Facade Usage

The package provides a facade for easy access to team functionality:

use FoxRunHoldings\LaravelTeams\Facades\Teams;

// Create a team
$team = Teams::create([
    'name' => 'My Team',
    'owner_id' => auth()->id(),
]);

// Find a team
$team = Teams::find(1);

// Create an invitation
$invitation = Teams::invite($team->id, 'user@example.com', 'member');

// Accept an invitation
Teams::acceptInvitation($invitation->id);

// Switch to a team
Teams::switchTeam($team->id);

// Get current team
$currentTeam = Teams::getCurrentTeam();

Livewire Components

The package provides several Livewire components that you can use in your views:

Team Invitations

<livewire:teams.invitations />

Team Management

<livewire:teams.manage />

Team Members

<livewire:teams.members />

Team Switcher

<livewire:teams.switcher />

Routes

Add the following routes to your routes/web.php:

Route::middleware(['auth'])->group(function () {
    Route::get('/teams', function () {
        return view('teams.manage');
    })->name('teams');
    
    Route::get('/teams/members', function () {
        return view('teams.members');
    })->name('teams.members');
    
    Route::get('/teams/invitations', function () {
        return view('teams.invitations');
    })->name('teams.invitations');
});

Configuration

The package configuration is published to config/teams.php. You can customize:

User model class
Available team roles
Invitation statuses
Pagination settings
Route configuration

Database Structure

The package creates the following tables:

teams - Team information
team_user - Many-to-many relationship between teams and users
team_invitations - Team invitations
Adds current_team_id to the users table

Contributing

Fork the repository
Create a feature branch
Make your changes
Add tests
Submit a pull request

License

This package is open-sourced software licensed under the MIT license.

Support

For support, please open an issue on GitHub or contact us at info@foxrunholdings.com.

fox-run-holdings / laravel-teams

Maintainers

Details