src/Custom/ABFController.php line 150

Open in your IDE?
  1. <?php
  3. /**
  4.  * @file
  5.  *   Contriller for use in the app that adds some constantly used helper methods.
  6.  *
  7.  * @ToDo Add a server side password validation function to test for all the password requirements.
  8.  */
  10. namespace App\Custom;
  12. use App\Custom\ABFWebService;
  13. use Psr\Log\LoggerInterface;
  14. use stdClass;
  15. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  16. use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
  17. use Symfony\Component\HttpFoundation\RequestStack;
  18. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  20. /**
  21.  * Controller for the app pages
  22.  */
  23. class ABFController extends AbstractController
  24. {
  25.     /**
  26.      * Logging.
  27.      *
  28.      * @var LoggerInterface
  29.      */
  30.     protected $logger;
  32.     /**
  33.      * Session.
  34.      *
  35.      * @var SessionInterface
  36.      */
  37.     protected $session;
  39.     /**
  40.      * @var RequestStack
  41.      */
  42.     protected $requestStack;
  44.     /**
  45.      * Parameters that we want to use immediately.
  46.      */
  47.     protected $params;
  49.     /**
  50.      * Session timeout in seconds
  51.      *
  52.      * @var int
  53.      */
  54.     protected $sessionTimeout;
  56.     /**
  57.      * Link to API interface.
  58.      *
  59.      * @var ABFWebService
  60.      */
  61.     protected $api;
  63.     /**
  64.      * Constructor
  65.      *
  66.      * @param LoggerInterface       $logger       Access to the logging system.
  67.      * @param RequestStack          $requestStack Interface to the PHP request.
  68.      * @param ParameterBagInterface $params       Interface to the parameters of the app.
  69.      */
  70.     public function __construct(LoggerInterface $logger, RequestStack $requestStack, ParameterBagInterface $params)
  71.     {
  72.         $this->logger = $logger;
  73.         $this->requestStack = $requestStack;
  74.         $this->params = $params;
  75.         $this->session = $this->requestStack->getSession();
  76.         $this->sessionTimeout = $this->params->get('session.timeout');
  77.         $this->api = $this->getWebservice();
  78.     }
  80.     /**
  81.      * Load an instance of the ABFWebService for communication with the API
  82.      *
  83.      * @return ABFWebService
  84.      */
  85.     protected function getWebservice(): ABFWebService
  86.     {
  87.         return new ABFWebService(
  88.             $this->params->get('api.host'),
  89.             $this->params->get('api.port'),
  90.             $this->params->get('api.user'),
  91.             $this->params->get('api.pass'),
  92.             $this->params->get('api.queue')
  93.         );
  94.     }
  96.     /**
  97.      * Handler for ABFErrorExceptions.
  98.      *
  99.      * 412 Errors are sent when the API returns OK = 0.
  100.      * 418 Errors are sent when an exception happened in the packet and queue process.
  101.      *
  102.      * @param ABFErrorException $e The thrown exception.
  103.      *
  104.      * @return string The message to print.
  105.      */
  106.     protected function handleABFError(ABFErrorException $e): string
  107.     {
  108.         $message = '';
  109.         // Log the error locally.
  110.         $this->logger->error(sprintf('ABF Error: %d - %s', $e->getCode(), $e->getMessage()));
  112.         switch ($e->getCode()) {
  113.             case 412:
  114.                 $message = sprintf("The system could not handle your request at this time. (%s)", $e->getMessage());
  115.                 break;
  116.             case 418:
  117.                 $message = "The connection to the system was interrupted. Please try your request again";
  118.                 break;
  119.             default:
  120.                 $message = "An error has occurred in the background. Please try your request again.";
  121.         }
  123.         return $message;
  124.     }
  126.     /**
  127.      * Sets the session timer.
  128.      *
  129.      */
  130.     protected function setSessionTimer(): void
  131.     {
  132.         $this->session->set('t', time());
  133.     }
  135.     /**
  136.      * Check to see if session is still valid for the time peroid.
  137.      * Session needs to be cleared at 20min.
  138.      *
  139.      * @return bool
  140.      */
  141.     protected function isSessionValid(): bool
  142.     {
  143.         // Test if session exists.
  144.         if (!$this->session) {
  145.             $this->session->start();
  147.             return false;
  148.         }
  150.         $startTime = (int) $this->session->get('t', 0);
  151.         // If the app session timeout is 5min or less just use that.
  152.         // Otherwise use 80% of the session timeout value.
  153.         // The Goal is to have the app timer run out before the api timer for the session.
  154.         $period = (600 >= $this->sessionTimeout ? $this->sessionTimeout : (int) $this->sessionTimeout * 0.8);
  155.         $now = time();
  157.         $this->logger->info(sprintf('Starttime: %d, Period: %d, Now: %d', $startTime, $period, $now));
  158.         $this->logger->info(sprintf("Start + period is after now? %s", (($startTime + $period) > $now)));
  160.         return ($startTime + $period) > $now;
  161.     }
  163.     /**
  164.      * Create a stable one way encryption of a password.
  165.      *
  166.      * @param string $password
  167.      *   The password string to encrypt
  168.      *
  169.      * @return string
  170.      *   The encrypted password.
  171.      */
  172.     protected function encryptPassword(string $password): string
  173.     {
  174.         // Use the app secret as the salt.
  175.         $salt = $this->params->get('app.secret');
  176.         $this->logger->info("Salt: " . $salt);
  177.         return crypt(trim($password), $salt);
  178.     }
  180.     /**
  181.      * Encrypt the provided string.
  182.      *
  183.      * @param string $term
  184.      *   The string to be encrypted.
  185.      *
  186.      * @return string
  187.      *   The encrypted string.
  188.      */
  189.     protected function encrypt(string $term): string
  190.     {
  191.         // Use the app secret as the key.
  192.         $key = $this->params->get('app.secret');
  194.         // Generate the initialization vector.
  195.         $iv = openssl_random_pseudo_bytes(openssl_cipher_iv_length('aes-256-cbc'));
  197.         // Encrypt the provided string.
  198.         $encryptedString = openssl_encrypt($term, 'aes-256-cbc', $key, 0, $iv);
  200.         // Attach the initialization vector to the encrypted_string
  201.         // and base64 endcode the lot.
  202.         // phpcs:ignore
  203.         return base64_encode($encryptedString . '||' . $iv);
  204.     }
  206.     /**
  207.      * Decrypt the provided string using the provided key.
  208.      *
  209.      * @param string|null $encryptedString
  210.      *   The string to decrypt.
  211.      *
  212.      * @return string
  213.      *   The original plaintext string.
  214.      */
  215.     protected function decrypt(string $encryptedString = null): string
  216.     {
  217.         if (0 === strlen($encryptedString)) {
  218.             // need to have something to return
  219.             return '';
  220.         }
  222.         // Use the app secret as the key.
  223.         $key = $this->params->get('app.secret');
  225.         // Decode and split apart the encrypted string to get what we want to
  226.         // decrypt and the initialization vector.
  227.         list($encryptedText, $iv) = explode('||', \base64_decode($encryptedString), 2);
  229.         // Perform the final decryption and return th plaintext string.
  230.         return openssl_decrypt($encryptedText, 'aes-256-cbc', $key, 0, $iv);
  231.     }
  233.     /**
  234.      * Returns an array of the values for the given key from each of the objects submitted.
  235.      *
  236.      * @param array $objectArray The array of objects to search.
  237.      * @param array $keys        The array of keys to use in the search.
  238.      *
  239.      * @return array Array of dictionaries to return.
  240.      */
  241.     protected function getItemsFromObject(array $objectArray, array $keys): array
  242.     {
  243.         $out = [];
  245.         //$this->logger->info('the original object');
  246.         //$this->logger->info(print_r($objectArray, true));
  248.         foreach ($objectArray as $obj) {
  249.             $keysArePresent = true;
  250.             foreach ($keys as $key) {
  251.                 if (!array_key_exists($key, $obj)) {
  252.                     $keysArePresent = false;
  253.                 }
  254.             }
  256.             if ($keysArePresent) {
  257.                 $thisItem = [];
  258.                 foreach ($keys as $key) {
  259.                     $thisItem[$key] = $obj[$key];
  260.                 }
  261.                 $out[] = $thisItem;
  262.             }
  263.         }
  264.         //$this->logger->info('the resulting object.');
  265.         //$this->logger->info(print_r($out, true));
  267.         return $out;
  268.     }
  270.     /**
  271.      * Returns the first and last days of the current month
  272.      *
  273.      * @param DateTime|null $date Optional date in the month.
  274.      *
  275.      * @return array Array of dates [firstOfMonth, lastOfMonth].
  276.      */
  277.     protected function getMonthStartAndEnd(\DateTime $date = null): array
  278.     {
  279.         if (!$date) {
  280.             $date = new \DateTime();
  281.         }
  283.         return [
  284.             // phpcs:ignore -- Concatenation operator spacing.
  285.             $date->format('Y-m') . '-01',
  286.             $date->format('Y-m-t'),
  287.         ];
  288.     }
  290.     /**
  291.      * Takes two dates and returns them oldest first.
  292.      *
  293.      * @param string $date1 First date.
  294.      * @param string $date2 Second date.
  295.      *
  296.      * @return array Sorted dates.
  297.      */
  298.     protected function putDatesInCorrectOrder(string $date1, string $date2): array
  299.     {
  300.         try {
  301.             // Cast the date strings to DateTime.
  302.             $d1 = new \DateTime($date1);
  303.             $d2 = new \DateTime($date2);
  305.             if ($d1 > $d2) {
  306.                 return [$date2, $date1];
  307.             }
  308.         } catch (\Exception $e) {
  309.             $this->logger->warning(sprintf('Error putting dates in correct order: %s', $e->getMessage()));
  310.         }
  312.         return [$date1, $date2];
  313.     }
  315.     /**
  316.      * Make sure a given date is not in the past.
  317.      * Test a date to make sure it is at least today. If not return today.
  318.      *
  319.      * @param DateTime $date The date to test.
  320.      *
  321.      * @return DateTime
  322.      */
  323.     protected function dateFloor(\DateTime $date): \DateTime
  324.     {
  325.         $today = new \DateTime();
  327.         // Set the time of the date to the same thing for both.
  328.         $today->setTime(0, 0, 0, 0);
  329.         $date->setTime(0, 0, 0, 0);
  331.         if ($today <= $date) {
  332.             return $date;
  333.         }
  335.         return $today;
  336.     }
  339.     /**
  340.      * Get 18 months ago. Used to limit how far back to get transactions.
  341.      *
  342.      * @param bool $dateAsString Return the date as a string. Default false.
  343.      *
  344.      * @return DateTime The first day of the month 18 months prior.
  345.      */
  346.     protected function getTwentyFourMonthsAgo(bool $dateAsString = false): \DateTime
  347.     {
  348.         // Now
  349.         $d = new \DateTime();
  351.         // Set date to first of the month.
  352.         $d->setDate($d->format('Y'), $d->format('m'), 1);
  354.         // Subtract 18 months
  355.         $d->sub(new \DateInterval('P24M'));
  357.         return $dateAsString ? $d->format('Y-m-d') : $d;
  358.     }
  360.     /**
  361.      * Return the subaccount nickname and account as a string.
  362.      *
  363.      * @param string $account     The main account string.
  364.      * @param string $subaccount  The subaccount to get the nickname for.
  365.      * @param string $clientToken The logged in users's token.
  366.      * @param string $clientIp    The client IP address.
  367.      *                            Default 0.0.0.0
  368.      *
  369.      * @return string The formatted nickname string.
  370.      */
  371.     protected function getAccountNameString(string $account, string $subaccount, string $clientToken, string $clientIp = '0.0.0.0.'): string
  372.     {
  373.         try {
  374.             // Update the session timer
  375.             $this->setSessionTimer();
  377.             $subaccounts = $this->api->abfGetSubaccounts(
  378.                 $account,
  379.                 $clientToken,
  380.                 $clientIp
  381.             );
  383.             foreach ($subaccounts as $sub) {
  384.                 if ($subaccount === $sub['account'] && strlen($sub['nickname'])) {
  385.                     return sprintf('%s (%s)', $sub['nickname'], $sub['account']);
  386.                 }
  387.             }
  388.         } catch (ABFTimeoutException $e) {
  389.             $this->logger->warning(sprintf('getAccountNameString: %s', $e->getMessage()));
  390.         } catch (ABFErrorException $e) {
  391.             $this->logger->warning(sprintf('getAccountNameString: %s', $e->getMessage()));
  392.         } catch (\Exception $e) {
  393.             $this->logger->warning(sprintf('getAccountNameString: %s', $e->getMessage()));
  394.         }
  396.         return $subaccount;
  397.     }
  399.     /**
  400.      * Return an array of subaccounts and their balances in cents and dollars.
  401.      *
  402.      * @param string $account     The main account string.
  403.      * @param array  $subaccounts An array of sub account names to return balances for.
  404.      * @param string $clientToken The logged in user's token.
  405.      * @param string $clientIp    The client's IP address.
  406.      *                            Default = 0.0.0.0
  407.      *
  408.      * @return array An array with the subaccount names as keys with values array of the balance in dollars and cents.
  409.      */
  410.     protected function getSubaccountBalances(string $account, array $subaccounts, string $clientToken, string $clientIp = '0.0.0.0'): array
  411.     {
  412.         $out = [];
  413.         // Preload return array with a reasonable amount.
  414.         foreach ($subaccounts as $sa) {
  415.             $out[$sa] = [
  416.                 'dollars' => 10000.00,
  417.                 'cents' => 1000000,
  418.             ];
  419.         }
  421.         try {
  422.             // Update the session timer
  423.             $this->setSessionTimer();
  425.             $result = $this->api->abfGetSubaccounts(
  426.                 $account,
  427.                 $clientToken,
  428.                 $clientIp
  429.             );
  431.             foreach ($result as $sa) {
  432.                 $thisSubAccount = $sa['account'];
  433.                 if (array_key_exists($thisSubAccount, $out)) {
  434.                     $out[$thisSubAccount]['cents'] = $sa['balance'];
  435.                     $out[$thisSubAccount]['dollars'] = $sa['balance'] / 100;
  436.                 }
  437.             }
  438.         } catch (ABFTimeoutException $e) {
  439.             $this->logger->warning(sprintf('getSubaccountBalances Timeout Exception: %s', $e->getMessage()));
  440.         } catch (ABFErrorException $e) {
  441.             $this->logger->warning(sprintf('getSubaccountBalances Timeout Exception: %s', $this->handleABFError($e)));
  442.         } catch (\Exception $e) {
  443.             $this->logger->warning(sprintf('getSubaccountBalances Timeout Exception: %s', $e->getMessage()));
  444.         }
  446.         return $out;
  447.     }
  449.     /**
  450.      * Ping system to send the verification code.
  451.      *
  452.      * @param string      $email      The email address of the account manager.
  453.      * @param string      $adminToken The API admin token.
  454.      * @param string      $clientIp   The client's IP address.
  455.      *                                Default = 0.0.0.0
  456.      * @param string|null $phone      The phone number of the account manager. Default to null.
  457.      * @param bool        $resend     If this is a resend of the code. Default false.
  458.      *
  459.      * @return array the type and code of the flash message to present.
  460.      */
  461.     protected function sendVerificationCode(string $email, string $adminToken, string $clientIp = '0.0.0.0', string $phone = null, bool $resend = false): array
  462.     {
  463.         $type = '';
  464.         $message = '';
  466.         try {
  467.             // Update the session timer
  468.             $this->setSessionTimer();
  470.             if ($phone) {
  471.                 // Send code.
  472.                 $sentLink = $this->api->sendSmsVerification(
  473.                     $phone,
  474.                     $email,
  475.                     $adminToken,
  476.                     $clientIp
  477.                 );
  479.                 if (!$sentLink) {
  480.                     throw new \Exception('Something went wrong sending the verification code to your device. Please try again later.');
  481.                 }
  483.                 // Add success message.
  484.                 $message = $resend
  485.                     ? "The validation code has been re-sent to your device. Please enter this code in the form below. It is valid for one hour."
  486.                     : "A validation code has been sent to your device. Please enter this code in the form below. It is valid for one hour.";
  488.                 $type = 'success';
  489.             } else {
  490.                 // Send code.
  491.                 $sentLink = $this->api->sendEmailVerification(
  492.                     $email,
  493.                     $adminToken,
  494.                     $clientIp
  495.                 );
  497.                 if (!$sentLink) {
  498.                     throw new \Exception('Something went wrong sending the verification code to your email. Please try again later.');
  499.                 }
  501.                 // Add success message.
  502.                 $message = $resend
  503.                     ? "The validation code has been re-sent to your registered email address. Please enter this code in the form below. It is valid for one hour."
  504.                     : "A validation code has been sent to your registered email address. Please enter this code in the form below. It is valid for one hour.";
  506.                 $type = 'success';
  507.             }
  508.         } catch (ABFTimeoutException $e) {
  509.             $type = 'danger';
  510.             $message = $e->getMessage();
  511.         } catch (ABFErrorException $e) {
  512.             $type = 'danger';
  513.             $message = $this->handleABFError($e);
  514.         } catch (\Exception $e) {
  515.             $type = 'danger';
  516.             $message = $e->getMessage();
  517.         }
  519.         return [$type, $message];
  520.     }
  522.     /**
  523.      * Returns html describing the password requirements
  524.      *
  525.      * @return string
  526.      */
  527.     protected function getPasswordRequirementText(): string
  528.     {
  529.         $constraints = $this->getPasswordConstraints();
  530.         $specialCharacterList = implode(', ', $this->getCharacters('special'));
  532.         $html = '
  533.         <div class="password-text">
  534.             <p>Valid passwords meet the following criteria:</p>
  535.             <ul>
  536.         ';
  538.         $html .= sprintf('<li>Are at least %d characters long.</li>', $constraints->minLength);
  540.         $html .= $constraints->requireLowercase ? '<li>Contain at least one lowercase letter.</li>' : '';
  541.         $html .= $constraints->requireUppercase ? '<li>Contain at least one uppercase (capital) letter.</li>' : '';
  542.         $html .= $constraints->requireNumber ? '<li>Contain at least one number (0 - 9).</li>' : '';
  543.         $html .= $constraints->requireSpecialChar ? sprintf('<li>Contain at least one special character (%s).</li>', $specialCharacterList) : '';
  546.         $html .= '
  547.             </ul>
  548.         </div>';
  550.         return $html;
  551.     }
  553.     /**
  554.      * Tests to see if a given password meets the system password standards.
  555.      *
  556.      * @param string $password The password string to validate.
  557.      *
  558.      * @return array Array containing [bool, string]: Valid state, Error string.
  559.      */
  560.     protected function passwordIsValid(string $password): array
  561.     {
  562.         $constraints = $this->getPasswordConstraints();
  564.         try {
  565.             // Verify length of password.
  566.             if ($constraints->minLength > strlen($password)) {
  567.                 throw new \Exception(sprintf('The password must be at least %d characters long.', $constraints->minLength));
  568.             }
  570.             // Verify Lowercase char is present
  571.             if ($constraints->requireLowercase) {
  572.                 if (!$this->stringContains($password, $this->getCharacters('lowercase'))) {
  573.                     throw new \Exception('The password must contain at least one lowercase letter.');
  574.                 }
  575.             }
  577.             // Verify Uppercase char is present
  578.             if ($constraints->requireUppercase) {
  579.                 if (!$this->stringContains($password, $this->getCharacters('uppercase'))) {
  580.                     throw new \Exception('The password must contain at least one uppercase letter.');
  581.                 }
  582.             }
  583.             // Verify number is present
  584.             if ($constraints->requireNumber) {
  585.                 if (!$this->stringContains($password, $this->getCharacters('numbers'))) {
  586.                     throw new \Exception('The password must contain at least one number');
  587.                 }
  588.             }
  589.             // Verify Lowercase char is present
  590.             if ($constraints->requireSpecialChar) {
  591.                 if (!$this->stringContains($password, $this->getCharacters('special'))) {
  592.                     throw new \Exception('The password must contain at least one special character.');
  593.                 }
  594.             }
  596.             return [true, ''];
  597.         } catch (\Exception $e) {
  598.             return [false, $e->getMessage()];
  599.         }
  600.     }
  602.     /**
  603.      * Return an object with all the password constraints
  604.      *
  605.      * @return stdClass
  606.      */
  607.     protected function getPasswordConstraints(): stdClass
  608.     {
  609.         $obj = new stdClass();
  611.         $obj->minLength = (int) $this->params->get('password.min_length');
  612.         $obj->requireLowercase = (bool) $this->params->get('password.require_lowercase');
  613.         $obj->requireUppercase = (bool) $this->params->get('password.require_uppercase');
  614.         $obj->requireNumber = (bool) $this->params->get('password.require_number');
  615.         $obj->requireSpecialChar = (bool) $this->params->get('password.require_special_character');
  617.         return $obj;
  618.     }
  620.     /**
  621.      * Testing function to see if at least one character in the string is contained in the provided array.
  622.      *
  623.      * @param string $string         The string to test.
  624.      * @param array  $characterArray The array of characters to test against.
  625.      *
  626.      * @return bool If the string contains at least one item from the array.
  627.      */
  628.     private function stringContains(string $string, array $characterArray): bool
  629.     {
  630.         for ($i = 0; $i < strlen($string); $i++) {
  631.             if (in_array(substr($string, $i, 1), $characterArray)) {
  632.                 return true;
  633.             }
  634.         }
  636.         return false;
  637.     }
  639.     /**
  640.      * Returns array of characters used in password tests.
  641.      *
  642.      * @param string $set The array set to return.
  643.      *
  644.      * @return array
  645.      */
  646.     private function getCharacters(string $set): array
  647.     {
  648.         $out = [];
  649.         switch ($set) {
  650.             case 'uppercase':
  651.                 $out = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
  652.                 break;
  653.             case 'numbers':
  654.                 $out = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
  655.                 break;
  656.             case 'special':
  657.                 $out = ['!', '@', '#', '$', '%', '^', '&', '*', '(', ')', '.', ',', '-', '_', '+', '=', ':', ';'];
  658.                 break;
  659.             default:
  660.                 $out = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];
  661.         }
  663.         return $out;
  664.     }
  665. }