src/Controller/BusinessContactsController.php line 33

  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\BusinessContacts;
  6. use App\Form\BusinessContactsType;
  7. use App\Form\ImportType;
  8. use App\Repository\BusinessContactsRepository;
  9. use App\Repository\BusinessTypesRepository;
  10. use App\Services\BusinessContactVCFExport;
  11. use App\Services\ImportBusinessContactsService;
  12. use App\Services\CompanyDetailsService;
  13. use App\Services\CountBusinessContactsService;
  14. use App\Services\PhoneAnalyzer;
  15. use Doctrine\ORM\EntityManagerInterface;
  16. use PhpOffice\PhpSpreadsheet\Spreadsheet;
  17. use PhpOffice\PhpSpreadsheet\Writer\Csv;
  18. use Psr\Log\LoggerInterface;
  19. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  20. use Symfony\Bundle\SecurityBundle\Security;
  21. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  22. use Symfony\Component\HttpFoundation\File\Exception\FileException;
  23. use Symfony\Component\HttpFoundation\Request;
  24. use Symfony\Component\HttpFoundation\Response;
  25. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  26. use Symfony\Component\HttpFoundation\StreamedResponse;
  27. use Symfony\Component\Routing\Annotation\Route;
  28. use Symfony\Component\String\Slugger\SluggerInterface;
  30. /**
  31.  * @Route("/businesscontacts")
  32.  */
  33. class BusinessContactsController extends AbstractController
  34. {
  35.     public function __construct(private readonly LoggerInterface $logger)
  36.     {}
  38.     /**
  39.      * @Route("/index", name="business_contacts_index", methods={"GET"})
  40.      */
  41.     public function index(Request $request, BusinessContactsRepository $businessContactsRepository, BusinessTypesRepository $businessTypesRepository, CountBusinessContactsService $countBusinessContactsService, PhoneAnalyzer $phoneAnalyzer): Response
  42.     {
  43.         // All types (for selectors, etc.) — alpha by label
  44.         $business_types_all = $businessTypesRepository->findAll();
  45.         usort($business_types_all, function ($a, $b) {
  46.             return strcmp($a->getBusinessType(), $b->getBusinessType());
  47.         });
  49.         $businessTypeName = $request->query->get('business_type');
  50.         $adminViewParam = $request->query->get('admin_view'); // "Admin" or null
  52.         $isAdmin = $this->isGranted('ROLE_ADMIN');
  53.         $isAdminView = $isAdmin && $adminViewParam === 'Admin';   // 👈 only true when admin *and* button toggled on
  55.         // Decide contacts + types as before
  56.         if ($businessTypeName) {
  57.             $businessType = $businessTypesRepository->findOneBy(['businessType' => $businessTypeName]);
  59.             if ($businessType) {
  60.                 // Filtered to a single type
  61.                 $business_contacts = $businessContactsRepository->findBy(
  62.                     ['businessType' => $businessType],
  63.                     ['id' => 'ASC']
  64.                 );
  65.                 $business_types = [$businessType]; // headings for only this type
  66.             } else {
  67.                 // Invalid filter: fallback to all
  68.                 $business_contacts = $businessContactsRepository->findAll();
  69.                 $business_types = $businessTypesRepository->findBy([], ['ranking' => 'ASC']);
  70.             }
  71.         } else {
  72.             // No filter: show everything
  73.             $business_contacts = $businessContactsRepository->findAll();
  74.             $business_types = $businessTypesRepository->findBy([], ['ranking' => 'ASC']);
  75.         }
  77.         // 🔐 Role-based + AdminView-based filtering
  78.         // If NOT in AdminView (i.e. non-admin OR admin with AdminView OFF) → show only Approved
  79.         if (!$isAdminView) {
  80.             $business_contacts = array_filter($business_contacts, function ($contact) {
  81.                 return method_exists($contact, 'getStatus')
  82.                     && $contact->getStatus() === 'Approved';
  83.             });
  84.             $business_contacts = array_values($business_contacts);
  85.         }
  87.         // Analyze phones (as before)
  88.         foreach ($business_contacts as $business_contact) {
  89.             $business_contact->phoneAnalysis = [
  90.                 'mobile' => $business_contact->getMobile() ? $phoneAnalyzer->analyze($business_contact->getMobile()) : null,
  91.                 'landline' => $business_contact->getLandline() ? $phoneAnalyzer->analyze($business_contact->getLandline()) : null,
  92.             ];
  93.         }
  95.         // --- Group + sort within each group: company -> firstName -> lastName ---
  96.         $norm = function (?string $s): string {
  97.             return $s === null ? '' : mb_strtolower(trim($s));
  98.         };
  100.         $cmp = function ($a, $b) use ($norm): int {
  101.             $aCompany = $norm(method_exists($a, 'getCompany') ? $a->getCompany() : null);
  102.             $bCompany = $norm(method_exists($b, 'getCompany') ? $b->getCompany() : null);
  104.             $aFirst = $norm(method_exists($a, 'getFirstName') ? $a->getFirstName() : null);
  105.             $bFirst = $norm(method_exists($b, 'getFirstName') ? $b->getFirstName() : null);
  107.             $aLast = $norm(method_exists($a, 'getLastName') ? $a->getLastName() : null);
  108.             $bLast = $norm(method_exists($b, 'getLastName') ? $b->getLastName() : null);
  110.             $emptyOrder = function (string $x, string $y): ?int {
  111.                 $xe = ($x === '');
  112.                 $ye = ($y === '');
  113.                 if ($xe && !$ye) return 1;
  114.                 if (!$xe && $ye) return -1;
  115.                 return null;
  116.             };
  118.             if (($eo = $emptyOrder($aCompany, $bCompany)) !== null) return $eo;
  119.             if ($aCompany !== $bCompany) return $aCompany <=> $bCompany;
  121.             if (($eo = $emptyOrder($aFirst, $bFirst)) !== null) return $eo;
  122.             if ($aFirst !== $bFirst) return $aFirst <=> $bFirst;
  124.             if (($eo = $emptyOrder($aLast, $bLast)) !== null) return $eo;
  125.             if ($aLast !== $bLast) return $aLast <=> $bLast;
  127.             $aId = method_exists($a, 'getId') ? (int)$a->getId() : 0;
  128.             $bId = method_exists($b, 'getId') ? (int)$b->getId() : 0;
  129.             return $aId <=> $bId;
  130.         };
  132.         $contacts_by_type = [];
  133.         foreach ($business_types as $bt) {
  134.             $contacts_by_type[$bt->getId()] = [];
  135.         }
  136.         foreach ($business_contacts as $c) {
  137.             $type = $c->getBusinessType();
  138.             if ($type && array_key_exists($type->getId(), $contacts_by_type)) {
  139.                 $contacts_by_type[$type->getId()][] = $c;
  140.             }
  141.         }
  142.         foreach ($contacts_by_type as &$group) {
  143.             usort($group, $cmp);
  144.         }
  145.         unset($group);
  147.         return $this->render('business_contacts/index.html.twig', [
  148.             'business_contacts' => $business_contacts,
  149.             'business_types' => $business_types,
  150.             'business_types_all' => $business_types_all,
  151.             'countBusinessContactsService' => $countBusinessContactsService,
  152.             'list_or_map' => 'list',
  153.             'admin_check' => $isAdminView ? 'Yes' : 'No', // 👈 now reflects the toggle, not just the role
  154.             'current_business_type' => $businessTypeName,
  155.             'contacts_by_type' => $contacts_by_type,
  156.         ]);
  157.     }
  160.     /**
  161.      * @Route("/map/{subset}", name="business_contacts_map", methods={"GET"})
  162.      */
  163.     public function map(Request $request, string $subset, BusinessContactsRepository $businessContactsRepository, BusinessTypesRepository $businessTypesRepository, CountBusinessContactsService $countBusinessContacts): Response
  164.     {
  166.         $isAdmin = $this->isGranted('ROLE_ADMIN');
  168.         // Build criteria
  169.         $criteria = [];
  170.         if (!$isAdmin) {
  171.             $criteria['status'] = 'Approved';
  172.         }
  174.         if ($subset !== 'All') {
  175.             $business_type = $businessTypesRepository->findOneBy(['businessType' => $subset]);
  176.             // If the subset name is invalid, return no results instead of error
  177.             if ($business_type) {
  178.                 $criteria['businessType'] = $business_type;
  179.             } else {
  180.                 $business_contacts = [];
  181.             }
  182.         }
  184.         // Fetch contacts (if not already set due to invalid subset)
  185.         if (!isset($business_contacts)) {
  186.             $business_contacts = $businessContactsRepository->findBy($criteria);
  187.         }
  189.         // Compute map stats (only count rows with valid coords)
  190.         $latitude_total = 0.0;
  191.         $longitude_total = 0.0;
  192.         $count = 0;
  194.         $latitude_max = -100.0;
  195.         $latitude_min = 100.0;
  196.         $longitude_max = -100.0;
  197.         $longitude_min = 100.0;
  199.         foreach ($business_contacts as $business_contact) {
  200.             $lat = $business_contact->getLocationLatitude();
  201.             $lng = $business_contact->getLocationLongitude();
  203.             // Must have both coords and not be zero
  204.             if ($lat !== null && $lng !== null && (float)$lat !== 0.0 && (float)$lng !== 0.0) {
  205.                 $count++;
  206.                 $latitude_total += (float)$lat;
  207.                 $longitude_total += (float)$lng;
  209.                 if ($lat > $latitude_max) $latitude_max = (float)$lat;
  210.                 if ($lat < $latitude_min) $latitude_min = (float)$lat;
  211.                 if ($lng > $longitude_max) $longitude_max = (float)$lng;
  212.                 if ($lng < $longitude_min) $longitude_min = (float)$lng;
  213.             }
  214.         }
  216.         if ($count === 0) {
  217.             $latitude_average = 'No data';
  218.             $longitude_average = 'No data';
  219.             $latitude_range = 'TBD';
  220.             $longitude_range = 'TBD';
  221.         } else {
  222.             $latitude_average = $latitude_total / $count;
  223.             $longitude_average = $longitude_total / $count;
  225.             if ($count === 1) {
  226.                 $latitude_range = 'TBD';
  227.                 $longitude_range = 'TBD';
  228.             } else {
  229.                 $latitude_range = $latitude_max - $latitude_min;
  230.                 $longitude_range = $longitude_max - $longitude_min;
  231.             }
  232.         }
  234.         $business_types = $businessTypesRepository->findBy([], ['ranking' => 'ASC']);
  236.         return $this->render('business_contacts/map_of_business_contacts.html.twig', [
  237. //            'google_maps_api_key' => $this->getParameter('google_maps_api_key'),
  238.             'business_contacts' => $business_contacts,
  239.             'business_types' => $business_types,
  240.             'subset' => $subset,
  241.             'latitude_max' => $latitude_max,
  242.             'latitude_min' => $latitude_min,
  243.             'latitude_average' => $latitude_average,
  244.             'latitude_range' => $latitude_range,
  245.             'longitude_max' => $longitude_max,
  246.             'longitude_min' => $longitude_min,
  247.             'longitude_average' => $longitude_average,
  248.             'longitude_range' => $longitude_range,
  249.             'count' => $count,
  250.             'list_or_map' => 'map',
  251.             'admin_check' => $isAdmin ? 'Yes' : 'No',
  252.         ]);
  253.     }
  255.     /**
  256.      * @Route("/new/{business_type}", name="business_contacts_new", methods={"GET", "POST"})
  257.      */
  258.     public function new(Request $request, string $business_type, BusinessContactsRepository $businessContactsRepository, BusinessTypesRepository $businessTypesRepository, CompanyDetailsService $companyDetails, EntityManagerInterface $entityManager): Response
  259.     {
  260.         $business_type = $businessTypesRepository->find($business_type);
  261.         $default_country = $companyDetails->getCompanyDetails()->getCompanyAddressCountry();
  262.         $businessContact = new BusinessContacts();
  263.         $businessContact->setBusinessType($business_type);
  264.         $businessContact->setAddressCountry($default_country);
  265.         $form = $this->createForm(BusinessContactsType::class, $businessContact);
  266.         $form->handleRequest($request);
  268.         if ($form->isSubmitted() && $form->isValid()) {
  269.             $photo = $form['photo']->getData();
  270.             if ($photo) {
  271.                 $uniqueId = uniqid(); // Generates a unique ID
  272.                 $uniqueId3digits = substr($uniqueId, 10, 3); // Extracts the first 3 digits
  273.                 $files_name = [];
  274.                 $photo_directory = $this->getParameter('business_contacts_photos_directory');
  275.                 $fileName = pathinfo($photo->getClientOriginalName(), PATHINFO_FILENAME);
  276.                 $file_extension = $photo->guessExtension();
  277.                 $newFileName = $businessContact->getCompany() . "_" . $uniqueId3digits . "." . $file_extension;
  278.                 $photo->move($photo_directory, $newFileName);
  279.                 $businessContact->setPhoto($newFileName);
  280.             }
  282.             $file = $form['files']->getData();
  283.             if ($file) {
  284.                 $file_name = [];
  285.                 $file_directory = $this->getParameter('business_contacts_attachments_directory');
  286.                 $fileName = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
  287.                 $file_extension = $file->guessExtension();
  288.                 $newFileName = $fileName . "." . $file_extension;
  289.                 $file->move($file_directory, $newFileName);
  290.                 $businessContact->setFiles($newFileName);
  291.             }
  294.             $businessContactsRepository->add($businessContact, true);
  295.             $firstName = $businessContact->getFirstName();
  296.             $lastName = $businessContact->getLastName();
  297.             $entityManager->persist($businessContact);
  298.             $entityManager->flush();
  299.             return $this->redirectToRoute('business_contacts_index', [], Response::HTTP_SEE_OTHER);
  300.         }
  302.         return $this->renderForm('business_contacts/new.html.twig', [
  303.             'business_contact' => $businessContact,
  304.             'form' => $form,
  305.         ]);
  306.     }
  308.     /**
  309.      * @Route("/suggestion", name="business_contacts_suggestion", methods={"GET", "POST"})
  310.      */
  311.     public function suggestion(Request $request, BusinessContactsRepository $businessContactsRepository): Response
  312.     {
  313.         $businessContact = new BusinessContacts();
  314.         $form = $this->createForm(BusinessContactsType::class, $businessContact);
  315.         $form->handleRequest($request);
  317.         if ($form->isSubmitted() && $form->isValid()) {
  318.             $businessContactsRepository->add($businessContact, true);
  319.             $businessContact->setStatus('Pending');
  321.             return $this->redirectToRoute('business_contacts_index', [], Response::HTTP_SEE_OTHER);
  322.         }
  324.         return $this->renderForm('business_contacts/new.html.twig', [
  325.             'business_contact' => $businessContact,
  326.             'form' => $form,
  327.         ]);
  328.     }
  330.     /**
  331.      * @Route("/show/{id}", name="business_contacts_show", methods={"GET"})
  332.      */
  333.     public function show(BusinessContacts $businessContact): Response
  334.     {
  335.         $longitude = $businessContact->getLocationLongitude();
  336.         $latitude = $businessContact->getLocationLatitude();
  337.         return $this->render('business_contacts/show.html.twig', [
  338.             'business_contact' => $businessContact,
  339.             'longitude' => $longitude,
  340.             'latitude' => $latitude,
  341.         ]);
  342.     }
  344.     /**
  345.      * @Route("/edit/{id}", name="business_contacts_edit", methods={"GET", "POST"})
  346.      */
  347.     public function edit(Request $request, BusinessContacts $businessContact, BusinessContactsRepository $businessContactsRepository): Response
  348.     {
  349.         $form = $this->createForm(BusinessContactsType::class, $businessContact);
  350.         $form->handleRequest($request);
  352.         if ($form->isSubmitted() && $form->isValid()) {
  353.             $photo = $form['photo']->getData();
  354.             if ($photo) {
  355.                 $files_name = [];
  356.                 $photo_directory = $this->getParameter('business_contacts_photos_directory');
  357.                 $fileName = pathinfo($photo->getClientOriginalName(), PATHINFO_FILENAME);
  358.                 $file_extension = $photo->guessExtension();
  359.                 if ($businessContact->getFirstName() == '') {
  360.                     $newFileName = $businessContact->getCompany() . "." . $file_extension;
  361.                 } else {
  362.                     $newFileName = $businessContact->getCompany() . "_" . $businessContact->getFirstName() . "_" . $businessContact->getLastName() . "." . $file_extension;
  363.                 }
  365.                 $photo->move($photo_directory, $newFileName);
  366.                 $businessContact->setPhoto($newFileName);
  367.             }
  369.             $file = $form['files']->getData();
  370.             if ($file) {
  371.                 $file_name = [];
  372.                 $file_directory = $this->getParameter('business_contacts_attachments_directory');
  373.                 $fileName = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
  374.                 $file_extension = $file->guessExtension();
  375.                 $newFileName = $fileName . "." . $file_extension;
  376.                 $file->move($file_directory, $newFileName);
  377.                 $businessContact->setFiles($newFileName);
  378.             }
  380.             $businessContactsRepository->add($businessContact, true);
  382.             return $this->redirectToRoute('business_contacts_index', [], Response::HTTP_SEE_OTHER);
  383.         }
  385.         return $this->renderForm('business_contacts/edit.html.twig', [
  386.             'business_contact' => $businessContact,
  387.             'form' => $form,
  388.         ]);
  389.     }
  391.     /**
  392.      * @Route("/toggle_status/{id}", name="business_contacts_toggle_status", methods={"POST","GET"})
  393.      */
  394.     public function toggleStatus(BusinessContacts $businessContact, EntityManagerInterface $entityManager): Response
  395.     {
  396.         $this->denyAccessUnlessGranted('ROLE_ADMIN');
  397.         $current = $businessContact->getStatus();
  398.         if ($current === 'Approved') {
  399.             $businessContact->setStatus('Not approved');
  400.         } elseif ($current === 'Not approved') {
  401.             $businessContact->setStatus('Approved');
  402.         }
  403.         $entityManager->flush();
  404.         return $this->redirectToRoute('business_contacts_index');
  405.     }
  408.     /**
  409.      * @Route("/delete/{id}", name="business_contacts_delete", methods={"POST"})
  410.      */
  411.     public function delete(Request $request, BusinessContacts $businessContact, BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $entityManager): Response
  412.     {
  413.         $referer = $request->headers->get('referer');
  414.         $file_name = $businessContact->getFiles();
  416.         if ($file_name) {
  417.             $file = $this->getParameter('business_contacts_attachments_directory') . $file_name;
  418.             if (file_exists($file)) {
  419.                 unlink($file);
  420.             }
  421.             $businessContact->setFiles('');
  422.             $entityManager->flush();
  423.         }
  425.         $photo_file_name = $businessContact->getPhoto();
  426.         if ($photo_file_name) {
  427.             $photo_file_name = $this->getParameter('business_contacts_photos_directory') . $photo_file_name;
  428.             if (file_exists($photo_file_name)) {
  429.                 unlink($photo_file_name);
  430.             }
  431.             $businessContact->setPhoto('');
  432.             $entityManager->flush();
  433.         }
  435.         if ($this->isCsrfTokenValid('delete' . $businessContact->getId(), $request->request->get('_token'))) {
  436.             $id = $businessContact->getId();
  437.             $businessContactsRepository->remove($businessContact, true);
  439.             // Check if referer is a show or edit page for this deleted entity, if so redirect to index
  440.             if ($referer) {
  441.                 $refererPath = parse_url($referer, PHP_URL_PATH);
  442.                 if (strpos($refererPath, '/business_contacts/show/' . $id) !== false ||
  443.                     strpos($refererPath, '/business_contacts/edit/' . $id) !== false) {
  444.                     return $this->redirectToRoute('business_contacts_index');
  445.                 }
  446.             }
  447.         }
  448.         return $this->redirect($referer ?: $this->generateUrl('business_contacts_index'));
  449.     }
  451.     /**
  452.      * @Route("/delete_GPS_location/{id}", name="business_contacts_delete_GPS_location", methods={"POST"})
  453.      */
  454.     public function deleteGPSLocation(Request $request, int $id, BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $entityManager): Response
  455.     {
  456.         $referer = $request->headers->get('referer');
  457.         $businessContact = $businessContactsRepository->find($id);
  459.         if ($this->isCsrfTokenValid('delete_gps' . $businessContact->getId(), $request->request->get('_token'))) {
  460.             $businessContact->setLocationLatitude(null);
  461.             $businessContact->setLocationLongitude(null);
  462.             $entityManager->flush();
  463.         }
  465.         return $this->redirect($referer ?: $this->generateUrl('business_contacts_index'));
  466.     }
  469.     /**
  470.      * @Route("/delete_all_GPS_locations", name="business_contacts_delete_all_GPS_locations", methods={"POST"})
  471.      */
  472.     public function deleteAllBusinessContactsGPSLocations(Request $request, BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $entityManager): Response
  473.     {
  474.         $referer = $request->headers->get('referer');
  476.         if ($this->isCsrfTokenValid('delete_all_gps', $request->request->get('_token'))) {
  477.             $business_contacts = $businessContactsRepository->findAll();
  478.             foreach ($business_contacts as $business_contact) {
  479.                 $business_contact->setLocationLongitude(null);
  480.                 $business_contact->setLocationLatitude(null);
  481.             }
  482.             $entityManager->flush();
  483.         }
  484.         return $this->redirect($referer ?: $this->generateUrl('business_contacts_index'));
  485.     }
  488.     /**
  489.      * @Route("/delete_all", name="business_contacts_delete_all", methods={"POST"})
  490.      */
  491.     public function deleteAllBusinessContacts(Request $request, BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $entityManager): Response
  492.     {
  493.         if ($this->isCsrfTokenValid('delete_all_business_contacts', $request->request->get('_token'))) {
  494.             $business_contacts = $businessContactsRepository->findAll();
  495.             foreach ($business_contacts as $business_contact) {
  496.                 $entityManager->remove($business_contact);
  497.             }
  498.             $entityManager->flush();
  499.         }
  500.         return $this->redirectToRoute('business_contacts_index', [], Response::HTTP_SEE_OTHER);
  501.     }
  504.     /**
  505.      * @Route("/delete_photo_file/{id}", name="business_contact_delete_photo_file", methods={"POST"})
  506.      */
  507.     public function deleteBusinessContactPhotoFile(int $id, Request $request, BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $entityManager): Response
  508.     {
  509.         $businessContact = $businessContactsRepository->find($id);
  511.         if (!$businessContact) {
  512.             throw $this->createNotFoundException('Business contact not found');
  513.         }
  515.         $referer = $request->headers->get('referer') ?? $this->generateUrl('business_contacts_edit', ['id' => $id]);
  517.         if ($this->isCsrfTokenValid('delete_photo' . $businessContact->getId(), $request->request->get('_token'))) {
  518.             $photoFileName = $businessContact->getPhoto();
  520.             if ($photoFileName) {
  521.                 $fullPath = $this->getParameter('business_contacts_photos_directory') . DIRECTORY_SEPARATOR . $photoFileName;
  523.                 if (is_file($fullPath)) {
  524.                     @unlink($fullPath);
  525.                 }
  527.                 $businessContact->setPhoto(null);
  528.                 $entityManager->flush();
  529.             }
  530.         }
  532.         return $this->redirect($referer);
  533.     }
  536.     /**
  537.      * @Route("/delete_attachment_file/{id}", name="business_contact_delete_attachment_file", methods={"POST"})
  538.      */
  539.     public function deleteBusinessContactAttachmentFile(int $id, Request $request, BusinessContacts $businessContact, EntityManagerInterface $entityManager)
  540.     {
  541.         $referer = $request->headers->get('referer');
  543.         if ($this->isCsrfTokenValid('delete_attachment' . $businessContact->getId(), $request->request->get('_token'))) {
  544.             $file_name = $businessContact->getFiles();
  545.             if ($file_name) {
  546.                 $file = $this->getParameter('business_contacts_attachments_directory') . "/" . $file_name;
  547.                 if (file_exists($file)) {
  548.                     unlink($file);
  549.                 }
  550.                 $businessContact->setFiles('');
  551.                 $entityManager->flush();
  552.             }
  553.         }
  554.         return $this->redirect($referer);
  555.     }
  557.     /**
  558.      * @Route ("/view/photo/{id}", name="view_business_contact_photo")
  559.      */
  560.     public function viewBusinessContactPhoto(Request $request, $id, BusinessContactsRepository $businessContactsRepository)
  561.     {
  562.         $business_contact = $businessContactsRepository->find($id);
  563.         return $this->render('business_contacts/view_photo.html.twig', ['business_contact' => $business_contact]);
  564.     }
  567.     /**
  568.      * @Route ("/business_contacts_export", name="business_contacts_export" )
  569.      */
  570.     public function businessContactsExport(BusinessContactsRepository $businessContactsRepository)
  571.     {
  572.         $data = [];
  573.         $exported_date = new \DateTime('now');
  574.         $exported_date_formatted = $exported_date->format('d-M-Y');
  575.         $fileName = 'business_contacts_export_' . $exported_date_formatted . '.csv';
  577.         $count = 0;
  578.         $business_contact_list = $businessContactsRepository->findAll();
  579.         foreach ($business_contact_list as $business_contact) {
  581.             $data[] = [
  582.                 "BusinessContacts",
  583.                 $business_contact->getStatus(),
  584.                 $business_contact->getBusinessOrPerson(),
  585.                 $business_contact->getBusinessType()->getBusinessType(),
  586.                 $business_contact->getCompany(),
  587.                 $business_contact->getFirstName(),
  589.                 $business_contact->getLastName(),
  590.                 $business_contact->getWebsite(),
  591.                 $business_contact->getEmail(),
  592.                 $business_contact->getLandline(),
  593.                 $business_contact->getMobile(),
  595.                 $business_contact->getAddressStreet(),
  596.                 $business_contact->getAddressCity(),
  597.                 $business_contact->getAddressCounty(),
  598.                 $business_contact->getAddressPostCode(),
  599.                 $business_contact->getAddressCountry(),
  601.                 $business_contact->getLocationLongitude(),
  602.                 $business_contact->getLocationLatitude(),
  603.                 $business_contact->getNotes()
  604.             ];
  605.         }
  606.         $spreadsheet = new Spreadsheet();
  607.         $sheet = $spreadsheet->getActiveSheet();
  608.         $sheet->setTitle('Business Contacts');
  609.         $sheet->getCell('A1')->setValue('Entity');
  610.         $sheet->getCell('B1')->setValue('Status');
  611.         $sheet->getCell('C1')->setValue('Business Or Person');
  612.         $sheet->getCell('D1')->setValue('Business Type');
  613.         $sheet->getCell('E1')->setValue('Company');
  614.         $sheet->getCell('F1')->setValue('First Name');
  616.         $sheet->getCell('G1')->setValue('Last Name');
  617.         $sheet->getCell('H1')->setValue('Web Page');
  618.         $sheet->getCell('I1')->setValue('E-mail');
  619.         $sheet->getCell('J1')->setValue('Business Phone');
  620.         $sheet->getCell('K1')->setValue('Mobile Phone');
  622.         $sheet->getCell('L1')->setValue('Business Street');
  623.         $sheet->getCell('M1')->setValue('Business City');
  624.         $sheet->getCell('N1')->setValue('Business County');
  625.         $sheet->getCell('O1')->setValue('Business Postal Code');
  626.         $sheet->getCell('P1')->setValue('Business Country/Region');
  628.         $sheet->getCell('Q1')->setValue('Location Longitude');
  629.         $sheet->getCell('R1')->setValue('Location Latitude');
  630.         $sheet->getCell('S1')->setValue('Notes');
  632.         $sheet->fromArray($data, null, 'A2', true);
  633.         $total_rows = $sheet->getHighestRow();
  634.         for ($i = 2; $i <= $total_rows; $i++) {
  635.             $cell = "L" . $i;
  636.             $sheet->getCell($cell)->getHyperlink()->setUrl("https://google.com");
  637.         }
  638.         $writer = new Csv($spreadsheet);
  639.         $response = new StreamedResponse(function () use ($writer) {
  640.             $writer->save('php://output');
  641.         });
  642.         $response->headers->set('Content-Type', 'application/vnd.ms-excel');
  643.         $response->headers->set('Content-Disposition', sprintf('attachment;filename="%s"', $fileName));
  644.         $response->headers->set('Cache-Control', 'max-age=0');
  645.         return $response;
  646.     }
  649.     /**
  650.      * Export all BusinessContacts as a ZIP of individual .vcf files.
  651.      *
  652.      * @Route("/business_contacts_export_vcf_zip", name="business_contacts_export_vcf_zip", methods={"GET"})
  653.      */
  654.     public function exportBusinessContactsAsZip(BusinessContactsRepository $businessContactsRepository, BusinessContactVCFExport $businessContactVCFExport): Response
  655.     {
  656.         $contacts = $businessContactsRepository->findAll();
  657.         if (!$contacts) {
  658.             return new Response('No contacts to export.', Response::HTTP_NO_CONTENT);
  659.         }
  661.         // Final file name: business_contacts_YYYYMMDD.zip
  662.         $datePart = (new \DateTimeImmutable('now'))->format('Ymd');
  663.         $baseName = "business_contacts_{$datePart}";
  664.         $exportDir = rtrim($businessContactVCFExport->getExportDirectory(), "/\\");
  665.         $zipPath = $exportDir . DIRECTORY_SEPARATOR . $baseName . '.zip';
  667.         // Ensure export dir is OK
  668.         if (!is_dir($exportDir) || !is_writable($exportDir)) {
  669.             $msg = "Export directory is not writable: {$exportDir}";
  670.             $this->logger->error($msg);
  671.             return new Response($msg, Response::HTTP_INTERNAL_SERVER_ERROR);
  672.         }
  674.         // Make name unique if needed
  675.         if (file_exists($zipPath)) {
  676.             $i = 1;
  677.             do {
  678.                 $zipPath = $exportDir . DIRECTORY_SEPARATOR . $baseName . '-' . $i . '.zip';
  679.                 $i++;
  680.             } while (file_exists($zipPath));
  681.         }
  682.         $downloadName = basename($zipPath); // what the user downloads
  684.         // Create temp dir for individual VCFs
  685.         $tempDir = sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'bc_vcards_' . bin2hex(random_bytes(6));
  686.         if (!@mkdir($tempDir, 0777, true) && !is_dir($tempDir)) {
  687.             $msg = "Failed to create temporary directory: {$tempDir}";
  688.             $this->logger->error($msg);
  689.             return new Response($msg, Response::HTTP_INTERNAL_SERVER_ERROR);
  690.         }
  692.         try {
  693.             // Write each contact as its own .vcf using the service's BusinessContacts generator
  694.             foreach ($contacts as $c) {
  695.                 $first = trim((string)($c->getFirstName() ?? ''));
  696.                 $last = trim((string)($c->getLastName() ?? ''));
  697.                 $comp = trim((string)($c->getCompany() ?? ''));
  698.                 $label = $comp !== '' ? $comp : trim($first . ' ' . $last);
  699.                 if ($label === '') {
  700.                     $label = 'contact';
  701.                 }
  703.                 $safe = preg_replace('/[^a-zA-Z0-9._-]/', '_', $label);
  704.                 $vcfPath = $tempDir . DIRECTORY_SEPARATOR . $safe . '.vcf';
  706.                 // This writes the file to $vcfPath (and returns its contents)
  707.                 $businessContactVCFExport->generateVCard($c, $vcfPath);
  708.             }
  710.             // Zip them up
  711.             $zip = new \ZipArchive();
  712.             if ($zip->open($zipPath, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) !== true) {
  713.                 throw new \RuntimeException("Cannot create ZIP archive at: {$zipPath}");
  714.             }
  716.             foreach (glob($tempDir . DIRECTORY_SEPARATOR . '*.vcf') as $file) {
  717.                 $zip->addFile($file, basename($file));
  718.             }
  719.             $zip->close();
  721.         } catch (\Throwable $e) {
  722.             $this->logger->error('Failed to generate ZIP of vCards: ' . $e->getMessage(), ['exception' => $e]);
  723.             // Cleanup temp dir on failure
  724.             foreach (glob($tempDir . DIRECTORY_SEPARATOR . '*') ?: [] as $f) {
  725.                 @unlink($f);
  726.             }
  727.             @rmdir($tempDir);
  728.             return new Response('Failed to generate ZIP: ' . $e->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
  729.         }
  731.         // Cleanup temp dir (ZIP stays until sent)
  732.         foreach (glob($tempDir . DIRECTORY_SEPARATOR . '*') ?: [] as $f) {
  733.             @unlink($f);
  734.         }
  735.         @rmdir($tempDir);
  737.         /** @var BinaryFileResponse $response */
  738.         $response = $this->file($zipPath, $downloadName, ResponseHeaderBag::DISPOSITION_ATTACHMENT);
  739.         // Delete the ZIP after it's been sent to the client
  740.         $response->deleteFileAfterSend(true);
  742.         return $response;
  743.     }
  746.     /**
  747.      * @Route ("/business_contacts_import", name="business_contacts_import" )
  748.      */
  749.     public function businessContactsImport(Request $request, SluggerInterface $slugger, BusinessContactsRepository $businessContactsRepository, ImportBusinessContactsService $businessContactsImportService): Response
  750.     {
  751.         $form = $this->createForm(ImportType::class);
  752.         $form->handleRequest($request);
  753.         if ($form->isSubmitted() && $form->isValid()) {
  754.             $importFile = $form->get('File')->getData();
  755.             if ($importFile) {
  756.                 $originalFilename = pathinfo($importFile->getClientOriginalName(), PATHINFO_FILENAME);
  757.                 $safeFilename = $slugger->slug($originalFilename);
  758.                 $newFilename = $safeFilename . '.' . 'csv';
  759.                 try {
  760.                     $importFile->move(
  761.                         $this->getParameter('business_contacts_import_directory'),
  762.                         $newFilename
  763.                     );
  764.                 } catch (FileException $e) {
  765.                     die('Import failed');
  766.                 }
  767.                 $businessContactsImportService->importBusinessContacts($newFilename);
  768.                 return $this->redirectToRoute('business_contacts_index');
  769.             }
  770.         }
  771.         return $this->render('home/import.html.twig', [
  772.             'form' => $form->createView(),
  773.             'heading' => 'Business Contacts Import',
  774.         ]);
  775.     }
  778.     /**
  779.      * @Route("/update/location", name="update_business_contact_location", methods={"POST"})
  780.      */
  781.     public function updateLocation(BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $manager): Response
  782.     {
  783.         $id = $_POST['id'];
  784.         $latitude = $_POST['latitude'];
  785.         $longitude = $_POST['longitude'];
  786.         $gps = $latitude . ',' . $longitude;
  787.         $business_contact = $businessContactsRepository->find($id);
  788.         $business_contact->setLocationLongitude($longitude)
  789.             ->setLocationLatitude($latitude);
  790.         $manager->flush();
  791.         return new Response(null);
  792.     }
  794.     /**
  795.      * @Route("/gps_location_clear/{id}", name="business_contact_clear_gps_location")
  796.      */
  797.     public function clearGPSLocation(Request $request, BusinessContacts $businessContacts, EntityManagerInterface $entityManager)
  798.     {
  799.         $referer = $request->headers->get('referer');
  800.         $businessContacts->setLocationLongitude(null);
  801.         $businessContacts->setLocationLatitude(null);
  802.         $entityManager->flush();
  803.         return $this->redirect($referer);
  804.     }
  807.     /**
  808.      * @Route("/show_attachment/{id}", name="business_contact_show_attachment")
  809.      */
  810.     public function showAttachmentBusinessContact(int $id, BusinessContactsRepository $businessContactsRepository)
  811.     {
  812.         $business_contact = $businessContactsRepository->find($id);
  813.         $filename = $business_contact->getFiles();
  814.         $filepath = $this->getParameter('business_contacts_attachments_directory') . "/" . $filename;
  815.         if (file_exists($filepath)) {
  816.             $response = new BinaryFileResponse($filepath);
  817.             $response->setContentDisposition(
  818.                 ResponseHeaderBag::DISPOSITION_INLINE, //use ResponseHeaderBag::DISPOSITION_ATTACHMENT to save as an attachment
  819.                 $filename
  820.             );
  821.             return $response;
  822.         } else {
  823.             return new Response("file does not exist");
  824.         }
  825.     }
  828.     /**
  829.      * Export a single BusinessContact vCard with photo + proper filename formatting
  830.      *
  831.      * @Route("/create_vcard_business_contact/{id}", name="create_vcard_business_contact", methods={"GET"})
  832.      */
  833.     public function createVCFBusinessContact(BusinessContacts $businessContacts, BusinessContactVCFExport $exporter): Response
  834.     {
  835.         $type = strtolower((string)$businessContacts->getBusinessOrPerson());
  836.         if ($type === 'business') {
  837.             $company = trim((string)$businessContacts->getCompany());
  838.             $fileBaseName = $company !== '' ? $company : 'Business';
  839.         } else {
  840.             $first = trim((string)$businessContacts->getFirstName());
  841.             $last = trim((string)$businessContacts->getLastName());
  842.             $company = trim((string)$businessContacts->getCompany());
  844.             $namePart = trim($first . '_' . $last) ?: 'Contact';
  845.             $fileBaseName = $company !== ''
  846.                 ? sprintf('%s (%s)', $namePart, $company)
  847.                 : $namePart;
  848.         }
  849.         $safe = static fn(string $s): string => preg_replace('/[^A-Za-z0-9._() -]+/', '_', $s) ?: 'Contact';
  851.         $downloadName = $safe($fileBaseName) . '.vcf';
  853.         $exportDir = rtrim($exporter->getExportDirectory(), "/\\");
  854.         if (!is_dir($exportDir) || !is_writable($exportDir)) {
  855.             return new Response("Export directory is not writable: $exportDir", Response::HTTP_INTERNAL_SERVER_ERROR);
  856.         }
  858.         $filePath = $exportDir . DIRECTORY_SEPARATOR . $downloadName;
  860.         // Generate vCard with embedded photo via your service
  861.         try {
  862.             $exporter->generateVCard($businessContacts, $filePath);
  863.         } catch (\Throwable $e) {
  864.             return new Response('Failed to generate vCard: ' . $e->getMessage(), 500);
  865.         }
  867.         if (!is_file($filePath) || filesize($filePath) === 0) {
  868.             return new Response('vCard was not generated', 500);
  869.         }
  871.         return $this->file($filePath, $downloadName, ResponseHeaderBag::DISPOSITION_ATTACHMENT);
  872.     }
  874. }