Project.php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Casts\Attribute;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasManyThrough;
use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\Auth;

/**
 * @property int $id
 * @property string $name
 * @property ?string $description
 * @property ?string $homeurl
 * @property ?string $cvsurl
 * @property ?string $bugtrackerurl
 * @property ?string $bugtrackernewissueurl
 * @property ?string $bugtrackertype
 * @property ?string $documentationurl
 * @property int $imageid
 * @property int $public
 * @property int $coveragethreshold
 * @property ?string $testingdataurl
 * @property string $nightlytime
 * @property bool $emaillowcoverage
 * @property bool $emailtesttimingchanged
 * @property bool $emailbrokensubmission
 * @property bool $emailredundantfailures
 * @property ?string $cvsviewertype
 * @property float $testtimestd
 * @property float $testtimestdthreshold
 * @property bool $showtesttime
 * @property int $testtimemaxstatus
 * @property int $emailmaxitems
 * @property int $emailmaxchars
 * @property bool $displaylabels
 * @property int $autoremovetimeframe
 * @property int $uploadquota Maximum sum of uploaded file sizes (in bytes)
 * @property int $uploadquotagb Maximum sum of uploaded file sizes (in GiB)
 * @property bool $showcoveragecode
 * @property bool $authenticatesubmissions
 * @property ?string $ldapfilter
 * @property ?string $banner
 * @property ?string $logoUrl
 * @property ?string $cmakeprojectroot
 *
 * @method Builder<Project> forUser()
 * @method Builder<Project> administeredByUser()
 *
 * @mixin Builder<Project>
 */
class Project extends Model
{
    protected $table = 'project';

    public $timestamps = false;

    protected $fillable = [
        'name',
        'description',
        'homeurl',
        'cvsurl',
        'bugtrackerurl',
        'bugtrackernewissueurl',
        'bugtrackertype',
        'documentationurl',
        'imageid',
        'public',
        'coveragethreshold',
        'testingdataurl',
        'nightlytime',
        'emaillowcoverage',
        'emailtesttimingchanged',
        'emailbrokensubmission',
        'emailredundantfailures',
        'cvsviewertype',
        'testtimestd',
        'testtimestdthreshold',
        'showtesttime',
        'testtimemaxstatus',
        'emailmaxitems',
        'emailmaxchars',
        'displaylabels',
        'autoremovetimeframe',
        'uploadquota',
        'uploadquotagb',
        'showcoveragecode',
        'authenticatesubmissions',
        'ldapfilter',
        'banner',
        'cmakeprojectroot',
    ];

    protected $casts = [
        'id' => 'integer',
        'imageid' => 'integer',
        'public' => 'integer',
        'emaillowcoverage' => 'boolean',
        'emailtesttimingchanged' => 'boolean',
        'emailbrokensubmission' => 'boolean',
        'emailredundantfailures' => 'boolean',
        'showtesttime' => 'boolean',
        'displaylabels' => 'boolean',
        'coveragethreshold' => 'integer',
        'showcoveragecode' => 'boolean',
        'authenticatesubmissions' => 'boolean',
        'testtimestd' => 'float',
        'testtimestdthreshold' => 'float',
        'testtimemaxstatus' => 'integer',
        'emailmaxitems' => 'integer',
        'emailmaxchars' => 'integer',
        'autoremovetimeframe' => 'integer',
        'uploadquota' => 'integer',
    ];

    protected $attributes = [
        'coveragethreshold' => 70,
        'nightlytime' => '00:00:00',
        'emaillowcoverage' => false,
        'emailtesttimingchanged' => false,
        'emailbrokensubmission' => true,
        'emailredundantfailures' => false,
        'testtimestd' => 4,
        'testtimestdthreshold' => 1,
        'showtesttime' => false,
        'testtimemaxstatus' => 3,
        'emailmaxitems' => 5,
        'emailmaxchars' => 255,
        'displaylabels' => true,
        'autoremovetimeframe' => 90,
        'uploadquota' => 10,
        'showcoveragecode' => true,
        'authenticatesubmissions' => false,
    ];

    public const PROJECT_ADMIN = 2;
    public const PROJECT_USER = 0;

    public const ACCESS_PRIVATE = 0;
    public const ACCESS_PUBLIC = 1;
    public const ACCESS_PROTECTED = 2;

    /**
     * @return Attribute<?string,void>
     */
    protected function logoUrl(): Attribute
    {
        return Attribute::make(
            get: function (mixed $value, array $attributes): ?string {
                if ((int) $attributes['imageid'] === 0) {
                    return null;
                }

                return url('/image/' . $attributes['imageid']);
            },
        );
    }

    /**
     * @return Attribute<int,int>
     */
    protected function uploadquotagb(): Attribute
    {
        return Attribute::make(
            get: fn (mixed $value, array $attributes): int => (int) ((int) $attributes['uploadquota'] / (2 ** 30)),
            set: fn (int $value): array => [
                'uploadquota' => $value * (2 ** 30),
            ]
        );
    }

    /**
     * Get the users who have been added to this project.  Note that this selects users with all roles.
     *
     * Note: This is *not* all of the users who have access to this project!
     *
     * @return BelongsToMany<User, $this>
     */
    public function users(): BelongsToMany
    {
        return $this->belongsToMany(User::class, 'user2project', 'projectid', 'userid');
    }

    /**
     * Get the users with the lowest user role.
     *
     * @return BelongsToMany<User, $this>
     */
    public function basicUsers(): BelongsToMany
    {
        return $this->belongsToMany(User::class, 'user2project', 'projectid', 'userid')
            ->wherePivot('role', self::PROJECT_USER);
    }

    /**
     * Get the users who have the administrator role for this project
     *
     * @return BelongsToMany<User, $this>
     */
    public function administrators(): BelongsToMany
    {
        return $this->belongsToMany(User::class, 'user2project', 'projectid', 'userid')
            ->wherePivot('role', self::PROJECT_ADMIN);
    }

    /**
     * Get the projects available to the specified user, or the current user if no user specified.
     * Available as a query builder function: Project::forUser(?User)->...
     *
     * @param Builder<self> $query
     */
    public function scopeForUser(Builder $query): void
    {
        $user = Auth::user();

        if ($user === null) {
            $query->where('public', self::ACCESS_PUBLIC);
        } elseif (!$user->admin) {
            $query->where(function ($subquery) use ($user): void {
                $subquery->whereHas('users', function ($subquery2) use ($user): void {
                    $subquery2->where('users.id', $user->id);
                })
                    ->orWhere('public', self::ACCESS_PUBLIC)
                    ->orWhere('public', self::ACCESS_PROTECTED);
            });
        }
        // Else, this is an admin user, so we shouldn't apply any filters...
    }

    /**
     * Get the projects the current user has admin access to.
     *
     * @param Builder<self> $query
     */
    public function scopeAdministeredByUser(Builder $query): void
    {
        $user = Auth::user();

        if ($user !== null && $user->admin) {
            return;
        }
        $query->whereHas('administrators', function ($subquery) use ($user): void {
            $subquery->where('users.id', $user?->id);
        });
    }

    /**
     * Get the subprojects as of a specified date, or the latest subprojects if no date specified.
     *
     * @return HasMany<SubProject, $this>
     */
    public function subprojects(?Carbon $date = null): HasMany
    {
        if ($date === null) {
            $date = Carbon::now()->setTimezone('UTC');
        }

        return $this->hasMany(SubProject::class, 'projectid', 'id')
            ->where('starttime', '<=', Carbon::now()->setTimezone('UTC'))
            ->where(function ($query) use ($date): void {
                $query->where('endtime', '>', $date)
                    ->orWhere('endtime', '=', Carbon::create(1980));
            });
    }

    /**
     * @return HasMany<PinnedTestMeasurement, $this>
     */
    public function pinnedTestMeasurements(): HasMany
    {
        return $this->hasMany(PinnedTestMeasurement::class, 'projectid', 'id');
    }

    /**
     * @return HasMany<BuildGroup, $this>
     */
    public function buildgroups(): HasMany
    {
        return $this->hasMany(BuildGroup::class, 'projectid', 'id');
    }

    /**
     * @return HasMany<Build, $this>
     */
    public function builds(): HasMany
    {
        return $this->hasMany(Build::class, 'projectid');
    }

    /**
     * @return HasManyThrough<Test, Build, $this>
     */
    public function tests(): HasManyThrough
    {
        return $this->hasManyThrough(Test::class, Build::class, 'projectid', 'buildid');
    }

    /**
     * @return HasOne<Build, $this>
     */
    public function mostRecentBuild(): HasOne
    {
        return $this->hasOne(Build::class, 'projectid', 'id')
            ->ofMany(['submittime' => 'max'], function (Builder $query): void {
                $query->onlyParents();
            });
    }

    /**
     * Queries the sites which have submitted builds to this project.  A convenience method to
     * get sites from all builds in aggregate form.
     *
     * @return BelongsToMany<Site, $this>
     */
    public function sites(): BelongsToMany
    {
        return $this->belongsToMany(Site::class, Build::class, 'projectid', 'siteid')->distinct();
    }

    /**
     * @return HasMany<ProjectInvitation, $this>
     */
    public function invitations(): HasMany
    {
        return $this->hasMany(ProjectInvitation::class, 'project_id');
    }

    /**
     * @return HasMany<SubProjectGroup, $this>
     */
    public function subProjectGroups(): HasMany
    {
        return $this->hasMany(SubProjectGroup::class, 'projectid');
    }

    /**
     * @return HasMany<Repository, $this>
     */
    public function repositories(): HasMany
    {
        return $this->hasMany(Repository::class, 'projectid');
    }
}