src/Controller/ConfigureHelpdesk.php line 56

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' => 'uvdesk_mailbox',
  51.         ],
  52.     ];
  54.     public function load()
  55.     {
  56.         return $this->render('installation-wizard/index.html.twig');
  57.     }
  59.     public function evaluateSystemRequirements(Request $request, KernelInterface $kernel)
  60.     {
  61.         $max_execution_time = ini_get('max_execution_time');
  62.         // Evaluate system specification requirements
  63.         switch (strtolower($request->request->get('specification'))) {
  64.             case 'php-version':
  65.                 $response = [
  66.                     'status'  => version_compare(phpversion(), '7.0.0', '<') ? false : true,
  67.                     'version' => sprintf('%s.%s.%s', PHP_MAJOR_VERSION, PHP_MINOR_VERSION, PHP_RELEASE_VERSION),
  68.                 ];
  70.                 if ($response['status']) {
  71.                     $response['message'] = sprintf('Using PHP v%s', $response['version']);
  72.                 } else {
  73.                     $response['message'] = sprintf('Currently using PHP v%s. Please use PHP 7 or greater.', $response['version']);
  74.                 }
  75.                 break;
  76.             case 'php-extensions':
  77.                 $extensions_status = array_map(function ($extension) {
  78.                     return [
  79.                         $extension['name'] => extension_loaded($extension['name']),
  80.                     ];
  81.                 }, self::$requiredExtensions);
  83.                 $response = [
  84.                     'extensions' => $extensions_status,
  85.                 ];
  86.                 break;
  87.             case 'php-maximum-execution':
  88.                 $response['status' ] = $max_execution_time >= 30 ? true : false;
  90.                 if ($response['status']) {
  91.                     $response['message'] = sprintf('Maximum execution time is %s', ini_get('max_execution_time').' sec');
  92.                 } else {
  93.                     $response['message'] = sprintf('Please increase your max execution time.' );
  94.                     $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>';
  95.                 }
  96.                 break;
  97.             case 'php-envfile-permission':
  98.                     $filename =  $kernel->getProjectDir().'/.env';
  99.                     
  100.                     if (!is_writable($filename)) {
  101.                         @chmod($filename, 0666);
  102.                     }
  104.                     $response['status'] = is_writable($filename) ? true : false;
  105.    
  106.                     if ($response['status']) {
  107.                         $response['message'] = sprintf('Read/Write permission enabled for .env file.');
  108.                     } else {
  109.                         $response['message'] = sprintf('Please enable read/write permission for <b>.env</b> file of your project.');
  110.                         $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>';
  111.                     }
  112.                 break;
  113.             case 'php-configfiles-permission':
  114.                     $configfiles_status = array_map(function ($configfile) use ($kernel) {
  115.                         $filename = $kernel->getProjectDir().'/config/packages/'.$configfile['name'].'.yaml';
  116.                         
  117.                         if (!is_writable($filename)) {
  118.                             @chmod($filename, 0666);
  119.                         }
  121.                         return [
  122.                             $configfile['name'] => is_writable($filename) ,
  123.                         ];
  124.                     }, self::$requiredConfigfiles);
  125.    
  126.                     $response = [
  127.                         'configfiles' => $configfiles_status,
  128.                         '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>',
  129.                     ];
  130.                 break;
  131.             case 'redis-status':
  132.                 if (extension_loaded('redis')) {
  133.                     return new JsonResponse([
  134.                         'status'      => false,
  135.                         'message'     => "Redis extension is installed on your server follow the details",               
  136.                         '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>'
  137.                         ]);
  138.                 }
  139.                 break;
  140.             default:
  141.                 $code = 404;
  142.                 break;
  143.         }
  144.         
  145.         return new Response(json_encode($response ?? []), $code ?? 200, self::DEFAULT_JSON_HEADERS);
  146.     }
  148.     public function verifyDatabaseCredentials(Request $request)
  149.     {
  150.         if (session_status() == PHP_SESSION_NONE) {
  151.             session_start();
  152.         }
  153.         
  154.         try {
  155.             $connectionUrl = strtr(self::DB_URL_TEMPLATE, [
  156.                 '[host]'     => $request->request->get('serverName'),
  157.                 '[port]'     => $request->request->get('serverPort'),
  158.                 '[user]'     => $request->request->get('username'),
  159.                 '[password]' => $request->request->get('password'),
  160.             ]);
  162.             if ($request->request->get('serverVersion') != null) {
  163.                 $connectionUrl .= "?serverVersion=" . $request->request->get('serverVersion');
  164.             }
  166.             $databaseConnection = DriverManager::getConnection([
  167.                 'url' => $connectionUrl,
  168.             ]);
  170.             $entityManager = EntityManager::create($databaseConnection, Setup::createAnnotationMetadataConfiguration(['src/Entity'], false));
  171.             
  172.             // Establish a connection if not active
  173.             if (false == $databaseConnection->isConnected()) {
  174.                 $databaseConnection->connect();
  175.             }
  177.             // Check if database exists
  178.             $createDatabase = (bool) $request->request->get('createDatabase');
  180.             if (
  181.                 ! in_array($request->request->get('database'), $databaseConnection->getSchemaManager()->listDatabases()) 
  182.                 && false == $createDatabase
  183.             ) {
  184.                 return new JsonResponse([
  185.                     'status'  => false,
  186.                     'message' => "The requested database was not found."
  187.                 ]);
  188.             }
  190.             // Storing database configuration to session.
  191.             $_SESSION['DB_CONFIG'] = [
  192.                 'host'           => $request->request->get('serverName'),
  193.                 'port'           => $request->request->get('serverPort'),
  194.                 'version'        => $request->request->get('serverVersion'),
  195.                 'username'       => $request->request->get('username'),
  196.                 'password'       => $request->request->get('password'),
  197.                 'database'       => $request->request->get('database'),
  198.                 'createDatabase' => $createDatabase,
  199.             ];
  200.         } catch (\Exception $e) {
  201.             return new JsonResponse([
  202.                 'status'  => false,
  203.                 'message' => "Failed to establish a connection with database server."
  204.             ]);
  205.         }
  206.         
  207.         return new JsonResponse(['status' => true]);
  208.     }
  210.     public function prepareSuperUserDetailsXHR(Request $request)
  211.     {
  212.         if (session_status() == PHP_SESSION_NONE) {
  213.             session_start();
  214.         }
  215.         
  216.         // unset($_SESSION['USER_DETAILS']);
  218.         $_SESSION['USER_DETAILS'] = [
  219.             'name'     => $request->request->get('name'),
  220.             'email'    => $request->request->get('email'),
  221.             'password' => $request->request->get('password'),
  222.         ];
  224.         return new Response(json_encode(['status' => true]), 200, self::DEFAULT_JSON_HEADERS);
  225.     }
  227.     public function updateConfigurationsXHR(Request $request, KernelInterface $kernel)
  228.     {
  229.         if (session_status() == PHP_SESSION_NONE) {
  230.             session_start();
  231.         }
  233.         $database_host    = $_SESSION['DB_CONFIG']['host'];
  234.         $database_port    = $_SESSION['DB_CONFIG']['port'];
  235.         $database_version = $_SESSION['DB_CONFIG']['version'];
  236.         $database_user    = $_SESSION['DB_CONFIG']['username'];
  237.         $database_pass    = $_SESSION['DB_CONFIG']['password'];
  238.         $database_name    = $_SESSION['DB_CONFIG']['database'];
  240.         $create_database = $_SESSION['DB_CONFIG']['createDatabase'];
  242.         try {
  243.             $connectionUrl = strtr(self::DB_URL_TEMPLATE, [
  244.                 '[host]'     => $database_host,
  245.                 '[port]'     => $database_port,
  246.                 '[user]'     => $database_user,
  247.                 '[password]' => $database_pass,
  248.             ]);
  250.             if (! empty($database_version)) {
  251.                 $connectionUrl .= "?serverVersion=$database_version";
  252.             }
  254.             $databaseConnection = DriverManager::getConnection([
  255.                 'url' => $connectionUrl,
  256.             ]);
  258.             $entityManager = EntityManager::create($databaseConnection, Setup::createAnnotationMetadataConfiguration(['src/Entity'], false));
  260.             // Establish an active connection with database server
  261.             if (false == $databaseConnection->isConnected()) {
  262.                 $databaseConnection->connect();
  263.             }
  265.             // Check if database exists
  266.             if (! in_array($database_name, $databaseConnection->getSchemaManager()->listDatabases())) {
  267.                 if (false == $create_database) {
  268.                     throw new \Exception('Database does not exist.');
  269.                 }
  270.                 
  271.                 // Create database
  272.                 $databaseConnection->getSchemaManager()->createDatabase($databaseConnection->getDatabasePlatform()->quoteSingleIdentifier($database_name));
  273.             }
  275.             $connectionUrl = strtr(self::DB_URL_TEMPLATE . "/[database]", [
  276.                 '[host]'     => $database_host,
  277.                 '[port]'     => $database_port,
  278.                 '[user]'     => $database_user,
  279.                 '[password]' => $database_pass,
  280.                 '[database]' => $database_name,
  281.             ]);
  283.             if (!empty($database_version)) {
  284.                 $connectionUrl .= "?serverVersion=$database_version";
  285.             }
  287.             // Update .env
  288.             $application = new Application($kernel);
  289.             $application->setAutoExit(false);
  291.             $returnCode = $application->run(new ArrayInput([
  292.                 'command' => 'uvdesk_wizard:env:update', 
  293.                 'name'    => 'DATABASE_URL', 
  294.                 'value'   => $connectionUrl
  295.             ]), new NullOutput());
  296.     
  297.             if (0 === $returnCode) {
  298.                 return new JsonResponse(['success' => true]);
  299.             }
  300.         } catch (\Exception $e) {
  301.             return new JsonResponse([
  302.                 'status'  => false,
  303.                 'message' => "An unexpected error occurred: " . $e->getMessage(), 
  304.             ]);
  305.         }
  307.         return new JsonResponse(['success' => false], 500);
  308.     }
  310.     public function migrateDatabaseSchemaXHR(Request $request, KernelInterface $kernel)
  311.     {
  312.         $application = new Application($kernel);
  313.         $application->setAutoExit(false);
  315.         $resultCode = $application->run(new ArrayInput([
  316.             'command' => 'uvdesk_wizard:database:migrate'
  317.         ]), new NullOutput());
  318.         
  319.         return new Response(json_encode([]), 200, self::DEFAULT_JSON_HEADERS);
  320.     }
  322.     public function populateDatabaseEntitiesXHR(Request $request, KernelInterface $kernel)
  323.     {
  324.         $application = new Application($kernel);
  325.         $application->setAutoExit(false);
  327.         $resultCode = $application->run(new ArrayInput([
  328.             'command'  => 'doctrine:fixtures:load',
  329.             '--append' => true,
  330.         ]), new NullOutput());
  332.         return new Response(json_encode([]), 200, self::DEFAULT_JSON_HEADERS);
  333.     }
  335.     public function createDefaultSuperUserXHR(Request $request, UserPasswordEncoderInterface $encoder)
  336.     {
  337.         if (session_status() == PHP_SESSION_NONE) {
  338.             session_start();
  339.         }
  341.         // $entityManager = $this->getDoctrine()->getEntityManager();
  342.         $entityManager = $this->getDoctrine()->getManager();
  344.         $role = $entityManager->getRepository(SupportRole::class)->findOneByCode('ROLE_SUPER_ADMIN');
  345.         $userInstance = $entityManager->getRepository(UserInstance::class)->findOneBy([
  346.             'isActive'    => true,
  347.             'supportRole' => $role,
  348.         ]);
  349.             
  350.         if (empty($userInstance)) {
  351.             list($name, $email, $password) = array_values($_SESSION['USER_DETAILS']);
  352.             // Retrieve existing user or generate new empty user
  353.             $accountExistsFlag = false;
  354.             $user = $entityManager->getRepository(User::class)->findOneByEmail($email) ?: (new User())->setEmail($email);
  356.             if ($user->getId() != null) {
  357.                 $userInstance = $user->getAgentInstance();
  359.                 if (!empty($userInstance)) {
  360.                     $accountExistsFlag = true;
  362.                     if ($userInstance->getSupportRole()->getId() != $role->getId()) {
  363.                         $userInstance->setSupportRole($role);
  365.                         $entityManager->persist($userInstance);
  366.                         $entityManager->flush();
  367.                     }
  368.                 }
  369.             } else {
  370.                 $username = explode(' ', $name, 2);
  371.                 $encodedPassword = $encoder->encodePassword($user, $password);
  373.                 $user
  374.                     ->setFirstName($username[0])
  375.                     ->setLastName(! empty($username[1]) ? $username[1] : '')
  376.                     ->setPassword($encodedPassword)
  377.                     ->setIsEnabled(true);
  378.                 
  379.                 $entityManager->persist($user);
  380.                 $entityManager->flush();
  381.             }
  382.             
  383.             if (false == $accountExistsFlag) {
  384.                 $userInstance = new UserInstance();
  385.                 $userInstance->setSource('website');
  386.                 $userInstance->setIsActive(true);
  387.                 $userInstance->setIsVerified(true);
  388.                 $userInstance->setUser($user);
  389.                 $userInstance->setSupportRole($role);
  391.                 $entityManager->persist($userInstance);
  392.                 $entityManager->flush();
  393.             }
  394.         }
  396.         return new Response(json_encode([]), 200, self::DEFAULT_JSON_HEADERS);
  397.     }
  399.     public function websiteConfigurationXHR(Request $request, UVDeskService $uvdesk)
  400.     {
  401.         switch ($request->getMethod()) {
  402.             case "GET":
  403.                 $currentWebsitePrefixCollection = $uvdesk->getCurrentWebsitePrefixes();
  404.                 
  405.                 if ($currentWebsitePrefixCollection) {
  406.                     $result = $currentWebsitePrefixCollection;
  407.                     $result['status'] = true;
  408.                 } else {
  409.                     $result['status'] = false;
  410.                 }
  411.                 break;
  412.             case "POST":
  413.                 if (session_status() == PHP_SESSION_NONE) {
  414.                     session_start();
  415.                 }
  416.                 
  417.                 $_SESSION['PREFIXES_DETAILS'] = [
  418.                     'member'   => $request->request->get('member-prefix'),
  419.                     'customer' => $request->request->get('customer-prefix'),
  420.                 ];
  422.                 $result = ['status' => true];
  423.                 break;
  424.             default:
  425.                 break;
  426.         }
  428.         return new Response(json_encode($result ?? []), 200, self::DEFAULT_JSON_HEADERS);
  429.     }
  431.     public function updateWebsiteConfigurationXHR(Request $request, UVDeskService $uvdesk)
  432.     {
  433.         if (session_status() == PHP_SESSION_NONE) {
  434.             session_start();
  435.         }
  437.         $collectionURL= $uvdesk->updateWebsitePrefixes(
  438.             $_SESSION['PREFIXES_DETAILS']['member'],
  439.             $_SESSION['PREFIXES_DETAILS']['customer']
  440.         );
  441.         
  442.         // uvdesk tracker
  443.         $userDetails =[
  444.             'name'   => $_SESSION['USER_DETAILS']['name'],
  445.             'email'  => $_SESSION['USER_DETAILS']['email'],
  446.             'domain' => $this->getParameter('uvdesk.site_url'),
  447.         ];
  448.         
  449.         Helpdesk::addUserDetailsInTracker($userDetails);
  451.         return new Response(json_encode($collectionURL), 200, self::DEFAULT_JSON_HEADERS);
  452.     }
  453. }