NewsletterSubscription.module

<?php namespace ProcessWire;
/**
 * NewsletterSubscription
 * Allow users to subscribe and unsubscribe to a newsletter
 * See README.md for usage instructions.
 *
 * ProcessWire 3.x
 * Licensed under GNU/GPL v2, see LICENSE.TXT
 *
 * @author Tabea David
 * @version 1.0.1
 * @copyright Copyright (c) 2016
 * @see https://github.com/justonestep/processwire-newslettersubscription
 * @see http://www.processwire.com
 */

/**
 * Class NewsletterSubscription
 */
class NewsletterSubscription extends WireData implements Module, ConfigurableModule {

  /**
   * Retrieves module meta data
   * Implementation of the Module interface
   *
   * @return array
   * @see http://processwire.com/apigen/class-Module.html
   */
  public static function getModuleInfo() {
    return array(
      'title' => 'NewsletterSubscription',
      'summary' => 'Allow users to subscribe and unsubscribe to a newsletter',
      'version' => '1.0.1',
      'author' => 'Tabea David',
      'href' => 'http://github.com/justonestep/processwire-newslettersubscription',
      'autoload' => false,
      'singular' => false,
      'icon' => 'newspaper-o',
    );
  }

  /**
   * Markup used during the render() method
   */
  static protected $markup = array(
    'list' => "{out}\n",
    'item' => "\n\t<div {attrs}>\n{out}\n\t</div>",
    'item_label' => "\n\t\t<label class='form__item--label' for='{for}'>{out}</label>",
    'item_label_hidden' => "\n\t\t<label class='field__header field__header--hidden {class}'>{out}</label>",
    'item_content' => "{out}",
    'item_error' => "\n<p class='field--error--message'>{out}</p>",
    'item_description' => "\n<p class='field__description'>{out}</p>",
    'item_head' => "\n<h2>{out}</h2>",
    'item_notes' => "\n<p class='field__notes'>{out}</p>",
    'item_icon' => "",
    'item_toggle' => "",
    // ALSO:
    // InputfieldAnything => array( any of the properties above to override on a per-Inputifeld basis)
  );

  /**
   * Classes used during the render() method
   */
  static protected $classes = array(
    'form' => 'form', // additional clases for inputfieldform (optional)
    'list' => 'fields',
    'list_clearfix' => 'clearfix',
    'item' => 'form__item form__item--{name}',
    'item_label' => '', // additional classes for inputfieldheader (optional)
    'item_content' => '',  // additional classes for inputfieldcontent (optional)
    'item_required' => 'field--required', // class is for inputfield
    'item_error' => 'field--error', // note: not the same as markup[item_error], class is for inputfield
    'item_collapsed' => 'field--collapsed',
    'item_column_width' => 'field__column',
    'item_column_width_first' => 'field__column--first',
    'item_show_if' => 'field--show-if',
    'item_required_if' => 'field--required-if'
    // ALSO:
    // InputfieldAnything => array( any of the properties above to override on a per-Inputifeld basis)
  );

  /**
   * Render newsletter subscription
   *
   * @param array $options
   * @return string
   */
  public function ___render($options = array()) {
    $out = '';

    // confirmation link was clicked
    if ($action = $this->sanitizer->text($this->input->get->a)) {
      $out = $action === 'subscribe' ? $this->validateSubscribeToken() : $this->validateUnsubscribeToken();
    } else {
      // render basic form (and errors)
      $out = $this->renderForm($options);
    }

    return $out;
  }

  /**
   * Set markup
   *
   * @param Form $form
   * @param array $options
   */
  private function setMarkup(&$form, $options) {
    $markup = isset($options['markup']) ? array_merge(self::$markup, $options['markup']) : self::$markup;
    $form->setMarkup($markup);
  }

  /**
   * Set classes
   *
   * @param Form $form
   * @param array $options
   */
  private function setClasses(&$form, $options) {
    $classes = isset($options['classes']) ? array_merge(self::$classes, $options['classes']) : self::$classes;
    $form->setClasses($classes);
  }

  /**
   * Get user by token
   */
  private function getUserByToken() {
    $token = $this->db->escapeStr($this->input->get->t);
    $userAuthSalt = $this->db->escapeStr($this->config->userAuthSalt);
    $role = $this->roles->get('newsletter');

    $select = 'p.id, e.data AS email, p.modified FROM pages AS p';
    $joinEmail = 'field_email e ON (p.id = e.pages_id)';
    $joinRole = 'field_roles r ON (p.id = r.pages_id)';
    $where = "r.data = '{$role->id}'";

    if ($this->sanitizer->text($this->input->get->a) === 'subscribe') {
      $addWhere = "sha1(CONCAT(e.data, p.id, '$userAuthSalt')) = '$token'";
      $addWhere .= ' && p.status = ' . Page::statusHidden;
    } else {
      $addWhere = "sha1(CONCAT(e.data, '$userAuthSalt')) = '$token'";
      $addWhere .= ' && p.status = ' . Page::statusOn;
    }

    return $this->db->query("SELECT $select LEFT JOIN $joinEmail LEFT JOIN $joinRole WHERE $where && $addWhere");
  }

  /**
   * Get and validate user
   *
   * @param string $out
   * @param integer $status
   * @return User
   */
  private function getAndValidateUser(&$out, $status) {
    $result = $this->getUserByToken();

    if ($this->input->get->a === 'subscribe') {
      $message = html_entity_decode($this->_("Unfortunately there's no such user in the database."), ENT_QUOTES, 'UTF-8');
    } else {
      $message = html_entity_decode($this->_("Unfortunately there's no such user in the database (unsubscribe)."), ENT_QUOTES, 'UTF-8');
    }

    // no user/page was found
    if (!$result->num_rows) {
      $out .= $message;
      return false;
    }

    list ($id, $email, $modified) = $result->fetch_row();
    $user = $this->users->get($id);

    // page is not hidden / user has not role `newsletter`
    if (!$user || $user->status !== $status || !$user->hasRole('newsletter')) {
      $out .= $message;
      return false;
    }

    // only if action equals subscribe: validate created + time x
    // compare today and created + valid duration time
    if ($status !== Page::statusOn) {
      $createdDate = new \DateTime($modified);
      $period = "P{$this->periodOfValidity}D";
      $createdDate->add(new \DateInterval($period));
      $today = new \DateTime();
      if ($today > $createdDate) {
        $out .= $this->_('Unfortunately this confirmation token has expired.');
        return false;
      }
    }

    return $user;
  }

  /**
   * validate unsubscribe token
   *
   * @return string
   */
  private function validateUnsubscribeToken() {
    $out = '';

    // delete user
    if ($user = $this->getAndValidateUser($out, Page::statusOn)) {
      if ($this->notifyAdmin) $this->notifyAdmin($user, 'unsubscribe');
      $this->users->delete($user);
      $this->log->save('messages', "User has been successfully deleted with email `{$user->email}`.");
      $out .= html_entity_decode($this->_('Your account has been successfully deleted.'), ENT_QUOTES, 'UTF-8');
    }

    return $out;
  }

  /**
   * validate subscribe token
   *
   * @return string
   */
  private function validateSubscribeToken() {
    $out = '';

    // enable user
    if ($user = $this->getAndValidateUser($out, Page::statusHidden)) {
      $user->set('status', Page::statusOn);
      $user->save();

      $this->log->save('messages', "User has been successfully confirmed with email `{$user->email}`.");
      $out .= html_entity_decode($this->_('Thank you for your newsletter subscription.'), ENT_QUOTES, 'UTF-8');
      if ($this->notifyAdmin) $this->notifyAdmin($user, 'subscribe');
    }

    return $out;
  }

  /**
   * Notify Admin
   *
   * @param User $user
   * @param string $action
   */
  public function ___notifyAdmin($user, $action) {
    $wireMail = wireMail();

    // $wireMail->to($this->notifyAdminMailto);
    list($toEmail, $toName) = $this->extractEmailAndName($this->notifyAdminMailto);
    $wireMail->to = "$toName <$toEmail>";

    if ($action === 'subscribe') {
      $mailFrom = $this->adminNotifyGetContent($user, $this->notifyAdminSubscribeMailfrom);
      $message = $this->adminNotifyGetContent($user, $this->notifyAdminMessageSubscribe);
      $wireMail->subject($this->_('Newsletter Subscription Notification'));
    } else {
      $mailFrom = $this->adminNotifyGetContent($user, $this->notifyAdminUnsubscribeMailfrom);
      $message = $this->adminNotifyGetContent($user, $this->notifyAdminMessageUnsubscribe);
      $wireMail->subject($this->_('Newsletter Unsubscription Notification'));
    }

    // $wireMail->from($mailFrom);
    list($fromEmail, $fromName) = $this->extractEmailAndName($mailFrom);
    $wireMail->from = "$fromName <$fromEmail>";

    $wireMail->body(trim($message));
    $numSent = $wireMail->send();

    if (!$numSent) {
      $this->log->save('errors', "Email could not been sent to `{$this->notifyAdminMailto}`.");
    } else {
      $this->log->save('messages', "Email has been sent successfully to `{$this->notifyAdminMailto}`.");
    }
  }

  /**
   * Render form
   *
   * @param array $options
   * @return string
   */
  private function renderForm($options = array()) {
    $form = $this->getForm($options);
    $this->setMarkup($form, $options);
    $this->setClasses($form, $options);
    $out = '';

    // if form was submitted
    if ($this->input->post->submit) {

      // if unsubscribe=unsubscribe don't process form, only validate email
      if ($this->input->post->unsubscribe === 'unsubscribe') {
        $success = $this->doUnsubscribe($form);
        $text = $this->_('Your newsletter request has been processed successfully! Please check your email for further instructions to comfirm the unsubscription.');
      } else {
        $success = $this->doSubscribe($form);
        $text = $this->_('Congratulations, your newsletter request has been processed successfully! Please check your email for further instructions.');
      }

      // the form contains errors
      if (!$success) {
        $message = array('error', $this->_('Please verify the data you have entered.'));
        $out .= $form->render();
      } else {
        $message = array('success', $text);
      }

      $this->input->post->success = $success;
      $out .= "<p class='newsletter--{$message[0]}'>{$message[1]}</p>";
    } else {
      $out .= $form->render();
    }

    return $out;
  }

  /**
   * subscribe user
   *
   * @param Form $form
   * @return boolean
   */
  private function doSubscribe($form) {
    $form->processInput($this->input->post);

    // email unique with role newsletter
    $email = $form->get('email');
    $unique = $this->users->find("email=$email->value,roles=newsletter,status=" . Page::statusOn);
    if (!$this->noCompare && count($unique) > 0) $email->error(__('This email address is already registered.'));

    if ($form->getErrors()) {
      // the form contains errors
      $success = false;
    } else {
      $success = true;
      $this->addUser();
    }

    return $success;
  }

  /**
   * unsubscribe user
   *
   * @param Form $form
   * @return boolean
   */
  private function doUnsubscribe($form) {
    $emailFormItem = $form->get('email');
    $emailString = $this->sanitizer->email($this->input->post->email);

    if (!$emailString) {
      $success = false;
      $emailFormItem->error($this->_('Please enter a valid email address.'));
    } else {
      $success = true;
      $user = $this->users->get("email=$emailString,roles=newsletter,status=" . Page::statusOn);

      // create user with email address to enable unsubscribtion via token
      if ($this->noCompare && !$user instanceof User) {
        $user = new User();
        $user->of(false);
        $user->name = "tmp_$emailString";
        $user->email = $emailString;
        $user->addRole('newsletter');
        $user->status = Page::statusOn;
        $user->save();
        $user->of(false);
      }

      // do not show if email could not be found
      if ($user instanceof User) {
        // send unsubscribe mail
        $token = sha1($emailString . $this->config->userAuthSalt);
        $this->sendValidationMail($token, $user, 'unsubscribe');
      }
    }

    return $success;
  }

  /**
   * Add new user
   */
  private function addUser() {
    $emailString = $this->sanitizer->email($this->input->post->email);
    $overwrite = $this->users->find("email={$emailString},roles=newsletter");
    $isReload = false;

    $u = count($overwrite) > 0 ? $overwrite->first() : new User();
    $name = $this->generateUsername();

    $u->of(false);
    $u->name = $name;
    $u->email = $emailString;
    $u->addRole('newsletter');
    $u->status = Page::statusHidden;

    foreach ($this->formfields as $f) {
      if ($f === 'email') continue;
      $val = $this->input->post->$f;
      $u->$f = is_array($val) ? $this->input->post->$f : $this->sanitizer->text($this->input->post->$f);
    }

    try {
      $u->save();
    } catch (WireException $e) {
      if (!$this->noCompare) $isReload = true;
    }

    if (!$isReload) {
      $u->of(true);

      $this->log->save('messages', "User has been successfully subscribed with email `{$u->email}`.");
      $token = sha1($u->email . $u->id . $this->config->userAuthSalt);
      $this->sendValidationMail($token, $u);
    }
  }

  /**
   * Send validation mail
   *
   * @param string $token
   * @param User $u
   * @param string action
   */
  private function sendValidationMail($token, $u, $action = 'subscribe') {
    $link = $this->page->httpUrl . "?a={$action}&t={$token}";
    $wireMail = wireMail();

    if ($this->namefields && substr($u->name, 0, 4) !== 'tmp_') {
      $names = array();
      foreach ($this->namefields as $n) $names[] = $u->$n;
      $name = implode(' ', $names);
    } else {
      $name = $u->name;
    }

    // $wireMail->to("$name<{$u->email}>");
    list($toEmail, $toName) = $this->extractEmailAndName("$name<{$u->email}>");
    $wireMail->to = "$toName <$toEmail>";

    // $wireMail->from($this->mailfrom);
    list($fromEmail, $fromName) = $this->extractEmailAndName($this->mailfrom);
    $wireMail->from = "$fromName <$fromEmail>";

    if ($action === 'subscribe') {
      $message = $this->getMessageContent($name, $link, $u, $this->messageSubscribe);
      $wireMail->subject($this->_('Newsletter Subscription'));
    } else {
      $message = $this->getMessageContent($name, $link, $u, $this->messageUnsubscribe);
      $wireMail->subject($this->_('Newsletter Unsubscription'));
    }

    $wireMail->body(trim($message));
    $numSent = $wireMail->send();

    if (!$numSent) {
      $this->log->save('errors', "Email could not been sent to `{$u->email}`.");
    } else {
      $this->log->save('messages', "Email has been sent successfully to `{$u->email}`.");
    }
  }

  /**
   * extract email from name
   * substitute umlaute
   *
   * @param string $email
   * @return array
   */
  public function extractEmailAndName($email) {
    $name = '';
    if (strpos($email, '<') !== false && strpos($email, '>') !== false) {
      // email has separate from name and email
      if (preg_match('/^(.*?)<([^>]+)>.*$/', $email, $matches)) {
        $name = preg_replace(
          array('/ä/', '/ö/', '/ü/', '/Ä/', '/Ö/', '/Ü/','/ß/'),
          array('ae', 'oe', 'ue', 'Ae', 'Oe', 'Ue', 'ss'),
          $matches[1]
        );
        $email = $matches[2];
      }
    }

    return array($email, $name);
  }

  /**
   * Get message content, substitute variables
   *
   * @param string $name
   * @param string $link
   * @param User $user
   * @param string $text
   * @return string
   */
  private function getMessageContent($name, $link, $user, $text) {
    if (preg_match('/\%name\%/', $text)) $text = str_replace('%name%', $name, $text);
    if (preg_match('/\%link\%/', $text)) $text = str_replace('%link%', $link, $text);
    preg_match_all('/\%(.*?)\%/', $text, $matches);

    if (isset($user)) {
      foreach ($matches[0] as $key => $match) {
        $text = str_replace($match, $user->{$matches[1][$key]}, $text);
      }
    }

    return $text;
  }

  /**
   * Admin Notify
   * Get message content, substitute variables
   *
   * @param string $name
   * @param string $link
   * @param User $user
   * @param string $text
   * @return string
   */
  public function adminNotifyGetContent($user, $text) {
    preg_match_all('/\%(.*?)\%/', $text, $matches);

    foreach ($matches[0] as $key => $match) {
      $text = str_replace($match, $user->{$matches[1][$key]}, $text);
    }

    return $text;
  }

  /**
   * Generate username
   *
   * @return string
   */
  private function generateUsername() {
    // set username
    $name = array();
    if ($this->namefields) {
      foreach ($this->namefields as $n) {
        $name[] = $this->sanitizer->text($this->input->post->$n);
      }

      $newName = $this->sanitizer->username(implode('-', $name));
    } else {
      // no name fields available, generate name from email address
      $email = explode('@', $this->sanitizer->email($this->input->email));
      $newName = $email[0];
    }

    // check whether username already exist
    if (!$this->users->get($newName) instanceof NullPage) {
      foreach (range(1, 100) as $number) {
        $n = $newName . $number;
        if ($this->users->get($n) instanceof NullPage) {
          $newName = $n;
          break;
        }
      }
    }

    return $newName;
  }

  /**
   * Get form
   *
   * @param array $options
   * @return Form
   */
  private function getForm($options) {
    $form = $this->modules->get('InputfieldForm');

    $form->action = isset($options['action']) ? $options['action'] : './';
    $form->method = 'post';
    $form->attr('id+name','subscribe-form');
    if (isset($options['prependMarkup'])) $form->prependMarkup = $options['prependMarkup'];
    if (isset($options['appendMarkup'])) $form->appendMarkup = $options['appendMarkup'];

    // add unsubscribe button
    if ($this->unsubscribe) {
      $val = $this->input->post->unsubscribe ? $this->input->post->unsubscribe : 'subscribe';
      $field = $this->modules->get('InputfieldRadios');
      $field->label = __('You want to');
      $field->addOption('subscribe', __('subscribe'));
      $field->addOption('unsubscribe', __('unsubscribe'));
      $field->attr('name+id','unsubscribe');
      $field->attr('value', $val);
      $field->required = 1;
      $form->append($field);
    }

    // add fields
    if (is_array($this->formfields)) {
      foreach ($this->formfields as $fieldname) {
        $field = $this->fields->get($fieldname);

        if ($field) {
          $inputfield = $field->getInputfield($this->page);
          if ($fieldname === 'email') $inputfield->required = 1;
          $form->append($inputfield);
        }
      }
    }

    // add hidden field roles
    // to enable `requiredIf roles=newsletter` dependencies
    if ($this->unsubscribe) {
      $field = $this->modules->get('InputfieldHidden');
      $field->label = __('Roles');
      $field->attr('name+id','roles');
      $field->attr('value', 'newsletter');
      $field->required = 1;
      $form->append($field);
    }

    // add a submit button to the form
    $submit = $this->modules->get('InputfieldSubmit');
    $submit->name = 'submit';
    $submit->attr('value', __('Send'));
    $submit->attr('class', 'button');
    $form->append($submit);

    return $form;
  }

  /**
   * install routine
   * called only when the module is installed
   *
   * @access public
   */
  public function ___install() {
    // add role `newsletter`, only permission page-view
    $name = 'newsletter';
    if ($this->roles->get("name={$name}") instanceof NullPage) {
      $this->roles->add($name);
      $this->message("Created new role `{$name}`");
    }
  }

  /**
   * called only when the module is uninstalled
   * this should return the site to the same state it was in before the module was installed
   *
   * @access public
   */
  public function ___uninstall() {
    // remove role `newsletter`
    $name = 'newsletter';
    if (!$this->roles->get("name={$name}") instanceof NullPage) {
      $this->roles->delete($name);
      $this->message("Deleted role `{$name}`");
    }
  }

}