Coyote\Http\Controllers\Microblog\SubmitController

Complexity

Total Complexity

10

Size/Duplication

Total Lines	123
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	preview()	0	3	1
A	delete()	0	19	2
A	save()	0	45	4
A	getParser()	0	3	1
A	toggleSponsored()	0	6	1

<?php

namespace Coyote\Http\Controllers\Microblog;

use Coyote\Events\MicroblogWasDeleted;
use Coyote\Events\MicroblogSaved;
use Coyote\Http\Controllers\Controller;
use Coyote\Http\Requests\MicroblogRequest;
use Coyote\Http\Resources\MicroblogResource;
use Coyote\Microblog;
use Coyote\Notifications\Microblog\DeletedNotification;
use Coyote\Repositories\Criteria\WithTrashed;
use Coyote\Repositories\Contracts\UserRepositoryInterface as UserRepository;
use Coyote\Services\Stream\Activities\Create as Stream_Create;
use Coyote\Services\Stream\Activities\Update as Stream_Update;
use Coyote\Services\Stream\Activities\Delete as Stream_Delete;
use Coyote\Services\Stream\Objects\Microblog as Stream_Microblog;
use Illuminate\Http\Request;

/**
 * Class SubmitController
 * @package Coyote\Http\Controllers\Microblog
 */
class SubmitController extends Controller
{
    /**
     * @var UserRepository
     */
    private $user;

    /**
     * @param UserRepository $user
     */
    public function __construct(UserRepository $user)
    {
        parent::__construct();

        $this->user = $user;
    }

    /**
     * @param MicroblogRequest $request
     * @param $microblog
     * @return MicroblogResource
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function save(MicroblogRequest $request, ?Microblog $microblog)
    {
        $this->user->pushCriteria(new WithTrashed());

        if (!$microblog->exists) {
            $microblog->user()->associate($this->auth);

The method user() does not exist on null.

        } else {
            $this->authorize('update', $microblog);
        }

        $microblog->fill($request->only(['text']));

        $this->transaction(function () use ($microblog, $request) {
            $microblog->save();
            $microblog->assets()->sync($request->input('assets'));

            $object = (new Stream_Microblog())->map($microblog);

It seems like $microblog can also be of type null; however, parameter $microblog of Coyote\Services\Stream\Objects\Microblog::map() does only seem to accept Coyote\Microblog, maybe add an additional type check?

            if ($microblog->wasRecentlyCreated) {
                // increase reputation points
                app('reputation.microblog.create')->map($microblog)->save();

The method map() does not exist on Illuminate\Contracts\Foundation\Application.

                // put this to activity stream
                stream(Stream_Create::class, $object);

                if ($this->auth->allow_subscribe) {
                    // enable subscribe button
                    $microblog->is_subscribed = true;

The property is_subscribed does not seem to exist on Coyote\Microblog. Are you sure there is no database migration missing?

                    $microblog->subscribers()->create(['user_id' => $this->auth->id]);
                }
            } else {
                stream(Stream_Update::class, $object);
            }

            $microblog->setTags(array_pluck($request->input('tags', []), 'name'));
        });

        broadcast(new MicroblogSaved($microblog))->toOthers();

It seems like $microblog can also be of type null; however, parameter $microblog of Coyote\Events\MicroblogSaved::__construct() does only seem to accept Coyote\Microblog, maybe add an additional type check?

        MicroblogResource::withoutWrapping();

        $microblog->unsetRelation('assets');
        $microblog->load(['assets', 'tags']);

        return new MicroblogResource($microblog);
    }

    /**
     * Usuniecie wpisu z mikrobloga
     *
     * @param \Coyote\Microblog $microblog
     */
    public function delete($microblog)
    {
        abort_if(!$microblog->exists, 404);
        $this->authorize('delete', $microblog);

        $this->transaction(function () use ($microblog) {
            $microblog->delete();
            // cofniecie pkt reputacji
            app('reputation.microblog.create')->undo($microblog->id);

The method undo() does not exist on Illuminate\Contracts\Foundation\Application.

            // put this to activity stream
            stream(Stream_Delete::class, (new Stream_Microblog())->map($microblog));
        });

        if ($this->userId !== $microblog->user_id) {
            $microblog->user->notify(new DeletedNotification($microblog, $this->auth));
        }

        event(new MicroblogWasDeleted($microblog));
    }

    /**
     * @param Request $request
     * @return \Symfony\Component\HttpFoundation\Response
     */
    public function preview(Request $request)
    {
        return response($this->getParser()->parse((string) $request->get('text')));
    }

    /**
     * @param Microblog $microblog
     * @throws \Illuminate\Auth\Access\AuthorizationException
     */
    public function toggleSponsored(Microblog $microblog)
    {
        $this->authorize('moderate', $microblog);

        $microblog->is_sponsored = !$microblog->is_sponsored;
        $microblog->save();
    }

    /**
     * @return \Coyote\Services\Parser\Factories\PmFactory
     */
    private function getParser()
    {
        return app('parser.microblog');

The expression return app('parser.microblog') returns the type Coyote\Services\Parser\Factories\MicroblogFactory which is incompatible with the documented return type Coyote\Services\Parser\Factories\PmFactory.

    }
}