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.         $tmpfname = tempnam("/tmp", "audio.png");
  105.         file_put_contents($tmpfname, file_get_contents("https://dummyimage.com/170x170/3e3e3e/ffffff.png&text=%20audio%20"));
  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.             $pathparts = pathinfo($thumb->getAsset()->getFilename());
  231.             $ext = isset($pathparts["extension"]) ? $pathparts["extension"] : 'image';
  232.             $tmpfname = tempnam("/tmp", "image.png");
  233.             file_put_contents($tmpfname, file_get_contents("https://dummyimage.com/300x300/3e3e3e/ffffff.png&text=%20{$ext}%20"));
  234.             $response = new BinaryFileResponse($tmpfname);
  235.         }
  236.         $this->addThumbnailCacheHeaders($response);
  237.         return $response;
  239.     }
  241.     /**
  242.      * @Route("/promemoria/api/download-as-zip", methods={"GET"})
  243.      *
  244.      * @param Request $request
  245.      *
  246.      * @return BinaryFileResponse
  247.      */
  248.     public function downloadAsZip(Request $request)
  249.     {
  251.         $name = $request->get('name', '');
  252.         $version = $request->get('version', 'original');
  253.         $watermarked = $request->get('watermarked', 0);
  255.         $zipName = ($name ?: 'collection-' . time()) . '.zip';
  256.         $zipFile = tempnam("/tmp", $zipName);
  258.         $zip = new \ZipArchive();
  259.         $zipState = $zip->open($zipFile, \ZipArchive::CREATE);
  261.         $selectedIds = $request->get('selectedIds', '');
  263.         if (strlen($selectedIds) > 0 && $zipState === true) {
  265.             $conditionFilters = [];
  267.             $selectedIds = explode(',', $selectedIds);
  268.             $ids = [];
  269.             foreach ($selectedIds as $id) {
  270.                 if(!$this->checkHash($id)){
  271.                     $response = new Response();
  272.                     $response->setStatusCode(401);
  273.                     return $response;
  274.                 }
  275.                 $ids[] = intval($id);
  276.             }
  277.             $conditionFilters[] = 'id IN (' . implode(',', $ids) . ')';
  278.             $conditionFilters[] .= "type != 'folder'";
  279.             $condition = implode(' AND ', $conditionFilters);
  281.             $assetList = new Asset\Listing();
  282.             $assetList->setCondition($condition);
  283.             $assetList->setOrderKey('LENGTH(path) ASC, id ASC', false);
  284.             $assetList->setOffset((int)$request->get('offset'));
  285.             $assetList->setLimit((int)$request->get('limit'));
  287.             foreach ($assetList->load() as $a) {
  288.                 if (!$a instanceof Asset\Folder) {
  289.                     if($a instanceof Asset\Image){
  290.                         $a = $this->getThumb($a, $watermarked ? $version : "no_watermark", $version === 'original');
  291.                     }
  292.                     if ($a instanceof Asset\Image\Thumbnail) {
  293.                         $dir_prefix = '/var/www/html/public/var/tmp/thumbnails';
  294.                         $pathReference = $a->getPathReference();
  295.                         //serve per generare la thumb nel caso non esista
  296.                         $fileContent = Tool\Storage::get('thumbnail')->read($pathReference['storagePath']);
  297.                         $path = urldecode($a->getPath());
  298.                     } else {
  299.                         $dir_prefix = '/var/www/html/public/var/assets';
  300.                         $path = $a->getRealFullPath();
  301.                     }
  302.                     $zip->addFile($dir_prefix.$path, basename($path));
  303.                 }
  304.             }
  306.             $zip->close();
  308.             $response = new BinaryFileResponse($zipFile);
  309.             $response->headers->set('Content-Type', 'application/zip');
  310.             $response->setContentDisposition(ResponseHeaderBag::DISPOSITION_ATTACHMENT, $zipName);
  311.             $response->deleteFileAfterSend(true);
  313.             return $response;
  315.         }
  317.         return $this->json(['error' => true]);
  319.     }
  321.     /**
  322.      * @Route("/promemoria/api/getShortToken", methods={"GET"})
  323.      * @param Request $request
  324.      *
  325.      * @return JsonResponse
  326.      */
  327.     public function getShortToken(Request $request)
  328.     {
  330.         $response = new Response();
  331.         $response->setStatusCode(400);
  333.         $db = \Pimcore\Db::get();
  334.         $jwtToken = $request->get('jwtToken');
  336.         $this->clearExpiredShortUrls();
  338.         if (!empty($jwtToken)) {
  340.             $generatedToken = substr(md5(uniqid(mt_rand(), true)), 0, 8);
  342.             $db->insert('promemoria_shorturl', [
  343.                 'jwtToken' => $jwtToken,
  344.                 'shortToken' => $generatedToken
  345.             ]);
  347.             return $this->json(['shortToken' => $generatedToken]);
  348.         }
  350.         return $response;
  352.     }
  354.     /**
  355.      * @Route("/promemoria/api/getJwtToken", methods={"GET"})
  356.      * @param Request $request
  357.      *
  358.      * @return JsonResponse
  359.      */
  360.     public function getJwtToken(Request $request)
  361.     {
  363.         $response = new Response();
  364.         $response->setStatusCode(400);
  366.         $db = \Pimcore\Db::get();
  367.         $shortToken = $request->get('shortToken');
  369.         $this->clearExpiredShortUrls();
  371.         if (!empty($shortToken)) {
  373.             $res = $db->fetchRow("SELECT jwtToken FROM promemoria_shorturl WHERE shortToken = " . $db->quote($shortToken));
  375.             return $this->json(['jwtToken' => $res['jwtToken']]);
  376.         }
  378.         return $response;
  380.     }
  382.     /**
  383.      * @Route("/promemoria/api/changePassword", methods={"POST"})
  384.      * @param Request $request
  385.      *
  386.      * @return JsonResponse
  387.      */
  388.     public function changePassword(Request $request)
  389.     {
  391.         $response = new Response();
  392.         $response->setStatusCode(401);
  394.         $data = json_decode($request->getContent());
  395.         $newPassword = $data->password;
  397.         $pimcoreUser = Authentication::authenticateSession();
  399.         if(empty($pimcoreUser)){
  400.             return $response;
  401.         }
  403.         if (!empty($pimcoreUser) && !empty($newPassword)) {
  405.             $pimcoreUser->setPassword(Authentication::getPasswordHash($pimcoreUser->getUsername(), $newPassword));
  406.             $pimcoreUser->save();
  408.             return $this->json(['message' => 'Password changed']);
  410.         }
  412.         return $response;
  414.     }
  416.     /**
  417.      * @Route("/promemoria/api/getUserList", methods={"POST"}))
  418.      * @param Request $request
  419.      *
  420.      * @return JsonResponse
  421.      */
  422.     public function getUserList(Request $request)
  423.     {
  424.         $pimcoreUser = Authentication::authenticateSession();
  425.         if(empty($pimcoreUser)){
  426.             $response = new Response();
  427.             $response->setStatusCode(401);
  428.             return $response;
  429.         }
  431.         $db = \Pimcore\Db::get();
  432.         $query = <<<QUERY
  433.         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
  434.         FROM users u
  435.         INNER JOIN users r ON u.type = 'user' and u.roles = r.id and u.roles != '' and u.active = 1
  436.         order by u.name asc
  437. QUERY;
  438.         return $this->json(['users' => $db->executeQuery($query)->fetchAll()]);
  439.     }
  441.     /**
  442.     * @Route("/promemoria/api/getRoleList", methods={"POST"}))
  443.     * @param Request $request
  444.     *
  445.     * @return JsonResponse
  446.     */
  447.     public function getRoleList(Request $request)
  448.     {
  449.         $pimcoreUser = Authentication::authenticateSession();
  450.         if(empty($pimcoreUser)){
  451.             $response = new Response();
  452.             $response->setStatusCode(401);
  453.             return $response;
  454.         }
  456.         $db = \Pimcore\Db::get();
  457.         $query = <<<QUERY
  458.         SELECT u.id as role_id, u.name as name
  459.         FROM users u
  460.         WHERE
  461.         u.type = 'role'
  462.         order by u.name asc
  463. QUERY;
  464.         return $this->json(['roles' => $db->executeQuery($query)->fetchAll()]);
  465.     }
  467.     /**
  468.      * @Route("/promemoria/api/upsertUser", methods={"POST"})
  469.      * @param Request $request
  470.      *
  471.      * @return JsonResponse
  472.      */
  473.     public function upsertUser(Request $request)
  474.     {
  476.         $pimcoreUser = Authentication::authenticateSession();
  477.         if(empty($pimcoreUser)){
  478.             $response = new Response();
  479.             $response->setStatusCode(401);
  480.             return $response;
  481.         }
  482.         $userAdmin = new UserAdmin($pimcoreUser);
  483.         if(!in_array("ROLE_PIMCORE_ADMIN", $userAdmin->getRoles())
  484.             && !in_array("ROLE_MANAGER", $userAdmin->getRoles())){
  485.             $response = new Response();
  486.             $response->setStatusCode(401);
  487.             return $response;
  488.         }
  490.         $data = json_decode($request->getContent());
  491.         $user = new User();
  492.         if(!empty($data->user_id)){
  493.             $user = User::getById($data->user_id);
  494.         }
  495.         $user->setParentid(0);
  496.         $user->setUsername($data->user_name);
  497.         $user->setFirstname($data->fname);
  498.         $user->setLastname($data->lname);
  499.         $user->setEmail($data->email);
  500.         $user->setActive($data->active);
  501.         $user->setLanguage("it");
  502.         $user->setContentLanguages("it,en");
  503.         if(!empty($data->password)){
  504.             $user->setPassword(Authentication::getPasswordHash($data->user_name, $data->password));
  505.         }
  506.         $user->setRoles($data->role_id);
  507.         $user->save();
  509.         return $this->json(['message' => 'User updated']);
  510.     }
  512.     /**
  513.      * @Route("/promemoria/api/deleteUser", methods={"POST"})
  514.      * @param Request $request
  515.      *
  516.      * @return JsonResponse
  517.      */
  518.     public function deleteUser(Request $request)
  519.     {
  521.         $pimcoreUser = Authentication::authenticateSession();
  522.         if(empty($pimcoreUser)){
  523.             $response = new Response();
  524.             $response->setStatusCode(401);
  525.             return $response;
  526.         }
  527.         $data = json_decode($request->getContent());
  528.         $user = User::getById($data->user_id);
  529.         $userAdmin = new UserAdmin($user);
  530.         if(in_array("ROLE_PIMCORE_ADMIN", $userAdmin->getRoles())){
  531.             $response = new Response();
  532.             $response->setStatusCode(401);
  533.             return $response;
  534.         }
  535.         $user->delete();
  536.         return $this->json(['message' => 'User deleted']);
  537.     }
  539.     /**
  540.      * @Route("/promemoria/api/buca", methods={"POST"})
  541.      * @param Request $request
  542.      *
  543.      * @return JsonResponse
  544.      */
  545.     public function buca(Request $request)
  546.     {
  547.         $token = $request->get("token");
  548.         $config = \App\PromemoriaBundle\PromemoriaBundle::getConfig();
  549.         if(!empty($config["googleRecaptchaSecretKey"]) && !empty($token)){
  550.             $verifyResponse = file_get_contents('https://www.google.com/recaptcha/api/siteverify?secret=' . $config["googleRecaptchaSecretKey"] . '&response=' . $token);
  551.             $responseData = json_decode($verifyResponse);
  552.             if (!$responseData->success || $responseData->score < 0.5) {
  553.                 $response = new Response();
  554.                 $response->setStatusCode(401);
  555.                 return $response;
  556.             }
  557.             $email = $request->get("email");
  558.             $pimcoreUsername = empty($email) ? "website" : $email;
  559.             $pimcoreId = 0;
  560.         }else{
  561.             $pimcoreUser = Authentication::authenticateSession();
  562.             if(empty($pimcoreUser)){
  563.                 $email = $request->get("email");
  564.                 if(empty($email)){
  565.                     $response = new Response();
  566.                     $response->setStatusCode(401);
  567.                     return $response;
  568.                 }else{
  569.                     $pimcoreUsername = $email;
  570.                     $pimcoreId = 0;
  571.                 }
  572.             }else{
  573.                 $pimcoreUsername = $pimcoreUser->getUsername();
  574.                 $pimcoreId = $pimcoreUser->getId();
  575.             }
  576.         }
  577.         // crezione folder utente se non esiste
  578.         $parentBuca = "/Buca/";
  579.         $parentPath = $parentBuca . $pimcoreUsername;
  580.         $parentAsset = \Pimcore\Model\Asset::getByPath($parentPath);
  581.         if(!$parentAsset){
  582.             $parent = \Pimcore\Model\Asset::getByPath($parentBuca);
  583.             $parentAsset = $this->createFolder($pimcoreUsername, $parent->getId(), 'asset');
  584.         }
  585.         $parentObject = \Pimcore\Model\DataObject::getByPath($parentPath);
  586.         if(!$parentObject){
  587.             $parent = \Pimcore\Model\DataObject::getByPath($parentBuca);
  588.             $parentObject = $this->createFolder($pimcoreUsername, $parent->getId());
  589.         }
  591.         // creazione oggetto e media
  592.         $separatore = "$";
  593.         $classe = "\Pimcore\Model\DataObject\\" . $request->get("class");
  594.         $fields = json_decode($request->get("fields"), TRUE);
  595.         $obj = new $classe();
  596.         $obj->setParentId($parentObject->getId());
  597.         foreach ($fields as $key => $typeField) {
  598.             $fieldDefiniton = $obj->getClass()->getFieldDefinition($key);
  599.             $type = $fieldDefiniton ? $fieldDefiniton->getFieldtype() : "localizedfield";
  600.             $type = strpos($key, $separatore) !== FALSE ? "block" : $type;
  602.             if(in_array($typeField,["file","image"])){
  603.                 $files = $request->files->get($key);
  604.                 $metadati = $request->get($key . "Metadati");
  605.                 if(!empty($files)){
  606.                     $isMultiple = is_array($files);
  607.                     $files = $isMultiple ? $files : [$files];
  608.                     if(!empty($metadati)){
  609.                         $metadati = $isMultiple ? $metadati : [$metadati];
  610.                     }
  611.                     $values = [];
  612.                     if($typeField === "image"){
  613.                         foreach ($files as $index => $file) {
  614.                             $advancedImage = new \Pimcore\Model\DataObject\Data\Hotspotimage();
  615.                             $metadatis = !empty($metadati) && !empty($metadati[$index]) ? json_decode($metadati[$index], TRUE) : [];
  616.                             $advancedImage->setImage($this->createAsset($parentAsset, $file, "image", $metadatis));
  617.                             $values[] = $advancedImage;
  618.                         }
  619.                         $values = new \Pimcore\Model\DataObject\Data\ImageGallery($values);
  620.                     }else{
  621.                         foreach ($files as $index => $file) {
  622.                             $values[] = $this->createAsset($parentAsset, $file);
  623.                         }
  624.                     }
  625.                     $obj->{"set" . ucfirst($key)}($isMultiple ? $values : $values[0]);
  626.                 }
  627.             }else {
  628.                 $val = $request->get($key);
  629.                 if(!empty($val)){
  630.                     switch($typeField){
  631.                         case "link":
  632.                             $link = new \Pimcore\Model\DataObject\Data\Link();
  633.                             $link->setText("Link");
  634.                             $link->setPath($val);
  635.                             $val = $link;
  636.                             break;
  637.                         case 'date':
  638.                             $val = \Carbon\Carbon::createFromFormat('Y-m-d', $val);
  639.                             break;
  640.                     }
  641.                     switch($type){
  642.                         case "video":
  643.                             $video = new \Pimcore\Model\DataObject\Data\Video();
  644.                             $video->setType("youtube");
  645.                             $video->setData($val);
  646.                             $result = preg_match("/(?<=v=)[a-zA-Z0-9-]+(?=&)|(?<=v\/)[^&]+(?=\?)|(?<=v=)[^&]+|(?<=youtu.be\/)[^&]+/", $val, $matches);
  647.                             if($result){
  648.                                 $video->setType("youtube");
  649.                                 $video->setData($matches[0]);
  650.                             }
  651.                             $result = preg_match("/(?<=vimeo.com\/)[^&]+/", $val, $matches);
  652.                             if($result){
  653.                                 $video->setType("vimeo");
  654.                                 $video->setData($matches[0]);
  655.                             }
  656.                             $obj->{"set" . ucfirst($key)}($video);
  657.                             break;
  658.                         case "block":
  659.                             list ($keyContainer, $keyMeta) = explode($separatore, $key);
  660.                             $metadata = [];
  661.                             $metadata[$keyMeta] = new \Pimcore\Model\DataObject\Data\BlockElement($keyMeta, $typeField, $val);
  662.                             $obj->{"set" . ucfirst($keyContainer)}([$metadata]);
  663.                             break;
  664.                         case "localizedfield":
  665.                             $obj->{"set" . ucfirst($key)}($val, 'it');
  666.                             break;
  667.                         case "multiselect":
  668.                             $obj->{"set" . ucfirst($key)}([$val]);
  669.                             break;
  670.                         default:
  671.                             $obj->{"set" . ucfirst($key)}($val);
  672.                             break;
  673.                     }
  674.                     if($key === 'dcTitle'){
  675.                         $obj->setKey(\Pimcore\Model\Element\Service::getValidKey($val, 'object'));
  676.                     }
  677.                 }
  678.             }
  679.         }
  680.         $obj->setUserOwner($pimcoreId);
  681.         $obj->setUserModification($pimcoreId);
  682.         $obj->save();
  683.         $tags = $request->get("tags");
  684.         if(!empty($tags)){
  685.             \Pimcore\Model\Element\Tag::setTagsForElement('object', $obj->getId(), array_map(function($id){
  686.                 return \Pimcore\Model\Element\Tag::getById($id);
  687.             }, $tags));
  688.         }
  689.         return $this->json(["status" =>  true ]);
  690.     }
  692.     /**
  693.      * @Route("/promemoria/api/bucaSelect", methods={"POST"})
  694.      * @param Request $request
  695.      *
  696.      * @return JsonResponse
  697.      */
  698.     public function bucaSelect(Request $request)
  699.     {
  700.         $pimcoreUser = Authentication::authenticateSession();
  701.         if(empty($pimcoreUser)){
  702.             $response = new Response();
  703.             $response->setStatusCode(401);
  704.             return $response;
  705.         }
  706.         $data = json_decode($request->getContent());
  708.         $classe = "\Pimcore\Model\DataObject\\" . $data->class;
  709.         $obj = new $classe();
  710.         $fieldDefiniton = $obj->getClass()->getFieldDefinition($data->field);
  712.         return $this->json($fieldDefiniton->getOptions());
  713.     }
  715.      /**
  716.      * @Route("/promemoria/api/bucaTags", methods={"POST"})
  717.      * @param Request $request
  718.      *
  719.      * @return JsonResponse
  720.      */
  721.     public function bucaTags(Request $request)
  722.     {
  723.         $pimcoreUser = Authentication::authenticateSession();
  724.         if(empty($pimcoreUser)){
  725.             $response = new Response();
  726.             $response->setStatusCode(401);
  727.             return $response;
  728.         }
  729.         $data = json_decode($request->getContent());
  731.         $tagList = new \Pimcore\Model\Element\Tag\Listing();
  732.         $tagList->setCondition("parentId = ?", $data->parentId);
  733.         $tagList->setOrderKey("id");
  734.         $tags = [];
  735.         foreach ($tagList->load() as $tag) {
  736.             $tags[] = [
  737.                 "id" => $tag->getId(),
  738.                 "label" => $tag->getName()
  739.             ];
  740.         }
  741.         return $this->json($tags);
  742.     }
  744.     /**
  745.      * @Route("/promemoria/api/check-email", methods={"POST"}))
  746.      * @param Request $request
  747.      *
  748.      * @return JsonResponse
  749.      */
  750.     public function checkEmail(Request $request)
  751.     {
  752.         $response = new Response();
  753.         $response->setStatusCode(400);
  754.         $data = json_decode($request->getContent());
  755.         if(empty($data->email)){
  756.             return $response;
  757.         }
  758.         $user = false;
  759.         $entries = new \Pimcore\Model\User\Listing();
  760.         $entries->setLimit(1);
  761.         $entries->setCondition("email LIKE ?", [$data->email]);
  762.         foreach ($entries as $entry) {
  763.             $user = $entry;
  764.             return $this->json([
  765.                 'status' => true
  766.             ]);
  767.         }
  768.         return $response;
  769.     }
  771.     /**
  772.      * @Route("/promemoria/api/change-reset-password", methods={"POST"}))
  773.      * @param Request $request
  774.      *
  775.      * @return JsonResponse
  776.      */
  777.     public function changeResetPassword(Request $request)
  778.     {
  779.         $response = new Response();
  780.         $response->setStatusCode(400);
  781.         $data = json_decode($request->getContent());
  783.         if(empty($data->email) || empty($data->password)){
  784.             return $response;
  785.         }
  787.         $entries = new \Pimcore\Model\User\Listing();
  788.         $entries->setLimit(1);
  789.         $entries->setCondition("email LIKE ?", [$data->email]);
  790.         foreach ($entries as $entry) {
  791.             $user = $entry;
  792.             $user->setPassword(Authentication::getPasswordHash($user->getUsername(), $data->password));
  793.             $user->save();
  794.             return $this->json([
  795.                 'status' => true
  796.             ]);
  797.         }
  798.         return $response;
  799.     }
  801.     /* PRIVATE */
  802.     private function clearExpiredShortUrls()
  803.     {
  804.         $db = \Pimcore\Db::get();
  805.         $db->deleteWhere('promemoria_shorturl', 'insertDate < NOW() - INTERVAL 1 WEEK');
  806.     }
  807.     private function createFolder($name, $parent, $type = 'object'){
  808.         $folder = $type === 'object' ? new \Pimcore\Model\DataObject\Folder() : new \Pimcore\Model\Asset\Folder();
  809.         $folder->setParentId($parent);
  810.         $type === 'object'  ? $folder->setKey($name) : $folder->setFilename($name);
  811.         $folder->save();
  812.         return $folder;
  813.     }
  815.     private function createAsset($parentAsset, $file, $type="", $metadati = []){
  816.         $newAsset = $type ? new \Pimcore\Model\Asset\Image() : new \Pimcore\Model\Asset();
  817.         $newAsset->setFilename($this->checkFileAndRename($parentAsset->getFullPath(), $file->getClientOriginalName()));
  818.         $newAsset->setData(file_get_contents($file->getPathname()));
  819.         $newAsset->setParent($parentAsset);
  820.         if(!empty($metadati)){
  821.             foreach ($metadati as $key => $value) {
  822.                 $newAsset->addMetadata($key, "input", $value);
  823.             }
  824.         }
  825.         $newAsset->save();
  826.         return $newAsset;
  827.     }
  828.     private function checkFileAndRename($parentPath, $filename){
  829.         $path_parts = pathinfo($filename);
  830.         $i = 1;
  831.         while(\Pimcore\Model\Asset::getByPath($parentPath . "/" . $filename)){
  832.             $filename = $path_parts['filename'] . "_$i." . $path_parts['extension'];
  833.             $i++;
  834.         }
  835.         return $filename;
  836.     }
  837.     private function getThumb($image, $type, $original=false){
  838.         $thumb = $this->getThumbnail($image, "watermarked_" . $type);
  839.         if(!$thumb || empty($thumb->getConfig())) {
  840.             $thumb = $this->getThumbnail($image, $type);
  841.         }
  842.         if(!$thumb || empty($thumb->getConfig())){
  843.             if($original) return $image;
  844.             $thumb = $this->getThumbnail($image, Asset\Image\Thumbnail\Config::getPreviewConfig());
  845.         }
  846.         return $thumb;
  847.     }
  849.     private function getThumbnail($image, $type){
  850.         try{
  851.             return $image->getThumbnail($type);
  852.         }catch(\Exception $err){
  853.             return null;
  854.         }
  855.     }
  857.     private function addThumbnailCacheHeaders(Response $response)
  858.     {
  859.        $lifetime = 300;
  860.         $date = new \DateTime('now');
  861.         $date->add(new \DateInterval('PT' . $lifetime . 'S'));
  863.         $response->setMaxAge($lifetime);
  864.         $response->setPublic();
  865.         $response->setExpires($date);
  866.         $response->headers->set('Access-Control-Allow-Origin', '*');
  867.     }
  869.     private function checkHash($id){
  870.         list($id, $hash) = explode("-", $id);
  871.         return $hash === substr(md5($id . md5(getenv("dotenv_suffix"))), 0, 8);
  872.     }
  873. }