<?php

namespace Cadoles\PortalBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Security\Core\Authentication\Token\UsernamePasswordToken;
use Symfony\Component\Security\Http\Event\InteractiveLoginEvent;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Doctrine\Common\Collections\ArrayCollection;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Filesystem\Filesystem;
use Symfony\Component\HttpFoundation\File\File;
use GuzzleHttp\Exception\RequestException;
use Symfony\Component\Form\FormError;


use Cadoles\PortalBundle\Entity\Pagewidget;
use Cadoles\PortalBundle\Form\PagewidgetType;

class PagewidgetController extends Controller
{
    private $labelentity="CadolesPortalBundle:Pagewidget";
    private $routeprimary="cadoles_portal_config_pagewidget";

    private function searchArray($array, $key, $value) 
    { 
        $results = array(); 
    
        if (is_array($array)) 
        { 
            if (isset($array[$key]) && $array[$key] == $value) 
                $results[] = $array; 
    
            foreach ($array as $subarray) 
                $results = array_merge($results, $this->searchArray($subarray, $key, $value)); 
        } 
    
        return $results; 
    } 

    private function entityForm(Pagewidget $entity,$idpage,$id,$access="config",$by="view")
    {
        if ($this->getDoctrine()->getManager()->contains($entity)) {
            $widgettype= $this->getDoctrine()->getManager()->getRepository("CadolesPortalBundle:Pagewidget")->find($id)->getWidget();
            $params = $widgettype->getParameter();
            $values = $entity->getParameter();

            foreach($params->fields as $key => $param) {
                $tmp = $this->searchArray($values,"id",$param->id);
                if(is_array($tmp)&&!empty($tmp)) 
                    $params->fields[$key]->value=$tmp[0]["value"];
                else
                    $params->fields[$key]->value=$param->value;
            }

            return $this->createForm(PagewidgetType::class, $entity, [
                'param'     => $params,
                'mode'      => "update",
                'access'    => $access,
                'idicon'    => ($entity->getIcon()?$entity->getIcon()->getId():$widgettype->getIcon()->getId()),
                'method'    => 'POST',
            ]);
        } else {
            $widgettype= $this->getDoctrine()->getManager()->getRepository("CadolesPortalBundle:Widget")->find($id);
            $entity->setName($widgettype->getName());
            $entity->setHeight($widgettype->getHeight());
            $entity->setAutoajust($widgettype->getAutoajust());
            $entity->setBorder($widgettype->getBorder());
            $entity->setColorheaderback($widgettype->getColorheaderback());
            $entity->setColorheaderfont($widgettype->getColorheaderfont());
            $entity->setColorbodyback($widgettype->getColorbodyback());
            $entity->setColorbodyfont($widgettype->getColorbodyfont());
            $entity->setIcon($widgettype->getIcon());

            $param = $widgettype->getParameter();
            return $this->createForm(PagewidgetType::class, $entity, [
                'param'     => $param,
                'mode'      => ($by=="view"?"submit":"submittemplate"),
                'access'    => $access,
                'idicon'    => $widgettype->getIcon()->getId(),
                'method'    => 'POST',
            ]);
        }
    }

    public function submitAction(Request $request,$idpage,$idwidgettype,$access="config")
    {
        $by=$request->query->get('by');
        $entity = new Pagewidget();
        $form   = $this->entityForm($entity,$idpage,$idwidgettype,$access,$by);
        $form->handleRequest($request);
        

        // On s'assure que la page où l'on souhaite insérer un widget est bien du bon type
        $page=$this->getDoctrine()->getRepository("CadolesPortalBundle:Page")->findoneby(["id"=>$idpage]);
        if (!$page)
            throw $this->createNotFoundException('Unable to find entity.');
        if($page->getPagecategory()->getId()!=2)
            throw $this->createNotFoundException('Permission denied');

        // Sur erreur
        $this->getErrorForm(null,$form,$request,$idwidgettype,$page,$entity,"submit");
        
        // Sur validation
        if ($form->get('submit')->isClicked() && $form->isValid()) {  
            $idicon = $form->get('idicon')->getData();
            $icon=$this->getDoctrine()->getRepository("CadolesPortalBundle:Icon")->findoneby(["id"=>$idicon]);
            $widgettype=$this->getDoctrine()->getRepository("CadolesPortalBundle:Widget")->findoneby(["id"=>$idwidgettype]);

            // Localisation par défaut en R1C1
            $entity->setLoc("R1C1");
            $entity->setRoworder("1");

            // Rattachement icon / panel / widgettype
            $entity->setIcon($icon);
            $entity->setPage($page);
            $entity->setWidget($widgettype);

            // Récupération des paramétres
            $jsons=$widgettype->getParameter();
            $param=array();
            $param["fields"]=array();
            foreach($jsons->fields as $field) {
                $tmp=array();
                $tmp["id"]=$field->id;
                $tmp["value"]=$form->get($field->id)->getData();
                array_push($param["fields"],$tmp);
            }

            $entity->setParameter($param);

            $em = $this->getDoctrine()->getManager();
            $em->persist($entity);
            $em->flush();

            
            // Notification création widget
            $groups=$page->getGroups();
            if($groups[0]) {
                if($groups[0]->getFgcanshare()) {
                    $message="Création Widget ".$entity->getName();
                    $usergroup=$em->getRepository("CadolesCoreBundle:Usergroup")->findOneBy(["group"=>$groups[0],"user"=>$this->getUser()]);
                    if($usergroup) {
                        $key=$usergroup->getKeyvalue();
                        $websocket = $this->container->get('cadoles.websocket.pushmessage')->send($key,$this->getUser()->getId(),$groups[0]->getId(),$message);                    
                    }
                }
            }

            if($access=="config") {
                if($by=="view")
                    return $this->redirect($this->generateUrl('cadoles_portal_config_page_view',["id"=>$idpage]));
                else
                    return $this->redirect($this->generateUrl('cadoles_portal_config_pagetemplate_view',["id"=>$idpage]));
            }
            else
                return $this->redirect($this->generateUrl('cadoles_core_home',["id"=>$idpage]));
        }

        $icons=$this->getDoctrine()->getRepository("CadolesPortalBundle:Icon")->findBy(["user"=>null]);
        $iconsuser=null;
        if($access=="user") $iconsuser=$this->getDoctrine()->getRepository("CadolesPortalBundle:Icon")->findBy(["user"=>$this->getUser()]);

        return $this->render($this->labelentity.':edit.html.twig', [
            'useheader'         => true,
            'usemenu'           => false,
            'usesidebar'        => ($access=="config"),
            'maxwidth'          => ($access=="user"),                     
            'entity'            => $entity,
            'icons'             => $icons,
            'iconsuser'         => $iconsuser,
            'mode'              => ($by=="view"?"submit":"submittemplate"),
            'access'            => $access,
            'idpage'            => $idpage,
            'form'              => $form->createView(),
        ]);
    }

    public function updateAction(Request $request,$idpage,$idwidget,$access="config")
    {
        $by=$request->query->get('by');
        $usage=$request->query->get('usage');
        $group=$request->query->get('group');

        // Recherche du pagewidget
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($idwidget);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // On s'assure que l'utilisateur à la permission de modifier
        if($access=="user") {
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$entity->getPage(),$cansee,$canupdate);
            if(!$canupdate) throw $this->createNotFoundException('Permission denied');
        }

        // Création du formulaire
        $form   = $this->entityForm($entity,$idpage,$idwidget,$access,$by);
        $form->handleRequest($request);

        // Validation
        if ($form->isValid()) {
            $em = $this->getDoctrine()->getManager();

            $idicon = $form->get('idicon')->getData();
            $icon=$this->getDoctrine()->getRepository("CadolesPortalBundle:Icon")->findoneby(["id"=>$idicon]);
            $entity->setIcon($icon);
            
            // Récupération des paramétres
            $widgettype= $entity->getWidget();
            $jsons=$widgettype->getParameter();
            $param=array();
            $param["fields"]=array();
            foreach($jsons->fields as $field) {
                $tmp=array();
                $tmp["id"]=$field->id;

                $tmp["value"]=$form->get($field->id)->getData();
                array_push($param["fields"],$tmp);
            }

            $entity->setParameter($param);
            
            $em = $this->getDoctrine()->getManager();
            $em->persist($entity);
            $em->flush();

            // Si widget RSS On supprime le potentiel cache de ce flux
            if($entity->getWidget()->getId()==-1880) {
                $dir = $this->container->getParameter('kernel.root_dir').'/../web/uploads/flux/';
                $mask = $dir."widget-".$entity->getId().".*";
                array_map( "unlink", glob( $mask ) );
            }

            // Retour
            if($by=="view")
                return $this->redirect($this->generateUrl('cadoles_portal_'.$access.'_page_view',["id"=>$idpage,"usage"=>$usage,"group"=>$group]));
            else
                return $this->redirect($this->generateUrl('cadoles_portal_'.$access.'_pagetemplate_view',["id"=>$idpage]));
        }

        $icons=$this->getDoctrine()->getRepository("CadolesPortalBundle:Icon")->findBy(["user"=>null]);
        $iconsuser=null;
        if($access=="user") $iconsuser=$this->getDoctrine()->getRepository("CadolesPortalBundle:Icon")->findBy(["user"=>$this->getUser()]);

        return $this->render($this->labelentity.':edit.html.twig', [
            'useheader'         => ($access=="config"),
            'usemenu'           => false,
            'usesidebar'        => ($access=="config"),   
            'maxwidth'          => ($access=="user"),                  
            'entity'            => $entity,
            'icons'             => $icons,
            'iconsuser'         => $iconsuser,            
            'mode'              => ($by=="view"?"update":"updatetemplate"),
            'access'            => $access,   
            'idpage'            => $idpage,         
            'form'              => $form->createView(),
            'usage'             => $usage,
            'group'             => $group
        ]);
    }

    public function deleteAction(Request $request,$access="config")
    {
        // S'assurer que c'est un appel ajax
        if (!$request->isXmlHttpRequest()) return new JsonResponse(array('message' => 'Interdit'), 400);

        // Récupération des parametres
        $output=array();
        $idwidget=$request->request->get('idwidget');

        // Recherche du pagetwidget
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($idwidget);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // On s'assure que l'utilisateur à la permission de supprimer
        if($access=="user") {
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$entity->getPage(),$cansee,$canupdate);
            if(!$canupdate) throw $this->createNotFoundException('Permission denied');
        }

        // Notification création widget
        $groups=$entity->getPage()->getGroups();
        if($groups[0]) {
            if($groups[0]->getFgcanshare()) {
                $message="Suppression Widget ".$entity->getName();
                $usergroup=$em->getRepository("CadolesCoreBundle:Usergroup")->findOneBy(["group"=>$groups[0],"user"=>$this->getUser()]);
                if($usergroup) {
                    $key=$usergroup->getKeyvalue();
                    $websocket = $this->container->get('cadoles.websocket.pushmessage')->send($key,$this->getUser()->getId(),$groups[0]->getId(),$message);                    
                }
            }
        }

        // Supression du pagewidget
        $em->remove($entity);
        $em->flush();

        $response = new Response(json_encode($output));    
        $response->headers->set('Content-Type', 'application/json');        
        return $response;        
    }

    public function orderAction(Request $request)
    {
        // S'assurer que c'est un appel ajax
        if (!$request->isXmlHttpRequest()) return new JsonResponse(array('message' => 'Interdit'), 400);

        $output=array();
        $idwidget=$request->request->get('idwidget');
        $order=$request->request->get('order');
        $idloc=$request->request->get('idloc');

        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($idwidget);
        if (!$entity) {
            throw $this->createNotFoundException('Unable to find entity.');
        }

        $entity->setRoworder($order);
        $entity->setLoc($idloc);
        $em->persist($entity);
        $em->flush();

        $response = new Response(json_encode($output));    
        $response->headers->set('Content-Type', 'application/json');        
        return $response;        
    }

    public function uploadAction(Request $request,$access=null) {
        // Fichier temporaire uploadé
        $tmpfile    = $request->files->get('upload');
        $extention  = $tmpfile->getClientOriginalExtension();

        // Répertoire de Destination
        $fs         = new Filesystem();
        $rootdir    = $this->get('kernel')->getRootDir()."/../web";
        $fs->mkdir($rootdir."/uploads/ckeditor");
        
        // Fichier cible
        $targetName = uniqid().".".$extention;
        $targetFile = $rootdir."/uploads/ckeditor/".$targetName;
        $targetUrl  = "/".$this->getParameter('alias')."/uploads/ckeditor/".$targetName;
        $message    = "";

        move_uploaded_file($tmpfile,$targetFile);
        
        $output["uploaded"]=1;
        $output["fileName"]=$targetName;
        $output["url"]=$targetUrl;

        return new Response(json_encode($output));

    }

    
    protected function getErrorForm($id,$form,$request,$idwidgettype,$page,$data,$mode) {
        if ($form->get('submit')->isClicked()&&$mode=="delete") {
        
        }

        if ($form->get('submit')->isClicked() && ($mode=="submit" || $mode=="update")) {
            // Interdire l'insertion de 2 chat dans la meme page
            if($idwidgettype==-1840) {
                $pagewidget=$this->getDoctrine()->getRepository("CadolesPortalBundle:Pagewidget")->findoneby(["page"=>$page,"widget"=>-1840]);
                if($pagewidget) {
                    $form->addError(new FormError("Vous ne pouvez pas insérer deux widgets de type Chat dans la même page"));
                }
            }
        }

        if ($form->get('submit')->isClicked() && !$form->isValid()) {
            $this->get('session')->getFlashBag()->clear();
            $validator = $this->get('validator');
            $errors = $validator->validate($data);
            foreach( $errors as $error ) {
                $request->getSession()->getFlashBag()->add("error", $error->getMessage());
            }

            $errors = $form->getErrors();
            foreach( $errors as $error ) {
                $request->getSession()->getFlashBag()->add("error", $error->getMessage());
            }
        }
    }

    public function viewurlAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        $url="";
        foreach($entity->getParameter()["fields"] as $parameter) {
            if($parameter["id"]=="url")
                $url=$parameter["value"];
        }

        // Gestion des url youtuve
        $url=str_replace("http://www.youtube.com","https://www.youtube.com",$url);
        $url=str_replace("https://www.youtube.com/watch?v=","https://www.youtube.com/embed/",$url);

        // Detecter le type de lien
        $imagemedia=false;
        $pathinfo = pathinfo($url);

        // Type image
        if(array_key_exists("extension",$pathinfo)) { 
            if($pathinfo['extension']=="jpg"||$pathinfo['extension']=="gif"||$pathinfo['extension']=="png") {
                $imagemedia=true;
            }
        }

        // Spécifique Deviant Art
        if(strpos($url, "images-wixmp") !== false) $imagemedia=true;
            
            
        return $this->render($this->labelentity.':viewurl.html.twig', [
            'entity'        => $entity,
            'canupdate'     => $canupdate,
            'url'           => $url,
            'imagemedia'    => $imagemedia,
            'access'        => $access
        ]);
    }

    public function viewitemAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        // Récupération des paramétres du widget
        $modedesktop=0;
        $iditemcategory=null;
        $withbookmark=true;
        $search=false;
        $menu=false;
        $menuall=true;
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "modedesktop":
                    $modedesktop=$parameter["value"];
                    break;

                case "withbookmark":
                    $withbookmark=$parameter["value"];
                    break;

                case "itemcategory":
                    $iditemcategory=$parameter["value"];
                    if($iditemcategory) $itemcategoryfilter=$em->getRepository("CadolesPortalBundle:Itemcategory")->findBy(["id"=>$iditemcategory]);
                    break;

                case "search":
                    $search=($parameter["value"]==1);
                    break;

                case "menu":
                    $menu=($parameter["value"]==1);
                    break;

                case "menuall":
                    $menuall=($parameter["value"]==1);
                    break;

            }
        }
        
        
        // Profilage
        $user=$this->getUser();
        $roles=($user?$user->getRoles():["ROLE_ANONYME"]);
        $groups=($user?$user->getGroups():[]);
        $niveau01=($user?$user->getNiveau01():[]);

        // Bookmark de l'utilisateur
        $bookmarks = array();
        if($user)
            $bookmarks=$em->getRepository("CadolesPortalBundle:Bookmark")->findBy(["user"=>$user]);

        // Bookmark lié à un item
        $bookmarksitems=new ArrayCollection();
        foreach($bookmarks as $bookmark) {
            if($bookmark->getItem()) $bookmarksitems->add($bookmark->getItem());
        }

        // Initialisation du calcul des items
        $items=new ArrayCollection();

        // Récupération des items par rôles
        foreach($roles as $role) {
            $qb = $em->createQueryBuilder();
            $qb->select('item')
                ->from("CadolesPortalBundle:Item", 'item')
                ->where($qb->expr()->like('item.roles', $qb->expr()->literal("%$role%")));
            
            if($iditemcategory && $itemcategoryfilter) {
                $qb->andWhere("item.itemcategory=:itemcategory")
                   ->setParameter("itemcategory",$itemcategoryfilter);
            }
            $itemsroles=$qb->getQuery()->getResult();
            foreach($itemsroles as $itemrole) {
                if($withbookmark==1) {
                    if(!$items->contains($itemrole)) $items->add($itemrole);
                }
                else {
                    if(!$bookmarksitems->contains($itemrole) && !$items->contains($itemrole)) $items->add($itemrole);
                }
            }
        }

        // Récupération des items par group
        foreach($groups as $group) {
            $qb = $em->createQueryBuilder();
            $qb->select('item')
                ->from("CadolesPortalBundle:Item", 'item')
                ->where(":group MEMBER OF item.groups")
                ->setParameter("group",$group->getGroup());
            
            if($iditemcategory && $itemcategoryfilter) {
                $qb->andWhere("item.itemcategory=:itemcategory")
                   ->setParameter("itemcategory",$itemcategoryfilter);
            }
            $itemsgroups=$qb->getQuery()->getResult();
            foreach($itemsgroups as $itemgroup) {
                if($withbookmark==1) {
                    if(!$items->contains($itemgroup)) $items->add($itemgroup);
                }
                else {
                    if(!$bookmarksitems->contains($itemgroup) && !$items->contains($itemgroup)) $items->add($itemgroup);
                }
            }
        }

        // Récupération des items par niveau01
        if($niveau01) {
            $qb = $em->createQueryBuilder();
            $qb->select('item')
                ->from("CadolesPortalBundle:Item", 'item')
                ->where(":niveau01 MEMBER OF item.niveau01s")
                ->setParameter("niveau01",$niveau01);
            
            if($iditemcategory && $itemcategoryfilter) {
                $qb->andWhere("item.itemcategory=:itemcategory")
                   ->setParameter("itemcategory",$itemcategoryfilter);
            }
            $itemsniveau01s=$qb->getQuery()->getResult();
            foreach($itemsniveau01s as $itemniveau01) {
                if($withbookmark==1) {
                    if(!$items->contains($itemniveau01)) $items->add($itemniveau01);
                }
                else {
                    if(!$bookmarksitems->contains($itemniveau01) && !$items->contains($itemniveau01)) $items->add($itemniveau01);
                }
            }
        }

        // Trie des items
        $itemsordered = $items->getIterator();
        $itemsordered->uasort(function ($first, $second) {
            if((int) $first->getRowOrder() > (int) $second->getRowOrder())
                $return=1;
            elseif((int) $first->getRowOrder() == (int) $second->getRowOrder()) {
                if($first->getTitle() > $second->getTitle())
                    $return=1;
                else
                    $return=-1;
            }
            else
                $return=-1;

            return $return;
        });

        // Catégories affichées
        $itemcategorys = $this->getDoctrine()->getRepository('CadolesPortalBundle:Itemcategory')->findBy([], ['rowOrder' => 'asc']);
        if($iditemcategory && $itemcategoryfilter) $itemcategorys = $itemcategoryfilter;
        
        switch($withbookmark) {
            // items uniquement
            case 1: $bookmarks=null; break;

            // bookmarks uniquement
            case 2: $itemsordered=null; break;

        }

        // Render
        return $this->render($this->labelentity.':viewitem.html.twig', [
            'entity'        => $entity,
            'canadd'        => ($user),
            'canupdate'     => $canupdate,
            'modedesktop'   => $modedesktop,
            'items'         => $itemsordered,
            'itemcategorys' => $itemcategorys,
            'bookmarks'     => $bookmarks,
            'access'        => $access,
            'search'        => $search,
            'menu'          => $menu,
            'menuall'       => $menuall,
            'withbookmark'  => $withbookmark,
        ]);
    }    

    public function viewitemessentialAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        // Récupération des paramétres du widget
        $modedesktop=0;
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "modedesktop":
                    $modedesktop=$parameter["value"];
                    break;
            }
        }
        
        
        // Profilage
        $user=$this->getUser();
        $roles=($user?$user->getRoles():["ROLE_ANONYME"]);
        $groups=($user?$user->getGroups():[]);
        $niveau01=($user?$user->getNiveau01():[]);

        // Bookmark de l'utilisateur
        $bookmarks = array();
        if($user)
            $bookmarks=$em->getRepository("CadolesPortalBundle:Bookmark")->findBy(["user"=>$user]);

        // Bookmark lié à un item
        $bookmarksitems=new ArrayCollection();
        foreach($bookmarks as $bookmark) {
            if($bookmark->getItem()) $bookmarksitems->add($bookmark->getItem());
        }

        // Initialisation du calcul des items
        $items=new ArrayCollection();

        // Récupération des items par rôles
        foreach($roles as $role) {
            $qb = $em->createQueryBuilder();
            $qb->select('item')
                ->from("CadolesPortalBundle:Item", 'item')
                ->where($qb->expr()->like('item.roles', $qb->expr()->literal("%$role%")))
                ->andWhere("item.essential=:flag")
                ->setParameter("flag",true);
            
            $itemsroles=$qb->getQuery()->getResult();
            foreach($itemsroles as $itemrole) {
                if(!$bookmarksitems->contains($itemrole) && !$items->contains($itemrole)) $items->add($itemrole);
            }
        }

        // Récupération des items par group
        foreach($groups as $group) {
            $qb = $em->createQueryBuilder();
            $qb->select('item')
                ->from("CadolesPortalBundle:Item", 'item')
                ->where(":group MEMBER OF item.groups")
                ->andWhere("item.essential=:flag")
                ->setParameter("flag",true)                
                ->setParameter("group",$group->getGroup());
            
            $itemsgroups=$qb->getQuery()->getResult();
            foreach($itemsgroups as $itemgroup) {
                if(!$bookmarksitems->contains($itemgroup) && !$items->contains($itemgroup)) $items->add($itemgroup);
            }
        }

        // Récupération des items par niveau01
        if($niveau01) {
            $qb = $em->createQueryBuilder();
            $qb->select('item')
                ->from("CadolesPortalBundle:Item", 'item')
                ->where(":niveau01 MEMBER OF item.niveau01s")
                ->andWhere("item.essential=:flag")
                ->setParameter("flag",true)                
                ->setParameter("niveau01",$niveau01);
            
            $itemsniveau01s=$qb->getQuery()->getResult();
            foreach($itemsniveau01s as $itemniveau01) {
                if(!$bookmarksitems->contains($itemniveau01) && !$items->contains($itemniveau01)) $items->add($itemniveau01);
            }
        }

        // Trie des items
        $itemsordered = $items->getIterator();
        $itemsordered->uasort(function ($first, $second) {
            if((int) $first->getRowOrder() > (int) $second->getRowOrder())
                $return=1;
            elseif((int) $first->getRowOrder() == (int) $second->getRowOrder()) {
                if($first->getTitle() > $second->getTitle())
                    $return=1;
                else
                    $return=-1;
            }
            else
                $return=-1;

            return $return;
        });

        // Render
        return $this->render($this->labelentity.':viewitemessential.html.twig', [
            'entity'        => $entity,
            'canadd'        => ($user),
            'canupdate'     => $canupdate,
            'modedesktop'   => $modedesktop,
            'items'         => $itemsordered,
            'bookmarks'     => $bookmarks,
            'access'        => $access,
        ]);
    } 

    public function viewalertAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        // Récupération des paramétres du widget
        $idalertcategory=null;
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "alertcategory":
                    $idalertcategory=$parameter["value"];
                    if($idalertcategory) $alertcategoryfilter=$em->getRepository("CadolesPortalBundle:Alertcategory")->find($idalertcategory);
                    break;
            }
        }
        
        
        // Profilage
        $user=$this->getUser();
        $roles=($user?$user->getRoles():["ROLE_ANONYME"]);
        $niveau01=($user?$user->getNiveau01():null);
        $groups=($user?$user->getGroups():[]);

        // Initialisation du calcul des alerts
        $alerts=new ArrayCollection();

        // Récupération des alerts par rôles
        foreach($roles as $role) {
            $qb = $em->createQueryBuilder();
            $qb->select('alert')
                ->from("CadolesPortalBundle:Alert", 'alert')
                ->where($qb->expr()->like('alert.roles', $qb->expr()->literal("%$role%")))
                ->andWhere('alert.publishedat <= :today')
                ->andWhere($qb->expr()->orX(
                    $qb->expr()->gt('alert.unpublishedat', ':today'),
                    $qb->expr()->isNull('alert.unpublishedat')
                ))    
                ->setParameter('today', date('Y-m-d'));            
            
            if($idalertcategory && $alertcategoryfilter) {
                $qb->andWhere("alert.alertcategory=:alertcategory")
                   ->setParameter("alertcategory",$alertcategoryfilter);
            }
            $alertsroles=$qb->getQuery()->getResult();
            foreach($alertsroles as $alertrole) {
                if(!$alerts->contains($alertrole)) $alerts->add($alertrole);
            }
        }

        // Récupération par Niveau01
        $qb = $em->createQueryBuilder();
        $qb->select('alert')
            ->from("CadolesPortalBundle:Alert", 'alert')
            ->where(":niveau01 MEMBER OF alert.niveau01s")
            ->andWhere('alert.publishedat <= :today')
            ->andWhere($qb->expr()->orX(
                $qb->expr()->gt('alert.unpublishedat', ':today'),
                $qb->expr()->isNull('alert.unpublishedat')
            ))
            ->setParameter("niveau01",$niveau01)
            ->setParameter('today', date('Y-m-d'));
        
        if($idalertcategory && $alertcategoryfilter) {
            $qb->andWhere("alert.alertcategory=:alertcategory")
               ->setParameter("alertcategory",$alertcategoryfilter);
        }
        $alertsniveau01s=$qb->getQuery()->getResult();
        foreach($alertsniveau01s as $alertsniveau01) {
            if(!$alerts->contains($alertsniveau01s)) $alerts->add($alertsniveau01);
        }

        // Récupération des alerts par group
        foreach($groups as $group) {
            $qb = $em->createQueryBuilder();
            $qb->select('alert')
                ->from("CadolesPortalBundle:Alert", 'alert')
                ->where(":group MEMBER OF alert.groups")
                ->andWhere('alert.publishedat <= :today')
                ->andWhere($qb->expr()->orX(
                    $qb->expr()->gt('alert.unpublishedat', ':today'),
                    $qb->expr()->isNull('alert.unpublishedat')
                ))
                ->setParameter("group",$group->getGroup())
                ->setParameter('today', date('Y-m-d'));
            
            if($idalertcategory && $alertcategoryfilter) {
                $qb->andWhere("alert.alertcategory=:alertcategory")
                   ->setParameter("alertcategory",$alertcategoryfilter);
            }
            $alertsgroups=$qb->getQuery()->getResult();
            foreach($alertsgroups as $alertgroup) {
                if(!$alerts->contains($alertgroup)) $alerts->add($alertgroup);
            }
        }

        // Trie des alerts
        $alertsordered = $alerts->getIterator();
        $alertsordered->uasort(function ($first, $second) {
            return (int) $first->getRowOrder() > (int) $second->getRowOrder() ? 1 : -1;
        });
        
        // Render
        return $this->render($this->labelentity.':viewalert.html.twig', [
            'entity'        => $entity,
            'canupdate'     => $canupdate,
            'alerts'        => $alertsordered,
            'access'        => $access
        ]);
    }     


    public function viewfluxAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        // Récupération des paramétres du widget
        $modelist=0;
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "modelist":
                    $modelist=$parameter["value"];
                    break;
            }
        }

        // Profilage
        $user=$this->getUser();
        $roles=($user?$user->getRoles():["ROLE_ANONYME"]);
        $groups=($user?$user->getGroups():[]);

        // Initialisation du calcul des fluxs
        $fluxs=new ArrayCollection();

        // Récupération des fluxs par rôles
        foreach($roles as $role) {
            $qb = $em->createQueryBuilder();
            $qb->select('flux')
                ->from("CadolesPortalBundle:Flux", 'flux')
                ->where($qb->expr()->like('flux.roles', $qb->expr()->literal("%$role%")));
            
            $fluxsroles=$qb->getQuery()->getResult();
            foreach($fluxsroles as $fluxrole) {
                if(!$fluxs->contains($fluxrole)) $fluxs->add($fluxrole);
            }
        }

        // Récupération des fluxs par group
        foreach($groups as $group) {
            $qb = $em->createQueryBuilder();
            $qb->select('flux')
                ->from("CadolesPortalBundle:Flux", 'flux')
                ->where(":group MEMBER OF flux.groups")
                ->setParameter("group",$group->getGroup());
            
            $fluxsgroups=$qb->getQuery()->getResult();
            foreach($fluxsgroups as $fluxgroup) {
                if(!$fluxs->contains($fluxgroup)) $fluxs->add($fluxgroup);
            }
        }


		$feeds=array();
        $filesystem = new Filesystem();

		foreach($fluxs as $keyflux => $flux) {
            // On regarde si le flux a été lu il y a peu
            $toregen=true;
            $url=$flux->getUrl();

            // Feed lié à un user interne
            $filecache='uploads/flux/flux-'.$flux->getId().'.txt';
            if(stripos($url,"##userid##")!==false) {
                if($user) {
                    $url=str_replace("##userid##",$user->getId(),$url);
                    $filecache=$filecache='uploads/flux/flux-'.$user->getId()."-".$flux->getId().'.txt';
                }
            }

            // Si le fichie cache existe
            if($filesystem->exists($filecache)) {
                // On récupère la date de modification du fichier
                $timestampfile = filemtime($filecache);
                $datetimeFormat = 'Y-m-d H:i:s';
                $datefile = new \DateTime();
                $datefile->setTimestamp($timestampfile);
    
                // On ajoute 30mn
                $datefile->add(new \DateInterval('PT30M'));
                
                // Si la date est inférieur à maintenant on regénère le flux
                $now = new \DateTime();
                if($datefile>=$now) {
                    $toregen=false;
                    $backup = unserialize(file_get_contents($filecache));
                    $feeds=array_merge($feeds,$backup);
                    if(empty($backup)) unset($fluxs[$keyflux]);                    
                }
            }

            // Si le fichier est trop ancien on relit le flus
            if($toregen) {
                $PROXYactivate = $em->getRepository("CadolesCoreBundle:Config")->find("PROXYactivate")->getValue();
                $weburl=$this->getParameter('weburl');

                if(stripos($url,"/")==0) {
                    $url="https://".$weburl.$url;
                    $PROXYactivate=false; 
                }
                if(stripos($url,"https://".$weburl)===0) $PROXYactivate=false; 
                if(stripos($url,"http://".$weburl)===0) $PROXYactivate=false; 
                
                if($PROXYactivate) {
                    $PROXYserver    = $em->getRepository("CadolesCoreBundle:Config")->find("PROXYserver")->getValue();
                    $PROXYport      = $em->getRepository("CadolesCoreBundle:Config")->find("PROXYport")->getValue();
                    $clientguzzle = new \GuzzleHttp\Client(array('timeout' => 3,'verify'=>false,'proxy' => ['http'  => 'http://'.$PROXYserver.':'.$PROXYport,'https' => 'http://'.$PROXYserver.':'.$PROXYport]));
                }
                else
                    $clientguzzle = new \GuzzleHttp\Client(['timeout' => 3,'verify'=>false]);
    
                try {
                    $clientguzzle->request('GET', $url);
                } catch (RequestException $e) {
                    if ($e->hasResponse()) {
                        continue;
                    }
                }
    
                // On lit le flux rss
                $client = new \FeedIo\Adapter\Guzzle\Client($clientguzzle);
                $logger = new \Psr\Log\NullLogger();
                $feedIo = new \FeedIo\FeedIo($client, $logger);
                                
                $result     = $feedIo->read($url);
                $feedtitle  = $result->getFeed()->getTitle();
                
                
                $backup=[];

                // Pour chaque articles
                $nbflux=0;
                foreach ($result->getFeed() as $item) {
                    $title 			= $item->getTitle();
                    $link			= $item->getLink();
                    $description 	= substr(strip_tags($item->getDescription()),0,250);
                    $description    = str_replace("&para;","",$description);
                    $date 			= $item->getLastModified();
                    $dateformat		= ($date?$item->getLastModified()->format('d/m/Y H:i:s'):"");
                    $content 		= $item->getDescription();
                    $media          = $item->getMedias();
                    $mediaurl		= "";

                    foreach ($item->getMedias() as $itemMedia) {
                        if($itemMedia->getType()=="image/jpeg")
                            $mediaurl=$itemMedia->getUrl();
                    }

                    foreach ($item->getAllElements() as $element) {

                        if($element->getName()=="content:encoded")
                            $content = $element->getValue();
                    }

                    if($mediaurl!="") {
                        $imgurl=$mediaurl;
                    }
                    else {
                        // Récupérer la première image du contenu
                        $imgcontent="";
                        $imgurl="";
                        $imgstart = stripos($content,"<img");
                        if($imgstart!== false) {
                            $imgend = stripos($content,">",$imgstart);
                            $imgcontent=substr($content,$imgstart,$imgend-$imgstart+1);
                        
                            $imgstart = stripos($imgcontent,"src=");
                            $imgurl=substr($imgcontent,$imgstart+5);
                            $imgend = stripos($imgurl,'"');

                            if($imgend===false) $imgend = stripos($imgurl,"'");
                            $imgurl=substr($imgurl,0,$imgend);
                        }
                    }

                    // Garder le flux
                    
                    $tmp=array(
                        "feedtitle"		=> $feedtitle,
                        "title" 		=> $title,
                        "link"			=> $link,
                        "description"	=> $description,
                        "date"			=> $date,
                        "dateformat"	=> $dateformat,
                        "content"		=> $content,
                        "image"			=> $imgurl,
                        "color"         => $flux->getColor(),
                        "fluxid"        => $flux->getId(),
                        "fluxtitle"     => $flux->getTitle(),
                    );

                    array_push($feeds,$tmp);
                    array_push($backup,$tmp);

                    $nbflux++;
                    if($nbflux>=$flux->getMaxread()&&$flux->getMaxread()>0) break;
                }


                if($nbflux==0) unset($fluxs[$keyflux]);  
                
                // On sauvegarde le résultat en fichier on rechargera son contenu que s'il n'a pas été lu depuis 30mn
                $filesystem->dumpFile($filecache, serialize($backup));
            }
		}

        // Trie des fluxs
        $fluxsordered = $fluxs->getIterator();
        $fluxsordered->uasort(function ($first, $second) {
            return (int) $first->getRowOrder() > (int) $second->getRowOrder() ? 1 : -1;
        });
                
        // Trie des feeds
    	$libelle=array();
		foreach ($feeds as $key => $valeur) {
			$libelle[$key] = $valeur["date"];
		}
		array_multisort($libelle, SORT_DESC, $feeds);

        // Render
        return $this->render($this->labelentity.':viewflux.html.twig', [
            'entity'        => $entity,
            'canupdate'     => $canupdate,
            'modelist'      => $modelist,
            'fluxs'         => $fluxsordered,
            'access'        => $access,
            'feeds'         => $feeds,
            
        ]);
    }      


    public function viewrssAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }     

        // Récupération des paramétres du widget
        $url="";
        $nbarticle="_blank";
        $modelist=0;
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "url":
                    $url=$parameter["value"];
                    break;
                case "nbarticle":
                    $nbarticle=$parameter["value"];
                    break;           
                case "modelist":
                    $modelist=$parameter["value"];
                    break;                             
            }
        }  

        // On regarde si le flux a été lu il y a peu
        $toregen=true;
        $filecache=$filecache='uploads/flux/widget-'.$id.'.txt';
        $user=$this->getUser();
        if(stripos($url,"##userid##")!==false) {
            if($user) {
                $url=str_replace("##userid##",$user->getId(),$url);
                $filecache=$filecache='uploads/flux/widget-'.$user->getId()."-".$id.'.txt';
            }
        }

        $filesystem = new Filesystem();
        if($filesystem->exists($filecache)) {
            // On récupère la date de modification du fichier
            $timestampfile = filemtime($filecache);
            $datetimeFormat = 'Y-m-d H:i:s';
            $datefile = new \DateTime();
            $datefile->setTimestamp($timestampfile);

            // On ajoute 30mn
            $datefile->add(new \DateInterval('PT30M'));
            
            // Si la date est inférieur à maintenant on regénère le flux
            $now = new \DateTime();
            if($datefile>=$now) {
                $toregen=false;
                $feeds = unserialize(file_get_contents($filecache));
            }
        }

        // Si le fichier est trop ancien on relit le flus
        if($toregen) {
            // Connexion au client
            $PROXYactivate = $em->getRepository("CadolesCoreBundle:Config")->find("PROXYactivate")->getValue();
            $weburl=$this->getParameter('weburl');
            if(stripos($url,"/")==0) {
                $url="https://".$weburl.$url;
                $PROXYactivate=false; 
            }
            if(stripos($url,"https://".$weburl)===0) $PROXYactivate=false; 
            if(stripos($url,"http://".$weburl)===0) $PROXYactivate=false;              

            if($PROXYactivate) {
                $PROXYserver    = $em->getRepository("CadolesCoreBundle:Config")->find("PROXYserver")->getValue();
                $PROXYport      = $em->getRepository("CadolesCoreBundle:Config")->find("PROXYport")->getValue();
                $clientguzzle = new \GuzzleHttp\Client(array('timeout' => 3,'verify'=>false,'proxy' => ['http'  => 'http://'.$PROXYserver.':'.$PROXYport,'https' => 'http://'.$PROXYserver.':'.$PROXYport]));
            }
            else
                $clientguzzle = new \GuzzleHttp\Client(array('timeout' => 3,'verify'=>false));

            try {
                $clientguzzle->request('GET', $url);
            } catch (RequestException $e) {
                if ($e->hasResponse()) {
                    // Render
                    $feeds=[];
                    return $this->render($this->labelentity.':viewflux.html.twig', [
                        'entity'        => $entity,
                        'canupdate'     => $canupdate,
                        'access'        => $access,
                        'feeds'         => $feeds,
                    ]);
                }
            }

            $client = new \FeedIo\Adapter\Guzzle\Client($clientguzzle);
            $logger = new \Psr\Log\NullLogger();
            $feedIo = new \FeedIo\FeedIo($client, $logger);

            $feeds=array();
            
            // On lit le flux rss
            $result     = $feedIo->read($url);
            $feedtitle  = $result->getFeed()->getTitle();
            
            
            // Pour chaque articles
            $nbflux=0;
            foreach ($result->getFeed() as $item) {
                $title 			= $item->getTitle();
                $link			= $item->getLink();
                $description 	= substr(strip_tags($item->getDescription()),0,250);
                $description    = str_replace("&para;","",$description);
                $date 			= $item->getLastModified();
                $dateformat		= ($date?$item->getLastModified()->format('d/m/Y H:i:s'):"");
                $content 		= $item->getDescription();
                $media          = $item->getMedias();
                $mediaurl		= "";

                foreach ($item->getMedias() as $itemMedia) {
                    if($itemMedia->getType()=="image/jpeg")
                        $mediaurl=$itemMedia->getUrl();
                }

                foreach ($item->getAllElements() as $element) {
                    if($element->getName()=="content:encoded")
                        $content = $element->getValue();
                }

                if($mediaurl!="") {
                    $imgurl=$mediaurl;
                }
                else {
                    // Récupérer la première image du contenu
                    $imgcontent="";
                    $imgurl="";
                    $imgstart = stripos($content,"<img");
                    if($imgstart!== false) {
                        $imgend = stripos($content,">",$imgstart);
                        $imgcontent=substr($content,$imgstart,$imgend-$imgstart+1);
                        
                        $imgstart = stripos($imgcontent,"src=");
                        $imgurl=substr($imgcontent,$imgstart+5);
                        $imgend = stripos($imgurl,'"');

                        if($imgend===false) $imgend = stripos($imgurl,"'");
                        $imgurl=substr($imgurl,0,$imgend);
                    }
                }
                
                // Garder le flux
                array_push($feeds,array(
                    "feedtitle"		=> $feedtitle,
                    "title" 		=> $title,
                    "link"			=> $link,
                    "description"	=> $description,
                    "date"			=> $date,
                    "dateformat"	=> $dateformat,
                    "content"		=> $content,
                    "image"			=> $imgurl,
                    // "color"         => $flux->getColor(),
                    "fluxid"        => 0,
                    "fluxtitle"     => $entity->getName(),
                    ));

                $nbflux++;
                if($nbflux>=$nbarticle&&$nbarticle>0) break;
            }


            $libelle=array();
            foreach ($feeds as $key => $valeur) {
                $libelle[$key] = $valeur["date"];
            }
            array_multisort($libelle, SORT_DESC, $feeds);

            // On sauvegarde le résultat en fichier on rechargera son contenu que s'il n'a pas été lu depuis 30mn
            $filesystem->dumpFile($filecache, serialize($feeds));
        }

        // Render
        return $this->render($this->labelentity.':viewflux.html.twig', [
            'entity'        => $entity,
            'canupdate'     => $canupdate,
            'fluxs'         => ["id"=>0],
            'access'        => $access,
            'feeds'         => $feeds,
            'modelist'      => $modelist,
        ]);
    }  

    public function viewbookmarkAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }   
        

        // Récupération des paramétres du widget
        $modedesktop=0;
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "modedesktop":
                    $modedesktop=$parameter["value"];
                    break;
            }
        }
        
        // Profilage
        $user=$this->getUser();

        // Bookmark du widget
        $bookmarks=$em->getRepository("CadolesPortalBundle:Bookmark")->findBy(["pagewidget"=>$entity]);
        
        // Render
        return $this->render($this->labelentity.':viewbookmark.html.twig', [
            'entity'        => $entity,
            'canadd'        => $canupdate,
            'canupdate'     => $canupdate,
            'modedesktop'   => $modedesktop,
            'bookmarks'     => $bookmarks,
            'access'        => $access,
        ]);
    }   

    public function viewlinkAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        // Récupération des paramétres du widget
        $url="";
        $target="_blank";
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "url":
                    $url=$parameter["value"];
                    break;
                case "target":
                    $target=$parameter["value"];
                    break;                    
            }
        }
        
        // Render
        return $this->render($this->labelentity.':viewlink.html.twig', [
            'entity'        => $entity,
            'canadd'        => false,
            'canupdate'     => $canupdate,
            'url'           => $url,
            'target'        => $target,
            'access'        => $access,
        ]);
    }       

    public function vieweditorAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        // Récupération des paramétres du widget
        $html="";
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "html":
                    $html=$parameter["value"];
                    break;
                 
            }
        }
        
        // Render
        return $this->render($this->labelentity.':vieweditor.html.twig', [
            'entity'        => $entity,
            'canadd'        => false,
            'canupdate'     => $canupdate,
            'html'          => $html,
            'access'        => $access,
        ]);
    }   

    public function viewslideAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }
        
        // Parametres
        $interval="2";
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "interval":
                    $interval=$parameter["value"];
                    break;                
            }
        }

        $slides=$em->getRepository("CadolesPortalBundle:Slide")->findBy(["pagewidget"=>$entity],['roworder'=>'ASC','title'=>'ASC']);

        // Render
        return $this->render($this->labelentity.':viewslide.html.twig', [
            'entity'        => $entity,
            'canadd'        => $canupdate,
            'canupdate'     => $canupdate,
            'slides'        => $slides,
            'interval'      => $interval,
            'access'        => $access,
        ]);
    }    

    public function viewfileAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }
        
        $directory=$this->get('kernel')->getRootDir()."/../uploads/file/widget-".$id;
        $files=[];
        $fs = new Filesystem();

        if($fs->exists($directory)) {
            $finder = new Finder();
            $finder->sortByName()->in($directory)->exclude('thumb')->exclude('thumbmini');
            
            foreach ($finder as $file) {
                $tmp=[];
                $tmp["name"]=$file->getRelativePathname();
                $tmp["extension"]=strtolower($file->getExtension());
                $fileinfo = new file($file->getPathname());
                $tmp["minetype"]=$fileinfo->getMimeType();
                $tmp["minefamily"]=explode("/",$tmp["minetype"])[0];

                $tmp["thumb"]="";
                if($tmp["extension"]=="pdf") {
                    $tmp["thumb"]="/".$this->getParameter('alias')."/bundles/cadolescore/images/files/".$tmp["extension"].".png";
                    
                    /* ne plus afficher l'apercu du pdf
                    if($fs->exists($directory."/thumbmini/".$tmp["name"])) {
                        $data = file_get_contents($directory."/thumbmini/".$tmp["name"]);
                        $tmp["thumb"]="data:image/jpg;base64," . base64_encode($data);
                    }
                    elseif($fs->exists($directory."/thumb/".$tmp["name"])) {
                        $data = file_get_contents($directory."/thumb/".$tmp["name"]);
                        $tmp["thumb"]="data:image/jpg;base64," . base64_encode($data);
                    }
                    */
                }
                elseif($fs->exists($directory."/thumbmini/".$tmp["name"])) {
                    $data = file_get_contents($directory."/thumbmini/".$tmp["name"]);
                    $tmp["thumb"]="data:image/" . $tmp["extension"] . ";base64," . base64_encode($data);
                }
                elseif($fs->exists($directory."/thumb/".$tmp["name"])) {
                    $data = file_get_contents($directory."/thumb/".$tmp["name"]);
                    $tmp["thumb"]="data:image/" . $tmp["extension"] . ";base64," . base64_encode($data);
                }
                elseif($fs->exists($this->get('kernel')->getRootDir()."/../web/bundles/cadolescore/images/files/".$tmp["extension"].".png")) {
                    $tmp["thumb"]="/".$this->getParameter('alias')."/bundles/cadolescore/images/files/".$tmp["extension"].".png";
                }

                array_push($files,$tmp);
            }
        }

        // Render
        return $this->render($this->labelentity.':viewfile.html.twig', [
            'entity'        => $entity,
            'canadd'        => $canupdate,
            'canupdate'     => $canupdate,
            'files'         => $files,
            'access'        => $access,
        ]);
    }
    
    public function viewgaleryAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }
        
        $directory=$this->get('kernel')->getRootDir()."/../uploads/file/widget-".$id;
        $files=[];
        $fs = new Filesystem();

        if($fs->exists($directory)) {
            $finder = new Finder();
            $finder->sortByName()->in($directory)->exclude('thumb')->exclude('thumbmini');
            
            foreach ($finder as $file) {
                $tmp=[];
                $tmp["name"]=$file->getRelativePathname();
                $tmp["extension"]=$file->getExtension();
                $fileinfo = new file($file->getPathname());
                $tmp["minetype"]=$fileinfo->getMimeType();
                $tmp["minefamily"]=explode("/",$tmp["minetype"])[0];

                $tmp["thumb"]="";
                if($fs->exists($directory."/thumb/".$tmp["name"])) {
                    $data = file_get_contents($directory."/thumb/".$tmp["name"]);
                    $tmp["thumb"]="data:image/" . $tmp["extension"] . ";base64," . base64_encode($data);
                }

                array_push($files,$tmp);
            }
        }

        
        // Render
        return $this->render($this->labelentity.':viewgalery.html.twig', [
            'entity'        => $entity,
            'canadd'        => $canupdate,
            'canupdate'     => $canupdate,
            'files'         => $files,
            'access'        => $access,
        ]);
    }    

    public function viewcalendarAction(Request $request,$id,$access="config") {
        $usage=$request->query->get('usage');
        $group=$request->query->get('group');

        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        $groupentity=$em->getRepository("CadolesCoreBundle:Group")->find($group);

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        // Parametres
        $nbday="0";
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "nbday":
                    $nbday=$parameter["value"];
                    break;                
            }
        }

        // On récupère soit les calendriers du group en cours soit l'ensemble des calendriers de l'utilisateur
        if($usage=="group") {
            $calendars=$em->getRepository("CadolesPortalBundle:Calendar")->getCalendarsGroup($this->getUser(),$group);
            if($calendars) $firstcalendar=$calendars[0]->getId();
        }
        else {
            $this->getDoctrine()->getRepository("CadolesPortalBundle:Calendar")->getCalendarsUser($this->getUser(),$calendarssuser,$calendarsadmin,$calendarsshared);
            $calendars=array_merge($calendarssuser,$calendarsadmin->toArray(),$calendarsshared); 
            $firstcalendar="all";
        }

        // Début & fin
        $start=new \DateTime();
        $start->setTime(0,0);

        $end=new \DateTime();
        $end->setTime(0,0);
        $end->add(new \DateInterval('P3M'));
        $end->modify('last day of this month');

        $events=[];
        $eventids=[];

        foreach($calendars as $calendar) {
            $calendarevents = $this->getDoctrine()->getRepository("CadolesPortalBundle:Calendarevent")->getCalendareventByDate($calendar,$start,$end);

            foreach($calendarevents as $calendarevent) {
                $tmp=[];
                $tmp['id']            = strval($calendarevent->getId());
                $tmp['title']         = $calendarevent->getName();
                $tmp['description']   = $calendarevent->getDescription();
                $tmp['start']         = $calendarevent->getStart();
                $tmp['end']           = $calendarevent->getEnd();
                $tmp['color']         = "#".(is_null($calendar->getColor())?$this->get('session')->get('color')["main"]:$calendar->getColor());
                $tmp['allDay']        = $calendarevent->getAllday();
                $tmp['calendar']      = $calendar->getId();
                $tmp['editable']      = $calendar->getCanupdate();

                // Si évènement sur la journée on enlève une 1 seconde à la date de fin
                if($tmp['allDay'])
                    $tmp['end']->sub(new \DateInterval('PT1S'));

                array_push($events,$tmp);
                array_push($eventids,$tmp["id"]);
            }
        }

        // On récupére les évenement partagé de l'utilisateur
        if($this->getUser()) {
            $calendarevents = $this->getDoctrine()->getRepository("CadolesPortalBundle:Calendarevent")->getCalendareventGroupsShareByDate($this->getUser(),$start,$end);
            foreach($calendarevents as $calendarevent) {
                if($usage=="group") {
                    if(!$calendarevent->getGroups()->contains($groupentity)) continue;
                }

                $tmp=[];
                $tmp['id']            = strval($calendarevent->getId());
                $tmp['title']         = $calendarevent->getName();
                $tmp['description']   = $calendarevent->getDescription();
                $tmp['start']         = $calendarevent->getStart();
                $tmp['end']           = $calendarevent->getEnd();
                $tmp['color']         = "#".(is_null($calendar->getColor())?$this->get('session')->get('color')["main"]:$calendar->getColor());
                $tmp['allDay']        = $calendarevent->getAllday();
                $tmp['calendar']      = $calendar->getId();
                $tmp['editable']      = $calendar->getCanupdate();

                // Si évènement sur la journée on enlève une 1 seconde à la date de fin
                if($tmp['allDay'])
                    $tmp['end']->sub(new \DateInterval('PT1S'));

                if(!in_array($tmp['id'],$eventids)) {
                    array_push($events,$tmp);
                    array_push($eventids,$tmp["id"]);
                }
            }
        }
        
        // Render
        return $this->render($this->labelentity.':viewcalendar.html.twig', [
            'entity'        => $entity,
            'canadd'        => $canupdate,
            'canupdate'     => $canupdate,
            'events'        => $events,
            'nbday'         => $nbday,
            'access'        => $access,
            'firstcalendar' => $firstcalendar,
            'usage'         => $usage
        ]);
    }  

    public function viewblogAction(Request $request,$id,$access="config") {
        $usage=$request->query->get('usage');
        $group=$request->query->get('group');

        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        // Parametres
        $nbarticle=10;
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "nbarticle":
                    $nbarticle=$parameter["value"];
                    break;                
            }
        }

        // On récupère soit les blogs du group en cours soit l'ensemble des blogs de l'utilisateur
        if($usage=="group") {
            $blogs=$em->getRepository("CadolesPortalBundle:Blog")->getBlogsGroup($this->getUser(),$group);
            if($blogs) $firstblog=$blogs[0]->getId();
        }
        else {
            $em->getRepository("CadolesPortalBundle:Blog")->getBlogsUser($this->getUser(),$blogsuser,$blogsadmin,$blogsshared);
            $blogs=array_merge($blogsuser,$blogsadmin->toArray(),$blogsshared);
            $firstblog="all";
        }

        // On récupère les nbarticle de ses blogs
        $em->getRepository("CadolesPortalBundle:Blogarticle")->getBlogsArticles($blogs,0,$nbarticle,$count,$blogarticles);

        // Render
        return $this->render($this->labelentity.':viewblog.html.twig', [
            'entity'        => $entity,
            'canadd'        => $canupdate,
            'canupdate'     => $canupdate,
            'blogarticles'  => $blogarticles,
            'nbarticle'     => $nbarticle,
            'access'        => $access,
            'firstblog'     => $firstblog,
            'usage'         => $usage
        ]);
    }  

    public function viewprojectAction(Request $request,$id,$access="config") {
        $usage=$request->query->get('usage');
        $group=$request->query->get('group');

        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        // Parametres
        $nbarticle=10;
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "nbarticle":
                    $nbarticle=$parameter["value"];
                    break;                
            }
        }

        // On récupère soit les projects du group en cours soit l'ensemble des projects de l'utilisateur
        $user=$this->getUser();
        if($usage=="group") {
            $projects=$em->getRepository("CadolesPortalBundle:Project")->getProjectsGroup($this->getUser(),$group);
            if($projects) $firstproject=$projects[0]->getId();
        }
        else {
            $em->getRepository("CadolesPortalBundle:Project")->getProjectsUser($user,$projectsuser,$projectsadmin,$projectsshared);
            $projects=array_merge($projectsuser,$projectsadmin->toArray(),$projectsshared);
            $firstproject="all";
        }

        // On récupère les nbarticle de ses projects
        $em->getRepository("CadolesPortalBundle:Projecttask")->getProjectsTasks($projects,0,$nbarticle,$count,$projecttasks);

        foreach($projecttasks as $key => $projecttask) {
            if($projecttask->getPercentage()==100) unset($projecttasks[$key]);
        }

        if($usage!="group") {
            foreach($projecttasks as $key => $projecttask) {
                if(!$user) unset($projecttasks[$key]);
                else {
                    if($projecttask->getUser() && $projecttask->getUser()!=$user) unset($projecttasks[$key]);
                    elseif($projecttask->getOwner() && $projecttask->getOwner()!=$user) unset($projecttasks[$key]);
                }
            }
        }

        // Render
        return $this->render($this->labelentity.':viewproject.html.twig', [
            'entity'        => $entity,
            'canadd'        => $canupdate,
            'canupdate'     => $canupdate,
            'projecttasks'  => $projecttasks,
            'nbarticle'     => $nbarticle,
            'access'        => $access,
            'firstproject'  => $firstproject,
            'usage'         => $usage
        ]);
    }  

    public function viewseparatorAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }
        
        // Parametres
        $seetitle=false;
        $seeicon=false;
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "seetitle":
                    $seetitle=boolval($parameter["value"]);
                    break;     
                case "seeicon":
                    $seeicon=boolval($parameter["value"]);
                    break;                                    
            }
        }

        // Render
        return $this->render($this->labelentity.':viewseparator.html.twig', [
            'entity'        => $entity,
            'canadd'        => $canupdate,
            'canupdate'     => $canupdate,
            'seetitle'      => $seetitle,
            'seeicon'       => $seeicon,
            'access'        => $access,
        ]);
    } 

    public function viewclockAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }
        
        // Parametres
        $clock="0";
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "clock":
                    $clock=$parameter["value"];
                    break;                
            }
        }

        // Render
        return $this->render($this->labelentity.':viewframe.html.twig', [
            'entity'        => $entity,
            'canadd'        => $canupdate,
            'canupdate'     => $canupdate,
            'onheader'      => true,
            'tool'          => ($clock==0?"cadoles_portal_user_tool_clockanalogique":"cadoles_portal_user_tool_clocknumerique"),
            'access'        => $access,
        ]);
    }  

    public function viewcalculatorAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }
        

        // Render
        return $this->render($this->labelentity.':viewframe.html.twig', [
            'entity'        => $entity,
            'canadd'        => $canupdate,
            'canupdate'     => $canupdate,
            'onheader'      => true,
            'tool'          => "cadoles_portal_user_tool_calculator",
            'access'        => $access,
        ]);
    }            

    public function viewappexternalAction($id,$access="config") {
        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        // Récupération des paramétres du widget
        $idappexternal=null;
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {
                case "appexternal":
                    $idappexternal=$parameter["value"];
                    break;
                case "modedesktop":
                    $modedesktop=$parameter["value"];
                    break;                
            }
        }
        
        $user=$this->getUser();
        $items=[];
        $itemcategorys=[];
        if($user) {
            if($idappexternal) $appextenals=$em->getRepository("CadolesPortalBundle:Appexternal")->findBy(["id"=>$idappexternal]);
            else  $appextenals=$em->getRepository("CadolesPortalBundle:Appexternal")->findAll();
            foreach($appextenals as $appexternal) {
                switch($appexternal->getName()) {
                    case "Limesurvey":
                        $category=["id"=>0,"label"=>"Limesurvey"];
                        array_push($itemcategorys,$category);

                        $directory=$this->get('kernel')->getRootDir()."/../uploads/limesurvey/".$user->getId();
                        $files=[];
                        $fs = new Filesystem();

                        if($fs->exists($directory."/invitation.json")) {
                            $file=file_get_contents($directory."/invitation.json");
                            $json = substr($file, 0, -2);  // sup dernier ,
                            $surveys = json_decode("{".$json."}", true);
                            if(is_array($surveys)) {
                                foreach($surveys as $id => $survey) {
                                    array_push($items,["id"=>$id,"title"=>$survey["title"],"subtitle"=>"Sondage","url"=>$survey["url"],"itemcategory"=>$category,"color"=>"328637","icon"=>"icon_limesurvey.png"]);
                                }
                            }
                        }

                        break;

                    case "Moodle":
                        $category=["id"=>1,"label"=>"Moodle"];
                        array_push($itemcategorys,$category);

                        $directory=$this->get('kernel')->getRootDir()."/../uploads/moodle/".$user->getId();
                        $files=[];
                        $fs = new Filesystem();

                        if($fs->exists($directory."/invitation.json")) {
                            $file=file_get_contents($directory."/invitation.json");
                            $json = substr($file, 0, -2);  // sup dernier ,
                            $courses = json_decode("{".$json."}", true);
                            if(is_array($courses)) {
                                foreach($courses as $id => $course) {
                                    array_push($items,["id"=>$id,"title"=>$course["title"],"subtitle"=>"Cours","url"=>$course["url"],"itemcategory"=>$category,"color"=>"f77f11","icon"=>"icon_moodle.png"]);
                                }
                            }
                        }

                        break;                        
                }
            }
        }

        // Trier les item par title
        $title  = array_column($items, 'title');
        array_multisort($title, SORT_ASC, $items);

        // Render
        return $this->render($this->labelentity.':viewappexternal.html.twig', [
            'entity'        => $entity,
            'canadd'        => ($user),
            'canupdate'     => $canupdate,
            'modedesktop'   => $modedesktop,
            'items'         => $items,
            'itemcategorys' => $itemcategorys,
            'access'        => $access,
        ]);
    }     

    public function viewinfoAction(Request $request,$id,$access="config") {
        $usage=$request->query->get('usage');
        $group=$request->query->get('group');    
        $user=$this->getUser();

        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');
        $page=$entity->getPage();

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        $icon=null;
        $title=null;
        $description=null;
        $members=[];
        if($usage=="group") {
            $group=$em->getRepository("CadolesCoreBundle:Group")->find($group);
            if($group) {
                $title=$group->getLabel();
                $id=$group->getId();
                if($group->getDescription())
                    $description="<strong>Description</strong><br>".$group->getDescription();
                if($group->getIcon())
                    $icon="/".$group->getIcon()->getLabel();
                
                    
                foreach($group->getUsers() as $usergroup) {
                    
                    array_push($members,$usergroup);
                }
            }
        }
        else {
            $title=$entity->getPage()->getName();
            $proprio=$entity->getPage()->getUser();
            $id=0;
            if($proprio) {
                $description="Propriétaire de la page<br>".$proprio->getLastname()." ".$proprio->getLastname();
                $icon="/uploads/avatar/".$proprio->getAvatar();
            }
        }
        // Render
        return $this->render($this->labelentity.':viewinfo.html.twig', [
            'entity'        => $entity,
            'canadd'        => $canupdate,
            'canupdate'     => $canupdate,
            'usage'         => $usage,
            'icon'          => $icon,
            'title'         => $title,
            'description'   => $description,
            'members'       => $members,
            'id'            => $id,
            'idpage'        => $page->getId(),   
        ]);
    }     

    public function viewchatAction(Request $request,$id,$access="config") {
        $usage=$request->query->get('usage');
        $group=$request->query->get('group'); 

        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        if($usage!="group"||!$group) {
            $group=$em->getRepository("CadolesCoreBundle:Group")->findOneBy(["fgall"=>true])->getId();
        }

        // Render
        return $this->render($this->labelentity.':viewchat.html.twig', [
            'entity'        => $entity,
            'canadd'        => $canupdate,
            'canupdate'     => $canupdate,
            'onheader'      => false,
            'tool'          => "cadoles_websocket_chat",
            'access'        => $access,
            'usage'         => $usage,
            'group'         => $group,
        ]);
    } 


    public function viewgroupAction(Request $request,$id,$access="config") {
        $usage=$request->query->get('usage');
        $group=$request->query->get('group');    
        $user=$this->getUser();

        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        $mygroups=[];
        $this->getDoctrine()->getRepository("CadolesPortalBundle:Page")->getPagesUser($user,null,$default,$pagesuser,$pagesadmin,$groupsshared);
        if(is_array($groupsshared)) {
            foreach($groupsshared as $groupshared) {

                $title=$groupshared->getLabel();
                $idpage=$groupshared->pagesshared[0]->getId();
                $color=$groupshared->getColor();
                $icon=null;
                if($groupshared->getIcon())
                    $icon="/".$groupshared->getIcon()->getLabel();  

                array_push($mygroups,["title"=>$title,"icon"=>$icon,"id"=>$idpage,"color"=>$color]);
            }
        }
        
        // Render
        return $this->render($this->labelentity.':viewgroup.html.twig', [
            'entity'        => $entity,
            'canadd'        => ($user),
            'canupdate'     => $canupdate,
            'usage'         => $usage,
            'groups'        => $mygroups,

        ]);
    }  
    
    public function viewgroupmessageAction(Request $request,$id,$access="config") {
        $usage=$request->query->get('usage');
        $group=$request->query->get('group');    
        $user=$this->getUser();

        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }

        // Récupération des paramétres du widget
        $modelist=1;
        $nbarticle=5;
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {     
                case "modelist":
                    $modelist=$parameter["value"];
                    break;                             
                case "nbarticle":
                    $nbarticle=$parameter["value"];
                    break;                             
            }
        }  

        $mygroups=[];
        $mymsg= [];
        $this->getDoctrine()->getRepository("CadolesPortalBundle:Page")->getPagesUser($user,null,$default,$pagesuser,$pagesadmin,$groupsshared);
        if(is_array($groupsshared)) {
            foreach($groupsshared as $groupshared) {
                // On récupère les info du groupe
                $title=$groupshared->getLabel();
                $idpage=$groupshared->pagesshared[0]->getId();
                $color=$groupshared->getColor();

                // On récupère l'ensemble des messages du groupes
                $messages=$this->getDoctrine()->getRepository("CadolesWebsocketBundle:Message")->findBy(["group"=>$groupshared]);
                foreach($messages as $key => $message) {
                    // persistante collection à revoir
                    if($message->getSees()->count()>0) {
                        if($message->getSees()->contains($user) ) {

                            unset($messages[$key]);
                        }
                    }
                }

                foreach($messages as $key => $message) {
                    $tmp=["id" => $message->getId(), "user" => $message->getUser(), "date"=>$message->getSubmitdate(), "topic"=>$message->getTopic(), "pageid" => $idpage, "pagetitle" => $title, "color" => $color];
                    array_push($mymsg,$tmp);   
                }
            }
            
            $ord = array();
            foreach ($mymsg as $key => $value){
                $ord[] = $value['date'];
            }
            array_multisort($ord, SORT_DESC, $mymsg);
        }

        
        // Render
        return $this->render($this->labelentity.':viewgroupmessage.html.twig', [
            'entity'        => $entity,
            'canadd'        => ($user),
            'canupdate'     => $canupdate,
            'usage'         => $usage,
            'modelist'      => $modelist,
            'messages'      => $mymsg, 
            'nbarticle'     => $nbarticle,

        ]);
    } 
    
    public function viewOnlydocAction(Request $request,$id,$access="config") {
        $usage=$request->query->get('usage');
        $group=$request->query->get('group');    
        $user=$this->getUser();

        $em = $this->getDoctrine()->getManager();
        $entity = $em->getRepository($this->labelentity)->find($id);
        if (!$entity) throw $this->createNotFoundException('Unable to find entity.');

        // Permissions
        if($access=="config") {
            $canupdate = true;
            $cansee = true;
        }
        else {
            // On s'assure que l'utilisateur à la permission de voir
            $page=$entity->getPage();
            $em->getRepository("CadolesPortalBundle:Page")->getPermission($this->getUser(),$page,$cansee,$canupdate);
            if(!$cansee) throw $this->createNotFoundException('Permission denied');
        }
        
        
        $onlyservice = $this->container->get('cadoles.portal.service.only');
        $files=$onlyservice->getDocument($group, $folders, $firstfolder, $tasks);
        $grp=null;
        if($group) $grp=$em->getRepository("CadolesCoreBundle:Group")->find($group);
        if($grp) $idonly= $grp->getIdOnlyoffice();
        else $idonly=0;

        // Récupération des paramétres du widget
        $apponly=0;
        foreach($entity->getParameter()["fields"] as $parameter) {
            switch($parameter["id"]) {     
                case "apponly":
                    $apponly=$parameter["value"];
                    break;                             
            }
        } 

        // Render
        return $this->render($this->labelentity.':viewonlydoc.html.twig', [
            'entity'        => $entity,
            'canadd'        => $cansee,
            'canupdate'     => $cansee,
            'firstfolder'   => $firstfolder,
            'folders'       => $folders,
            'tasks'         => $tasks,
            'urlonly'       => $this->getParameter("widonlyoffice_url")."/products/projects/projects.aspx?prjID=".$idonly,
            'apponly'       => $apponly,
            'files'         => $files,
            'access'        => $access,
        ]);
    }    
}