572 lines
21 KiB
PHP
572 lines
21 KiB
PHP
<?php
|
|
|
|
namespace KupShop\ContentBundle\Controller;
|
|
|
|
use KupShop\AdminBundle\Util\BlocksHistory;
|
|
use KupShop\CDNBundle\CDN;
|
|
use KupShop\ContentBundle\Util\BlocekSettings;
|
|
use KupShop\ContentBundle\Util\Block;
|
|
use KupShop\ContentBundle\View\BlockEditView;
|
|
use KupShop\ContentBundle\View\BlockHistoryView;
|
|
use KupShop\I18nBundle\Translations\PhotosTranslation;
|
|
use KupShop\KupShopBundle\Query\JsonOperator;
|
|
use KupShop\KupShopBundle\Util\Functional\Mapping;
|
|
use KupShop\KupShopBundle\Util\Logging\SentryLogger;
|
|
use KupShop\KupShopBundle\Util\StringUtil;
|
|
use KupShop\KupShopBundle\Util\System\PathFinder;
|
|
use Query\Operator;
|
|
use Query\QueryBuilder;
|
|
use Query\Translation;
|
|
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
|
|
use Symfony\Component\HttpFoundation\File\UploadedFile;
|
|
use Symfony\Component\HttpFoundation\JsonResponse;
|
|
use Symfony\Component\HttpFoundation\Request;
|
|
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
|
|
use Symfony\Component\Routing\Annotation\Route;
|
|
|
|
class BlockController extends AbstractController
|
|
{
|
|
use \DatabaseCommunication;
|
|
|
|
public function __construct(protected ?CDN $cdn = null)
|
|
{
|
|
}
|
|
|
|
/**
|
|
* @Route("/_blocek/upload/")
|
|
*/
|
|
public function uploadAction(Request $request)
|
|
{
|
|
try {
|
|
$this->doCheckPermissions();
|
|
} catch (\Exception $e) {
|
|
return new JsonResponse([
|
|
'result' => false,
|
|
'error' => $e->getMessage(),
|
|
]);
|
|
}
|
|
|
|
$result = false;
|
|
$message = null;
|
|
try {
|
|
$result = sqlGetConnection()->transactional(
|
|
function () use ($request) {
|
|
$uploadedIds = [];
|
|
|
|
$photos = new \Photos('none');
|
|
|
|
/** @var UploadedFile $file */
|
|
foreach ($request->files->get('file', []) as $file) {
|
|
$data = [
|
|
'name' => $file->getClientOriginalName(),
|
|
'tmp_name' => $file->getRealPath(),
|
|
];
|
|
|
|
$photos->newImage();
|
|
$photos->uploadImage($data);
|
|
$photoId = $photos->insertImageIntoDB();
|
|
if (!$photoId) {
|
|
throw new \Exception('Nahrání se nepodařilo, zkuste to znovu.');
|
|
}
|
|
|
|
$uploadedIds[] = $photoId;
|
|
}
|
|
|
|
return $uploadedIds;
|
|
}
|
|
);
|
|
} catch (\Exception $e) {
|
|
$message = $e->getMessage();
|
|
}
|
|
|
|
return new JsonResponse([
|
|
'result' => $result,
|
|
'message' => $message,
|
|
]);
|
|
}
|
|
|
|
#[Route('/_blocek/video-info/')]
|
|
public function videoInfoAction(Request $request, PathFinder $pathFinder): JsonResponse
|
|
{
|
|
$result = false;
|
|
$message = null;
|
|
$data = [];
|
|
try {
|
|
if (!findModule(\Modules::CDN) || !$this->cdn) {
|
|
throw new \Exception('Není povolen modul CDN!');
|
|
}
|
|
|
|
$videos = $this->getPhotosData((array) $request->get('videoId', []), function (QueryBuilder $qb) {
|
|
$qb->leftJoin('ph', 'videos', 'v', 'ph.id = v.id_photo');
|
|
$qb->addSelect('v.*');
|
|
});
|
|
|
|
foreach ($videos as $video) {
|
|
if (!$video['id_cdn']) {
|
|
throw new \Exception('Video není nahráno v CDN!');
|
|
}
|
|
|
|
$data[] = [
|
|
'id' => (int) $video['id'],
|
|
'title' => $video['descr'],
|
|
'id_cdn' => $video['id_cdn'],
|
|
'url_mp4' => $this->cdn->getMP4Video($video['id_cdn'], '720p'),
|
|
'url_hls' => $this->cdn->getHLSPlaylist($video['id_cdn']),
|
|
'thumbnail' => $this->cdn->getThumbnail($video['id_cdn'])['url'],
|
|
];
|
|
}
|
|
|
|
$result = true;
|
|
} catch (\Exception $e) {
|
|
$message = $e->getMessage();
|
|
$data = [];
|
|
}
|
|
|
|
return $this->jsonResponse(result: $result, data: $data, message: $message);
|
|
}
|
|
|
|
/**
|
|
* @Route("/_blocek/photo-info/")
|
|
*/
|
|
public function photoInfoAction(Request $request, PathFinder $pathFinder): JsonResponse
|
|
{
|
|
$result = false;
|
|
$message = null;
|
|
$data = [];
|
|
try {
|
|
foreach ($this->getPhotosData((array) $request->get('photoId', [])) as $photo) {
|
|
$file = $pathFinder->getDataDir().'photos/'.$photo['source'].$photo['image_2'];
|
|
if (!file_exists($file)) {
|
|
throw new \Exception('Obrázek nebyl nalezen!');
|
|
}
|
|
|
|
[$width, $height] = getimagesize($file);
|
|
|
|
$data[] = [
|
|
'id' => (int) $photo['id'],
|
|
'width' => $width,
|
|
'height' => $height,
|
|
'timestamp' => filemtime($file),
|
|
'title' => $photo['descr'],
|
|
];
|
|
}
|
|
|
|
$result = true;
|
|
} catch (\Exception $e) {
|
|
$message = $e->getMessage();
|
|
$data = [];
|
|
}
|
|
|
|
return $this->jsonResponse(result: $result, data: $data, message: $message);
|
|
}
|
|
|
|
private function jsonResponse(bool $result, array $data, ?string $message = null): JsonResponse
|
|
{
|
|
return new JsonResponse(
|
|
[
|
|
'result' => $result,
|
|
'message' => $message,
|
|
'data' => $data,
|
|
],
|
|
200,
|
|
[
|
|
'Access-Control-Allow-Origin' => '*',
|
|
]
|
|
);
|
|
}
|
|
|
|
private function getPhotosData(array $ids, ?callable $specs = null): array
|
|
{
|
|
$photos = sqlQueryBuilder()
|
|
->select('ph.*')
|
|
->from('photos', 'ph')
|
|
->andWhere(Operator::inIntArray($ids, 'ph.id'))
|
|
->andWhere(Translation::coalesceTranslatedFields(PhotosTranslation::class));
|
|
|
|
if ($specs) {
|
|
$photos->andWhere($specs);
|
|
}
|
|
|
|
return $photos->execute()->fetchAllAssociative();
|
|
}
|
|
|
|
/**
|
|
* @Route("/_blocek/edit-block/{id}/")
|
|
*/
|
|
public function editBlockAction(Request $request, Block $block, BlockEditView $blockEditView, $id)
|
|
{
|
|
$blockEditView->setBlockId($id);
|
|
|
|
return $blockEditView->getResponse();
|
|
}
|
|
|
|
/**
|
|
* @Route("/_blocek/history-block/{historyId}/{blockId}/")
|
|
*/
|
|
public function historyBlockAction(Request $request, Block $block, BlockHistoryView $blockHistoryView, $historyId, $blockId)
|
|
{
|
|
$blockHistoryView->setBlockId($blockId);
|
|
$blockHistoryView->setHistoryId($historyId);
|
|
|
|
return $blockHistoryView->getResponse();
|
|
}
|
|
|
|
/**
|
|
* @Route("/_blocek/save-block/")
|
|
*/
|
|
public function saveBlockAction(Request $request, SentryLogger $sentryLogger, BlocksHistory $blocksHistory, Block $blockUtil)
|
|
{
|
|
try {
|
|
$this->doCheckPermissions();
|
|
} catch (\Exception $e) {
|
|
return new JsonResponse([
|
|
'result' => false,
|
|
'error' => $e->getMessage(),
|
|
]);
|
|
}
|
|
|
|
$data_array = json_decode($request->getContent(), true);
|
|
|
|
try {
|
|
$result = sqlGetConnection()->transactional(
|
|
function () use ($blockUtil, $data_array, $blocksHistory) {
|
|
foreach ($data_array as $data) {
|
|
if ($data['id_block'] = $this->getBlockId($blockUtil,
|
|
$data['id_block'] ?: null,
|
|
$data['object_type'] ?: null,
|
|
$data['object_id'] ?: null)) {
|
|
// get images blocks
|
|
$imagesBlocks = $this->getImageBlocks(json_decode($data['json_content'], true));
|
|
|
|
$language = ($data['id_language'] ?? null);
|
|
$data['json_content'] = json_encode(json_decode($data['json_content'], true));
|
|
$data['content'] = StringUtil::unicodeToEntities($data['content']);
|
|
if (!$language) {
|
|
$block = ['id' => $data['id_block'], 'name' => '', 'content' => $data['content']];
|
|
$blocksHistory->saveBlocksHistory([$data['id_block'] => $block]);
|
|
// save content
|
|
sqlQueryBuilder()->update('blocks')
|
|
->directValues(
|
|
[
|
|
'json_content' => $data['json_content'],
|
|
'content' => $data['content'],
|
|
]
|
|
)
|
|
->where(Operator::equals(['id' => $data['id_block']]))
|
|
->execute();
|
|
|
|
$rootId = sqlQueryBuilder()->select('id_root')->from('blocks')
|
|
->where(Operator::equals(['id' => $data['id_block']]))
|
|
->execute()->fetchColumn();
|
|
$pageID = sqlQueryBuilder()->select('id')->from('pages')
|
|
->where(Operator::equals(['id_block' => $rootId]))
|
|
->execute()->fetchColumn();
|
|
if ($pageID) {
|
|
$this->updateSQL('pages', ['updated' => date('Y-m-d H:i:s')], ['id' => $pageID]);
|
|
}
|
|
} else {
|
|
// save content - translations
|
|
$originalName = sqlQueryBuilder()->select('name')->from('blocks_translations')
|
|
->where(Operator::equals([
|
|
'id_block' => $data['id_block'],
|
|
'id_language' => $data['id_language'],
|
|
]))->setMaxResults(1)->execute()->fetchColumn(0);
|
|
if ($originalName === false) {
|
|
$this->insertSQL('blocks_translations',
|
|
[
|
|
'id_block' => $data['id_block'],
|
|
'id_language' => $data['id_language'],
|
|
'json_content' => $data['json_content'],
|
|
'content' => $data['content'],
|
|
]);
|
|
} else {
|
|
$this->updateSQL('blocks_translations',
|
|
[
|
|
'name' => $originalName,
|
|
'json_content' => $data['json_content'],
|
|
'content' => $data['content'],
|
|
'updated' => date('Y-m-d H:i:s'),
|
|
],
|
|
[
|
|
'id_block' => $data['id_block'],
|
|
'id_language' => $data['id_language'],
|
|
]);
|
|
}
|
|
}
|
|
|
|
// create photos relations
|
|
sqlQueryBuilder()->delete('photos_blocks_new_relation')
|
|
->where(Operator::equals(['id_block' => $data['id_block']]))
|
|
->execute();
|
|
|
|
if (!empty($imagesBlocks)) {
|
|
foreach ($imagesBlocks as $imageBlock) {
|
|
if (isset($imageBlock['settings']['photo'])) {
|
|
$imageBlock['settings']['photos'][0]['photo'] = $imageBlock['settings']['photo'];
|
|
}
|
|
$photos = $imageBlock['settings']['photos'];
|
|
foreach ($photos as $ph) {
|
|
try {
|
|
$photoId = $ph['photo']['id'];
|
|
sqlQueryBuilder()
|
|
->insert('photos_blocks_new_relation')
|
|
->directValues(
|
|
[
|
|
'id_photo' => $photoId,
|
|
'id_block' => $data['id_block'],
|
|
]
|
|
)->execute();
|
|
} catch (\Exception $e) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
throw new \Exception('Nor id_block, object_type or object_id specified!');
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
);
|
|
} catch (\Exception $e) {
|
|
$sentryLogger->captureException($e);
|
|
|
|
return new JsonResponse([
|
|
'result' => false,
|
|
'error' => $e->getMessage(),
|
|
]);
|
|
}
|
|
|
|
return new JsonResponse([
|
|
'result' => $result,
|
|
]);
|
|
}
|
|
|
|
protected function getBlockId(Block $blockUtil, ?int $id_block, ?string $objectType, ?int $objectId)
|
|
{
|
|
if ($id_block ?? false) {
|
|
return $id_block;
|
|
}
|
|
if (!$objectType || !$objectId) {
|
|
return false;
|
|
}
|
|
|
|
return $blockUtil->insertFirstBlock($objectType, $objectId, '');
|
|
}
|
|
|
|
public function getImageBlocks($settings)
|
|
{
|
|
$result = [];
|
|
foreach ($settings as $setting) {
|
|
$imageBlocks = array_filter(
|
|
$settings,
|
|
function ($x) {
|
|
return isset($x['settings']['photo']) || isset($x['settings']['photos']);
|
|
}
|
|
);
|
|
$result = array_merge($result, $imageBlocks);
|
|
if (!empty($setting['children'])) {
|
|
$result = array_merge($result, $this->getImageBlocks($setting['children']));
|
|
}
|
|
}
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function doCheckPermissions()
|
|
{
|
|
if (!getAdminUser()) {
|
|
throw new NotFoundHttpException('Platnost přihlášení vypršela');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @Route("/_blocek/ProductsBlock/")
|
|
*/
|
|
public function getProductsAction(Request $request, Block $blockUtil)
|
|
{
|
|
if (!$request->getContent()) {
|
|
throw new NotFoundHttpException('Empty data');
|
|
}
|
|
|
|
$blocekData = json_decode_strict($request->getContent(), true);
|
|
|
|
$filterSpecs = $blockUtil->getProductsBlockSpecs($blocekData);
|
|
|
|
$smarty = createSmarty(false, true);
|
|
$smarty->assign('spec', $filterSpecs);
|
|
$smarty->assign('data', $blocekData);
|
|
|
|
$response['html'] = $smarty->fetch('block.products.blocek.tpl');
|
|
$response['result'] = true;
|
|
$response['filter'] = $blocekData;
|
|
|
|
// Detect empty product list in edit mode
|
|
if ($request->get('editor') && strpos($response['html'], 'href') === false) {
|
|
$response['result'] = false;
|
|
}
|
|
|
|
return new JsonResponse($response);
|
|
}
|
|
|
|
protected function getOrderDir($order_dir)
|
|
{
|
|
$order_dir = trim($order_dir);
|
|
if (($order_dir != 'ASC') && ($order_dir != 'DESC')) {
|
|
$order_dir = 'ASC';
|
|
}
|
|
|
|
return $order_dir;
|
|
}
|
|
|
|
protected function getOrderFields($order_by)
|
|
{
|
|
switch ($order_by) {
|
|
case 'code':
|
|
$order = 'p.code';
|
|
break;
|
|
case 'title':
|
|
$order = 'p.title';
|
|
break;
|
|
case 'price':
|
|
$order = 'p.price';
|
|
break;
|
|
case 'date':
|
|
$order = 'p.date_added';
|
|
break;
|
|
case 'sell':
|
|
$order = 'p.pieces_sold';
|
|
break;
|
|
case 'discount':
|
|
$order = 'p.discount';
|
|
break;
|
|
case 'store':
|
|
$order = 'p.in_store';
|
|
break;
|
|
case 'random':
|
|
$order = 'RAND()';
|
|
break;
|
|
default:
|
|
$order = 'p.title';
|
|
break;
|
|
}
|
|
|
|
return $order;
|
|
}
|
|
|
|
#[Route('/_blocek/settings/')]
|
|
public function getBlocekSettings(BlocekSettings $blocekSettings): JsonResponse
|
|
{
|
|
$blocekSettings->fetchSettings();
|
|
|
|
return new JsonResponse(['message' => 'BlocekSettings', 'data' => $blocekSettings->asArray()]);
|
|
}
|
|
|
|
/**
|
|
* @Route("/_blocek/templates/")
|
|
*/
|
|
public function getTemplatesAction(Block $blockUtils)
|
|
{
|
|
$message = null;
|
|
$data = [];
|
|
|
|
if (!findModule(\Modules::TEMPLATES)) {
|
|
return new JsonResponse(
|
|
[
|
|
'message' => 'No templates module',
|
|
'data' => $data,
|
|
]
|
|
);
|
|
}
|
|
|
|
$qb = sqlQueryBuilder()
|
|
->select('tc.*')
|
|
->from('templates_categories', 'tc')
|
|
->Where(Operator::like([JsonOperator::value('tc.data', 'show_in_editor') => 'Y']));
|
|
|
|
$templateCategories = sqlFetchAll($qb->execute(), 'id');
|
|
$templateCategoriesIDs = array_keys($templateCategories);
|
|
|
|
$templates = sqlQueryBuilder()
|
|
->select('t.*')
|
|
->from('templates', 't')
|
|
->where(Operator::inIntArray($templateCategoriesIDs, 't.id_category'));
|
|
|
|
foreach ($templates->execute() as $template) {
|
|
$blocks = $blockUtils->getBlocks($template['id_block']);
|
|
|
|
// beru obsah jen prvního bloku
|
|
if ($blocks[0]['content'] ?? false) {
|
|
$data[] = [
|
|
'name' => $template['name'],
|
|
'group' => $templateCategories[$template['id_category']]['name'],
|
|
'content' => json_decode($blocks[0]['json_content']),
|
|
];
|
|
}
|
|
}
|
|
|
|
return new JsonResponse(
|
|
[
|
|
'message' => $message,
|
|
'data' => $data,
|
|
]
|
|
);
|
|
}
|
|
|
|
#[Route('/_blocek/icons/')]
|
|
public function getIconsAction(Block $blockUtils): JsonResponse
|
|
{
|
|
$fontIcons = json_decode_strict(file_get_contents('web/build/icons-list.json'), true);
|
|
|
|
$fileIcons = new \GlobIterator('data/icons/*.svg', \FilesystemIterator::CURRENT_AS_PATHNAME);
|
|
$fileIcons = Mapping::mapKeys($fileIcons, fn ($fileName) => [basename('file-'.$fileName, '.svg'), '/'.$fileName]);
|
|
|
|
return new JsonResponse(
|
|
[
|
|
'success' => true,
|
|
'font_icons' => $fontIcons,
|
|
'file_icons' => $fileIcons,
|
|
]
|
|
);
|
|
}
|
|
|
|
#[Route('/_blocek/icons-inline/')]
|
|
public function getIconsInlineAction(Block $blockUtils): JsonResponse
|
|
{
|
|
if (!findModule(\Modules::COMPONENTS)) {
|
|
$fontIcons = json_decode_strict(file_get_contents('web/build/icons-list.json'), true);
|
|
}
|
|
|
|
$engineIcons = new \GlobIterator('engine/web/common/static/images/icons/*.svg', \FilesystemIterator::CURRENT_AS_PATHNAME);
|
|
$shopIcons = new \GlobIterator('data/icons/*.svg', \FilesystemIterator::CURRENT_AS_PATHNAME);
|
|
|
|
$fileIcons = [];
|
|
|
|
// Apparently, its not necessary to strip doctype and xml tag, blocek lib will handle this.
|
|
// foreach ($engineIcons as $iconPath) {
|
|
// $icon = Icon::fromFile($iconPath);
|
|
// $fileIcons[basename($iconPath, '.svg')] = $icon->toHtml();
|
|
// }
|
|
// foreach ($shopIcons as $iconPath) {
|
|
// $icon = Icon::fromFile($iconPath);
|
|
// $fileIcons[basename($iconPath, '.svg')] = $icon->toHtml();
|
|
// }
|
|
|
|
foreach ($engineIcons as $iconPath) {
|
|
$fileIcons[basename($iconPath, '.svg')] = file_get_contents($iconPath);
|
|
}
|
|
foreach ($shopIcons as $iconPath) {
|
|
$fileIcons[basename($iconPath, '.svg')] = file_get_contents($iconPath);
|
|
}
|
|
|
|
return new JsonResponse(
|
|
[
|
|
'success' => true,
|
|
'font_icons' => $fontIcons ?? [],
|
|
'file_icons' => $fileIcons,
|
|
]
|
|
);
|
|
}
|
|
}
|