AuthorDatasource

Complexity

Total Complexity

41

Size/Duplication

Total Lines	163
Duplicated Lines	0 %

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
F	execute()	0	142	37
A	__processAuthorFilter()	0	17	4

<?php

/**
 * @package data-sources
 */
/**
 * The `AuthorDatasource` extends the base `Datasource` class and allows
 * the retrieval of Author information from the current Symphony installation.
 *
 * @since Symphony 2.3
 */
class AuthorDatasource extends Datasource
{
    public function __processAuthorFilter($field, $filter)
    {
        if (!is_array($filter)) {
            $bits = preg_split('/,\s*/', $filter, -1, PREG_SPLIT_NO_EMPTY);
            $bits = array_map('trim', $bits);

It seems like $bits can also be of type false; however, parameter $arr1 of array_map() does only seem to accept array, maybe add an additional type check?

        } else {
            $bits = $filter;
        }

        $authors = Symphony::Database()->fetchCol('id', sprintf("
                SELECT `id` FROM `tbl_authors`
                WHERE `%s` IN ('%s')",
                $field,
                implode("', '", $bits)
        ));

        return (is_array($authors) && !empty($authors) ? $authors : null);
    }

    public function execute(array &$param_pool = null)

Incorrect spacing between argument "$param_pool" and equals sign; expected 0 but found 1

Incorrect spacing between default value and equals sign for argument "$param_pool"; expected 0 but found 1

    {
        $author_ids = array();

        if (is_array($this->dsParamFILTERS) && !empty($this->dsParamFILTERS)) {
            foreach ($this->dsParamFILTERS as $field => $value) {
                if (!is_array($value) && trim($value) == '') {
                    continue;
                }

                $ret = $this->__processAuthorFilter($field, $value);

                if (empty($ret)) {
                    $author_ids = array();
                    break;
                }

                if (empty($author_ids)) {
                    $author_ids = $ret;
                    continue;
                }

                $author_ids = array_intersect($author_ids, $ret);
            }

            $authors = AuthorManager::fetchByID(array_values($author_ids));
        } else {
            $authors = AuthorManager::fetch($this->dsParamSORT, $this->dsParamORDER);
        }

        if ((!is_array($authors) || empty($authors)) && $this->dsParamREDIRECTONEMPTY === 'yes') {

The property dsParamREDIRECTONEMPTY does not exist on AuthorDatasource. Did you maybe forget to declare it?

            throw new FrontendPageNotFoundException;
        } elseif (!is_array($authors) || empty($authors)) {
            $result = $this->emptyXMLSet();
            return $result;
        } else {
            if ($this->_negate_result === true) {
                return $this->negateXMLSet();
            }

            if (!$this->_param_output_only) {
                $result = new XMLElement($this->dsParamROOTELEMENT);

The property dsParamROOTELEMENT does not exist on AuthorDatasource. Did you maybe forget to declare it?

            }

            $singleParam = false;
            $key = 'ds-' . $this->dsParamROOTELEMENT;

            if (isset($this->dsParamPARAMOUTPUT)) {
                if (!is_array($this->dsParamPARAMOUTPUT)) {
                    $this->dsParamPARAMOUTPUT = array($this->dsParamPARAMOUTPUT);

The property dsParamPARAMOUTPUT does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

                }

                $singleParam = count($this->dsParamPARAMOUTPUT) === 1;
            }

            foreach ($authors as $author) {
                if (isset($this->dsParamPARAMOUTPUT)) {
                    foreach ($this->dsParamPARAMOUTPUT as $param) {
                        // The new style of paramater is `ds-datasource-handle.field-handle`
                        $param_key = $key . '.' . str_replace(':', '-', $param);

                        if (!is_array($param_pool[$param_key])) {
                            $param_pool[$param_key] = array();
                        }

                        $param_pool[$param_key][] = ($param === 'name' ? $author->getFullName() : $author->get($param));

Inline shorthand IF statement requires brackets around comparison

                        if ($singleParam) {
                            if (!is_array($param_pool[$key])) {
                                $param_pool[$key] = array();
                            }

                            $param_pool[$key][] = ($param === 'name' ? $author->getFullName() : $author->get($param));

Inline shorthand IF statement requires brackets around comparison

                        }
                    }
                }

                if ($this->_param_output_only) {
                    continue;
                }

                $xAuthor = new XMLElement('author');
                $xAuthor->setAttributeArray(array(
                    'id' => $author->get('id'),
                    'user-type' => $author->get('user_type'),
                    'primary-account' => $author->get('primary')
                ));

                // No included elements, so just create the Author XML
                if (!isset($this->dsParamINCLUDEDELEMENTS) || !is_array($this->dsParamINCLUDEDELEMENTS) || empty($this->dsParamINCLUDEDELEMENTS)) {
                    $result->appendChild($xAuthor);

The variable $result does not seem to be defined for all execution paths leading up to this point.

                } else {
                    // Name
                    if (in_array('name', $this->dsParamINCLUDEDELEMENTS)) {
                        $xAuthor->appendChild(
                            new XMLElement('name', $author->getFullName())
                        );
                    }

                    // Username
                    if (in_array('username', $this->dsParamINCLUDEDELEMENTS)) {
                        $xAuthor->appendChild(
                            new XMLElement('username', $author->get('username'))
                        );
                    }

                    // Email
                    if (in_array('email', $this->dsParamINCLUDEDELEMENTS)) {
                        $xAuthor->appendChild(
                            new XMLElement('email', $author->get('email'))
                        );
                    }

                    // Author Token
                    if (in_array('author-token', $this->dsParamINCLUDEDELEMENTS) && $author->isTokenActive()) {
                        $xAuthor->appendChild(
                            new XMLElement('author-token', $author->createAuthToken())
                        );
                    }

                    // Default Area
                    if (in_array('default-area', $this->dsParamINCLUDEDELEMENTS) && !is_null($author->get('default_area'))) {
                        // Section
                        if ($section = SectionManager::fetch($author->get('default_area'))) {
                            $default_area = new XMLElement('default-area', $section->get('name'));

It seems like $section->get('name') can also be of type array; however, parameter $value of XMLElement::__construct() does only seem to accept XMLElement|string, maybe add an additional type check?

                            $default_area->setAttributeArray(array('id' => $section->get('id'), 'handle' => $section->get('handle'), 'type' => 'section'));
                            $xAuthor->appendChild($default_area);

                            // Pages
                        } else {
                            $default_area = new XMLElement('default-area', $author->get('default_area'));
                            $default_area->setAttribute('type', 'page');
                            $xAuthor->appendChild($default_area);
                        }
                    }

                    $result->appendChild($xAuthor);
                }
            }
        }

        return $result;
    }
}