Symfony Profiler

<?php
namespace App\Controller;
use App\Entity\Tags;
use App\Entity\TagsPerson;
use App\Entity\Person;
use App\Entity\Speaker;
use App\Form\PersonType;
use App\Service\UiService;
use App\Utils\CountryHelper;
use App\Entity\CustomerDocument;
use App\Entity\ManualNewsletter;
use App\Form\CustomerHistoryType;
use Menke\UserBundle\Entity\User;
use App\Form\CustomerDocumentType;
use App\Form\TagsPersonType;
use App\Repository\CartRepository;
use App\Repository\OrderRepository;
use Doctrine\ORM\NoResultException;
use App\Entity\CustomerHistoryEntry;
use App\Repository\TagsRepository;
use App\Repository\TagsPersonRepository;
use App\Repository\PersonRepository;
use App\Service\EmailHistoryService;
use App\Repository\InvoiceRepository;
use App\Service\CustomerHistoryService;
use App\Repository\ClientConfigRepository;
use App\Repository\ProtocolEntryRepository;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\EntityManagerInterface;
use Menke\UserBundle\Service\MailerService;
use Symfony\Component\HttpFoundation\Request;
use App\Repository\CustomerDocumentRepository;
use Symfony\Component\HttpFoundation\Response;
use App\Repository\OAuth\AccessTokenRepository;
use Menke\UserBundle\Repository\UserRepository;
use Symfony\Component\Routing\Annotation\Route;
use App\Repository\OAuth\RefreshTokenRepository;
use App\Repository\CustomerHistoryEntryRepository;
use Symfony\Component\HttpFoundation\RequestStack;
use Menke\UserBundle\Controller\AbstractClientableController;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
use Symfony\Component\Security\Csrf\TokenGenerator\TokenGeneratorInterface;
use Doctrine\Persistence\ManagerRegistry;
/**
* @Route("/customer")
* @IsGranted("ROLE_SPEAKER")
*/
class CustomerController extends AbstractClientableController
{
const LISTING_LIMIT = 25;
/**
* @Route("/", name="customer_index", methods="GET")
*/
public function index(
PersonRepository $personRepository,
UiService $uiService,
TagsPersonRepository $tagsPersonRepository,
TagsRepository $tagsRepository,
Request $request,
RequestStack $requestStack,
): Response {
$order = $uiService->getSortOrder('customer-index-listing');
$tags = $request->get('tag');
if ($tags) {
$requestStack->getSession()->set('tag', $tags);
}
$customers = $personRepository->getCustomersByClientPaged(
$this->getCurrentClient(),
self::LISTING_LIMIT,
$order['orderDirection'] ?? 'ASC',
$order['orderBy'] ?? 'lastname',
1,
($tags) ? $tags : null,
);
return $this->render('customer/index.html.twig', [
'uiService' => $uiService,
'customers' => $customers,
'tagsPerson' => $tagsPersonRepository->findAll(),
'tags' => $tagsRepository->findAll(),
'total' => $customers->count(),
'pages' => ceil($customers->count() / self::LISTING_LIMIT),
'page' => 1,
'tag' => $request->get('tag'),
]);
}
/**
* @Route("/export/all/{tag}", name="customer_export_all", methods="GET", defaults={"tag"=""})
*/
public function indexexportall(
PersonRepository $personRepository,
UiService $uiService,
$tag,
): Response {
$people = $personRepository->getPersonByClient(
$this->getCurrentClient(),
true,
false,
$tag,
'asc',
'lastname',
);
$response = $this->render('person/export-addresses.csv.twig', [
'people' => $people
]);
$response->setStatusCode(200);
$response->headers->set('Content-Type', 'text/csv; charset=utf-8');
$response->headers->set('Content-Disposition', 'attachment; filename="Personen.csv"');
return $response;
}
/**
* @Route("/{page}/{orderby}/{order}", name="customer_index_listing", methods="GET", requirements={"page"="\d+","order"="asc|desc"})
*/
public function indexListing(
PersonRepository $personRepository,
UiService $uiService,
$page,
$orderby,
$order,
TagsPersonRepository $tagsPersonRepository,
): Response {
$uiService->storeSortOrder('customer-index-listing', $orderby, $order);
$customers = $personRepository->getCustomersByClientPaged(
$this->getCurrentClient(),
self::LISTING_LIMIT,
$order,
$orderby,
$page
);
return $this->render('customer/_index_listing.html.twig', [
'uiService' => $uiService,
'customers' => $customers,
'total' => $customers->count(),
'tagsPerson' => $tagsPersonRepository->findAll(),
'pages' => ceil($customers->count() / self::LISTING_LIMIT),
'page' => 1,
]);
}
/**
* @Route("/family", name="customer_family_index", methods="GET")
*/
public function indexFamily(PersonRepository $personRepository): Response
{
$customers = $personRepository->getFamilyByClientPaged(
$this->getCurrentClient(),
self::LISTING_LIMIT,
'ASC',
'lastname',
1
);
return $this->render('customer/index_family.html.twig', [
'env' => $_ENV,
'customers' => $customers,
'total' => $customers->count(),
'pages' => ceil($customers->count() / self::LISTING_LIMIT),
'page' => 1,
]);
}
/**
* @Route("/{id}/invoice-recipient", name="customer_invoice_recipient", methods="GET")
*/
public function invoiceRecipient(
Request $request,
Person $person,
PersonRepository $repo
) {
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
$family = $repo->findInvoiceReciepsByCustomerPaged(
$person,
self::LISTING_LIMIT
);
return $this->render('customer/invoice_recipient.html.twig', [
'env' => $_ENV,
'customer' => $person,
'family' => $family->getIterator(),
'total' => $family->count(),
'pages' => ceil($family->count() / self::LISTING_LIMIT),
'page' => 1,
]);
}
/**
* @Route("/family/{page}/{orderby}/{order}/{filter}", name="customer_family_index_listing", methods="GET|POST", requirements={"page"="\d+","order"="asc|desc"}, defaults={"filter"=""})
*/
public function indexFamilyListing(
PersonRepository $personRepository,
$page,
$orderby,
$order,
$filter
): Response {
$parsedFilters = [];
if ($filter) {
$filter = explode('&', $filter);
foreach ($filter as $item) {
$item = explode('=', $item);
$key = filter_var($item[0], FILTER_SANITIZE_STRING);
$value = filter_var($item[1], FILTER_SANITIZE_STRING);
$parsedFilters[$key] = $value;
}
}
$customers = $personRepository->getFamilyByClientPaged(
$this->getCurrentClient(),
self::LISTING_LIMIT,
$order,
$orderby,
$page,
$parsedFilters
);
return $this->render('customer/_index_family_listing.html.twig', [
'env' => $_ENV,
'customers' => $customers,
'total' => $customers->count(),
'pages' => ceil($customers->count() / self::LISTING_LIMIT),
'page' => $page,
]);
}
/**
* @Route("/new", name="customer_new", methods="GET|POST")
*/
public function new(
Request $request,
UserPasswordHasherInterface $passwordHasher,
TokenGeneratorInterface $generator,
MailerService $mailer,
CountryHelper $countryHelper,
ClientConfigRepository $configRepo,
EmailHistoryService $emailHistoryService,
ManagerRegistry $managerRegistry,
UserRepository $userRepository,
): Response {
$person = new Person();
$form = $this->createForm(PersonType::class, $person, [
'form_type' => PersonType::TYPE_CUSTOMER,
'countries' => $countryHelper->getCountryChoices(),
]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$clientConfig = $configRepo->getSingleByClient(
$this->getCurrentClient()
);
try {
$interval = new \DateInterval(
'P' . $clientConfig->getAutoDeleteSpanCustomer()
);
} catch (\Exception $e) {
$interval = new \DateInterval('P1Y');
}
$user = $person->getUser();
//Set random Password. Is then changed by the user
if (empty($user->getPassword())) {
$user->setPassword(
substr(
$generator->generateToken(),
0,
8
)
);
}
$hash = $passwordHasher->hashPassword($user, $user->getPassword());
$user->setPassword($hash);
if ($_ENV['SEND_MAIL_TO_NEW_BACKEND_GENERATED_USER'] == '1'){
$user->setActivateToken($generator->generateToken());
$user->setActivateRequestedAt(new \DateTime());
} else {
$user->setActivatedAt(new \DateTime());
}
$person->setIsCustomer(true);
$person->getUser()->setRole(User::ROLE_USER);
$person->getUser()->setClient($this->getCurrentClient());
// check if username (eMail) exists and throw error
$username = $form->get('user')->getData();
if($userRepository->findOneBy(['username' => ''.$username.'']))
{
$this->addFlash('error', 'Die "E-Mail / Benutzername" '. $username. ' gibt es schon!');
return $this->render('customer/new.html.twig', [
'env' => $_ENV,
'customer' => $person,
'form' => $form->createView(),
'create' => true,
]);
}
$person->setCreated(new \Datetime());
$person->getUser()->setCreated(new \Datetime());
$person->setDeleteDate(date_add(new \DateTime(), $interval));
$managerRegistry->getManager()->persist($person);
// $em = $this->getDoctrine()->getManager();
// $em->persist($person);
if ($person->isPrivacyPolicyConfirmed()) {
$entry = CustomerHistoryEntry::createForPrivacyPolicyConfirm(
$person,
$this->getCurrentUser()->getEmail()
);
$managerRegistry->getManager()->persist($entry);
// $em->persist($entry);
}
if ($person->isSpeaker()) {
$speaker = new Speaker();
$speaker->setPerson($person);
$person->getUser()->setRole(User::ROLE_SPEAKER);
$managerRegistry->getManager()->persist($speaker);
// $em->persist($speaker);
}
$managerRegistry->getManager()->flush();
// $em->flush();
if ($_ENV['SEND_MAIL_TO_NEW_BACKEND_GENERATED_USER'] == '1'){
$sentMessage = $mailer->sendActivateMessage(
$user,
$user->getActivateToken()
);
$sentMessage['message'] = 'Es wurde eine Aktivierungs-E-Mail gesendet.';
}
else {
$sentMessage['subject'] = 'Neuer Kunde im Backend angelegt';
$sentMessage['message'] = 'Es wurde KEINE Aktivierungs-E-Mail gesendet.';
}
$emailHistoryService->saveProtocolEntriesFromPerson(
$this->getCurrentClient(),
$person,
$this->getCurrentUser()->getEmail(),
$sentMessage['subject'],
$sentMessage['message'],
'Der neue Kunde wurde erstellt.'
);
// Es wird auch ein Teilnehmer mit angelegt
$familymember = new Person();
$familymember->setIsCustomer(false);
$familymember->setFamilyMemberOf($person);
$familymember->setFirstname($person->getFirstname());
$familymember->setLastname($person->getLastname());
$familymember->setCreated(new \Datetime());
$managerRegistry->getManager()->persist($familymember);
// $em->persist($familymember);
// $em->flush();
$managerRegistry->getManager()->flush();
$this->addFlash('notice', 'Kunde angelegt');
return $this->redirectToRoute('customer_index');
}
return $this->render('customer/new.html.twig', [
'env' => $_ENV,
'customer' => $person,
'form' => $form->createView(),
'create' => true
]);
}
/**
* @Route("/{id}/edit", name="customer_edit", methods="GET|POST")
*/
public function edit(
Request $request,
Person $person,
UserPasswordHasherInterface $passwordHasher,
TagsPersonRepository $tagsPersonRepository,
TagsRepository $tagsRepository,
CountryHelper $countryHelper,
ClientConfigRepository $configRepo,
CustomerHistoryEntryRepository $customerHistoryRepo,
TokenGeneratorInterface $generator,
OrderRepository $orderRepository,
UserRepository $userRepository,
MailerService $mailer,
EmailHistoryService $emailHistoryService,
ManagerRegistry $managerRegistry,
): Response {
$newsletterSetByAdmin = null;
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
if (!$person->isCustomer()) {
throw new NotFoundHttpException();
}
$managerRegistry->getManager()->persist($person);
if (!$person->getDeleteDate()){
$clientConfig = $configRepo->getSingleByClient(
$this->getCurrentClient()
);
$interval = new \DateInterval(
'P' . $clientConfig->getAutoDeleteSpanCustomer()
);
$person->setDeleteDate(date_add(new \DateTime(), $interval));
// $em = $this->getDoctrine()->getManager();
$person->setModified(new \datetime());
// $em->persist($person);
$managerRegistry->getManager()->persist($person);
$managerRegistry->getManager()->flush();
// $em->flush();
}
/**
* history entry if the comment has changed
*/
$requestComment = null;
if (isset($request->request->get('person')['comment'])) {
$requestComment = $request->request->get('person')['comment'];
}
if ($person->getComment() != $requestComment) {
$entry = new CustomerHistoryEntry();
$outComment = strlen($requestComment) > 30 ? substr($requestComment, 0, 50) . "..." : $requestComment;
$entry->setEntry(
"Kunde: " .
$person->getFirstname() . " " .
$person->getLastname() . "<br/>" .
"Kommentar wurde geändert: " . $outComment
);
$entry->setCustomer($person);
$entry->setSystemAgent($this->getCurrentUser()->getEmail());
$managerRegistry->getManager()->persist($entry);
// $em = $this->getDoctrine()->getManager();
// $em->persist($entry);
}
#dd("GLEICH");
try {
$latestNewsletterEntry = $customerHistoryRepo->findLatestByCustomerAndType(
$person,
[
CustomerHistoryEntry::TYPE_NEWSLETTER_REGISTER,
CustomerHistoryEntry::TYPE_NEWSLETTER_DEREGISTER,
]
);
} catch (NoResultException $e) {
$latestNewsletterEntry = null;
}
if ($latestNewsletterEntry && $latestNewsletterEntry->getAdminId() ) {
$newsletterSetByAdmin = $userRepository->find(
$latestNewsletterEntry->getAdminId()
);
if ($newsletterSetByAdmin) {
$newsletterInfo['admin_info'] = $newsletterSetByAdmin->getUsername();
$person->setReceiveNewsletter(true);
}
if ($latestNewsletterEntry->getManualNewsletter()) {
$newsletterInfo['activated'] = $latestNewsletterEntry
->getManualNewsletter()
->getActivated();
$person->setReceiveNewsletter(true);
}
}
$newsletterEdit = $request->request->get('newsletter-check');
if (is_null($newsletterEdit)) {
$newsletterEdit = CustomerHistoryEntry::TYPE_NEWSLETTER_DEREGISTER;
}
$isPrivacyPolicyConfirmed = $person->isPrivacyPolicyConfirmed();
$oldDateOoFBirth = $person->getDateOfBirth()
? $person->getDateOfBirth()->format('Y-m-d')
: null;
$form = $this->createForm(PersonType::class, $person, [
'required_pw' => false,
'is_edit_form' => true,
'form_type' => PersonType::TYPE_CUSTOMER,
'countries' => $countryHelper->getCountryChoices(),
]);
$form->handleRequest($request);
if ($form->isSubmitted()) {
if ($form->isValid()) {
// $em = $this->getDoctrine()->getManager();
if (
$person->isPrivacyPolicyConfirmed() !==
$isPrivacyPolicyConfirmed
) {
if ($person->isPrivacyPolicyConfirmed()) {
$entry = CustomerHistoryEntry::createForPrivacyPolicyConfirm(
$person,
$this->getCurrentUser()->getEmail()
);
} else {
$entry = CustomerHistoryEntry::createForPrivacyPolicyDeconfirm(
$person,
$this->getCurrentUser()->getEmail()
);
}
// $em->persist($entry);
$managerRegistry->getManager()->persist($entry);
}
$emailFrom =
$this->getUser()
->getClient()
->getEmail();
//Deregister an newsletter
if (
$latestNewsletterEntry &&
$latestNewsletterEntry->getType() ===
CustomerHistoryEntry::TYPE_NEWSLETTER_REGISTER
) {
if ($latestNewsletterEntry->getType() != $newsletterEdit) {
$item = new CustomerHistoryEntry();
$item->setCustomer($person);
$item->setEntry(
'Newsletter abgemeldet durch einen Admin.'
);
$item->setSystemAgent('rest_activation');
$item->setDate(new \DateTime());
$item->setType(
CustomerHistoryEntry::TYPE_NEWSLETTER_DEREGISTER
);
$item->setAdminId($this->getCurrentUser()->getId());
$item->setSetByAdmin(true);
// $em->persist($item);
$managerRegistry->getManager()->persist($item);
$person->setReceiveNewsletter(false);
// $em->persist($person);
$person->setModified(new \datetime());
$sentMessage = $mailer->sendDeactivatedMessage(
$emailFrom,
$person->getContactEmail()
);
$emailHistoryService->saveProtocolEntriesFromPerson(
$this->getCurrentClient(),
$person,
$emailFrom,
$sentMessage['subject'],
$sentMessage['message'],
'Newsletter deabonniert'
);
}
} elseif (
//Register manually a newsletter for a client.
$latestNewsletterEntry &&
$latestNewsletterEntry->getType() ===
CustomerHistoryEntry::TYPE_NEWSLETTER_DEREGISTER
) {
if ($latestNewsletterEntry->getType() != $newsletterEdit) {
$moment = new \DateTime();
$newsletter = new ManualNewsletter();
$newsletter->setActivateToken(
$generator->generateToken()
);
$newsletter->setActivated(false);
$newsletter->setKeyExpired(
$moment->add(new \DateInterval('P1D'))
);
$newsletter->setPerson($person);
// $em->persist($newsletter);
$managerRegistry->getManager()->persist($newsletter);
$item = new CustomerHistoryEntry();
$item->setCustomer($person);
$item->setEntry(
'Newsletter abonniert von einem Admin.'
);
$item->setSystemAgent('rest_activation');
$item->setDate(new \DateTime());
$item->setType(
CustomerHistoryEntry::TYPE_NEWSLETTER_REGISTER
);
$item->setAdminId($this->getCurrentUser()->getId());
$item->setSetByAdmin(true);
$item->setManualNewsletter($newsletter);
// $em->persist($item);
$managerRegistry->getManager()->persist($item);
$url = $this->generateUrl(
'subscribe_newsletter_set_by_admin',
['token' => $newsletter->getActivateToken()],
UrlGeneratorInterface::ABSOLUTE_URL
);
$sentMessage = $mailer->sendActivatedMessage(
$emailFrom,
$url,
$person->getContactEmail()
);
$emailHistoryService->saveProtocolEntriesFromPerson(
$this->getCurrentClient(),
$person,
$emailFrom,
$sentMessage['subject'],
$sentMessage['message'],
'Newsletter Aktivierungs-E-Mail gesendet'
);
}
} else {
//If no lates Newsletter Entry exists and the Admin want to register this client.
if (
!$latestNewsletterEntry &&
$newsletterEdit === CustomerHistoryEntry::TYPE_NEWSLETTER_REGISTER
) {
$moment = new \DateTime();
$newsletter = new ManualNewsletter();
$newsletter->setActivateToken(
$generator->generateToken()
);
$newsletter->setActivated(false);
$newsletter->setKeyExpired(
$moment->add(new \DateInterval('P1D'))
);
$newsletter->setPerson($person);
// $em->persist($newsletter);
$managerRegistry->getManager()->persist($newsletter);
$item = new CustomerHistoryEntry();
$item->setCustomer($person);
$item->setEntry(
'Newsletter abonniert von einem Admin.'
);
$item->setSystemAgent('rest_activation');
$item->setDate(new \DateTime());
$item->setType(
CustomerHistoryEntry::TYPE_NEWSLETTER_REGISTER
);
$item->setAdminId($this->getCurrentUser()->getId());
$item->setSetByAdmin(true);
$item->setManualNewsletter($newsletter);
// $em->persist($item);
$managerRegistry->getManager()->persist($item);
$url = $this->generateUrl(
'subscribe_newsletter_set_by_admin',
['token' => $newsletter->getActivateToken()],
UrlGeneratorInterface::ABSOLUTE_URL
);
$sentMessage = $mailer->sendActivatedMessage(
$emailFrom,
$url,
$person->getContactEmail()
);
$emailHistoryService->saveProtocolEntriesFromPerson(
$this->getCurrentClient(),
$person,
$emailFrom,
$sentMessage['subject'],
$sentMessage['message'],
'Newsletter Aktivierungs-E-Mail gesendet'
);
}
}
if ($person->isSpeaker() && !$person->getSpeaker()) {
$speaker = new Speaker();
$speaker->setPerson($person);
$person->getUser()->setRole(User::ROLE_SPEAKER);
// $em->persist($speaker);
$managerRegistry->getManager()->persist($speaker);
$speaker->setCreated(new \datetime());
$this->addFlash('notice', 'Kunde in Referent umgewandelt');
}
// Update customer in booked items
$orders = $orderRepository->findByCustomerPaged(
$person,
);
foreach ($orders as $order) {
$order->setCustomerTitle($person->getTitle());
$order->setCustomerSalutation($person->getSalutation());
$order->setCustomerMember($person->getMember());
$order->setCustomerFirstname($person->getFirstname());
$order->setCustomerLastname($person->getLastname());
$order->setCustomerCompany($person->getCompany());
$order->setCustomerMember($person->getMember());
$order->setCustomerStreet($person->getStreet());
$order->setCustomerStreetNumber($person->getStreetNumber());
$order->setCustomerPostalcode($person->getPostalcode());
$order->setCustomerCity($person->getCity());
$order->setCustomerContactEmail($person->getContactEmail());
$order->setCustomerPhone($person->getPhone());
$order->setModified(new \datetime());
$managerRegistry->getManager()->persist($order);
}
$adresses = $person->updateOrderAddresses();
if ($adresses) {
foreach ($adresses as $adress) {
// $em->flush($adress);
$managerRegistry->getManager()->flush($adress);
}
}
// $em->flush();
//check if email exists and return error
$username = $form->get('user')->getData();
$result = $userRepository->findBy(['username' => ''.$username.'']);
if(!isset($result[0]) || ((count($result) < 2 ) && ($result[0]->getId() == $person->getUser()->getId())))
{
$person->setModified(new \datetime());
$managerRegistry->getManager()->flush();
$this->addFlash('notice', 'Kunde gespeichert');
}
else
{
$this->addFlash('error', 'Die "E-Mail / Benutzername" '. $username. ' gibt es schon!');
}
//Redirect to Order
if ($request->get('fromOrder')) {
return $this->redirectToRoute('order_new', [
'return' => $person->getId(),
]);
}
//Redirect to Invoice
if ($request->get('fromInvoice')) {
return $this->redirectToRoute('invoice_show', [
'id' => $request->get('invoiceId'),
]);
} else { return $this->redirectToRoute('customer_edit', [
'id' => $person->getId(),
]);
}
} else {
$this->addFlash(
'error',
'Einige Felder enthalten ungültige Daten.'
);
}
}
$managerRegistry->getManager()->persist($person);
$managerRegistry->getManager()->flush();
return $this->render('customer/edit.html.twig', [
'tagsPerson' => $tagsPersonRepository->findByTagByPerson($person->getId()),
'tags' => $tagsRepository->findAll(),
'env' => $_ENV,
'customer' => $person,
'form' => $form->createView(),
'latestNewsletterEntry' => $latestNewsletterEntry,
'newsletterSetByAdmin' => $newsletterInfo ?? null,
]);
}
/**
* @Route("/{id}", name="customer_delete", methods="DELETE", requirements={"id"="\d+"})
*/
public function delete(
Request $request,
Person $customer,
PersonRepository $personRepo,
CartRepository $cartRepo,
AccessTokenRepository $accessTokenRepos,
RefreshTokenRepository $refreshTokenRepo,
ProtocolEntryRepository $protocolRepository
): Response {
$this->denyAccessUnlessGranted('ROLE_MANAGER', $customer);
if (!$customer->isCustomer()) {
throw new NotFoundHttpException();
}
if (
$this->isCsrfTokenValid(
'delete' . $customer->getId(),
$request->request->get('_token')
)
) {
$em = $this->getDoctrine()->getManager();
if (!$customer->isCustomer()) {
return $this->redirectToRoute('customer_index');
}
$this->removeCustomer(
$customer,
$personRepo,
$cartRepo,
$accessTokenRepos,
$refreshTokenRepo,
$em
);
if (!$customer->isSpeaker()) {
$this->removeUser($customer->getUser(), $protocolRepository);
$em->remove($customer);
$em->remove($customer->getUser());
} else {
$customer->setIsCustomer(false);
}
$em->flush();
$this->addFlash('notice', 'Kunde gelöscht');
}
return $this->redirectToRoute('customer_index');
}
/**
* @Route("/multiple", name="customer_delete-multiple", methods="DELETE")
*/
public function deleteMultiple(
Request $request,
PersonRepository $personRepo,
CartRepository $cartRepo,
AccessTokenRepository $accessTokenRepos,
RefreshTokenRepository $refreshTokenRepo,
ProtocolEntryRepository $protocolRepository
): Response {
if (
$this->isCsrfTokenValid(
'delete_customers',
$request->request->get('_token')
)
) {
$em = $this->getDoctrine()->getManager();
$deleteIds = $request->request->get('item');
foreach ($deleteIds as $id => $value) {
if ($value) {
$customer = $personRepo->find($id);
$this->denyAccessUnlessGranted('ROLE_MANAGER', $customer);
if (!$customer->isCustomer()) {
continue;
}
$this->removeCustomer(
$customer,
$personRepo,
$cartRepo,
$accessTokenRepos,
$refreshTokenRepo,
$em
);
if (!$customer->isSpeaker()) {
$this->removeUser(
$customer->getUser(),
$protocolRepository
);
$em->remove($customer);
$em->remove($customer->getUser());
} else {
$customer->setIsCustomer(false);
}
}
}
$em->flush();
$this->addFlash(
'notice',
count($deleteIds) > 1 ? 'Kunden gelöscht' : 'Kunde gelöscht'
);
}
return $this->redirectToRoute('customer_index');
}
protected function removeUser(
User $user,
ProtocolEntryRepository $protocolRepository
) {
$entries = $protocolRepository->findBy(['user' => $user]);
foreach ($entries as $entry) {
$entry->setUser(null);
}
}
protected function removeCustomer(
Person &$customer,
PersonRepository $personRepo,
CartRepository $cartRepo,
AccessTokenRepository $accessTokenRepos,
RefreshTokenRepository $refreshTokenRepo,
$em
) {
foreach ($customer->getOrders() as $order) {
$order->setCustomer(null);
foreach ($order->getOrderItems() as $item) {
foreach ($item->getParticipants() as $participant) {
$participant->setPerson(null);
}
}
foreach ($order->getWaitItems() as $item) {
foreach ($item->getParticipants() as $participant) {
$participant->setPerson(null);
}
}
foreach ($order->getInvoices() as $invoice) {
foreach ($invoice->getItems() as $item) {
foreach ($item->getParticipants() as $participant) {
$participant->setPerson(null);
}
}
}
}
$familyMembers = $personRepo->findBy(['familyMemberOf' => $customer]);
foreach ($familyMembers as $familyMember) {
$familyMember->setFamilyMemberOf(null);
$em->remove($familyMember);
}
foreach ($customer->getCourses() as $course) {
$customer->removeCourse($course);
}
foreach ($customer->getDocuments() as $document) {
$documentIds[] = $document->getId();
$em->remove($document);
}
foreach ($customer->getHistory() as $historyEntry) {
$em->remove($historyEntry);
}
$carts = $cartRepo->findBy(['customer' => $customer]);
foreach ($carts as $cart) {
$em->remove($cart);
}
$accessTokens = $accessTokenRepos->findBy([
'user' => $customer->getUser(),
]);
foreach ($accessTokens as $accessToken) {
$em->remove($accessToken);
}
$refreshTokens = $refreshTokenRepo->findBy([
'user' => $customer->getUser(),
]);
foreach ($refreshTokens as $refreshToken) {
$em->remove($refreshToken);
}
$em->flush();
}
/**
* @Route("/{id}/courses", name="customer_courses", methods="GET")
*/
public function courses(
Request $request,
Person $person,
OrderRepository $repo,
UiService $uiService
) {
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
$order = $uiService->getSortOrder('customer-courses-listing');
$orders = $repo->findByCustomerPaged(
$person,
self::LISTING_LIMIT,
$order['orderDirection'] ?? 'ASC',
$order['orderBy'] ?? 'title',
1,
true
);
return $this->render('customer/courses.html.twig', [
'uiService' => $uiService,
'customer' => $person,
'orders' => $orders,
'total' => $orders->count(),
'pages' => ceil($orders->count() / self::LISTING_LIMIT),
'page' => 1,
]);
}
/**
* @Route("/{id}/courses/{page}/{orderby}/{order}", name="customer_courses_listing", methods="GET")
*/
public function courseListing(
Request $request,
Person $person,
$page,
$orderby,
$order,
OrderRepository $repo,
UiService $uiService
) {
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
$uiService->storeSortOrder(
'customer-courses-listing',
$orderby,
$order
);
$orders = $repo->findByCustomerPaged(
$person,
self::LISTING_LIMIT,
$order,
$orderby,
$page,
true
);
return $this->render('customer/tabs/_courses_listing.html.twig', [
'orders' => $orders->getIterator(),
'total' => $orders->count(),
'pages' => ceil($orders->count() / self::LISTING_LIMIT),
'page' => $page,
]);
}
/**
* @Route("/{id}/invoices", name="customer_invoices", methods="GET")
*/
public function invoices(
Request $request,
Person $person,
InvoiceRepository $repo
) {
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
$invoices = $repo->findByCustomerPaged($person, self::LISTING_LIMIT);
return $this->render('customer/invoices.html.twig', [
'customer' => $person,
'invoices' => $invoices->getIterator(),
'total' => $invoices->count(),
'pages' => ceil($invoices->count() / self::LISTING_LIMIT),
'page' => 1,
]);
}
/**
* @Route("/{id}/invoices/{page}/{orderby}/{order}/{search}", name="customer_invoices_listing", methods="GET", defaults={"search"=""})
*/
public function invoicesListing(
Request $request,
Person $person,
$page,
$orderby,
$order,
$search,
InvoiceRepository $repo
) {
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
$invoices = $repo->findByCustomerPaged(
$person,
self::LISTING_LIMIT,
$order,
$orderby,
$page,
false,
$search
);
return $this->render('customer/tabs/_invoices_listing.html.twig', [
'customer' => $person,
'invoices' => $invoices->getIterator(),
'total' => $invoices->count(),
'pages' => ceil($invoices->count() / self::LISTING_LIMIT),
'page' => $page,
]);
}
/**
* @Route("/{id}/orders", name="customer_orders", methods="GET")
*/
public function orders(
Request $request,
Person $person,
OrderRepository $repo,
UiService $uiService
) {
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
$order = $uiService->getSortOrder('customer-orders-listing');
$orders = $repo->findByCustomerPaged(
$person,
self::LISTING_LIMIT,
$order['orderDirection'] ?? 'DESC',
$order['orderBy'] ?? 'id'
);
return $this->render('customer/orders.html.twig', [
'uiService' => $uiService,
'customer' => $person,
'orders' => $orders->getIterator(),
'total' => $orders->count(),
'pages' => ceil($orders->count() / self::LISTING_LIMIT),
'page' => 1,
]);
}
/**
* @Route("/{id}/orders/{page}/{orderby}/{order}/{search}", name="customer_orders_listing", methods="GET", defaults={"search"=""})
*/
public function ordersListing(
Person $person,
$page,
$orderby,
$order,
$search,
OrderRepository $repo,
UiService $uiService
): Response {
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
$uiService->storeSortOrder('customer-orders-listing', $orderby, $order);
$orders = $repo->findByCustomerPaged(
$person,
self::LISTING_LIMIT,
$order,
$orderby,
$page,
false,
$search
);
return $this->render('customer/tabs/_orders_listing.html.twig', [
'customer' => $person,
'orders' => $orders->getIterator(),
'total' => $orders->count(),
'pages' => ceil($orders->count() / self::LISTING_LIMIT),
'page' => $page,
]);
}
/**
* @Route("/{id}/history", name="customer_history", methods="GET|POST")
*/
public function history(
Request $request,
Person $person,
CustomerHistoryService $service
) {
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
$entry = new CustomerHistoryEntry();
$form = $this->createForm(CustomerHistoryType::class, $entry);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$user = $this->getCurrentUser();
$entry->setCustomer($person);
$entry->setSystemAgent($user->getEmail());
$em = $this->getDoctrine()->getManager();
$em->persist($entry);
$em->flush();
$this->addFlash('notice', 'History-Eintrag angelegt');
return $this->redirectToRoute('customer_history', [
'id' => $person->getId(),
]);
}
$history = $service->findByCustomerPaged(
$person,
self::LISTING_LIMIT
);
return $this->render('customer/history.html.twig', [
'customer' => $person,
'history' => $history->getIterator(),
'total' => $history->count(),
'pages' => ceil($history->count() / self::LISTING_LIMIT),
'page' => 1,
'history_add_form' => $form->createView(),
]);
}
/**
* @Route("/{id}/history/{page}/{orderby}/{order}/{search}", name="customer_history_listing", methods="GET", defaults={"search"=""}, requirements={"page"="\d+"})
*/
public function historyListing(
Request $request,
Person $person,
$page,
$orderby,
$order,
$search,
CustomerHistoryService $service
) {
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
$history = $service->findByCustomerPaged(
$person,
self::LISTING_LIMIT,
$order,
$orderby,
$page,
$search
);
return $this->render('customer/tabs/_history_listing.html.twig', [
'history' => $history->getIterator(),
'total' => $history->count(),
'pages' => ceil($history->count() / self::LISTING_LIMIT),
'page' => $page,
]);
}
/**
* @Route("/{id}/tags", name="tags_person", methods="GET|POST")
*/
public function tagsPersonEintragen(
Request $request,
Person $person,
TagsPersonRepository $tagsPersonRepository,
TagsRepository $tagsRepository,
): Response
{
return $this->render('customer/tags.html.twig',[
'customer' => $person,
'tagsPerson' => $tagsPersonRepository->findByTagByPerson($person->getId()),
'tags' => $tagsRepository->findAll(),
]);
}
private $managerRegistry;
public function __construct(ManagerRegistry $managerRegistry)
{
$this->managerRegistry = $managerRegistry->getManager();
}
/**
* @Route("/{id}/tagsadd/{tags}", name="tags_person_add", methods="GET|POST")
*/
public function saveTagsPersonNew(
Person $person,
Tags $tags, )
{
$saveTagsPerson = new TagsPerson();
$saveTagsPerson->setTags($tags);
$saveTagsPerson->setPerson($person);
$this->managerRegistry->persist($saveTagsPerson);
$this->managerRegistry->flush();
$this->addFlash('notice', 'Tag übertragen');
return $this->redirectToRoute('tags_person', [
'id' => $person->getId(),
]);
}
/**
* @Route("/{id}/tagsremove/{tagid}", name="tags_person_remove", methods="GET|POST")
*/
public function removeTagsEntry(
$id,
TagsPerson $tagid,)
{
$em = $this->getDoctrine()->getManager();
$em->remove($tagid);
$em->flush();
$this->addFlash('notice', 'Tag übertragen');
return $this->redirectToRoute('tags_person', [
'id' => $id,
]);
}
/**
* @Route("/{id}/documents", name="customer_documents", methods="GET|POST")
*/
public function documents(
Request $request,
Person $person,
CustomerDocumentRepository $repo
) {
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
$document = new CustomerDocument();
$form = $this->createForm(CustomerDocumentType::class, $document);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$user = $this->getCurrentUser();
$document->setCustomer($person);
$document->setSystemAgent($user->getEmail());
$em = $this->getDoctrine()->getManager();
$em->persist($document);
$em->flush();
$this->addFlash('notice', 'Dokument hochgeladen');
return $this->redirectToRoute('customer_documents', [
'id' => $person->getId(),
]);
}
$documents = $repo->findByCustomerPaged($person, self::LISTING_LIMIT);
return $this->render('customer/documents.html.twig', [
'customer' => $person,
'documents' => $documents->getIterator(),
'total' => $documents->count(),
'pages' => ceil($documents->count() / self::LISTING_LIMIT),
'page' => 1,
'document_add_form' => $form->createView(),
]);
}
/**
* @Route("/{id}/documents/{page}/{orderby}/{order}/{search}", name="customer_document_listing", methods="GET", defaults={"search"=""})
*/
public function documentListing(
Request $request,
Person $person,
$page,
$orderby,
$order,
$search,
CustomerDocumentRepository $repo
) {
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
$documents = $repo->findByCustomerPaged(
$person,
self::LISTING_LIMIT,
$order,
$orderby,
$page,
$search
);
return $this->render('customer/tabs/_documents_listing.html.twig', [
'documents' => $documents->getIterator(),
'total' => $documents->count(),
'pages' => ceil($documents->count() / self::LISTING_LIMIT),
'page' => 1,
]);
}
/**
* @Route("/{id}/family", name="customer_family", methods="GET|POST")
*/
public function family(
Request $request,
Person $person,
PersonRepository $repo
) {
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
$family = $repo->findFamilyByCustomerPaged(
$person,
self::LISTING_LIMIT
);
return $this->render('customer/family.html.twig', [
'env' => $_ENV,
'customer' => $person,
'family' => $family->getIterator(),
'total' => $family->count(),
'pages' => ceil($family->count() / self::LISTING_LIMIT),
'page' => 1,
]);
}
/**
* @Route("/{id}/family/{page}/{orderby}/{order}/{search}", name="customer_family_listing", methods="GET", defaults={"search"=""})
*/
public function familyListing(
Request $request,
Person $person,
$page,
$orderby,
$order,
$search,
PersonRepository $repo
) {
#dd($order, $orderby, $search);
$this->denyAccessUnlessGranted('ROLE_MANAGER', $person);
$family = $repo->findFamilyByCustomerPaged(
$person,
self::LISTING_LIMIT,
$order,
$orderby,
$page,
$search
);
return $this->render('customer/tabs/_family_listing.html.twig', [
'family' => $family->getIterator(),
'total' => $family->count(),
'pages' => ceil($family->count() / self::LISTING_LIMIT),
'page' => 1,
]);
}
/**
* @Route("/profile", name="customer_profile", methods="GET|POST")
*/
public function profile(
Request $request,
PersonRepository $personRepo,
UserPasswordHasherInterface $passwordHasher,
CountryHelper $countryHelper
): Response {
$user = $this->getCurrentUser();
$person = $personRepo->getByUser($user);
//$password = $user->getPassword();
$isPrivacyPolicyConfirmed = $person->isPrivacyPolicyConfirmed();
$form = $this->createForm(PersonType::class, $person, [
'required_pw' => false,
'is_edit_form' => false,
'form_type' => PersonType::TYPE_CUSTOMER,
'is_user_role' => true,
'countries' => $countryHelper->getCountryChoices(),
]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$em = $this->getDoctrine()->getManager();
/*if (!empty($user->getPassword())) {
$hash = $encoder->encodePassword($user, $user->getPassword());
$user->setPassword($hash);
} else {
$user->setPassword($password);
}*/
if (
$person->isPrivacyPolicyConfirmed() !==
$isPrivacyPolicyConfirmed
) {
if ($person->isPrivacyPolicyConfirmed()) {
$entry = new CustomerHistoryEntry(
'Datenschutz zugestimmt',
$person,
$user->getEmail()
);
} else {
$entry = new CustomerHistoryEntry(
'Datenschutzzustimmung zurückgezogen',
$person,
$user->getEmail()
);
}
$em->persist($entry);
}
$this->getDoctrine()
->getManager()
->flush();
$this->addFlash('notice', 'Profil gespeichert');
return $this->redirectToRoute('customer_profile');
}
return $this->render('customer/profile.html.twig', [
'customer' => $person,
'form' => $form->createView(),
]);
}
}

src/Controller/CustomerController.php line 1206