mirror of
https://github.com/alchemy-fr/Phraseanet.git
synced 2025-10-24 18:33:13 +00:00
396 lines
13 KiB
PHP
396 lines
13 KiB
PHP
<?php
|
|
/*
|
|
* This file is part of Phraseanet
|
|
*
|
|
* (c) 2005-2016 Alchemy
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
|
|
namespace Alchemy\Phrasea\Controller\Admin;
|
|
|
|
use Alchemy\Phrasea\Controller\Controller;
|
|
use Alchemy\Phrasea\Metadata\TagProvider;
|
|
use Alchemy\Phrasea\Vocabulary\ControlProvider\ControlProviderInterface;
|
|
use Assert\Assertion;
|
|
use Symfony\Component\HttpFoundation\Request;
|
|
use Symfony\Component\HttpFoundation\Response;
|
|
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
|
|
use Symfony\Component\HttpKernel\Exception\HttpException;
|
|
|
|
class FieldsController extends Controller
|
|
{
|
|
public function updateFields(Request $request, $sbas_id)
|
|
{
|
|
$fields = [];
|
|
$databox = $this->findDataboxById((int) $sbas_id);
|
|
$metaStructure = $databox->get_meta_structure();
|
|
$connection = $databox->get_connection();
|
|
$data = $this->getFieldsJsonFromRequest($request);
|
|
|
|
$connection->beginTransaction();
|
|
|
|
foreach ($data as $jsonField) {
|
|
try {
|
|
$field = $metaStructure->get_element($jsonField['id']);
|
|
|
|
if ($field->get_name() !== $jsonField['name']) {
|
|
$this->validateNameField($metaStructure, $jsonField);
|
|
}
|
|
|
|
$this->validateTagField($jsonField);
|
|
|
|
$this->updateFieldWithData($field, $jsonField);
|
|
$field->save();
|
|
$fields[] = $field->toArray();
|
|
} catch (\Exception $e) {
|
|
$connection->rollback();
|
|
$this->app->abort(500, $this->app->trans('Field %name% could not be saved, please try again or contact an admin.', ['%name%' => $jsonField['name']]));
|
|
break;
|
|
}
|
|
}
|
|
|
|
$connection->commit();
|
|
|
|
return $this->app->json($fields);
|
|
}
|
|
|
|
public function getLanguage()
|
|
{
|
|
return $this->app->json([
|
|
'something_wrong' => $this->app->trans('Something wrong happened, please try again or contact an admin.'),
|
|
'created_success' => $this->app->trans('%s field has been created with success.'),
|
|
'deleted_success' => $this->app->trans('%s field has been deleted with success.'),
|
|
'are_you_sure_delete' => $this->app->trans('Do you really want to delete the field %s ?'),
|
|
'validation_blank' => $this->app->trans('Field can not be blank.'),
|
|
'validation_name_exists' => $this->app->trans('Field name already exists.'),
|
|
'validation_name_invalid' => $this->app->trans('Field name is not valid.'),
|
|
'validation_tag_invalid' => $this->app->trans('Field source is not valid.'),
|
|
'field_error' => $this->app->trans('Field %s contains errors.'),
|
|
'fields_save' => $this->app->trans('Your configuration has been successfuly saved.'),
|
|
]);
|
|
}
|
|
|
|
public function displayApp($sbas_id)
|
|
{
|
|
$languages = [];
|
|
|
|
foreach ($this->app['locales.available'] as $code => $language) {
|
|
$data = explode('_', $code);
|
|
$languages[$data[0]] = $language;
|
|
}
|
|
|
|
return $this->render('/admin/fields/index.html.twig', [
|
|
'sbas_id' => $sbas_id,
|
|
'languages' => $languages,
|
|
]);
|
|
}
|
|
|
|
public function listDcFields()
|
|
{
|
|
$data = $this->app['serializer']->serialize(array_values(\databox::get_available_dcfields()), 'json');
|
|
|
|
return new Response($data, 200, ['content-type' => 'application/json']);
|
|
}
|
|
|
|
public function listVocabularies()
|
|
{
|
|
return $this->app->json(array_map(
|
|
[$this, 'getVocabularyAsArray'],
|
|
$this->fetchVocabularies()
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @return ControlProviderInterface[]
|
|
*/
|
|
private function fetchVocabularies()
|
|
{
|
|
$vocabularies = $this->getVocabularies();
|
|
|
|
$instances = array_map(
|
|
function ($type) use ($vocabularies) {
|
|
return $vocabularies[$type];
|
|
},
|
|
$vocabularies->keys()
|
|
);
|
|
|
|
Assertion::allIsInstanceOf($instances, ControlProviderInterface::class);
|
|
|
|
return $instances;
|
|
}
|
|
|
|
/**
|
|
* @param string $type
|
|
* @return ControlProviderInterface
|
|
*/
|
|
private function fetchVocabulary($type)
|
|
{
|
|
$vocabularies = $this->getVocabularies();
|
|
|
|
$vocabulary = $vocabularies[strtolower($type)];
|
|
|
|
Assertion::isInstanceOf($vocabulary, ControlProviderInterface::class);
|
|
|
|
return $vocabulary;
|
|
}
|
|
|
|
private function getVocabularyAsArray(ControlProviderInterface $vocabulary)
|
|
{
|
|
return [
|
|
'type' => $vocabulary->getType(),
|
|
'name' => $vocabulary->getName(),
|
|
];
|
|
}
|
|
|
|
public function getVocabulary($type)
|
|
{
|
|
return $this->app->json($this->getVocabularyAsArray($this->fetchVocabulary($type)));
|
|
}
|
|
|
|
public function searchTag(Request $request)
|
|
{
|
|
$term = str_replace(['/', ':', '.'], ' ', strtolower($request->query->get('term')));
|
|
$res = [];
|
|
|
|
$term = explode(' ', $term, 2);
|
|
if(($term[0] = trim($term[0])) != '') {
|
|
if( ($nparts = count($term)) == 2) {
|
|
$term[1] = trim($term[1]);
|
|
}
|
|
$provider = new TagProvider();
|
|
|
|
foreach ($provider->getLookupTable() as $namespace => $tags) {
|
|
$match_ns = (strpos($namespace, $term[0]) !== false);
|
|
if($nparts == 2 && !$match_ns) {
|
|
// with "abc:xyz", "abc" MUST match the namespace
|
|
continue;
|
|
}
|
|
foreach ($tags as $tagname => $datas) {
|
|
if($nparts == 1) {
|
|
// "abc" can match the namespace OR the tagname
|
|
$match = $match_ns || (strpos($tagname, $term[0]) !== false);
|
|
}
|
|
else {
|
|
// match "abc:xyz" against namespace (already true) AND tagname
|
|
$match = ($term[1] == '' || strpos($tagname, $term[1]) !== false);
|
|
}
|
|
|
|
if($match) {
|
|
$res[] = [
|
|
'id' => $namespace . '/' . $tagname,
|
|
/** @Ignore */
|
|
'label' => $datas['namespace'] . ' / ' . $datas['tagname'],
|
|
'value' => $datas['namespace'] . ':' . $datas['tagname'],
|
|
];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return $this->app->json($res);
|
|
}
|
|
|
|
public function getTag($tagname)
|
|
{
|
|
$tag = \databox_field::loadClassFromTagName($tagname);
|
|
$json = $this->app['serializer']->serialize($tag, 'json');
|
|
|
|
return new Response($json, 200, ['Content-Type' => 'application/json']);
|
|
}
|
|
|
|
public function createField(Request $request, $sbas_id)
|
|
{
|
|
$databox = $this->findDataboxById((int) $sbas_id);
|
|
$data = $this->getFieldJsonFromRequest($request);
|
|
|
|
$metaStructure = $databox->get_meta_structure();
|
|
$this->validateNameField($metaStructure, $data);
|
|
$this->validateTagField($data);
|
|
|
|
try {
|
|
$field = \databox_field::create($this->app, $databox, $data['name']);
|
|
$this->updateFieldWithData($field, $data);
|
|
$field->save();
|
|
} catch (\Exception $e) {
|
|
throw new HttpException(500, $this->app->trans(
|
|
'Field %name% could not be created, please try again or contact an admin.',
|
|
['%name%' => $data['name']]
|
|
));
|
|
}
|
|
|
|
return $this->app->json($field->toArray(), 201, [
|
|
'location' => $this->app->path('admin_fields_show_field', [
|
|
'sbas_id' => $sbas_id,
|
|
'id' => $field->get_id(),
|
|
])]);
|
|
}
|
|
|
|
public function listFields($sbas_id)
|
|
{
|
|
$databox = $this->findDataboxById((int) $sbas_id);
|
|
|
|
return $this->app->json($databox->get_meta_structure()->toArray());
|
|
}
|
|
|
|
public function getField($sbas_id, $id)
|
|
{
|
|
$databox = $this->findDataboxById((int) $sbas_id);
|
|
$field = $databox->get_meta_structure()->get_element($id);
|
|
|
|
return $this->app->json($field->toArray());
|
|
}
|
|
|
|
public function updateField(Request $request, $sbas_id, $id)
|
|
{
|
|
$databox = $this->findDataboxById((int) $sbas_id);
|
|
$field = $databox->get_meta_structure()->get_element($id);
|
|
$data = $this->getFieldJsonFromRequest($request);
|
|
|
|
$this->validateTagField($data);
|
|
|
|
if ($field->get_name() !== $data['name']) {
|
|
$metaStructure = $databox->get_meta_structure();
|
|
$this->validateNameField($metaStructure, $data);
|
|
}
|
|
|
|
$this->updateFieldWithData($field, $data);
|
|
$field->save();
|
|
|
|
return $this->app->json($field->toArray());
|
|
}
|
|
|
|
public function deleteField($sbas_id, $id)
|
|
{
|
|
$databox = $this->findDataboxById((int) $sbas_id);
|
|
$databox->get_meta_structure()->get_element($id)->delete();
|
|
|
|
return new Response('', 204);
|
|
}
|
|
|
|
private function getFieldJsonFromRequest(Request $request)
|
|
{
|
|
$data = $this->requestBodyToJson($request);
|
|
$required = $this->getMandatoryFieldProperties();
|
|
|
|
foreach ($required as $key) {
|
|
if (false === array_key_exists($key, $data)) {
|
|
$this->app->abort(400, sprintf('The entity must contain a key `%s`', $key));
|
|
}
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
private function getFieldsJsonFromRequest(Request $request)
|
|
{
|
|
$data = $this->requestBodyToJson($request);
|
|
$required = $this->getMandatoryFieldProperties();
|
|
|
|
foreach ($data as $field) {
|
|
foreach ($required as $key) {
|
|
if (false === array_key_exists($key, $field)) {
|
|
$this->app->abort(400, sprintf('The entity must contain a key `%s`', $key));
|
|
}
|
|
}
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
private function updateFieldWithData(\databox_field $field, array $data)
|
|
{
|
|
$field
|
|
->set_name($data['name'])
|
|
->set_thumbtitle($data['thumbtitle'])
|
|
->set_tag(\databox_field::loadClassFromTagName($data['tag']))
|
|
->set_business($data['business'])
|
|
->set_aggregable($data['aggregable'])
|
|
->set_indexable($data['indexable'])
|
|
->set_multi($data['multi'])
|
|
->set_required($data['required'])
|
|
->set_separator($data['separator'])
|
|
->set_readonly($data['readonly'])
|
|
->set_type($data['type'])
|
|
->set_tbranch($data['tbranch'])
|
|
->set_generate_cterms($data['generate_cterms'])
|
|
->set_gui_editable($data['gui_editable'])
|
|
->set_gui_visible($data['gui_visible'])
|
|
->set_report($data['report'])
|
|
->setVocabularyControl(null)
|
|
->setVocabularyRestricted(false);
|
|
|
|
foreach ($data['labels'] as $code => $label) {
|
|
$field->set_label($code, $label);
|
|
}
|
|
|
|
if (isset($data['sorter'])) {
|
|
$field->set_position($data['sorter']);
|
|
}
|
|
|
|
try {
|
|
$vocabulary = $this->fetchVocabulary($data['vocabulary-type']);
|
|
$field->setVocabularyControl($vocabulary);
|
|
$field->setVocabularyRestricted($data['vocabulary-restricted']);
|
|
} catch (\InvalidArgumentException $e) {
|
|
// Invalid vocabulary requested
|
|
}
|
|
|
|
if ('' !== $dcesElement = (string) $data['dces-element']) {
|
|
$class = sprintf('\databox_Field_DCES_%s', $dcesElement);
|
|
|
|
if (!class_exists($class)) {
|
|
throw new BadRequestHttpException(sprintf('DCES element %s does not exist.', $dcesElement));
|
|
}
|
|
|
|
$field->set_dces_element(new $class());
|
|
}
|
|
}
|
|
|
|
private function getMandatoryFieldProperties()
|
|
{
|
|
return [
|
|
'name', 'multi', 'thumbtitle', 'tag', 'business', 'indexable', 'aggregable',
|
|
'required', 'separator', 'readonly', 'gui_editable', 'gui_visible' , 'type', 'tbranch', 'generate_cterms', 'report',
|
|
'vocabulary-type', 'vocabulary-restricted', 'dces-element', 'labels'
|
|
];
|
|
}
|
|
|
|
private function validateNameField(\databox_descriptionStructure $metaStructure, array $field)
|
|
{
|
|
if (null !== $metaStructure->get_element_by_name($field['name'])) {
|
|
throw new BadRequestHttpException(sprintf('Field %s already exists.', $field['name']));
|
|
}
|
|
}
|
|
|
|
private function validateTagField(array $field)
|
|
{
|
|
try {
|
|
\databox_field::loadClassFromTagName($field['tag'], true);
|
|
} catch (\Exception_Databox_metadataDescriptionNotFound $e) {
|
|
throw new BadRequestHttpException(sprintf('Provided tag %s is unknown.', $field['tag']));
|
|
}
|
|
}
|
|
|
|
private function requestBodyToJson(Request $request)
|
|
{
|
|
$body = $request->getContent();
|
|
$data = @json_decode($body, true);
|
|
|
|
if (JSON_ERROR_NONE !== json_last_error()) {
|
|
throw new BadRequestHttpException('Body must contain a valid JSON payload.');
|
|
}
|
|
|
|
return $data;
|
|
}
|
|
|
|
/**
|
|
* @return ControlProviderInterface[]|\Pimple
|
|
*/
|
|
private function getVocabularies()
|
|
{
|
|
return $this->app['vocabularies'];
|
|
}
|
|
}
|