/**
* @see ValueFormatter::format
*
* @param string $conceptUri
*
* @throws InvalidArgumentException
* @return string|null Null if the concept URI refers to a unitless unit. Otherwise a label or
* an entity ID or the original concept URI.
*/
public function format($conceptUri)
{
if (!is_string($conceptUri)) {
throw new InvalidArgumentException('$conceptUri must be a string');
}
if (array_key_exists($conceptUri, $this->unitlessUnitIds)) {
return null;
}
try {
$entityId = $this->externalEntityIdParser->parse($conceptUri);
try {
// TODO: Ideally we would show unit *symbols*, taking from a config file,
// a system message, or a statement on the unit's item.
$term = $this->labelLookup->getLabel($entityId);
} catch (LabelDescriptionLookupException $ex) {
$term = null;
}
if ($term !== null) {
return $term->getText();
} else {
// Fall back to the entity ID.
return $entityId->getSerialization();
}
} catch (EntityIdParsingException $ex) {
// Fall back to the raw concept URI.
return $conceptUri;
}
}
/**
* @see StringValueParser::stringParse
*
* @since 0.4
*
* @param string $value
*
* @throws ParseException
* @return EntityIdValue
*/
protected function stringParse($value)
{
try {
return new EntityIdValue($this->parser->parse($value));
} catch (EntityIdParsingException $ex) {
throw new ParseException($ex->getMessage(), $value, self::FORMAT_NAME);
}
}
/**
* Parses the given string into an EntityId by first stripping a fixed prefix.
* If the string does not start with the expected prefix, an EntityIdParsingException
* is thrown.
*
* @param string $idSerialization An entity ID with some prefix attached, e.g. an entity URI.
*
* @throws EntityIdParsingException If the string does not start with the expected prefix,
* or the remaining suffix is not a valid entity ID string.
* @return EntityId
*/
public function parse($idSerialization)
{
$prefixLength = strlen($this->prefix);
if (strncmp($idSerialization, $this->prefix, $prefixLength) !== 0) {
throw new EntityIdParsingException('Missing expected prefix "' . $this->prefix . '" in "' . $idSerialization . '"');
}
$idSerialization = substr($idSerialization, $prefixLength);
return $this->idParser->parse($idSerialization);
}
/**
* @see Deserializer::deserialize
*
* @param string $serialization
*
* @throws DeserializationException
* @return EntityId
*/
public function deserialize($serialization)
{
$this->assertEntityIdIsString($serialization);
try {
return $this->entityIdParser->parse($serialization);
} catch (EntityIdParsingException $e) {
throw new DeserializationException("'{$serialization}' is not a valid entity ID", $e);
}
}
private function parseResult(array $result, $search)
{
$search = $this->cleanLabel($search);
$results = $this->filterResults($result['search'], $search);
$entityIds = array();
foreach ($results as $entry) {
$entityIds[] = $this->entityIdParser->parse($entry['id']);
}
return $entityIds;
}
/**
* @param string $name
*
* @return EntityId|null
* @throws UserInputException
*/
private function getEntityIdParam($name)
{
$rawId = $this->getTextParam($name);
if ($rawId === '') {
return null;
}
try {
return $this->idParser->parse($rawId);
} catch (EntityIdParsingException $ex) {
throw new UserInputException('wikibase-wikibaserepopage-invalid-id', array($rawId), 'Entity id is not valid');
}
}
private function propertyMatchesFilter(EntityId $propertyId)
{
if (isset($this->requestParams['property'])) {
try {
$parsedProperty = $this->idParser->parse($this->requestParams['property']);
} catch (EntityIdParsingException $e) {
$this->errorReporter->dieException($e, 'param-invalid');
}
/** @var EntityId $parsedProperty */
return $propertyId->equals($parsedProperty);
}
return true;
}
/**
* @see ApiBase::execute()
*/
public function execute()
{
$params = $this->extractRequestParams();
$bot = $this->getUser()->isAllowed('bot') && $params['bot'];
try {
$fromId = $this->idParser->parse($params['from']);
$toId = $this->idParser->parse($params['to']);
$this->createRedirect($fromId, $toId, $bot, $this->getResult());
} catch (EntityIdParsingException $ex) {
$this->errorReporter->dieException($ex, 'invalid-entity-id');
} catch (RedirectCreationException $ex) {
$this->handleRedirectCreationException($ex);
}
}
/**
* @since 0.4
*
* @param Title $title
* @param string $action
* @param bool $hasLangLinks
* @param string[]|null $noExternalLangLinks
* @param string|null $prefixedId
*
* @return string|null HTML or null for no link
*/
public function getLink(Title $title, $action, $hasLangLinks, array $noExternalLangLinks = null, $prefixedId)
{
if ($this->canHaveLink($title, $action, $noExternalLangLinks)) {
$entityId = null;
if (is_string($prefixedId)) {
$entityId = $this->entityIdParser->parse($prefixedId);
}
if ($entityId && $hasLangLinks) {
return $this->getEditLinksLink($entityId);
}
return $this->getAddLinksLink($title, $entityId);
}
return null;
}
/**
* @see EntityIdLookup::getEntityIds
*
* @param Title[] $titles
*
* @return EntityId[]
*/
public function getEntityIds(array $titles)
{
$db = $this->loadBalancer->getConnection(DB_SLAVE);
$pageIds = array_map(function (Title $title) {
return $title->getArticleID();
}, $titles);
$res = $db->select('page_props', array('pp_page', 'pp_value'), array('pp_page' => $pageIds, 'pp_propname' => 'wikibase_item'), __METHOD__);
$entityIds = array();
foreach ($res as $row) {
$entityIds[$row->pp_page] = $this->idParser->parse($row->pp_value);
}
$this->loadBalancer->reuseConnection($db);
return $entityIds;
}
/**
* @param string $serialization
*
* @return StatementGuid
* @throws StatementGuidParsingException
*/
public function parse($serialization)
{
if (!is_string($serialization)) {
throw new StatementGuidParsingException('$serialization must be a string; got ' . gettype($serialization));
}
$keyParts = explode(StatementGuid::SEPARATOR, $serialization);
if (count($keyParts) !== 2) {
throw new StatementGuidParsingException('$serialization does not have the correct number of parts');
}
try {
return new StatementGuid($this->entityIdParser->parse($keyParts[0]), $keyParts[1]);
} catch (EntityIdParsingException $ex) {
throw new StatementGuidParsingException('$serialization contains invalid EntityId: ' . $ex->getMessage());
}
}
/**
* @see ValueValidator::validate()
*
* @param string $value The value to validate
*
* @return Result
*/
public function validate($value)
{
$result = Result::newSuccess();
try {
$entityId = $this->idParser->parse($value);
if ($this->forbiddenTypes === null || in_array($entityId->getEntityType(), $this->forbiddenTypes)) {
// The label looks like a valid ID - we don't like that!
$error = Error::newError('Looks like an Entity ID: ' . $value, null, $this->errorCode, array($value));
$result = Result::newError(array($error));
}
} catch (EntityIdParsingException $parseException) {
// All fine, the parsing did not work, so there is no entity id :)
}
return $result;
}
/**
* @see ApiBase::execute
*
* @since 0.3
*/
public function execute()
{
$params = $this->extractRequestParams();
$this->validateParameters($params);
list($idString, $guid) = $this->getIdentifiers($params);
try {
$entityId = $this->idParser->parse($idString);
} catch (EntityIdParsingException $e) {
$this->errorReporter->dieException($e, 'param-invalid');
}
/** @var EntityId $entityId */
$entityRevision = $this->entityLoadingHelper->loadEntityRevision($entityId, EntityRevisionLookup::LATEST_FROM_SLAVE);
$entity = $entityRevision->getEntity();
$statements = $this->getStatements($entity, $guid);
$this->resultBuilder->addStatements($statements, null, $params['props']);
}
/**
* Gets an EntityId object from a string (with error handling)
*
* @param string $entityId
*
* @return EntityId
* @throws InvalidArgumentException
*/
private function getEntityIdFromString($entityId)
{
if (!is_string($entityId)) {
throw new InvalidArgumentException('The first argument must be an entity ID encoded as a string');
}
return $this->entityIdParser->parse($entityId);
}
/**
* @dataProvider provideGetCacheableUrls
*/
public function testGetCacheableUrls($id, $expected)
{
$id = $this->idParser->parse($id);
$uriManager = $this->makeUriManager();
$actual = $uriManager->getCacheableUrls($id);
$this->assertEquals($expected, $actual);
}
/**
* @param string $name
*
* @return ItemId|null
* @throws UserInputException
*/
private function getItemIdParam($name)
{
$rawId = $this->getTextParam($name);
if ($rawId === '') {
return null;
}
try {
$id = $this->idParser->parse($rawId);
if (!$id instanceof ItemId) {
throw new UserInputException('wikibase-itemmerge-not-item', array($name), 'Id does not refer to an item: ' . $name);
}
return $id;
} catch (EntityIdParsingException $ex) {
throw new UserInputException('wikibase-wikibaserepopage-invalid-id', array($rawId), 'Entity id is not valid');
}
}
/**
* @param array $document
* @return EntityId
* @throws EntityIdParsingException
*/
public function buildEntityIdForDocument(array $document)
{
if (!array_key_exists('_id', $document)) {
throw new EntityIdParsingException();
}
return $this->entityIdParser->parse($document['_id']);
}
/**
* @param OutputPage $out
*
* @return EntityId|null
*/
public function getEntityIdFromOutputPage(OutputPage $out)
{
if (!$this->entityContentFactory->isEntityContentModel($out->getTitle()->getContentModel())) {
return null;
}
$jsConfigVars = $out->getJsConfigVars();
if (array_key_exists('wbEntityId', $jsConfigVars)) {
$idString = $jsConfigVars['wbEntityId'];
try {
return $this->entityIdParser->parse($idString);
} catch (EntityIdParsingException $ex) {
wfLogWarning('Failed to parse EntityId config var: ' . $idString);
}
}
return null;
}
private function formatIfEntityId($value)
{
try {
return $this->idFormatter->formatEntityId($this->idParser->parse($value));
} catch (EntityIdParsingException $ex) {
return $value;
}
}
/**
* @param string $uri
*/
private function processUri($uri)
{
try {
$entityId = $this->externalEntityIdParser->parse($uri);
$this->entityIds[$entityId->getSerialization()] = $entityId;
} catch (EntityIdParsingException $ex) {
// noop
}
}
/**
* Validate the statement guid prefix is a valid entity id
*
* @since 0.4
*
* @param string $prefixedId
*
* @return boolean
*/
protected function validateStatementGuidPrefix($prefixedId)
{
try {
$this->entityIdParser->parse($prefixedId);
return true;
} catch (EntityIdParsingException $ex) {
return false;
}
}
/**
* @param string $idString
*
* @return EntityId|null
*/
private function tryParseId($idString)
{
try {
return $this->entityIdParser->parse($idString);
} catch (EntityIdParsingException $e) {
wfDebugLog(__CLASS__, 'Invalid entity id ' . $idString);
}
return null;
}
/**
* Parses an entity id string coming from the user
*
* @param string $entityIdParam
*
* @throws UsageException
* @return EntityId
* @todo this could go into an EntityModificationHelper or even in a ApiWikibaseHelper
*/
public function getEntityIdFromString($entityIdParam)
{
try {
$entityId = $this->entityIdParser->parse($entityIdParam);
} catch (EntityIdParsingException $ex) {
$this->errorReporter->dieException($ex, 'invalid-entity-id');
}
/** @var EntityId $entityId */
return $entityId;
}
/**
* @param array $data
* @param EntityId|string|null $id
*
* @return object
*/
public function unserializeEntity(array $data, $id = null)
{
if ($id !== null) {
if (is_string($id)) {
$id = $this->idParser->parse($id);
}
$data['id'] = $id->getSerialization();
$data['type'] = $id->getEntityType();
}
$entity = $this->deserializer->deserialize($data);
return $entity;
}
/**
* @param array $data
* @param EntityId|null $entityId
*/
private function checkEntityId(array $data, EntityId $entityId = null)
{
if (isset($data['id'])) {
if (!$entityId) {
$this->errorReporter->dieError('Illegal field used in call: "id", must not be given when creating a new entity', 'param-illegal');
}
$dataId = $this->idParser->parse($data['id']);
if (!$entityId->equals($dataId)) {
$this->errorReporter->dieError('Invalid field used in call: "id", must match id parameter', 'param-invalid');
}
}
}
/**
* Gets exact match for the search term as an EntityId if it can be found.
*
* @param string $term
* @param string $entityType
*
* @return EntityId|null
*/
private function getExactMatchForEntityId($term, $entityType)
{
try {
$entityId = $this->idParser->parse($term);
$title = $this->titleLookup->getTitleForId($entityId);
if ($title && $title->exists() && $entityId->getEntityType() === $entityType) {
return $entityId;
}
} catch (EntityIdParsingException $ex) {
// never mind, doesn't look like an ID.
}
return null;
}
/**
* @param ResultWrapper $res
*
* @return EntityId[] An associative array mapping page IDs to Entity IDs.
*/
private function slurpEntityIds(ResultWrapper $res)
{
$entityPerPage = array();
foreach ($res as $row) {
try {
$entityId = $this->idParser->parse($row->pp_value);
$entityPerPage[$row->pp_page] = $entityId;
} catch (Exception $ex) {
$this->exceptionHandler->handleException($ex, 'badEntityId', __METHOD__ . ': ' . 'Failed to parse entity ID: ' . $row->pp_value . ' at page ' . $row->pp_page);
}
}
return $entityPerPage;
}
/**
* Gets the entity and increments the expensive parser function count.
*
* @param Parser $parser
* @param string $entityIdString
*
* @return EntityId|null
*/
private function getEntityIdFromString(Parser $parser, $entityIdString)
{
try {
$entityId = $this->entityIdParser->parse($entityIdString);
} catch (EntityIdParsingException $ex) {
// Just ignore this
return null;
}
// Getting a foreign item is expensive (unless we already loaded it and it's cached)
if (!$this->restrictedEntityLookup->entityHasBeenAccessed($entityId)) {
$parser->incrementExpensiveFunctionCount();
}
return $entityId;
}
/**
* @param array $params
* @return EntityId[]
*/
private function getEntityIdsFromIdParam($params)
{
$ids = array();
if (isset($params['ids'])) {
foreach ($params['ids'] as $id) {
try {
$ids[] = $this->idParser->parse($id);
} catch (EntityIdParsingException $e) {
$this->errorReporter->dieError("Invalid id: {$id}", 'no-such-entity', 0, array('id' => $id));
}
}
}
return $ids;
}
/**
* Main method for handling requests.
*
* @since 0.4
*
* @param string $doc Document name, e.g. Q5 or Q5.json or Q5:33.xml
* @param WebRequest $request The request parameters. Known parameters are:
* - id: the entity ID
* - format: the format
* - oldid|revision: the revision ID
* - action=purge: to purge cached data from (web) caches
* @param OutputPage $output
*
* @note: Instead of an output page, a WebResponse could be sufficient, but
* redirect logic is currently implemented in OutputPage.
*
* @throws HttpError
*/
public function handleRequest($doc, WebRequest $request, OutputPage $output)
{
$revision = 0;
list($id, $format) = $this->uriManager->parseDocName($doc);
// get entity id and format from request parameter
$format = $request->getText('format', $format);
$id = $request->getText('id', $id);
$revision = $request->getInt('oldid', $revision);
$revision = $request->getInt('revision', $revision);
//TODO: malformed revision IDs should trigger a code 400
// If there is no ID, fail
if ($id === null || $id === '') {
//TODO: different error message?
throw new HttpError(400, wfMessage('wikibase-entitydata-bad-id')->params($id));
}
try {
$entityId = $this->entityIdParser->parse($id);
} catch (EntityIdParsingException $ex) {
throw new HttpError(400, wfMessage('wikibase-entitydata-bad-id')->params($id));
}
//XXX: allow for logged in users only?
if ($request->getText('action') === 'purge') {
$this->purgeWebCache($entityId);
//XXX: Now what? Proceed to show the data?
}
if ($format === null || $format === '') {
// if no format is given, apply content negotiation and return.
$this->httpContentNegotiation($request, $output, $entityId, $revision);
return;
}
//NOTE: will trigger a 415 if the format is not supported
$format = $this->getCanonicalFormat($format);
if ($doc !== null && $doc !== '') {
// if subpage syntax is used, always enforce the canonical form
$canonicalDoc = $this->uriManager->getDocName($entityId, $format);
if ($doc !== $canonicalDoc) {
$url = $this->uriManager->getDocUrl($entityId, $format, $revision);
$output->redirect($url, 301);
return;
}
}
// if the format is HTML, redirect to the entity's wiki page
if ($format === 'html') {
$url = $this->uriManager->getDocUrl($entityId, 'html', $revision);
$output->redirect($url, 303);
return;
}
$this->showData($request, $output, $format, $entityId, $revision);
}