X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=classes%2FManaged_DataObject.php;h=0857bb11f6c277612b69f809c749c93acd61400a;hb=a2d8305e2159f60df979898983b5fe4ccf166a16;hp=d17552212b173dbbb55b28365eebddc9e349da7a;hpb=b903db059cd8257db014d1c56a60e71a9e59f224;p=quix0rs-gnu-social.git diff --git a/classes/Managed_DataObject.php b/classes/Managed_DataObject.php index d17552212b..0857bb11f6 100644 --- a/classes/Managed_DataObject.php +++ b/classes/Managed_DataObject.php @@ -64,6 +64,11 @@ abstract class Managed_DataObject extends Memcached_DataObject return parent::pkeyGetClass(get_called_class(), $kv); } + static function pkeyCols() + { + return parent::pkeyColsClass(get_called_class()); + } + /** * Get multiple items from the database by key * @@ -298,4 +303,292 @@ abstract class Managed_DataObject extends Memcached_DataObject } return $ckeys; } + + public function escapedTableName() + { + return common_database_tablename($this->tableName()); + } + + /** + * Returns an object by looking at the primary key column(s). + * + * Will require all primary key columns to be defined in an associative array + * and ignore any keys which are not part of the primary key. + * + * Will NOT accept NULL values as part of primary key. + * + * @param array $vals Must match all primary key columns for the dataobject. + * + * @return Managed_DataObject of the get_called_class() type + * @throws NoResultException if no object with that primary key + */ + static function getByPK(array $vals) + { + $classname = get_called_class(); + + $pkey = static::pkeyCols(); + if (is_null($pkey)) { + throw new ServerException("Failed to get primary key columns for class '{$classname}'"); + } + + $object = new $classname(); + foreach ($pkey as $col) { + if (!array_key_exists($col, $vals)) { + throw new ServerException("Missing primary key column '{$col}' for ".get_called_class()." among provided keys: ".implode(',', array_keys($vals))); + } elseif (is_null($vals[$col])) { + throw new ServerException("NULL values not allowed in getByPK for column '{$col}'"); + } + $object->$col = $vals[$col]; + } + if (!$object->find(true)) { + throw new NoResultException($object); + } + return $object; + } + + /** + * Returns an object by looking at given unique key columns. + * + * Will NOT accept NULL values for a unique key column. Ignores non-key values. + * + * @param array $vals All array keys which are set must be non-null. + * + * @return Managed_DataObject of the get_called_class() type + * @throws NoResultException if no object with that primary key + */ + static function getByKeys(array $vals) + { + $classname = get_called_class(); + + $object = new $classname(); + + $keys = $object->keys(); + if (is_null($keys)) { + throw new ServerException("Failed to get key columns for class '{$classname}'"); + } + + foreach ($keys as $col) { + if (!array_key_exists($col, $vals)) { + continue; + } elseif (is_null($vals[$col])) { + throw new ServerException("NULL values not allowed in getByKeys for column '{$col}'"); + } + $object->$col = $vals[$col]; + } + if (!$object->find(true)) { + throw new NoResultException($object); + } + return $object; + } + + static function getByID($id) + { + if (empty($id)) { + throw new EmptyIdException(get_called_class()); + } + // getByPK throws exception if id is null + // or if the class does not have a single 'id' column as primary key + return static::getByPK(array('id' => $id)); + } + + /** + * Returns an ID, checked that it is set and reasonably valid + * + * If this dataobject uses a special id field (not 'id'), just + * implement your ID getting method in the child class. + * + * @return int ID of dataobject + * @throws Exception (when ID is not available or not set yet) + */ + public function getID() + { + // FIXME: Make these exceptions more specific (their own classes) + if (!isset($this->id)) { + throw new Exception('No ID set.'); + } elseif (empty($this->id)) { + throw new Exception('Empty ID for object! (not inserted yet?).'); + } + + return intval($this->id); + } + + /** + * WARNING: Only use this on Profile and Notice. We should probably do + * this with traits/"implements" or whatever, but that's over the top + * right now, I'm just throwing this in here to avoid code duplication + * in Profile and Notice classes. + */ + public function getAliases() + { + return array_keys($this->getAliasesWithIDs()); + } + + public function getAliasesWithIDs() + { + $aliases = array(); + $aliases[$this->getUri()] = $this->getID(); + + try { + $aliases[$this->getUrl()] = $this->getID(); + } catch (InvalidUrlException $e) { + // getUrl failed because no valid URL could be returned, just ignore it + } + + if (common_config('fix', 'fancyurls')) { + /** + * Here we add some hacky hotfixes for remote lookups that have been taught the + * (at least now) wrong URI but it's still obviously the same user. Such as: + * - https://site.example/user/1 even if the client requests https://site.example/index.php/user/1 + * - https://site.example/user/1 even if the client requests https://site.example//index.php/user/1 + * - https://site.example/index.php/user/1 even if the client requests https://site.example/user/1 + * - https://site.example/index.php/user/1 even if the client requests https://site.example///index.php/user/1 + */ + foreach ($aliases as $alias=>$id) { + try { + // get a "fancy url" version of the alias, even without index.php/ + $alt_url = common_fake_local_fancy_url($alias); + // store this as well so remote sites can be sure we really are the same profile + $aliases[$alt_url] = $id; + } catch (Exception $e) { + // Apparently we couldn't rewrite that, the $alias was as the function wanted it to be + } + + try { + // get a non-"fancy url" version of the alias, i.e. add index.php/ + $alt_url = common_fake_local_nonfancy_url($alias); + // store this as well so remote sites can be sure we really are the same profile + $aliases[$alt_url] = $id; + } catch (Exception $e) { + // Apparently we couldn't rewrite that, the $alias was as the function wanted it to be + } + } + } + return $aliases; + } + + // 'update' won't write key columns, so we have to do it ourselves. + // This also automatically calls "update" _before_ it sets the keys. + // FIXME: This only works with single-column primary keys so far! Beware! + /** + * @param DB_DataObject &$orig Must be "instanceof" $this + * @param string $pid Primary ID column (no escaping is done on column name!) + */ + public function updateWithKeys(Managed_DataObject $orig, $pid=null) + { + if (!$orig instanceof $this) { + throw new ServerException('Tried updating a DataObject with a different class than itself.'); + } + + if ($this->N <1) { + throw new ServerException('DataObject must be the result of a query (N>=1) before updateWithKeys()'); + } + + // do it in a transaction + $this->query('BEGIN'); + + $parts = array(); + foreach ($this->keys() as $k) { + if (strcmp($this->$k, $orig->$k) != 0) { + $parts[] = $k . ' = ' . $this->_quote($this->$k); + } + } + if (count($parts) == 0) { + // No changes to keys, it's safe to run ->update(...) + if ($this->update($orig) === false) { + common_log_db_error($this, 'UPDATE', __FILE__); + // rollback as something bad occurred + $this->query('ROLLBACK'); + throw new ServerException("Could not UPDATE non-keys for {$this->tableName()}"); + } + $orig->decache(); + $this->encache(); + + // commit our db transaction since we won't reach the COMMIT below + $this->query('COMMIT'); + // @FIXME return true only if something changed (otherwise 0) + return true; + } + + if ($pid === null) { + $schema = static::schemaDef(); + $pid = $schema['primary key']; + unset($schema); + } + $pidWhere = array(); + foreach((array)$pid as $pidCol) { + $pidWhere[] = sprintf('%1$s = %2$s', $pidCol, $this->_quote($orig->$pidCol)); + } + if (empty($pidWhere)) { + throw new ServerException('No primary ID column(s) set for updateWithKeys'); + } + + $qry = sprintf('UPDATE %1$s SET %2$s WHERE %3$s', + common_database_tablename($this->tableName()), + implode(', ', $parts), + implode(' AND ', $pidWhere)); + + $result = $this->query($qry); + if ($result === false) { + common_log_db_error($this, 'UPDATE', __FILE__); + // rollback as something bad occurred + $this->query('ROLLBACK'); + throw new ServerException("Could not UPDATE key fields for {$this->tableName()}"); + } + + // Update non-keys too, if the previous endeavour worked. + // The ->update call uses "$this" values for keys, that's why we can't do this until + // the keys are updated (because they might differ from $orig and update the wrong entries). + if ($this->update($orig) === false) { + common_log_db_error($this, 'UPDATE', __FILE__); + // rollback as something bad occurred + $this->query('ROLLBACK'); + throw new ServerException("Could not UPDATE non-keys for {$this->tableName()}"); + } + $orig->decache(); + $this->encache(); + + // commit our db transaction + $this->query('COMMIT'); + // @FIXME return true only if something changed (otherwise 0) + return $result; + } + + static public function beforeSchemaUpdate() + { + // NOOP + } + + static function newUri(Profile $actor, Managed_DataObject $object, $created=null) + { + if (is_null($created)) { + $created = common_sql_now(); + } + return TagURI::mint(strtolower(get_called_class()).':%d:%s:%d:%s', + $actor->getID(), + ActivityUtils::resolveUri($object->getObjectType(), true), + $object->getID(), + common_date_iso8601($created)); + } + + protected function onInsert() + { + // NOOP by default + } + + protected function onUpdate($dataObject=false) + { + // NOOP by default + } + + public function insert() + { + $this->onInsert(); + return parent::insert(); + } + + public function update($dataObject=false) + { + $this->onUpdate($dataObject); + return parent::update($dataObject); + } }