ldc-supportweb/app/Models/Ticket.php

<?php

namespace App\Models;

use App\Events\NotifyAdmin;
use App\Mail\TicketMention;
use Illuminate\Support\Str;
use App\Models\GitlabIssues;
use App\Enums\Users\RoleEnum;
use App\Models\Credit\Account;
use App\Models\Credit\Estimation;
use App\Models\Ticket\TicketType;
use Illuminate\Support\Collection;
use App\Events\NotifySubscriptions;
use App\Events\TicketStatusChanged;
use App\Jobs\SendTicketMentionMail;
use App\Enums\Tickets\TicketTypeEnum;
use App\Enums\Tickets\TicketStatusEnum;
use Illuminate\Database\Eloquent\Model;
use GrahamCampbell\GitLab\Facades\GitLab;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\ModelNotFoundException;

/**
 * @property int $id
 * @property int $created_by
 * @property int|null $assigned_to La personne a qui est assigné le ticket.
 * @property int $site_id
 * @property TicketTypeEnum $type
 * @property string $title Titre du ticket
 * @property string $text
 * @property string|null $file
 * @property string|null $file2
 * @property string|null $file3 Pièce jointes n°3
 * @property string|null $file4 Pièce jointes n°4
 * @property string|null $file5 Pièce jointes n°5
 * @property TicketStatusEnum $status
 * @property int $order Ticket order.
 * @property bool $is_internal
 * @property string|null $gitlab_issue URL de l'issue Gitlab
 * @property \Illuminate\Support\Carbon|null $date_mep Date MEP souhaitée
 * @property int $last_activity Last activity on the ticket.
 * @property \Illuminate\Support\Carbon|null $created_at
 * @property \Illuminate\Support\Carbon|null $updated_at
 * @property \Illuminate\Support\Carbon|null $deleted_at
 * @property-read \App\Models\User|null $assignedUser
 * @property-read Estimation|null $estimation
 * @property-read string $full_name
 * @property-read \Illuminate\Database\Eloquent\Collection<int, \App\Models\Label> $labels
 * @property-read \Illuminate\Database\Eloquent\Collection<int, Ticket> $linkedTickets
 * @property-read \Illuminate\Database\Eloquent\Collection<int, \App\Models\Message> $messages
 * @property-read \App\Models\User|null $projectManager
 * @property-read \App\Models\Site|null $site
 * @property-read \Illuminate\Database\Eloquent\Collection<int, \App\Models\User> $subscriptions
 * @property-read TicketType|null $ticketType
 * @property-read \App\Models\User|null $user
 * @method static \Illuminate\Database\Eloquent\Builder<static>|Ticket onlyTrashed()
 * @method static \Illuminate\Database\Eloquent\Builder<static>|Ticket withTrashed(bool $withTrashed = true)
 * @method static \Illuminate\Database\Eloquent\Builder<static>|Ticket withoutTrashed()
 * @mixin \Eloquent
 */
class Ticket extends Model
{
    use HasFactory;
    use SoftDeletes;

    /**
     * The attributes that are fillable.
     *
     * @var array
     */
    protected $fillable = [
        'site_id',
        'type',
        'status',
        'order',
        'date_mep',
        'text',
        'title',
        'is_internal',
        'last_activity',
    ];

    /**
     * The attributes that should be cast.
     *
     * @var array
     */
    protected $casts = [
        'is_internal'   => 'bool',
        'type'          => TicketTypeEnum::class,
        'status'        => TicketStatusEnum::class,
        'date_mep'      => 'date',
        'last_activity' => 'timestamp',
    ];

    /**
     * Perform any actions required after the model boots.
     *
     * @return void
     */
    protected static function booted()
    {
        static::creating(function (Ticket $ticket) {
            self::setOrder($ticket);
            // If bug force the ticket status on new. All the others are estimateTodo.
            if ($ticket->type->equals(TicketTypeEnum::bug)) {
                $ticket->status = TicketStatusEnum::new;
            } else {
                $ticket->status = TicketStatusEnum::estimateTodo;
            }
        });
        static::updating(function (Ticket $ticket) {
            if (
                !$ticket->original['status'] !== $ticket->status->value && $ticket->original['order'] === $ticket->order
            ) {
                $user = auth()->user();

                event(new TicketStatusChanged(
                    $ticket,
                    TicketStatusEnum::make($ticket->original['status']),
                    $user,
                    null,
                    false
                ));

                $message = $user ? sprintf('<b>%s</b> a modifié le statut en <b>%s</b>', $user->name, $ticket->status->label()) : sprintf('Le statut a été modifié en <b>%s</b>', $ticket->status->label());

                event(new NotifySubscriptions($ticket, $message));
                event(new NotifyAdmin($ticket, $message));
            }
            if ($ticket->status->equals(TicketStatusEnum::archived)) {
                self::setOrder($ticket, true);
            }
        });
    }

    /**
     * Set order after the last element of the list.
     *
     * @param self    $model
     * @param boolean $isArchived
     * @return void
     */
    private static function setOrder(self $model, bool $isArchived = false): void
    {
        $maxOrder = \intval(self::query()->where('status', '!=', TicketStatusEnum::archived)->max('order'));
        if ($isArchived) {
            $request = Ticket::query()
                ->where('site_id', $model->site_id)
                ->whereNot('status', TicketStatusEnum::archived)
                ->whereNot('id', $model->id)
                ->whereBetween('order', [$model->order, $maxOrder]);
            $request->decrement('order', 1);
            $model->order = 0;
            return;
        }
        $model->order = $maxOrder + 1;
    }


    // * RELATIONSHIPS

    /**
     * HasOne Credit\Estimation relation
     *
     * @return \Illuminate\Database\Eloquent\Relations\HasOne
     */
    public function estimation()
    {
        return $this->hasOne(Estimation::class);
    }

    /**
     * BelongsTo Site relation
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function site()
    {
        return $this->belongsTo(Site::class);
    }

    /**
     * BelongsTo User relation
     * The user that created the ticket
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function user()
    {
        return $this->belongsTo(User::class, 'created_by');
    }

    /**
     * BelongsTo User relation
     * The user that is in charge of the ticket
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function assignedUser()
    {
        return $this->belongsTo(User::class, 'assigned_to');
    }

    /**
     * BelongsTo User relation
     * The user that is in charge of the site linked to this ticket
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function projectManager()
    {
        return $this->belongsTo(User::class, 'project_manager_id');
    }

    /**
     * HasMany Message relation
     *
     * @return \Illuminate\Database\Eloquent\Relations\HasMany
     */
    public function messages()
    {
        return $this->hasMany(Message::class, 'ticket_id');
    }

    /**
     * BelongsToMany User relation
     * The Users that are following this ticket
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
     */
    public function subscriptions()
    {
        return $this->belongsToMany(User::class, 'subscriptions');
    }

    /**
     * BelongsToMany Label relation
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
     */
    public function labels()
    {
        return $this->belongsToMany(Label::class, 'label_ticket');
    }

    /**
     * BelongsTo ticket_type
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
     */
    public function ticketType()
    {
        return $this->belongsTo(TicketType::class, 'type', 'type');
    }

    /**
     * BelongsToMany Linked Ticket
     *
     * @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
     */
    public function linkedTickets()
    {
        return $this->belongsToMany(Ticket::class, 'linked_tickets', 'ticket_id', 'linked_ticket_id');
    }

    // * METHODS

    /**
     * Parse message @user tags and send emails to concerned users
     * returns and array with to users notified
     *
     * @param Message $message
     * @return Collection
     */
    public function sendBeenMentionnedToUser(Message $message): Collection
    {
        $ticket = $this;
        // Find @user + send mail si un seul user est trouvé.
        /** @var \Illuminate\Support\Collection<\App\Models\User> */
        $usersNotified = collect([]);
        $matches       = [];
        $ticket->load('site');
        \preg_match_all('/@\w*/', $message->message, $matches);
        $matches = collect($matches[0] ?? [])->unique();
        foreach ($matches as $pseudo_usertag) {
            try {
                /** @var \App\Models\User $user */
                $user = User::where('name', 'LIKE', '%' . ltrim($pseudo_usertag, '@') . '%')
                    ->where('email', '!=', $ticket->user->email)
                    ->where(function ($q) use ($ticket) {
                        $q->whereHas('sites', function ($q) use ($ticket) {
                            $q->where('id', $ticket->site->id);
                        })
                            ->orWhere('role', RoleEnum::admin)
                            ->orWhere('role', RoleEnum::developper);
                    })->firstOrFail();

                if ($ticket->is_internal) {
                    if ($user->isAdmin()) {
                        $usersNotified->add($user);
                        SendTicketMentionMail::dispatchAfterResponse(
                            $user,
                            new TicketMention($ticket, $message->message)
                        );
                    }
                } else {
                    $usersNotified->add($user);
                    SendTicketMentionMail::dispatchAfterResponse(
                        $user,
                        new TicketMention($ticket, $message->message)
                    );
                }
            } catch (ModelNotFoundException $e) {
                continue;
            } //end try
        } //end foreach

        return $usersNotified;
    }

    /**
     * full_name getter
     *
     * @return string
     */
    public function getFullNameAttribute(): string
    {
        return trans('Ticket n° :ticketId : :ticketSiteName', [
            'ticketId' => $this->id,
            'ticketSiteName' => $this->site->name
        ]);
    }

    /**
     * Check if an account has the same brand as this ticket.
     *
     * @param Account $account
     * @return boolean
     */
    public function accountIsValidForThisTicket(Account $account): bool
    {
        /** @var \App\Models\Brand|null */
        if (!($siteBrand = optional($this->site)->brand)) {
            return false;
        }

        /** @var \App\Models\Brand */
        $accountBrand = $account->brand;

        return !\is_null($accountBrand->id) and $accountBrand->id === $siteBrand->id;
    }

    /**
     * Format the ticket name to contain more information.
     *
     * @param self $ticket
     * @return string
     */
    public static function formatName(self $ticket): string
    {
        return sprintf(
            'Ticket %d (%s): %s',
            $ticket->id,
            $ticket->user ? $ticket->user->name : trans('Utilisateur supprimé'),
            Str::limit(\preg_replace('/[[:cntrl:]]+/', '', $ticket->text), 35),
        );
    }

    /**
     * Get an array of all files columns of the ticket.
     *
     * @return array
     */
    public function getFiles(): array
    {
        return [
            $this->file,
            $this->file2,
            $this->file3,
            $this->file4,
            $this->file5,
        ];
    }
}