ProcessRedirects.module

<?php namespace ProcessWire;

/**
 * Redirects module for ProcessWire
 */
class ProcessRedirects extends Process implements ConfigurableModule {

	/**
	 * Name of the redirects database table
	 *
	 * @var string
	 */
	const TABLE_NAME = 'process_redirects';

	/**
	 * Schema version for database table used by this module
	 *
	 * @var int
	 */
	const SCHEMA_VERSION = 3;

	/**
	 * Debug mode
	 *
	 * This is enabled by manually modifying this property. Intended for module development purposes only, not to be
	 * enabled on a live site.
	 *
	 * @var bool
	 */
	protected $debug_mode = false;

	/**
	 * Populate the default config data
	 *
	 * ProcessWire will automatically overwrite these values with anything the user has specifically configured. This
	 * is done in construct() rather than init() because ProcessWire populates config data after construct(), but
	 * before init().
	 */
	public function __construct() {
		foreach (self::getDefaultData() as $key => $value) {
			$this->set($key, $value);
		}
	}

	/**
	 * Get module info
	 *
	 * @return array
	 */
	public static function getModuleInfo(): array {
		return [
			'title' => 'Redirects',
			'summary' => __('Manage redirects'),
			'href' => 'https://processwire.com/talk/topic/148-release-redirects/',
			'version' => '2.2.2',
			'permanent' => false,
			'page' => [
				'name' => 'redirects',
				'parent' => 'setup',
				'title' => 'Redirects',
			],
			'autoload' => true,
			'singular' => true,
			'permission' => 'redirects-admin',
			'icon' => 'exchange',
			'requires' => [
				'ProcessWire>=3.0.112',
				'PHP>=7.1.0',
			],
		];
	}

	/**
	 * Default configuration for this module
	 *
	 * @return array
	 */
	public static function getDefaultData() {
		return [
			'schema_version' => 1,
		];
	}

	/**
	 * Module configuration
	 *
	 * Note: at the moment thi method doesn't do much of anything, and primarily exists so that we can store the schema
	 * version info in module configuration.
	 *
	 * @param array $data
	 * @return InputfieldWrapper
	 */
	public static function getModuleConfigInputfields(array $data): InputfieldWrapper {
		$data = array_merge(self::getDefaultData(), $data);
		$fields = new InputfieldWrapper();
		return $fields;
	}

	/**
	 * Init method
	 *
	 * This method is called when the module is loaded. We use it to attach hooks.
	 */
	public function init() {
		parent::init();

		// check for a database schema update
		if ($this->schema_version < self::SCHEMA_VERSION) {
			$this->updateDatabaseSchema();
		}

		$this->addHook('ProcessPageView::pageNotFound', $this, 'checkRedirects');
	}

	/**
	 * Default view for the Process (admin page)
	 *
	 * @return string
	 */
	public function ___execute(): string {

		// load vex
		$this->wire('modules')->get('JqueryUI')->use('vex');

		// load admin.js
		$this->config->scripts->add($this->config->urls->ProcessRedirects . 'js/admin.js');

		/** @var MarkupAdminDataTable */
		$table = $this->modules->get('MarkupAdminDataTable');
		$table
			->headerRow([
				$this->_('Redirect From'),
				$this->_("Redirect To"),
				$this->_("Test Redirect"),
				$this->_('Hits'),
				$this->_('Delete'),
			])
			->setEncodeEntities(false);

		// find all redirects and add them to the table
		$row_count = 0;
		$redirects = $this->database->query('SELECT * FROM ' . self::TABLE_NAME . ' ORDER BY redirect_from');
		foreach ($redirects as $redirect) {

			// prepare redirect target
			$redirect['redirect_to'] = $this->makeRedirectToURL($redirect['redirect_to']);

			// output in table rows with edit link and delete checkbox?
			$table->row([
				'<a href="edit/?id=' . (int) $redirect['id'] . '">' . $redirect['redirect_from'] . '</a>',
				'<a href="edit/?id=' . (int) $redirect['id'] . '">' . $redirect['redirect_to'] . '</a>',
				'<a target="_blank" class="pw-panel pw-panel-right" data-panel-width="75%" href="' . substr($this->config->urls->root, 0, -1) . $redirect['redirect_from'] . '">' . $this->_('Test') . ' <i class="fa fa-external-link" aria-hidden="true"></i></a>',
				(int) $redirect['counter'],
				'<input type="checkbox" name="delete[]" value="' . (int) $redirect['id'] . '">',
			]);

			++$row_count;
		}

		/** @var InputfieldButton */
		$button_add = $this->modules->get('InputfieldButton');
		$button_add->id = 'add_button';
		$button_add->value = $this->_('Add redirect');
		$button_add->href = './edit/?id=0';
		$button_add->icon = 'plus-circle';
		$button_add->showInHeader();

		/** @var InputfieldButton */
		$button_import = $this->modules->get('InputfieldButton');
		$button_import->id = 'import_button';
		$button_import->value = $this->_('Import');
		$button_import->href = './import/';
		$button_import->icon = 'paste';

		$button_export = null;
		if ($row_count) {
			/** @var InputfieldButton */
			$button_export = $this->modules->get('InputfieldButton');
			$button_export->id = 'export_button';
			$button_export->value = $this->_('Export');
			$button_export->href = './export/';
			$button_export->icon = 'copy';
			$button_export->setSecondary();
		}

		$button_delete = null;
		if ($row_count) {
			/** @var InputfieldButton */
			$button_delete = $this->modules->get('InputfieldButton');
			$button_delete->id = 'delete_button';
			$button_delete->type = 'submit';
			$button_delete->value = $this->_('Remove selected redirects');
			$button_delete->icon = 'trash-o';
			$button_delete->addClass('uk-align-right');
			$button_delete->setSecondary();
		}

		$label_alert_select = $this->_('You need to select at least one item to delete first.');
		$label_confirm_delete = $this->_('Are you sure you want to delete selected redirects?');
		return '<form id="redirects_form" action="./delete/" method="post" class="uk-margin-bottom"'
			. ' data-alert-select="' . $label_alert_select . '"'
			. ' data-confirm-delete="' . $label_confirm_delete . '"'
			. '>'
			. $this->session->CSRF->renderInput()
			. $table->render()
			. $button_add->render()
			. $button_import->render()
			. ($button_delete ? $button_delete->render() : '')
			. ($button_export ? $button_export->render() : '')
			. '</form>';
	}

	/**
	 * Edit/Add Redirect view
	 *
	 * This method is called when requesting the Process page with /edit/ suffix.
	 *
	 * @return string
	 *
	 * @throws Wire404Exception if trying to edit a non-existing redirect.
	 */
	public function ___executeEdit(): string {

		// add breadcrumb and set page headline
		$this->breadcrumb('../', $this->_('Redirects'));
		$this->headline($this->_('Add Redirect'));

		// load vex
		$this->wire('modules')->get('JqueryUI')->use('vex');

		// load admin.js
		$this->config->scripts->add($this->config->urls->ProcessRedirects . 'js/admin.js');

		// default settings
		$id = (int) $this->input->get->id ?: 0;
		$from = '';
		$to = '';

		// check if we're editing an existing record
		if ($id > 0) {
			$this->headline($this->_('Edit Redirect'));
			$stmt = $this->database->prepare("
				SELECT id, redirect_from, redirect_to
				FROM " . self::TABLE_NAME . "
				WHERE id = :id
			");
			$stmt->bindParam('id', $id, \PDO::PARAM_INT);
			$stmt->execute();
			$redirect = $stmt->fetch(\PDO::FETCH_NUM);
			if ($redirect === false) {
				throw new Wire404Exception($this->_('Redirect not found.'));
			}
			list($id, $from, $to) = $redirect;
			$to = $this->makeRedirectToURL($to);
		}

		/** @var InputfieldForm */
		$form = $this->modules->get('InputfieldForm');
		$form->method = 'post';
		$form->id = 'ProcessRedirectsEditForm';
		$form->attr('data-no-redirect-to', $this->_('Please select target page.'));
		$form->action = '../save/';

		// add instructions field
		$form->add($this->getInstructions());

		/** @var InputfieldHidden */
		$field = $this->modules->get('InputfieldHidden');
		$field->name = 'id';
		$field->value = $id;
		$form->add($field);

		/** @var InputfieldText */
		$field = $this->modules->get('InputfieldText');
		$field->label = $this->_('Redirect From');
		$field->required = true;
		$field->requiredAttr = true;
		$field->description = $this->_('Enter relative path with slashes (e.g. `/some/path/`).');
		$field->notes = $this->_('Note: Redirect From must not match any existing, viewable page. See "Instructions" section for more details.');
		$field->attr('id+name', 'redirect_from');
		$field->value = $from;
		$form->add($field);

		/** @var InputfieldPageListSelect */
		$field = $this->modules->get('InputfieldPageListSelect');
		$field->label = $this->_('Select Page to Redirect To');
		$field->attr('id+name', 'select_page');
		$field->startLabel = $this->_('Select Page');
		$field->parent_id = 0; // tell it to start from homepage
		if (strpos($to, '/') === 0) {
			// if a value is already set determine if it's a page, in which case populate the input with the page_id
			$page = $this->pages->get($to);
			if ($page->id) {
				$field->value = $page->id;
			}
		} else {
			$page = $this->wire(new NullPage());
		}
		$form->add($field);

		/** @var InputfieldURL */
		$field = $this->modules->get('InputfieldURL');
		$field->label = $this->_('or type URL here');
		$field->description = $this->_('Enter a valid URL, i.e. www.otherdomain.com/dir/ or relative URL like /season/summer/');
		$field->name = 'redirect_to';
		$field->id = 'redirect_to';
		$field->collapsed = $page->id || $id == 0 ? 1 : 0;
		$field->value = $to;
		$form->add($field);

		/** @var InputfieldButton */
		$field = $this->modules->get('InputfieldButton');
		$field->type = 'submit';
		$field->value = $this->_('Save');
		$form->add($field);

		return $form->render();
	}

	/**
	 * Import view
	 *
	 * This method is called when requesting the Process page with /import/ suffix.
	 *
	 * @return string
	 */
	public function ___executeImport(): string {

		$this->breadcrumb('../', $this->_('Redirects'));
		$this->headline($this->_('Import Redirects'));

		return $this->getImportForm()->render();
	}

	/**
	 * Export view
	 *
	 * This method is called when requesting the Process page with /export/ suffix.
	 *
	 * @return string
	 */
	public function ___executeExport(): string {

		$this->breadcrumb('../', $this->_('Redirects'));
		$this->headline($this->_('Export Redirects'));

		/** @var InputfieldWrapper */
		$wrapper = $this->wire(new InputfieldWrapper);
		$wrapper->setClasses([
			'list' => 'Inputfields uk-grid uk-grid-collapse uk-grid-match uk-grid-stack uk-margin-bottom',
		]);

		/** @var InputfieldTextarea */
		$field = $this->modules->get('InputfieldTextarea');
		$field->label = $this->_('List of redirects');
		$field->description = $this->_('This field contains all existing redirects. You can export them by selecting, copying, and pasting to a text editor or other application of your choice.');
		$field->icon = 'copy';
		$field->name = 'redirects';
		$field->value = '';
		$field->rows = 15;
		$wrapper->add($field);

		// find all redirects and add them to the export field
		$redirects = $this->database->query('SELECT redirect_from, redirect_to FROM ' . self::TABLE_NAME . ' ORDER BY redirect_from');
		foreach ($redirects as $redirect) {
			$redirect_to = $this->makeRedirectToURL($redirect['redirect_to']);
			$field->value = $field->value . "\n" . $redirect['redirect_from'] . "," . $redirect_to;
		}

		/** @var InputfieldButton */
		$button_back = $this->modules->get('InputfieldButton');
		$button_back->id = 'back_button';
		$button_back->value = $this->_('Back');
		$button_back->href = '../';
		$button_back->setSecondary();

		/** @var InputfieldButton */
		$button_csv = $this->modules->get('InputfieldButton');
		$button_csv->id = 'csv_download_button';
		$button_csv->value = $this->_('Download CSV');
		$button_csv->icon = 'file-excel-o';
		$button_csv->href = '../download/';
		$button_csv->addClass('uk-align-right');
		$button_csv->setSecondary();

		return $wrapper->render()
			. $button_back->render()
			. $button_csv->render();
	}

	/**
	 * Download view
	 *
	 * This method is called when requesting the Process page with /download/ suffix.
	 */
	public function ___executeDownload() {

		// define output file name
		$filename = "redirects_" . date('Y-m-d_H-i') . ".csv";

		// send CSV headers
		header("Content-type: application/force-download");
		header("Content-Transfer-Encoding: Binary");
		header("Content-disposition: attachment; filename=$filename");

		// open file pointer and write header row
		$fp = fopen('php://output', 'w');
		fputcsv($fp, [
			'redirect_from',
			'redirect_to',
		]);

		// find all redirects and add them to output
		$redirects = $this->database->query('SELECT redirect_from, redirect_to FROM ' . self::TABLE_NAME . ' ORDER BY redirect_from');
		foreach ($redirects as $redirect) {
			$redirect_to = $this->makeRedirectToURL($redirect['redirect_to']);
			fputcsv($fp, [
				$redirect['redirect_from'],
				$redirect_to,
			]);
		}

		// close file pointer and exit
		fclose($fp);
		exit();
	}

	/**
	 * Save Redirect
	 *
	 * This method is called when requesting the Process page with /save/ suffix.
	 *
	 * @throws WireException if CSRF token is missing or invalid.
	 */
	public function ___executeSave(): void {

		// CSRF protection
		if (!$this->session->CSRF->hasValidToken()) {
			throw new WireException($this->_('CSRF check failed, redirect was not saved. Please try again.'));
		}

		// read arguments from POST data
		$id = (int) $this->input->post->id;
		$from = $this->input->post->redirect_from;
		$to = $this->input->post->redirect_to;

		// fall back to select_page value if redirect_to is empty
		if (empty($to) && $this->input->post->select_page && (int) $this->input->post->select_page == $this->input->post->select_page) {
			$select_page = $this->pages->get((int) $this->input->post->select_page);
			if ($select_page->id && !$select_page->isTrash() && $select_page->viewable()) {
				$to = $select_page->url;
			}
		}

		// check for errors; if an error is found, redirect back with an error message
		if ($from == '' || $to == '') {
			$this->error($this->_('No redirect created, please check provided values.'));
			$this->session->redirect('../', false);
		} else {
			$clean_path = $this->sanitizer->path($from);
			$path_match = $this->pages->getByPath($clean_path, [
				'useLanguages' => true,
			]);
			// check if given path matches existing page and validate the result by comparing full paths (Pages::getByPath()
			// can return a partial match if the page name is unique) and basenames (in case there's a multi-lingual match)
			if ($path_match->id && ($path_match->path == $clean_path || $path_match->name != basename($clean_path))) {
				$this->error($this->_('The Redirect From URL already exists as a page path. Redirect not added.'));
				$this->session->redirect('../', false);
			}
		}

		// save redirect and redirect back with a success message
		$this->saveRedirect($from, $to, $id);
		$this->message(sprintf(
			$this->_('Saved redirect from "%s" to "%s".'),
			$from,
			$to
		));
		$this->session->redirect('../', false);
	}

	/**
	 * Save Redirect array
	 *
	 * This method is called when requesting the Process page with /savearray/ suffix.
	 *
	 * @throws WireException if CSRF token is missing or invalid.
	 * @throws WireException if uploaded CSV file can't be read.
	 */
	public function ___executeSavearray(): void {

		// CSRF protection
		if (!$this->session->CSRF->hasValidToken()) {
			throw new WireException($this->_('CSRF check failed, redirect was not saved. Please try again.'));
		}

		$count = 0;
		$redirects_array = [];

		if ($this->input->post->import_from == 'file') {
			// file upload
			$form = $this->getImportForm();
			$form->processInput($this->input->post);
			if (count($form->getErrors())) {
				$this->error($this->_('No redirects created, invalid import file.'));
				$this->session->redirect('../', false);
			}
			$file = basename($form->getChildByName('file')->value);
			if (!empty($file)) {
				$upload_path = $this->getUploadPath();
				$upload_file = $upload_path . $file;
				if (file_exists($upload_file)) {
					$fp = fopen($upload_file, "r");
					if ($fp === false) {
						throw new WireException($this->_('Unable to read uploaded CSV file.'));
					}
					while (($redirect = fgets($fp)) !== false) {
						$redirects_array[] = $redirect;
					}
					fclose($fp);
					$this->files->unlink($upload_file, $upload_path);
				}
			}
		} else {
			// text input
			$redirects_array = preg_split("/\r\n|\n|\r/", $this->input->post->redirects);
		}

		if (empty($redirects_array) || $redirects_array[0] == '') {
			$this->error($this->_('No redirects created, please check your values.'));
			$this->session->redirect('../', false);
		}

		// counter: skipped, added, edited
		$count = [0, 0, 0];

		// keep track of from paths in case there are duplicates
		$paths = [];

		foreach ($redirects_array as $redirect) {

			// process redirect row ([from path],[to URL])
			$redirect_urls = explode(',', $redirect);
			$from = trim($redirect_urls[0] ?? '', " \t\n\r\0\x0B\"");
			$to = trim($redirect_urls[1] ?? '', " \t\n\r\0\x0B\"");

			// silently skip header row
			if ($from == 'redirect_from' && $to == 'redirect_to') {
				continue;
			}

			// skip empty or partial rows
			if ($from == '' || $to == '') {
				if ($from != '' || $to != '') {
					// partial row, log failure
					$this->error(sprintf(
						$this->_('Malformed input, redirect not added: %s'),
						$redirect
					));
					++$count[0];
				}
				continue;
			}

			// skip duplicates
			if (array_key_exists($from, $paths)) {
				$this->error(sprintf(
					$this->_('Duplicate from path, redirect not added: %s'),
					$redirect
				));
				++$count[0];
				continue;
			}
			$paths[$from] = 1;

			// save redirect and increment counter
			$result_code = $this->saveRedirect($from, $to);
			++$count[$result_code];
		}

		// redirect back with a success message
		$this->message(vsprintf(
			$this->_('Saved redirects (%1$d skipped, %2$d added, %3$d updated)'),
			$count
		));
		$this->session->redirect('../', false);
	}

	/**
	 * Delete Redirect
	 *
	 * This method is called when requesting the Process page with /delete/ suffix.
	 */
	public function ___executeDelete(): void {

		// CSRF protection
		if (!$this->session->CSRF->hasValidToken()) {
			throw new WireException($this->_('CSRF check failed, redirect was not saved. Please try again.'));
		}

		// counter for deleted redirects
		$count = 0;

		// make sure that we're actually trying to delete something
		if (!$this->input->post->delete) {
			$this->message($this->_('Nothing to delete.'));
			$this->session->redirect('../', false);
		}

		// prepare delete statement
		$stmt = $this->database->prepare("
			DELETE FROM " . self::TABLE_NAME . "
			WHERE id = :id
		");

		// delete items either based on an array of redirect IDs or a single redirect ID
		if (is_array($this->input->post->delete)) {
			foreach ($this->input->post->delete as $id) {
				if ((int) $id != $id) continue;
				$stmt->bindParam('id', $id, \PDO::PARAM_INT);
				$stmt->execute();
				++$count;
			}
		} else {
			$id = $this->input->post->delete;
			if ((int) $id == $id) {
				$stmt->bindParam('id', $id, \PDO::PARAM_INT);
				$stmt->execute();
				++$count;
			}
		}

		// redirect back with a success message
		$this->message(sprintf(
			$this->_n('Deleted %d redirect.', 'Deleted %d redirects.', $count),
			$count
		));
		$this->session->redirect('../', false);
	}

	/**
	 * Look for matching redirects
	 *
	 * This method is hooked into ProcesPageView::pageNotFound, which means that it gets executed when a visitor hits
	 * the 404 page.
	 *
	 * @param HookEvent $event
	 */
	public function checkRedirects(HookEvent $event): void {

		// get requested URL
		$request_url = $_SERVER['REQUEST_URI'] ?? '';

		// multiple slashes at the beginning of the URL are assumed to be a mistake, an unexpected result of a redirect, or an attempt to
		// somehow exploit the system, so we'll remove them
		if (strpos($request_url, '//') === 0) {
			$request_url = '/' . ltrim($request_url, '/');
		}

		// determine the URL path that wasn't found
		$parsed_url = parse_url($request_url);
		$url = rtrim($parsed_url['path'], '/');

		// if installed in a subdirectory, make $url relative to the directory ProcessWire is installed in
		if ($this->config->urls->root != '/') {
			$url = substr($url, strlen($this->config->urls->root)-1);
		}

		// grab query string
		$query = $parsed_url['query'] ?? null;
		$query_url = $query === null ? null : $url . '?' . $query . '&';

		// check if query string matches should be checked as well (query string is present and database contains
		// redirect_from paths with query strings)
		$use_query_url = $query_url !== null && $this->database->query("SELECT id FROM " . self::TABLE_NAME . " WHERE redirect_from LIKE '/%?%' LIMIT 1")->rowCount();

		// now see if it's in the DB
		$stmt = $this->database->prepare("
			SELECT id, redirect_to
			FROM " . self::TABLE_NAME . "
			WHERE :url LIKE REPLACE(REPLACE(TRIM(TRAILING '/' FROM redirect_from), '*', '%'), '_', '\_')
			" . ($use_query_url ? "OR :query_url LIKE CONCAT(REPLACE(REPLACE(TRIM(TRAILING '/' FROM REPLACE(redirect_from, '/?', '?')), '*', '%'), '_', '\_'), '&%')" : "") . "
			LIMIT 1
		");
		$stmt->bindParam('url', $url, \PDO::PARAM_STR);
		if ($use_query_url) {
			$stmt->bindParam('query_url', $query_url, \PDO::PARAM_STR);
		}
		$stmt->execute();
		$result = $stmt->fetch(\PDO::FETCH_NUM);

		// debug mode?
		if ($this->debug_mode) {
			echo "<pre>";
			$stmt->debugDumpParams();
			die("\n" . ($result === false ? "MISS" : "HIT: " . var_export($result, true)));
		}

		// bail out early if there was no match
		if ($result === false) return;

		// if there is a match, update hit counter and perform a redirect
		list($id, $redirect_to) = $result;
		$update_stmt = $this->database->prepare("
			UPDATE " . self::TABLE_NAME . "
			SET counter = counter + 1
			WHERE id = :id
		");
		$update_stmt->bindParam('id', $id, \PDO::PARAM_INT);
		$update_stmt->execute();
		$redirect_to = $this->makeRedirectToURL($redirect_to, true);
		if ($query !== null) {
			$redirect_to .= (strpos($redirect_to, '?') === false ? '?' : '&') . $query;
		}
		$this->session->redirect($redirect_to);
	}

	/**
	 * Convert stored value to target URL
	 *
	 * This method detects stored page IDs and converts them to URLs at the time of request. At least for now it won't
	 * modify existing URLs in any way.
	 *
	 * If second argument ($http) is set as 'true' and first argument ($to) matches an existing page, this method will
	 * return the full httpUrl for the page; otherwise we'll return the (relative) path to the page.
	 *
	 * @param string $to Target URL, or a page ID with a caret prefix
	 * @param bool $http Return httpUrl property instead of path?
	 * @return string
	 */
	private function makeRedirectToURL(string $to, bool $http = false): string {

		// bail out early if target URL doesn't start with a caret (in which case it's already an URL)
		if (strpos($to, '^') !== 0) return $to;

		// get a page matching the stored ID value
		$target_page = $this->pages->get((int) substr($to, 1));

		// if a page was found, return full httpUrl or relative path depending on provided arguments
		if ($target_page->id) {
			$to = $target_page->get($http ? 'httpUrl' : 'path');
		}

		return $to;
	}

	/**
	 * Get form for the import feature
	 *
	 * @return InputfieldForm
	 */
	private function getImportForm(): InputfieldForm {

		// get upload path
		$upload_path = $this->getUploadPath();

		/** @var InputfieldForm */
		$form = $this->modules->get('InputfieldForm');
		$form->method = 'post';
		$form->action = '../savearray/';

		/** @var InputfieldRadios */
		if ($upload_path !== null) {
			$import_from_field = $this->modules->get('InputfieldRadios');
			$import_from_field->name = 'import_from';
			$import_from_field->label = $this->_('Import from');
			$import_from_field->optionColumns = 1;
			$import_from_field->icon = 'toggle-on';
			$import_from_field->value = 'text';
			$import_from_field->addOptions([
				'text' => $this->_('Text input'),
				'file' => $this->_('File upload'),
			]);
			$form->add($import_from_field);
		}

		/** @var InputfieldTextarea */
		$redirects_field = $this->modules->get('InputfieldTextarea');
		$redirects_field->label = $this->_('List of redirects');
		$redirects_field->icon = 'paste';
		// note: technically speaking commas are valid characters in URLs, so this may throw off the importer if a URL
		// contains a comma (see https://stackoverflow.com/a/1547940/1397709 for details).
		$redirects_field->description = $this->_('Comma separated list, where each line contains one redirect (redirect_from,redirect_to).');
		$redirects_field->notes = implode("\n", [
			$this->_('Example') . ":\n",
			$this->_('/campaign/,/products/tools/offers/'),
			$this->_('/another-campaign/,https://www.example.com'),
			$this->_('/index.php?page=2,/about-us/'),
			$this->_('/shop/products/*,/products/'),
		]);
		$redirects_field->name = 'redirects';
		$redirects_field->rows = 15;
		if ($upload_path !== null) {
			$redirects_field->showIf = 'import_from=text';
		}
		$form->add($redirects_field);

		if ($upload_path !== null) {
			/** @var InputfieldFile */
			$file_field = $this->modules->get('InputfieldFile');
			$file_field->name = 'file';
			$file_field->label = $this->_('Upload file');
			$file_field->description = $this->_('Import redirects by uploading a CSV file. Each row should contain two comma separated values: local source path (1) and redirect target (2).');
			$file_field->notes = $this->_("1. Source path should be a non-existing path on current site (e.g. /some/path/).\n2. Redirect target may be local path (/path/to/page/), external URL (https://www.example.com/), or page ID prefixed with a caret (e.g. ^1234).");
			$file_field->icon = 'upload';
			$file_field->extensions = 'csv';
			$file_field->overwrite = 'true';
			$file_field->maxFiles = 1;
			$file_field->descriptionRows = 0;
			$file_field->destinationPath = $upload_path;
			$file_field->showIf = 'import_from=file';
			$form->add($file_field);
		}

		/** @var InputfieldButton */
		$button_submit = $this->modules->get('InputfieldButton');
		$button_submit->type = 'submit';
		$button_submit->value = $this->_('Add New Redirects');
		$form->add($button_submit);

		return $form;
	}

	/**
	 * Get upload path
	 *
	 * Check if upload path exists; if not found, attempt to create it.
	 *
	 * @return string|null Upload path or null if not found and unable to create
	 */
	private function getUploadPath(): ?string {
		$upload_path = $this->config->paths->cache . 'ProcessRedirects/';
		if (!is_dir($upload_path) && !wireMkdir($upload_path)) {
			return null;
		}
		return $upload_path;
	}

	/**
	 * Save a redirect into the database
	 *
	 * @param string $from
	 * @param string $to
	 * @param int $id
	 * @return int 0 for failure, 1 for add (new redirect), 2 for edit (existing redirect)
	 */
	private function saveRedirect(string $from, string $to, int $id = 0): int {

		$from = $this->formatURL($this->addUrlSlashes($from));
		$to = $this->sanitizer->url($to);

		// if target address is a relative path (local URL) and points to an existing page, store a page ID instead;
		// we're also going to add a caret prefix (^[page ID]) to make the stored ID easily distinguishable
		if (strpos($to, '/') === 0) {
			$target_page = $this->pages->get($to);
			if ($target_page->id && !$target_page->isTrash()) {
				$to = '^' . $target_page->id;
			}
		}

		// if 'id' argument is zero, we're adding a new redirect
		if ($id === 0) {
			$stmt = $this->database->prepare("
				INSERT INTO " . self::TABLE_NAME . " (redirect_from, redirect_to)
				VALUES (:from, :to)
				ON DUPLICATE KEY UPDATE redirect_from = VALUES(redirect_from), redirect_to = VALUES(redirect_to)
			");
			$stmt->bindParam('from', $from, \PDO::PARAM_STR);
			$stmt->bindParam('to', $to, \PDO::PARAM_STR);
			return $stmt->execute() ? $stmt->rowCount() : 0;
		}

		// nope, looks like we're updating existing redirect
		$stmt = $this->database->prepare("
			UPDATE " . self::TABLE_NAME . "
			SET redirect_from = :from, redirect_to = :to
			WHERE id = :id
		");
		$stmt->bindParam('from', $from, \PDO::PARAM_STR);
		$stmt->bindParam('to', $to, \PDO::PARAM_STR);
		$stmt->bindParam('id', $id, \PDO::PARAM_INT);
		return $stmt->execute() ? 2 : 0;
	}

	/**
	 * Add slashes to URL
	 *
	 * @param string $url
	 * @return string
	 */
	private function addUrlSlashes(string $url): string {
		if (substr($url, 0, 1) != "/") {
			$url = "/" . $url;
		}
		return $url;
	}

	/**
	 * Format URL mimicking our JavaScript features (js/admin.js)
	 *
	 * @param string $uri Raw URI
	 * @return string Encoded URI
	 */
	private function formatURL(string $uri): string {
		return str_replace(' ', '%20', trim($uri));
	}

	/**
	 * Get instructions inputfield
	 *
	 * @return InputfieldMarkup
	 */
	private function getInstructions(): InputfieldMarkup {

		/** @var InputfieldMarkup */
		$instructions = $this->modules->get('InputfieldMarkup');
		$instructions->label = $this->_('Instructions');
		$instructions->value = $this->sanitizer->entitiesMarkdown(implode("\n", [
			$this->_('The value in the "Redirect From" field should be a local, relative path — such as `/some/path/`. Provided path must also not match that of any existing page; existing page always takes precedence over a redirect, effectively rendering the redirect inactive.') . "\n",
			$this->_('Examples of supported values:'),
			$this->_('- Path with one or more parts: `/campaign/`, `/old/site/path/`, etc.'),
			$this->_('- Path with a file extension: `/products/t-shirt.html`'),
			$this->_('- Path with a query string: `/index.php?page=2`') . "\n",
			$this->_('You may use "`*`" as a wildcard for matching zero or more characters: `/products/*` would match `/products/`, `/products/t-shirt/`, etc.'),
		]), ['fullMarkdown' => true]);
		$instructions->icon = 'info-circle';
		$instructions->collapsed = Inputfield::collapsedYes;

		return $instructions;
	}

	/**
	 * Update database schema
	 *
	 * This method applies incremental updates until latest schema version is reached. Current schema version is stored
	 * in module config.
	 *
	 * @throws WireException if database schema version isn't recognized
	 */
	private function updateDatabaseSchema() {
		while ($this->schema_version < self::SCHEMA_VERSION) {
			++$this->schema_version;
			switch ($this->schema_version) {
				case 3:
					$this->database->exec("
						ALTER TABLE " . self::TABLE_NAME . "
						MODIFY COLUMN redirect_from VARCHAR(250) NOT NULL DEFAULT '',
						MODIFY COLUMN redirect_to VARCHAR(250) NOT NULL DEFAULT ''
					");
				case 2:
					try {
						$this->database->exec("RENAME TABLE `ProcessRedirects` TO `process_redirects`");
					} catch (\Exception $e) {
						// just in case
					}
					break;
				default:
					throw new WireException(sprintf(
						"Unrecognized database schema version %s",
						$this->schema_version
					));
			}
			$this->modules->saveConfig($this, 'schema_version', $this->schema_version);
		}
	}

	/**
	 * Install method
	 *
	 * This method gets triggered when this module is installed.
	 */
	public function ___install(): void {
		parent::___install();
		$this->database->query("
			CREATE TABLE " . self::TABLE_NAME . " (
				id int unsigned NOT NULL auto_increment,
				counter int unsigned DEFAULT 0,
				redirect_from varchar(250) NOT NULL DEFAULT '',
				redirect_to varchar(250) NOT NULL DEFAULT '',
				PRIMARY KEY(id),
				UNIQUE KEY(redirect_from)
			) ENGINE = MYISAM;
		");
		$this->modules->saveConfig($this, 'schema_version', self::SCHEMA_VERSION);
	}

	/**
	 * Uninstall method
	 *
	 * This method gets triggered when this module is uninstalled.
	 */
	public function ___uninstall(): void {
		parent::___uninstall();
		$this->database->query("DROP TABLE IF EXISTS " . self::TABLE_NAME);
	}
}