ProcessPageListerUrls.module

<?php namespace ProcessWire;

/**
 * Class ProcessPageListerUrls
 *
 * Copyright 2016 by Martijn Geerts
 *
 * ProcessWire 2.x
 * Copyright (C) 2014 by Ryan Cramer
 * Licensed under GNU/GPL v2, see LICENSE.TXT
 *
 * http://processwire.com
 *
 */

class ProcessPageListerUrls extends ProcessPageLister implements ConfigurableModule {

	/**
	 * Module info
	 *
	 * @return array Associative array with module information
	 *
	 */
	public static function getModuleInfo() {
		return array(
			'title' => 'PLUs (Page Lister URLs)',
			'summary' => 'Link to listerpages with predefined settings.',
			'version' => '0.0.3',
			'author' => 'Martijn Geerts',
			'icon' => 'search-plus',
			'singular' => true,
			'autoload' => false,
			'permission' => 'page-lister',
			);
	}

	// @var Page See ___execute
	protected $linkPage;

	// @var Page ListerPage
	protected static $listerPage = null;

	// @var string Default cipher method
	public static $defaultCipherMethod = 'AES-256-CBC';

	// @var array Fieldnames allowed as columns
	protected $allowedColumns = null;

	public function __construct() {
		$this->set('cipher_method', self::$defaultCipherMethod);
		$this->set('iv_size', '');
	}

	/**
	 * Get the page where this module lives.
	 *
	 */
	public function init() {
		parent::init(); // always remember to call the parent init
		if (!$this->cipher_method) $this->error("Please select a cipher method in the module configuration.");
		$this->linkPage = $this->wire('pages')->get('template=admin, process=' . $this->wire('modules')->getModuleID($this));
	}

	/**
	 * ListerProUrl playground, handy for creating ListerProUrls.
	 *
	 * @return string Markup
	 *
	 */
	public function ___execute() {

		$string = '';
		$alphabet = range('a', 'z');
		foreach ($alphabet as $letter) {
			$part = $this->wire('input')->get($letter);
			if (!$part) break;
			$string .= $part;
		}

		$dirty = wireDecodeJSON($this->decrypt(rawurldecode($string)));
		$listerPage = isset($dirty['listerPage']) ? $this->listerPage($dirty['listerPage']) : $this->wire(new NullPage());

		// return invalid page
		if (!$listerPage->id) {
			$message = $this->_("We couldn't load the lister page.");
			return $this->invalidPage($message);
		}

		$allow = array('initSelector', 'defaultSelector', 'columns', 'defaultSort');
		$clean = array();

		foreach ($allow as $key) {

			if (!isset($dirty[$key])) continue;

			$value = $dirty[$key];
			$sanitized = '';

			if ($key === 'initSelector') {
				// do access stuf, etc.
				$sanitized = $this->validateSelector($value);

			} else if ($key === 'defaultSelector') {
				// do access stuf, etc.
				$sanitized = $this->validateSelector($value);

			} elseif ($key === 'columns' && is_array($value)) {
				$sanitized = $this->validateColumns($value);

			} elseif ($key === 'defaultSort') {
				$sanitized = $this->sanitizer->selectorValue($value);
			}

			// Assign sanitized value to variables
			$$key = $sanitized;
		}

		// Maximum include hidden and not called twice (Bug ListerPro ?)
		$includeAmount = (int) substr_count($initSelector . $defaultSelector, 'include=');

		if ($includeAmount === 0) {
			$initSelector . ', include=hidden';
		} else if ($includeAmount > 1) {
			$cleanedSelectors = array_map(function($value) {
				return trim($value);
			}, array_filter(explode(',', $defaultSelector), function($value) {
				return strpos($value, 'include=') === false;
			}));

			$defaultSelector = implode(', ', $cleanedSelectors);
		}

		$this->wire('session')->set('initSelector', $initSelector);

		$clean = array(
			'initSelector' => $initSelector,
			'defaultSelector' => $defaultSelector,
			'columns' => $columns,
			'defaultSort' => $defaultSort,
			);

		foreach (array_keys($clean) as $key) {
			$value = $clean[$key];
			if ($key === 'columns' && is_string($value)) {
				unset($clean[$key]);
			} else if (!$value) {
				unset($clean[$key]);
			}
		}

		self::$listerPage = $listerPage;
		$url = self::addSessionBookmarkCustom(md5(json_encode($clean)), $clean);
		if (!$url) return $this->invalidPage();
		$this->session->redirect($url);
	}

	/**
	 * Given a unique ID and an array of Lister settings (in $bookmark) return a URL to view those pages in Lister
	 *
	 * @param string $id ID or name of bookmark
	 * @param array $bookmark Bookmark data
	 * @return string Returns URL to Lister with this bookmark or blank on failure (like if user doesn't have access)
	 *
	 */
	public static function addSessionBookmarkCustom($id, array $bookmark) {

		$user = wire('user');
		if(!$user->isSuperuser() && !$user->hasPermission('page-lister')) return '';

		$maxBookmarks = 30;
		$bookmarks = wire("session")->get(self::sessionBookmarksName);
		if(!is_array($bookmarks)) $bookmarks = array();

		if(count($bookmarks) > $maxBookmarks) {
			// trim bookmarks to max size
			$bookmarks = array_slice($bookmarks, -1 * $maxBookmarks, null, true);
		}

		$bookmarks[$id] = $bookmark;
		wire("session")->set(self::sessionBookmarksName, $bookmarks);

		return self::$listerPage->url . "?session_bookmark=$id";
	}

	/**
	 * Whether or not to allow the given $fields as columns.
	 *
	 * @param array $columns Array with column names
	 * @return array Cleaned array
	 *
	 */
	public function validateColumns(array $columns) {
		$array = array();
		foreach ($columns as $fieldName) {
			// System columns (name, status, template, templates_id etc... etc...)
			if (isset($this->systemLabels[$fieldName])) {
				$array[] = $fieldName;
				continue;
			}

			$a = explode('.', $fieldName);
			$field = $this->fields->get($a[0]);
			if (!($field instanceof Field)) continue;

			if (!$this->allowColumnField($field)) continue;
			$array[] = $fieldName;
		}
		return $array;
	}


	/**
	 * Get Initialization Vector size
	 *
	 * @param string $method
	 * @return mixed Integer on succes
	 *
	 */
	private function getIvLength($method = null) {
		if (!$method) throw new WireException("getIvLength needs a method.");
		$length = openssl_cipher_iv_length($method);
		if ($length === false && is_string($this->iv_size)) {
			$this->error("Can't get the cipher initialization vector (iv) length.");
		} else if ($length === false) {
			$length = (int) $this->iv_size;
		}

		return $length;
	}

	/**
	 * Encrypt String
	 *
	 * @param string $string String to encrypt
	 * @param string $method Cipher method to use
	 * @return string Encrypted string
	 *
	 */
	public function encrypt($string, $method = null) {
		$hash = $this->wire('config')->userAuthSalt;
		if (!$method) $method = $this->cipher_method;
		$length = $this->getIvLength($method);

		// will set error
		if ($length === false) return false;
		$iv = @mcrypt_create_iv($length, MCRYPT_DEV_URANDOM);
		$encrypted = @openssl_encrypt($string, $method, $hash, 0, $iv);
		return ($encrypted === false) ? false : $iv . $encrypted;
	}

	/**
	 * Decrypt encrypted string
	 *
	 * @param string $string String to encrypt
	 * @param string $method Cipher method to use
	 * @return string Decrypted string
	 *
	 */
	public function decrypt($string, $method = null) {
		if (!$method) $method = $this->cipher_method;
		$length = $this->getIvLength($method);
		if (!$length) return false;
		$iv = substr($string, 0, $length);
		$string = substr($string, $length);
		$hash = $this->wire('config')->userAuthSalt;
		return openssl_decrypt($string, $method, $hash, 0, $iv);
	}

	/**
	 * Invalid Listerpage Markup
	 *
	 * @param string $message
	 * @return string
	 *
	 */
	public function invalidPage($message = '') {
		if (!$message) $message = $this->_("We encountered a problem.");
	 	$this->headline($this->className());
		$wrapper = $this->wire('modules')->get('InputfieldForm');

		$f = $this->wire('modules')->get('InputfieldMarkup');
		$f->set('label', $this->className());
		$f->set('value', $message);
		$wrapper->add($f);

		return $wrapper->render();
	}

	/**
	 * Return a valid ProcessPageListerPro or a NullPage
	 *
	 * @param mixed integer|Page $ListerPage Admin page with ProcessPageListerPro process
	 * @return Page Valid ListerProPage or NullPage on failing.
	 *
	 */
	public function listerPage($listerPage) {
		// Check for ID
		if (!($listerPage instanceof Page)) {
			if (!ctype_digit("$listerPage")) return new NullPage;
			$listerPage = $this->wire('pages')->get($listerPage);
		}
		if ($listerPage->template != 'admin') return new NullPage;
		if (!$listerPage->fields->has('process')) return new NullPage;
		if (strpos('ProcessPageListerPro', $listerPage->process) !== false) return $listerPage;
		return $this->wire(new NullPage);
	}

	/**
	 * Set sessions and returns an url.
	 *
	 * @param Page $ListerPage Destination of the URL.
	 * @param string $initSelector Initial selector string that all further selections are filtered by.
	 * @param string $defaultSelector Default selector string that appears but MAY be removed or changed.
	 * @param array $columns Array of column names to show in lister.
	 * @param string $defaultSort Where to sort on.
	 * @return string
	 *
	 */
	public function url(Page $listerPage, $initSelector = '', $defaultSelector = '', array $columns = array(), $defaultSort = '') {

		if (!$this->cipher_method) {
			return $this->wire('page')->url;
		}

		// Don't give URL to people that don't have page-lister permissions
		$user = $this->wire('user');
		if (!$user->isSuperuser() && !$user->hasPermission('page-lister')) return '';

		$ListerPage = $this->listerPage($listerPage);

		// No lister page return empty string
		if (!$ListerPage->id) return '';

		$query = array(
			'listerPage' => $listerPage->id,
			'initSelector' => $initSelector,
			'defaultSelector' => $defaultSelector,
			'columns' => $columns,
			'defaultSort' => $defaultSort,
			);

		// Build get string with variables no longer then the max 512 characters

		$encoded = $this->encrypt(wireEncodeJSON($query, true));
		if ($encoded === false) {
			$this->error("URL encryption error.");
			return '';
		}

		$results = '';
		$alphabet = range('a', 'z');
		$string = rawurlencode($encoded);
		$parts = str_split($string, 256);
		foreach ($parts as $key => $part) $results .= '&' . $alphabet[$key] . '=' . $part;

		return $this->linkPage->url . "?" . ltrim($results, '&');
	}

	/**
	 * Install
	 *
	 * Call ___installPage directly (using page in self::getModuleInfo() doesn't work)
	 *
	 */
	public function install() {
		$name = 'plus';
		$parent = $this->wire('pages')->get("parent.id=" . $this->wire('config')->adminRootPageID . ", name=setup");
		$title = self::getModuleInfo()['title'];
		$template = 'admin';
		parent::___installPage($name, $parent, $title, $template, array('status' => Page::statusHidden));
	}

	/**
	 * Install
	 *
	 * Call ___uninstallPage directly (using page in self::getModuleInfo() doesn't work)
	 *
	 */
	public function uninstall() {
		parent::___uninstallPage();
	}

	/**
	 * Module config
	 *
	 * @param array $data
	 * @return InputfieldWrapper
	 *
	 */
	public static function getModuleConfigInputfields(array $data) {
		$inputfields = new InputfieldWrapper();
		$cipherMethods = openssl_get_cipher_methods();

		$name = 'cipher_method';
		$value = isset($data[$name]) ? $data[$name] : self::$defaultCipherMethod;
		$f = wire('modules')->get("InputfieldSelect");
		$f->set('label', __("Cipher method"));
		$f->set('description', __("Cipher method to use for building the URL."));
		$f->set('required', true);
		$f->set('name', $name);
		$f->set('value', $value);
		$f->addOption('', '');
		foreach ($cipherMethods as $method) $f->addOption($method, $method);
		$inputfields->add($f);

		$name = 'iv_size';
		$value = isset($data[$name]) ? $data[$name] : '';
		$f = wire('modules')->get("InputfieldInteger");
		$f->set('label', __("Initialization vector size"));
		$description =
		__("In some cases we are unable to determen the initialization vector size based on the cipher method.") . ' ' .
		__("When we fail, we try it with the given size.");
		$f->set('description', $description);
		$f->set('name', $name);
		$f->set('value', $value);
		$f->attr('size', '3');
		$f->attr('type', 'number');
		$f->attr('style', 'width: 3.5em;');
		$inputfields->add($f);

		return $inputfields;
	}
}