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

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.     /**
  385.      * @param null|array|mixed $object
  386.      * @param array|mixed $data
  387.      * @param \Closure|null $createObjectCallback
  388.      */
  389.     public function setObjectDataFromArray($object = null, $data, $includedDataKeys = null,
  390.                                            \Closure $createObjectCallback = null,
  391.         $beforeObjectPersistCallback = null)
  392.     {
  393.         if ($object && !is_array($object)) {
  394.             $object = [$object];
  395.         }
  396.         if (!is_array($data)) {
  397.             $data = [$data];
  398.         }
  400.         $objectIndex = -1;
  401.         foreach ($data as $currentData) {
  402.             $objectIndex++;
  403.             $currentObject = null;
  404.             if (!$object) {
  405.                 $currentObject = $createObjectCallback();
  406.             } else {
  407.                 $currentObject = $object[$objectIndex];
  408.             }
  409.             foreach ($currentData as $setMethod => $dataElement) {
  410.                 if ($includedDataKeys && !in_array($setMethod, $includedDataKeys)) {
  411.                     continue;
  412.                 }
  413.                 $setMethod = 'set' . ucfirst($setMethod);
  415.                 if (method_exists($currentObject, $setMethod)) {
  416.                     $currentObject->{$setMethod}($dataElement);
  417.                 }
  418.             }
  419.             if (!$object) {
  420.                 if (!$beforeObjectPersistCallback || $beforeObjectPersistCallback($currentObject, $currentData)) {
  421.                     $this->em->persist($currentObject);
  422.                     $this->em->flush();
  423.                 }
  424.             }
  425.         }
  426.     }
  428.     /**
  429.      * @param mixed|array $object
  430.      */
  431.     public static function objectToArray($object, $includedDataKeys, $onDataCreateCallback = null,
  432.                                          array $overrideKeyNames = null): array
  433.     {
  434.         $objects = $object;
  435.         if (!is_array($objects)) {
  436.             $objects = [$object];
  437.         }
  439.         $objectsData = [];
  440.         $objectsDataIndex = -1;
  441.         foreach ($objects as $currentObject) {
  442.             $objectsDataIndex++;
  443.             $currentObjectData = [];
  444.             foreach ($includedDataKeys as $dataKey) {
  445.                 $getMethod = 'get' . ucfirst($dataKey);
  446.                 if ($overrideKeyNames) {
  447.                     if (in_array($dataKey, array_keys($overrideKeyNames))) {
  448.                         $dataKey = $overrideKeyNames[$dataKey];
  449.                     }
  450.                 }
  451.                 $currentObjectData[$dataKey] = $currentObject->{$getMethod}();
  452.             }
  453.             if ($onDataCreateCallback) {
  454.                 $currentObjectData = $onDataCreateCallback($currentObject, $currentObjectData);
  455.             }
  456.             if ($currentObjectData) {
  457.                 $objectsData[$objectsDataIndex] = $currentObjectData;
  458.             }
  459.         }
  461.         if (is_array($object)) {
  462.             return $objectsData;
  463.         } else {
  464.             return $objectsData[0];
  465.         }
  466.     }
  468.     /**
  469.      * @param mixed|array $object
  470.      */
  471.     public static function objectToId($object)
  472.     {
  473.         $objects = $object;
  474.         $isArray = is_array($objects);
  475.         if (!$isArray) {
  476.             $objects = [$object];
  477.         }
  479.         $result = [];
  480.         foreach ($objects as $object) {
  481.             $result[] = $object->getId();
  482.         }
  484.         if ($isArray) {
  485.             return $result;
  486.         } else {
  487.             return $result[0];
  488.         }
  489.     }
  491.     public static function objectToStringId($object): string
  492.     {
  493.         return implode(",", self::objectToId($object));
  494.     }
  496.     public static function sumObjectField($object, $field)
  497.     {
  498.         $objects = $object;
  499.         $isArray = is_array($objects);
  500.         if (!$isArray) {
  501.             $objects = [$object];
  502.         }
  504.         $result = 0;
  505.         $field = "get" . ucfirst($field);
  506.         foreach ($objects as $object) {
  507.             $result += $object->$field();
  508.         }
  510.         return $result;
  511.     }
  513.     /**
  514.      *
  515.      * $callback = function($curElement, $elementIndex, $key) {};
  516.      *
  517.      * @param $array
  518.      * @param null $callback
  519.      * @param null $childElementName
  520.      * @param null $childElementValue
  521.      * @param null $element
  522.      * @param null $skipElement
  523.      * @param null $childArraysElementValueRegex
  524.      * @param bool $returnDetailedResult
  525.      * @return array|int
  526.      */
  527.     static public function findIndexInArray($array, $callback = null, $childElementName = null, $childElementValue = null, $element = null,
  528.                                             $skipElement = null, $childArraysElementValueRegex = null, bool $returnDetailedResult = false,
  529.                                             $childElementMethodName = null, $childElementMethodResult = null, $childArraysElementValue = null)
  530.     {
  531.         $elementIndex = 0;
  532.         $foundIndex = -1;
  533.         $foundKey = null;
  534.         $detailedResult = [];
  536.         foreach ($array as $key => $curElement) {
  537.             $found = (!$skipElement || $skipElement != $curElement) &&
  538.                 ((!$callback || $callback($curElement, $elementIndex, $key)) &&
  539.                     (!$childElementName || (isset($curElement[$childElementName]) && (!$childElementValue || $curElement[$childElementName] == $childElementValue))) &&
  540.                     (!$element || $element == $curElement) &&
  541.                     (!$childElementMethodName || call_user_func([$curElement, $childElementMethodName]) == $childElementMethodResult));
  542.             if ($found && ($childArraysElementValueRegex || $childArraysElementValue)) {
  543.                 $found = false;
  544.                 $detailedResult['foundChildElementValue'] = null;
  545.                 $tmpArray = ($childElementName ? $curElement[$childElementName] : $curElement);
  546.                 foreach ($tmpArray as $childKey => $curChildElement) {
  547.                     if ((!$childArraysElementValueRegex || preg_match($childArraysElementValueRegex, $curChildElement)) &&
  548.                         (!$childArraysElementValue || $curChildElement == $childArraysElementValue))
  549.                     {
  550.                         $detailedResult['foundChildElementValue'] = $curChildElement;
  551.                         $found = true;
  552.                         break;
  553.                     }
  554.                 }
  555.             }
  556.             if ($found) {
  557.                 $foundIndex = $elementIndex;
  558.                 $foundKey = $key;
  559.                 break;
  560.             }
  561.             $elementIndex++;
  562.         }
  564.         if ($returnDetailedResult) {
  565.             $detailedResult['index'] = $foundIndex;
  566.             $detailedResult['key'] = $foundKey;
  567.             return $detailedResult;
  568.         } else {
  569.             return $foundIndex;
  570.         }
  571.     }
  573.     /**
  574.      * @return array|int
  575.      */
  576.     static public function findIndexInArrayByElement($array, $element = null)
  577.     {
  578.         return self::findIndexInArray($array, null, null, null, $element);
  579.     }
  582.     public static function findInArrayByChildArrayElementValue($array, $childArrayElementValue, $childElementName = null,
  583.                                                                bool $returnDetailedResult = false)
  584.     {
  585.         return self::findInArray($array, null, $childElementName, null, null, null,
  586.             null, null, $returnDetailedResult, null,
  587.             null, $childArrayElementValue);
  588.     }
  590.     static public function findInArray($array, $callback = null, $childElementName = null, $childElementValue = null, $element = null,
  591.                                        $skipElement = null, $getResultElementValueWithName = null,
  592.                                        $childArraysElementValueRegex = null,
  593.                                        bool $returnDetailedResult = false, $childElementMethodName = null, $childElementMethodResult = null,
  594.         $childArraysElementValue = null)
  595.     {
  596.         $result = self::findIndexInArray($array, $callback, $childElementName, $childElementValue, $element, $skipElement, $childArraysElementValueRegex,
  597.             $returnDetailedResult, $childElementMethodName, $childElementMethodResult, $childArraysElementValue);
  598.         $index = ($returnDetailedResult ? $result['index'] : $result);
  599.         $subResult = $index;
  601.         if ($index > -1 || is_string($index)) {
  602.             $foundKey = array_keys($array)[$index];
  603.             if ($getResultElementValueWithName) {
  604.                 $subResult = $array[$foundKey][$getResultElementValueWithName];
  605.             } else {
  606.                 $subResult = $array[$foundKey];
  607.             }
  608.         } else {
  609.             $subResult = null;
  610.         }
  612.         if ($returnDetailedResult) {
  613.             $result['result'] = $subResult;
  614.         } else {
  615.             $result = $subResult;
  616.         }
  618.         return $result;
  619.     }
  621.     public static function findInArrayByElementMethodResult($array, $childElementMethodName, $childElementMethodResult)
  622.     {
  623.         return self::findInArray($array, null, null, null, null, null,
  624.             null, null, false, $childElementMethodName,
  625.             $childElementMethodResult);
  626.     }
  628.     public static function convertArray(array $array, $elementMethodName = null)
  629.     {
  630.         foreach ($array as $key => $value) {
  631.             if ($elementMethodName) {
  632.                 $array[$key] = call_user_func([$value, $elementMethodName]);
  633.             }
  634.         }
  635.         return $array;
  636.     }
  638.     public static function sumArray($array, $elementMethodName = null, array $keys = null): float
  639.     {
  640.         if ($keys) {
  641.             return Other::sumArray(array_intersect_key($array, array_flip($keys)));
  642.         }
  644.         /** @var float $sum */
  645.         $sum = 0.0;
  646.         foreach ($array as $key => $value) {
  647.             if ($elementMethodName) {
  648.                 $sum += (float)call_user_func([$value, $elementMethodName]);
  649.             } else {
  650.                 $sum += (float)$value;
  651.             }
  652.         }
  653.         return $sum;
  654.     }
  656.     public static function getVarPath(?string $subPath = null): string
  657.     {
  658.         $path = self::getRootPath( '/var/' . ($subPath ?: "")) ;
  659.         return $path;
  660.     }
  662.     public static function getRootPath(?string $subPath = null): string
  663.     {
  664.         $path = self::findParentPathWithDir(__DIR__, ['src', 'var']) . ($subPath ?: "");
  665.         return $path;
  666.     }
  668.     public static function setSettings(array $settings = null, string $settingName = null, $settingValue = null, $fileName = "settings.json", $isAbsolutePath = false)
  669.     {
  670.         if (!$isAbsolutePath) {
  671.             $fileName = self::getVarPath($fileName);
  672.         }
  673.         if ($settingName) {
  674.             $settings = [$settingName => $settingValue];
  675.         }
  677.         $currentSettings = [];
  678.         if (is_file($fileName)) {
  679.             $currentSettings = json_decode(file_get_contents($fileName), true);
  680.         }
  681.         foreach ($settings as $key => $value) {
  682.             $currentSettings[$key] = $value;
  683.         }
  684.         self::writeTxtToFile($currentSettings, $fileName, null, true);
  685.     }
  687.     /**
  688.      * @param string|null $settingName
  689.      * @param bool $nullIfNotExists
  690.      * @param $fileName
  691.      * @return array|mixed|null
  692.      * @throws \Exception
  693.      */
  694.     public static function getSettings(string $settingName = null, bool $nullIfNotExists = false, $fileName = "settings.json", $isAbsolutePath = false)
  695.     {
  696.         if (!$isAbsolutePath) {
  697.             $fileName = self::getVarPath($fileName);
  698.         }
  700.         $settings = [];
  701.         if (is_file($fileName)) {
  702.             $settings = json_decode(file_get_contents($fileName), true);
  703.         }
  704.         if ($settingName) {
  705.             if (!isset($settings[$settingName])) {
  706.                 if ($nullIfNotExists) {
  707.                     return null;
  708.                 } else {
  709.                     throw new \Exception((is_file($fileName) ? "Setting not exists: $settingName" : "Settings file not exists: $fileName"));
  710.                 }
  711.             }
  712.             return $settings[$settingName];
  713.         } else {
  714.             return $settings;
  715.         }
  716.     }
  718.     public static function findInChildArray($array, $childArrayKey, $childArrayValue): ?array
  719.     {
  720.         foreach ($array as $key => $element) {
  721.             if (isset($element[$childArrayKey]) && $element[$childArrayKey] == $childArrayValue) {
  722.                 return ["key" => $key, "childKey" => $childArrayKey, "value" => $childArrayValue, "childArray" => $element];
  723.             }
  724.         }
  725.         return null;
  726.     }
  728.     public static function getIdIndexedEntityArray(array $entities): array
  729.     {
  730.         $arr = [];
  731.         foreach ($entities as $item) {
  732.             $arr[$item->getId()] = $item;
  733.         }
  734.         return $arr;
  735.     }
  737.     public static function removeFilesByRegex($directory, $regex) {
  738.         $files = glob($directory . '/*');
  740.         $removeFiles = [];
  742.         if ($files !== false) {
  743.             foreach ($files as $file) {
  744.                 if (preg_match($regex, basename($file))) {
  745.                     $removeFiles[] = $file;
  746.                 }
  747.             }
  749.             foreach ($removeFiles as $file) {
  750.                 unlink($file);
  751.             }
  752.         }
  753.     }
  755.     public static function getRequestAttributes(Request $request)
  756.     {
  757.         return array_intersect_key($request->attributes->all(),
  758.             array_flip(array_filter(array_keys($request->attributes->all()),
  759.                 function ($key) {return !str_starts_with($key, "_");})));
  760.     }
  762.     public static function sleepMs($milliseconds) {
  763.         $microseconds = $milliseconds * 1000;
  764.         usleep($microseconds);
  765.     }
  767.     public static function filterArrayNotNull(array $arr): array
  768.     {
  769.         return array_filter($arr, function ($value) {
  770.             return $value !== null;
  771.         });
  772.     }
  774.     public static function assertObjectHydrated($object, bool $hydrateFlag = null)
  775.     {
  776.         if (!$object && !$hydrateFlag) {
  777.             throw new \Exception("Object not hydrated");
  778.         }
  779.     }
  781.     /**
  782.      * @param array|mixed $value
  783.      * @param $callback
  784.      * @return void
  785.      */
  786.     public static function forEach($value, $callback): void
  787.     {
  788.         if (is_array($value)) {
  789.             foreach ($value as $element) {
  790.                 $callback($element);
  791.             }
  792.         } else {
  793.             $callback($value);
  794.         }
  795.     }
  797.     public static function runProcess(string $name, string $args, $throwOnNonZeroExitCode = false, bool $async = false): array
  798.     {
  799. //        $command = "$name " . escapeshellarg($args);
  800.         $command = ($async ? "nohup " : "") . "$name $args" . ($async ? " > " . $_ENV['PYTHON_TELEGRAM_PATH'] . "/var/log/aaa 2>&1 & echo $!" : "");
  802. //        if (strpos($command, "python3")) {
  803. //            throw new \Exception("$command");
  804. //        }
  806.         if ($async) {
  807.             exec($command, $output);
  808.             $pid = (int)$output[0];
  809.             return [
  810.                 'pid' => $pid,
  811.             ];
  812.         }
  814.         // Open a process for the Python script
  815.         $descriptorspec = [
  816.             0 => ['pipe', 'r'], // stdin is a pipe that the child will read from
  817.             1 => ['pipe', 'w'], // stdout is a pipe that the child will write to
  818.             2 => ['pipe', 'w']  // stderr is a pipe that the child will write to
  819.         ];
  821.         $process = proc_open($command, $descriptorspec, $pipes);
  823.         if (is_resource($process)) {
  824.             $status = proc_get_status($process);
  825.             $pid = $status['pid'] ?? null;
  827.             fclose($pipes[0]);
  829.             $stdout = stream_get_contents($pipes[1]);
  830.             fclose($pipes[1]);
  832.             $stderr = stream_get_contents($pipes[2]);
  833.             fclose($pipes[2]);
  835.             $exitCode = proc_close($process);
  837.             // Output any errors
  838. //            if (!empty($stderr)) {
  839. //                throw new \Exception("Errors:\n" . $stderr) ;
  840. //            }
  842.             $result = [
  843.                 'stdout' => trim($stdout),
  844.                 'stderr' => $stderr,
  845.                 'exitCode' => $exitCode,
  846.                 "pid" => $pid,
  847.             ];
  849.             if ($throwOnNonZeroExitCode && $exitCode !== 0) {
  850.                 throw new \Exception("Exit code is not 0: " . $stderr);
  851.             }
  853.             return $result;
  854.         } else {
  855.             throw new \Exception("Failed to open process.") ;
  856.         }
  857.     }
  859.     public static function hasArrayCurlFile(array $arr): bool
  860.     {
  861.         foreach ($arr as $value) {
  862.             if ($value instanceof \CURLFile) {
  863.                 return true;
  864.             }
  865.             if (is_array($value) && self::hasArrayCurlFile($value)) {
  866.                 return true;
  867.             }
  868.         }
  869.         return false;
  870.     }
  871. }