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.         // Admins see ALL; others only 'Approved'
  161.         $isAdmin = $this->isGranted('ROLE_ADMIN');
  163.         // Build criteria
  164.         $criteria = [];
  165.         if (!$isAdmin) {
  166.             $criteria['status'] = 'Approved';
  167.         }
  169.         if ($subset !== 'All') {
  170.             $business_type = $businessTypesRepository->findOneBy(['businessType' => $subset]);
  171.             // If the subset name is invalid, return no results instead of error
  172.             if ($business_type) {
  173.                 $criteria['businessType'] = $business_type;
  174.             } else {
  175.                 $business_contacts = [];
  176.             }
  177.         }
  179.         // Fetch contacts (if not already set due to invalid subset)
  180.         if (!isset($business_contacts)) {
  181.             $business_contacts = $businessContactsRepository->findBy($criteria);
  182.         }
  184.         // Compute map stats (only count rows with valid coords)
  185.         $latitude_total = 0.0;
  186.         $longitude_total = 0.0;
  187.         $count = 0;
  189.         $latitude_max = -100.0;
  190.         $latitude_min = 100.0;
  191.         $longitude_max = -100.0;
  192.         $longitude_min = 100.0;
  194.         foreach ($business_contacts as $business_contact) {
  195.             $lat = $business_contact->getLocationLatitude();
  196.             $lng = $business_contact->getLocationLongitude();
  198.             // Must have both coords and not be zero
  199.             if ($lat !== null && $lng !== null && (float)$lat !== 0.0 && (float)$lng !== 0.0) {
  200.                 $count++;
  201.                 $latitude_total  += (float)$lat;
  202.                 $longitude_total += (float)$lng;
  204.                 if ($lat > $latitude_max)   $latitude_max = (float)$lat;
  205.                 if ($lat < $latitude_min)   $latitude_min = (float)$lat;
  206.                 if ($lng > $longitude_max)  $longitude_max = (float)$lng;
  207.                 if ($lng < $longitude_min)  $longitude_min = (float)$lng;
  208.             }
  209.         }
  211.         if ($count === 0) {
  212.             $latitude_average = 'No data';
  213.             $longitude_average = 'No data';
  214.             $latitude_range = 'TBD';
  215.             $longitude_range = 'TBD';
  216.         } else {
  217.             $latitude_average = $latitude_total / $count;
  218.             $longitude_average = $longitude_total / $count;
  220.             if ($count === 1) {
  221.                 $latitude_range = 'TBD';
  222.                 $longitude_range = 'TBD';
  223.             } else {
  224.                 $latitude_range  = $latitude_max - $latitude_min;
  225.                 $longitude_range = $longitude_max - $longitude_min;
  226.             }
  227.         }
  229.         $business_types = $businessTypesRepository->findBy([], ['ranking' => 'ASC']);
  231.         return $this->render('business_contacts/map_of_business_contacts.html.twig', [
  232. //            'google_maps_api_key' => $this->getParameter('google_maps_api_key'), // e.g. set in services.yaml or .env
  233.             'business_contacts'   => $business_contacts,
  234.             'business_types'      => $business_types,
  235.             'subset'              => $subset,
  236.             'latitude_max'        => $latitude_max,
  237.             'latitude_min'        => $latitude_min,
  238.             'latitude_average'    => $latitude_average,
  239.             'latitude_range'      => $latitude_range,
  240.             'longitude_max'       => $longitude_max,
  241.             'longitude_min'       => $longitude_min,
  242.             'longitude_average'   => $longitude_average,
  243.             'longitude_range'     => $longitude_range,
  244.             'count'               => $count,
  245.             'list_or_map'         => 'map',
  246.             'admin_check'         => $isAdmin ? 'Yes' : 'No',
  247.         ]);
  248.     }
  250.     /**
  251.      * @Route("/new/{business_type}", name="business_contacts_new", methods={"GET", "POST"})
  252.      */
  253.     public function new(Request $request, string $business_type, BusinessContactsRepository $businessContactsRepository, BusinessTypesRepository $businessTypesRepository, CompanyDetailsService $companyDetails, EntityManagerInterface $entityManager): Response
  254.     {
  255.         $business_type = $businessTypesRepository->find($business_type);
  256.         $default_country = $companyDetails->getCompanyDetails()->getCompanyAddressCountry();
  257.         $businessContact = new BusinessContacts();
  258.         $businessContact->setBusinessType($business_type);
  259.         $businessContact->setAddressCountry($default_country);
  260.         $form = $this->createForm(BusinessContactsType::class, $businessContact);
  261.         $form->handleRequest($request);
  263.         if ($form->isSubmitted() && $form->isValid()) {
  264.             $photo = $form['photo']->getData();
  265.             if ($photo) {
  266.                 $uniqueId = uniqid(); // Generates a unique ID
  267.                 $uniqueId3digits = substr($uniqueId, 10, 3); // Extracts the first 3 digits
  268.                 $files_name = [];
  269.                 $photo_directory = $this->getParameter('business_contacts_photos_directory');
  270.                 $fileName = pathinfo($photo->getClientOriginalName(), PATHINFO_FILENAME);
  271.                 $file_extension = $photo->guessExtension();
  272.                 $newFileName = $businessContact->getCompany() . "_" . $uniqueId3digits . "." . $file_extension;
  273.                 $photo->move($photo_directory, $newFileName);
  274.                 $businessContact->setPhoto($newFileName);
  275.             }
  277.             $file = $form['files']->getData();
  278.             if ($file) {
  279.                 $file_name = [];
  280.                 $file_directory = $this->getParameter('business_contacts_attachments_directory');
  281.                 $fileName = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
  282.                 $file_extension = $file->guessExtension();
  283.                 $newFileName = $fileName . "." . $file_extension;
  284.                 $file->move($file_directory, $newFileName);
  285.                 $businessContact->setFiles($newFileName);
  286.             }
  289.             $businessContactsRepository->add($businessContact, true);
  290.             $firstName = $businessContact->getFirstName();
  291.             $lastName = $businessContact->getLastName();
  292.             $entityManager->persist($businessContact);
  293.             $entityManager->flush();
  294.             return $this->redirectToRoute('business_contacts_index', [], Response::HTTP_SEE_OTHER);
  295.         }
  297.         return $this->renderForm('business_contacts/new.html.twig', [
  298.             'business_contact' => $businessContact,
  299.             'form' => $form,
  300.         ]);
  301.     }
  303.     /**
  304.      * @Route("/suggestion", name="business_contacts_suggestion", methods={"GET", "POST"})
  305.      */
  306.     public function suggestion(Request $request, BusinessContactsRepository $businessContactsRepository): Response
  307.     {
  308.         $businessContact = new BusinessContacts();
  309.         $form = $this->createForm(BusinessContactsType::class, $businessContact);
  310.         $form->handleRequest($request);
  312.         if ($form->isSubmitted() && $form->isValid()) {
  313.             $businessContactsRepository->add($businessContact, true);
  314.             $businessContact->setStatus('Pending');
  316.             return $this->redirectToRoute('business_contacts_index', [], Response::HTTP_SEE_OTHER);
  317.         }
  319.         return $this->renderForm('business_contacts/new.html.twig', [
  320.             'business_contact' => $businessContact,
  321.             'form' => $form,
  322.         ]);
  323.     }
  325.     /**
  326.      * @Route("/show/{id}", name="business_contacts_show", methods={"GET"})
  327.      */
  328.     public function show(BusinessContacts $businessContact): Response
  329.     {
  330.         $longitude = $businessContact->getLocationLongitude();
  331.         $latitude = $businessContact->getLocationLatitude();
  332.         return $this->render('business_contacts/show.html.twig', [
  333.             'business_contact' => $businessContact,
  334.             'longitude' => $longitude,
  335.             'latitude' => $latitude,
  336.         ]);
  337.     }
  339.     /**
  340.      * @Route("/edit/{id}", name="business_contacts_edit", methods={"GET", "POST"})
  341.      */
  342.     public function edit(Request $request, BusinessContacts $businessContact, BusinessContactsRepository $businessContactsRepository): Response
  343.     {
  344.         $form = $this->createForm(BusinessContactsType::class, $businessContact);
  345.         $form->handleRequest($request);
  347.         if ($form->isSubmitted() && $form->isValid()) {
  348.             $photo = $form['photo']->getData();
  349.             if ($photo) {
  350.                 $files_name = [];
  351.                 $photo_directory = $this->getParameter('business_contacts_photos_directory');
  352.                 $fileName = pathinfo($photo->getClientOriginalName(), PATHINFO_FILENAME);
  353.                 $file_extension = $photo->guessExtension();
  354.                 if ($businessContact->getFirstName() == '') {
  355.                     $newFileName = $businessContact->getCompany() . "." . $file_extension;
  356.                 } else {
  357.                     $newFileName = $businessContact->getCompany() . "_" . $businessContact->getFirstName() . "_" . $businessContact->getLastName() . "." . $file_extension;
  358.                 }
  360.                 $photo->move($photo_directory, $newFileName);
  361.                 $businessContact->setPhoto($newFileName);
  362.             }
  364.             $file = $form['files']->getData();
  365.             if ($file) {
  366.                 $file_name = [];
  367.                 $file_directory = $this->getParameter('business_contacts_attachments_directory');
  368.                 $fileName = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
  369.                 $file_extension = $file->guessExtension();
  370.                 $newFileName = $fileName . "." . $file_extension;
  371.                 $file->move($file_directory, $newFileName);
  372.                 $businessContact->setFiles($newFileName);
  373.             }
  375.             $businessContactsRepository->add($businessContact, true);
  377.             return $this->redirectToRoute('business_contacts_index', [], Response::HTTP_SEE_OTHER);
  378.         }
  380.         return $this->renderForm('business_contacts/edit.html.twig', [
  381.             'business_contact' => $businessContact,
  382.             'form' => $form,
  383.         ]);
  384.     }
  386.     /**
  387.      * @Route("/delete/{id}", name="business_contacts_delete", methods={"POST"})
  388.      */
  389.     public function delete(Request $request, BusinessContacts $businessContact, BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $entityManager): Response
  390.     {
  391.         $referer = $request->headers->get('referer');
  392.         $file_name = $businessContact->getFiles();
  394.         if ($file_name) {
  395.             $file = $this->getParameter('business_contacts_attachments_directory') . $file_name;
  396.             if (file_exists($file)) {
  397.                 unlink($file);
  398.             }
  399.             $businessContact->setFiles('');
  400.             $entityManager->flush();
  401.         }
  403.         $photo_file_name = $businessContact->getPhoto();
  404.         if ($photo_file_name) {
  405.             $photo_file_name = $this->getParameter('business_contacts_photos_directory') . $photo_file_name;
  406.             if (file_exists($photo_file_name)) {
  407.                 unlink($photo_file_name);
  408.             }
  409.             $businessContact->setPhoto('');
  410.             $entityManager->flush();
  411.         }
  413.         if ($this->isCsrfTokenValid('delete' . $businessContact->getId(), $request->request->get('_token'))) {
  414.             $businessContactsRepository->remove($businessContact, true);
  415.         }
  416.         return $this->redirect($referer);
  417.     }
  419.     /**
  420.      * @Route("/delete_GPS_location/{id}", name="business_contacts_delete_GPS_location", methods={"GET","POST"})
  421.      */
  422.     public function deleteGPSLocation(Request $request, int $id, BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $entityManager): Response
  423.     {
  424.         $referer = $request->headers->get('referer');
  425.         $businessContact = $businessContactsRepository->find($id);
  426.         $businessContact->setLocationLatitude(null);
  427.         $businessContact->setLocationLongitude(null);
  428.         $entityManager->flush();
  430.         return $this->redirect($referer ?: $this->generateUrl('business_contacts_index'));
  431.     }
  434.     /**
  435.      * @Route("/delete_all_GPS_locations", name="business_contacts_delete_all_GPS_locations")
  436.      */
  437.     public function deleteAllBusinessContactsGPSLocations(Request $request, BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $entityManager): Response
  438.     {
  439.         $referer = $request->headers->get('referer');
  440.         $business_contacts = $businessContactsRepository->findAll();
  441.         foreach ($business_contacts as $business_contact) {
  442.             $business_contact->setLocationLongitude(null);
  443.             $business_contact->setLocationLatitude(null);
  444.             $entityManager->flush();
  445.         }
  446.         return $this->redirect($referer ?: $this->generateUrl('business_contacts_index'));
  447.     }
  450.     /**
  451.      * @Route("/delete_all", name="business_contacts_delete_all")
  452.      */
  453.     public function deleteAllBusinessContacts(BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $entityManager): Response
  454.     {
  455.         $business_contacts = $businessContactsRepository->findAll();
  456.         foreach ($business_contacts as $business_contact) {
  457.             $entityManager->remove($business_contact);
  458.             $entityManager->flush();
  459.         }
  460.         return $this->redirectToRoute('business_contacts_index', [], Response::HTTP_SEE_OTHER);
  461.     }
  464.     /**
  465.      * @Route("/delete_photo_file/{id}", name="business_contact_delete_photo_file", methods={"POST", "GET"})
  466.      */
  467.     public function deleteBusinessContactPhotoFile(int $id, Request $request, BusinessContacts $businessContact, EntityManagerInterface $entityManager)
  468.     {
  469.         $referer = $request->headers->get('referer');
  470.         $photo_file_name = $businessContact->getPhoto();
  471.         if ($photo_file_name) {
  472.             $photo_file_name = $this->getParameter('business_contacts_photos_directory') . "/" . $photo_file_name;
  473.             if (file_exists($photo_file_name)) {
  474.                 unlink($photo_file_name);
  475.             }
  476.             $businessContact->setPhoto('');
  477.             $entityManager->flush();
  478.         }
  479.         return $this->redirect($referer);
  480.     }
  482.     /**
  483.      * @Route("/delete_attachment_file/{id}", name="business_contact_delete_attachment_file", methods={"POST", "GET"})
  484.      */
  485.     public function deleteBusinessContactAttachmentFile(int $id, Request $request, BusinessContacts $businessContact, EntityManagerInterface $entityManager)
  486.     {
  487.         $referer = $request->headers->get('referer');
  488.         $file_name = $businessContact->getFiles();
  489.         if ($file_name) {
  490.             $file = $this->getParameter('business_contacts_attachments_directory') . "/" . $file_name;
  491.             if (file_exists($file)) {
  492.                 unlink($file);
  493.             }
  494.             $businessContact->setFiles('');
  495.             $entityManager->flush();
  496.         }
  497.         return $this->redirect($referer);
  498.     }
  500.     /**
  501.      * @Route ("/view/photo/{id}", name="view_business_contact_photo")
  502.      */
  503.     public function viewBusinessContactPhoto(Request $request, $id, BusinessContactsRepository $businessContactsRepository)
  504.     {
  505.         $business_contact = $businessContactsRepository->find($id);
  506.         return $this->render('business_contacts/view_photo.html.twig', ['business_contact' => $business_contact]);
  507.     }
  510.     /**
  511.      * @Route ("/business_contacts_export", name="business_contacts_export" )
  512.      */
  513.     public function businessContactsExport(BusinessContactsRepository $businessContactsRepository)
  514.     {
  515.         $data = [];
  516.         $exported_date = new \DateTime('now');
  517.         $exported_date_formatted = $exported_date->format('d-M-Y');
  518.         $fileName = 'business_contacts_export_' . $exported_date_formatted . '.csv';
  520.         $count = 0;
  521.         $business_contact_list = $businessContactsRepository->findAll();
  522.         foreach ($business_contact_list as $business_contact) {
  524.             $data[] = [
  525.                 "BusinessContacts",
  526.                 $business_contact->getStatus(),
  527.                 $business_contact->getBusinessOrPerson(),
  528.                 $business_contact->getBusinessType()->getBusinessType(),
  529.                 $business_contact->getCompany(),
  530.                 $business_contact->getFirstName(),
  532.                 $business_contact->getLastName(),
  533.                 $business_contact->getWebsite(),
  534.                 $business_contact->getEmail(),
  535.                 $business_contact->getLandline(),
  536.                 $business_contact->getMobile(),
  538.                 $business_contact->getAddressStreet(),
  539.                 $business_contact->getAddressCity(),
  540.                 $business_contact->getAddressCounty(),
  541.                 $business_contact->getAddressPostCode(),
  542.                 $business_contact->getAddressCountry(),
  544.                 $business_contact->getLocationLongitude(),
  545.                 $business_contact->getLocationLatitude(),
  546.                 $business_contact->getNotes()
  547.             ];
  548.         }
  549.         $spreadsheet = new Spreadsheet();
  550.         $sheet = $spreadsheet->getActiveSheet();
  551.         $sheet->setTitle('Business Contacts');
  552.         $sheet->getCell('A1')->setValue('Entity');
  553.         $sheet->getCell('B1')->setValue('Status');
  554.         $sheet->getCell('C1')->setValue('Business Or Person');
  555.         $sheet->getCell('D1')->setValue('Business Type');
  556.         $sheet->getCell('E1')->setValue('Company');
  557.         $sheet->getCell('F1')->setValue('First Name');
  559.         $sheet->getCell('G1')->setValue('Last Name');
  560.         $sheet->getCell('H1')->setValue('Web Page');
  561.         $sheet->getCell('I1')->setValue('E-mail');
  562.         $sheet->getCell('J1')->setValue('Business Phone');
  563.         $sheet->getCell('K1')->setValue('Mobile Phone');
  565.         $sheet->getCell('L1')->setValue('Business Street');
  566.         $sheet->getCell('M1')->setValue('Business City');
  567.         $sheet->getCell('N1')->setValue('Business County');
  568.         $sheet->getCell('O1')->setValue('Business Postal Code');
  569.         $sheet->getCell('P1')->setValue('Business Country/Region');
  571.         $sheet->getCell('Q1')->setValue('Location Longitude');
  572.         $sheet->getCell('R1')->setValue('Location Latitude');
  573.         $sheet->getCell('S1')->setValue('Notes');
  575.         $sheet->fromArray($data, null, 'A2', true);
  576.         $total_rows = $sheet->getHighestRow();
  577.         for ($i = 2; $i <= $total_rows; $i++) {
  578.             $cell = "L" . $i;
  579.             $sheet->getCell($cell)->getHyperlink()->setUrl("https://google.com");
  580.         }
  581.         $writer = new Csv($spreadsheet);
  582.         $response = new StreamedResponse(function () use ($writer) {
  583.             $writer->save('php://output');
  584.         });
  585.         $response->headers->set('Content-Type', 'application/vnd.ms-excel');
  586.         $response->headers->set('Content-Disposition', sprintf('attachment;filename="%s"', $fileName));
  587.         $response->headers->set('Cache-Control', 'max-age=0');
  588.         return $response;
  589.     }
  592.     /**
  593.      * Export all BusinessContacts as a ZIP of individual .vcf files.
  594.      *
  595.      * @Route("/business_contacts_export_vcf_zip", name="business_contacts_export_vcf_zip", methods={"GET"})
  596.      */
  597.     public function exportBusinessContactsAsZip(BusinessContactsRepository $businessContactsRepository, BusinessContactVCFExport $businessContactVCFExport): Response
  598.     {
  599.         $contacts = $businessContactsRepository->findAll();
  600.         if (!$contacts) {
  601.             return new Response('No contacts to export.', Response::HTTP_NO_CONTENT);
  602.         }
  604.         // Final file name: business_contacts_YYYYMMDD.zip
  605.         $datePart = (new \DateTimeImmutable('now'))->format('Ymd');
  606.         $baseName = "business_contacts_{$datePart}";
  607.         $exportDir = rtrim($businessContactVCFExport->getExportDirectory(), "/\\");
  608.         $zipPath = $exportDir . DIRECTORY_SEPARATOR . $baseName . '.zip';
  610.         // Ensure export dir is OK
  611.         if (!is_dir($exportDir) || !is_writable($exportDir)) {
  612.             $msg = "Export directory is not writable: {$exportDir}";
  613.             $this->logger->error($msg);
  614.             return new Response($msg, Response::HTTP_INTERNAL_SERVER_ERROR);
  615.         }
  617.         // Make name unique if needed
  618.         if (file_exists($zipPath)) {
  619.             $i = 1;
  620.             do {
  621.                 $zipPath = $exportDir . DIRECTORY_SEPARATOR . $baseName . '-' . $i . '.zip';
  622.                 $i++;
  623.             } while (file_exists($zipPath));
  624.         }
  625.         $downloadName = basename($zipPath); // what the user downloads
  627.         // Create temp dir for individual VCFs
  628.         $tempDir = sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'bc_vcards_' . bin2hex(random_bytes(6));
  629.         if (!@mkdir($tempDir, 0777, true) && !is_dir($tempDir)) {
  630.             $msg = "Failed to create temporary directory: {$tempDir}";
  631.             $this->logger->error($msg);
  632.             return new Response($msg, Response::HTTP_INTERNAL_SERVER_ERROR);
  633.         }
  635.         try {
  636.             // Write each contact as its own .vcf using the service's BusinessContacts generator
  637.             foreach ($contacts as $c) {
  638.                 $first = trim((string)($c->getFirstName() ?? ''));
  639.                 $last = trim((string)($c->getLastName() ?? ''));
  640.                 $comp = trim((string)($c->getCompany() ?? ''));
  641.                 $label = $comp !== '' ? $comp : trim($first . ' ' . $last);
  642.                 if ($label === '') {
  643.                     $label = 'contact';
  644.                 }
  646.                 $safe = preg_replace('/[^a-zA-Z0-9._-]/', '_', $label);
  647.                 $vcfPath = $tempDir . DIRECTORY_SEPARATOR . $safe . '.vcf';
  649.                 // This writes the file to $vcfPath (and returns its contents)
  650.                 $businessContactVCFExport->generateVCard($c, $vcfPath);
  651.             }
  653.             // Zip them up
  654.             $zip = new \ZipArchive();
  655.             if ($zip->open($zipPath, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) !== true) {
  656.                 throw new \RuntimeException("Cannot create ZIP archive at: {$zipPath}");
  657.             }
  659.             foreach (glob($tempDir . DIRECTORY_SEPARATOR . '*.vcf') as $file) {
  660.                 $zip->addFile($file, basename($file));
  661.             }
  662.             $zip->close();
  664.         } catch (\Throwable $e) {
  665.             $this->logger->error('Failed to generate ZIP of vCards: ' . $e->getMessage(), ['exception' => $e]);
  666.             // Cleanup temp dir on failure
  667.             foreach (glob($tempDir . DIRECTORY_SEPARATOR . '*') ?: [] as $f) {
  668.                 @unlink($f);
  669.             }
  670.             @rmdir($tempDir);
  671.             return new Response('Failed to generate ZIP: ' . $e->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
  672.         }
  674.         // Cleanup temp dir (ZIP stays until sent)
  675.         foreach (glob($tempDir . DIRECTORY_SEPARATOR . '*') ?: [] as $f) {
  676.             @unlink($f);
  677.         }
  678.         @rmdir($tempDir);
  680.         /** @var BinaryFileResponse $response */
  681.         $response = $this->file($zipPath, $downloadName, ResponseHeaderBag::DISPOSITION_ATTACHMENT);
  682.         // Delete the ZIP after it's been sent to the client
  683.         $response->deleteFileAfterSend(true);
  685.         return $response;
  686.     }
  689.     /**
  690.      * @Route ("/business_contacts_import", name="business_contacts_import" )
  691.      */
  692.     public function businessContactsImport(Request $request, SluggerInterface $slugger, BusinessContactsRepository $businessContactsRepository, ImportBusinessContactsService $businessContactsImportService): Response
  693.     {
  694.         $form = $this->createForm(ImportType::class);
  695.         $form->handleRequest($request);
  696.         if ($form->isSubmitted() && $form->isValid()) {
  697.             $importFile = $form->get('File')->getData();
  698.             if ($importFile) {
  699.                 $originalFilename = pathinfo($importFile->getClientOriginalName(), PATHINFO_FILENAME);
  700.                 $safeFilename = $slugger->slug($originalFilename);
  701.                 $newFilename = $safeFilename . '.' . 'csv';
  702.                 try {
  703.                     $importFile->move(
  704.                         $this->getParameter('business_contacts_import_directory'),
  705.                         $newFilename
  706.                     );
  707.                 } catch (FileException $e) {
  708.                     die('Import failed');
  709.                 }
  710.                 $businessContactsImportService->importBusinessContacts($newFilename);
  711.                 return $this->redirectToRoute('business_contacts_index');
  712.             }
  713.         }
  714.         return $this->render('home/import.html.twig', [
  715.             'form' => $form->createView(),
  716.             'heading' => 'Business Contacts Import',
  717.         ]);
  718.     }
  721.     /**
  722.      * @Route("/update/location", name="update_business_contact_location", methods={"POST"})
  723.      */
  724.     public function updateLocation(BusinessContactsRepository $businessContactsRepository, EntityManagerInterface $manager): Response
  725.     {
  726.         $id = $_POST['id'];
  727.         $latitude = $_POST['latitude'];
  728.         $longitude = $_POST['longitude'];
  729.         $gps = $latitude . ',' . $longitude;
  730.         $business_contact = $businessContactsRepository->find($id);
  731.         $business_contact->setLocationLongitude($longitude)
  732.             ->setLocationLatitude($latitude);
  733.         $manager->flush();
  734.         return new Response(null);
  735.     }
  737.     /**
  738.      * @Route("/gps_location_clear/{id}", name="business_contact_clear_gps_location")
  739.      */
  740.     public
  741.     function clearGPSLocation(Request $request, BusinessContacts $businessContacts, EntityManagerInterface $entityManager)
  742.     {
  743.         $referer = $request->headers->get('referer');
  744.         $businessContacts->setLocationLongitude(null);
  745.         $businessContacts->setLocationLatitude(null);
  746.         $entityManager->flush();
  747.         return $this->redirect($referer);
  748.     }
  751.     /**
  752.      * @Route("/show_attachment/{id}", name="business_contact_show_attachment")
  753.      */
  754.     public function showAttachmentBusinessContact(int $id, BusinessContactsRepository $businessContactsRepository)
  755.     {
  756.         $business_contact = $businessContactsRepository->find($id);
  757.         $filename = $business_contact->getFiles();
  758.         $filepath = $this->getParameter('business_contacts_attachments_directory') . "/" . $filename;
  759.         if (file_exists($filepath)) {
  760.             $response = new BinaryFileResponse($filepath);
  761.             $response->setContentDisposition(
  762.                 ResponseHeaderBag::DISPOSITION_INLINE, //use ResponseHeaderBag::DISPOSITION_ATTACHMENT to save as an attachment
  763.                 $filename
  764.             );
  765.             return $response;
  766.         } else {
  767.             return new Response("file does not exist");
  768.         }
  769.     }
  772. //    /**
  773. //     * @Route("/create/Vcard/{id}", name="create_vcard")
  774. //     */
  775. //    public function createVcard(int $id, BusinessContactsRepository $businessContactsRepository)
  776. //    {
  777. //        $business_contact = $businessContactsRepository->find($id);
  778. //        $vcard = new VCard();
  779. //        $businessOrPerson = $business_contact->getBusinessOrPerson();
  780. //        $business_type = $business_contact->getBusinessType()->getBusinessType();
  781. //        $firstName = $business_contact->getFirstName();
  782. //        $lastName = $business_contact->getLastName();
  783. //        $mobile = $business_contact->getMobile();
  784. //        $landline = $business_contact->getLandline();
  785. //        $company = $business_contact->getCompany();
  786. //        $website = $business_contact->getWebsite();
  787. //        $addressStreet = $business_contact->getAddressStreet();
  788. //        $addressCity = $business_contact->getAddressCity();
  789. //        $addressPostCode = $business_contact->getAddressPostcode();
  790. //        $addressCountry = $business_contact->getAddressCountry();
  791. //        $longitude = $business_contact->getLocationLongitude();
  792. //        $latitude = $business_contact->getLocationLatitude();
  793. //        $notes = $business_contact->getNotes();
  794. //
  795. //        if ($businessOrPerson = "Business") {
  796. //            $firstNameCard = $company;
  797. //            $lastNameCard = $business_type;
  798. //            $companyCard = [];
  799. //        }
  800. //        if ($businessOrPerson = "Person") {
  801. //            $firstNameCard = $firstName;
  802. //            $lastNameCard = $lastName;
  803. //            $companyCard = $company;
  804. //        }
  805. //        $vcard->addName($lastNameCard, $firstNameCard);
  806. //        $vcard->addEmail($business_contact->getEmail())
  807. //            ->addPhoneNumber($landline, 'work')
  808. //            ->addPhoneNumber($mobile, 'mobile')
  809. //            ->addCompany($companyCard)
  810. //            ->addURL($website)
  811. //            ->addNote($notes)
  812. //            ->addAddress($name = '', $extended = '', $street = $addressStreet, $city = $addressCity, $region = '', $zip = $addressPostCode, $country = $addressCountry, $type = 'WORK;POSTAL');
  813. //        $vcard->download();
  814. //        return new Response(null);
  815. //    }
  818.     /**
  819.      * Export a single BusinessContact as vCard with embedded photo.
  820.      * @Route("/create_vcard_business_contact/{id}", name="create_vcard_business_contact", methods={"GET"})
  821.      */
  822.     public function createVCFBusinessContact(
  823.         Request                  $request,
  824.         Security                 $security,
  825.         BusinessContacts         $businessContacts,
  826.         BusinessContactVCFExport $exporter
  827.     ): Response
  828.     {
  829.         // Decide filename based on Business vs Person
  830.         $businessOrPerson = (string)($businessContacts->getBusinessOrPerson() ?? 'Person');
  831.         $businessType = method_exists($businessContacts, 'getBusinessType') && $businessContacts->getBusinessType()
  832.             ? (string)$businessContacts->getBusinessType()->getBusinessType()
  833.             : '';
  835.         if (strcasecmp($businessOrPerson, 'Business') === 0) {
  836.             $baseA = (string)($businessContacts->getCompany() ?? 'Company');
  837.             $baseB = $businessType !== '' ? $businessType : 'Business';
  838.         } else {
  839.             $baseA = (string)($businessContacts->getFirstName() ?? 'Unknown');
  840.             $baseB = (string)($businessContacts->getLastName() ?? 'Contact');
  841.         }
  843.         // Sanitize but keep the comma between parts
  844.         $safe = fn(string $s) => preg_replace('/[^\w\-\.\s]/u', '', $s); // allow letters, numbers, _, -, ., space
  845.         $fileName = sprintf('%s,%s.vcf', $safe($baseA), $safe($baseB));
  847.         $exportDir = $exporter->getExportDirectory();
  848.         if (!is_dir($exportDir) || !is_writable($exportDir)) {
  849.             return new Response("Export directory is not writable: $exportDir", Response::HTTP_INTERNAL_SERVER_ERROR);
  850.         }
  852.         $filePath = rtrim($exportDir, '/\\') . DIRECTORY_SEPARATOR . $fileName;
  854.         try {
  855.             $exporter->generateVCard($businessContacts, $filePath);
  856.         } catch (\Throwable $e) {
  857.             return new Response('Failed to generate vCard: ' . $e->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
  858.         }
  860.         if (!is_file($filePath) || filesize($filePath) === 0) {
  861.             return new Response('vCard file was not created or is empty.', Response::HTTP_INTERNAL_SERVER_ERROR);
  862.         }
  864.         // Force download with your exact requested filename
  865.         return $this->file($filePath, $fileName, ResponseHeaderBag::DISPOSITION_ATTACHMENT);
  866.     }
  869. }