Symfony Profiler

<?php
namespace App\Controller\Marches;
use App\Entity\Bureau;
use App\Service\BaseService;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\HttpFoundation\Request;
use Doctrine\ORM\EntityManagerInterface;
use App\Service\ValidateService;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\Serializer\SerializerInterface;
use App\Entity\ModelFichier;
use App\Entity\Fichier;
use App\Entity\DetailFichier;
use App\Entity\InfosDetailFichier;
use App\Entity\Utilisateur;
use App\Entity\Mission;
use App\Entity\DetailMission;
use App\Entity\LogUser;
use Symfony\Component\HttpFoundation\Session\Session;
use App\Entity\Marche;
use App\Entity\Devis;
use App\Entity\DetailDevis;
use App\Entity\Bordereau;
use App\Entity\DetailBord;
use App\Entity\InfosModalBordereau;
use App\Entity\InfosDetailBord;
use App\Entity\InfosModelFichier;
use App\Repository\MissionRepository;
use App\Repository\MarcheRepository;
use App\Repository\UtilisateurRepository;
use Symfony\Component\HttpFoundation\StreamedResponse;
use App\Entity\MouvementStock;
use App\Entity\Piece;
use App\Entity\StockMission;
use App\Entity\StockReception;
use App\Repository\DetailMissionRepository;
use App\Entity\DetailsOptionModel;
use App\Entity\Images;
use Doctrine\DBAL\Connection;
use ZipArchive;
class MissionController extends AbstractController
{
private $conn;
public $baseService;
public function __construct(Connection $conn , BaseService $baseService)
{
$this->conn = $conn;
$this->baseService = $baseService;
}
#[Route('/importationFichier', name: 'importationFichier')]
public function importationFichier(EntityManagerInterface $entityManager,MarcheRepository $marcheRepository): Response
{
$session = new Session;
$response = '';
$chckAccess = $this->baseService->Role(80);
if($chckAccess == 0){
return $this->redirectToRoute('login');
}else if ($chckAccess == 2){
return $this->redirectToRoute('infoUtilisateur');
}
$user = $session->get('user');
$bureauSelected = $session->get('bureauSelected');
$articles = "";
$marche = "";
$bureau= $entityManager->getRepository(Bureau::class)->find($bureauSelected);
if($bureau)
{
$marches = $marcheRepository->getMarchesConfigurer($bureauSelected);
if($marches)
{
// if($marche->getTypeMarc() == 1)
// {
// $dv = $entityManager->getRepository(Devis::class)->find($marche->getIdDevis());
// $articles = $entityManager->getRepository(DetailDevis::class)->findBy(['idDevis'=>$dv->getId()]);
// }
// else
// {
// $dv = $entityManager->getRepository(Bordereau::class)->find($marche->getIdDevis());
// $articles = $entityManager->getRepository(DetailBord::class)->findBy(['idBord'=>$dv->getId()]);
// }
}
}else{
$marches= $entityManager->getRepository(Marche::class)->findBy(array('EtatMarc' => 1));
}
return $this->render('mission/importationFichier.html.twig', [
'controller_name' => 'MissionController',
'articles' => $articles,
'marches' => $marches
]);
}
#[Route('/getColumn/', name: 'getColumn')]
public function getColumn(Request $request,SerializerInterface $serializer)
{
$response="";
if(!empty($_FILES['fichier']['name']))
{
$extensions_valides = array('csv');
$fileName = $_FILES['fichier']['name'];
$extension_upload = strtolower(substr(strrchr($fileName, '.'), 1));
$fileError = $_FILES['fichier']['error'];
$fileTmpLoc = $_FILES['fichier']['tmp_name'];
if ($fileError > 0)
{
$response="Erreur lors du transfert du fichier !!";
} else {
if (in_array($extension_upload, $extensions_valides))
{
$csv = file_get_contents($fileTmpLoc);
$search = ",";
$replace = ".";
$csv = str_replace($search,$replace,$csv);
file_put_contents($fileTmpLoc,$csv);
$csv2 = file_get_contents($fileTmpLoc);
$search2 = "'";
$replace2 = "";
$csv2 = str_replace($search2,$replace2,$csv2);
file_put_contents($fileTmpLoc,$csv2);
if (($handle = fopen($fileTmpLoc, "r")) !== FALSE) {
while (($data = fgetcsv($handle, 1000000, ";")) !== FALSE)
{
break;
}
$exist=false;
$array_unique = array_unique($data);
if (count($data) - count($array_unique))
{
for ($i=0; $i<count($data); $i++)
{
if (!array_key_exists($i, $array_unique))
{
$exist=true;
}
}
}
for ($i=0;$i<count($data);$i++)
{
$data[$i]=str_replace(" ","_",$data[$i]);
if(empty($data[$i]))
{
$exist=true;
}
}
if($exist==true)
{
fclose($handle);
$response="Les entêtes de colonnes doivent être unique et non vides !!";
}
else
{
$dataRows= "<table class='table table-striped table-bordered'>\n\n";
$f = fopen($fileTmpLoc, "r");
$count=0;
while (($line = fgetcsv($f)) !== false) {
if($count==0)
{
$line2=array_map("utf8_encode", $line);
$row = $line2[0]; // We need to get the actual row (it is the first element in a 1-element array)
$cells = explode(";",$row);
$dataRows.= "<tr>";
for($i=0;$i<count($cells);$i++)
{
$cells[$i]=strtoupper(preg_replace('/[^A-Za-z]+/',"", str_replace(" ","",$cells[$i])));
}
}
if($count>0)
{
$row = $line[0]; // We need to get the actual row (it is the first element in a 1-element array)
$cells = explode(";",$row);
$dataRows.= "<tr>";
for($i=0;$i<count($cells);$i++)
{
$cells[$i]=strtoupper(preg_replace('/[^A-Za-z0-9]+/',"", $cells[$i]));
}
}
$row = $line[0]; // We need to get the actual row (it is the first element in a 1-element array)
$cells = explode(";",$row);
$dataRows.= "<tr>";
foreach ($cells as $cell)
{
$dataRows.= "<td>" . htmlspecialchars(utf8_encode($cell)) . "</td>";
}
$dataRows.= "</tr>\n";
$count++;
}
fclose($f);
$dataRows.= "\n</table>";
$data = array_map("utf8_encode", $data );
$json = $serializer->serialize($data, 'json');
return new JsonResponse(array("response" => "success","colonnes"=>$json,"rows"=>$dataRows));
}
}
} else {
$response="Extension de fichier incorrecte, importer un fichier csv SVP !!";
}
}
} else {
$response="Importer un fichier SVP !!";
}
return new Response($response);
}
#[Route('/importFile/', name: 'importFile')]
public function importFileAction(Request $request, EntityManagerInterface $entityManager,ValidateService $validateService)
{
ini_set('memory_limit','-1');
ini_set('memory_size','-1');
ini_set('max_execution_time','-1');
$response = "";
$article = $request->get('article');
$mch = $request->get('marche');
if($_FILES['fichier']['size']<=0)
{
$response="le fichier est vide !!";
}
else
{
$fileError = $_FILES['fichier']['error'];
$fileTmpLoc = $_FILES['fichier']['tmp_name'];
$extensions_valides = array('csv');
$fileName = $_FILES['fichier']['name'];
$extension_upload = strtolower(substr(strrchr($fileName, '.'), 1));
$n = $fileName . date_format(new \DateTime(), "Y-m-dH:i:s");
$nom = sha1($n);
$fileStore = "assets/fichiers/imports/" . $nom . '.' . $extension_upload;
if ($fileError > 0)
{
$response="Erreur lors du transfert du fichier !!";
}
else
{
if (in_array($extension_upload, $extensions_valides))
{
$csv = file_get_contents($fileTmpLoc);
$csv = utf8_encode($csv); // Convert to UTF-8 if needed
$search = ",";
$replace = ".";
$csv = str_replace($search,$replace,$csv);
file_put_contents($fileTmpLoc,$csv);
$csv2 = file_get_contents($fileTmpLoc);
$search2 = "'";
$replace2 = "";
$csv2 = str_replace($search2,$replace2,$csv2);
file_put_contents($fileTmpLoc,$csv2);
if (($handle = fopen($fileTmpLoc, "r")) !== FALSE)
{
while (($data = fgetcsv($handle, 1000000, ";")) !== FALSE)
{
break;
}
$exist=false;
$array_unique = array_unique($data);
if (count($data) - count($array_unique))
{
for ($i=0; $i<count($data); $i++)
{
if (!array_key_exists($i, $array_unique))
{
$exist=true;
}
}
}
for ($i=0;$i<count($data);$i++)
{
$data[$i]=str_replace(" ","_",$data[$i]);
if(empty($data[$i]))
{
$exist=true;
}
}
if($exist==true)
{
fclose($handle);
$response="Les entêtes de colonnes doivent être unique et non vides !!";
}
else
{
$marche = $entityManager->getRepository(Marche::class)->find($mch);
if($marche->getTypeMarc() == 1)
{
$art = $entityManager->getRepository(DetailDevis::class)->find($article);
}
else
{
$art = $entityManager->getRepository(DetailBord::class)->find($article);
}
$infosModel = $entityManager->getRepository(InfosModelFichier::class)->findByIdModal($art->getIdModalFich());
$check = 0;
for ($i = 0; $i < count($data); $i++) {
// Check if the key exists in $infosModel before accessing it
// $data[$i]=str_replace(" ","_",$data[$i]);
if (array_key_exists($i, $infosModel) && $data[$i] != $infosModel[$i]->getNomInfo()) {
$check++;
}
}
if($check > 0)
{
$response="Le format de fichier ne correspond pas au format de fichier habituel pour cet article !!";
}
else
{
$fichier = new Fichier();
$fichier->setIdModal($art->getIdModalFich());
$fichier->setIdMarche($mch);
$fichier->setNomFich($fileName);
$fichier->setDateCreation(new \DateTime());
$fichier->setEtatFich(0);
$fichier->setUrlFich($fileStore);
$entityManager->persist($fichier);
$entityManager->flush();
$f = fopen($fileTmpLoc, "r");
$count = 0;
while (($line = fgetcsv($f, 1000000, ";")) !== false) {
if ($count > 0) {
// Example: Create a DetailsFichier entity for each data row
/*$detailsFichier = new DetailFichier();
$detailsFichier->setIdFichier($fichier->getId()); // Associate with the parent Fichier
$detailsFichier->setIdModal($fichier->getIdModal()); // Associate with the parent Fichier
$detailsFichier->setNumeDeta($fichier->getIdModal().''.$count); // Associate with the parent Fichier
$detailsFichier->setEtatDeta(0); // Associate with the parent Fichier
$detailsFichier->setIdDetailBord($article); // Associate with the parent Fichier
$entityManager->persist($detailsFichier);
$entityManager->flush();*/
$sql='
INSERT INTO `detail_fichier`( `id_modal`, `id_fichier`, `nume_deta`, `etat_deta`, `id_detail_bord`) VALUES
(:id_modal, :id_fichier, :nume_deta, :etat_deta, :id_detail_bord)
';
$stmt = $this->conn->prepare($sql);
$stmt->bindValue(":id_modal",$fichier->getIdModal());
$stmt->bindValue(":id_fichier",$fichier->getId());
$stmt->bindValue(":nume_deta",$fichier->getIdModal().''.$count);
$stmt->bindValue(":etat_deta",0);
$stmt->bindValue(":id_detail_bord",$article);
$stmt = $stmt->executeQuery();
$sql2 = 'SELECT max(t.id) from detail_fichier t';
$stmt = $this->conn->prepare($sql2);
$maxDetailsFichier = $stmt->executeQuery()->fetchOne();
$row = $line; // Use $line directly, as it is an array of cells
for ($i = 0; $i < count($row); $i++) {
// $infosdetail = new InfosDetailFichier();
// $infosdetail->setIdFichier($fichier->getId());
// $infosdetail->setIdDetail($maxDetailsFichier);
// $infosdetail->setIdInfo($infosModel[$i]->getId());
// $infosdetail->setValueInfo($row[$i]);
// $entityManager->persist($infosdetail);
// $entityManager->flush();
$sql3='
INSERT INTO `infos_detail_fichier`( `id_detail`, `id_fichier`, `id_info`, `value_info`)
VALUES (:id_detail,:id_fichier,:id_info,:value_info)
';
$stmt = $this->conn->prepare($sql3);
$stmt->bindValue(":id_detail",$maxDetailsFichier);
$stmt->bindValue(":id_fichier",$fichier->getId());
$stmt->bindValue(":id_info",$infosModel[$i]->getId());
$stmt->bindValue(":value_info",$row[$i]);
$stmt = $stmt->executeQuery();
}
}
$count++;
}
move_uploaded_file($fileTmpLoc, $fileStore);
fclose($f);
$entityManager->flush();
$response = 'ok';
}
}
}
}
else
{
$response="Extension de fichier incorrecte, importer un fichier csv SVP !!";
}
}
}
return new Response($response);
}
#[Route('/listFichiers', name: 'listFichiers')]
public function listFichiers(Request $request, EntityManagerInterface $entityManager,MarcheRepository $marcheRepository): Response
{
$chckAccess = $this->baseService->Role(81);
if($chckAccess == 0){
return $this->redirectToRoute('login');
}else if ($chckAccess == 2){
return $this->redirectToRoute('infoUtilisateur');
}
$session = new Session;
$bureauSelected = $session->get('bureauSelected');
$images = -1;
$idImage = [];
if($bureauSelected != 0)
{
$marches = $marcheRepository->getMarches($bureauSelected);
$marchIds = array_map(function ($marche) {
return $marche->getId();
}, $marches);
// Retrieve all fichiers associated with any of the marches
$fichiers = $entityManager->getRepository(Fichier::class)->findByIdMarche($marchIds);
foreach ($fichiers as $fichier) {
$idFichier = $fichier->getId();
$images = $entityManager->getRepository(Images::class)->findByIdFichier($idFichier);
foreach ($images as $image) {
$idImage[] = $image->getIdFichier();
}
}
}
else
{
$fichiers = $entityManager->getRepository(Fichier::class)->findAll();
foreach ($fichiers as $fichier) {
$idFichier = $fichier->getId();
$images = $entityManager->getRepository(Images::class)->findByIdFichier($idFichier);
foreach ($images as $image) {
$idImage[] = $image->getIdFichier();
}
}
}
return $this->render('mission/listFichiers.html.twig', [
'controller_name' => 'MissionController',
'fichiers' => $fichiers,
'images' => $idImage
]);
}
#[Route('/deleteFichier/{id}/', name: 'deleteFichier')]
public function deleteFichier(Request $request, EntityManagerInterface $entityManager,$id): Response
{
ini_set('memory_limit','-1');
ini_set('memory_size','-1');
ini_set('max_execution_time','-1');
$response = "";
$chckAccess = $this->baseService->Role(115);
if($chckAccess == 0){
$response = "Vous n'avez pas accès à cette opération";
}else if ($chckAccess == 2){
$response = "Vous n'avez pas accès à cette opération";
}
if($response == ""){
$fichier = $entityManager->getRepository(Fichier::class)->find($id);
if (!$fichier)
{
$response = 'Desolé, ce fichier est introuvable !';
}
else
{
$details = $entityManager->getRepository(DetailFichier::class)->findByIdFichier($id);
foreach($details as $detail)
{
$entityManager->remove($detail);
}
$infos = $entityManager->getRepository(InfosDetailFichier::class)->findByIdFichier($id);
foreach($infos as $info)
{
$entityManager->remove($info);
}
// Remove the utilisateur
$entityManager->remove($fichier);
$entityManager->flush();
$response = "ok";
}
}
return new Response($response);
}
#[Route('/exporterFichier/{id}/', name: 'exporterFichier')]
public function exporterFichier(Request $request, EntityManagerInterface $entityManager, SerializerInterface $serializer ,$id): Response
{
$response = "";
$chckAccess = $this->baseService->Role(116);
if($chckAccess == 0){
$response = "Vous n'avez pas accès à cette opération";
}else if ($chckAccess == 2){
$response = "Vous n'avez pas accès à cette opération";
}
if( $response == ""){
$fichier = $entityManager->getRepository(Fichier::class)->find($id);
$details = $entityManager->getRepository(DetailFichier::class)->findByIdFichier($id);
$modal = $entityManager->getRepository(ModelFichier::class)->find($fichier->getIdModal());
$infoModal = $entityManager->getRepository(InfosModelFichier::class)->findByIdModal($modal->getId());
$response = new StreamedResponse();
$response->setCallback(function () use ($fichier , $entityManager,$details,$infoModal) {
$handle = fopen('php://output', 'w+');
$entite =array();
if ($infoModal !== null) {
for ($i = 0; $i < count($infoModal); $i++) {
$entite[$i] = $infoModal[$i]->getNomInfo();
}
$entite[count($infoModal)+1] = 'LATTITUDE';
$entite[count($infoModal)+2] = 'LONGTITUDE';
}
fputcsv($handle,$entite, ';');
for($j=0;$j<count($details);$j++) {
$value = $entityManager->getRepository(InfosDetailFichier::class)->findByIdDetail($details[$j]->getId());
$values = array();
for ($k=0; $k < count($value); $k++) {
$values[$k]= $value[$k]->getValueInfo();
}
$values[count($value)+1]= $details[$j]->getLatitude();
$values[count($value)+2]= $details[$j]->getLongitude();;
fputcsv($handle, $values, ';');
}
fclose($handle);
});
$filename = ''.$fichier->getNomFich().'.csv'; // Specify the filename with the extension
$response->setStatusCode(200);
$response->headers->set('Content-Type', 'text/csv; charset=utf-8');
$response->headers->set('Content-Disposition', 'attachment; filename="' . $filename . '"');
}
return $response;
}
#[Route('/exporterImage/{id}', name: 'exporter_image')]
public function exporterImage(Request $request, EntityManagerInterface $entityManager, $id): Response
{
// 🔹 Récupérer les images liées au fichier
$images = $entityManager->getRepository(Images::class)->findByIdFichier($id);
if (!$images || count($images) === 0) {
return new Response("Aucune image trouvée pour ce fichier.", Response::HTTP_NOT_FOUND);
}
// 🔹 Créer un dossier temporaire pour le ZIP
$tempDir = sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'temp_zip';
if (!file_exists($tempDir)) {
mkdir($tempDir, 0777, true);
}
// 🔹 Nom unique du fichier ZIP
$zipFilePath = $tempDir . DIRECTORY_SEPARATOR . 'images_' . uniqid() . '.zip';
$zip = new \ZipArchive();
if ($zip->open($zipFilePath, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) !== true) {
return new Response("Erreur lors de la création du fichier ZIP.", Response::HTTP_INTERNAL_SERVER_ERROR);
}
$added = false;
$projectDir = $this->getParameter('kernel.project_dir');
// 🔹 Ajouter chaque image au ZIP
foreach ($images as $image) {
$relativePath = $image->getUrlImage(); // ex: /assets/imagesMissions/xxxx.jpg
// Enlever le premier slash et construire le chemin absolu
$absolutePath = $projectDir . '/public' . $relativePath;
if (file_exists($absolutePath)) {
$zip->addFile($absolutePath, basename($absolutePath));
$added = true;
} else {
// (optionnel) Pour debug :
// dump("Fichier introuvable : " . $absolutePath);
}
}
$zip->close();
if (!$added || !file_exists($zipFilePath)) {
return new Response("Aucune image valide trouvée à compresser.", Response::HTTP_NOT_FOUND);
}
// 🔹 Créer la réponse avec le contenu ZIP
$response = new Response(file_get_contents($zipFilePath));
$response->headers->set('Content-Type', 'application/zip');
$response->headers->set('Content-Disposition', 'attachment; filename="images.zip"');
$response->headers->set('Content-Length', filesize($zipFilePath));
// 🔹 Supprimer le ZIP après téléchargement (sécurisé)
register_shutdown_function(static function () use ($zipFilePath) {
if (file_exists($zipFilePath)) {
@unlink($zipFilePath);
}
});
return $response;
}
#[Route('/addMission', name: 'addMission')]
public function addMission(Request $request, EntityManagerInterface $entityManager,ValidateService $validateService,
MarcheRepository $marcheRepository, MissionRepository $missionRepo, DetailMissionRepository $detailMissionRepo,BaseService $baseService): Response
{
$chckAccess = $this->baseService->Role(117);
if($chckAccess == 0){
return $this->redirectToRoute('login');
}else if ($chckAccess == 2){
return $this->redirectToRoute('infoUtilisateur');
}
$session = new Session;
$bureau = $session->get('bureauSelected');
$response = "";
$id=$request->get('id');
$agent=$request->get('idAgent');
$IdArticle = 0;
$idMarcher = 0;
if($id != null)
{
$from = 1;
$fichier = $entityManager->getRepository(Fichier::class)->findOneById($id);
$IdArticle = $fichier->getIdModal();
$idMarcher = $fichier->getIdMarche();
}
else
{
$from = 2;
}
if(!$agent && !$id){
$from = 3;
$id = $request->get('fichiers');
}
$bureauSelected = $session->get('bureauSelected');
if($bureauSelected == 0)
{
$marches = $entityManager->getRepository(Marche::class)->findAll();
}
else
{
$marches = $marcheRepository->getMarches($bureauSelected);
//$marches = $entityManager->getRepository(Marche::class)->findByIdBure($bureauSelected);
}
if($bureau != 0)
{
$marches = $marcheRepository->getMarches($bureau);
$marchIds = array_map(function ($marche) {
return $marche->getId();
}, $marches);
// Retrieve all fichiers associated with any of the marches
$fichiers = $entityManager->getRepository(Fichier::class)->findByIdMarche($marchIds);
}
else
{
$fichiers = $entityManager->getRepository(Fichier::class)->findAll();
$fichiers = $marcheRepository->getFichierConfigurer();
}
$fichier = $entityManager->getRepository(Fichier::class)->findOneById($id);
if($request->getMethod()=='POST')
{
$selected = $request->get('selected');
$agent = $request->get('agents');
$titre=$request->get('titre');
if($selected == null)
{
$response = "veuillez selectionner";
}
else
{
$marche = $entityManager->getRepository(Marche::class)->findOneById($fichier->getIdMarche());
$numero = $missionRepo->getNumero($fichier->getIdMarche());
$agentDetail = $entityManager->getRepository(Utilisateur::class)->findOneById($agent);
$mission = new Mission();
$mission->setIdFichier($id);
$mission->setIdAgent($agent);
$mission->setEtatMiss(0);
$mission->setTitre($titre);
$mission->setIdMarche($fichier->getIdMarche());
// $mission->setDateDebut(new \DateTime());
// $mission->setDateFin(new \DateTime());
$mission->setDateCreation(new \DateTime());
$mission->setNumeMiss($numero);
$entityManager->persist($mission);
$entityManager->flush();
$text = 'Veuillez consulter votre mission affectée';
$baseService->addNotifications($text , 2 , $mission->getId() , $agent,0);
for($i=0;$i<count($selected);$i++)
{
$detail_fichier = $entityManager->getRepository(DetailFichier::class)->find($selected[$i]);
$detail_fichier->setEtatDeta(1);
$detailNum = $detailMissionRepo->getNumero($detail_fichier->getIdDetailBord());
$detail = new DetailMission();
$detail->setIdMission($mission->getId());
$detail->setIdDetail($selected[$i]);
$detail->setEtatDeta(0);
$detail->setNumeDeta($detailNum);
$refeDeta = 'REF' . str_pad($detailNum, 10, '0', STR_PAD_LEFT);
$detail->setRefeDeta($refeDeta);
$detail->setIdDetailBord($detail_fichier->getIdDetailBord());
//$mission->setIdMarche(0);
$detail->setDateCreation(new \DateTime());
$detail->setTypeMarc($marche->getTypeMarc());
$entityManager->persist($detail);
$entityManager->flush();
//Update date fille
$sql='UPDATE `infos_detail_fichier` d SET d.`value_info`=:value where d.id_detail = :idDetail and d.id_info in (select i.id from infos_model_fichier i where i.type_info = :idInfo) ';
$stmt = $this->conn->prepare($sql);
$stmt->bindValue(":idDetail",$selected[$i]);
$stmt->bindValue(":value",$agent);
$stmt->bindValue(":idInfo",9);
$stmt = $stmt->executeQuery();
$sql='UPDATE `infos_detail_fichier` d SET d.`value_info`=:value where d.id_detail = :idDetail and d.id_info in (select i.id from infos_model_fichier i where i.type_info = :idInfo) ';
$stmt = $this->conn->prepare($sql);
$stmt->bindValue(":idDetail",$selected[$i]);
$stmt->bindValue(":value",'"'.$agentDetail->getNomUtil()." ".$agentDetail->getPrenUtil().'"');
$stmt->bindValue(":idInfo",10);
$stmt = $stmt->executeQuery();
}
if($marche->getTypeMarc() == 1)
{
$article = $entityManager->getRepository(DetailDevis::class)->find($detail_fichier->getIdDetailBord());
}
else
{
$article = $entityManager->getRepository(DetailBord::class)->find($detail_fichier->getIdDetailBord());
}
if($article)
{
if($marche->getTypeMarc() == 1)
{
$code = $article->getDescDetDev();
}
else
{
$code = $article->getObjet();
}
$image = $article->getIconArti();
if($article->getCodeArti() != null && $article->getCodeArti() != "")
{
$mission->setCodeArti($article->getCodeArti());
}
else
{
$mission->setCodeArti($code);
}
$mission->setImagArti($image);
}
$fichier->setEtatFich(1);
$entityManager->flush();
$response = "ok";
}
}
return $this->render('mission/addMission.html.twig', [
'controller_name' => 'MissionController',
'response' => $response,
'fichiers' => $fichiers,
'idFichier' => $id,
'agent' => $agent,
'fromIn' => $from,
'marches' => $marches,
'IdArticle' => $IdArticle,
'idMarcher' => $idMarcher
]);
}
#[Route('/addMissionByCarte', name: 'addMissionByCarte')]
public function addMissionByCarte(Request $request, EntityManagerInterface $entityManager,ValidateService $validateService,
MarcheRepository $marcheRepository, MissionRepository $missionRepo, DetailMissionRepository $detailMissionRepo): Response
{
$chckAccess = $this->baseService->Role(117);
if($chckAccess == 0){
return $this->redirectToRoute('login');
}else if ($chckAccess == 2){
return $this->redirectToRoute('infoUtilisateur');
}
$session = new Session;
$bureau = $session->get('bureauSelected');
$response = "";
$idFile = $request->get('idFile');
$idAgent = $request->get('agent');
$file = $entityManager->getRepository(Fichier::class)->find($idFile);
$marche = $entityManager->getRepository(Marche::class)->find($file->getIdMarche());
$agent = $entityManager->getRepository(Utilisateur::class)->find($idAgent);
$detail = $entityManager->getRepository(DetailFichier::class)->findBy(['idFichier'=>$idFile]);
if($request->getMethod()=='POST')
{
$selected = $request->get('checkboxvar');
$agent = $request->get('agents');
$titre = $request->get('titre');
if($selected == null)
{
$response = "Veuillez selectionner !";
}
else
{
$numero = $missionRepo->getNumero($file->getIdMarche());
$mission = new Mission();
$mission->setIdFichier($idFile);
$mission->setIdAgent($idAgent);
$mission->setEtatMiss(0);
$mission->setTitre($titre);
$mission->setIdMarche($file->getIdMarche());
// $mission->setDateDebut(new \DateTime());
// $mission->setDateFin(new \DateTime());
$mission->setDateCreation(new \DateTime());
$mission->setNumeMiss($numero);
$entityManager->persist($mission);
$entityManager->flush();
for($i=0;$i<count($selected);$i++)
{
$detail_fichier = $entityManager->getRepository(DetailFichier::class)->find($selected[$i]);
$detail_fichier->setEtatDeta(1);
$detailNum = $detailMissionRepo->getNumero($detail_fichier->getIdDetailBord());
$detail = new DetailMission();
$detail->setIdMission($mission->getId());
$detail->setIdDetail($selected[$i]);
$detail->setEtatDeta(0);
$detail->setNumeDeta($detailNum);
$refeDeta = 'REF' . str_pad($detailNum, 10, '0', STR_PAD_LEFT);
$detail->setRefeDeta($refeDeta);
$detail->setIdDetailBord($detail_fichier->getIdDetailBord());
//$mission->setIdMarche(0);
$detail->setDateCreation(new \DateTime());
$detail->setTypeMarc($marche->getTypeMarc());
$entityManager->persist($detail);
$entityManager->flush();
}
if($marche->getTypeMarc() == 1)
{
$article = $entityManager->getRepository(DetailDevis::class)->find($detail_fichier->getIdDetailBord());
}
else
{
$article = $entityManager->getRepository(DetailBord::class)->find($detail_fichier->getIdDetailBord());
}
if($article)
{
$mission->setCodeArti($article->getCodeArti());
$mission->setImagArti($article->getIconArti());
}
$file->setEtatFich(1);
$entityManager->flush();
$response = "ok";
}
}
return $this->render('mission/addMissionByCarte.html.twig', [
'controller_name' => 'MissionController',
'idFile'=>$idFile,
'idAgent'=>$idAgent,
'detail'=>$detail
// 'response' => $response,
// 'fichiers' => $fichiers,
// 'idFichier' => $id,
// 'agent' => $agent,
// 'fromIn' => $from
]);
}
#[Route('/ajaxAddMissions', name: 'ajaxAddMissions')]
public function ajaxAddBonCommande(Request $request, EntityManagerInterface $entityManager, MarcheRepository $marcheRepository ,SerializerInterface $serializer,
ValidateService $validateService): Response
{
$session = new Session;
$user = $session->get('user');
$response = "";
$id=$request->get('id');
$response = "ok";
return new Response($response);
}
#[Route('/getFichierDetails/{id}/', name: 'getFichierDetails')]
public function getFichierDetails(Request $request, EntityManagerInterface $entityManager, SerializerInterface $serializer,$id): Response
{
ini_set('memory_limit','-1');
ini_set('memory_size','-1');
ini_set('max_execution_time','-1');
$response = "";
$fichier = $entityManager->getRepository(Fichier::class)->find($id);
if (!$fichier)
{
$response = 'Desolé, ce fichier est introuvable !';
}
else
{
$dataToSend = [];
$details = $entityManager->getRepository(DetailFichier::class)->findByIdFichier($id);
$modal = $entityManager->getRepository(ModelFichier::class)->find($fichier->getIdModal());
$infoModal = $entityManager->getRepository(InfosModelFichier::class)->findByIdModal($modal->getId());
$dataToSend[0] = $infoModal;
$dts = [];
for($i=0;$i<count($details);$i++) {
$query = "SELECT *
FROM infos_detail_fichier idf
WHERE idf.id_detail = :idDetail";
$stmt = $this->conn->prepare($query);
// $stmt->bindValue(":id",$id);
$stmt->bindValue(":idDetail",$details[$i]->getId());
$stmt = $stmt->executeQuery();
$liste_groupe = $stmt->fetchAll();
$dts[$i]["infosDetailFichier"] = $liste_groupe;
$dts[$i]["etat"] = $details[$i]->getEtatDeta();
$dts[$i]["idDetail"] = $details[$i]->getId();
}
$dataToSend[1] = $dts;
}
$detailsFichier = array_values($dataToSend);
$detailsJson = $serializer->serialize($detailsFichier, 'json');
return new JsonResponse($detailsJson, 200, [], true);
}
#[Route('/getFichierDetailsForCarte/{id}/', name: 'getFichierDetailsForCarte')]
public function getFichierDetailsForCarte(Request $request, EntityManagerInterface $entityManager, SerializerInterface $serializer,$id): Response
{
ini_set('memory_limit','-1');
ini_set('memory_size','-1');
ini_set('max_execution_time','-1');
$response = "";
$fichier = $entityManager->getRepository(Fichier::class)->find($id);
if (!$fichier)
{
$response = 'Desolé, ce fichier est introuvable !';
}
else
{
$dataToSend = [];
$details = $entityManager->getRepository(DetailFichier::class)->findByIdFichier($id);
$modal = $entityManager->getRepository(ModelFichier::class)->find($fichier->getIdModal());
$infoModal = $entityManager->getRepository(InfosModelFichier::class)->findByIdModal($modal->getId());
$dataToSend[0] = $infoModal;
$dts = [];
$marche = $entityManager->getRepository(Marche::class)->findOneById($fichier->getIdMarche());
$type = $marche->getTypeMarc();
for($i=0;$i<count($details);$i++) {
$query = "SELECT *
FROM infos_detail_fichier idf
WHERE idf.id_detail = :idDetail";
$stmt = $this->conn->prepare($query);
// $stmt->bindValue(":id",$id);
$stmt->bindValue(":idDetail",$details[$i]->getId());
$stmt = $stmt->executeQuery();
$liste_groupe = $stmt->fetchAll();
$dts[$i]["infosDetailFichier"] = $liste_groupe;
$dts[$i]["etat"] = $details[$i]->getEtatDeta();
$dts[$i]["idDetail"] = $details[$i]->getId();
$dts[$i]["longitude"] = $details[$i]->getLongitude();
$dts[$i]["latitude"] = $details[$i]->getLatitude();
if($type == 1){
$detailBord = $entityManager->getRepository(DetailDevis::class)->find($details[$i]->getIdDetailBord());
$dts[$i]["reference"] = $detailBord->getDescDetDev().'-'.$details[$i]->getId();
}else{
$detailBord = $entityManager->getRepository(DetailBord::class)->find($details[$i]->getIdDetailBord());
$dts[$i]["reference"] = $detailBord->getObjet().'-'.$details[$i]->getId();
}
}
$dataToSend[1] = $dts;
}
$detailsFichier = array_values($dataToSend);
$detailsJson = $serializer->serialize($detailsFichier, 'json');
return new JsonResponse($detailsJson, 200, [], true);
}
#[Route('/listMissions', name: 'listMissions')]
public function listMissions(Request $request, EntityManagerInterface $entityManager, MissionRepository $missionsRepo, UtilisateurRepository $userRepository, MarcheRepository $marcheRepository): Response
{
$chckAccess = $this->baseService->Role(82);
if($chckAccess == 0){
return $this->redirectToRoute('login');
}else if ($chckAccess == 2){
return $this->redirectToRoute('infoUtilisateur');
}
$session = new Session;
$bureauSelected = $session->get('bureauSelected');
$missionsEnAttente = $missionsRepo->getMissionsEnCours(0);
$missionsEncours = $missionsRepo->getMissionsEnCours(1);
if($bureauSelected != 0)
{
$users = $userRepository->getBureauUsers($bureauSelected);
}
else
{
$users = $entityManager->getRepository(Utilisateur::class)->findAll();
}
$years = [];
$yearsDebut = 2023;
$yearsFin = (new \DateTime())->format('Y');
for ($i = $yearsDebut; $i <= $yearsFin; $i++) {
$years[] = $i;
}
$myYear = $request->get('year');
if($myYear)
{
$yearSelect = $myYear;
}
else
{
$yearSelect = $yearsFin;
}
$months = [];
for ($i = 1; $i <= 12; $i++) {
$monthNumber = $i;
$monthNameFrench = '';
// Assign French month names based on the numeric representation
switch ($i) {
case 1:
$monthNameFrench = 'Janvier';
break;
case 2:
$monthNameFrench = 'Février';
break;
case 3:
$monthNameFrench = 'Mars';
break;
case 4:
$monthNameFrench = 'Avril';
break;
case 5:
$monthNameFrench = 'Mai';
break;
case 6:
$monthNameFrench = 'Juin';
break;
case 7:
$monthNameFrench = 'Juillet';
break;
case 8:
$monthNameFrench = 'Août';
break;
case 9:
$monthNameFrench = 'Septembre';
break;
case 10:
$monthNameFrench = 'Octobre';
break;
case 11:
$monthNameFrench = 'Novembre';
break;
case 12:
$monthNameFrench = 'Décembre';
break;
}
$months[] = ['number' => $monthNumber, 'name' => $monthNameFrench];
}
/***********Marche***********/
$bureauSelected = $session->get('bureauSelected');
if($bureauSelected == 0)
{
$marches = $entityManager->getRepository(Marche::class)->findAll();
}
else
{
$marches = $marcheRepository->getMarches($bureauSelected);
}
return $this->render('mission/listMissions.html.twig', [
'controller_name' => 'MissionController',
'missions' => $missionsEncours,
'yearSelect' => $yearSelect ,
"years"=>$years,
'months'=>$months,
'users' => $users,
'marches'=>$marches,
'missionsEnAttente' => $missionsEnAttente
]);
}
/********Mission by marché********/
#[Route('/missions/by-marche', name: 'missions_by_marche', methods: ['GET'])]
public function missionsByMarche(Request $request, MissionRepository $missionsRepo): JsonResponse
{
$marcheId = $request->query->get('marcheId');
if ($marcheId == 0) {
$missions = $missionsRepo->getMissionsEnCours(1);
} else {
$missions = $missionsRepo->getMissionsByMr(1,$marcheId);
}
$data = [];
foreach ($missions as $m) {
$dateDebut = isset($m['date_debut']) ? new \DateTime($m['date_debut']) : null;
$dateFin = isset($m['date_fin']) ? new \DateTime($m['date_fin']) : null;
$data[] = [
'id' => $m['id'],
'fichierNom' => $m['fichier']['nom_fich'] ?? '',
'titre' => $m['titre'] ?? '',
'nume_miss' => $m['nume_miss'] ?? '',
'agentNom' => ($m['agent']['nom_util'] ?? '') . ' ' . ($m['agent']['pren_util'] ?? ''),
'date_debut' => $dateDebut ? $dateDebut->format('Y-m-d') : "",
'date_fin' => $dateFin ? $dateFin->format('Y-m-d') : "",
'etat_miss' => $m['etat_miss'] ?? null,
];
}
return $this->json($data);
}
/****************************/
#[Route('/updateMission', name: 'updateMission')]
public function updateMission(Request $request, EntityManagerInterface $entityManager,ValidateService $validateService,
MissionRepository $missionRepo, DetailMissionRepository $detailMissionRepo): Response
{
$chckAccess = $this->baseService->Role(84);
if($chckAccess == 0){
return $this->redirectToRoute('login');
}else if ($chckAccess == 2){
return $this->redirectToRoute('infoUtilisateur');
}
$response = "";
$idMission=$request->get('id');
$mission = $entityManager->getRepository(Mission::class)->find($idMission);
$detailMissions = $entityManager->getRepository(DetailMission::class)->findBy(['idMission'=>$idMission]);
if($mission){
$fichiers = $entityManager->getRepository(Fichier::class)->findAll();
$idFichier=$mission->getIdFichier();
if($request->getMethod()=='POST')
{
$selected = $request->get('selected');
$agent = $request->get('agents');
$titre = $request->get('titre');
$mission->setTitre($titre);
$entityManager->persist($mission);
$entityManager->flush();
if($selected == null)
{
$response = "veuillez selectionner";
}
else
{
$mission->setIdAgent($agent);
$missionRepo->miseAjourDt($idMission);
$idMarche = $detailMissions[0]->getTypeMarc();
foreach($detailMissions as $dm)
{
$entityManager->remove($dm);
}
for($i=0;$i<count($selected);$i++)
{
$detail_fichier = $entityManager->getRepository(DetailFichier::class)->find($selected[$i]);
$detail_fichier->setEtatDeta(1);
$detailNum = $detailMissionRepo->getNumero($detail_fichier->getIdDetailBord());
$detail = new DetailMission();
$detail->setIdMission($idMission);
$detail->setIdDetail($selected[$i]);
$detail->setEtatDeta(0);
$detail->setNumeDeta($detailNum);
$refeDeta = 'REF' . str_pad($detailNum, 10, '0', STR_PAD_LEFT);
$detail->setRefeDeta($refeDeta);
$detail->setIdDetailBord($detail_fichier->getIdDetailBord());
//$mission->setIdMarche(0);
$detail->setDateCreation(new \DateTime());
$detail->setTypeMarc($idMarche);
$entityManager->persist($detail);
$entityManager->flush();
}
$entityManager->flush();
$response = "ok";
return $this->redirect('/listMissions');
}
}
}
else
{
return $this->redirect('/listMissions');
}
return $this->render('mission/updateMission.html.twig', [
'controller_name' => 'MissionController',
'response' => $response,
'fichiers' => $fichiers,
'idFichier' => $idFichier,
'mission' => $mission,
'idMission'=>$idMission,
'agentSelected'=>$mission->getIdAgent(),
'detailMissions' => $detailMissions
]);
}
#[Route('/updateMissionByCarte', name: 'updateMissionByCarte')]
public function updateMissionByCarte(Request $request, EntityManagerInterface $entityManager,ValidateService $validateService,MissionRepository $missionRepo): Response
{
$response = "";
$chckAccess = $this->baseService->Role(84);
if($chckAccess == 0){
return $this->redirectToRoute('login');
}else if ($chckAccess == 2){
return $this->redirectToRoute('infoUtilisateur');
}
$idMission=$request->get('id');
$mission = $entityManager->getRepository(Mission::class)->find($idMission);
$detailMissions = $entityManager->getRepository(DetailMission::class)->findBy(['idMission'=>$idMission]);
if($mission){
$fichiers = $entityManager->getRepository(Fichier::class)->findAll();
$idFichier=$mission->getIdFichier();
$detail = $entityManager->getRepository(DetailFichier::class)->findBy(['idFichier'=>$idFichier]);
if($request->getMethod()=='POST')
{
$selected = $request->get('selected');
$agent = $request->get('agents');
if($selected == null)
{
$response = "veuillez selectionner !!";
}
else
{
// $mission = new Mission();
// $mission->setIdFichier($idFichier);
$mission->setIdAgent($agent);
// $mission->setEtatMiss(0);
// $mission->setIdMarche(0);
// $mission->setDateDebut(new \DateTime());
// $mission->setDateFin(new \DateTime());
// $mission->setDateCreation(new \DateTime());
// $mission->setNumeMiss(1);
// $entityManager->persist($mission);
// $entityManager->flush();
// $detailsFichierSelected = $entityManager->getRepository(DetailFichier::class)->find($selected[$i]);
$missionRepo->miseAjourDt($idMission);
$idMarche = $detailMissions[0]->getTypeMarc();
foreach($detailMissions as $dm)
{
$entityManager->remove($dm);
}
for($i=0;$i<count($selected);$i++)
{
$detail_fichier = $entityManager->getRepository(DetailFichier::class)->find($selected[$i]);
$detail_fichier->setEtatDeta(1);
$detail = new DetailMission();
$detail->setIdMission($idMission);
$detail->setIdDetail($selected[$i]);
$detail->setEtatDeta(0);
$detail->setIdDetailBord($detail_fichier->getIdDetailBord());
//$mission->setIdMarche(0);
$detail->setDateCreation(new \DateTime());
$detail->setTypeMarc($idMarche);
$entityManager->persist($detail);
}
$entityManager->flush();
$response = "ok";
return $this->redirect('/listMissions');
}
}
}else{
return $this->redirect('/listMissions');
}
return $this->render('mission/updateMissionByCarte.html.twig', [
'controller_name' => 'MissionController',
'response' => $response,
'fichiers' => $fichiers,
'idFichier' => $idFichier,
'idMission'=>$idMission,
'agentSelected'=>$mission->getIdAgent(),
'detailMissions' => $detailMissions,
'idAgent'=>$mission->getIdAgent(),
'idFile'=>$idFichier,
'detail'=>$detail
]);
}
#[Route('/updateTitreMission', name: 'update_titre_mission', methods: ['POST'])]
public function updateTitreMission(Request $request, EntityManagerInterface $entityManager): Response
{
$idMission = $request->request->get('id');
$nouveauTitre = $request->request->get('titre');
if (!$idMission || !$nouveauTitre) {
$this->addFlash('error', 'ID ou titre manquant.');
return $this->redirectToRoute('showMission', ['id' => $idMission]);
}
$mission = $entityManager->getRepository(Mission::class)->find($idMission);
if (!$mission) {
$this->addFlash('error', 'Mission non trouvée.');
return $this->redirectToRoute('listMissions');
}
$mission->setTitre($nouveauTitre);
$entityManager->flush();
$this->addFlash('success', 'Titre mis à jour avec succès.');
return $this->redirectToRoute('showMission', ['id' => $idMission]);
}
#[Route('/liste_missions_terminee', name: 'liste_missions_terminee')]
public function listMissionsTerminee(Request $request, EntityManagerInterface $entityManager , MissionRepository $missionsRepo): Response
{
$chckAccess = $this->baseService->Role(82);
if($chckAccess == 0){
return $this->redirectToRoute('login');
}else if ($chckAccess == 2){
return $this->redirectToRoute('infoUtilisateur');
}
$month = $request->get('month');
$year = $request->get('year');
// Create a DateTime object for the first day of the specified month and year
$firstDay = new \DateTime("$year-$month-01");
// Get the last day of the month by modifying the first day
$lastDay = clone $firstDay;
$lastDay->modify('last day of this month');
$date_debut = $firstDay->format('Y-m-d') ;
$date_fin = $lastDay->format('Y-m-d');
$missions = $missionsRepo->getMissionsByDate(2,$date_debut , $date_fin);
return $this->render('mission/liste_missions_terminee.html.twig', [
'controller_name' => 'MissionController',
'missions'=>$missions
]);
}
#[Route('/deleteMission/{id}/', name: 'deleteMission')]
public function deleteMission(Request $request, EntityManagerInterface $entityManager,$id): Response
{
$response = "";
$chckAccess = $this->baseService->Role(86);
if($chckAccess == 0){
$response = "Vous n'avez pas accès à cette opération";
}else if ($chckAccess == 2){
$response = "Vous n'avez pas accès à cette opération";
}
if( $response == ""){
$mission = $entityManager->getRepository(Mission::class)->find($id);
if (!$mission)
{
$response = 'Desolé, cette mission est introuvable !';
}
else
{
$details = $entityManager->getRepository(DetailMission::class)->findByIdMission($id);
foreach($details as $detail)
{
$detail_fichier = $entityManager->getRepository(DetailFichier::class)->find($detail->getIdDetail());
$detail_fichier->setEtatDeta(0);
$entityManager->remove($detail);
}
// Remove the utilisateur
$entityManager->remove($mission);
$entityManager->flush();
$entityManager->flush();
$response = "ok";
}
}
return new Response($response);
}
#[Route('/getMissionsByFile/{id}/', name: 'getMissionsByFile')]
public function getMissionsByFile(Request $request, EntityManagerInterface $entityManager, SerializerInterface $serializer, $id): Response
{
$response = "";
$fichier = $entityManager->getRepository(Fichier::class)->find($id);
if (!$fichier) {
$response = 'Désolé, ce fichier est introuvable !';
} else {
$dataToSend = [];
// Use a foreach loop instead of for loop
foreach ($entityManager->getRepository(Mission::class)->findByIdFichier($id) as $i => $mission) {
$dataToSend[$i]['id'] = $mission->getId();
$dts[$i]["agent"] = $entityManager->getRepository(Utilisateur::class)->find($mission->getIdAgent());
$dts[$i]["date_debut"] = $mission->getDateDebut();
$dts[$i]["date_fin"] = $mission->getDateFin(); // Corrected the property name
$dts[$i]["etat_miss"] = $mission->getEtatMiss(); // Corrected the property name
$dts[$i]["numer_miss"] = $mission->getNumeMiss(); // Corrected the property name
// Assuming you want to add these details to $dataToSend
$dataToSend[$i]['agent'] = $dts[$i]["agent"];
$dataToSend[$i]['date_debut'] = $dts[$i]["date_debut"];
$dataToSend[$i]['date_fin'] = $dts[$i]["date_fin"];
$dataToSend[$i]['etat_miss'] = $dts[$i]["etat_miss"];
$dataToSend[$i]['numeMiss'] = $dts[$i]["numer_miss"];
}
}
$missionsList = array_values($dataToSend);
$detailsJson = $serializer->serialize($missionsList, 'json');
return new JsonResponse($detailsJson, 200, [], true);
}
#[Route('/getArticle/{id}/', name: 'getArticle')]
public function getArticle(Request $request, EntityManagerInterface $entityManager, $id,SerializerInterface $serializer): JsonResponse
{
$response = [];
$marche = $entityManager->getRepository(Marche::class)->find($id);
if ($marche) {
if ($marche->getTypeMarc() == 1) {
$dv = $entityManager->getRepository(Devis::class)->find($marche->getIdDevis());
$articles = $entityManager->getRepository(DetailDevis::class)->findBy(['idDevis' => $dv->getId()]);
} else {
$dv = $entityManager->getRepository(Bordereau::class)->find($marche->getIdDevis());
$articles = $entityManager->getRepository(DetailBord::class)->findBy(['idBord' => $dv->getId()]);
}
// Assuming $articles is an array of Article-like entities
$response["articles"] = $articles;
$response["type"] = $marche->getTypeMarc() ;
}
$json = $serializer->serialize($response, 'json');
return new JsonResponse($json);
}
#[Route('/confirmerMission/{id}/', name: 'confirmerMission')]
public function confirmerMission(Request $request, EntityManagerInterface $entityManager,$id): Response
{
$response = "";
$chckAccess = $this->baseService->Role(83);
if($chckAccess == 0){
$response = "Vous n'avez pas accès à cette opération";
}else if ($chckAccess == 2){
$response = "Vous n'avez pas accès à cette opération";
}
if( $response == ""){
$mission = $entityManager->getRepository(Mission::class)->find($id);
if (!$mission)
{
$response = 'Desolé, cette mission est introuvable !';
}
else
{
$mission->setEtatMiss(1);
// Remove the utilisateur
$entityManager->flush();
$response = "ok";
}
}
return new Response($response);
}
#[Route('/reafecterMission', name: 'reafecterMission')]
public function reafecterMission(Request $request, EntityManagerInterface $entityManager ,MissionRepository $missionRepo, DetailMissionRepository $detailMissionRepo,BaseService $baseService): Response
{
$response = "";
$chckAccess = $this->baseService->Role(87);
if($chckAccess == 0){
$response = "Vous n'avez pas accès à cette opération";
}else if ($chckAccess == 2){
$response = "Vous n'avez pas accès à cette opération";
}
if( $response == ""){
$idMission = $request->get('idMission');
$idUser = $request->get('idUser');
$mission = $entityManager->getRepository(Mission::class)->find($idMission);
if (!$mission) {
$response = 'Désolé, cette mission est introuvable !';
} else {
$details = $entityManager->getRepository(DetailMission::class)->findByIdMission($idMission);
$selectedDetails = []; // Move initialization outside the loop
foreach ($details as $detail) {
if ($detail->getEtatDeta() != 1) {
$detail->setEtatDeta(-1);
$selectedDetails[] = $detail; // Collect details that meet the condition
}
}
if (count($selectedDetails) > 0) {
$marche = $entityManager->getRepository(Marche::class)->findOneById($mission->getIdMarche());
$numero = $missionRepo->getNumero($mission->getIdMarche());
$ms = new Mission();
$ms->setIdFichier($mission->getIdFichier());
$ms->setIdAgent($idUser);
$ms->setEtatMiss(0);
$ms->setIdMarche($mission->getIdMarche());
$ms->setCodeArti($mission->getCodeArti());
$ms->setImagArti($mission->getImagArti());
$ms->setDateCreation(new \DateTime());
$ms->setNumeMiss($numero);
$entityManager->persist($ms);
$entityManager->flush();
$text = 'Veuillez consulter votre mission affectée';
$baseService->addNotifications($text , 2 , $mission->getId() , $idUser,0);
foreach ($selectedDetails as $selectedDetail)
{
$detailNum = $detailMissionRepo->getNumero($details[0]->getIdDetailBord());
$detail = new DetailMission();
$detail->setIdMission($ms->getId());
$detail->setIdDetail($selectedDetail->getIdDetail());
$detail->setEtatDeta(0);
$detail->setNumeDeta($detailNum);
$refeDeta = 'REF' . str_pad($detailNum, 10, '0', STR_PAD_LEFT);
$detail->setRefeDeta($refeDeta);
$detail->setIdDetailBord($selectedDetail->getIdDetailBord());
$detail->setDateCreation(new \DateTime());
$detail->setTypeMarc($marche->getTypeMarc());
$entityManager->persist($detail);
$entityManager->flush();
}
if($marche->getTypeMarc() == 1)
{
$article = $entityManager->getRepository(DetailDevis::class)->find($selectedDetails[0]->getIdDetailBord());
}
else
{
$article = $entityManager->getRepository(DetailBord::class)->find($selectedDetails[0]->getIdDetailBord());
}
if($article)
{
$mission->setCodeArti($article->getCodeArti());
$mission->setImagArti($article->getIconArti());
}
$mission->setEtatMiss(2);
$entityManager->flush();
$response = "ok";
} else {
$response = "Il n'y a aucun détail à réaffecter à un autre agent.";
}
}
}
return new Response($response);
}
#[Route('/getImageDetails/{id}/', name: 'getImageDetails')]
public function getImageDetails(Request $request, EntityManagerInterface $entityManager, SerializerInterface $serializer,$id): Response
{
$chckAccess = $this->baseService->Role(16);
if($chckAccess == 0){
return $this->redirectToRoute('login');
}else if ($chckAccess == 2){
return $this->redirectToRoute('infoUtilisateur');
}
$response = "";
$bonsLivraison = $entityManager->getRepository(Images::class)->findByIdDetailFichier($id);
if (!$bonsLivraison) {
$response = "Desolé, il n'ya aucune images introuvale !";
return new JsonResponse(['error' => $response], 200);
}
$bons = array_values($bonsLivraison);
$bonsJson = $serializer->serialize($bons, 'json');
// Return a JSON response with the data
return new JsonResponse($bonsJson, 200, [], true);
}
#[Route('/showMission', name: 'showMission')]
public function showMission(Request $request, EntityManagerInterface $entityManager,ValidateService $validateService,MissionRepository $missionRepo): Response
{
$chckAccess = $this->baseService->Role(82);
if($chckAccess == 0){
return $this->redirectToRoute('login');
}else if ($chckAccess == 2){
return $this->redirectToRoute('infoUtilisateur');
}
$response = "";
$idMission=$request->get('id');
$mission = $entityManager->getRepository(Mission::class)->find($idMission);
if($mission)
{
$detailMissions = $entityManager->getRepository(DetailMission::class)->findBy(['idMission'=>$idMission]);
$agent = $entityManager->getRepository(Utilisateur::class)->find($mission->getIdAgent());
}
else
{
return $this->redirect('/listMissions');
}
return $this->render('mission/showMission.html.twig', [
'controller_name' => 'MissionController',
'response' => $response,
'mission'=>$mission,
'detailMissions' => $detailMissions,
'utilisateur' => $agent
]);
}
#[Route('/saisieMission', name: 'saisieMission')]
public function saisieMission(Request $request, EntityManagerInterface $entityManager,
DetailMissionRepository $detailMissionRepo): Response
{
$response = "";
$chckAccess = $this->baseService->Role(118);
if($chckAccess == 0){
return $this->redirectToRoute('login');
}else if ($chckAccess == 2){
return $this->redirectToRoute('infoUtilisateur');
}
$idFichier = $request->get('idFichier');
$idMission = $request->get('idMission');
$nomFichier = $request->get('nomFichier');
$idArticle = $request->get('idArticle');
$idMarcher = $request->get('idMarcher');
$Obligatoire = true;
$fichier = $entityManager->getRepository(Fichier::class)->find($idFichier);
if($idMission)
$mission = $entityManager->getRepository(Mission::class)->find($idMission);
if($fichier)
{
$array = array();
$form = $entityManager->getRepository(InfosModelFichier::class)->findBy(array('idModal' => $fichier->getIdModal()));
for ($i=0; $i < count($form); $i++) {
$array[$i]['array'] = $form[$i];
$array[$i]['option'] = $entityManager->getRepository(DetailsOptionModel::class)->findBy(array('id_model' => $form[$i]->getId()));
}
foreach ($form as $info) {
if ($info->getIsObligatoire() == 1) {
$Obligatoire = true;
$value = $request->get($info->getNomInfo());
if (empty($value)) {
$Obligatoire = false;
}
}
}
$lastDetail = $entityManager->getRepository(DetailFichier::class)->findOneBy(array('idModal' => $fichier->getIdModal(),'idFichier' => $idFichier), array('id' => 'DESC'));
$marche = $entityManager->getRepository(Marche::class)->findOneById($fichier->getIdMarche());
if(!$lastDetail){
$lastNum = 0;
$idArticle = $idArticle;
}
else{
$lastNum = (int)$lastDetail->getNumeDeta();
$idArticle = $lastDetail->getIdDetailBord();
}
if($request->getMethod()=='POST')
{
if(!$Obligatoire){
$response = 'un des champs obligatoires vides';
}
else{
$detail = new DetailFichier();
$detail->setIdModal($fichier->getIdModal());
$detail->setIdFichier($idFichier);
$detail->setNumeDeta($lastNum+1);
if (isset($idMission) && $mission)
{
$detail->setEtatDeta(1);
}
else
{
$detail->setEtatDeta(0);
}
$detail->setIdDetailBord($idArticle);
$entityManager->persist($detail);
$entityManager->flush();
foreach($form as $f)
{
$value=$request->get($f->getNomInfo());
$info = new InfosDetailFichier();
$info->setIdDetail($detail->getId());
$info->setIdInfo($f->getId());
$info->setValueInfo($value);
$info->setIdFichier($idFichier);
$entityManager->persist($info);
$entityManager->flush();
}
if (isset($idMission) && $mission)
{
$detailNum = $detailMissionRepo->getNumero($lastDetail->getIdDetailBord());
$detMiss = new DetailMission();
$detMiss->setIdDetail($detail->getId());
$detMiss->setIdMission($idMission);
$detMiss->setEtatDeta(0);
$detMiss->setNumeDeta($detailNum);
$refeDeta = 'REF' . str_pad($detailNum, 10, '0', STR_PAD_LEFT);
$detMiss->setRefeDeta($refeDeta);
$detMiss->setDateCreation(new \DateTime());
$detMiss->setIdDetailBord($idArticle);
$detMiss->setTypeMarc($marche->getTypeMarc());
$entityManager->persist($detMiss);
$entityManager->flush();
}
$response = 'ok';
}
}
}
else
{
$response = 'Desolé, ce fichier est introuvable !';
}
return $this->render('mission/saisieMission.html.twig', [
'controller_name' => 'MissionController',
'response' => $response,
'form' => $form,
'array'=>$array,
'idFichier'=>$idFichier
]);
}
#[Route('/deleteDetailMission/{id}/', name: 'deleteDetailMission')]
public function deleteDetailMission(Request $request, EntityManagerInterface $entityManager,$id): Response
{
$response = "";
$chckAccess = $this->baseService->Role(86);
if($chckAccess == 0){
$response = "Vous n'avez pas accès à cette opération";
}else if ($chckAccess == 2){
$response = "Vous n'avez pas accès à cette opération";
}
if( $response == ""){
$detailMission = $entityManager->getRepository(DetailMission::class)->find($id);
if (!$detailMission)
{
$response = 'Desolé, ce detail est introuvable !';
}
else
{
$detailFichier = $entityManager->getRepository(DetailFichier::class)->find($detailMission->getIdDetail());
$detailFichier->setEtatDeta(0);
// Remove the detail
$entityManager->remove($detailMission);
$entityManager->flush();
$response = "ok";
}
}
return new Response($response);
}
#[Route('/getFormDetaile/{id}/', name: 'getFormDetaile')]
public function getFormDetaile(Request $request, EntityManagerInterface $entityManager, $id, SerializerInterface $serializer): Response
{
$response = [];
$response['error'] = 'ok';
$detailMission = $entityManager->getRepository(DetailMission::class)->find($id);
if (!$detailMission)
{
$response['error'] = 'Désolé, ce détail de mission est introuvable !';
}
else
{
$detailFichier = $entityManager->getRepository(DetailFichier::class)->find($detailMission->getIdDetail());
if ($detailFichier)
{
$infosModal = $entityManager->getRepository(InfosModelFichier::class)->findBy(array("idModal" => $detailFichier->getIdModal()));
$infosdetail = $entityManager->getRepository(InfosDetailFichier::class)->findBy(array("idDetail" => $detailFichier->getId()));
$response['infosModal'] = $infosModal;
$response['infosdetail'] = $infosdetail;
}
else
{
$response['error'] = 'Désolé, ce détail de fichier est introuvable !';
}
}
$json = $serializer->serialize($response, 'json');
return new JsonResponse($json);
}
#[Route('/updateDetail', name: 'updateDetail')]
public function updateDetail(Request $request, EntityManagerInterface $entityManager): Response
{
$response = "";
$idDetail=$request->get('idDetail');
$detailFichier = $entityManager->getRepository(DetailFichier::class)->find($idDetail);
if ($detailFichier)
{
$infosModal = $entityManager->getRepository(InfosModelFichier::class)->findBy(array("idModal" => $detailFichier->getIdModal()));
foreach($infosModal as $info)
{
$value=$request->get('info_'.$info->getId());
$infodetail = $entityManager->getRepository(InfosDetailFichier::class)->findOneBy(array("idDetail" => $idDetail,"idInfo" => $info->getId()));
if($infodetail)
{
$infodetail->setValueInfo($value);
}
}
$entityManager->flush();
$response = "ok";
}
else
{
$response = "Desolé, ce detail est introuvable !";
}
return new Response($response);
}
#[Route('/finaliserDetailMission/{id}/', name: 'finaliserDetailMission')]
public function finaliserDetailMission(Request $request, EntityManagerInterface $entityManager,$id): Response
{
$response = "";
$chckAccess = $this->baseService->Role(88);
if($chckAccess == 0){
$response = "Vous n'avez pas accès à cette opération";
}else if ($chckAccess == 2){
$response = "Vous n'avez pas accès à cette opération";
}
if( $response == ""){
$detailMission = $entityManager->getRepository(DetailMission::class)->find($id);
if (!$detailMission)
{
$response = 'Desolé, ce detail est introuvable !';
}
else
{
$detailFichier = $entityManager->getRepository(DetailFichier::class)->find($detailMission->getIdDetail());
$detailMission->setEtatDeta(1);
// Remove the detail
$detailFichier->setEtatDeta(2);
$entityManager->flush();
$response = "ok";
}
}
return new Response($response);
}
#[Route('/finaliserMission/{id}/', name: 'finaliserMission')]
public function finaliserMission(Request $request, EntityManagerInterface $entityManager,$id): Response
{
$response = "";
$chckAccess = $this->baseService->Role(88);
if($chckAccess == 0){
$response = "Vous n'avez pas accès à cette opération";
}else if ($chckAccess == 2){
$response = "Vous n'avez pas accès à cette opération";
}
if( $response == ""){
$mission = $entityManager->getRepository(Mission::class)->find($id);
if (!$mission)
{
$response = 'Desolé, cette mission est introuvable !';
}
else
{
$detailsMission = $entityManager->getRepository(DetailMission::class)->findBy(array("idMission" => $mission->getId()));
foreach($detailsMission as $detailMission)
{
$detailFichier = $entityManager->getRepository(DetailFichier::class)->find($detailMission->getIdDetail());
$detailMission->setEtatDeta(1);
$detailFichier->setEtatDeta(2);
}
$mission->setEtatMiss(2);
$stockMission = $entityManager->getRepository(StockMission::class)->findBy(array("idMission" => $mission->getId()));
foreach($stockMission as $stock)
{
if($stock->getQte() > 0)
{
$mouvement = new MouvementStock();
$mouvement->setIdPiec($stock->getIdPiece());
$mouvement->setDateMouv(new \DateTime());
$mouvement->setToStock($stock->getFromStock());
$mouvement->setQte($stock->getQte());
$mouvement->setFromStock(-1);
$mouvement->setMotifMouv('Retroure de stock mission');
$mouvement->setEtatMouv(0);
$entityManager->persist($mouvement);
$entityManager->flush();
if($stock->getFromStock() == 0)
{
$article = $entityManager->getRepository(Piece::class)->find($stock->getIdPiece());
$inStokc = $article->getInStock();
$qteArticle = $inStokc + $stock->getQte();
$article->setInStock($qteArticle);
}
else
{
$stockR = new StockReception();
$stockR->setIdBure($stock->getFromStock());
$stockR->setIdPiec($stock->getIdPiece());
$stockR->setQte($stock->getQte());
$stockR->setIdMouv($mouvement->getId());
$entityManager->persist($stockR);
}
}
}
$entityManager->flush();
$response = "ok";
}
}
return new Response($response);
}
#[Route('/getModalArticle', name: 'getModalArticle')]
public function getModalArticle(Request $request, EntityManagerInterface $entityManager, BaseService $baseService, SerializerInterface $serializer): Response
{
$response = "";
$articleId = $request->get('ArticleId');
$detailBord = $entityManager->getRepository(DetailBord::class)->findOneById($articleId);
$detailDevis = $entityManager->getRepository(DetailDevis::class)->findOneById($articleId);
if ($detailBord) {
$idModal = $detailBord->getIdModalFich();
} elseif ($detailDevis) {
$idModal = $detailDevis->getIdModalFich();
}
$modeles = $entityManager->getRepository(InfosModelFichier::class)->findByIdModal($idModal);
$resultModeles = array_values($modeles);
$modelesJson = $serializer->serialize($resultModeles, 'json');
return new JsonResponse($modelesJson, 200, [], true);
}
#[Route('/CreateNewFichier', name: 'CreateNewFichier')]
public function CreateNewFichier(Request $request, EntityManagerInterface $entityManager, BaseService $baseService, SerializerInterface $serializer): Response
{
$response = [];
$response['error'] = 'Ok';
$idFichier = $request->get('idFichier');
$idMission = $request->get('idMission');
$nomFichier = $request->get('nomFichier');
$idArticle = $request->get('idArticle');
$idMarcher = $request->get('idMarcher');
$detailBord = $entityManager->getRepository(DetailBord::class)->findOneById($idArticle);
$detailDevis = $entityManager->getRepository(DetailDevis::class)->findOneById($idArticle);
if ($detailBord) {
$idModal = $detailBord->getIdModalFich();
} elseif ($detailDevis) {
$idModal = $detailDevis->getIdModalFich();
}
$Obligatoire = true;
if($idFichier == -1)
{
$response['form'] = 1;
}
else
{
$response['form'] = 2;
}
if($idFichier == -1){
$fichier = new Fichier();
$fichier->setNomFich($nomFichier);
$fichier->setDateCreation(new \DateTime());
$fichier->setIdModal($idModal);
$fichier->setIdMarche($idMarcher);
$fichier->setEtatFich(0);
$fichier->setUrlFich('');
$entityManager->persist($fichier);
$entityManager->flush();
$idNewFichier =$fichier->getId();
$response['idFichier'] = $idNewFichier;
}
else{
$fichier = $entityManager->getRepository(Fichier::class)->find($idFichier);
}
$array = array();
$form = $entityManager->getRepository(InfosModelFichier::class)->findBy(array('idModal' => $fichier->getIdModal()));
for ($i=0; $i < count($form); $i++) {
$array[$i]['array'] = $form[$i];
$array[$i]['option'] = $entityManager->getRepository(DetailsOptionModel::class)->findBy(array('id_model' => $form[$i]->getId()));
if($form[$i]->getIsObligatoire() == 1){
$Obligatoire = false;
}
}
$json = $serializer->serialize($response, 'json');
return new JsonResponse($json);
}
}

src/Controller/Marches/MissionController.php line 655