mirror of
https://github.com/alchemy-fr/Phraseanet.git
synced 2025-10-09 19:13:26 +00:00
1967 lines
56 KiB
PHP
1967 lines
56 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of Phraseanet
|
|
*
|
|
* (c) 2005-2015 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\Border\File;
|
|
use Alchemy\Phrasea\Cache\Exception;
|
|
use Alchemy\Phrasea\Core\Event\Record\RecordCollectionChangedEvent;
|
|
use Alchemy\Phrasea\Core\Event\Record\RecordCreatedEvent;
|
|
use Alchemy\Phrasea\Core\Event\Record\RecordDeletedEvent;
|
|
use Alchemy\Phrasea\Core\Event\Record\RecordEvent;
|
|
use Alchemy\Phrasea\Core\Event\Record\RecordEvents;
|
|
use Alchemy\Phrasea\Core\Event\Record\RecordMetadataChangedEvent;
|
|
use Alchemy\Phrasea\Core\Event\Record\RecordOriginalNameChangedEvent;
|
|
use Alchemy\Phrasea\Core\Event\Record\RecordStatusChangedEvent;
|
|
use Alchemy\Phrasea\Core\PhraseaTokens;
|
|
use Alchemy\Phrasea\Media\ArrayTechnicalDataSet;
|
|
use Alchemy\Phrasea\Media\FloatTechnicalData;
|
|
use Alchemy\Phrasea\Media\IntegerTechnicalData;
|
|
use Alchemy\Phrasea\Media\StringTechnicalData;
|
|
use Alchemy\Phrasea\Media\TechnicalData;
|
|
use Alchemy\Phrasea\Media\TechnicalDataSet;
|
|
use Alchemy\Phrasea\Metadata\Tag\TfBasename;
|
|
use Alchemy\Phrasea\Metadata\Tag\TfFilename;
|
|
use Alchemy\Phrasea\Model\Entities\User;
|
|
use Alchemy\Phrasea\Model\RecordInterface;
|
|
use Alchemy\Phrasea\Model\Serializer\CaptionSerializer;
|
|
use Alchemy\Phrasea\SearchEngine\SearchEngineInterface;
|
|
use Alchemy\Phrasea\SearchEngine\SearchEngineOptions;
|
|
use Doctrine\ORM\EntityManager;
|
|
use MediaVorus\Media\MediaInterface;
|
|
use MediaVorus\MediaVorus;
|
|
use Rhumsaa\Uuid\Uuid;
|
|
use Symfony\Component\HttpFoundation\File\File as SymfoFile;
|
|
|
|
class record_adapter implements RecordInterface, cache_cacheableInterface
|
|
{
|
|
const CACHE_ORIGINAL_NAME = 'originalname';
|
|
const CACHE_TECHNICAL_DATA = 'technical_data';
|
|
const CACHE_MIME = 'mime';
|
|
const CACHE_TITLE = 'title';
|
|
const CACHE_SHA256 = 'sha256';
|
|
const CACHE_SUBDEFS = 'subdefs';
|
|
const CACHE_GROUPING = 'grouping';
|
|
const CACHE_STATUS = 'status';
|
|
|
|
private $base_id;
|
|
private $collection_id;
|
|
private $record_id;
|
|
private $mime;
|
|
private $number;
|
|
private $status;
|
|
private $subdefs;
|
|
private $type;
|
|
private $sha256;
|
|
private $isStory;
|
|
private $duration;
|
|
/** @var databox */
|
|
private $databox;
|
|
/** @var DateTime */
|
|
private $created;
|
|
/** @var string */
|
|
private $original_name;
|
|
/** @var TechnicalDataSet */
|
|
private $technical_data;
|
|
/** @var string */
|
|
private $uuid;
|
|
/** @var DateTime */
|
|
private $updated;
|
|
/** @var Application */
|
|
protected $app;
|
|
|
|
/**
|
|
* @param Application $app
|
|
* @param integer $sbas_id
|
|
* @param integer $record_id
|
|
* @param integer $number
|
|
* @param bool $load
|
|
*/
|
|
public function __construct(Application $app, $sbas_id, $record_id, $number = null, $load = true)
|
|
{
|
|
$this->app = $app;
|
|
$this->databox = $this->app->findDataboxById((int) $sbas_id);
|
|
$this->number = (int) $number;
|
|
$this->record_id = (int) $record_id;
|
|
|
|
if ($load) {
|
|
$this->load();
|
|
}
|
|
}
|
|
|
|
protected function load()
|
|
{
|
|
if (null === $record = $this->getDatabox()->getRecordRepository()->find($this->record_id)) {
|
|
throw new Exception_Record_AdapterNotFound('Record ' . $this->record_id . ' on database ' . $this->get_sbas_id() . ' not found ');
|
|
}
|
|
|
|
$this->mirror($record);
|
|
}
|
|
|
|
/**
|
|
* @param record_adapter $record
|
|
*/
|
|
private function mirror(record_adapter $record)
|
|
{
|
|
$this->mime = $record->getMimeType();
|
|
$this->sha256 = $record->getSha256();
|
|
$this->original_name = $record->getOriginalName();
|
|
$this->type = $record->getType();
|
|
$this->isStory = $record->isStory();
|
|
$this->uuid = $record->getUuid();
|
|
$this->updated = $record->getUpdated();
|
|
$this->created = $record->getCreated();
|
|
$this->base_id = $record->getBaseId();
|
|
$this->collection_id = $record->getCollectionId();
|
|
}
|
|
|
|
/**
|
|
* @return DateTime
|
|
* @deprecated {@link self::getCreated}
|
|
*/
|
|
public function get_creation_date()
|
|
{
|
|
return $this->getCreated();
|
|
}
|
|
|
|
public function getCreated()
|
|
{
|
|
return $this->created;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
* @deprecated use {@link getUuid} instead.
|
|
*/
|
|
public function get_uuid()
|
|
{
|
|
return $this->getUuid();
|
|
}
|
|
|
|
public function getUuid()
|
|
{
|
|
return $this->uuid;
|
|
}
|
|
|
|
/**
|
|
* @return DateTime
|
|
* @deprecated use {@link self::getUpdated} instead
|
|
*/
|
|
public function get_modification_date()
|
|
{
|
|
return $this->getUpdated();
|
|
}
|
|
|
|
public function getUpdated()
|
|
{
|
|
return $this->updated;
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
*/
|
|
public function getNumber()
|
|
{
|
|
return $this->number;
|
|
}
|
|
|
|
/**
|
|
* Set a relative number (order) for the current in its set
|
|
*
|
|
* @param int $number
|
|
* @return $this
|
|
*/
|
|
public function setNumber($number)
|
|
{
|
|
$this->number = (int) $number;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param string $type
|
|
* @return $this
|
|
* @throws Exception
|
|
* @throws \Doctrine\DBAL\DBALException
|
|
* @deprecated use {@link self::setType} instead.
|
|
*/
|
|
public function set_type($type)
|
|
{
|
|
return $this->setType($type);
|
|
}
|
|
|
|
/**
|
|
* @param string $type
|
|
* @return $this
|
|
* @throws Exception
|
|
* @throws \Doctrine\DBAL\DBALException
|
|
*/
|
|
public function setType($type)
|
|
{
|
|
$type = strtolower($type);
|
|
|
|
$old_type = $this->getType();
|
|
|
|
if (!in_array($type, ['document', 'audio', 'video', 'image', 'flash', 'map'])) {
|
|
throw new Exception('unrecognized document type');
|
|
}
|
|
|
|
$connbas = $this->databox->get_connection();
|
|
|
|
$sql = 'UPDATE record SET type = :type WHERE record_id = :record_id';
|
|
$connbas->executeUpdate($sql, ['type' => $type, 'record_id' => $this->getRecordId()]);
|
|
|
|
if ($old_type !== $type) {
|
|
$this->rebuild_subdefs();
|
|
}
|
|
|
|
$this->type = $type;
|
|
$this->delete_data_from_cache();
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns the type of the document
|
|
*
|
|
* @return string
|
|
* @deprecated use {@link self::getType} instead.
|
|
*/
|
|
public function get_type()
|
|
{
|
|
return $this->getType();
|
|
}
|
|
|
|
public function getType()
|
|
{
|
|
return $this->type;
|
|
}
|
|
|
|
/**
|
|
* @param string $mime
|
|
* @return $this
|
|
* @deprecated use {@link self::setMimeType} instead.
|
|
*/
|
|
public function set_mime($mime)
|
|
{
|
|
return $this->setMimeType($mime);
|
|
}
|
|
|
|
public function setMimeType($mime)
|
|
{
|
|
// see http://lists.w3.org/Archives/Public/xml-dist-app/2003Jul/0064.html
|
|
if (!preg_match("/^[a-zA-Z0-9!#$%^&\\*_\\-\\+{}\\|'.`~]+\\/[a-zA-Z0-9!#$%^&\\*_\\-\\+{}\\|'.`~]+$/", $mime)) {
|
|
throw new \Exception(sprintf('Unrecognized mime type %s', $mime));
|
|
}
|
|
|
|
if ($this->databox->get_connection()->executeUpdate(
|
|
'UPDATE record SET mime = :mime WHERE record_id = :record_id',
|
|
array(':mime' => $mime, ':record_id' => $this->get_record_id())
|
|
)) {
|
|
|
|
$this->rebuild_subdefs();
|
|
$this->delete_data_from_cache();
|
|
}
|
|
|
|
$this->mime = $mime;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
* @deprecated use {@link self::getMimeType} instead.
|
|
*/
|
|
public function get_mime()
|
|
{
|
|
return $this->getMimeType();
|
|
}
|
|
|
|
public function getMimeType()
|
|
{
|
|
return $this->mime;
|
|
}
|
|
|
|
/**
|
|
* Return true if the record is a grouping
|
|
*
|
|
* @return bool
|
|
* @deprecated use {@link self::isStory} instead
|
|
*/
|
|
public function is_grouping()
|
|
{
|
|
return $this->isStory();
|
|
}
|
|
|
|
public function isStory()
|
|
{
|
|
return $this->isStory;
|
|
}
|
|
|
|
/**
|
|
* Return base_id of the record
|
|
*
|
|
* @return int
|
|
* @deprecated use {@link self::getBaseId} instead.
|
|
*/
|
|
public function get_base_id()
|
|
{
|
|
return $this->getBaseId();
|
|
}
|
|
|
|
public function getBaseId()
|
|
{
|
|
return $this->base_id;
|
|
}
|
|
|
|
/**
|
|
* Return collection_id of the record
|
|
*
|
|
* @return int
|
|
* @deprecated use {@link self::getCollectionId} instead.
|
|
*/
|
|
public function get_collection_id()
|
|
{
|
|
return $this->getCollectionId();
|
|
}
|
|
|
|
public function getCollectionId()
|
|
{
|
|
return $this->collection_id;
|
|
}
|
|
|
|
/**
|
|
* Return record collection
|
|
*
|
|
* @return \collection
|
|
*/
|
|
public function get_collection()
|
|
{
|
|
return \collection::get_from_coll_id($this->app, $this->databox, $this->collection_id);
|
|
}
|
|
|
|
/**
|
|
* Returns record_id of the record
|
|
*
|
|
* @return int
|
|
* @deprecated use {@link self::getRecordId} instead.
|
|
*/
|
|
public function get_record_id()
|
|
{
|
|
return $this->getRecordId();
|
|
}
|
|
|
|
public function getRecordId()
|
|
{
|
|
return $this->record_id;
|
|
}
|
|
|
|
/**
|
|
* @return databox
|
|
* @deprecated use {@link self::getDatabox} instead.
|
|
*/
|
|
public function get_databox()
|
|
{
|
|
return $this->getDatabox();
|
|
}
|
|
|
|
/**
|
|
* @return databox
|
|
*/
|
|
public function getDatabox()
|
|
{
|
|
return $this->databox;
|
|
}
|
|
|
|
/**
|
|
* @return media_subdef
|
|
*/
|
|
public function get_thumbnail()
|
|
{
|
|
return $this->get_subdef('thumbnail');
|
|
}
|
|
|
|
/**
|
|
* @param string|string[] $devices
|
|
* @param string|string[] $mimes
|
|
* @return media_subdef[]
|
|
*/
|
|
public function get_embedable_medias($devices = null, $mimes = null)
|
|
{
|
|
return $this->getSubdfefByDeviceAndMime($devices, $mimes);
|
|
}
|
|
|
|
/**
|
|
* get duration formatted as xx:xx:xx
|
|
*
|
|
* @return string
|
|
*/
|
|
public function get_formated_duration()
|
|
{
|
|
return p4string::format_seconds($this->get_duration());
|
|
}
|
|
|
|
/**
|
|
* Returns duration in seconds
|
|
*
|
|
* @return int
|
|
*/
|
|
public function get_duration()
|
|
{
|
|
if (!$this->duration) {
|
|
$duration = $this->get_technical_infos(media_subdef::TC_DATA_DURATION);
|
|
$this->duration = $duration ? round($duration->getValue()) : false;
|
|
}
|
|
|
|
return $this->duration;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param collection $collection
|
|
* @param appbox $appbox
|
|
* @return record_adapter
|
|
*/
|
|
public function move_to_collection(collection $collection, appbox $appbox)
|
|
{
|
|
if ($this->get_collection()->get_base_id() === $collection->get_base_id()) {
|
|
return $this;
|
|
}
|
|
|
|
$sql = "UPDATE record SET coll_id = :coll_id WHERE record_id =:record_id";
|
|
|
|
$params = [
|
|
':coll_id' => $collection->get_coll_id(),
|
|
':record_id' => $this->get_record_id()
|
|
];
|
|
|
|
$stmt = $this->get_databox()->get_connection()->prepare($sql);
|
|
$stmt->execute($params);
|
|
$stmt->closeCursor();
|
|
|
|
$this->base_id = $collection->get_base_id();
|
|
|
|
$this->app['phraseanet.logger']($this->get_databox())
|
|
->log($this, Session_Logger::EVENT_MOVE, $collection->get_coll_id(), '');
|
|
|
|
$this->delete_data_from_cache();
|
|
|
|
$this->dispatch(RecordEvents::COLLECTION_CHANGED, new RecordCollectionChangedEvent($this));
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return null|media_subdef
|
|
*/
|
|
public function get_rollover_thumbnail()
|
|
{
|
|
if ($this->get_type() != 'video') {
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
return $this->get_subdef('thumbnailGIF');
|
|
} catch (\Exception $e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
* @deprecated use {self::getSha256} instead.
|
|
*/
|
|
public function get_sha256()
|
|
{
|
|
return $this->getSha256();
|
|
}
|
|
|
|
public function getSha256()
|
|
{
|
|
return $this->sha256;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function get_status()
|
|
{
|
|
if (!$this->status) {
|
|
$this->status = $this->retrieve_status();
|
|
}
|
|
|
|
return $this->status;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
* @throws Exception
|
|
* @throws \Doctrine\DBAL\DBALException
|
|
*/
|
|
protected function retrieve_status()
|
|
{
|
|
try {
|
|
$data = $this->get_data_from_cache(self::CACHE_STATUS);
|
|
} catch (Exception $e) {
|
|
$data = false;
|
|
}
|
|
|
|
if (false !== $data) {
|
|
return $data;
|
|
}
|
|
|
|
$status = $this->get_databox()->get_connection()->fetchColumn(
|
|
'SELECT BIN(status) as status FROM record WHERE record_id = :record_id',
|
|
[':record_id' => $this->get_record_id()]
|
|
);
|
|
|
|
if (false === $status) {
|
|
throw new Exception('status not found');
|
|
}
|
|
|
|
$status = str_pad($status, 32, '0', STR_PAD_LEFT);
|
|
|
|
$this->set_data_to_cache($status, self::CACHE_STATUS);
|
|
|
|
return $status;
|
|
}
|
|
|
|
public function has_subdef($name)
|
|
{
|
|
return in_array($name, $this->get_available_subdefs());
|
|
}
|
|
|
|
/**
|
|
* @param string $name
|
|
* @return media_subdef
|
|
*/
|
|
public function get_subdef($name)
|
|
{
|
|
$name = strtolower($name);
|
|
|
|
if (!in_array($name, $this->get_available_subdefs())) {
|
|
throw new Exception_Media_SubdefNotFound(sprintf("subdef `%s` not found", $name));
|
|
}
|
|
|
|
if (isset($this->subdefs[$name])) {
|
|
return $this->subdefs[$name];
|
|
}
|
|
|
|
if (!$this->subdefs) {
|
|
$this->subdefs = [];
|
|
}
|
|
|
|
$substitute = ($name !== 'document');
|
|
|
|
return $this->subdefs[$name] = new media_subdef($this->app, $this, $name, $substitute);
|
|
}
|
|
|
|
/**
|
|
* Returns an array of subdef matching
|
|
*
|
|
* @param string|string[] $devices the matching device (see databox_subdef::DEVICE_*)
|
|
* @param string|string[] $mimes the matching mime types
|
|
* @return media_subdef[]
|
|
*/
|
|
public function getSubdfefByDeviceAndMime($devices = null, $mimes = null)
|
|
{
|
|
$subdefNames = $subdefs = [];
|
|
|
|
$availableSubdefs = $this->get_subdefs();
|
|
|
|
if (isset($availableSubdefs['document'])) {
|
|
|
|
$mime_ok = !$mimes || in_array($availableSubdefs['document']->get_mime(), (array) $mimes);
|
|
$devices_ok = !$devices || array_intersect($availableSubdefs['document']->getDevices(), (array) $devices);
|
|
|
|
if ($mime_ok && $devices_ok) {
|
|
$subdefs['document'] = $availableSubdefs['document'];
|
|
}
|
|
}
|
|
|
|
$searchDevices = array_merge((array) $devices, (array) databox_subdef::DEVICE_ALL);
|
|
|
|
$type = $this->isStory() ? 'image' : $this->get_type();
|
|
|
|
foreach ($this->databox->get_subdef_structure() as $group => $databoxSubdefs) {
|
|
|
|
if ($type != $group) {
|
|
continue;
|
|
}
|
|
|
|
foreach ($databoxSubdefs as $databoxSubdef) {
|
|
|
|
if ($devices && !array_intersect($databoxSubdef->getDevices(), $searchDevices)) {
|
|
continue;
|
|
}
|
|
|
|
array_push($subdefNames, $databoxSubdef->get_name());
|
|
}
|
|
}
|
|
|
|
foreach ($availableSubdefs as $subdef) {
|
|
|
|
if (!in_array($subdef->get_name(), $subdefNames)) {
|
|
continue;
|
|
}
|
|
|
|
if ($mimes && !in_array($subdef->get_mime(), (array) $mimes)) {
|
|
continue;
|
|
}
|
|
|
|
$subdefs[$subdef->get_name()] = $subdef;
|
|
}
|
|
|
|
return $subdefs;
|
|
}
|
|
|
|
/**
|
|
* @return media_subdef[]
|
|
*/
|
|
public function get_subdefs()
|
|
{
|
|
if (!$this->subdefs) {
|
|
$this->subdefs = [];
|
|
}
|
|
|
|
$subdefs = $this->get_available_subdefs();
|
|
foreach ($subdefs as $name) {
|
|
$this->get_subdef($name);
|
|
}
|
|
|
|
return $this->subdefs;
|
|
}
|
|
|
|
/**
|
|
* @return string[]
|
|
*/
|
|
protected function get_available_subdefs()
|
|
{
|
|
try {
|
|
$data = $this->get_data_from_cache(self::CACHE_SUBDEFS);
|
|
} catch (\Exception $e) {
|
|
$data = false;
|
|
}
|
|
|
|
if (is_array($data)) {
|
|
return $data;
|
|
}
|
|
|
|
$connbas = $this->get_databox()->get_connection();
|
|
|
|
$rs = $connbas->fetchAll(
|
|
'SELECT name FROM subdef s LEFT JOIN record r ON s.record_id = r.record_id WHERE r.record_id = :record_id',
|
|
['record_id' => $this->get_record_id()]
|
|
);
|
|
|
|
$subdefs = ['preview', 'thumbnail'];
|
|
|
|
foreach ($rs as $row) {
|
|
$subdefs[] = $row['name'];
|
|
}
|
|
|
|
$subdefs = array_unique($subdefs);
|
|
$this->set_data_to_cache($subdefs, self::CACHE_SUBDEFS);
|
|
|
|
return $subdefs;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function get_collection_logo()
|
|
{
|
|
return collection::getLogo($this->base_id, $this->app, true);
|
|
}
|
|
|
|
/**
|
|
* Return a Technical data set or a specific technical data or false when not found
|
|
*
|
|
* @param string $data
|
|
* @return TechnicalDataSet|TechnicalData|false
|
|
*/
|
|
public function get_technical_infos($data = '')
|
|
{
|
|
if (!$this->technical_data && !$this->mapTechnicalDataFromCache()) {
|
|
$this->technical_data = [];
|
|
$rs = $this->fetchTechnicalDataFromDb();
|
|
|
|
$this->mapTechnicalDataFromDb($rs);
|
|
|
|
$this->set_data_to_cache($this->technical_data, self::CACHE_TECHNICAL_DATA);
|
|
}
|
|
|
|
if ($data) {
|
|
if (isset($this->technical_data[$data])) {
|
|
return $this->technical_data[$data];
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return $this->technical_data;
|
|
}
|
|
|
|
/**
|
|
* @return caption_record
|
|
*/
|
|
public function get_caption()
|
|
{
|
|
return new caption_record($this->app, $this, $this->get_databox());
|
|
}
|
|
|
|
public function getCaption(array $fields = null)
|
|
{
|
|
return $this->getCaptionFieldsMap($this->get_caption()->get_fields($fields, true));
|
|
}
|
|
|
|
/**
|
|
* @param caption_field[] $fields
|
|
* @return array
|
|
*/
|
|
private function getCaptionFieldsMap(array $fields)
|
|
{
|
|
$collection = [];
|
|
|
|
foreach ($fields as $field) {
|
|
$values = array_map(function(caption_Field_Value $fieldValue) {
|
|
return $fieldValue->getValue();
|
|
}, $field->get_values());
|
|
|
|
$collection[$field->get_name()] = $values;
|
|
}
|
|
|
|
return $collection;
|
|
}
|
|
|
|
/**
|
|
* @param bool $removeExtension
|
|
* @return string
|
|
*/
|
|
public function get_original_name($removeExtension = null)
|
|
{
|
|
if ($removeExtension) {
|
|
return pathinfo($this->original_name, PATHINFO_FILENAME);
|
|
}
|
|
|
|
return $this->original_name;
|
|
}
|
|
|
|
public function set_original_name($original_name)
|
|
{
|
|
$this->original_name = $original_name;
|
|
|
|
foreach ($this->get_databox()->get_meta_structure()->get_elements() as $data_field) {
|
|
|
|
if ($data_field->get_tag() instanceof TfFilename) {
|
|
$original_name = pathinfo($original_name, PATHINFO_FILENAME);
|
|
} elseif (!$data_field->get_tag() instanceof TfBasename) {
|
|
continue;
|
|
}
|
|
|
|
// Replacing original name in multi values is non sense
|
|
if ($data_field->is_multi()) {
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
$field = $this->get_caption()->get_field($data_field->get_name());
|
|
$values = $field->get_values();
|
|
$value = end($values);
|
|
|
|
$this->set_metadatas([[
|
|
'meta_struct_id' => $field->get_meta_struct_id(),
|
|
'meta_id' => $value->getId(),
|
|
'value' => $original_name,
|
|
]], true);
|
|
} catch (\Exception $e) {
|
|
// Caption is not setup, ignore error
|
|
}
|
|
}
|
|
|
|
$this->get_databox()->get_connection()->executeUpdate(
|
|
'UPDATE record SET originalname = :originalname WHERE record_id = :record_id',
|
|
['originalname' => $original_name, 'record_id' => $this->get_record_id()]
|
|
);
|
|
|
|
$this->delete_data_from_cache();
|
|
|
|
$this->dispatch(RecordEvents::ORIGINAL_NAME_CHANGED, new RecordOriginalNameChangedEvent($this));
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param bool $highlight
|
|
* @param SearchEngineInterface $searchEngine
|
|
* @param null $removeExtension
|
|
* @param SearchEngineOptions $options
|
|
* @return string
|
|
*/
|
|
public function get_title($highlight = false, SearchEngineInterface $searchEngine = null, $removeExtension = null, SearchEngineOptions $options = null)
|
|
{
|
|
$cache = !$highlight && !$searchEngine && !$removeExtension;
|
|
|
|
if ($cache) {
|
|
try {
|
|
return $this->get_data_from_cache(self::CACHE_TITLE);
|
|
} catch (\Exception $e) {
|
|
|
|
}
|
|
}
|
|
|
|
$title = '';
|
|
|
|
$fields = $this->get_databox()->get_meta_structure();
|
|
|
|
$fields_to_retrieve = [];
|
|
|
|
foreach ($fields as $field) {
|
|
if (in_array($field->get_thumbtitle(), ['1', $this->app['locale']])) {
|
|
$fields_to_retrieve [] = $field->get_name();
|
|
}
|
|
}
|
|
|
|
if (count($fields_to_retrieve) > 0) {
|
|
$retrieved_fields = $this->get_caption()->get_highlight_fields($highlight, $fields_to_retrieve, $searchEngine);
|
|
$titles = [];
|
|
foreach ($retrieved_fields as $value) {
|
|
foreach ($value['values'] as $v) {
|
|
$titles[] = $v['value'];
|
|
}
|
|
}
|
|
$title = trim(implode(' - ', $titles));
|
|
}
|
|
|
|
if (trim($title) === '') {
|
|
$title = trim($this->get_original_name($removeExtension));
|
|
}
|
|
|
|
$title = $title != "" ? $title : $this->app->trans('reponses::document sans titre');
|
|
|
|
if ($cache) {
|
|
$this->set_data_to_cache(self::CACHE_TITLE, $title);
|
|
}
|
|
|
|
return $title;
|
|
}
|
|
|
|
/**
|
|
* @return media_subdef
|
|
*/
|
|
public function get_preview()
|
|
{
|
|
return $this->get_subdef('preview');
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function has_preview()
|
|
{
|
|
try {
|
|
return $this->get_subdef('preview')->is_physically_present();
|
|
} catch (\Exception $e) {
|
|
unset($e);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @return string
|
|
*/
|
|
public function get_serialize_key()
|
|
{
|
|
return $this->get_sbas_id() . '_' . $this->get_record_id();
|
|
}
|
|
|
|
/**
|
|
* @return int
|
|
* @deprecated use {@link self::getDataboxId} instead
|
|
*/
|
|
public function get_sbas_id()
|
|
{
|
|
return $this->get_databox()->get_sbas_id();
|
|
}
|
|
|
|
public function substitute_subdef($name, MediaInterface $media, Application $app, $adapt=true)
|
|
{
|
|
$newfilename = $this->record_id . '_0_' . $name . '.' . $media->getFile()->getExtension();
|
|
|
|
if ($name == 'document') {
|
|
$baseprefs = $this->get_databox()->get_sxml_structure();
|
|
|
|
$pathhd = p4string::addEndSlash((string) ($baseprefs->path));
|
|
|
|
$filehd = $this->get_record_id() . "_document." . strtolower($media->getFile()->getExtension());
|
|
$pathhd = databox::dispatch($app['filesystem'], $pathhd);
|
|
|
|
$app['filesystem']->copy($media->getFile()->getRealPath(), $pathhd . $filehd, true);
|
|
|
|
$subdefFile = $pathhd . $filehd;
|
|
|
|
$meta_writable = true;
|
|
} else {
|
|
$type = $this->isStory() ? 'image' : $this->get_type();
|
|
|
|
$subdef_def = $this->get_databox()->get_subdef_structure()->get_subdef($type, $name);
|
|
|
|
if ($this->has_subdef($name) && $this->get_subdef($name)->is_physically_present()) {
|
|
|
|
$path_file_dest = $this->get_subdef($name)->get_pathfile();
|
|
$this->get_subdef($name)->remove_file();
|
|
$this->clearSubdefCache($name);
|
|
} else {
|
|
$path = databox::dispatch($app['filesystem'], $subdef_def->get_path());
|
|
$app['filesystem']->mkdir($path, 0750);
|
|
$path_file_dest = $path . $newfilename;
|
|
}
|
|
|
|
if($adapt) {
|
|
try {
|
|
$app['media-alchemyst']->turnInto(
|
|
$media->getFile()->getRealPath(),
|
|
$path_file_dest,
|
|
$subdef_def->getSpecs()
|
|
);
|
|
} catch (\MediaAlchemyst\Exception\ExceptionInterface $e) {
|
|
return $this;
|
|
}
|
|
|
|
$subdefFile = $path_file_dest;
|
|
}
|
|
else{
|
|
$app['filesystem']->copy($media->getFile()->getRealPath(), $path_file_dest);
|
|
|
|
$subdefFile = $path_file_dest;
|
|
}
|
|
|
|
$meta_writable = $subdef_def->meta_writeable();
|
|
}
|
|
|
|
$app['filesystem']->chmod($subdefFile, 0760);
|
|
$media = $app->getMediaFromUri($subdefFile);
|
|
$subdef = media_subdef::create($app, $this, $name, $media);
|
|
$subdef->set_substituted(true);
|
|
|
|
$this->delete_data_from_cache(self::CACHE_SUBDEFS);
|
|
|
|
if ($meta_writable) {
|
|
$this->write_metas();
|
|
}
|
|
|
|
if ($name == 'document' && $adapt) {
|
|
$this->rebuild_subdefs();
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param DOMDocument $dom_doc
|
|
* @return record_adapter
|
|
*/
|
|
protected function set_xml(DOMDocument $dom_doc)
|
|
{
|
|
$connbas = $this->get_databox()->get_connection();
|
|
$sql = 'UPDATE record SET xml = :xml WHERE record_id= :record_id';
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute(
|
|
[
|
|
':xml' => $dom_doc->saveXML(),
|
|
':record_id' => $this->record_id
|
|
]
|
|
);
|
|
$stmt->closeCursor();
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @todo move this function to caption_record
|
|
* @param Array $params An array containing three keys : meta_struct_id (int) , meta_id (int or null) and value (Array)
|
|
* @param databox $databox
|
|
* @return record_adapter
|
|
* @throws Exception
|
|
* @throws Exception_InvalidArgument
|
|
*/
|
|
protected function set_metadata(Array $params, databox $databox)
|
|
{
|
|
$mandatoryParams = ['meta_struct_id', 'meta_id', 'value'];
|
|
|
|
foreach ($mandatoryParams as $param) {
|
|
if (!array_key_exists($param, $params)) {
|
|
throw new Exception_InvalidArgument(sprintf('Invalid metadata, missing key %s', $param));
|
|
}
|
|
}
|
|
|
|
if (!is_scalar($params['value'])) {
|
|
throw new Exception('Metadata value should be scalar');
|
|
}
|
|
|
|
$databox_field = $databox->get_meta_structure()->get_element($params['meta_struct_id']);
|
|
|
|
$caption_field = new caption_field($this->app, $databox_field, $this);
|
|
|
|
$vocab = $vocab_id = null;
|
|
|
|
if (isset($params['vocabularyId']) && $databox_field->getVocabularyControl()) {
|
|
try {
|
|
$vocab = $databox_field->getVocabularyControl();
|
|
$vocab_id = $params['vocabularyId'];
|
|
$vocab->validate($vocab_id);
|
|
} catch (\Exception $e) {
|
|
$vocab = $vocab_id = null;
|
|
}
|
|
}
|
|
|
|
if (trim($params['meta_id']) !== '') {
|
|
$tmp_val = trim($params['value']);
|
|
|
|
$caption_field_value = $caption_field->get_value($params['meta_id']);
|
|
|
|
if ($tmp_val === '') {
|
|
$caption_field_value->delete();
|
|
unset($caption_field_value);
|
|
} else {
|
|
$caption_field_value->set_value($params['value']);
|
|
if ($vocab && $vocab_id) {
|
|
$caption_field_value->setVocab($vocab, $vocab_id);
|
|
}
|
|
}
|
|
} else {
|
|
$caption_field_value = caption_Field_Value::create($this->app, $databox_field, $this, $params['value'], $vocab, $vocab_id);
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @todo move this function to caption_record
|
|
*
|
|
* @param array $metadatas
|
|
* @param boolean $force_readonly
|
|
*
|
|
* @return record_adapter
|
|
*/
|
|
public function set_metadatas(array $metadatas, $force_readonly = false)
|
|
{
|
|
$databox_descriptionStructure = $this->get_databox()->get_meta_structure();
|
|
|
|
foreach ($metadatas as $param) {
|
|
if (!is_array($param)) {
|
|
throw new Exception_InvalidArgument('Invalid metadatas argument');
|
|
}
|
|
|
|
$db_field = $databox_descriptionStructure->get_element($param['meta_struct_id']);
|
|
|
|
if ($db_field->is_readonly() === true && !$force_readonly) {
|
|
continue;
|
|
}
|
|
|
|
$this->set_metadata($param, $this->databox);
|
|
}
|
|
|
|
$xml = new DOMDocument();
|
|
$xml->loadXML($this->app['serializer.caption']->serialize($this->get_caption(), CaptionSerializer::SERIALIZE_XML, true));
|
|
|
|
$this->set_xml($xml);
|
|
unset($xml);
|
|
|
|
$this->dispatch(RecordEvents::METADATA_CHANGED, new RecordMetadataChangedEvent($this));
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @return record_adapter
|
|
*/
|
|
public function rebuild_subdefs()
|
|
{
|
|
$databox = $this->app->findDataboxById($this->get_sbas_id());
|
|
$connbas = $databox->get_connection();
|
|
$sql = 'UPDATE record SET jeton=(jeton | ' . PhraseaTokens::MAKE_SUBDEF . ') WHERE record_id = :record_id';
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function get_missing_subdefs()
|
|
{
|
|
$databox = $this->get_databox();
|
|
|
|
try {
|
|
$this->get_hd_file();
|
|
} catch (\Exception $e) {
|
|
return array();
|
|
}
|
|
|
|
$subDefDefinitions = $databox->get_subdef_structure()->getSubdefGroup($this->get_type());
|
|
if (!$subDefDefinitions) {
|
|
return array();
|
|
}
|
|
|
|
$record = $this;
|
|
$wanted_subdefs = array_map(function(media_subdef $subDef) {
|
|
return $subDef->get_name();
|
|
}, array_filter($subDefDefinitions, function(media_subdef $subDef) use ($record) {
|
|
return !$record->has_subdef($subDef->get_name());
|
|
}));
|
|
|
|
|
|
$missing_subdefs = array_map(function(media_subdef $subDef) {
|
|
return $subDef->get_name();
|
|
}, array_filter($this->get_subdefs(), function(media_subdef $subdef) {
|
|
return !$subdef->is_physically_present();
|
|
}));
|
|
|
|
return array_values(array_merge($wanted_subdefs, $missing_subdefs));
|
|
}
|
|
|
|
/**
|
|
* @return record_adapter
|
|
*/
|
|
public function write_metas()
|
|
{
|
|
$tokenMask = PhraseaTokens::WRITE_META_DOC | PhraseaTokens::WRITE_META_SUBDEF;
|
|
$this->databox->get_connection()->executeUpdate(
|
|
'UPDATE record SET jeton = jeton | :tokenMask WHERE record_id= :record_id',
|
|
['tokenMask' => $tokenMask, 'record_id' => $this->record_id]
|
|
);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param string $status
|
|
* @return record_adapter
|
|
*/
|
|
public function set_binary_status($status)
|
|
{
|
|
$connection = $this->databox->get_connection();
|
|
|
|
$connection->executeUpdate(
|
|
'UPDATE record SET status = :status WHERE record_id= :record_id',
|
|
['status' => bindec($status), 'record_id' => $this->record_id]
|
|
);
|
|
|
|
$sql = 'REPLACE INTO status (id, record_id, name, value) VALUES (null, :record_id, :name, :value)';
|
|
$stmt = $connection->prepare($sql);
|
|
|
|
$status = strrev($status);
|
|
$length = strlen($status);
|
|
for ($i = 4; $i < $length; $i++) {
|
|
$stmt->execute([
|
|
':record_id' => $this->get_record_id(),
|
|
':name' => $i,
|
|
':value' => $status[$i]
|
|
]);
|
|
}
|
|
$stmt->closeCursor();
|
|
|
|
$this->delete_data_from_cache(self::CACHE_STATUS);
|
|
|
|
$this->dispatch(RecordEvents::STATUS_CHANGED, new RecordStatusChangedEvent($this));
|
|
|
|
return $this;
|
|
}
|
|
|
|
private function dispatch($eventName, RecordEvent $event)
|
|
{
|
|
$this->app['dispatcher']->dispatch($eventName, $event);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param Application $app
|
|
* @param \collection $collection
|
|
*
|
|
* @return \record_adapter
|
|
*/
|
|
public static function createStory(Application $app, \collection $collection)
|
|
{
|
|
$connection = $collection->get_databox()->get_connection();
|
|
|
|
$sql = 'INSERT INTO record (coll_id, record_id, parent_record_id, moddate, credate, type, sha256, uuid, originalname, mime)'
|
|
.' VALUES (:coll_id, NULL, :parent_record_id, NOW(), NOW(), :type, :sha256, :uuid , :originalname, :mime)';
|
|
|
|
$stmt = $connection->prepare($sql);
|
|
|
|
$stmt->execute([
|
|
':coll_id' => $collection->get_coll_id(),
|
|
':parent_record_id' => 1,
|
|
':type' => 'unknown',
|
|
':sha256' => null,
|
|
':uuid' => Uuid::uuid4(),
|
|
':originalname' => null,
|
|
':mime' => null,
|
|
]);
|
|
$stmt->closeCursor();
|
|
|
|
$story_id = $connection->lastInsertId();
|
|
|
|
$story = new self($app, $collection->get_databox()->get_sbas_id(), $story_id);
|
|
|
|
try {
|
|
$log_id = $app['phraseanet.logger']($collection->get_databox())->get_id();
|
|
|
|
$sql = 'INSERT INTO log_docs (id, log_id, date, record_id, action, final, comment)'
|
|
. ' VALUES (null, :log_id, now(), :record_id, "add", :coll_id,"")';
|
|
$stmt = $connection->prepare($sql);
|
|
$stmt->execute([
|
|
':log_id' => $log_id,
|
|
':record_id' => $story_id,
|
|
':coll_id' => $collection->get_coll_id()
|
|
]);
|
|
$stmt->closeCursor();
|
|
} catch (\Exception $e) {
|
|
unset($e);
|
|
}
|
|
|
|
$story->dispatch(RecordEvents::CREATED, new RecordCreatedEvent($story));
|
|
|
|
return $story;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param File $file
|
|
* @param Application $app
|
|
*
|
|
* @return \record_adapter
|
|
*/
|
|
public static function createFromFile(File $file, Application $app)
|
|
{
|
|
$databox = $file->getCollection()->get_databox();
|
|
|
|
$sql = 'INSERT INTO record
|
|
(coll_id, record_id, parent_record_id, moddate, credate
|
|
, type, sha256, uuid, originalname, mime)
|
|
VALUES
|
|
(:coll_id, null, :parent_record_id, NOW(), NOW()
|
|
, :type, :sha256, :uuid
|
|
, :originalname, :mime)';
|
|
|
|
$stmt = $databox->get_connection()->prepare($sql);
|
|
|
|
$stmt->execute([
|
|
':coll_id' => $file->getCollection()->get_coll_id(),
|
|
':parent_record_id' => 0,
|
|
':type' => $file->getType() ? $file->getType()->getType() : 'unknown',
|
|
':sha256' => $file->getMedia()->getHash('sha256'),
|
|
':uuid' => $file->getUUID(true),
|
|
':originalname' => $file->getOriginalName(),
|
|
':mime' => $file->getFile()->getMimeType(),
|
|
]);
|
|
$stmt->closeCursor();
|
|
|
|
$record_id = $databox->get_connection()->lastInsertId();
|
|
|
|
$record = new self($app, $databox->get_sbas_id(), $record_id);
|
|
|
|
try {
|
|
$log_id = $app['phraseanet.logger']($databox)->get_id();
|
|
|
|
$sql = 'INSERT INTO log_docs (id, log_id, date, record_id, action, final, comment)
|
|
VALUES (null, :log_id, now(),
|
|
:record_id, "add", :coll_id,"")';
|
|
$stmt = $databox->get_connection()->prepare($sql);
|
|
$stmt->execute([
|
|
':log_id' => $log_id,
|
|
':record_id' => $record_id,
|
|
':coll_id' => $file->getCollection()->get_coll_id()
|
|
]);
|
|
$stmt->closeCursor();
|
|
} catch (\Exception $e) {
|
|
unset($e);
|
|
}
|
|
|
|
$pathhd = databox::dispatch($app['filesystem'], trim($databox->get_sxml_structure()->path));
|
|
$newname = $record->get_record_id() . "_document." . pathinfo($file->getOriginalName(), PATHINFO_EXTENSION);
|
|
|
|
$app['filesystem']->copy($file->getFile()->getRealPath(), $pathhd . $newname, true);
|
|
|
|
$media = $app->getMediaFromUri($pathhd . $newname);
|
|
media_subdef::create($app, $record, 'document', $media);
|
|
|
|
$record->delete_data_from_cache(\record_adapter::CACHE_SUBDEFS);
|
|
|
|
$record->insertTechnicalDatas($app['mediavorus']);
|
|
|
|
$record->dispatch(RecordEvents::CREATED, new RecordCreatedEvent($record));
|
|
|
|
return $record;
|
|
}
|
|
|
|
/**
|
|
* Read technical datas an insert them
|
|
* This method can be long to perform
|
|
*
|
|
* @return record_adapter
|
|
*/
|
|
public function insertTechnicalDatas(MediaVorus $mediavorus)
|
|
{
|
|
try {
|
|
$document = $this->get_subdef('document');
|
|
} catch (\Exception_Media_SubdefNotFound $e) {
|
|
return $this;
|
|
}
|
|
|
|
$sql = 'DELETE FROM technical_datas WHERE record_id = :record_id';
|
|
$stmt = $this->get_databox()->get_connection()->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$sql = 'INSERT INTO technical_datas (id, record_id, name, value)
|
|
VALUES (null, :record_id, :name, :value)';
|
|
$stmt = $this->get_databox()->get_connection()->prepare($sql);
|
|
|
|
foreach ($document->readTechnicalDatas($mediavorus) as $name => $value) {
|
|
if (is_null($value)) {
|
|
continue;
|
|
} elseif (is_bool($value)) {
|
|
if ($value) {
|
|
$value = 1;
|
|
} else {
|
|
$value = 0;
|
|
}
|
|
}
|
|
|
|
$stmt->execute([
|
|
':record_id' => $this->get_record_id()
|
|
, ':name' => $name
|
|
, ':value' => $value
|
|
]);
|
|
}
|
|
|
|
$stmt->closeCursor();
|
|
|
|
$this->delete_data_from_cache(self::CACHE_TECHNICAL_DATA);
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @param databox $databox
|
|
* @param string $sha256
|
|
* @param integer $record_id
|
|
* @return record_adapter[]
|
|
* @deprecated use {@link databox::getRecordRepository} instead.
|
|
*/
|
|
public static function get_record_by_sha(\databox $databox, $sha256, $record_id = null)
|
|
{
|
|
$records = $databox->getRecordRepository()->findBySha256($sha256);
|
|
|
|
if (!is_null($record_id)) {
|
|
$records = array_filter($records, function (record_adapter $record) use ($record_id) {
|
|
return $record->getRecordId() == $record_id;
|
|
});
|
|
}
|
|
|
|
return $records;
|
|
}
|
|
|
|
/**
|
|
* Search for a record on a databox by UUID
|
|
*
|
|
* @param \databox $databox
|
|
* @param string $uuid
|
|
* @param int $record_id Restrict check on a record_id
|
|
* @return record_adapter[]
|
|
* @deprecated use {@link databox::getRecordRepository} instead.
|
|
*/
|
|
public static function get_record_by_uuid(\databox $databox, $uuid, $record_id = null)
|
|
{
|
|
$records = $databox->getRecordRepository()->findByUuid($uuid);
|
|
|
|
if (!is_null($record_id)) {
|
|
$records = array_filter($records, function (record_adapter $record) use ($record_id) {
|
|
return $record->getRecordId() == $record_id;
|
|
});
|
|
}
|
|
|
|
return $records;
|
|
}
|
|
|
|
/**
|
|
* @return \Symfony\Component\HttpFoundation\File\File|null
|
|
*/
|
|
public function get_hd_file()
|
|
{
|
|
$hd = $this->get_subdef('document');
|
|
|
|
if ($hd->is_physically_present()) {
|
|
return new SymfoFile($hd->get_pathfile());
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* @return Array : list of deleted files;
|
|
*/
|
|
public function delete()
|
|
{
|
|
$connbas = $this->get_databox()->get_connection();
|
|
|
|
$ftodel = [];
|
|
foreach ($this->get_subdefs() as $subdef) {
|
|
if (!$subdef->is_physically_present())
|
|
continue;
|
|
|
|
if ($subdef->get_name() === 'thumbnail') {
|
|
$this->app['filesystem']->remove($this->app['phraseanet.thumb-symlinker']->getSymlinkPath($subdef->get_pathfile()));
|
|
}
|
|
|
|
$ftodel[] = $subdef->get_pathfile();
|
|
$watermark = $subdef->get_path() . 'watermark_' . $subdef->get_file();
|
|
if (file_exists($watermark))
|
|
$ftodel[] = $watermark;
|
|
$stamp = $subdef->get_path() . 'stamp_' . $subdef->get_file();
|
|
if (file_exists($stamp))
|
|
$ftodel[] = $stamp;
|
|
}
|
|
|
|
$origcoll = $this->collection_id;
|
|
|
|
$xml = $this->app['serializer.caption']->serialize($this->get_caption(), CaptionSerializer::SERIALIZE_XML);
|
|
|
|
$this->app['phraseanet.logger']($this->get_databox())
|
|
->log($this, Session_Logger::EVENT_DELETE, $origcoll, $xml);
|
|
|
|
$sql = "DELETE FROM record WHERE record_id = :record_id";
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$sql = "DELETE FROM metadatas WHERE record_id = :record_id";
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$sql = "DELETE FROM prop WHERE record_id = :record_id";
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$sql = "DELETE FROM idx WHERE record_id = :record_id";
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$sql = "DELETE FROM permalinks
|
|
WHERE subdef_id
|
|
IN (SELECT subdef_id FROM subdef WHERE record_id=:record_id)";
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$sql = "DELETE FROM subdef WHERE record_id = :record_id";
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$sql = "DELETE FROM technical_datas WHERE record_id = :record_id";
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$sql = "DELETE FROM thit WHERE record_id = :record_id";
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$sql = "DELETE FROM regroup WHERE rid_parent = :record_id";
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$sql = "DELETE FROM regroup WHERE rid_child = :record_id";
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$orderElementRepository = $this->app['repo.order-elements'];
|
|
|
|
/* @var $repository Alchemy\Phrasea\Model\Repositories\OrderElementRepository */
|
|
foreach ($orderElementRepository->findBy(['recordId' => $this->get_record_id()]) as $order_element) {
|
|
if ($order_element->getSbasId($this->app) == $this->get_sbas_id()) {
|
|
$this->app['orm.em']->remove($order_element);
|
|
}
|
|
}
|
|
|
|
$basketElementRepository = $this->app['repo.basket-elements'];
|
|
|
|
/* @var $repository Alchemy\Phrasea\Model\Repositories\BasketElementRepository */
|
|
foreach ($basketElementRepository->findElementsByRecord($this) as $basket_element) {
|
|
$this->app['orm.em']->remove($basket_element);
|
|
}
|
|
|
|
$this->app['orm.em']->flush();
|
|
|
|
$this->app['filesystem']->remove($ftodel);
|
|
|
|
$this->delete_data_from_cache(self::CACHE_SUBDEFS);
|
|
|
|
$this->dispatch(RecordEvents::DELETED, new RecordDeletedEvent($this));
|
|
|
|
return array_keys($ftodel);
|
|
}
|
|
|
|
/**
|
|
* @param string $option optional cache name
|
|
* @return string
|
|
*/
|
|
public function get_cache_key($option = null)
|
|
{
|
|
return 'record_' . $this->get_serialize_key() . ($option ? '_' . $option : '');
|
|
}
|
|
|
|
public function clearSubdefCache($subdefname)
|
|
{
|
|
if ($this->has_subdef($subdefname)) {
|
|
$this->get_subdef($subdefname)->delete_data_from_cache();
|
|
|
|
$permalink = $this->get_subdef($subdefname)->get_permalink();
|
|
|
|
if ($permalink instanceof media_Permalink_Adapter) {
|
|
$permalink->delete_data_from_cache();
|
|
}
|
|
}
|
|
|
|
$this->delete_data_from_cache(self::CACHE_SUBDEFS);
|
|
}
|
|
|
|
/**
|
|
* @param string $option optional cache name
|
|
* @return mixed
|
|
*/
|
|
public function get_data_from_cache($option = null)
|
|
{
|
|
$databox = $this->get_databox();
|
|
|
|
return $databox->get_data_from_cache($this->get_cache_key($option));
|
|
}
|
|
|
|
public function set_data_to_cache($value, $option = null, $duration = 0)
|
|
{
|
|
$databox = $this->get_databox();
|
|
|
|
return $databox->set_data_to_cache($value, $this->get_cache_key($option), $duration);
|
|
}
|
|
|
|
public function delete_data_from_cache($option = null)
|
|
{
|
|
switch ($option) {
|
|
case self::CACHE_STATUS:
|
|
$this->status = null;
|
|
break;
|
|
case self::CACHE_SUBDEFS:
|
|
$this->subdefs = null;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
$databox = $this->get_databox();
|
|
|
|
return $databox->delete_data_from_cache($this->get_cache_key($option));
|
|
}
|
|
|
|
public function log_view($log_id, $referrer, $gv_sit)
|
|
{
|
|
$databox = $this->app->findDataboxById($this->get_sbas_id());
|
|
$connbas = $databox->get_connection();
|
|
|
|
$sql = 'INSERT INTO log_view (id, log_id, date, record_id, referrer, site_id)
|
|
VALUES
|
|
(null, :log_id, now(), :rec, :referrer, :site)';
|
|
|
|
$params = [
|
|
':log_id' => $log_id
|
|
, ':rec' => $this->get_record_id()
|
|
, ':referrer' => $referrer
|
|
, ':site' => $gv_sit
|
|
];
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute($params);
|
|
$stmt->closeCursor();
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* @var Array
|
|
*/
|
|
protected $container_basket;
|
|
|
|
/**
|
|
* @todo de meme avec stories
|
|
* @return Array
|
|
*/
|
|
public function get_container_baskets(EntityManager $em, User $user)
|
|
{
|
|
return $em
|
|
->getRepository('Phraseanet:Basket')
|
|
->findContainingRecordForUser($this, $user);
|
|
}
|
|
|
|
/**
|
|
* @param databox $databox
|
|
* @param int $original_name
|
|
* @param bool $caseSensitive
|
|
* @param int $offset_start
|
|
* @param int $how_many
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function get_records_by_originalname(databox $databox, $original_name, $caseSensitive = false, $offset_start = 0, $how_many = 10)
|
|
{
|
|
$offset_start = (int) ($offset_start < 0 ? 0 : $offset_start);
|
|
$how_many = (int) (($how_many > 20 || $how_many < 1) ? 10 : $how_many);
|
|
|
|
$sql = sprintf('SELECT record_id FROM record
|
|
WHERE originalname = :original_name '
|
|
. ($caseSensitive ? 'COLLATE utf8_bin' : 'COLLATE utf8_unicode_ci')
|
|
. ' LIMIT %d, %d'
|
|
, $offset_start, $how_many);
|
|
|
|
$stmt = $databox->get_connection()->prepare($sql);
|
|
$stmt->execute([':original_name' => $original_name]);
|
|
$rs = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
|
$stmt->closeCursor();
|
|
|
|
$records = [];
|
|
foreach ($rs as $row) {
|
|
$records[] = $databox->get_record($row['record_id']);
|
|
}
|
|
|
|
return $records;
|
|
}
|
|
|
|
/**
|
|
* @return set_selection
|
|
* @throws Exception
|
|
* @throws \Doctrine\DBAL\DBALException
|
|
*/
|
|
public function get_children()
|
|
{
|
|
if (!$this->isStory()) {
|
|
throw new Exception('This record is not a grouping');
|
|
}
|
|
|
|
if ($this->app->getAuthenticatedUser()) {
|
|
$sql = 'SELECT record_id
|
|
FROM regroup g
|
|
INNER JOIN (record r
|
|
INNER JOIN collusr c
|
|
ON site = :site
|
|
AND usr_id = :usr_id
|
|
AND c.coll_id = r.coll_id
|
|
AND ((status ^ mask_xor) & mask_and) = 0
|
|
AND r.parent_record_id=0
|
|
)
|
|
ON (g.rid_child = r.record_id AND g.rid_parent = :record_id)
|
|
ORDER BY g.ord ASC, dateadd ASC, record_id ASC';
|
|
|
|
$params = [
|
|
':site' => $this->app['conf']->get(['main', 'key']),
|
|
':usr_id' => $this->app->getAuthenticatedUser()->getId(),
|
|
':record_id' => $this->get_record_id(),
|
|
];
|
|
} else {
|
|
$sql = 'SELECT record_id
|
|
FROM regroup g
|
|
INNER JOIN record r
|
|
ON (g.rid_child = r.record_id AND g.rid_parent = :record_id)
|
|
ORDER BY g.ord ASC, dateadd ASC, record_id ASC';
|
|
|
|
$params = [
|
|
':record_id' => $this->get_record_id()
|
|
];
|
|
}
|
|
|
|
$stmt = $this->get_databox()->get_connection()->prepare($sql);
|
|
$stmt->execute($params);
|
|
$rs = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
|
$stmt->closeCursor();
|
|
|
|
$set = new set_selection($this->app);
|
|
$i = 1;
|
|
foreach ($rs as $row) {
|
|
$set->add_element(new record_adapter($this->app, $this->get_sbas_id(), $row['record_id'], $i));
|
|
$i++;
|
|
}
|
|
|
|
return $set;
|
|
}
|
|
|
|
/**
|
|
* @return set_selection
|
|
*/
|
|
public function get_grouping_parents()
|
|
{
|
|
$sql = 'SELECT r.record_id
|
|
FROM regroup g
|
|
INNER JOIN (record r
|
|
INNER JOIN collusr c
|
|
ON site = :site
|
|
AND usr_id = :usr_id
|
|
AND c.coll_id = r.coll_id
|
|
AND ((status ^ mask_xor) & mask_and)=0
|
|
AND r.parent_record_id = 1
|
|
)
|
|
ON (g.rid_parent = r.record_id)
|
|
WHERE rid_child = :record_id';
|
|
|
|
$stmt = $this->get_databox()->get_connection()->prepare($sql);
|
|
$stmt->execute([
|
|
':site' => $this->app['conf']->get(['main', 'key']),
|
|
':usr_id' => $this->app->getAuthenticatedUser()->getId(),
|
|
':record_id' => $this->get_record_id(),
|
|
]);
|
|
$rs = $stmt->fetchAll(PDO::FETCH_ASSOC);
|
|
$stmt->closeCursor();
|
|
|
|
$set = new set_selection($this->app);
|
|
foreach ($rs as $row) {
|
|
$set->add_element(new record_adapter($this->app, $this->get_sbas_id(), $row['record_id']));
|
|
}
|
|
|
|
return $set;
|
|
}
|
|
|
|
public function hasChild(\record_adapter $record)
|
|
{
|
|
return $this->get_children()->offsetExists($record->get_serialize_key());
|
|
}
|
|
|
|
public function appendChild(\record_adapter $record)
|
|
{
|
|
if (!$this->isStory()) {
|
|
throw new \Exception('Only stories can append children');
|
|
}
|
|
|
|
$connbas = $this->get_databox()->get_connection();
|
|
|
|
$ord = 0;
|
|
|
|
$sql = "SELECT (max(ord)+1) as ord
|
|
FROM regroup WHERE rid_parent = :parent_record_id";
|
|
|
|
$stmt = $connbas->prepare($sql);
|
|
|
|
$stmt->execute([':parent_record_id' => $this->get_record_id()]);
|
|
|
|
$row = $stmt->fetch(PDO::FETCH_ASSOC);
|
|
|
|
$stmt->closeCursor();
|
|
|
|
if ($row) {
|
|
$ord = is_null($row["ord"]) ? 0 : $row["ord"];
|
|
}
|
|
|
|
$sql = 'INSERT INTO regroup (id, rid_parent, rid_child, dateadd, ord)
|
|
VALUES (null, :parent_record_id, :record_id, NOW(), :ord)';
|
|
|
|
$params = [
|
|
':parent_record_id' => $this->get_record_id()
|
|
, ':record_id' => $record->get_record_id()
|
|
, ':ord' => $ord
|
|
];
|
|
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute($params);
|
|
|
|
$stmt->closeCursor();
|
|
|
|
$sql = 'UPDATE record SET moddate = NOW() WHERE record_id = :record_id';
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$this->delete_data_from_cache();
|
|
|
|
return $this;
|
|
}
|
|
|
|
public function removeChild(\record_adapter $record)
|
|
{
|
|
if (!$this->isStory()) {
|
|
throw new \Exception('Only stories can append children');
|
|
}
|
|
|
|
$connbas = $this->get_databox()->get_connection();
|
|
|
|
$sql = "DELETE FROM regroup WHERE rid_parent = :parent_record_id
|
|
AND rid_child = :record_id";
|
|
|
|
$params = [
|
|
':parent_record_id' => $this->get_record_id()
|
|
, ':record_id' => $record->get_record_id()
|
|
];
|
|
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute($params);
|
|
$stmt->closeCursor();
|
|
|
|
$sql = 'UPDATE record SET moddate = NOW() WHERE record_id = :record_id';
|
|
$stmt = $connbas->prepare($sql);
|
|
$stmt->execute([':record_id' => $this->get_record_id()]);
|
|
$stmt->closeCursor();
|
|
|
|
$this->delete_data_from_cache();
|
|
|
|
return $this;
|
|
}
|
|
|
|
/** {@inheritdoc} */
|
|
public function getDataboxId()
|
|
{
|
|
return $this->get_databox()->get_sbas_id();
|
|
}
|
|
|
|
/** {@inheritdoc} */
|
|
public function getOriginalName()
|
|
{
|
|
return $this->get_original_name();
|
|
}
|
|
|
|
/** {@inheritdoc} */
|
|
public function setOriginalName($originalName)
|
|
{
|
|
$this->set_original_name($originalName);
|
|
}
|
|
|
|
/** {@inheritdoc} */
|
|
public function getId()
|
|
{
|
|
return $this->get_serialize_key();
|
|
}
|
|
|
|
public function setStatus($status)
|
|
{
|
|
$this->set_binary_status($status);
|
|
|
|
$this->delete_data_from_cache(self::CACHE_STATUS);
|
|
}
|
|
|
|
/** {@inheritdoc} */
|
|
public function getStatusBitField()
|
|
{
|
|
return bindec($this->get_status());
|
|
}
|
|
|
|
/** {@inheritdoc} */
|
|
public function getExif()
|
|
{
|
|
return $this->get_technical_infos()->getValues();
|
|
}
|
|
|
|
public function getStatusStructure()
|
|
{
|
|
return $this->databox->getStatusStructure();
|
|
}
|
|
|
|
public function putInCache()
|
|
{
|
|
$data = [
|
|
'mime' => $this->mime,
|
|
'sha256' => $this->sha256,
|
|
'originalName' => $this->original_name,
|
|
'type' => $this->type,
|
|
'isStory' => $this->isStory,
|
|
'uuid' => $this->uuid,
|
|
'updated' => $this->updated->format(DATE_ISO8601),
|
|
'created' => $this->created->format(DATE_ISO8601),
|
|
'base_id' => $this->base_id,
|
|
'collection_id' => $this->collection_id,
|
|
];
|
|
|
|
$this->set_data_to_cache($data);
|
|
}
|
|
|
|
/**
|
|
* @param array $row
|
|
*/
|
|
public function mapFromData(array $row)
|
|
{
|
|
if (!isset($row['base_id'])) {
|
|
$row['base_id'] = phrasea::baseFromColl($this->get_sbas_id(), $row['collection_id'], $this->app);
|
|
}
|
|
|
|
$this->collection_id = (int)$row['collection_id'];
|
|
$this->base_id = (int)$row['base_id'];
|
|
$this->created = new DateTime($row['created']);
|
|
$this->updated = new DateTime($row['updated']);
|
|
$this->uuid = $row['uuid'];
|
|
|
|
$this->isStory = ($row['isStory'] == '1');
|
|
$this->type = $row['type'];
|
|
$this->original_name = $row['originalName'];
|
|
$this->sha256 = $row['sha256'];
|
|
$this->mime = $row['mime'];
|
|
}
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
private function mapTechnicalDataFromCache()
|
|
{
|
|
try {
|
|
$technical_data = $this->get_data_from_cache(self::CACHE_TECHNICAL_DATA);
|
|
} catch (Exception $e) {
|
|
$technical_data = false;
|
|
}
|
|
|
|
if (false === $technical_data) {
|
|
return false;
|
|
}
|
|
|
|
$this->technical_data = $technical_data;
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @return false|array
|
|
*/
|
|
private function fetchTechnicalDataFromDb()
|
|
{
|
|
$sql = 'SELECT name, value FROM technical_datas WHERE record_id = :record_id';
|
|
|
|
return $this->get_databox()->get_connection()
|
|
->fetchAll($sql, ['record_id' => $this->get_record_id()]);
|
|
}
|
|
|
|
/**
|
|
* @param array $rows
|
|
*/
|
|
private function mapTechnicalDataFromDb(array $rows)
|
|
{
|
|
$this->technical_data = new ArrayTechnicalDataSet();
|
|
|
|
foreach ($rows as $row) {
|
|
switch (true) {
|
|
case ctype_digit($row['value']):
|
|
$this->technical_data[] = new IntegerTechnicalData($row['name'], $row['value']);
|
|
break;
|
|
case preg_match('/[0-9]?\.[0-9]+/', $row['value']):
|
|
$this->technical_data[] = new FloatTechnicalData($row['name'], $row['value']);
|
|
break;
|
|
default:
|
|
$this->technical_data[] = new StringTechnicalData($row['name'], $row['value']);
|
|
}
|
|
}
|
|
}
|
|
}
|