Files
mytodos/app/Models/Folder.php
T
ecdown 177f122c10
tests / ci (push) Canceled after 0s
added roles and organizations
2026-10-15 20:59:32 -07:00

368 lines
12 KiB
PHP

<?php
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', 'organization_id', 'name', 'visibility', 'parent_id', 'color'])]
class Folder extends Model
{
/** @use HasFactory<FolderFactory> */
use HasFactory;
public const COLORS = [
'zinc', 'red', 'orange', 'amber', 'green', 'emerald',
'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
{
return $this->belongsTo(Folder::class, 'parent_id');
}
/** @return HasMany<Folder, $this> */
public function children(): HasMany
{
return $this->hasMany(Folder::class, 'parent_id');
}
/** @return HasMany<Todo, $this> */
public function todos(): HasMany
{
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.
*
* @param Builder<Folder> $query
* @return Builder<Folder>
*/
public function scopeForUser(Builder $query, User|int $user): Builder
{
return $query->where('user_id', $user instanceof User ? $user->id : $user);
}
/**
* Scope the query to top-level folders (no parent).
*
* @param Builder<Folder> $query
* @return Builder<Folder>
*/
public function scopeToplevel(Builder $query): Builder
{
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").
*
* @return Collection<int, array{folder: Folder, depth: int, path: string}>
*/
public static function treeForUser(User|int $user): Collection
{
$folders = Folder::query()
->forUser($user)
->with('organization')
->orderBy('name')
->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, $indexed): void {
$path = $prefix === '' ? $folder->name : $prefix.' / '.$folder->name;
$tree->push([
'folder' => $folder,
'depth' => $depth,
'path' => $path,
]);
foreach ($indexed->where('parent_id', $folder->id)->values() as $child) {
$visit($child, $depth + 1, $path);
}
};
$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;
}
}