src/Controller/BusinessContactsController.php line 48

  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.     {
  37.     }
  39.     /**
  40.      * @Route("/index", name="business_contacts_index", methods={"GET"})
  41.      */
  42.     public function index(Request $request, BusinessContactsRepository $businessContactsRepository, BusinessTypesRepository $businessTypesRepository, CountBusinessContactsService $countBusinessContactsService, PhoneAnalyzer $phoneAnalyzer): Response
  43.     {
  44.         // All types (for selectors, etc.) — alpha by label
  45.         $business_types_all = $businessTypesRepository->findAll();
  46.         usort($business_types_all, function ($a, $b) {
  47.             return strcmp($a->getBusinessType(), $b->getBusinessType());
  48.         });
  50.         $businessTypeName = $request->query->get('business_type');
  51.         $adminView = $request->query->get('admin_view');
  53.         // Determine which types to render as groups + which contacts to include
  54.         if ($businessTypeName) {
  55.             $businessType = $businessTypesRepository->findOneBy(['businessType' => $businessTypeName]);
  57.             if ($businessType) {
  58.                 // Filtered to a single type
  59.                 $business_contacts = $businessContactsRepository->findBy(
  60.                     ['businessType' => $businessType],
  61.                     ['id' => 'ASC']
  62.                 );
  63.                 $business_types = [$businessType]; // headings for only this type
  64.             } else {
  65.                 // Invalid filter: fallback to all
  66.                 $business_contacts = $businessContactsRepository->findAll();
  67.                 $business_types = $businessTypesRepository->findBy([], ['ranking' => 'ASC']);
  68.             }
  69.         } else {
  70.             // No filter: show everything
  71.             $business_contacts = $businessContactsRepository->findAll();
  72.             $business_types = $businessTypesRepository->findBy([], ['ranking' => 'ASC']);
  73.         }
  75.         // Analyze phones (as before)
  76.         foreach ($business_contacts as $business_contact) {
  77.             $business_contact->phoneAnalysis = [
  78.                 'mobile' => $business_contact->getMobile() ? $phoneAnalyzer->analyze($business_contact->getMobile()) : null,
  79.                 'landline' => $business_contact->getLandline() ? $phoneAnalyzer->analyze($business_contact->getLandline()) : null,
  80.             ];
  81.         }
  83.         // --- Group + sort within each group: company -> firstName -> lastName ---
  84.         $norm = function (?string $s): string {
  85.             return $s === null ? '' : mb_strtolower(trim($s));
  86.         };
  88.         $cmp = function ($a, $b) use ($norm): int {
  89.             // Adjust getter names here if your entity differs
  90.             $aCompany = $norm(method_exists($a, 'getCompany') ? $a->getCompany() : null);
  91.             $bCompany = $norm(method_exists($b, 'getCompany') ? $b->getCompany() : null);
  93.             $aFirst = $norm(method_exists($a, 'getFirstName') ? $a->getFirstName() : null);
  94.             $bFirst = $norm(method_exists($b, 'getFirstName') ? $b->getFirstName() : null);
  96.             $aLast = $norm(method_exists($a, 'getLastName') ? $a->getLastName() : null);
  97.             $bLast = $norm(method_exists($b, 'getLastName') ? $b->getLastName() : null);
  99.             // Empty values sort AFTER non-empty
  100.             $emptyOrder = function (string $x, string $y): ?int {
  101.                 $xe = ($x === '');
  102.                 $ye = ($y === '');
  103.                 if ($xe && !$ye) return 1;
  104.                 if (!$xe && $ye) return -1;
  105.                 return null; // both empty or both non-empty -> continue
  106.             };
  108.             // Compare company
  109.             if (($eo = $emptyOrder($aCompany, $bCompany)) !== null) return $eo;
  110.             if ($aCompany !== $bCompany) return $aCompany <=> $bCompany;
  112.             // Compare firstName
  113.             if (($eo = $emptyOrder($aFirst, $bFirst)) !== null) return $eo;
  114.             if ($aFirst !== $bFirst) return $aFirst <=> $bFirst;
  116.             // Compare lastName
  117.             if (($eo = $emptyOrder($aLast, $bLast)) !== null) return $eo;
  118.             if ($aLast !== $bLast) return $aLast <=> $bLast;
  120.             // Stable fallback by id
  121.             $aId = method_exists($a, 'getId') ? (int)$a->getId() : 0;
  122.             $bId = method_exists($b, 'getId') ? (int)$b->getId() : 0;
  123.             return $aId <=> $bId;
  124.         };
  126.         // Build grouped array keyed by the types we are actually rendering
  127.         $contacts_by_type = [];
  128.         foreach ($business_types as $bt) {
  129.             $contacts_by_type[$bt->getId()] = [];
  130.         }
  131.         foreach ($business_contacts as $c) {
  132.             $type = $c->getBusinessType();
  133.             if ($type && array_key_exists($type->getId(), $contacts_by_type)) {
  134.                 $contacts_by_type[$type->getId()][] = $c;
  135.             }
  136.         }
  137.         // Sort each group
  138.         foreach ($contacts_by_type as &$group) {
  139.             usort($group, $cmp);
  140.         }
  141.         unset($group);
  142.         // --- end group+sort ---
  144.         return $this->render('business_contacts/index.html.twig', [
  145.             'business_contacts' => $business_contacts,           // kept for compatibility
  146.             'business_types' => $business_types,
  147.             'business_types_all' => $business_types_all,
  148.             'countBusinessContactsService' => $countBusinessContactsService,
  149.             'list_or_map' => 'list',
  150.             'admin_check' => $adminView === 'Admin' ? 'Yes' : 'No',
  151.             'current_business_type' => $businessTypeName,
  152.             'contacts_by_type' => $contacts_by_type,            // used by Twig single-table template
  153.         ]);
  154.     }
  156.     /**
  157.      * @Route("/map/{subset}", name="business_contacts_map", methods={"GET"})
  158.      */
  159.     public function map(Request $request, string $subset, BusinessContactsRepository $businessContactsRepository, BusinessTypesRepository $businessTypesRepository, CountBusinessContactsService $countBusinessContacts): Response
  160.     {
  161.         // Admins see ALL; others only 'Approved'
  162.         $isAdmin = $this->isGranted('ROLE_ADMIN');
  164.         // Build criteria
  165.         $criteria = [];
  166.         if (!$isAdmin) {
  167.             $criteria['status'] = 'Approved';
  168.         }
  170.         if ($subset !== 'All') {
  171.             $business_type = $businessTypesRepository->findOneBy(['businessType' => $subset]);
  172.             // If the subset name is invalid, return no results instead of error
  173.             if ($business_type) {
  174.                 $criteria['businessType'] = $business_type;
  175.             } else {
  176.                 $business_contacts = [];
  177.             }
  178.         }
  180.         // Fetch contacts (if not already set due to invalid subset)
  181.         if (!isset($business_contacts)) {
  182.             $business_contacts = $businessContactsRepository->findBy($criteria);
  183.         }
  185.         // Compute map stats (only count rows with valid coords)
  186.         $latitude_total = 0.0;
  187.         $longitude_total = 0.0;
  188.         $count = 0;
  190.         $latitude_max = -100.0;
  191.         $latitude_min = 100.0;
  192.         $longitude_max = -100.0;
  193.         $longitude_min = 100.0;
  195.         foreach ($business_contacts as $business_contact) {
  196.             $lat = $business_contact->getLocationLatitude();
  197.             $lng = $business_contact->getLocationLongitude();
  199.             // Must have both coords and not be zero
  200.             if ($lat !== null && $lng !== null && (float)$lat !== 0.0 && (float)$lng !== 0.0) {
  201.                 $count++;
  202.                 $latitude_total += (float)$lat;
  203.                 $longitude_total += (float)$lng;
  205.                 if ($lat > $latitude_max) $latitude_max = (float)$lat;
  206.                 if ($lat < $latitude_min) $latitude_min = (float)$lat;
  207.                 if ($lng > $longitude_max) $longitude_max = (float)$lng;
  208.                 if ($lng < $longitude_min) $longitude_min = (float)$lng;
  209.             }
  210.         }
  212.         if ($count === 0) {
  213.             $latitude_average = 'No data';
  214.             $longitude_average = 'No data';
  215.             $latitude_range = 'TBD';
  216.             $longitude_range = 'TBD';
  217.         } else {
  218.             $latitude_average = $latitude_total / $count;
  219.             $longitude_average = $longitude_total / $count;
  221.             if ($count === 1) {
  222.                 $latitude_range = 'TBD';
  223.                 $longitude_range = 'TBD';
  224.             } else {
  225.                 $latitude_range = $latitude_max - $latitude_min;
  226.                 $longitude_range = $longitude_max - $longitude_min;
  227.             }
  228.         }
  230.         $business_types = $businessTypesRepository->findBy([], ['ranking' => 'ASC']);
  232.         return $this->render('business_contacts/map_of_business_contacts.html.twig', [
  233. //            'google_maps_api_key' => $this->getParameter('google_maps_api_key'), // e.g. set in services.yaml or .env
  234.             'business_contacts' => $business_contacts,
  235.             'business_types' => $business_types,
  236.             'subset' => $subset,
  237.             'latitude_max' => $latitude_max,
  238.             'latitude_min' => $latitude_min,
  239.             'latitude_average' => $latitude_average,
  240.             'latitude_range' => $latitude_range,
  241.             'longitude_max' => $longitude_max,
  242.             'longitude_min' => $longitude_min,
  243.             'longitude_average' => $longitude_average,
  244.             'longitude_range' => $longitude_range,
  245.             'count' => $count,
  246.             'list_or_map' => 'map',
  247.             'admin_check' => $isAdmin ? 'Yes' : 'No',
  248.         ]);
  249.     }
  251.     /**
  252.      * @Route("/new/{business_type}", name="business_contacts_new", methods={"GET", "POST"})
  253.      */
  254.     public function new(Request $request, string $business_type, BusinessContactsRepository $businessContactsRepository, BusinessTypesRepository $businessTypesRepository, CompanyDetailsService $companyDetails, EntityManagerInterface $entityManager): Response
  255.     {
  256.         $business_type = $businessTypesRepository->find($business_type);
  257.         $default_country = $companyDetails->getCompanyDetails()->getCompanyAddressCountry();
  258.         $businessContact = new BusinessContacts();
  259.         $businessContact->setBusinessType($business_type);
  260.         $businessContact->setAddressCountry($default_country);
  261.         $form = $this->createForm(BusinessContactsType::class, $businessContact);
  262.         $form->handleRequest($request);
  264.         if ($form->isSubmitted() && $form->isValid()) {
  265.             $photo = $form['photo']->getData();
  266.             if ($photo) {
  267.                 $uniqueId = uniqid(); // Generates a unique ID
  268.                 $uniqueId3digits = substr($uniqueId, 10, 3); // Extracts the first 3 digits
  269.                 $files_name = [];
  270.                 $photo_directory = $this->getParameter('business_contacts_photos_directory');
  271.                 $fileName = pathinfo($photo->getClientOriginalName(), PATHINFO_FILENAME);
  272.                 $file_extension = $photo->guessExtension();
  273.                 $newFileName = $businessContact->getCompany() . "_" . $uniqueId3digits . "." . $file_extension;
  274.                 $photo->move($photo_directory, $newFileName);
  275.                 $businessContact->setPhoto($newFileName);
  276.             }
  278.             $file = $form['files']->getData();
  279.             if ($file) {
  280.                 $file_name = [];
  281.                 $file_directory = $this->getParameter('business_contacts_attachments_directory');
  282.                 $fileName = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
  283.                 $file_extension = $file->guessExtension();
  284.                 $newFileName = $fileName . "." . $file_extension;
  285.                 $file->move($file_directory, $newFileName);
  286.                 $businessContact->setFiles($newFileName);
  287.             }
  290.             $businessContactsRepository->add($businessContact, true);
  291.             $firstName = $businessContact->getFirstName();
  292.             $lastName = $businessContact->getLastName();
  293.             $entityManager->persist($businessContact);
  294.             $entityManager->flush();
  295.             return $this->redirectToRoute('business_contacts_index', [], Response::HTTP_SEE_OTHER);
  296.         }
  298.         return $this->renderForm('business_contacts/new.html.twig', [
  299.             'business_contact' => $businessContact,
  300.             'form' => $form,
  301.         ]);
  302.     }
  304.     /**
  305.      * @Route("/suggestion", name="business_contacts_suggestion", methods={"GET", "POST"})
  306.      */
  307.     public function suggestion(Request $request, BusinessContactsRepository $businessContactsRepository): Response
  308.     {
  309.         $businessContact = new BusinessContacts();
  310.         $form = $this->createForm(BusinessContactsType::class, $businessContact);
  311.         $form->handleRequest($request);
  313.         if ($form->isSubmitted() && $form->isValid()) {
  314.             $businessContactsRepository->add($businessContact, true);
  315.             $businessContact->setStatus('Pending');
  317.             return $this->redirectToRoute('business_contacts_index', [], Response::HTTP_SEE_OTHER);
  318.         }
  320.         return $this->renderForm('business_contacts/new.html.twig', [
  321.             'business_contact' => $businessContact,
  322.             'form' => $form,
  323.         ]);
  324.     }
  326.     /**
  327.      * @Route("/show/{id}", name="business_contacts_show", methods={"GET"})
  328.      */
  329.     public function show(BusinessContacts $businessContact): Response
  330.     {
  331.         $longitude = $businessContact->getLocationLongitude();
  332.         $latitude = $businessContact->getLocationLatitude();
  333.         return $this->render('business_contacts/show.html.twig', [
  334.             'business_contact' => $businessContact,
  335.             'longitude' => $longitude,
  336.             'latitude' => $latitude,
  337.         ]);
  338.     }
  340.     /**
  341.      * @Route("/edit/{id}", name="business_contacts_edit", methods={"GET", "POST"})
  342.      */
  343.     public function edit(Request $request, BusinessContacts $businessContact, BusinessContactsRepository $businessContactsRepository): Response
  344.     {
  345.         $form = $this->createForm(BusinessContactsType::class, $businessContact);
  346.         $form->handleRequest($request);
  348.         if ($form->isSubmitted() && $form->isValid()) {
  349.             $photo = $form['photo']->getData();
  350.             if ($photo) {
  351.                 $files_name = [];
  352.                 $photo_directory = $this->getParameter('business_contacts_photos_directory');
  353.                 $fileName = pathinfo($photo->getClientOriginalName(), PATHINFO_FILENAME);
  354.                 $file_extension = $photo->guessExtension();
  355.                 if ($businessContact->getFirstName() == '') {
  356.                     $newFileName = $businessContact->getCompany() . "." . $file_extension;
  357.                 } else {
  358.                     $newFileName = $businessContact->getCompany() . "_" . $businessContact->getFirstName() . "_" . $businessContact->getLastName() . "." . $file_extension;
  359.                 }
  361.                 $photo->move($photo_directory, $newFileName);
  362.                 $businessContact->setPhoto($newFileName);
  363.             }
  365.             $file = $form['files']->getData();
  366.             if ($file) {
  367.                 $file_name = [];
  368.                 $file_directory = $this->getParameter('business_contacts_attachments_directory');
  369.                 $fileName = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
  370.                 $file_extension = $file->guessExtension();
  371.                 $newFileName = $fileName . "." . $file_extension;
  372.                 $file->move($file_directory, $newFileName);
  373.                 $businessContact->setFiles($newFileName);
  374.             }
  376.             $businessContactsRepository->add($businessContact, true);
  378.             return $this->redirectToRoute('business_contacts_index', [], Response::HTTP_SEE_OTHER);
  379.         }
  381.         return $this->renderForm('business_contacts/edit.html.twig', [
  382.             'business_contact' => $businessContact,
  383.             'form' => $form,
  384.         ]);
  385.     }
  387.     /**
  388.      * @Route("/delete/{id}", name="business_contacts_delete", methods={"POST"})
  389.      */
  390.     public function delete(Request $request, BusinessContacts $businessContact, BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $entityManager): Response
  391.     {
  392.         $referer = $request->headers->get('referer');
  393.         $file_name = $businessContact->getFiles();
  395.         if ($file_name) {
  396.             $file = $this->getParameter('business_contacts_attachments_directory') . $file_name;
  397.             if (file_exists($file)) {
  398.                 unlink($file);
  399.             }
  400.             $businessContact->setFiles('');
  401.             $entityManager->flush();
  402.         }
  404.         $photo_file_name = $businessContact->getPhoto();
  405.         if ($photo_file_name) {
  406.             $photo_file_name = $this->getParameter('business_contacts_photos_directory') . $photo_file_name;
  407.             if (file_exists($photo_file_name)) {
  408.                 unlink($photo_file_name);
  409.             }
  410.             $businessContact->setPhoto('');
  411.             $entityManager->flush();
  412.         }
  414.         if ($this->isCsrfTokenValid('delete' . $businessContact->getId(), $request->request->get('_token'))) {
  415.             $id = $businessContact->getId();
  416.             $businessContactsRepository->remove($businessContact, true);
  418.             // Check if referer is a show or edit page for this deleted entity, if so redirect to index
  419.             if ($referer) {
  420.                 $refererPath = parse_url($referer, PHP_URL_PATH);
  421.                 if (strpos($refererPath, '/business_contacts/show/' . $id) !== false ||
  422.                     strpos($refererPath, '/business_contacts/edit/' . $id) !== false) {
  423.                     return $this->redirectToRoute('business_contacts_index');
  424.                 }
  425.             }
  426.         }
  427.         return $this->redirect($referer ?: $this->generateUrl('business_contacts_index'));
  428.     }
  430.     /**
  431.      * @Route("/delete_GPS_location/{id}", name="business_contacts_delete_GPS_location", methods={"POST"})
  432.      */
  433.     public function deleteGPSLocation(Request $request, int $id, BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $entityManager): Response
  434.     {
  435.         $referer = $request->headers->get('referer');
  436.         $businessContact = $businessContactsRepository->find($id);
  438.         if ($this->isCsrfTokenValid('delete_gps' . $businessContact->getId(), $request->request->get('_token'))) {
  439.             $businessContact->setLocationLatitude(null);
  440.             $businessContact->setLocationLongitude(null);
  441.             $entityManager->flush();
  442.         }
  444.         return $this->redirect($referer ?: $this->generateUrl('business_contacts_index'));
  445.     }
  448.     /**
  449.      * @Route("/delete_all_GPS_locations", name="business_contacts_delete_all_GPS_locations", methods={"POST"})
  450.      */
  451.     public function deleteAllBusinessContactsGPSLocations(Request $request, BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $entityManager): Response
  452.     {
  453.         $referer = $request->headers->get('referer');
  455.         if ($this->isCsrfTokenValid('delete_all_gps', $request->request->get('_token'))) {
  456.             $business_contacts = $businessContactsRepository->findAll();
  457.             foreach ($business_contacts as $business_contact) {
  458.                 $business_contact->setLocationLongitude(null);
  459.                 $business_contact->setLocationLatitude(null);
  460.             }
  461.             $entityManager->flush();
  462.         }
  463.         return $this->redirect($referer ?: $this->generateUrl('business_contacts_index'));
  464.     }
  467.     /**
  468.      * @Route("/delete_all", name="business_contacts_delete_all", methods={"POST"})
  469.      */
  470.     public function deleteAllBusinessContacts(Request $request, BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $entityManager): Response
  471.     {
  472.         if ($this->isCsrfTokenValid('delete_all_business_contacts', $request->request->get('_token'))) {
  473.             $business_contacts = $businessContactsRepository->findAll();
  474.             foreach ($business_contacts as $business_contact) {
  475.                 $entityManager->remove($business_contact);
  476.             }
  477.             $entityManager->flush();
  478.         }
  479.         return $this->redirectToRoute('business_contacts_index', [], Response::HTTP_SEE_OTHER);
  480.     }
  483.     /**
  484.      * @Route("/delete_photo_file/{id}", name="business_contact_delete_photo_file", methods={"POST"})
  485.      */
  486.     public function deleteBusinessContactPhotoFile(int $id, Request $request, BusinessContacts $businessContact, EntityManagerInterface $entityManager)
  487.     {
  488.         $referer = $request->headers->get('referer');
  490.         if ($this->isCsrfTokenValid('delete_photo' . $businessContact->getId(), $request->request->get('_token'))) {
  491.             $photo_file_name = $businessContact->getPhoto();
  492.             if ($photo_file_name) {
  493.                 $photo_file_name = $this->getParameter('business_contacts_photos_directory') . "/" . $photo_file_name;
  494.                 if (file_exists($photo_file_name)) {
  495.                     unlink($photo_file_name);
  496.                 }
  497.                 $businessContact->setPhoto('');
  498.                 $entityManager->flush();
  499.             }
  500.         }
  501.         return $this->redirect($referer);
  502.     }
  504.     /**
  505.      * @Route("/delete_attachment_file/{id}", name="business_contact_delete_attachment_file", methods={"POST"})
  506.      */
  507.     public function deleteBusinessContactAttachmentFile(int $id, Request $request, BusinessContacts $businessContact, EntityManagerInterface $entityManager)
  508.     {
  509.         $referer = $request->headers->get('referer');
  511.         if ($this->isCsrfTokenValid('delete_attachment' . $businessContact->getId(), $request->request->get('_token'))) {
  512.             $file_name = $businessContact->getFiles();
  513.             if ($file_name) {
  514.                 $file = $this->getParameter('business_contacts_attachments_directory') . "/" . $file_name;
  515.                 if (file_exists($file)) {
  516.                     unlink($file);
  517.                 }
  518.                 $businessContact->setFiles('');
  519.                 $entityManager->flush();
  520.             }
  521.         }
  522.         return $this->redirect($referer);
  523.     }
  525.     /**
  526.      * @Route ("/view/photo/{id}", name="view_business_contact_photo")
  527.      */
  528.     public function viewBusinessContactPhoto(Request $request, $id, BusinessContactsRepository $businessContactsRepository)
  529.     {
  530.         $business_contact = $businessContactsRepository->find($id);
  531.         return $this->render('business_contacts/view_photo.html.twig', ['business_contact' => $business_contact]);
  532.     }
  535.     /**
  536.      * @Route ("/business_contacts_export", name="business_contacts_export" )
  537.      */
  538.     public function businessContactsExport(BusinessContactsRepository $businessContactsRepository)
  539.     {
  540.         $data = [];
  541.         $exported_date = new \DateTime('now');
  542.         $exported_date_formatted = $exported_date->format('d-M-Y');
  543.         $fileName = 'business_contacts_export_' . $exported_date_formatted . '.csv';
  545.         $count = 0;
  546.         $business_contact_list = $businessContactsRepository->findAll();
  547.         foreach ($business_contact_list as $business_contact) {
  549.             $data[] = [
  550.                 "BusinessContacts",
  551.                 $business_contact->getStatus(),
  552.                 $business_contact->getBusinessOrPerson(),
  553.                 $business_contact->getBusinessType()->getBusinessType(),
  554.                 $business_contact->getCompany(),
  555.                 $business_contact->getFirstName(),
  557.                 $business_contact->getLastName(),
  558.                 $business_contact->getWebsite(),
  559.                 $business_contact->getEmail(),
  560.                 $business_contact->getLandline(),
  561.                 $business_contact->getMobile(),
  563.                 $business_contact->getAddressStreet(),
  564.                 $business_contact->getAddressCity(),
  565.                 $business_contact->getAddressCounty(),
  566.                 $business_contact->getAddressPostCode(),
  567.                 $business_contact->getAddressCountry(),
  569.                 $business_contact->getLocationLongitude(),
  570.                 $business_contact->getLocationLatitude(),
  571.                 $business_contact->getNotes()
  572.             ];
  573.         }
  574.         $spreadsheet = new Spreadsheet();
  575.         $sheet = $spreadsheet->getActiveSheet();
  576.         $sheet->setTitle('Business Contacts');
  577.         $sheet->getCell('A1')->setValue('Entity');
  578.         $sheet->getCell('B1')->setValue('Status');
  579.         $sheet->getCell('C1')->setValue('Business Or Person');
  580.         $sheet->getCell('D1')->setValue('Business Type');
  581.         $sheet->getCell('E1')->setValue('Company');
  582.         $sheet->getCell('F1')->setValue('First Name');
  584.         $sheet->getCell('G1')->setValue('Last Name');
  585.         $sheet->getCell('H1')->setValue('Web Page');
  586.         $sheet->getCell('I1')->setValue('E-mail');
  587.         $sheet->getCell('J1')->setValue('Business Phone');
  588.         $sheet->getCell('K1')->setValue('Mobile Phone');
  590.         $sheet->getCell('L1')->setValue('Business Street');
  591.         $sheet->getCell('M1')->setValue('Business City');
  592.         $sheet->getCell('N1')->setValue('Business County');
  593.         $sheet->getCell('O1')->setValue('Business Postal Code');
  594.         $sheet->getCell('P1')->setValue('Business Country/Region');
  596.         $sheet->getCell('Q1')->setValue('Location Longitude');
  597.         $sheet->getCell('R1')->setValue('Location Latitude');
  598.         $sheet->getCell('S1')->setValue('Notes');
  600.         $sheet->fromArray($data, null, 'A2', true);
  601.         $total_rows = $sheet->getHighestRow();
  602.         for ($i = 2; $i <= $total_rows; $i++) {
  603.             $cell = "L" . $i;
  604.             $sheet->getCell($cell)->getHyperlink()->setUrl("https://google.com");
  605.         }
  606.         $writer = new Csv($spreadsheet);
  607.         $response = new StreamedResponse(function () use ($writer) {
  608.             $writer->save('php://output');
  609.         });
  610.         $response->headers->set('Content-Type', 'application/vnd.ms-excel');
  611.         $response->headers->set('Content-Disposition', sprintf('attachment;filename="%s"', $fileName));
  612.         $response->headers->set('Cache-Control', 'max-age=0');
  613.         return $response;
  614.     }
  617.     /**
  618.      * Export all BusinessContacts as a ZIP of individual .vcf files.
  619.      *
  620.      * @Route("/business_contacts_export_vcf_zip", name="business_contacts_export_vcf_zip", methods={"GET"})
  621.      */
  622.     public function exportBusinessContactsAsZip(BusinessContactsRepository $businessContactsRepository, BusinessContactVCFExport $businessContactVCFExport): Response
  623.     {
  624.         $contacts = $businessContactsRepository->findAll();
  625.         if (!$contacts) {
  626.             return new Response('No contacts to export.', Response::HTTP_NO_CONTENT);
  627.         }
  629.         // Final file name: business_contacts_YYYYMMDD.zip
  630.         $datePart = (new \DateTimeImmutable('now'))->format('Ymd');
  631.         $baseName = "business_contacts_{$datePart}";
  632.         $exportDir = rtrim($businessContactVCFExport->getExportDirectory(), "/\\");
  633.         $zipPath = $exportDir . DIRECTORY_SEPARATOR . $baseName . '.zip';
  635.         // Ensure export dir is OK
  636.         if (!is_dir($exportDir) || !is_writable($exportDir)) {
  637.             $msg = "Export directory is not writable: {$exportDir}";
  638.             $this->logger->error($msg);
  639.             return new Response($msg, Response::HTTP_INTERNAL_SERVER_ERROR);
  640.         }
  642.         // Make name unique if needed
  643.         if (file_exists($zipPath)) {
  644.             $i = 1;
  645.             do {
  646.                 $zipPath = $exportDir . DIRECTORY_SEPARATOR . $baseName . '-' . $i . '.zip';
  647.                 $i++;
  648.             } while (file_exists($zipPath));
  649.         }
  650.         $downloadName = basename($zipPath); // what the user downloads
  652.         // Create temp dir for individual VCFs
  653.         $tempDir = sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'bc_vcards_' . bin2hex(random_bytes(6));
  654.         if (!@mkdir($tempDir, 0777, true) && !is_dir($tempDir)) {
  655.             $msg = "Failed to create temporary directory: {$tempDir}";
  656.             $this->logger->error($msg);
  657.             return new Response($msg, Response::HTTP_INTERNAL_SERVER_ERROR);
  658.         }
  660.         try {
  661.             // Write each contact as its own .vcf using the service's BusinessContacts generator
  662.             foreach ($contacts as $c) {
  663.                 $first = trim((string)($c->getFirstName() ?? ''));
  664.                 $last = trim((string)($c->getLastName() ?? ''));
  665.                 $comp = trim((string)($c->getCompany() ?? ''));
  666.                 $label = $comp !== '' ? $comp : trim($first . ' ' . $last);
  667.                 if ($label === '') {
  668.                     $label = 'contact';
  669.                 }
  671.                 $safe = preg_replace('/[^a-zA-Z0-9._-]/', '_', $label);
  672.                 $vcfPath = $tempDir . DIRECTORY_SEPARATOR . $safe . '.vcf';
  674.                 // This writes the file to $vcfPath (and returns its contents)
  675.                 $businessContactVCFExport->generateVCard($c, $vcfPath);
  676.             }
  678.             // Zip them up
  679.             $zip = new \ZipArchive();
  680.             if ($zip->open($zipPath, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) !== true) {
  681.                 throw new \RuntimeException("Cannot create ZIP archive at: {$zipPath}");
  682.             }
  684.             foreach (glob($tempDir . DIRECTORY_SEPARATOR . '*.vcf') as $file) {
  685.                 $zip->addFile($file, basename($file));
  686.             }
  687.             $zip->close();
  689.         } catch (\Throwable $e) {
  690.             $this->logger->error('Failed to generate ZIP of vCards: ' . $e->getMessage(), ['exception' => $e]);
  691.             // Cleanup temp dir on failure
  692.             foreach (glob($tempDir . DIRECTORY_SEPARATOR . '*') ?: [] as $f) {
  693.                 @unlink($f);
  694.             }
  695.             @rmdir($tempDir);
  696.             return new Response('Failed to generate ZIP: ' . $e->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
  697.         }
  699.         // Cleanup temp dir (ZIP stays until sent)
  700.         foreach (glob($tempDir . DIRECTORY_SEPARATOR . '*') ?: [] as $f) {
  701.             @unlink($f);
  702.         }
  703.         @rmdir($tempDir);
  705.         /** @var BinaryFileResponse $response */
  706.         $response = $this->file($zipPath, $downloadName, ResponseHeaderBag::DISPOSITION_ATTACHMENT);
  707.         // Delete the ZIP after it's been sent to the client
  708.         $response->deleteFileAfterSend(true);
  710.         return $response;
  711.     }
  714.     /**
  715.      * @Route ("/business_contacts_import", name="business_contacts_import" )
  716.      */
  717.     public function businessContactsImport(Request $request, SluggerInterface $slugger, BusinessContactsRepository $businessContactsRepository, ImportBusinessContactsService $businessContactsImportService): Response
  718.     {
  719.         $form = $this->createForm(ImportType::class);
  720.         $form->handleRequest($request);
  721.         if ($form->isSubmitted() && $form->isValid()) {
  722.             $importFile = $form->get('File')->getData();
  723.             if ($importFile) {
  724.                 $originalFilename = pathinfo($importFile->getClientOriginalName(), PATHINFO_FILENAME);
  725.                 $safeFilename = $slugger->slug($originalFilename);
  726.                 $newFilename = $safeFilename . '.' . 'csv';
  727.                 try {
  728.                     $importFile->move(
  729.                         $this->getParameter('business_contacts_import_directory'),
  730.                         $newFilename
  731.                     );
  732.                 } catch (FileException $e) {
  733.                     die('Import failed');
  734.                 }
  735.                 $businessContactsImportService->importBusinessContacts($newFilename);
  736.                 return $this->redirectToRoute('business_contacts_index');
  737.             }
  738.         }
  739.         return $this->render('home/import.html.twig', [
  740.             'form' => $form->createView(),
  741.             'heading' => 'Business Contacts Import',
  742.         ]);
  743.     }
  746.     /**
  747.      * @Route("/update/location", name="update_business_contact_location", methods={"POST"})
  748.      */
  749.     public function updateLocation(BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $manager): Response
  750.     {
  751.         $id = $_POST['id'];
  752.         $latitude = $_POST['latitude'];
  753.         $longitude = $_POST['longitude'];
  754.         $gps = $latitude . ',' . $longitude;
  755.         $business_contact = $businessContactsRepository->find($id);
  756.         $business_contact->setLocationLongitude($longitude)
  757.             ->setLocationLatitude($latitude);
  758.         $manager->flush();
  759.         return new Response(null);
  760.     }
  762.     /**
  763.      * @Route("/gps_location_clear/{id}", name="business_contact_clear_gps_location")
  764.      */
  765.     public
  766.     function clearGPSLocation(Request $request, BusinessContacts $businessContacts, EntityManagerInterface $entityManager)
  767.     {
  768.         $referer = $request->headers->get('referer');
  769.         $businessContacts->setLocationLongitude(null);
  770.         $businessContacts->setLocationLatitude(null);
  771.         $entityManager->flush();
  772.         return $this->redirect($referer);
  773.     }
  776.     /**
  777.      * @Route("/show_attachment/{id}", name="business_contact_show_attachment")
  778.      */
  779.     public function showAttachmentBusinessContact(int $id, BusinessContactsRepository $businessContactsRepository)
  780.     {
  781.         $business_contact = $businessContactsRepository->find($id);
  782.         $filename = $business_contact->getFiles();
  783.         $filepath = $this->getParameter('business_contacts_attachments_directory') . "/" . $filename;
  784.         if (file_exists($filepath)) {
  785.             $response = new BinaryFileResponse($filepath);
  786.             $response->setContentDisposition(
  787.                 ResponseHeaderBag::DISPOSITION_INLINE, //use ResponseHeaderBag::DISPOSITION_ATTACHMENT to save as an attachment
  788.                 $filename
  789.             );
  790.             return $response;
  791.         } else {
  792.             return new Response("file does not exist");
  793.         }
  794.     }
  797. //    /**
  798. //     * @Route("/create/Vcard/{id}", name="create_vcard")
  799. //     */
  800. //    public function createVcard(int $id, BusinessContactsRepository $businessContactsRepository)
  801. //    {
  802. //        $business_contact = $businessContactsRepository->find($id);
  803. //        $vcard = new VCard();
  804. //        $businessOrPerson = $business_contact->getBusinessOrPerson();
  805. //        $business_type = $business_contact->getBusinessType()->getBusinessType();
  806. //        $firstName = $business_contact->getFirstName();
  807. //        $lastName = $business_contact->getLastName();
  808. //        $mobile = $business_contact->getMobile();
  809. //        $landline = $business_contact->getLandline();
  810. //        $company = $business_contact->getCompany();
  811. //        $website = $business_contact->getWebsite();
  812. //        $addressStreet = $business_contact->getAddressStreet();
  813. //        $addressCity = $business_contact->getAddressCity();
  814. //        $addressPostCode = $business_contact->getAddressPostcode();
  815. //        $addressCountry = $business_contact->getAddressCountry();
  816. //        $longitude = $business_contact->getLocationLongitude();
  817. //        $latitude = $business_contact->getLocationLatitude();
  818. //        $notes = $business_contact->getNotes();
  819. //
  820. //        if ($businessOrPerson = "Business") {
  821. //            $firstNameCard = $company;
  822. //            $lastNameCard = $business_type;
  823. //            $companyCard = [];
  824. //        }
  825. //        if ($businessOrPerson = "Person") {
  826. //            $firstNameCard = $firstName;
  827. //            $lastNameCard = $lastName;
  828. //            $companyCard = $company;
  829. //        }
  830. //        $vcard->addName($lastNameCard, $firstNameCard);
  831. //        $vcard->addEmail($business_contact->getEmail())
  832. //            ->addPhoneNumber($landline, 'work')
  833. //            ->addPhoneNumber($mobile, 'mobile')
  834. //            ->addCompany($companyCard)
  835. //            ->addURL($website)
  836. //            ->addNote($notes)
  837. //            ->addAddress($name = '', $extended = '', $street = $addressStreet, $city = $addressCity, $region = '', $zip = $addressPostCode, $country = $addressCountry, $type = 'WORK;POSTAL');
  838. //        $vcard->download();
  839. //        return new Response(null);
  840. //    }
  843.     /**
  844.      * Export a single BusinessContact as vCard with embedded photo.
  845.      * @Route("/create_vcard_business_contact/{id}", name="create_vcard_business_contact", methods={"GET"})
  846.      */
  847.     public function createVCFBusinessContact(Request $request, Security $security, BusinessContacts $businessContacts, BusinessContactVCFExport $exporter): Response
  848.     {
  849.         // Decide filename based on Business vs Person
  850.         $businessOrPerson = (string)($businessContacts->getBusinessOrPerson() ?? 'Person');
  851.         $businessType = method_exists($businessContacts, 'getBusinessType') && $businessContacts->getBusinessType()
  852.             ? (string)$businessContacts->getBusinessType()->getBusinessType()
  853.             : '';
  855.         if (strcasecmp($businessOrPerson, 'Business') === 0) {
  856.             $baseA = (string)($businessContacts->getCompany() ?? 'Company');
  857.             $baseB = $businessType !== '' ? $businessType : 'Business';
  858.         } else {
  859.             $baseA = (string)($businessContacts->getFirstName() ?? 'Unknown');
  860.             $baseB = (string)($businessContacts->getLastName() ?? 'Contact');
  861.         }
  863.         // Sanitize but keep the comma between parts
  864.         $safe = fn(string $s) => preg_replace('/[^\w\-\.\s]/u', '', $s); // allow letters, numbers, _, -, ., space
  865.         $fileName = sprintf('%s,%s.vcf', $safe($baseA), $safe($baseB));
  867.         $exportDir = $exporter->getExportDirectory();
  868.         if (!is_dir($exportDir) || !is_writable($exportDir)) {
  869.             return new Response("Export directory is not writable: $exportDir", Response::HTTP_INTERNAL_SERVER_ERROR);
  870.         }
  872.         $filePath = rtrim($exportDir, '/\\') . DIRECTORY_SEPARATOR . $fileName;
  874.         try {
  875.             $exporter->generateVCard($businessContacts, $filePath);
  876.         } catch (\Throwable $e) {
  877.             return new Response('Failed to generate vCard: ' . $e->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
  878.         }
  880.         if (!is_file($filePath) || filesize($filePath) === 0) {
  881.             return new Response('vCard file was not created or is empty.', Response::HTTP_INTERNAL_SERVER_ERROR);
  882.         }
  884.         // Force download with your exact requested filename
  885.         return $this->file($filePath, $fileName, ResponseHeaderBag::DISPOSITION_ATTACHMENT);
  886.     }
  889. }