/** * Gets a configuration value * * Plugin authors should use elgg_get_config(). * * @note Internal: These settings are stored in the dbprefix_config table and read * during system boot into $CONFIG. * * @param string $name The name of the config value * * @return mixed|null */ function get($name) { $name = trim($name); // check for deprecated values. // @todo might be a better spot to define this? $new_name = false; switch ($name) { case 'pluginspath': $new_name = 'plugins_path'; break; case 'sitename': $new_name = 'site_name'; break; } // @todo these haven't really been implemented in Elgg 1.8. Complete in 1.9. // show dep message if ($new_name) { // $msg = "Config value $name has been renamed as $new_name"; $name = $new_name; // elgg_deprecated_notice($msg, $dep_version); } // decide from where to return the value if (isset($this->CONFIG->{$name})) { return $this->CONFIG->{$name}; } $sql = "\n\t\t\tSELECT value\n\t\t\tFROM {$this->CONFIG->dbprefix}config\n\t\t\tWHERE name = :name\n\t\t"; $params[':name'] = $name; $result = $this->db->getDataRow($sql, null, $params); if ($result) { $result = unserialize($result->value); $this->CONFIG->{$name} = $result; return $result; } return null; }
/** * Returns SQL appropriate for relationship joins and wheres * * @todo add support for multiple relationships and guids. * * @param string $column Column name the GUID should be checked against. * Provide in table.column format. * @param string $relationship Type of the relationship * @param int $relationship_guid Entity GUID to check * @param bool $inverse_relationship Is $relationship_guid the target of the relationship? * * @return mixed * @access private */ public function getEntityRelationshipWhereSql($column, $relationship = null, $relationship_guid = null, $inverse_relationship = false) { if ($relationship == null && $relationship_guid == null) { return ''; } $wheres = array(); $joins = array(); $group_by = ''; if ($inverse_relationship) { $joins[] = "JOIN {$this->db->getTablePrefix()}entity_relationships r on r.guid_one = {$column}"; } else { $joins[] = "JOIN {$this->db->getTablePrefix()}entity_relationships r on r.guid_two = {$column}"; } if ($relationship) { $wheres[] = "r.relationship = '" . $this->db->sanitizeString($relationship) . "'"; } if ($relationship_guid) { if ($inverse_relationship) { $wheres[] = "r.guid_two = '{$relationship_guid}'"; } else { $wheres[] = "r.guid_one = '{$relationship_guid}'"; } } else { // See #5775. Queries that do not include a relationship_guid must be grouped by entity table alias, // otherwise the result set is not unique $group_by = $column; } if ($where_str = implode(' AND ', $wheres)) { return array('wheres' => array("({$where_str})"), 'joins' => $joins, 'group_by' => $group_by); } return ''; }
/** * Deletes all private settings for an entity * * @param int $entity_guid The Entity GUID * @return bool */ public function removeAllForEntity($entity_guid) { $this->cache->clear($entity_guid); _elgg_services()->boot->invalidateCache(); $query = "\n\t\t\tDELETE FROM {$this->table}\n\t\t\tWHERE entity_guid = :entity_guid\n\t\t"; $params = [':entity_guid' => (int) $entity_guid]; return $this->db->deleteData($query, $params); }
/** * Deletes all private settings for an entity * * @param int $entity_guid The Entity GUID * @return bool */ function removeAllForEntity($entity_guid) { $entity_guid = (int) $entity_guid; $entity = $this->entities->get($entity_guid); if (!$entity instanceof \ElggEntity) { return false; } return $this->db->deleteData("DELETE FROM {$this->table}\n\t\t\tWHERE entity_guid = {$entity_guid}"); }
/** * Check to see if a user has already created an annotation on an object * * @param int $entity_guid Entity guid * @param string $annotation_type Type of annotation * @param int $owner_guid Defaults to logged in user. * * @return bool */ function exists($entity_guid, $annotation_type, $owner_guid = null) { if (!$owner_guid && !($owner_guid = $this->session->getLoggedInUserGuid())) { return false; } $sql = "SELECT id FROM {$this->db->prefix}annotations\n\t\t\t\tWHERE owner_guid = :owner_guid\n\t\t\t\tAND entity_guid = :entity_guid\n\t\t\t\tAND name = :annotation_type"; $result = $this->db->getDataRow($sql, null, [':owner_guid' => (int) $owner_guid, ':entity_guid' => (int) $entity_guid, ':annotation_type' => $annotation_type]); return (bool) $result; }
/** * Get a populated cache object * * @return array */ protected function getPopulatedCache() { if ($this->cache === null) { $rows = $this->db->getData("\n\t\t\t\tSELECT *\n\t\t\t\tFROM {$this->db->prefix}entity_subtypes\n\t\t\t"); $this->cache = []; foreach ($rows as $row) { $this->cache[$row->id] = $row; } } return $this->cache; }
/** * Load entire datalist in memory. * * This could cause OOM problems if the datalists table is large. * * @todo make a list of datalists that we want to get in one grab * * @return array * @access private */ function loadAll() { $result = $this->db->getData("SELECT * FROM {$this->table}"); $map = array(); if (is_array($result)) { foreach ($result as $row) { $map[$row->name] = $row->value; $this->cache->put($row->name, $row->value); } } return $map; }
/** * When an entity is updated, resets the access ID on all of its child metadata * * @param string $event The name of the event * @param string $object_type The type of object * @param \ElggEntity $object The entity itself * * @return true * @access private Set as private in 1.9.0 */ function handleUpdate($event, $object_type, $object) { if ($object instanceof \ElggEntity) { if (!$this->isMetadataIndependent($object->getType(), $object->getSubtype())) { $access_id = (int) $object->access_id; $guid = (int) $object->getGUID(); $query = "update {$this->table} set access_id = {$access_id} where entity_guid = {$guid}"; $this->db->updateData($query); } } return true; }
/** * Get subscription records from the database * * Records are an object with two vars: guid and methods with the latter * being a comma-separated list of subscription relationship names. * * @param int $container_guid The GUID of the subscription target * @return array */ protected function getSubscriptionRecords($container_guid) { $container_guid = $this->db->sanitizeInt($container_guid); // create IN clause $rels = $this->getMethodRelationships(); if (!$rels) { return array(); } array_walk($rels, array($this->db, 'sanitizeString')); $methods_string = "'" . implode("','", $rels) . "'"; $db_prefix = $this->db->prefix; $query = "SELECT guid_one AS guid, GROUP_CONCAT(relationship SEPARATOR ',') AS methods\n\t\t\tFROM {$db_prefix}entity_relationships\n\t\t\tWHERE guid_two = {$container_guid} AND\n\t\t\t\t\trelationship IN ({$methods_string}) GROUP BY guid_one"; return $this->db->getData($query); }
/** * Disables all entities owned and contained by a user (or another entity) * * @param int $owner_guid The owner GUID * @return bool */ public function disableEntities($owner_guid) { $entity = get_entity($owner_guid); if (!$entity || !$entity->canEdit()) { return false; } if (!$this->events->trigger('disable', $entity->type, $entity)) { return false; } $query = "\n\t\t\tUPDATE {$this->table}entities\n\t\t\tSET enabled='no'\n\t\t\tWHERE owner_guid = :owner_guid\n\t\t\tOR container_guid = :owner_guid"; $params = [':owner_guid' => (int) $owner_guid]; _elgg_invalidate_cache_for_entity($entity->guid); _elgg_invalidate_memcache_for_entity($entity->guid); if ($this->db->updateData($query, true, $params)) { return true; } return false; }
/** * Removes user $guid's admin flag. * * @param int $user_guid User GUID * @return bool */ public function removeAdmin($user_guid) { $user = get_entity($user_guid); if (!$user instanceof ElggUser || !$user->canEdit()) { return false; } if (!$this->events->trigger('remove_admin', 'user', $user)) { return false; } $query = "\n\t\t\tUPDATE {$this->table}\n\t\t\tSET admin = 'no'\n\t\t\tWHERE guid = :guid\n\t\t"; $params = [':guid' => (int) $user_guid]; _elgg_invalidate_cache_for_entity($user_guid); _elgg_invalidate_memcache_for_entity($user_guid); if ($this->db->updateData($query, true, $params)) { return true; } return false; }
/** * {@inheritDoc} */ public function gc($max_lifetime) { $life = time() - $max_lifetime; $query = "DELETE FROM {$this->db->getTablePrefix()}users_sessions WHERE ts < '{$life}'"; return (bool) $this->db->deleteData($query); }
/** * {@inheritdoc} */ public function sanitizeString($value) { return $this->db->sanitizeString($value); }
/** * The full name of the metastrings table, including prefix. * * @return string */ public function getTableName() { return $this->db->getTablePrefix() . "metastrings"; }
/** * Get the number of queries performed since the object was constructed * * @return int # of queries */ public function getDelta() { return $this->db->getQueryCount() - $this->initial; }
/** * {@inheritdoc} */ public function __construct(Config $config, Logger $logger = null) { parent::__construct($config, $logger); $this->test = TestCase::getInstance(); }
/** * Populate the boot data * * @param \stdClass $config Elgg CONFIG object * @param \Elgg\Database $db Elgg database * @param EntityTable $entities Entities service * @param Plugins $plugins Plugins service * * @return void * @throws \InstallationException */ public function populate(\stdClass $config, Database $db, EntityTable $entities, Plugins $plugins) { // get subtypes $rows = $db->getData("\n\t\t\tSELECT *\n\t\t\tFROM {$db->prefix}entity_subtypes\n\t\t"); foreach ($rows as $row) { $this->subtype_data[$row->id] = $row; } // get config $rows = $db->getData("\n\t\t\tSELECT *\n\t\t\tFROM {$db->prefix}config\n\t\t"); foreach ($rows as $row) { $this->config_values[$row->name] = unserialize($row->value); } if (!array_key_exists('installed', $this->config_values)) { // try to fetch from old pre 3.0 datalists table // need to do this to be able to perform an upgrade from 2.x to 3.0 try { $rows = $db->getData("\n\t\t\t\t\tSELECT *\n\t\t\t\t\tFROM {$db->prefix}datalists\n\t\t\t\t"); foreach ($rows as $row) { $value = $row->value; if ($row->name == 'processed_upgrades') { // config table already serializes data so no need to double serialize $value = unserialize($value); } $this->config_values[$row->name] = $value; } } catch (\Exception $e) { } } // get site entity $this->site = $entities->get($this->config_values['default_site'], 'site'); if (!$this->site) { throw new \InstallationException("Unable to handle this request. This site is not configured or the database is down."); } // get plugins $this->active_plugins = $plugins->find('active'); // get plugin settings if (!$this->active_plugins) { return; } // find GUIDs with not too many private settings $guids = array_map(function (\ElggPlugin $plugin) { return $plugin->guid; }, $this->active_plugins); // find plugin GUIDs with not too many settings $limit = 40; $set = implode(',', $guids); $sql = "\n\t\t\tSELECT entity_guid\n\t\t\tFROM {$db->prefix}private_settings\n\t\t\tWHERE entity_guid IN ({$set})\n\t\t\t AND name NOT LIKE 'plugin:user_setting:%'\n\t\t\t AND name NOT LIKE 'elgg:internal:%'\n\t\t\tGROUP BY entity_guid\n\t\t\tHAVING COUNT(*) > {$limit}\n\t\t"; $unsuitable_guids = $db->getData($sql, function ($row) { return (int) $row->entity_guid; }); $guids = array_values($guids); $guids = array_diff($guids, $unsuitable_guids); if ($guids) { // get the settings $set = implode(',', $guids); $rows = $db->getData("\n\t\t\t\tSELECT entity_guid, `name`, `value`\n\t\t\t\tFROM {$db->prefix}private_settings\n\t\t\t\tWHERE entity_guid IN ({$set})\n\t\t\t\t AND name NOT LIKE 'plugin:user_setting:%'\n\t\t\t\t AND name NOT LIKE 'elgg:internal:%'\n\t\t\t\tORDER BY entity_guid\n\t\t\t"); // make sure we show all entities as loaded $this->plugin_settings = array_fill_keys($guids, []); foreach ($rows as $i => $row) { $this->plugin_settings[$row->entity_guid][$row->name] = $row->value; } } }
/** * Checks if mutex is locked * * @param string $namespace Namespace to use for the database table * @return bool */ public function isLocked($namespace) { $this->assertNamespace($namespace); return (bool) count($this->db->getData("SHOW TABLES LIKE '{$this->db->getTablePrefix()}{$namespace}_lock'")); }