Coyote\Http\Controllers\User\NotificationsController

Complexity

Total Complexity

17

Size/Duplication

Total Lines	176
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	delete()	0	3	1
A	__construct()	0	3	1
A	getSideMenu()	0	6	2
A	index()	0	14	1
A	save()	0	5	1
A	markAsRead()	0	9	2
A	settings()	0	8	1
A	ajax()	0	14	1
A	mark()	0	12	2
A	redirectToUrl()	0	20	3
A	url()	0	16	2

<?php

namespace Coyote\Http\Controllers\User;

use Coyote\Events\NotificationRead;
use Coyote\Notification;
use Coyote\Repositories\Contracts\NotificationRepositoryInterface as NotificationRepository;
use Coyote\Http\Resources\NotificationResource;
use Illuminate\Http\Request;
use Carbon;

class NotificationsController extends BaseController
{
    use SettingsTrait, HomeTrait {

The trait Coyote\Http\Controllers\User\HomeTrait requires some properties which are not provided by Coyote\Http\Controllers\User\NotificationsController: $pm_unread, $pm

        SettingsTrait::getSideMenu as settingsSideMenu;
        HomeTrait::getSideMenu as homeSideMenu;
    }

    public function __construct(private NotificationRepository $notification)
    {
        parent::__construct();
    }

    /**
     * @return mixed
     */
    public function getSideMenu()
    {
        if ($this->request->route()->getName() == 'user.notifications') {
            return $this->homeSideMenu();
        } else {
            return $this->settingsSideMenu();
        }
    }

    /**
     * @return \Illuminate\View\View
     */
    public function index()
    {
        $this->breadcrumb->push('Powiadomienia', route('user.notifications'));

        $pagination = $this->notification->lengthAwarePaginate($this->userId);
        // mark as read
        $this->mark($pagination);

        $pagination->setCollection(
            collect(NotificationResource::collection($pagination->getCollection())->toArray($this->request))
        );

        return $this->view('user.notifications.home', [
            'pagination'          => $pagination
        ]);
    }

    /**
     * @return \Illuminate\View\View
     */
    public function settings()
    {
        $this->breadcrumb->push('Ustawienia powiadomień', route('user.notifications.settings'));

        return $this->view('user.notifications.settings', [
            'groups'        => $this->notification->notificationTypes()->groupBy('category'),
            'settings'      => $this->auth->notificationSettings()->get()->sortBy('channel')->groupBy('type_id'),
            'channels'      => Notification::getChannels()
        ]);
    }

    /**
     * @param Request $request
     * @return \Illuminate\Http\RedirectResponse
     */
    public function save(Request $request)
    {
        $this->notification->updateSettings($this->userId, $request->input('settings'));

        return back()->with('success', 'Zmiany zostały zapisane');
    }

    /**
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function ajax(Request $request)
    {
        $unread = $this->auth->notifications_unread;
        $offset = $request->query('offset', 0);

        $notifications = $this->notification->takeForUser($this->userId, max(10, $unread), $offset);
        $unread -= $this->mark($notifications);

        // format notification's headline
        $notifications = array_filter(NotificationResource::collection($notifications)->toArray($this->request));

It seems like Coyote\Http\Resources\NotificationResource::collection($notifications)->toArray($this->request) can also be of type Illuminate\Contracts\Support\Arrayable and JsonSerializable; however, parameter $array of array_filter() does only seem to accept array, maybe add an additional type check?

        return response()->json([
            'count'             => $unread,
            'notifications'     => $notifications
        ]);
    }

    /**
     * @param int $id
     */
    public function delete($id)
    {
        $this->notification->delete($id);
    }

    /**
     * Marks all alerts as read
     */
    public function markAsRead()
    {
        if ($this->auth->notifications_unread) {
            $this->notification->where('user_id', $this->userId)->whereNull('read_at')->update([

The method where() does not exist on Coyote\Repositories\Contracts\NotificationRepositoryInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Coyote\Repositories\Contracts\NotificationRepositoryInterface.

                'read_at' => Carbon\Carbon::now()
            ]);
        }

        $this->notification->where('user_id', $this->userId)->update(['is_clicked' => true]);
    }

    /**
     * @param string $id
     * @return \Illuminate\Http\RedirectResponse
     *
     * @deprecated
     */
    public function url(string $id)
    {
        /** @var \Coyote\Notification $notification */
        $notification = $this->notification->findOrFail($id, ['id', 'url', 'read_at', 'user_id', 'is_clicked']);

        $notification->is_clicked = true;

        if (!$notification->read_at) {
            $notification->read_at = Carbon\Carbon::now();

            broadcast(new NotificationRead($notification));
        }

        $notification->save();

        return redirect()->to($notification->url);
    }

    public function redirectToUrl()
    {
        $path = urldecode($this->request->get('path'));

It seems like $this->request->get('path') can also be of type null; however, parameter $string of urldecode() does only seem to accept string, maybe add an additional type check?

        /** @var \Coyote\Notification $notification */
        $notification = $this->auth->notifications()->where('url', $path)->first();

        if ($notification) {

$notification is of type Coyote\Notification, thus it always evaluated to true.

            $notification->is_clicked = true;

            if (!$notification->read_at) {
                $notification->read_at = now();

                broadcast(new NotificationRead($notification));
            }

            $notification->save();
        }

        return redirect()->to($path);
    }

    /**
     * Mark alerts as read and returns number of marked alerts
     *
     * @param \Illuminate\Support\Collection $notifications
     * @return int
     */
    private function mark($notifications)
    {
        $ids = $notifications
            ->reject(fn (Notification $notification) => $notification->read_at !== null)
            ->pluck('id')
            ->all();

        if (!empty($ids)) {
            $this->notification->markAsRead($ids);
        }

        return count($ids);
    }
}