contentBlueprintsEvents::__formAction()

Complexity

Conditions	31
Paths	> 20000

Size

Total Lines	259
Code Lines	114

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

<?php
    public function __formAction()
    {
        $fields = $_POST['fields'];
        $this->_errors = array();
        $providers = Symphony::ExtensionManager()->getProvidersOf(iProvider::EVENT);
        $providerClass = null;

        if (trim($fields['name']) == '') {
            $this->_errors['name'] = __('This is a required field');
        } elseif (strpos($fields['name'], '\\') !== false) {
            $this->_errors['name'] = __('This field contains invalid characters') . ' (\\)';
        }

        if (trim($fields['source']) == '') {
            $this->_errors['source'] = __('This is a required field');
        }

        $filters = isset($fields['filters']) ? $fields['filters'] : array();

        // See if a Provided Datasource is saved
        if (!empty($providers)) {
            foreach ($providers as $providerClass => $provider) {
                if ($fields['source'] == call_user_func(array($providerClass, 'getSource'))) {
                    call_user_func_array(array($providerClass, 'validate'), array(&$fields, &$this->_errors));
                    break;
                }

                unset($providerClass);
            }
        }

        $classname = Lang::createHandle($fields['name'], 255, '_', false, true, array('@^[^a-z\d]+@i' => '', '/[^\w-\.]/i' => ''));
        $rootelement = str_replace('_', '-', $classname);
        $extends = 'SectionEvent';

        // Check to make sure the classname is not empty after handlisation.
        if (empty($classname) && !isset($this->_errors['name'])) {
            $this->_errors['name'] = __('Please ensure name contains at least one Latin-based character.', array($classname));
        }

        $file = EVENTS . '/event.' . $classname . '.php';

The constant EVENTS was not found. Maybe you did not declare it correctly or list all dependencies?

        $isDuplicate = false;
        $queueForDeletion = null;

        if ($this->_context[0] == 'new' && is_file($file)) {
            $isDuplicate = true;
        } elseif ($this->_context[0] == 'edit') {
            $existing_handle = $this->_context[1];

            if ($classname != $existing_handle && is_file($file)) {
                $isDuplicate = true;
            } elseif ($classname != $existing_handle) {
                $queueForDeletion = EVENTS . '/event.' . $existing_handle . '.php';
            }
        }

        // Duplicate
        if ($isDuplicate) {
            $this->_errors['name'] = __('An Event with the name %s already exists', array('<code>' . $classname . '</code>'));
        }

        if (empty($this->_errors)) {
            $source = $fields['source'];
            $params = array(
                'rootelement' => $rootelement,
            );

            $about = array(
                'name' => $fields['name'],
                'version' => 'Symphony ' . Symphony::Configuration()->get('version', 'symphony'),
                'release date' => DateTimeObj::getGMT('c'),
                'author name' => Symphony::Author()->getFullName(),
                'author website' => URL,

The constant URL was not found. Maybe you did not declare it correctly or list all dependencies?

                'author email' => Symphony::Author()->get('email')
            );

            // If there is a provider, get their template
            if ($providerClass) {
                $eventShell = file_get_contents(call_user_func(array($providerClass, 'getTemplate')));
            } else {
                $eventShell = file_get_contents($this->getTemplate('blueprints.event'));

It seems like $this->getTemplate('blueprints.event') can also be of type false; however, parameter $filename of file_get_contents() does only seem to accept string, maybe add an additional type check?

                $about['trigger condition'] = $rootelement;
            }

            $this->__injectAboutInformation($eventShell, $about);

            // Replace the name
            $eventShell = str_replace('<!-- CLASS NAME -->', $classname, $eventShell);

            // Build the templates
            if ($providerClass) {
                $eventShell = call_user_func(array($providerClass, 'prepare'), $fields, $params, $eventShell);
            } else {
                $this->__injectFilters($eventShell, $filters);

                // Add Documentation
                $ajaxEventDoc = new contentAjaxEventDocumentation();
                $doc_parts = array();

                // Add Documentation (Success/Failure)
                $ajaxEventDoc->addEntrySuccessDoc($doc_parts, $rootelement, $filters);
                $ajaxEventDoc->addEntryFailureDoc($doc_parts, $rootelement, $filters);

                // Filters
                $ajaxEventDoc->addDefaultFiltersDoc($doc_parts, $rootelement, $filters);

                // Frontend Markup
                $ajaxEventDoc->addFrontendMarkupDoc($doc_parts, $rootelement, $fields['source'], $filters);
                $ajaxEventDoc->addSendMailFilterDoc($doc_parts, $filters);

                /**
                 * Allows adding documentation for new filters. A reference to the $documentation
                 * array is provided, along with selected filters
                 * @delegate AppendEventFilterDocumentation
                 * @param string $context
                 * '/blueprints/events/(edit|new|info)/'
                 * @param array $selected
                 *  An array of all the selected filters for this Event
                 * @param array $documentation
                 *  An array of all the documentation XMLElements, passed by reference
                 * @param string $rootelment
                 *  The name of this event, as a handle.
                 */
                Symphony::ExtensionManager()->notifyMembers('AppendEventFilterDocumentation', '/blueprints/events/', array(
                    'selected' => $filters,
                    'documentation' => &$doc_parts,
                    'rootelement' => $rootelement
                ));

                $documentation = join(PHP_EOL, array_map(function($part) {
                    return rtrim($part->generate(true, 4));
                }, $doc_parts));
                $documentation = str_replace('\'', '\\\'', $documentation);

                $eventShell = str_replace('<!-- CLASS EXTENDS -->', $extends, $eventShell);
                $eventShell = str_replace('<!-- DOCUMENTATION -->', General::tabsToSpaces($documentation, 4), $eventShell);
            }

            $eventShell = str_replace('<!-- ROOT ELEMENT -->', $rootelement, $eventShell);
            $eventShell = str_replace('<!-- CLASS NAME -->', $classname, $eventShell);
            $eventShell = str_replace('<!-- SOURCE -->', addslashes($source), $eventShell);

            // Remove left over placeholders
            $eventShell = preg_replace(array('/<!--[\w ]++-->/'), '', $eventShell);

            if ($this->_context[0] == 'new') {
                /**
                 * Prior to creating an Event, the file path where it will be written to
                 * is provided and well as the contents of that file.
                 *
                 * @delegate EventsPreCreate
                 * @since Symphony 2.2
                 * @param string $context
                 * '/blueprints/events/'
                 * @param string $file
                 *  The path to the Event file
                 * @param string $contents
                 *  The contents for this Event as a string passed by reference
                 * @param array $filters
                 *  An array of the filters attached to this event
                 */
                Symphony::ExtensionManager()->notifyMembers('EventPreCreate', '/blueprints/events/', array(
                    'file' => $file,
                    'contents' => &$eventShell,
                    'filters' => $filters
                ));
            } else {
                /**
                 * Prior to editing an Event, the file path where it will be written to
                 * is provided and well as the contents of that file.
                 *
                 * @delegate EventPreEdit
                 * @since Symphony 2.2
                 * @param string $context
                 * '/blueprints/events/'
                 * @param string $file
                 *  The path to the Event file
                 * @param string $contents
                 *  The contents for this Event as a string passed by reference
                 * @param array $filters
                 *  An array of the filters attached to this event
                 */
                Symphony::ExtensionManager()->notifyMembers('EventPreEdit', '/blueprints/events/', array(
                    'file' => $file,
                    'contents' => &$eventShell,
                    'filters' => $filters
                ));
            }

            // Write the file
            if (!General::writeFile($file, $eventShell, Symphony::Configuration()->get('write_mode', 'file'))) {

It seems like Symphony::Configuration()->get('write_mode', 'file') can also be of type array; however, parameter $perm of General::writeFile() does only seem to accept integer|string, maybe add an additional type check?

                $this->pageAlert(
                    __('Failed to write Event to disk.')
                    . ' ' . __('Please check permissions on %s.', array('<code>/workspace/events</code>')),
                    Alert::ERROR
                );

                // Write successful
            } else {
                if (function_exists('opcache_invalidate')) {
                    opcache_invalidate($file, true);
                }

                // Attach this event to pages
                $connections = $fields['connections'];
                ResourceManager::setPages(ResourceManager::RESOURCE_TYPE_EVENT, is_null($existing_handle) ? $classname : $existing_handle, $connections);

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

                if ($queueForDeletion) {
                    General::deleteFile($queueForDeletion);

                    $pages = PageManager::fetch(false, array('events', 'id'), array("
                        `events` REGEXP '[[:<:]]" . $existing_handle . "[[:>:]]'
                    "));

                    if (is_array($pages) && !empty($pages)) {
                        foreach ($pages as $page) {
                            $page['events'] = preg_replace('/\b'.$existing_handle.'\b/i', $classname, $page['events']);

                            PageManager::edit($page['id'], $page);
                        }
                    }
                }

                if ($this->_context[0] == 'new') {
                    /**
                     * After creating the Event, the path to the Event file is provided
                     *
                     * @delegate EventPostCreate
                     * @since Symphony 2.2
                     * @param string $context
                     * '/blueprints/events/'
                     * @param string $file
                     *  The path to the Event file
                     */
                    Symphony::ExtensionManager()->notifyMembers('EventPostCreate', '/blueprints/events/', array(
                        'file' => $file
                    ));
                } else {
                    /**
                     * After editing the Event, the path to the Event file is provided
                     *
                     * @delegate EventPostEdit
                     * @since Symphony 2.2
                     * @param string $context
                     * '/blueprints/events/'
                     * @param string $file
                     *  The path to the Event file
                     * @param string $previous_file
                     *  The path of the previous Event file in the case where an Event may
                     *  have been renamed. To get the handle from this value, see
                     *  `EventManager::__getHandleFromFilename`
                     */
                    Symphony::ExtensionManager()->notifyMembers('EventPostEdit', '/blueprints/events/', array(
                        'file' => $file,
                        'previous_file' => ($queueForDeletion) ? $queueForDeletion : null
                    ));
                }

                redirect(SYMPHONY_URL . '/blueprints/events/edit/'.$classname.'/'.($this->_context[0] == 'new' ? 'created' : 'saved') . '/');

The constant SYMPHONY_URL was not found. Maybe you did not declare it correctly or list all dependencies?

            }