.gitignore

+site/
+.vscode

CRM/Civirules/Action.php

@@ -8,15 +8,16 @@
 
 abstract class CRM_Civirules_Action {
 
-  protected $ruleAction = array();
+  protected array $ruleAction = [];
 
-  protected $action = array();
+  protected array $action = [];
 
   /**
    * Process the action
    *
    * @param CRM_Civirules_TriggerData_TriggerData $triggerData
-   * @access public
+   *
+   * @throws Exception
    */
   abstract public function processAction(CRM_Civirules_TriggerData_TriggerData $triggerData);
 
@@ -32,20 +33,21 @@ abstract class CRM_Civirules_Action {
    * If you don't have a delay you should return false
    *
    * @param DateTime $date the current scheduled date/time
+   * @param CRM_Civirules_TriggerData_TriggerData $triggerData
+   *
    * @return bool|DateTime
    */
-  public function delayTo(DateTime $date) {
-    return false;
+  public function delayTo(DateTime $date, CRM_Civirules_TriggerData_TriggerData $triggerData) {
+    return FALSE;
   }
 
   /**
    * Method to set RuleActionData
    *
    * @param $ruleAction
-   * @access public
    */
   public function setRuleActionData($ruleAction) {
-    $this->ruleAction = array();
+    $this->ruleAction = [];
     if (is_array($ruleAction)) {
       $this->ruleAction = $ruleAction;
     }
@@ -55,20 +57,42 @@ abstract class CRM_Civirules_Action {
    * Method to set actionData
    *
    * @param $action
-   * @access public
    */
   public function setActionData($action) {
     $this->action = $action;
   }
 
+
+  /**
+   * Returns condition data as an array and ready for export.
+   * E.g. replace ids for names.
+   *
+   * @return array
+   */
+  public function exportActionParameters() {
+    return $this->getActionParameters();
+  }
+
+  /**
+   * Returns condition data as an array and ready for import.
+   * E.g. replace name for ids.
+   *
+   * @return string
+   */
+  public function importActionParameters($action_params=null) {
+    if (!empty($action_params)) {
+      return serialize($action_params);
+    }
+    return '';
+  }
+
   /**
    * Convert parameters to an array of parameters
    *
    * @return array
-   * @access protected
    */
   protected function getActionParameters() {
-    $params = array();
+    $params = [];
     if (!empty($this->ruleAction['action_params'])) {
       $params = unserialize($this->ruleAction['action_params']);
     }
@@ -82,42 +106,65 @@ abstract class CRM_Civirules_Action {
    *
    * @param int $ruleActionId
    * @return bool|string
-   * $access public
    */
   abstract public function getExtraDataInputUrl($ruleActionId);
 
+  /**
+   * @param string $url
+   * @param int $ruleActionID
+   *
+   * @return string
+   */
+  public function getFormattedExtraDataInputUrl(string $url, int $ruleActionID): string {
+    return CRM_Utils_System::url($url, 'rule_action_id=' . $ruleActionID, FALSE, NULL, FALSE, FALSE, TRUE);
+  }
+
   /**
    * Returns a user friendly text explaining the condition params
    * e.g. 'Older than 65'
    *
    * @return string
-   * @access public
    */
   public function userFriendlyConditionParams() {
     return '';
   }
 
+  /**
+   * This function validates whether this action works with the selected trigger.
+   *
+   * This function could be overridden in child classes to provide additional validation
+   * whether an action is possible in the current setup.
+   *
+   * @param CRM_Civirules_Trigger $trigger
+   * @param CRM_Civirules_BAO_Rule $rule
+   *
+   * @return bool
+   */
+  public function doesWorkWithTrigger(CRM_Civirules_Trigger $trigger, CRM_Civirules_BAO_Rule $rule) {
+    return TRUE;
+  }
+
   /**
    * Logs a message to the logger
    *
    * @param $message
-   * @param \CRM_Civirules_EventData_EventData|NULL $eventData
+   * @param \CRM_Civirules_TriggerData_TriggerData|NULL $triggerData
    * @param string $level Should be one of \Psr\Log\LogLevel
    */
-  protected function logAction($message, CRM_Civirules_EventData_EventData $eventData=null, $level=\Psr\Log\LogLevel::INFO) {
-    $context = array();
+  protected function logAction($message, CRM_Civirules_TriggerData_TriggerData $triggerData=null, $level=\Psr\Log\LogLevel::INFO) {
+    $context = [];
     $context['message'] = $message;
     $context['rule_id'] = $this->ruleAction['rule_id'];
     $rule = new CRM_Civirules_BAO_Rule();
     $rule->id = $this->ruleAction['rule_id'];
     $context['rule_title'] = '';
-    if ($rule->find(true)) {
+    if ($rule->find(TRUE)) {
       $context['rule_title'] = $rule->label;
     }
     $context['rule_action_id'] = $this->ruleAction['id'];
     $context['action_label'] = CRM_Civirules_BAO_Action::getActionLabelWithId($this->ruleAction['action_id']);
     $context['action_parameters'] = $this->userFriendlyConditionParams();
-    $context['contact_id'] = $eventData ? $eventData->getContactId() : - 1;
+    $context['contact_id'] = $triggerData ? $triggerData->getContactId() : - 1;
     $msg = "{action_label} (ID: {rule_action_id})\r\n\r\n{message}\r\n\r\nRule: '{rule_title}' with id {rule_id}";
     if ($context['contact_id'] > 0) {
       $msg .= "\r\nFor contact: {contact_id}";
@@ -125,5 +172,52 @@ abstract class CRM_Civirules_Action {
     CRM_Civirules_Utils_LoggerFactory::log($msg, $context, $level);
   }
 
+  /**
+   * @return int
+   */
+  public function getRuleId() {
+    return $this->ruleAction['rule_id'];
+  }
+
+  /**
+   * Get various types of help text for the action:
+   *   - actionDescription: When choosing from a list of actions, explains what the action does.
+   *   - actionDescriptionWithParams: When a action has been configured for a rule provides a
+   *       user friendly description of the action and params (see $this->userFriendlyConditionParams())
+   *   - actionParamsHelp (default): If the action has configurable params, show this help text when configuring
+   * @param string $context
+   *
+   * @return string
+   */
+  public function getHelpText(string $context): string {
+    // Child classes should override this function
+
+    switch ($context) {
+      case 'actionDescriptionWithParams':
+        return $this->userFriendlyConditionParams();
+
+      case 'actionDescription':
+      case 'actionParamsHelp':
+      default:
+        // Historically getHelpText() was on the form class.
+        // But we have no way to get the form class - only the path via getExtraDataInputUrl()
+        // The Form *does* have access to the action class via $this->actionClass so if getHelpText()
+        //   is on the actionClass we can just do $this->actionClass->getHelpText().
+
+        // getHelpText() doesn't exist on action class.
+        // Try to get Form class for action and see if getHelpText() exists there
+        $classBits = explode('_', get_class($this));
+
+        $formClass = $classBits[0] . '_' . $classBits[1] . '_Form';
+        for ($i = 2; $i < count($classBits); $i++) {
+          $formClass .= '_' . $classBits[$i];
+        }
+        if (class_exists($formClass) && method_exists($formClass, 'getHelpText')) {
+          $helpText = (new $formClass())->getHelpText();
+        }
+    }
+
+    return $helpText ?? '';
+  }
 
-}
\ No newline at end of file
+}

CRM/Civirules/ActionEngine/AbstractActionEngine.php

+<?php
+
+abstract class CRM_Civirules_ActionEngine_AbstractActionEngine {
+
+  /**
+   * @var array
+   */
+  protected array $ruleAction;
+
+  /**
+   * @var CRM_Civirules_TriggerData_TriggerData
+   */
+  protected CRM_Civirules_TriggerData_TriggerData $triggerData;
+
+  /**
+   * Function to execute the rule action.
+   *
+   * @return void
+   */
+  abstract public function execute();
+
+  /**
+   * Function to calculate the delay of the action.
+   *
+   * @param $delayedTo
+   * @return false|DateTime
+   */
+  abstract public function delayTo($delayedTo);
+
+  /**
+   * @param array $ruleAction
+   *   Data from the ruleAction object.
+   * @param CRM_Civirules_TriggerData_TriggerData $triggerData
+   *   Data from the trigger.
+   */
+  public function __construct(array $ruleAction, CRM_Civirules_TriggerData_TriggerData $triggerData) {
+    $this->ruleAction = $ruleAction;
+    $this->triggerData = $triggerData;
+  }
+
+  /**
+   * @return array
+   */
+  public function getRuleAction(): array {
+    return $this->ruleAction;
+  }
+
+  /**
+   * @return CRM_Civirules_TriggerData_TriggerData
+   */
+  public function getTriggerData(): CRM_Civirules_TriggerData_TriggerData {
+    return $this->triggerData;
+  }
+
+  /**
+   * Sets the trigger data
+   *
+   * @param CRM_Civirules_TriggerData_TriggerData $triggerData
+   *
+   * @return CRM_Civirules_ActionEngine_AbstractActionEngine
+   */
+  public function setTriggerData(CRM_Civirules_TriggerData_TriggerData $triggerData): CRM_Civirules_ActionEngine_AbstractActionEngine {
+    $this->triggerData = $triggerData;
+    return $this;
+  }
+
+  /**
+   * Returns whether we should ignore rechecking of the conditions when an action
+   * is executed with a delay
+   *
+   * @return bool
+   */
+  public function ignoreConditionsOnDelayedProcessing(): bool {
+    return (bool) $this->ruleAction['ignore_condition_with_delay'] ?? FALSE;
+  }
+
+}

CRM/Civirules/ActionEngine/Factory.php

+<?php
+
+class CRM_Civirules_ActionEngine_Factory {
+  
+  private static $instances = array();
+  
+  /**
+   * Returns the engine for executing actions.
+   * 
+   * @param array $ruleAction
+   *   Data from the ruleAction object.
+   * @param CRM_Civirules_TriggerData_TriggerData $triggerData
+   *   Data from the trigger.
+   */
+  public static function getEngine($ruleAction, CRM_Civirules_TriggerData_TriggerData $triggerData) {
+    $id = $ruleAction['id'];
+    if (!isset(self::$instances[$id])) {
+      // This is the place where could add other engine to the system.
+      self::$instances[$id] = new CRM_Civirules_ActionEngine_RuleActionEngine($ruleAction, $triggerData);
+    }
+    $engine = clone self::$instances[$id];
+    $engine->setTriggerData($triggerData);
+    return $engine;
+  }
+  
+}

CRM/Civirules/ActionEngine/RuleActionEngine.php

+<?php
+
+/**
+ * Class to execute actions provided by civirules
+ */
+
+class CRM_Civirules_ActionEngine_RuleActionEngine extends CRM_Civirules_ActionEngine_AbstractActionEngine {
+
+  /**
+   * @var CRM_Civirules_Action
+   */
+  protected $actionClass;
+
+  public function __construct($ruleAction, CRM_Civirules_TriggerData_TriggerData $triggerData) {
+    parent::__construct($ruleAction, $triggerData);
+    $this->actionClass = CRM_Civirules_BAO_Action::getActionObjectById($ruleAction['action_id'], true);
+    if (!$this->ruleAction) {
+      throw new Exception('Could not instanciate action for ruleAction with action_id: '.$ruleAction['action_id']);
+    }
+    $this->actionClass->setRuleActionData($ruleAction);
+  }
+
+  /**
+   * Function to execute the rule action.
+   *
+   * @throws \Exception
+   */
+  public function execute() {
+    $this->actionClass->processAction($this->triggerData);
+  }
+
+  /**
+   * Function to calculate the delay of the action.
+   *
+   * @return void
+   */
+  public function delayTo($delayedTo) {
+    return $this->actionClass->delayTo($delayedTo, $this->triggerData);
+  }
+
+}

CRM/Civirules/BAO/Action.php

 <?php
+
 /**
- * BAO Action for CiviRule Action
- * 
- * @author Erik Hommel (CiviCooP) <erik.hommel@civicoop.org>
- * @license http://www.gnu.org/licenses/agpl-3.0.html
+ * DAO class was renamed for API4/searchkit compatibility
  */
-class CRM_Civirules_BAO_Action extends CRM_Civirules_DAO_Action {
-
-  /**
-   * Function to get values
-   * 
-   * @return array $result found rows with data
-   * @access public
-   * @static
-   */
-  public static function getValues($params) {
-    $result = array();
-    $action = new CRM_Civirules_BAO_Action();
-    if (!empty($params)) {
-      $fields = self::fields();
-      foreach ($params as $key => $value) {
-        if (isset($fields[$key])) {
-          $action->$key = $value;
-        }
-      }
-    }
-    $action->find();
-    while ($action->fetch()) {
-      $row = array();
-      self::storeValues($action, $row);
-      $result[$row['id']] = $row;
-    }
-    return $result;
-  }
-
-  /**
-   * Function to add or update action
-   * 
-   * @param array $params 
-   * @return array $result
-   * @access public
-   * @throws Exception when params is empty
-   * @static
-   */
-  public static function add($params) {
-    $result = array();
-    if (empty($params)) {
-      throw new Exception('Params can not be empty when adding or updating a civirule action');
-    }
-    $action = new CRM_Civirules_BAO_Action();
-    $fields = self::fields();
-    foreach ($params as $key => $value) {
-      if (isset($fields[$key])) {
-        $action->$key = $value;
-      }
-    }
-    $action->save();
-    self::storeValues($action, $result);
-    return $result;
-  }
-
-  /**
-   * Function to delete an action with id
-   * 
-   * @param int $actionId
-   * @throws Exception when actionId is empty
-   * @access public
-   * @static
-   */
-  public static function deleteWithId($actionId) {
-    if (empty($actionId)) {
-      throw new Exception('action id can not be empty when attempting to delete a civirule action');
-    }
-
-    if (!CRM_Core_DAO::checkTableExists(self::getTableName())) {
-      return;
-    }
-
-    //delete rows from rule_action to prevent a foreign key constraint error
-    CRM_Core_DAO::executeQuery("DELETE FROM `civirule_rule_action` where `action_id` = %1", array(1 => array($actionId, 'Integer')));
-
-    $action = new CRM_Civirules_BAO_Action();
-    $action->id = $actionId;
-    $action->delete();
-    return;
-  }
-
-  /**
-   * Function to disable an action
-   * 
-   * @param int $actionId
-   * @throws Exception when actionId is empty
-   * @access public
-   * @static
-   */
-  public static function disable($actionId) {
-    if (empty($actionId)) {
-      throw new Exception('action id can not be empty when attempting to disable a civirule action');
-    }
-    $action = new CRM_Civirules_BAO_Action();
-    $action->id = $actionId;
-    $action->find(true);
-    self::add(array('id' => $action->id, 'is_active' => 0));
-  }
-
-  /**
-   * Function to enable an action
-   * 
-   * @param int $actionId
-   * @throws Exception when actionId is empty
-   * @access public
-   * @static
-   */
-  public static function enable($actionId) {
-    if (empty($actionId)) {
-      throw new Exception('action id can not be empty when attempting to enable a civirule action');
-    }
-    $action = new CRM_Civirules_BAO_Action();
-    $action->id = $actionId;
-    $action->find(true);
-    self::add(array('id' => $action->id, 'is_active' => 1));
-  }
-  /**
-   * Function to retrieve the label of an action with actionId
-   *
-   * @param int $actionId
-   * @return string $action->label
-   * @access public
-   * @static
-   */
-  public static function getActionLabelWithId($actionId) {
-    if (empty($actionId)) {
-      return '';
-    }
-    $action = new CRM_Civirules_BAO_Action();
-    $action->id = $actionId;
-    $action->find(true);
-    return $action->label;
-  }
-
-  /**
-   * Get the action class for this condition
-   *
-   * @param $actionId
-   * @param bool $abort if true this function will throw an exception if class could not be instantiated
-   * @return CRM_Civirules_Action
-   * @throws Exception if abort is set to true and class does not exist or is not valid
-   */
-  public static function getActionObjectById($actionId, $abort=true) {
-    $action = new CRM_Civirules_BAO_Action();
-    $action->id = $actionId;
-    if (!$action->find(true)) {
-      if ($abort) {
-        throw new Exception('CiviRule could not find action');
-      }
-      return false;
-    }
-
-    $className = $action->class_name;
-    if (!class_exists($className)) {
-      if ($abort) {
-
-        throw new Exception('CiviRule action class "' . $className . '" does not exist');
-      }
-      return false;
-    }
-
-    $object = new $className();
-    if (!$object instanceof CRM_Civirules_Action) {
-      if ($abort) {
-        throw new Exception('CiviRule action class "' . $className . '" is not a subclass of CRM_Civirules_Action');
-      }
-      return false;
-    }
-
-    $actionData = array();
-    CRM_Core_DAO::storeValues($action, $actionData);
-    $object->setActionData($actionData);
-
-    return $object;
-  }
-
-}
+class_alias('CRM_Civirules_BAO_CiviRulesAction', 'CRM_Civirules_BAO_Action');

CRM/Civirules/BAO/CiviRulesAction.php

+<?php
+/**
+ * BAO Action for CiviRule Action
+ *
+ * @author Erik Hommel (CiviCooP) <erik.hommel@civicoop.org>
+ * @license http://www.gnu.org/licenses/agpl-3.0.html
+ */
+class CRM_Civirules_BAO_CiviRulesAction extends CRM_Civirules_DAO_CiviRulesAction {
+
+  /**
+   * Function to get values
+   *
+   * @return array $result found rows with data
+   * @access public
+   * @static
+   */
+  public static function getValues($params) {
+    $result = array();
+    $action = new CRM_Civirules_BAO_Action();
+    if (!empty($params)) {
+      $fields = self::fields();
+      foreach ($params as $key => $value) {
+        if (isset($fields[$key])) {
+          $action->$key = $value;
+        }
+      }
+    }
+    $action->find();
+    while ($action->fetch()) {
+      $row = array();
+      self::storeValues($action, $row);
+      $result[$row['id']] = $row;
+    }
+    return $result;
+  }
+
+  /**
+   * Function to delete an action with id
+   *
+   * @param int $actionId
+   * @throws Exception when actionId is empty
+   * @access public
+   * @static
+   */
+  public static function deleteWithId($actionId) {
+    if (empty($actionId)) {
+      throw new Exception('action id can not be empty when attempting to delete a civirule action');
+    }
+
+    if (!CRM_Core_DAO::checkTableExists(self::getTableName())) {
+      return;
+    }
+
+    //delete rows from rule_action to prevent a foreign key constraint error
+    CRM_Core_DAO::executeQuery("DELETE FROM `civirule_rule_action` where `action_id` = %1", array(1 => array($actionId, 'Integer')));
+
+    $action = new CRM_Civirules_BAO_Action();
+    $action->id = $actionId;
+    $action->delete();
+    return;
+  }
+
+  /**
+   * Function to retrieve the label of an action with actionId
+   *
+   * @param int $actionId
+   * @return string $action->label
+   * @access public
+   * @static
+   */
+  public static function getActionLabelWithId($actionId) {
+    if (empty($actionId)) {
+      return '';
+    }
+    $action = new CRM_Civirules_BAO_Action();
+    $action->id = $actionId;
+    $action->find(true);
+    return $action->label;
+  }
+
+  /**
+   * Get the action class for this condition
+   *
+   * @param $actionId
+   * @param bool $abort if true this function will throw an exception if class could not be instantiated
+   * @return CRM_Civirules_Action
+   * @throws Exception if abort is set to true and class does not exist or is not valid
+   */
+  public static function getActionObjectById($actionId, $abort=true) {
+    $action = new CRM_Civirules_BAO_Action();
+    $action->id = $actionId;
+    if (!$action->find(true)) {
+      if ($abort) {
+        throw new Exception('CiviRule could not find action');
+      }
+      return false;
+    }
+
+    $className = $action->class_name;
+    if (!class_exists($className)) {
+      if ($abort) {
+
+        throw new Exception('CiviRule action class "' . $className . '" does not exist');
+      }
+      return false;
+    }
+
+    $object = new $className();
+    if (!$object instanceof CRM_Civirules_Action) {
+      if ($abort) {
+        throw new Exception('CiviRule action class "' . $className . '" is not a subclass of CRM_Civirules_Action');
+      }
+      return false;
+    }
+
+    $actionData = array();
+    CRM_Core_DAO::storeValues($action, $actionData);
+    $object->setActionData($actionData);
+
+    return $object;
+  }
+
+}

CRM/Civirules/BAO/CiviRulesCondition.php

+<?php
+/**
+ * BAO Condition for CiviRule Condition
+ *
+ * @author Erik Hommel (CiviCooP) <erik.hommel@civicoop.org>
+ * @license http://www.gnu.org/licenses/agpl-3.0.html
+ */
+class CRM_Civirules_BAO_CiviRulesCondition extends CRM_Civirules_DAO_Condition {
+
+  /**
+   * Cache for CiviRule Condition ID - class name mapping
+   *
+   * @var array
+   */
+  protected static $conditionClassNames = [];
+
+  /**
+   * Function to get values
+   *
+   * @return array $result found rows with data
+   * @access public
+   * @static
+   */
+  public static function getValues($params) {
+    $result = [];
+    $condition = new CRM_Civirules_BAO_Condition();
+    if (!empty($params)) {
+      $fields = self::fields();
+      foreach ($params as $key => $value) {
+        if (isset($fields[$key])) {
+          $condition->$key = $value;
+        }
+      }
+    }
+    $condition->find();
+    while ($condition->fetch()) {
+      $row = [];
+      self::storeValues($condition, $row);
+      $result[$row['id']] = $row;
+    }
+    return $result;
+  }
+
+  /**
+   * Deprecated add or update condition
+   *
+   * @param array $params
+   *
+   * @return \CRM_Civirules_DAO_CiviRulesCondition
+   * @throws Exception when params is empty
+   *
+   * @deprecated
+   */
+  public static function add($params) {
+    CRM_Core_Error::deprecatedFunctionWarning('writeRecord');
+    return self::writeRecord($params);
+  }
+
+  /**
+   * Function to delete a condition with id
+   *
+   * @param int $conditionId
+   * @throws Exception when conditionId is empty
+   * @access public
+   * @static
+   */
+  public static function deleteWithId($conditionId) {
+    if (empty($conditionId)) {
+      throw new Exception('condition id can not be empty when attempting to delete a civirule condition');
+    }
+
+    if (!CRM_Core_DAO::checkTableExists(self::getTableName())) {
+      return;
+    }
+
+    //delete rows from rule_condition to prevent a foreign key constraint error
+    CRM_Core_DAO::executeQuery("DELETE FROM `civirule_rule_condition` where `condition_id` = %1", [1 => [$conditionId, 'Integer']]);
+
+    $condition = new CRM_Civirules_BAO_Condition();
+    $condition->id = $conditionId;
+    $condition->delete();
+    return;
+  }
+
+  /**
+   * Function to disable a condition
+   *
+   * @param int $conditionId
+   * @throws Exception when conditionId is empty
+   * @access public
+   * @static
+   */
+  public static function disable($conditionId) {
+    if (empty($conditionId)) {
+      throw new Exception('condition id can not be empty when attempting to disable a civirule condition');
+    }
+    $condition = new CRM_Civirules_BAO_Condition();
+    $condition->id = $conditionId;
+    $condition->find(true);
+    self::writeRecord(['id' => $condition->id, 'is_active' => 0]);
+  }
+
+  /**
+   * Function to enable a condition
+   *
+   * @param int $conditionId
+   * @throws Exception when conditionId is empty
+   * @access public
+   * @static
+   */
+  public static function enable($conditionId) {
+    if (empty($conditionId)) {
+      throw new Exception('condition id can not be empty when attempting to enable a civirule condition');
+    }
+    $condition = new CRM_Civirules_BAO_Condition();
+    $condition->id = $conditionId;
+    $condition->find(true);
+    self::writeRecord(['id' => $condition->id, 'is_active' => 1]);
+  }
+
+  /**
+   * Function to retrieve the label of a condition with conditionId
+   *
+   * @param int $conditionId
+   * @return string $condition->label
+   * @access public
+   * @static
+   */
+  public static function getConditionLabelWithId($conditionId) {
+    if (empty($conditionId)) {
+      return '';
+    }
+    $condition = new CRM_Civirules_BAO_Condition();
+    $condition->id = $conditionId;
+    $condition->find(true);
+    return $condition->label;
+  }
+
+  /**
+   * Get the condition class for this condition
+   *
+   * @param int $conditionID
+   * @param bool $abort if true this function will throw an exception if class could not be instanciated
+   *
+   * @return CRM_Civirules_Condition|FALSE
+   * @throws Exception if abort is set to true and class does not exist or is not valid
+   */
+  public static function getConditionObjectById(int $conditionID, bool $abort=TRUE) {
+    if (isset(self::$conditionClassNames[$conditionID])) {
+      $className = self::$conditionClassNames[$conditionID];
+    } else {
+      $condition = new CRM_Civirules_BAO_Condition();
+      $condition->id = $conditionID;
+      if (!$condition->find(TRUE)) {
+        if ($abort) {
+          throw new Exception('CiviRule could not find condition');
+        }
+        return FALSE;
+      }
+
+      $className = $condition->class_name;
+      if (!class_exists($className)) {
+        if ($abort) {
+          throw new Exception('CiviRule condition class "' . $className . '" does not exist');
+        }
+        return FALSE;
+      }
+      self::$conditionClassNames[$conditionID] = $className;
+    }
+
+    $object = new $className();
+    if (!$object instanceof CRM_Civirules_Condition) {
+      if ($abort) {
+        throw new Exception('CiviRule condition class "' . $className . '" is not a subclass of CRM_Civirules_Condition');
+      }
+      return FALSE;
+    }
+    return $object;
+  }
+}

CRM/Civirules/BAO/CiviRulesRule.php

+<?php
+/**
+ * BAO Rule for CiviRule Rule
+ *
+ * @author Erik Hommel (CiviCooP) <erik.hommel@civicoop.org>
+ * @license http://www.gnu.org/licenses/agpl-3.0.html
+ */
+class CRM_Civirules_BAO_CiviRulesRule extends CRM_Civirules_DAO_Rule {
+
+  /**
+   * Function to get values
+   *
+   * @return array $result found rows with data
+   */
+  public static function getValues($params) {
+    $result = [];
+    $rule = new CRM_Civirules_BAO_Rule();
+    if (!empty($params)) {
+      $fields = self::fields();
+      foreach ($params as $key => $value) {
+        if (isset($fields[$key])) {
+          $rule->$key = $value;
+        }
+      }
+    }
+    $rule->find();
+    while ($rule->fetch()) {
+      $row = [];
+      self::storeValues($rule, $row);
+      // add trigger label
+      if (isset($rule->trigger_id) && !empty($rule->trigger_id)) {
+        $row['trigger'] = CRM_Civirules_BAO_Trigger::getTriggerLabelWithId($rule->trigger_id);
+      }
+      $result[$row['id']] = $row;
+    }
+    return $result;
+  }
+
+  /**
+   * Deprecated add function
+   *
+   * @param array $params
+   *
+   * @return \CRM_Civirules_DAO_CiviRulesRule
+   * @throws Exception when params is empty
+   *
+   * @deprecated
+   */
+  public static function add($params) {
+    CRM_Core_Error::deprecatedFunctionWarning('writeRecord');
+    return self::writeRecord($params);
+  }
+
+  /**
+   * Function to delete a rule with id
+   *
+   * @param int $ruleId
+   *
+   * @throws Exception when ruleId is empty
+   */
+  public static function deleteWithId($ruleId) {
+    if (empty($ruleId)) {
+      throw new Exception(ts('rule id can not be empty when attempting to delete a civirule rule'));
+    }
+    CRM_Utils_Hook::pre('delete', 'CiviRuleRule', $ruleId, CRM_Core_DAO::$_nullArray);
+    // also delete all references to the rule from logging if present
+    if (self::checkTableExists('civirule_rule_log')) {
+      $query = 'DELETE FROM civirule_rule_log WHERE rule_id = %1';
+      CRM_Core_DAO::executeQuery($query, [1 => [$ruleId, 'Integer']]);
+    }
+    $rule = new CRM_Civirules_BAO_Rule();
+    $rule->id = $ruleId;
+    $rule->delete();
+    CRM_Utils_Hook::post('delete', 'CiviRuleRule', $ruleId, CRM_Core_DAO::$_nullArray);
+  }
+
+  /**
+   * Function to retrieve the label of a rule with ruleId
+   *
+   * @param int $ruleId
+   *
+   * @return string $rule->label
+   */
+  public static function getRuleLabelWithId($ruleId) {
+    if (empty($ruleId)) {
+      return '';
+    }
+    $rule = new CRM_Civirules_BAO_Rule();
+    $rule->id = $ruleId;
+    $rule->find(true);
+    return $rule->label;
+  }
+
+  /**
+   * Function to check if a label already exists in the rule table
+   *
+   * @param $labelToBeChecked
+   * @return bool
+   */
+  public static function labelExists($labelToBeChecked) {
+    $rule = new CRM_Civirules_BAO_Rule();
+    $rule->label = $labelToBeChecked;
+    if ($rule->count() > 0) {
+      return TRUE;
+    }
+    return FALSE;
+  }
+
+  /**
+   * Returns an array with rules which should be triggered immediately
+   *
+   * @param string $objectName ObjectName in the Post hook
+   * @param string $op op in the Post hook
+   *
+   * @return array
+   */
+  public static function findRulesByObjectNameAndOp($objectName, $op) {
+    if (empty(\Civi::$statics[__CLASS__]['findRulesByObjectNameAndOp'][$objectName][$op])) {
+      $triggers = [];
+      $sql = "SELECT r.id AS rule_id, t.id AS trigger_id, t.class_name, r.trigger_params
+            FROM `civirule_rule` r
+            INNER JOIN `civirule_trigger` t ON r.trigger_id = t.id AND t.is_active = 1";
+      // If $objectName is a Contact Type, also search for "Contact".
+      if ($objectName == 'Individual' || $objectName == 'Organization' || $objectName == 'Household') {
+        $sqlWhere = " WHERE r.`is_active` = 1 AND t.cron = 0 AND (t.object_name = %1 OR t.object_name = 'Contact') AND t.op LIKE %2";
+      } else {
+        $sqlWhere = " WHERE r.`is_active` = 1 AND t.cron = 0 AND t.object_name = %1 AND t.op LIKE %2";
+      }
+      $sql .= $sqlWhere;
+      $params[1] = [$objectName, 'String'];
+      $params[2] = ["%$op%", 'String'];
+
+      $dao = CRM_Core_DAO::executeQuery($sql, $params);
+      while ($dao->fetch()) {
+        $triggerObject = CRM_Civirules_BAO_Trigger::getPostTriggerObjectByClassName($dao->class_name, FALSE);
+        if ($triggerObject !== FALSE) {
+          $triggerObject->setTriggerId($dao->trigger_id);
+          $triggerObject->setRuleId($dao->rule_id);
+          $triggerObject->setTriggerParams($dao->trigger_params ?? '');
+          $triggers[] = $triggerObject;
+        }
+      }
+      \Civi::$statics[__CLASS__]['findRulesByObjectNameAndOp'][$objectName][$op] = $triggers;
+    }
+    return \Civi::$statics[__CLASS__]['findRulesByObjectNameAndOp'][$objectName][$op];
+  }
+
+  /**
+   * Returns an array with cron triggers which should be triggered in the cron
+   *
+   * @return array
+   */
+  public static function findRulesForCron() {
+    $cronTriggers = [];
+    $sql = "SELECT r.id AS rule_id, t.id AS trigger_id, t.class_name, r.trigger_params
+            FROM `civirule_rule` r
+            INNER JOIN `civirule_trigger` t ON r.trigger_id = t.id AND t.is_active = 1
+            WHERE r.`is_active` = 1 AND t.cron = 1
+            ORDER BY rule_id";
+
+    $dao = CRM_Core_DAO::executeQuery($sql);
+    while ($dao->fetch()) {
+      $cronTriggerObject = CRM_Civirules_BAO_Trigger::getTriggerObjectByClassName($dao->class_name, FALSE);
+      if ($cronTriggerObject !== FALSE) {
+        $cronTriggerObject->setTriggerId($dao->trigger_id);
+        $cronTriggerObject->setRuleId($dao->rule_id);
+        $cronTriggerObject->setTriggerParams($dao->trigger_params ?? '');
+        $cronTriggers[] = $cronTriggerObject;
+      }
+    }
+    return $cronTriggers;
+  }
+
+  /**
+   * Returns an array with cron triggers which should be triggered in the cron
+   *
+   * @return array
+   */
+  public static function findRulesByClassname($classname) {
+    $triggers = [];
+    $sql = "SELECT r.id AS rule_id, t.id AS trigger_id, t.class_name, r.trigger_params
+            FROM `civirule_rule` r
+            INNER JOIN `civirule_trigger` t ON r.trigger_id = t.id AND t.is_active = 1
+            WHERE r.`is_active` = 1 AND t.class_name = %1";
+    $params[1] = [$classname, 'String'];
+    $dao = CRM_Core_DAO::executeQuery($sql, $params);
+    while ($dao->fetch()) {
+      $triggerObject = CRM_Civirules_BAO_Trigger::getTriggerObjectByClassName($dao->class_name, FALSE);
+      if ($triggerObject !== FALSE) {
+        $triggerObject->setTriggerId($dao->trigger_id);
+        $triggerObject->setRuleId($dao->rule_id);
+        $triggerObject->setTriggerParams($dao->trigger_params ?? '');
+        $triggers[] = $triggerObject;
+      }
+    }
+    return $triggers;
+  }
+
+  /**
+   * Method to determine if a rule is active on the civicrm queue
+   *
+   * @param $ruleId
+   * @return bool
+   */
+  public static function isRuleOnQueue($ruleId) {
+    $query = "SELECT * FROM civicrm_queue_item WHERE queue_name = %1";
+    $dao = CRM_Core_DAO::executeQuery($query, [1 => ["org.civicoop.civirules.action", "String"]]);
+    while ($dao->fetch()) {
+      if (isset($dao->data)) {
+        $queueItemData = @unserialize($dao->data);
+        if ($queueItemData) {
+          foreach($queueItemData->arguments as $dataArgument) {
+            if (is_subclass_of($dataArgument, 'CRM_Civirules_Action')) {
+              if ($dataArgument->getRuleId() == $ruleId) {
+                return TRUE;
+              }
+            }
+          }
+        }
+      }
+    }
+    return FALSE;
+  }
+
+  /**
+   * Function to unserialize the CiviRulesRule trigger_params
+   *
+   * @return array
+   */
+  public function unserializeParams(): array {
+    if (!empty($this->trigger_params) && !is_array($this->trigger_params)) {
+      return unserialize($this->trigger_params);
+    }
+    return [];
+  }
+
+}

CRM/Civirules/BAO/CiviRulesRuleAction.php

+<?php
+/**
+ * BAO RuleAction for CiviRule Rule Action
+ *
+ * @author Erik Hommel (CiviCooP) <erik.hommel@civicoop.org>
+ * @license http://www.gnu.org/licenses/agpl-3.0.html
+ */
+class CRM_Civirules_BAO_CiviRulesRuleAction extends CRM_Civirules_DAO_CiviRulesRuleAction implements \Civi\Core\HookInterface {
+
+  /**
+   * Function to unserialize the CiviRulesRuleAction action_params
+   *
+   * @return array
+   */
+  public function unserializeParams(): array {
+    if (!empty($this->action_params) && !is_array($this->action_params)) {
+      return unserialize($this->action_params);
+    }
+    return [];
+  }
+
+  /**
+   * Callback for hook_civicrm_post().
+   * @param \Civi\Core\Event\PostEvent $event
+   */
+  public static function self_hook_civicrm_post(\Civi\Core\Event\PostEvent $event) {
+    if (in_array($event->action, ['create' , 'edit'])) {
+      CRM_Utils_Weight::correctDuplicateWeights('CRM_Civirules_DAO_CiviRulesRuleAction');
+    }
+  }
+
+}

CRM/Civirules/BAO/CiviRulesRuleCondition.php

+<?php
+
+use Civi\Api4\CiviRulesRuleCondition;
+
+/**
+ * BAO RuleCondition for CiviRule Rule Condition
+ *
+ * @author Erik Hommel (CiviCooP) <erik.hommel@civicoop.org>
+ * @license http://www.gnu.org/licenses/agpl-3.0.html
+ */
+class CRM_Civirules_BAO_CiviRulesRuleCondition extends CRM_Civirules_DAO_RuleCondition implements \Civi\Core\HookInterface {
+
+  /**
+   * Function to disable a rule condition
+   *
+   * @param int $ruleConditionId
+   *
+   * @throws Exception when ruleConditionId is empty
+   */
+  public static function disable($ruleConditionId) {
+    if (!empty($ruleConditionId)) {
+      CiviRulesRuleCondition::update(FALSE)
+        ->addValue('is_active', 0)
+        ->addWhere('id', '=', $ruleConditionId)
+        ->execute();
+    }
+  }
+
+  /**
+   * Function to enable a rule condition
+   *
+   * @param int $ruleConditionId
+   *
+   * @throws Exception when ruleConditionId is empty
+   */
+  public static function enable($ruleConditionId) {
+    if (!empty($ruleConditionId)) {
+      CiviRulesRuleCondition::update(FALSE)
+        ->addValue('is_active', 1)
+        ->addWhere('id', '=', $ruleConditionId)
+        ->execute();
+    }
+  }
+
+  /**
+   * Function to count the number of conditions for a rule
+   *
+   * @param int $ruleId
+   *
+   * @return int
+   */
+  public static function countConditionsForRule($ruleId) {
+    return CiviRulesRuleCondition::get(FALSE)
+      ->addWhere('rule_id', '=', $ruleId)
+      ->execute()->count();
+  }
+
+  /**
+   * Callback for hook_civicrm_post().
+   * @param \Civi\Core\Event\PostEvent $event
+   */
+  public static function self_hook_civicrm_post(\Civi\Core\Event\PostEvent $event) {
+    if (in_array($event->action, ['create' , 'edit'])) {
+      CRM_Utils_Weight::correctDuplicateWeights('CRM_Civirules_DAO_CiviRulesRuleCondition');
+    }
+    if ($event->action === 'delete') {
+      if (property_exists($event->object, 'rule_id'))
+      self::emptyConditionLinkForFirstCondition($event->object->rule_id);
+    }
+  }
+
+  private static function emptyConditionLinkForFirstCondition($ruleID) {
+    $firstRuleCondition = CiviRulesRuleCondition::get(FALSE)
+      ->addSelect('id', 'condition_link')
+      ->addWhere('rule_id', '=', $ruleID)
+      ->addOrderBy('weight', 'ASC')
+      ->addOrderBy('id', 'ASC')
+      ->execute()
+      ->first();
+    if (!empty($firstRuleCondition) && !empty($firstRuleCondition['condition_link'])) {
+      CiviRulesRuleCondition::update(FALSE)
+        ->addValue('condition_link', NULL)
+        ->addWhere('id', '=', $firstRuleCondition['id'])
+        ->execute();
+    }
+  }
+
+  /**
+   * Function to unserialize the CiviRulesRuleCondition condition_params
+   *
+   * @return array
+   */
+  public function unserializeParams(): array {
+    if (!empty($this->condition_params) && !is_array($this->condition_params)) {
+      return unserialize($this->condition_params);
+    }
+    return [];
+  }
+
+}

CRM/Civirules/BAO/CiviRulesRuleLog.php

+<?php
+use CRM_Civirules_ExtensionUtil as E;
+
+class CRM_Civirules_BAO_CiviRulesRuleLog extends CRM_Civirules_DAO_RuleLog {
+
+  /**
+   * Create a new RuleLog based on array-data
+   *
+   * @param array $params key-value pairs
+   * @return CRM_Civirules_DAO_RuleLog|NULL
+   *
+  public static function create($params) {
+    $className = 'CRM_Civirules_DAO_RuleLog';
+    $entityName = 'RuleLog';
+    $hook = empty($params['id']) ? 'create' : 'edit';
+
+    CRM_Utils_Hook::pre($hook, $entityName, CRM_Utils_Array::value('id', $params), $params);
+    $instance = new $className();
+    $instance->copyValues($params);
+    $instance->save();
+    CRM_Utils_Hook::post($hook, $entityName, $instance->id, $instance);
+
+    return $instance;
+  } */
+
+}

CRM/Civirules/BAO/CiviRulesRuleTag.php

+<?php
+/**
+ * BAO RuleAction for CiviRule Rule Tag
+ *
+ * @author Erik Hommel (CiviCooP) <erik.hommel@civicoop.org>
+ * @license http://www.gnu.org/licenses/agpl-3.0.html
+ */
+class CRM_Civirules_BAO_CiviRulesRuleTag extends CRM_Civirules_DAO_RuleTag  {
+
+  /**
+   * Function to get values
+   *
+   * @return array $result found rows with data
+   * @access public
+   * @static
+   */
+  public static function getValues($params) {
+    $result = array();
+    $ruleTag = new CRM_Civirules_BAO_RuleTag();
+    if (!empty($params)) {
+      $fields = self::fields();
+      foreach ($params as $key => $value) {
+        if (isset($fields[$key])) {
+          $ruleTag->$key = $value;
+        }
+      }
+    }
+    $ruleTag->find();
+    while ($ruleTag->fetch()) {
+      $row = array();
+      self::storeValues($ruleTag, $row);
+      if (!empty($row['rule_id']) && !empty($row['rule_tag_id'])) {
+        $result[$row['id']] = $row;
+      } else {
+        //invalid ruleTag because there is no linked tag or rule
+        CRM_Civirules_BAO_RuleTag::deleteWithId($row['id']);
+      }
+    }
+    return $result;
+  }
+
+  /**
+   * Deprecated unction to add or update rule tag
+   *
+   * @param array $params
+   *
+   * @return \CRM_Civirules_DAO_CiviRulesRuleTag
+   * @throws Exception when params is empty
+   *
+   * @deprecated
+   */
+  public static function add($params) {
+    CRM_Core_Error::deprecatedFunctionWarning('writeRecord');
+    return self::writeRecord($params);
+  }
+
+  /**
+   * Function to delete a rule tag with id
+   *
+   * @param int $ruleTagId
+   * @throws Exception when ruleTagId is empty
+   * @access public
+   * @static
+   */
+  public static function deleteWithId($ruleTagId) {
+    if (empty($ruleTagId)) {
+      throw new Exception('rule tag id can not be empty when attempting to delete a civirule rule tag');
+    }
+    $ruleTag = new CRM_Civirules_BAO_RuleTag();
+    $ruleTag->id = $ruleTagId;
+    $ruleTag->delete();
+  }
+
+}

CRM/Civirules/BAO/CiviRulesTrigger.php

+<?php
+/**
+ * BAO Trigger for CiviRule Trigger
+ *
+ * @author Erik Hommel (CiviCooP) <erik.hommel@civicoop.org>
+ * @license http://www.gnu.org/licenses/agpl-3.0.html
+ */
+class CRM_Civirules_BAO_CiviRulesTrigger extends CRM_Civirules_DAO_Trigger {
+
+  /**
+   * Function to get values
+   *
+   * @return array $result found rows with data
+   * @access public
+   * @static
+   */
+  public static function getValues($params) {
+    $result = [];
+    $trigger = new CRM_Civirules_BAO_Trigger();
+    if (!empty($params)) {
+      $fields = self::fields();
+      foreach ($params as $key => $value) {
+        if (isset($fields[$key])) {
+          $trigger->$key = $value;
+        }
+      }
+    }
+    $trigger->find();
+    while ($trigger->fetch()) {
+      $row = [];
+      self::storeValues($trigger, $row);
+      $result[$row['id']] = $row;
+    }
+    return $result;
+  }
+
+  /**
+   * Deprecated function to add or update trigger
+   *
+   * @param array $params
+   *
+   * @return \CRM_Civirules_DAO_CiviRulesTrigger
+   * @throws Exception when params is empty
+   *
+   * @deprecated
+   */
+  public static function add($params) {
+    CRM_Core_Error::deprecatedFunctionWarning('writeRecord');
+    return self::writeRecord($params);
+  }
+
+  /**
+   * Function to delete a trigger with id
+   *
+   * @param int $triggerId
+   * @throws Exception when triggerId is empty
+   */
+  public static function deleteWithId($triggerId) {
+    if (empty($triggerId)) {
+      throw new Exception('trigger id can not be empty when attempting to delete a civirule trigger');
+    }
+    $trigger = new CRM_Civirules_BAO_Trigger();
+    $trigger->id = $triggerId;
+    $trigger->delete();
+  }
+
+  /**
+   * Function to disable a trigger
+   *
+   * @param int $triggerId
+   * @throws Exception when triggerId is empty
+   */
+  public static function disable($triggerId) {
+    if (empty($triggerId)) {
+      throw new Exception('trigger id can not be empty when attempting to disable a civirule trigger');
+    }
+    $trigger = new CRM_Civirules_BAO_Trigger();
+    $trigger->id = $triggerId;
+    $trigger->find(true);
+    self::writeRecord(['id' => $trigger->id, 'is_active' => 0]);
+  }
+
+  /**
+   * Function to enable a trigger
+   *
+   * @param int $triggerId
+   * @throws Exception when triggerId is empty
+   */
+  public static function enable($triggerId) {
+    if (empty($triggerId)) {
+      throw new Exception('trigger id can not be empty when attempting to enable a civirule trigger');
+    }
+    $trigger = new CRM_Civirules_BAO_Trigger();
+    $trigger->id = $triggerId;
+    $trigger->find(true);
+    self::writeRecord(['id' => $trigger->id, 'is_active' => 1]);
+  }
+
+  /**
+   * Function to retrieve the label of an eva triggerent with triggerId
+   *
+   * @param int $triggerId
+   * @return string $trigger->label
+   */
+  public static function getTriggerLabelWithId($triggerId) {
+    if (empty($triggerId)) {
+      return '';
+    }
+    $trigger = new CRM_Civirules_BAO_Trigger();
+    $trigger->id = $triggerId;
+    $trigger->find(true);
+    return $trigger->label;
+  }
+
+  /**
+   * Get the trigger class based on class name or on objectName
+   *
+   * @param $className
+   * @param bool $abort
+   *
+   * @return \CRM_Civirules_Trigger|false
+   * @throws \Exception if abort is set to true and class does not exist or is not valid
+   */
+  public static function getPostTriggerObjectByClassName($className, bool $abort=TRUE) {
+    if (empty($className)) {
+      $className = 'CRM_Civirules_Trigger_Post';
+    }
+    return self::getTriggerObjectByClassName($className, $abort);
+  }
+
+  /**
+   * Get the trigger class for this trigger
+   *
+   * @param $className
+   * @param bool $abort if true this function will throw an exception if class could not be instantiated
+   *
+   * @return \CRM_Civirules_Trigger|false
+   * @throws \Exception if abort is set to true and class does not exist or is not valid
+   */
+  public static function getTriggerObjectByClassName($className, bool $abort=TRUE) {
+    if (!class_exists($className)) {
+      if ($abort) {
+
+        throw new Exception('CiviRule trigger class "' . $className . '" does not exist');
+      }
+      return FALSE;
+    }
+
+    $object = new $className();
+    if (!$object instanceof CRM_Civirules_Trigger) {
+      if ($abort) {
+        throw new Exception('CiviRule trigger class "' . $className . '" is not a subclass of CRM_Civirules_Trigger');
+      }
+      return FALSE;
+    }
+    return $object;
+  }
+
+  /**
+   * @param int $triggerId
+   * @param bool $abort
+   *
+   * @return \CRM_Civirules_Trigger|false
+   * @throws \Civi\Core\Exception\DBQueryException
+   */
+  public static function getTriggerObjectByTriggerId($triggerId, bool $abort=TRUE) {
+    $sql = "SELECT t.*
+            FROM `civirule_trigger` t
+            WHERE t.`is_active` = 1 AND t.id = %1";
+
+    $params[1] = [$triggerId, 'Integer'];
+    $dao = CRM_Core_DAO::executeQuery($sql, $params);
+    if ($dao->fetch()) {
+      if (!empty($dao->object_name) && !empty($dao->op) && empty($dao->cron)) {
+        return self::getPostTriggerObjectByClassName($dao->class_name, $abort);
+      } elseif (!empty($dao->class_name)) {
+        return self::getTriggerObjectByClassName($dao->class_name, $abort);
+      }
+    }
+
+    if ($abort) {
+      throw new Exception('Could not find trigger with ID: '.$triggerId);
+    }
+    return FALSE;
+  }
+
+  /**
+   * Method to check if a trigger exists with class_name or object_name/op
+   *
+   * @param array $params
+   *
+   * @return bool
+   */
+  public static function triggerExists($params) {
+    if (isset($params['class_name']) && !empty($params['class_name'])) {
+      $checkParams['class_name'] = $params['class_name'];
+    } else {
+      if (isset($params['object_name']) && isset($params['op']) && !empty($params['object_name']) && !empty($params['op'])) {
+        $checkParams['object_name'] = $params['object_name'];
+        $checkParams['op'] = $params['op'];
+      }
+    }
+    if (!empty($checkParams)) {
+      $foundTriggers = self::getValues($checkParams);
+      if (!empty($foundTriggers)) {
+        return TRUE;
+      }
+    }
+    return FALSE;
+  }
+}

CRM/Civirules/BAO/Condition.php

 <?php
+
 /**
- * BAO Condition for CiviRule Condition
- * 
- * @author Erik Hommel (CiviCooP) <erik.hommel@civicoop.org>
- * @license http://www.gnu.org/licenses/agpl-3.0.html
+ * DAO class was renamed for API4/searchkit compatibility
  */
-class CRM_Civirules_BAO_Condition extends CRM_Civirules_DAO_Condition {
-
-  /**
-   * Function to get values
-   * 
-   * @return array $result found rows with data
-   * @access public
-   * @static
-   */
-  public static function getValues($params) {
-    $result = array();
-    $condition = new CRM_Civirules_BAO_Condition();
-    if (!empty($params)) {
-      $fields = self::fields();
-      foreach ($params as $key => $value) {
-        if (isset($fields[$key])) {
-          $condition->$key = $value;
-        }
-      }
-    }
-    $condition->find();
-    while ($condition->fetch()) {
-      $row = array();
-      self::storeValues($condition, $row);
-      $result[$row['id']] = $row;
-    }
-    return $result;
-  }
-
-  /**
-   * Function to add or update condition
-   * 
-   * @param array $params 
-   * @return array $result
-   * @access public
-   * @throws Exception when params is empty
-   * @static
-   */
-  public static function add($params) {
-    $result = array();
-    if (empty($params)) {
-      throw new Exception('Params can not be empty when adding or updating a civirule condition');
-    }
-    $condition = new CRM_Civirules_BAO_Condition();
-    $fields = self::fields();
-    foreach ($params as $key => $value) {
-      if (isset($fields[$key])) {
-        $condition->$key = $value;
-      }
-    }
-    if (!isset($condition->name) || empty($condition->name)) {
-      $condition->name = CRM_Civirules_Utils::buildNameFromLabel($condition->label);
-    }
-    $condition->save();
-    self::storeValues($condition, $result);
-    return $result;
-  }
-
-  /**
-   * Function to delete a condition with id
-   * 
-   * @param int $conditionId
-   * @throws Exception when conditionId is empty
-   * @access public
-   * @static
-   */
-  public static function deleteWithId($conditionId) {
-    if (empty($conditionId)) {
-      throw new Exception('condition id can not be empty when attempting to delete a civirule condition');
-    }
-
-    if (!CRM_Core_DAO::checkTableExists(self::getTableName())) {
-      return;
-    }
-
-    //delete rows from rule_condition to prevent a foreign key constraint error
-    CRM_Core_DAO::executeQuery("DELETE FROM `civirule_rule_condition` where `condition_id` = %1", array(1 => array($conditionId, 'Integer')));
-
-    $condition = new CRM_Civirules_BAO_Condition();
-    $condition->id = $conditionId;
-    $condition->delete();
-    return;
-  }
-
-  /**
-   * Function to disable a condition
-   * 
-   * @param int $conditionId
-   * @throws Exception when conditionId is empty
-   * @access public
-   * @static
-   */
-  public static function disable($conditionId) {
-    if (empty($conditionId)) {
-      throw new Exception('condition id can not be empty when attempting to disable a civirule condition');
-    }
-    $condition = new CRM_Civirules_BAO_Condition();
-    $condition->id = $conditionId;
-    $condition->find(true);
-    self::add(array('id' => $condition->id, 'is_active' => 0));
-  }
-
-  /**
-   * Function to enable a condition
-   * 
-   * @param int $conditionId
-   * @throws Exception when conditionId is empty
-   * @access public
-   * @static
-   */
-  public static function enable($conditionId) {
-    if (empty($conditionId)) {
-      throw new Exception('condition id can not be empty when attempting to enable a civirule condition');
-    }
-    $condition = new CRM_Civirules_BAO_Condition();
-    $condition->id = $conditionId;
-    $condition->find(true);
-    self::add(array('id' => $condition->id, 'is_active' => 1));
-  }
-
-  /**
-   * Function to retrieve the label of a condition with conditionId
-   *
-   * @param int $conditionId
-   * @return string $condition->label
-   * @access public
-   * @static
-   */
-  public static function getConditionLabelWithId($conditionId) {
-    if (empty($conditionId)) {
-      return '';
-    }
-    $condition = new CRM_Civirules_BAO_Condition();
-    $condition->id = $conditionId;
-    $condition->find(true);
-    return $condition->label;
-  }
-
-  /**
-   * Get the condition class for this condition
-   *
-   * @param $conditionId
-   * @param bool $abort if true this function will throw an exception if class could not be instanciated
-   * @return CRM_Civirules_Condition
-   * @throws Exception if abort is set to true and class does not exist or is not valid
-   */
-  public static function getConditionObjectById($conditionId, $abort=true) {
-    $condition = new CRM_Civirules_BAO_Condition();
-    $condition->id = $conditionId;
-    if (!$condition->find(true)) {
-      if ($abort) {
-        throw new Exception('CiviRule could not find condition');
-      }
-      return false;
-    }
-
-    $className = $condition->class_name;
-    if (!class_exists($className)) {
-      if ($abort) {
-
-        throw new Exception('CiviRule condition class "' . $className . '" does not exist');
-      }
-      return false;
-    }
-
-    $object = new $className();
-    if (!$object instanceof CRM_Civirules_Condition) {
-      if ($abort) {
-        throw new Exception('CiviRule condition class "' . $className . '" is not a subclass of CRM_Civirules_Condition');
-      }
-      return false;
-    }
-    return $object;
-  }
-}
\ No newline at end of file
+class_alias('CRM_Civirules_BAO_CiviRulesCondition', 'CRM_Civirules_BAO_Condition');

CRM/Civirules/BAO/Rule.php

 <?php
+
 /**
- * BAO Rule for CiviRule Rule
- * 
- * @author Erik Hommel (CiviCooP) <erik.hommel@civicoop.org>
- * @license http://www.gnu.org/licenses/agpl-3.0.html
+ * DAO class was renamed for API4/searchkit compatibility
  */
-class CRM_Civirules_BAO_Rule extends CRM_Civirules_DAO_Rule {
-
-  /**
-   * Function to get values
-   * 
-   * @return array $result found rows with data
-   * @access public
-   * @static
-   */
-  public static function getValues($params) {
-    $result = array();
-    $rule = new CRM_Civirules_BAO_Rule();
-    if (!empty($params)) {
-      $fields = self::fields();
-      foreach ($params as $key => $value) {
-        if (isset($fields[$key])) {
-          $rule->$key = $value;
-        }
-      }
-    }
-    $rule->find();
-    while ($rule->fetch()) {
-      $row = array();
-      self::storeValues($rule, $row);
-      $result[$row['id']] = $row;
-    }
-    return $result;
-  }
-
-  /**
-   * Function to add or update rule
-   * 
-   * @param array $params 
-   * @return array $result
-   * @access public
-   * @throws Exception when params is empty
-   * @static
-   */
-  public static function add($params) {
-    $result = array();
-    if (empty($params)) {
-      throw new Exception('Params can not be empty when adding or updating a civirule rule');
-    }
-    $rule = new CRM_Civirules_BAO_Rule();
-    $fields = self::fields();
-    foreach ($params as $key => $value) {
-      if (isset($fields[$key])) {
-        $rule->$key = $value;
-      }
-    }
-    if (!isset($rule->name) || empty($rule->name)) {
-      if (isset($rule->label)) {
-        $rule->name = CRM_Civirules_Utils::buildNameFromLabel($rule->label);
-      }
-    }
-    $rule->save();
-    self::storeValues($rule, $result);
-    return $result;
-  }
-
-  /**
-   * Function to delete a rule with id
-   * 
-   * @param int $ruleId
-   * @throws Exception when ruleId is empty
-   * @access public
-   * @static
-   */
-  public static function deleteWithId($ruleId) {
-    if (empty($ruleId)) {
-      throw new Exception('rule id can not be empty when attempting to delete a civirule rule');
-    }
-    CRM_Civirules_BAO_RuleAction::deleteWithRuleId($ruleId);
-    CRM_Civirules_BAO_RuleCondition::deleteWithRuleId($ruleId);
-    $rule = new CRM_Civirules_BAO_Rule();
-    $rule->id = $ruleId;
-    $rule->delete();
-    return;
-  }
-
-  /**
-   * Function to disable a rule
-   * 
-   * @param int $ruleId
-   * @throws Exception when ruleId is empty
-   * @access public
-   * @static
-   */
-  public static function disable($ruleId) {
-    if (empty($ruleId)) {
-      throw new Exception('rule id can not be empty when attempting to disable a civirule rule');
-    }
-    $rule = new CRM_Civirules_BAO_Rule();
-    $rule->id = $ruleId;
-    $rule->find(true);
-    self::add(array('id' => $rule->id, 'is_active' => 0));
-  }
-
-  /**
-   * Function to enable an rule
-   * 
-   * @param int $ruleId
-   * @throws Exception when ruleId is empty
-   * @access public
-   * @static
-   */
-  public static function enable($ruleId) {
-    if (empty($ruleId)) {
-      throw new Exception('rule id can not be empty when attempting to enable a civirule rule');
-    }
-    $rule = new CRM_Civirules_BAO_Rule();
-    $rule->id = $ruleId;
-    $rule->find(true);
-    self::add(array('id' => $rule->id, 'is_active' => 1));
-  }
-
-  /**
-   * Function to retrieve the label of a rule with ruleId
-   * 
-   * @param int $ruleId
-   * @return string $rule->label
-   * @access public
-   * @static
-   */
-  public static function getRuleLabelWithId($ruleId) {
-    if (empty($ruleId)) {
-      return '';
-    }
-    $rule = new CRM_Civirules_BAO_Rule();
-    $rule->id = $ruleId;
-    $rule->find(true);
-    return $rule->label;
-  }
-
-  /**
-   * Function to check if a label already exists in the rule table
-   *
-   * @param $labelToBeChecked
-   * @return bool
-   * @access public
-   * @static
-   */
-  public static function labelExists($labelToBeChecked) {
-    $rule = new CRM_Civirules_BAO_Rule();
-    $rule->label = $labelToBeChecked;
-    if ($rule->count() > 0) {
-      return TRUE;
-    }
-    return FALSE;
-  }
-
-  /**
-   * Returns an array with rules which should be triggered immediately
-   *
-   * @param string $objectName ObjectName in the Post hook
-   * @param string $op op in the Post hook
-   * @return array
-   */
-  public static function findRulesByObjectNameAndOp($objectName, $op)
-  {
-    $triggers = array();
-    $sql = "SELECT r.id AS rule_id, t.id AS trigger_id, t.class_name, r.trigger_params
-            FROM `civirule_rule` r
-            INNER JOIN `civirule_trigger` t ON r.trigger_id = t.id AND t.is_active = 1
-            WHERE r.`is_active` = 1 AND t.cron = 0 AND t.object_name = %1 AND t.op = %2";
-    $params[1] = array($objectName, 'String');
-    $params[2] = array($op, 'String');
-
-    $dao = CRM_Core_DAO::executeQuery($sql, $params);
-    while ($dao->fetch()) {
-      $triggerObject = CRM_Civirules_BAO_Trigger::getPostTriggerObjectByClassName($dao->class_name, false);
-      if ($triggerObject !== false) {
-        $triggerObject->setTriggerId($dao->trigger_id);
-        $triggerObject->setRuleId($dao->rule_id);
-        $triggerObject->setTriggerParams($dao->trigger_params);
-        $triggers[] = $triggerObject;
-      }
-    }
-    return $triggers;
-  }
-
-  /**
-   * Returns an array with cron triggers which should be triggered in the cron
-   *
-   * @return array
-   */
-  public static function findRulesForCron()
-  {
-    $cronTriggers = array();
-    $sql = "SELECT r.id AS rule_id, t.id AS trigger_id, t.class_name, r.trigger_params
-            FROM `civirule_rule` r
-            INNER JOIN `civirule_trigger` t ON r.trigger_id = t.id AND t.is_active = 1
-            WHERE r.`is_active` = 1 AND t.cron = 1";
-
-    $dao = CRM_Core_DAO::executeQuery($sql);
-    while ($dao->fetch()) {
-      $cronTriggerObject = CRM_Civirules_BAO_Trigger::getTriggerObjectByClassName($dao->class_name, false);
-      if ($cronTriggerObject !== false) {
-        $cronTriggerObject->setTriggerId($dao->trigger_id);
-        $cronTriggerObject->setRuleId($dao->rule_id);
-        $cronTriggerObject->setTriggerParams($dao->trigger_params);
-        $cronTriggers[] = $cronTriggerObject;
-      }
-    }
-    return $cronTriggers;
-  }
-
-  /*
-   * Function to get latest rule id
-   *
-   * @return int $ruleId
-   * @access public
-   * @static
-   */
-  public static function getLatestRuleId() {
-    $rule = new CRM_Civirules_BAO_Rule();
-    $query = 'SELECT MAX(id) AS maxId FROM '.$rule->tableName();
-    $dao = CRM_Core_DAO::executeQuery($query);
-    if ($dao->fetch()) {
-      return $dao->maxId;
-    }
-  }
-}
\ No newline at end of file
+class_alias('CRM_Civirules_BAO_CiviRulesRule', 'CRM_Civirules_BAO_Rule');

CRM/Civirules/BAO/RuleAction.php

 <?php
+
 /**
- * BAO RuleAction for CiviRule Rule Action
- * 
- * @author Erik Hommel (CiviCooP) <erik.hommel@civicoop.org>
- * @license http://www.gnu.org/licenses/agpl-3.0.html
+ * DAO class was renamed for API4/searchkit compatibility
  */
-class CRM_Civirules_BAO_RuleAction extends CRM_Civirules_DAO_RuleAction {
-
-  /**
-   * Function to get values
-   * 
-   * @return array $result found rows with data
-   * @access public
-   * @static
-   */
-  public static function getValues($params) {
-    $result = array();
-    $ruleAction = new CRM_Civirules_BAO_RuleAction();
-    if (!empty($params)) {
-      $fields = self::fields();
-      foreach ($params as $key => $value) {
-        if (isset($fields[$key])) {
-          $ruleAction->$key = $value;
-        }
-      }
-    }
-    $ruleAction->find();
-    while ($ruleAction->fetch()) {
-      $row = array();
-      self::storeValues($ruleAction, $row);
-      if (!empty($row['action_id'])) {
-        $result[$row['id']] = $row;
-      } else {
-        //invalid ruleAction because no there is no linked action
-        CRM_Civirules_BAO_RuleAction::deleteWithId($row['id']);
-      }
-    }
-    return $result;
-  }
-
-  /**
-   * Function to add or update rule action
-   * 
-   * @param array $params 
-   * @return array $result
-   * @access public
-   * @throws Exception when params is empty
-   * @static
-   */
-  public static function add($params) {
-    $result = array();
-    if (empty($params)) {
-      throw new Exception('Params can not be empty when adding or updating a civirule rule action');
-    }
-    $ruleAction = new CRM_Civirules_BAO_RuleAction();
-    $fields = self::fields();
-    foreach ($params as $key => $value) {
-      if (isset($fields[$key])) {
-        $ruleAction->$key = $value;
-      }
-    }
-    $ruleAction->save();
-    self::storeValues($ruleAction, $result);
-    return $result;
-  }
-
-  /**
-   * Function to delete a rule action with id
-   * 
-   * @param int $ruleActionId
-   * @throws Exception when ruleActionId is empty
-   * @access public
-   * @static
-   */
-  public static function deleteWithId($ruleActionId) {
-    if (empty($ruleActionId)) {
-      throw new Exception('rule action id can not be empty when attempting to delete a civirule rule action');
-    }
-    $ruleAction = new CRM_Civirules_BAO_RuleAction();
-    $ruleAction->id = $ruleActionId;
-    $ruleAction->delete();
-    return;
-  }
-
-  /**
-   * Function to disable a rule action
-   * 
-   * @param int $ruleActionId
-   * @throws Exception when ruleActionId is empty
-   * @access public
-   * @static
-   */
-  public static function disable($ruleActionId) {
-    if (empty($ruleActionId)) {
-      throw new Exception('rule action id can not be empty when attempting to disable a civirule rule action');
-    }
-    $ruleAction = new CRM_Civirules_BAO_RuleAction();
-    $ruleAction->id = $ruleActionId;
-    $ruleAction->find(true);
-    self::add(array('id' => $ruleAction->id, 'is_active' => 0));
-  }
-
-  /**
-   * Function to enable a rule action
-   * 
-   * @param int $ruleActionId
-   * @throws Exception when ruleActionId is empty
-   * @access public
-   * @static
-   */
-  public static function enable($ruleActionId) {
-    if (empty($ruleActionId)) {
-      throw new Exception('rule action id can not be empty when attempting to enable a civirule rule action');
-    }
-    $ruleAction = new CRM_Civirules_BAO_RuleAction();
-    $ruleAction->id = $ruleActionId;
-    $ruleAction->find(true);
-    self::add(array('id' => $ruleAction->id, 'is_active' => 1));
-  }
-
-  /**
-   * Function to delete all rule actions with rule id
-   *
-   * @param int $ruleId
-   * @access public
-   * @static
-   */
-  public static function deleteWithRuleId($ruleId) {
-    $ruleAction = new CRM_Civirules_BAO_RuleAction();
-    $ruleAction->rule_id = $ruleId;
-    $ruleAction->find(false);
-    while ($ruleAction->fetch()) {
-      $ruleAction->delete();
-    }
-  }
-
-}
\ No newline at end of file
+class_alias('CRM_Civirules_BAO_CiviRulesRuleAction', 'CRM_Civirules_BAO_RuleAction');

CRM/Civirules/BAO/RuleCondition.php

 <?php
+
 /**
- * BAO RuleCondition for CiviRule Rule Condition
- * 
- * @author Erik Hommel (CiviCooP) <erik.hommel@civicoop.org>
- * @license http://www.gnu.org/licenses/agpl-3.0.html
+ * DAO class was renamed for API4/searchkit compatibility
  */
-class CRM_Civirules_BAO_RuleCondition extends CRM_Civirules_DAO_RuleCondition {
-
-  /**
-   * Function to get values
-   * 
-   * @return array $result found rows with data
-   * @access public
-   * @static
-   */
-  public static function getValues($params) {
-    $result = array();
-    $ruleCondition = new CRM_Civirules_BAO_RuleCondition();
-    if (!empty($params)) {
-      $fields = self::fields();
-      foreach ($params as $key => $value) {
-        if (isset($fields[$key])) {
-          $ruleCondition->$key = $value;
-        }
-      }
-    }
-    $ruleCondition->find();
-    while ($ruleCondition->fetch()) {
-      $row = array();
-      self::storeValues($ruleCondition, $row);
-      if (!empty($row['condition_id'])) {
-        $result[$row['id']] = $row;
-      } else {
-        //invalid ruleCondition because no there is no linked condition
-        CRM_Civirules_BAO_RuleCondition::deleteWithId($row['id']);
-      }
-    }
-    return $result;
-  }
-
-  /**
-   * Function to add or update rule condition
-   * 
-   * @param array $params 
-   * @return array $result
-   * @access public
-   * @throws Exception when params is empty
-   * @static
-   */
-  public static function add($params) {
-    $result = array();
-    if (empty($params)) {
-      throw new Exception('Params can not be empty when adding or updating a civirule rule condition');
-    }
-    $ruleCondition = new CRM_Civirules_BAO_RuleCondition();
-    $fields = self::fields();
-    foreach ($params as $key => $value) {
-      if (isset($fields[$key])) {
-        $ruleCondition->$key = $value;
-      }
-    }
-    $ruleCondition->save();
-    self::storeValues($ruleCondition, $result);
-    return $result;
-  }
-
-  /**
-   * Function to delete a rule condition with id
-   * 
-   * @param int $ruleConditionId
-   * @throws Exception when ruleConditionId is empty
-   * @access public
-   * @static
-   */
-  public static function deleteWithId($ruleConditionId) {
-    if (empty($ruleConditionId)) {
-      throw new Exception('rule condition id can not be empty when attempting to delete a civirule rule condition');
-    }
-    $ruleCondition = new CRM_Civirules_BAO_RuleCondition();
-    $ruleCondition->id = $ruleConditionId;
-    $ruleCondition->delete();
-    return;
-  }
-
-  /**
-   * Function to disable a rule condition
-   * 
-   * @param int $ruleConditionId
-   * @throws Exception when ruleConditionId is empty
-   * @access public
-   * @static
-   */
-  public static function disable($ruleConditionId) {
-    if (empty($ruleConditionId)) {
-      throw new Exception('rule condition id can not be empty when attempting to disable a civirule rule condition');
-    }
-    $ruleCondition = new CRM_Civirules_BAO_RuleCondition();
-    $ruleCondition->id = $ruleConditionId;
-    $ruleCondition->find(true);
-    self::add(array('id' => $ruleCondition->id, 'is_active' => 0));
-  }
-
-  /**
-   * Function to enable a rule condition
-   * 
-   * @param int $ruleConditionId
-   * @throws Exception when ruleConditionId is empty
-   * @access public
-   * @static
-   */
-  public static function enable($ruleConditionId) {
-    if (empty($ruleConditionId)) {
-      throw new Exception('rule condition id can not be empty when attempting to enable a civirule rule condition');
-    }
-    $ruleCondition = new CRM_Civirules_BAO_RuleCondition();
-    $ruleCondition->id = $ruleConditionId;
-    $ruleCondition->find(true);
-    self::add(array('id' => $ruleCondition->id, 'is_active' => 1));
-  }
-
-  /**
-   * Function to delete all rule conditions with rule id
-   *
-   * @param int $ruleId
-   * @access public
-   * @static
-   */
-  public static function deleteWithRuleId($ruleId) {
-    $ruleCondition = new CRM_Civirules_BAO_RuleCondition();
-    $ruleCondition->rule_id = $ruleId;
-    $ruleCondition->find(FALSE);
-    while ($ruleCondition->fetch()) {
-      $ruleCondition->delete();
-    }
-  }
-
-  /**
-   * Function to count the number of conditions for a rule
-   *
-   * @param int $ruleId
-   * @return int
-   * @access public
-   * @static
-   */
-  public static function countConditionsForRule($ruleId) {
-    $ruleCondition = new CRM_Civirules_BAO_RuleCondition();
-    $ruleCondition->rule_id = $ruleId;
-    return $ruleCondition->count();
-  }
-}
\ No newline at end of file
+class_alias('CRM_Civirules_BAO_CiviRulesRuleCondition', 'CRM_Civirules_BAO_RuleCondition');

CRM/Civirules/BAO/RuleLog.php

+<?php
+
+/**
+ * DAO class was renamed for API4/searchkit compatibility
+ */
+class_alias('CRM_Civirules_BAO_CiviRulesRuleLog', 'CRM_Civirules_BAO_RuleLog');