mirror of
https://github.com/alchemy-fr/Phraseanet.git
synced 2025-10-14 13:33:14 +00:00
465 lines
16 KiB
PHP
465 lines
16 KiB
PHP
<?php
|
|
|
|
/*
|
|
* This file is part of Phraseanet
|
|
*
|
|
* (c) 2005-2012 Alchemy
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace Alchemy\Phrasea\Controller\Prod;
|
|
|
|
use MediaVorus\MediaVorus;
|
|
use Alchemy\Phrasea\Border;
|
|
use Silex\Application;
|
|
use Silex\ControllerProviderInterface;
|
|
use Silex\ControllerCollection;
|
|
use Symfony\Component\HttpFoundation\Request;
|
|
use Symfony\Component\HttpFoundation\Response;
|
|
|
|
/**
|
|
* Lazaret controller collection
|
|
*
|
|
* Defines routes related to the lazaret (quarantine) functionality
|
|
*
|
|
* @license http://opensource.org/licenses/gpl-3.0 GPLv3
|
|
* @link www.phraseanet.com
|
|
*/
|
|
class Lazaret implements ControllerProviderInterface
|
|
{
|
|
|
|
/**
|
|
* Connect the ControllerCollection to the Silex Application
|
|
*
|
|
* @param Application $app A silex application
|
|
* @return \Silex\ControllerCollection
|
|
*/
|
|
public function connect(Application $app)
|
|
{
|
|
$controllers = new ControllerCollection();
|
|
|
|
/**
|
|
* Lazaret Elements route
|
|
*
|
|
* name : lazaret_elements
|
|
*
|
|
* description : List all lazaret elements
|
|
*
|
|
* method : GET
|
|
*
|
|
* parameters : 'offset' int (optional) default 0 : List offset
|
|
* 'limit' int (optional) default 10 : List limit
|
|
*
|
|
* return : HTML Response
|
|
*/
|
|
$controllers->get('/', $this->call('listElement'))
|
|
->bind('lazaret_elements');
|
|
|
|
/**
|
|
* Lazaret Element route
|
|
*
|
|
* name : lazaret_element
|
|
*
|
|
* descritpion : Get one lazaret element identified by {file_id} parameter
|
|
*
|
|
* method : GET
|
|
*
|
|
* return : JSON Response
|
|
*/
|
|
$controllers->get('/{file_id}/', $this->call('getElement'))
|
|
->assert('file_id', '\d+')
|
|
->bind('lazaret_element');
|
|
|
|
/**
|
|
* Lazaret Force Add route
|
|
*
|
|
* name : lazaret_force_add
|
|
*
|
|
* description : Move a lazaret element identified by {file_id} parameter into phraseanet
|
|
*
|
|
* method : POST
|
|
*
|
|
* parameters : 'bas_id' int (mandatory) : The id of the destination collection
|
|
* 'keep_attributes' boolean (optional) : Keep all attributes attached to the lazaret element
|
|
* 'attributes' array (optional) : Attributes id's to attach to the lazaret element
|
|
*
|
|
* return : JSON Response
|
|
*/
|
|
$controllers->post('/{file_id}/force-add/', $this->call('addElement'))
|
|
->assert('file_id', '\d+')
|
|
->bind('lazaret_force_add');
|
|
|
|
/**
|
|
* Lazaret Deny route
|
|
*
|
|
* name : lazaret_deny_element
|
|
*
|
|
* description : Remove a lazaret element identified by {file_id} parameter
|
|
*
|
|
* method : POST
|
|
*
|
|
* return : JSON Response
|
|
*/
|
|
$controllers->post('/{file_id}/deny/', $this->call('denyElement'))
|
|
->assert('file_id', '\d+')
|
|
->bind('lazaret_deny_element');
|
|
|
|
/**
|
|
* Lazaret Accept Route
|
|
*
|
|
* name : lazaret_accept
|
|
*
|
|
* description : Substitute the phraseanet record identified by
|
|
* the post parameter 'record_id'by the lazaret element identified
|
|
* by {file_id} parameter
|
|
*
|
|
* method : POST
|
|
*
|
|
* parameters : 'record_id' int (mandatory) : The substitued record
|
|
*
|
|
* return : JSON Response
|
|
*/
|
|
$controllers->post('/{file_id}/accept/', $this->call('acceptElement'))
|
|
->assert('file_id', '\d+')
|
|
->bind('lazaret_accept');
|
|
|
|
/**
|
|
* Lazaret Thumbnail route
|
|
*
|
|
* name : lazaret_thumbnail
|
|
*
|
|
* descritpion : Get the thumbnail attached to the lazaret element
|
|
* identified by {file_id} parameter
|
|
*
|
|
* method : GET
|
|
*
|
|
* return : JSON Response
|
|
*/
|
|
$controllers->get('/{file_id}/thumbnail/', $this->call('thumbnailElement'))
|
|
->assert('file_id', '\d+')
|
|
->bind('lazaret_thumbnail');
|
|
|
|
return $controllers;
|
|
}
|
|
|
|
/**
|
|
* List all elements in lazaret
|
|
*
|
|
* @param Application $app A Silex application
|
|
* @param Request $request The current request
|
|
*
|
|
* @return Response
|
|
*/
|
|
public function listElement(Application $app, Request $request)
|
|
{
|
|
$em = $app['Core']->getEntityManager();
|
|
$user = $app['Core']->getAuthenticatedUser();
|
|
/* @var $user \User_Adapter */
|
|
$baseIds = array_keys($user->ACL()->get_granted_base(array('canaddrecord')));
|
|
|
|
$lazaretFiles = null;
|
|
|
|
if (count($baseIds) > 0) {
|
|
$lazaretRepository = $em->getRepository('Entities\LazaretFile');
|
|
|
|
$lazaretFiles = $lazaretRepository->findPerPage(
|
|
$baseIds, $request->get('offset', 0), $request->get('limit', 10)
|
|
);
|
|
}
|
|
|
|
$html = $app['Core']['Twig']->render(
|
|
'prod/upload/lazaret.html.twig', array('lazaretFiles' => $lazaretFiles)
|
|
);
|
|
|
|
return new Response($html);
|
|
}
|
|
|
|
/**
|
|
* Get one lazaret Element
|
|
*
|
|
* @param Application $app A Silex application
|
|
* @param Request $request The current request
|
|
* @param int $file_id A lazaret element id
|
|
*
|
|
* @return Response
|
|
*/
|
|
public function getElement(Application $app, Request $request, $file_id)
|
|
{
|
|
$ret = array('success' => false, 'message' => '', 'result' => array());
|
|
|
|
try {
|
|
$lazaretFile = $app['Core']['EM']->find('Entities\LazaretFile', $file_id);
|
|
|
|
/* @var $lazaretFile \Entities\LazaretFile */
|
|
if (null === $lazaretFile) {
|
|
throw new \Exception_NotFound(sprintf('Lazaret file id %d not found', $file_id));
|
|
}
|
|
|
|
$file = array(
|
|
'filename' => $lazaretFile->getOriginalName(),
|
|
'base_id' => $lazaretFile->getBaseId(),
|
|
'created' => $lazaretFile->getCreated()->format(\DateTime::ATOM),
|
|
'updated' => $lazaretFile->getUpdated()->format(\DateTime::ATOM),
|
|
'pathname' => $lazaretFile->getPathname(),
|
|
'sha256' => $lazaretFile->getSha256(),
|
|
'uuid' => $lazaretFile->getUuid(),
|
|
);
|
|
|
|
$ret['result'] = $file;
|
|
$ret['success'] = true;
|
|
} catch (\Exception_NotFound $e) {
|
|
$ret['message'] = _('File is not present in quarantine anymore, please refresh');
|
|
} catch (\Exception $e) {
|
|
$ret['message'] = _('An error occured');
|
|
}
|
|
|
|
return self::formatJson($app['Core']['Serializer'], $ret);
|
|
}
|
|
|
|
/**
|
|
* Add an element to phraseanet
|
|
*
|
|
* @param Application $app A Silex application
|
|
* @param Request $request The current request
|
|
* @param int $file_id A lazaret element id
|
|
*
|
|
* @return Response
|
|
*/
|
|
public function addElement(Application $app, Request $request, $file_id)
|
|
{
|
|
$ret = array('success' => false, 'message' => '', 'result' => array());
|
|
|
|
//Optional parameter
|
|
$keepAttributes = ! ! $request->get('keep_attributes', false);
|
|
$attributesToKeep = $request->get('attributes', array());
|
|
|
|
//Mandatory parameter
|
|
if (null === $baseId = $request->get('bas_id')) {
|
|
$ret['message'] = _('You must give a destination collection');
|
|
|
|
return self::formatJson($app['Core']['Serializer'], $ret);
|
|
}
|
|
|
|
try {
|
|
$lazaretFile = $app['Core']['EM']->find('Entities\LazaretFile', $file_id);
|
|
|
|
/* @var $lazaretFile \Entities\LazaretFile */
|
|
if (null === $lazaretFile) {
|
|
throw new \Exception_NotFound(sprintf('Lazaret file id %d not found', $file_id));
|
|
}
|
|
|
|
$borderFile = Border\File::buildFromPathfile(
|
|
$lazaretFile->getPathname(), $lazaretFile->getCollection(), $lazaretFile->getOriginalName()
|
|
);
|
|
|
|
$record = null;
|
|
/* @var $record \record_adapter */
|
|
|
|
//Post record creation
|
|
$callBack = function($element, $visa, $code) use (&$record) {
|
|
$record = $element;
|
|
};
|
|
|
|
//Force creation record
|
|
$app['Core']['border-manager']->process(
|
|
$lazaretFile->getSession(), $borderFile, $callBack, Border\Manager::FORCE_RECORD
|
|
);
|
|
|
|
if ($keepAttributes) {
|
|
//add attribute
|
|
foreach ($lazaretFile->getAttributes() as $attr) {
|
|
|
|
//Check which ones to keep
|
|
if ( ! ! count($attributesToKeep)) {
|
|
if ( ! in_array($attr->getId(), $attributesToKeep)) {
|
|
continue;
|
|
}
|
|
}
|
|
|
|
try {
|
|
$attribute = Border\Attribute\Factory::getFileAttribute($attr->getName(), $attr->getValue());
|
|
} catch (\InvalidArgumentException $e) {
|
|
continue;
|
|
}
|
|
|
|
/* @var $attribute Border\Attribute\Attribute */
|
|
|
|
switch ($attribute->getName()) {
|
|
case Border\Attribute\Attribute::NAME_METADATA:
|
|
/**
|
|
* @todo romain neutron
|
|
*/
|
|
break;
|
|
case Border\Attribute\Attribute::NAME_STORY:
|
|
$attribute->getValue()->appendChild($record);
|
|
break;
|
|
case Border\Attribute\Attribute::NAME_STATUS:
|
|
$record->set_binary_status($attribute->getValue());
|
|
break;
|
|
case Border\Attribute\Attribute::NAME_METAFIELD:
|
|
/**
|
|
* @todo romain neutron
|
|
*/
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//Delete lazaret file
|
|
$app['Core']['EM']->remove($lazaretFile);
|
|
$app['Core']['EM']->flush();
|
|
$ret['success'] = true;
|
|
} catch (\Exception_NotFound $e) {
|
|
$ret['message'] = _('File is not present in quarantine anymore, please refresh');
|
|
} catch (\Exception $e) {
|
|
$ret['message'] = _('An error occured');
|
|
}
|
|
|
|
return self::formatJson($app['Core']['Serializer'], $ret);
|
|
}
|
|
|
|
/**
|
|
* Delete a lazaret element
|
|
*
|
|
* @param Application $app A Silex application where the controller is mounted on
|
|
* @param Request $request The current request
|
|
* @param int $file_id A lazaret element id
|
|
*
|
|
* @return Response
|
|
*/
|
|
public function denyElement(Application $app, Request $request, $file_id)
|
|
{
|
|
$ret = array('success' => false, 'message' => '', 'result' => array());
|
|
|
|
try {
|
|
$lazaretFile = $app['Core']['EM']->find('Entities\LazaretFile', $file_id);
|
|
|
|
/* @var $lazaretFile \Entities\LazaretFile */
|
|
if (null === $lazaretFile) {
|
|
throw new \Exception_NotFound(sprintf('Lazaret file id %d not found', $file_id));
|
|
}
|
|
|
|
//Delete lazaret file
|
|
$app['Core']['EM']->remove($lazaretFile);
|
|
$app['Core']['EM']->flush();
|
|
|
|
$ret['success'] = true;
|
|
} catch (\Exception_NotFound $e) {
|
|
$ret['message'] = _('File is not present in quarantine anymore, please refresh');
|
|
} catch (\Exception $e) {
|
|
$ret['message'] = _('An error occured');
|
|
}
|
|
|
|
return self::formatJson($app['Core']['Serializer'], $ret);
|
|
}
|
|
|
|
/**
|
|
* Substitute a record element by a lazaret element
|
|
*
|
|
* @param Application $app A Silex application where the controller is mounted on
|
|
* @param Request $request The current request
|
|
* @param int $file_id A lazaret element id
|
|
*
|
|
* @return Response
|
|
*/
|
|
public function acceptElement(Application $app, Request $request, $file_id)
|
|
{
|
|
$ret = array('success' => false, 'message' => '', 'result' => array());
|
|
|
|
//Mandatory parameter
|
|
if (null === $recordId = $request->get('record_id')) {
|
|
$ret['message'] = _('You must give a destination record');
|
|
|
|
return self::formatJson($app['Core']['Serializer'], $ret);
|
|
}
|
|
|
|
try {
|
|
$lazaretFile = $app['Core']['EM']->find('Entities\LazaretFile', $file_id);
|
|
|
|
/* @var $lazaretFile \Entities\LazaretFile */
|
|
if (null === $lazaretFile) {
|
|
throw new \Exception_NotFound(sprintf('Lazaret file id %d not found', $file_id));
|
|
}
|
|
|
|
$found = false;
|
|
|
|
//Check if the choosen record is eligible to the substitution
|
|
foreach ($lazaretFile->getRecordsToSubstitute() as $record) {
|
|
if ($record->get_record_id() !== (int) $recordId) {
|
|
continue;
|
|
}
|
|
|
|
$found = true;
|
|
break;
|
|
}
|
|
|
|
if ( ! $found) {
|
|
$ret['message'] = _('The destination record provided is not allowed');
|
|
|
|
return self::formatJson($app['Core']['Serializer'], $ret);
|
|
}
|
|
|
|
$media = MediaVorus::guess(new \SplFileInfo($lazaretFile->getPathname()));
|
|
|
|
$record = $lazaretFile->getCollection()->get_databox()->get_record($recordId);
|
|
$record->substitute_subdef('document', $media);
|
|
|
|
//Delete lazaret file
|
|
$app['Core']['EM']->remove($lazaretFile);
|
|
$app['Core']['EM']->flush();
|
|
|
|
$ret['success'] = true;
|
|
|
|
} catch (\Exception_NotFound $e) {
|
|
$ret['message'] = _('File is not present in quarantine anymore, please refresh');
|
|
} catch (\Exception $e) {
|
|
$ret['message'] = _('An error occured');
|
|
}
|
|
|
|
return self::formatJson($app['Core']['Serializer'], $ret);
|
|
}
|
|
|
|
/**
|
|
* Get the associated lazaret element thumbnail
|
|
*
|
|
* @param Application $app A Silex application where the controller is mounted on
|
|
* @param Request $request The current request
|
|
* @param int $file_id A lazaret element id
|
|
*
|
|
* @return Response
|
|
*/
|
|
public function thumbnailElement(Application $app, Request $request, $file_id)
|
|
{
|
|
$lazaretFile = $app['Core']['EM']->find('Entities\LazaretFile', $file_id);
|
|
|
|
/* @var $lazaretFile \Entities\LazaretFile */
|
|
if (null === $lazaretFile) {
|
|
return new Response(null, 404);
|
|
}
|
|
|
|
$response = \set_export::stream_file(
|
|
$lazaretFile->getPathname(), $lazaretFile->getOriginalName(), 'image/jpeg', 'inline'
|
|
);
|
|
|
|
return $response;
|
|
}
|
|
|
|
protected static function formatJson(\Symfony\Component\Serializer\Serializer $serializer, $datas)
|
|
{
|
|
return new Response($serializer->serialize($datas, 'json'), 200, array('content-type' => 'application/json'));
|
|
}
|
|
|
|
/**
|
|
* Prefix the method to call with the controller class name
|
|
*
|
|
* @param string $method The method to call
|
|
* @return string
|
|
*/
|
|
private function call($method)
|
|
{
|
|
return sprintf('%s::%s', __CLASS__, $method);
|
|
}
|
|
}
|