mirror of
https://github.com/alchemy-fr/Phraseanet.git
synced 2025-10-08 18:44:30 +00:00
1087 lines
26 KiB
PHP
1087 lines
26 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of Phraseanet
|
|
*
|
|
* (c) 2005-2014 Alchemy
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
use Alchemy\Phrasea\Application;
|
|
use Alchemy\Phrasea\Vocabulary;
|
|
use Alchemy\Phrasea\Vocabulary\ControlProvider\ControlProviderInterface;
|
|
use Alchemy\Phrasea\Metadata\Tag\Nosource;
|
|
use Doctrine\DBAL\Driver\Connection;
|
|
use PHPExiftool\Driver\TagInterface;
|
|
use PHPExiftool\Driver\TagFactory;
|
|
use PHPExiftool\Exception\TagUnknown;
|
|
use Alchemy\Phrasea\Exception\InvalidArgumentException;
|
|
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
|
|
|
|
class databox_field implements cache_cacheableInterface
|
|
{
|
|
/**
|
|
*
|
|
* @var <type>
|
|
*/
|
|
protected $id;
|
|
|
|
/**
|
|
*
|
|
* @var databox
|
|
*/
|
|
protected $databox;
|
|
|
|
/**
|
|
*
|
|
* @var \PHPExiftool\Driver\Tag
|
|
*/
|
|
protected $tag;
|
|
|
|
/**
|
|
*
|
|
* @var <type>
|
|
*/
|
|
protected $name;
|
|
|
|
/**
|
|
*
|
|
* @var <type>
|
|
*/
|
|
protected $indexable;
|
|
|
|
/**
|
|
*
|
|
* @var <type>
|
|
*/
|
|
protected $readonly;
|
|
|
|
/**
|
|
*
|
|
* @var <type>
|
|
*/
|
|
protected $position;
|
|
|
|
/**
|
|
*
|
|
* @var <type>
|
|
*/
|
|
protected $required;
|
|
|
|
/**
|
|
*
|
|
* @var <type>
|
|
*/
|
|
protected $multi;
|
|
|
|
/**
|
|
*
|
|
* @var <type>
|
|
*/
|
|
protected $report;
|
|
|
|
/**
|
|
*
|
|
* @var <type>
|
|
*/
|
|
protected $type;
|
|
|
|
/**
|
|
*
|
|
* @var <type>
|
|
*/
|
|
protected $tbranch;
|
|
|
|
/**
|
|
*
|
|
* @var <type>
|
|
*/
|
|
protected $separator;
|
|
|
|
/**
|
|
*
|
|
* @var <type>
|
|
*/
|
|
protected $thumbtitle;
|
|
|
|
/**
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $labels = [];
|
|
|
|
/**
|
|
*
|
|
* @var boolean
|
|
*/
|
|
protected $Business;
|
|
protected $renamed = false;
|
|
|
|
/**
|
|
*
|
|
*
|
|
* To implement : change multi
|
|
* Change vocab Id
|
|
*
|
|
*/
|
|
|
|
/**
|
|
*
|
|
* @var int
|
|
*/
|
|
protected $sbas_id;
|
|
protected static $_instance = [];
|
|
protected $dces_element;
|
|
protected $Vocabulary;
|
|
protected $VocabularyType;
|
|
protected $VocabularyRestriction = false;
|
|
protected $on_error = false;
|
|
protected $original_src;
|
|
|
|
const TYPE_TEXT = "text";
|
|
const TYPE_DATE = "date";
|
|
const TYPE_STRING = "string";
|
|
const TYPE_NUMBER = "number";
|
|
|
|
/**
|
|
* http://dublincore.org/documents/dces/
|
|
*/
|
|
const DCES_TITLE = 'Title';
|
|
const DCES_CREATOR = 'Creator';
|
|
const DCES_SUBJECT = 'Subject';
|
|
const DCES_DESCRIPTION = 'Description';
|
|
const DCES_PUBLISHER = 'Publisher';
|
|
const DCES_CONTRIBUTOR = 'Contributor';
|
|
const DCES_DATE = 'Date';
|
|
const DCES_TYPE = 'Type';
|
|
const DCES_FORMAT = 'Format';
|
|
const DCES_IDENTIFIER = 'Identifier';
|
|
const DCES_SOURCE = 'Source';
|
|
const DCES_LANGUAGE = 'Language';
|
|
const DCES_RELATION = 'Relation';
|
|
const DCES_COVERAGE = 'Coverage';
|
|
const DCES_RIGHTS = 'Rights';
|
|
|
|
/**
|
|
*
|
|
* @param databox $databox
|
|
* @param <type> $id
|
|
* @return databox_field
|
|
*/
|
|
protected function __construct(Application $app, databox $databox, $id)
|
|
{
|
|
$this->app = $app;
|
|
$this->set_databox($databox);
|
|
$this->sbas_id = $databox->get_sbas_id();
|
|
|
|
$connbas = $this->get_connection();
|
|
|
|
$sql = "SELECT `thumbtitle`, `separator`, `dces_element`, `tbranch`,
|
|
`type`, `report`, `multi`, `required`, `readonly`, `indexable`,
|
|
`name`, `src`, `business`, `VocabularyControlType`,
|
|
`RestrictToVocabularyControl`, `sorter`,
|
|
`label_en`, `label_fr`, `label_de`, `label_nl`
|
|
FROM metadatas_structure WHERE id=:id";
|
|
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':id' => $id]);
|
|
$row = $stmt->fetch(PDO::FETCH_ASSOC);
|
|
$stmt->closeCursor();
|
|
|
|
if (!$row) {
|
|
throw new NotFoundHttpException(sprintf('Unable to find field in %s', $id));
|
|
}
|
|
|
|
$this->id = (int) $id;
|
|
|
|
$this->original_src = $row['src'];
|
|
$this->tag = self::loadClassFromTagName($row['src'], false);
|
|
|
|
if ($row['src'] != $this->tag->getTagname()) {
|
|
$this->on_error = true;
|
|
}
|
|
|
|
foreach (['en', 'fr', 'de', 'nl'] as $code) {
|
|
$this->labels[$code] = $row['label_' . $code];
|
|
}
|
|
|
|
$this->name = $row['name'];
|
|
$this->indexable = (Boolean) $row['indexable'];
|
|
$this->readonly = (Boolean) $row['readonly'];
|
|
$this->required = (Boolean) $row['required'];
|
|
$this->multi = (Boolean) $row['multi'];
|
|
$this->Business = (Boolean) $row['business'];
|
|
$this->report = (Boolean) $row['report'];
|
|
$this->position = (Int) $row['sorter'];
|
|
$this->type = $row['type'] ? : self::TYPE_STRING;
|
|
$this->tbranch = $row['tbranch'];
|
|
$this->VocabularyType = $row['VocabularyControlType'];
|
|
$this->VocabularyRestriction = !!$row['RestrictToVocabularyControl'];
|
|
|
|
if ($row['dces_element']) {
|
|
$dc_class = 'databox_Field_DCES_' . $row['dces_element'];
|
|
$this->dces_element = new $dc_class();
|
|
}
|
|
|
|
$this->separator = self::checkMultiSeparator($row['separator'], $this->multi);
|
|
|
|
$this->thumbtitle = $row['thumbtitle'];
|
|
|
|
$this->loadVocabulary();
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return type \Alchemy\Phrasea\Vocabulary\ControlProvider\ControlProviderInterface
|
|
*/
|
|
public function getVocabularyControl()
|
|
{
|
|
return $this->Vocabulary;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isVocabularyRestricted()
|
|
{
|
|
return $this->VocabularyRestriction;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function isBusiness()
|
|
{
|
|
return $this->Business;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param Application $app
|
|
* @param \databox $databox
|
|
* @param int $id
|
|
*
|
|
* @return \databox_field
|
|
*/
|
|
public static function get_instance(Application $app, databox $databox, $id)
|
|
{
|
|
$cache_key = 'field_' . $id;
|
|
$instance_id = $databox->get_sbas_id() . '_' . $id;
|
|
if ( ! isset(self::$_instance[$instance_id]) || (self::$_instance[$instance_id] instanceof self) === false) {
|
|
try {
|
|
self::$_instance[$instance_id] = $databox->get_data_from_cache($cache_key);
|
|
} catch (\Exception $e) {
|
|
self::$_instance[$instance_id] = new self($app, $databox, $id);
|
|
$databox->set_data_to_cache(self::$_instance[$instance_id], $cache_key);
|
|
}
|
|
}
|
|
self::$_instance[$instance_id]->app = $app;
|
|
|
|
return self::$_instance[$instance_id];
|
|
}
|
|
|
|
public function hydrate(Application $app)
|
|
{
|
|
$this->app = $app;
|
|
$this->set_databox($this->app['phraseanet.appbox']->get_databox($this->sbas_id));
|
|
$this->loadVocabulary();
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param databox $databox
|
|
*/
|
|
public function set_databox(databox $databox)
|
|
{
|
|
$this->databox = $databox;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return Connection
|
|
*/
|
|
public function get_connection()
|
|
{
|
|
return $this->databox->get_connection();
|
|
}
|
|
|
|
public function get_original_source()
|
|
{
|
|
return $this->original_src;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return databox
|
|
*/
|
|
public function get_databox()
|
|
{
|
|
return $this->databox;
|
|
}
|
|
|
|
public function delete()
|
|
{
|
|
caption_field::delete_all_metadatas($this->app, $this);
|
|
|
|
$connbas = $this->get_connection();
|
|
$sql = 'DELETE FROM metadatas_structure WHERE id = :id';
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':id' => $this->get_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$dom_struct = $this->databox->get_dom_structure();
|
|
$xp_struct = $this->databox->get_xpath_structure();
|
|
|
|
$nodes = $xp_struct->query(
|
|
'/record/description/*[@meta_id=' . $this->id . ']'
|
|
);
|
|
|
|
foreach ($nodes as $node) {
|
|
/* @var $node DOMNode */
|
|
$node->parentNode->removeChild($node);
|
|
}
|
|
|
|
$this->delete_data_from_cache();
|
|
$this->databox->saveStructure($dom_struct);
|
|
|
|
return;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return databox_field
|
|
*/
|
|
public function save()
|
|
{
|
|
$connbas = $this->get_connection();
|
|
|
|
$sql = 'UPDATE metadatas_structure SET
|
|
`name` = :name,
|
|
`src` = :source,
|
|
`indexable` = :indexable,
|
|
`readonly` = :readonly,
|
|
`required` = :required,
|
|
`separator` = :separator,
|
|
`multi` = :multi,
|
|
`business` = :business,
|
|
`report` = :report,
|
|
`type` = :type,
|
|
`tbranch` = :tbranch,
|
|
`sorter` = :position,
|
|
`thumbtitle` = :thumbtitle,
|
|
`VocabularyControlType` = :VocabularyControlType,
|
|
`RestrictToVocabularyControl` = :RestrictVocab,
|
|
`label_en` = :label_en,
|
|
`label_fr` = :label_fr,
|
|
`label_de` = :label_de,
|
|
`label_nl` = :label_nl
|
|
WHERE id = :id';
|
|
|
|
$params = [
|
|
':name' => $this->name,
|
|
':source' => $this->tag->getTagname(),
|
|
':indexable' => $this->indexable ? '1' : '0',
|
|
':readonly' => $this->readonly ? '1' : '0',
|
|
':required' => $this->required ? '1' : '0',
|
|
':separator' => $this->separator,
|
|
':multi' => $this->multi ? '1' : '0',
|
|
':business' => $this->Business ? '1' : '0',
|
|
':report' => $this->report ? '1' : '0',
|
|
':type' => $this->type,
|
|
':tbranch' => $this->tbranch,
|
|
':position' => $this->position,
|
|
':thumbtitle' => $this->thumbtitle,
|
|
':VocabularyControlType' => $this->Vocabulary ? $this->Vocabulary->getType() : null,
|
|
':RestrictVocab' => $this->Vocabulary ? ($this->VocabularyRestriction ? '1' : '0') : '0',
|
|
':id' => $this->id,
|
|
':label_en' => isset($this->labels['en']) ? $this->labels['en'] : null,
|
|
':label_fr' => isset($this->labels['fr']) ? $this->labels['fr'] : null,
|
|
':label_de' => isset($this->labels['de']) ? $this->labels['de'] : null,
|
|
':label_nl' => isset($this->labels['nl']) ? $this->labels['nl'] : null
|
|
];
|
|
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute($params);
|
|
$stmt->closeCursor();
|
|
|
|
if ($this->renamed) {
|
|
caption_field::rename_all_metadatas($this);
|
|
$this->renamed = false;
|
|
}
|
|
|
|
$dom_struct = $this->databox->get_dom_structure();
|
|
$xp_struct = $this->databox->get_xpath_structure();
|
|
|
|
$nodes = $xp_struct->query(
|
|
'/record/description/*[@meta_id=' . $this->id . ']'
|
|
);
|
|
|
|
if ($nodes->length == 0) {
|
|
$meta = $dom_struct->createElement($this->name);
|
|
$nodes_parent = $xp_struct->query('/record/description');
|
|
$nodes_parent->item(0)->appendChild($meta);
|
|
} else {
|
|
$meta = $nodes->item(0);
|
|
|
|
if ($this->name != $meta->nodeName) {
|
|
$old_meta = $meta;
|
|
$meta = $dom_struct->createElement($this->name);
|
|
$nodes_parent = $xp_struct->query('/record/description');
|
|
$nodes_parent->item(0)->replaceChild($meta, $old_meta);
|
|
}
|
|
}
|
|
$meta->setAttribute('src', $this->tag->getTagname());
|
|
$meta->setAttribute('index', $this->indexable ? '1' : '0');
|
|
$meta->setAttribute('readonly', $this->readonly ? '1' : '0');
|
|
$meta->setAttribute('required', $this->required ? '1' : '0');
|
|
$meta->setAttribute('multi', $this->multi ? '1' : '0');
|
|
$meta->setAttribute('report', $this->report ? '1' : '0');
|
|
$meta->setAttribute('business', $this->Business ? '1' : '0');
|
|
$meta->setAttribute('type', $this->type);
|
|
$meta->setAttribute('tbranch', $this->tbranch);
|
|
if ($this->multi) {
|
|
$meta->setAttribute('separator', $this->separator);
|
|
}
|
|
$meta->setAttribute('thumbtitle', $this->thumbtitle);
|
|
$meta->setAttribute('meta_id', $this->id);
|
|
$meta->setAttribute('sorter', $this->position);
|
|
|
|
$this->delete_data_from_cache();
|
|
$this->databox->saveStructure($dom_struct);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Sets a localized label for the field.
|
|
*
|
|
* @param string $code
|
|
* @param null|string $value
|
|
*
|
|
* @return \databox_field
|
|
*
|
|
* @throws InvalidArgumentException
|
|
*/
|
|
public function set_label($code, $value)
|
|
{
|
|
if (!array_key_exists($code, $this->labels)) {
|
|
throw new InvalidArgumentException(sprintf('Code %s is not defined', $code));
|
|
}
|
|
|
|
$this->labels[$code] = $value;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Gets a localized label for the field.
|
|
*
|
|
* @param string $code
|
|
*
|
|
* @return string
|
|
*
|
|
* @throws InvalidArgumentException
|
|
*/
|
|
public function get_label($code)
|
|
{
|
|
if (!array_key_exists($code, $this->labels)) {
|
|
throw new InvalidArgumentException(sprintf('Code %s is not defined', $code));
|
|
}
|
|
|
|
return isset($this->labels[$code]) && '' !== $this->labels[$code] ? $this->labels[$code] : $this->name;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param string $name
|
|
* @return databox_field
|
|
*/
|
|
public function set_name($name)
|
|
{
|
|
$previous_name = $this->name;
|
|
|
|
$name = self::generateName($name);
|
|
|
|
if ($name === '') {
|
|
throw new \Exception_InvalidArgument();
|
|
}
|
|
|
|
$this->name = $name;
|
|
|
|
if ($this->name !== $previous_name) {
|
|
$this->renamed = true;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Get a PHPExiftool Tag from tagName
|
|
*
|
|
* @param type $tagName
|
|
* @return \PHPExiftool\Driver\Tag
|
|
* @throws Exception_Databox_metadataDescriptionNotFound
|
|
*/
|
|
public static function loadClassFromTagName($tagName, $throwException = true)
|
|
{
|
|
$tagName = str_replace('/rdf:rdf/rdf:description/', '', $tagName);
|
|
|
|
if (trim($tagName) === '') {
|
|
|
|
$tag = new Alchemy\Phrasea\Metadata\Tag\Nosource();
|
|
} elseif (strpos($tagName, 'Phraseanet:') === 0) {
|
|
|
|
$tagName = str_replace('Phraseanet:', '', $tagName);
|
|
|
|
$tagName = explode('-', $tagName);
|
|
$tagName = array_map('ucfirst', $tagName);
|
|
$tagName = implode('', $tagName);
|
|
|
|
$classname = '\\Alchemy\\Phrasea\\Metadata\\Tag\\' . $tagName;
|
|
|
|
if ( ! class_exists($classname)) {
|
|
if ($throwException) {
|
|
throw new Exception_Databox_metadataDescriptionNotFound(sprintf("tagname %s not found", $tagName));
|
|
} else {
|
|
$tag = new Alchemy\Phrasea\Metadata\Tag\Nosource();
|
|
}
|
|
} else {
|
|
$tag = new $classname();
|
|
}
|
|
} else {
|
|
try {
|
|
$tag = TagFactory::getFromRDFTagname($tagName);
|
|
} catch (TagUnknown $e) {
|
|
if ($throwException) {
|
|
throw new NotFoundHttpException(sprintf("Tag %s not found", $tagName), $e);
|
|
}
|
|
$tag = new Alchemy\Phrasea\Metadata\Tag\Nosource();
|
|
}
|
|
}
|
|
|
|
return $tag;
|
|
}
|
|
|
|
public function set_tag(TagInterface $tag = null)
|
|
{
|
|
if ($tag === null) {
|
|
$tag = new Nosource();
|
|
}
|
|
|
|
$this->tag = $tag;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return \PHPExiftool\Driver\Tag
|
|
*/
|
|
public function get_tag()
|
|
{
|
|
return $this->tag;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return databox_Field_DCESAbstract
|
|
*/
|
|
public function get_dces_element()
|
|
{
|
|
return $this->dces_element;
|
|
}
|
|
|
|
public function set_dces_element(databox_Field_DCESAbstract $DCES_element = null)
|
|
{
|
|
$connbas = $this->get_connection();
|
|
|
|
if (null !== $DCES_element) {
|
|
$sql = 'UPDATE metadatas_structure
|
|
SET dces_element = null WHERE dces_element = :dces_element';
|
|
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([
|
|
':dces_element' => $DCES_element->get_label()
|
|
]);
|
|
$stmt->closeCursor();
|
|
}
|
|
|
|
$sql = 'UPDATE metadatas_structure
|
|
SET dces_element = :dces_element WHERE id = :id';
|
|
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([
|
|
':dces_element' => $DCES_element ? $DCES_element->get_label() : null
|
|
, ':id' => $this->id
|
|
]);
|
|
$stmt->closeCursor();
|
|
$this->dces_element = $DCES_element;
|
|
|
|
$this->delete_data_from_cache();
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param boolean $bool
|
|
* @return databox_field
|
|
*/
|
|
public function set_indexable($bool)
|
|
{
|
|
$this->indexable = ! ! $bool;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set a vocabulary
|
|
*
|
|
* @param ControlProviderInterface $vocabulary
|
|
* @return \databox_field
|
|
*/
|
|
public function setVocabularyControl(ControlProviderInterface $vocabulary = null)
|
|
{
|
|
$this->Vocabulary = $vocabulary;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set whether or not the vocabulary is restricted to the provider
|
|
*
|
|
* @param boolean $boolean
|
|
* @return \databox_field
|
|
*/
|
|
public function setVocabularyRestricted($boolean)
|
|
{
|
|
$this->VocabularyRestriction = ! ! $boolean;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param boolean $readonly
|
|
*
|
|
* @return databox_field
|
|
*/
|
|
public function set_readonly($readonly)
|
|
{
|
|
$this->readonly = ! ! $readonly;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param boolean $boolean
|
|
* @return databox_field
|
|
*/
|
|
public function set_business($boolean)
|
|
{
|
|
$this->Business = ! ! $boolean;
|
|
|
|
if ($this->Business) {
|
|
$this->thumbtitle = null;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param boolean $required
|
|
* @return databox_field
|
|
*/
|
|
public function set_required($required)
|
|
{
|
|
$this->required = ! ! $required;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param boolean $report
|
|
* @return databox_field
|
|
*/
|
|
public function set_report($report)
|
|
{
|
|
$this->report = ! ! $report;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param string $type
|
|
* @return databox_field
|
|
*/
|
|
public function set_type($type)
|
|
{
|
|
$this->type = $type;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param string $branch
|
|
* @return databox_field
|
|
*/
|
|
public function set_tbranch($branch)
|
|
{
|
|
$this->tbranch = $branch;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param string $separator
|
|
* @return databox_field
|
|
*/
|
|
public function set_separator($separator)
|
|
{
|
|
$this->separator = self::checkMultiSeparator($separator, $this->multi);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Return the separator depending of the multi attribute
|
|
*
|
|
* @param string $separator
|
|
* @param boolean $multi
|
|
* @return string
|
|
*/
|
|
protected static function checkMultiSeparator($separator, $multi)
|
|
{
|
|
if (! $multi) {
|
|
return '';
|
|
}
|
|
|
|
if (strpos($separator, ';') === false) {
|
|
$separator .= ';';
|
|
}
|
|
|
|
return $separator;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param string $value
|
|
* @return databox_field
|
|
*/
|
|
public function set_thumbtitle($value)
|
|
{
|
|
$this->thumbtitle = $value;
|
|
|
|
if (!$this->thumbtitle) {
|
|
$this->Business = false;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return string
|
|
*/
|
|
public function get_thumbtitle()
|
|
{
|
|
return $this->thumbtitle;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return integer
|
|
*/
|
|
public function get_id()
|
|
{
|
|
return $this->id;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return string
|
|
*/
|
|
public function get_type()
|
|
{
|
|
return $this->type;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return string
|
|
*/
|
|
public function get_tbranch()
|
|
{
|
|
return $this->tbranch;
|
|
}
|
|
|
|
/**
|
|
* @param Boolean $all If set to false, returns a one-char separator to use for serialiation
|
|
*
|
|
* @return string
|
|
*/
|
|
public function get_separator($all = true)
|
|
{
|
|
if ($all) {
|
|
return $this->separator;
|
|
}
|
|
|
|
return substr($this->separator, 0, 1);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function is_indexable()
|
|
{
|
|
return $this->indexable;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function is_readonly()
|
|
{
|
|
return $this->readonly;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function is_required()
|
|
{
|
|
return $this->required;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function is_multi()
|
|
{
|
|
return $this->multi;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function is_report()
|
|
{
|
|
return $this->report;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function get_name()
|
|
{
|
|
return $this->name;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function get_position()
|
|
{
|
|
return $this->position;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return string
|
|
*/
|
|
public function set_position($position)
|
|
{
|
|
$this->position = $position;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Return true is the field is unknown
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function is_on_error()
|
|
{
|
|
return $this->on_error;
|
|
}
|
|
|
|
public function toArray()
|
|
{
|
|
return [
|
|
'id' => $this->id,
|
|
'sbas-id' => $this->sbas_id,
|
|
'labels' => $this->labels,
|
|
'name' => $this->name,
|
|
'tag' => $this->tag->getTagname(),
|
|
'business' => $this->Business,
|
|
'type' => $this->type,
|
|
'sorter' => $this->position,
|
|
'thumbtitle' => $this->thumbtitle,
|
|
'tbranch' => $this->tbranch,
|
|
'separator' => $this->separator,
|
|
'required' => $this->required,
|
|
'report' => $this->report,
|
|
'readonly' => $this->readonly,
|
|
'multi' => $this->multi,
|
|
'indexable' => $this->indexable,
|
|
'dces-element' => $this->dces_element ? $this->dces_element->get_label() : null,
|
|
'vocabulary-type' => $this->Vocabulary ? $this->Vocabulary->getType() : null,
|
|
'vocabulary-restricted' => $this->VocabularyRestriction,
|
|
];
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param \Alchemy\Phrasea\Application $app
|
|
* @param databox $databox
|
|
* @param type $name
|
|
* @param type $multi
|
|
*
|
|
* @return databox_field
|
|
*
|
|
* @throws \Exception_InvalidArgument
|
|
*/
|
|
public static function create(Application $app, databox $databox, $name, $multi)
|
|
{
|
|
$sorter = 0;
|
|
|
|
$sql = 'SELECT (MAX(sorter) + 1) as sorter FROM metadatas_structure';
|
|
$stmt = $databox->get_connection()->prepare($sql);
|
|
$stmt->execute();
|
|
$row = $stmt->fetch(PDO::FETCH_ASSOC);
|
|
$stmt->closeCursor();
|
|
|
|
if ($row) {
|
|
$sorter = max(1, (int) $row['sorter']);
|
|
}
|
|
|
|
$sql = "INSERT INTO metadatas_structure
|
|
(`id`, `name`, `src`, `readonly`, `indexable`, `type`, `tbranch`,
|
|
`thumbtitle`, `multi`, `business`,
|
|
`report`, `sorter`)
|
|
VALUES (null, :name, '', 0, 1, 'string', '',
|
|
null, :multi,
|
|
0, 1, :sorter)";
|
|
|
|
$name = self::generateName($name);
|
|
|
|
if ($name === '') {
|
|
throw new \Exception_InvalidArgument();
|
|
}
|
|
|
|
$multi = $multi ? 1 : 0;
|
|
|
|
$stmt = $databox->get_connection()->prepare($sql);
|
|
$stmt->execute([':name' => $name, ':sorter' => $sorter, ':multi' => $multi]);
|
|
$id = $databox->get_connection()->lastInsertId();
|
|
$stmt->closeCursor();
|
|
|
|
$databox->delete_data_from_cache(databox::CACHE_META_STRUCT);
|
|
|
|
return self::get_instance($app, $databox, $id);
|
|
}
|
|
|
|
public static function generateName($name)
|
|
{
|
|
$unicode_processor = new unicode();
|
|
|
|
$name = $unicode_processor->remove_nonazAZ09($name, false, false);
|
|
|
|
return $unicode_processor->remove_first_digits($name);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return array
|
|
*/
|
|
public function __sleep()
|
|
{
|
|
$vars = [];
|
|
foreach ($this as $key => $value) {
|
|
if (in_array($key, ['databox', 'app', 'Vocabulary']))
|
|
continue;
|
|
$vars[] = $key;
|
|
}
|
|
|
|
return $vars;
|
|
}
|
|
|
|
/**
|
|
* Part of the cache_cacheableInterface
|
|
*
|
|
* @param string $option
|
|
* @return string
|
|
*/
|
|
public function get_cache_key($option = null)
|
|
{
|
|
return 'field_' . $this->get_id() . ($option ? $option . '_' : '');
|
|
}
|
|
|
|
/**
|
|
* Part of the cache_cacheableInterface
|
|
*
|
|
* @param string $option
|
|
* @return mixed
|
|
*/
|
|
public function get_data_from_cache($option = null)
|
|
{
|
|
return $this->databox->get_data_from_cache($this->get_cache_key($option));
|
|
}
|
|
|
|
/**
|
|
* Part of the cache_cacheableInterface
|
|
*
|
|
* @param mixed $value
|
|
* @param string $option
|
|
* @param int $duration
|
|
* @return caption_field
|
|
*/
|
|
public function set_data_to_cache($value, $option = null, $duration = 0)
|
|
{
|
|
return $this->databox->set_data_to_cache($value, $this->get_cache_key($option), $duration);
|
|
}
|
|
|
|
/**
|
|
* Part of the cache_cacheableInterface
|
|
*
|
|
* @param string $option
|
|
* @return caption_field
|
|
*/
|
|
public function delete_data_from_cache($option = null)
|
|
{
|
|
return $this->databox->delete_data_from_cache($this->get_cache_key($option));
|
|
}
|
|
|
|
private function loadVocabulary()
|
|
{
|
|
try {
|
|
$this->Vocabulary = Vocabulary\Controller::get($this->app, $this->VocabularyType);
|
|
} catch (\InvalidArgumentException $e) {
|
|
|
|
}
|
|
}
|
|
|
|
public static function purge()
|
|
{
|
|
self::$_instance = [];
|
|
}
|
|
}
|