datatable.directory/app/Models/Table.php

<?php

namespace App\Models;

use App\Models\Concerns\Reportable;
use function GuzzleHttp\Psr7\build_query;
use http\QueryString;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;

/**
 * A data table object (referencing revisions)
 *
 * @property int $id
 * @property \Carbon\Carbon $created_at
 * @property \Carbon\Carbon $updated_at
 * @property int $owner_id
 * @property int $ancestor_id
 * @property int $revision_id
 * @property string $name
 * @property string $title
 * @property string $description
 * @property string $license
 * @property string $origin
 * @property int $visits
 * @property-read string $viewRoute
 * @property-read string $draftRoute
 * @property-read string $settingsRoute
 * @property-read string $deleteRoute
 * @property-read string $draftSessionKey
 * @property-read string $draftDiscardRoute
 * @property-read string $draftUpdateRoute
 * @property-read string $draftSubmitRoute
 * @property-read string $revisionsRoute
 * @property-read User $owner
 * @property-read Table $parentTable
 * @property-read Table[]|Collection $forks
 * @property-read Revision[]|Collection $revisions
 * @property-read Revision $revision
 * @property-read Proposal[]|Collection $proposal
 * @property-read TableComment[]|Collection $comments
 * @property-read User[]|Collection $favouritingUsers
 * @property-read User[]|Collection $discussionFollowers
 */
class Table extends BaseModel
{
    use Reportable;
    protected $guarded = [];

    protected $touches = ['owner'];

    public function countVisit()
    {
        // Temporarily disable timestamps to avoid touching updated_at
        $oldt = $this->touches;
        $this->touches = [];
        $this->timestamps = false;

        $this->increment('visits');

        $this->timestamps = true;
        $this->touches = $oldt;
    }

    /** Get owner from the instance cache (use when building table lists) */
    public function cachedOwner()
    {
        return User::getCached($this->owner_id);
    }

    /** Owning user */
    public function owner()
    {
        return $this->belongsTo(User::class, 'owner_id');
    }

    /** Fork precursor */
    public function parentTable()
    {
        return $this->belongsTo(Table::class, 'ancestor_id');
    }

    /** Fork descendants */
    public function forks()
    {
        return $this->hasMany(Table::class, 'ancestor_id');
    }

    /** All related revisions (this may include merged revisions) */
    public function revisions()
    {
        return $this->belongsToMany(Revision::class, 'table_revision_pivot');
    }

    /** Active revision */
    public function revision()
    {
        return $this->belongsTo(Revision::class, 'revision_id');
    }

    /** Proposals submitted to this table */
    public function proposals()
    {
        return $this->hasMany(Proposal::class);
    }

    /** User-submitted comments */
    public function comments()
    {
        return $this->hasMany(TableComment::class);
    }

    /** Users favouriting this table */
    public function favouritingUsers()
    {
        return $this->belongsToMany(User::class, 'table_favourites');
    }

    /**
     * Relation to the pivot table, for favourite counting
     */
    public function favourites()
    {
        return $this->hasMany(TableFavouritePivot::class);
    }

    /** Users to notify about comments */
    public function discussionFollowers()
    {
        return $this->belongsToMany(User::class, 'discussion_follows');
    }

    public function __get($name)
    {
        if (ends_with($name, 'Route')) {
            $arg = [
                'user' => $this->cachedOwner()->name,
                'table' => $this->name
            ];

            switch ($name) {
                case 'viewRoute':     return route('table.view', $arg);
                case 'settingsRoute': return route('table.conf', $arg);
                case 'draftRoute':    return route('table.draft', $arg);
                case 'deleteRoute':   return route('table.delete', $arg);
                case 'draftDiscardRoute':    return route('table.draft-discard', $arg);
                case 'draftUpdateRoute':    return route('table.draft-update', $arg);
                case 'draftSubmitRoute':    return route('table.draft-submit', $arg);
                case 'revisionsRoute':    return route('table.revisions', $arg);
            }
        }

        if ($name == 'draftSessionKey') return "proposal.{$this->id}";

        return parent::__get($name);
    }

    /**
     * Get route to some action (so we dont have to add xxRoute for everything)
     *
     * @param $action
     * @param array $getargs
     * @return string
     */
    public function actionRoute($action, $getargs = [])
    {
        $user = $this->cachedOwner()->name;
        $table = $this->name;

        $base = "/@$user/$table";
        if ($action != 'view') $base .= "/$action";

        if ($getargs) {
            return $base . '?' . build_query($getargs);
        } else {
            return $base;
        }
    }

    public function getDraftRoute($tab=null)
    {
        return route('table.draft', [
            'user' => $this->cachedOwner()->name,
            'table' => $this->name,
            'tab' => $tab,
        ]);
    }

    public function scopeForList(Builder $query)
    {
        return $query->with('revision:id,row_count')->with('owner:id,name,title')
            ->withCount(['favourites', 'forks', 'revisions', 'proposals', 'comments']);
    }
}