ProcessContentFlow.module

<?php
/**
 * Content Flow
 * ================
 * @website https://github.com/ryannmicua/ProcessContentFlow
 * @author Ryann Micua <http://pogidude.com/>
 * @license GPL 3 <http://www.gnu.org/licenses/gpl-3.0.txt>
 * 
 * An attempt to creating an editorial workflow in ProcessWire
 */

class ProcessContentFlow extends Process implements Module, ConfigurableModule {

   protected $form;
   protected $isPost;
   protected $data = array();

   protected static $module_dir;
   protected static $module_url; 
   protected static $defaults = array(
      );

   /* fields that will be added to templates that have workflow enabled */
   protected static $workflowFields = array(
      'cf_status',
      'cf_users',
      'cf_roles'
      );

   /* fields that will be added to status template */
   protected static $statusFields = array(
      'cf_status_description',
      'cf_users',
      'cf_roles'
      );

   const PERMISSION_NAME = 'contentflow-access';
   const ROOT_PAGE_NAME = 'contentflow';
   const ROOT_TEMPLATE_NAME = 'contentflow';
   const STATUS_TEMPLATE_NAME = 'contentflow-status';
   const HOLDER_TEMPLATE_NAME = 'contentflow-holder';

   public function __construct(){
      //set paths and urls
      self::$module_dir = $this->config->paths->siteModules . __CLASS__;
      self::$module_url = $this->config->urls->siteModules . __CLASS__;
   }

   public static function getModuleInfo(){
      return array(
         'title' => 'Content Flow',
         'version' => 1,
         'summary' => 'Adds an editorial/publishing workflow inside ProcessWire.',
         'author' => 'Pogidude',
         'singular' => true,
         //'autoload' => true,
         'href' => 'https://github.com/ryannmicua/ProcessContentFlow',
         'permission' => self::PERMISSION_NAME,
         'installs' => array('PageContentFlow')
      );
   }

   /**
    * Attach our hooks here
    */
   public function init(){

      //don't run section below unless we are on our Process page
      if($this->page->id != $this->root_page_id) return;

      $this->page->setOutputFormatting(false); 

      //determine if we're going to be dealing with a save/post request
      $this->isPost = ($this->input->post->isPost == 'true' && true);

      parent::init();
      
      if(!$this->isPost) $this->modules->get('JqueryWireTabs');

      $this->data = $this->modules->getModuleConfigData($this);

   }

   /**
    * Execute and call render functions
    * 
    * @return html
    */
   public function ___execute(){

      //$this->setFuel('processHeadline', 'Content Flow Here');
      $this->form = $this->modules->get('InputfieldForm');

      $this->form = $this->buildForm($this->form);
      $this->form->setTrackChanges();

      if($this->isPost && count($_POST)){ $this->processSave(); }

      return $this->renderUI();
   }

   public function ___executeTry(){
      $form = $this->modules->get('InputfieldForm');
      $field = $this->modules->get('InputfieldMarkup');
      $field->label = $this->_('My Markup');
      $field->attr('value', '<pre><code>'.print_r($this->data,true).print_r($this->page->templates_with_workflow,true).'</code></pre>');
      $form->append($field);
      return $form->render(); 
   }

   public function ___executeWorkflowTemplates(){
      
      //TODO: make sure user has permission to update templates
      
      if(!isset($_GET['templates'])) throw new WireException("This method requires a 'templates' GET var");

      $templatesGet = explode(',', $_GET['templates']);
      $templatesCurrent = count($this->page->templates_with_workflow) ? $this->page->templates_with_workflow : array();

      $templatesAdd = array();
      //build array of templates where workflow will be added to
      foreach($templatesGet as $templateId){
         if(in_array($templateId, $templatesCurrent)) continue;
         $template = $this->templates->get((int) $templateId);
         if(!$template) throw new WireException("Unknown template ID: $templateId");
         $templatesAdd[] = $template;
      }

      //build array of templates where workflow will be removed from
      $templatesRemove = array();
      //build array of templates where workflow will be added to
      foreach($templatesCurrent as $templateId){
         if(in_array($templateId, $templatesGet)) continue;
         $template = $this->templates->get((int) $templateId);
         if(!$template) throw new WireException("Unknown template ID: $templateId");
         $templatesRemove[] = $template;
      }

      $form = $this->modules->get('InputfieldForm');
      $form->attr('action', 'saveWorkflowTemplates');
      $form->attr('method', 'post');
      $form->description = $this->_('Update templates that will have workflow');

      if(!empty($templatesAdd)){
         //display templates where workflow will be added
         $field = $this->modules->get('InputfieldMarkup');
         $field->label = $this->_('Confirm adding workflow to these templates');
         $field->description = $this->_('A workflow tab and related fields will be added to the following templates');
         $list = '';
         foreach($templatesAdd as $t){
            $list .= '<li class="ui-state-highlight"><span class="ui-icon ui-icon-alert"></span> ' . $this->getTemplateLabel($t) . '</li>';
         }
         $list = '<ul>'.$list.'</ul>';
         $fieldVal = $list.'<p>'.$this->_('The following fields will be added to these templates.').'</p><ul>';
         foreach(self::$workflowFields as $fname){
            $fieldVal .= '<li>'.$fname.'</li>';
         }
         $fieldVal .= '</ul>';
         $field->attr('value', $fieldVal);
         $form->append($field);
      }

      if(!empty($templatesRemove)){
         //display templates where workflow will be removed
         $field = $this->modules->get('InputfieldMarkup');
         $field->label = $this->_('Confirm removal of workflow from these templates');
         $field->description = $this->_("Warning, removal of workflow from these templates will also remove all associated workflow data and fields. And yes, you cannot get these data back.");
         $list = '';
         foreach($templatesRemove as $t){
            $list .= '<li class="ui-state-highlight"><span class="ui-icon ui-icon-alert"></span> ' . $this->getTemplateLabel($t) . '</li>';
         }
         $list = '<ul>'.$list.'</ul>';
         $fieldVal = $list.'<p>'.$this->_('The following fields will be deleted from these templates.').'</p><ul>';
         foreach(self::$workflowFields as $fname){
            $fieldVal .= '<li>'.$fname.'</li>';
         }
         $fieldVal .= '</ul>';
         $field->attr('value', $fieldVal);
         $form->append($field);
      }

      $f = $this->modules->get("InputfieldCheckbox"); 
      $f->attr('name', 'confirmChange'); 
      $f->attr('value', 'confirm'); 
      $f->label = $this->_('Are you sure?'); // Checkbox label to confirm they want to apply the changes
      $f->description = $this->_('Please confirm that you understand the above by clicking the checkbox below.'); // Checkbox description to confirm they want to apply the changes
      $form->append($f); 

      $f = $this->modules->get('InputfieldHidden');
      $f->attr('name', 'templates'); 
      $f->attr('value', implode(',',$templatesGet)); //$templatesGet is array of template IDs.
      $form->append($f); 

      $f = $this->modules->get("InputfieldSubmit");
      $form->append($f);

      $this->breadcrumbs->add(new Breadcrumb($this->page->url, $this->page->get('title|name')));

      return $form->render(); 
   }

   /**
    * Save templates with workflow
    * @param  array $templates array of template IDs
    */
   public function ___executeSaveWorkflowTemplates($templates = null){
      //TODO: make sure user has permission
      
      $this->redirectUrl = $this->page->url;
      
      if(isset($_POST['confirmChange']) && $_POST['confirmChange'] != 'confirm') $this->processSaveRedirect($this->redirectUrl);

      if(isset($_POST['templates'])){
         $temp = array();
         $temp = explode(',', $_POST['templates']);

         foreach($temp as $t){
            $templates[] = intval($t);
         }
      }

      if(!is_array($templates)) throw new WireException("This method requires correct 'templates' var");

      if(empty($templates)) throw new WireException("'templates' var empty");

      //current templates with workflow
      $templatesCurrent = count($this->page->templates_with_workflow) ? $this->page->templates_with_workflow : array();

      //build array of templates where workflow will be added to
      $templatesAdd = array();
      //loop through array of templates that must have workflow (includes templates that ALREADY have workflow)
      foreach($templates as $templateId){

         //do not include templates that already have workflow
         if(in_array($templateId, $templatesCurrent)) continue;

         $template = $this->templates->get((int) $templateId);
         if(!$template) throw new WireException("Unknown template ID: $templateId");
         $templatesAdd[] = $template;
      }

      //build array of templates that we should remove workflow from
      $templatesRemove = array();
      //loop through array of current templates that ALREADY has workflow
      foreach($templatesCurrent as $templateId){

         //do not includes templates that should have workflow
         if(in_array($templateId, $templates)) continue;

         $template = $this->templates->get((int) $templateId);
         if(!$template) throw new WireException("Unknown template ID: $templateId");
         $templatesRemove[] = $template;
      }

      //$this->session->CSRF->validate();

      if(!empty($templatesAdd)){
         try{
            $this->addTemplateFields($templatesAdd, $this->getWorkflowFields());

            /*
            foreach($templatesAdd as $t){
               //get the field in the context of the fieldgroup. set 2nd parameter to TRUE
               $field = $t->fields->getField('cf_roles', true);
               $field->label = $this->_('Notify Roles (User Groups)');
               $field->description = '';
               $this->fields->saveFieldgroupContext($field, $t->fields);

               $field = $t->fields->getField('cf_users', true);
               $field->label = $this->_('Notify Users');
               $field->description = '';
               $this->fields->saveFieldgroupContext($field, $t->fields);
            }
            */

         }catch(Exception $e){
            $this->error($e->getMessage());
         }
      }

      if(!empty($templatesRemove)){
         try{
            $this->removeTemplateFields($templatesRemove, $this->getWorkflowFields());
         }catch(Exception $e){
            $this->error($e->getMessage());
         }
      }

      $languages = $this->languages;

      $this->page->set('templates_with_workflow', $templates);
      $this->page->save();

      $this->session->redirect($this->page->url);
   }

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

      $form = $this->modules->get('InputfieldForm');
      $form->attr('method', 'post');
      $form->attr('action', 'addnewstatus');
      $form->description = $this->_('Add new status');

      $statusTemplate = $this->templates->get(self::STATUS_TEMPLATE_NAME);

      $inputfield = $statusTemplate->fields->getField('title',true)->getInputfield($page);
      $inputfield->label = $this->_('Title');
      $inputfield->attr('name', 'cf_status_title');
      $form->append($inputfield); 

      $inputfield = $statusTemplate->fields->getField('cf_status_description')->getInputfield($page);
      $form->append($inputfield);

      $field = $this->modules->get('InputfieldPageName');
      $field->parentPage = $this->parent; 
      $field->attr('name', 'cf_status_name'); 
      $field->label = $this->_('System Name');
      $field->required = true;
      $field->collapsed = Inputfield::collapsedYes;
      $form->append($field);

      $saveField = $modules->get('InputfieldSubmit');
      $saveField->attr('name', 'add_new_status');
      $saveField->attr('id', 'submitSave');
      $saveField->class .= ' head_button_clone';
      $saveField->attr('value', $this->_('Add New Status'));
      $form->append($saveField);

      $form->setTrackChanges();

      if($this->input->post->add_new_status) $this->processInputAddNewStatus($form);

      $this->breadcrumbs->add(new Breadcrumb($this->page->url, $this->page->get('title|name')));

      return $form->render();
   }

   /**
    * Render our pages
    */
   protected function renderUI(){

      //$this->setFuel('processHeadline', 'Content Flow Here');
      

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

   /**
    * Process submission
    */
   protected function processSave(){
      $message = $this->_('Saved Settings');
      $post = $this->input->post;
      $page = $this->page;
      
      $this->processInput($this->form);

      foreach(array_unique($this->page->getChanges()) as $change) {
         $this->message(sprintf($this->_('Change: %s'), $change)); // Message shown for each changed field
      }

      if($page->save()){
         $this->message($message);
      } else {
         $this->error($this->_('Problem saving settings'));
      }

      $this->processSaveRedirect($this->redirectUrl);
   }

   /**
    * Process Input from submitted form
    */
   protected function ___processInput(Inputfield $form, $level = 0){
      static $skipFields = array(
         'submit_save',
         'isPost',
         'cf_status_title',
         'cf_status_description',
         'cf_status_add'
         );

      if(!$level){
         $form->processInput($this->input->post);
      }

      $languages = $this->languages;

      foreach($form as $inputfield){
         $name = $inputfield->attr('name');

         if(in_array($name, $skipFields)) continue;

         if($name == 'templates_with_workflow'){
            $this->processInputTemplatesWithWorkflow($inputfield);
            continue;
         }

         if($name && $inputfield->isChanged()){
            if($languages && $inputfield->useLanguages){
               $v = $this->page->get($name);
               if(is_object($v)){
                  $v->setFromInputfield($inputfield);
                  $this->page->set($name, $v);
                  $this->page->trackChange($name);
               }
            } else {
               $this->page->set($name, $inputfield->value);
            }
         }

         if($inputfield instanceof InputfieldWrapper && count($inputfield->getChildren())){
            $this->processInput($inputfield, $level + 1); 
         }
      }
   }

   protected function processInputTemplatesWithWorkflow(Inputfield $inputfield){

      if(!$inputfield->value || !is_array($inputfield->value)){
         return true;
      }

      if($inputfield->isChanged()){
         $this->redirectUrl = 'workflowtemplates?templates=' . implode(',', $inputfield->value); 
      }
      
   }

   protected function processInputAddNewStatus(Inputfield $form){
      $page = new Page();
      $parent = $this->pages->get($this->status_root_page_id);
      $template = $this->templates->get(self::STATUS_TEMPLATE_NAME);
      $languages = $this->languages;

      if($parent instanceof NullPage) throw new WireException($this->_('Parent for status page does not exist.'));

      if(is_null($template)) throw new WireException($this->_('Required template for status page "'.self::STATUS_TEMPLATE_NAME.'"" does not exist.'));

      //if(!$parent->isAllowedTemplate($template)) throw new WireException("You don't have access to add pages with template '$template'");

      $form->processInput($this->input->post);

      $nameField = $form->children->get('cf_status_name');
      $name = $nameField->value;

      if(!strlen($name)) {
         $this->error($this->_("Missing required field: Name")); 
         return false; 
      }

      $titleField = $form->children->get('cf_status_title');
      $title = $titleField->value;
      if(!strlen($title)) {
         $this->error($this->_("Missing required field: Title")); 
         return false; 
      }

      $descriptionField = $form->children->get('cf_status_description');
      $description = $nameField->value;

      if($parent->child("name=$name, include=all")->id) {
         $nameField->error($this->_("The name you selected is already in use. Please select another.")); 
         return false;
      }

      $page->template = $template;
      $page->parent = $parent;
      $page->name = $name;
      $page->title = $title;
      $page->cf_status_description = $description;
      $page->sort = $parent->numChildren;

      foreach($page->fields as $field) {
         $f = $form->children->get($field->name); 
         if($f) {
            if($languages && $f->useLanguages) {
               // account for language fields (most likely FieldtypePageTitleLanguage)
               $value = $page->get($field->name); 
               if(is_object($value)) $value->setFromInputfield($f);
            } else {
               $value = $f->attr('value'); 
            }
            $page->set($field->name, $value); 
         } else {
            $publishNow = false; // non-global fields means we won't publish yet
         }
      }

      try {
         $this->pages->save($page); 
      } catch(Exception $e) {
         $this->error($e->getMessage()); 
         return false;
      }

      $this->session->message(sprintf($this->_('New status "%1$s" created.'), $page->title));
      $this->session->redirect($this->page->url);
   }

   /**
    * Perform an after save redirect
    */
   protected function ___processSaveRedirect($redirectUrl){
      if(!$redirectUrl) $redirectUrl = './?s=1';
      $this->redirectUrl = $redirectUrl;
      $this->session->redirect($redirectUrl);
   }

   /**
    * Build form
    */
   protected function ___buildForm(InputfieldForm $form){
      $modules = $this->modules;
      
      $form->attr('id', __CLASS__);

      //build our tabs
      $form->append($this->buildFormDashboard());
      //$form->append($this->buildFormNotificationSettings());
      $form->append($this->buildFormStatusSettings());
      $form->append($this->buildFormWorkflowSettings());

      $saveField = $modules->get('InputfieldSubmit');
      $saveField->attr('name', 'submit_save');
      $saveField->attr('id', 'submitSave');
      $saveField->class .= ' head_button_clone';
      $saveField->attr('value', $this->_('Save Settings'));
      $form->append($saveField);

      $hidden = $modules->get('InputfieldHidden');
      $hidden->attr('name', 'isPost');
      $hidden->attr('value', 'true');
      $form->append($hidden);

      return $form;
   }

   /**
    * Build the 'Dashboard' tab on the Content Flow form
    */
   protected function ___buildFormDashboard(){
      $modules = $this->modules;

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

      $fieldset = $modules->get('InputfieldFieldset');
      $fieldset->label = $this->_('Content Dashboard');
      $fieldset->description = $this->_('This is where you can view the pages under each status.');

      $masterTable = $modules->get('MarkupAdminDataTable');
      $masterTable->headerRow(array(
         $this->_('Title'),
         //$this->_('Workflow Status'),
         $this->_('Published?'),
         $this->_('Created by')
         ));
      $masterTable->setEncodeEntities(false);
      $masterTable->setSortable(true);

      $statusRootPage = $this->pages->get($this->status_root_page_id);

      if($statusRootPage instanceof NullPage){
         $this->error($this->_('Status root page is not set.'));
         $wrapper->add($fieldset);
         return $wrapper;
      }

      if(!$statusRootPage->numChildren){
         $wrapper->add($fieldset);
         return $wrapper;
      }

      $statuses = $statusRootPage->children('template='.self::STATUS_TEMPLATE_NAME);

      /*
      //create checkboxes for status filter
      $field = $modules->get('InputfieldCheckboxes');
      $field->attr('id+name', 'filter_status');
      $field->label = $this->_('Show only pages with the following status');
      $field->optionColumns = 1;
      foreach($statuses as $s){
         $field->addOption($s->id, $s->title);
      }
      $fieldset->add($field);
      */
     
      //show table
      foreach($statuses as $status){
         $fieldset->add($this->buildPagesWithStatusTable($status, $masterTable));
      }

      $wrapper->add($fieldset);
      return $wrapper;
   }

   protected function buildPagesWithStatusTable(Page $status, MarkupAdminDataTable $masterTable){
      $table = clone $masterTable;

      $pages = $this->pages->find("cf_status=$status,has_parent!={$this->config->trashPageID},include=all");

      $field = $this->modules->get('InputfieldMarkup');
      $field->label = $status->get('title|name');

      if(!count($pages)){
         //didn't find any pages
         $field->collapsed = Inputfield::collapsedYes;
         $field->value = $this->_('There are no pages with this status');
         return $field;
      }

      foreach($pages as $page){
         $row = array();
         $row["$page->title "] = $this->config->urls->admin . "page/edit/?id={$page->id}";
         $row[] = $page->is(Page::statusUnpublished) ? $this->_('No') : $this->_('Yes');
         $createdBy = $page->createdUser;
         $row["$createdBy->name "] = $this->config->urls->admin . "access/users/edit/?id={$createdBy->id}";
         $table->row($row);
      }

      $field->value = $table->render();

      return $field;
   }

   /**
    * Build the 'Notification Settings' tab
    */
   protected function ___buildFormNotificationSettings(){
      $modules = $this->modules;

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

      $field = $modules->get('InputfieldMarkup');
      $field->label = $this->_('My Markup');
      $field->attr('value', '<h4>Notification Saettings</h4>');

      $wrapper->append($field);
      return $wrapper;
   }

   /**
    * Build 'Status Settings' tab
    */
   protected function ___buildFormStatusSettings(){
      $languages = $this->languages;
      $language = $this->user->language; 
      $page = $this->page;
      $modules = $this->modules;

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

      //Fieldset for 'Add new status'
      $fieldset = $modules->get('InputfieldFieldset');
      $fieldset->label = $this->_('Statuses');
      $fieldset->description = $this->_('Create your own statuses to add structure to your publishing workflow. Edit existing ones and drag and drop to change their order.');

      $inputbutton = $modules->get('InputfieldButton');
      $inputbutton->attr('id+name', 'AddStatusBtn');
      $inputbutton->attr('value', $this->_('Add New Status'));
      $inputbutton->attr('href', './addnewstatus');
      $fieldset->append($inputbutton);

      $table = $this->modules->get('MarkupAdminDataTable');
      $table->headerRow(array(
         $this->_('Title'),
         $this->_('Description')
         ));
      $table->setEncodeEntities(false);
      $table->setSortable(true);

      $statusRoot = $this->pages->get($this->status_root_page_id);
      if($statusRoot->numChildren){
         foreach($statusRoot->children('template='.self::STATUS_TEMPLATE_NAME) as $s){
            $row = array();
            $row["$s->title "] = $this->config->urls->admin . "page/edit/?id={$s->id}";
            $row[] = $s->cf_status_description;
            $table->row($row);
         }
      }

      $field = $modules->get('InputfieldMarkup');
      $field->label = $this->_('Available Statuses');
      $field->description = $this->_('List of available statuses');
      $field->value = $table->render();
      $fieldset->append($field);

      $wrapper->append($fieldset);

      return $wrapper;
   }

   /**
    * Build 'Workflow Settings' tab
    */
   protected function ___buildFormWorkflowSettings(){
      $modules = $this->modules;
      $page = $this->page;

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

      //add templates_with_workflow field
      $field = $page->fields->get('templates_with_workflow');
      $fieldTemplates = $field->getInputfield($page);
      if(!$fieldTemplates){
         $this->error('Could not display Templates field');
      } else {
         
         $fieldTemplates->value = $page->get($field->name);

         $wrapper->append($fieldTemplates);
      }

      return $wrapper;
   }

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



   /**
    * ======================================
    * INSTALL, UNINSTALL, INPUTCONFIG, SETTINGS
    * ======================================
    */


   public function ___install(){

      //create our custom templates
      $this->createCustomTemplates();

      //create our custom admin pages
      $this->createCustomPages();

      //create fields
      $this->createFields();

      //set up root template
      $this->setupRootPageAndTemplate();

      //set up status template
      $this->setupStatusTemplate();


      //create our default statuses
      $statusRoot = $this->pages->get("id={$this->status_root_page_id}");
      if(!$statusRoot->numChildren){
         $defaultStatuses = $this->getStuff('status');
         foreach($defaultStatuses as $name => $statusFields){
            $p = new Page();
            $p->parent = $statusRoot;
            $p->template = $this->templates->get(self::STATUS_TEMPLATE_NAME);
            $p->name = $name;
            $p->title = $statusFields['title'];
            $p->cf_status_description = $statusFields['cf_status_description'];
            $p->save();
         }
      }
   }

   public function ___uninstall(){
      $permission = $this->permissions->get(self::PERMISSION_NAME);
      if($permission->id){
         $permission->delete();
      }

      //delete our cf tree
      $adminRootId = $this->config->adminRootPageID;
      $cfPage = $checkPage = $this->pages->get("parent=$adminRootId,name=" . self::ROOT_PAGE_NAME);
      if($cfPage->id){
         //delete cf page and all children permanently
         $cfPath = $cfPage->url;
         if($this->pages->delete($cfPage, true)){
            $this->message('Deleted Content Flow page and all children at: ' . $cfPath);
         } else {
            $this->error('Problem deleting Content Flow page and all children at: ' . $cfPath);
         }
      }

      //delete other pages that use our templates
      $this->deleteCustomPages();
      
      //remove our custom templates
      $this->removeCustomTemplates();

      //delete our fields
      $this->removeFields();

   }

   public static function getModuleConfigInputFields( array $data ){
      $data = array_merge(self::$defaults, $data);

      $fields = new InputfieldWrapper();
      $modules = wire('modules');

      return $fields;
   }

   protected function getStuff($type=''){
      $templates = array( self::ROOT_TEMPLATE_NAME, self::HOLDER_TEMPLATE_NAME, self::STATUS_TEMPLATE_NAME);
      $statuses = array(
         'pitch' => array( 'title' => $this->_('Pitch'), 'cf_status_description' => $this->_('Idea proposed; waiting for acceptance')),
         'assigned' => array( 'title' => $this->_('Assigned'), 'cf_status_description' => $this->_('Content assigned to writer.')),
         'draft' => array('title' => $this->_('Draft (In Progress)'), 'cf_status_description' => $this->_('Page content is under construction; not ready for review or publication.')),
         'pending' => array( 'title' => $this->_('Pending Review'), 'cf_status_description' => $this->_('Content needs to be reviewed by an editor')),
         'ready' => array('title' => $this->_('Ready to Publish'), 'cf_status_description' => $this->_('Content is good to go.'))
         );

      switch($type){
         case 'templates':
            return $templates;

         case 'status':
         case 'statuses':
            return $statuses;

         default:
            return array();
      }
   }

   /**
    * HELPER FUNCTIONS
    */
   

   /**
    * Set module data on $this->data but won't actually save module data. To save,
    * call $this->saveModuleData()
    * 
    * @param string $key
    * @param mixed $value
    */
   protected function setModuleData($key, $value){
      $this->data[$key] = $value;
   }

   /**
    * Saves the data array stored on $this->data
    *
    * return bool true on success otherwise false
    */
   protected function saveModuleData(){
      return $this->modules->saveModuleConfigData($this, $this->data);
   }


   /**
    * Returns list of workflow field names in array format
    */
   public function getWorkflowFields(){
      return self::$workflowFields;
   }


   /**
    * Returns list of status field name in array format
    */
   public function getStatusFields(){
      return self::$statusFields;
   }


   /**
    * Return list of templates with workflow enabled
    */
   public function getTemplatesWithWorkflow(){
      $page = $this->pages->get($this->root_page_id);

      if($page instanceof NullPage) return array();

      $templates = $page->templates_with_workflow;

      if(empty($templates))
         return array();
      else
         return $page->templates_with_workflow;
   }

   /**
    * Return a label for a given template
    * @param  Template $template template object
    * @return String             nice label of the template
    */
   protected function getTemplateLabel(Template $template) {
      $label = '';
      $user = wire('user'); 
      $language = wire('languages') && $user->language->id && !$user->language->isDefault ? wire('user')->language : null;
      if($language) $label = $template->get('label' . $language->id);
      if(!$label) $label = $template->label ? $template->label : $template->name; 
      return $label;
   }


   /**
    * Add specified fields to specified templates
    * @param array $templates    array of templates names/template id/Template objects
    * @param array $fieldNames   array of field names/Field objects
    */
   protected function addTemplateFields($templates = null, $fieldNames = null){
      
      if(empty($templates) || empty($fieldNames)){
         $this->error(sprintf($this->_('Error while calling %1$s::addTemplateFields(). Parameters must not be empty.'), __CLASS__));
      }

      //$this->session->CSRF->validate();

      foreach($templates as $tname){
         if($tname instanceof Template)
            $template = $tname;
         else
            $template = $this->templates->get($tname);

         if(is_null($template)){
            $this->error(sprintf($this->_('Error adding fields to template "%1$s" because template does not exist.'), $tname));
         } else {
            foreach($fieldNames as $fieldName){

               if(is_object($fieldName))
                  $field = $fieldName;
               else
                  if(!$field = $this->fields->get($fieldName)) continue;

               if(!$template->fields->has($field)){
                  $template->fields->add($field);
                  $this->fieldAdded($field,$template);
                  
               } else {
                  $field = $template->fields->getField($field->id, true); //get in context
                  $template->fields->add($field);
               }
               /*
               $template->fields->add($fieldName);
               if($template->fields->save()){
                  $this->message(sprintf($this->_('Added field "%1$s" to template "%2$s"'), $fieldName, $template->name));
               } 
               */
               
               $template->fields->save();
            }
         }
      }

   }


   /**
    * Remove specified fields to specified templates
    * @param array $templates    array of templates names/template id/Template objects
    * @param array $fieldNames   array of field names i.e. array('title', 'body');
    */
   protected function removeTemplateFields($templates = null, $fieldNames = null){
      if(empty($templates) || empty($fieldNames)){
         $this->error(sprintf($this->_('Error while calling %1$s::removeTemplateFields(). Parameters must not be empty.'), __CLASS__));
      }

      //$this->session->CSRF->validate();

      foreach($templates as $tname){
         if($tname instanceof Template)
            $template = $tname;
         else
            $template = $this->templates->get($tname);

         if(is_null($template)){
            $this->error(sprintf($this->_('Error removing fields from template "%1$s" because template does not exist.'), $tname));
         } else {
            foreach($template->fields as $field){
               if(in_array($field->name, $fieldNames)){
                  $template->fields->remove($field);
                  $this->fieldRemoved($field, $template);
               }
            }

            $template->fields->save();
         }
      }

   }

   /**
    * For hooks to listen to when a field is removed from a template
    *
    */
   public function ___fieldRemoved($field, $template) { 
      $this->message(sprintf($this->_('Removed field "%1$s" from template/fieldgroup "%2$s"'), $field, $template)); 
   }

   /**
    * For hooks to listen to when a field is added to a template
    *
    */
   public function ___fieldAdded($field, $template) { 
      $this->message(sprintf($this->_('Added field "%1$s" to template/fieldgroup "%2$s"'), $field, $template)); 
   }

   /**
    * Status message when system field is created
    */
   protected function systemFieldCreated($field) { 
      $this->message(sprintf($this->_('System field "%1$s" created'), $field));
   }



   /**
    * INSTALL/UNINSTALL HELPER FUNCTIONS
    */
   
   protected function createCustomTemplates(){

      foreach( $this->getStuff('templates') as $tname ){

         $temp = $this->templates->get($tname);
         if(is_null($temp)){

            $fg = $this->fieldgroups->get($tname);
            if(!$fg){
               $fg = new Fieldgroup();
               $fg->name = $tname; //fieldgroup and template have the same name
               $fg->add($this->fields->get('title')); //required field
               $fg->save();
            }

            $temp = new Template();
            $temp->name = $tname;
            $temp->fieldgroup = $fg;
            $temp->noGlobal = 1;
            $temp->nameContentTab = 1;
            $temp->flags = $temp->flags | Template::flagSystem;
            if($temp->save()){
               $this->message('Created template: ' . $tname);
            } else {
               $this->error('Problem creating template: ' . $tname);
            }
         }
      }
   }

   protected function removeCustomTemplates(){

      $this->prepareTemplatesForRemoval();

      foreach($this->getStuff('templates') as $tname){
         $temp = $this->templates->get($tname);
         if(!is_null($temp)){
            //try to delete our custom template
            try{
               $fg = $temp->fieldgroup;

               $temp->flags = Template::flagSystemOverride;
               $temp->flags = 0;
               $temp->save();
               if($this->templates->delete($temp)){
                  $this->message('Removed template: ' . $tname);
               } else {
                  $this->message('Could not remove template: ' . $tname);
               }

               //TODO: check if other templates are using fieldgroup??
               $this->fieldgroups->delete($fg);
               
            } catch(Exception $e){
               //this can happen if *someone* uses our holder templates
               $this->error('Fatal error while deleting template: ' . $tname);
            }
         }
      }

      $this->templatesRemoved();
   }

   protected function ___prepareTemplatesForRemoval(){

      //remove cf fields from contentflow-status template
      $statusFields = $this->getStatusFields();
      $template = $this->templates->get(self::STATUS_TEMPLATE_NAME);
      $this->removeTemplateFields(array($template), $statusFields);
   }

   protected function ___templatesRemoved(){}


   protected function ___setupRootPageAndTemplate(){

      $basePage = $this->pages->get($this->root_page_id);

      //set 'process' field
      $basePage->process = $this;

      //set 'templates_with_workflow' field to empty array to avoid error
      $basePage->templates_with_workflow = array();

      //add template fields and stuff here.
      $baseTemplate = $this->templates->get(self::ROOT_TEMPLATE_NAME);
      $baseTemplateFields = array('templates_with_workflow', 'process');
      if(is_null($baseTemplate)){
         $this->error(sprintf($this->_('Error adding fields to base template (%1$s) because it does not exist.'), self::ROOT_TEMPLATE_NAME));
      } else {
         foreach($baseTemplateFields as $fieldName){
            $baseTemplate->fields->add($fieldName);
            $baseTemplate->fields->save();
            $this->fieldAdded($fieldName, $baseTemplate); 
         }
      }

      //specify alternate template filename
      $baseTemplate->altFilename = 'admin';

      //allow url segments
      $baseTemplate->urlSegments = 1;

      //save
      $basePage->save();
      $baseTemplate->save();

   }


   protected function setupStatusTemplate(){
      $template = $this->templates->get(self::STATUS_TEMPLATE_NAME);

      if(!$template) return; //TODO: error messages?

      $fieldNames = $this->getStatusFields();

      //these additional fields should already be available in the system
      $additionalFields = array();

      $this->addTemplateFields(array($template), array_merge($fieldNames, $additionalFields));

      /* save selected fields in the context of the contentflow-status template/fieldgroup only */

      //get the field in the context of the fieldgroup. set 2nd parameter to TRUE
      $field = $template->fields->getField('cf_roles', true);
      $field->label = $this->_('Notify Roles');
      $field->description = $this->_('Select the roles (user groups) that should receive notifications when a page is set to this status.');
      $this->fields->saveFieldgroupContext($field, $template->fields);

      $field = $template->fields->getField('cf_users', true);
      $field->label = $this->_('Notify Users');
      $field->description = $this->_('Select the users that should receive notifications when a page is set to this status.');
      $this->fields->saveFieldgroupContext($field, $template->fields);

   }

   protected function createFields(){
      //create 'templates with workflow' field
      if(!$this->fields->get('templates_with_workflow')){
         $field = new Field();
         $field->name = 'templates_with_workflow';
         $field->label = $this->_('Templates with workflow');
         $field->description = $this->_('Specify which templates should have publishing workflow');
         $field->labelFieldName = 'label';
         $field->type = wire('modules')->get('FieldtypeTemplates');
         $field->flags = $field->flags | Field::flagSystem;

         //set initial template types available
         $templateTypes = array();
         foreach($this->templates as $template){
            if($template->flags & Template::flagSystem) continue;
            $templateTypes[] = $template->id;
         }
         $field->templateTypes = $templateTypes;

         if($field->save()){
            $this->systemFieldCreated($field);
         } else {
            $this->error(sprintf($this->_('Problem creating system field: %1$s'), $field->name));
         }

      }

      /**
       * Create 'cf_status' field
       * This field is added to pages that should have an editorial workflow
       */
      if(!$this->fields->get('cf_status')){
         $field = new Field();
         $field->name = 'cf_status';
         $field->label = $this->_('Workflow Status');
         $field->description = $this->_('Defines the keys stages in the workflow. Select the stage this page is in.');
         $field->labelFieldName = 'title';
         $field->required = 1;
         $field->type = wire('modules')->get('FieldtypePage');
         $field->inputfield = 'InputfieldSelect';
         $field->derefAsPage = FieldtypePage::derefAsPageOrFalse;
         $field->parent_id = $this->status_root_page_id;
         $field->flags = $field->flags | Field::flagSystem;
         if($field->save()){
            $this->systemFieldCreated($field);
         } else {
            $this->error('Problem creating system field: ' . $field->name);
         }
      }

      /**
       * Create 'cf_status_description' field
       * This field is added to 'contentflow-status' type pages
       */
      if(!$this->fields->get('cf_status_description')){
         $field = new Field();
         $field->name = 'cf_status_description';
         $field->label = $this->_('Status Description');
         $field->description = $this->_('Describe what this custom status is to be used for. This field is primarily for administrative use only.');
         $field->type = wire('modules')->get('FieldtypeTextarea');
         $field->flags = $field->flags | Field::flagSystem;
         if($field->save()){
            $this->systemFieldCreated($field);
         } else {
            $this->error(sprintf($this->_('Problem creating system field: %1$s'), $field->name));
         }
      }

      /**
       * Create 'cf_users' field
       * This field will list all users as checkbox
       */
      if(!$this->fields->get('cf_users')){
         $field = new Field();
         $field->name = 'cf_users';
         $field->label = $this->_('Users');
         $field->type = wire('modules')->get('FieldtypePage');

         $field->labelFieldName = 'name';
         $field->findPagesSelector = 'template=user,sort=name';
         $field->inputfield = 'InputfieldCheckboxes';
         $field->derefAsPage = FieldtypePage::derefAsPageArray;
         $field->flags = $field->flags | Field::flagSystem;
         if($field->save()){
            $this->systemFieldCreated($field);
         } else {
            $this->error(sprintf($this->_('Problem creating system field: %1$s'), $field->name));
         }
      }

      /**
       * Create 'cf_roles' field
       * This field will list all roles as checkbox
       */
      if(!$this->fields->get('cf_roles')){
         $field = new Field();
         $field->name = 'cf_roles';
         $field->label = $this->_('Roles (User Groups)');
         $field->type = wire('modules')->get('FieldtypePage');

         $field->labelFieldName = 'name';
         $field->findPagesSelector = 'template=role,sort=name';
         $field->inputfield = 'InputfieldCheckboxes';
         $field->derefAsPage = FieldtypePage::derefAsPageArray;
         $field->flags = $field->flags | Field::flagSystem;
         if($field->save()){
            $this->systemFieldCreated($field);
         } else {
            $this->error(sprintf($this->_('Problem creating system field: %1$s'), $field->name));
         }
      }

   }

   protected function removeFields(){

      //remove workflow fields from templates (if any)
      $fieldNames = $this->getWorkflowFields();
      $templates = $this->templates;
      $this->removeTemplateFields($templates, $fieldNames);

      $statusFields = $this->getStatusFields();

      //now remove all contentflow fields including workflow fields
      $fields = array_merge($fieldNames, $statusFields, array('templates_with_workflow'));

      foreach($fields as $fname){
         $field = null;
         $field = $this->fields->get($fname);
         if($field){
            $field->flags = Field::flagSystemOverride;
            $field->flags = 0;
            if($this->fields->delete($field)){
               $this->message('Deleted field: ' . $fname);
            } else {
               $this->error('Problem deleting field: ' . $fname);
            }
         }
      }
   }

   protected function createCustomPages(){
      
      $templates = $this->templates;
      $pages = $this->pages;
      $data = array();

      $holderTemplate = $templates->get(self::HOLDER_TEMPLATE_NAME);

      //see if we still need to create our page
      $checkPage = $this->pages->get('template=' . self::ROOT_TEMPLATE_NAME . ',name=' . self::ROOT_PAGE_NAME);
      if(!$checkPage->id){
         //create our base settings page under "admin"
         $cfPage = new Page();
         $cfPage->template = $templates->get(self::ROOT_TEMPLATE_NAME);
         $cfPage->parent = $pages->get($this->config->adminRootPageID);
         $cfPage->title = 'Content Flow';
         $cfPage->name = self::ROOT_PAGE_NAME;
         $cfPage->save();

         $cfRootPage = $cfPage;
      } else {
         $cfRootPage = $checkPage;
      }

      //save our cf root page id so we can reference this later.
      $this->setModuleData('root_page_id', $cfRootPage->id);


      //see if we still need to create our permissions
      $checkPermission = $this->permissions->get(self::PERMISSION_NAME);
      if(!$checkPermission->id){
         $perm = new Permission();
         $perm->name = self::PERMISSION_NAME;
         $perm->title = $this->_('Access Content Flow pages');
         $perm->save();
      }

      //create status pages
      $checkStatusRoot = $pages->get("parent=$cfRootPage,name=contentflow-statuses");
      if(!$checkStatusRoot->id){
         $pStatuses = new Page();
         $pStatuses->template = $holderTemplate;
         $pStatuses->parent = $cfRootPage;
         $pStatuses->name = 'status';
         $pStatuses->title = $this->_('Status');
         $pStatuses->save();

         $statusRoot = $pStatuses;
      } else {
         $statusRoot = $checkStatusRoot;
      }
      $this->setModuleData('status_root_page_id', $statusRoot->id);

      //save module data
      $this->saveModuleData();
   }

   protected function deleteCustomPages(){
      $templates = $this->getStuff('templates');
      $pages = $this->pages->find("template=".implode('|', $templates));
      foreach($pages as $page){
         $path = $page->url;
         if($this->pages->delete($page,true)){
            $this->message(sprintf($this->_('Deleted content flow type page and all children at: %1$s'), $path));
         } else {
            $this->error(sprintf($this->_('Problem deleting content flow type page and all children at: %1$s'), $path));
         }
      }
   }
}