Subversion Repositories web.creative

<?php namespace ProcessWire;

/**
 * ProcessWire Page Path History
 *
 * Keeps track of past URLs where pages have lived and automatically 301 redirects
 * to the new location whenever the past URL is accessed. 
 *
 * ProcessWire 3.x, Copyright 2019 by Ryan Cramer
 * https://processwire.com
 * 
 * @method upgrade($fromVersion, $toVersion)
 * @property int $minimumAge
 * 
 *
 */

class PagePathHistory extends WireData implements Module, ConfigurableModule {

  public static function getModuleInfo() {
    return array(
      'title' => 'Page Path History', 
      'version' => 5, 
      'summary' => "Keeps track of past URLs where pages have lived and automatically redirects (301 permament) to the new location whenever the past URL is accessed.",
      'singular' => true, 
      'autoload' => true, 
      );
  }

  /**
   * Table created by this module
   *
   */
  const dbTableName = 'page_path_history';

  /**
   * Minimum age in seconds that a page must be before we'll bother remembering its previous path
   *
   */
  const minimumAge = 120; 

  /**
   * Maximum segments to support in a redirect URL
   *
   * Used to place a limit on recursion and paths
   *
   */
  const maxSegments = 10;

  /**
   * PagePageHistory module/schema version
   * 
   * @var int
   * 
   */
  protected $version = 0;

  /**
   * Construct
   * 
   */
  public function __construct() {
    parent::__construct();
    $this->set('minimumAge', self::minimumAge); 
  }

  /**
   * Initialize the hooks
   *
   */
  public function init() {
    $this->pages->addHook('moved', $this, 'hookPageMoved'); 
    $this->pages->addHook('renamed', $this, 'hookPageMoved'); 
    $this->pages->addHook('deleted', $this, 'hookPageDeleted');
    $this->addHook('ProcessPageView::pageNotFound', $this, 'hookPageNotFound'); 
    $this->addHook('Page::addUrl', $this, 'hookPageAddUrl');
    $this->addHook('Page::removeUrl', $this, 'hookPageRemoveUrl');
  }

  /**
   * Get version of this module/schema
   * 
   * @return int
   * 
   */
  protected function getVersion() {
    if($this->version) return $this->version;
    $this->version = $this->wire('modules')->getModuleInfoProperty($this, 'version');
    if(!$this->version) $this->version = 1;
    return $this->version;
  }

  /**
   * Whether or not to consider language_id in page_path_history module table
   * 
   * @return Languages|bool Returns Languages object if yes, or boolean false if not
   * 
   */
  protected function getLanguages() {
    if($this->getVersion() < 2) return false;
    if(!$this->wire('modules')->isInstalled('LanguageSupportPageNames')) return false;
    return $this->wire('languages');
  }

  /**
   * Given a language ID, name or Language object, return Language object or NULL if not found
   * 
   * @param int|string|Language $language
   * @return Language|null
   * 
   */
  protected function getLanguage($language) {
    $languages = $this->getLanguages();
    if(!$languages) return null;
    if($language instanceof Page) {
      // ok
    } else if($language === 0) {
      $language = $languages->getDefault();
    } else if(is_int($language) || ctype_digit($language)) {
      $language = $languages->get((int) $language);
    } else if(is_string($language) && $language) {
      $language = $languages->get($this->wire('sanitizer')->pageNameUTF8($language));
    }
    if($language && !$language->id) $language = null;
    return $language;
  }

  /**
   * Set a history path for a page and delete any existing entries for page’s current path
   * 
   * @param Page $page
   * @param string $path
   * @param Language|int $language
   * @return bool True on success, or false if path already consumed in history
   *
   */
  public function setPathHistory(Page $page, $path, $language = null) {
    
    $database = $this->wire('database');
    $table = self::dbTableName;
    $result = $this->addPathHistory($page, $path, $language);
    
    if($result) {
      // delete any possible entries that overlap with the $page current path since are no longer applicable
      $query = $database->prepare("DELETE FROM $table WHERE path=:path LIMIT 1");
      $query->bindValue(":path", rtrim($this->wire('sanitizer')->pagePathName($page->path, Sanitizer::toAscii), '/'));
      $query->execute();
    }
    
    return $result;
  }

  /**
   * Add a history path for a page
   * 
   * @param Page $page
   * @param string $path
   * @param null|Language $language
   * @return bool True if path was added, or false if it likely overlaps with an existing path
   * 
   */
  public function addPathHistory(Page $page, $path, $language = null) {
    
    $database = $this->wire('database');
    $table = self::dbTableName;
    $path = $this->wire('sanitizer')->pagePathName('/' . trim($path, '/'), Sanitizer::toAscii);
    
    $selector = "path=$path";
    if($this->wire('modules')->isInstalled('PagePaths')) $selector .= ", id!=$page->id";
    if($this->wire('pages')->count($selector)) return false; 
    
    $language = $this->getLanguage($language);

    $sql = "INSERT INTO $table SET path=:path, pages_id=:pages_id, created=NOW()";
    if($language) $sql .= ', language_id=:language_id';

    $query = $database->prepare($sql);
    $query->bindValue(":path", $path);
    $query->bindValue(":pages_id", $page->id, \PDO::PARAM_INT);
    if($language) $query->bindValue(':language_id', $language->id, \PDO::PARAM_INT);

    try {
      $result = $query->execute();
    } catch(\Exception $e) {
      // ignore the exception because it means there is already a past URL (duplicate)
      $result = false;
    }
    
    return $result;
  }
  
  /**
   * Delete path entry for given page and path
   * 
   * @param Page $page
   * @param string $path
   * @return int
   * 
   */
  public function deletePathHistory(Page $page, $path) {
    
    $database = $this->wire('database');
    $table = self::dbTableName;
    $path = $this->wire('sanitizer')->pagePathName('/' . trim($path, '/'), Sanitizer::toAscii);
    
    $sql = "DELETE FROM $table WHERE path=:path AND pages_id=:pages_id LIMIT 1";
    $query = $database->prepare($sql);
    $query->bindValue(':path', $path);
    $query->bindValue(':pages_id', $page->id, \PDO::PARAM_INT);
    $query->execute();
    
    $cnt = $query->rowCount();
    $query->closeCursor();
    
    return $cnt;
  }
  
  /**
   * Get an array of all paths the given page has previously had, oldest to newest
   *
   * For the options argument: 
   * - Optionally specify a Language instance (or name or ID) to isolate results to a specific language.
   * - Optionally specify boolean true to return verbose info. 
   * 
   * @param Page $page Page to retrieve paths for. 
   * @param Language|null|array|bool Specify an option below: 
   *  - `language` (Language|int|string): Limit returned paths to this language. If none specified, then all languages are included.
   *  - `verbose` (bool): Return associative array for each path with additional info (date and language, if present).
   *  - `virtual` (bool): Return history that includes auto-determined virtual entries from parent history? (default=true)
   *     What this does is also include changes to parent pages that would affect overall URL to requested page. 
   *  - Or you may specify the `language` option for the options argument. 
   *  - Or you may specify boolean `true` for options argument as a shortcut for the `verbose` option. 
   * @return array of paths
   * 
   */
  public function getPathHistory(Page $page, $options = array()) {
    
    static $level = 0;
    $level++;
    
    $defaults = array(
      'language' => !is_array($options) && !is_bool($options) ? $options : null, 
      'verbose' => is_bool($options) ? $options : false, 
      'virtual' => true, 
    );
    
    /** @var WireDatabasePDO $database */
    $database = $this->wire('database');
    
    /** @var Sanitizer $sanitizer */
    $sanitizer = $this->wire('sanitizer');
    
    $paths = array();
    $options = is_array($options) ? array_merge($defaults, $options) : $defaults;
    
    if($this->getVersion() < 2) {
      $options['language'] = null;
      $allowLanguage = false;
    } else {
      $allowLanguage = $this->wire('languages') && $this->wire('modules')->isInstalled('LanguageSupportPageNames');
    }
    
    $language = $options['language'] && $allowLanguage ? $this->getLanguage($options['language']) : null;
    $finds = array('pages_id' => $page->id);
    $selects = array('path');
    $wheres = array();
    
    if($options['verbose']) $selects[] = 'created';
    if($options['verbose'] && $allowLanguage) $selects[] = 'language_id';
    if($language) $finds['language_id'] = $language->isDefault() ? 0 : $language->id;
    
    foreach($finds as $col => $value) {
      $wheres[] = "$col=:$col";
    }
  
    $query = $database->prepare(
      'SELECT ' . implode(', ', $selects) . ' FROM ' . self::dbTableName . ' ' . 
      'WHERE ' . implode(' AND ', $wheres) . ' ' . 
      "ORDER BY created"
    );
    
    foreach($finds as $col => $value) {
      $query->bindValue(":$col", $value, \PDO::PARAM_INT); 
    }
    
    try {
      $query->execute();
      
      /** @noinspection PhpAssignmentInConditionInspection */
      while($row = $query->fetch(\PDO::FETCH_ASSOC)) {
        
        $path = $sanitizer->pagePathName($row['path'], Sanitizer::toUTF8);
        
        if($options['verbose']) {
          $value = array('path' => $path);
          $pathDate = $row['created'];
          $value['date'] = $pathDate;
          if($allowLanguage && isset($row['language_id'])) {
            $pathLanguage = $this->getLanguage((int) $row['language_id']);
            $value['language'] = $pathLanguage && $pathLanguage->id ? $pathLanguage : null;
          }
        } else {
          $value = $path;
        }
        
        $paths[$path] = $value;
      }
    } catch(\Exception $e) {
      // intentionally blank
    }
    
    if($options['virtual']) {
      // get changes to current and previous parents as well
      foreach($paths as $value) {
        $virtualPaths = $this->getVirtualHistory($page, $value, $options);
        foreach($virtualPaths as $virtualPath => $virtualInfo) {
          if(isset($paths[$virtualPath])) continue;
          $paths[$virtualPath] = $virtualInfo;
        }
      }
      if($level === 1 && $options['verbose']) {
        $paths = $this->sortVerbosePathInfo($paths); 
      }
    } 
  
    $level--;
    
    return array_values($paths);
  }

  /**
   * Sort verbose paths by date
   * 
   * @param array $paths Verbose paths
   * @param bool $newest Sort newest to oldest? Specify false so sort oldest to newest. (default=true)
   * @return array
   * 
   */
  protected function sortVerbosePathInfo(array $paths, $newest = true) {
    
    $sortPaths = array();
    
    foreach($paths as $value) {
      $date = strtotime($value['date']);
      while(isset($sortPaths[$date])) $date++;
      $sortPaths[$date] = $value;
    }
    
    if($newest) {
      krsort($sortPaths);
    } else {
      ksort($sortPaths);
    }
    
    return $sortPaths;
  }

  /**
   * Get history which includes entries not actually in pages_paths table reflecting changes to parents
   * 
   * @param Page $page
   * @param string|array $path
   * @param array $options
   *
   * @return array
   * 
   */
  protected function getVirtualHistory(Page $page, $path, array $options) {
    
    $paths = array();
    $checkParents = array();
    
    if(is_array($path)) {
      // path is verbose info
      $pathInfo = $path;
      $path = $pathInfo['path'];
    } else {
      // path is string
      $pathInfo = array('path');
    }
  
    // separate page name and parent path
    $parts = explode('/', trim($path, '/'));
    $pageName = array_pop($parts);
    $parentPath = implode('/', $parts);
  
    // if page’s current parent is not homepage, include it 
    if($page->parent_id > 1) {
      $checkParents[] = $page->parent;
    }

    // if historical parent path differs from page’s current parent path, include it
    if($parentPath === '' || $parentPath === '/') {
      // historial parent is root/home
    } else if($parentPath === trim($page->parent()->path(), '/')) {
      // historial parent is the same as current parent
    } else if($parentPath === trim($page->path(), '/')) {
      // historial parent is the page itself
    } else {
      // historial parent may be one we want to check
      $parent = $this->wire()->pages->get("/$parentPath");
      if(!$parent->id) $parent = $this->getPage($parentPath);
      // if parent from path is different from current page parent, include in our list of parents to check
      if($parent->id > 1 && $parent->id != $page->parent_id && $parent->id != $page->id) {
        $checkParents[] = $parent;
      }
    }

    // get paths for each parent 
    foreach($checkParents as $parent) {
      $parentPaths = $this->getVirtualHistoryParent($page, $pageName, $pathInfo, $parent, $options);
      foreach($parentPaths as $parentPath => $parentInfo) {
        if(!isset($paths[$parentPath])) {
          $paths[$parentPath] = $parentInfo;
        }
      }
    }
    
    return $paths;
  }

  /**
   * Get virtual history for page in context of a specific parent (companion to getVirtualHistory method)
   * 
   * @param Page $page
   * @param string $pageName Historical name (or same as page->name)
   * @param array|string $pagePathInfo Path or pathInfo array
   * @param Page $parent
   * @param array $options
   * @return array
   * 
   */
  protected function getVirtualHistoryParent(Page $page, $pageName, array $pagePathInfo, Page $parent, array $options) {
    
    $paths = array();
    
    // get path history for this parent
    $parentPaths = $this->getPathHistory($parent, $options);

    // pageNamesDates is array of name => timestamp
    $pageNamesDates = array(
      $pageName => isset($pagePathInfo['date']) ? strtotime($pagePathInfo['date']) : 0
    );

    // if historical name differs from current name, include current name in pageNamesDates
    if($page->name != $pageName) {
      $pageNamesDates[$page->name] = $page->modified;
    }

    // iterate through each of the names this page has had, along with the date that it was changed to it
    foreach($pageNamesDates as $name => $date) {

      // iterate through all possible parent paths
      foreach($parentPaths as $parentPathInfo) {

        $parentPath = $options['verbose'] ? $parentPathInfo['path'] : $parentPathInfo;

        // create path that is historical parent path plus current iteration of page name
        $path = $parentPath . '/' . $name;

        // if we've already got this path, skip it
        if(isset($paths[$path])) continue;

        // non-verbose mode only includes paths
        if(empty($options['verbose'])) {
          $paths[$path] = $path;
          continue;
        }
        
        // if parent change date is older than page change date, then we can skip it
        if(strtotime($parentPathInfo['date']) < $date) continue;
      
        // if path is related to trash do not include it
        if(strpos($path, '/trash/') === 0 || preg_match('!/\d+\.\d+\.\d+_[-_a-z0-9]+!', $path)) {
          continue;
        }
        
        // create verbose info for this entry
        $pathInfo = array(
          'path' => $path,
          'date' => $parentPathInfo['date'],
          'virtual' => $parent->id
        );
        
        // if parent is specific to a language, include that info in the verbose value
        if(isset($parentPathInfo['language'])) {
          $pathInfo['language'] = $parentPathInfo['language'];
        }
        
        $paths[$path] = $pathInfo;
      }
    }
    
    return $paths;
  }

  /**
   * Hook called when a page is moved or renamed
   * 
   * @param HookEvent $event
   *
   */
  public function hookPageMoved(HookEvent $event) {

    /** @var Page $page */
    $page = $event->arguments[0];
    /** @var Languages $languages */
    $languages = $this->getLanguages();

    $age = time() - $page->created;
    if($page->template == 'admin' || $this->wire('pages')->cloning || $age < $this->minimumAge) return;

    // note that the paths we store have no trailing slash
    
    if($languages) {
      $parent = $page->parent();
      $parentPrevious = $page->parentPrevious;
      if($parentPrevious && $parentPrevious->id == $parent->id) $parentPrevious = null;
      foreach($languages as $language) {
        /** @var Language $language */
        if($language->isDefault()) continue;
        $namePrevious = $page->get("-name$language");
        if(!$namePrevious && !$parentPrevious) continue;
        if(!$namePrevious) $namePrevious = $page->name;
        $languages->setLanguage($language);
        $pathPrevious = $parentPrevious ? $parentPrevious->path() : $page->parent()->path();
        $pathPrevious = rtrim($pathPrevious, '/') . "/$namePrevious";
        $this->setPathHistory($page, $pathPrevious, $language->id);
        $languages->unsetLanguage();
      }
    }

    if(!$page->namePrevious) {
      // abort saving a former URL if it looks like there isn't going to be one
      if(!$page->parentPrevious || $page->parentPrevious->id == $page->parent->id) return;
    }

    if($page->parentPrevious) {

      // if former or current parent is in trash, then don't bother saving redirects
      if($page->parentPrevious->isTrash() || $page->parent->isTrash()) return; 

      // the start of our redirect URL will be the previous parent's URL
      $path = $page->parentPrevious->path;

    } else {
      // the start of our redirect URL will be the current parent's URL (i.e. name changed)
      $path = $page->parent->path;
    }

    if($page->namePrevious) {
      $path = rtrim($path, '/') . '/' . $page->namePrevious;
    } else {
      $path = rtrim($path, '/') . '/' . $page->name;
    }
    
    if($languages) $languages->setDefault();
    $this->setPathHistory($page, $path);
    if($languages) $languages->unsetDefault();
  }

  /**
   * Hook called upon 404 from ProcessPageView::pageNotFound
   * 
   * @param HookEvent $event
   *
   */
  public function hookPageNotFound(HookEvent $event) {
  
    /** @var Page $page */
    $page = $event->arguments(0);
    /** @var Wire404Exception $exception */
    $exception = $event->arguments(4); 

    // If there is a page object set, then it means the 404 was triggered
    // by the user not having access to it, or by the $page's template 
    // throwing a 404 exception. In either case, we don't want to do a 
    // redirect if there is a $page since any 404 is intentional there.
    if($page && $page->id) {
      // it did resolve to a Page: maybe a front-end 404
      if(!$exception) {
        // pageNotFound was called without an Exception
        return;
      } else if($exception->getCode() == Wire404Exception::codeFunction) {
        // the wire404() function was called: allow PagePathHistory
      } else if($exception->getMessage() === "1") {
        // also allow PagePathHistory to operate when: throw new WireException(true);
      } else {
        // likely user didn't have access or intentional 404 that should not redirect
        return;
      } 
    }
    
    $languages = $this->getLanguages();
    if($languages) {
      // the LanguageSupportPageNames may change the original requested path, so we ask it for the original
      $path = $this->wire('modules')->get('LanguageSupportPageNames')->getRequestPath();
      $path = $path ? $this->wire('sanitizer')->pagePathName($path) : $event->arguments(1);
    } else {
      $path = $event->arguments(1);
    }
    
    $page = $this->getPage($path);
    
    if($page->id && $page->viewable()) {
      // if a page was found, redirect to it...
      $language = $page->get('_language');
      if($language && $languages) {
        // ...optionally for a specific language
        if($page->get("status$language")) {
          $languages->setLanguage($language);
        }
      }
      $this->session->redirect($page->url);
    }
  }

  /**
   * Given a previously existing path, return the matching Page object or NullPage if not found.
   * 
   * If the path is for a specific language, this method also sets a $page->_language property
   * containing the Language object the path is for. 
   *
   * @param string $path Historical path of page you want to retrieve
   * @param int $level Recursion level for internal recursive use only
   * @return Page|NullPage
   *
   */
  public function getPage($path, $level = 0) {
    
    $page = $this->wire('pages')->newNullPage();
    $pathRemoved = '';
    $cnt = 0;
    $database = $this->wire('database');
    $table = self::dbTableName;
    $languages = $this->getLanguages();
    
    if(!$level) $path = $this->wire('sanitizer')->pagePathName($path, Sanitizer::toAscii);
    $path = '/' . trim($path, '/');

    while(strlen($path) && !$page->id && $cnt < self::maxSegments) {

      $sql = "SELECT pages_id ";
      if($languages) $sql .= ", language_id ";
      $sql .= "FROM $table WHERE path=:path";
      $query = $database->prepare($sql);
      $query->bindValue(":path", $path); 
      $error = false;
      
      try {
        $query->execute();
      } catch(\Exception $e) {
        if(strpos($e->getMessage(), '1054') !== false) $this->upgrade(1, 2);
        $this->wire('log')->error('PagePathHistory::getPage() - ' . $e->getMessage());
        $error = true;
      }
      
      if($error) break;
      
      if($query->rowCount() > 0) {
        // found a match
        $row = $query->fetch(\PDO::FETCH_NUM);
        $pages_id = (int) $row[0];
        $language_id = $languages && isset($row[1]) ? $row[1] : 0;
        $page = $this->pages->get((int) $pages_id);
        if($language_id) $page->setQuietly("_language", $this->getLanguage($language_id));
      } else {
        // didn't find a match, we'll pop the last segment off and try again for the parent
        $pos = strrpos($path, '/');
        $pathRemoved = substr($path, $pos) . $pathRemoved;
        $path = substr($path, 0, $pos);
      }
      
      $query->closeCursor();
      $cnt++;
    } 

    // if no page was found, then we can stop trying now
    if(!$page->id) return $page; 

    if($cnt > 1) {
      // a parent match was found if our counter is > 1
      $parent = $page; 
      // use the new parent path and add the removed components back on to it
      $path = rtrim($parent->path, '/') . $pathRemoved; 
      // see if it might exist at the new parent's URL
      $page = $this->wire('pages')->getByPath($path, array(
        'useHistory' => false,
        'useLanguages' => $languages ? true : false
      )); 
      if($page->id) {
        // found a page
        if($languages) {
          $language = $this->wire('modules')->get('LanguageSupportPageNames')->getPagePathLanguage($path, $page);
          if($language) $page->setQuietly('_language', $language);
        }
      } else if($level < self::maxSegments) {
        // if not, then go recursive, trying again
        $page = $this->getPage($path, $level + 1);
      }
    }
    
    return $page;   
  }

  /**
   * When a page is deleted, remove it from our redirects list as well
   * 
   * @param HookEvent $event
   *
   */
  public function hookPageDeleted(HookEvent $event) {
    $page = $event->arguments[0];
    $database = $this->wire('database');
    $query = $database->prepare("DELETE FROM " . self::dbTableName . " WHERE pages_id=:pages_id"); 
    $query->bindValue(":pages_id", $page->id, \PDO::PARAM_INT);
    $query->execute();
  }

  /**
   * Implementation for $page->addUrl($url, [$language]) method
   * 
   * @param HookEvent $event
   * 
   */
  public function hookPageAddUrl(HookEvent $event) {
    /** @var Page $page */
    $page = $event->object; 
    /** @var string $url */
    $url = $event->arguments(0);
    /** @var Language|null $language */
    $language = $event->arguments(1);
    $event->return = $this->addPathHistory($page, $this->urlToPath($url), $language); 
  }
  
  /**
   * Implementation for $page->removeUrl($url, [$language]) method
   *
   * @param HookEvent $event
   *
   */
  public function hookPageRemoveUrl(HookEvent $event) {
    /** @var page $page */
    $page = $event->object;
    /** @var string $url */
    $url = $event->arguments(0);
    $event->return = (bool) $this->deletePathHistory($page, $this->urlToPath($url));
  }

  /**
   * Given URL that may include a root subdirectory, convert it to path relative to root subdirectory
   * 
   * @param string $url
   * @return string
   * 
   */
  protected function urlToPath($url) {
    $rootUrl = $this->wire('config')->urls->root;
    if(strlen($rootUrl) > 1 && strpos($url, $rootUrl) === 0) {
      $path = substr($url, strlen($rootUrl) - 1);
    } else {
      $path = $url;
    }
    return $path;
  }

  /**
   * Install
   * 
   */
  public function ___install() {
    
    $len = $this->wire('database')->getMaxIndexLength();

    $sql =  "CREATE TABLE " . self::dbTableName . " (" . 
        "path VARCHAR($len) NOT NULL, " . 
        "pages_id INT UNSIGNED NOT NULL, " .
        "language_id INT UNSIGNED DEFAULT 0, " . // v2
        "created TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, " . 
        "PRIMARY KEY path (path), " . 
        "INDEX pages_id (pages_id), " . 
        "INDEX created (created) " . 
        ") ENGINE={$this->config->dbEngine} DEFAULT CHARSET={$this->config->dbCharset}";

    $this->wire('database')->exec($sql); 

  }

  /**
   * Uninstall
   * 
   */
  public function ___uninstall() {
    $this->wire('database')->query("DROP TABLE " . self::dbTableName); 
  }

  /**
   * Upgrade PagePathHistory module schema
   * 
   * @param int $fromVersion
   * @param int $toVersion
   * 
   */
  public function ___upgrade($fromVersion, $toVersion) {
    
    if($fromVersion == 1) {
    
      $messagePrefix = "PagePathHistory v$fromVersion => v$toVersion: ";
      $database = $this->wire('database');
      $table = self::dbTableName;
      
      try {
        $database->exec("ALTER TABLE $table ADD language_id INT UNSIGNED DEFAULT 0");
        $message = "Added 'language_id' column";
        $error = false;
      } catch(\Exception $e) {
        $error = true;
        $message = $e->getMessage();
      }
      
      $message = $messagePrefix . $message;
      $error ? $this->error($message) : $this->message($message);
    }
  }

  /**
   * Module config
   * 
   * @param InputfieldWrapper $inputfields
   * 
   */
  public function getModuleConfigInputfields(InputfieldWrapper $inputfields) {
    /** @var InputfieldInteger $f */
    $f = $this->wire('modules')->get('InputfieldInteger');
    $f->attr('name', 'minimumAge');
    $f->label = $this->_('Minimum age (seconds)');
    $f->description = $this->_('Start recording history for a page this many seconds after it has been created. At least 2 or more seconds recommended.');
    $f->notes = sprintf($this->_('Default: %s'), self::minimumAge);
    $f->val((int) $this->minimumAge);
    $f->required = true;
    $inputfields->add($f);
  }

}