src/Controller/ConfigureHelpdesk.php line 57

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Console\Wizard\ConfigureHelpdesk as Helpdesk;
  6. use Doctrine\DBAL\DriverManager;
  7. use Doctrine\ORM\Tools\Setup;
  8. use Doctrine\ORM\EntityManager;
  9. use Symfony\Bundle\FrameworkBundle\Console\Application;
  10. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  11. use Symfony\Component\Yaml\Yaml;
  12. use Symfony\Component\HttpFoundation\Request;
  13. use Symfony\Component\HttpFoundation\Response;
  14. use Symfony\Component\Console\Input\ArrayInput;
  15. use Symfony\Component\Console\Output\NullOutput;
  16. use Symfony\Component\HttpKernel\KernelInterface;
  17. use Symfony\Component\HttpFoundation\JsonResponse;
  18. use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
  19. use Webkul\UVDesk\CoreFrameworkBundle\Entity\SupportRole;
  20. use Webkul\UVDesk\CoreFrameworkBundle\Entity\User;
  21. use Webkul\UVDesk\CoreFrameworkBundle\Entity\UserInstance;
  22. use Webkul\UVDesk\CoreFrameworkBundle\Services\UVDeskService;
  24. class ConfigureHelpdesk extends AbstractController
  25. {
  26.     const DB_URL_TEMPLATE = "mysql://[user]:[password]@[host]:[port]";
  27.     const DB_ENV_PATH_TEMPLATE = "DATABASE_URL=DB_DRIVER://DB_USER:DB_PASSWORD@DB_HOST/DB_NAME\n";
  28.     const DB_ENV_PATH_PARAM_TEMPLATE = "env(DATABASE_URL): 'DB_DRIVER://DB_USER:DB_PASSWORD@DB_HOST/DB_NAME'\n";
  29.     const DEFAULT_JSON_HEADERS = [
  30.         'Content-Type' => 'application/json',
  31.     ];
  33.     private static $requiredExtensions = [
  34.         [
  35.             'name' => 'imap',
  36.         ],
  37.         [
  38.             'name' => 'mailparse',
  39.         ],
  40.         [
  41.             'name' => 'mysqli',
  42.         ],
  43.     ];
  45.     private static $requiredConfigfiles = [
  46.         [
  47.             'name' => 'uvdesk',
  48.         ],
  49.         [
  50.             'name' => 'swiftmailer',
  51.         ],
  52.         [
  53.             'name' => 'uvdesk_mailbox',
  54.         ],
  55.     ];
  57.     public function load()
  58.     {
  59.         return $this->render('installation-wizard/index.html.twig');
  60.     }
  62.     public function evaluateSystemRequirements(Request $request, KernelInterface $kernel)
  63.     {
  64.         $max_execution_time = ini_get('max_execution_time');
  65.         // Evaluate system specification requirements
  66.         switch (strtolower($request->request->get('specification'))) {
  67.             case 'php-version':
  68.                 $response = [
  69.                     'status'  => version_compare(phpversion(), '7.0.0', '<') ? false : true,
  70.                     'version' => sprintf('%s.%s.%s', PHP_MAJOR_VERSION, PHP_MINOR_VERSION, PHP_RELEASE_VERSION),
  71.                 ];
  73.                 if ($response['status']) {
  74.                     $response['message'] = sprintf('Using PHP v%s', $response['version']);
  75.                 } else {
  76.                     $response['message'] = sprintf('Currently using PHP v%s. Please use PHP 7 or greater.', $response['version']);
  77.                 }
  78.                 break;
  79.             case 'php-extensions':
  80.                 $extensions_status = array_map(function ($extension) {
  81.                     return [
  82.                         $extension['name'] => extension_loaded($extension['name']),
  83.                     ];
  84.                 }, self::$requiredExtensions);
  86.                 $response = [
  87.                     'extensions' => $extensions_status,
  88.                 ];
  89.                 break;
  90.             case 'php-maximum-execution':
  91.                 $response['status' ] = $max_execution_time >= 30 ? true : false;
  93.                 if ($response['status']) {
  94.                     $response['message'] = sprintf('Maximum execution time is %s', ini_get('max_execution_time').' sec');
  95.                 } else {
  96.                     $response['message'] = sprintf('Please increase your max execution time.' );
  97.                     $response['description'] = '</span>Issue can be resolved by simply<p><a href="https://www.simplified.guide/php/increase-max-execution-time" target="_blank"> increasing your maximum execution time</a> make it 60 or more and restart your server after making this change, refresh the browser and try again.</p>';
  98.                 }
  99.                 break;
  100.             case 'php-envfile-permission':
  101.                     $filename =  $kernel->getProjectDir().'/.env';
  102.                     $response['status'] = is_writable($filename) ? true : false;
  103.    
  104.                     if ($response['status']) {
  105.                         $response['message'] = sprintf('Read/Write permission enabled for .env file.');
  106.                     } else {
  107.                         $response['message'] = sprintf('Please enable read/write permission for <b>.env</b> file of your project.');
  108.                         $response['description'] = '</span> Issue can be resolved by simply <a href="https://www.uvdesk.com/en/blog/open-source-helpdesk-installation-on-ubuntu-uvdesk/" target="_blank"><p> enabling your <b>.env</b> file read/write permission</a> refresh the browser and try again.</p>';
  109.                     }
  110.                 break;
  111.             case 'php-configfiles-permission':
  112.                     $configfiles_status = array_map(function ($configfile) use ($kernel) {
  113.                         return [
  114.                             $configfile['name'] => is_writable($kernel->getProjectDir().'/config/packages/'.$configfile['name'].'.yaml') ,
  115.                         ];
  116.                     }, self::$requiredConfigfiles);
  117.    
  118.                     $response = [
  119.                         'configfiles' => $configfiles_status,
  120.                         'description' => '</span> <br><p> Issue can be resolved by simply <a href="https://www.uvdesk.com/en/blog/open-source-helpdesk-installation-on-ubuntu-uvdesk/" target="_blank"> enabling read/write permissions for your files under config/packages folder of your project.</a></p>',
  121.                     ];
  122.                 break;
  123.             case 'redis-status':
  124.                 if (extension_loaded('redis')) {
  125.                     return new JsonResponse([
  126.                         'status'      => false,
  127.                         'message'     => "Redis extension is installed on your server follow the details",               
  128.                         'description' =>'<span>Please check the  <a href="https://github.com/uvdesk/community-skeleton/issues/364#issuecomment-780486976" target="_blank">Redis host</a> specified in the <span style="font-weight:600;">setup.php</span> file. If your Redis server host is different, you can either update it with your Redis host or follow the steps in the <a href="https://github.com/uvdesk/community-skeleton/issues/364#issuecomment-780486976" target="_blank">URL</a>. After making the changes, reload the page and try again.</span>'
  129.                         ]);
  130.                 }
  131.                 break;
  132.             default:
  133.                 $code = 404;
  134.                 break;
  135.         }
  136.         
  137.         return new Response(json_encode($response ?? []), $code ?? 200, self::DEFAULT_JSON_HEADERS);
  138.     }
  140.     public function verifyDatabaseCredentials(Request $request)
  141.     {
  142.         if (session_status() == PHP_SESSION_NONE) {
  143.             session_start();
  144.         }
  145.         
  146.         try {
  147.             $connectionUrl = strtr(self::DB_URL_TEMPLATE, [
  148.                 '[host]'     => $request->request->get('serverName'),
  149.                 '[port]'     => $request->request->get('serverPort'),
  150.                 '[user]'     => $request->request->get('username'),
  151.                 '[password]' => $request->request->get('password'),
  152.             ]);
  154.             if ($request->request->get('serverVersion') != null) {
  155.                 $connectionUrl .= "?serverVersion=" . $request->request->get('serverVersion');
  156.             }
  158.             $databaseConnection = DriverManager::getConnection([
  159.                 'url' => $connectionUrl,
  160.             ]);
  162.             $entityManager = EntityManager::create($databaseConnection, Setup::createAnnotationMetadataConfiguration(['src/Entity'], false));
  163.             
  164.             // Establish a connection if not active
  165.             if (false == $databaseConnection->isConnected()) {
  166.                 $databaseConnection->connect();
  167.             }
  169.             // Check if database exists
  170.             $createDatabase = (bool) $request->request->get('createDatabase');
  172.             if (
  173.                 ! in_array($request->request->get('database'), $databaseConnection->getSchemaManager()->listDatabases()) 
  174.                 && false == $createDatabase
  175.             ) {
  176.                 return new JsonResponse([
  177.                     'status'  => false,
  178.                     'message' => "The requested database was not found."
  179.                 ]);
  180.             }
  182.             // Storing database configuration to session.
  183.             $_SESSION['DB_CONFIG'] = [
  184.                 'host'           => $request->request->get('serverName'),
  185.                 'port'           => $request->request->get('serverPort'),
  186.                 'version'        => $request->request->get('serverVersion'),
  187.                 'username'       => $request->request->get('username'),
  188.                 'password'       => $request->request->get('password'),
  189.                 'database'       => $request->request->get('database'),
  190.                 'createDatabase' => $createDatabase,
  191.             ];
  192.         } catch (\Exception $e) {
  193.             return new JsonResponse([
  194.                 'status'  => false,
  195.                 'message' => "Failed to establish a connection with database server."
  196.             ]);
  197.         }
  198.         
  199.         return new JsonResponse(['status' => true]);
  200.     }
  202.     public function prepareSuperUserDetailsXHR(Request $request)
  203.     {
  204.         if (session_status() == PHP_SESSION_NONE) {
  205.             session_start();
  206.         }
  207.         
  208.         // unset($_SESSION['USER_DETAILS']);
  210.         $_SESSION['USER_DETAILS'] = [
  211.             'name'     => $request->request->get('name'),
  212.             'email'    => $request->request->get('email'),
  213.             'password' => $request->request->get('password'),
  214.         ];
  216.         return new Response(json_encode(['status' => true]), 200, self::DEFAULT_JSON_HEADERS);
  217.     }
  219.     public function updateConfigurationsXHR(Request $request, KernelInterface $kernel)
  220.     {
  221.         if (session_status() == PHP_SESSION_NONE) {
  222.             session_start();
  223.         }
  225.         $database_host    = $_SESSION['DB_CONFIG']['host'];
  226.         $database_port    = $_SESSION['DB_CONFIG']['port'];
  227.         $database_version = $_SESSION['DB_CONFIG']['version'];
  228.         $database_user    = $_SESSION['DB_CONFIG']['username'];
  229.         $database_pass    = $_SESSION['DB_CONFIG']['password'];
  230.         $database_name    = $_SESSION['DB_CONFIG']['database'];
  232.         $create_database = $_SESSION['DB_CONFIG']['createDatabase'];
  234.         try {
  235.             $connectionUrl = strtr(self::DB_URL_TEMPLATE, [
  236.                 '[host]'     => $database_host,
  237.                 '[port]'     => $database_port,
  238.                 '[user]'     => $database_user,
  239.                 '[password]' => $database_pass,
  240.             ]);
  242.             if (! empty($database_version)) {
  243.                 $connectionUrl .= "?serverVersion=$database_version";
  244.             }
  246.             $databaseConnection = DriverManager::getConnection([
  247.                 'url' => $connectionUrl,
  248.             ]);
  250.             $entityManager = EntityManager::create($databaseConnection, Setup::createAnnotationMetadataConfiguration(['src/Entity'], false));
  252.             // Establish an active connection with database server
  253.             if (false == $databaseConnection->isConnected()) {
  254.                 $databaseConnection->connect();
  255.             }
  257.             // Check if database exists
  258.             if (! in_array($database_name, $databaseConnection->getSchemaManager()->listDatabases())) {
  259.                 if (false == $create_database) {
  260.                     throw new \Exception('Database does not exist.');
  261.                 }
  262.                 
  263.                 // Create database
  264.                 $databaseConnection->getSchemaManager()->createDatabase($databaseConnection->getDatabasePlatform()->quoteSingleIdentifier($database_name));
  265.             }
  267.             $connectionUrl = strtr(self::DB_URL_TEMPLATE . "/[database]", [
  268.                 '[host]'     => $database_host,
  269.                 '[port]'     => $database_port,
  270.                 '[user]'     => $database_user,
  271.                 '[password]' => $database_pass,
  272.                 '[database]' => $database_name,
  273.             ]);
  275.             if (!empty($database_version)) {
  276.                 $connectionUrl .= "?serverVersion=$database_version";
  277.             }
  279.             // Update .env
  280.             $application = new Application($kernel);
  281.             $application->setAutoExit(false);
  283.             $returnCode = $application->run(new ArrayInput([
  284.                 'command' => 'uvdesk_wizard:env:update', 
  285.                 'name'    => 'DATABASE_URL', 
  286.                 'value'   => $connectionUrl
  287.             ]), new NullOutput());
  288.     
  289.             if (0 === $returnCode) {
  290.                 return new JsonResponse(['success' => true]);
  291.             }
  292.         } catch (\Exception $e) {
  293.             return new JsonResponse([
  294.                 'status'  => false,
  295.                 'message' => "An unexpected error occurred: " . $e->getMessage(), 
  296.             ]);
  297.         }
  299.         return new JsonResponse(['success' => false], 500);
  300.     }
  302.     public function migrateDatabaseSchemaXHR(Request $request, KernelInterface $kernel)
  303.     {
  304.         $application = new Application($kernel);
  305.         $application->setAutoExit(false);
  307.         $resultCode = $application->run(new ArrayInput([
  308.             'command' => 'uvdesk_wizard:database:migrate'
  309.         ]), new NullOutput());
  310.         
  311.         return new Response(json_encode([]), 200, self::DEFAULT_JSON_HEADERS);
  312.     }
  314.     public function populateDatabaseEntitiesXHR(Request $request, KernelInterface $kernel)
  315.     {
  316.         $application = new Application($kernel);
  317.         $application->setAutoExit(false);
  319.         $resultCode = $application->run(new ArrayInput([
  320.             'command'  => 'doctrine:fixtures:load',
  321.             '--append' => true,
  322.         ]), new NullOutput());
  324.         return new Response(json_encode([]), 200, self::DEFAULT_JSON_HEADERS);
  325.     }
  327.     public function createDefaultSuperUserXHR(Request $request, UserPasswordEncoderInterface $encoder)
  328.     {
  329.         if (session_status() == PHP_SESSION_NONE) {
  330.             session_start();
  331.         }
  333.         // $entityManager = $this->getDoctrine()->getEntityManager();
  334.         $entityManager = $this->getDoctrine()->getManager();
  336.         $role = $entityManager->getRepository(SupportRole::class)->findOneByCode('ROLE_SUPER_ADMIN');
  337.         $userInstance = $entityManager->getRepository(UserInstance::class)->findOneBy([
  338.             'isActive'    => true,
  339.             'supportRole' => $role,
  340.         ]);
  341.             
  342.         if (empty($userInstance)) {
  343.             list($name, $email, $password) = array_values($_SESSION['USER_DETAILS']);
  344.             // Retrieve existing user or generate new empty user
  345.             $accountExistsFlag = false;
  346.             $user = $entityManager->getRepository(User::class)->findOneByEmail($email) ?: (new User())->setEmail($email);
  348.             if ($user->getId() != null) {
  349.                 $userInstance = $user->getAgentInstance();
  351.                 if (!empty($userInstance)) {
  352.                     $accountExistsFlag = true;
  354.                     if ($userInstance->getSupportRole()->getId() != $role->getId()) {
  355.                         $userInstance->setSupportRole($role);
  357.                         $entityManager->persist($userInstance);
  358.                         $entityManager->flush();
  359.                     }
  360.                 }
  361.             } else {
  362.                 $username = explode(' ', $name, 2);
  363.                 $encodedPassword = $encoder->encodePassword($user, $password);
  365.                 $user
  366.                     ->setFirstName($username[0])
  367.                     ->setLastName(! empty($username[1]) ? $username[1] : '')
  368.                     ->setPassword($encodedPassword)
  369.                     ->setIsEnabled(true);
  370.                 
  371.                 $entityManager->persist($user);
  372.                 $entityManager->flush();
  373.             }
  374.             
  375.             if (false == $accountExistsFlag) {
  376.                 $userInstance = new UserInstance();
  377.                 $userInstance->setSource('website');
  378.                 $userInstance->setIsActive(true);
  379.                 $userInstance->setIsVerified(true);
  380.                 $userInstance->setUser($user);
  381.                 $userInstance->setSupportRole($role);
  383.                 $entityManager->persist($userInstance);
  384.                 $entityManager->flush();
  385.             }
  386.         }
  388.         return new Response(json_encode([]), 200, self::DEFAULT_JSON_HEADERS);
  389.     }
  391.     public function websiteConfigurationXHR(Request $request, UVDeskService $uvdesk)
  392.     {
  393.         switch ($request->getMethod()) {
  394.             case "GET":
  395.                 $currentWebsitePrefixCollection = $uvdesk->getCurrentWebsitePrefixes();
  396.                 
  397.                 if ($currentWebsitePrefixCollection) {
  398.                     $result = $currentWebsitePrefixCollection;
  399.                     $result['status'] = true;
  400.                 } else {
  401.                     $result['status'] = false;
  402.                 }
  403.                 break;
  404.             case "POST":
  405.                 if (session_status() == PHP_SESSION_NONE) {
  406.                     session_start();
  407.                 }
  408.                 
  409.                 $_SESSION['PREFIXES_DETAILS'] = [
  410.                     'member'   => $request->request->get('member-prefix'),
  411.                     'customer' => $request->request->get('customer-prefix'),
  412.                 ];
  414.                 $result = ['status' => true];
  415.                 break;
  416.             default:
  417.                 break;
  418.         }
  420.         return new Response(json_encode($result ?? []), 200, self::DEFAULT_JSON_HEADERS);
  421.     }
  423.     public function updateWebsiteConfigurationXHR(Request $request, UVDeskService $uvdesk)
  424.     {
  425.         if (session_status() == PHP_SESSION_NONE) {
  426.             session_start();
  427.         }
  429.         $collectionURL= $uvdesk->updateWebsitePrefixes(
  430.             $_SESSION['PREFIXES_DETAILS']['member'],
  431.             $_SESSION['PREFIXES_DETAILS']['customer']
  432.         );
  433.         
  434.         // uvdesk tracker
  435.         $userDetails =[
  436.             'name'   => $_SESSION['USER_DETAILS']['name'],
  437.             'email'  => $_SESSION['USER_DETAILS']['email'],
  438.             'domain' => $this->getParameter('uvdesk.site_url'),
  439.         ];
  440.         
  441.         Helpdesk::addUserDetailsInTracker($userDetails);
  443.         return new Response(json_encode($collectionURL), 200, self::DEFAULT_JSON_HEADERS);
  444.     }
  445. }