Subversion Repositories web.active

<?php namespace ProcessWire;

/**
 * ProcessWire Repeater Fieldtype
 *
 * Maintains a collection of fields that are repeated for any number of times.
 *
 * For documentation about how Fieldtypes work, see: 
 * /wire/core/Fieldtype.php
 * /wire/core/FieldtypeMulti.php
 * 
 * ProcessWire 3.x, Copyright 2016 by Ryan Cramer
 * https://processwire.com
 *
 * @todo: automatic sorting.
 * @todo: look into possibility of only creating repeater parents when there is at least one item.
 * 
 * @property int $repeatersRootPageID
 * @method saveConfigInputfields(Field $field, Template $template, Page $parent)
 * @method readyPageSaved(Page $readyPage, Page $ownerPage, Field $field) Hook called when ready page is saved
 * 
 * Page status notes for repeater items: 
 * - Unpublished & Hidden: Ready page, not yet used. Appears in unformatted repeater PageArray but user has not saved it.
 * - Unpublished & On: Publish requested and can be published as long as no input errors. 
 * - Unpublished & NOT On: Item has been unpublished.
 * 
 * Unpublished or hidden pages do not appear in formatted PageArray value, only in unformatted. 
 *
 */

class FieldtypeRepeater extends Fieldtype implements ConfigurableModule {

  public static function getModuleInfo() {
    return array(
      'title' => __('Repeater', __FILE__), // Module Title
      'summary' => __('Maintains a collection of fields that are repeated for any number of times.', __FILE__), // Module Summary
      'version' => 106,
      'autoload' => true,
      'installs' => 'InputfieldRepeater'
      );
  }

  const templateNamePrefix = 'repeater_';
  const fieldPageNamePrefix = 'for-field-';
  const repeaterPageNamePrefix = 'for-page-'; 
  const defaultRepeaterMaxItems = 0;

  const collapseExisting = 0;
  const collapseNone = 3;
  const collapseAll = 1;
  
  const loadingNew = 0;
  const loadingAll = 1;
  const loadingOff = 2;

  /**
   * When non-zero, a deletePageField function call occurred and we shouldn't re-create any repeater parents
   *
   * The value it contains is the ID of the parent page used by the field for repeater items
   *
   */
  protected $deletePageField = 0;

  /**
   * Page assigned by our ProcessPageEdit::ajaxSave hook, kept for comparison for editable() access
   * 
   * @var Page
   *
   */
  protected $ajaxPage;

  /**
   * Name of field that appeared in HTTP_X_FIELDNAME, before it was modified
   *
   */
  protected $ajaxFieldName = '';

  /**
   * Construct the Repeater Fieldtype
   *
   */
  public function __construct() {

    require_once(dirname(__FILE__) . '/RepeaterPage.php'); 
    require_once(dirname(__FILE__) . '/RepeaterPageArray.php'); 

    $this->set('repeatersRootPageID', 0);   
  }

  /** 
   * Setup a hook to Pages::delete so that we can remove references when pages are deleted
   *
   */
  public function init() {
    $this->wire('pages')->addHookAfter('deleteReady', $this, 'hookPagesDelete');
    parent::init();
    // $this->initFields();
  }

  /** 
   * Setup a hook so that we can keep ajax saves working with ProcessPageEdit
   *
   */
  public function ready() {
    // if(in_array('WirePageEditor', wireClassImplements((string) $this->wire('page')->process))) { // @todo
    // $this->initFields(); // intentionally repeated from init()

    // make sure that all templates used by repeater pages enforce a Page type of RepeaterPage
    foreach($this->wire('fields') as $field) {
      $fieldtype = $field->type;
      if(!$fieldtype || !$fieldtype instanceof FieldtypeRepeater) continue;
      /** @var FieldtypeRepeater $fieldtype */
      $template = $fieldtype->getRepeaterTemplate($field);
      if(!$template) continue;
      $class = $fieldtype->getPageClass();
      if(__NAMESPACE__ && $class) $class = wireClassName($class);
      $_class = $template->get('pageClass'); 
      if($class === $_class) continue;
      $template->set('pageClass', $class); 
      $template->save();
    }
 
    /** @var Page $page */
    $page = $this->wire('page');
    
    /** @var Process|null $process */
    $process = $page->process;
    
    /** @var User $user */
    $user = $this->wire('user');
    
    /** @var Config $config */
    $config = $this->wire('config');
    
    /** @var WireInput $input */
    $input = $this->wire('input');
    
    $inEditor = $process == 'ProcessPageEdit' || $process == 'ProcessProfile';
    $isSuperuser = $user->isSuperuser();
    
    if($inEditor) {
      // ProcessPageEdit or ProcessProfile
      $this->addHookBefore('ProcessPageEdit::ajaxSave', $this, 'hookProcessPageEditAjaxSave');
    }
    
    if($inEditor && $config->ajax) {
      // handle scenario of repeater within repeater field
      $fieldName = $input->get('field');
      $pageID = (int) $input->get('id');
      if($pageID && strpos($fieldName, '_repeater') && preg_match('/^(.+)_repeater\d+$/', $fieldName, $matches)) {
        $editPage = $this->wire('pages')->get($pageID);
        if($editPage->id && strpos($editPage->template->name, self::templateNamePrefix) === 0) {
          // update field name to exclude the _repeater1234 part at the end, so that PageEdit recognizes it
          $input->get->__set('field', $matches[1]);
        }
      }
    }
    
    if(!$inEditor && !$user->isGuest() && !$isSuperuser && $user->hasPermission('page-edit')) {
      // allow for front-end editor to also trigger an inEditor=true condition
      if(strpos($page->url, $config->urls->admin) === false && $page->editable()) {
        if($this->wire('modules')->isInstalled('PageFrontEdit')) $inEditor = true;
      }
    }
  
    if($inEditor && !$isSuperuser) {
      // need an extra hook to handle permissions
      $this->addHookAfter('PagePermissions::pageEditable', $this, 'hookPagePermissionsPageEditableAjax');
    }
    
    $this->addHookBefore('PageFinder::getQuery', $this, 'hookPageFinderGetQuery'); 

  }

  /**
   * Initialize repeater fields at boot
   * 
  protected function initFields() {
    
    static $initFields = array();
    $className = $this->className();
    if(isset($initFields[$className])) return;
    
    $fields = $this->wire('fields');
    if(!$fields) return;
    
    // make sure that all templates used by repeater pages enforce a Page type of RepeaterPage
    foreach($fields as $field) {
      if(!$field->type || $field->type->className() != $className) continue; 
      $template = $this->getRepeaterTemplate($field);
      if(!$template) continue;
      if(__NAMESPACE__) {
        $template->setQuietly('pageClass', wireClassName($this->getPageClass()));
      } else {
        $template->setQuietly('pageClass', $this->getPageClass());
      }
    }
    
    $initFields[$className] = 1; 
  }
   */
  
  /**
   * Get class name to use Field objects of this type (must be class that extends Field class)
   *
   * Return blank if default class (Field) should be used.
   *
   * @param array $a Field data from DB (if needed)
   * @return string Return class name or blank to use default Field class
   * @since 3.0.146
   *
   */
  public function getFieldClass(array $a = array()) {
    require_once(dirname(__FILE__) . '/RepeaterField.php');
    return 'RepeaterField';
  }

  /**
   * Get the class used for repeater Page objects
   * 
   * @return string
   * 
   */
  public function getPageClass() {
    return __NAMESPACE__ . "\\RepeaterPage";
  }

  /**
   * Get the class used for repeater PageArray objects
   *
   * @return string
   * 
   */
  public function getPageArrayClass() {
    return __NAMESPACE__ . "\\RepeaterPageArray";
  }

  /**
   * Hook called after PagePermissions::pageEditable() when Process is ProcessPageEdit and call is ajax
   * 
   * @param HookEvent $event
   * 
   */
  public function hookPagePermissionsPageEditableAjax(HookEvent $event) {
    
    if($event->return) return;
    
    $page = $event->arguments(0);
    if(!$page instanceof RepeaterPage) return;
    
    $forField = $page->getForField();
    $n = 0;
    
    while($page instanceof RepeaterPage) {
      $forField = $page->getForField();
      $page = $page->getForPage();
      if(++$n > 20) break;
    }
    
    if(!$page instanceof RepeaterPage) {
      // found the original owning page (forPage)
      
      $editable = null;
      /** @var User $user */
      $user = $this->wire('user');
      /** @var WireInput $input */
      $input = $this->wire('input');
      /** @var Field|null $field */
      $field = $input->get('field') ? $this->wire('fields')->get($input->get->fieldName('field')) : $forField;
    
      if($page instanceof User && $field && $field->type instanceof FieldtypeRepeater) {
        // editing a repeater field in a User
        if($user->hasPermission('user-admin')) {
          $editable = true;
        } else if($page->id === $user->id) {
          // user editing themself, repeater field
          /** @var PagePermissions $pagePermissions */
          $pagePermissions = $this->wire('modules')->get('PagePermissions');
          $editable = $pagePermissions->userFieldEditable($field);
        }
      }
      
      if($editable === null) $editable = $page->editable();
      
      $event->return = $editable;
    }
  }

  /**
   * Hook into PageFinder::getQuery
   *
   * Determines if the query is attempting to directly search a field used by a repeater. 
   * If it is, then it specifically excludes them. This is so that one could use a 'title' field
   * in both a repeater and elsewhere, and not worry about repeaters themselves appearing in 
   * search results for an admin.
   * 
   * @param HookEvent $event
   *
   */
  public function hookPageFinderGetQuery(HookEvent $event) {

    static $fieldsUsedInRepeaters = null;
    static $templatesUsedByRepeaters = array();

    /** @var Selectors $selectors */
    $selectors = $event->arguments[0]; 
    /** @var PageFinder $pageFinder */
    $pageFinder = $event->object; 
    $pageFinderOptions = $pageFinder->getOptions();

    // determine which fields are used in repeaters
    if(is_null($fieldsUsedInRepeaters)) {
      $fieldsUsedInRepeaters = array('title'); // title used by admin template (repeater parents)
      foreach($this->wire('templates') as $template) {
        if(strpos($template->name, self::templateNamePrefix) === 0) {
          $templatesUsedByRepeaters[] = $template->id; 
          foreach($template->fieldgroup as $field) {
            $fieldsUsedInRepeaters[] = $field->name; 
          }
        }
      }
    }

    // did we find a field used by a repeater in the selector?
    $found = false;

    // was include=all specified?
    $includeAll = !empty($pageFinderOptions['findAll']);

    // if user is guest, then repeater pages will already be excluded (since they don't have view access to them) so no need for extra filter
    if(!$includeAll && $this->wire('user')->isGuest()) $includeAll = true; 

    // determine if any of the fields used in the selector are also used in a repeater
    // and set $found and $includeAll as appropriate
    if(!$includeAll) foreach($selectors as $selector) {

      $fields = $selector->field; 
      if(!is_array($fields)) $fields = array($fields);

      foreach($fields as $name) {

        if(strpos($name, '.')) {
          /** @noinspection PhpUnusedLocalVariableInspection */
          list($name, $unused) = explode('.', $name); // field.subfield
        }

        // is field name one used by a repeater?
        if(in_array($name, $fieldsUsedInRepeaters)) $found = true;

        if($name == 'status' && $selector->operator == '<' && $selector->value == Page::statusMax) {
          // include=all is the same as status<Page::statusMax, so we look for that here
          $includeAll = true;
        } else if(in_array($name, array('parent', 'parent_id', 'template', 'templates_id')) && $selector->operator == '=') {
          // optimization: if parent, parent_id, template, or templates_id is given, and an equals '=' operator is used, 
          // there's no need to explicitly exclude repeaters since the parent and/or template is specific
          $includeAll = true;
        } else if($name == 'templates_id' && $selector->operator == '=' && in_array($selector->value, $templatesUsedByRepeaters)) {
          // ensure that the repeaters own queries work since they specify a templates_id
          // note: this is now redundent given the code added directly above this, but kept for clarification
          $includeAll = true;
        } else if($name == 'has_parent' && $selector->value != 1 && $selector->operator == '=' && $selector->value != '/') {
          // if has_parent is specified and is not homepage, no need to exclude results
          $includeAll = true;
        }

        if($includeAll) break;
      }
      
      if($includeAll) break;
    }

    // if field is one used by a repeater, and there was no include=all, 
    // then exclude repeaters from appearing in these PageFinder search results
    if($found && !$includeAll) {
      // for reference: $selectors->add(new SelectorNotEqual('has_parent', $this->repeatersRootPageID)); 
      $selectors->add(new SelectorNotEqual('templates_id', $templatesUsedByRepeaters)); // more efficient than has_parent
    }
  }

  /**
   * This hook is called before ProcessPageEdit::ajaxSave
   *
   * We modify the HTTP_X_FIELDNAME var to remove the "_repeater123" portion of the variable, 
   * since ProcessPageEdit doesn't know about repeaters. 
   * 
   * @param HookEvent $event
   *
   */
  public function hookProcessPageEditAjaxSave(HookEvent $event) {

    // if this isn't a repeater field we're dealing with, then abort
    if(!isset($_SERVER['HTTP_X_FIELDNAME']) || !preg_match('/^(.+)(_repeater(\d+))$/', $_SERVER['HTTP_X_FIELDNAME'], $matches)) return;
    $fieldName = $this->wire('sanitizer')->fieldName($matches[1]); 
    $repeaterPageID = (int) $matches[3]; 
    if($repeaterPageID < 1) return;

    // make sure the owning page is editable since we'll be replacing the $page param that goes to ajaxSave
    /** @var Page $ownerPage */
    $ownerPage = $event->arguments[0]; 
    if(!$ownerPage->editable()) return;

    // make sure it's a valid repeaterPage
    $repeaterPage = $this->wire('pages')->get($repeaterPageID); 
    if(!$repeaterPage->id) return; 

    // check that the given repeaterPage is actually a repeater component of the ownerPage
    if($repeaterPage->id != $ownerPage->id && !$this->isRepeaterItemValidOnPage($repeaterPage, $ownerPage)) {
      $this->error("Repeater item $repeaterPage not valid for owner page $ownerPage");
      return;
    }
    
    // repopulate the ProcessPageEdit::ajaxSave function's argument to be the repeaterPage rather than the ownerPage
    $args = $event->arguments; 
    $args[0] = $repeaterPage; 
    $event->arguments = $args; 

    // repopulate the server header to be the fieldName (sans _repeater\d+)
    $this->ajaxFieldName = $this->wire('sanitizer')->fieldName($_SERVER['HTTP_X_FIELDNAME']);
    $_SERVER['HTTP_X_FIELDNAME'] = $fieldName;

    // save a copy for comparison in our hookPageEditable function 
    $this->ajaxPage = $repeaterPage;

    // add a hook to allow edit access because some users may not have access
    // to the repeater pages themselves, and ProcessPageEdit's editable check
    // prevents them from completing the ajax save. this hook fixes that.
    $this->addHookAfter('ProcessPageEdit::ajaxEditable', $this, 'hookProcessPageEditAjaxEditable'); 

    // ensures that InputfieldFile outputs markup with the proper fieldname, including the repeater_ part
    $this->addHookBefore('InputfieldFile::renderItem', $this, 'hookInputfieldFileRenderItem'); 
  }

  /**
   * Is the given repeater item valid on the given owner page?
   * 
   * @param Page $repeaterItem
   * @param Page $ownerPage
   * @return null|Field Returns the repeater Field object that is valid, or null if not valid
   * 
   */
  protected function isRepeaterItemValidOnPage(Page $repeaterItem, Page $ownerPage) {
    
    $hasField = null;
    $repeaters = array();
    
    foreach($ownerPage->fieldgroup as $f) {
      if(!$f->type instanceof FieldtypeRepeater) continue;
      $repeaters[$f->name] = $f->name;
      $grandparent = $this->getRepeaterParent($f);
      $name = self::repeaterPageNamePrefix . $ownerPage->id; 
      $parent = $grandparent->child("name=$name, include=all");
      if(!$parent->id) continue;
      $child = $parent->child("include=all, id=$repeaterItem->id");
      if($child->id) {
        // found it, it's valid
        $hasField = $f;
        break;
      }
    }
    
    if($hasField) return $hasField;
    
    // check for nested repeater
    foreach($repeaters as $name) {
      $repeaterItems = $ownerPage->get($name);  
      if(!$repeaterItems) continue;
      if($repeaterItems instanceof PageArray) {
        foreach($repeaterItems as $nestedOwnerPage) {
          // perform recursive check
          $hasField = $this->isRepeaterItemValidOnPage($repeaterItem, $nestedOwnerPage);
          if($hasField) break;
        }
      } else if($repeaterItems instanceof RepeaterPage) {
        // for single item value (i.e. FieldtypeFieldsetPage)
        $hasField = $this->isRepeaterItemValidOnPage($repeaterItem, $repeaterItems);
      } else {
        continue;
      }
    }
    
    return $hasField;
  }

  /**
   * Temporary hook into Page::editable to capture the editable check for the page we swapped into the ajaxSave
   *
   * Prevents the 'no access' error when non-superuser attempts to perform an ajax save
   * 
   * @param HookEvent $event
   *
   */
  public function hookProcessPageEditAjaxEditable(HookEvent $event) {
    /** @var Page $page */
    $page = $event->arguments[0]; 
    $fieldName = isset($event->arguments[1]) ? $this->wire('sanitizer')->fieldName($event->arguments[1]) : '';
    if($page->id && $this->ajaxPage && $this->ajaxPage->id == $page->id) {
      $event->return = true; 
    }

    // if a fieldName was specified, double check that it's a valid field in a repeater
    if($event->return && $fieldName) {
      if(!$this->ajaxPage->hasField($fieldName)) $event->return = false;
    }
  }

  /**
   * Ensure that InputfieldFile outputs markup with the proper fieldname (including the repeater_ part)
   * 
   * @param HookEvent $event
   *
   */
  public function hookInputfieldFileRenderItem(HookEvent $event) {
    $arguments = $event->arguments; 
    $id = $arguments[1]; 
    $id = str_replace($_SERVER['HTTP_X_FIELDNAME'], $this->ajaxFieldName, $id); 
    $arguments[1] = $id; 
    $event->arguments = $arguments; 
  
    // update id attribute of the Inputfield itself
    // so that anything in InputfieldFile referring to it's overall id attribute
    // reflects the actual id attribute of the Inputfield
    /** @var Inputfield $inputfield */
    $inputfield = $event->object; 
    $id = $inputfield->attr('id');
    $id = str_replace($_SERVER['HTTP_X_FIELDNAME'], $this->ajaxFieldName, $id); 
    $inputfield->attr('id', $id); 
  }

  /**
   * Delete any repeater pages that are owned by a page that was deleted
   * 
   * @param HookEvent $event
   *
   */
  public function hookPagesDelete(HookEvent $event) {

    $page = $event->arguments[0];

    foreach($page->template->fieldgroup as $field) {
      if(!$field->type instanceof FieldtypeRepeater) continue; 
      $fieldParent = $this->wire('pages')->get($field->parent_id);  
      if(!$fieldParent->id) continue; 
      $p = $fieldParent->child('include=all, name=' . self::repeaterPageNamePrefix . $page->id);  
      if(!$p->id) continue; 
      $p->addStatus(Page::statusSystemOverride); 
      $p->removeStatus(Page::statusSystem);
      $this->message("Deleted page {$p->path}", Notice::debug); 
      $this->wire('pages')->delete($p, true);
    }
  }

  /**
   * FieldtypeRepeater instances are only compatible with other FieldtypeRepeater derived classes. 
   *
   * @param Field $field 
   * @return WireArray
   *
   */
  public function ___getCompatibleFieldtypes(Field $field) {
    $fieldtypes = parent::___getCompatibleFieldtypes($field); 
    foreach($fieldtypes as $type) if(!$type instanceof FieldtypeRepeater) $fieldtypes->remove($type); 
    return $fieldtypes; 
  }

  /**
   * Get a blank value of this type, i.e. return a blank PageArray
   *
   * @param Page $page
   * @param Field $field
   * @return PageArray
   *
   */
  public function getBlankValue(Page $page, Field $field) {
    $class = $this->getPageArrayClass();
    $pageArray = $this->wire(new $class($page, $field));
    $pageArray->setTrackChanges(true);
    return $pageArray;
  }

  /**
   * Returns a unique name for a repeater page
   *
   * @return string
   *
   */
  public function getUniqueRepeaterPageName() {
    static $cnt = 0;
    return str_replace('.', '-', microtime(true)) . '-' . (++$cnt);
  }

  /**
   * Get the class for the Inputfield (template method)
   * 
   * @return string
   * 
   */
  protected function getInputfieldClass() {
    return 'InputfieldRepeater';
  }

  /**
   * Return an InputfieldRepeater, ready to be used
   *
   * @param Page $page Page being edited
   * @param Field $field Field that needs an Inputfield
   * @return Inputfield
   *
   */
  public function getInputfield(Page $page, Field $field) {

    $inputfield = $this->wire('modules')->get($this->getInputfieldClass()); 
    $inputfield->set('page', $page); 
    $inputfield->set('field', $field);
    $inputfield->set('repeaterMaxItems', (int) $field->get('repeaterMaxItems'));
    $inputfield->set('repeaterMinItems', (int) $field->get('repeaterMinItems')); 
    $inputfield->set('repeaterDepth', (int) $field->get('repeaterDepth'));
    $inputfield->set('repeaterReadyItems', 0);  // ready items deprecated

    $pageArray = $page->getUnformatted($field->name); 
    if(!$pageArray instanceof PageArray) $pageArray = $this->getBlankValue($page, $field); 
    
    // we want to check that this page actually has the field before creating ready pages
    // this is just since PW may call getInputfield with a dummyPage (usually homepage) for tests
    // and we don't want to go on creating readyPages or setting up parent/template where not used
    if($page->hasField($field)) {
      if(!count($pageArray)) {
        // force the wakeup function to be called since it wouldn't have been for a field that doesn't yet exist
        $pageArray = $this->wakeupValue($page, $field, null);
      }
    }
    $page->set($field->name, $pageArray); 
    $inputfield->attr('value', $pageArray); 

    return $inputfield; 
  }

  /**
   * Get next page ready to be used as a new repeater item, creating it if it doesn't already exist
   * 
   * @param Page $page
   * @param Field $field
   * @param PageArray|Page $value
   * @param array $notIDs Optional Page IDs that should be excluded from the next ready page
   * @return Page
   * 
   */
  public function getNextReadyPage(Page $page, Field $field, $value = null, array $notIDs = array()) {
    $readyPage = null;
    if($value) {
      if($value instanceof Page) $value = array($value); 
      foreach($value as $item) {
        /** @var Page $item */
        if($item->hasStatus(Page::statusUnpublished) 
          && $item->hasStatus(Page::statusHidden) 
          && $item->id
          && substr($item->name, -1) !== 'c' // cloned item
          && !in_array($item->id, $notIDs)) {
          // existing/unused ready item that we will reuse  
          $readyPage = $item;
          // touch the modified date for existing page to identify it as still current
          $query = $this->wire('database')->prepare('UPDATE pages SET modified=NOW(), modified_users_id=:user_id WHERE id=:id');
          $query->bindValue(':id', $readyPage->id, \PDO::PARAM_INT);
          $query->bindValue(':user_id', $this->wire('user')->id, \PDO::PARAM_INT);
          $query->execute();
          break;
        }
      }
    }
    if(!$readyPage) {
      $readyPage = $this->getBlankRepeaterPage($page, $field);
      $readyPage->sort = count($value);
      $readyPage->save();
    }
    $readyPage->setQuietly('_repeater_new', 1);
    $this->readyPageSaved($readyPage, $page, $field); 
    return $readyPage;
  }

  /**
   * Hook called when a ready page is saved
   * 
   * @param Page $readyPage
   * @param Page $ownerPage
   * @param Field $field
   * 
   */
  protected function ___readyPageSaved(Page $readyPage, Page $ownerPage, Field $field) {
    // for hooks only
  }

  /**
   * Returns a blank page ready for use as a repeater
   *
   * Also ensures that the parent repeater page exists.
   * This is public so that the Inputfield can pull from it too.
   *
   * @param Field $field
   * @param Page $page The page that the repeater field lives on
   * @return Page
   *
   */
  public function getBlankRepeaterPage(Page $page, Field $field) {
    if($this->deletePageField === $field->get('parent_id')) $this->deletePageField = 0;
    $parent = $this->getRepeaterPageParent($page, $field); 
    $class = $this->getPageClass();
    $readyPage = $this->wire(new $class());
    $readyPage->template = $this->getRepeaterTemplate($field);
    if($parent->id) $readyPage->parent = $parent; 
    $readyPage->addStatus(Page::statusOn); // request publish for new items by defalt
    $readyPage->addStatus(Page::statusHidden); // ready page
    $readyPage->addStatus(Page::statusUnpublished); // ready page
    $readyPage->name = $this->getUniqueRepeaterPageName();
    $readyPage->setForPage($page);
    $readyPage->setForField($field);
    return $readyPage; 
  }

  /**
   * Given a raw value (value as stored in DB), return the value as it would appear in a Page object
   *
   * Something to note is that this wakeup function is different than most in that the $value it is given 
   * is just an array like array('data' => 123, 'parent_id' => 456) -- it doesn't actually contain any of the
   * repeater page data other than saying how many there are and the parent where they are stored. So this 
   * wakeup function can technically do it's job without even having the $value, unlike most other fieldtypes.
   *
   * @param Page $page
   * @param Field $field
   * @param array $value
   * @return PageArray $value
   *
   */
  public function ___wakeupValue(Page $page, Field $field, $value) {

    $parent_id = null; 
    $field_parent_id = $field->get('parent_id'); 
    $template_id = $field->get('template_id'); 
    // $outputFormatting = $page->outputFormatting();

    // if it's already in the target format, leave it
    if($value instanceof PageArray) return $value; 

    // if this field has no parent set, just return a blank pageArray
    if(!$field_parent_id) return $this->getBlankValue($page, $field); 

    if(is_array($value) && !empty($value['parent_id'])) {
      // this is what we get if there was a record in the DB and the parent has been setup
      $parent_id = (int) $value['parent_id']; 

    } else {
      // no record in the DB yet, so setup the parent if it isn't already
      $parent = $this->getRepeaterPageParent($page, $field); 
      $parent_id = $parent->id; 
    }

    // get the template_id used by the repeater pages
    if(!$template_id) $template_id = $this->getRepeaterTemplate($field)->id; 

    // if we were unable to determine a parent for some reason, then just return a blank pageArray
    if(!$parent_id || !$template_id) return $this->getBlankValue($page, $field); 

    // build the selector: find pages with our parent
    // $selector = "parent_id=$parent_id, templates_id=$template_id, sort=sort, check_access=0";
    $selector = "parent_id=$parent_id, templates_id=$template_id, sort=sort, include=all";

    /*
    if($outputFormatting) { 
      // if an unpublished page is being previewed, let unpublished items be shown (ready items will be removed afterwards)
      if($page->hasStatus(Page::statusUnpublished) && $page->editable($field->name)) $selector .= ", include=all"; 
    } else {
      // if the page is an edit state, then make it include the hidden/unpublished ready pages
      if($page->editable($field->name)) $selector .= ", include=all";
    }
    */
    
    $template = $this->wire('templates')->get((int) $template_id);
    $pageArrayClass = $this->getPageArrayClass();
    $pageArray = $this->wire(new $pageArrayClass($page, $field)); 

    // load the repeater pages
    $options = array(
      'cache' => false, 
      'caller' => $this->className() . '::wakeupValue',
      'loadOptions' => array(
        'cache' => false, 
        'parent_id' => $parent_id, 
        'template' => $template,
        'pageClass' => $this->getPageClass(),
        'pageArray' => $pageArray, 
      )
    );
    
    $pageArray = $this->wire('pages')->find($selector, $options);
    $pageArray->resetTrackChanges(true); 

    return $pageArray; 

  }

  /**
   * Given an 'awake' value, as set by wakeupValue, convert the value back to a basic type for storage in DB. 
   *
   * In this case, the sleepValue doesn't represent the actual value as they are stored in pages. 
   *              
   * @param Page $page
   * @param Field $field
   * @param string|int|array|object $value
   * @return array
   *
   */
  public function ___sleepValue(Page $page, Field $field, $value) {

    $sleepValue = array();

    // if value is already an array, then just return it
    if(is_array($value)) return $sleepValue; 
  
    // if $value isn't a PageArray, then abort  
    if(!$value instanceof PageArray) return array();
    
    /** @var PageArray $value */

    $count = 0; 
    $ids = array();

    // iterate through the array and count how many published we have
    foreach($value as $p) {
      if(!$p->id || $p->isHidden() || $p->isUnpublished()) continue; 
      $ids[] = $p->id;
      $count++;
    }

    // our sleepValue is simply just the total number of repeater pages
    // a cache of page IDs in 'data' (for export portability)
    // and a quick reference to the parent where they are contained
    $sleepValue = array(
      'data' => implode(',', $ids),
      'count' => $count,
      'parent_id' => $this->getRepeaterPageParent($page, $field)->id, 
      );  

    return $sleepValue;
  }

  /**
   * Export repeater value
   * 
   * @param Page $page
   * @param Field $field
   * @param RepeaterPageArray $value
   * @param array $options
   *  - `minimal` (bool): Export a minimal array of just fields and values indexed by repeater page name (default=false)
   * @return array
   * 
   */
  public function ___exportValue(Page $page, Field $field, $value, array $options = array()) {
    
    $a = array();
    if(!WireArray::iterable($value)) return $a;
  
    if(!empty($options['minimal']) || !empty($options['FieldtypeRepeater']['minimal'])) {
      // minimal export option includes only fields data
      
      foreach($value as $k => $p) {
        /** @var Page $p */
        if($p->isUnpublished()) continue;
        $v = array(); 
        foreach($p->template->fieldgroup as $f) {
          if(!$p->hasField($f)) continue;
          $v[$f->name] = $f->type->exportValue($p, $f, $p->getUnformatted($f->name), $options);
        }
        $a[$p->name] = $v;
      }
      
    } else {
      // regular export
      /** @var PagesExportImport $exporter */
      $exporter = $this->wire(new PagesExportImport());
      $a = $exporter->pagesToArray($value, $options);
    }
    
    return $a;
  }

  /**
   * Import repeater value previously exported by exportValue()
   * 
   * @param Page $page
   * @param Field $field
   * @param array $value
   * @param array $options
   * @return bool|PageArray
   * @throws WireException
   * 
   */
  public function ___importValue(Page $page, Field $field, $value, array $options = array()) {
    
    if(empty($value['type']) || $value['type'] != 'ProcessWire:PageArray') {
      throw new WireException("$field->name: Invalid repeater importValue() \$value argument"); 
    }
    
    if(!$page->id) {
      $page->trackChange($field->name); 
      throw new WireException("$field->name: Repeater will import after page is created");
    }
    
    $repeaterParent = $this->getRepeaterPageParent($page, $field);
    $repeaterTemplate = $this->getRepeaterTemplate($field);
    $repeaterPageClass = $this->getPageClass();
    $repeaterPageArrayClass = $this->getPageArrayClass();
    $parentPath = $repeaterParent->path();
    $commit = isset($options['commit']) ? (bool) $options['commit'] : true;
    $messages = array();
    $numAdded = 0;
    $changesByField = array();
    $numUpdated = 0;
    $numDeleted = 0;
    $itemsAdded = array();
    $itemsDeleted = array();
    $importItemNames = array();
    $existingValue = $page->get($field->name); 
    
    if(!$existingValue instanceof PageArray) { // i.e. FieldsetPage
      $existingValue = $existingValue->id ? array($existingValue) : array();
    }
    
    // update paths for local
    foreach($value['pages'] as $key => $item) {
      $name = $item['settings']['name'];
      if(strpos($name, self::repeaterPageNamePrefix) === 0 && count($value['pages']) == 1) {
        $name = self::repeaterPageNamePrefix . $page->id;  // i.e. FieldsetPage 
        $value['pages'][$key]['settings']['name'] = $name;
      }
      $path = $parentPath . $name . '/';
      $importItemNames[$name] = $name;
      $value['pages'][$key]['path'] = $path;
      $p = $this->wire('pages')->get($path); 
      if($p->id) continue; // already exists
      
      // from this point forward, it is assumed we are creating a new repeater item
      $numAdded++;
      $page->trackChange($field->name); 
      
      if($commit) {
        // create new repeater item, ready to be populated
        /** @var RepeaterPage $readyPage */
        $p = $this->wire(new $repeaterPageClass());
        if($repeaterParent->id) $p->parent = $repeaterParent;
        $p->template = $repeaterTemplate;
        $p->name = $name;
        $p->setForPage($page);
        $p->setForField($field);
        $p->save();
        $itemsAdded[$p->id] = $p;
        if($p->name != $name) $importItemNames[$p->name] = $p->name;
      }
    }

    if($page->get('_importType') == 'update') {
      foreach($existingValue as $p) {
        if(!isset($importItemNames[$p->name])) {
          $itemsDeleted[] = $p;
          $numDeleted++;
        }
      }
    }
  
    /** @var RepeaterPageArray $pageArray */
    $pageArray = $this->wire(new $repeaterPageArrayClass($page, $field));
    
    $importOptions = array(
      'commit' => $commit, 
      'create' => true, 
      'update' => true, 
      'delete' => true, // @todo 
      'pageArray' => $pageArray
    );
    
    /** @var PagesExportImport $importer */
    $importer = $this->wire(new PagesExportImport()); 
    $pageArray = $importer->arrayToPages($value, $importOptions);   
    
    foreach($pageArray as $p) {
      $changes = $p->get('_importChanges'); 
      if(!count($changes)) continue;
      if(isset($itemsAdded[$p->id]) || !$p->id) continue;
      $numUpdated++;
      foreach($changes as $fieldName) {
        if(!isset($changesByField[$fieldName])) $changesByField[$fieldName] = 0;
        $changesByField[$fieldName]++;
      }
      $this->wire('notices')->move($p, $pageArray, array('prefix' => "$field->name (id=$p->id): ")); 
    }
    
    if($numDeleted && $commit) {
      foreach($itemsDeleted as $p) {
        $this->wire('pages')->delete($p); 
      }
    }
    
    if($numUpdated) {
      $updateCounts = array();
      foreach($changesByField as $fieldName => $count) {
        $updateCounts[] = "$fieldName ($count)";  
      }
      $messages[] = "$numUpdated page(s) updated – " . implode(', ', $updateCounts);
    }
    
    if($numAdded) $messages[] = "$numAdded new page(s) added";
    if($numDeleted) $messages[] = "$numDeleted page(s) DELETED";
    
    foreach($messages as $message) {
      $pageArray->message("$field->name: $message");
    }
    
    $pageArray->resetTrackChanges();
    
    $totalChanges = $numUpdated + $numAdded + $numDeleted;
    if(!$totalChanges) {
      // prevent it from being counted as a change when import code sets the value back to the page
      $page->setQuietly($field->name, $pageArray);
    }
  
    return $pageArray;
  }

  /**
   * Get associative array of options (name => default) that Fieldtype supports for importValue
   * 
   * #pw-internal
   *
   * @param Field $field
   * @return array
   *
   */
  public function getImportValueOptions(Field $field) {
    $options = parent::getImportValueOptions($field);
    $options['test'] = true; 
    return $options; 
  }

  /**
   * Get information used by selectors for querying this field
   *
   * @param Field $field
   * @param array $data
   * @return array
   *
   */
  public function ___getSelectorInfo(Field $field, array $data = array()) {
    $info = $this->wire('modules')->get('FieldtypePage')->getSelectorInfo($field, $data);
    $info['operators'] = array(); // force it to be non selectable, subfields only
    return $info;
  }

  /**
   * Return the parent used by the repeater pages for the given Page and Field
   *
   * i.e. /processwire/repeaters/for-field-name/for-page-name/
   *
   * @param Page $page
   * @param Field $field
   * @return Page
   *
   */
  protected function getRepeaterPageParent(Page $page, Field $field) {

    $repeaterParent = $this->getRepeaterParent($field);
    $parent = $repeaterParent->child('name=' . self::repeaterPageNamePrefix . $page->id . ', include=all');
    if($parent->id) return $parent;

    $parent = $this->wire('pages')->newPage($repeaterParent->template);
    $parent->parent = $repeaterParent; 
    $parent->name = self::repeaterPageNamePrefix . $page->id;
    $parent->title = $page->name;
    $parent->addStatus(Page::statusSystem);

    // exit early if a field is in the process of being deleted
    // so that a repeater page parent doesn't get automatically re-created
    if($this->deletePageField === $field->get('parent_id')) return $parent; 

    $parent->save();
    $this->message("Created '$field' page parent: " . $parent->path, Notice::debug); 

    return $parent; 
  }

  /**
   * Return the repeater parent used by $field, i.e. /processwire/repeaters/for-field-name/
   * 
   * Auto generate a repeater parent page named 'for-field-[id]', if it doesn't already exist
   *
   * @param Field $field
   * @return Page
   * @throws WireException
   *
   */
  protected function getRepeaterParent(Field $field) {

    $parentID = (int) $field->get('parent_id');
    if($parentID) {
      $parent = $this->wire('pages')->get($parentID); 
      if($parent->id) return $parent; 
    }

    
    $repeatersRootPage = $this->wire('pages')->get((int) $this->repeatersRootPageID); 
    $parentName = self::fieldPageNamePrefix . $field->id; 

    // we call this just to ensure it exists, so template is created if it doesn't exist yet
    if(!$field->get('template_id')) $this->getRepeaterTemplate($field); 

    $parent = $repeatersRootPage->child("name=$parentName, include=all"); 

    if(!$parent->id) {
      $parent = $this->wire('pages')->newPage($repeatersRootPage->template);
      $parent->parent = $repeatersRootPage; 
      $parent->name = $parentName;
      $parent->title = $field->name; 
      $parent->addStatus(Page::statusSystem);
      $parent->save();
      $this->message("Created '$field' parent: $parent->path", Notice::debug); 
    }

    if($parent->id) {
      if(!$field->get('parent_id')) {
        // parent_id setting not yet in field
        $field->set('parent_id', $parent->id); 
        $field->save();
      }
    } else {
      throw new WireException("Unable to create parent {$repeatersRootPage->path}$parentName"); 
    }

    return $parent; 
  }

  /**
   * Update repeater template and fieldgroup to have same name as field
   * 
   * @param Template $template Template having old name
   * @param string $name New name for template
   * 
   */
  protected function updateRepeaterTemplateName(Template $template, $name) {
  
    if($template->name != $name && !$this->wire('templates')->get($name)) {
      $this->message("Renamed repeater template from '$template->name' to '$name'", Notice::debug); 
      $flags = $template->flags;
      $template->flags = Template::flagSystemOverride;
      $template->flags = 0;
      $template->save();
      $template->name = $name;
      $template->flags = $flags;
      $template->save();
    }
  
    if($template->fieldgroup && $template->fieldgroup->name != $name && !$this->wire('fieldgroups')->get($name)) {
      $template->fieldgroup->name = $name;
      $template->fieldgroup->save();
    }
  } 

  /**
   * Return the repeater template used by Field, i.e. repeater_name
   * 
   * Auto generate a repeater template, if it doesn't already exist.
   *
   * @param Field $field
   * @return Template
   * @throws WireException
   *
   */
  protected function getRepeaterTemplate(Field $field) {

    $template = null;
    $templateID = (int) $field->get('template_id');
    $templateName = self::templateNamePrefix . $field->name; 
    
    if($templateID) {
      $template = $this->wire('templates')->get($templateID);
      if($template && $template->name !== $templateName) {
        // repeater has been renamed, update the template and fieldgroup names
        $this->updateRepeaterTemplateName($template, $templateName);
      }
    }

    // if template already exists, return it now
    if($template) return $template;

    // make sure the template name isn't already in use, make a unique one if it is
    $n = 0; 
    while($this->wire('templates')->get($templateName) || $this->wire('fieldgroups')->get($templateName)) {
      $templateName = self::templateNamePrefix . $field->name . (++$n); 
    }

    // create the fieldgroup
    $fieldgroup = $this->wire(new Fieldgroup());
    $fieldgroup->name = $templateName;
    $fieldgroup->save();  

    if(!$fieldgroup->id) throw new WireException("Unable to create repeater fieldgroup: $templateName"); 

    // create the template
    $template = $this->wire(new Template()); 
    $template->name = $templateName; 
    $template->fieldgroup = $fieldgroup; 
    $this->populateRepeaterTemplateSettings($template); 
    $template->save();

    if(!$template->id) throw new WireException("Unable to create template: $templateName"); 

    // save the template_id setting to the field
    $field->set('template_id', $template->id);  
    $field->save();

    $this->message("Created '$field' template: $template", Notice::debug);

    return $template; 
  }

  /**
   * Populate the settings for a newly created repeater template
   * 
   * @param Template $template
   * 
   */
  protected function populateRepeaterTemplateSettings(Template $template) {
    $template->flags = Template::flagSystem;
    $template->noChildren = 1;
    $template->noParents = 1; // prevents users from creating pages with this template, but not us
    $template->noGlobal = 1; 
  }

  /**
   * Handles the sanitization and convertion to PageArray value
   *
   * @param Page $page
   * @param Field $field
   * @param mixed $value
   * @return PageArray
   *
   */
  public function sanitizeValue(Page $page, Field $field, $value) {

    // if they are setting it to a PageArray, then we'll take it
    if($value instanceof PageArray) return $value; 

    // otherwise, lets get the current value so we can add to it or return it
    $pageArray = $page->get($field->name); 

    // if no value was provided, then return the existing value already in the page
    if(!$value) return $pageArray; 

    // if it's a string, see if we can convert it to a Page or PageArray
    if(is_string($value)) $value = $this->sanitizeValueString($page, $field, $value); 

    // if it's a Page, and not  NullPage, add it to the existing PageArray
    if($value instanceof Page) {
      $pageArray->add($value); 
      return $pageArray; 
    }

    // if it's a new PageArray, combine it with the existing PageArray
    if($value instanceof PageArray) {
      foreach($value as $pg) {
        if(!$pg->id) continue; 
        $pageArray->add($pg); 
      }
      return $pageArray; 
    }

    if(!is_array($value)) $value = array($value); 
    foreach($value as $p) $pageArray->add($p); 

    return $pageArray; 
  }

  /**
   * Given a string value return a Page or PageArray
   *  
   * @param Page $page
   * @param Field $field
   * @param string $value
   * @return Page|PageArray
   *
   */
  protected function sanitizeValueString(Page $page, Field $field, $value) {

    if($page) {} // ignore
    $result = false;

    if(ctype_digit("$value")) {
      // single page ID
      $result = $this->wire('pages')->get((int) $value); 

    } else if(strpos($value, ',')) {
      // csv string of page IDs
      $value = explode(',', $value);  
      $result = array();
      foreach($value as $k => $v) {
        $v = (int) $v; 
        if($v) $result[] = $v; 
      }
      $result = $this->wire('pages')->getById($result, $this->getRepeaterTemplate($field), $field->get('parent_id')); 

    } else if(Selectors::stringHasOperator($value)) {
      // selector
      $parentID = $field->get('parent_id');
      $templateID = $field->get('template_id');
      $result = $this->wire('pages')->find("parent_id=$parentID, templates_id=$templateID, $value");

    } else if(strlen($value) && $value[0] == '/') {
      // path
      $result = $this->wire('pages')->get($value); 
    }

    return $result; 
  }

  /**
   * Perform output formatting on the value delivered to the API
   *
   * This method is only used when $page->outputFormatting is true. 
   * 
   * @param Page $page
   * @param Field $field
   * @param PageArray $value
   * @return PageArray
   *
   */
  public function ___formatValue(Page $page, Field $field, $value) {
    
    $maxItems = (int) $field->get('repeaterMaxItems');

    if(!$value instanceof PageArray) $value = $this->getBlankValue($page, $field);

    // used as a clone if a formatted version of $value is different from non-formatted
    $formatted = null;
    $cnt = 0;

    // remove unpublished and ready items that shouldn't be here
    foreach($value as $p) {
      $cnt++;
      if($p->isHidden() || $p->isUnpublished() || ($maxItems && $cnt > $maxItems)) {
        if(is_null($formatted)) $formatted = clone $value;
        /** @var Page $formatted */
        $trackChanges = $formatted->trackChanges();
        $formatted->setTrackChanges(false); 
        $formatted->remove($p); 
        $formatted->setTrackChanges($trackChanges); 
        $cnt--;
      }
    }

    return is_null($formatted) ? $value : $formatted;
  }

  /**
   * Update a DatabaseQuerySelect object to match a Page
   *
   * @param DatabaseQuerySelect $query
   * @param string $table
   * @param string $subfield
   * @param string $operator
   * @param string $value
   * @return DatabaseQuerySelect
   * @throws WireException
   *
   */
  public function getMatchQuery($query, $table, $subfield, $operator, $value) {

    $field = $query->field;

    if($subfield == 'count') { 
      $value = (int) $value; 

      if( ($operator == '=' && $value == 0) || 
        (in_array($operator, array('<', '<=')) && $value > -1) ||
        ($operator == '!=' && $value)) {

        $templateIDs = array();
        foreach($field->getTemplates() as $template) $templateIDs[] = (int) $template->id; 
        if(count($templateIDs)) {
          $templateIDs = implode(',', $templateIDs); 
          $sql =  
            "($table.count{$operator}$value OR " . 
            "($table.count IS NULL AND pages.templates_id IN($templateIDs)))";
          $query->where($sql); 
        } else {
          $query->where("1>2"); // forced non-match
        }

      } else {
        $query->where("($table.count{$operator}$value)"); 
      }

    } else if($subfield == 'parent_id' || $subfield == 'parent') {  

      $subfield = 'parent_id';
      if(is_object($value)) $value = (string) $value; 
      $value = (int) $value;
      $query->where("($table.$subfield{$operator}$value)"); 

    } else if($subfield == 'data' || $subfield == 'id' || !$subfield) {
      
      // support matching of IDs via word matching fulltext index
      if(ctype_digit("$value") && !empty($value)) {
        if($subfield === 'id') $subfield = 'data';
        if($operator === '=') { 
          $operator = '~=';
        } else if($operator === '!=') {
          // @todo specify NOT
          $operator = '~=';
        }
      }

      if(in_array($operator, array('*=', '~=', '^=', '$=', '%='))) {
        /** @var DatabaseQuerySelectFulltext $ft */
        $ft = $this->wire(new DatabaseQuerySelectFulltext($query));
        $ft->match($table, $subfield, $operator, $value);

      } else if(empty($value)) {
        // empty/0 value
        if($operator === '=' && $subfield === 'id') {
          $query->where('1>2'); // force non-match
        } else {
          // match where count is 0
          $query->where("$table.count{$operator}0");
        }

      } else {
        // match /path/to/page or other, not implemented
      }
      
    } else {
      $f = $this->wire('fields')->get($subfield);
      if(!$f) return $query; // unknown subfield
      
      // match fields from the repeater template
      // perform a separate find() operation for the subfield
      $pageFinder = $this->wire(new PageFinder());
      $value = $this->wire('sanitizer')->selectorValue($value);
      $templateID = $field->get('template_id');
      $selectors = $this->wire(new Selectors("templates_id=$templateID, check_access=0, $f->name$operator$value"));
      $matches = $pageFinder->find($selectors);

      // use the IDs found from the separate find() as our getMatchQuery
      if(count($matches)) {
        $ids = array();
        foreach($matches as $match) {
          $parentID = (int) $match['parent_id'];
          $ids[$parentID] = $parentID;
        }
        $query->where("$table.parent_id IN(" . implode(',', $ids) . ")");
      } else {
        $query->where("1>2");  // force a non-match
      }
    }

    return $query; 
  }

  /**
   * Return the database schema in predefined format 
   * 
   * @param Field $field
   * @return array
   *
   */
  public function getDatabaseSchema(Field $field) {

    $schema = parent::getDatabaseSchema($field); 

    // fields
    $schema['data'] = 'text NOT NULL';
    $schema['count'] = 'int NOT NULL';
    $schema['parent_id'] = 'int NOT NULL';

    // indexes
    $schema['keys']['data'] = 'FULLTEXT KEY `data` (`data`)'; // just a cache of CSV page IDs for portability
    $schema['keys']['data_exact'] = 'KEY `data_exact` (`data`(1))'; // just for checking if the field has a value
    $schema['keys']['count'] = 'KEY `count` (`count`, `pages_id`)'; 
    $schema['keys']['parent_id'] = 'KEY parent_id (`parent_id`, `pages_id`)';
  
    // indicate that this schema does not hold all data managed by this fieldtype
    $schema['xtra']['all'] = false; 

    return $schema;
  }

  /**
   * Save the given field from page 
   *
   * @param Page $page Page object to save. 
   * @param Field $field Field to retrieve from the page. 
   * @return bool True on success, false on DB save failure.
   *
   */
  public function ___savePageField(Page $page, Field $field) {

    if(!$page->id || !$field->id) return false;
    $value = $page->get($field->name); 
    
    if($value instanceof RepeaterPage) {
      // for FieldsetPage compatibility
      $pageArrayClass = $this->getPageArrayClass();
      /** @var RepeaterPageArray $pageArray */
      $pageArray = $this->wire(new $pageArrayClass($page, $field));
      $pageArray->add($value);
      $pageArray->resetTrackChanges();
      $value = $pageArray;
    }

    // pages that will be saved
    $savePages = array();

    // options to pass to save() or clone()
    $saveOptions = array('uncacheAll' => false); 

    // pages that will be deleted
    $deletePages = $value->getItemsRemoved();

    $repeaterParent = $this->getRepeaterPageParent($page, $field);
    $parent_id = $repeaterParent->id;
    $template_id = $field->get('template_id'); 

    // iterate through each page in the pageArray value
    // and determine which need to be saved 
    foreach($value as $key => $p) {
      
      /** @var Page $p */

      if($p->template->id != $template_id) {
        $value->remove($p);
        $this->message("Removed invalid template ({$p->template->name}) page {$p->path} from field $field", Notice::debug); 
        continue; 
      }

      if($p->parent->id != $parent_id) {
        // clone the individual repeater pages
        $value->remove($p); 
        $p = $this->wire('pages')->clone($p, $repeaterParent, false, $saveOptions);
        $value->add($p);
        $this->message("Cloned to {$p->path} from field $field", Notice::debug); 
        continue; 
      }

      if($p->isNew() && !$p->name && !$p->title) {
        // if we've got a new repeater page without a name or title
        // then it's not going to save because it has no way of generating a name
        // so we will generate one for it
        $p->name = $this->getUniqueRepeaterPageName();
      }

      if($p->isChanged() || $p->isNew()) {
        // if the page has changed or is new, then we will queue it to be saved
        $savePages[] = $p; 

      } else if($p->id && $p->isUnpublished() && !$p->isHidden()) {
        // if the page has an ID, but is still unpublished, though not hidden, then we queue it to be saved (and published)
        $savePages[] = $p; 
      }
    }

    // iterate the pages that had changes and need to be saved
    foreach($savePages as $p) {
      
      if($p->id) {
        // existing page
        $isHidden = $p->isHidden();
        $isUnpublished = $p->isUnpublished();
        $isOn = $p->hasStatus(Page::statusOn);
        $isProcessed = $p->get('_repeater_processed') === true;
        $hasErrors = $p->get('_repeater_errors') ? true : false;
        
        if($isHidden && $isUnpublished) continue; // this is a 'ready' page, we can ignore
        
        $changes = implode(', ', $p->getChanges());
        $this->message("Saved '$field' page: {$p->path} " . ($changes ? "($changes)" : ''), Notice::debug); 

        if($isUnpublished && $isOn && $isProcessed && !$hasErrors) {
          // publish requested and allowed
          $p->removeStatus(Page::statusUnpublished);
        }

      } else {
        $this->message("Added new '$field' page", Notice::debug); 
      }

      // save the repeater page
      $this->wire('pages')->save($p, $saveOptions);       
    }

    // iterate through the pages that were removed
    foreach($deletePages as $p) {
      // if the deleted value is still present in the pageArray, then don't delete it
      if($value->has($p)) continue; 
      // $this->message("Deleted Repeater", Notice::debug); 
      // delete the repeater page
      $this->wire('pages')->delete($p, $saveOptions);
    }

    $result = parent::___savePageField($page, $field);
    // ensure that any of our cloned page replacements (removes) don't get recorded any follow-up saves
    $value->resetTrackChanges();
    return $result;
  }

  /**
   * Delete the given field, which implies: drop the table $field->table
   *
   * This should only be called by the Fields class since fieldgroups_fields lookup entries must be deleted before this method is called. 
   *
   * With the repeater, we must delete the associated fieldgroup, template and parent as well
   *
   * @param Field $field Field object
   * @return bool True on success, false on DB delete failure.
   *
   */
  public function ___deleteField(Field $field) {

    $template = $this->wire('templates')->get((int) $field->get('template_id')); 
    $parent = $this->wire('pages')->get((int) $field->get('parent_id')); 

    // delete the pages used by this field
    // check that the parent really is still in our repeaters structure before deleting anything
    if($parent->id && $parent->parent_id == $this->repeatersRootPageID) {

      $parentPath = $parent->path;

      // remove system status from repeater field parent
      $parent->addStatus(Page::statusSystemOverride); 
      $parent->removeStatus(Page::statusSystem); 

      // remove system status from repeater page parents
      foreach($parent->children as $child) {
        $child->addStatus(Page::statusSystemOverride);
        $child->removeStatus(Page::statusSystem); 
      }

      // resursively delete the field parent and everything below it 
      $this->wire('pages')->delete($parent, true); 

      $this->message("Deleted '$field' parent: $parentPath", Notice::debug); 
    }

    // delete the template used by this field
    // check that the template still has system flag before deleting it
    if($template && ($template->flags & Template::flagSystem)) {

      $templateName = $template->name; 

      // remove system flag from the template
      $template->flags = Template::flagSystemOverride; 
      $template->flags = 0;

      // delete the template
      $this->wire('templates')->delete($template);  

      // delete the fieldgroup
      $fieldgroup = $this->wire('fieldgroups')->get($templateName); 
      if($fieldgroup) $this->wire('fieldgroups')->delete($fieldgroup); 

      $this->message("Deleted '$field' template: $templateName", Notice::debug); 
    }

    return parent::___deleteField($field); 
  }

  /**
   * Delete the given Field from the given Page
   *
   * @param Page $page 
   * @param Field $field Field object
   * @return bool True on success, false on DB delete failure.
   *
   */
  public function ___deletePageField(Page $page, Field $field) {

    $result = parent::___deletePageField($page, $field); 
    $this->deletePageField = $field->get('parent_id');
    $fieldParent = $this->wire('pages')->get((int) $field->get('parent_id'));

    // confirm that this field parent page is still part of the pages we manage
    if($fieldParent->parent_id == $this->repeatersRootPageID) {
      // locate the repeater page parent
      $parent = $fieldParent->child('name=' . self::repeaterPageNamePrefix . $page->id . ', include=all'); 
      if($parent->id) { 
        // remove system status from repeater page parent
        $parent->addStatus(Page::statusSystemOverride);
        $parent->removeStatus(Page::statusSystem);
        $this->message("Deleted {$parent->path}", Notice::debug); 
        // delete the repeater page parent and all the repeater pages in it
        $this->wire('pages')->delete($parent, true); 
      }
    }

    return $result;
  }

  /**
   * Delete old ready pages that are just taking up space
   * 
   * @param Field $field
   * @param bool $delete Specify true to delete the old ready pages
   * @param int $secondsOld Number of seconds old that the page has to be to be considered "old" (default=259200 or 3 days)
   * @return int Count of old ready pages, or if $delete===true, then number that was deleted
   * 
   */
  public function countOldReadyPages(Field $field, $delete = false, $secondsOld = 259200) {
    if(!$field->type instanceof FieldtypeRepeater) return 0;
    $cnt = 0;
    $template = $this->getRepeaterTemplate($field);
    $parent = $this->getRepeaterParent($field);
    if(!$template || !$parent) return 0;
    $status = Page::statusHidden + Page::statusUnpublished;
    $modified = time() - $secondsOld;
    $selector = "has_parent=$parent, template=$template, status>=$status, modified<=$modified, include=all";
    if($delete) {
      $items = $this->wire('pages')->find($selector);
      foreach($items as $item) {
        try {
          if($item->delete()) $cnt++;
        } catch(\Exception $e) {
          $this->error("Error deleting old repeater item $item->path - " . $e->getMessage());
        }
      }
    } else {
      $cnt = $this->wire('pages')->count($selector);
    }
    return $cnt;
  }

  /**
   * Create a cloned copy of Field
   * 
   * @param Field $field
   * @throws WireException
   *
   */
  public function ___cloneField(Field $field) {
    throw new WireException($this->className() . " does not currently support field cloning.");   
    /*  
    $field = parent::___cloneField($field); 
    $field->parent_id = null;
    $field->template_id = null;
    */
  }
  
  /**
   * Export configuration values for external consumption
   *
   * Use this method to externalize any config values when necessary.
   * For example, internal IDs should be converted to GUIDs where possible.
   * Most Fieldtype modules can use the default implementation already provided here.
   *
   * #pw-group-configuration
   *
   * @param Field $field
   * @param array $data
   * @return array
   *
   */
  public function ___exportConfigData(Field $field, array $data) {
    
    $data = parent::___exportConfigData($field, $data); 
    
    $template = $this->wire('templates')->get((int) $data['template_id']); 
    
    $data['template_id'] = 0;
    $data['parent_id'] = 0;
    $data['repeaterFields'] = array();
    $data['fieldContexts'] = array();
    
    $a = $field->get('repeaterFields');
    if(!is_array($a)) $a = array();
    
    foreach($a as $fid) {
      $f = $this->wire('fields')->get((int) $fid); 
      if(!$f) continue;
      $data['repeaterFields'][] = $f->name;
      $data['fieldContexts'][$f->name] = $template->fieldgroup->getFieldContextArray($f->id);
    }
    
    return $data;
  }
  
  /**
   * Convert an array of exported data to a format that will be understood internally
   *
   * This is the opposite of the exportConfigData() method.
   * Most modules can use the default implementation provided here.
   *
   * #pw-group-configuration
   *
   * @param Field $field
   * @param array $data
   * @return array Data as given and modified as needed. Also included is $data[errors], an associative array
   *  indexed by property name containing errors that occurred during import of config data.
   *
   */
  public function ___importConfigData(Field $field, array $data) {
    
    if(!$field->type instanceof FieldtypeRepeater) return $data;
  
    $errors = array();
    $repeaterFields = array();
    $saveFieldgroup = false;
    $saveFieldgroupContext = false;
    $template = $field->id ? $this->getRepeaterTemplate($field) : null;
  
    if(!empty($data['repeaterFields'])) {
      foreach($data['repeaterFields'] as $name) {
        $f = $this->wire('fields')->get($name);
        if(!$f || !$f instanceof Field) {
          $errors[] = "Unable to locate field to add to repeater: $name";
          continue;
        }
        $repeaterFields[] = $f->id;
      }
      $data['repeaterFields'] = $repeaterFields;
    }
    
    if($template && !empty($data['fieldContexts'])) {
      foreach($data['fieldContexts'] as $name => $contextData) {
        $f = $this->wire('fields')->get($name);
        if(!$f || !$f instanceof Field) continue;
        if($template->fieldgroup->hasField($f)) {
          $f = $template->fieldgroup->getFieldContext($f->name);
        }
        $template->fieldgroup->add($f);
        $saveFieldgroup = true;
        if(!empty($contextData)) {
          $template->fieldgroup->setFieldContextArray($f->id, $contextData);
          $saveFieldgroupContext = true;
        }
      }
    }
    
    if($template) {
      if($saveFieldgroupContext) {
        $template->fieldgroup->saveContext();
      }
      if($saveFieldgroup) {
        $template->fieldgroup->save();
      }
    }
    
    unset($data['fieldContexts']); 
    
    $data = parent::___importConfigData($field, $data);
    
    if(count($errors)) {
      $data['errors'] = array_merge($data['errors'], array('repeaterFields' => $errors)); 
    }
    
    return $data; 
  }

  /**
   * Return configuration fields definable for each FieldtypePage
   * 
   * @param Field $field
   * @return InputfieldWrapper
   *
   */
  public function ___getConfigInputfields(Field $field) {

    $inputfields = parent::___getConfigInputfields($field);
    $template = $this->getRepeaterTemplate($field); 
    $parent = $this->getRepeaterParent($field); 

    if($this->wire('input')->post->repeaterFields) {
      $this->saveConfigInputfields($field, $template, $parent);
    }
    
    require_once(__DIR__ . '/config.php');
    $helper = new FieldtypeRepeaterConfigHelper($field);
    $inputfields = $helper->getConfigInputfields($inputfields, $template, $parent);
    return $inputfields; 
  }

  /**
   * Helper to getConfigInputfields, handles adding and removing of repeater fields
   * 
   * @param Field $field
   * @param Template $template
   * @param Page $parent
   * 
   */
  protected function ___saveConfigInputfields(Field $field, Template $template, Page $parent) {
    if($parent) {} // ignore
    require_once(__DIR__ . '/config.php');
    $helper = new FieldtypeRepeaterConfigHelper($field);
    $helper->saveConfigInputfields($template);
  }

  /**
   * Just here to fulfill ConfigurableModule interface
   * 
   * @param array $data
   * @return InputfieldWrapper
   *
   */
  public function getModuleConfigInputfields(array $data) {
    if($data) {} // ignore
    return $this->wire(new InputfieldWrapper());
  }

  /**
   * Remove advanced options that aren't supposed with repeaters
   * 
   * @param Field $field
   * @return InputfieldWrapper
   *
   */
  public function ___getConfigAdvancedInputfields(Field $field) {
    $inputfields = parent::___getConfigAdvancedInputfields($field);
    // these two are potential troublemakers when it comes to repeaters
    $inputfields->remove($inputfields->get('autojoin'));
    $inputfields->remove($inputfields->get('global'));
    return $inputfields;
  }

  /**
   * Install the module
   *
   */
  public function ___install() {
  
    /** @var Pages $pages */
    $pages = $this->wire('pages');

    $adminRoot = $pages->get($this->wire('config')->adminRootPageID); 
    $page = $adminRoot->child("name=repeaters, template=admin, include=all"); 
    
    if(!$page->id) {
      $page = $pages->newPage('admin');
      $page->parent = $adminRoot;
      $page->status = Page::statusHidden | Page::statusLocked | Page::statusSystemID;
      $page->name = 'repeaters';
      $page->title = 'Repeaters';
      $page->sort = $adminRoot->numChildren;
      $page->save();
      $this->message("Added page {$page->path}", Notice::debug); 
    }

    $configData = array('repeatersRootPageID' => $page->id); 
    $this->wire('modules')->saveModuleConfigData($this, $configData);
  }

  /**
   * Uninstall the module (delete the repeaters page)
   *
   */
  public function ___uninstall() {

    // don't delete repeaters page unless actually for FieldtypeRepeater
    if($this->className() != 'FieldtypeRepeater') return;
    $page = $this->wire('pages')->get($this->repeatersRootPageID); 
    if($page->id && $page->name == 'repeaters' && $page->template == 'admin') { 
      $page->addStatus(Page::statusSystemOverride); 
      $page->removeStatus(Page::statusSystem); 
      $page->removeStatus(Page::statusSystemID); 
      $page->removeStatus(Page::statusSystemOverride);
      $page->removeStatus(Page::statusLocked); 
      $this->wire('pages')->delete($page); 
      $this->message("Removed page {$page->path}", Notice::debug); 
    }
  }

}