SilverStripe\DocumentConverter\ImportField::importFromPOST()

Complexity

Conditions	33
Paths	> 20000

Size

Total Lines	225
Code Lines	136

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

<?php
    public function importFromPOST($tmpFile, $splitHeader = false, $publishPages = false, $chosenFolderID = null)
    {

        $fileDescriptor = [
            'name' => $tmpFile['name'],
            'path' => $tmpFile['tmp_name'],
            'mimeType' => $tmpFile['type']
        ];

        $sourcePage = $this->form->getRecord();
        $importerClass = $this->config()->get('importer_class');
        $importer = Injector::inst()->create($importerClass, $fileDescriptor, $chosenFolderID);
        $content = $importer->import();

        if (is_array($content) && isset($content['error'])) {
            return $content;
        }

        // Clean up with tidy (requires tidy module)
        $tidy = new Tidy();
        $tidy->parseString($content, ['output-xhtml' => true], 'utf8');
        $tidy->cleanRepair();

        $fragment = [];
        foreach ($tidy->body()->child as $child) {
            $fragment[] = $child->value;
        }

        $htmlValue = Injector::inst()->create(HTMLValue::class, implode("\n", $fragment));

        // Sanitise
        $santiser = Injector::inst()->create(HTMLEditorSanitiser::class, HTMLEditorConfig::get_active());
        $santiser->sanitise($htmlValue);

        // Load in the HTML
        $doc = $htmlValue->getDocument();
        $xpath = new DOMXPath($doc);

        // make sure any images are added as Image records with a relative link to assets
        $chosenFolder = ($this->chosenFolderID) ? DataObject::get_by_id(Folder::class, $this->chosenFolderID) : null;

The property chosenFolderID does not exist on SilverStripe\DocumentConverter\ImportField. Since you implemented __get, consider adding a @property annotation.

        $folderName = ($chosenFolder) ? '/' . $chosenFolder->Name : '';
        $imgs = $xpath->query('//img');
        for ($i = 0; $i < $imgs->length; $i++) {
            $img = $imgs->item($i);
            $originalPath = 'assets/' . $folderName . '/' . $img->getAttribute('src');
            $name = FileNameFilter::create()->filter(basename($originalPath));

            $image = Image::get()->filter([
                'Name' => $name,
                'ParentID' => (int)$chosenFolderID
            ])->first();
            if (!($image && $image->exists())) {
                $image = Image::create();
                $image->ParentID = (int)$chosenFolderID;
                $image->Name = $name;
                $image->write();
            }

            // make sure it's put in place correctly so Image record knows where it is.
            // e.g. in the case of underscores being renamed to dashes.
            @rename(Director::getAbsFile($originalPath), Director::getAbsFile($image->getFilename()));

It seems like you do not handle an error condition for rename(). This can introduce security issues, and is generally not recommended.

            $img->setAttribute('src', $image->getFilename());
        }

        $remove_rules = [
            // Change any headers that contain font tags (other than font face tags) into p elements
            '//h1[.//font[not(@face)]]' => 'p',
            // Remove any font tags
            '//font'
        ];

        foreach ($remove_rules as $rule => $parenttag) {
            if (is_numeric($rule)) {
                $rule = $parenttag;
                $parenttag = null;
            }

            $nodes = [];
            foreach ($xpath->query($rule) as $node) {
                $nodes[] = $node;
            }

            foreach ($nodes as $node) {
                $parent = $node->parentNode;

                if ($parenttag) {

The expression $parenttag of type null|string is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

                    $parent = $doc->createElement($parenttag);
                    $node->nextSibling ?
                        $node->parentNode->insertBefore($parent, $node->nextSibling) :
                        $node->parentNode->appendChild($parent);
                }

                while ($node->firstChild) {
                    $parent->appendChild($node->firstChild);
                }
                $node->parentNode->removeChild($node);
            }
        }

        // Strip style, class, lang attributes.
        $els = $doc->getElementsByTagName('*');
        for ($i = 0; $i < $els->length; $i++) {
            $el = $els->item($i);
            $el->removeAttribute('class');
            $el->removeAttribute('style');
            $el->removeAttribute('lang');
        }

        $els = $doc->getElementsByTagName('*');

The assignment to $els is dead and can be removed.

        $headingXPath = [
            'self::h1',
            'self::h2',
            'self::h3',
            'self::h4',
            'self::h5',
            'self::h6',
        ];
        // Remove a bunch of unwanted elements
        $clean = [
            // Empty paragraphs
            '//p[not(descendant-or-self::text() | descendant-or-self::img)]',
            // Empty headers
            '//*[' . implode(' | ', $headingXPath) . '][not(descendant-or-self::text() | descendant-or-self::img)]',
            // Anchors
            '//a[not(@href)]',
            // BR tags
            '//br'
        ];

        foreach ($clean as $query) {
            // First get all the nodes. Need to build array, as they'll disappear from the
            // nodelist while we're deleteing them, causing the indexing to screw up.
            $nodes = [];
            foreach ($xpath->query($query) as $node) {
                $nodes[] = $node;
            }

            // Then remove them all
            foreach ($nodes as $node) {
                if ($node->parentNode) {
                    $node->parentNode->removeChild($node);
                }
            }
        }

        // Now split the document into portions by H1
        $body = $doc->getElementsByTagName('body')->item(0);

        $this->unusedChildren = [];

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

        foreach ($sourcePage->Children() as $child) {
            $this->unusedChildren[$child->ID] = $child;
        }

        $documentImporterFieldError = false;

        $documentImporterFieldErrorHandler = function (
            $errno,

The parameter $errno is not used and could be removed.

            $errstr,

The parameter $errstr is not used and could be removed.

            $errfile,

The parameter $errfile is not used and could be removed.

            $errline

The parameter $errline is not used and could be removed.

        ) use ($documentImporterFieldError) {

The import $documentImporterFieldError is not used and could be removed.

            $documentImporterFieldError = _t(

The assignment to $documentImporterFieldError is dead and can be removed.

                'SilverStripe\\DocumentConverter\\ServiceConnector.PROCESSFAILED',
                'Could not process document, please double-check you uploaded a .doc or .docx format.',
                'Document Converter processes Word documents into HTML.'
            );

            // Do not cascade the error through other handlers
            return true;
        };

        set_error_handler($documentImporterFieldErrorHandler);

        $subtitle = null;
        $subdoc = new DOMDocument();

The call to DOMDocument::__construct() has too few arguments starting with version.

        $subnode = $subdoc->createElement('body');
        $node = $body->firstChild;
        $sort = 1;
        if ($splitHeader == 1 || $splitHeader == 2) {
            while ($node && !$documentImporterFieldError) {
                if ($node instanceof DOMElement && $node->tagName == 'h' . $splitHeader) {
                    if ($subnode->hasChildNodes()) {
                        $this->writeContent($subtitle, $subdoc, $subnode, $sort, $publishPages);
                        $sort++;
                    }

                    $subdoc = new DOMDocument();
                    $subnode = $subdoc->createElement('body');
                    $subtitle = trim(preg_replace('/\n|\r/', '', Convert::html2raw($node->textContent)));
                } else {
                    $subnode->appendChild($subdoc->importNode($node, true));
                }

                $node = $node->nextSibling;
            }
        } else {
            $this->writeContent($subtitle, $subdoc, $body, null, $publishPages);
        }

        if ($subnode->hasChildNodes() && !$documentImporterFieldError) {
            $this->writeContent($subtitle, $subdoc, $subnode, null, $publishPages);
        }

        restore_error_handler();
        if ($documentImporterFieldError) {
            return ['error' => $documentImporterFieldError];
        }

        foreach ($this->unusedChildren as $child) {
            $origStage = Versioned::current_stage();

The method current_stage() does not exist on SilverStripe\Versioned\Versioned.

            Versioned::reading_stage('Stage');

The method reading_stage() does not exist on SilverStripe\Versioned\Versioned.

            $draft = clone $child;
            $draft->delete();

            Versioned::reading_stage('Live');
            $published = clone $child;
            $published->delete();

            Versioned::reading_stage($origStage);
        }

        $sourcePage->write();
    }