ImageReferenceHookHelper.module

<?php

namespace ProcessWire;

// todos: open inputfield in repeaters on page edit load

class ImageReferenceHookHelper extends WireData implements Module
{
    /**
     * Return an array of module information
     *
     * @return array
     */
    public static function getModuleInfo()
    {
        return array(
            'title' => 'Hook Helper Module for FieldtypeImageReference',
            'version' => 212,
            'summary' => __('Adds hooks to Pagefiles to restrict deletion of images that are used by FieldtypeImageReference.'),
            'author' => 'Gerhard Sitzmann',
            'href' => '',
            'autoload' => true,
            'requires' => array(
                'FieldtypeImageReference',
                'PHP>=7.1.0',
                'ProcessWire>=3.0.120'
            )
        );
    }

    public function init()
    {

        $this->addHookBefore('Pagefiles::delete', $this, 'preventDeletion');
        // $this->addHookBefore('InputfieldFile::processInputDeleteFile', $this, 'preventMessage');
        // todo: prevent falsy message that file has been deleted. how to remove message from session from within hook function?

        // load page in page edit process
        // $this->addHookBefore('ProcessPageEdit::loadPage', $this, 'loadImageReferenceVirtualpage');
    }

    /**
     * Executes before an image gets deleted that lives on a page which holds images for FieldtypeImageReference
     * If references to that image are found on other pages, deletion is prevented and error messages are shown.
     *
     * @param Hookevent $event
     * @return void
     */
    public function preventDeletion(Hookevent $event)
    {
        $thisFieldname = $event->object->field;
        // get fields of type imagereference that have this imagesfield assigned
        $fields = $this->getRelevantFields($thisFieldname);
        $deleted = $event->arguments(0);
        $editPage = $deleted->page;
        $imagePageIds = $this->getImagePageIds($fields, $editPage);
        $pageid = $deleted->page->id;
        if (!in_array($pageid, $imagePageIds)) return;
        $filename = $deleted->basename;
        $fieldnames = array_map(function ($f) {
            return $f->name;
        }, $fields);
        $pagelist = '';
        foreach ($fieldnames as $name) {
            $pages = $this->wire('pages')->find("{$name}.filename={$filename}, {$name}.pageid={$pageid}, include=all");
            if ($pages->count) {
                $label = $pages->first()->getField($name)->label;
                $pagelist .= sprintf($this->_("Remove image from field: %s on following pages:"), "<em>{$label}</em>");
                $pagelist .= '<ul>';
                foreach ($pages as $p) {
                    $urlParam = "&field={$name}";
                    if (strpos($p->template->name, 'repeater_') !== false) { // case page is a repeaterpage
                        // $field = $p->getField($name);
                        // $inputfield = $field->getInputfield($p);
                        $repeaterfieldName = substr($p->template->name, strlen('repeater_'));
                        $urlParam = "&field={$repeaterfieldName}";
                    }
                    $p = $this->getPageToEdit($p);
                    $pagelist .= "<li>" 
                    . $this->_('Page title') . ": <em>{$p->title}</em>, " 
                    . $this->_('Page path') . ": <em>{$p->path}</em>
                     &nbsp;<a href='{$p->editUrl}{$urlParam}' title='" . $this->_('Edit page in new tab') . 
                    "' target='_blank'><strong>" . $this->_('Edit page') . "</strong></a></li>";
                }
                $pagelist .= '</ul>';
            }
        }
        if ($pagelist) {
            $message = sprintf(
                $this->_('You cannot delete image %s as it is being used on other pages.'),
                "<em>{$filename}</em>"
            ) . '<br>';
            $message .= "{$pagelist}<br>";
            $message .= $this->_('After all references are removed, you may delete the image');
            $imgInput = $event->object->field->getInputfield($event->object->page);
            $this->error($message, Notice::allowMarkup);
            $imgInput->error(sprintf($this->_("Image %s cannot be deleted (follow instructions at the top)"), $filename));
            $event->replace = true; // prevents deletion
        }
    }

    /**
     * loads an instance of ImageReferenceVirtualpage into page edit screen
     *
     * @param Hookevent $event
     * @return Page ImageReferenceVirtualpage object
     */
    public function loadImageReferenceVirtualpage(Hookevent $event) {
        $id = $event->arguments(0);
        $imagereferencefield = $this->wire('input')->imagereferencefield;
        if(!$imagereferencefield) return;
        if($id != 999999999) return;
        $event->replace = true;
        $path = $this->wire('config')->paths->templates . $this->wire('fields')->get($imagereferencefield)->folderpath;
        $vPage = new ImageReferenceVirtualpage($path);
        $vPage->populateImages();
        $event->return = $vPage;

    }

    /**
     * prevent processing of delete request to avoid falsy session notification about deletion 
     *
     * @param Hookevent $event
     * @return void
     */
    public function preventMessage(Hookevent $event)
    {
        $this->wire('session')->removeNotices();
    }

    /**
     * Collects IDs of all pages and their children that  hold images for fields of type FieldtypeImageReference
     *
     * @param array $fields all relevant fields of type FieldtypeImageReference
     * @param Page $editPage page that is being edited
     * @return array array of page ids
     */
    public function getImagePageIds($fields, $editPage)
    {
        $ids = array();
        foreach ($fields as $f) {
            if($f->imagespage) $ids[] = $f->imagespage;
        }
        $pages = $this->wire('pages')->find($ids, array('include' => 'hidden'));
        foreach ($fields as $field) {
            if ($field->includechildren) {
                foreach ($pages as $p) {
                    $pages->add($p->children('include=all'));
                }
            }
            if($field->fromeditpage) $pages->add($editPage);
        }
        return $pages->explode('id');
    }

    /**
     * get names of imagereference fields that have an imagesfield with name $fieldName assigned
     *
     * @param string $fieldName name of the imagesfield
     * @return array array of fields of type FieldtypeImageReference
     */
    public function getRelevantFields($fieldName)
    {
        $fields = array();
        foreach ($this->wire('fields') as $f) {
            if (!$f->type instanceof FieldtypeImageReference) continue;
            if (( !empty($f->imagesfields) && in_array($fieldName, $f->imagesfields) ) ||(!empty($f->imagesfieldspage) && in_array($fieldName, $f->imagesfieldspage ))) $fields[] = $f;
        }
        return $fields;
    }

    /**
     * checks if $page is a repeaterpage and travels up the $page's parents until it is not a repeater page
     * used so that editors are not presented with links to internal repeater pages
     *
     * @param Page $page
     * @return Page
     */
    public function getPageToEdit($page)
    {
        if (strpos($page->template->name, 'repeater_') === false) return $page;
        while (strpos($page->template->name, 'repeater_') !== false) {
            $page = $page->getForPage();
        }
        return $page;
    }
}