Symfony Profiler

<?php
namespace App\Controller;
use App\Entity\Lot;
use App\Form\ImportType;
use App\Form\LotBulkAuction;
use App\Form\LotBulkChangeStatus;
use App\Form\LotBulkDelete;
use App\Form\LotBulkImageDelete;
use App\Form\LotBulkReportSale;
use App\Form\LotBulkReportSold;
use App\Form\LotBulkReturn;
use App\Form\LotType;
use App\Repository\AuctionRepository;
use App\Repository\CategoryRepository;
use App\Repository\ChangeLogRepository;
use App\Repository\ClientRepository;
use App\Repository\CountryRepository;
use App\Repository\DealerRepository;
use App\Repository\InvoiceRepository;
use App\Repository\LotRepository;
use App\Service\ImportService;
use App\Service\ExportService;
use Doctrine\Persistence\ManagerRegistry;
use PhpOffice\PhpSpreadsheet\Exception;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Mailer\Exception\TransportExceptionInterface;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Validator\Constraints;
use Symfony\Component\Validator\Validator\ValidatorInterface;
/**
* @Route("/")
*/
class LotController extends AbstractController
{
use SortByIdsTrait;
/**
* @Route("/", name="lot_index", methods={"GET"})
*
* @param Request $request
* @param LotRepository $lotRepository
* @param AuctionRepository $auctionRepository
* @param CountryRepository $countryRepository
* @param CategoryRepository $categoryRepository
* @param DealerRepository $dealerRepository
* @param ClientRepository $clientRepository
* @param InvoiceRepository $invoiceRepository
*
* @return Response
*/
public function index(
Request $request,
LotRepository $lotRepository,
AuctionRepository $auctionRepository,
CountryRepository $countryRepository,
CategoryRepository $categoryRepository,
DealerRepository $dealerRepository,
ClientRepository $clientRepository,
InvoiceRepository $invoiceRepository
): Response {
$this->denyAccessUnlessGranted('IS_AUTHENTICATED_FULLY');
$perPage = 100;
$filters = [];
$sort = $request->query->get('sort');
$sortOrder = $request->query->get('sortOrder');
$term = $request->query->get('term');
$page = $request->query->get('page', 1);
$ids = $request->query->get('ids', false);
$filters['auction'] = $request->query->get('auction');
$filters['country'] = $request->query->get('country');
$filters['category'] = $request->query->get('category');
$filters['category2'] = $request->query->get('category2');
$filters['nominal'] = $request->query->get('nominal');
$filters['year'] = $request->query->get('year');
$filters['dealer'] = $request->query->get('dealer');
$filters['customer'] = $request->query->get('customer');
$filters['status'] = $request->query->get('status');
$filters['invoice'] = $request->query->get('invoice');
$filters['checked'] = $request->query->get('checked');
$filters['statusPhoto'] = $request->query->get('statusPhoto');
if ($ids) {
$perPage = null;
$page = null;
$sort = null;
$sortOrder = null;
}
$lotsIds = $lotRepository->getAll($term, $sort, $sortOrder, $filters, null);
$availableIds = array_column(
array_slice($lotsIds, ($page - 1) * $perPage, $perPage),
'id'
);
$lots = $lotRepository->getAllByIds($availableIds);
$lots = $this->sortByIds($lots, $availableIds);
if ($ids) {
$return = [];
foreach ($lots as $lot) {
$return[] = $lot->getId();
}
return new JsonResponse($return);
}
$lotsCount = $lotRepository->getCount($term, $filters);
$pages = ceil($lotsCount / $perPage);
$auctions = $auctionRepository->getAll();
$countries = $countryRepository->findBy([], ['name' => 'ASC']);
$categories = $categoryRepository->findBy([], ['name' => 'ASC']);
$dealers = $dealerRepository->getAll();
$customers = $clientRepository->getAll();
$statuses = Lot::getStatuses();
$invoices = $invoiceRepository->findAll();
return $this->render('lot/index.html.twig', [
'lots' => $lots,
'sort' => $sort,
'sortOrder' => $sortOrder,
'page' => $page,
'filters' => $filters,
'pages' => $pages,
'total' => $lotsCount,
'term' => $term,
'auctions' => $auctions,
'countries' => $countries,
'categories' => $categories,
'dealers' => $dealers,
'customers' => $customers,
'statuses' => $statuses,
'invoices' => $invoices,
]);
}
/**
* @Route("/lot/new", name="lot_new", methods={"GET","POST"})
*
* @param Request $request
* @param ManagerRegistry $doctrine
*
* @return Response
*/
public function new(Request $request, ManagerRegistry $doctrine): Response
{
if (!$this->isGranted('ROLE_WAREHOUSE') && !$this->isGranted('ROLE_EDITOR')) {
throw $this->createAccessDeniedException();
}
$lot = new Lot();
$form = $this->createForm(LotType::class, $lot);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$entityManager = $doctrine->getManager();
$entityManager->persist($lot);
$entityManager->flush();
return $this->redirectToRoute('lot_index');
}
return $this->render('lot/new.html.twig', [
'lot' => $lot,
'form' => $form->createView(),
'image' => null,
'imageA' => null,
'imageB' => null,
'missing' => [],
'changes' => [],
]);
}
/**
* @Route("/lot/import", name="lot_import", methods={"GET", "POST"})
*
* @IsGranted("ROLE_WAREHOUSE")
*
* @param Request $request
* @param ImportService $importService
*
* @return Response
*/
public function import(Request $request, ImportService $importService): Response
{
$form = $this->createForm(ImportType::class);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$file = $form->get('file')->getData();
$importErrors = $importService->importLot($file->getRealPath());
if (!$importErrors) {
$this->addFlash('success', 'Lots imported successfully!');
return $this->redirectToRoute('lot_index');
}
if (!empty($importErrors['exists'])) {
$this->addFlash('danger', [
'message' => 'Lot already exists (' . count($importErrors['exists']) . ')',
'messages' => $importErrors['exists'],
]);
}
if (!empty($importErrors['auction'])) {
$this->addFlash('danger', [
'message' => 'Auction hasn\'t been found (' . count($importErrors['auction']) . ')',
'messages' => $importErrors['auction'],
]);
}
if (!empty($importErrors['dealer'])) {
$this->addFlash('danger', [
'message' => 'Dealer does not exist (' . count($importErrors['dealer']) . ')',
'messages' => $importErrors['dealer'],
]);
}
if (!empty($importErrors['incorrect'])) {
$this->addFlash('warning', [
'message' => 'Incorrect data (' . count($importErrors['incorrect']) . ')',
'messages' => $importErrors['incorrect'],
]);
}
return $this->redirectToRoute('lot_import');
}
return $this->render('lot/import.html.twig', [
'form' => $form->createView(),
]);
}
/**
* @Route("/lot/import-result", name="lot_result_import", methods={"GET", "POST"})
*
* @IsGranted("ROLE_WAREHOUSE")
*
* @param Request $request
* @param ImportService $importService
*
* @return Response
*/
public function importResult(Request $request, ImportService $importService): Response
{
$form = $this->createForm(ImportType::class);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$file = $form->get('file')->getData();
$importErrors = $importService->importAuctionResults($file->getRealPath());
if (!$importErrors) {
$this->addFlash('success', 'Auction results imported successfully!');
return $this->redirectToRoute('lot_index');
}
foreach ($importErrors as $importError) {
$this->addFlash('danger', $importError);
}
return $this->redirectToRoute('lot_result_import');
}
return $this->render('lot/import.html.twig', [
'form' => $form->createView(),
]);
}
/**
* @Route("/lot/batch", name="lot_batch", methods={"POST"})
*
* @IsGranted("ROLE_MANAGER")
*
* @param Request $request
* @param ExportService $exportService
*
* @return Response
*/
public function batch(Request $request, ExportService $exportService): Response
{
$method = $request->get('method');
$lots = $request->get('elements');
if (!$lots) {
$this->addFlash('danger', 'No Lots selected for export');
return $this->redirectToRoute('lot_index');
}
if ($method === 'export-lots') {
try {
return $exportService->exportLots($lots);
} catch (Exception $e) {
$this->addFlash('danger', 'Error while trying to export lots');
return $this->redirectToRoute('lot_index');
}
}
if ($method === 'export-images') {
return $exportService->exportImages($lots);
}
$this->addFlash('danger', 'Unknown batch method');
return $this->redirectToRoute('lot_index');
}
/**
* @Route("/lot/bulk/move-to-auction", name="lot_bulk_auction", methods={"GET", "POST"})
*
* @IsGranted("ROLE_MANAGER")
*
* @param Request $request
* @param ExportService $exportService
* @param LotRepository $repository
* @param ManagerRegistry $doctrine
*
* @return Response
*/
public function lotAuction(
Request $request,
ExportService $exportService,
LotRepository $repository,
ManagerRegistry $doctrine
): Response {
$lots = $request->get('elements', []);
$form = $this->createForm(LotBulkAuction::class, null, [
'lots' => $lots,
'action' => $this->generateUrl('lot_bulk_auction'),
]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$format = $form->get('format')->getData();
$lotIds = explode(',', $form->get('lots')->getData());
$validationData = $this->validateLots($lotIds, $repository, false, true, true);
if (!empty($validationData['error'])) {
foreach ($validationData['error'] as $error) {
$this->addFlash('danger', $error);
}
return $this->redirectToRoute('lot_index');
}
$auction = $form->get('auction')->getData();
if (!$auction) {
$this->addFlash('danger', 'Auction not found');
return $this->redirectToRoute('lot_index');
}
$lots = $repository->findBy([
'id' => $lotIds,
]);
try {
$response = $exportService->moveLots($lots, $auction, $format);
} catch (Exception $e) {
$this->addFlash('danger', 'Error while trying to move lots to auction');
return $this->redirectToRoute('lot_index');
}
foreach ($lots as $lot) {
$lot->setAuction($auction);
}
$doctrine->getManager()->flush();
return $response;
}
return $this->render('lot/bulk/auction.html.twig', [
'form' => $form->createView()
]);
}
/**
* @Route("lot/bulk/return", name="lot_bulk_return", methods={"GET", "POST"})
*
* @IsGranted("ROLE_MANAGER")
*
* @param Request $request
* @param ExportService $exportService
* @param ValidatorInterface $validator
* @param LotRepository $repository
* @param ManagerRegistry $doctrine
*
* @return Response
*
* @throws TransportExceptionInterface
*/
public function lotReturn(
Request $request,
ExportService $exportService,
ValidatorInterface $validator,
LotRepository $repository,
ManagerRegistry $doctrine
): Response {
$lotIds = $request->get('elements', []);
$attachmentNumber = 0;
$email = '';
if ($lotIds) {
$validationData = $this->validateLots($lotIds, $repository, true);
if (!empty($validationData['error'])) {
foreach ($validationData['error'] as $error) {
$this->addFlash('danger', $error);
}
return new Response(null, 404);
}
$attachmentNumber = $validationData['number_dealer'];
$email = $validationData['email'];
}
$form = $this->createForm(LotBulkReturn::class, null, [
'lots' => $lotIds,
'email' => $email,
'number' => $attachmentNumber,
'action' => $this->generateUrl('lot_bulk_return'),
]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$format = $form->get('format')->getData();
$attachmentNumber = $form->get('number')->getData();
$sendEmails = $form->get('send')->getData();
$lotIds = explode(',', $form->get('lots')->getData());
if ($sendEmails) {
$emailData = $form->get('email')->getData();
$emails = explode(';', $emailData);
$invalidEmail = $this->validateBulkEmails($validator, $emails);
if ($invalidEmail) {
$this->addFlash('danger', 'Invalid email address: ' . $invalidEmail);
return $this->redirect($request->headers->get('referer'));
}
} else {
$emails = [];
}
$lots = $repository->findBy([
'id' => $lotIds,
]);
foreach ($lots as $lot) {
$lot->setStatus(Lot::STATUS_RETURN);
if ($lot->getDealer()) {
$lot->getDealer()->setAttachmentNo($attachmentNumber);
}
}
$doctrine->getManager()->flush();
try {
return $exportService->returnLots($lots, $attachmentNumber, $emails, $format);
} catch (Exception $e) {
$this->addFlash('danger', 'Error while trying to return');
return $this->redirectToRoute('lot_index');
}
}
return $this->render('lot/bulk/return.html.twig', [
'form' => $form->createView()
]);
}
/**
* @Route("/lot/bulk/report-items-for-sale", name="lot_bulk_report_sale", methods={"GET", "POST"})
*
* @IsGranted("ROLE_MANAGER")
*
* @param Request $request
* @param ExportService $exportService
* @param ValidatorInterface $validator
* @param LotRepository $repository
* @param ManagerRegistry $doctrine
*
* @return Response
*
* @throws TransportExceptionInterface
*/
public function lotReportSale(
Request $request,
ExportService $exportService,
ValidatorInterface $validator,
LotRepository $repository,
ManagerRegistry $doctrine
): Response {
$lotIds = $request->get('elements', []);
$attachmentNumber = 0;
$email = '';
if ($lotIds) {
$validationData = $this->validateLots($lotIds, $repository, false, false, false);
if (!empty($validationData['error'])) {
foreach ($validationData['error'] as $error) {
$this->addFlash('danger', $error);
}
return new Response(null, 404);
}
$attachmentNumber = $validationData['number_dealer'];
$email = $validationData['email'];
$email .= ';customer@numisbalt.lt';
}
$form = $this->createForm(LotBulkReportSale::class, null, [
'lots' => $lotIds,
'email' => $email,
'number' => $attachmentNumber,
'action' => $this->generateUrl('lot_bulk_report_sale'),
]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$format = $form->get('format')->getData();
$attachmentNumber = $form->get('number')->getData();
$sendEmails = $form->get('send')->getData();
$lotIds = explode(',', $form->get('lots')->getData());
if ($sendEmails) {
$emailData = $form->get('email')->getData();
$emails = explode(';', $emailData);
$invalidEmail = $this->validateBulkEmails($validator, $emails);
if ($invalidEmail) {
$this->addFlash('danger', 'Invalid email address: ' . $invalidEmail);
return $this->redirect($request->headers->get('referer'));
}
} else {
$emails = [];
}
$lots = $repository->findBy([
'id' => $lotIds,
]);
foreach ($lots as $lot) {
if ($lot->getDealer()) {
$lot->getDealer()->setAttachmentNo($attachmentNumber);
}
}
$doctrine->getManager()->flush();
try {
return $exportService->reportSale($lots, $attachmentNumber, $emails, $format);
} catch (Exception $e) {
$this->addFlash('danger', 'Error while trying to report items for sale');
return $this->redirectToRoute('lot_index');
}
}
return $this->render('lot/bulk/report-sale.html.twig', [
'form' => $form->createView()
]);
}
/**
* @Route("/lot/bulk/report-sold-items", name="lot_bulk_report_sold", methods={"GET", "POST"})
*
* @IsGranted("ROLE_MANAGER")
*
* @param Request $request
* @param ExportService $exportService
* @param ValidatorInterface $validator
* @param LotRepository $repository
* @param ManagerRegistry $doctrine
*
* @return Response
*
* @throws TransportExceptionInterface
*/
public function lotReportSold(
Request $request,
ExportService $exportService,
ValidatorInterface $validator,
LotRepository $repository,
ManagerRegistry $doctrine
): Response {
$lotIds = $request->get('elements', []);
$attachmentNumber = 0;
$email = '';
if ($lotIds) {
$validationData = $this->validateLots($lotIds, $repository, true, false, false);
if (!empty($validationData['error'])) {
foreach ($validationData['error'] as $error) {
$this->addFlash('danger', $error);
}
return new Response(null, 404);
}
$attachmentNumber = $validationData['number_dealer'];
$email = $validationData['email'];
$email .= ';customer@numisbalt.lt';
}
$form = $this->createForm(LotBulkReportSold::class, null, [
'lots' => $lotIds,
'email' => $email,
'number' => $attachmentNumber,
'action' => $this->generateUrl('lot_bulk_report_sold'),
]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$format = $form->get('format')->getData();
$attachmentNumber = $form->get('number')->getData();
$sendEmails = $form->get('send')->getData();
$lotIds = explode(',', $form->get('lots')->getData());
if ($sendEmails) {
$emailData = $form->get('email')->getData();
$emails = explode(';', $emailData);
$invalidEmail = $this->validateBulkEmails($validator, $emails);
if ($invalidEmail) {
$this->addFlash('danger', 'Invalid email address: ' . $invalidEmail);
return $this->redirect($request->headers->get('referer'));
}
} else {
$emails = [];
}
$lots = $repository->findBy([
'id' => $lotIds,
]);
foreach ($lots as $lot) {
$lot->setStatus(Lot::STATUS_SOLD);
if ($lot->getDealer()) {
$lot->getDealer()->setAttachmentNo($attachmentNumber);
}
}
$doctrine->getManager()->flush();
try {
return $exportService->reportSold($lots, $attachmentNumber, $emails, $format);
} catch (Exception $e) {
$this->addFlash('danger', 'Error while trying to report items for sale');
return $this->redirectToRoute('lot_index');
}
}
return $this->render('lot/bulk/report-sold.html.twig', [
'form' => $form->createView()
]);
}
/**
* @Route("/lotbulk/image-delete", name="lot_bulk_image_delete", methods={"POST"})
*
* @IsGranted("ROLE_ADMIN")
*/
public function lotBulkImageDelete(Request $request, LotRepository $repository): Response
{
$lotIds = $request->get('elements', []);
if ($lotIds) {
$validationData = $this->validateLots($lotIds, $repository, false, true, false);
if (!empty($validationData['error'])) {
foreach ($validationData['error'] as $error) {
$this->addFlash('danger', $error);
}
return new Response(null, 404);
}
}
$form = $this->createForm(LotBulkImageDelete::class, null, [
'lots' => $lotIds,
'action' => $this->generateUrl('lot_bulk_image_delete'),
]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$deleteCount = 0;
$deleteSize = 0;
$lotIds = explode(',', $form->get('lots')->getData());
$lots = $repository->findBy([
'id' => $lotIds,
]);
foreach ($lots as $lot) {
foreach ($lot->getImages() as $image) {
$path = $this->getParameter('images_directory') . '/' . $image->getFileName();
if (file_exists($path)) {
$deleteSize += filesize($path);
$deleteCount++;
unlink($path);
}
}
}
$this->addFlash('info', sprintf('Deleted %d images (size: %.2f MB)', $deleteCount, $deleteSize / 1000000));
return $this->redirectToRoute('lot_index');
}
return $this->render('lot/bulk/image-delete.html.twig', [
'form' => $form->createView()
]);
}
/**
* @Route("/lot/bulk/delete", name="lot_bulk_delete", methods={"POST"})
*
* @IsGranted("ROLE_ADMIN")
*
* @param Request $request
* @param LotRepository $repository
* @param ManagerRegistry $doctrine
*
* @return Response
*/
public function lotBulkDelete(Request $request, LotRepository $repository, ManagerRegistry $doctrine): Response
{
$lotIds = $request->get('elements', []);
if ($lotIds) {
$validationData = $this->validateLots($lotIds, $repository, false, true);
if (!empty($validationData['error'])) {
foreach ($validationData['error'] as $error) {
$this->addFlash('danger', $error);
}
return new Response(null, 404);
}
}
$form = $this->createForm(LotBulkDelete::class, null, [
'lots' => $lotIds,
'action' => $this->generateUrl('lot_bulk_delete'),
]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$lotIds = explode(',', $form->get('lots')->getData());
$lots = $repository->findBy([
'id' => $lotIds,
]);
foreach ($lots as $lot) {
$doctrine->getManager()->remove($lot);
}
$doctrine->getManager()->flush();
return $this->redirectToRoute('lot_index');
}
return $this->render('lot/bulk/delete.html.twig', [
'form' => $form->createView()
]);
}
/**
* @Route("/lot/bulk/change-status", name="lot_bulk_change_status", methods={"GET", "POST"})
*
* @IsGranted("ROLE_MANAGER")
*
* @param Request $request
* @param LotRepository $repository
* @param ManagerRegistry $doctrine
*
* @return Response
*/
public function lotBulkChangeStatus(
Request $request,
LotRepository $repository,
ManagerRegistry $doctrine
): Response {
$lotIds = $request->get('elements', []);
if ($lotIds) {
$validationData = $this->validateLots($lotIds, $repository, false, true, false);
if (!empty($validationData['error'])) {
foreach ($validationData['error'] as $error) {
$this->addFlash('danger', $error);
}
return new Response(null, 404);
}
}
$form = $this->createForm(LotBulkChangeStatus::class, null, [
'lots' => $lotIds,
'method' => 'POST',
'action' => $this->generateUrl('lot_bulk_change_status'),
]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$status = $form->get('status')->getData();
$lotIds = explode(',', $form->get('lots')->getData());
$lots = $repository->findBy([
'id' => $lotIds,
]);
foreach ($lots as $lot) {
$lot->setStatus($status);
}
$doctrine->getManager()->flush();
return $this->redirectToRoute('lot_index');
}
return $this->render('lot/bulk/change-status.html.twig', [
'form' => $form->createView()
]);
}
/**
* @param array $lotIds
* @param LotRepository $repository
* @param bool $checkAuction
* @param bool $checkExistenceOnly
* @param bool $checkReturnAndSold
*
* @return array
*/
private function validateLots(
array $lotIds,
LotRepository $repository,
bool $checkAuction = false,
bool $checkExistenceOnly = false,
bool $checkReturnAndSold = true
): array {
$errors = [];
$lots = [];
$email = null;
$attachmentNumberDealer = null;
$previousLot = null;
$previousAuction = null;
if (!$lotIds) {
$errors[] = 'No lots selected';
}
if (!$checkExistenceOnly || $checkReturnAndSold) {
$lots = $repository->findBy(['id' => $lotIds]);
}
if (!$checkExistenceOnly) {
foreach ($lots as $lot) {
if (!$lot->getDealer()) {
$errors[] = 'Lot doesn\'t have dealer assigned';
}
if (!$previousLot) {
$previousLot = $lot;
} elseif ($previousLot instanceof Lot && $previousLot->getDealer() !== $lot->getDealer()) {
$errors[] = 'Selected multiple dealers';
}
if ($checkAuction) {
if (!$lot->getAuction()) {
$errors[] = 'Lot doesn\'t have auction assigned';
}
if (!$previousAuction) {
$previousAuction = $lot;
} elseif (
$previousAuction instanceof Lot && $previousAuction->getAuction() !== $lot->getAuction()
) {
$errors[] = 'Selected multiple auctions';
}
}
$attachmentNumberDealer = (int)$lot->getDealer()->getAttachmentNo();
$email = $lot->getDealer()->getEmail();
}
}
if ($checkReturnAndSold) {
foreach ($lots as $lot) {
if (in_array($lot->getStatus(), [Lot::STATUS_RETURN, Lot::STATUS_SOLD], true)) {
$errors[] = 'No actions are allowed for Sold or Returned lots. Change lot status to make changes';
}
}
}
return [
'number_dealer' => $attachmentNumberDealer,
'email' => $email,
'error' => $errors,
];
}
/**
* @param ValidatorInterface $validator
* @param array $emails
*
* @return string|null
*/
private function validateBulkEmails(ValidatorInterface $validator, array $emails): ?string
{
$constraintEmail = new Constraints\Email();
foreach ($emails as $email) {
if (count($validator->validate($email, $constraintEmail))) {
return $email;
}
}
return null;
}
/**
* @Route("/lot/{id}/edit", name="lot_edit", methods={"GET","POST"})
*
* @param Request $request
* @param Lot $lot
* @param ManagerRegistry $doctrine
* @param ChangeLogRepository $changeLogRepository
*
* @return Response
*/
public function edit(
Request $request,
Lot $lot,
ManagerRegistry $doctrine,
ChangeLogRepository $changeLogRepository
): Response {
if (
!$this->isGranted('ROLE_MANAGER') &&
!$this->isGranted('ROLE_QUALITY') &&
!$this->isGranted('ROLE_PHOTO')
) {
throw $this->createAccessDeniedException();
}
$image = null;
$imageA = null;
$imageB = null;
$imageC = null;
$imageD = null;
$missing = $lot->getMissing();
$form = $this->createForm(LotType::class, $lot, [
'missing' => $missing,
]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$doctrine->getManager()->flush();
if ($this->isGranted('ROLE_QUALITY') && $request->get('submit') === 'checked') {
$lot->setChecked(true);
}
if (!$lot->getMissing()) {
$lot->setStatus(Lot::STATUS_IN_AUCTION);
$doctrine->getManager()->flush();
}
return $this->redirectToRoute('lot_index');
}
foreach ($lot->getImages() as $lotImage) {
$name = explode('.', $lotImage->getFileName());
if (substr($name[0], -1) === 'a') {
$imageA = $lotImage;
} elseif (substr($name[0], -1) === 'b') {
$imageB = $lotImage;
} elseif (substr($name[0], -1) === 'c') {
$imageC = $lotImage;
} elseif (substr($name[0], -1) === 'd') {
$imageD = $lotImage;
} else {
$image = $lotImage;
}
}
$changes = $this->isGranted('ROLE_MANAGER') ? $changeLogRepository->getLotChanges($lot) : [];
return $this->render('lot/edit.html.twig', [
'lot' => $lot,
'form' => $form->createView(),
'image' => $image,
'imageA' => $imageA,
'imageB' => $imageB,
'imageC' => $imageC,
'imageD' => $imageD,
'missing' => $missing,
'changes' => $changes,
]);
}
/**
* @Route("/data", name="lot_data", methods={"GET"})
*
* @IsGranted("ROLE_FINANCE")
*
* @param Request $request
* @param LotRepository $lotRepository
*
* @return JsonResponse
*/
public function data(Request $request, LotRepository $lotRepository): JsonResponse
{
$lotId = $request->get('id', null);
if (!$lotId) {
return new JsonResponse();
}
$lot = $lotRepository->find($lotId);
if (!$lot) {
return new JsonResponse();
}
$data = [
'id' => $lot->getId(),
'lotId' => $lot->getLotId(),
'sum' => $lot->getSold(),
'lotName' => 'Lot name???',
'lotFee' => 'TODO fees',
];
return new JsonResponse($data);
}
/**
* @Route("/lot/{id}", name="lot_delete", methods={"POST"})
*
* @IsGranted("ROLE_ADMIN")
*
* @param Request $request
* @param Lot $lot
* @param ManagerRegistry $doctrine
*
* @return Response
*/
public function delete(Request $request, Lot $lot, ManagerRegistry $doctrine): Response
{
if ($this->isCsrfTokenValid('delete' . $lot->getId(), $request->request->get('_token'))) {
$entityManager = $doctrine->getManager();
$entityManager->remove($lot);
$entityManager->flush();
}
return $this->redirectToRoute('lot_index');
}
}

src/Controller/LotController.php line 58