private function getSerialized(AbstractQuery $query)
{
if ($query instanceof CollectionQuery) {
return '(' . implode(' ' . $query->getType() . ' ', $this->serializeQueries($query->getSubQueries())) . ')';
}
return $this->commandsSerializer->serialize($query);
}
/**
* @since 0.2
*
* @param Reference $reference new reference value
* @param Statement|StatementGuid|string $statement Statement object or GUID which has the reference
* @param Reference|string $targetReference target (old) reference of hash
* @param EditInfo|null $editInfo
*
* @return bool
* @throws UnexpectedValueException
*/
public function set(Reference $reference, $statement, $targetReference = null, EditInfo $editInfo = null)
{
if (is_string($statement)) {
$guid = $statement;
} else {
if ($statement instanceof StatementGuid) {
$guid = $statement->getSerialization();
} else {
if ($statement instanceof Statement) {
$guid = $statement->getGuid();
} else {
throw new UnexpectedValueException('Could not get statement guid from $target');
}
}
}
if (!is_string($guid)) {
throw new UnexpectedValueException('Unexpected statement guid got from $target');
}
$referenceSerialization = $this->referenceSerializer->serialize($reference);
$params = array('statement' => $guid, 'snaks' => json_encode($referenceSerialization['snaks']), 'snaks-order' => json_encode($referenceSerialization['snaks-order']));
if (!is_null($targetReference)) {
if ($targetReference instanceof Reference) {
$targetReference = $reference->getHash();
}
if (!is_string($targetReference)) {
throw new UnexpectedValueException('Could not get reference hash from $targetReference');
}
$params['reference'] = $targetReference;
}
$this->api->postRequest('wbsetreference', $params, $editInfo);
return true;
}
private function getDataSection()
{
$data = [];
foreach ($this->item->statements as $simpleStatement) {
$data[$simpleStatement->propertyName] = $this->statementSerializer->serialize($simpleStatement);
}
return $data;
}
private function getSerialized(ReferenceList $references)
{
$serialization = array();
foreach ($references as $reference) {
$serialization[] = $this->referenceSerializer->serialize($reference);
}
return $serialization;
}
private function getSerialized(MediaInfo $mediaInfo)
{
$serialization = array('type' => $mediaInfo->getType(), 'labels' => $this->termListSerializer->serialize($mediaInfo->getLabels()), 'descriptions' => $this->termListSerializer->serialize($mediaInfo->getDescriptions()), 'statements' => $this->statementListSerializer->serialize($mediaInfo->getStatements()));
$id = $mediaInfo->getId();
if ($id !== null) {
$serialization['id'] = $id->getSerialization();
}
return $serialization;
}
/**
* @since 0.2
*
* @param DataValue $value
* @param string $dataTypeId
* @param GenericOptions $options
*
* @returns string
*/
public function format(DataValue $value, $dataTypeId, GenericOptions $options = null)
{
if ($options === null) {
$options = new GenericOptions();
}
$params = array('datavalue' => json_encode($this->dataValueSerializer->serialize($value)), 'datatype' => $dataTypeId, 'options' => json_encode($options->getOptions()));
$result = $this->api->getRequest(new SimpleRequest('wbformatvalue', $params));
return $result['result'];
}
/**
* @since 0.5
*
* @param Statement $statement
* @param EditInfo|null $editInfo
*
* @throws InvalidArgumentException
* @return bool
*
* @todo allow setting of indexes
*/
public function set(Statement $statement, EditInfo $editInfo = null)
{
if ($statement->getGuid() === null) {
throw new InvalidArgumentException('Can not set a statement that does not have a GUID');
}
$params = array('claim' => $this->statementSerializer->serialize($statement));
$this->api->postRequest('wbsetclaim', $params, $editInfo);
return true;
}
/**
* @param AliasGroupList $aliasGroupList
*
* @return array
*/
private function getSerialized(AliasGroupList $aliasGroupList)
{
$serialization = array();
foreach ($aliasGroupList->getIterator() as $aliasGroup) {
$serialization[$aliasGroup->getLanguageCode()] = $this->aliasGroupSerializer->serialize($aliasGroup);
}
if ($this->useObjectsForMaps) {
$serialization = (object) $serialization;
}
return $serialization;
}
private function getDataSection()
{
$data = [];
foreach ($this->item->statements as $simpleStatement) {
$propertyId = $simpleStatement->propertyId->getSerialization();
if (array_key_exists($propertyId, $this->propertyMap)) {
$data[$this->propertyMap[$propertyId]] = $this->statementSerializer->serialize($simpleStatement);
}
}
return $data;
}
private function getSerialized(Snak $snak)
{
$serialization = array('snaktype' => $snak->getType(), 'property' => $snak->getPropertyId()->getSerialization());
if ($this->serializeWithHash) {
$serialization['hash'] = $snak->getHash();
}
if ($snak instanceof PropertyValueSnak) {
$serialization['datavalue'] = $this->dataValueSerializer->serialize($snak->getDataValue());
}
return $serialization;
}
/**
* @param TermList $termList
*
* @return array
*/
private function getSerialized(TermList $termList)
{
$serialization = array();
foreach ($termList->getIterator() as $term) {
$serialization[$term->getLanguageCode()] = $this->termSerializer->serialize($term);
}
if ($this->useObjectsForMaps) {
$serialization = (object) $serialization;
}
return $serialization;
}
private function getSerialized(SnakList $snaks)
{
$serialization = array();
/**
* @var Snak $snak
*/
foreach ($snaks as $snak) {
$serialization[$snak->getPropertyId()->getSerialization()][] = $this->snakSerializer->serialize($snak);
}
if ($this->useObjectsForMaps) {
$serialization = (object) $serialization;
}
return $serialization;
}
private function getSerialized(StatementList $statementList)
{
$serialization = array();
foreach ($statementList->toArray() as $statement) {
$idSerialization = $statement->getPropertyId()->getSerialization();
if (!array_key_exists($idSerialization, $serialization)) {
$serialization[$idSerialization] = array();
}
$serialization[$idSerialization][] = $this->statementSerializer->serialize($statement);
}
if ($this->useObjectsForMaps) {
$serialization = (object) $serialization;
}
return $serialization;
}
/**
* Constructor
*
* @param string $input - YAML string
* @param array $config - possible configuration changes
*
* @returns Yaml
*
* @since 1.0
*/
public function __construct($input, array $config = array())
{
parent::__construct();
$config = array_merge($this->config, $config);
$this->config = new ArrayObject($config, ArrayObject::ARRAY_AS_PROPS);
$this->data = $input;
}
private function addQualifiersToSerialization(Statement $statement, &$serialization)
{
$qualifiers = $statement->getQualifiers();
if ($qualifiers->count() !== 0) {
$serialization['qualifiers'] = $this->qualifierSnaksSerializer->serialize($qualifiers);
$serialization['qualifiers-order'] = $this->buildQualifiersOrderList($qualifiers);
}
}
/**
* Constructor
*
* @param string $input - filename
*
* @returns Ini
*
* @since 1.0
*/
public function __construct($input)
{
parent::__construct();
$this->data = $input;
$this->parser = new \IniParser();
foreach ($this->config as $property => $value) {
$this->parser->{$property} = $value;
}
}
private function addSiteLinksToSerialization(Item $item, array &$serialization)
{
$serialization['sitelinks'] = array();
foreach ($item->getSiteLinkList()->toArray() as $siteLink) {
$serialization['sitelinks'][$siteLink->getSiteId()] = $this->siteLinkSerializer->serialize($siteLink);
}
if ($this->useObjectsForMaps) {
$serialization['sitelinks'] = (object) $serialization['sitelinks'];
}
}
/**
* @since 0.1
* @param Revision $revision
* @param EditInfo|null $editInfo
*
* @throws RuntimeException
* @throws InvalidArgumentException
* @returns Item|Property new version of the entity
*/
public function save(Revision $revision, EditInfo $editInfo = null)
{
if (!$revision->getContent()->getData() instanceof EntityDocument) {
throw new RuntimeException('Can only save Content of EntityDocuments');
}
/** @var Item|Property $entity */
$entity = $revision->getContent()->getData();
$serialized = $this->entitySerializer->serialize($entity);
$params = array('data' => json_encode($serialized));
$revId = $revision->getId();
if (!is_null($revId)) {
$params['baserevid'] = $revId;
}
$entityId = $entity->getId();
if (!is_null($entityId)) {
$params['id'] = $entityId->getSerialization();
// Always clear so that removing elements is possible
$params['clear'] = 'true';
// Add more detail to the default "Cleared an entity" summary
// Note: this is later overridden if a summary is provided in the EditInfo
$params['summary'] = 'Edited a ' . $entity->getType();
} else {
$params['new'] = $entity->getType();
}
// If no editInfo is explicitly passed call back to the one in the revision?
if ($editInfo === null) {
$editInfo = $revision->getEditInfo();
}
if ($editInfo->getBot()) {
$params['bot'] = true;
}
if ($editInfo->getMinor()) {
$params['minor'] = true;
}
$summary = $editInfo->getSummary();
if (!empty($summary)) {
$params['summary'] = $summary;
}
$result = $this->api->postRequest('wbeditentity', $params, $editInfo);
return $this->entityDeserializer->deserialize($result['entity']);
}
/**
* Encodes an Entity into a blob for storage.
*
* @see EntityHandler::serializeContent()
*
* @param EntityDocument $entity
* @param string|null $format The desired serialization format.
*
* @throws InvalidArgumentException If the format is not supported.
* @throws MWContentSerializationException
* @return string A blob representing the given Entity.
*/
public function encodeEntity(EntityDocument $entity, $format)
{
try {
$data = $this->entitySerializer->serialize($entity);
$blob = $this->encodeEntityContentData($data, $format);
if ($this->maxBlobSize > 0 && strlen($blob) > $this->maxBlobSize) {
throw new MWContentSerializationException('Content too big! Entity: ' . $entity->getId());
}
return $blob;
} catch (SerializationException $ex) {
MWExceptionHandler::logException($ex);
throw new MWContentSerializationException($ex->getMessage(), 0, $ex);
}
}
/**
* @param EntityId $entityId
*
* @throws EntityLookupException
* @throws StorageException
*
* @return string|null
*/
protected function generateDumpForEntityId(EntityId $entityId)
{
try {
$entity = $this->entityLookup->getEntity($entityId);
if (!$entity) {
throw new EntityLookupException($entityId, 'Entity not found: ' . $entityId->getSerialization());
}
} catch (MWContentSerializationException $ex) {
throw new StorageException('Deserialization error for ' . $entityId->getSerialization());
} catch (RevisionedUnresolvedRedirectException $e) {
// Redirects aren't supposed to be in the JSON dumps
return null;
}
$data = $this->entitySerializer->serialize($entity);
$data = $this->injectEntitySerializationWithDataTypes($data);
// HACK: replace empty arrays with objects at the first level of the array
foreach ($data as &$element) {
if (empty($element)) {
$element = new stdClass();
}
}
$json = $this->encode($data);
return $json;
}
/**
* @param Entity $entity
*
* @return array
*/
public function serializeEntity(Entity $entity)
{
$data = $this->serializer->serialize($entity);
return $data;
}
/**
* @param EntityDocument $entityDocument
* @return array
*/
public function buildDocumentForEntity(EntityDocument $entityDocument)
{
return $this->addIndexedDataToSerialization($this->filterLanguages($this->entitySerializer->serialize($entityDocument)));
}
private function serializeProperty() : array
{
return array_merge(['type' => $this->property->type], $this->entitySerializer->serialize($this->property));
}
private function assertSerializesWithoutException(Serializer $serializer, $object)
{
$serializer->serialize($object);
$this->assertTrue(true, 'No exception occurred during serialization');
}
/**
* Constructor
*
* @param array $input - structure to be encoded
*
* @returns Ini
*
* @since 1.0
*/
public function __construct(array $input)
{
parent::__construct();
$this->data = $input;
}
/**
* Constructor
*
* @param string $root - root element
* @param mixed $input - structure to be encoded
* @param array $config - additional configuration options
*
* @returns Xml
*
* @throws \InvalidArgumentException
*
* @since 1.0
*/
public function __construct($root, array $input, array $config = array())
{
if (!is_string($root) || empty($root)) {
throw new InvalidArgumentException('Root element must be a valid string.');
}
parent::__construct();
$this->root = $root;
$this->data = $input;
$config = array_merge($this->config, $config);
$this->config = new ArrayObject($config, ArrayObject::ARRAY_AS_PROPS);
}
private function addStatementListToSerialization(Property $property, array &$serialization)
{
$serialization['claims'] = $this->statementListSerializer->serialize($property->getStatements());
}
/**
* Constructor
*
* @param string $input - JSON string
* @param array $config - possible configuration changes
*
* @returns Xml
*
* @throws InvalidArgumentException
*
* @since 1.0
*/
public function __construct($input, array $config = array())
{
if (!is_string($input)) {
throw new InvalidArgumentException('XML serializer accepts only strings.');
}
parent::__construct();
$config = array_merge($this->config, $config);
$this->config = new ArrayObject($config, ArrayObject::ARRAY_AS_PROPS);
$this->data = $input;
}
protected function assertSerializerThatCanSerializeObject(Serializer $serializer, $object)
{
$this->assertTrue($serializer->isSerializerFor($object));
}
public function testWithUnsupportedObject()
{
$this->setExpectedException('Serializers\\Exceptions\\UnsupportedObjectException');
$this->serializer->serialize(new PropertyNoValueSnak(42));
}
