1706 lines
68 KiB
PHP
1706 lines
68 KiB
PHP
<?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 $entity;
|
|
private $page;
|
|
private $id;
|
|
private $access;
|
|
private $look;
|
|
private $mini;
|
|
private $selwidget;
|
|
private $usage;
|
|
private $group;
|
|
|
|
private $cansee;
|
|
private $canupdate;
|
|
private $canadd;
|
|
|
|
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"]=($field->type!="hidden"?$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,$canadd);
|
|
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"]=($field->type!="hidden"?$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,$canadd);
|
|
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());
|
|
}
|
|
}
|
|
}
|
|
|
|
protected function setRequest($request,$id,$access) {
|
|
$this->em = $this->getDoctrine()->getManager();
|
|
$this->user = $this->getUser();
|
|
$this->id = $id;
|
|
$this->access = $access;
|
|
$this->look = $request->query->get('look');
|
|
$this->selwidget = $request->query->get('selwidget');
|
|
$this->usage = $request->query->get('usage');
|
|
$this->group = $request->query->get('group');
|
|
|
|
// Le widget existe-t-il ?
|
|
$this->entity = $this->em->getRepository($this->labelentity)->find($this->id);
|
|
if (!$this->entity) throw $this->createNotFoundException('Unable to find entity.');
|
|
|
|
// Permissions
|
|
if($this->access=="config") {
|
|
$this->canupdate = true;
|
|
}
|
|
else {
|
|
// On s'assure que l'utilisateur à la permission de voir
|
|
$this->page=$this->entity->getPage();
|
|
$this->em->getRepository("CadolesPortalBundle:Page")->getPermission($this->user,$this->page,$this->cansee,$this->canupdate,$this->canadd);
|
|
if(!$this->cansee) throw $this->createNotFoundException('Permission denied');
|
|
}
|
|
|
|
// Affichage miniature ?
|
|
$this->mini = ($this->look=="list"&&$this->entity->getId()!=$this->selwidget);
|
|
|
|
// Préference utilisateur
|
|
if(!$this->mini) $this->getPreference($this->entity);
|
|
}
|
|
|
|
protected function getPreference(&$entity) {
|
|
$user=$this->getUser();
|
|
if($user) {
|
|
$preference=$user->getPreference();
|
|
$id=$entity->getId();
|
|
|
|
// Preference widgetshowhide
|
|
if($this->look=="list") {
|
|
$entity->setOpened(true);
|
|
$entity->setBorder(false);
|
|
}
|
|
else {
|
|
if(is_array($preference)) {
|
|
if(array_key_exists("widgetshowhide",$preference)) {
|
|
if(array_key_exists($id,$preference["widgetshowhide"]))
|
|
$entity->setOpened(($preference["widgetshowhide"][$id]=="true"));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected function getRender($view,$params) {
|
|
// Paramétres toujours présent dans un rendu de widget
|
|
$allways = [
|
|
'entity' => $this->entity,
|
|
'canupdate' => $this->canupdate,
|
|
'access' => $this->access,
|
|
'look' => $this->look,
|
|
'mini' => $this->mini,
|
|
];
|
|
|
|
// Parametres spéficiques
|
|
$params=array_merge($allways,$params);
|
|
|
|
// Rendu
|
|
return $this->render($this->labelentity.':'.$view, $params);
|
|
}
|
|
|
|
public function viewurlAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Valeur par défaut
|
|
$url="";
|
|
$imagemedia=false;
|
|
|
|
// Datas associées au widget
|
|
if(!$this->mini) {
|
|
// Récupération des paramétres du widget
|
|
foreach($this->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
|
|
$pathinfo = pathinfo($url);
|
|
|
|
// Type image
|
|
if(array_key_exists("extension",$pathinfo)) {
|
|
if($pathinfo['extension']=="jpg"||$pathinfo['extension']=="gif"||$pathinfo['extension']=="png") {
|
|
$imagemedia=true;
|
|
}
|
|
}
|
|
// Si url classique on igonore l'usage de la sonde dnma
|
|
else {
|
|
if(stripos($url,"?")===false)
|
|
$url.="?notsondednma=true";
|
|
else
|
|
$url.="¬sondednma=true";
|
|
}
|
|
|
|
// Spécifique Deviant Art
|
|
if(strpos($url, "images-wixmp") !== false) $imagemedia=true;
|
|
}
|
|
|
|
return $this->getRender('viewurl.html.twig', [
|
|
'url' => $url,
|
|
'imagemedia' => $imagemedia,
|
|
]);
|
|
}
|
|
|
|
public function viewurlfixeAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Valeur par défaut
|
|
$url="";
|
|
$imagemedia=false;
|
|
|
|
// Datas associées au widget
|
|
if(!$this->mini) {
|
|
// Récupération des paramétres du widget
|
|
$widgettype= $this->entity->getWidget();
|
|
$jsons=$widgettype->getParameter();
|
|
$param=array();
|
|
$param["fields"]=array();
|
|
foreach($jsons->fields as $field) {
|
|
if($field->id=="url")
|
|
$url=$field->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
|
|
$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->getRender('viewurl.html.twig', [
|
|
'url' => $url,
|
|
'imagemedia' => $imagemedia,
|
|
]);
|
|
}
|
|
|
|
public function viewitemAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Valeur par défaut
|
|
$modedesktop=0;
|
|
$menu=false;
|
|
$menuall=true;
|
|
$search=false;
|
|
$withbookmark=true;
|
|
$bookmarks=null;
|
|
$itemsordered=null;
|
|
$itemcategorys=null;
|
|
|
|
// Datas associées au widget
|
|
if(!$this->mini) {
|
|
// Récupération des paramétres du widget
|
|
$iditemcategory=null;
|
|
foreach($this->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"];
|
|
break;
|
|
|
|
case "search":
|
|
$search=($parameter["value"]==1);
|
|
break;
|
|
|
|
case "menu":
|
|
$menu=($parameter["value"]==1);
|
|
break;
|
|
|
|
case "menuall":
|
|
$menuall=($parameter["value"]==1);
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
// Profilage
|
|
$itemsordered = $this->em->getRepository("CadolesPortalBundle:Item")->getUserItems($this->user,$bookmarks,$items,$itemcategorys,$iditemcategory,$this->get('session')->get('ssoitems'),$withbookmark,false);
|
|
}
|
|
|
|
// Render
|
|
return $this->getRender('viewitem.html.twig', [
|
|
'canadd' => ($this->user),
|
|
'modedesktop' => $modedesktop,
|
|
'search' => $search,
|
|
'menu' => $menu,
|
|
'menuall' => $menuall,
|
|
'withbookmark' => $withbookmark,
|
|
'bookmarks' => $bookmarks,
|
|
'items' => $itemsordered,
|
|
'itemcategorys' => $itemcategorys,
|
|
]);
|
|
}
|
|
|
|
public function viewitemessentialAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Valeur par défaut
|
|
$modedesktop=0;
|
|
$itemsordered=null;
|
|
$bookmarks=null;
|
|
|
|
// Datas associées au widget
|
|
if(!$this->mini) {
|
|
// Récupération des paramétres du widget
|
|
foreach($this->entity->getParameter()["fields"] as $parameter) {
|
|
switch($parameter["id"]) {
|
|
case "modedesktop":
|
|
$modedesktop=$parameter["value"];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Profilage
|
|
$itemsordered = $this->em->getRepository("CadolesPortalBundle:Item")->getUserItems($this->user,$bookmarks,$items,$itemcategorys,null,$this->get('session')->get('ssoitems'),0,true);
|
|
}
|
|
|
|
// Render
|
|
return $this->getRender('viewitemessential.html.twig', [
|
|
'canadd' => ($this->user),
|
|
'modedesktop' => $modedesktop,
|
|
'items' => $itemsordered,
|
|
'bookmarks' => $bookmarks,
|
|
]);
|
|
}
|
|
|
|
public function viewalertAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Valeur par défaut
|
|
$alertsordered=null;
|
|
|
|
// Datas associées au widget
|
|
if(!$this->mini) {
|
|
// Récupération des paramétres du widget
|
|
$idalertcategory=null;
|
|
$alertcategoryfilter=null;
|
|
foreach($this->entity->getParameter()["fields"] as $parameter) {
|
|
switch($parameter["id"]) {
|
|
case "alertcategory":
|
|
$idalertcategory=$parameter["value"];
|
|
if($idalertcategory) $alertcategoryfilter=$this->em->getRepository("CadolesPortalBundle:Alertcategory")->find($idalertcategory);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Profilage
|
|
$alertsordered=$this->em->getRepository("CadolesPortalBundle:Alert")->getUserAlerts($this->user,$idalertcategory,$alertcategoryfilter,$this->get('session')->get('ssoitems'));
|
|
}
|
|
|
|
// Render
|
|
return $this->getRender('viewalert.html.twig', [
|
|
'alerts' => $alertsordered,
|
|
]);
|
|
}
|
|
|
|
public function viewfluxAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Valeur par défaut
|
|
$modelist=0;
|
|
$fluxsordered=null;
|
|
$feeds=null;
|
|
|
|
// Datas associées au widget
|
|
if(!$this->mini) {
|
|
// Récupération des paramétres du widget
|
|
foreach($this->entity->getParameter()["fields"] as $parameter) {
|
|
switch($parameter["id"]) {
|
|
case "modelist":
|
|
$modelist=$parameter["value"];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Profilage
|
|
$fluxs=$this->em->getRepository("CadolesPortalBundle:Flux")->getUserFluxs($this->user);
|
|
|
|
$feeds=array();
|
|
$filesystem = new Filesystem();
|
|
|
|
// Généraltion du cache associés aux flux
|
|
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 = $this->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 = $this->em->getRepository("CadolesCoreBundle:Config")->find("PROXYserver")->getValue();
|
|
$PROXYport = $this->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);
|
|
|
|
try {
|
|
$result = $feedIo->read($url);
|
|
}
|
|
catch (\Exception $e) {
|
|
$result=null;
|
|
}
|
|
|
|
if($result) {
|
|
$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("¶","",$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->getRender('viewflux.html.twig', [
|
|
'modelist' => $modelist,
|
|
'fluxs' => $fluxsordered,
|
|
'feeds' => $feeds,
|
|
]);
|
|
}
|
|
|
|
public function viewrssAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Valeur par défaut
|
|
$modelist=0;
|
|
$fluxs=["id"=>0];
|
|
$feeds=null;
|
|
|
|
// Datas associées au widget
|
|
if(!$this->mini) {
|
|
// Récupération des paramétres du widget
|
|
$url="";
|
|
$nbarticle="_blank";
|
|
$modelist=0;
|
|
foreach($this->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 = $this->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 = $this->em->getRepository("CadolesCoreBundle:Config")->find("PROXYserver")->getValue();
|
|
$PROXYport = $this->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->getRender('viewflux.html.twig', [
|
|
'fluxs' => $fluxs,
|
|
'feeds' => $feeds,
|
|
'modelist' => $modelist,
|
|
]);
|
|
}
|
|
}
|
|
|
|
$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
|
|
try {
|
|
$result = $feedIo->read($url);
|
|
}
|
|
catch (\Exception $e) {
|
|
$result=null;
|
|
}
|
|
|
|
if($result) {
|
|
$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("¶","",$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" => $this->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->getRender('viewflux.html.twig', [
|
|
'fluxs' => $fluxs,
|
|
'feeds' => $feeds,
|
|
'modelist' => $modelist,
|
|
]);
|
|
}
|
|
|
|
public function viewbookmarkAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Valeur par défaut
|
|
$modedesktop=0;
|
|
$bookmarks=null;
|
|
|
|
// Datas associées au widget
|
|
if(!$this->mini) {
|
|
// Récupération des paramétres du widget
|
|
foreach($this->entity->getParameter()["fields"] as $parameter) {
|
|
switch($parameter["id"]) {
|
|
case "modedesktop":
|
|
$modedesktop=$parameter["value"];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Bookmark du widget
|
|
$bookmarks=$this->em->getRepository("CadolesPortalBundle:Bookmark")->findBy(["pagewidget"=>$this->entity]);
|
|
}
|
|
|
|
// Render
|
|
return $this->getRender('viewbookmark.html.twig', [
|
|
'canadd' => $this->canadd,
|
|
'modedesktop' => $modedesktop,
|
|
'bookmarks' => $bookmarks,
|
|
]);
|
|
}
|
|
|
|
public function viewlinkAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Récupération des paramétres du widget
|
|
$url="";
|
|
$target="_blank";
|
|
foreach($this->entity->getParameter()["fields"] as $parameter) {
|
|
switch($parameter["id"]) {
|
|
case "url":
|
|
$url=$parameter["value"];
|
|
break;
|
|
case "target":
|
|
$target=$parameter["value"];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Render
|
|
return $this->getRender('viewlink.html.twig', [
|
|
'canadd' => false,
|
|
'url' => $url,
|
|
'target' => $target,
|
|
]);
|
|
}
|
|
|
|
public function vieweditorAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Récupération des paramétres du widget
|
|
$html="";
|
|
foreach($this->entity->getParameter()["fields"] as $parameter) {
|
|
switch($parameter["id"]) {
|
|
case "html":
|
|
$html=$parameter["value"];
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
// Render
|
|
return $this->getRender('vieweditor.html.twig', [
|
|
'canadd' => false,
|
|
'html' => $html,
|
|
]);
|
|
}
|
|
|
|
public function viewslideAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Récupération des paramétres du widget
|
|
$interval="2";
|
|
foreach($this->entity->getParameter()["fields"] as $parameter) {
|
|
switch($parameter["id"]) {
|
|
case "interval":
|
|
$interval=$parameter["value"];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Récupération des slides
|
|
$slides=$this->em->getRepository("CadolesPortalBundle:Slide")->findBy(["pagewidget"=>$this->entity],['roworder'=>'ASC','title'=>'ASC']);
|
|
|
|
// Render
|
|
return $this->getRender('viewslide.html.twig', [
|
|
'canadd' => $this->canadd,
|
|
'slides' => $slides,
|
|
'interval' => $interval,
|
|
]);
|
|
}
|
|
|
|
public function viewfileAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Récupération des paramétres du widget
|
|
$view="small";
|
|
foreach($this->entity->getParameter()["fields"] as $parameter) {
|
|
switch($parameter["id"]) {
|
|
case "modelist":
|
|
$view=($parameter["value"]==0?"small":"list");
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Render
|
|
return $this->getRender('viewfile.html.twig', [
|
|
'canadd' => $this->canadd,
|
|
'directory' => "widget-".$id,
|
|
'view' => $view,
|
|
]);
|
|
}
|
|
|
|
public function viewgaleryAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
$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->getRender('viewgalery.html.twig', [
|
|
'canadd' => $this->canadd,
|
|
'files' => $files,
|
|
]);
|
|
}
|
|
|
|
public function viewcalendarAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Récupération des paramétres du widget
|
|
$nbday="0";
|
|
foreach($this->entity->getParameter()["fields"] as $parameter) {
|
|
switch($parameter["id"]) {
|
|
case "nbday":
|
|
$nbday=$parameter["value"];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Récupérer les events de l'utilisateur
|
|
$user=$this->getUser();
|
|
$events=$this->em->getRepository("CadolesPortalBundle:Calendarevent")->getUserCalendarevents($user,$this->get('session')->get('color')["main"],$this->usage,$this->group,$firstcalendar);
|
|
|
|
// Render
|
|
return $this->getRender('viewcalendar.html.twig', [
|
|
'canadd' => $this->canadd,
|
|
'events' => $events,
|
|
'nbday' => $nbday,
|
|
'firstcalendar' => $firstcalendar,
|
|
'usage' => $this->usage,
|
|
]);
|
|
}
|
|
|
|
public function viewblogAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Récupération des paramétres du widget
|
|
$nbarticle=10;
|
|
foreach($this->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($this->usage=="group") {
|
|
$blogs=$this->em->getRepository("CadolesPortalBundle:Blog")->getBlogsGroup($this->getUser(),$this->group);
|
|
if($blogs) $firstblog=$blogs[0]->getId();
|
|
}
|
|
else {
|
|
$this->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
|
|
$this->em->getRepository("CadolesPortalBundle:Blogarticle")->getBlogsArticles($blogs,0,$nbarticle,$count,$blogarticles);
|
|
|
|
|
|
// Render
|
|
return $this->getRender('viewblog.html.twig', [
|
|
'canadd' => $this->canadd,
|
|
'blogarticles' => $blogarticles,
|
|
'nbarticle' => $nbarticle,
|
|
'firstblog' => $firstblog,
|
|
'usage' => $this->usage,
|
|
]);
|
|
}
|
|
|
|
public function viewprojectAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Parametres
|
|
$nbarticle=10;
|
|
foreach($this->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($this->usage=="group") {
|
|
$projects=$this->em->getRepository("CadolesPortalBundle:Project")->getProjectsGroup($this->getUser(),$this->group);
|
|
if($projects) $firstproject=$projects[0]->getId();
|
|
}
|
|
else {
|
|
$this->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
|
|
$this->em->getRepository("CadolesPortalBundle:Projecttask")->getProjectsTasks($projects,0,$nbarticle,$count,$projecttasks);
|
|
|
|
foreach($projecttasks as $key => $projecttask) {
|
|
if($projecttask->getPercentage()==100) unset($projecttasks[$key]);
|
|
}
|
|
|
|
if($this->usage!="group") {
|
|
foreach($projecttasks as $key => $projecttask) {
|
|
if(!$user) unset($projecttasks[$key]);
|
|
else {
|
|
if($projecttask->getUser() && $projecttask->getUser()!=$user)
|
|
unset($projecttasks[$key]);
|
|
elseif(!$projecttask->getUser() && $projecttask->getOwner() && $projecttask->getOwner()!=$user)
|
|
unset($projecttasks[$key]);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// Render
|
|
return $this->getRender('viewproject.html.twig', [
|
|
'canadd' => $this->canupdate,
|
|
'projecttasks' => $projecttasks,
|
|
'nbarticle' => $nbarticle,
|
|
'firstproject' => $firstproject,
|
|
'usage' => $this->usage,
|
|
]);
|
|
}
|
|
|
|
public function viewseparatorAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Parametres
|
|
$seetitle=false;
|
|
$seeicon=false;
|
|
foreach($this->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->getRender('viewseparator.html.twig', [
|
|
'canadd' => $this->canupdate,
|
|
'seetitle' => $seetitle,
|
|
'seeicon' => $seeicon,
|
|
]);
|
|
}
|
|
|
|
public function viewclockAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Parametres
|
|
$clock="0";
|
|
foreach($this->entity->getParameter()["fields"] as $parameter) {
|
|
switch($parameter["id"]) {
|
|
case "clock":
|
|
$clock=$parameter["value"];
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Render
|
|
return $this->getRender('viewframe.html.twig', [
|
|
'canadd' => $this->canupdate,
|
|
'onheader' => true,
|
|
'tool' => ($clock==0?"cadoles_portal_user_tool_clockanalogique":"cadoles_portal_user_tool_clocknumerique"),
|
|
]);
|
|
}
|
|
|
|
public function viewcalculatorAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Render
|
|
return $this->getRender('viewframe.html.twig', [
|
|
'canadd' => $this->canupdate,
|
|
'onheader' => true,
|
|
'tool' => "cadoles_portal_user_tool_calculator",
|
|
]);
|
|
}
|
|
|
|
public function viewappexternalAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Récupération des paramétres du widget
|
|
$idappexternal=null;
|
|
foreach($this->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=$this->em->getRepository("CadolesPortalBundle:Appexternal")->findBy(["id"=>$idappexternal]);
|
|
else $appextenals=$this->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->getRender('viewappexternal.html.twig', [
|
|
'canadd' => ($user),
|
|
'modedesktop' => $modedesktop,
|
|
'items' => $items,
|
|
'itemcategorys' => $itemcategorys,
|
|
]);
|
|
}
|
|
|
|
public function viewinfoAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
$icon=null;
|
|
$title=null;
|
|
$description=null;
|
|
$members=[];
|
|
if($this->usage=="group") {
|
|
$groupentity=$this->em->getRepository("CadolesCoreBundle:Group")->find($this->group);
|
|
if($groupentity) {
|
|
$title=$this->entity->getPage()->getName();
|
|
$id=$groupentity->getId();
|
|
if($groupentity->getDescription())
|
|
$description="<strong>Description</strong><br>".$groupentity->getDescription();
|
|
if($groupentity->getIcon())
|
|
$icon="/".$groupentity->getIcon()->getLabel();
|
|
|
|
|
|
foreach($groupentity->getUsers() as $usergroup) {
|
|
array_push($members,$usergroup);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
$title=$this->entity->getPage()->getName();
|
|
$proprio=$this->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->getRender('viewinfo.html.twig', [
|
|
'canadd' => $this->canupdate,
|
|
'usage' => $this->usage,
|
|
'icon' => $icon,
|
|
'title' => $title,
|
|
'description' => $description,
|
|
'members' => $members,
|
|
'id' => $id,
|
|
'idpage' => $this->entity->getPage()->getId(),
|
|
]);
|
|
}
|
|
|
|
public function viewchatAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
$group=$this->group;
|
|
if($this->usage!="group"||!$group) {
|
|
$group=$this->em->getRepository("CadolesCoreBundle:Group")->findOneBy(["fgall"=>true])->getId();
|
|
}
|
|
|
|
// Render
|
|
return $this->getRender('viewchat.html.twig', [
|
|
'canadd' => $this->canupdate,
|
|
'onheader' => false,
|
|
'tool' => "cadoles_websocket_chat",
|
|
'usage' => $this->usage,
|
|
'group' => $group,
|
|
]);
|
|
}
|
|
|
|
|
|
public function viewgroupAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
$user=$this->getUser();
|
|
$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->getRender('viewgroup.html.twig', [
|
|
'canadd' => ($user),
|
|
'usage' => $this->usage,
|
|
'groups' => $mygroups,
|
|
]);
|
|
}
|
|
|
|
public function viewgroupmessageAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Récupération des paramétres du widget
|
|
$modelist=1;
|
|
$nbarticle=5;
|
|
foreach($this->entity->getParameter()["fields"] as $parameter) {
|
|
switch($parameter["id"]) {
|
|
case "modelist":
|
|
$modelist=$parameter["value"];
|
|
break;
|
|
case "nbarticle":
|
|
$nbarticle=$parameter["value"];
|
|
break;
|
|
}
|
|
}
|
|
|
|
$mymsg= [];
|
|
$user=$this->getUser();
|
|
$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->getRender('viewgroupmessage.html.twig', [
|
|
'canadd' => ($user),
|
|
'usage' => $this->usage,
|
|
'modelist' => $modelist,
|
|
'messages' => $mymsg,
|
|
'nbarticle' => $nbarticle,
|
|
]);
|
|
}
|
|
|
|
public function viewOnlydocAction(Request $request,$id,$access="config") {
|
|
// Récupération de la requete
|
|
$this->setRequest($request,$id,$access);
|
|
|
|
// Récupération des paramétres du widget
|
|
$apponly=0;
|
|
$view="small";
|
|
foreach($this->entity->getParameter()["fields"] as $parameter) {
|
|
switch($parameter["id"]) {
|
|
case "apponly":
|
|
$apponly=$parameter["value"];
|
|
break;
|
|
case "modelist":
|
|
$view=($parameter["value"]==0?"small":"list");
|
|
break;
|
|
}
|
|
}
|
|
|
|
return $this->getRender('viewonlydoc.html.twig', [
|
|
'canadd' => $this->canupdate,
|
|
'directory' => $id,
|
|
'view' => $view,
|
|
]);
|
|
}
|
|
}
|
|
|
|
|
|
|