src/Library/Utils/Other/Other.php line 394

Open in your IDE?
  1. <?php
  3. namespace App\Library\Utils\Other;
  5. use App\Library\Utils\Dev\ReflectionUtils\ReflectionUtils;
  6. use App\Library\Utils\StringUtils;
  7. use Doctrine\ORM\EntityManagerInterface;
  8. use Symfony\Component\Console\Input\InputInterface;
  9. use Symfony\Component\Console\Output\OutputInterface;
  10. use Symfony\Component\Console\Question\Question;
  11. use Symfony\Component\HttpFoundation\Request;
  13. class Other
  14. {
  15.     public function __construct(EntityManagerInterface $em)
  16.     {
  17.         $this->em = $em;
  18.     }
  20.     /**
  21.      * @param InputInterface $input
  22.      * @param OutputInterface $output
  23.      * @param string $defaultAnswerMsg
  24.      * @return array|mixed|string|string[]|null
  25.      */
  26.     public static function askUser(InputInterface $input, OutputInterface $output, $helper, $questionTxt, &$replaceAll = null,
  27.                                                   $defaultAnswerMsg = null, $noMsg = null, $stopMsg = null,
  28.                                    array $answers = null, $defaultAnswer = "yes", $useYesNoAllAnswers = true, $allowAnyInput = false,
  29.                                                   $stopInputOnEmptyAnswer = false, array $generateMenu = null)
  30.     {
  31.         $answer = null;
  32.         $yesNoAllAnswers = ['y', 'n', 'a', 's', 'yes', 'no', 'all'];
  33.         if ($answers === null) $answers = [];
  34.         $answers = array_merge(
  35.             ($useYesNoAllAnswers ? $yesNoAllAnswers : []),
  36.             ($answers ? $answers : []),
  37.             ($stopInputOnEmptyAnswer ? ["stop"] : [])
  38.         );
  39.         if ($stopInputOnEmptyAnswer) $defaultAnswer = "stop";
  40.         if (!in_array($defaultAnswer, $answers)) {
  41.             $defaultAnswer = null;
  42.         }
  44.         $answerShortcuts = ['s', 'y', 'n', 'a'];
  45.         $answerShortcutReplacements = ['stop', 'yes', 'no', 'all'];
  47.         if ($generateMenu) {
  48.             $menuItemNumber = 0;
  49.             foreach ($generateMenu as $menuItemData) {
  50.                 $menuCaption = ($menuItemData[1] ? $menuItemData[1] : $menuItemData[2]);
  51.                 $answerReplacement = $menuItemData[2];
  52.                 if (!$answerReplacement) continue;
  53.                 $menuItemNumber++;
  54.                 $answerStr = ($menuItemData[0] ? $menuItemData[0] : strval($menuItemNumber));
  55.                 $questionTxt .= "\n" . $answerStr . ". " . $menuCaption . " ";
  56.                 $answers = array_merge($answers, [$answerStr, $answerReplacement]);
  57.                 if (strlen($answerStr) == 1) {
  58.                     $answerShortcuts = array_merge($answerShortcuts, [$answerStr]);
  59.                     $answerShortcutReplacements = array_merge($answerShortcutReplacements, [$answerReplacement]);
  60.                 }
  61.             }
  62.         }
  64.         if ($defaultAnswer) $questionTxt .= "\nPress Enter - " . ($defaultAnswerMsg ? $defaultAnswerMsg : $defaultAnswer) . ' ';
  66.         while (!$replaceAll && (!$answer || (!$allowAnyInput && !in_array($answer, $answers)))) {
  67.             $question = new Question($questionTxt, '[DEFAULT]');
  68.             $answer = $helper->ask($input, $output, $question);
  69.             if ($answer == '[DEFAULT]') $answer = $defaultAnswer;
  70.             if (strlen($answer) == '1') {
  71.                 $answer = str_replace($answerShortcuts, $answerShortcutReplacements, $answer);
  72.             }
  73.         }
  75.         if ($answer == 'no') {
  76.             if ($noMsg) echo $noMsg;
  77.         } else if ($answer == 'yes' || $answer == 'all') {
  78.             if ($answer == 'all') $replaceAll = true;
  79.         } else if ($answer == 'stop') {
  80.             if ($stopMsg) echo $stopMsg;
  81.             return null;
  82.         }
  84.         return $answer;
  85.     }
  87.     public static function findParentPathWithDir($path, $childDirNames)
  88.     {
  89.         if (!is_array($childDirNames)) {
  90.             $childDirNames = [$childDirNames];
  91.         }
  92.         while (true) {
  93.             $path = realpath($path . "/..");
  94.             $continueSearch = false;
  95.             foreach ($childDirNames as $childDirName) {
  96.                 if (($continueSearch = !is_dir($path . "/" . $childDirName))) break;
  97.             }
  98.             if (!$continueSearch) break;
  99.         }
  101.         return $path;
  102.     }
  104.     static public function getPathStructure($path)
  105.     {
  106.         $result = [
  107.             'segments' => explode("/", $path),
  108.         ];
  109.         $result['fileNameWithExtension'] = $result['segments'][array_key_last($result['segments'])];
  110.         $fileNameWithExtensionArr = explode(".", $result['fileNameWithExtension']);
  111.         $result['extension'] = $fileNameWithExtensionArr[array_key_last($fileNameWithExtensionArr)];
  112.         unset($fileNameWithExtensionArr[array_key_last($fileNameWithExtensionArr)]);
  113.         $result['fileNameWithoutExtension'] = implode(".", $fileNameWithExtensionArr);
  114.         $result['lastSegment'] = $result['segments'][array_key_last($result['segments'])];
  115.         $pathWithoutLastSegment = $result['segments'];
  116.         unset($pathWithoutLastSegment[array_key_last($pathWithoutLastSegment)]);
  117.         $pathWithoutLastSegment = implode("/", $pathWithoutLastSegment);
  118.         $result['pathWithoutLastSegment'] = $pathWithoutLastSegment;
  120.         return $result;
  121.     }
  123.     public static function getAllSubdirs($path, $asString = false, bool $addFilesString, $_dirLevel = "", $recursively = true)
  124.     {
  125.         $dirStructure = [];
  126.         $strDirStructure = "";
  128.         foreach (scandir($path) as $objName) {
  129.             if ($objName != "." && $objName != ".." & is_dir($path . DIRECTORY_SEPARATOR . $objName)) {
  130.                 if ($asString) {
  131.                     $filesString = "";
  132.                     if ($addFilesString) {
  133.                         $addFilesCount = 3;
  134.                         foreach (glob("$path/$objName/*") as $filePath) {
  135.                             if (is_dir($filePath)) {
  136.                                 continue;
  137.                             }
  138.                             if ($addFilesCount == 0) {
  139.                                 $filesString .= ($filesString ? ", " : "") . "...";
  140.                                 break;
  141.                             }
  142.                             $filesString .= ($filesString ? ", " : "") . self::getPathStructure($filePath)['lastSegment'];
  143.                             $addFilesCount--;
  144.                         }
  145.                         if (strlen($filesString) > 150) {
  146.                             $filesString = substr($filesString, 0, 150) . "...";
  147.                         }
  148.                         if ($filesString) {
  149.                             $filesString = "     ($filesString)";
  150.                         }
  151.                     }
  152.                     $strDirStructure .= $_dirLevel . '- ' . $objName . $filesString . "\r\n" .
  153.                         self::getAllSubdirs($path . DIRECTORY_SEPARATOR . $objName, true, $addFilesString, $_dirLevel . "     ", true);
  154.                 } else {
  155.                     $dirStructure[$objName] = ($recursively ? self::getAllSubdirs($path . DIRECTORY_SEPARATOR . $objName, false, $addFilesString, "", true) :
  156.                         $path . DIRECTORY_SEPARATOR . $objName);
  157.                 }
  158.             }
  159.         }
  160.         if ($asString) {
  161.             return $strDirStructure;
  162.         } else {
  163.             return $dirStructure;
  164.         }
  165.     }
  167.     public static function createGuid(int $length = 16)
  168.     {
  169.         $guid = bin2hex(openssl_random_pseudo_bytes($length));
  170.         return $guid;
  171.     }
  173.     public static function createToken(): string
  174.     {
  175.         return self::createGuid(32);
  176.     }
  178.     /**
  179.      * @param array|string $addDataBefore
  180.      * @param array|string|mixed $data
  181.      * @param $fileNameWithoutExtension
  182.      */
  183.     public static function appendLog($data, $fileNameWithoutExtension = 'tests', $addDataBefore = null, $toOneLine = true)
  184.     {
  185.         try {
  186.             $path = null;
  187.             if (is_file($fileNameWithoutExtension)) {
  188.                 $path = $fileNameWithoutExtension;
  189.             } else {
  190.                 $path = self::findParentPathWithDir(__DIR__, ['src', 'var']) . '/var/log/' . $fileNameWithoutExtension . ".log";
  191.             }
  192.             if (is_array($data)) {
  193. //            $data = json_encode($data);
  194.                 $data = ($toOneLine ? StringUtils::arrayToOneLineString($data) : var_export($data, true));
  195.             }
  197.             if ($addDataBefore) {
  198.                 if (is_array($addDataBefore)) {
  199.                     $addDataBeforeArr = $addDataBefore;
  200.                     $addDataBefore = "";
  201.                     foreach ($addDataBeforeArr as $dataLable => $dataTmp) {
  202.                         if (is_object($dataTmp) && (ReflectionUtils::hasParentClass($dataTmp, [\Exception::class, \Error::class]))) {
  203.                             if (is_numeric($dataLable)) {
  204.                                 $dataLable = get_class($dataTmp);
  205.                             }
  206.                             $dataTmp = $dataTmp->getMessage() . ". (File: " . $dataTmp->getFile() . ":" . $dataTmp->getLine() .
  207.                                 ". Trace: " . var_export(self::getBacktrace($dataTmp->getTrace()), true) . ")";
  208.                         }
  210.                         if (!is_numeric($dataLable)) {
  211.                             $dataLable = ucfirst($dataLable);
  212.                         }
  213.                         $addNext = "";
  214.                         if (is_numeric($dataLable) && is_string($dataTmp)) {
  215.                             $addNext = ucfirst($dataTmp);
  216.                         } else {
  217.                             if (is_bool($dataTmp) || is_null($dataTmp)) {
  218.                                 $dataTmp = json_encode($dataTmp);
  219.                             }
  220.                             $addNext = "{$dataLable}: " . $dataTmp;
  221.                         }
  222.                         $addDataBefore .= ($addDataBefore ? ". " : "") . $addNext;
  223.                     }
  224.                 }
  225.                 $data = $addDataBefore . $data . "\r\n";
  226.             }
  228.             self::writeTxtToFile($data, $path, null, false, null, null,
  229.                 false, true, true);
  230.         } catch (\Exception $exception) {
  231.             try {
  232.                 self::writeTxtToFile("Cant append log. Exception: {$exception->getMessage()}. {$exception->getFile()}:{$exception->getLine()}" , $path,
  233.                     null, false, null, null,
  234.                     false, true, true);
  235.             } catch (\Exception $exception) {
  236.             }
  237.         }
  238.     }
  240.     public static function canAddDebugLog(): bool
  241.     {
  242.         return isset($_ENV["DEBUG_LOG"]) && $_ENV["DEBUG_LOG"] == 1;
  243.     }
  245.     public static function appendTestLog($data, $addDataBefore = null, $toOneLine = true)
  246.     {
  247.         self::appendLog($data, 'tests', $addDataBefore, $toOneLine);
  248.     }
  250.     public static function appendQueryLog($data, $addDataBefore = null, $toOneLine = true)
  251.     {
  252.         self::appendLog($data, 'queryLog', $addDataBefore, $toOneLine);
  253.     }
  255.     public static function appendTgBotLog($data, $addDataBefore = null, $toOneLine = true)
  256.     {
  257.         self::appendLog($data, 'tgBotLog', $addDataBefore, $toOneLine);
  258.     }
  260.     public static function appendPyTgStderrLog($data, $addDataBefore = null, $toOneLine = true)
  261.     {
  262.         self::appendLog($data, 'pyTgStderrLog', $addDataBefore, $toOneLine);
  263.     }
  265.     public static function appendSuccessRoomAccessLog($data, $addDataBefore = null, $toOneLine = true)
  266.     {
  267.         self::appendLog($data, 'successRoomAccess', $addDataBefore, $toOneLine);
  268.     }
  270.     public static function appendUserStartedStreamLog($data, $addDataBefore = null, $toOneLine = true)
  271.     {
  272.         self::appendLog($data, 'userStartedStream', $addDataBefore, $toOneLine);
  273.     }
  275.     public static function appendAuthLog($data, $addDataBefore = null, $toOneLine = true)
  276.     {
  277.         self::appendLog($data, 'authLog', $addDataBefore, $toOneLine);
  278.     }
  280.     /**
  281.      * {@inheritdoc}
  282.      * @return null
  283.      */
  284.     static function writeTxtToFile($data, $fileName = 'logs.txt', string $findRootDirName = null, bool $jsonEncode = false,
  285.                                    $caption = null, $do_var_export = false, $is_all_defined_vars = false, $addDate = false,
  286.                                    bool $append = false)
  287.     {
  288.         if ($findRootDirName) {
  289.             $logDirPath = "./";
  290.             $logDirRealPath = null;
  291.             $dirLevel = 0;
  292.             while (!str_ends_with(($logDirRealPath = realpath($logDirPath)), "/" . $findRootDirName)) {
  293.                 $logDirPath .= "../";
  294.                 $dirLevel++;
  295.                 if ($dirLevel == 500) {
  296.                     throw new \Exception('Cant\'t find root dir.');
  297.                 }
  298.             }
  299.             $fileName = $logDirRealPath . "/" . $fileName;
  300.         }
  302.         try {
  303.             if ($is_all_defined_vars) {
  304.                 if ($caption == null) {
  305.                     $caption = "all_defined_vars";
  306.                 }
  307.                 $allVars = [];
  308.                 foreach ($data as $varName => $varData) {
  309.                     $isClassObj = !is_bool($varData) && !is_int($varData) && !is_float($varData) && !is_string($varData) && !is_array($varData);
  310.                     if ($isClassObj) {
  311.                         $allVars[$varName] = get_class($varData);
  312.                     } else {
  313.                         $allVars[$varName] = $varData;
  314.                     }
  315.                     if (is_array($varData)) {
  316.                         $allVars[$varName] = array_keys($varData);
  317.                     }
  318.                 }
  319.                 $data = $allVars;
  320.             }
  321.         } catch (\Exception $ex) {
  322.             $data = "error: " . $ex->getMessage();
  323.         }
  325.         if ($do_var_export) {
  326.             $data = var_export($data, true);
  327.         }
  328.         if ($caption) {
  329. //            $data = $caption . "-->\n" . $data . "\n<--" . $caption;
  330.             $data = $caption . ": " . $data;
  331.         }
  332.         if ($addDate) {
  333.             $data = (new \DateTime())->format('d.m.Y H:i:s') . ": " . $data;
  334.         }
  335.         $flags = 0;
  336.         if ($append) {
  337.             $flags = FILE_APPEND | LOCK_EX;
  338.         }
  339.         if ($jsonEncode) {
  340.             $data = json_encode($data, JSON_PRETTY_PRINT);
  341.         }
  342.         $myfile = file_put_contents($fileName, $data . PHP_EOL, $flags);
  343.     }
  345.     public static function getHostUrl($slashAtEnd = true): string
  346.     {
  347.         $url = $_SERVER["REQUEST_SCHEME"] . "://" . $_SERVER['SERVER_NAME'] .
  348.             (isset($_SERVER['SERVER_PORT']) && $_SERVER['SERVER_PORT'] ? ":" . $_SERVER['SERVER_PORT'] : "") .
  349.             ($slashAtEnd ? "/" : "");
  350.         return $url;
  351.     }
  353.     public static function filterArray($array, $callback = null, $childElementMethodName = null, $childElementMethodResult = null): array
  354.     {
  355.         $array = array_filter($array, function ($curElement) use ($callback, $childElementMethodName, $childElementMethodResult) {
  356.             $result = (!$callback || ($callback($curElement)) &&
  357.                 (!$childElementMethodName || call_user_func([$curElement, $childElementMethodName]) == $childElementMethodResult));
  358.             return $result;
  359.         });
  360.         return $array;
  361.     }
  363.     public static function getBacktrace(array $backtrace = null): ?array
  364.     {
  365.         if (!$backtrace) {
  366.             $backtrace = debug_backtrace();
  367.         }
  368.         foreach ($backtrace as &$trace) {
  369.             if (isset($trace['file']) && isset($trace["line"]) && isset($trace["function"])) {
  370.                 $trace = "{$trace['file']}:{$trace["line"]} (->{$trace["function"]})";
  371.             } else {
  372.                 $trace = "...";
  373.             }
  374.         }
  375.         return $backtrace;
  376.     }
  378.     public static function removeKey(array $array, string $key): array
  379.     {
  380.         unset($array[$key]);
  381.         return $array;
  382.     }
  384.     public static function getRemoteIp(): ?string
  385.     {
  386.         return $_SERVER['REMOTE_ADDR'] ?? null;
  387.     }
  389.     /**
  390.      * @param null|array|mixed $object
  391.      * @param array|mixed $data
  392.      * @param \Closure|null $createObjectCallback
  393.      */
  394.     public function setObjectDataFromArray($object = null, $data, $includedDataKeys = null,
  395.                                            \Closure $createObjectCallback = null,
  396.         $beforeObjectPersistCallback = null)
  397.     {
  398.         if ($object && !is_array($object)) {
  399.             $object = [$object];
  400.         }
  401.         if (!is_array($data)) {
  402.             $data = [$data];
  403.         }
  405.         $objectIndex = -1;
  406.         foreach ($data as $currentData) {
  407.             $objectIndex++;
  408.             $currentObject = null;
  409.             if (!$object) {
  410.                 $currentObject = $createObjectCallback();
  411.             } else {
  412.                 $currentObject = $object[$objectIndex];
  413.             }
  414.             foreach ($currentData as $setMethod => $dataElement) {
  415.                 if ($includedDataKeys && !in_array($setMethod, $includedDataKeys)) {
  416.                     continue;
  417.                 }
  418.                 $setMethod = 'set' . ucfirst($setMethod);
  420.                 if (method_exists($currentObject, $setMethod)) {
  421.                     $currentObject->{$setMethod}($dataElement);
  422.                 }
  423.             }
  424.             if (!$object) {
  425.                 if (!$beforeObjectPersistCallback || $beforeObjectPersistCallback($currentObject, $currentData)) {
  426.                     $this->em->persist($currentObject);
  427.                     $this->em->flush();
  428.                 }
  429.             }
  430.         }
  431.     }
  433.     /**
  434.      * @param mixed|array $object
  435.      */
  436.     public static function objectToArray($object, $includedDataKeys, $onDataCreateCallback = null,
  437.                                          array $overrideKeyNames = null): array
  438.     {
  439.         $objects = $object;
  440.         if (!is_array($objects)) {
  441.             $objects = [$object];
  442.         }
  444.         $objectsData = [];
  445.         $objectsDataIndex = -1;
  446.         foreach ($objects as $currentObject) {
  447.             $objectsDataIndex++;
  448.             $currentObjectData = [];
  449.             foreach ($includedDataKeys as $dataKey) {
  450.                 $getMethod = 'get' . ucfirst($dataKey);
  451.                 if ($overrideKeyNames) {
  452.                     if (in_array($dataKey, array_keys($overrideKeyNames))) {
  453.                         $dataKey = $overrideKeyNames[$dataKey];
  454.                     }
  455.                 }
  456.                 $currentObjectData[$dataKey] = $currentObject->{$getMethod}();
  457.             }
  458.             if ($onDataCreateCallback) {
  459.                 $currentObjectData = $onDataCreateCallback($currentObject, $currentObjectData);
  460.             }
  461.             if ($currentObjectData) {
  462.                 $objectsData[$objectsDataIndex] = $currentObjectData;
  463.             }
  464.         }
  466.         if (is_array($object)) {
  467.             return $objectsData;
  468.         } else {
  469.             return $objectsData[0];
  470.         }
  471.     }
  473.     /**
  474.      * @param mixed|array $object
  475.      */
  476.     public static function objectToId($object)
  477.     {
  478.         $objects = $object;
  479.         $isArray = is_array($objects);
  480.         if (!$isArray) {
  481.             $objects = [$object];
  482.         }
  484.         $result = [];
  485.         foreach ($objects as $object) {
  486.             $result[] = $object->getId();
  487.         }
  489.         if ($isArray) {
  490.             return $result;
  491.         } else {
  492.             return $result[0];
  493.         }
  494.     }
  496.     public static function objectToStringId($object): string
  497.     {
  498.         return implode(",", self::objectToId($object));
  499.     }
  501.     public static function sumObjectField($object, $field)
  502.     {
  503.         $objects = $object;
  504.         $isArray = is_array($objects);
  505.         if (!$isArray) {
  506.             $objects = [$object];
  507.         }
  509.         $result = 0;
  510.         $field = "get" . ucfirst($field);
  511.         foreach ($objects as $object) {
  512.             $result += $object->$field();
  513.         }
  515.         return $result;
  516.     }
  518.     /**
  519.      *
  520.      * $callback = function($curElement, $elementIndex, $key) {};
  521.      *
  522.      * @param $array
  523.      * @param null $callback
  524.      * @param null $childElementName
  525.      * @param null $childElementValue
  526.      * @param null $element
  527.      * @param null $skipElement
  528.      * @param null $childArraysElementValueRegex
  529.      * @param bool $returnDetailedResult
  530.      * @return array|int
  531.      */
  532.     static public function findIndexInArray($array, $callback = null, $childElementName = null, $childElementValue = null, $element = null,
  533.                                             $skipElement = null, $childArraysElementValueRegex = null, bool $returnDetailedResult = false,
  534.                                             $childElementMethodName = null, $childElementMethodResult = null, $childArraysElementValue = null)
  535.     {
  536.         $elementIndex = 0;
  537.         $foundIndex = -1;
  538.         $foundKey = null;
  539.         $detailedResult = [];
  541.         foreach ($array as $key => $curElement) {
  542.             $found = (!$skipElement || $skipElement != $curElement) &&
  543.                 ((!$callback || $callback($curElement, $elementIndex, $key)) &&
  544.                     (!$childElementName || (isset($curElement[$childElementName]) && (!$childElementValue || $curElement[$childElementName] == $childElementValue))) &&
  545.                     (!$element || $element == $curElement) &&
  546.                     (!$childElementMethodName || call_user_func([$curElement, $childElementMethodName]) == $childElementMethodResult));
  547.             if ($found && ($childArraysElementValueRegex || $childArraysElementValue)) {
  548.                 $found = false;
  549.                 $detailedResult['foundChildElementValue'] = null;
  550.                 $tmpArray = ($childElementName ? $curElement[$childElementName] : $curElement);
  551.                 foreach ($tmpArray as $childKey => $curChildElement) {
  552.                     if ((!$childArraysElementValueRegex || preg_match($childArraysElementValueRegex, $curChildElement)) &&
  553.                         (!$childArraysElementValue || $curChildElement == $childArraysElementValue))
  554.                     {
  555.                         $detailedResult['foundChildElementValue'] = $curChildElement;
  556.                         $found = true;
  557.                         break;
  558.                     }
  559.                 }
  560.             }
  561.             if ($found) {
  562.                 $foundIndex = $elementIndex;
  563.                 $foundKey = $key;
  564.                 break;
  565.             }
  566.             $elementIndex++;
  567.         }
  569.         if ($returnDetailedResult) {
  570.             $detailedResult['index'] = $foundIndex;
  571.             $detailedResult['key'] = $foundKey;
  572.             return $detailedResult;
  573.         } else {
  574.             return $foundIndex;
  575.         }
  576.     }
  578.     /**
  579.      * @return array|int
  580.      */
  581.     static public function findIndexInArrayByElement($array, $element = null)
  582.     {
  583.         return self::findIndexInArray($array, null, null, null, $element);
  584.     }
  587.     public static function findInArrayByChildArrayElementValue($array, $childArrayElementValue, $childElementName = null,
  588.                                                                bool $returnDetailedResult = false)
  589.     {
  590.         return self::findInArray($array, null, $childElementName, null, null, null,
  591.             null, null, $returnDetailedResult, null,
  592.             null, $childArrayElementValue);
  593.     }
  595.     static public function findInArray($array, $callback = null, $childElementName = null, $childElementValue = null, $element = null,
  596.                                        $skipElement = null, $getResultElementValueWithName = null,
  597.                                        $childArraysElementValueRegex = null,
  598.                                        bool $returnDetailedResult = false, $childElementMethodName = null, $childElementMethodResult = null,
  599.         $childArraysElementValue = null)
  600.     {
  601.         $result = self::findIndexInArray($array, $callback, $childElementName, $childElementValue, $element, $skipElement, $childArraysElementValueRegex,
  602.             $returnDetailedResult, $childElementMethodName, $childElementMethodResult, $childArraysElementValue);
  603.         $index = ($returnDetailedResult ? $result['index'] : $result);
  604.         $subResult = $index;
  606.         if ($index > -1 || is_string($index)) {
  607.             $foundKey = array_keys($array)[$index];
  608.             if ($getResultElementValueWithName) {
  609.                 $subResult = $array[$foundKey][$getResultElementValueWithName];
  610.             } else {
  611.                 $subResult = $array[$foundKey];
  612.             }
  613.         } else {
  614.             $subResult = null;
  615.         }
  617.         if ($returnDetailedResult) {
  618.             $result['result'] = $subResult;
  619.         } else {
  620.             $result = $subResult;
  621.         }
  623.         return $result;
  624.     }
  626.     public static function findInArrayByElementMethodResult($array, $childElementMethodName, $childElementMethodResult)
  627.     {
  628.         return self::findInArray($array, null, null, null, null, null,
  629.             null, null, false, $childElementMethodName,
  630.             $childElementMethodResult);
  631.     }
  633.     public static function convertArray(array $array, $elementMethodName = null)
  634.     {
  635.         foreach ($array as $key => $value) {
  636.             if ($elementMethodName) {
  637.                 $array[$key] = call_user_func([$value, $elementMethodName]);
  638.             }
  639.         }
  640.         return $array;
  641.     }
  643.     public static function sumArray($array, $elementMethodName = null, array $keys = null): float
  644.     {
  645.         if ($keys) {
  646.             return Other::sumArray(array_intersect_key($array, array_flip($keys)));
  647.         }
  649.         /** @var float $sum */
  650.         $sum = 0.0;
  651.         foreach ($array as $key => $value) {
  652.             if ($elementMethodName) {
  653.                 $sum += (float)call_user_func([$value, $elementMethodName]);
  654.             } else {
  655.                 $sum += (float)$value;
  656.             }
  657.         }
  658.         return $sum;
  659.     }
  661.     public static function getVarPath(?string $subPath = null): string
  662.     {
  663.         $path = self::getRootPath( '/var/' . ($subPath ?: "")) ;
  664.         return $path;
  665.     }
  667.     public static function getRootPath(?string $subPath = null): string
  668.     {
  669.         $path = self::findParentPathWithDir(__DIR__, ['src', 'var']) . ($subPath ?: "");
  670.         return $path;
  671.     }
  673.     public static function getProjectDirName(): string
  674.     {
  675.         $rootPath = explode("/", Other::getRootPath());
  676.         $dirName = end($rootPath);
  677.         return $dirName;
  678.     }
  680.     public static function setSettings(array $settings = null, string $settingName = null, $settingValue = null, $fileName = "settings.json", $isAbsolutePath = false)
  681.     {
  682.         if (!$isAbsolutePath) {
  683.             $fileName = self::getVarPath($fileName);
  684.         }
  685.         if ($settingName) {
  686.             $settings = [$settingName => $settingValue];
  687.         }
  689.         $currentSettings = [];
  690.         if (is_file($fileName)) {
  691.             $currentSettings = json_decode(file_get_contents($fileName), true);
  692.         }
  693.         foreach ($settings as $key => $value) {
  694.             $currentSettings[$key] = $value;
  695.         }
  696.         self::writeTxtToFile($currentSettings, $fileName, null, true);
  697.     }
  699.     /**
  700.      * @param string|null $settingName
  701.      * @param bool $nullIfNotExists
  702.      * @param $fileName
  703.      * @return array|mixed|null
  704.      * @throws \Exception
  705.      */
  706.     public static function getSettings(string $settingName = null, bool $nullIfNotExists = false, $fileName = "settings.json", $isAbsolutePath = false)
  707.     {
  708.         if (!$isAbsolutePath) {
  709.             $fileName = self::getVarPath($fileName);
  710.         }
  712.         $settings = [];
  713.         if (is_file($fileName)) {
  714.             $settings = json_decode(file_get_contents($fileName), true);
  715.         }
  716.         if ($settingName) {
  717.             if (!isset($settings[$settingName])) {
  718.                 if ($nullIfNotExists) {
  719.                     return null;
  720.                 } else {
  721.                     throw new \Exception((is_file($fileName) ? "Setting not exists: $settingName" : "Settings file not exists: $fileName"));
  722.                 }
  723.             }
  724.             return $settings[$settingName];
  725.         } else {
  726.             return $settings;
  727.         }
  728.     }
  730.     public static function findInChildArray($array, $childArrayKey, $childArrayValue): ?array
  731.     {
  732.         foreach ($array as $key => $element) {
  733.             if (isset($element[$childArrayKey]) && $element[$childArrayKey] == $childArrayValue) {
  734.                 return ["key" => $key, "childKey" => $childArrayKey, "value" => $childArrayValue, "childArray" => $element];
  735.             }
  736.         }
  737.         return null;
  738.     }
  740.     public static function getIdIndexedEntityArray(array $entities): array
  741.     {
  742.         $arr = [];
  743.         foreach ($entities as $item) {
  744.             $arr[$item->getId()] = $item;
  745.         }
  746.         return $arr;
  747.     }
  749.     public static function removeFilesByRegex($directory, $regex) {
  750.         $files = glob($directory . '/*');
  752.         $removeFiles = [];
  754.         if ($files !== false) {
  755.             foreach ($files as $file) {
  756.                 if (preg_match($regex, basename($file))) {
  757.                     $removeFiles[] = $file;
  758.                 }
  759.             }
  761.             foreach ($removeFiles as $file) {
  762.                 unlink($file);
  763.             }
  764.         }
  765.     }
  767.     public static function getRequestAttributes(Request $request)
  768.     {
  769.         return array_intersect_key($request->attributes->all(),
  770.             array_flip(array_filter(array_keys($request->attributes->all()),
  771.                 function ($key) {return !str_starts_with($key, "_");})));
  772.     }
  774.     public static function sleepMs($milliseconds) {
  775.         $microseconds = $milliseconds * 1000;
  776.         usleep($microseconds);
  777.     }
  779.     public static function filterArrayNotNull(array $arr): array
  780.     {
  781.         return array_filter($arr, function ($value) {
  782.             return $value !== null;
  783.         });
  784.     }
  786.     public static function assertObjectHydrated($object, bool $hydrateFlag = null)
  787.     {
  788.         if (!$object && !$hydrateFlag) {
  789.             throw new \Exception("Object not hydrated");
  790.         }
  791.     }
  793.     /**
  794.      * @param array|mixed $value
  795.      * @param $callback
  796.      * @return void
  797.      */
  798.     public static function forEach($value, $callback): void
  799.     {
  800.         if (is_array($value)) {
  801.             foreach ($value as $element) {
  802.                 $callback($element);
  803.             }
  804.         } else {
  805.             $callback($value);
  806.         }
  807.     }
  809.     public static function runProcess(string $name, string $args, $throwOnNonZeroExitCode = false, bool $async = false): array
  810.     {
  811. //        $command = "$name " . escapeshellarg($args);
  812.         $command = ($async ? "nohup " : "") . "$name $args" . ($async ? " > " . $_ENV['PYTHON_TELEGRAM_PATH'] . "/var/log/aaa 2>&1 & echo $!" : "");
  814. //        if (strpos($command, "python3")) {
  815. //            throw new \Exception("$command");
  816. //        }
  818.         if ($async) {
  819.             exec($command, $output);
  820.             $pid = (int)$output[0];
  821.             return [
  822.                 'pid' => $pid,
  823.             ];
  824.         }
  826.         // Open a process for the Python script
  827.         $descriptorspec = [
  828.             0 => ['pipe', 'r'], // stdin is a pipe that the child will read from
  829.             1 => ['pipe', 'w'], // stdout is a pipe that the child will write to
  830.             2 => ['pipe', 'w']  // stderr is a pipe that the child will write to
  831.         ];
  833.         $process = proc_open($command, $descriptorspec, $pipes);
  835.         if (is_resource($process)) {
  836.             $status = proc_get_status($process);
  837.             $pid = $status['pid'] ?? null;
  839.             fclose($pipes[0]);
  841.             $stdout = stream_get_contents($pipes[1]);
  842.             fclose($pipes[1]);
  844.             $stderr = stream_get_contents($pipes[2]);
  845.             fclose($pipes[2]);
  847.             $exitCode = proc_close($process);
  849.             // Output any errors
  850. //            if (!empty($stderr)) {
  851. //                throw new \Exception("Errors:\n" . $stderr) ;
  852. //            }
  854.             $result = [
  855.                 'stdout' => trim($stdout),
  856.                 'stderr' => $stderr,
  857.                 'exitCode' => $exitCode,
  858.                 "pid" => $pid,
  859.             ];
  861.             if ($throwOnNonZeroExitCode && $exitCode !== 0) {
  862.                 throw new \Exception("Exit code is not 0: " . $stderr);
  863.             }
  865.             return $result;
  866.         } else {
  867.             throw new \Exception("Failed to open process.") ;
  868.         }
  869.     }
  871.     public static function hasArrayCurlFile(array $arr): bool
  872.     {
  873.         foreach ($arr as $value) {
  874.             if ($value instanceof \CURLFile) {
  875.                 return true;
  876.             }
  877.             if (is_array($value) && self::hasArrayCurlFile($value)) {
  878.                 return true;
  879.             }
  880.         }
  881.         return false;
  882.     }
  884.     /**
  885.      * @param array $arr
  886.      * @return array{curl: array, rest: array}
  887.      */
  888.     public static function unmergeArrayCurlFiles(array $arr): array
  889.     {
  890.         $result = [
  891.             "files" => [],
  892.             "rest" => [],
  893.         ];
  895.         foreach ($arr as $key => $value) {
  896.             if ($value instanceof \CURLFile) {
  897.                 $result["files"][$key] = $value;
  898.             } else {
  899.                 $result["rest"][$key] = $value;
  900.             }
  901.         }
  903.         return $result;
  904.     }
  906.     public static function tryDoSilent($callback, $returnOnUnhandledError = null, callable $onHandledError = null, callable $onUnhandledError = null,
  907.                                        callable $onSuccess = null, array $handleExceptionClasses = null)
  908.     {
  909.         if (!$onUnhandledError) {
  910.             $onUnhandledError = function (\Throwable $throwable) {};
  911.         }
  912.         return self::tryDo($callback, $returnOnUnhandledError, $onHandledError, $onUnhandledError, $onSuccess, $handleExceptionClasses);
  913.     }
  915.     public static function tryDo($callback, $returnOnUnhandledError = null, callable $onHandledError = null, callable $onUnhandledError = null,
  916.                                  callable $onSuccess = null, array $handleExceptionClasses = null)
  917.     {
  918.         try {
  919.             $result = $callback();
  920.             if ($onSuccess) {
  921.                 $onSuccess($result);
  922.             } else {
  923.                 return $result;
  924.             }
  925.         } catch (\Throwable $exception) {
  926.             if ($handleExceptionClasses && $onHandledError) {
  927.                 foreach ($handleExceptionClasses as $handledException) {
  928.                     if ($exception instanceof $handledException) {
  929.                         return $onHandledError($exception);
  930.                     }
  931.                 }
  932.             }
  933.             if ($onUnhandledError) {
  934.                 return $onUnhandledError($exception);
  935.             }
  936.             if ($returnOnUnhandledError) {
  937.                 return $returnOnUnhandledError;
  938.             }
  939.             throw $exception;
  940.         }
  941.     }
  942. }