Club Drupal

// This is not necessary as the classes are autoloaded via the registry. However

// it saves some possible update headaches until the registry is rebuilt.

require_once dirname(__FILE__) . '/faces.inc';

/**

  /**

   * Overridden.

   * @see DrupalDefaultEntityController::attachLoad()

   */

  protected function attachLoad(&$queried_entities, $revision_id = FALSE) {

    $ids = array_keys($queried_entities);

    $result = db_select('rules_tags')

      ->fields('rules_tags', array('id', 'tag'))

  /**

   * Override to support having events and tags as conditions.

   * @see rules_query_rules_config_load_multiple_alter()

   */

  protected function applyConditions($entities, $conditions = array()) {

   * @param $export

   *   A serialized string in JSON format as produced by the

   *   RulesPlugin::export() method, or the PHP export as usual PHP array.

   */

  public function import($export, &$error_msg = '') {

    $export = is_array($export) ? $export : drupal_json_decode($export);

    foreach ($rules_config->events() as $event) {

      db_insert('rules_trigger')

        ->fields(array(

    }

  }

      foreach ($rules_config->dependencies as $dependency) {

        db_insert('rules_dependencies')

          ->fields(array(

      }

    }

  }

  /**

   * Overridden to support tags and events in $conditions.

   * @see EntityAPIControllerExportable::buildQuery()

   */

  protected function buildQuery($ids, $conditions = array(), $revision_id = FALSE) {

    $query_conditions =& $query->conditions();

    foreach ($query_conditions as &$condition) {

      // One entry in $query_conditions is a string with key '#conjunction'.

      if (is_array($condition)) {

        // Support using 'tags' => array('tag1', 'tag2') as condition.

        if ($condition['field'] == 'base.tags') {

  /**

   * Overridden to also delete tags and events.

   * @see EntityAPIControllerExportable::delete()

   */

  public function delete($ids, DatabaseTransaction $transaction = NULL) {

    return $return;

  }

}

/**

 * The RulesExtendable uses the rules cache to setup the defined extenders

 * and overrides automatically.

 * As soon faces is used the faces information is autoloaded using setUp().

  /**

   * The name of the info definitions associated with info about this class.

   * This would be defined abstract, if possible. Common rules hooks with class

   * info are e.g. plugin_info and data_info.

   */

   */

  protected $itemName;

  public function __construct() {

    $this->setUp();

    if (isset($this->cache[$this->hook][$this->itemName])) {

      $this->itemInfo = &$this->cache[$this->hook][$this->itemName];

    }

    if (!empty($this->itemInfo['faces_cache'])) {

      list($this->facesMethods, $this->facesIncludes, $this->faces) = $this->itemInfo['faces_cache'];

    }

  }

  /**

   */

  public function forceSetUp() {

    if (!isset($this->cache) || (!empty($this->itemInfo['faces_cache']) && !$this->faces)) {

   *   The info about the item as specified in the hook.

   * @param $interface

   *   The interface to check for.

   *   Whether it supports the given interface.

   */

  public static function itemFacesAs(&$itemInfo, $interface) {

    return in_array($interface, class_implements($itemInfo['class'])) || isset($itemInfo['faces_cache'][2][$interface]);

  }

}

/**

  /**

   * The parent element, if any.

   * @var RulesContainerPlugin

   */

  protected $parent = NULL;

  /**

   * Identifies an element inside a configuration.

   */

  protected $availableVariables;

  /**

   * Sets a new parent element.

   */

   * Iterate over all elements nested below the current element.

   *

   * This helper can be used to recursively iterate over all elements of a

   * over the object.

   *

   * @param $mode

  /**

   * Evaluate the element on a given rules evaluation state.

   */

  protected static function compare(RulesPlugin $a, RulesPlugin $b) {

    if ($a->weight == $b->weight) {

  /**

   * Returns info about parameters needed for executing the configured plugin.

   *

   *   Whether optional parameters should be included.

   *

   * @see self::pluginParameterInfo()

  }

  /**

   * E.g. this is used to assert the content type of a node if the condition

   */

  protected function variableInfoAssertions() {

    return array();

  }

  /**

   */

  public function getPluginName() {

    return $this->itemName;

   * Usually settings get processed automatically, however if $this->settings

   * has been altered manually after element construction, it needs to be

   * invoked explicitly with $force set to TRUE.

   */

  public function processSettings($force = FALSE) {

    // Process if not done yet.

  }

  /**

   *

   *

   * @throws RulesIntegrityException

   *   is thrown.

   */

  public function integrityCheck() {

      elseif (!$this->isRoot() && !isset($this->settings[$name]) && empty($info['optional']) && $info['type'] != 'hidden') {

        throw new RulesIntegrityException(t('Missing configuration for parameter %name.', array('%name' => $name)), array($this, 'parameter', $name));

      }

    }

  }

  /**

   * Returns the argument as configured in the element settings for the

   * parameter $name described with $info.

   *

   *   The name of the parameter for which to get the argument.

   * @param $info

   *   Info about the parameter.

   * @param RulesState $state

   *   The current evaluation state.

   *   (optional) The language code used to get the argument value if the

   *   argument value should be translated. By default (NULL) the current

   *   interface language will be used.

    if (!empty($this->settings[$name . ':process'])) {

      // For processing, make sure the data is unwrapped now.

      $return = rules_unwrap_data(array($arg), array($info));

      // separate parameter to process().

      $info['#name'] = $name;

      $info['#langcode'] = $langcode;

  }

  /**

   *

   *   The selector string, e.g. "node:author:mail".

   *

   * @return EntityMetadataWrapper

            }

          }

        }

        catch (EntityMetadataWrapperException $e) {

          return FALSE;

        }

  }

  /**

   */

  public function save($name = NULL, $module = 'rules') {

    if (isset($this->parent)) {

      // default configurations 'module' points to the module providing the

      // default configuration, so the module via which the rules is configured

      // is stored in the "owner" property.

      // module only for the modules providing default configurations.

      $this->module = !isset($this->module) || $module != 'rules' ? $module : $this->module;

      if (!isset($this->owner)) {

  }

  /**

   * If invoked on a rules configuration it is deleted from database. If

   * invoked on a contained rule element, it's removed from the configuration.

   */

   *   A status constant, i.e. one of ENTITY_CUSTOM, ENTITY_IN_CODE,

   *   ENTITY_OVERRIDDEN or ENTITY_FIXED.

   *

   *   TRUE if the configuration has the status, else FALSE.

   *

   * @see entity_has_status()

  }

  /**

   */

  public function destroy() {

    parent::destroy();

  }

  /**

   */

  public function form(&$form, &$form_state, array $options = array()) {

    $this->__call('form', array(&$form, &$form_state, $options));

  /**

   * Exports a rule configuration.

   *

   *   An optional prefix for each line.

   *   Optional. Set to TRUE to format the export using PHP arrays. By default

   *   JSON is used.

   * @return

   *

   * @see rules_import()

   */

  }

  /**

   */

  protected function returnExport($export, $prefix = '', $php = FALSE) {

    $this->ensureNameExists();

  public function resetInternalCache() {

    $this->availableVariables = NULL;

  }

}

/**

 */

abstract class RulesAbstractPlugin extends RulesPlugin {

  protected $infoLoaded = FALSE;

  /**

   *   The plugin implementation's name.

   *   Further information provided about the plugin. Optional.

   * @throws RulesException

   *   If validation of the passed settings fails RulesExceptions are thrown.

   */

    $this->elementName = $name;

    $this->settings = (array) $settings + array('#_needs_processing' => TRUE);

    $this->setUp();

    if (isset($this->cache[$this->itemName . '_info'][$this->elementName])) {

      $this->info = $this->cache[$this->itemName . '_info'][$this->elementName];

      // Remember that the info has been correctly setup.

      $this->infoLoaded = TRUE;

      // Register the defined class, if any.

   */

  abstract protected function executeCallback(array $args, RulesState $state = NULL);

  public function evaluate(RulesState $state) {

    $this->processSettings();

    try {

  }

  public function getPluginName() {

  }

  /**

    self::includeFiles();

    // Get the plugin's own info data.

      $info += array(

        'parameter' => isset($info['arguments']) ? $info['arguments'] : array(),

        'provides' => isset($info['new variables']) ? $info['new variables'] : array(),

      // RulesPluginImplInterface.

      unset($this->faces['RulesPluginHandlerInterface']);

      foreach ($this->faces as $interface) {

        $methods = $file_names = array();

        $includes = self::getIncludeFiles($info['module']);

        // Cache only the plugin implementation specific callbacks.

        $info['faces_cache'][$interface] = array($methods, array_filter($file_names));

      }

      $info['faces_cache'] = rules_filter_array($info['faces_cache'], 0, TRUE);

      // We don't need that any more.

      unset($info['callbacks'], $info['base']);

  }

  /**

   * callbacks may reside in that file.

   */

  protected function loadBasicInclude() {

  }

  /**

   */

  public static function includeFiles() {

    static $included;

        $dirs += $result;

      }

      foreach ($dirs as $module => $directory) {

        }

      }

      $included = TRUE;

  }

  /**

   */

  protected static function getIncludeFiles($module, $all = TRUE) {

    // Automatically add "$module.rules_forms.inc" and "$module.rules.inc".

    $files[] = $module . '.rules_forms';

    if ($all) {

    }

    return $filenames[$function];

  }

}

/**

 */

interface RulesActionInterface {

  /**

   *

   * @throws RulesEvaluationException

   *   Throws an exception if not all necessary arguments have been provided.

   */

  public function execute();

}

/**

 */

interface RulesConditionInterface {

  /**

   *

   * @throws RulesEvaluationException

   *   Throws an exception if not all necessary arguments have been provided.

   * Returns whether the element is configured to negate the result.

   */

  public function isNegated();

}

interface RulesTriggerableInterface {

  /**

  /**

   * Removes an event from the rule configuration.

   *

   *   The name of the (configured) event to remove.

   * @return RulesTriggerableInterface

   *   The object instance itself, to allow chaining.

   */

  /**

   * Gets the event settings associated with the given (configured) event.

   *

   *   The (configured) event's name.

   *

   * @return array|null

  /**

   * Processes settings independent from a form submission.

   *

   */

  public function process();

  public function dependencies();

  /**

   *

   * Validation and processing of the settings should be untied from the form

   * and implemented in validate() and process() wherever it makes sense.

   */

  public function form_alter(&$form, $form_state, $options);

  /**

   *

   * @see RulesPlugin::variableInfoAssertions()

   */

interface RulesActionHandlerInterface extends RulesPluginHandlerInterface {}

/**

 *

 * Provides the interface used for implementing an abstract plugin by using

 * the Faces extension mechanism.

interface RulesPluginImplInterface extends RulesPluginHandlerInterface {

  /**

   */

  public function execute();

}

/**

 * @see RulesContainerPlugin::optimize()

 */

interface RulesOptimizationInterface {

  /**

   * Optimizes a rule configuration in order to speed up evaluation.

   */

  public function optimize();

}

/**

  }

  public function validate() {}

  public function process() {}

  public function info_alter(&$element_info) {}

  public function dependencies() {}

  public function form_alter(&$form, $form_state, $options) {}

  public function assertions() {}

}

/**

abstract class RulesActionHandlerBase extends RulesPluginHandlerBase implements RulesActionHandlerInterface {}

/**

 *

 * If a plugin implementation does not provide a function for a method, the

 * default method of this class will be invoked.

class RulesAbstractPluginDefaults extends RulesPluginHandlerBase implements RulesPluginImplInterface {

  public function execute() {

  }

}

/**

 */

class RulesRecursiveElementIterator extends ArrayIterator implements RecursiveIterator {

}

/**

  }

  /**

   *

   * @return RulesRecursiveElementIterator

   */

  }

  /**

   * Returns info about variables available in the evaluation state for any

   * children elements or if given for a special child element.

   *

  }

  /**

   * Condition containers just return a boolean while action containers return

   * the configured provided variables as an array of variables.

   */

  }

  /**

   */

  public function delete($keep_children = TRUE) {

    if (isset($this->parent) && $keep_children) {

  /**

   * Sorts all child elements by their weight.

   *

   *   If enabled a deep sort is performed, thus the whole element tree below

   *   this element is sorted.

   */

  public function sortChildren($deep = FALSE) {

    // Make sure the array order is kept in case two children have the same

    foreach (array_values($this->children) as $i => $child) {

      $child->weight += $i / 1000;

    }

  }

  /**

   */

  protected function exportFlat() {

    // By default we always use flat style for plugins without any parameters

      $element->optimize();

    }

  }

}

/**

  }

  /**

   *

   */

  public function action($name, $settings = array()) {

    $action = (is_object($name) && $name instanceof RulesActionInterface) ? $name : rules_action($name, $settings);

  }

  /**

   * Returns an array of variable names, which are provided by passing through

   * the provided variables of the children.

   */

      $this->info['provides'] = $export['PROVIDES VARIABLES'];

    }

  }

}

/**

  protected $negate = FALSE;

  /**

   *

   */

  public function condition($name, $settings = array()) {

    $condition = (is_object($name) && $name instanceof RulesConditionInterface) ? $name : rules_condition($name, $settings);

    }

    return $vars;

  }

}

/**

   * @return RulesLog

   *   Returns the rules logger instance.

   */

    if (!isset(self::$logger)) {

      $class = __CLASS__;

      self::$logger = new $class(variable_get('rules_log_level', self::INFO));

  }

  protected $log = array();

  /**

   * This is a singleton.

  /**

   * Checks the log and throws an exception if there were any problems.

   */

    foreach ($this->log as $entry) {

      if ($entry[2] >= $logLevel) {

        throw new Exception($this->render());

  }

  /**

   *

   *   Whether the an error has been logged.

   */

  public function hasErrors($logLevel = self::WARN) {

        // messages here.

        $vars['head'] = t($this->log[$line][0], $this->log[$line][1]);

        if (isset($this->log[$line][5])) {

        }

        $vars['log'] = $this->renderHelper($line);

        $output[] = theme('rules_debug_element', $vars);

      }

      else {

        if ($this->log[$line][2] >= RulesLog::WARN) {

          $level = $this->log[$line][2] == RulesLog::WARN ? 'warn' : 'error';

        }

        if (isset($this->log[$line][5]) && !isset($this->log[$line][4])) {

        }

        $output[] = $msg;

  public function clear() {

    $this->log = array();

  }

}

/**

 *

 */

abstract class RulesException extends Exception {}

 */

class RulesEvaluationException extends RulesException {

  /**

   *   The exception message containing placeholder as t().

   *   Replacement arguments such as for t().

   * @param $element

   *   The element of a configuration causing the exception or an array

   *   consisting of the element and keys specifying a setting value causing

   *   the exception.

   *   The RulesLog severity. Defaults to RulesLog::WARN.

   */

    $this->element = is_array($element) ? array_shift($element) : $element;

    $this->keys = is_array($element) ? $element : array();

    $this->msg = $msg;

        rules_clear_cache();

      }

    }

    $this->message = t($this->msg, $this->args);

  }

}

/**

 *

 * @see RulesPlugin::integrityCheck()

 */

class RulesIntegrityException extends RulesException {

  /**

   * @param string $msg

   *   The exception message, already translated.

   * @param $element

   *   The element of a configuration causing the exception or an array

   *   consisting of the element and keys specifying a parameter or provided

   *   variable causing the exception, e.g.

   */

    $this->element = is_array($element) ? array_shift($element) : $element;

    $this->keys = is_array($element) ? $element : array();

    parent::__construct($msg);

  }

}

/**

/**

 * Determines the plugin to be used for importing a child element.

 *

 *   The key to look for, e.g. 'OR' or 'DO'.

 *   The default to return if no special plugin can be found.

 */

function _rules_import_get_plugin($key, $default = 'action') {

      }

    }

  }

  if (strpos($key, 'NOT ') === 0) {

    $key = substr($key, 4);

  }