943 lines
19 KiB
PHP
943 lines
19 KiB
PHP
<?php
|
|
|
|
trait cmpUtil {
|
|
var $gitStatus = "Unknown";
|
|
var $gitDate = "";
|
|
var $gitTime = "";
|
|
var $gitTimeStamp = "";
|
|
var $gitCommit = "";
|
|
var $gitComment = "";
|
|
|
|
var $maxFileSize = 104856;
|
|
|
|
function toArray($obj) {
|
|
$re = array();
|
|
$in = null;
|
|
|
|
if(is_array($obj))
|
|
$in = $obj;
|
|
|
|
if(is_object($obj))
|
|
$in = get_object_vars($obj);
|
|
|
|
if(is_string($obj)) return $obj;
|
|
if(is_float($obj)) return $obj;
|
|
if(is_bool($obj)) return $obj;
|
|
if(is_int($obj)) return $obj;
|
|
|
|
foreach((array) $in as $k => $v) {
|
|
if(is_array($in[$k])) {
|
|
// echo "$k array\n";
|
|
$re[$k] = $this->toArray($v);
|
|
continue;
|
|
}
|
|
|
|
if(is_object($in[$k])) {
|
|
// echo "$k object\n";
|
|
$re[$k] = $this->toArray($v);
|
|
continue;
|
|
}
|
|
|
|
// echo "$k string?\n";
|
|
$re[$k] = $v;
|
|
}
|
|
|
|
return $re;
|
|
}
|
|
|
|
function errorJSON($err, $f = 2) {
|
|
switch($err) {
|
|
case JSON_ERROR_NONE : $this->e('Ошибок нет' , $f); break;
|
|
case JSON_ERROR_DEPTH : $this->e('Достигнута максимальная глубина стека' , $f); break;
|
|
case JSON_ERROR_STATE_MISMATCH : $this->e('Некорректные разряды или не совпадение режимов' , $f); break;
|
|
case JSON_ERROR_CTRL_CHAR : $this->e('Некорректный управляющий символ' , $f); break;
|
|
case JSON_ERROR_SYNTAX : $this->e('Синтаксическая ошибка, не корректный JSON' , $f); break;
|
|
case JSON_ERROR_UTF8 : $this->e('Некорректные символы UTF-8, возможно неверная кодировка' , $f); break;
|
|
case JSON_ERROR_RECURSION : $this->e('Одна или несколько зацикленных ссылок в кодируемом значении' , $f); break;
|
|
case JSON_ERROR_INF_OR_NAN : $this->e('Одно или несколько значений NAN или INF в кодируемом значении' , $f); break;
|
|
case JSON_ERROR_UNSUPPORTED_TYPE : $this->e('Передано значение с неподдерживаемым типом' , $f); break;
|
|
case JSON_ERROR_INVALID_PROPERTY_NAME : $this->e('Имя свойства не может быть закодировано' , $f); break;
|
|
case JSON_ERROR_UTF16 : $this->e('Некорректный символ UTF-16, возможно некорректно закодирован' , $f); break;
|
|
default : $this->e('Неизвестная ошибка' , $f); break;
|
|
}
|
|
}
|
|
|
|
function decodeJSONRaw($str, $f = 2) {
|
|
$obj = json_decode(
|
|
$str , // string $json
|
|
true , // ?bool $associative = null
|
|
512 , // int $depth = 512
|
|
JSON_INVALID_UTF8_IGNORE // int $flags = 0
|
|
);
|
|
|
|
$err = json_last_error();
|
|
|
|
if($err === JSON_ERROR_NONE)
|
|
return $this->toArray($obj);
|
|
|
|
$this->errorJSON($err, $f + 1);
|
|
|
|
$this->d("Invalid JSON: " . $str, $f);
|
|
|
|
return null;
|
|
}
|
|
|
|
function decodeJSON($str, $d = 0) {
|
|
$m = array();
|
|
|
|
// eq '/[[:cntrl:]]/u';
|
|
// $re = '/[\x00-\x1F\x7F]/u';
|
|
// Add ignore 0x09, 0x0a, 0x0d
|
|
$re = '/[\x00-\x08\x0b-\x0c\x0e-\x1F\x7F]/u';
|
|
|
|
// $ign = array("0x09", "0x0a", "0x0d");
|
|
|
|
if(preg_match_all($re, $str, $m)) {
|
|
$tr = array();
|
|
|
|
for($i = 0; $i < count($m[0]); $i++) {
|
|
$bin = $m[0][$i];
|
|
|
|
if(isset($tr[$bin]))
|
|
continue;
|
|
|
|
$hex = "0x" . bin2hex($bin);
|
|
|
|
// if(in_array($hex, $ign))
|
|
// continue;
|
|
|
|
$tr[$bin] = $hex;
|
|
|
|
if($d)
|
|
$this->d("decodeJSON: Translate " . $hex);
|
|
}
|
|
|
|
$str = strtr($str, $tr);
|
|
}
|
|
|
|
return $this->decodeJSONRaw($str, 6);
|
|
}
|
|
|
|
function encodeJSON($obj) {
|
|
$text = json_encode($obj, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
|
|
|
|
$err = json_last_error();
|
|
|
|
if($err === JSON_ERROR_NONE)
|
|
return $text;
|
|
|
|
$this->errorJSON($err);
|
|
|
|
return null;
|
|
}
|
|
|
|
function encodeJSONCompact($obj) {
|
|
$text = json_encode($obj, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
|
|
|
|
$err = json_last_error();
|
|
|
|
if($err === JSON_ERROR_NONE)
|
|
return $text;
|
|
|
|
$this->errorJSON($err);
|
|
|
|
return null;
|
|
}
|
|
|
|
function readFile($file) {
|
|
return @file_get_contents(
|
|
$file , // string
|
|
false , // bool $use_include_path
|
|
null , // ?resource $context
|
|
0 , // int $offset
|
|
$this->maxFileSize , // ?int $length
|
|
);
|
|
}
|
|
|
|
function readJSON($file) {
|
|
$raw = $this->readFile($file);
|
|
|
|
if(!$raw) {
|
|
$this->e("Can't read '$file'");
|
|
return false;
|
|
}
|
|
|
|
$obj = $this->decodeJSON($raw, 1);
|
|
|
|
if(is_array($obj)) {
|
|
return $obj;
|
|
}
|
|
|
|
if(!$obj) {
|
|
$this->e("Invalid JSON file '$file'");
|
|
return false;
|
|
}
|
|
|
|
// var_export($obj);
|
|
|
|
return $obj;
|
|
}
|
|
|
|
function appendConf($arr) {
|
|
if(!$arr)
|
|
return false;
|
|
|
|
foreach($arr as $k => $v) {
|
|
// $this->d("Set parm .$k to $v");
|
|
$this->parm[$k] = $v;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function readJSONConf($file) {
|
|
$obj = $this->readJSON($file);
|
|
|
|
if(!$obj)
|
|
return false;
|
|
|
|
$this->appendConf($obj);
|
|
|
|
if(isset($this->parm["timezone"]) && $this->parm["timezone"]) {
|
|
$this->d("Set timezone '" . $this->parm["timezone"] . "'");
|
|
date_default_timezone_set($this->parm["timezone"]);
|
|
}
|
|
|
|
do {
|
|
if(!isset($this->parm["maxFileSize"]))
|
|
break;
|
|
|
|
if(!$this->parm["maxFileSize"])
|
|
break;
|
|
|
|
if(!is_numeric($this->parm["maxFileSize"])) {
|
|
$this->d("Not numeric maxFileSize");
|
|
break;
|
|
}
|
|
|
|
$this->maxFileSize = 1*$this->parm["maxFileSize"];
|
|
$this->d("Set maxFileSize '" . $this->maxFileSize . "'");
|
|
} while(0);
|
|
|
|
if(isset($this->parm["php_ini"]) && is_array($this->parm["php_ini"])) {
|
|
foreach($this->parm["php_ini"] as $k => $v) {
|
|
ini_set($k, $v);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
function fgExec($cmd) {
|
|
$cmd .= " 2>/tmp/fgExec.err";
|
|
|
|
$this->d("fgExec: $cmd");
|
|
|
|
ob_start();
|
|
passthru($cmd, $ret);
|
|
$out = ob_get_contents();
|
|
ob_end_clean();
|
|
|
|
$a = array(
|
|
"return" => $ret,
|
|
"stderr" => array(),
|
|
"output" => $out
|
|
);
|
|
|
|
$ff = "/tmp/fgExec.err";
|
|
|
|
$err = @file($ff);
|
|
// var_export($err);
|
|
|
|
if(!is_array($err)) {
|
|
$a["stderr"][] = "Can't read file: $ff";
|
|
}
|
|
else for($i = 0; $i < count($err); $i++) {
|
|
$str = trim($err[$i], "\r\n");
|
|
|
|
// $this->d($str);
|
|
$a["stderr"][] = $str;
|
|
}
|
|
|
|
@unlink("/tmp/fgExec.err");
|
|
|
|
return $a;
|
|
}
|
|
|
|
function cmpShellEscStr($str) {
|
|
$ttr = array(
|
|
"\t" => "\\\t", "\$" => "\\\$",
|
|
"\\" => "\\\\", "\"" => "\\\"",
|
|
" " => "\\ " , "`" => "\\`",
|
|
"#" => "\\#" , "&" => "\\&",
|
|
"(" => "\\(" , ")" => "\\)",
|
|
"*" => "\\*" , "|" => "\\|",
|
|
"[" => "\\[" , "]" => "\\]",
|
|
"{" => "\\{" , "}" => "\\}",
|
|
";" => "\\;" , "'" => "\\'",
|
|
"<" => "\\<" , ">" => "\\>",
|
|
"?" => "\\?" , "!" => "\\!"
|
|
);
|
|
|
|
do {
|
|
if(!is_array($str))
|
|
break;
|
|
|
|
if(!isset($str[0]))
|
|
return null;
|
|
|
|
if($str[0] != "asis") {
|
|
$this->d("Unknown modifier '".$str[0]."'");
|
|
return null;
|
|
}
|
|
|
|
if(!isset($str[1]) || !$str[1]) {
|
|
$this->d("Invalid string '".$str[1]."'");
|
|
return null;
|
|
}
|
|
|
|
return $str[1];
|
|
} while(0);
|
|
|
|
return strtr($str, $ttr);
|
|
}
|
|
|
|
function cmpShellEscArr($cmaRaw) {
|
|
$cmaEsc = array();
|
|
|
|
for($i = 0; $i < count($cmaRaw); $i++) {
|
|
$str = $this->cmpShellEscStr($cmaRaw[$i]);
|
|
|
|
if(!$str) {
|
|
return null;
|
|
}
|
|
|
|
$cmaEsc[] = $str;
|
|
}
|
|
|
|
return $cmaEsc;
|
|
}
|
|
|
|
function cmpShellEsc($cmaRaw) {
|
|
if(is_array($cmaRaw)) {
|
|
$cmaEsc = $this->cmpShellEscArr($cmaRaw);
|
|
return join(" ", $cmaEsc);
|
|
}
|
|
|
|
return $this->cmpShellEscStr($cmaRaw);
|
|
}
|
|
|
|
function cmpSysExecEventString(&$prs, &$buf, &$opt) {
|
|
$fs = "/\n/";
|
|
|
|
if(isset($opt["eventStringDelimer"]) && $opt["eventStringDelimer"])
|
|
$fs = $opt["eventStringDelimer"];
|
|
|
|
$a = preg_split($fs, $buf);
|
|
|
|
if(!$a) {
|
|
$this->d("Can't split buffer");
|
|
return false;
|
|
}
|
|
|
|
$c = count($a) - 1;
|
|
|
|
if($c < 1)
|
|
return true;
|
|
|
|
for($i = 0; $i < $c; $i++) {
|
|
if(!isset($opt["silent"]) || !$opt["silent"])
|
|
$this->d($prs["streamCurrent"] . ": " . $a[$i]);
|
|
|
|
$callName = "";
|
|
|
|
if($prs["streamCurrent"] == "stdout") {
|
|
$callName = "eventStringStdOut";
|
|
}
|
|
else if($prs["streamCurrent"] == "stderr") {
|
|
$callName = "eventStringStdErr";
|
|
}
|
|
|
|
if(!isset($opt["eventStringStdOut"]))
|
|
continue;
|
|
|
|
if(!$opt["eventStringStdOut"])
|
|
continue;
|
|
|
|
if(!isset($opt[$callName]["call"])) {
|
|
$this->d("Unset $callName.call");
|
|
continue;
|
|
}
|
|
|
|
if(!is_callable($opt[$callName]["call"])) {
|
|
$this->d("Uncallable $callName.call");
|
|
continue;
|
|
}
|
|
|
|
$parm = null;
|
|
|
|
if(isset($opt[$callName]["parm"]))
|
|
$parm = $opt[$callName]["parm"];
|
|
|
|
try {
|
|
$ret = call_user_func(
|
|
$opt[$callName]["call"],
|
|
array(
|
|
"string" => $a[$i],
|
|
"parm" => $parm,
|
|
"prs" => $prs
|
|
)
|
|
);
|
|
} catch(Exception | Error $e) {
|
|
$this->e($e);
|
|
}
|
|
}
|
|
|
|
// $this->d("Stream tail: " . $a[$c]);
|
|
$buf = $a[$c];
|
|
|
|
return true;
|
|
}
|
|
|
|
function cmpSysExecEventListenner(&$ppsAll, &$opt) {
|
|
$prs = array();
|
|
|
|
while(!feof($ppsAll[1])) {
|
|
$read = [ $ppsAll[1], $ppsAll[2] ];
|
|
$write = null;
|
|
$except = null;
|
|
|
|
// $this->d("Add stream event listenner");
|
|
$cnt = stream_select(
|
|
$read,
|
|
$write,
|
|
$except,
|
|
1, // seconds
|
|
0 // microseconds
|
|
);
|
|
|
|
if(false === $cnt) {
|
|
$this->d("stream_select err");
|
|
return false;
|
|
}
|
|
|
|
// $this->d("Streams event count : " . $sel);
|
|
|
|
if(!$cnt) {
|
|
continue;
|
|
}
|
|
|
|
$out = stream_get_contents($ppsAll[1]);
|
|
if($out) {
|
|
$prs["streamCurrent"] = "stdout";
|
|
|
|
if(!$this->cmpSysExecEventString($prs, $out, $opt))
|
|
return false;
|
|
}
|
|
|
|
$err = stream_get_contents($ppsAll[2]);
|
|
if($err) {
|
|
$prs["streamCurrent"] = "stderr";
|
|
|
|
if(!$this->cmpSysExecEventString($prs, $err, $opt))
|
|
return false;
|
|
}
|
|
|
|
// while
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function cmpSysExecEventSwo(&$ppsAll, &$opt) {
|
|
do {
|
|
if(!isset($opt["stdInEventAdd"]) || !$opt["stdInEventAdd"])
|
|
break;
|
|
|
|
if(!isset($opt["stdInEventAdd"]["call"])) {
|
|
$this->d("Unset callable stdInEventAdd");
|
|
break;
|
|
}
|
|
|
|
if(!is_callable($opt["stdInEventAdd"]["call"])) {
|
|
$this->d("Invalid callable stdInEventAdd");
|
|
break;
|
|
}
|
|
|
|
if(!isset($opt["silent"]) || !$opt["silent"])
|
|
$this->d("Call stdInEventAdd");
|
|
|
|
($opt["stdInEventAdd"]["call"]) (
|
|
$ppsAll[0],
|
|
$opt["stdInEventAdd"]
|
|
);
|
|
} while(0);
|
|
|
|
do {
|
|
if(!isset($opt["stdOutEventAdd"]) || !$opt["stdOutEventAdd"])
|
|
break;
|
|
|
|
if(!isset($opt["stdOutEventAdd"]["call"])) {
|
|
$this->d("Unset callable stdOutEventAdd");
|
|
break;
|
|
}
|
|
|
|
if(!is_callable($opt["stdOutEventAdd"]["call"])) {
|
|
$this->d("Invalid callable stdOutEventAdd");
|
|
break;
|
|
}
|
|
|
|
if(!isset($opt["silent"]) || !$opt["silent"])
|
|
$this->d("Call stdOutEventAdd");
|
|
|
|
($opt["stdOutEventAdd" ]["call"]) (
|
|
$ppsAll[1],
|
|
$opt["stdOutEventAdd"]
|
|
);
|
|
} while(0);
|
|
|
|
do {
|
|
if(!isset($opt["stdErrEventAdd"]) || !$opt["stdErrEventAdd"])
|
|
break;
|
|
|
|
if(!isset($opt["stdErrEventAdd"]["call"])) {
|
|
$this->d("Unset callable stdErrEventAdd");
|
|
break;
|
|
}
|
|
|
|
if(!is_callable($opt["stdErrEventAdd"]["call"])) {
|
|
$this->d("Invalid callable stdErrEventAdd");
|
|
break;
|
|
}
|
|
|
|
if(!isset($opt["silent"]) || !$opt["silent"])
|
|
$this->d("Call stdErrEventAdd");
|
|
|
|
($opt["stdErrEventAdd"]["call"]) (
|
|
$ppsAll[2],
|
|
$opt["stdErrEventAdd"]
|
|
);
|
|
} while(0);
|
|
|
|
do {
|
|
if(!isset($opt["eventWait"]) || !$opt["eventWait"])
|
|
break;
|
|
|
|
if(!isset($opt["eventWait"]["call"])) {
|
|
$this->d("Unset callable eventWait");
|
|
break;
|
|
}
|
|
|
|
if(!is_callable($opt["eventWait"]["call"])) {
|
|
$this->d("Invalid callable eventWait");
|
|
break;
|
|
}
|
|
|
|
if(!isset($opt["silent"]) || !$opt["silent"])
|
|
$this->d("Call eventWait");
|
|
|
|
($opt["eventWait"]["call"])();
|
|
} while(0);
|
|
|
|
return true;
|
|
}
|
|
|
|
function cmpSysExec($cmaRaw, $opt = []) {
|
|
$cmdStr = $this->cmpShellEsc($cmaRaw);
|
|
|
|
if(!isset($opt["silent"]) || !$opt["silent"]) {
|
|
$this->d("cmpSysExec: " . $cmdStr);
|
|
}
|
|
|
|
$fdsAll = array(
|
|
0 => array("pipe", "r"), // stdin
|
|
1 => array("pipe", "w"), // stdout
|
|
2 => array("pipe", "w") // stderr
|
|
);
|
|
|
|
$workDir = "/tmp";
|
|
|
|
if(isset($opt["workDir"]) && $opt["workDir"])
|
|
$workDir = $opt["workDir"];
|
|
|
|
$envAll = null;
|
|
|
|
$ppsAll = array();
|
|
|
|
$prcRes = proc_open($cmdStr, $fdsAll, $ppsAll, $workDir, $envAll);
|
|
|
|
if(!is_resource($prcRes)) {
|
|
$this->e("Can't create process");
|
|
return null;
|
|
}
|
|
|
|
$blk = 1;
|
|
|
|
if(isset($opt["blocking"])) {
|
|
$blk = $opt["blocking"];
|
|
}
|
|
|
|
$retVal = 255;
|
|
$out = "";
|
|
$err = "";
|
|
|
|
if(isset($opt["eventString"]) && $opt["eventString"]) {
|
|
stream_set_blocking($ppsAll[1], 0);
|
|
stream_set_blocking($ppsAll[2], 0);
|
|
|
|
if(isset($opt["stdin"]) && $opt["stdin"]) {
|
|
fwrite($ppsAll[0], $opt["stdin"]);
|
|
fclose($ppsAll[0]);
|
|
}
|
|
|
|
$this->cmpSysExecEventListenner($ppsAll, $opt);
|
|
}
|
|
else if($blk) {
|
|
stream_set_blocking($ppsAll[1], $blk);
|
|
stream_set_blocking($ppsAll[2], $blk);
|
|
|
|
if(isset($opt["stdin"]) && $opt["stdin"]) {
|
|
fwrite($ppsAll[0], $opt["stdin"]);
|
|
fclose($ppsAll[0]);
|
|
}
|
|
|
|
$out = stream_get_contents($ppsAll[1], 1048576);
|
|
$err = stream_get_contents($ppsAll[2], 1048576);
|
|
}
|
|
else {
|
|
stream_set_blocking($ppsAll[1], $blk);
|
|
stream_set_blocking($ppsAll[2], $blk);
|
|
|
|
// $this->d("Nonblock");
|
|
|
|
$this->cmpSysExecEventSwo($ppsAll, $opt);
|
|
|
|
}
|
|
|
|
// $this->d("Close all pipe");
|
|
|
|
fclose($ppsAll[1]);
|
|
fclose($ppsAll[2]);
|
|
|
|
$retVal = proc_close($prcRes);
|
|
|
|
|
|
if(!isset($opt["return"]) || !$opt["return"] || $opt["return"] == "full") {
|
|
return array(
|
|
"retval" => $retVal,
|
|
"stdout" => $out,
|
|
"stderr" => $err
|
|
);
|
|
}
|
|
|
|
$val = 0;
|
|
|
|
if(isset($opt["retval"]) && $opt["retval"])
|
|
$val = $opt["retval"];
|
|
|
|
if(!isset($opt["noerror"]) || !$opt["noerror"]) {
|
|
if($retVal !== $val) {
|
|
if(!isset($opt["silent"]) || !$opt["silent"]) {
|
|
$this->d($err);
|
|
$this->d("Return code: " . $retVal);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
if($err) {
|
|
$this->d($err);
|
|
}
|
|
}
|
|
|
|
if(isset($opt["return"]) && $opt["return"]) {
|
|
switch(@$opt["return"]) {
|
|
case "retval":
|
|
return 1*$retVal;
|
|
|
|
case "outstr":
|
|
return $out;
|
|
|
|
case "outarr":
|
|
default:
|
|
return explode("\n", $out);
|
|
}
|
|
}
|
|
|
|
return explode("\n", $out);
|
|
}
|
|
|
|
function cmpSysExecTest() {
|
|
$a = array(
|
|
"ping" ,
|
|
"-c" ,
|
|
"4" ,
|
|
"127.0.0.1" ,
|
|
);
|
|
|
|
$this->d("Launch");
|
|
$this->d($a);
|
|
|
|
$this->cmpSysExec($a, array(
|
|
"silent" => false,
|
|
"eventString" => true,
|
|
"eventStringStdOut" => array(
|
|
"call" => [$this, "d"],
|
|
"parm" => "testparm"
|
|
)
|
|
));
|
|
}
|
|
|
|
|
|
function getGitStatus($dir = ".") {
|
|
$a = array(
|
|
"git", "status", "--porcelain"
|
|
);
|
|
|
|
$gitStatus = $this->cmpSysExec($a, ["workDir" => $dir]);
|
|
|
|
if($gitStatus["retval"]) {
|
|
$this->d("GIT have errors");
|
|
$this->d($gitStatus["stderr"]);
|
|
return ;
|
|
}
|
|
|
|
if(!$gitStatus["stdout"]) {
|
|
return null;
|
|
}
|
|
|
|
$this->w("GIT have changes");
|
|
|
|
$arr = explode("\n", $gitStatus["stdout"]);
|
|
$ret = array();
|
|
|
|
for($i = 0; $i < count($arr); $i++) {
|
|
$arr[$i] = trim($arr[$i], "\n \r\t");
|
|
|
|
if(!$arr[$i])
|
|
continue;
|
|
|
|
$ff = explode(" ", $arr[$i], 2);
|
|
|
|
$this->d("flag=" . $ff[0] . " file=" . $ff[1]);
|
|
|
|
$ret[] = $ff;
|
|
}
|
|
|
|
// $this->d($ret);
|
|
|
|
return $ret;
|
|
}
|
|
|
|
function getGitLog1($dir = ".") {
|
|
// https://git-scm.com/docs/pretty-formats
|
|
$frmReq = array(
|
|
array("commitHash", "H" ),
|
|
array("commitDate", "ci"),
|
|
array("commitTStm", "ct"),
|
|
array("authorMail", "ae")
|
|
);
|
|
|
|
$frmArr = array();
|
|
|
|
for($i = 0; $i < count($frmReq); $i++)
|
|
$frmArr[] = "%" . $frmReq[$i][1];
|
|
|
|
$frmStr = join("%n", $frmArr);
|
|
|
|
$a = array(
|
|
"git", "log", "--pretty=format:$frmStr", "-1"
|
|
);
|
|
|
|
$gitCommit = $this->cmpSysExec($a, ["workDir" => $dir]);
|
|
|
|
if($gitCommit["retval"]) {
|
|
$this->d("GIT have errors");
|
|
$this->d($gitCommit["stderr"]);
|
|
return null;
|
|
}
|
|
|
|
$b = explode("\n", $gitCommit["stdout"]);
|
|
|
|
$frmRet = array();
|
|
|
|
for($i = 0; $i < count($frmReq); $i++)
|
|
$frmRet[ $frmReq[$i][0] ] = $b[$i];
|
|
|
|
return $frmRet;
|
|
}
|
|
|
|
function cmpTraitInit($obj, $lvl = 0) {
|
|
$listTrait = class_uses($obj);
|
|
|
|
foreach($listTrait as $trait) {
|
|
$this->d("Used trait $trait");
|
|
|
|
do {
|
|
$traitRoot = OUT_PROJ_DIR . "/" . $trait;
|
|
$traitGit = $traitRoot . "/.git";
|
|
|
|
if(!is_dir($traitGit))
|
|
break;
|
|
|
|
$ret = $this->getGitStatus($traitRoot);
|
|
|
|
$ret = $this->getGitLog1($traitRoot);
|
|
|
|
$this->d($ret);
|
|
} while(0);
|
|
|
|
$this->cmpTraitInit($trait, $lvl+1);
|
|
|
|
$initMeth = $trait . "Init";
|
|
|
|
if(!method_exists($this, $initMeth)) {
|
|
// $this->d("No method $initMeth");
|
|
continue;
|
|
}
|
|
|
|
$parm = null;
|
|
|
|
if(isset($this->parm[$trait])) {
|
|
// $this->d("Found parm");
|
|
$parm = $this->parm[$trait];
|
|
}
|
|
|
|
$this->swoSelfCall(array("func" => $initMeth, "parm" => $parm));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
function isMD5($str) {
|
|
if(preg_match("/^[0-9a-f]{32}$/", $str))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
function isUNID($str) {
|
|
return $this->isMD5($str);
|
|
}
|
|
|
|
function isDateFT($str) {
|
|
if(preg_match("/^(20[0-9]{2}-[01][0-9]-[0-3][0-9]) ([0-2][0-9]:[0-5][0-9]:[0-5][0-9])$/", $str))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
function isP7Phone($str) {
|
|
if(preg_match("/^\+7(9[0-9]{2})([0-9]{7})$/", $str))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
function isPxPhone($str) {
|
|
if(preg_match("/^\+7(9[0-9]{2})([0-9]+)$/", $str)) {
|
|
return true;
|
|
}
|
|
|
|
if(preg_match("/^\+([0-9]+)$/", $str)) {
|
|
$this->d("Wild number $str");
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function normalizePhone($inp) {
|
|
if(preg_match("/^((\+7)|8)?(\d{3})(\d{7,8})$/", $inp, $m)) {
|
|
return "+7" . $m[3] . $m[4];
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function isINN($inn) {
|
|
$inn = (string) $inn;
|
|
|
|
if(!preg_match("/^[0-9]{10,12}$/", $inn)) {
|
|
return null;
|
|
}
|
|
|
|
switch(strlen($inn)) {
|
|
case 10:
|
|
$n = 0;
|
|
|
|
foreach([2, 4, 10, 3, 5, 9, 4, 6, 8] as $i => $k) {
|
|
$n += $k * (int) $inn[$i];
|
|
}
|
|
|
|
$n10 = $n % 11 % 10;
|
|
|
|
if($n10 === (int) $inn[9])
|
|
return true;
|
|
|
|
return false;
|
|
|
|
case 12:
|
|
$n = 0;
|
|
|
|
foreach([7, 2, 4, 10, 3, 5, 9, 4, 6, 8] as $i => $k) {
|
|
$n += $k * (int) $inn[$i];
|
|
}
|
|
|
|
$n11 = $n % 11 % 10;
|
|
|
|
$n = 0;
|
|
|
|
foreach([3, 7, 2, 4, 10, 3, 5, 9, 4, 6, 8] as $i => $k) {
|
|
$n += $k * (int) $inn[$i];
|
|
}
|
|
|
|
$n12 = $n % 11 % 10;
|
|
|
|
if(($n11 === (int) $inn[10]) && ($n12 === (int) $inn[11]))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function isSnils($snils) {
|
|
$snils = (string) $snils;
|
|
|
|
if(!preg_match("/^[0-9]{11}$/", $snils)) {
|
|
return null;
|
|
}
|
|
|
|
$sum = 0;
|
|
|
|
for($i = 0; $i < 9; $i++) {
|
|
$sum += (int) $snils[$i] * (9 - $i);
|
|
}
|
|
|
|
$cs = 0;
|
|
|
|
if ($sum < 100) {
|
|
$cs = $sum;
|
|
} elseif ($sum > 101) {
|
|
$cs = $sum % 101;
|
|
if ($cs === 100) {
|
|
$cs = 0;
|
|
}
|
|
}
|
|
|
|
if($cs === (int) substr($snils, -2)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// END
|
|
}
|
|
|
|
?>
|