lekoala / silverstripe-common-extensions

src/URLSegmentExtension.php

<?php

namespace LeKoala\CommonExtensions;

use SilverStripe\Control\Director;
use SilverStripe\ORM\DataObject;
use SilverStripe\Forms\FieldList;
use SilverStripe\ORM\DataExtension;
use SilverStripe\ORM\ValidationResult;
use SilverStripe\View\Parsers\URLSegmentFilter;

/**
 * URL Segment extension
 *
 * By default link will be applied WITHOUT actions
 *
 * @property DataObject $owner
 * @property string $URLSegment
 */
class URLSegmentExtension extends DataExtension
{
    private static $db = [

The private property $db is not used, and could be removed.

        "URLSegment" => "Varchar(191)",
    ];
    private static $indexes = [

The private property $indexes is not used, and could be removed.

        "URLSegmentUnique" => [
            "type" => "unique",
            "columns" => ["URLSegment"]
        ],
    ];

    /**
     * Get a class by URLSegment
     *
     * @param string $class
     * @param string $URLSegment
     * @return DataObject
     */
    public static function getByURLSegment($class, $URLSegment)
    {
        return $class::get()->filter('URLSegment', $URLSegment)->first();
    }

    public function updateCMSFields(FieldList $fields)
    {
        $URLSegment = $fields->dataFieldByName('URLSegment');
        if ($URLSegment) {
            $URLSegment->setTitle(_t('URLSegmentExtension.URLSEGMENT', 'URL Segment'));

            $Title = $fields->dataFieldByName('Title');
            if ($Title) {
                $fields->insertAfter('Title', $URLSegment);
            }
        }
    }

    /**
     * @return boolean
     */
    public function isSearchable()
    {
        return $this->owner->hasMethod('Page');
    }

    /**
     * We have this link method by default that allows us to define
     * a link for this record
     *
     * You can define your own methods in your DataObject class
     *
     * @param string $action
     * @return string
     */
    public function Link($action = null)
    {
        $url = $this->owner->Page()->Link($this->owner->URLSegment);
        if ($action) {
            $url .= "/$action";
        }
        return $url;
    }

    /**
     * @return string
     */
    public function AbsoluteLink()
    {
        return Director::absoluteURL($this->Link());

The expression return SilverStripe\Control\Director::absoluteURL($this->Link()) could also return false which is incompatible with the documented return type string. Did you maybe forget to handle an error condition?

    }

    /**
     * Cannot use the same url segment
     *
     * @param ValidationResult $validationResult
     * @return void
     */
    public function validate(ValidationResult $validationResult)
    {
        $duplicate = $this->getDuplicateRecord();
        if ($duplicate) {

$duplicate is of type SilverStripe\ORM\DataObject, thus it always evaluated to true.

            $validationResult->addFieldError("URLSegment", "Segment already used by record #" . $duplicate->ID);
        }
    }

    /**
     * Find another record with the same url segment
     *
     * @param string $segment
     * @return DataObject
     */
    public function getDuplicateRecord($segment = null)
    {
        if ($segment === null) {
            $segment = $this->owner->URLSegment;
        }
        if (!$segment) {
            return false;

The expression return false returns the type false which is incompatible with the documented return type SilverStripe\ORM\DataObject.

        }
        $class = get_class($this->owner);
        return $class::get()->exclude('ID', $this->owner->ID)->filter("URLSegment", $segment)->first();
    }

    /**
     * This method allows you to customize url segment generation
     *
     * By default, URL segment is based on page title
     *
     * @return string
     */
    public function getBaseURLSegment()
    {
        $segment = $this->owner->getTitle();
        if ($this->owner->hasMethod('updateURLSegment')) {
            $this->owner->updateURLSegment($segment);
        }
        $filter = new URLSegmentFilter();
        $baseSegment = $filter->filter($segment);
        if (is_numeric($baseSegment)) {
            return false;

The expression return false returns the type false which is incompatible with the documented return type string.

        }
        return $baseSegment;
    }

    /**
     * Generate a new url segment and checks for duplicates
     *
     * @return string
     */
    public function generateURLSegment()
    {
        $baseSegment = $segment = $this->getBaseURLSegment();
        if (!$baseSegment) {
            return;
        }
        $duplicate = $this->getDuplicateRecord($segment);
        $i = 0;
        while ($duplicate) {
            $i++;
            $segment = $baseSegment . '-' . $i;
            $duplicate = $this->getDuplicateRecord($segment);
        }
        return $segment;
    }

    public function onBeforeWrite()
    {
        // Generate segment if no segment
        if (!$this->owner->URLSegment && $this->getBaseURLSegment()) {
            $this->owner->URLSegment = $this->generateURLSegment();
        }
    }
}