/** * @see SpecialSetEntity::setValue() * * @since 0.4 * * @param Entity $entity * @param string $languageCode * @param string $value * * @return Summary */ protected function setValue($entity, $languageCode, $value) { $summary = new Summary('wbsetaliases'); if ($value === '') { $aliases = $entity->getFingerprint()->getAliasGroup($languageCode)->getAliases(); $changeOp = $this->termChangeOpFactory->newRemoveAliasesOp($languageCode, $aliases); } else { $changeOp = $this->termChangeOpFactory->newSetAliasesOp($languageCode, explode('|', $value)); } $this->applyChangeOp($changeOp, $entity, $summary); return $summary; }
/** * @param Entity $entity * * @return array */ public function build(Entity $entity) { $entityId = $entity->getId(); if (!$entityId) { $entityId = ''; //XXX: should probably throw an exception } else { $entityId = $entityId->getSerialization(); } $configVars = array('wbEntityId' => $entityId, 'wbEntity' => FormatJson::encode($this->getSerializedEntity($entity))); return $configVars; }
/** * @see ChangeOp::apply() * - a new claim with $snak as mainsnak gets added when $claimGuid is empty and $snak is set * - the claim's mainsnak gets set to $snak when $claimGuid and $snak are set */ public function apply(Entity $entity, Summary $summary = null) { if (!$entity instanceof StatementListHolder) { throw new InvalidArgumentException('$entity must be a StatementListHolder'); } $statements = $entity->getStatements(); if (empty($this->statementGuid)) { $this->addStatement($statements, $entity->getId(), $summary); } else { $this->setStatement($statements, $summary); } $entity->setStatements($statements); }
/** * @see ChangeOp::apply * * @param Entity $entity * @param Summary|null $summary * * @throws InvalidArgumentException * @throws ChangeOpException */ public function apply(Entity $entity, Summary $summary = null) { if (!$entity instanceof StatementListHolder) { throw new InvalidArgumentException('$entity must be a StatementListHolder'); } $statements = $entity->getStatements(); $statement = $statements->getFirstStatementWithGuid($this->guid); if ($statement === null) { throw new ChangeOpException("Entity does not have statement with GUID {$this->guid}"); } $statements->removeStatementsWithGuid($this->guid); $entity->setStatements($statements); $removedSnak = $statement->getMainSnak(); $this->updateSummary($summary, 'remove', '', $this->getSummaryArgs($removedSnak)); }
/** * @see ChangeOp::apply() */ public function apply(Entity $entity, Summary $summary = null) { if (!$entity instanceof StatementListHolder) { throw new InvalidArgumentException('$entity must be a StatementListHolder'); } $statements = $entity->getStatements(); $statement = $statements->getFirstStatementWithGuid($this->statementGuid); if ($statement === null) { throw new ChangeOpException("Entity does not have a statement with GUID {$this->statementGuid}"); } $qualifiers = $statement->getQualifiers(); $this->removeQualifier($qualifiers, $summary); $statement->setQualifiers($qualifiers); $entity->setStatements($statements); }
/** * Watches or unwatches the entity. * * @note Keep in sync with logic in EditPage! * @todo: move to separate service * * @param bool $watch whether to watch or unwatch the page. * * @throws MWException */ private function updateWatchlist($watch) { if ($this->getTitle() === null) { throw new MWException('Title not yet known!'); } $this->entityStore->updateWatchlist($this->user, $this->newEntity->getId(), $watch); }
public function importStatements(Entity $entity) { $statements = $entity->getStatements(); $this->logger->info('Adding statements: ' . $entity->getId()->getSerialization()); if (!$statements->isEmpty()) { $localId = $this->entityMappingStore->getLocalId($entity->getId()->getSerialization()); if (!$localId) { $this->logger->error($entity->getId()->getSerialization() . ' not found'); } try { $this->addStatementList($this->idParser->parse($localId), $statements); } catch (\Exception $ex) { $this->logger->error($ex->getMessage()); } } }
/** * @see ChangeOp::apply() */ public function apply(Entity $entity, Summary $summary = null) { if (!$entity instanceof StatementListHolder) { throw new InvalidArgumentException('$entity must be a StatementListHolder'); } $statements = $entity->getStatements(); $statement = $statements->getFirstStatementWithGuid($this->statementGuid); if ($statement === null) { throw new ChangeOpException("Entity does not have claim with GUID {$this->statementGuid}"); } $references = $statement->getReferences(); $this->removeReference($references, $summary); if ($summary !== null) { $summary->addAutoSummaryArgs($this->getSnakSummaryArgs($statement->getMainSnak())); } $statement->setReferences($references); $entity->setStatements($statements); }
/** * @see ChangeOp::apply() */ public function apply(Entity $entity, Summary $summary = null) { if (!$entity instanceof StatementListHolder) { throw new InvalidArgumentException('$entity must be a StatementListHolder'); } $statements = $entity->getStatements(); $statement = $statements->getFirstStatementWithGuid($this->statementGuid); if ($statement === null) { throw new ChangeOpException("Entity does not have a statement with GUID {$this->statementGuid}"); } $oldRank = $statement->getRank(); $statement->setRank($this->rank); $this->updateSummary($summary, null, '', $this->getSnakSummaryArgs($statement->getMainSnak())); if ($summary !== null) { $statementRankSerializer = new StatementRankSerializer(); $summary->addAutoCommentArgs(array($statementRankSerializer->serialize($oldRank), $statementRankSerializer->serialize($this->rank))); } $entity->setStatements($statements); }
/** * @param array $params * @param Statement $statement * @param Entity $entity * * @throws InvalidArgumentException * @return Summary * * @todo this summary builder is ugly and summary stuff needs to be refactored */ private function getSummary(array $params, Statement $statement, Entity $entity) { if (!$entity instanceof StatementListProvider) { throw new InvalidArgumentException('$entity must be a StatementListProvider'); } $claimSummaryBuilder = new ClaimSummaryBuilder($this->getModuleName(), new ClaimDiffer(new OrderedListDiffer(new ComparableComparer()))); $summary = $claimSummaryBuilder->buildClaimSummary($entity->getStatements()->getFirstStatementWithGuid($statement->getGuid()), $statement); if (isset($params['summary'])) { $summary->setUserSummary($params['summary']); } return $summary; }
/** * @dataProvider provideSaveEntityError */ public function testSaveEntityError(Entity $entity, $flags, $baseRevId, $error) { /** @var WikiPageEntityStore $store */ list($store, ) = $this->createStoreAndLookup(); $user = $GLOBALS['wgUser']; // setup target item $one = new Item(); $one->setLabel('en', 'one'); $r1 = $store->saveEntity($one, 'create one', $user, EDIT_NEW); // inject ids if (is_int($baseRevId)) { // use target item's revision as an offset $baseRevId += $r1->getRevisionId(); } if ($entity->getId() === null) { // use target item's id $entity->setId($r1->getEntity()->getId()); } // check for error $this->setExpectedException($error); $store->saveEntity($entity, '', $GLOBALS['wgUser'], $flags, $baseRevId); }
/** * @see ChangeOp::apply */ public function apply(Entity $entity, Summary $summary = null) { if (!$entity instanceof Item) { throw new InvalidArgumentException('ChangeOpSiteLink can only be applied to Item instances'); } $siteLinks = $entity->getSiteLinkList(); if ($this->pageName === null && $this->badges === null || $this->pageName === '') { if ($siteLinks->hasLinkWithSiteId($this->siteId)) { $this->updateSummary($summary, 'remove', $this->siteId, $siteLinks->getBySiteId($this->siteId)->getPageName()); $siteLinks->removeLinkWithSiteId($this->siteId); } else { //TODO: throw error, or ignore silently? } } else { $commentArgs = array(); if ($this->pageName === null) { if (!$siteLinks->hasLinkWithSiteId($this->siteId)) { throw new InvalidArgumentException('The sitelink does not exist'); } // If page name is not set (but badges are) make sure that it remains intact $pageName = $siteLinks->getBySiteId($this->siteId)->getPageName(); } else { $pageName = $this->pageName; $commentArgs[] = $pageName; } $action = $siteLinks->hasLinkWithSiteId($this->siteId) ? 'set' : 'add'; $badges = $this->applyBadges($siteLinks, $action, $commentArgs); $this->updateSummary($summary, $action, $this->siteId, $commentArgs); // FIXME: Use SiteLinkList::setNewSiteLink. $siteLinks->removeLinkWithSiteId($this->siteId); $siteLinks->addNewSiteLink($this->siteId, $pageName, $badges); } }
/** * @param Entity $entity * @param Summary|null $summary * * @throws InvalidArgumentException */ private function applyClaimToEntity(Entity $entity, Summary $summary = null) { if (!$entity instanceof StatementListHolder) { throw new InvalidArgumentException('$entity must be a StatementListHolder'); } $statements = $this->removeStatement($entity->getStatements()->toArray(), $summary); $statements = $this->addStatement($statements); $entity->setStatements(new StatementList($statements)); }
private function getReferencedEntities(Entity $entity) { $snaks = $entity->getStatements()->getAllSnaks(); $entities = array(); foreach ($snaks as $snak) { $entities[] = $snak->getPropertyId()->getSerialization(); if ($snak instanceof PropertyValueSnak) { $value = $snak->getDataValue(); if ($value instanceof EntityIdValue) { $entities[] = $value->getEntityId()->getSerialization(); } } } return array_unique($entities); }
public function detectLabelDescriptionConflictsForEntity(Entity $entity) { foreach ($entity->getFingerprint()->getLabels()->toTextArray() as $lang => $label) { if (!$entity->getFingerprint()->hasDescription($lang)) { continue; } $description = $entity->getFingerprint()->getDescription($lang)->getText(); if ($label === 'DUPE' && $description === 'DUPE') { return Result::newError(array(Error::newError('found conflicting terms', 'label', 'label-with-description-conflict', array('label', $lang, $label, 'Q666')))); } } return Result::newSuccess(); }
/** * Validates this ChangeOp * * @see ChangeOp::validate() * * @since 0.5 * * @param Entity $entity * * @throws ChangeOpException * @return Result */ public function validate(Entity $entity) { $languageValidator = $this->termValidatorFactory->getLanguageValidator(); $termValidator = $this->termValidatorFactory->getLabelValidator($entity->getType()); // check that the language is valid $result = $languageValidator->validate($this->languageCode); if (!$result->isValid()) { return $result; } // It should be possible to remove invalid aliases, but not to add/set new invalid ones if ($this->action === 'set' || $this->action === '' || $this->action === 'add') { // Check that the new aliases are valid foreach ($this->aliases as $alias) { $result = $termValidator->validate($alias); if (!$result->isValid()) { return $result; } } } elseif ($this->action !== 'remove') { throw new ChangeOpException('Bad action: ' . $this->action); } //XXX: Do we want to check the updated fingerprint, as we do for labels and descriptions? return $result; }
/** * Prepares the given entity data for comparison with $entity. * That is, this method should add any extra data from $entity to $entityData. * * @param Entity $entity * @param array $entityData */ protected function prepareEntityData(Entity $entity, array &$entityData) { /* @var Property $entity */ $entityData['datatype'] = $entity->getDataTypeId(); }
/** * Validates this ChangeOp * * @see ChangeOp::validate() * * @since 0.5 * * @param Entity $entity * * @return Result */ public function validate(Entity $entity) { $languageValidator = $this->termValidatorFactory->getLanguageValidator(); $termValidator = $this->termValidatorFactory->getLabelValidator($entity->getType()); $fingerprintValidator = $this->termValidatorFactory->getFingerprintValidator($entity->getType()); // check that the language is valid $result = $languageValidator->validate($this->languageCode); if ($result->isValid() && $this->label !== null) { // Check that the new label is valid $result = $termValidator->validate($this->label); } if (!$result->isValid()) { return $result; } // Check if the new fingerprint of the entity is valid (e.g. if the label is unique) $fingerprint = unserialize(serialize($entity->getFingerprint())); $this->updateFingerprint($fingerprint); $result = $fingerprintValidator->validateFingerprint($fingerprint, $entity->getId(), array($this->languageCode)); return $result; }
/** * @see SpecialModifyEntity::modifyEntity * * @param Entity $entity * * @return Summary|bool */ protected function modifyEntity(Entity $entity) { $changeOps = $this->getChangeOps($entity->getFingerprint()); $summary = false; $success = true; foreach ($changeOps as $module => $changeOp) { $summary = new Summary($module); try { $this->applyChangeOp($changeOp, $entity, $summary); } catch (ChangeOpException $ex) { $this->showErrorHTML($ex->getMessage()); $success = false; } } if (!$success) { return false; } elseif (count($changeOps) === 1) { return $summary; } return $this->getSummaryForLabelDescriptionAliases(); }
public function doTestValidRequest(Entity $entity, $guid, $value, $expectedSummary) { $wikibaseRepo = WikibaseRepo::getDefaultInstance(); $entityLookup = $wikibaseRepo->getEntityLookup(); $obtainedEntity = $entityLookup->getEntity($entity->getId()); $claimCount = count($obtainedEntity->getClaims()); $params = array('action' => 'wbsetclaimvalue', 'claim' => $guid, 'value' => FormatJson::encode($value), 'snaktype' => 'value'); list($resultArray, ) = $this->doApiRequestWithToken($params); $this->assertResultSuccess($resultArray); $this->assertInternalType('array', $resultArray, 'top level element is an array'); $this->assertArrayHasKey('claim', $resultArray, 'top level element has a claim key'); $claim = $resultArray['claim']; $this->assertEquals($value, $claim['mainsnak']['datavalue']['value']); /** @var StatementListProvider $obtainedEntity */ $obtainedEntity = $entityLookup->getEntity($entity->getId()); $page = new WikiPage($wikibaseRepo->getEntityTitleLookup()->getTitleForId($entity->getId())); $generatedSummary = $page->getRevision()->getComment(Revision::RAW); $this->assertEquals($expectedSummary, $generatedSummary, 'Summary mismatch'); $statements = $obtainedEntity->getStatements(); $this->assertEquals($claimCount, $statements->count(), 'Claim count should not change after doing a setclaimvalue request'); $obtainedClaim = $statements->getFirstStatementWithGuid($guid); $this->assertNotNull($obtainedClaim); $dataValue = $wikibaseRepo->getDataValueFactory()->newFromArray($claim['mainsnak']['datavalue']); $this->assertTrue($obtainedClaim->getMainSnak()->getDataValue()->equals($dataValue)); }
/** * @param Entity $entity */ private function buildResult(Entity $entity) { $builder = $this->getResultBuilder(); if ($entity instanceof FingerprintProvider) { $fingerprint = $entity->getFingerprint(); $builder->addLabels($fingerprint->getLabels(), 'entity'); $builder->addDescriptions($fingerprint->getDescriptions(), 'entity'); $builder->addAliasGroupList($fingerprint->getAliasGroups(), 'entity'); } if ($entity instanceof Item) { $builder->addSiteLinkList($entity->getSiteLinkList(), 'entity'); } $builder->addStatements($entity->getClaims(), 'entity'); }
/** * Returns the form elements. * * @since 0.5 * * @param Entity $entity * * @return string HTML */ protected function getFormElements(Entity $entity = null) { $id = 'wb-modifyentity-id'; return Html::label($this->msg('wikibase-modifyentity-id')->text(), $id, array('class' => 'wb-label')) . Html::input('id', $entity === null ? '' : $entity->getId(), 'text', array('class' => 'wb-input', 'id' => $id)); }
/** * Attempt to modify entity * * @since 0.1 * * @param Entity &$entity * * @return Status */ protected function modifyEntity(Entity &$entity) { $contentLanguageCode = $this->contentLanguage->getCode(); if ($this->label !== '') { $entity->setLabel($contentLanguageCode, $this->label); } if ($this->description !== '') { $entity->setDescription($contentLanguageCode, $this->description); } if (count($this->aliases) !== 0) { $entity->setAliases($contentLanguageCode, $this->aliases); } return Status::newGood(); }
protected function addToOutput(Entity $entity, Status $status, $oldRevId = null) { $this->getResultBuilder()->addBasicEntityInformation($entity->getId(), 'entity'); $this->getResultBuilder()->addRevisionIdFromStatusToResult($status, 'entity', $oldRevId); $params = $this->extractRequestParams(); if (isset($params['site']) && isset($params['title'])) { $normTitle = $this->stringNormalizer->trimToNFC($params['title']); if ($normTitle !== $params['title']) { $this->getResultBuilder()->addNormalizedTitle($params['title'], $normTitle, 'normalized'); } } $this->getResultBuilder()->markSuccess(1); }
/** * @param Entity $entity * @param Snak $mainSnak * * @return Statement */ private function makeStatement(Entity $entity, Snak $mainSnak) { $statement = new Statement($mainSnak); $guidGenerator = new GuidGenerator(); $statement->setGuid($guidGenerator->newGuid($entity->getId())); return $statement; }
private function assertHasNoTerms(Entity $entity) { $this->assertEquals(array(), $entity->getLabels()); $this->assertEquals(array(), $entity->getDescriptions()); $this->assertEquals(array(), $entity->getAllAliases()); }