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

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 appendPyTgStderrLog($data, $addDataBefore = null, $toOneLine = true)
  256.     {
  257.         self::appendLog($data, 'pyTgStderrLog', $addDataBefore, $toOneLine);
  258.     }
  260.     public static function appendSuccessRoomAccessLog($data, $addDataBefore = null, $toOneLine = true)
  261.     {
  262.         self::appendLog($data, 'successRoomAccess', $addDataBefore, $toOneLine);
  263.     }
  265.     public static function appendUserStartedStreamLog($data, $addDataBefore = null, $toOneLine = true)
  266.     {
  267.         self::appendLog($data, 'userStartedStream', $addDataBefore, $toOneLine);
  268.     }
  270.     public static function appendAuthLog($data, $addDataBefore = null, $toOneLine = true)
  271.     {
  272.         self::appendLog($data, 'authLog', $addDataBefore, $toOneLine);
  273.     }
  275.     /**
  276.      * {@inheritdoc}
  277.      * @return null
  278.      */
  279.     static function writeTxtToFile($data, $fileName = 'logs.txt', string $findRootDirName = null, bool $jsonEncode = false,
  280.                                    $caption = null, $do_var_export = false, $is_all_defined_vars = false, $addDate = false,
  281.                                    bool $append = false)
  282.     {
  283.         if ($findRootDirName) {
  284.             $logDirPath = "./";
  285.             $logDirRealPath = null;
  286.             $dirLevel = 0;
  287.             while (!str_ends_with(($logDirRealPath = realpath($logDirPath)), "/" . $findRootDirName)) {
  288.                 $logDirPath .= "../";
  289.                 $dirLevel++;
  290.                 if ($dirLevel == 500) {
  291.                     throw new \Exception('Cant\'t find root dir.');
  292.                 }
  293.             }
  294.             $fileName = $logDirRealPath . "/" . $fileName;
  295.         }
  297.         try {
  298.             if ($is_all_defined_vars) {
  299.                 if ($caption == null) {
  300.                     $caption = "all_defined_vars";
  301.                 }
  302.                 $allVars = [];
  303.                 foreach ($data as $varName => $varData) {
  304.                     $isClassObj = !is_bool($varData) && !is_int($varData) && !is_float($varData) && !is_string($varData) && !is_array($varData);
  305.                     if ($isClassObj) {
  306.                         $allVars[$varName] = get_class($varData);
  307.                     } else {
  308.                         $allVars[$varName] = $varData;
  309.                     }
  310.                     if (is_array($varData)) {
  311.                         $allVars[$varName] = array_keys($varData);
  312.                     }
  313.                 }
  314.                 $data = $allVars;
  315.             }
  316.         } catch (\Exception $ex) {
  317.             $data = "error: " . $ex->getMessage();
  318.         }
  320.         if ($do_var_export) {
  321.             $data = var_export($data, true);
  322.         }
  323.         if ($caption) {
  324. //            $data = $caption . "-->\n" . $data . "\n<--" . $caption;
  325.             $data = $caption . ": " . $data;
  326.         }
  327.         if ($addDate) {
  328.             $data = (new \DateTime())->format('d.m.Y H:i:s') . ": " . $data;
  329.         }
  330.         $flags = 0;
  331.         if ($append) {
  332.             $flags = FILE_APPEND | LOCK_EX;
  333.         }
  334.         if ($jsonEncode) {
  335.             $data = json_encode($data, JSON_PRETTY_PRINT);
  336.         }
  337.         $myfile = file_put_contents($fileName, $data . PHP_EOL, $flags);
  338.     }
  340.     public static function getHostUrl($slashAtEnd = true): string
  341.     {
  342.         $url = $_SERVER["REQUEST_SCHEME"] . "://" . $_SERVER['SERVER_NAME'] .
  343.             (isset($_SERVER['SERVER_PORT']) && $_SERVER['SERVER_PORT'] ? ":" . $_SERVER['SERVER_PORT'] : "") .
  344.             ($slashAtEnd ? "/" : "");
  345.         return $url;
  346.     }
  348.     public static function filterArray($array, $callback = null, $childElementMethodName = null, $childElementMethodResult = null): array
  349.     {
  350.         $array = array_filter($array, function ($curElement) use ($callback, $childElementMethodName, $childElementMethodResult) {
  351.             $result = (!$callback || ($callback($curElement)) &&
  352.                 (!$childElementMethodName || call_user_func([$curElement, $childElementMethodName]) == $childElementMethodResult));
  353.             return $result;
  354.         });
  355.         return $array;
  356.     }
  358.     public static function getBacktrace(array $backtrace = null): ?array
  359.     {
  360.         if (!$backtrace) {
  361.             $backtrace = debug_backtrace();
  362.         }
  363.         foreach ($backtrace as &$trace) {
  364.             if (isset($trace['file']) && isset($trace["line"]) && isset($trace["function"])) {
  365.                 $trace = "{$trace['file']}:{$trace["line"]} (->{$trace["function"]})";
  366.             } else {
  367.                 $trace = "...";
  368.             }
  369.         }
  370.         return $backtrace;
  371.     }
  373.     public static function removeKey(array $array, string $key): array
  374.     {
  375.         unset($array[$key]);
  376.         return $array;
  377.     }
  379.     /**
  380.      * @param null|array|mixed $object
  381.      * @param array|mixed $data
  382.      * @param \Closure|null $createObjectCallback
  383.      */
  384.     public function setObjectDataFromArray($object = null, $data, $includedDataKeys = null,
  385.                                            \Closure $createObjectCallback = null,
  386.         $beforeObjectPersistCallback = null)
  387.     {
  388.         if ($object && !is_array($object)) {
  389.             $object = [$object];
  390.         }
  391.         if (!is_array($data)) {
  392.             $data = [$data];
  393.         }
  395.         $objectIndex = -1;
  396.         foreach ($data as $currentData) {
  397.             $objectIndex++;
  398.             $currentObject = null;
  399.             if (!$object) {
  400.                 $currentObject = $createObjectCallback();
  401.             } else {
  402.                 $currentObject = $object[$objectIndex];
  403.             }
  404.             foreach ($currentData as $setMethod => $dataElement) {
  405.                 if ($includedDataKeys && !in_array($setMethod, $includedDataKeys)) {
  406.                     continue;
  407.                 }
  408.                 $setMethod = 'set' . ucfirst($setMethod);
  410.                 if (method_exists($currentObject, $setMethod)) {
  411.                     $currentObject->{$setMethod}($dataElement);
  412.                 }
  413.             }
  414.             if (!$object) {
  415.                 if (!$beforeObjectPersistCallback || $beforeObjectPersistCallback($currentObject, $currentData)) {
  416.                     $this->em->persist($currentObject);
  417.                     $this->em->flush();
  418.                 }
  419.             }
  420.         }
  421.     }
  423.     /**
  424.      * @param mixed|array $object
  425.      */
  426.     public static function objectToArray($object, $includedDataKeys, $onDataCreateCallback = null,
  427.                                          array $overrideKeyNames = null): array
  428.     {
  429.         $objects = $object;
  430.         if (!is_array($objects)) {
  431.             $objects = [$object];
  432.         }
  434.         $objectsData = [];
  435.         $objectsDataIndex = -1;
  436.         foreach ($objects as $currentObject) {
  437.             $objectsDataIndex++;
  438.             $currentObjectData = [];
  439.             foreach ($includedDataKeys as $dataKey) {
  440.                 $getMethod = 'get' . ucfirst($dataKey);
  441.                 if ($overrideKeyNames) {
  442.                     if (in_array($dataKey, array_keys($overrideKeyNames))) {
  443.                         $dataKey = $overrideKeyNames[$dataKey];
  444.                     }
  445.                 }
  446.                 $currentObjectData[$dataKey] = $currentObject->{$getMethod}();
  447.             }
  448.             if ($onDataCreateCallback) {
  449.                 $currentObjectData = $onDataCreateCallback($currentObject, $currentObjectData);
  450.             }
  451.             if ($currentObjectData) {
  452.                 $objectsData[$objectsDataIndex] = $currentObjectData;
  453.             }
  454.         }
  456.         if (is_array($object)) {
  457.             return $objectsData;
  458.         } else {
  459.             return $objectsData[0];
  460.         }
  461.     }
  463.     /**
  464.      * @param mixed|array $object
  465.      */
  466.     public static function objectToId($object)
  467.     {
  468.         $objects = $object;
  469.         $isArray = is_array($objects);
  470.         if (!$isArray) {
  471.             $objects = [$object];
  472.         }
  474.         $result = [];
  475.         foreach ($objects as $object) {
  476.             $result[] = $object->getId();
  477.         }
  479.         if ($isArray) {
  480.             return $result;
  481.         } else {
  482.             return $result[0];
  483.         }
  484.     }
  486.     public static function objectToStringId($object): string
  487.     {
  488.         return implode(",", self::objectToId($object));
  489.     }
  491.     public static function sumObjectField($object, $field)
  492.     {
  493.         $objects = $object;
  494.         $isArray = is_array($objects);
  495.         if (!$isArray) {
  496.             $objects = [$object];
  497.         }
  499.         $result = 0;
  500.         $field = "get" . ucfirst($field);
  501.         foreach ($objects as $object) {
  502.             $result += $object->$field();
  503.         }
  505.         return $result;
  506.     }
  508.     /**
  509.      *
  510.      * $callback = function($curElement, $elementIndex, $key) {};
  511.      *
  512.      * @param $array
  513.      * @param null $callback
  514.      * @param null $childElementName
  515.      * @param null $childElementValue
  516.      * @param null $element
  517.      * @param null $skipElement
  518.      * @param null $childArraysElementValueRegex
  519.      * @param bool $returnDetailedResult
  520.      * @return array|int
  521.      */
  522.     static public function findIndexInArray($array, $callback = null, $childElementName = null, $childElementValue = null, $element = null,
  523.                                             $skipElement = null, $childArraysElementValueRegex = null, bool $returnDetailedResult = false,
  524.                                             $childElementMethodName = null, $childElementMethodResult = null, $childArraysElementValue = null)
  525.     {
  526.         $elementIndex = 0;
  527.         $foundIndex = -1;
  528.         $foundKey = null;
  529.         $detailedResult = [];
  531.         foreach ($array as $key => $curElement) {
  532.             $found = (!$skipElement || $skipElement != $curElement) &&
  533.                 ((!$callback || $callback($curElement, $elementIndex, $key)) &&
  534.                     (!$childElementName || (isset($curElement[$childElementName]) && (!$childElementValue || $curElement[$childElementName] == $childElementValue))) &&
  535.                     (!$element || $element == $curElement) &&
  536.                     (!$childElementMethodName || call_user_func([$curElement, $childElementMethodName]) == $childElementMethodResult));
  537.             if ($found && ($childArraysElementValueRegex || $childArraysElementValue)) {
  538.                 $found = false;
  539.                 $detailedResult['foundChildElementValue'] = null;
  540.                 $tmpArray = ($childElementName ? $curElement[$childElementName] : $curElement);
  541.                 foreach ($tmpArray as $childKey => $curChildElement) {
  542.                     if ((!$childArraysElementValueRegex || preg_match($childArraysElementValueRegex, $curChildElement)) &&
  543.                         (!$childArraysElementValue || $curChildElement == $childArraysElementValue))
  544.                     {
  545.                         $detailedResult['foundChildElementValue'] = $curChildElement;
  546.                         $found = true;
  547.                         break;
  548.                     }
  549.                 }
  550.             }
  551.             if ($found) {
  552.                 $foundIndex = $elementIndex;
  553.                 $foundKey = $key;
  554.                 break;
  555.             }
  556.             $elementIndex++;
  557.         }
  559.         if ($returnDetailedResult) {
  560.             $detailedResult['index'] = $foundIndex;
  561.             $detailedResult['key'] = $foundKey;
  562.             return $detailedResult;
  563.         } else {
  564.             return $foundIndex;
  565.         }
  566.     }
  568.     /**
  569.      * @return array|int
  570.      */
  571.     static public function findIndexInArrayByElement($array, $element = null)
  572.     {
  573.         return self::findIndexInArray($array, null, null, null, $element);
  574.     }
  577.     public static function findInArrayByChildArrayElementValue($array, $childArrayElementValue, $childElementName = null,
  578.                                                                bool $returnDetailedResult = false)
  579.     {
  580.         return self::findInArray($array, null, $childElementName, null, null, null,
  581.             null, null, $returnDetailedResult, null,
  582.             null, $childArrayElementValue);
  583.     }
  585.     static public function findInArray($array, $callback = null, $childElementName = null, $childElementValue = null, $element = null,
  586.                                        $skipElement = null, $getResultElementValueWithName = null,
  587.                                        $childArraysElementValueRegex = null,
  588.                                        bool $returnDetailedResult = false, $childElementMethodName = null, $childElementMethodResult = null,
  589.         $childArraysElementValue = null)
  590.     {
  591.         $result = self::findIndexInArray($array, $callback, $childElementName, $childElementValue, $element, $skipElement, $childArraysElementValueRegex,
  592.             $returnDetailedResult, $childElementMethodName, $childElementMethodResult, $childArraysElementValue);
  593.         $index = ($returnDetailedResult ? $result['index'] : $result);
  594.         $subResult = $index;
  596.         if ($index > -1 || is_string($index)) {
  597.             $foundKey = array_keys($array)[$index];
  598.             if ($getResultElementValueWithName) {
  599.                 $subResult = $array[$foundKey][$getResultElementValueWithName];
  600.             } else {
  601.                 $subResult = $array[$foundKey];
  602.             }
  603.         } else {
  604.             $subResult = null;
  605.         }
  607.         if ($returnDetailedResult) {
  608.             $result['result'] = $subResult;
  609.         } else {
  610.             $result = $subResult;
  611.         }
  613.         return $result;
  614.     }
  616.     public static function findInArrayByElementMethodResult($array, $childElementMethodName, $childElementMethodResult)
  617.     {
  618.         return self::findInArray($array, null, null, null, null, null,
  619.             null, null, false, $childElementMethodName,
  620.             $childElementMethodResult);
  621.     }
  623.     public static function convertArray(array $array, $elementMethodName = null)
  624.     {
  625.         foreach ($array as $key => $value) {
  626.             if ($elementMethodName) {
  627.                 $array[$key] = call_user_func([$value, $elementMethodName]);
  628.             }
  629.         }
  630.         return $array;
  631.     }
  633.     public static function sumArray($array, $elementMethodName = null, array $keys = null): float
  634.     {
  635.         if ($keys) {
  636.             return Other::sumArray(array_intersect_key($array, array_flip($keys)));
  637.         }
  639.         /** @var float $sum */
  640.         $sum = 0.0;
  641.         foreach ($array as $key => $value) {
  642.             if ($elementMethodName) {
  643.                 $sum += (float)call_user_func([$value, $elementMethodName]);
  644.             } else {
  645.                 $sum += (float)$value;
  646.             }
  647.         }
  648.         return $sum;
  649.     }
  651.     public static function getVarPath(?string $subPath = null): string
  652.     {
  653.         $path = self::getRootPath( '/var/' . ($subPath ?: "")) ;
  654.         return $path;
  655.     }
  657.     public static function getRootPath(?string $subPath = null): string
  658.     {
  659.         $path = self::findParentPathWithDir(__DIR__, ['src', 'var']) . ($subPath ?: "");
  660.         return $path;
  661.     }
  663.     public static function setSettings(array $settings = null, string $settingName = null, $settingValue = null, $fileName = "settings.json", $isAbsolutePath = false)
  664.     {
  665.         if (!$isAbsolutePath) {
  666.             $fileName = self::getVarPath($fileName);
  667.         }
  668.         if ($settingName) {
  669.             $settings = [$settingName => $settingValue];
  670.         }
  672.         $currentSettings = [];
  673.         if (is_file($fileName)) {
  674.             $currentSettings = json_decode(file_get_contents($fileName), true);
  675.         }
  676.         foreach ($settings as $key => $value) {
  677.             $currentSettings[$key] = $value;
  678.         }
  679.         self::writeTxtToFile($currentSettings, $fileName, null, true);
  680.     }
  682.     /**
  683.      * @param string|null $settingName
  684.      * @param bool $nullIfNotExists
  685.      * @param $fileName
  686.      * @return array|mixed|null
  687.      * @throws \Exception
  688.      */
  689.     public static function getSettings(string $settingName = null, bool $nullIfNotExists = false, $fileName = "settings.json", $isAbsolutePath = false)
  690.     {
  691.         if (!$isAbsolutePath) {
  692.             $fileName = self::getVarPath($fileName);
  693.         }
  695.         $settings = [];
  696.         if (is_file($fileName)) {
  697.             $settings = json_decode(file_get_contents($fileName), true);
  698.         }
  699.         if ($settingName) {
  700.             if (!isset($settings[$settingName])) {
  701.                 if ($nullIfNotExists) {
  702.                     return null;
  703.                 } else {
  704.                     throw new \Exception((is_file($fileName) ? "Setting not exists: $settingName" : "Settings file not exists: $fileName"));
  705.                 }
  706.             }
  707.             return $settings[$settingName];
  708.         } else {
  709.             return $settings;
  710.         }
  711.     }
  713.     public static function findInChildArray($array, $childArrayKey, $childArrayValue): ?array
  714.     {
  715.         foreach ($array as $key => $element) {
  716.             if (isset($element[$childArrayKey]) && $element[$childArrayKey] == $childArrayValue) {
  717.                 return ["key" => $key, "childKey" => $childArrayKey, "value" => $childArrayValue, "childArray" => $element];
  718.             }
  719.         }
  720.         return null;
  721.     }
  723.     public static function getIdIndexedEntityArray(array $entities): array
  724.     {
  725.         $arr = [];
  726.         foreach ($entities as $item) {
  727.             $arr[$item->getId()] = $item;
  728.         }
  729.         return $arr;
  730.     }
  732.     public static function removeFilesByRegex($directory, $regex) {
  733.         $files = glob($directory . '/*');
  735.         $removeFiles = [];
  737.         if ($files !== false) {
  738.             foreach ($files as $file) {
  739.                 if (preg_match($regex, basename($file))) {
  740.                     $removeFiles[] = $file;
  741.                 }
  742.             }
  744.             foreach ($removeFiles as $file) {
  745.                 unlink($file);
  746.             }
  747.         }
  748.     }
  750.     public static function getRequestAttributes(Request $request)
  751.     {
  752.         return array_intersect_key($request->attributes->all(),
  753.             array_flip(array_filter(array_keys($request->attributes->all()),
  754.                 function ($key) {return !str_starts_with($key, "_");})));
  755.     }
  757.     public static function sleepMs($milliseconds) {
  758.         $microseconds = $milliseconds * 1000;
  759.         usleep($microseconds);
  760.     }
  762.     public static function filterArrayNotNull(array $arr): array
  763.     {
  764.         return array_filter($arr, function ($value) {
  765.             return $value !== null;
  766.         });
  767.     }
  769.     public static function assertObjectHydrated($object, bool $hydrateFlag = null)
  770.     {
  771.         if (!$object && !$hydrateFlag) {
  772.             throw new \Exception("Object not hydrated");
  773.         }
  774.     }
  776.     /**
  777.      * @param array|mixed $value
  778.      * @param $callback
  779.      * @return void
  780.      */
  781.     public static function forEach($value, $callback): void
  782.     {
  783.         if (is_array($value)) {
  784.             foreach ($value as $element) {
  785.                 $callback($element);
  786.             }
  787.         } else {
  788.             $callback($value);
  789.         }
  790.     }
  792.     public static function runProcess(string $name, string $args, $throwOnNonZeroExitCode = false, bool $async = false): array
  793.     {
  794. //        $command = "$name " . escapeshellarg($args);
  795.         $command = ($async ? "nohup " : "") . "$name $args" . ($async ? " > " . $_ENV['PYTHON_TELEGRAM_PATH'] . "/var/log/aaa 2>&1 & echo $!" : "");
  797. //        if (strpos($command, "python3")) {
  798. //            throw new \Exception("$command");
  799. //        }
  801.         if ($async) {
  802.             exec($command, $output);
  803.             $pid = (int)$output[0];
  804.             return [
  805.                 'pid' => $pid,
  806.             ];
  807.         }
  809.         // Open a process for the Python script
  810.         $descriptorspec = [
  811.             0 => ['pipe', 'r'], // stdin is a pipe that the child will read from
  812.             1 => ['pipe', 'w'], // stdout is a pipe that the child will write to
  813.             2 => ['pipe', 'w']  // stderr is a pipe that the child will write to
  814.         ];
  816.         $process = proc_open($command, $descriptorspec, $pipes);
  818.         if (is_resource($process)) {
  819.             $status = proc_get_status($process);
  820.             $pid = $status['pid'] ?? null;
  822.             fclose($pipes[0]);
  824.             $stdout = stream_get_contents($pipes[1]);
  825.             fclose($pipes[1]);
  827.             $stderr = stream_get_contents($pipes[2]);
  828.             fclose($pipes[2]);
  830.             $exitCode = proc_close($process);
  832.             // Output any errors
  833. //            if (!empty($stderr)) {
  834. //                throw new \Exception("Errors:\n" . $stderr) ;
  835. //            }
  837.             $result = [
  838.                 'stdout' => trim($stdout),
  839.                 'stderr' => $stderr,
  840.                 'exitCode' => $exitCode,
  841.                 "pid" => $pid,
  842.             ];
  844.             if ($throwOnNonZeroExitCode && $exitCode !== 0) {
  845.                 throw new \Exception("Exit code is not 0: " . $stderr);
  846.             }
  848.             return $result;
  849.         } else {
  850.             throw new \Exception("Failed to open process.") ;
  851.         }
  852.     }
  853. }