ArticleController::postAction() - Code Metrics - Inspection of "[POC] Replaced document-manager by event-sourcing..." - sulu/SuluArticleBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — develop (#305)

by Wachter
created 2018-02-11 17:51 UTC
ArticleController::postAction() B

↳ Parent: ArticleController
Complexity

Conditions	1
Paths	1
Size

Total Lines	28
Code Lines	16
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	10
CRAP Score	1
Importance

Changes
Metric	Value
dl	0
loc	28
ccs	10
cts	10
cp	1
rs	8.8571
c	0
b	0
f	0
cc	1
eloc	16
nc	1
nop	1
crap	1
<?php

/*
 * This file is part of Sulu.
 *
 * (c) MASSIVE ART WebServices GmbH
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Sulu\Bundle\ArticleBundle\Controller;

use FOS\RestBundle\Controller\Annotations\Post;
use FOS\RestBundle\Routing\ClassResourceInterface;
use JMS\Serializer\SerializationContext;
use ONGR\ElasticsearchBundle\Service\Manager;
use ONGR\ElasticsearchDSL\Query\Compound\BoolQuery;
use ONGR\ElasticsearchDSL\Query\FullText\MatchPhrasePrefixQuery;
use ONGR\ElasticsearchDSL\Query\FullText\MatchQuery;
use ONGR\ElasticsearchDSL\Query\MatchAllQuery;
use ONGR\ElasticsearchDSL\Query\TermLevel\IdsQuery;
use ONGR\ElasticsearchDSL\Query\TermLevel\RangeQuery;
use ONGR\ElasticsearchDSL\Query\TermLevel\TermQuery;
use ONGR\ElasticsearchDSL\Sort\FieldSort;
use Prooph\Common\Event\ProophActionEventEmitter;
use Prooph\Common\Messaging\FQCNMessageFactory;
use Prooph\EventStore\ActionEventEmitterEventStore;
use Prooph\EventStore\Pdo\MySqlEventStore;
use Prooph\EventStore\Pdo\PersistenceStrategy\MySqlAggregateStreamStrategy;
use Prooph\EventStore\Pdo\Projection\MySqlProjectionManager;
use Prooph\EventStoreBusBridge\EventPublisher;
use Prooph\ServiceBus\CommandBus;
use Prooph\ServiceBus\EventBus;
use Prooph\ServiceBus\Plugin\Router\CommandRouter;
use Prooph\ServiceBus\Plugin\Router\EventRouter;
use Prooph\SnapshotStore\Pdo\PdoSnapshotStore;
use Ramsey\Uuid\Uuid;
use Sulu\Bundle\ArticleBundle\Admin\ArticleAdmin;
use Sulu\Bundle\ArticleBundle\Document\ArticleDocument;
use Sulu\Bundle\ArticleBundle\ListBuilder\ElasticSearchFieldDescriptor;
use Sulu\Bundle\ArticleBundle\Metadata\ArticleViewDocumentIdTrait;
use Sulu\Bundle\ArticleBundle\Prooph\Infrastruture\ArticleRepository;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Article;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Command\DeleteArticleCommand;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Command\PostArticleCommand;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Command\PublishArticleCommand;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Command\PutArticleCommand;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Command\UnpublishArticleCommand;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Event\CreateTranslation;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Event\ModifyTranslationStructure;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Event\PublishTranslation;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Event\RemoveArticle;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Event\UnpublishTranslation;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Handler\DeleteArticleHandler;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Handler\PostArticleHandler;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Handler\PublishArticleHandler;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Handler\PutArticleHandler;
use Sulu\Bundle\ArticleBundle\Prooph\Model\Handler\UnpublishArticleHandler;
use Sulu\Bundle\ArticleBundle\Prooph\Projection\ArticleDocumentProjector;
use Sulu\Bundle\ArticleBundle\Prooph\Projection\ArticleIndexProjector;
use Sulu\Component\Content\Mapper\ContentMapperInterface;
use Sulu\Component\DocumentManager\DocumentManagerInterface;
use Sulu\Component\DocumentManager\Metadata\BaseMetadataFactory;
use Sulu\Component\Rest\Exception\RestException;
use Sulu\Component\Rest\ListBuilder\ListRepresentation;
use Sulu\Component\Rest\RequestParametersTrait;
use Sulu\Component\Rest\RestController;
use Sulu\Component\Security\Authorization\PermissionTypes;
use Sulu\Component\Security\Authorization\SecurityCondition;
use Sulu\Component\Security\SecuredControllerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

/**
 * Provides API for articles.
 */
class ArticleController extends RestController implements ClassResourceInterface, SecuredControllerInterface
{
    const DOCUMENT_TYPE = 'article';

    use RequestParametersTrait;
    use ArticleViewDocumentIdTrait;

    /**
     * Create field-descriptor array.
     *
     * @return ElasticSearchFieldDescriptor[]
     */
    private function getFieldDescriptors()
    {
        return [
            'uuid' => new ElasticSearchFieldDescriptor('id', null, 'public.id', false, false, 'string', '', '', false),
            'typeTranslation' => new ElasticSearchFieldDescriptor(
                'typeTranslation',
                'typeTranslation.raw',
                'sulu_article.list.type',
                !$this->getParameter('sulu_article.display_tab_all'),
                false
            ),
            'title' => new ElasticSearchFieldDescriptor('title', 'title.raw', 'public.title', false, true),
            'creatorFullName' => new ElasticSearchFieldDescriptor(
                'creatorFullName',
                'creatorFullName.raw',
                'sulu_article.list.creator',
                true,
                false
            ),
            'changerFullName' => new ElasticSearchFieldDescriptor(
                'changerFullName',
                'changerFullName.raw',
                'sulu_article.list.changer',
                false,
                false
            ),
            'authorFullName' => new ElasticSearchFieldDescriptor(
                'authorFullName',
                'authorFullName.raw',
                'sulu_article.author',
                false,
                false
            ),
            'created' => new ElasticSearchFieldDescriptor('created', null, 'public.created', true, false, 'datetime'),
            'changed' => new ElasticSearchFieldDescriptor('changed', null, 'public.changed', false, false, 'datetime'),
            'authored' => new ElasticSearchFieldDescriptor('authored', null, 'sulu_article.authored', false, false, 'date'),
        ];
    }

    /**
     * Returns fields.
     *
     * @return Response
     */
    public function cgetFieldsAction()
    {
        $fieldDescriptors = $this->getFieldDescriptors();

        return $this->handleView($this->view(array_values($fieldDescriptors)));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Returns list of articles.
     *
     * @param Request $request
     *
     * @return Response
     */
    public function cgetAction(Request $request)
    {
        $locale = $this->getRequestParameter($request, 'locale', true);

        $restHelper = $this->get('sulu_core.list_rest_helper');

        /** @var Manager $manager */
        $manager = $this->get('es.manager.default');
        $repository = $manager->getRepository($this->get('sulu_article.view_document.factory')->getClass('article'));
        $search = $repository->createSearch();

        $limit = (int) $restHelper->getLimit();
        $page = (int) $restHelper->getPage();

        if (null !== $locale) {
            $search->addQuery(new TermQuery('locale', $locale));
        }

        if (count($ids = array_filter(explode(',', $request->get('ids', ''))))) {
            $search->addQuery(new IdsQuery($this->getViewDocumentIds($ids, $locale)));
            $limit = count($ids);
        }

        if (!empty($searchPattern = $restHelper->getSearchPattern())
            && 0 < count($searchFields = $restHelper->getSearchFields())
        ) {
            $boolQuery = new BoolQuery();
            foreach ($searchFields as $searchField) {
                $boolQuery->add(new MatchPhrasePrefixQuery($searchField, $searchPattern), BoolQuery::SHOULD);
            }
            $search->addQuery($boolQuery);
        }

        if (null !== ($type = $request->get('type'))) {
            $search->addQuery(new TermQuery('type', $type));
        }

        if ($contactId = $request->get('contactId')) {
            $boolQuery = new BoolQuery();
            $boolQuery->add(new MatchQuery('changer_contact_id', $contactId), BoolQuery::SHOULD);
            $boolQuery->add(new MatchQuery('creator_contact_id', $contactId), BoolQuery::SHOULD);
            $boolQuery->add(new MatchQuery('author_id', $contactId), BoolQuery::SHOULD);
            $search->addQuery($boolQuery);
        }

        if ($categoryId = $request->get('categoryId')) {
            $search->addQuery(new TermQuery('excerpt.categories.id', $categoryId), BoolQuery::MUST);
        }

        if ($tagId = $request->get('tagId')) {
            $search->addQuery(new TermQuery('excerpt.tags.id', $tagId), BoolQuery::MUST);
        }

        if ($pageId = $request->get('pageId')) {
            $search->addQuery(new TermQuery('parent_page_uuid', $pageId), BoolQuery::MUST);
        }

        if ($workflowStage = $request->get('workflowStage')) {
            $search->addQuery(new TermQuery('published_state', 'published' === $workflowStage), BoolQuery::MUST);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        $authoredFrom = $request->get('authoredFrom');
        $authoredTo = $request->get('authoredTo');
        if ($authoredFrom || $authoredTo) {
            $search->addQuery($this->getRangeQuery('authored', $authoredFrom, $authoredTo), BoolQuery::MUST);
        }

        if (null === $search->getQueries()) {
            $search->addQuery(new MatchAllQuery());
        }

        if (null !== $restHelper->getSortColumn() &&
            $sortField = $this->getSortFieldName($restHelper->getSortColumn())
        ) {
            $search->addSort(
                new FieldSort($sortField, $restHelper->getSortOrder())
            );
        }

        $search->setSize($limit);
        $search->setFrom(($page - 1) * $limit);

        $result = [];
        $searchResult = $repository->findDocuments($search);
        foreach ($searchResult as $document) {
            if (false !== ($index = array_search($document->getUuid(), $ids))) {
                $result[$index] = $document;
            } else {
                $result[] = $document;
            }
        }

        if (count($ids)) {
            ksort($result);
            $result = array_values($result);
        }

        return $this->handleView(
            $this->view(
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                new ListRepresentation(
                    $result,
                    'articles',
                    'get_articles',
                    $request->query->all(),
                    $page,
                    $limit,
                    $searchResult->count()
                )
            )
        );
    }

    /**
     * Returns query to filter by given range.
     *
     * @param string $field
     * @param string $from
     * @param string $to
     *
     * @return RangeQuery
     */
    private function getRangeQuery($field, $from, $to)
    {
        return new RangeQuery($field, array_filter(['gte' => $from, 'lte' => $to]));
    }

    /**
     * Returns single article.
     *
     * @param string  $uuid
     * @param Request $request
     *
     * @return Response
     */
    public function getAction($uuid, Request $request)
    {
        $locale = $this->getRequestParameter($request, 'locale', true);
        $document = $this->getDocumentManager()->find(
            $uuid,
            $locale,
            [
                'load_ghost_content' => true,
                'load_shadow_content' => false,
            ]
        );

        return $this->handleView(
            $this->view($document)->setSerializationContext(

                SerializationContext::create()
                    ->setSerializeNull(true)
                    ->setGroups(['defaultPage', 'defaultArticle', 'smallArticlePage'])
            )
        );
    }

    /**
     * Create article.
     *
     * @param Request $request
     *
     * @return Response
     */
    public function postAction(Request $request)
    {
        $id = Uuid::uuid4()->toString();

        $locale = $this->getRequestParameter($request, 'locale', true);
        $this->getCommandBus()->dispatch(
            new PostArticleCommand(
                [
                    'id' => $id,
                    'locale' => $locale,
                    'userId' => $this->getUser()->getId(),
                    'requestData' => $request->request->all(),
                ]
            )
        );

        $this->handleActionParameter($id, $request->get('action'), $locale);

        $document = $this->getDocumentManager()->find($id, $locale);

        return $this->handleView(
            $this->view($document)->setSerializationContext(

                SerializationContext::create()
                    ->setSerializeNull(true)
                    ->setGroups(['defaultPage', 'defaultArticle', 'smallArticlePage'])
            )
        );
    }

    /**
     * Update articles.
     *
     * @param Request $request
     * @param string  $uuid
     *
     * @return Response
     */
    public function putAction(Request $request, $uuid)
    {
        $locale = $this->getRequestParameter($request, 'locale', true);
        $action = $request->get('action');

        $document = $this->getDocumentManager()->find(
            $uuid,
            $locale,
            [
                'load_ghost_content' => false,
                'load_shadow_content' => false,
            ]
        );

        $this->get('sulu_hash.request_hash_checker')->checkHash($request, $document, $document->getUuid());

        $this->getCommandBus()->dispatch(
            new PutArticleCommand(
                [
                    'id' => $uuid,
                    'locale' => $locale,
                    'userId' => $this->getUser()->getId(),
                    'requestData' => $request->request->all(),
                ]
            )
        );

        $this->handleActionParameter($uuid, $action, $locale);

        $document = $this->getDocumentManager()->find($uuid, $locale);

        return $this->handleView(
            $this->view($document)->setSerializationContext(

                SerializationContext::create()
                    ->setSerializeNull(true)
                    ->setGroups(['defaultPage', 'defaultArticle', 'smallArticlePage'])
            )
        );
    }

    /**
     * Deletes multiple documents.
     *
     * @param Request $request
     *
     * @return Response
     */
    public function cdeleteAction(Request $request)
    {
        $ids = array_filter(explode(',', $request->get('ids', '')));

        foreach ($ids as $id) {
            $this->getCommandBus()->dispatch(
                new DeleteArticleCommand(
                    [
                        'id' => $id,
                        'userId' => $this->getUser()->getId(),
                    ]
                )
            );
        }

        return $this->handleView($this->view(null));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Deletes multiple documents.
     *
     * @param string $id
     *
     * @return Response
     */
    public function deleteAction($id)
    {
        $this->getCommandBus()->dispatch(
            new DeleteArticleCommand(
                [
                    'id' => $id,
                    'userId' => $this->getUser()->getId(),
                ]
            )
        );

        return $this->handleView($this->view(null));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Trigger a action for given article specified over get-action parameter.
     *
     * @Post("/articles/{uuid}")
     *
     * @param string $uuid
     * @param Request $request
     *
     * @return Response
     */
    public function postTriggerAction($uuid, Request $request)
    {
        // extract parameter
        $action = $this->getRequestParameter($request, 'action', true);
        $locale = $this->getRequestParameter($request, 'locale', true);

        // prepare vars
        $view = null;
        $data = null;
        $userId = $this->getUser()->getId();

        try {
            switch ($action) {
                case 'unpublish':
                    $this->getCommandBus()->dispatch(
                        new UnpublishArticleCommand(
                            [
                                'id' => $uuid,
                                'locale' => $locale,
                                'userId' => $this->getUser()->getId(),
                            ]
                        )
                    );

                    $data = $this->getDocumentManager()->find($uuid, $locale);

                    break;
                case 'remove-draft':
                    $data = $this->getDocumentManager()->find($uuid, $locale);
                    $this->getDocumentManager()->removeDraft($data, $locale);
                    $this->getDocumentManager()->flush();

                    break;
                case 'copy-locale':
                    $destLocales = $this->getRequestParameter($request, 'dest', true);
                    $destLocales = explode(',', $destLocales);

                    $securityChecker = $this->get('sulu_security.security_checker');
                    foreach ($destLocales as $destLocale) {
                        $securityChecker->checkPermission(
                            new SecurityCondition($this->getSecurityContext(), $destLocale),
                            PermissionTypes::EDIT
                        );
                    }

                    $this->getMapper()->copyLanguage($uuid, $userId, null, $locale, $destLocales);

                    $data = $this->getDocumentManager()->find($uuid, $locale);

                    break;
                case 'copy':
                    /** @var ArticleDocument $document */
                    $document = $this->getDocumentManager()->find($uuid, $locale);
                    $copiedPath = $this->getDocumentManager()->copy($document, dirname($document->getPath()));
                    $this->getDocumentManager()->flush();

                    $data = $this->getDocumentManager()->find($copiedPath, $locale);

                    break;
                case 'order':
                    $this->orderPages($this->getRequestParameter($request, 'pages', true), $locale);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    $this->getDocumentManager()->flush();
                    $this->getDocumentManager()->clear();

                    $data = $this->getDocumentManager()->find($uuid, $locale);

                    break;
                default:
                    throw new RestException('Unrecognized action: ' . $action);
            }

            // prepare view
            $view = $this->view($data);
            $view->setSerializationContext(

                SerializationContext::create()
                    ->setSerializeNull(true)
                    ->setGroups(['defaultPage', 'defaultArticle', 'smallArticlePage'])
            );
        } catch (RestException $exc) {
            $view = $this->view($exc->toArray(), 400);
        }

        return $this->handleView($view);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * Ordering given pages.
     *
     * @param array $pages
     * @param string $locale
     */
    private function orderPages(array $pages, $locale)
    {
        $documentManager = $this->getDocumentManager();

        for ($i = 0; $i < count($pages); ++$i) {
for ($i=0; $i<count($array); $i++) { // calls count() on each iteration
}

// Better
for ($i=0, $c=count($array); $i<$c; $i++) { // calls count() just once
}
            $document = $documentManager->find($pages[$i], $locale);
            $documentManager->reorder($document, null);
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getSecurityContext()
    {
        return ArticleAdmin::SECURITY_CONTEXT;
    }

    /**
     * Returns document-manager.
     *
     * @return DocumentManagerInterface
     */
    protected function getDocumentManager()
    {
        return $this->get('sulu_document_manager.document_manager');
    }

    /**
     * @return ContentMapperInterface
     */
    protected function getMapper()
    {
        return $this->get('sulu.content.mapper');
    }

    private function handleActionParameter(string $id, ?string $action, string $locale)
    {
        if ($action === 'publish') {
            $this->getCommandBus()->dispatch(
                new PublishArticleCommand(
                    [
                        'id' => $id,
                        'locale' => $locale,
                        'userId' => $this->getUser()->getId(),
                    ]
                )
            );
        }
    }

    /**
     * @param string $sortBy
     *
     * @return null|string
     */
    private function getSortFieldName($sortBy)
    {
        $sortBy = $this->uncamelize($sortBy);
        $fieldDescriptors = $this->getFieldDescriptors();

        if (array_key_exists($sortBy, $fieldDescriptors)) {
            return $fieldDescriptors[$sortBy]->getSortField();
        }

        return null;
    }

    /**
     * Converts camel case string into normalized string with underscore.
     *
     * @param string $camel
     *
     * @return string
     */
    private function uncamelize($camel)
    {
        $camel = preg_replace(
            '/(?!^)[[:upper:]][[:lower:]]/',
            '$0',
            preg_replace('/(?!^)[[:upper:]]+/', '_$0', $camel)
        );

        return strtolower($camel);
    }

    /**
     * @return BaseMetadataFactory
     */
    protected function getMetadataFactory()
    {
        return $this->get('sulu_document_manager.metadata_factory.base');
    }

    protected function getCommandBus()
    {
        $pdo = new \PDO('mysql:dbname=su_article_prooph;host=127.0.0.1', 'root', '');
        $eventStore = new MySqlEventStore(new FQCNMessageFactory(), $pdo, new MySqlAggregateStreamStrategy());
        $eventEmitter = new ProophActionEventEmitter();
        $eventStore = new ActionEventEmitterEventStore($eventStore, $eventEmitter);

        $eventBus = new EventBus($eventEmitter);
        $eventPublisher = new EventPublisher($eventBus);
        $eventPublisher->attachToEventStore($eventStore);

        $pdoSnapshotStore = new PdoSnapshotStore($pdo);
        $userRepository = new ArticleRepository(Article::class, $eventStore, $pdoSnapshotStore);

        $projectionManager = new MySqlProjectionManager($eventStore, $pdo);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        $structureFactory = $this->get('sulu_content.structure.factory');
        $routeGenerator = $this->get('sulu_route.chain_generator');
        $conflictResolver = $this->get('sulu_route.manager.conflict_resolver.auto_increment');

        $commandBus = new CommandBus();
        $router = new CommandRouter();
        $router->route(PostArticleCommand::class)->to(new PostArticleHandler($userRepository, $structureFactory, $routeGenerator, $conflictResolver));
        $router->route(PublishArticleCommand::class)->to(new PublishArticleHandler($userRepository));
        $router->route(UnpublishArticleCommand::class)->to(new UnpublishArticleHandler($userRepository));
        $router->route(PutArticleCommand::class)->to(new PutArticleHandler($userRepository, $structureFactory));
        $router->route(DeleteArticleCommand::class)->to(new DeleteArticleHandler($userRepository));
        $router->attachToMessageBus($commandBus);

        $documentProjector = new ArticleDocumentProjector(
            $this->getDocumentManager(),
            $this->getMetadataFactory(),
            $this->get('form.factory')
        );

        $indexProjector = new ArticleIndexProjector(
            $this->getDocumentManager(),
            $this->get('sulu_article.elastic_search.article_indexer'),
            $this->get('sulu_article.elastic_search.article_live_indexer')
        );

        $eventRouter = new EventRouter();
        $eventRouter->route(CreateTranslation::class)->to([$documentProjector, 'onCreateTranslation']);
        $eventRouter->route(CreateTranslation::class)->to([$indexProjector, 'onCreateTranslation']);
        $eventRouter->route(PublishTranslation::class)->to([$documentProjector, 'onPublishTranslation']);
        $eventRouter->route(PublishTranslation::class)->to([$indexProjector, 'onPublishTranslation']);
        $eventRouter->route(UnpublishTranslation::class)->to([$documentProjector, 'onUnpublishTranslation']);
        $eventRouter->route(UnpublishTranslation::class)->to([$indexProjector, 'onUnpublishTranslation']);
        $eventRouter->route(ModifyTranslationStructure::class)->to([$documentProjector, 'onModifyTranslationStructure']);
        $eventRouter->route(ModifyTranslationStructure::class)->to([$indexProjector, 'onModifyTranslationStructure']);
        $eventRouter->route(RemoveArticle::class)->to([$documentProjector, 'onRemoveArticle']);
        $eventRouter->route(RemoveArticle::class)->to([$indexProjector, 'onRemoveArticle']);
        $eventRouter->attachToMessageBus($eventBus);

        return $commandBus;
    }
}

sulu / SuluArticleBundle

Pull Request — develop (#305)

ArticleController::postAction() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
