Symfony Profiler

<?php
namespace App\Controller;
#-----------(Tables)ENTITY--------------
use App\Entity\Recrutements;
use App\Entity\Users;
use App\Entity\Partenaires;
use App\Entity\Mentions;
use App\Entity\Equipes;
use App\Entity\Actualites;
use App\Entity\Abouts;
use App\Entity\Valeurs;
use App\Entity\Contacts;
use App\Entity\Centres;
use App\Entity\Galeries;
use App\Entity\Villes;
use App\Entity\Referenceclients;
use App\Entity\Bannieres;
use App\Entity\Thematiques;
use App\Entity\Managements;
use App\Entity\Avis;
use App\Entity\Themes;
use App\Entity\Formations;
use App\Entity\Albums;
use App\Entity\Videos;
#-----------(Formulaires)FORMS--------------
use App\Form\FormationFormType;
use App\Form\ThemeFormType;
use App\Form\EditThemeFormType;
use App\Form\VideoFormType;
use App\Form\AlbumFormType;
use App\Form\GalerieFormType;
use App\Form\ManagementFormType;
use App\Form\ActualiteFormType;
use App\Form\ReferenceclientFormType;
use App\Form\PartenaireFormType;
use App\Form\ContactFormType;
use App\Form\UserFormType;
use App\Form\CentreFormType;
use App\Form\AboutFormType;
use App\Form\ValeurFormType;
use App\Form\BanniereFormType;
use App\Form\EquipeFormType;
use App\Form\VilleFormType;
use App\Form\ThematiqueFormType;
use App\Form\MentionFormType;
use App\Form\AvisFormType;
use App\Form\EditFormationFormType;
use App\Form\EditAvisFormType;
use App\Form\EditMentionFormType;
use App\Form\EditEquipeFormType;
use App\Form\EditPartenaireFormType;
use App\Form\EditReferenceclientFormType;
use App\Form\EditProfilFormType;
use App\Form\EditPassFormType;
use App\Form\EditAboutFormType;
use App\Form\EditValeurFormType;
use App\Form\EditActualiteFormType;
use App\Form\EditUserFormType;
use App\Form\EditCentreFormType;
use App\Form\EditRecrutementFormType;
use App\Form\EditContactFormType;
use App\Form\EditBanniereFormType;
use App\Form\EditVilleFormType;
use App\Form\EditThematiqueFormType;
use App\Form\EditManagementFormType;
#-----------REPOSITORY--------------
use App\Repository\FormationsRepository;
use App\Repository\ThemesRepository;
use App\Repository\ManagementsRepository;
use App\Repository\MentionsRepository;
use App\Repository\ThematiquesRepository;
use App\Repository\BannieresRepository;
use App\Repository\VillesRepository;
use App\Repository\BlogsRepository;
use App\Repository\ReferenceclientsRepository;
use App\Repository\CentresRepository;
use App\Repository\GaleriesRepository;
use App\Repository\EquipesRepository;
use App\Repository\ValeursRepository;
use App\Repository\AboutsRepository;
use App\Repository\ActualitesRepository;
use App\Repository\PartenairesRepository;
use App\Repository\RecrutementsRepository;
use App\Repository\UsersRepository;
use App\Repository\ContactsRepository;
use App\Repository\AvisRepository;
use App\Repository\AlbumsRepository;
use App\Repository\VideosRepository;
#-------------------------------
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\String\Slugger\SluggerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\File\Exception\FileException;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
use App\Entity\Certificats;
use App\Form\CertificatFormType;
use App\Form\EditCertificatFormType;
use App\Repository\CertificatsRepository;
use App\Entity\Expertises;
use App\Form\ExpertiseFormType;
use App\Form\EditExpertiseFormType;
use App\Repository\ExpertisesRepository;
use App\Entity\Certyous;
use App\Form\CertyouFormType;
use App\Form\EditCertyouFormType;
use App\Repository\CertyousRepository;
use App\Entity\Sessions;
use App\Form\SessionFormType;
use App\Form\EditSessionFormType;
use App\Repository\SessionsRepository;
class AdminController extends AbstractController
{
#[Route('admin/tableau-de-bord', name: 'admin.dashboard')]
public function dashboard(): Response
{
return $this->render('admin/admin-index.html.twig', [
'controller_name' => 'AdminController',
]);
}
public function retour(Request $request)
{
$referer = $request->headers->get('referer');
return $this->redirect($referer ?? $this->generateUrl('admin.dashboard'));
}
#[Route('admin/del/certificats/personnalises/{id}', name: 'admin.del.certificat.certyou', methods:['GET'])]
public function delete_certyou(
$id,
CertyousRepository $certyousRepository,
EntityManagerInterface $entityManager
){
$select_certyou = $certyousRepository->find($id);
if (!$select_certyou) {
$this->addFlash('warning', 'Certificat introuvable');
}
$entityManager->remove($select_certyou);
$entityManager->flush();
$this->addFlash(
'danger',
'Ce certificat bien supprimé');
return $this->redirectToRoute('admin.certificat.certyou');
}
#[Route('admin/del/certificats/personnalises/date/{id}', name: 'admin.del.certificat.certyou.date', methods:['GET'])]
public function delete_certyou_date(
$id,
SessionsRepository $sessionRepository,
EntityManagerInterface $entityManager
){
$session = $sessionRepository->find($id);
if (!$session) {
$this->addFlash('warning', 'Session introuvable');
}
$entityManager->remove($session);
$entityManager->flush();
$this->addFlash(
'danger',
'Cette date a été bien supprimée');
return $this->redirectToRoute('admin.edit.certificat.certyou',['id' => $id]);
}
#[Route('admin/edit/certificats/personnalises/{id}', name: 'admin.edit.certificat.certyou', methods:['GET','POST'])]
public function edit_certificat_certyou(
$id,
Request $request,
SluggerInterface $slugger,
VillesRepository $villeRepository,
SessionsRepository $sessionRepository,
CertyousRepository $certyousRepository,
EntityManagerInterface $entityManager
): Response
{
$user = $this->getUser();
$editcertyou = $certyousRepository->findOneBy(array('id' => $id));
//dd($editcertyou);
$type = $editcertyou->getType();
//dd($type);
$queryBuilder = $entityManager->createQueryBuilder();
$queryBuilder
->select('ses')
->from(Sessions::class, 'ses')
->where('ses.certyou = :id')
->setParameter('id', $id);
$dates = $queryBuilder->getQuery()->getResult();
if($user){
$certyou = new Certyous();
$editcertyouForm = $this->createForm(EditCertyouFormType::class, $editcertyou);
$editcertyouForm->handleRequest($request);
if ($editcertyouForm->isSubmitted()) {
$userId = $user->getId();
$theme = $editcertyouForm->get('theme')->getData();
$slug = $slugger->slug($theme)->lower()->toString();
$type = $editcertyouForm->get('type')->getData();
$prixpresentiel = $editcertyouForm->get('prixpresentiel')->getData();
$prixvituelle = $editcertyouForm->get('prixvirtuelle')->getData();
$devise = $editcertyouForm->get('devise')->getData();
$editcertyou->setTheme($theme);
$editcertyou->setSlug($slug);
$editcertyou->setType($type);
$editcertyou->setAdminsId($userId);
$entityManager->flush();
$this->addFlash('success','La modification a été bien effectuée');
return $this->redirectToRoute('admin.certificat.certyou');
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/edit/edit-admin-certyou.html.twig', [
'dates' => $dates,
'type' => $type,
'editcertyou' => $editcertyou,
'editcertyouForm' => $editcertyouForm->createView(),
]);
}
//------------------------------------------------------------------------------------------------------
#[Route('admin/certificats/personnalises/{id}/sessions', name: 'admin.certificat.certyou.session', methods:['POST'])]
public function certificat_certyou_session(
int $id,
Request $request,
CertyousRepository $certyousRepository,
EntityManagerInterface $entityManager
): Response
{
$user = $this->getUser();
$userId = $user->getId();
$certyou = $certyousRepository->find($id);
if (!$certyou) {
throw $this->createNotFoundException('Certificat introuvable');
}
$session = new Sessions();
$session->setCertyou($certyou);
$form = $this->createForm(SessionFormType::class, $session);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$session->setAdminsId($userId);
$entityManager->persist($session);
$entityManager->flush();
$this->addFlash('success', 'Session ajoutée avec succès');
return $this->redirectToRoute('admin.certificat.certyou');
}
return $this->render('admin/show/admin-certyou.html.twig', [
'certyou' => $certyou,
'addcertyouForm' => $form->createView(),
]);
}
//-------------------------------------------------------------------------------------------------
#[Route('admin/certificats/personnalises', name: 'admin.certificat.certyou', methods:['GET','POST'])]
public function certificat_certyou(
Request $request,
SluggerInterface $slugger,
CertyousRepository $certyousRepository,
EntityManagerInterface $entityManager
): Response
{
$certyou = new Certyous();
$addcertyouForm = $this->createForm(CertyouFormType::class, $certyou);
$addcertyouForm->handleRequest($request);
$queryBuilder = $entityManager->createQueryBuilder();
$queryBuilder
->select(
'cert.id','cert.prixpresentiel','cert.prixvirtuelle',
'cert.devise','cert.theme','cert.duree','cert.slug',
'cert.type','cert.createdat'
)
->from(Certyous::class, 'cert');
$certyous = $queryBuilder->getQuery()->getResult();
$date = [];
if (!empty($certyous)) {
$queryBuilder = $entityManager->createQueryBuilder();
$queryBuilder
->select(
'cert.id AS cert_id',
'ses.session'
)
->from(Sessions::class, 'ses')
->innerJoin(Certyous::class, 'cert', 'WITH', 'ses.certyou = cert.id')
->orderBy('ses.createdat', 'DESC');
$sessions = $queryBuilder->getQuery()->getResult();
foreach ($sessions as $row) {
$date[$row['cert_id']][] = $row['session'];
}
}
$sessionForms = [];
foreach ($certyous as $cert) {
$session = new Sessions();
$form = $this->createForm(SessionFormType::class, $session, [
'action' => $this->generateUrl('admin.certificat.certyou.session', [
'id' => $cert['id']
])
]);
$sessionForms[$cert['id']] = $form->createView();
}
if ($addcertyouForm->isSubmitted() && $addcertyouForm->isValid()) {
$user = $this->getUser();
if ($user) {
$theme = $addcertyouForm->get('theme')->getData();
$slug = $slugger->slug($theme)->lower();
$type = $addcertyouForm->get('type')->getData();
$certyou->setTheme($theme);
$certyou->setSlug($slug);
$certyou->setType($type);
$certyou->setAdminsId($user->getId());
$entityManager->persist($certyou);
$entityManager->flush();
$this->addFlash('success', 'Certificat ajouté avec succès');
return $this->redirectToRoute('admin.certificat.certyou');
}
}
return $this->render('admin/show/admin-certyou.html.twig', [
'certyou' => $certyous,
'date' => $date,
'sessionForms' => $sessionForms,
'addcertyouForm' => $addcertyouForm->createView(),
]);
}
/*
#[Route('admin/certificats/certyou', name: 'admin.certificat.certyou', methods:['GET','POST'])]
public function certificat_certyou(
Request $request,
SluggerInterface $slugger,
CertyousRepository $certyousRepository,
EntityManagerInterface $entityManager
): Response
{
$certyou = new Certyous();
$addcertyouForm = $this->createForm(CertyouFormType::class,$certyou);
$addcertyouForm->handleRequest($request);
$session = new Sessions();
$addsessionForm = $this->createForm(SessionFormType::class, $session);
$addsessionForm->handleRequest($request);
$queryBuilder = $entityManager->createQueryBuilder();
$queryBuilder
->select(
'cert.id','cert.prixpresentiel','cert.prixvirtuelle','cert.slug',
'cert.devise','cert.theme','cert.duree','vil.nom AS vilnom',
'vil.pays','cert.createdat'
)
->from(Certyous::class, 'cert')
->leftJoin(Villes::class, 'vil', 'WITH', 'cert.ville = vil.id');
//->leftJoin(Sessions::class, 'ses', 'WITH', 'cert.id = ses.certyou');
$certyous = $queryBuilder->getQuery()->getResult();
if($certyous != null){
$queryBuilder = $entityManager->createQueryBuilder();
$queryBuilder
->select(
'cert.id','cert.prixpresentiel','cert.prixvirtuelle','cert.slug',
'cert.devise','cert.theme','cert.duree','vil.nom AS vilnom',
'vil.pays','cert.createdat','ses.session'
)
->from(Certyous::class, 'cert')
->leftJoin(Villes::class, 'vil', 'WITH', 'cert.ville = vil.id')
->leftJoin(Sessions::class, 'ses', 'WITH', 'cert.id = ses.certyou')
->orderBy('ses.createdat', 'DESC');
$date = $queryBuilder->getQuery()->getResult();
}
$user = $this->getUser();
if ($addcertyouForm->isSubmitted()) {
if ($user) {
$userId = $user->getId();
$theme = $addcertyouForm->get('theme')->getData();
$slug = $slugger->slug($theme)->lower()->toString();
$ville = $addcertyouForm->get('ville')->getData();
$prixpresentiel = $addcertyouForm->get('prixpresentiel')->getData();
$prixvituelle = $addcertyouForm->get('prixvirtuelle')->getData();
$devise = $addcertyouForm->get('devise')->getData();
$certyou = $addcertyouForm->getData();
if($ville){
$certyou->setVille($ville);
}else{
$certyou->setVille(null);
}
$certyou->setTheme($theme);
$certyou->setSlug($slug);
$certyou->setPrixvirtuelle($prixvituelle);
$certyou->setPrixpresentiel($prixpresentiel);
$certyou->setDevise($devise);
$certyou->setAdminsId($userId);
$entityManager->persist($certyou);
$entityManager->flush();
$this->addFlash(
'success',
'Ce certificat a été bien enrégistré');
return $this->redirectToRoute('admin.certificat.certyou');
} else {
$this->addFlash('danger', 'Erreur survenue lors de l\'enregistrement de l\'information');
}
}
return $this->render('admin/show/admin-certyou.html.twig', [
'certyou' => $certyous,
'date' => $date,
'addsessionForm' => $addsessionForm->createView(),
'addcertyouForm' => $addcertyouForm->createView(),
]);
}
*/
//-------------------------------------------------------------------------------------------
#[Route('admin/certificats/internationaux', name: 'admin.certificat', methods:['GET','POST'])]
public function certificat(
Request $request,
SluggerInterface $slugger,
CertificatsRepository $certificatRepository,
EntityManagerInterface $entityManager
): Response
{
$certificat = new Certificats();
$addcertificatForm = $this->createForm(CertificatFormType::class,$certificat);
$addcertificatForm->handleRequest($request);
//$certificats = $certificatRepository->findAll();
$queryBuilder = $entityManager->createQueryBuilder();
$queryBuilder
->select(
'cert.id','cert.session','cert.prix','cert.slug',
'cert.devise','cert.theme','vil.nom AS vilnom',
'vil.pays','cert.createdat','cert.type'
)
->from(Certificats::class, 'cert')
->innerJoin(Villes::class, 'vil', 'WITH', 'cert.ville = vil.id');
$certificats = $queryBuilder->getQuery()->getResult();
$user = $this->getUser();
if ($addcertificatForm->isSubmitted()) {
if ($user) {
$userId = $user->getId();
$theme = $addcertificatForm->get('theme')->getData();
$slug = $slugger->slug($theme);
$ville = $addcertificatForm->get('ville')->getData();
$session = $addcertificatForm->get('session')->getData();
$type = $addcertificatForm->get('type')->getData();
$prix = $addcertificatForm->get('prix')->getData();
$devise = $addcertificatForm->get('devise')->getData();
$certificat = $addcertificatForm->getData();
$idVille = $ville->getId();
$verify = $certificatRepository->findOneBy(array(
'theme' => $theme,
'slug' => $slug,
'ville' => $idVille,
'session' => $session,
'type' => $type,
'prix' => $session,
'devise' => $type,
));
if($verify){
$this->addFlash('danger', 'Ce certificat a déjà été enrégistré');
return $this->redirectToRoute('admin.certificat');
}
$certificat->setTheme($theme);
$certificat->setSlug($slug);
$certificat->setVille($ville);
$certificat->setSession($session);
$certificat->setType($type);
$certificat->setPrix($prix);
$certificat->setDevise($devise);
$certificat->setAdminsId($userId);
$entityManager->persist($certificat);
$entityManager->flush();
$this->addFlash(
'success',
'Ce certificat a été bien enrégistré');
return $this->redirectToRoute('admin.certificat');
} else {
$this->addFlash('danger', 'Erreur survenue lors de l\'enregistrement de l\'information');
}
}
return $this->render('admin/show/admin-certificat.html.twig', [
'certificat' => $certificats,
'addcertificatForm' => $addcertificatForm->createView(),
]);
}
#-----------------SUPPERIMER UN CERTIFICAT-----------------------
#[Route('admin/del/certificats/internationaux/{id}', name: 'admin.del.certificat', methods:['GET'])]
public function delete_certificat(
$id,
CertificatsRepository $certificatsRepository,
EntityManagerInterface $entityManager
){
$select_certificat = $certificatsRepository->find(array('id' => $id));
$entityManager->remove($select_certificat);
$entityManager->flush();
$this->addFlash(
'danger',
'Ce certificat bien supprimé');
return $this->redirectToRoute('admin.certificat');
}
#[Route('admin/edit/certificats/internationaux/{id}', name: 'admin.edit.certificat', methods:['GET','POST'])]
public function edit_certificat(
$id,
Request $request,
SluggerInterface $slugger,
VillesRepository $villeRepository,
CertificatsRepository $certificatRepository,
EntityManagerInterface $entityManager
): Response
{
$user = $this->getUser();
$certificats = $certificatRepository->findOneBy(array('id' => $id));
$idVille = $certificats->getVille();
$getville = $villeRepository->findOneBy(array('id' => $idVille));
$nomVille = $getville->getNom();
//dd($nomVille);
if($user){
$certificat = new Certificats();
$editcertificatForm = $this->createForm(EditCertificatFormType::class, $certificat);
$editcertificatForm->handleRequest($request);
if ($editcertificatForm->isSubmitted()) {
$userId = $user->getId();
$theme = $editcertificatForm->get('theme')->getData();
$slug = $slugger->slug($theme);
$ville = $editcertificatForm->get('ville')->getData();
$session = $editcertificatForm->get('session')->getData();
$type = $editcertificatForm->get('type')->getData();
$prix = $editcertificatForm->get('prix')->getData();
$devise = $editcertificatForm->get('devise')->getData();
$idVille = $ville->getId();
//dd($idVille);
$verify = $certificatRepository->findOneBy(array(
'theme' => $theme,
'slug' => $slug,
'ville' => $idVille,
'session' => $session,
'type' => $type,
'prix' => $session,
'devise' => $type,
));
$certificats->setTheme($theme);
$certificats->setSlug($slug);
$certificats->setVille($ville);
$certificats->setSession($session);
$certificats->setType($type);
$certificats->setPrix($prix);
$certificats->setDevise($devise);
$certificats->setAdminsId($userId);
$entityManager->flush();
$this->addFlash('success','La modification a été bien effectuée');
return $this->redirectToRoute('admin.certificat');
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/edit/edit-admin-certificat.html.twig', [
'nomVille' => $nomVille,
'certificats' => $certificats,
'editcertificatForm' => $editcertificatForm->createView(),
]);
}
//----------------------------------------------------------------------------------------------
#[Route('admin/notre-expertises', name: 'admin.expertise', methods:['GET','POST'])]
public function expertise(
Request $request,
SluggerInterface $slugger,
ExpertisesRepository $expertiseRepository,
EntityManagerInterface $entityManager
): Response
{
$expertise = new Expertises();
$Data_expert = $expertiseRepository->findAll();
$user = $this->getUser();
$userId = $user->getId();
$expertiseForm = $this->createForm(ExpertiseFormType::class, $expertise);
$editexpertiseForm = $this->createForm(EditExpertiseFormType::class, $expertise);
if ($user) {
if($Data_expert == null){
$expertiseForm = $this->createForm(ExpertiseFormType::class, $expertise);
$expertiseForm->handleRequest($request);
if($expertiseForm->isSubmitted() && $expertiseForm->isValid()){
$userId = $user->getId();
$statut = $expertiseForm->get('statut')->getData();
$texte = $expertiseForm->get('texte')->getData();
$expertise->setTexte($texte);
$expertise->setAdminsId($userId);
$expertise->setStatut($statut);
$entityManager->persist($expertise);
$entityManager->flush();
$this->addFlash('success','Notre expertise a été bien enrégistrée');
}
}else{
$editexpertiseForm = $this->createForm(EditExpertiseFormType::class, $expertise);
$editexpertiseForm->handleRequest($request);
$data = $editexpertiseForm->getData();
if ($editexpertiseForm->isSubmitted() && $editexpertiseForm->isValid()) {
$userId = $user->getId();
$data = $expertiseRepository->find(1);
$statut = $editexpertiseForm->get('statut')->getData();
$texte = $editexpertiseForm->get('texte')->getData();
$data->setTexte($texte);
$data->setAdminsId($userId);
$data->setStatut($statut);
$entityManager->flush();
$this->addFlash('success','Notre expertise a été bien modifiée');
}
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/show/admin-expertise.html.twig', [
'Databout' => $Data_expert,
'aboutForm' => $expertiseForm->createView(),
'editaboutForm' => $editexpertiseForm->createView(),
]);
}
//---------------------------------------------------------------------------------------------
#[Route('admin/video', name: 'admin.video', methods:['GET','POST'])]
public function video(
Request $request,
SluggerInterface $slugger,
VideosRepository $videoRepository,
EntityManagerInterface $entityManager
): Response
{
$video = new Videos();
$listvideo = $videoRepository->findAll();
$user = $this->getUser();
$videoForm = $this->createForm(VideoFormType::class, $listvideo);
$videoForm->handleRequest($request);
if($user){
$userId = $user->getId();
//dd($userId);
if($videoForm->isSubmitted()){
$titre = $videoForm->get('titre')->getData();
$lien = $videoForm->get('lien')->getData();
$statut = $videoForm->get('statut')->getData();
//$album = $albumForm->getData();
$video->setTitre($titre);
$video->setLien($lien);
$video->setStatut($statut);
$video->setAdminsId($userId);
$entityManager->persist($video);
$entityManager->flush();
$this->addFlash('success','La vidéo a été bien enrégistrée');
return $this->redirectToRoute('admin.album');
}
}
return $this->render('admin/show/admin-video.html.twig', [
'listvideo' => $listvideo,
'videoForm' => $videoForm->createView(),
'controller_name' => 'AdminController',
]);
}
#-----------------SUPPERIMER UN GALERIE-----------------------
#[Route('admin/del/video/{id}', name: 'admin.del.video', methods:['GET'])]
public function delete_video(
// $slug,
$id,
VideosRepository $videosRepository,
EntityManagerInterface $entityManager
){
$select_video = $videosRepository->findOneBy(['id' => $id]);
if(!$select_video) {
throw $this->createNotFoundException('Vidéo introuvable');
}
$entityManager->remove($select_video);
$entityManager->flush();
$this->addFlash(
'danger',
'La vidéos a été bien supprimée avec succès');
return $this->redirectToRoute('admin.video');
}
#[Route('admin/album', name: 'admin.album', methods:['GET','POST'])]
public function album(
Request $request,
SluggerInterface $slugger,
AlbumsRepository $albumRepository,
EntityManagerInterface $entityManager
): Response
{
$album = new Albums();
$Datalbum = $albumRepository->findAll();
$user = $this->getUser();
$albumForm = $this->createForm(AlbumFormType::class, $album);
$albumForm->handleRequest($request);
if($user){
$userId = $user->getId();
//dd($userId);
if($albumForm->isSubmitted()){
$nom = $albumForm->get('nom')->getData();
$slug = $slugger->slug($nom);
$statut = $albumForm->get('statut')->getData();
$img_gal = $albumForm->get('image')->getData();
//$album = $albumForm->getData();
if ($img_gal) {
foreach ($img_gal as $img) {
$newFilename = uniqid().'.'.$img->guessExtension();
$img->move(
$this->getParameter('photo_galerie'),
$newFilename
);
// Exemple : si tu as une entité Galerie
$galerie = new Galeries();
$galerie->setImage($newFilename);
$galerie->setNom($slug);
$entityManager->persist($galerie);
}
}
$album->setNom($nom);
$album->setSlug($slug);
$album->setStatut($statut);
$album->setAdminsId($userId);
$entityManager->persist($album);
$entityManager->flush();
return $this->redirectToRoute('admin.album');
}
}
return $this->render('admin/show/admin-album.html.twig', [
'albums' => $Datalbum,
'albumForm' => $albumForm->createView(),
'controller_name' => 'AdminController',
]);
}
#[Route('admin/galeries/{slug}', name: 'admin.galerie', methods:['GET','POST'])]
public function GaleriesImg(
string $slug,
Request $request,
GaleriesRepository $galerieRepository,
AlbumsRepository $albumRepository,
EntityManagerInterface $entityManager
): Response
{
$user = $this->getUser();
// 🔹 Récupération d'une SEULE galerie
$galerie = $galerieRepository->findBy(['nom' => $slug]);
$Datalbum = $albumRepository->findOneBy(['nom' => $slug]);
//dd($galerie);
// 🔹 Formulaire lié à l'entité
$galerieForm = $this->createForm(GalerieFormType::class, $galerie);
$galerieForm->handleRequest($request);
if ($user && $galerieForm->isSubmitted()) {
$img_gal = $galerieForm->get('image')->getData();
//dd($img_gal);
if ($img_gal) {
// dd($img_gal);
foreach ($img_gal as $img) {
$newFilename = uniqid().'.'.$img->guessExtension();
$img->move(
$this->getParameter('photo_galerie'),
$newFilename
);
// 🔹 Mise à jour de l'entité EXISTANTE
//$galerie = New Galeries();
$galerie = new Galeries();
$galerie->setImage($newFilename);
$galerie->setNom($slug);
$entityManager->persist($galerie);
}
}
// 🔹 Enregistrement réel en base
$entityManager->flush();
$this->addFlash(
'success',
'Album a été bien enrégistré');
return $this->redirectToRoute('admin.galerie', ['slug' => $slug]);
}
return $this->render('admin/show/admin-galerie.html.twig', [
'slug' => $slug,
'galeries' => $galerie,
'galerieForm' => $galerieForm->createView(),
]);
}
#-----------------SUPPERIMER UN GALERIE-----------------------
#[Route('admin/del/galerie/{id}', name: 'admin.del.galerie', methods:['GET'])]
public function delete_gal(
// $slug,
$id,
GaleriesRepository $galeriesRepository,
EntityManagerInterface $entityManager
){
$select_gal = $galeriesRepository->findOneBy(['id' => $id]);
if(!$select_gal) {
throw $this->createNotFoundException('Galerie introuvable');
}
$slug = $select_gal->getCentre();
$entityManager->remove($select_gal);
$entityManager->flush();
$this->addFlash(
'danger',
'L\'image a été bien supprimée de la galerie');
return $this->redirectToRoute('admin.galerie',['slug' => $slug]);
}
#-----------------SUPPERIMER UN GALERIE-----------------------
#[Route('admin/del/album/{slug}', name: 'admin.del.album', methods:['GET'])]
public function delete_album(
$slug,
GaleriesRepository $galeriesRepository,
AlbumsRepository $albumRepository,
EntityManagerInterface $entityManager
) {
// 🔹 Récupération de l'album
$select_album = $albumRepository->findOneBy(['slug' => $slug]);
/*
$gal = $galeriesRepository->findOneBy(['nom' => $slug]);
if($gal){
}
$entityManager->remove($select_album);
$entityManager->flush();
$this->addFlash('danger', 'L\'album a été bien supprimé');
return $this->redirectToRoute('admin.album');*/
//dd($select_album);
if (!$select_album) {
$this->addFlash('danger', 'Album introuvable');
return $this->redirectToRoute('admin.album');
}
$gal = $galeriesRepository->findOneBy(['nom' => $slug]);
if($gal){
// 🔹 Récupération de la galerie liée à l'album
$select_gal = $select_album->getNom();
if (!$select_gal) {
$this->addFlash('danger', 'Galerie introuvable pour cet album');
return $this->redirectToRoute('admin.album');
}
// 🔹 Suppression
$entityManager->remove($select_album);
$entityManager->flush();
//$this->addFlash('danger', 'Les images a été bien supprimée de la galerie');
return $this->redirectToRoute('admin.album');
}else{
$entityManager->remove($select_album);
$entityManager->flush();
$this->addFlash('danger', 'L\'album a été bien supprimé');
return $this->redirectToRoute('admin.album');
}
}
#[Route('admin/galerie-centres/{slug}', name: 'admin.galerie.centres', methods:['GET','POST'])]
public function galeries(
$slug,
Request $request,
SluggerInterface $slugger,
GaleriesRepository $galRepository,
EntityManagerInterface $entityManager
): Response
{
$user = $this->getUser();
if (!$user) {
return $this->redirectToRoute('login.connexion');
}
$queryBuilder = $entityManager->createQueryBuilder();
$queryBuilder
->select('gal.id', 'gal.imgal', 'gal.nom')
->from(Galeries::class, 'gal')
->where('gal.nom = :nom')
->setParameter('nom', $slug);
$galeries = $queryBuilder->getQuery()->getResult();
return $this->render('admin/show/admin-galerie.html.twig', [
'slug' => $slug,
'galeries' => $galeries
]);
}
#-----------------SUPPERIMER UN GALERIE-----------------------
#[Route('admin/del/galerie-centres/{nom}/{id}', name: 'admin.del.galerie', methods:['GET'])]
public function delete_galerie(
$nom,
$id,
GaleriesRepository $GA,
EntityManagerInterface $entityManager
){
$slug = $nom;
$select_galerie = $GA->findOneBy(array('id' => $id));
$entityManager->remove($select_galerie);
$entityManager->flush();
$this->addFlash(
'danger',
'Image bien supprimée de la galerie');
return $this->redirectToRoute('admin.galerie',['slug' => $slug]);
}
//-MENTION ---------------------------------------------------------------------------------------------
#[Route('admin/mentions', name: 'admin.mention', methods:['GET','POST'])]
public function mention(
Request $request,
SluggerInterface $slugger,
MentionsRepository $mentionRepository,
EntityManagerInterface $entityManager
): Response
{
$mention = new Mentions();
$mentions = $mentionRepository->findAll();
// dd($presentations);
$addmentionForm = $this->createForm(MentionFormType::class,$mention);
$addmentionForm->handleRequest($request);
$user = $this->getUser();
if ($addmentionForm->isSubmitted() && $addmentionForm->isValid()) {
if ($user) {
$userId = $user->getId();
$titre = $addmentionForm->get('titremen')->getData();
$slug = $slugger->slug($titre);
$texte = $addmentionForm->get('detailmen')->getData();
$statut = $addmentionForm->get('statutmen')->getData();
$mention = $addmentionForm->getData();
$verify = $mentionRepository->findOneBy(array(
'slug' => $slug
));
if($verify){
$this->addFlash('danger', 'Ce titre é déjà été enrégistré');
return $this->redirectToRoute('admin.mention');
}
if(empty($texte)){
$mention->setDetailMen('...');
}else{
$mention->setDetailMen($texte);
}
$mention->setTitreMen($titre);
$mention->setSlug($slug);
$mention->setStatutMen($statut);
$mention->setAdminsId($userId);
$entityManager->persist($mention);
$entityManager->flush();
$this->addFlash(
'success',
'Le sous menu a été bien enrégistré');
return $this->redirectToRoute('admin.mention');
} else {
$this->addFlash('danger', 'Erreur survenue lors de l\'enregistrement de l\'information');
}
}
return $this->render('admin/show/admin-mention.html.twig', [
'mentions' => $mentions,
'addmentionForm' => $addmentionForm->createView(),
]);
}
//-EDITER MENTION ---------------------------------------------------------------------------------------------
#[Route('admin/mention/{slug}', name: 'admin.edit.mention', methods:['GET','POST'])]
public function edit_mention(
$slug,
Request $request,
SluggerInterface $slugger,
MentionsRepository $mentionRepository,
EntityManagerInterface $entityManager
): Response
{
$user = $this->getUser();
$infomention = $mentionRepository->findOneBy(array(
'slug' => $slug
));
if($user){
$mention = new Mentions();
$editmentionForm = $this->createForm(EditMentionFormType::class, $mention);
$editmentionForm->handleRequest($request);
if ($editmentionForm->isSubmitted()) {
$userId = $user->getId();
$titre = $editmentionForm->get('titremen')->getData();
$slug = $slugger->slug($titre);
$detail = $editmentionForm->get('detailmen')->getData();
$statut = $editmentionForm->get('statutmen')->getData();
$entreprise = $editmentionForm->getData();
if(empty($detail)){
$infomention->setDetailMen('...');
}else{
$infomention->setDetailMen($detail);
}
$infomention->setTitreMen($titre);
$infomention->setSlug($slug);
$infomention->setDetailMen($detail);
$infomention->setStatutMen($statut);
$infomention->setAdminsId($userId);
$entityManager->flush();
$this->addFlash('success','La modification a été bien effectuée');
return $this->redirectToRoute('admin.mention');
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/edit/edit-admin-mention.html.twig', [
'infomention' => $infomention,
'editmentionForm' => $editmentionForm->createView(),
]);
}
#[Route('admin/del/mention/{slug}', name: 'admin.del.mention', methods:['GET'])]
public function delete_mention(
$slug,
MentionsRepository $MEN,
EntityManagerInterface $entityManager
){
$select_mention = $MEN->findOneBy(array('slug' => $slug));
$entityManager->remove($select_mention);
$entityManager->flush();
$this->addFlash(
'danger',
'L\'information a été bien supprimée');
return $this->redirectToRoute('admin.mention');
}
//----------------------------------------------------------------------------------------------
#[Route('admin/presentation/qui-sommes-nous', name: 'admin.qui-sommes-nous', methods:['GET','POST'])]
public function about(
Request $request,
SluggerInterface $slugger,
AboutsRepository $aboutRepository,
EntityManagerInterface $entityManager
): Response
{
$about = new Abouts();
$Databout = $aboutRepository->findAll();
$user = $this->getUser();
$aboutForm = $this->createForm(AboutFormType::class, $about);
$editaboutForm = $this->createForm(EditAboutFormType::class, $about);
if ($user) {
if($Databout == null){
$aboutForm = $this->createForm(AboutFormType::class, $about);
$aboutForm->handleRequest($request);
if($aboutForm->isSubmitted() && $aboutForm->isValid()){
$userId = $user->getId();
$texte = $aboutForm->get('texte')->getData();
$imageFile = $aboutForm->get('image')->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_apropos'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$about->setImage($newFilename);
}else{
$about->setImage("no-file");
}
$about->setTexte($texte);
$about->setAdminsId($userId);
$entityManager->persist($about);
$entityManager->flush();
$this->addFlash('success','Le texte de présentation a été bien enrégistré');
}
}else{
$editaboutForm = $this->createForm(EditAboutFormType::class, $about);
$editaboutForm->handleRequest($request);
$data = $editaboutForm->getData();
if ($editaboutForm->isSubmitted() && $editaboutForm->isValid()) {
//dd($editaboutForm);
$userId = $user->getId();
$data = $aboutRepository->find(1);
$imageFile = $editaboutForm->get('image')->getData();
// dd($imageFile);
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_apropos'),
$newFilename
);
} catch (FileException $e) {}
$data->setImage($newFilename);
}
$data->setTexte($editaboutForm->get('texte')->getData());
$entityManager->flush();
$this->addFlash('success','Le texte de présentation a été bien modifié');
}
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/show/admin-qui-sommes-nous.html.twig', [
'Databout' => $Databout,
'aboutForm' => $aboutForm->createView(),
'editaboutForm' => $editaboutForm->createView(),
]);
}
#[Route('admin/presentation/nos-valeurs', name: 'admin.valeur', methods:['GET','POST'])]
public function valeur(
Request $request,
SluggerInterface $slugger,
ValeursRepository $valeurRepository,
EntityManagerInterface $entityManager
): Response
{
$valeur = new Valeurs();
$Datavaleur = $valeurRepository->findAll();
$user = $this->getUser();
$valeurForm = $this->createForm(ValeurFormType::class, $valeur);
$editvaleurForm = $this->createForm(ValeurFormType::class, $valeur);
if ($user) {
if($Datavaleur == null){
$valeurForm = $this->createForm(ValeurFormType::class, $valeur);
$valeurForm->handleRequest($request);
if($valeurForm->isSubmitted() && $valeurForm->isValid()){
$userId = $user->getId();
$texte = $valeurForm->get('texte')->getData();
$imageFile = $valeurForm->get('image')->getData();
$valeur->setTexte($texte);
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_valeur'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$valeur->setImage($newFilename);
}else{
$valeur->setImage("no-file");
}
$valeur->setAdminsId($userId);
$entityManager->persist($valeur);
$entityManager->flush();
$this->addFlash('success','Le texte de présentation a été bien enrégistré');
}
}else{
$editvaleurForm = $this->createForm(EditValeurFormType::class, $valeur);
$editvaleurForm->handleRequest($request);
$data = $editvaleurForm->getData();
if ($editvaleurForm->isSubmitted() && $editvaleurForm->isValid()) {
$userId = $user->getId();
$data = $valeurRepository->find(1);
$imageFile = $editvaleurForm->get('image')->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_valeur'),
$newFilename
);
} catch (FileException $e) {}
$data->setImage($newFilename);
}
// dd($data);
$data->setTexte($editvaleurForm->get('texte')->getData());
$data->setAdminsId($userId);
$entityManager->flush();
$this->addFlash('success','Le texte de présentation a été bien modifié');
}
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/show/admin-valeur.html.twig', [
'data' => $Datavaleur,
'valeurForm' => $valeurForm->createView(),
'editvaleurForm' => $editvaleurForm->createView(),
]);
}
//----------------------------------------------------------------------------------------------
#[Route('admin/edit/emploi/{id}', name: 'admin.edit.recrutement', methods:['GET','POST'])]
public function edit_job(
$id,
Request $request,
RecrutementsRepository $jobRepository,
): Response
{
$infoalerte = $jobRepository->find($id);
$alerte = new Recrutements();
$editalerteForm = $this->createForm(EditRecrutementFormType::class, $alerte);
$editalerteForm->handleRequest($request);
// dd($infoalerte);
if($infoalerte != null){
return $this->render('admin/edit/edit-admin-alerte.html.twig', [
'infoalerte' => $infoalerte,
'editalerteForm' => $editalerteForm->createView(),
]);
}
return $this->render('admin/edit/edit-admin-alerte.html.twig', [
'infoalerte' => $infoalerte,
'editalerteForm' => $editalerteForm->createView(),
]);
}
#[Route('admin/nos-centres', name: 'admin.centres', methods:['GET','POST'])]
public function centres(
Request $request,
SluggerInterface $slugger,
VillesRepository $centreRepository,
EntityManagerInterface $entityManager,
): Response
{
$centre = new Villes();
$centres = $centreRepository->findAll();
$addcentreForm = $this->createForm(VilleFormType::class, $centre);
$addcentreForm->handleRequest($request);
$user = $this->getUser();
if ($addcentreForm->isSubmitted()) {
if ($user) {
$userId = $user->getId();
$nom = $addcentreForm->get('nom')->getData();
$slug = $slugger->slug($nompart);
$pays = $addcentreForm->get('pays')->getData();
$texte = $addcentreForm->get('texte')->getData();
$longitude = $addcentreForm->get('longitude')->getData();
$latitude = $addcentreForm->get('latitude')->getData();
$centre = $addcentreForm->getData();
$imageFile = $addcentreForm->get('image')->getData();
$img_gal = $addcentreForm->get('img_gal')->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_centre'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$centre->setImage($newFilename);
}else{
$centre->setImage("no-file");
}
if ($img_gal) {
foreach ($img_gal as $image) {
$newFilename = uniqid().'.'.$image->guessExtension();
$image->move(
$this->getParameter('photo_centre'),
$newFilename
);
// Exemple : si tu as une entité Galerie
$galerie = new Galeries();
$galerie->setImage($newFilename);
$galerie->setNom($nom);
$entityManager->persist($galerie);
}
}
$centre->setNom($nom);
$centre->setSlug($slug);
$centre->setPays($pays);
$centre->setLongitude($longitude);
$centre->setLatitude($latitude);
$centre->setTexte($texte);
$centre->setAdminsId($userId);
$entityManager->persist($centre);
$entityManager->flush();
$this->addFlash(
'success',
'L\'article a été bien enrégistré');
return $this->redirectToRoute('admin.centres');
} else {
$this->addFlash('danger', 'Erreur survenue lors de l\'enregistrement du centre');
}
}
return $this->render('admin/show/admin-centre.html.twig', [
'centres' => $centres,
'addcentreForm' => $addcentreForm->createView(),
]);
}
#[Route('/admin/centre/{slug}', name: 'admin.edit.centre', methods: ['GET','POST'])]
public function edit_centre(
string $slug,
Request $request,
SluggerInterface $slugger,
VillesRepository $villesRepository,
EntityManagerInterface $entityManager
): Response
{
$user = $this->getUser();
if (!$user) {
return $this->redirectToRoute('login.connexion');
}
$infocentre = $villesRepository->findOneBy(['slug' => $slug]);
if (!$infocentre) {
throw $this->createNotFoundException('Centre introuvable');
}
// âÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ on édite l’existant
$form = $this->createForm(EditVilleFormType::class, $infocentre);
$form->handleRequest($request);
if ($form->isSubmitted()) {
// dd( $form->get('img_gal')->getData());
/** IMAGE PRINCIPALE **/
$imageFile = $form->get('image')->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
$imageFile->move(
$this->getParameter('photo_centre'),
$newFilename
);
$infocentre->setImage($newFilename);
}
/** GALERIE **/
$imagesGalerie = $form->get('img_gal')->getData();
if ($imagesGalerie) {
foreach ($imagesGalerie as $image) {
$filename = uniqid().'.'.$image->guessExtension();
$image->move($this->getParameter('photo_centre'), $filename);
$galerie = new Galeries();
$galerie->setImage($filename);
$galerie->setNom($slugger->slug($form->get('nom')->getData())); // âÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂ ENTITÉ
$entityManager->persist($galerie);
}
}
$infocentre->setAdminsId($user->getId());
$entityManager->flush();
$this->addFlash('success', 'La modification a été effectuée avec succès');
return $this->redirectToRoute('admin.centres');
}
return $this->render('admin/edit/edit-admin-centre.html.twig', [
'infocentre' => $infocentre,
'editcentreForm' => $form->createView(),
]);
}
#-----------------CREER UN PARTENAIRE-----------------------
#[Route('admin/nos-partenaires', name: 'admin.nos-partenaires', methods:['POST','GET'])]
public function create_partenaires(
Request $request,
PartenairesRepository $partenaireRepository,
SluggerInterface $slugger,
EntityManagerInterface $entityManager
): Response
{
$partenaire = new Partenaires();
$listpartenaire = $partenaireRepository->findAll();
$addPartenaireForm = $this->createForm(PartenaireFormType::class, $partenaire);
$addPartenaireForm->handleRequest($request);
$user = $this->getUser();
if($user){
if ($addPartenaireForm->isSubmitted() && $addPartenaireForm->isValid()) {
if ($user) {
$userId = $user->getId();
$nom = $addPartenaireForm->get('nompart')->getData();
$slug = $slugger->slug($nom);
$pays = $addPartenaireForm->get('payspart')->getData();
$partenaire = $addPartenaireForm->getData();
$imageFile = $addPartenaireForm->get('imagepart')->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_partenaire'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$partenaire->setImagePart($newFilename);
}else{
$imageFile = "no-file";
}
$partenaire->setNomPart($nom);
$partenaire->setSlug($slug);
$partenaire->setPaysPart($pays);
$partenaire->setAdminsId($userId);
$entityManager->persist($partenaire);
$entityManager->flush();
$this->addFlash(
'success',
'Le nouveau partenaire a été bien enrégistré');
return $this->redirectToRoute('admin.nos-partenaires');
} else {
$this->addFlash(
'warning',
'Erreur survenu lors de l\'enrégistrement');
return $this->render('admin/show/admin-nos-partenaires.html.twig', [
'partenaires' => $listpartenaire,
'addPartenaireForm' => $addPartenaireForm->createView(),
]);
}
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/show/admin-nos-partenaires.html.twig', [
'partenaires' => $listpartenaire,
'addPartenaireForm' => $addPartenaireForm->createView(),
]);
}
#-----------------EDITER UN PARTENAIRE-----------------------
#[Route('admin/edit/nos-partenaires/{slug}', name: 'admin.edit.partenaires', methods:['GET','POST'])]
public function edit_partenaires(
$slug,
Request $request,
SluggerInterface $slugger,
PartenairesRepository $PR,
EntityManagerInterface $entityManager
): Response
{
$partenaire = new Partenaires();
$editPartenaireForm = $this->createForm(EditPartenaireFormType::class, $partenaire);
$infos_par = $PR->findOneBy(array('slug' => $slug));
$editPartenaireForm->handleRequest($request);
$user = $this->getUser();
if($user == null){
return $this->redirectToRoute('login.connexion');
}
if ($editPartenaireForm->isSubmitted()) {
$userId = $user->getId();
$nompart = $editPartenaireForm->get('nompart')->getData();
$slug = $slugger->slug($nompart);
$payspart = $editPartenaireForm->get('payspart')->getData();
$lienpart = $editPartenaireForm->get('lienpart')->getData();
$imageFile = $editPartenaireForm->get('imagepart')->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_partenaire'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$infos_par->setImagePart($newFilename);
}
$infos_par->setNomPart($nompart);
$infos_par->setSlug($slug);
$infos_par->setPaysPart($payspart);
$infos_par->setLienPart($lienpart);
$infos_par->setAdminsId($userId);
$entityManager->flush();
$this->addFlash('success','Modification bien effectuée.');
return $this->redirectToRoute('admin.nos-partenaires');
}
return $this->render('admin/edit/edit-admin-nos-partenaire.html.twig', [
'ipart' => $infos_par,
'editPartenaireForm' => $editPartenaireForm->createView(),
]);
}
#-----------------SUPPERIMER UN PARTENAIRE-----------------------
#[Route('admin/del/nos-partenaires/{slug}', name: 'admin.del.partenaires', methods:['GET'])]
public function delete_partenaires(
$slug,
PartenairesRepository $PR,
EntityManagerInterface $entityManager
){
$select_partner = $PR->findOneBy(array('slug' => $slug));
$entityManager->remove($select_partner);
$entityManager->flush();
$this->addFlash(
'danger',
'Le partenaire a été bien supprimé');
return $this->redirectToRoute('admin.nos-partenaires');
}
#-----------------------------------------------------------------------
#[Route('admin/themes', name: 'admin.theme', methods:['POST','GET'])]
public function create_theme(
Request $request,
ThemesRepository $themeRepository,
SluggerInterface $slugger,
EntityManagerInterface $entityManager
): Response
{
$theme = new Themes();
$listheme = $themeRepository->findAll();
$addthemeForm = $this->createForm(ThemeFormType::class, $theme);
$addthemeForm->handleRequest($request);
$user = $this->getUser();
if($user){
if ($addthemeForm->isSubmitted()) {
if ($user) {
$userId = $user->getId();
$thematiqueid = $addthemeForm->get('thematique')->getData();
$nom = $addthemeForm->get('nom')->getData();
$slug = $slugger->slug($nom);
$texte = $addthemeForm->get('description')->getData();
$search = $themeRepository->findOneBy(array('nom' => $nom));
if($search){
$this->addFlash('danger','Ce thème est déjà enrégistré');
return $this->redirectToRoute('admin.theme');
}
if(!$texte){
$description = "...";
}else{
$description = $addthemeForm->get('description')->getData();
}
$thematique = $addthemeForm->getData();
$theme->setThematique($thematiqueid);
$theme->setNom($nom);
$theme->setSlug($slug);
$theme->setDescription($description);
$entityManager->persist($theme);
$entityManager->flush();
$this->addFlash(
'success',
'Le nouveau thème a été bien enrégistré');
return $this->redirectToRoute('admin.theme');
} else {
$this->addFlash(
'warning',
'Erreur survenu lors de l\'enrégistrement');
return $this->render('admin/show/admin-theme.html.twig', [
'listheme' => $listheme,
'addthemeForm' => $addthemeForm->createView(),
]);
}
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/show/admin-theme.html.twig', [
'listheme' => $listheme,
'addthemeForm' => $addthemeForm->createView(),
]);
}
#---------------------------------------------------------------------
#[Route('admin/edit/theme/{slug}', name: 'admin.edit.theme', methods:['GET','POST'])]
public function edit_theme(
$slug,
Request $request,
SluggerInterface $slugger,
ThemesRepository $themeRepository,
EntityManagerInterface $entityManager
): Response {
$infos_them = $themeRepository->findOneBy(['slug' => $slug]);
if (!$infos_them) {
throw $this->createNotFoundException('Thème introuvable');
}
$editThemeForm = $this->createForm(EditThemeFormType::class, $infos_them);
$editThemeForm->handleRequest($request);
$them = $infos_them->getThematique()?->getNom();
$user = $this->getUser();
if (!$user) {
return $this->redirectToRoute('login.connexion');
}
if ($editThemeForm->isSubmitted() && $editThemeForm->isValid()) {
$nom = $editThemeForm->get('nom')->getData();
$slug = $slugger->slug($nom)->lower();
$infos_them->setSlug($slug);
$entityManager->flush();
$this->addFlash('success', 'Modification bien effectuée.');
return $this->redirectToRoute('admin.theme');
}
return $this->render('admin/edit/edit-admin-theme.html.twig', [
'infos_them' => $infos_them,
'them' => $them,
'editThemeForm' => $editThemeForm->createView(),
]);
}
/*
#[Route('admin/edit/theme/{slug}', name: 'admin.edit.theme', methods:['GET','POST'])]
public function edit_theme(
$slug,
Request $request,
SluggerInterface $slugger,
ThemesRepository $themeRepository,
EntityManagerInterface $entityManager
): Response
{
$infos_them = $themeRepository->findOneBy(array('slug' => $slug));
$editThemeForm = $this->createForm(EditThemeFormType::class, $infos_them);
$editThemeForm->handleRequest($request);
$user = $this->getUser();
if($user == null){
return $this->redirectToRoute('login.connexion');
}
if ($editThemeForm->isSubmitted()) {
$userId = $user->getId();
$thematiqueid = $editThemeForm->get('thematique')->getData();
$nom = $editThemeForm->get('nom')->getData();
$slug = $slugger->slug($nom);
$description = $editThemeForm->get('description')->getData();
$theme = $editThemeForm->getData();
$infos_them->setThematique($thematiqueid);
$infos_them->setNom($nom);
$infos_them->setSlug($slug);
$infos_them->setDescription($description);
$entityManager->flush();
$this->addFlash('success','Modification bien effectuée.');
return $this->redirectToRoute('admin.theme');
}
return $this->render('admin/edit/edit-admin-theme.html.twig', [
'infos_them' => $infos_them,
'editThemeForm' => $editThemeForm->createView(),
]);
}*/
#[Route('admin/del/theme/{slug}', name: 'admin.del.theme', methods:['GET'])]
public function delete_theme(
$slug,
ThemesRepository $themeRepository,
EntityManagerInterface $entityManager
){
$select_them = $themeRepository->findOneBy(array('slug' => $slug));
$entityManager->remove($select_them);
$entityManager->flush();
$this->addFlash(
'danger',
'Le thème a été bien supprimé');
return $this->redirectToRoute('admin.theme');
}
#-----------------------------------------------------------------------
#[Route('admin/thematiques', name: 'admin.thematique', methods:['POST','GET'])]
public function create_thematique(
Request $request,
ThematiquesRepository $thematiqueRepository,
SluggerInterface $slugger,
EntityManagerInterface $entityManager
): Response
{
$thematique = new Thematiques();
$listhematique = $thematiqueRepository->findAll();
$addthematiqueForm = $this->createForm(ThematiqueFormType::class, $thematique);
$addthematiqueForm->handleRequest($request);
$user = $this->getUser();
if($user){
if ($addthematiqueForm->isSubmitted()) {
if ($user) {
$userId = $user->getId();
$nom = $addthematiqueForm->get('nom')->getData();
$slug = $slugger->slug($nom);
$description = $addthematiqueForm->get('description')->getData();
$thematique = $addthematiqueForm->getData();
$thematique->setNom($nom);
$thematique->setSlug($slug);
$thematique->setDescription($description);
$entityManager->persist($thematique);
$entityManager->flush();
$this->addFlash(
'success',
'La nouvelle thématique a été bien enrégistré');
return $this->redirectToRoute('admin.thematique');
} else {
$this->addFlash(
'warning',
'Erreur survenu lors de l\'enrégistrement');
return $this->render('admin/show/admin-thematique.html.twig', [
'listhematique' => $listhematique,
'addthematiqueForm' => $addthematiqueForm->createView(),
]);
}
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/show/admin-thematique.html.twig', [
'listhematique' => $listhematique,
'addthematiqueForm' => $addthematiqueForm->createView(),
]);
}
#---------------------------------------------------------------------
#[Route('admin/edit/thematique/{slug}', name: 'admin.edit.thematique', methods:['GET','POST'])]
public function edit_thematique(
$slug,
Request $request,
SluggerInterface $slugger,
ThematiquesRepository $PR,
EntityManagerInterface $entityManager
): Response
{
$thematique = new Thematiques();
$editThematiqueForm = $this->createForm(EditThematiqueFormType::class, $thematique);
$infos_them = $PR->findOneBy(array('slug' => $slug));
$editThematiqueForm->handleRequest($request);
$user = $this->getUser();
if($user == null){
return $this->redirectToRoute('login.connexion');
}
if ($editThematiqueForm->isSubmitted()) {
$userId = $user->getId();
$nom = $editThematiqueForm->get('nom')->getData();
$slug = $slugger->slug($nom);
$description = $editThematiqueForm->get('description')->getData();
$thematique = $editThematiqueForm->getData();
$infos_them->setNom($nom);
$infos_them->setSlug($slug);
$infos_them->setDescription($description);
$entityManager->flush();
$this->addFlash('success','Modification bien effectuée.');
return $this->redirectToRoute('admin.thematique');
}
return $this->render('admin/edit/edit-admin-thematique.html.twig', [
'infos_them' => $infos_them,
'editThematiqueForm' => $editThematiqueForm->createView(),
]);
}
#-----------------SUPPERIMER UN PARTENAIRE-----------------------
#[Route('admin/del/thematique/{slug}', name: 'admin.del.thematique', methods:['GET'])]
public function delete_thematique(
$slug,
ThematiquesRepository $thematiqueRepository,
EntityManagerInterface $entityManager
){
$select_them = $thematiqueRepository->findOneBy(array('slug' => $slug));
$entityManager->remove($select_them);
$entityManager->flush();
$this->addFlash(
'danger',
'La thématique a été bien supprimée');
return $this->redirectToRoute('admin.thematique');
}
#-----------------------------------------------------------------------
#[Route('admin/formations', name: 'admin.formation', methods:['POST','GET'])]
public function create_formation(
Request $request,
FormationsRepository $formationRepository,
SluggerInterface $slugger,
EntityManagerInterface $entityManager
): Response
{
$formation = new Formations();
//$listformation = $formationRepository->findAll();
$queryBuilder = $entityManager->createQueryBuilder();
$queryBuilder
->select(
'for.id', 'for.dates_session', 'for.prix', 'for.devise', 'th.nom',
'thm.nom AS thmnom','vil.nom AS vilnom','vil.pays','for.created_at','th.slug',
'th.description','for.devise'
)
->from(Formations::class, 'for')
->innerJoin(Themes::class,'th', 'WITH', 'for.theme = th.id')
->innerJoin(Villes::class, 'vil', 'WITH', 'for.ville = vil.id')
->innerJoin(Thematiques::class, 'thm', 'WITH', 'th.thematique = thm.id');
$listformation = $queryBuilder->getQuery()->getResult();
$addformationForm = $this->createForm(FormationFormType::class, $formation);
$addformationForm->handleRequest($request);
$user = $this->getUser();
if($user){
if ($addformationForm->isSubmitted()) {
if ($user) {
//$userId = $user->getId();
$theme = $addformationForm->get('theme')->getData();
$ville = $addformationForm->get('ville')->getData();
$datesSession = $addformationForm->get('dates_session')->getData();
$price = $addformationForm->get('prix')->getData();
$devise = $addformationForm->get('devise')->getData();
$formation = $addformationForm->getData();
$imageFile = $addformationForm->get('image')->getData();
$themeId = $theme ? $theme->getId() : null;
$villeId = $ville ? $ville->getId() : null;
// Supprimer les espaces
$prix = str_replace(' ', '', $price);
$count = $formationRepository->count([
'theme' => $themeId,
'ville' => $villeId,
'prix' => $prix,
'dates_session' => $datesSession,
]);
//dd($themeId,$villeId, $prix,$datesSession);
if ($count > 0) {
$this->addFlash('danger', 'Cette formation existe déjà.');
return $this->redirectToRoute('admin.formation');
}
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_formation'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$formation->setImage($newFilename);
}else{
$formation->setImage("no-file");
}
$formation->setTheme($theme);
$formation->setVille($ville);
$formation->setDatesSession($addformationForm->get('dates_session')->getData());
$formation->setPrix($prix);
$formation->setDevise($devise);
$entityManager->persist($formation);
$entityManager->flush();
$this->addFlash(
'success',
'La nouvelle formation a été bien enrégistrée');
return $this->redirectToRoute('admin.formation');
} else {
$this->addFlash(
'warning',
'Erreur survenu lors de l\'enrégistrement');
return $this->render('admin/show/admin-formations.html.twig', [
'listformation' => $listformation,
'addformationForm' => $addformationForm->createView(),
]);
}
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/show/admin-formations.html.twig', [
'listformation' => $listformation,
'addformationForm' => $addformationForm->createView(),
]);
}
#---------------------------------------------------------------------
#[Route('admin/edit/formation/{id}', name: 'admin.edit.formation', methods:['GET','POST'])]
public function edit_formation(
$id,
Request $request,
SluggerInterface $slugger,
FormationsRepository $formationsRepository,
EntityManagerInterface $entityManager
): Response
{
$formations = new Formations();
$formation = $formationsRepository->find($id);
$editFormationForm = $this->createForm(EditFormationFormType::class, $formation);
$editFormationForm->handleRequest($request);
$user = $this->getUser();
if($user == null){
return $this->redirectToRoute('login.connexion');
}
if ($editFormationForm->isSubmitted()) {
$theme = $editFormationForm->get('theme')->getData();
$ville = $editFormationForm->get('ville')->getData();
$session = $editFormationForm->get('dates_session')->getData();
$price = $editFormationForm->get('prix')->getData();
$devise = $editFormationForm->get('devise')->getData();
$infos_form = $editFormationForm->getData();
$imageFile = $editFormationForm->get('image')->getData();
$themeId = $theme ? $theme->getId() : null;
$villeId = $ville ? $ville->getId() : null;
// Supprimer les espaces
$prix = str_replace(' ', '', $price);
$count = $formationsRepository->count([
'theme' => $themeId,
'ville' => $villeId,
'prix' => $prix,
'dates_session' => $session,
]);
//dd($themeId,$villeId, $prix,$datesSession);
/*if ($count > 0) {
$this->addFlash('danger', 'Cette formation existe déjà.');
return $this->redirectToRoute('admin.formation');
}*/
if ($imageFile != null) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_formation'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$formation->setImage($newFilename);
}
$date = $session;
// Supprimer les espaces
$prix = str_replace(' ', '', $prix);
// Remplacer la virgule par un point si nécessaire
$prix = str_replace(',', '.', $prix);
//dd($dates_session);
$formation->setTheme($theme);
$formation->setVille($ville);
$formation->setDatesSession($editFormationForm->get('dates_session')->getData());
$formation->setPrix($prix);
$formation->setDevise($devise);
$entityManager->flush();
$this->addFlash('success','Modification bien effectuée.');
return $this->redirectToRoute('admin.formation');
}
return $this->render('admin/edit/edit-admin-formation.html.twig', [
'infos_form' => $formation,
'editFormationForm' => $editFormationForm->createView(),
]);
}
#[Route('admin/del/formation/{id}', name: 'admin.del.formation', methods:['GET'])]
public function delete_formation(
$id,
FormationsRepository $formationRepository,
EntityManagerInterface $entityManager
){
$select_form = $formationRepository->findOneBy(array('id' => $id));
$entityManager->remove($select_form);
$entityManager->flush();
$this->addFlash(
'danger',
'La formation a été bien supprimée');
return $this->redirectToRoute('admin.formation');
}
#-----------------CREER UN PARTENAIRE-----------------------
#[Route('admin/notre-equipe', name: 'admin.equipe', methods:['POST','GET'])]
public function create_equipe(
Request $request,
EquipesRepository $equipeRepository,
SluggerInterface $slugger,
EntityManagerInterface $entityManager
): Response
{
$equipe = new Equipes();
$listequipe = $equipeRepository->findAll();
$addEquipeForm = $this->createForm(EquipeFormType::class, $equipe);
$addEquipeForm->handleRequest($request);
$user = $this->getUser();
if($user){
if ($addEquipeForm->isSubmitted()) {
if ($user) {
$userId = $user->getId();
$nom = $addEquipeForm->get('nom')->getData();
$slug = $slugger->slug($nom);
$titre = $addEquipeForm->get('titre')->getData();
$face = $addEquipeForm->get('face')->getData() ?? '#';
$twit = $addEquipeForm->get('titre')->getData() ?? '#';
$link = $addEquipeForm->get('link')->getData() ?? '#';
$imageFile = $addEquipeForm->get('image')->getData();
$equipe = $addEquipeForm->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_equipe'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$equipe->setImage($newFilename);
}else{
$equipe->setImage("no-file");
}
$equipe->setNom($nom);
$equipe->setSlug($slug);
$equipe->setTitre($titre);
$equipe->setFace($face);
$equipe->setTwit($twit);
$equipe->setLink($link);
$equipe->setAdminsId($userId);
//$entityManager->persist($equipe);
$entityManager->flush();
$this->addFlash(
'success',
'Le membre a été bien enrégistré');
return $this->redirectToRoute('admin.equipe');
} else {
$this->addFlash(
'warning',
'Erreur survenu lors de l\'enrégistrement');
return $this->render('admin/show/admin-equipe.html.twig', [
'listequipe' => $listequipe,
'addEquipeForm' => $addEquipeForm->createView(),
]);
}
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/show/admin-equipe.html.twig', [
'listequipe' => $listequipe,
'addEquipeForm' => $addEquipeForm->createView(),
]);
}
#-----------------EDITER UN PARTENAIRE-----------------------
#[Route('admin/edit/notre-equipe/{slug}', name: 'admin.edit.equipe', methods:['GET','POST'])]
public function edit_equipe(
$slug,
Request $request,
SluggerInterface $slugger,
EquipesRepository $PR,
EntityManagerInterface $entityManager
): Response
{
$equipe = new Equipes();
$editEquipeForm = $this->createForm(EditEquipeFormType::class, $equipe);
$infos_equi = $PR->findOneBy(array('slug' => $slug));
$editEquipeForm->handleRequest($request);
$user = $this->getUser();
if($user == null){
return $this->redirectToRoute('login.connexion');
}
if ($editEquipeForm->isSubmitted()) {
$userId = $user->getId();
$nom = $editEquipeForm->get('nom')->getData();
$slug = $slugger->slug($nom);
$titre = $editEquipeForm->get('titre')->getData();
$face = $editEquipeForm->get('face')->getData() ?? '#';
$twit = $editEquipeForm->get('titre')->getData() ?? '#';
$link = $editEquipeForm->get('link')->getData() ?? '#';
$imageFile = $editEquipeForm->get('image')->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_partenaire'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$infos_equi->setImage($newFilename);
}
$infos_equi->setNom($nom);
$infos_equi->setSlug($slug);
$infos_equi->setTitre($titre);
$infos_equi->setFace($face);
$infos_equi->setTwit($twit);
$infos_equi->setLink($link);
$infos_equi->setAdminsId($userId);
$entityManager->flush();
$this->addFlash('success','Modification bien effectuée.');
return $this->redirectToRoute('admin.equipe');
}
return $this->render('admin/edit/edit-admin-equipe.html.twig', [
'infos_equi' => $infos_equi,
'editEquipeForm' => $editEquipeForm->createView(),
]);
}
#-----------------SUPPERIMER UN PARTENAIRE-----------------------
#[Route('admin/del/equipe/{slug}', name: 'admin.del.equipe', methods:['GET'])]
public function delete_equipe(
$slug,
EquipesRepository $PR,
EntityManagerInterface $entityManager
){
$select_equipe = $PR->findOneBy(array('slug' => $slug));
$entityManager->remove($select_equipe);
$entityManager->flush();
$this->addFlash(
'danger',
'Le membre a été bien supprimé');
return $this->redirectToRoute('admin.equipe');
}
#-----------------CREER UN PARTENAIRE-----------------------
#[Route('admin/nos-references', name: 'admin.references', methods:['POST','GET'])]
public function create_references(
Request $request,
ReferenceclientsRepository $referenceRepository,
SluggerInterface $slugger,
EntityManagerInterface $entityManager
): Response
{
$references = new Referenceclients();
$listreference = $referenceRepository->findAll();
$addReferenceForm = $this->createForm(ReferenceclientFormType::class, $references);
$addReferenceForm->handleRequest($request);
$user = $this->getUser();
if($user){
if ($addReferenceForm->isSubmitted() && $addReferenceForm->isValid()) {
if ($user) {
$userId = $user->getId();
$nom = $addReferenceForm->get('nom')->getData();
$slug = $slugger->slug($nom);
$imageFile = $addReferenceForm->get('image')->getData();
$references = $addReferenceForm->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_reference'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$references->setImage($newFilename);
}else{
$references->setImage("no-file");
}
$references->setNom($nom);
$references->setSlug($slug);
$references->setAdminsId($userId);
$entityManager->persist($references);
$entityManager->flush();
$this->addFlash(
'success',
'La nouvelle référence a été bien enrégistré');
return $this->redirectToRoute('admin.references');
} else {
$this->addFlash(
'warning',
'Erreur survenu lors de l\'enrégistrement');
return $this->render('admin/show/admin-nos-references.html.twig', [
'listreference' => $listreference,
'addPartenaireForm' => $addReferenceForm->createView(),
]);
}
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/show/admin-nos-references.html.twig', [
'listreference' => $listreference,
'addReferenceForm' => $addReferenceForm->createView(),
]);
}
#-----------------EDITER UN PARTENAIRE-----------------------
#[Route('admin/edit/nos-references/{slug}', name: 'admin.edit.reference', methods:['GET','POST'])]
public function edit_references(
$slug,
Request $request,
SluggerInterface $slugger,
ReferenceclientsRepository $REF,
EntityManagerInterface $entityManager
): Response
{
$references = new Referenceclients();
$editReferenceForm = $this->createForm(EditReferenceclientFormType::class, $references);
$infos_ref = $REF->findOneBy(array('slug' => $slug));
$editReferenceForm->handleRequest($request);
$user = $this->getUser();
if($user == null){
return $this->redirectToRoute('login.connexion');
}
if ($editReferenceForm->isSubmitted()) {
$userId = $user->getId();
$nom = $editReferenceForm->get('nom')->getData();
$slug = $slugger->slug($nom);
$imageFile = $editReferenceForm->get('image')->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_reference'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$infos_ref->setImage($newFilename);
}
$infos_ref->setNom($nom);
$infos_ref->setSlug($slug);
$infos_ref->setAdminsId($userId);
$entityManager->flush();
$this->addFlash('success','Modification bien effectuée.');
return $this->redirectToRoute('admin.references');
}
return $this->render('admin/edit/edit-admin-nos-references.html.twig', [
'info_ref' => $infos_ref,
'editReferenceForm' => $editReferenceForm->createView(),
]);
}
#-----------------SUPPERIMER UN PARTENAIRE-----------------------
#[Route('admin/del/nos-references/{slug}', name: 'admin.del.reference', methods:['GET'])]
public function delete_referent(
$slug,
ReferenceclientsRepository $REF,
EntityManagerInterface $entityManager
){
$select_ref = $REF->findOneBy(array('slug' => $slug));
$entityManager->remove($select_ref);
$entityManager->flush();
$this->addFlash(
'danger',
'La référence a été bien supprimé');
return $this->redirectToRoute('admin.references');
}
//--------------------------------------------------------------------------------------
#[Route('admin/actualite', name: 'admin.actualite', methods:['GET','POST'])]
public function actualite(
Request $request,
SluggerInterface $slugger,
ActualitesRepository $actualiteRepository,
EntityManagerInterface $entityManager
): Response
{
$actualite = new Actualites();
$listactualite = $actualiteRepository->findAll();
$addactualiteForm = $this->createForm(ActualiteFormType::class, $actualite);
$addactualiteForm->handleRequest($request);
$user = $this->getUser();
if($user){
if ($addactualiteForm->isSubmitted()) {
// dd('OK');
$userId = $user->getId();
$titre = $addactualiteForm->get('titre')->getData();
$slug = $slugger->slug($titre);
$resume = $addactualiteForm->get('resume')->getData();
$texte = $addactualiteForm->get('texte')->getData();
$statut = $addactualiteForm->get('statut')->getData();
if(!$texte){
$description = "...";
}else{
$description = $addactualiteForm->get('texte')->getData();
}
$actualite = $addactualiteForm->getData();
$imageFile = $addactualiteForm->get('image')->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_actualite'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$actualite->setImage($newFilename);
}else{
$imageFile = "no-file";
}
$actualite->setTitre($titre);
$actualite->setSlug($slug);
$actualite->setResume($resume);
$actualite->setTexte($description);
$actualite->setStatut($statut);
$actualite->setAdminsId($userId);
$entityManager->persist($actualite);
$entityManager->flush();
$this->addFlash(
'success',
'L\'article a été bien enrégistré');
return $this->redirectToRoute('admin.actualite');
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/show/admin-actualite.html.twig', [
'actualites' => $listactualite,
'addactualiteForm' => $addactualiteForm->createView(),
]);
}
#[Route('admin/edit/actualite/{slug}', name: 'admin.edit.actualite', methods:['GET','POST'])]
public function edit_actualite(
$slug,
Request $request,
SluggerInterface $slugger,
EntityManagerInterface $entityManager,
ActualitesRepository $actualiteRepository
): Response
{
$actualite = new Actualites();
$user = $this->getUser();
$infoactu = $actualiteRepository->findOneBy(array(
'slug' => $slug
));
$editactualiteForm = $this->createForm(EditActualiteFormType::class, $infoactu);
$editactualiteForm->handleRequest($request);
if($user){
if ($editactualiteForm->isSubmitted()) {
$userId = $user->getId();
$titre = $editactualiteForm->get('titre')->getData();
$slug = $slugger->slug($titre);
$resume = $editactualiteForm->get('resume')->getData();
$texte = $editactualiteForm->get('texte')->getData();
$statut = $editactualiteForm->get('statut')->getData();
// $actualite = $editactualiteForm->getData();
$imageFile = $editactualiteForm->get('image')->getData();
// dd($imageFile);
if ($imageFile != null) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_actualite'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$infoactu->setImage($newFilename);
}
$infoactu->setTitre($titre);
$infoactu->setSlug($slug);
$infoactu->setResume($resume);
$infoactu->setTexte($texte);
$infoactu->setStatut($statut);
$infoactu->setAdminsId($userId);
$entityManager->flush();
$this->addFlash('success','La modification a étét bien effectuée');
return $this->redirectToRoute('admin.actualite');
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/edit/edit-admin-actualite.html.twig', [
'infoactu' => $infoactu,
'editactualiteForm' => $editactualiteForm->createView(),
]);
}
#-----------------SUPPERIMER UN ACTUALITE-----------------------
#[Route('admin/del/actualite/{slug}', name: 'admin.del.actualite', methods:['GET'])]
public function delete_actualite(
$slug,
ActualitesRepository $AC,
EntityManagerInterface $entityManager
){
$select_actu = $AC->findOneBy(array('slug' => $slug));
$entityManager->remove($select_actu);
$entityManager->flush();
$this->addFlash(
'danger',
'Le post a été bien supprimé');
return $this->redirectToRoute('admin.actualite');
}
//--
//--------------------------------------------------------------------------------------
#[Route('admin/banniere', name: 'admin.banniere', methods:['GET','POST'])]
public function create_banniere(
Request $request,
SluggerInterface $slugger,
BannieresRepository $banniereRepository,
EntityManagerInterface $entityManager
): Response
{
$slide = new Bannieres();
$countSlide = $banniereRepository->count();
$listslides = $banniereRepository->findAll();
$addbanniereForm = $this->createForm(BanniereFormType::class, $slide);
$addbanniereForm->handleRequest($request);
$user = $this->getUser();
if ($user) {
if($addbanniereForm->isSubmitted() && $addbanniereForm->isValid()){
$listslides = $banniereRepository->findAll();
$userId = $user->getId();
$slide = $addbanniereForm->getData();
$texte = $addbanniereForm->get('texte')->getData();
$imageFile = $addbanniereForm->get('image')->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_banniere'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$slide->setImage($newFilename);
}else{
$slide = "no-file";
}
$slide->setTexte($texte);
$slide->setAdminsId($userId);
$entityManager->persist($slide);
$entityManager->flush();
$this->addFlash(
'success',
'La bannière a été bien enrégistré');
return $this->redirectToRoute('admin.banniere');
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/show/admin-banniere.html.twig', [
'listslide' => $listslides,
'countSlide' => $countSlide,
'addbanniereForm' => $addbanniereForm->createView(),
]);
}
#[Route('admin/edit/banniere/{id}', name: 'admin.edit.banniere', methods:['GET','POST'])]
public function edit_banniere(
$id,
Request $request,
SluggerInterface $slugger,
BannieresRepository $banniereRepository,
EntityManagerInterface $entityManager
): Response
{
$user = $this->getUser();
$infos = $banniereRepository->find($id);
// dd($infos);
$banniere = new Bannieres();
$editSlideForm = $this->createForm(EditBanniereFormType::class, $banniere);
$editSlideForm->handleRequest($request);
$data = $editSlideForm->getData();
if($user){
if ($editSlideForm->isSubmitted()) {
// dd($editSlideForm);
$userId = $user->getId();
$data = $banniereRepository->find(1);
$texte = $editSlideForm->get('texte')->getData();
$imageFile = $editSlideForm->get('image')->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_banniere'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$infos->setImage($newFilename);
}
$infos->setTexte($texte);
$infos->setAdminsId($userId);
$entityManager->flush();
$this->addFlash('success','Les informations concernant la bannières ont été bien modifiées');
return $this->redirectToRoute('admin.banniere');
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/edit/edit-admin-banniere.html.twig', [
'infos' => $infos,
'editSlideForm' => $editSlideForm->createView(),
]);
}
#[Route('admin/del/banniere/{id}', name: 'admin.del.banniere', methods:['GET'])]
public function delete_banniere(
$slug,
BannieresRepository $BAR,
EntityManagerInterface $entityManager
){
$select_ban = $BAR->findOneBy(array('id' => $id));
$entityManager->remove($select_ban);
$entityManager->flush();
$this->addFlash(
'danger',
'La bannière a été bien supprimé');
return $this->redirectToRoute('admin.banniere');
}
#[Route('admin/utilisateurs', name: 'admin.users', methods:['POST','GET'])]
public function create_utilisateur(
Request $request,
SluggerInterface $slugger,
UsersRepository $UR,
EntityManagerInterface $entityManager,
UserPasswordHasherInterface $passwordHasher
): Response
{
// if (!$this->isGranted('ROLE_ADMIN')) {
// $error ="Vous n'avez pas accès à cette page.";
// return $this->render('admin/error/page-erreur.html.twig', [
// 'error' => $error,
// ]);
// //throw $this->createAccessDeniedException('No access for you!');
// }
$listuser = $UR->findAll();
$user = new Users();
$addUserForm = $this->createForm(UserFormType::class, $user);
$addUserForm->handleRequest($request);
if ($addUserForm->isSubmitted() && $addUserForm->isValid()) {
if ($user) {
$user = $addUserForm->getData();
$imageFile = $addUserForm->get('image')->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_user'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$user->setImage($newFilename);
}else{
$user->setImage('no-file');
}
$plaintextPassword = $addUserForm->get('password')->getData();
$hashedPassword = $passwordHasher->hashPassword(
$user,
$plaintextPassword
);
$user->setPassword($hashedPassword);
$entityManager->persist($user);
$entityManager->flush();
$this->addFlash(
'success',
'Votre compte a été créé.'
);
return $this->redirectToRoute('admin.users');
} else {
// Handle the case where the user is not authenticated
}
}
return $this->render('admin/show/admin-utilisateur.html.twig', [
'users' => $listuser,
'addUserForm' => $addUserForm->createView(),
]);
}
// //Lien avec paramètre
#[Route('admin/edit/utilisateurs/{id}', name: 'admin.edit.users', methods:['GET','POST'])]
public function edit_utilisateur(
$id,
Request $request,
UsersRepository $UR,
): Response
{
$infos = $UR->find($id);
$user = new Users();
$editUserForm = $this->createForm(EditUserFormType::class, $user);
$editUserForm->handleRequest($request);
return $this->render('admin/edit/edit-admin-utilisateur.html.twig', [
'infos' => $infos,
]);
}
#[Route('admin/del/utilisateurs/{id}', name: 'admin.del.users', methods:['GET'])]
public function delete_users(
$id,
UsersRepository $usersRepository,
EntityManagerInterface $entityManager,
): Response{
$select_user = $usersRepository->findOneBy(array('id' => $id));
$id = $select_user->getId();
$entityManager->remove($select_user);
$entityManager->flush();
$this->addFlash(
'danger',
'Cet utilisateur a été bien supprimé');
return $this->redirectToRoute('admin.users');
}
#[Route('admin/refresh/utilisateurs/{id}', name: 'admin.refresh.users', methods:['GET','POST'])]
public function refresh_users(
$id,
usersRepository $UR,
EntityManagerInterface $entityManager,
): Response
{
// get EntityManager
$select_user = $UR->findOneBy(array('id' => $id));
$statut = $select_user->getStatut();
// dd($select_user);
$user = $this->getUser();
$actif = "Actif";
$inactif = "Inactif";
if($statut == "Actif"){
$select_user->setStatut($inactif);
$entityManager->flush();
$this->addFlash(
'warning',
'Le compte de l\'utilisateur a été bien désactivé');
return $this->redirectToRoute('admin.users');
}else{
$select_user->setStatut($actif);
$entityManager->flush();
$this->addFlash(
'success',
'Le compte de l\'utilisateur a été bien résactivé');
return $this->redirectToRoute('admin.users');
}
}
//------------------------------------------------------------------------------------
#[Route('admin/contact', name: 'admin.contact', methods:['GET','POST'])]
public function contact(
Request $request,
ContactsRepository $contactRepository,
EntityManagerInterface $entityManager,
): Response
{
$contact = new Contacts();
$user = $this->getUser();
$listcont = $contactRepository->findAll();
if (empty($user)) {
return $this->redirectToRoute('login.connexion');
}
// Cas où aucun contact n'existe : création
if (empty($listcont)) {
$contact = new Contacts();
$contactForm = $this->createForm(ContactFormType::class, $contact);
$contactForm->handleRequest($request);
if ($contactForm->isSubmitted() && $contactForm->isValid()) {
$contact->setUsersId($user);
$entityManager->persist($contact);
$entityManager->flush();
$this->addFlash('success', 'Les informations ont été enregistrées avec succès.');
return $this->redirectToRoute('admin.contact');
}
return $this->render('admin/show/admin-contact.html.twig', [
'listcont' => [],
'contactForm' => $contactForm->createView(),
'editcontactForm' => null,
]);
} else {
// Cas où un contact existe : édition
$editcontact = $listcont[0]; // On prend le premier (ou tu peux filtrer par utilisateur si nécessaire)
$editcontactForm = $this->createForm(EditContactFormType::class, $editcontact);
$editcontactForm->handleRequest($request);
if ($editcontactForm->isSubmitted() && $editcontactForm->isValid()) {
$editcontact->setUsersId($user);
$entityManager->flush();
$this->addFlash('success', 'Les informations ont été mises à jour avec succès.');
return $this->redirectToRoute('admin.contact');
}
return $this->render('admin/show/admin-contact.html.twig', [
'listcont' => $listcont,
'contactForm' => null,
'editcontactForm' => $editcontactForm->createView(),
]);
}
}
#[Route('admin/edit/mot-de-passe/{id}', name: 'admin.edit.passe', methods:['GET','POST'])]
public function edit_passe(
$id,
Request $request,
UsersRepository $UR,
UserPasswordHasherInterface $passwordHasher,
EntityManagerInterface $entityManager
): Response
{
$infos = $UR->find($id);
// $user = new Users();
$user = $this->getUser();
$role = $user ? $user->getRole() : [];
$editUserPassForm = $this->createForm(EditPassFormType::class, $infos);
$editUserPassForm->handleRequest($request);
// dd($editUserProfilForm);
if($user){
if($infos != null){
if($editUserPassForm->isSubmitted()){
$userId = $user->getId();
$plaintextPassword = $editUserPassForm->get('password')->getData();
$hashedPassword = $passwordHasher->hashPassword(
$user,
$plaintextPassword
);
$infos->setPassword($hashedPassword);
$entityManager->flush();
$this->addFlash('success','La modification a étét bien effectuée');
}
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/edit/edit-admin-pass.html.twig', [
'infos' => $infos,
'editUserPassForm' => $editUserPassForm->createView(),
]);
}
//--------------------------------------------------------------------------------------
#[Route('admin/top-management', name: 'admin.managements', methods:['GET','POST'])]
public function management(
Request $request,
SluggerInterface $slugger,
ManagementsRepository $managementRepository,
EntityManagerInterface $entityManager
): Response
{
$management = new Managements();
$managements = $managementRepository->findAll();
$addmanagementForm = $this->createForm(ManagementFormType::class, $management);
$addmanagementForm->handleRequest($request);
$user = $this->getUser();
if($user){
if ($addmanagementForm->isSubmitted()) {
// dd('OK');
$userId = $user->getId();
$theme = $addmanagementForm->get('theme')->getData();
$slug = $slugger->slug($theme);
$ville = $addmanagementForm->get('ville')->getData();
$prix = $addmanagementForm->get('prix')->getData();
$devise = $addmanagementForm->get('devise')->getData();
$texte = $addmanagementForm->get('texte')->getData();
$debut = $addmanagementForm->get('datedebut')->getData();
$fin = $addmanagementForm->get('datefin')->getData();
if(!$texte){
$description = "...";
}else{
$description = $addmanagementForm->get('texte')->getData();
}
$management = $addmanagementForm->getData();
$imageFile = $addmanagementForm->get('image')->getData();
if ($imageFile) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_management'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$management->setImage($newFilename);
}else{
$management = "no-file";
}
$management->setTheme($theme);
$management->setSlug($slug);
$management->setVille($ville);
$management->setPrix($prix);
$management->setDevise($devise);
$management->setTexte($description);
$management->setDateDebut($debut);
$management->setDateFin($fin);
$management->setAdminsId($userId);
$entityManager->persist($management);
$entityManager->flush();
$this->addFlash(
'success',
'La rencontre a été bien enrégistrée');
return $this->redirectToRoute('admin.managements');
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/show/admin-management.html.twig', [
'managements' => $managements,
'addmanagementForm' => $addmanagementForm->createView(),
]);
}
#[Route('admin/edit/top-management/{slug}', name: 'admin.edit.management', methods:['GET','POST'])]
public function edit_managemente(
$slug,
Request $request,
SluggerInterface $slugger,
EntityManagerInterface $entityManager,
ManagementsRepository $managementRepository
): Response
{
$management = new Managements();
$user = $this->getUser();
$infoman = $managementRepository->findOneBy(array(
'slug' => $slug
));
$editmanagementForm = $this->createForm(EditManagementFormType::class, $infoman);
$editmanagementForm->handleRequest($request);
if($user){
if ($editmanagementForm->isSubmitted()) {
$userId = $user->getId();
$theme = $editmanagementForm->get('theme')->getData();
$slug = $slugger->slug($theme);
$ville = $editmanagementForm->get('ville')->getData();
$prix = $editmanagementForm->get('prix')->getData();
$devise = $editmanagementForm->get('devise')->getData();
$texte = $editmanagementForm->get('texte')->getData();
$debut = $editmanagementForm->get('datedebut')->getData();
$fin = $editmanagementForm->get('datefin')->getData();
$imageFile = $editmanagementForm->get('image')->getData();
if(!$texte){
$description = "...";
}else{
$description = $editmanagementForm->get('texte')->getData();
}
if ($imageFile != null) {
$originalFilename = pathinfo($imageFile->getClientOriginalName(), PATHINFO_FILENAME);
// this is needed to safely include the file name as part of the URL
$safeFilename = $slugger->slug($originalFilename);
$newFilename = $safeFilename.'-'.uniqid().'.'.$imageFile->guessExtension();
try {
$imageFile->move(
$this->getParameter('photo_management'),
$newFilename
);
} catch (FileException $e) {
// ... handle exception if something happens during file upload
}
$infoman->setImage($newFilename);
}
$infoman->setTheme($theme);
$infoman->setSlug($slug);
$infoman->setVille( $ville);
$infoman->setPrix($prix);
$infoman->setDevise($devise);
$infoman->setTexte($description);
$infoman->setDateDebut($debut);
$infoman->setDateFin($fin);
$infoman->setAdminsId($userId);
$entityManager->flush();
$this->addFlash('success','La modification a été bien effectuée');
return $this->redirectToRoute('admin.managements');
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/edit/edit-admin-management.html.twig', [
'infoman' => $infoman,
'editmanagementForm' => $editmanagementForm->createView(),
]);
}
#-----------------SUPPERIMER UN ACTUALITE-----------------------
#[Route('admin/del/top-management/{slug}', name: 'admin.del.management', methods:['GET'])]
public function delete_management(
$slug,
ManagementsRepository $managenentRepository,
EntityManagerInterface $entityManager
){
$select_management = $managenentRepository->findOneBy(array('slug' => $slug));
$entityManager->remove($select_management);
$entityManager->flush();
$this->addFlash(
'danger',
'La rencontre a été bien supprimée');
return $this->redirectToRoute('admin.managements');
}
#[Route('admin/avis-des-clients', name: 'admin.avis-des-clients', methods:['GET','POST'])]
public function avis(
Request $request,
AvisRepository $avisRepository,
EntityManagerInterface $entityManager,
): Response
{
$avis = new Avis();
$Listavis = $avisRepository->findAll();
$user = $this->getUser();
$addavisForm = $this->createForm(AvisFormType::class, $avis);
if ($user) {
$addavisForm = $this->createForm(AvisFormType::class, $avis);
$addavisForm->handleRequest($request);
if($addavisForm->isSubmitted() && $addavisForm->isValid()){
$userId = $user->getId();
$nom = htmlspecialchars($addavisForm->get('nom')->getData());
$fonction = htmlspecialchars($addavisForm->get('titre')->getData());
$note = htmlspecialchars($addavisForm->get('note')->getData());
$statut = htmlspecialchars($addavisForm->get('statut')->getData());
$commentaire = $addavisForm->get('commentaire')->getData();
$avis->setNom($nom);
$avis->setTitre($fonction);
$avis->setNote($note);
$avis->setCommentaire($commentaire);
$avis->setStatut($statut);
$avis->setAdminsId($userId);
$entityManager->persist($avis);
$entityManager->flush();
$this->addFlash('success','Le commentaire à été bien enrégistrer');
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/show/admin-avis-client.html.twig', [
'liste' => $Listavis,
'controller_name' => 'AdminController',
'avisForm' => $addavisForm->createView(),
]);
}
#[Route('admin/edit/avis-des-clients/{id}', name: 'admin.edit.avis-des-clients', methods:['GET','POST'])]
public function edit_avis(
$id,
Request $request,
AvisRepository $avisRepository,
EntityManagerInterface $entityManager,
): Response
{
$avis = new Avis();
$comment = $avisRepository->findOneBy(array('id' => $id));
$editAvisForm = $this->createForm(EditAvisFormType::class, $avis);
$editAvisForm->handleRequest($request);
$users = $this->getUser();
if ($users) {
if($editAvisForm->isSubmitted()){
$userId = $users->getId();
$nom = htmlspecialchars($editAvisForm->get('nom')->getData());
$fonction = htmlspecialchars($editAvisForm->get('titre')->getData());
$note = htmlspecialchars($editAvisForm->get('note')->getData());
$statut = htmlspecialchars($editAvisForm->get('statut')->getData());
$texte = $editAvisForm->get('commentaire')->getData();
$comment->setNom($nom);
$comment->setTitre($fonction);
$comment->setNote($note);
$comment->setCommentaire($texte);
$avis->setStatut($statut);
$comment->setAdminsId($userId);
$entityManager->flush();
$this->addFlash('success','Le commentaire à été bien modifié');
return $this->redirectToRoute('admin.avis-des-clients');
}
}else{
return $this->redirectToRoute('login.connexion');
}
return $this->render('admin/edit/edit-admin-avis.html.twig', [
'infos' => $comment,
'editAvisForm' => $editAvisForm->createView(),
]);
}
#[Route('admin/del/avis-des-clients/{id}', name: 'admin.del.avis-des-clients', methods:['GET'])]
public function delete_avis(
$id,
AvisRepository $avisRepository,
EntityManagerInterface $entityManager
){
$select_avis = $avisRepository->findOneBy(array('id' => $id));
$entityManager->remove($select_avis);
$entityManager->flush();
$this->addFlash(
'danger',
'Le commentaire a été bien supprimé');
return $this->redirectToRoute('admin.avis-des-clients');
}
}

src/Controller/AdminController.php line 1668