src/PromemoriaBundle/Controller/ApiController.php line 847

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.         $tmpfname = tempnam("/tmp", "audio.png");
  105.         file_put_contents($tmpfname, file_get_contents("https://dummyimage.com/170x170/3e3e3e/ffffff.png&text=audio"));
  106.         $response = new BinaryFileResponse($tmpfname);
  107.         $this->addThumbnailCacheHeaders($response);
  108.         return $response;
  110.     }
  112.     /**
  113.      * @Route("/promemoria/api/get-image-thumbnail", methods={"GET"})
  114.      *
  115.      * @param Request $request
  116.      *
  117.      * @return BinaryFileResponse|StreamedResponse
  118.      */
  119.     public function getImageThumbnail(Request $request)
  120.     {
  121.         $id = $request->get('id');
  122.         if(!$this->checkHash($id)){
  123.             $response = new Response();
  124.             $response->setStatusCode(401);
  125.             return $response;
  126.         }
  127.         $image = Asset\Image::getById(intval($id));
  128.         $thumb = $this->getThumb($image, $request->get('version', 'thumbnail'));
  129.         return $this->responseThumbnail($thumb);
  131.     }
  133.     /**
  134.      * @Route("/promemoria/api/get-video-thumbnail", methods={"GET"})
  135.      *
  136.      * @param Request $request
  137.      *
  138.      * @return BinaryFileResponse|StreamedResponse
  139.      */
  140.     public function getVideoThumbnail(Request $request)
  141.     {
  142.         $id = $request->get('id');
  143.         if(!$this->checkHash($id)){
  144.             $response = new Response();
  145.             $response->setStatusCode(401);
  146.             return $response;
  147.         }
  148.         $video = Asset\Video::getById(intval($id));
  149.         $thumb = $video->getImageThumbnail(Asset\Image\Thumbnail\Config::getPreviewConfig());
  150.         return $this->responseThumbnail($thumb);
  152.     }
  154.     /**
  155.      * @Route("/promemoria/api/get-document-thumbnail", methods={"GET"})
  156.      *
  157.      * @param Request $request
  158.      *
  159.      * @return BinaryFileResponse|StreamedResponse
  160.      */
  161.     public function getDocumentThumbnail(Request $request)
  162.     {
  163.         $id = $request->get('id');
  164.         if(!$this->checkHash($id)){
  165.             $response = new Response();
  166.             $response->setStatusCode(401);
  167.             return $response;
  168.         }
  169.         $document = Asset\Document::getById(intval($id));
  170.         $thumb = new Asset\Document\ImageThumbnail($document, Asset\Image\Thumbnail\Config::getPreviewConfig(), 1);
  171.         return $this->responseThumbnail($thumb);
  172.     }
  174.     /**
  175.      * @Route("/promemoria/api/get-video-preview", methods={"GET"})
  176.      *
  177.      * @param Request $request
  178.      *
  179.      * @return BinaryFileResponse
  180.      */
  181.     public function getVideoPreview(Request $request)
  182.     {
  184.         $response = new Response();
  185.         $response->setStatusCode(400);
  187.         $id = $request->get('id');
  188.         if(!$this->checkHash($id)){
  189.             $response->setStatusCode(401);
  190.             return $response;
  191.         }
  192.         $asset = Asset::getById(intval($id));
  194.         if(!empty($asset) && $asset->getType()=='video'){
  195.             $thumbnail = $asset->getThumbnail(Asset\Video\Thumbnail\Config::getPreviewConfig(), ['mp4']);
  196.             $storagePath = $asset->getRealPath() . '/' . preg_replace('@^' . preg_quote($asset->getPath(), '@') . '@', '', urldecode($thumbnail['formats']['mp4']));
  197.             $storage = \Pimcore\Tool\Storage::get('thumbnail');
  198.             if ($storage->fileExists($storagePath)) {
  199.                 $fs = $storage->fileSize($storagePath);
  200.                 $stream = $storage->readStream($storagePath);
  202.                 return new StreamedResponse(function () use ($stream) {
  203.                     fpassthru($stream);
  204.                 }, 200, [
  205.                     'Content-Type' => 'video/mp4',
  206.                     'Content-Length' => $fs,
  207.                     'Accept-Ranges' => 'bytes',
  208.                 ]);
  209.             } else {
  210.                 $response->setStatusCode(204);
  211.             }
  212.         }
  213.         return $response;
  215.     }
  217.     /**
  218.      * @param Response $response
  219.      */
  220.     protected function responseThumbnail($thumb)
  221.     {
  222.         $stream = $thumb->getStream();
  223.         if ($stream) {
  224.             $response = new StreamedResponse(function () use ($stream) {
  225.                 fpassthru($stream);
  226.             }, 200, [
  227.                 'Content-Type' => 'image/' . $thumb->getFileExtension(),
  228.             ]);
  229.         } else {
  230.             $response = new BinaryFileResponse(PIMCORE_PATH . '/bundles/AdminBundle/public/img/filetype-not-supported.svg');
  231.         }
  232.         $this->addThumbnailCacheHeaders($response);
  233.         return $response;
  235.     }
  237.     /**
  238.      * @Route("/promemoria/api/download-as-zip", methods={"GET"})
  239.      *
  240.      * @param Request $request
  241.      *
  242.      * @return BinaryFileResponse
  243.      */
  244.     public function downloadAsZip(Request $request)
  245.     {
  247.         $name = $request->get('name', '');
  248.         $version = $request->get('version', 'original');
  249.         $watermarked = $request->get('watermarked', 0);
  251.         $zipName = ($name ?: 'collection-' . time()) . '.zip';
  252.         $zipFile = tempnam("/tmp", $zipName);
  254.         $zip = new \ZipArchive();
  255.         $zipState = $zip->open($zipFile, \ZipArchive::CREATE);
  257.         $selectedIds = $request->get('selectedIds', '');
  259.         if (strlen($selectedIds) > 0 && $zipState === true) {
  261.             $conditionFilters = [];
  263.             $selectedIds = explode(',', $selectedIds);
  264.             $ids = [];
  265.             foreach ($selectedIds as $id) {
  266.                 if(!$this->checkHash($id)){
  267.                     $response = new Response();
  268.                     $response->setStatusCode(401);
  269.                     return $response;
  270.                 }
  271.                 $ids[] = intval($id);
  272.             }
  273.             $conditionFilters[] = 'id IN (' . implode(',', $ids) . ')';
  274.             $conditionFilters[] .= "type != 'folder'";
  275.             $condition = implode(' AND ', $conditionFilters);
  277.             $assetList = new Asset\Listing();
  278.             $assetList->setCondition($condition);
  279.             $assetList->setOrderKey('LENGTH(path) ASC, id ASC', false);
  280.             $assetList->setOffset((int)$request->get('offset'));
  281.             $assetList->setLimit((int)$request->get('limit'));
  283.             foreach ($assetList->load() as $a) {
  284.                 if (!$a instanceof Asset\Folder) {
  285.                     if($a instanceof Asset\Image){
  286.                         $a = $this->getThumb($a, $watermarked ? $version : "no_watermark", $version === 'original');
  287.                     }
  288.                     if ($a instanceof Asset\Image\Thumbnail) {
  289.                         $dir_prefix = '/var/www/html/public/var/tmp/thumbnails';
  290.                         $pathReference = $a->getPathReference();
  291.                         //serve per generare la thumb nel caso non esista
  292.                         $fileContent = Tool\Storage::get('thumbnail')->read($pathReference['storagePath']);
  293.                         $path = urldecode($a->getPath());
  294.                     } else {
  295.                         $dir_prefix = '/var/www/html/public/var/assets';
  296.                         $path = $a->getRealFullPath();
  297.                     }
  298.                     $zip->addFile($dir_prefix.$path, basename($path));
  299.                 }
  300.             }
  302.             $zip->close();
  304.             $response = new BinaryFileResponse($zipFile);
  305.             $response->headers->set('Content-Type', 'application/zip');
  306.             $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $zipName);
  307.             $response->deleteFileAfterSend(true);
  309.             return $response;
  311.         }
  313.         return $this->json(['error' => true]);
  315.     }
  317.     /**
  318.      * @Route("/promemoria/api/getShortToken", methods={"GET"})
  319.      * @param Request $request
  320.      *
  321.      * @return JsonResponse
  322.      */
  323.     public function getShortToken(Request $request)
  324.     {
  326.         $response = new Response();
  327.         $response->setStatusCode(400);
  329.         $db = \Pimcore\Db::get();
  330.         $jwtToken = $request->get('jwtToken');
  332.         $this->clearExpiredShortUrls();
  334.         if (!empty($jwtToken)) {
  336.             $generatedToken = substr(md5(uniqid(mt_rand(), true)), 0, 8);
  338.             $db->insert('promemoria_shorturl', [
  339.                 'jwtToken' => $jwtToken,
  340.                 'shortToken' => $generatedToken
  341.             ]);
  343.             return $this->json(['shortToken' => $generatedToken]);
  344.         }
  346.         return $response;
  348.     }
  350.     /**
  351.      * @Route("/promemoria/api/getJwtToken", methods={"GET"})
  352.      * @param Request $request
  353.      *
  354.      * @return JsonResponse
  355.      */
  356.     public function getJwtToken(Request $request)
  357.     {
  359.         $response = new Response();
  360.         $response->setStatusCode(400);
  362.         $db = \Pimcore\Db::get();
  363.         $shortToken = $request->get('shortToken');
  365.         $this->clearExpiredShortUrls();
  367.         if (!empty($shortToken)) {
  369.             $res = $db->fetchRow("SELECT jwtToken FROM promemoria_shorturl WHERE shortToken = " . $db->quote($shortToken));
  371.             return $this->json(['jwtToken' => $res['jwtToken']]);
  372.         }
  374.         return $response;
  376.     }
  378.     /**
  379.      * @Route("/promemoria/api/changePassword", methods={"POST"})
  380.      * @param Request $request
  381.      *
  382.      * @return JsonResponse
  383.      */
  384.     public function changePassword(Request $request)
  385.     {
  387.         $response = new Response();
  388.         $response->setStatusCode(401);
  390.         $data = json_decode($request->getContent());
  391.         $newPassword = $data->password;
  393.         $pimcoreUser = Authentication::authenticateSession();
  395.         if(empty($pimcoreUser)){
  396.             return $response;
  397.         }
  399.         if (!empty($pimcoreUser) && !empty($newPassword)) {
  401.             $pimcoreUser->setPassword(Authentication::getPasswordHash($pimcoreUser->getUsername(), $newPassword));
  402.             $pimcoreUser->save();
  404.             return $this->json(['message' => 'Password changed']);
  406.         }
  408.         return $response;
  410.     }
  412.     /**
  413.      * @Route("/promemoria/api/getUserList", methods={"POST"}))
  414.      * @param Request $request
  415.      *
  416.      * @return JsonResponse
  417.      */
  418.     public function getUserList(Request $request)
  419.     {
  420.         $pimcoreUser = Authentication::authenticateSession();
  421.         if(empty($pimcoreUser)){
  422.             $response = new Response();
  423.             $response->setStatusCode(401);
  424.             return $response;
  425.         }
  427.         $db = \Pimcore\Db::get();
  428.         $query = <<<QUERY
  429.         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
  430.         FROM users u
  431.         INNER JOIN users r ON u.type = 'user' and u.roles = r.id and u.roles != '' and u.active = 1
  432.         order by u.name asc
  433. QUERY;
  434.         return $this->json(['users' => $db->executeQuery($query)->fetchAll()]);
  435.     }
  437.     /**
  438.     * @Route("/promemoria/api/getRoleList", methods={"POST"}))
  439.     * @param Request $request
  440.     *
  441.     * @return JsonResponse
  442.     */
  443.     public function getRoleList(Request $request)
  444.     {
  445.         $pimcoreUser = Authentication::authenticateSession();
  446.         if(empty($pimcoreUser)){
  447.             $response = new Response();
  448.             $response->setStatusCode(401);
  449.             return $response;
  450.         }
  452.         $db = \Pimcore\Db::get();
  453.         $query = <<<QUERY
  454.         SELECT u.id as role_id, u.name as name
  455.         FROM users u
  456.         WHERE
  457.         u.type = 'role'
  458.         order by u.name asc
  459. QUERY;
  460.         return $this->json(['roles' => $db->executeQuery($query)->fetchAll()]);
  461.     }
  463.     /**
  464.      * @Route("/promemoria/api/upsertUser", methods={"POST"})
  465.      * @param Request $request
  466.      *
  467.      * @return JsonResponse
  468.      */
  469.     public function upsertUser(Request $request)
  470.     {
  472.         $pimcoreUser = Authentication::authenticateSession();
  473.         if(empty($pimcoreUser)){
  474.             $response = new Response();
  475.             $response->setStatusCode(401);
  476.             return $response;
  477.         }
  478.         $userAdmin = new UserAdmin($pimcoreUser);
  479.         if(!in_array("ROLE_PIMCORE_ADMIN", $userAdmin->getRoles())
  480.             && !in_array("ROLE_MANAGER", $userAdmin->getRoles())){
  481.             $response = new Response();
  482.             $response->setStatusCode(401);
  483.             return $response;
  484.         }
  486.         $data = json_decode($request->getContent());
  487.         $user = new User();
  488.         if(!empty($data->user_id)){
  489.             $user = User::getById($data->user_id);
  490.         }
  491.         $user->setParentid(0);
  492.         $user->setUsername($data->user_name);
  493.         $user->setFirstname($data->fname);
  494.         $user->setLastname($data->lname);
  495.         $user->setEmail($data->email);
  496.         $user->setActive($data->active);
  497.         $user->setLanguage("it");
  498.         if(!empty($data->password)){
  499.             $user->setPassword(Authentication::getPasswordHash($data->user_name, $data->password));
  500.         }
  501.         $user->setRoles($data->role_id);
  502.         $user->save();
  504.         return $this->json(['message' => 'User updated']);
  505.     }
  507.     /**
  508.      * @Route("/promemoria/api/deleteUser", methods={"POST"})
  509.      * @param Request $request
  510.      *
  511.      * @return JsonResponse
  512.      */
  513.     public function deleteUser(Request $request)
  514.     {
  516.         $pimcoreUser = Authentication::authenticateSession();
  517.         if(empty($pimcoreUser)){
  518.             $response = new Response();
  519.             $response->setStatusCode(401);
  520.             return $response;
  521.         }
  522.         $data = json_decode($request->getContent());
  523.         $user = User::getById($data->user_id);
  524.         $userAdmin = new UserAdmin($user);
  525.         if(in_array("ROLE_PIMCORE_ADMIN", $userAdmin->getRoles())){
  526.             $response = new Response();
  527.             $response->setStatusCode(401);
  528.             return $response;
  529.         }
  530.         $user->delete();
  531.         return $this->json(['message' => 'User deleted']);
  532.     }
  534.     /**
  535.      * @Route("/promemoria/api/buca", methods={"POST"})
  536.      * @param Request $request
  537.      *
  538.      * @return JsonResponse
  539.      */
  540.     public function buca(Request $request)
  541.     {
  542.         $token = $request->get("token");
  543.         $config = \App\PromemoriaBundle\PromemoriaBundle::getConfig();
  544.         if(!empty($config["googleRecaptchaSecretKey"]) && !empty($token)){
  545.             $verifyResponse = file_get_contents('https://www.google.com/recaptcha/api/siteverify?secret=' . $config["googleRecaptchaSecretKey"] . '&response=' . $token);
  546.             $responseData = json_decode($verifyResponse);
  547.             if (!$responseData->success || $responseData->score < 0.5) {
  548.                 $response = new Response();
  549.                 $response->setStatusCode(401);
  550.                 return $response;
  551.             }
  552.             $pimcoreUsername = "website";
  553.             $pimcoreId = 0;
  554.         }else{
  555.             $pimcoreUser = Authentication::authenticateSession();
  556.             if(empty($pimcoreUser)){
  557.                 $response = new Response();
  558.                 $response->setStatusCode(401);
  559.                 return $response;
  560.             }
  561.             $pimcoreUsername = $pimcoreUser->getUsername();
  562.             $pimcoreId = $pimcoreUser->getId();
  563.         }
  564.         // crezione folder utente se non esiste
  565.         $parentBuca = "/Buca/";
  566.         $parentPath = $parentBuca . $pimcoreUsername;
  567.         $parentAsset = \Pimcore\Model\Asset::getByPath($parentPath);
  568.         if(!$parentAsset){
  569.             $parent = \Pimcore\Model\Asset::getByPath($parentBuca);
  570.             $parentAsset = $this->createFolder($pimcoreUsername, $parent->getId(), 'asset');
  571.         }
  572.         $parentObject = \Pimcore\Model\DataObject::getByPath($parentPath);
  573.         if(!$parentObject){
  574.             $parent = \Pimcore\Model\DataObject::getByPath($parentBuca);
  575.             $parentObject = $this->createFolder($pimcoreUsername, $parent->getId());
  576.         }
  578.         // creazione oggetto e media
  579.         $separatore = "$";
  580.         $classe = "\Pimcore\Model\DataObject\\" . $request->get("class");
  581.         $fields = json_decode($request->get("fields"), TRUE);
  582.         $obj = new $classe();
  583.         $obj->setParentId($parentObject->getId());
  584.         foreach ($fields as $key => $typeField) {
  585.             $fieldDefiniton = $obj->getClass()->getFieldDefinition($key);
  586.             $type = $fieldDefiniton ? $fieldDefiniton->getFieldtype() : "localizedfield";
  587.             $type = strpos($key, $separatore) !== FALSE ? "block" : $type;
  589.             if(in_array($typeField,["file","image"])){
  590.                 $files = $request->files->get($key);
  591.                 $didascalie = $request->get($key . "Didascalia");
  592.                 if(!empty($files)){
  593.                     $isMultiple = is_array($files);
  594.                     $files = $isMultiple ? $files : [$files];
  595.                     $values = [];
  596.                     if($typeField === "image"){
  597.                         foreach ($files as $index => $file) {
  598.                             $advancedImage = new \Pimcore\Model\DataObject\Data\Hotspotimage();
  599.                             $advancedImage->setImage($this->createAsset($parentAsset, $file, "image"));
  600.                             $values[] = $advancedImage;
  601.                         }
  602.                         $values = new \Pimcore\Model\DataObject\Data\ImageGallery($values);
  603.                     }else{
  604.                         foreach ($files as $index => $file) {
  605.                             $values[] = $this->createAsset($parentAsset, $file);
  606.                         }
  607.                     }
  608.                     $obj->{"set" . ucfirst($key)}($isMultiple ? $values : $values[0]);
  609.                 }
  610.             }else {
  611.                 $val = $request->get($key);
  612.                 if(!empty($val)){
  613.                     switch($typeField){
  614.                         case "link":
  615.                             $link = new \Pimcore\Model\DataObject\Data\Link();
  616.                             $link->setText("Link");
  617.                             $link->setPath($val);
  618.                             $val = $link;
  619.                             break;
  620.                         case 'date':
  621.                             $val = \Carbon\Carbon::createFromFormat('Y-m-d', $val);
  622.                             break;
  623.                     }
  624.                     switch($type){
  625.                         case "video":
  626.                             $video = new \Pimcore\Model\DataObject\Data\Video();
  627.                             $video->setType("youtube");
  628.                             $video->setData($val);
  629.                             $result = preg_match("/(?<=v=)[a-zA-Z0-9-]+(?=&)|(?<=v\/)[^&]+(?=\?)|(?<=v=)[^&]+|(?<=youtu.be\/)[^&]+/", $val, $matches);
  630.                             if($result){
  631.                                 $video->setType("youtube");
  632.                                 $video->setData($matches[0]);
  633.                             }
  634.                             $result = preg_match("/(?<=vimeo.com\/)[^&]+/", $val, $matches);
  635.                             if($result){
  636.                                 $video->setType("vimeo");
  637.                                 $video->setData($matches[0]);
  638.                             }
  639.                             $obj->{"set" . ucfirst($key)}($video);
  640.                             break;
  641.                         case "block":
  642.                             list ($keyContainer, $keyMeta) = explode($separatore, $key);
  643.                             $metadata = [];
  644.                             $metadata[$keyMeta] = new \Pimcore\Model\DataObject\Data\BlockElement($keyMeta, $typeField, $val);
  645.                             $obj->{"set" . ucfirst($keyContainer)}([$metadata]);
  646.                             break;
  647.                         case "localizedfield":
  648.                             $obj->{"set" . ucfirst($key)}($val, 'it');
  649.                             break;
  650.                         case "multiselect":
  651.                             $obj->{"set" . ucfirst($key)}([$val]);
  652.                             break;
  653.                         default:
  654.                             $obj->{"set" . ucfirst($key)}($val);
  655.                             break;
  656.                     }
  657.                     if($key === 'dcTitle'){
  658.                         $obj->setKey(\Pimcore\Model\Element\Service::getValidKey($val, 'object'));
  659.                     }
  660.                 }
  661.             }
  662.         }
  663.         $obj->setUserOwner($pimcoreId);
  664.         $obj->setUserModification($pimcoreId);
  665.         $obj->save();
  666.         $tags = $request->get("tags");
  667.         if(!empty($tags)){
  668.             \Pimcore\Model\Element\Tag::setTagsForElement('object', $obj->getId(), array_map(function($id){
  669.                 return \Pimcore\Model\Element\Tag::getById($id);
  670.             }, $tags));
  671.         }
  672.         return $this->json(["status" =>  true ]);
  673.     }
  675.     /**
  676.      * @Route("/promemoria/api/bucaSelect", methods={"POST"})
  677.      * @param Request $request
  678.      *
  679.      * @return JsonResponse
  680.      */
  681.     public function bucaSelect(Request $request)
  682.     {
  683.         $pimcoreUser = Authentication::authenticateSession();
  684.         if(empty($pimcoreUser)){
  685.             $response = new Response();
  686.             $response->setStatusCode(401);
  687.             return $response;
  688.         }
  689.         $data = json_decode($request->getContent());
  691.         $classe = "\Pimcore\Model\DataObject\\" . $data->class;
  692.         $obj = new $classe();
  693.         $fieldDefiniton = $obj->getClass()->getFieldDefinition($data->field);
  695.         return $this->json($fieldDefiniton->getOptions());
  696.     }
  698.      /**
  699.      * @Route("/promemoria/api/bucaTags", methods={"POST"})
  700.      * @param Request $request
  701.      *
  702.      * @return JsonResponse
  703.      */
  704.     public function bucaTags(Request $request)
  705.     {
  706.         $pimcoreUser = Authentication::authenticateSession();
  707.         if(empty($pimcoreUser)){
  708.             $response = new Response();
  709.             $response->setStatusCode(401);
  710.             return $response;
  711.         }
  712.         $data = json_decode($request->getContent());
  714.         $tagList = new \Pimcore\Model\Element\Tag\Listing();
  715.         $tagList->setCondition("parentId = ?", $data->parentId);
  716.         $tagList->setOrderKey("id");
  717.         $tags = [];
  718.         foreach ($tagList->load() as $tag) {
  719.             $tags[] = [
  720.                 "id" => $tag->getId(),
  721.                 "label" => $tag->getName()
  722.             ];
  723.         }
  724.         return $this->json($tags);
  725.     }
  727.     /**
  728.      * @Route("/promemoria/api/check-email", methods={"POST"}))
  729.      * @param Request $request
  730.      *
  731.      * @return JsonResponse
  732.      */
  733.     public function checkEmail(Request $request)
  734.     {
  735.         $response = new Response();
  736.         $response->setStatusCode(400);
  737.         $data = json_decode($request->getContent());
  738.         if(empty($data->email)){
  739.             return $response;
  740.         }
  741.         $user = false;
  742.         $entries = new \Pimcore\Model\User\Listing();
  743.         $entries->setLimit(1);
  744.         $entries->setCondition("email LIKE ?", [$data->email]);
  745.         foreach ($entries as $entry) {
  746.             $user = $entry;
  747.             return $this->json([
  748.                 'status' => true
  749.             ]);
  750.         }
  751.         return $response;
  752.     }
  754.     /**
  755.      * @Route("/promemoria/api/change-reset-password", methods={"POST"}))
  756.      * @param Request $request
  757.      *
  758.      * @return JsonResponse
  759.      */
  760.     public function changeResetPassword(Request $request)
  761.     {
  762.         $response = new Response();
  763.         $response->setStatusCode(400);
  764.         $data = json_decode($request->getContent());
  766.         if(empty($data->email) || empty($data->password)){
  767.             return $response;
  768.         }
  770.         $entries = new \Pimcore\Model\User\Listing();
  771.         $entries->setLimit(1);
  772.         $entries->setCondition("email LIKE ?", [$data->email]);
  773.         foreach ($entries as $entry) {
  774.             $user = $entry;
  775.             $user->setPassword(Authentication::getPasswordHash($user->getUsername(), $data->password));
  776.             $user->save();
  777.             return $this->json([
  778.                 'status' => true
  779.             ]);
  780.         }
  781.         return $response;
  782.     }
  784.     /* PRIVATE */
  785.     private function clearExpiredShortUrls()
  786.     {
  787.         $db = \Pimcore\Db::get();
  788.         $db->deleteWhere('promemoria_shorturl', 'insertDate < NOW() - INTERVAL 1 WEEK');
  789.     }
  790.     private function createFolder($name, $parent, $type = 'object'){
  791.         $folder = $type === 'object' ? new \Pimcore\Model\DataObject\Folder() : new \Pimcore\Model\Asset\Folder();
  792.         $folder->setParentId($parent);
  793.         $type === 'object'  ? $folder->setKey($name) : $folder->setFilename($name);
  794.         $folder->save();
  795.         return $folder;
  796.     }
  798.     private function createAsset($parentAsset, $file, $type=""){
  799.         $newAsset = $type ? new \Pimcore\Model\Asset\Image() : new \Pimcore\Model\Asset();
  800.         $newAsset->setFilename($this->checkFileAndRename($parentAsset->getFullPath(), $file->getClientOriginalName()));
  801.         $newAsset->setData(file_get_contents($file->getPathname()));
  802.         $newAsset->setParent($parentAsset);
  803.         $newAsset->save();
  804.         return $newAsset;
  805.     }
  806.     private function checkFileAndRename($parentPath, $filename){
  807.         $path_parts = pathinfo($filename);
  808.         $i = 1;
  809.         while(\Pimcore\Model\Asset::getByPath($parentPath . "/" . $filename)){
  810.             $filename = $path_parts['filename'] . "_$i." . $path_parts['extension'];
  811.             $i++;
  812.         }
  813.         return $filename;
  814.     }
  815.     private function getThumb($image, $type, $original=false){
  816.         $thumb = $this->getThumbnail($image, "watermarked_" . $type);
  817.         if(!$thumb || empty($thumb->getConfig())) {
  818.             $thumb = $this->getThumbnail($image, $type);
  819.         }
  820.         if(!$thumb || empty($thumb->getConfig())){
  821.             if($original) return $image;
  822.             $thumb = $this->getThumbnail($image, Asset\Image\Thumbnail\Config::getPreviewConfig());
  823.         }
  824.         return $thumb;
  825.     }
  827.     private function getThumbnail($image, $type){
  828.         try{
  829.             return $image->getThumbnail($type);
  830.         }catch(\Exception $err){
  831.             return null;
  832.         }
  833.     }
  835.     private function addThumbnailCacheHeaders(Response $response)
  836.     {
  837.        $lifetime = 300;
  838.         $date = new \DateTime('now');
  839.         $date->add(new \DateInterval('PT' . $lifetime . 'S'));
  841.         $response->setMaxAge($lifetime);
  842.         $response->setPublic();
  843.         $response->setExpires($date);
  844.         $response->headers->set('Access-Control-Allow-Origin', '*');
  845.     }
  847.     private function checkHash($id){
  848.         list($id, $hash) = explode("-", $id);
  849.         return $hash === substr(md5($id . md5(getenv("dotenv_suffix"))), 0, 8);
  850.     }
  851. }