/**
* Sends the notifications based on subscriptions
*
* Returns an array in the form:
* <code>
* [
* 25 => [
* 'email' => true,
* 'sms' => false,
* ],
* 55 => [],
* ]
* </code>
*
* @param NotificationEvent $event Notification event
* @param array $subscriptions Subscriptions for this event
* @param array $params Default notification parameters
* @return array
* @access private
*/
protected function sendNotifications($event, $subscriptions, array $params = [])
{
if (!$this->methods) {
return 0;
}
$result = [];
foreach ($subscriptions as $guid => $methods) {
foreach ($methods as $method) {
$result[$guid][$method] = false;
if (in_array($method, $this->methods)) {
$result[$guid][$method] = $this->sendNotification($event, $guid, $method, $params);
}
}
}
$this->logger->notice("Results for the notification event {$event->getDescription()}: " . print_r($result, true));
return $result;
}
/**
* Unlocks mutex
*
* @param string $namespace Namespace to use for the database table
* @return void
*/
public function unlock($namespace)
{
$this->assertNamespace($namespace);
$this->db->deleteData("DROP TABLE {$this->db->getTablePrefix()}{$namespace}_lock");
$this->logger->notice("Mutex unlocked for {$namespace}.");
}
/**
* Returns SQL where clause for type and subtype on main entity table
*
* @param string $table Entity table prefix as defined in SELECT...FROM entities $table
* @param null|array $types Array of types or null if none.
* @param null|array $subtypes Array of subtypes or null if none
* @param null|array $pairs Array of pairs of types and subtypes
*
* @return false|string
* @access private
*/
public function getEntityTypeSubtypeWhereSql($table, $types, $subtypes, $pairs)
{
// subtype depends upon type.
if ($subtypes && !$types) {
$this->logger->warn("Cannot set subtypes without type.");
return false;
}
// short circuit if nothing is requested
if (!$types && !$subtypes && !$pairs) {
return '';
}
// these are the only valid types for entities in elgg
$valid_types = $this->config->get('entity_types');
// pairs override
$wheres = array();
if (!is_array($pairs)) {
if (!is_array($types)) {
$types = array($types);
}
if ($subtypes && !is_array($subtypes)) {
$subtypes = array($subtypes);
}
// decrementer for valid types. Return false if no valid types
$valid_types_count = count($types);
$valid_subtypes_count = 0;
// remove invalid types to get an accurate count of
// valid types for the invalid subtype detection to use
// below.
// also grab the count of ALL subtypes on valid types to decrement later on
// and check against.
//
// yes this is duplicating a foreach on $types.
foreach ($types as $type) {
if (!in_array($type, $valid_types)) {
$valid_types_count--;
unset($types[array_search($type, $types)]);
} else {
// do the checking (and decrementing) in the subtype section.
$valid_subtypes_count += count($subtypes);
}
}
// return false if nothing is valid.
if (!$valid_types_count) {
return false;
}
// subtypes are based upon types, so we need to look at each
// type individually to get the right subtype id.
foreach ($types as $type) {
$subtype_ids = array();
if ($subtypes) {
foreach ($subtypes as $subtype) {
// check that the subtype is valid
if (!$subtype && ELGG_ENTITIES_NO_VALUE === $subtype) {
// subtype value is 0
$subtype_ids[] = ELGG_ENTITIES_NO_VALUE;
} elseif (!$subtype) {
// subtype is ignored.
// this handles ELGG_ENTITIES_ANY_VALUE, '', and anything falsy that isn't 0
continue;
} else {
$subtype_id = get_subtype_id($type, $subtype);
if ($subtype_id) {
$subtype_ids[] = $subtype_id;
} else {
$valid_subtypes_count--;
$this->logger->notice("Type-subtype '{$type}:{$subtype}' does not exist!");
continue;
}
}
}
// return false if we're all invalid subtypes in the only valid type
if ($valid_subtypes_count <= 0) {
return false;
}
}
if (is_array($subtype_ids) && count($subtype_ids)) {
$subtype_ids_str = implode(',', $subtype_ids);
$wheres[] = "({$table}.type = '{$type}' AND {$table}.subtype IN ({$subtype_ids_str}))";
} else {
$wheres[] = "({$table}.type = '{$type}')";
}
}
} else {
// using type/subtype pairs
$valid_pairs_count = count($pairs);
$valid_pairs_subtypes_count = 0;
// same deal as above--we need to know how many valid types
// and subtypes we have before hitting the subtype section.
// also normalize the subtypes into arrays here.
foreach ($pairs as $paired_type => $paired_subtypes) {
if (!in_array($paired_type, $valid_types)) {
$valid_pairs_count--;
unset($pairs[array_search($paired_type, $pairs)]);
} else {
if ($paired_subtypes && !is_array($paired_subtypes)) {
$pairs[$paired_type] = array($paired_subtypes);
}
$valid_pairs_subtypes_count += count($paired_subtypes);
}
}
if ($valid_pairs_count <= 0) {
return false;
}
foreach ($pairs as $paired_type => $paired_subtypes) {
// this will always be an array because of line 2027, right?
// no...some overly clever person can say pair => array('object' => null)
if (is_array($paired_subtypes)) {
$paired_subtype_ids = array();
foreach ($paired_subtypes as $paired_subtype) {
if (ELGG_ENTITIES_NO_VALUE === $paired_subtype || ($paired_subtype_id = get_subtype_id($paired_type, $paired_subtype))) {
$paired_subtype_ids[] = ELGG_ENTITIES_NO_VALUE === $paired_subtype ? ELGG_ENTITIES_NO_VALUE : $paired_subtype_id;
} else {
$valid_pairs_subtypes_count--;
$this->logger->notice("Type-subtype '{$paired_type}:{$paired_subtype}' does not exist!");
// return false if we're all invalid subtypes in the only valid type
continue;
}
}
// return false if there are no valid subtypes.
if ($valid_pairs_subtypes_count <= 0) {
return false;
}
if ($paired_subtype_ids_str = implode(',', $paired_subtype_ids)) {
$wheres[] = "({$table}.type = '{$paired_type}'" . " AND {$table}.subtype IN ({$paired_subtype_ids_str}))";
}
} else {
$wheres[] = "({$table}.type = '{$paired_type}')";
}
}
}
// pairs override the above. return false if they don't exist.
if (is_array($wheres) && count($wheres)) {
$where = implode(' OR ', $wheres);
return "({$where})";
}
return '';
}
