Subversion Repositories web.active

<?php namespace ProcessWire;

/**
 * ProcessWire User Profile Editor
 *
 * ProcessWire 3.x, Copyright 2021 by Ryan Cramer
 * https://processwire.com
 *
 * @property array $profileFields Names of fields user is allowed to edit in their profile
 * @method bool|string isDisallowedUserName($value)
 *
 */

class ProcessProfile extends Process implements ConfigurableModule, WirePageEditor {

  public static function getModuleInfo() {
    return array(
      'title' => __('User Profile', __FILE__), // getModuleInfo title          
      'summary' => __('Enables user to change their password, email address and other settings that you define.', __FILE__), // getModuleInfo summary 
      'version' => 105, 
      'permanent' => true, 
      'permission' => 'profile-edit',
    );
  }
  
  /**
   * @var User
   * 
   */
  protected $user;

  /**
   * Label for user “name”
   * 
   * @var string
   * 
   */
  protected $userNameLabel = '';

  /**
   * Password required for changes to these field names
   * 
   * @var array
   * 
   */
  protected $passRequiredNames = array();

  /**
   * Construct/establish initial module configuration
   * 
   */
  public function __construct() {
    $this->set('profileFields', array()); 
    $this->userNameLabel = $this->_('User Login Name'); // Label for user login name
    parent::__construct();
  }

  /**
   * Execute/render profile edit form
   * 
   * @return string
   * @throws WireException
   * 
   */
  public function ___execute() {
    
    $fieldName = '';
    if(isset($_SERVER['HTTP_X_FIELDNAME'])) {
      $fieldName = $this->wire()->sanitizer->fieldName($_SERVER['HTTP_X_FIELDNAME']);
    }

    $this->user = $this->wire()->user; 
    $this->headline($this->_("Profile:") . ' ' . $this->user->name); // Primary Headline (precedes the username)
    $form = $this->buildForm($fieldName);
    
    if($this->wire()->input->post('submit_save_profile') || $fieldName) {
      $this->processInput($form, $fieldName); 
      if($fieldName) {
        // no need to redirect
      } else {
        $this->wire()->session->redirect("./");
      }
        
    } else { 
      return $form->render();
    }
    return '';
  } 

  /**
   * Build the form fields for adding a page
   * 
   * @param string $fieldName
   * @return InputfieldForm
   *
   */
  protected function buildForm($fieldName = '') {
  
    /** @var User $user */
    $user = $this->user;
    $modules = $this->wire()->modules;

    /** @var InputfieldForm $form */
    $form = $modules->get('InputfieldForm');
    $form->attr('id', 'ProcessProfile'); 
    $form->attr('action', './'); 
    $form->attr('method', 'post'); 
    $form->attr('enctype', 'multipart/form-data');
    $form->attr('autocomplete', 'off'); 
    $form->addClass('InputfieldFormConfirm');
    
    $fieldset = new InputfieldWrapper();
    $this->wire($fieldset);
    $form->add($fieldset);
  
    // is password required to change some Inputfields?
    $passRequired = false;
    // Inputfields where password is required to change
    $passRequiredInputfields = array();
    $this->wire()->config->js('ProcessProfile', array(
      'passRequiredAlert' => $this->_('For security, please enter your current password to save these changes:')
    ));
    
    /** @var JqueryUI $jQueryUI */
    $jQueryUI = $modules->get('JqueryUI');
    $jQueryUI->use('vex');
    
    if(in_array('name', $this->profileFields) && empty($fieldName)) {
      /** @var InputfieldText $f */
      $f = $modules->get('InputfieldText');
      $f->attr('id+name', '_user_name');
      $f->label = $this->userNameLabel;
      $f->description = $this->_('User name may contain lowercase a-z, 0-9, hyphen or underscore.'); 
      $f->icon = 'sign-in';
      $f->attr('value', $user->name);
      $f->attr('pattern', '^[-_a-z0-9]+$'); 
      $f->required = true; 
      $fieldset->add($f);
      $f->setTrackChanges(true);
      $passRequiredInputfields[] = $f;
    }

    foreach($user->fields as $field) {
      if($field->name == 'roles' || !in_array($field->name, $this->profileFields)) continue;
      if($fieldName && $field->name !== $fieldName) continue;
      /** @var Field $field */
      $field = $user->fields->getFieldContext($field);
      /** @var Inputfield $inputfield */
      $inputfield = $field->getInputfield($user);
      if(!$inputfield) continue;
      $inputfield->value = $user->get($field->name);
      
      if($field->name === 'admin_theme') {
        if(!$inputfield->value) $inputfield->value = $this->wire('config')->defaultAdminTheme;
        
      } else if($field->type instanceof FieldtypeImage) {
        if(!$user->hasPermission('page-edit-images', $user)) {
          $inputfield->set('useImageEditor', false);
        }
        
      } else if($field->type instanceof FieldtypePassword && $field->name == 'pass') {
        $inputfield->attr('autocomplete', 'off');
        if($inputfield->getSetting('requireOld') == InputfieldPassword::requireOldAuto) {
          $inputfield->set('requireOld', InputfieldPassword::requireOldYes); 
        }
        if($inputfield->getSetting('requireOld') == InputfieldPassword::requireOldYes) {
          $passRequired = true; 
        }
        if(!$inputfield->getSetting('icon')) $inputfield->set('icon', 'key');
        
      } else if($field->name === 'email') {
        if(!$inputfield->getSetting('icon')) $inputfield->set('icon', 'envelope-o');
        if(strlen($inputfield->value)) {
          $passRequiredInputfields[] = $inputfield;
        }
      } else if($field->name === 'tfa_type') {
        $passRequiredInputfields[] = $inputfield;
        if(!$inputfield->val()) {
          // initialize manually so it can add hooks (it just does some visual/wording tweaks)
          $tfa = $this->wire(new Tfa()); /** @var Tfa $tfa */
          $tfa->init(); 
        }
      }
      
      $fieldset->add($inputfield); 
    }
  
    /** @var InputfieldHidden $f */
    // note used for processing, present only for front-end JS compatibility with ProcessPageEdit
    $f = $modules->get('InputfieldHidden');
    $f->attr('id', 'Inputfield_id');
    $f->attr('name', 'id'); 
    $f->attr('value', $user->id);
    $f->addClass('InputfieldAllowAjaxUpload');
    $fieldset->add($f);

    /** @var InputfieldSubmit $field */
    $field = $modules->get('InputfieldSubmit');
    $field->attr('id+name', 'submit_save_profile'); 
    $field->showInHeader();
    $form->add($field); 
    
    if($passRequired && count($passRequiredInputfields)) {
      foreach($passRequiredInputfields as $f) {
        $f->addClass('InputfieldPassRequired', 'wrapClass');
        $this->passRequiredNames[$f->name] = $f->name;
      }
    }
  
    return $form; 
  }

  /**
   * Save the submitted page add form
   * 
   * @param Inputfield $form
   * @param string $fieldName
   * @throws WireException
   *
   */
  protected function processInput(Inputfield $form, $fieldName = '') {
    
    /** @var InputfieldForm $form */

    $user = $this->user; 
    $input = $this->wire()->input;
    $languages = $this->wire()->languages;
    $form->processInput($input->post);

    if(count($form->getErrors())) {
      $this->error($this->_("Profile not saved")); 
      return;
    }
    
    $passValue = $input->post->string('_old_pass');
    
    if(strlen($passValue)) {
      $passAuthenticated = $user->pass->matches($passValue);
      $passFailedMessage = $this->_('Required password was provided but is not correct');
    } else {
      $passAuthenticated = false;
      $passFailedMessage = $this->_('Required password was not provided');
    }
    
    $user->of(false);
    $user->setTrackChanges(true);

    if(in_array('name', $this->profileFields) && empty($fieldName)) {
      $f = $form->getChildByName('_user_name');
      if($f && $f->isChanged()) {
        if(isset($this->passRequiredNames[$f->name]) && !$passAuthenticated) {
          $f->error($passFailedMessage);
        } else {
          $this->processInputUsername($f);
        }
      }
    }

    foreach($user->fields as $field) {

      if($field->name == 'roles' || !in_array($field->name, $this->profileFields)) continue;
      if($fieldName && $field->name !== $fieldName) continue; 
      
      $field = $user->fields->getFieldContext($field);
      $inputfield = $form->getChildByName($field->name);  
      $value = $inputfield->attr('value');
      
      if(empty($value) && in_array($field->name, array('pass', 'email'))) continue;
      
      if($field->name == 'email' && strlen($value)) {
        $selector = "id!=$user->id, include=all, email=" . $this->sanitizer->selectorValue($value);
        if(count($this->users->find($selector))) {
          $this->error(sprintf($this->_('Email address "%s" already in use by another user.'), $value));
          continue; 
        }
      }
      
      $userValue = $user->get($field->name);
      if($field->type instanceof FieldtypeModule) $userValue = "$userValue";
      $changed = false;
      
      if($inputfield->isChanged()) {
        $changed = true;
      } else if(is_array($value) && $userValue instanceof WireData) { // i.e. Combo
        $userValueArray = $userValue->getArray();
        $changed = $userValueArray != $value;
      } else if($userValue !== $value) {
        $changed = true;
      }
      
      if(!$changed) continue;
        
      if(isset($this->passRequiredNames[$inputfield->name]) && !$passAuthenticated) {
        $inputfield->error($passFailedMessage);
        continue; 
      }

      if($languages && $inputfield->getSetting('useLanguages')) {
        if(is_object($userValue)) {
          $userValue->setFromInputfield($inputfield);
          $user->set($field->name, $userValue);
          $user->trackChange($field->name);
        } else {
          $user->set($field->name, $value);
        }
      } else {
        $user->set($field->name, $value);
      }
    }

    if($user->isChanged()) {
      $changes = implode(', ', array_unique($user->getChanges())); 
      $message = $this->_('Profile saved') . ' - ' . $changes; 
      $this->message($message);
      $this->wire()->log->message($message); 
      $this->wire()->users->save($user);
    }

    $user->of(true); 
  }

  /**
   * Process username inputfield
   * 
   * @param Inputfield $f The _user_name Inputfield
   * @return bool Returns true if username changed allowed, false if not
   * 
   */
  protected function processInputUsername(Inputfield $f) {
    
    $user = $this->user;
    $userName = $this->wire()->sanitizer->pageName($f->val());
    
    if(empty($userName)) return false;
    if($f->val() === $user->name) return false; // no change
    if($userName === $user->name) return false; // no change after sanitization
  
    /* at this point we know that user changed their name */
  
    $error = $this->isDisallowedUserName($f->val()); 
    if($error !== false) {
      $f->error($error); 
      return false;
    }
    
    $user->name = $userName;

    $languages = $this->wire()->languages;
    if($languages && $languages->hasPageNames()) {
      foreach($languages as $language) {
        if(!$language->isDefault()) $user->set("name$language->id", $userName);
      }
    }
    
    return true; 
  }
  
  /**
   * Return error message if user name is not allowed (to change to) or boolean false if it is
   *
   * @param string $value User name
   * @return bool|string
   *
   */
  public function ___isDisallowedUserName($value) {

    $disallowedNames = array(
      'superuser',
      'admin',
      'administrator',
      'root',
      'guest',
      'nobody',
    );

    $languages = $this->wire()->languages;
    $notAllowedLabel = $this->_('Not allowed');
    $userName = $this->wire()->sanitizer->pageName($value);
    
    if($userName !== $value) {
      return sprintf($this->_('Sanitized to “%s”, which differs from what you entered'), $userName);
    }

    if(strlen($userName) < 3) {
      return $this->_('Too short');
    } else if(strlen($userName) > 64) {
      return $this->_('Too long');
    }

    if(in_array($userName, $disallowedNames)) {
      return "$notAllowedLabel (#1)";
    }

    // check if user name is already in use
    if($languages) $languages->setDefault();
    $u = $this->wire()->users->get("name='$userName', include=all");
    if($languages) $languages->unsetDefault();
    if($u->id) {
      return $this->_('Already in use');
    }

    $role = $this->wire()->roles->get("name='$userName', include=all");
    if($role->id) {
      return "$notAllowedLabel (#2)";
    }

    if(!ctype_alnum(substr($userName, 0, 1)) || !ctype_alnum(substr($userName, -1))) {
      return $this->_('May not start or end with non-alpha, non-digit characters');
    }

    if(preg_match('/[-_.]{2,}/', $userName)) {
      return $this->_('May not contain adjacent hyphens, underscores or periods');
    }

    return false;
  }

  /**
   * Module configuration
   * 
   * @param array $data
   * @return InputfieldWrapper
   * @throws WireException
   * 
   */
  public function getModuleConfigInputfields(array $data) {

    $profileFields = isset($data['profileFields']) ? $data['profileFields'] : array();
    $fieldOptions = array();
    
    foreach($this->wire()->users->getTemplates() as $template) {
      foreach($template->fieldgroup as $field) {
        $fieldOptions[$field->name] = $field;
      }
    }
    
    ksort($fieldOptions);

    $inputfields = $this->wire(new InputfieldWrapper());
    
    /** @var InputfieldCheckboxes $f */
    $f = $this->wire()->modules->get('InputfieldCheckboxes');
    $f->label = $this->_("What fields can a user edit in their own profile?");
    $f->attr('id+name', 'profileFields');
    $f->icon = 'user-circle';
    $f->table = true;
    $f->thead = 
      $this->_('Name') . '|' . 
      $this->_('Label') . '|' . 
      $this->_('Type');
    
    $f->addOption('name', "name|$this->userNameLabel|System"); 
    
    foreach($fieldOptions as $name => $field) {
      if($name == 'roles') continue;
      $f->addOption($name, $name . '|' . str_replace('|', ' ', $field->getLabel()) . '|' . $field->type->shortName); 
    }
    
    $f->attr('value', $profileFields);
    $inputfields->add($f);

    return $inputfields;
  }

  /**
   * For WirePageEditor interface
   * 
   * @return Page
   * 
   */
  public function getPage() {
    return $this->wire()->user;
  }


}