Symfony Profiler

<?php
namespace App\Controller;
use App\Entity\BusinessTime;
use App\Entity\Category;
use App\Entity\Impressum;
use App\Entity\KassenUser;
use App\Entity\MenuSetting;
use App\Entity\MenuTemplate;
use App\Entity\Products;
use App\Entity\ShopData;
use App\Entity\ShopSetting;
use App\Entity\ShopTemplates;
use App\Entity\Tables;
use App\Entity\TablesCategories;
use App\Entity\Tax;
use App\Entity\Users;
use App\Entity\WarengruppenType;
use App\Form\RegistrationFormType;
use App\Repository\UsersRepository;
use App\Security\BlitzkonnektAuthAuthenticator;
use App\Security\EmailVerifier;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bridge\Twig\Mime\TemplatedEmail;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Mailer\Bridge\Google\Transport\GmailSmtpTransport;
use Symfony\Component\Mailer\Mailer;
use Symfony\Component\Mime\Address;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\String\ByteString;
use Symfony\Component\String\Slugger\AsciiSlugger;
use Symfony\Component\Uid\Uuid;
use SymfonyCasts\Bundle\VerifyEmail\Exception\VerifyEmailExceptionInterface;
class RegistrationController extends AbstractController
{
private EmailVerifier $emailVerifier;
public function __construct(EmailVerifier $emailVerifier)
{
$this->emailVerifier = $emailVerifier;
}
#[Route('/user/registration', name: 'app_register')]
public function register(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): Response
{
$user = new Users();
$form = $this->createForm(RegistrationFormType::class, $user);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
// encode the plain password
$user->setRoles(['ROLE_USER']);
$user->setUsername($form->get('email')->getData());
$user->setPassword(
$userPasswordHasher->hashPassword(
$user,
$form->get('plainPassword')->getData()
)
);
$entityManager->persist($user);
$entityManager->flush();
$shopDate = new ShopData();
$shopDate->setCreatedBy($user);
$shopDate->setGeschaftName($user->getEmail());
$shopDate->setConnector($user->getEmail());
$entityManager->persist($shopDate);
$entityManager->flush();
$user->setShopID($shopDate);
$entityManager->flush();
return $this->redirectToRoute('userNotificationBeta');
}
return $this->render('registration/register.html.twig', [
'registrationForm' => $form->createView(),
'user'=> $this->getUser()
]);
}
#[Route('/verify/email', name: 'app_verify_email')]
public function verifyUserEmail(Request $request, UsersRepository $usersRepository): Response
{
$id = $request->get('id');
if (null === $id) {
return $this->redirectToRoute('app_register');
}
$user = $usersRepository->find($id);
if (null === $user) {
return $this->redirectToRoute('app_register');
}
// validate email confirmation link, sets User::isVerified=true and persists
try {
$this->emailVerifier->handleEmailConfirmation($request, $user);
} catch (VerifyEmailExceptionInterface $exception) {
$this->addFlash('verify_email_error', $exception->getReason());
return $this->redirectToRoute('app_register');
}
// @TODO Change the redirect on success and handle or remove the flash message in your templates
$this->addFlash('success', 'Your email address has been verified.');
return $this->redirectToRoute('app_register');
}
#[Route('/api/user-add/auto', name: 'api_admin_auto_user')]
public function AdminAutoAddUser(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager){
$password = ByteString::fromRandom(16)->toString();
$connectorId = ByteString::fromRandom(32)->toString();
$api_admin_key = $request->get('adminKey');
$invoice = $request->get('invoice');
$kunden = $request->get('kunden');
if($api_admin_key === 'fwsvysB72W9ysvQJkSJXzNWA4NemkSXV') {
$user = new Users();
// encode the plain password
$user->setRoles(['ROLE_SHOP_OWNER']);
$user->setIsVerified(true);
$user->setName($kunden);
$user->setSurname($kunden);
$user->setKundeninvoice($invoice);
$user->setKundennumber($kunden);
$user->setUsername($invoice . $kunden);
$user->setPassword(
$userPasswordHasher->hashPassword(
$user,
$invoice . $kunden
)
);
$entityManager->persist($user);
$entityManager->flush();
$impressum = new Impressum();
$impressum->setCreatedBy($user);
$entityManager->persist($user);
$entityManager->flush();
$btime = new BusinessTime();
$btime->setCreatedBy($user);
$entityManager->persist($btime);
$entityManager->flush();
$demoTemplate = $entityManager->getRepository(MenuTemplate::class)->findOneBy(['name'=>'Demo']);
$templateMenuSetting = new MenuSetting();
$templateMenuSetting->setName("Demo");
$templateMenuSetting->setAlegrenOn('true');
$templateMenuSetting->setMenuBG("#666");
$templateMenuSetting->setBgColor("#000000");
$templateMenuSetting->setBodySize(14);
$templateMenuSetting->setCreatedBy($user);
$templateMenuSetting->setTitleSize(22);
$templateMenuSetting->setTextColor("#fff");
$templateMenuSetting->setBodyColor("#fff");
$templateMenuSetting->setMenuNav("#fff");
$templateMenuSetting->setTimeColor("#fff");
$templateMenuSetting->setFirmnameColor("#ff1f1f");
$templateMenuSetting->setMenuTemplates($demoTemplate);
$entityManager->persist($templateMenuSetting);
$entityManager->flush();
$demoTemplateShop = $entityManager->getRepository(ShopTemplates::class)->findOneBy(['name'=>'Demo']);
$templateShopSetting = new ShopSetting();
$templateShopSetting->setName("Demo");
$templateShopSetting->setAlegrenOn('true');
$templateShopSetting->setMenuBG("#666");
$templateShopSetting->setBgColor("#000000");
$templateShopSetting->setBodySize(14);
$templateMenuSetting->setFirmnameColor("#ff1f1f");
$templateShopSetting->setCreatedBy($user);
$templateShopSetting->setTitleSize(22);
$templateShopSetting->setTextColor("#fff");
$templateShopSetting->setBodyColor("#fff");
$templateShopSetting->setTitleColor("#fff");
$templateShopSetting->setShopTemplates($demoTemplateShop);
$entityManager->persist($templateShopSetting);
$entityManager->flush();
$shopDate = new ShopData();
$shopDate->setCreatedBy($user);
$shopDate->setMenuEnabled(false);
$shopDate->setShopEnabled(false);
$shopDate->setMenuSetting($templateMenuSetting);
$shopDate->setShopSetting($templateShopSetting);
$shopDate->setGeschaftName($user->getUsername());
$shopDate->setConnector($invoice . $kunden);
$shopDate->setAccountEnabled(true);
$shopDate->setMenuEnabled(true);
$shopDate->setShopEnabled(false);
$entityManager->persist($shopDate);
$entityManager->flush();
$user->setShopID($shopDate);
$entityManager->persist($user);
$entityManager->flush();
return $this->json([
'password' => $password
]);
} else {
return $this->json([
'key' => "KeyMissing"
]);
}
}
#[Route('/api/kasse/add-product', name: 'api_admin_kasse_products')]
public function APIConnectorKasse(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager){
$catName = $request->get('catName');
$connectorId = $request->get('connectorId');
$pName = $request->get('pName');
$ean = $request->get('pEan');
$plu = $request->get('pPlu');
$price = $request->get('pPrice');
$happyPrice = $request->get('happyPrice');
$unuqueId = $request->get('id');
$category = null;
$productes = null;
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$categoryCheck = $entityManager->getRepository(Category::class)->findOneBy(['name'=> $catName]);
if(!$categoryCheck) {
$category = new Category();
$category->setName($catName);
$category->setCreatedBy($shopDate->getCreatedBy());
$entityManager->persist($category);
$entityManager->flush();
} else {
$category = $categoryCheck;
}
$product = new Products();
$product->setName($pName);
$product->setUnuqueId($unuqueId);
$product->setCategory($category);
$product->setcreatedBy($shopDate->getCreatedBy());
$product->setEan($ean);
$product->setPlu($plu);
$product->setPrice($price);
$product->setPriceHappyHour($happyPrice);
// encode the plain password
$entityManager->persist($product);
$entityManager->flush();
$productes = $product;
return $this->json([
'product' => $productes->getName(),
'category' => $category->getName()
]);
} else {
return $this->json([
'key' => "KeyMissing"
]);
}
}
#[Route('/api/kasse/add-companyInfo', name: 'api_admin_add_companyInfo')]
public function APIConnectorKasseInfoCompany(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
$connectorId = str_replace('"', "", $request->get('connectorId'));
$companyInfo = $request->get('companyInfo');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate != null) {
$impressum = $entityManager->getRepository(Impressum::class)->findOneBy(['createdBy'=>$connectorId]);
if($companyInfo) {
$shopDate->setGeschaftName($companyInfo['Name']);
$shopDate->setShopOwner($companyInfo['Owner']);
$impressum->setGeschaftAddress($companyInfo['Address']);
$impressum->setGeschaftBank($companyInfo['Bank']);
$impressum->setGeschaftBIC($companyInfo['BIC']);
$impressum->setGeschaftCity($companyInfo['City']);
$impressum->setGeschaftIBAN($companyInfo['IBAN']);
$impressum->setGeschaftTel($companyInfo['Tel']);
$entityManager->persist($impressum);
$entityManager->flush();
$entityManager->persist($shopDate);
$entityManager->flush();
return $this->json(true);
} else {
return $this->json(false);
}
} else {
return $this->json(false);
}
}
#[Route('/kasse/checkKey/{connectorId}', name: 'getConnectorKey')]
public function getConnectorKey(Request $request, UsersRepository $usersRepository, EntityManagerInterface $entityManager, string $connectorId): Response
{
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate != null) {
return $this->json(true);
} else {
return $this->json(false);
}
}
#[Route('/kasse/getKey/{connectorId}', name: 'getKassenKey')]
public function getKassenKey(Request $request, UsersRepository $usersRepository, EntityManagerInterface $entityManager, string $connectorId): Response
{
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate != null) {
return $this->json(true);
} else {
return $this->json(false);
}
}
#[Route('/kasse/getNameOfShop/{connectorId}', name: 'getShopName')]
public function getNameOfShop(Request $request, UsersRepository $usersRepository, EntityManagerInterface $entityManager, string $connectorId): Response
{
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate != null) {
return $this->json($shopDate->getShopUrl());
} else {
return $this->json(false);
}
}
#[Route('/api/kasse/get-product-global', name: 'api_admin_kasse_getproducts_global')]
public function APIConnectorGetProductKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
$connectorId = str_replace('"', "", $request->get('connectorId'));
//$connectorId = $request->get('connectorId');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$products = $entityManager->getRepository(Products::class)->findBy(['createdBy' => $shopDate->getCreatedBy()]);
if($products != null) {
return $this->json($products);
} else {
return $this->json(false);
}
}else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/get-warengruppenType', name: 'api_admin_kasse_getwarengruppenType_global')]
public function APIConnectorGetwarengruppenTypeKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
$connectorId = str_replace('"', "", $request->get('connectorId'));
//$connectorId = $request->get('connectorId');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$warenGrupTypo = $entityManager->getRepository(WarengruppenType::class)->findBy(['createdBy' => $shopDate->getCreatedBy()]);
if($warenGrupTypo != null) {
return $this->json($warenGrupTypo);
} else {
return $this->json(false);
}
}else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/get-categories-global', name: 'api_admin_kasse_getcategories_global')]
public function APIConnectorGetCategoriesKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
$connectorId = str_replace('"', "", $request->get('connectorId'));
//$connectorId = $request->get('connectorId');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$categories = $entityManager->getRepository(Category::class)->findBy(['createdBy' => $shopDate->getCreatedBy()]);
if($categories != null) {
return $this->json($categories);
} else {
return $this->json(false);
}
} else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/set-fu-global', name: 'test')]
public function test(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
$requestData = $request->request->all();
//$overwrite = $request->get('overwrite');
/* $shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);*/
$categoryCheck = $entityManager->getRepository(Category::class)->findOneBy(['kasseCatId'=> 87, 'createdBy' => 21]);
dd($categoryCheck);
}
#[Route('/api/kasse/set-categories-global', name: 'api_admin_kasse_setcategories_global')]
public function APIConnectorSetCategoriesKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
$requestData = $request->request->all();
$connectorId = $requestData['connectorID'];
//$overwrite = $request->get('overwrite');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$categories = new Category();
if($requestData) {
$categoryCheck = $entityManager->getRepository(Category::class)->findOneBy(['kasseCatId'=> $requestData['kasseCatId'], 'createdBy' => $shopDate->getCreatedBy()]);
$modes = $entityManager->getRepository(WarengruppenType::class)->findOneBy(['modeid'=> $requestData['mode'], 'createdBy' => $shopDate->getCreatedBy()]);
$slugger = new AsciiSlugger();
/* dd($modes, $categoryCheck);*/
// Use the slug() method to convert the string to a URL format
$url = $slugger->slug($requestData['name'])->lower()->toString();
if($categoryCheck) {
$categoryCheck->setName($requestData['name']);
$categoryCheck->setKasseCatId($requestData['kasseCatId']);
// $categoryCheck->setAllwaySingleSaldo($requestData['allwaySingleSaldo']);
$categoryCheck->setAllwaySingleSaldo(false);
// $categoryCheck->setNotPrintSaldo($requestData['notPrintSaldo']);
$categoryCheck->setNotPrintSaldo(false);
$categoryCheck->setColor($requestData['color']);
$categoryCheck->setUrl($url);
$categoryCheck->setEnableMenu(false);
$categoryCheck->setEnableShop(false);
$categoryCheck->setNotPrintSaldo(false);
$categoryCheck->setDeviceID($requestData['deviceID']);
$categoryCheck->setKodSinchro($requestData['kodSynchro']);
$categoryCheck->setMode($modes->getId());
$categoryCheck->setSortID($requestData['sortID']);
$entityManager->persist($categoryCheck);
try {
$entityManager->flush();
return $this->json($categoryCheck);
} catch (\Exception $ex) {
return $this->json("Error");
}
} else {
$categories->setName($requestData['name']);
$categories->setKasseCatId($requestData['kasseCatId']);
$categories->setCreatedBy($shopDate->getCreatedBy());
$categories->setAllwaySingleSaldo(false);
//$categories->setAllwaySingleSaldo($requestData['allwaySingleSaldo']);
//$categories->setNotPrintSaldo($requestData['notPrintSaldo']);
$categories->setNotPrintSaldo(false);
$categories->setColor($requestData['color']);
$categories->setUrl($url);
$categories->setEnableMenu(false);
$categories->setEnableShop(false);
$categories->setNotPrintSaldo(false);
$categories->setDeviceID($requestData['deviceID']);
$categories->setKodSinchro($requestData['kodSynchro']);
$categories->setMode($modes->getId());
$categories->setSortID($requestData['sortID']);
$entityManager->persist($categories);
try {
$entityManager->flush();
return $this->json($categories);
} catch (\Exception $ex) {
return $this->json("Error");
}
}
} else {
return $this->json(false);
}
} else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/set-tax', name: 'api_admin_kasse_settax_global')]
public function APIConnectorSetTaxKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
$requestData = $request->request->all();;
$connectorId = $requestData['connectorID'];
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$tax = new Tax();
$taxChecker = $entityManager->getRepository(Tax::class)->findOneBy(['kasseID'=> $requestData['kasseid'], 'createdBy' => $shopDate->getCreatedBy()]);
if($requestData) {
if($taxChecker) {
$taxChecker->setName($requestData['name']);
$taxChecker->setStatus($requestData['status']);
$taxChecker->setCountry(intval($requestData['country']));
$taxChecker->setDescription($requestData['description']);
$taxChecker->setTaxValue($requestData['taxValue']);
$taxChecker->setDeviceID($requestData['deviceID']);
$taxChecker->setKasseID($requestData['kasseid']);
$entityManager->persist($taxChecker);
$entityManager->flush();
return $this->json($taxChecker);
} else {
$tax->setCreatedBy($shopDate->getCreatedBy());
$tax->setName($requestData['name']);
$tax->setStatus($requestData['status']);
$tax->setCountry(intval($requestData['country']));
$tax->setDescription($requestData['description']);
$tax->setTaxValue($requestData['taxValue']);
$tax->setDeviceID($requestData['deviceID']);
$tax->setKasseID($requestData['kasseid']);
$entityManager->persist($tax);
$entityManager->flush();
return $this->json($tax);
}
} else {
return $this->json(false);
}
} else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/set-warengruppentypen', name: 'api_admin_kasse_setwarengruppentypen_global')]
public function APIConnectorSetWarenGruppenTypenKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
//$requestData = json_decode($request->getContent(), true);
$requestData = $request->request->all();
$connectorId = $requestData['connectorID'];
//$overwrite = $request->get('overwrite');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$warengruppenutype = new WarengruppenType();
$warengruppenutypeChecker = $entityManager->getRepository(WarengruppenType::class)->findOneBy(['kassenID'=> $requestData['kasseid'], 'createdBy' => $shopDate->getCreatedBy()]);
if($requestData) {
if($warengruppenutypeChecker) {
$warengruppenutypeChecker->setName($requestData['name']);
$warengruppenutypeChecker->setCodeSynchro($requestData['codeSynchro']);
$warengruppenutypeChecker->setDeviceId($requestData['deviceId']);
$warengruppenutypeChecker->setModeid($requestData['modeid']);
$warengruppenutypeChecker->setKassenID($requestData['kasseid']);
$entityManager->persist($warengruppenutypeChecker);
$entityManager->flush();
return $this->json($warengruppenutypeChecker);
} else {
$warengruppenutype->setCreatedBy($shopDate->getCreatedBy());
$warengruppenutype->setName($requestData['name']);
$warengruppenutype->setCodeSynchro($requestData['codeSynchro']);
$warengruppenutype->setDeviceId($requestData['deviceId']);
$warengruppenutype->setModeid($requestData['modeid']);
$warengruppenutype->setKassenID($requestData['kasseid']);
$entityManager->persist($warengruppenutype);
$entityManager->flush();
return $this->json($warengruppenutype);
}
} else {
return $this->json(false);
}
} else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/set-firmendaten', name: 'api_admin_kasse_setfirmendaten_global')]
public function APIConnectorSetfirmendatenKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
$requestData = $request->request->all();
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $requestData['connectorID']]);
$impressum = $entityManager->getRepository(Impressum::class)->findOneBy(['createdBy' => $shopDate->getCreatedBy()]);
if($shopDate) {
$shopDate->setShopOwner($requestData['owner']);
$shopDate->setGeschaftName($requestData['name']);
$entityManager->persist($shopDate);
$entityManager->flush();
$impressum->setGeschaftInh($requestData['owner']);
$impressum->setGeschaftAddress($requestData['address']);
$impressum->setGeschaftCity($requestData['city']);
$impressum->setGeschaftZIP($requestData['zip']);
$impressum->setGeschaftEmail($requestData['email']);
$impressum->setGeschaftSteuer($requestData['taxnummer']);
$impressum->setGeschaftTel($requestData['tel']);
$impressum->setGeschaftIBAN($requestData['iban']);
$impressum->setGeschaftBank($requestData['bank']);
$impressum->setGeschaftBIC($requestData['bic']);
$entityManager->persist($impressum);
$entityManager->flush();
return $this->json(true);
} else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/set-raume', name: 'api_admin_kasse_setraume_global')]
public function APIConnectorSetRaumeKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
//$requestData = json_decode($request->getContent(), true);
$requestData = $request->request->all();
$connectorId = $requestData['connectorID'];
//$overwrite = $request->get('overwrite');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$tableCategories = new TablesCategories();
$tableCategoriesChecker = $entityManager->getRepository(TablesCategories::class)->findOneBy(['kasseId'=> $requestData['kassenId'], 'createdBy' => $shopDate->getCreatedBy()]);
if($requestData) {
if($tableCategoriesChecker) {
$tableCategoriesChecker->setTakeoutOrder($requestData['takeoutOrder']);
$tableCategoriesChecker->setTaxMode($requestData['taxMode']);
$tableCategoriesChecker->setName($requestData['name']);
$tableCategoriesChecker->setKasseId($requestData['kassenId']);
$tableCategoriesChecker->setPriceDeviation($requestData['priceDeviation']);
$tableCategoriesChecker->setColor($requestData['color']);
$tableCategoriesChecker->setImageMode($requestData['imageMode']);
$tableCategoriesChecker->setDescription($requestData['description']);
$warengrup = $entityManager->getRepository(WarengruppenType::class)->findOneBy(['kassenID'=> $requestData['modeId'], 'createdBy' => $shopDate->getCreatedBy()]);
if($warengrup) {
$tableCategoriesChecker->setModeId($warengrup);
}
$tableCategoriesChecker->setSortId($requestData['sortId']);
// $tableCategoriesChecker->setImageName($requestData['imageName']);
$tableCategoriesChecker->setRunCustomerSelect($requestData['runCustomerSelect']);
$entityManager->persist($tableCategoriesChecker);
$entityManager->flush();
return $this->json($tableCategoriesChecker);
} else {
$tableCategories->setCreatedBy($shopDate->getCreatedBy());
$tableCategories->setTakeoutOrder($requestData['takeoutOrder']);
$tableCategories->setTaxMode($requestData['taxMode']);
$tableCategories->setName($requestData['name']);
$tableCategories->setKasseId($requestData['kassenId']);
$tableCategories->setPriceDeviation($requestData['priceDeviation']);
$tableCategories->setColor($requestData['color']);
$tableCategories->setImageMode($requestData['imageMode']);
$tableCategories->setDescription($requestData['description']);
$warengrup = $entityManager->getRepository(WarengruppenType::class)->findOneBy(['kassenID'=> $requestData['modeId'], 'createdBy' => $shopDate->getCreatedBy()]);
if($warengrup){
$tableCategories->setModeId($warengrup);
}
$tableCategories->setSortId($requestData['sortId']);
// $tableCategories->setImageName($requestData['imageName']);
$tableCategories->setRunCustomerSelect($requestData['runCustomerSelect']);
$entityManager->persist($tableCategories);
$entityManager->flush();
return $this->json($tableCategories);
}
} else {
return $this->json(false);
}
} else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/set-tische', name: 'api_admin_kasse_setwtische_global')]
public function APIConnectorSettischeKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
//$requestData = json_decode($request->getContent(), true);
$requestData = $request->request->all();
$connectorId = $requestData['connectorID'];
//$overwrite = $request->get('overwrite');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$tables = new Tables();
$tablesChecker = $entityManager->getRepository(Tables::class)->findOneBy(['kasseID'=> $requestData['kassenId'], 'createdBy' => $shopDate->getCreatedBy()]);
if($requestData) {
if($tablesChecker) {
$tablesChecker->setColorString($requestData['colorString']);
$tablesChecker->setDescription($requestData['description']);
$tablesChecker->setSortId($requestData['sortId']);
$tablesChecker->setUnpaidDetail($requestData['unpaidDetail']);
$tablesChecker->setAlertMessage($requestData['alertMessage']);
$tablesCategoryChecker = $entityManager->getRepository(TablesCategories::class)->findOneBy(['kasseId'=> $requestData['levelId'], 'createdBy' => $shopDate->getCreatedBy()]);
if($tablesCategoryChecker) {
$tablesChecker->setTablecategory($tablesCategoryChecker);
}
$tablesChecker->setKasseID($requestData['kassenId']);
$tablesChecker->setName($requestData['name']);
$entityManager->persist($tablesChecker);
$entityManager->flush();
return $this->json($tablesChecker);
} else {
$tables->setCreatedBy($shopDate->getCreatedBy());
$tables->setColorString($requestData['colorString']);
$tables->setDescription($requestData['description']);
$tables->setSortId($requestData['sortId']);
$tables->setUnpaidDetail($requestData['unpaidDetail']);
$tables->setAlertMessage($requestData['alertMessage']);
$tablesCategoryChecker = $entityManager->getRepository(TablesCategories::class)->findOneBy(['kasseId'=> $requestData['levelId'], 'createdBy' => $shopDate->getCreatedBy()]);
if($tablesCategoryChecker) {
$tables->setTablecategory($tablesCategoryChecker);
}
$tables->setKasseID($requestData['kassenId']);
$tables->setName($requestData['name']);
$entityManager->persist($tables);
$entityManager->flush();
return $this->json($tables);
}
} else {
return $this->json(false);
}
} else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/set-users', name: 'api_admin_kasse_setuser_global')]
public function APIConnectorSetuserKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
//$requestData = json_decode($request->getContent(), true);
$requestData = $request->request->all();
$connectorId = $requestData['connectorID'];
//$overwrite = $request->get('overwrite');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$kassenUser = new KassenUser();
$kassenUserCheck = $entityManager->getRepository(KassenUser::class)->findOneBy(['kasseId'=> $requestData['kasseId'], 'createdBy' => $shopDate->getCreatedBy()]);
if($requestData) {
if($kassenUserCheck) {
$kassenUserCheck->setKasseId($requestData['kasseId']);
$kassenUserCheck->setLogin($requestData['login']);
$entityManager->persist($kassenUserCheck);
$entityManager->flush();
return $this->json($kassenUserCheck);
} else {
$kassenUser->setCreatedBy($shopDate->getCreatedBy());
$kassenUser->setKasseId($requestData['kasseId']);
$kassenUser->setLogin($requestData['login']);
$entityManager->persist($kassenUser);
$entityManager->flush();
return $this->json($kassenUser);
}
} else {
return $this->json(false);
}
} else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/set-zutaten', name: 'api_admin_kasse_zutaten_global')]
public function APIConnectorSetZutatenKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
//$requestData = json_decode($request->getContent(), true);
$requestData = $request->request->all();
$connectorId = $requestData['connectorID'];
//$overwrite = $request->get('overwrite');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$warengruppenutype = new WarengruppenType();
$warengruppenutypeChecker = $entityManager->getRepository(WarengruppenType::class)->findOneBy(['kassenID'=> $requestData['kasseid'], 'createdBy' => $shopDate->getCreatedBy()]);
if($requestData) {
if($warengruppenutypeChecker) {
$warengruppenutypeChecker->setName($requestData['name']);
$warengruppenutypeChecker->setCodeSynchro($requestData['codeSynchro']);
$warengruppenutypeChecker->setDeviceId($requestData['deviceId']);
$warengruppenutypeChecker->setModeid($requestData['modeid']);
$warengruppenutypeChecker->setKassenID($requestData['kasseid']);
$entityManager->persist($warengruppenutypeChecker);
$entityManager->flush();
return $this->json($warengruppenutypeChecker);
} else {
$warengruppenutype->setCreatedBy($shopDate->getCreatedBy());
$warengruppenutype->setName($requestData['name']);
$warengruppenutype->setCodeSynchro($requestData['codeSynchro']);
$warengruppenutype->setDeviceId($requestData['deviceId']);
$warengruppenutype->setModeid($requestData['modeid']);
$warengruppenutype->setKassenID($requestData['kasseid']);
$entityManager->persist($warengruppenutype);
$entityManager->flush();
return $this->json($warengruppenutype);
}
} else {
return $this->json(false);
}
} else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/set-single-product', name: 'api_admin_kasse_setsingleproduct_global')]
public function APIConnectorSetSingleProductKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
$requestData = $request->request->all();;
$connectorId = $requestData['connectorID'];
//$overwrite = $request->get('overwrite');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
if($requestData) {
$slugger = new AsciiSlugger();
// Use the slug() method to convert the string to a URL format
$url = $slugger->slug($requestData['productName'])->lower()->toString();
$product = new Products();
$unuqueId = $requestData['id'];
$plu = $requestData['plu'];
$ean = $requestData['ean'];
$categoryName = $requestData['categoryName'];
$categoryId = $requestData['categoryId'];
$productName = $requestData['productName'];
$productPrice = $requestData['productPrice'];
$productHappyHourPrice = $requestData['productHappyHourPrice'];
$productTaxId = $requestData['productTaxId'];
$productTax = $requestData['productTax'];
$staticTax = $requestData['staticTax'];
$productConsisted = $requestData['productConsisted'];
$productKitchenName = $requestData['productKitchenName'];
$minUnit = $requestData['minUnit'];
$minUnitCount = $requestData['minUnitCount'];
$isService = $requestData['isService'];
$maxProductDiscount = $requestData['maxProductDiscount'];
$productColor = $requestData['productColor'];
$productImages = $requestData['productImages'];
$productImagesShow = $requestData['productImagesShow'];
$productSortIndex = $requestData['productSortIndex'];
$withSupplement = $requestData['withSupplement'];
$hasVariablePrice = $requestData['hasVariablePrice'];
$categoryCheck = $entityManager->getRepository(Category::class)->findOneBy(['name'=> $categoryName, 'createdBy' => $shopDate->getCreatedBy()]);
if(!$categoryCheck) {
return $this->json("Categories not found");
}
$p = $entityManager->getRepository(Products::class)->findOneBy(['unuqueId' => $unuqueId, 'createdBy' => $shopDate->getCreatedBy()]);
$tax = $entityManager->getRepository(Tax::class)->findOneBy(['kasseID' => $productTaxId, 'createdBy' => $shopDate->getCreatedBy()]);
if($p) {
$p->setUnuqueId($unuqueId);
$p->setEan($ean);
$p->setMinUnit($minUnit);
$p->setMinUnitCount($minUnitCount);
$p->setIsService($isService);
$p->setPlu($plu);
$p->setHasVariablePrice($hasVariablePrice);
$p->setCategory($categoryCheck);
$p->setName($productName);
$p->setPrice($productPrice);
$p->setPriceHappyHour($productHappyHourPrice);
$p->setProductTax($productTax);
if($tax) {
$p->setTax($tax);
}
$p->setUrl($url);
$p->setStaticTax($staticTax);
$p->setProductConsisted($productConsisted);
//$p->setProductKitchenName($productKitchenName);
$p->setMaxProductDiscount($maxProductDiscount);
$p->setColor($productColor);
$p->setSortID($productSortIndex);
$p->setSuppliment($withSupplement);
$p->setcreatedBy($shopDate->getCreatedBy());
$p->setDeviceId("");
$p->setKodSynchro("");
$entityManager->persist($p);
$entityManager->flush();
} else {
$product->setUnuqueId($unuqueId);
$product->setEan($ean);
$product->setPlu($plu);
$product->setMinUnit($minUnit);
$product->setMinUnitCount($minUnitCount);
$product->setIsService($isService);
$product->setHasVariablePrice($hasVariablePrice);
$product->setCategory($categoryCheck);
$product->setName($productName);
$product->setPrice($productPrice);
$product->setPriceHappyHour($productHappyHourPrice);
$product->setProductTax($productTax);
if($tax) {
$product->setTax($tax);
}
$product->setUrl($url);
$product->setStaticTax($staticTax);
$product->setProductConsisted($productConsisted);
//$product->setProductKitchenName($productConsisted);
$product->setMaxProductDiscount($maxProductDiscount);
$product->setColor($productColor);
$product->setSortID($productSortIndex);
$product->setSuppliment($withSupplement);
$product->setcreatedBy($shopDate->getCreatedBy());
$product->setDeviceId("");
$product->setKodSynchro("");
// encode the plain password
$entityManager->persist($product);
$entityManager->flush();
}
$entityManager->persist($product);
try {
$entityManager->flush();
return $this->json($product);
} catch (\Exception $ex) {
return $this->json("Error");
}
} else {
return $this->json(false);
}
} else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/get-tax', name: 'api_admin_kasse_gettax_global')]
public function APIConnectorGetTaxKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
$connectorId = str_replace('"', "", $request->get('connectorId'));
//$connectorId = $request->get('connectorId');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$tax = $entityManager->getRepository(Tax::class)->findBy(['createdBy' => $shopDate->getCreatedBy()]);
if($tax != null) {
return $this->json($tax);
} else {
return $this->json(false);
}
} else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/get-tische', name: 'api_admin_kasse_gettische_global')]
public function APIConnectorGetTischeKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
$connectorId = str_replace('"', "", $request->get('connectorId'));
//$connectorId = $request->get('connectorId');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$tables = $entityManager->getRepository(Tables::class)->findBy(['createdBy' => $shopDate->getCreatedBy()]);
if($tables != null) {
return $this->json($tables);
} else {
return $this->json(false);
}
} else {
return $this->json("Key missing");
}
}
#[Route('/api/kasse/get-raume', name: 'api_admin_kasse_getraume_global')]
public function APIConnectorGetraumeKasseGlobal(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): \Symfony\Component\HttpFoundation\JsonResponse
{
$connectorId = str_replace('"', "", $request->get('connectorId'));
//$connectorId = $request->get('connectorId');
$shopDate = $entityManager->getRepository(ShopData::class)->findOneBy(['connector' => $connectorId]);
if($shopDate) {
$tablescategories = $entityManager->getRepository(TablesCategories::class)->findBy(['createdBy' => $shopDate->getCreatedBy()]);
if($tablescategories != null) {
return $this->json($tablescategories);
} else {
return $this->json(false);
}
} else {
return $this->json("Key missing");
}
}
function addCategoryFunction() {
}
function addProducteFunction() {
}
}

src/Controller/RegistrationController.php line 49