src/PromemoriaBundle/Controller/ApiController.php line 31

Open in your IDE?
  1. <?php
  3. namespace App\PromemoriaBundle\Controller;
  5. use Pimcore\Db;
  6. use Pimcore\File;
  7. use Pimcore\Tool;
  8. use Pimcore\Model\User;
  9. use Pimcore\Security\User\User as UserAdmin;
  10. use Pimcore\Model\Asset;
  11. use Pimcore\Tool\Session;
  12. use Pimcore\Event\AdminEvents;
  13. use Pimcore\Tool\Authentication;
  14. use Pimcore\Controller\FrontendController;
  15. use Pimcore\Bundle\AdminBundle\Controller\Admin;
  16. use Pimcore\Controller\Configuration\ResponseHeader;
  17. use Pimcore\Event\Admin\Login\LoginCredentialsEvent;
  19. use Symfony\Component\HttpFoundation\Request;
  20. use Symfony\Component\HttpFoundation\Response;
  21. use Symfony\Component\Routing\Annotation\Route;
  22. use Symfony\Component\HttpFoundation\JsonResponse;
  23. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  24. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  25. use Symfony\Component\HttpFoundation\StreamedResponse;
  26. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  27. use Symfony\Component\HttpFoundation\Session\Attribute\AttributeBagInterface;
  31. class ApiController extends FrontendController
  32. {
  34.        /**
  35.      * @Route("/promemoria/api/login", methods={"POST"})
  36.      * @param Request $request
  37.      *
  38.      * @return JsonResponse
  39.      */
  40.     public function login(Request $request)
  41.     {
  43.         $response = new Response();
  44.         $response->setStatusCode(401);
  46.         $data = json_decode($request->getContent());
  48.         if (!empty($data->username) &&  !empty($data->password)) {
  50.             $credentials = [
  51.                 'username' => $data->username,
  52.                 'password' => $data->password
  53.             ];
  55.             $event = new LoginCredentialsEvent($request, $credentials);
  56.             try {
  57.                 $this->dispatcher->dispatch(AdminEvents::LOGIN_CREDENTIALS, $event);
  58.             } catch (\Throwable $th) {
  60.             }
  61.             $pimcoreUser = Authentication::authenticatePlaintext($data->username, $data->password);
  62.             if ($pimcoreUser) {
  63.                 return Session::useSession(function (AttributeBagInterface $adminSession) use ($pimcoreUser) {
  64.                     $user = new UserAdmin($pimcoreUser);
  65.                     Session::regenerateId();
  66.                     $adminSession->set('user', $pimcoreUser);
  67.                     $adminSession->set('2fa_required', true);
  68.                     return $this->json(['ok' => true, 'user' => array(
  69.                         'id' => $pimcoreUser->getId(),
  70.                         'firstname' => $pimcoreUser->getFirstname(),
  71.                         'lastname' => $pimcoreUser->getLastname(),
  72.                         'email' => $pimcoreUser->getEmail(),
  73.                         'roles' => $user->getRoles()
  74.                     )]);
  75.                 });
  76.             }
  77.         }
  79.         return $response;
  81.     }
  83.     /**
  84.      * @Route("/promemoria/api/logout", methods={"POST", "GET"})
  85.      *
  86.      * @return JsonResponse
  87.      */
  88.     public function logout()
  89.     {
  91.         return $this->redirectToRoute('pimcore_admin_logout');
  93.     }
  95.     /**
  96.      * @Route("/promemoria/api/get-audio-thumbnail", methods={"GET"})
  97.      *
  98.      * @param Request $request
  99.      *
  100.      * @return BinaryFileResponse
  101.      */
  102.     public function getAudioThumbnail(Request $request)
  103.     {
  104.         $response = new BinaryFileResponse(__DIR__ . "/../Placeholder/audio.png");
  105.         $this->addThumbnailCacheHeaders($response);
  106.         return $response;
  108.     }
  110.     /**
  111.      * @Route("/promemoria/api/get-image-thumbnail", methods={"GET"})
  112.      *
  113.      * @param Request $request
  114.      *
  115.      * @return BinaryFileResponse|StreamedResponse
  116.      */
  117.     public function getImageThumbnail(Request $request)
  118.     {
  119.         $id = $request->get('id');
  120.         if(!$this->checkHash($id)){
  121.             $response = new Response();
  122.             $response->setStatusCode(401);
  123.             return $response;
  124.         }
  125.         $image = Asset\Image::getById(intval($id));
  126.         $thumb = $this->getThumb($image, $request->get('version', 'thumbnail'));
  127.         return $this->responseThumbnail($thumb);
  129.     }
  131.     /**
  132.      * @Route("/promemoria/api/get-video-thumbnail", methods={"GET"})
  133.      *
  134.      * @param Request $request
  135.      *
  136.      * @return BinaryFileResponse|StreamedResponse
  137.      */
  138.     public function getVideoThumbnail(Request $request)
  139.     {
  140.         $id = $request->get('id');
  141.         if(!$this->checkHash($id)){
  142.             $response = new Response();
  143.             $response->setStatusCode(401);
  144.             return $response;
  145.         }
  146.         $video = Asset\Video::getById(intval($id));
  147.         $thumb = $video->getImageThumbnail(Asset\Image\Thumbnail\Config::getPreviewConfig());
  148.         return $this->responseThumbnail($thumb);
  150.     }
  152.     /**
  153.      * @Route("/promemoria/api/get-document-thumbnail", methods={"GET"})
  154.      *
  155.      * @param Request $request
  156.      *
  157.      * @return BinaryFileResponse|StreamedResponse
  158.      */
  159.     public function getDocumentThumbnail(Request $request)
  160.     {
  161.         $id = $request->get('id');
  162.         if(!$this->checkHash($id)){
  163.             $response = new Response();
  164.             $response->setStatusCode(401);
  165.             return $response;
  166.         }
  167.         $document = Asset\Document::getById(intval($id));
  168.         $thumb = new Asset\Document\ImageThumbnail($document, Asset\Image\Thumbnail\Config::getPreviewConfig(), 1);
  169.         return $this->responseThumbnail($thumb);
  170.     }
  172.     /**
  173.      * @Route("/promemoria/api/get-video-preview", methods={"GET"})
  174.      *
  175.      * @param Request $request
  176.      *
  177.      * @return BinaryFileResponse
  178.      */
  179.     public function getVideoPreview(Request $request)
  180.     {
  182.         $response = new Response();
  183.         $response->setStatusCode(400);
  185.         $id = $request->get('id');
  186.         if(!$this->checkHash($id)){
  187.             $response->setStatusCode(401);
  188.             return $response;
  189.         }
  190.         $asset = Asset::getById(intval($id));
  192.         if(!empty($asset) && $asset->getType()=='video'){
  193.             $thumbnail = $asset->getThumbnail(Asset\Video\Thumbnail\Config::getPreviewConfig(), ['mp4']);
  194.             $storagePath = $asset->getRealPath() . '/' . preg_replace('@^' . preg_quote($asset->getPath(), '@') . '@', '', urldecode($thumbnail['formats']['mp4']));
  195.             $storage = \Pimcore\Tool\Storage::get('thumbnail');
  196.             if ($storage->fileExists($storagePath)) {
  197.                 $fs = $storage->fileSize($storagePath);
  198.                 $stream = $storage->readStream($storagePath);
  200.                 return new StreamedResponse(function () use ($stream) {
  201.                     fpassthru($stream);
  202.                 }, 200, [
  203.                     'Content-Type' => 'video/mp4',
  204.                     'Content-Length' => $fs,
  205.                     'Accept-Ranges' => 'bytes',
  206.                 ]);
  207.             } else {
  208.                 $response->setStatusCode(204);
  209.             }
  210.         }
  211.         return $response;
  213.     }
  215.     /**
  216.      * @param Response $response
  217.      */
  218.     protected function responseThumbnail($thumb)
  219.     {
  220.         $stream = $thumb->getStream();
  221.         if ($stream) {
  222.             $response = new StreamedResponse(function () use ($stream) {
  223.                 fpassthru($stream);
  224.             }, 200, [
  225.                 'Content-Type' => 'image/' . $thumb->getFileExtension(),
  226.             ]);
  227.         } else {
  228.             $pathparts = pathinfo($thumb->getAsset()->getFilename());
  229.             $ext = isset($pathparts["extension"]) ? $pathparts["extension"] : 'image';
  230.             $tmpfname = tempnam("/tmp", "image.png");
  231.             file_put_contents($tmpfname, file_get_contents("https://dummyimage.com/300x300/3e3e3e/ffffff.png&text=%20{$ext}%20"));
  232.             $response = new BinaryFileResponse($tmpfname);
  233.         }
  234.         $this->addThumbnailCacheHeaders($response);
  235.         return $response;
  237.     }
  239.     /**
  240.      * @Route("/promemoria/api/download-as-zip", methods={"GET"})
  241.      *
  242.      * @param Request $request
  243.      *
  244.      * @return BinaryFileResponse
  245.      */
  246.     public function downloadAsZip(Request $request)
  247.     {
  249.         $name = $request->get('name', '');
  250.         $version = $request->get('version', 'original');
  251.         $watermarked = $request->get('watermarked', 0);
  253.         $zipName = ($name ?: 'collection-' . time()) . '.zip';
  254.         $zipFile = tempnam("/tmp", $zipName);
  256.         $zip = new \ZipArchive();
  257.         $zipState = $zip->open($zipFile, \ZipArchive::CREATE);
  259.         $selectedIds = $request->get('selectedIds', '');
  261.         if (strlen($selectedIds) > 0 && $zipState === true) {
  263.             $conditionFilters = [];
  265.             $selectedIds = explode(',', $selectedIds);
  266.             $ids = [];
  267.             foreach ($selectedIds as $id) {
  268.                 if(!$this->checkHash($id)){
  269.                     $response = new Response();
  270.                     $response->setStatusCode(401);
  271.                     return $response;
  272.                 }
  273.                 $ids[] = intval($id);
  274.             }
  275.             $conditionFilters[] = 'id IN (' . implode(',', $ids) . ')';
  276.             $conditionFilters[] .= "type != 'folder'";
  277.             $condition = implode(' AND ', $conditionFilters);
  279.             $assetList = new Asset\Listing();
  280.             $assetList->setCondition($condition);
  281.             $assetList->setOrderKey('LENGTH(path) ASC, id ASC', false);
  282.             $assetList->setOffset((int)$request->get('offset'));
  283.             $assetList->setLimit((int)$request->get('limit'));
  285.             foreach ($assetList->load() as $a) {
  286.                 if (!$a instanceof Asset\Folder) {
  287.                     if($a instanceof Asset\Image){
  288.                         $a = $this->getThumb($a, $watermarked ? $version : "no_watermark", $version === 'original');
  289.                     }
  290.                     if ($a instanceof Asset\Image\Thumbnail) {
  291.                         $dir_prefix = '/var/www/html/public/var/tmp/thumbnails';
  292.                         $pathReference = $a->getPathReference();
  293.                         //serve per generare la thumb nel caso non esista
  294.                         $fileContent = Tool\Storage::get('thumbnail')->read($pathReference['storagePath']);
  295.                         $path = urldecode($a->getPath());
  296.                     } else {
  297.                         $dir_prefix = '/var/www/html/public/var/assets';
  298.                         $path = $a->getRealFullPath();
  299.                     }
  300.                     $zip->addFile($dir_prefix.$path, basename($path));
  301.                 }
  302.             }
  304.             $zip->close();
  306.             $response = new BinaryFileResponse($zipFile);
  307.             $response->headers->set('Content-Type', 'application/zip');
  308.             $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $zipName);
  309.             $response->deleteFileAfterSend(true);
  311.             return $response;
  313.         }
  315.         return $this->json(['error' => true]);
  317.     }
  319.     /**
  320.      * @Route("/promemoria/api/getShortToken", methods={"GET"})
  321.      * @param Request $request
  322.      *
  323.      * @return JsonResponse
  324.      */
  325.     public function getShortToken(Request $request)
  326.     {
  328.         $response = new Response();
  329.         $response->setStatusCode(400);
  331.         $db = \Pimcore\Db::get();
  332.         $jwtToken = $request->get('jwtToken');
  334.         $this->clearExpiredShortUrls();
  336.         if (!empty($jwtToken)) {
  338.             $generatedToken = substr(md5(uniqid(mt_rand(), true)), 0, 8);
  340.             $db->insert('promemoria_shorturl', [
  341.                 'jwtToken' => $jwtToken,
  342.                 'shortToken' => $generatedToken
  343.             ]);
  345.             return $this->json(['shortToken' => $generatedToken]);
  346.         }
  348.         return $response;
  350.     }
  352.     /**
  353.      * @Route("/promemoria/api/getJwtToken", methods={"GET"})
  354.      * @param Request $request
  355.      *
  356.      * @return JsonResponse
  357.      */
  358.     public function getJwtToken(Request $request)
  359.     {
  361.         $response = new Response();
  362.         $response->setStatusCode(400);
  364.         $db = \Pimcore\Db::get();
  365.         $shortToken = $request->get('shortToken');
  367.         $this->clearExpiredShortUrls();
  369.         if (!empty($shortToken)) {
  371.             $res = $db->fetchRow("SELECT jwtToken FROM promemoria_shorturl WHERE shortToken = " . $db->quote($shortToken));
  373.             return $this->json(['jwtToken' => $res['jwtToken']]);
  374.         }
  376.         return $response;
  378.     }
  380.     /**
  381.      * @Route("/promemoria/api/changePassword", methods={"POST"})
  382.      * @param Request $request
  383.      *
  384.      * @return JsonResponse
  385.      */
  386.     public function changePassword(Request $request)
  387.     {
  389.         $response = new Response();
  390.         $response->setStatusCode(401);
  392.         $data = json_decode($request->getContent());
  393.         $oldPassword = $data->oldPassword;
  394.         $newPassword = $data->password;
  396.         $pimcoreUser = Authentication::authenticateSession();
  398.         if($pimcoreUser && !empty($newPassword)){
  399.             $checkOldPassword = Authentication::authenticatePlaintext($pimcoreUser->getUsername(), $oldPassword);
  400.             if ($checkOldPassword) {
  401.                 $pimcoreUser->setPassword(Authentication::getPasswordHash($pimcoreUser->getUsername(), $newPassword));
  402.                 $pimcoreUser->save();
  403.                 return $this->json(['message' => 'Password changed']);
  404.             }
  405.         }
  406.         return $response;
  407.     }
  409.     /**
  410.      * @Route("/promemoria/api/getUserList", methods={"POST"}))
  411.      * @param Request $request
  412.      *
  413.      * @return JsonResponse
  414.      */
  415.     public function getUserList(Request $request)
  416.     {
  417.         $pimcoreUser = Authentication::authenticateSession();
  418.         if(empty($pimcoreUser)){
  419.             $response = new Response();
  420.             $response->setStatusCode(401);
  421.             return $response;
  422.         }
  424.         $db = \Pimcore\Db::get();
  425.         $query = <<<QUERY
  426.         SELECT u.id as user_id, u.name as user_name, u.firstname as fname, u.lastname as lname, u.email, r.id as role_id, r.name as role
  427.         FROM users u
  428.         INNER JOIN users r ON u.type = 'user' and u.roles = r.id and u.roles != '' and u.active = 1
  429.         order by u.name asc
  430. QUERY;
  431.         return $this->json(['users' => $db->executeQuery($query)->fetchAll()]);
  432.     }
  434.     /**
  435.     * @Route("/promemoria/api/getRoleList", methods={"POST"}))
  436.     * @param Request $request
  437.     *
  438.     * @return JsonResponse
  439.     */
  440.     public function getRoleList(Request $request)
  441.     {
  442.         $pimcoreUser = Authentication::authenticateSession();
  443.         if(empty($pimcoreUser)){
  444.             $response = new Response();
  445.             $response->setStatusCode(401);
  446.             return $response;
  447.         }
  449.         $db = \Pimcore\Db::get();
  450.         $query = <<<QUERY
  451.         SELECT u.id as role_id, u.name as name
  452.         FROM users u
  453.         WHERE
  454.         u.type = 'role'
  455.         order by u.name asc
  456. QUERY;
  457.         return $this->json(['roles' => $db->executeQuery($query)->fetchAll()]);
  458.     }
  460.     /**
  461.      * @Route("/promemoria/api/upsertUser", methods={"POST"})
  462.      * @param Request $request
  463.      *
  464.      * @return JsonResponse
  465.      */
  466.     public function upsertUser(Request $request)
  467.     {
  469.         $pimcoreUser = Authentication::authenticateSession();
  470.         if(empty($pimcoreUser)){
  471.             $response = new Response();
  472.             $response->setStatusCode(401);
  473.             return $response;
  474.         }
  475.         $userAdmin = new UserAdmin($pimcoreUser);
  476.         if(!in_array("ROLE_PIMCORE_ADMIN", $userAdmin->getRoles())
  477.             && !in_array("ROLE_MANAGER", $userAdmin->getRoles())){
  478.             $response = new Response();
  479.             $response->setStatusCode(401);
  480.             return $response;
  481.         }
  483.         $data = json_decode($request->getContent());
  484.         $user = new User();
  485.         if(!empty($data->user_id)){
  486.             $user = User::getById($data->user_id);
  487.         }
  488.         $user->setParentId(0);
  489.         $user->setUsername($data->user_name);
  490.         $user->setFirstname($data->fname);
  491.         $user->setLastname($data->lname);
  492.         $user->setEmail($data->email);
  493.         $user->setActive($data->active);
  494.         $user->setLanguage("it");
  495.         $user->setContentLanguages("it,en");
  496.         if(!empty($data->password)){
  497.             $user->setPassword(Authentication::getPasswordHash($data->user_name, $data->password));
  498.         }
  499.         $user->setRoles([$data->role_id]);
  500.         $user->save();
  502.         return $this->json(['message' => 'User updated']);
  503.     }
  505.     /**
  506.      * @Route("/promemoria/api/deleteUser", methods={"POST"})
  507.      * @param Request $request
  508.      *
  509.      * @return JsonResponse
  510.      */
  511.     public function deleteUser(Request $request)
  512.     {
  514.         $pimcoreUser = Authentication::authenticateSession();
  515.         if(empty($pimcoreUser)){
  516.             $response = new Response();
  517.             $response->setStatusCode(401);
  518.             return $response;
  519.         }
  520.         $data = json_decode($request->getContent());
  521.         $user = User::getById($data->user_id);
  522.         $userAdmin = new UserAdmin($user);
  523.         if(in_array("ROLE_PIMCORE_ADMIN", $userAdmin->getRoles())){
  524.             $response = new Response();
  525.             $response->setStatusCode(401);
  526.             return $response;
  527.         }
  528.         $user->delete();
  529.         return $this->json(['message' => 'User deleted']);
  530.     }
  532.     /**
  533.      * @Route("/promemoria/api/buca", methods={"POST"})
  534.      * @param Request $request
  535.      *
  536.      * @return JsonResponse
  537.      */
  538.     public function buca(Request $request)
  539.     {
  540.         $token = $request->get("token");
  541.         $config = \App\PromemoriaBundle\PromemoriaBundle::getConfig();
  542.         if(!empty($config["googleRecaptchaSecretKey"]) && !empty($token)){
  543.             $verifyResponse = file_get_contents('https://www.google.com/recaptcha/api/siteverify?secret=' . $config["googleRecaptchaSecretKey"] . '&response=' . $token);
  544.             $responseData = json_decode($verifyResponse);
  545.             if (!$responseData->success || $responseData->score < 0.5) {
  546.                 $response = new Response();
  547.                 $response->setStatusCode(401);
  548.                 return $response;
  549.             }
  550.             $email = $request->get("email");
  551.             $pimcoreUsername = empty($email) ? "website" : $email;
  552.             $pimcoreId = 0;
  553.         }else{
  554.             $pimcoreUser = Authentication::authenticateSession();
  555.             if(empty($pimcoreUser)){
  556.                 $email = $request->get("email");
  557.                 if(empty($email)){
  558.                     $response = new Response();
  559.                     $response->setStatusCode(401);
  560.                     return $response;
  561.                 }else{
  562.                     $pimcoreUsername = $email;
  563.                     $pimcoreId = 0;
  564.                 }
  565.             }else{
  566.                 $pimcoreUsername = $pimcoreUser->getUsername();
  567.                 $pimcoreId = $pimcoreUser->getId();
  568.             }
  569.         }
  570.         // crezione folder utente se non esiste
  571.         $parentBuca = "/Buca/";
  572.         $parentPath = $parentBuca . $pimcoreUsername;
  573.         $parentAsset = \Pimcore\Model\Asset::getByPath($parentPath);
  574.         if(!$parentAsset){
  575.             $parent = \Pimcore\Model\Asset::getByPath($parentBuca);
  576.             $parentAsset = $this->createFolder($pimcoreUsername, $parent->getId(), 'asset');
  577.         }
  578.         $parentObject = \Pimcore\Model\DataObject::getByPath($parentPath);
  579.         if(!$parentObject){
  580.             $parent = \Pimcore\Model\DataObject::getByPath($parentBuca);
  581.             $parentObject = $this->createFolder($pimcoreUsername, $parent->getId());
  582.         }
  584.         // creazione oggetto e media
  585.         $separatore = "$";
  586.         $classe = "\Pimcore\Model\DataObject\\" . $request->get("class");
  587.         $fields = json_decode($request->get("fields"), TRUE);
  588.         $obj = new $classe();
  589.         $obj->setParentId($parentObject->getId());
  590.         foreach ($fields as $key => $typeField) {
  591.             $fieldDefiniton = $obj->getClass()->getFieldDefinition($key);
  592.             $type = $fieldDefiniton ? $fieldDefiniton->getFieldtype() : "localizedfield";
  593.             $type = strpos($key, $separatore) !== FALSE ? "block" : $type;
  595.             if(in_array($typeField,["file","image"])){
  596.                 $files = $request->files->get($key);
  597.                 $metadati = $request->get($key . "Metadati");
  598.                 if(!empty($files)){
  599.                     $isMultiple = is_array($files);
  600.                     $files = $isMultiple ? $files : [$files];
  601.                     if(!empty($metadati)){
  602.                         $metadati = $isMultiple ? $metadati : [$metadati];
  603.                     }
  604.                     $values = [];
  605.                     if($typeField === "image"){
  606.                         foreach ($files as $index => $file) {
  607.                             $advancedImage = new \Pimcore\Model\DataObject\Data\Hotspotimage();
  608.                             $metadatis = !empty($metadati) && !empty($metadati[$index]) ? json_decode($metadati[$index], TRUE) : [];
  609.                             $advancedImage->setImage($this->createAsset($parentAsset, $file, "image", $metadatis));
  610.                             $values[] = $advancedImage;
  611.                         }
  612.                         $values = new \Pimcore\Model\DataObject\Data\ImageGallery($values);
  613.                     }else{
  614.                         foreach ($files as $index => $file) {
  615.                             $values[] = $this->createAsset($parentAsset, $file);
  616.                         }
  617.                     }
  618.                     $obj->{"set" . ucfirst($key)}($isMultiple ? $values : $values[0]);
  619.                 }
  620.             }else {
  621.                 $val = $request->get($key);
  622.                 if(!empty($val)){
  623.                     switch($typeField){
  624.                         case "link":
  625.                             $link = new \Pimcore\Model\DataObject\Data\Link();
  626.                             $link->setText("Link");
  627.                             $link->setPath($val);
  628.                             $val = $link;
  629.                             break;
  630.                         case 'date':
  631.                             $val = \Carbon\Carbon::createFromFormat('Y-m-d', $val);
  632.                             break;
  633.                     }
  634.                     switch($type){
  635.                         case "video":
  636.                             $video = new \Pimcore\Model\DataObject\Data\Video();
  637.                             $video->setType("youtube");
  638.                             $video->setData($val);
  639.                             $result = preg_match("/(?<=v=)[a-zA-Z0-9-]+(?=&)|(?<=v\/)[^&]+(?=\?)|(?<=v=)[^&]+|(?<=youtu.be\/)[^&]+/", $val, $matches);
  640.                             if($result){
  641.                                 $video->setType("youtube");
  642.                                 $video->setData($matches[0]);
  643.                             }
  644.                             $result = preg_match("/(?<=vimeo.com\/)[^&]+/", $val, $matches);
  645.                             if($result){
  646.                                 $video->setType("vimeo");
  647.                                 $video->setData($matches[0]);
  648.                             }
  649.                             $obj->{"set" . ucfirst($key)}($video);
  650.                             break;
  651.                         case "block":
  652.                             list ($keyContainer, $keyMeta) = explode($separatore, $key);
  653.                             $metadata = [];
  654.                             $metadata[$keyMeta] = new \Pimcore\Model\DataObject\Data\BlockElement($keyMeta, $typeField, $val);
  655.                             $obj->{"set" . ucfirst($keyContainer)}([$metadata]);
  656.                             break;
  657.                         case "localizedfield":
  658.                             $obj->{"set" . ucfirst($key)}($val, 'it');
  659.                             break;
  660.                         case "multiselect":
  661.                             $obj->{"set" . ucfirst($key)}([$val]);
  662.                             break;
  663.                         default:
  664.                             $obj->{"set" . ucfirst($key)}($val);
  665.                             break;
  666.                     }
  667.                     if($key === 'dcTitle'){
  668.                         $obj->setKey(\Pimcore\Model\Element\Service::getValidKey($val, 'object'));
  669.                     }
  670.                 }
  671.             }
  672.         }
  673.         $obj->setUserOwner($pimcoreId);
  674.         $obj->setUserModification($pimcoreId);
  675.         $obj->save();
  676.         $tags = $request->get("tags");
  677.         if(!empty($tags)){
  678.             \Pimcore\Model\Element\Tag::setTagsForElement('object', $obj->getId(), array_map(function($id){
  679.                 return \Pimcore\Model\Element\Tag::getById($id);
  680.             }, $tags));
  681.         }
  682.         return $this->json(["status" =>  true ]);
  683.     }
  685.     /**
  686.      * @Route("/promemoria/api/bucaSelect", methods={"POST"})
  687.      * @param Request $request
  688.      *
  689.      * @return JsonResponse
  690.      */
  691.     public function bucaSelect(Request $request)
  692.     {
  693.         $pimcoreUser = Authentication::authenticateSession();
  694.         if(empty($pimcoreUser)){
  695.             $response = new Response();
  696.             $response->setStatusCode(401);
  697.             return $response;
  698.         }
  699.         $data = json_decode($request->getContent());
  701.         $classe = "\Pimcore\Model\DataObject\\" . $data->class;
  702.         $obj = new $classe();
  703.         $fieldDefiniton = $obj->getClass()->getFieldDefinition($data->field);
  705.         return $this->json($fieldDefiniton->getOptions());
  706.     }
  708.      /**
  709.      * @Route("/promemoria/api/bucaTags", methods={"POST"})
  710.      * @param Request $request
  711.      *
  712.      * @return JsonResponse
  713.      */
  714.     public function bucaTags(Request $request)
  715.     {
  716.         $pimcoreUser = Authentication::authenticateSession();
  717.         if(empty($pimcoreUser)){
  718.             $response = new Response();
  719.             $response->setStatusCode(401);
  720.             return $response;
  721.         }
  722.         $data = json_decode($request->getContent());
  724.         $tagList = new \Pimcore\Model\Element\Tag\Listing();
  725.         $tagList->setCondition("parentId = ?", $data->parentId);
  726.         $tagList->setOrderKey("id");
  727.         $tags = [];
  728.         foreach ($tagList->load() as $tag) {
  729.             $tags[] = [
  730.                 "id" => $tag->getId(),
  731.                 "label" => $tag->getName()
  732.             ];
  733.         }
  734.         return $this->json($tags);
  735.     }
  737.     /**
  738.      * @Route("/promemoria/api/check-email", methods={"POST"}))
  739.      * @param Request $request
  740.      *
  741.      * @return JsonResponse
  742.      */
  743.     public function checkEmail(Request $request)
  744.     {
  745.         $response = new Response();
  746.         $response->setStatusCode(400);
  747.         $data = json_decode($request->getContent());
  748.         if(empty($data->email)){
  749.             return $response;
  750.         }
  751.         $user = false;
  752.         $entries = new \Pimcore\Model\User\Listing();
  753.         $entries->setLimit(1);
  754.         $entries->setCondition("email LIKE ?", [$data->email]);
  755.         foreach ($entries as $entry) {
  756.             $user = $entry;
  757.             return $this->json([
  758.                 'status' => true
  759.             ]);
  760.         }
  761.         return $response;
  762.     }
  764.     /**
  765.      * @Route("/promemoria/api/change-reset-password", methods={"POST"}))
  766.      * @param Request $request
  767.      *
  768.      * @return JsonResponse
  769.      */
  770.     public function changeResetPassword(Request $request)
  771.     {
  772.         $response = new Response();
  773.         $response->setStatusCode(400);
  774.         $data = json_decode($request->getContent());
  776.         if(empty($data->email) || empty($data->password)){
  777.             return $response;
  778.         }
  780.         $entries = new \Pimcore\Model\User\Listing();
  781.         $entries->setLimit(1);
  782.         $entries->setCondition("email LIKE ?", [$data->email]);
  783.         foreach ($entries as $entry) {
  784.             $user = $entry;
  785.             $user->setPassword(Authentication::getPasswordHash($user->getUsername(), $data->password));
  786.             $user->save();
  787.             return $this->json([
  788.                 'status' => true
  789.             ]);
  790.         }
  791.         return $response;
  792.     }
  794.     /* PRIVATE */
  795.     private function clearExpiredShortUrls()
  796.     {
  797.         $db = \Pimcore\Db::get();
  798.         $db->deleteWhere('promemoria_shorturl', 'insertDate < NOW() - INTERVAL 1 WEEK');
  799.     }
  800.     private function createFolder($name, $parent, $type = 'object'){
  801.         $folder = $type === 'object' ? new \Pimcore\Model\DataObject\Folder() : new \Pimcore\Model\Asset\Folder();
  802.         $folder->setParentId($parent);
  803.         $type === 'object'  ? $folder->setKey($name) : $folder->setFilename($name);
  804.         $folder->save();
  805.         return $folder;
  806.     }
  808.     private function createAsset($parentAsset, $file, $type="", $metadati = []){
  809.         $newAsset = $type ? new \Pimcore\Model\Asset\Image() : new \Pimcore\Model\Asset();
  810.         $newAsset->setFilename($this->checkFileAndRename($parentAsset->getFullPath(), $file->getClientOriginalName()));
  811.         $newAsset->setData(file_get_contents($file->getPathname()));
  812.         $newAsset->setParent($parentAsset);
  813.         if(!empty($metadati)){
  814.             foreach ($metadati as $key => $value) {
  815.                 $newAsset->addMetadata($key, "input", $value);
  816.             }
  817.         }
  818.         $newAsset->save();
  819.         return $newAsset;
  820.     }
  821.     private function checkFileAndRename($parentPath, $filename){
  822.         $path_parts = pathinfo($filename);
  823.         $i = 1;
  824.         while(\Pimcore\Model\Asset::getByPath($parentPath . "/" . $filename)){
  825.             $filename = $path_parts['filename'] . "_$i." . $path_parts['extension'];
  826.             $i++;
  827.         }
  828.         return $filename;
  829.     }
  830.     private function getThumb($image, $type, $original=false){
  831.         $thumb = $this->getThumbnail($image, "watermarked_" . $type);
  832.         if(!$thumb || empty($thumb->getConfig())) {
  833.             $thumb = $this->getThumbnail($image, $type);
  834.         }
  835.         if(!$thumb || empty($thumb->getConfig())){
  836.             if($original) return $image;
  837.             $thumb = $this->getThumbnail($image, Asset\Image\Thumbnail\Config::getPreviewConfig());
  838.         }
  839.         return $thumb;
  840.     }
  842.     private function getThumbnail($image, $type){
  843.         try{
  844.             return $image->getThumbnail($type);
  845.         }catch(\Exception $err){
  846.             return null;
  847.         }
  848.     }
  850.     private function addThumbnailCacheHeaders(Response $response)
  851.     {
  852.        $lifetime = 300;
  853.         $date = new \DateTime('now');
  854.         $date->add(new \DateInterval('PT' . $lifetime . 'S'));
  856.         $response->setMaxAge($lifetime);
  857.         $response->setPublic();
  858.         $response->setExpires($date);
  859.         $response->headers->set('Access-Control-Allow-Origin', '*');
  860.     }
  862.     private function checkHash($id){
  863.         list($id, $hash) = explode("-", $id);
  864.         return $hash === substr(md5($id . md5(getenv("dotenv_suffix"))), 0, 8);
  865.     }
  866. }