+257
-7
@@ -2,27 +2,38 @@
|
||||
|
||||
namespace App\Models;
|
||||
|
||||
use App\FolderRole;
|
||||
use App\FolderVisibility;
|
||||
use App\OrganizationRole;
|
||||
use App\WorkspaceType;
|
||||
use Database\Factories\FolderFactory;
|
||||
use Illuminate\Database\Eloquent\Attributes\Fillable;
|
||||
use Illuminate\Database\Eloquent\Builder;
|
||||
use Illuminate\Database\Eloquent\Factories\HasFactory;
|
||||
use Illuminate\Database\Eloquent\Model;
|
||||
use Illuminate\Database\Eloquent\Relations\BelongsTo;
|
||||
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
|
||||
use Illuminate\Database\Eloquent\Relations\HasMany;
|
||||
use Illuminate\Database\Eloquent\Relations\MorphMany;
|
||||
use Illuminate\Support\Carbon;
|
||||
use Illuminate\Support\Collection;
|
||||
use Illuminate\Support\Facades\DB;
|
||||
|
||||
/**
|
||||
* @property int $id
|
||||
* @property int $user_id
|
||||
* @property int|null $organization_id
|
||||
* @property string $name
|
||||
* @property FolderVisibility $visibility
|
||||
* @property string|null $color
|
||||
* @property int|null $parent_id
|
||||
* @property Folder|null $parent
|
||||
* @property Organization|null $organization
|
||||
* @property Collection<int, User> $shares
|
||||
* @property Carbon|null $created_at
|
||||
* @property Carbon|null $updated_at
|
||||
*/
|
||||
#[Fillable(['user_id', 'name', 'parent_id', 'color'])]
|
||||
#[Fillable(['user_id', 'organization_id', 'name', 'visibility', 'parent_id', 'color'])]
|
||||
class Folder extends Model
|
||||
{
|
||||
/** @use HasFactory<FolderFactory> */
|
||||
@@ -33,12 +44,60 @@ class Folder extends Model
|
||||
'sky', 'blue', 'indigo', 'violet', 'fuchsia', 'pink',
|
||||
];
|
||||
|
||||
/**
|
||||
* Folders always belong to a workspace and carry an explicit visibility.
|
||||
* Much of the app inserts rows in bulk without Eloquent, so rather than
|
||||
* enforcing these in the schema we fill them in here whenever they are
|
||||
* missing.
|
||||
*/
|
||||
protected static function booted(): void
|
||||
{
|
||||
static::creating(function (Folder $folder): void {
|
||||
// Sub-folders inherit the workspace of the parent, so creating a
|
||||
// child inside a folder shared from another workspace never leaks
|
||||
// it into the creator's current workspace.
|
||||
if ($folder->organization_id === null && $folder->parent_id !== null) {
|
||||
$folder->organization_id = Folder::query()
|
||||
->whereKey($folder->parent_id)
|
||||
->value('organization_id');
|
||||
}
|
||||
|
||||
$folder->organization_id ??= User::query()
|
||||
->whereKey($folder->user_id)
|
||||
->value('current_organization_id');
|
||||
|
||||
if ($folder->organization_id !== null) {
|
||||
$folder->organization_id = (int) $folder->organization_id;
|
||||
}
|
||||
|
||||
$folder->visibility ??= Folder::defaultVisibilityFor((int) $folder->organization_id);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the attributes that should be cast.
|
||||
*
|
||||
* @return array<string, string>
|
||||
*/
|
||||
protected function casts(): array
|
||||
{
|
||||
return [
|
||||
'visibility' => FolderVisibility::class,
|
||||
];
|
||||
}
|
||||
|
||||
/** @return BelongsTo<User, $this> */
|
||||
public function user(): BelongsTo
|
||||
{
|
||||
return $this->belongsTo(User::class);
|
||||
}
|
||||
|
||||
/** @return BelongsTo<Organization, $this> */
|
||||
public function organization(): BelongsTo
|
||||
{
|
||||
return $this->belongsTo(Organization::class);
|
||||
}
|
||||
|
||||
/** @return BelongsTo<Folder, $this> */
|
||||
public function parent(): BelongsTo
|
||||
{
|
||||
@@ -57,6 +116,20 @@ class Folder extends Model
|
||||
return $this->hasMany(Todo::class);
|
||||
}
|
||||
|
||||
/** @return BelongsToMany<User, $this> */
|
||||
public function shares(): BelongsToMany
|
||||
{
|
||||
return $this->belongsToMany(User::class)
|
||||
->withPivot('role', 'invited_by')
|
||||
->withTimestamps();
|
||||
}
|
||||
|
||||
/** @return MorphMany<Invitation, $this> */
|
||||
public function invitations(): MorphMany
|
||||
{
|
||||
return $this->morphMany(Invitation::class, 'inviteable');
|
||||
}
|
||||
|
||||
/**
|
||||
* Scope the query to folders owned by the given user.
|
||||
*
|
||||
@@ -79,6 +152,144 @@ class Folder extends Model
|
||||
return $query->whereNull('parent_id');
|
||||
}
|
||||
|
||||
/**
|
||||
* Scope the query to folders the given user can access. Pass a workspace
|
||||
* id to narrow the workspace-wide folders to the active workspace while
|
||||
* still surfacing folders explicitly shared with the user from anywhere.
|
||||
*
|
||||
* @param Builder<Folder> $query
|
||||
* @return Builder<Folder>
|
||||
*/
|
||||
public function scopeVisibleTo(Builder $query, User|int $user, ?int $workspaceId = null): Builder
|
||||
{
|
||||
$userId = $user instanceof User ? $user->id : $user;
|
||||
|
||||
return $query->where(function (Builder $query) use ($userId, $workspaceId): void {
|
||||
$query->where(function (Builder $owned) use ($userId, $workspaceId): void {
|
||||
$owned->where('folders.user_id', $userId);
|
||||
|
||||
if ($workspaceId !== null) {
|
||||
$owned->where('folders.organization_id', $workspaceId);
|
||||
}
|
||||
})
|
||||
->orWhereHas('shares', function (Builder $shares) use ($userId): void {
|
||||
$shares->where('folder_user.user_id', $userId);
|
||||
})
|
||||
->orWhere(function (Builder $member) use ($userId, $workspaceId): void {
|
||||
$member->where('folders.visibility', FolderVisibility::Workspace->value);
|
||||
|
||||
if ($workspaceId !== null) {
|
||||
$member->where('folders.organization_id', $workspaceId);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
$memberships = DB::table('organization_user')
|
||||
->where('organization_user.user_id', $userId)
|
||||
->select('organization_user.organization_id');
|
||||
|
||||
$member->whereIn('folders.organization_id', $memberships);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the visibility new folders should adopt in the given workspace.
|
||||
* Personal workspaces keep folders private; shared workspaces default new
|
||||
* folders to workspace-wide access. Falls back to private when the
|
||||
* workspace cannot be found.
|
||||
*/
|
||||
public static function defaultVisibilityFor(int $organizationId): FolderVisibility
|
||||
{
|
||||
$type = Organization::query()->whereKey($organizationId)->value('type');
|
||||
$workspaceType = $type instanceof WorkspaceType
|
||||
? $type
|
||||
: WorkspaceType::tryFrom(is_string($type) ? $type : '');
|
||||
|
||||
return $workspaceType?->defaultFolderVisibility() ?? FolderVisibility::Private;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the role explicitly granted to the user on this folder, or null
|
||||
* when the folder has not been shared with them.
|
||||
*/
|
||||
public function sharedRoleFor(User $user): ?FolderRole
|
||||
{
|
||||
$share = $this->relationLoaded('shares')
|
||||
? $this->shares->firstWhere('id', $user->id)
|
||||
: $this->shares()->whereKey($user->id)->first();
|
||||
|
||||
if ($share === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return FolderRole::tryFrom((string) $share->pivot->role);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the role the user holds through a workspace membership on this
|
||||
* folder, or null when they are not a member or the folder is private.
|
||||
*
|
||||
* @internal Only meaningful for folders shared with the workspace.
|
||||
*/
|
||||
public function workspaceMembershipRoleFor(User $user): ?FolderRole
|
||||
{
|
||||
if ($this->organization_id === null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
$role = OrganizationRole::tryFrom((string) DB::table('organization_user')
|
||||
->where('organization_id', $this->organization_id)
|
||||
->where('user_id', $user->id)
|
||||
->value('role'));
|
||||
|
||||
return $role?->defaultFolderRole();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the strongest role the user holds anywhere on this folder's
|
||||
* ancestry: their own grant if the folder is theirs, explicit shares
|
||||
* (which cascade through the whole subtree), and workspace-wide access
|
||||
* which flows down through folders that are themselves shared with the
|
||||
* workspace.
|
||||
*
|
||||
* Personal workspaces never share folders, and a private folder drops out
|
||||
* of workspace-wide access above it. Returns null when the user has no
|
||||
* access at all.
|
||||
*/
|
||||
public function effectiveRoleFor(User $user): ?FolderRole
|
||||
{
|
||||
if ($this->user_id === $user->id) {
|
||||
return FolderRole::Admin;
|
||||
}
|
||||
|
||||
$role = $this->sharedRoleFor($user);
|
||||
|
||||
// Workspace-wide access only reaches this folder and its descendants
|
||||
// while every folder between the grant and this folder is shared with
|
||||
// the workspace. A private folder therefore stops inherited workspace
|
||||
// access, though explicit shares above it still cascade.
|
||||
$inheritsWorkspace = $this->visibility === FolderVisibility::Workspace;
|
||||
|
||||
if ($inheritsWorkspace) {
|
||||
$role = FolderRole::higherOf($role, $this->workspaceMembershipRoleFor($user));
|
||||
}
|
||||
|
||||
$ancestor = $this->parent;
|
||||
|
||||
while ($ancestor !== null) {
|
||||
$role = FolderRole::higherOf($role, $ancestor->sharedRoleFor($user));
|
||||
|
||||
if ($inheritsWorkspace && $ancestor->visibility === FolderVisibility::Workspace) {
|
||||
$role = FolderRole::higherOf($role, $ancestor->workspaceMembershipRoleFor($user));
|
||||
}
|
||||
|
||||
$ancestor = $ancestor->parent;
|
||||
}
|
||||
|
||||
return $role;
|
||||
}
|
||||
|
||||
/**
|
||||
* Build a flattened, depth-aware tree of the user's folders
|
||||
* ordered top-down, with the full path (e.g. "Work / Acme Corp").
|
||||
@@ -89,12 +300,47 @@ class Folder extends Model
|
||||
{
|
||||
$folders = Folder::query()
|
||||
->forUser($user)
|
||||
->with('organization')
|
||||
->orderBy('name')
|
||||
->get()
|
||||
->keyBy('id');
|
||||
->get();
|
||||
|
||||
return static::flattenTree($folders);
|
||||
}
|
||||
|
||||
/**
|
||||
* Build the flattened tree of every folder the user can see in the given
|
||||
* workspace: their own folders, folders shared with the workspace, and
|
||||
* folders explicitly shared with them from any workspace.
|
||||
*
|
||||
* @return Collection<int, array{folder: Folder, depth: int, path: string}>
|
||||
*/
|
||||
public static function treeForVisibleTo(User|int $user, int $workspaceId): Collection
|
||||
{
|
||||
$folders = Folder::query()
|
||||
->visibleTo($user, $workspaceId)
|
||||
->with('organization')
|
||||
->withCount('shares')
|
||||
->orderBy('name')
|
||||
->get();
|
||||
|
||||
return static::flattenTree($folders);
|
||||
}
|
||||
|
||||
/**
|
||||
* Flatten a flat collection of folders into a depth-aware tree. A folder
|
||||
* whose parent is missing from the collection (for example a folder shared
|
||||
* from outside the active workspace) is treated as a root so it is never
|
||||
* dropped from the tree.
|
||||
*
|
||||
* @param Collection<int, Folder> $folders
|
||||
* @return Collection<int, array{folder: Folder, depth: int, path: string}>
|
||||
*/
|
||||
private static function flattenTree(Collection $folders): Collection
|
||||
{
|
||||
$indexed = $folders->keyBy('id');
|
||||
|
||||
$tree = collect();
|
||||
$visit = function (Folder $folder, int $depth, string $prefix) use (&$visit, &$tree, $folders): void {
|
||||
$visit = function (Folder $folder, int $depth, string $prefix) use (&$visit, &$tree, $indexed): void {
|
||||
$path = $prefix === '' ? $folder->name : $prefix.' / '.$folder->name;
|
||||
|
||||
$tree->push([
|
||||
@@ -103,13 +349,17 @@ class Folder extends Model
|
||||
'path' => $path,
|
||||
]);
|
||||
|
||||
foreach ($folders->where('parent_id', $folder->id)->values() as $child) {
|
||||
foreach ($indexed->where('parent_id', $folder->id)->values() as $child) {
|
||||
$visit($child, $depth + 1, $path);
|
||||
}
|
||||
};
|
||||
|
||||
foreach ($folders->whereNull('parent_id')->values() as $topLevel) {
|
||||
$visit($topLevel, 0, '');
|
||||
$roots = $indexed->filter(
|
||||
fn (Folder $folder): bool => $folder->parent_id === null || ! $indexed->has($folder->parent_id)
|
||||
);
|
||||
|
||||
foreach ($roots->values() as $root) {
|
||||
$visit($root, 0, '');
|
||||
}
|
||||
|
||||
return $tree;
|
||||
|
||||
Reference in New Issue
Block a user