PageContentFlow.module

<?php

/**
 * Adds method hook to Page objects for doing stuff when cfStatus changes
 * Page::cfChangedStatus($oldStatus, $newStatus) see bottom of this file to see description
 * about parameters
 */

class PageContentFlow extends WireData implements Module{

  protected $id;
  protected $page;
  protected $currentUser;
  protected $isPost = false;
  protected $cfRootPage;
  protected $cfMainModule;
  protected $stop = false;
  protected $pageStatusBeforeSave;
  protected $usersToNotify;

  public static function getModuleInfo() {
    return array(
       'title' => 'Content Flow Tab', 
       'version' => 1, 
       'summary' => 'Adds a Publish Workflow Tab on pages.',
       'singular' => true, 
       'autoload' => true,
       'requires' => array('ProcessContentFlow')
    );
  }


  public function init(){
    if(isset($_POST['id'])) $this->id = (int) $_POST['id']; 
       else if(isset($_GET['id'])) $this->id = (int) $_GET['id']; 

    if(!$this->id){
       $this->stop = true;
       return;
    }

    $this->usersToNotify = new PageArray();

    $this->currentUser = $this->user;
    $this->page = $this->pages->get($this->id);
    if($this->page instanceof NullPage){ $this->stop = true; return; }

    // determine if we're going to be dealing with a save/post request
    $this->isPost = ($this->input->post->id > 0 && (((int) $this->input->post->id) === $this->page->id)) || $this->config->ajax && (count($_POST) || isset($_SERVER['HTTP_X_FIELDNAME'])); 

    /** Add our hooks **/
    $this->addHook('Page::cfChangedStatus', $this, 'hookCFChangedStatus');

    wire()->pages->addHookAfter('saveReady', $this, 'hookGetCFStatusBeforeSave');
    $this->addHookAfter('Fieldtype::savePageField', $this, 'hookCheckChangeStatus');

  }

  public function ready(){

    if($this->stop) return;

    $this->cfMainModule = $this->modules->get('ProcessContentFlow');

    $this->cfRootPage = $this->pages->get($this->cfMainModule->root_page_id);

    if($this->cfRootPage instanceOf NullPage){
       $this->error('Could not load Content Flow base page.');
       $this->stop = true;
       return;
    }

    //don't run code below if we have a post request
    if($this->isPost) return;

    //check if this page should have a workflow tab 
    $templatesWithWorkflow = $this->cfMainModule->getTemplatesWithWorkflow();
    if(count($templatesWithWorkflow)){
       foreach($templatesWithWorkflow as $temp){
          if($temp->id == $this->page->template->id){
             $this->addHookAfter('ProcessPageEdit::buildForm', $this, 'hookRemoveCFFieldsFromEditPage');
             $this->addHookAfter('ProcessPageEdit::buildForm', $this, 'hookPageBuildForm');
             $this->addHookAfter('ProcessPageEdit::buildForm', $this, 'hookEditFormDescription');
             
             break;
          }
       }
    }
    
  }

  protected function ___buildFormWorkFlow(){
    $modules = $this->modules;
    $page = $this->page;

    $wrapper = new InputfieldWrapper();
    $wrapper->attr('id', __CLASS__ . 'WorkFlow');
    $wrapper->attr('title', $this->_('Publishing Workflow'));

    //add cf_status field
    $field = $page->template->fields->getField('cf_status');
    $inputfield = $field->getInputfield($page);
    if(!$inputfield){
       $this->error('Could not display Workflow Status field');
    } else {
       
       $inputfield->value = $page->get($field->name);
       $wrapper->append($inputfield);
    }

    return $wrapper;
  }

  protected function ___buildFormNotifications(){
    $page = $this->page;
    $modules = wire('modules');

    $wrapper = new InputfieldWrapper();
    $wrapper->attr('id', __CLASS__ . 'Notifications');
    $wrapper->attr('title', $this->_('Notifications'));

    $fieldset = $modules->get('InputfieldFieldset');
    $fieldset->label = $this->_('Notifications');
    $fieldset->description = $this->_('Select the users and roles (user groups) that should receive notifications when the workflow status of this page is updated.');

    //add cf_users field
    $field = $page->template->fields->getField('cf_users');
    $origInputfield = $field->getInputfield($page);
    if(!$origInputfield){
       $this->error('Could not display Notify Users field');
    } else {

      /**
       * We build our own inputfield because we want to show the user's 
       * display_name if it exists
       */
      $inputfield = $modules->get('InputfieldCheckboxes');
      $inputfield->attr('name', $origInputfield->attr('name'));
      $inputfield->attr('id', $origInputfield->attr('id'));
      $inputfield->label = $origInputfield->label;
      $inputfield->description = $origInputfield->description;
      $inputfield->columnWidth = 50;
      
      $origInputfield->value = $page->get($field->name);
      $value = $origInputfield->value;
      if($value instanceof Page) $inputfield->value = $value->id; //derefAsPage
      if($value instanceof PageArray) foreach($value as $v) $inputfield->value = $v->id; //derefAsPageArray

      $children = $origInputfield->getSelectablePages($page);
      if($children) foreach($children as $child){
        $label = $this->getUserLabelFieldName($origInputfield->labelFieldName, $child);
        $inputfield->addOption($child->id, $label);
      }

      $fieldset->append($inputfield);
    }

    //add roles field
    $field = $page->template->fields->getField('cf_roles');
    $inputfield = $field->getInputfield($page);
    if(!$inputfield){
       $this->error('Could not display Notify Roles field');
    } else {

      $inputfield->columnWidth = 50;        
      $inputfield->value = $page->get($field->name);

      $fieldset->append($inputfield);
    }


    $wrapper->append($fieldset);

    return $wrapper;

  }

   /**
    * Returns label field to be used when building own multi select fieldpage
    */
    public function ___getUserLabelFieldName($labelFieldName = '', WireData $page){
        $label = $labelFieldName ? $page->get($labelFieldName) : $page->name;

        if($page->display_name)
          $label = $page->display_name . " ($label) {$page->id}";

        return $label;
    }


  /**
   * ======================================
   * HOOKS GO BELOW
   * ======================================
   */

  /**
   * @Hooks to ProcessPageEdit::buildForm
   */
  public function hookPageBuildForm(HookEvent $event){
    $form = $event->return;

    //get the 'Content' tab input field wrapper so we can append our tab after this
    $contentTab = $form->children('id=ProcessPageEditContent')->first();

    $workflow = $this->buildFormWorkFlow();
    $notifications = $this->buildFormNotifications();

    if($contentTab->id){
       $event->return = $form->insertAfter($workflow, $contentTab);
       $event->return = $form->insertAfter($notifications, $workflow);
    } else {
       $event->return = $form->append($workflow);
       $event->return = $form->append($notifications);
    }


  }


  /**
  * Removes workflow fields from being returned when a page calls getInputfields() as in 
  * ProcessPageEdit::buildForm() because we don't want workflow fields to show up the normal
  * place. We want to show workflow fields under the 'Workflow' tab
  *
  * NOTE: If this hook is being run then it means that the current page has workflow enabled
  *
  * @Hooks to ProcessPageEdit::buildForm
  * @param  HookEvent $event
  */
  public function hookRemoveCFFieldsFromEditPage(HookEvent $event){
    $form = $event->return;

    $workflowFieldNames = $this->cfMainModule->getWorkflowFields();

    $fieldsToFilter = $form->find('name='.implode('|',$workflowFieldNames));

    if(!count($fieldsToFilter)) return;

    foreach($fieldsToFilter as $f){
       $f->parent->remove($f);
    }

    $event->return = $form;

  }


  /**
   * Add our status text to the form description (if the page is unpublished)
   *
   * NOTE: If this hook is triggered then it means the current page has workflow enabled
   * 
   * @hooks to ProcessPageEdit::buildForm
   * @param HookEvent $event
   */
  public function hookEditFormDescription(HookEvent $event){
    $form = $event->return;

    if($this->page->is(Page::statusUnpublished) && $this->page->cf_status){
      //append our status text to the form description
      if($form->description) $form->description .= sprintf($this->_(' [status: "%1$s"]'), $this->page->cf_status->get('title|name'));
    }

    $event->return = $form; //not really needed since $form is an object and is copied by reference
  }


  /**
  * Get status before page is saved
  */
  public function hookGetCFStatusBeforeSave(HookEvent $event){
    $page = $event->arguments('page');
    $statusFieldName = 'cf_status';

    if(!$page->fields->hasField($statusFieldName)) return;

    //we'll need the clone later
    $clone = clone $page;

    // get the old value of the field
    //$page->uncache();
    $clone->uncache();
    $this->pageStatusBeforeSave = $clone->$statusFieldName;   
    
  }


  /**
  * check if status has changed and trigger Page::cfChangedStatus hook
  *
  * hooks into Fieldtype::savePageField
  */
  protected function hookCheckChangeStatus(HookEvent $event){
    $page = $event->arguments('page');
    $field = $event->arguments('field');
    $statusFieldName = 'cf_status';

    //page field did not save to database
    if(!$event->return) return;
    
    //field is cf_status field
    if($field->name != $statusFieldName) return;
    
    $savedStatus = $page->get($statusFieldName);

    //don't do anything if cf_status hasn't changed
    if($this->pageStatusBeforeSave->id == $savedStatus->id) return;

    //trigger status change.
    //NOTE: Still not sure which one to keep.
    $page->cfChangedStatus($this->pageStatusBeforeSave, $savedStatus);
    $this->changedStatus($this->pageStatusBeforeSave, $savedStatus, $page);
  }


  /**
  * hook Page::cfChangeStatus
  */
  protected function hookCFChangedStatus(HookEvent $event){
    $old = $event->arguments(0);
    $new = $event->arguments(1);

    //$this->message('Publishing status has changed from ' . $old->title . ' to ' . $new->title);

    $notice = new NoticeMessage('Publishing status has changed from ' . $old->title . ' to ' . $new->title);
    $notice->class = $this->className();
    wire('notices')->prepend($notice);

    $event->return = true;
  }


  /**
   * =============================
   * CF Method Hooks and friends go below
   * =============================
   */

  /**
   * Hook called  a page has changed publishing status
   * !Note: technically, this hook is called after the cf_status field (of the page) has changed status
   * 
   * @param $old previous status (contentflow-status type page) the page was set to
   * @param $new new status (contentflow-status type page) the page was set to
   * @param Page $page the page that changed status
   */
  public function ___changedStatus($old, $new, Page $page){
    //TODO: should we notify users/roles in old status?
    
    $cfUsers = $this->buildListUsersToNotify($new, $page);

  }


  /**
   * Returns PageArray of user objects
   *
   * Makes a list (PageArray) of users that should be notified based of the passed status.
   * Users are selected from the cf_users and roles fields.
   * 
   * @param  Page   $status
   * @param  Page   $page  current page being saved
   * @return PageArray
   */
  protected function ___buildListUsersToNotify(Page $status, Page $page){
    /**
     * Get users/roles that should be notified as specified in the status
     */
    $userList = new PageArray();
    $rolesList = new PageArray();

    //specific users that should be notified
    $cfUsers = $status->cf_users;
    if(count($cfUsers))
      $userList->import($cfUsers);

    $pageUsers = $page->cf_users;
    if(count($pageUsers))
      $userList->import($pageUsers); //PW will take care not to include duplicates


    //get users from selected roles that should be notified
    $cfRoles = $status->cf_roles;
    $pageRoles = $page->cf_roles;

    if(count($cfRoles))
      $rolesList->import($cfRoles);

    if(count($pageRoles))
      $rolesList->import($pageRoles);


    //Now get the users from the rolesList
    if(count($rolesList)){
      foreach($this->users as $user){
        //do not include users who have been selected already
        if($userList->has($user)) continue;

        foreach($rolesList as $r){
          if($user->roles->has($r)){
            $userList->add($user);
            continue; //user is already in the list
          }
        }
      }
    }
    
    if(count($cfRoles)){

      foreach($this->users as $user){

        //do not include users who have been selected already
        if($cfUsers->has($user)) continue;

        foreach($cfRoles as $r){
          if($user->roles->has($r))
            $userList->add($user);
        }
      }
    }

    $this->usersToNotify->import($userList); //save the list

    return $userList;
  }


  /**
   * Returns PageArray of users to notify
   */
  public function ___getListUsersToNotify(){
    return $this->usersToNotify;
  }

}


/**
 * Description of Page::cfChangedStatus()
 *
 * both $oldStatus and $newStatus are just Page objects under /admin/Content Flow/Status
Page::cfChangedStatus($oldStatus, $newStatus)
 */