Mike
5 years ago
committed by
weigang
weigang
14 changed files with 1161 additions and 2 deletions
-
6Envoy.blade.php
-
28app/Controller/ParamsTokenController.php
-
52app/Controller/TestController.php
-
622app/Libs/SimpleSSDB.php
-
11app/Service/ParamsTokenServiceInterface.php
-
17app/Service/ParamsTokenSsdbService.php
-
39app/TaskWorker/SSDBTask.php
-
6composer.json
-
1config/autoload/dependencies.php
-
4config/autoload/server.php
-
16config/autoload/translation.php
-
7config/routes.php
-
177storage/languages/en/validation.php
-
177storage/languages/zh_CN/validation.php
@ -0,0 +1,28 @@ |
|||
<?php |
|||
|
|||
|
|||
namespace App\Controller; |
|||
|
|||
use App\Service\ParamsTokenServiceInterface; |
|||
use Hyperf\Di\Annotation\Inject; |
|||
|
|||
class ParamsTokenController extends BaseController |
|||
{ |
|||
/** |
|||
* @Inject |
|||
* @var ParamsTokenServiceInterface |
|||
*/ |
|||
protected $paramsTokenService; |
|||
|
|||
public function generate() |
|||
{ |
|||
$res = $this->paramsTokenService->generate($this->request->all()); |
|||
return $this->success($res); |
|||
} |
|||
|
|||
public function analyze() |
|||
{ |
|||
$res = $this->paramsTokenService->analyze($this->request->input('token')); |
|||
return $this->success($res); |
|||
} |
|||
} |
|||
@ -0,0 +1,52 @@ |
|||
<?php |
|||
|
|||
declare(strict_types=1); |
|||
namespace App\Controller; |
|||
|
|||
|
|||
use Hyperf\HttpServer\Contract\RequestInterface; |
|||
use Hyperf\HttpServer\Annotation\AutoController; |
|||
use Hyperf\Utils\Coroutine; |
|||
use Hyperf\Utils\ApplicationContext; |
|||
use Hyperf\Task\TaskExecutor; |
|||
use Hyperf\Task\Task; |
|||
use App\TaskWorker\SSDBTask; |
|||
|
|||
/** |
|||
* @AutoController() |
|||
* Class TestController |
|||
* @package App\Controller |
|||
*/ |
|||
class TestController extends AbstractController |
|||
{ |
|||
private $name = 'default action'; |
|||
|
|||
|
|||
public function index1(RequestInterface $request) |
|||
{ |
|||
// $container = ApplicationContext::getContainer();
|
|||
// $exec = $container->get(TaskExecutor::class);
|
|||
// $result = $exec->execute(new Task([MethodTask::class, 'handle'], [Coroutine::id()]));
|
|||
|
|||
$client = ApplicationContext::getContainer()->get(SSDBTask::class); |
|||
$result = $client->exec("set","bar","1234"); |
|||
$result = $client->exec("get","bar"); |
|||
|
|||
// $client = ApplicationContext::getContainer()->get(MethodTask::class);
|
|||
// $result = $client->handle("set");
|
|||
|
|||
$this->name = 'index1 action '. $result; |
|||
return $this->name; |
|||
} |
|||
|
|||
public function index2(RequestInterface $request) |
|||
{ |
|||
$this->name = 'index2 action'; |
|||
return $this->name; |
|||
} |
|||
|
|||
public function index3(RequestInterface $request) |
|||
{ |
|||
return $this->name; |
|||
} |
|||
} |
|||
@ -0,0 +1,622 @@ |
|||
<?php |
|||
/** |
|||
* Copyright (c) 2012, ideawu |
|||
* All rights reserved. |
|||
* @author: ideawu |
|||
* @link: http://www.ideawu.com/ |
|||
* |
|||
* SSDB PHP client SDK. |
|||
*/ |
|||
|
|||
namespace App\Libs; |
|||
use Exception; |
|||
|
|||
|
|||
class SSDBException extends Exception |
|||
{ |
|||
} |
|||
|
|||
class SSDBTimeoutException extends SSDBException |
|||
{ |
|||
} |
|||
|
|||
/** |
|||
* All methods(except *exists) returns false on error, |
|||
* so one should use Identical(if($ret === false)) to test the return value. |
|||
*/ |
|||
class SimpleSSDB extends SSDB |
|||
{ |
|||
function __construct($host, $port, $timeout_ms=2000){ |
|||
parent::__construct($host, $port, $timeout_ms); |
|||
$this->easy(); |
|||
} |
|||
} |
|||
|
|||
class SSDB_Response |
|||
{ |
|||
public $cmd; |
|||
public $code; |
|||
public $data = null; |
|||
public $message; |
|||
|
|||
function __construct($code='ok', $data_or_message=null){ |
|||
$this->code = $code; |
|||
if($code == 'ok'){ |
|||
$this->data = $data_or_message; |
|||
}else{ |
|||
$this->message = $data_or_message; |
|||
} |
|||
} |
|||
|
|||
function __toString(){ |
|||
if($this->code == 'ok'){ |
|||
$s = $this->data === null? '' : json_encode($this->data); |
|||
}else{ |
|||
$s = $this->message; |
|||
} |
|||
return sprintf('%-13s %12s %s', $this->cmd, $this->code, $s); |
|||
} |
|||
|
|||
function ok(){ |
|||
return $this->code == 'ok'; |
|||
} |
|||
|
|||
function not_found(){ |
|||
return $this->code == 'not_found'; |
|||
} |
|||
} |
|||
|
|||
// Depricated, use SimpleSSDB instead!
|
|||
class SSDB |
|||
{ |
|||
private $debug = false; |
|||
public $sock = null; |
|||
private $_closed = false; |
|||
private $recv_buf = ''; |
|||
private $_easy = false; |
|||
public $last_resp = null; |
|||
|
|||
function __construct($host, $port, $timeout_ms=2000){ |
|||
$timeout_f = (float)$timeout_ms/1000; |
|||
$this->sock = @stream_socket_client("[$host]:$port", $errno, $errstr, $timeout_f); |
|||
if(!$this->sock){ |
|||
throw new SSDBException("$errno: $errstr"); |
|||
} |
|||
$timeout_sec = intval($timeout_ms/1000); |
|||
$timeout_usec = ($timeout_ms - $timeout_sec * 1000) * 1000; |
|||
@stream_set_timeout($this->sock, $timeout_sec, $timeout_usec); |
|||
if(function_exists('stream_set_chunk_size')){ |
|||
@stream_set_chunk_size($this->sock, 1024 * 1024); |
|||
} |
|||
} |
|||
|
|||
function set_timeout($timeout_ms){ |
|||
$timeout_sec = intval($timeout_ms/1000); |
|||
$timeout_usec = ($timeout_ms - $timeout_sec * 1000) * 1000; |
|||
@stream_set_timeout($this->sock, $timeout_sec, $timeout_usec); |
|||
} |
|||
|
|||
/** |
|||
* After this method invoked with yesno=true, all requesting methods |
|||
* will not return a SSDB_Response object. |
|||
* And some certain methods like get/zget will return false |
|||
* when response is not ok(not_found, etc) |
|||
*/ |
|||
function easy(){ |
|||
$this->_easy = true; |
|||
} |
|||
|
|||
function close(){ |
|||
if(!$this->_closed){ |
|||
@fclose($this->sock); |
|||
$this->_closed = true; |
|||
$this->sock = null; |
|||
} |
|||
} |
|||
|
|||
function closed(){ |
|||
return $this->_closed; |
|||
} |
|||
|
|||
private $batch_mode = false; |
|||
private $batch_cmds = array(); |
|||
|
|||
function batch(){ |
|||
$this->batch_mode = true; |
|||
$this->batch_cmds = array(); |
|||
return $this; |
|||
} |
|||
|
|||
function multi(){ |
|||
return $this->batch(); |
|||
} |
|||
|
|||
function exec(){ |
|||
$ret = array(); |
|||
foreach($this->batch_cmds as $op){ |
|||
list($cmd, $params) = $op; |
|||
$this->send_req($cmd, $params); |
|||
} |
|||
foreach($this->batch_cmds as $op){ |
|||
list($cmd, $params) = $op; |
|||
$resp = $this->recv_resp($cmd, $params); |
|||
$resp = $this->check_easy_resp($cmd, $resp); |
|||
$ret[] = $resp; |
|||
} |
|||
$this->batch_mode = false; |
|||
$this->batch_cmds = array(); |
|||
return $ret; |
|||
} |
|||
|
|||
function request(){ |
|||
$args = func_get_args(); |
|||
$cmd = array_shift($args); |
|||
return $this->__call($cmd, $args); |
|||
} |
|||
|
|||
private $async_auth_password = null; |
|||
|
|||
function auth($password){ |
|||
$this->async_auth_password = $password; |
|||
return null; |
|||
} |
|||
|
|||
function __call($cmd, $params=array()){ |
|||
$cmd = strtolower($cmd); |
|||
if($this->async_auth_password !== null){ |
|||
$pass = $this->async_auth_password; |
|||
$this->async_auth_password = null; |
|||
$auth = $this->__call('auth', array($pass)); |
|||
if($auth !== true){ |
|||
throw new Exception("Authentication failed"); |
|||
} |
|||
} |
|||
|
|||
if($this->batch_mode){ |
|||
$this->batch_cmds[] = array($cmd, $params); |
|||
return $this; |
|||
} |
|||
|
|||
try{ |
|||
if($this->send_req($cmd, $params) === false){ |
|||
$resp = new SSDB_Response('error', 'send error'); |
|||
}else{ |
|||
$resp = $this->recv_resp($cmd, $params); |
|||
} |
|||
}catch(SSDBException $e){ |
|||
if($this->_easy){ |
|||
throw $e; |
|||
}else{ |
|||
$resp = new SSDB_Response('error', $e->getMessage()); |
|||
} |
|||
} |
|||
|
|||
if($resp->code == 'noauth'){ |
|||
$msg = $resp->message; |
|||
throw new Exception($msg); |
|||
} |
|||
|
|||
$resp = $this->check_easy_resp($cmd, $resp); |
|||
return $resp; |
|||
} |
|||
|
|||
private function check_easy_resp($cmd, $resp){ |
|||
$this->last_resp = $resp; |
|||
if($this->_easy){ |
|||
if($resp->not_found()){ |
|||
return NULL; |
|||
}else if(!$resp->ok() && !is_array($resp->data)){ |
|||
return false; |
|||
}else{ |
|||
return $resp->data; |
|||
} |
|||
}else{ |
|||
$resp->cmd = $cmd; |
|||
return $resp; |
|||
} |
|||
} |
|||
|
|||
function multi_set($kvs=array()){ |
|||
$args = array(); |
|||
foreach($kvs as $k=>$v){ |
|||
$args[] = $k; |
|||
$args[] = $v; |
|||
} |
|||
return $this->__call(__FUNCTION__, $args); |
|||
} |
|||
|
|||
function multi_hset($name, $kvs=array()){ |
|||
$args = array($name); |
|||
foreach($kvs as $k=>$v){ |
|||
$args[] = $k; |
|||
$args[] = $v; |
|||
} |
|||
return $this->__call(__FUNCTION__, $args); |
|||
} |
|||
|
|||
function multi_zset($name, $kvs=array()){ |
|||
$args = array($name); |
|||
foreach($kvs as $k=>$v){ |
|||
$args[] = $k; |
|||
$args[] = $v; |
|||
} |
|||
return $this->__call(__FUNCTION__, $args); |
|||
} |
|||
|
|||
function incr($key, $val=1){ |
|||
$args = func_get_args(); |
|||
return $this->__call(__FUNCTION__, $args); |
|||
} |
|||
|
|||
function decr($key, $val=1){ |
|||
$args = func_get_args(); |
|||
return $this->__call(__FUNCTION__, $args); |
|||
} |
|||
|
|||
function zincr($name, $key, $score=1){ |
|||
$args = func_get_args(); |
|||
return $this->__call(__FUNCTION__, $args); |
|||
} |
|||
|
|||
function zdecr($name, $key, $score=1){ |
|||
$args = func_get_args(); |
|||
return $this->__call(__FUNCTION__, $args); |
|||
} |
|||
|
|||
function zadd($key, $score, $value){ |
|||
$args = array($key, $value, $score); |
|||
return $this->__call('zset', $args); |
|||
} |
|||
|
|||
function zRevRank($name, $key){ |
|||
$args = func_get_args(); |
|||
return $this->__call("zrrank", $args); |
|||
} |
|||
|
|||
function zRevRange($name, $offset, $limit){ |
|||
$args = func_get_args(); |
|||
return $this->__call("zrrange", $args); |
|||
} |
|||
|
|||
function hincr($name, $key, $val=1){ |
|||
$args = func_get_args(); |
|||
return $this->__call(__FUNCTION__, $args); |
|||
} |
|||
|
|||
function hdecr($name, $key, $val=1){ |
|||
$args = func_get_args(); |
|||
return $this->__call(__FUNCTION__, $args); |
|||
} |
|||
|
|||
private function send_req($cmd, $params){ |
|||
$req = array($cmd); |
|||
foreach($params as $p){ |
|||
if(is_array($p)){ |
|||
$req = array_merge($req, $p); |
|||
}else{ |
|||
$req[] = $p; |
|||
} |
|||
} |
|||
return $this->send($req); |
|||
} |
|||
|
|||
private function recv_resp($cmd, $params){ |
|||
$resp = $this->recv(); |
|||
if($resp === false){ |
|||
return new SSDB_Response('error', 'Unknown error'); |
|||
}else if(!$resp){ |
|||
return new SSDB_Response('disconnected', 'Connection closed'); |
|||
} |
|||
if($resp[0] == 'noauth'){ |
|||
$errmsg = isset($resp[1])? $resp[1] : ''; |
|||
return new SSDB_Response($resp[0], $errmsg); |
|||
} |
|||
switch($cmd){ |
|||
case 'dbsize': |
|||
case 'ping': |
|||
case 'qset': |
|||
case 'getbit': |
|||
case 'setbit': |
|||
case 'countbit': |
|||
case 'strlen': |
|||
case 'set': |
|||
case 'setx': |
|||
case 'setnx': |
|||
case 'zset': |
|||
case 'hset': |
|||
case 'qpush': |
|||
case 'qpush_front': |
|||
case 'qpush_back': |
|||
case 'qtrim_front': |
|||
case 'qtrim_back': |
|||
case 'del': |
|||
case 'zdel': |
|||
case 'hdel': |
|||
case 'hsize': |
|||
case 'zsize': |
|||
case 'qsize': |
|||
case 'hclear': |
|||
case 'zclear': |
|||
case 'qclear': |
|||
case 'multi_set': |
|||
case 'multi_del': |
|||
case 'multi_hset': |
|||
case 'multi_hdel': |
|||
case 'multi_zset': |
|||
case 'multi_zdel': |
|||
case 'incr': |
|||
case 'decr': |
|||
case 'zincr': |
|||
case 'zdecr': |
|||
case 'hincr': |
|||
case 'hdecr': |
|||
case 'zget': |
|||
case 'zrank': |
|||
case 'zrrank': |
|||
case 'zcount': |
|||
case 'zsum': |
|||
case 'zremrangebyrank': |
|||
case 'zremrangebyscore': |
|||
case 'ttl': |
|||
case 'expire': |
|||
if($resp[0] == 'ok'){ |
|||
$val = isset($resp[1])? intval($resp[1]) : 0; |
|||
return new SSDB_Response($resp[0], $val); |
|||
}else{ |
|||
$errmsg = isset($resp[1])? $resp[1] : ''; |
|||
return new SSDB_Response($resp[0], $errmsg); |
|||
} |
|||
case 'zavg': |
|||
if($resp[0] == 'ok'){ |
|||
$val = isset($resp[1])? floatval($resp[1]) : (float)0; |
|||
return new SSDB_Response($resp[0], $val); |
|||
}else{ |
|||
$errmsg = isset($resp[1])? $resp[1] : ''; |
|||
return new SSDB_Response($resp[0], $errmsg); |
|||
} |
|||
case 'get': |
|||
case 'substr': |
|||
case 'getset': |
|||
case 'hget': |
|||
case 'qget': |
|||
case 'qfront': |
|||
case 'qback': |
|||
if($resp[0] == 'ok'){ |
|||
if(count($resp) == 2){ |
|||
return new SSDB_Response('ok', $resp[1]); |
|||
}else{ |
|||
return new SSDB_Response('server_error', 'Invalid response'); |
|||
} |
|||
}else{ |
|||
$errmsg = isset($resp[1])? $resp[1] : ''; |
|||
return new SSDB_Response($resp[0], $errmsg); |
|||
} |
|||
break; |
|||
case 'qpop': |
|||
case 'qpop_front': |
|||
case 'qpop_back': |
|||
if($resp[0] == 'ok'){ |
|||
$size = 1; |
|||
if(isset($params[1])){ |
|||
$size = intval($params[1]); |
|||
} |
|||
if($size <= 1){ |
|||
if(count($resp) == 2){ |
|||
return new SSDB_Response('ok', $resp[1]); |
|||
}else{ |
|||
return new SSDB_Response('server_error', 'Invalid response'); |
|||
} |
|||
}else{ |
|||
$data = array_slice($resp, 1); |
|||
return new SSDB_Response('ok', $data); |
|||
} |
|||
}else{ |
|||
$errmsg = isset($resp[1])? $resp[1] : ''; |
|||
return new SSDB_Response($resp[0], $errmsg); |
|||
} |
|||
break; |
|||
case 'keys': |
|||
case 'zkeys': |
|||
case 'hkeys': |
|||
case 'hlist': |
|||
case 'zlist': |
|||
case 'qslice': |
|||
if($resp[0] == 'ok'){ |
|||
$data = array(); |
|||
if($resp[0] == 'ok'){ |
|||
$data = array_slice($resp, 1); |
|||
} |
|||
return new SSDB_Response($resp[0], $data); |
|||
}else{ |
|||
$errmsg = isset($resp[1])? $resp[1] : ''; |
|||
return new SSDB_Response($resp[0], $errmsg); |
|||
} |
|||
case 'auth': |
|||
case 'exists': |
|||
case 'hexists': |
|||
case 'zexists': |
|||
if($resp[0] == 'ok'){ |
|||
if(count($resp) == 2){ |
|||
return new SSDB_Response('ok', (bool)$resp[1]); |
|||
}else{ |
|||
return new SSDB_Response('server_error', 'Invalid response'); |
|||
} |
|||
}else{ |
|||
$errmsg = isset($resp[1])? $resp[1] : ''; |
|||
return new SSDB_Response($resp[0], $errmsg); |
|||
} |
|||
break; |
|||
case 'multi_exists': |
|||
case 'multi_hexists': |
|||
case 'multi_zexists': |
|||
if($resp[0] == 'ok'){ |
|||
if(count($resp) % 2 == 1){ |
|||
$data = array(); |
|||
for($i=1; $i<count($resp); $i+=2){ |
|||
$data[$resp[$i]] = (bool)$resp[$i + 1]; |
|||
} |
|||
return new SSDB_Response('ok', $data); |
|||
}else{ |
|||
return new SSDB_Response('server_error', 'Invalid response'); |
|||
} |
|||
}else{ |
|||
$errmsg = isset($resp[1])? $resp[1] : ''; |
|||
return new SSDB_Response($resp[0], $errmsg); |
|||
} |
|||
break; |
|||
case 'scan': |
|||
case 'rscan': |
|||
case 'zscan': |
|||
case 'zrscan': |
|||
case 'zrange': |
|||
case 'zrrange': |
|||
case 'hscan': |
|||
case 'hrscan': |
|||
case 'hgetall': |
|||
case 'multi_hsize': |
|||
case 'multi_zsize': |
|||
case 'multi_get': |
|||
case 'multi_hget': |
|||
case 'multi_zget': |
|||
case 'zpop_front': |
|||
case 'zpop_back': |
|||
if($resp[0] == 'ok'){ |
|||
if(count($resp) % 2 == 1){ |
|||
$data = array(); |
|||
for($i=1; $i<count($resp); $i+=2){ |
|||
if($cmd[0] == 'z'){ |
|||
$data[$resp[$i]] = intval($resp[$i + 1]); |
|||
}else{ |
|||
$data[$resp[$i]] = $resp[$i + 1]; |
|||
} |
|||
} |
|||
return new SSDB_Response('ok', $data); |
|||
}else{ |
|||
return new SSDB_Response('server_error', 'Invalid response'); |
|||
} |
|||
}else{ |
|||
$errmsg = isset($resp[1])? $resp[1] : ''; |
|||
return new SSDB_Response($resp[0], $errmsg); |
|||
} |
|||
break; |
|||
default: |
|||
return new SSDB_Response($resp[0], array_slice($resp, 1)); |
|||
} |
|||
return new SSDB_Response('error', 'Unknown command: $cmd'); |
|||
} |
|||
|
|||
function send($data){ |
|||
$ps = array(); |
|||
foreach($data as $p){ |
|||
$ps[] = strlen($p); |
|||
$ps[] = $p; |
|||
} |
|||
$s = join("\n", $ps) . "\n\n"; |
|||
if($this->debug){ |
|||
echo '> ' . str_replace(array("\r", "\n"), array('\r', '\n'), $s) . "\n"; |
|||
} |
|||
try{ |
|||
while(true){ |
|||
$ret = @fwrite($this->sock, $s); |
|||
if($ret === false || $ret === 0){ |
|||
$this->close(); |
|||
throw new SSDBException('Connection lost'); |
|||
} |
|||
$s = substr($s, $ret); |
|||
if(strlen($s) == 0){ |
|||
break; |
|||
} |
|||
@fflush($this->sock); |
|||
} |
|||
}catch(Exception $e){ |
|||
$this->close(); |
|||
throw new SSDBException($e->getMessage()); |
|||
} |
|||
return $ret; |
|||
} |
|||
|
|||
function recv(){ |
|||
$this->step = self::STEP_SIZE; |
|||
while(true){ |
|||
$ret = $this->parse(); |
|||
if($ret === null){ |
|||
try{ |
|||
$data = @fread($this->sock, 1024 * 1024); |
|||
if($this->debug){ |
|||
echo '< ' . str_replace(array("\r", "\n"), array('\r', '\n'), $data) . "\n"; |
|||
} |
|||
}catch(Exception $e){ |
|||
$data = ''; |
|||
} |
|||
if($data === false || $data === ''){ |
|||
if(feof($this->sock)){ |
|||
$this->close(); |
|||
throw new SSDBException('Connection lost'); |
|||
}else{ |
|||
throw new SSDBTimeoutException('Connection timeout'); |
|||
} |
|||
} |
|||
$this->recv_buf .= $data; |
|||
# echo "read " . strlen($data) . " total: " . strlen($this->recv_buf) . "\n";
|
|||
}else{ |
|||
return $ret; |
|||
} |
|||
} |
|||
} |
|||
|
|||
const STEP_SIZE = 0; |
|||
const STEP_DATA = 1; |
|||
public $resp = array(); |
|||
public $step; |
|||
public $block_size; |
|||
|
|||
private function parse(){ |
|||
$spos = 0; |
|||
$epos = 0; |
|||
$buf_size = strlen($this->recv_buf); |
|||
// performance issue for large reponse
|
|||
//$this->recv_buf = ltrim($this->recv_buf);
|
|||
while(true){ |
|||
$spos = $epos; |
|||
if($this->step === self::STEP_SIZE){ |
|||
$epos = strpos($this->recv_buf, "\n", $spos); |
|||
if($epos === false){ |
|||
break; |
|||
} |
|||
$epos += 1; |
|||
$line = substr($this->recv_buf, $spos, $epos - $spos); |
|||
$spos = $epos; |
|||
|
|||
$line = trim($line); |
|||
if(strlen($line) == 0){ // head end
|
|||
$this->recv_buf = substr($this->recv_buf, $spos); |
|||
$ret = $this->resp; |
|||
$this->resp = array(); |
|||
return $ret; |
|||
} |
|||
$this->block_size = intval($line); |
|||
$this->step = self::STEP_DATA; |
|||
} |
|||
if($this->step === self::STEP_DATA){ |
|||
$epos = $spos + $this->block_size; |
|||
if($epos <= $buf_size){ |
|||
$n = strpos($this->recv_buf, "\n", $epos); |
|||
if($n !== false){ |
|||
$data = substr($this->recv_buf, $spos, $epos - $spos); |
|||
$this->resp[] = $data; |
|||
$epos = $n + 1; |
|||
$this->step = self::STEP_SIZE; |
|||
continue; |
|||
} |
|||
} |
|||
break; |
|||
} |
|||
} |
|||
|
|||
// packet not ready
|
|||
if($spos > 0){ |
|||
$this->recv_buf = substr($this->recv_buf, $spos); |
|||
} |
|||
return null; |
|||
} |
|||
} |
|||
@ -0,0 +1,11 @@ |
|||
<?php |
|||
|
|||
|
|||
namespace App\Service; |
|||
|
|||
|
|||
interface ParamsTokenServiceInterface |
|||
{ |
|||
public function generate($params); |
|||
public function analyze($token); |
|||
} |
|||
@ -0,0 +1,17 @@ |
|||
<?php |
|||
|
|||
namespace App\Service; |
|||
|
|||
class ParamsTokenSsdbService implements ParamsTokenServiceInterface |
|||
{ |
|||
|
|||
public function generate($params) |
|||
{ |
|||
return 'token_123456'; |
|||
} |
|||
|
|||
public function analyze($token) |
|||
{ |
|||
return ['page' => 'zh_cjdianc/pages/couponrebate/index', 'previous_id' => 211, 'is_expired' => 2]; |
|||
} |
|||
} |
|||
@ -0,0 +1,39 @@ |
|||
<?php |
|||
declare(strict_types=1); |
|||
namespace App\TaskWorker; |
|||
|
|||
use Hyperf\Utils\ApplicationContext; |
|||
use App\Libs\SimpleSSDB; |
|||
use Hyperf\Task\Annotation\Task; |
|||
|
|||
class SSDBTask |
|||
{ |
|||
/** |
|||
* @var SimpleSSDB |
|||
*/ |
|||
public $ss = null; |
|||
|
|||
|
|||
/** |
|||
* @Task |
|||
*/ |
|||
public function exec($method,...$args) |
|||
{ |
|||
$result = $this->client()->__call($method,$args); |
|||
|
|||
return $result; |
|||
} |
|||
|
|||
protected function client(){ |
|||
if ($this->ss instanceof SimpleSSDB) { |
|||
return $this->ss; |
|||
} |
|||
|
|||
$this->ss = new SimpleSSDB(env('SSDB_HOST'), env('SSDB_PORT')); |
|||
$this->ss->auth(env('SSDB_AUTH')); |
|||
|
|||
return $this->ss; |
|||
|
|||
} |
|||
} |
|||
|
|||
@ -0,0 +1,16 @@ |
|||
<?php |
|||
|
|||
declare(strict_types=1); |
|||
/** |
|||
* This file is part of Hyperf. |
|||
* |
|||
* @link https://www.hyperf.io |
|||
* @document https://hyperf.wiki |
|||
* @contact group@hyperf.io |
|||
* @license https://github.com/hyperf/hyperf/blob/master/LICENSE |
|||
*/ |
|||
return [ |
|||
'locale' => 'zh_CN', |
|||
'fallback_locale' => 'en', |
|||
'path' => BASE_PATH . '/storage/languages', |
|||
]; |
|||
@ -0,0 +1,177 @@ |
|||
<?php |
|||
|
|||
declare(strict_types=1); |
|||
/** |
|||
* This file is part of Hyperf. |
|||
* |
|||
* @link https://www.hyperf.io |
|||
* @document https://hyperf.wiki |
|||
* @contact group@hyperf.io |
|||
* @license https://github.com/hyperf/hyperf/blob/master/LICENSE |
|||
*/ |
|||
return [ |
|||
/* |
|||
|-------------------------------------------------------------------------- |
|||
| Validation Language Lines |
|||
|-------------------------------------------------------------------------- |
|||
| |
|||
| The following language lines contain the default error messages used by |
|||
| the validator class. Some of these rules have multiple versions such |
|||
| as the size rules. Feel free to tweak each of these messages here. |
|||
| |
|||
*/ |
|||
|
|||
'accepted' => 'The :attribute must be accepted.', |
|||
'active_url' => 'The :attribute is not a valid URL.', |
|||
'after' => 'The :attribute must be a date after :date.', |
|||
'after_or_equal' => 'The :attribute must be a date after or equal to :date.', |
|||
'alpha' => 'The :attribute may only contain letters.', |
|||
'alpha_dash' => 'The :attribute may only contain letters, numbers, and dashes.', |
|||
'alpha_num' => 'The :attribute may only contain letters and numbers.', |
|||
'array' => 'The :attribute must be an array.', |
|||
'before' => 'The :attribute must be a date before :date.', |
|||
'before_or_equal' => 'The :attribute must be a date before or equal to :date.', |
|||
'between' => [ |
|||
'numeric' => 'The :attribute must be between :min and :max.', |
|||
'file' => 'The :attribute must be between :min and :max kilobytes.', |
|||
'string' => 'The :attribute must be between :min and :max characters.', |
|||
'array' => 'The :attribute must have between :min and :max items.', |
|||
], |
|||
'boolean' => 'The :attribute field must be true or false.', |
|||
'confirmed' => 'The :attribute confirmation does not match.', |
|||
'date' => 'The :attribute is not a valid date.', |
|||
'date_format' => 'The :attribute does not match the format :format.', |
|||
'different' => 'The :attribute and :other must be different.', |
|||
'digits' => 'The :attribute must be :digits digits.', |
|||
'digits_between' => 'The :attribute must be between :min and :max digits.', |
|||
'dimensions' => 'The :attribute has invalid image dimensions.', |
|||
'distinct' => 'The :attribute field has a duplicate value.', |
|||
'email' => 'The :attribute must be a valid email address.', |
|||
'exists' => 'The selected :attribute is invalid.', |
|||
'file' => 'The :attribute must be a file.', |
|||
'filled' => 'The :attribute field is required.', |
|||
'gt' => [ |
|||
'numeric' => 'The :attribute must be greater than :value', |
|||
'file' => 'The :attribute must be greater than :value kb', |
|||
'string' => 'The :attribute must be greater than :value characters', |
|||
'array' => 'The :attribute must be greater than :value items', |
|||
], |
|||
'gte' => [ |
|||
'numeric' => 'The :attribute must be great than or equal to :value', |
|||
'file' => 'The :attribute must be great than or equal to :value kb', |
|||
'string' => 'The :attribute must be great than or equal to :value characters', |
|||
'array' => 'The :attribute must be great than or equal to :value items', |
|||
], |
|||
'image' => 'The :attribute must be an image.', |
|||
'in' => 'The selected :attribute is invalid.', |
|||
'in_array' => 'The :attribute field does not exist in :other.', |
|||
'integer' => 'The :attribute must be an integer.', |
|||
'ip' => 'The :attribute must be a valid IP address.', |
|||
'ipv4' => 'The :attribute must be a valid IPv4 address.', |
|||
'ipv6' => 'The :attribute must be a valid IPv6 address.', |
|||
'json' => 'The :attribute must be a valid JSON string.', |
|||
'lt' => [ |
|||
'numeric' => 'The :attribute must be less than :value', |
|||
'file' => 'The :attribute must be less than :value kb', |
|||
'string' => 'The :attribute must be less than :value characters', |
|||
'array' => 'The :attribute must be less than :value items', |
|||
], |
|||
'lte' => [ |
|||
'numeric' => 'The :attribute must be less than or equal to :value', |
|||
'file' => 'The :attribute must be less than or equal to :value kb', |
|||
'string' => 'The :attribute must be less than or equal to :value characters', |
|||
'array' => 'The :attribute must be less than or equal to :value items', |
|||
], |
|||
'max' => [ |
|||
'numeric' => 'The :attribute may not be greater than :max.', |
|||
'file' => 'The :attribute may not be greater than :max kilobytes.', |
|||
'string' => 'The :attribute may not be greater than :max characters.', |
|||
'array' => 'The :attribute may not have more than :max items.', |
|||
], |
|||
'mimes' => 'The :attribute must be a file of type: :values.', |
|||
'mimetypes' => 'The :attribute must be a file of type: :values.', |
|||
'min' => [ |
|||
'numeric' => 'The :attribute must be at least :min.', |
|||
'file' => 'The :attribute must be at least :min kilobytes.', |
|||
'string' => 'The :attribute must be at least :min characters.', |
|||
'array' => 'The :attribute must have at least :min items.', |
|||
], |
|||
'not_in' => 'The selected :attribute is invalid.', |
|||
'not_regex' => 'The :attribute cannot match a given regular rule.', |
|||
'numeric' => 'The :attribute must be a number.', |
|||
'present' => 'The :attribute field must be present.', |
|||
'regex' => 'The :attribute format is invalid.', |
|||
'required' => 'The :attribute field is required.', |
|||
'required_if' => 'The :attribute field is required when :other is :value.', |
|||
'required_unless' => 'The :attribute field is required unless :other is in :values.', |
|||
'required_with' => 'The :attribute field is required when :values is present.', |
|||
'required_with_all' => 'The :attribute field is required when :values is present.', |
|||
'required_without' => 'The :attribute field is required when :values is not present.', |
|||
'required_without_all' => 'The :attribute field is required when none of :values are present.', |
|||
'same' => 'The :attribute and :other must match.', |
|||
'size' => [ |
|||
'numeric' => 'The :attribute must be :size.', |
|||
'file' => 'The :attribute must be :size kilobytes.', |
|||
'string' => 'The :attribute must be :size characters.', |
|||
'array' => 'The :attribute must contain :size items.', |
|||
], |
|||
'starts_with' => 'The :attribute must be start with :values ', |
|||
'string' => 'The :attribute must be a string.', |
|||
'timezone' => 'The :attribute must be a valid zone.', |
|||
'unique' => 'The :attribute has already been taken.', |
|||
'uploaded' => 'The :attribute failed to upload.', |
|||
'url' => 'The :attribute format is invalid.', |
|||
'uuid' => 'The :attribute is invalid UUID.', |
|||
'max_if' => [ |
|||
'numeric' => 'The :attribute may not be greater than :max when :other is :value.', |
|||
'file' => 'The :attribute may not be greater than :max kilobytes when :other is :value.', |
|||
'string' => 'The :attribute may not be greater than :max characters when :other is :value.', |
|||
'array' => 'The :attribute may not have more than :max items when :other is :value.', |
|||
], |
|||
'min_if' => [ |
|||
'numeric' => 'The :attribute must be at least :min when :other is :value.', |
|||
'file' => 'The :attribute must be at least :min kilobytes when :other is :value.', |
|||
'string' => 'The :attribute must be at least :min characters when :other is :value.', |
|||
'array' => 'The :attribute must have at least :min items when :other is :value.', |
|||
], |
|||
'between_if' => [ |
|||
'numeric' => 'The :attribute must be between :min and :max when :other is :value.', |
|||
'file' => 'The :attribute must be between :min and :max kilobytes when :other is :value.', |
|||
'string' => 'The :attribute must be between :min and :max characters when :other is :value.', |
|||
'array' => 'The :attribute must have between :min and :max items when :other is :value.', |
|||
], |
|||
/* |
|||
|-------------------------------------------------------------------------- |
|||
| Custom Validation Language Lines |
|||
|-------------------------------------------------------------------------- |
|||
| |
|||
| Here you may specify custom validation messages for attributes using the |
|||
| convention "attribute.rule" to name the lines. This makes it quick to |
|||
| specify a specific custom language line for a given attribute rule. |
|||
| |
|||
*/ |
|||
|
|||
'custom' => [ |
|||
'attribute-name' => [ |
|||
'rule-name' => 'custom-message', |
|||
], |
|||
], |
|||
|
|||
/* |
|||
|-------------------------------------------------------------------------- |
|||
| Custom Validation Attributes |
|||
|-------------------------------------------------------------------------- |
|||
| |
|||
| The following language lines are used to swap attribute place-holders |
|||
| with something more reader friendly such as E-Mail Address instead |
|||
| of "email". This simply helps us make messages a little cleaner. |
|||
| |
|||
*/ |
|||
|
|||
'attributes' => [], |
|||
'phone_number' => 'The :attribute must be a valid phone number', |
|||
'telephone_number' => 'The :attribute must be a valid telephone number', |
|||
|
|||
'chinese_word' => 'The :attribute must contain valid characters(chinese/english character, number, underscore)', |
|||
'sequential_array' => 'The :attribute must be sequential array', |
|||
]; |
|||
@ -0,0 +1,177 @@ |
|||
<?php |
|||
|
|||
declare(strict_types=1); |
|||
/** |
|||
* This file is part of Hyperf. |
|||
* |
|||
* @link https://www.hyperf.io |
|||
* @document https://hyperf.wiki |
|||
* @contact group@hyperf.io |
|||
* @license https://github.com/hyperf/hyperf/blob/master/LICENSE |
|||
*/ |
|||
return [ |
|||
/* |
|||
|-------------------------------------------------------------------------- |
|||
| Validation Language Lines |
|||
|-------------------------------------------------------------------------- |
|||
| |
|||
| The following language lines contain the default error messages used by |
|||
| the validator class. Some of these rules have multiple versions such |
|||
| as the size rules. Feel free to tweak each of these messages here. |
|||
| |
|||
*/ |
|||
|
|||
'accepted' => ':attribute 必须接受', |
|||
'active_url' => ':attribute 必须是一个合法的 URL', |
|||
'after' => ':attribute 必须是 :date 之后的一个日期', |
|||
'after_or_equal' => ':attribute 必须是 :date 之后或相同的一个日期', |
|||
'alpha' => ':attribute 只能包含字母', |
|||
'alpha_dash' => ':attribute 只能包含字母、数字、中划线或下划线', |
|||
'alpha_num' => ':attribute 只能包含字母和数字', |
|||
'array' => ':attribute 必须是一个数组', |
|||
'before' => ':attribute 必须是 :date 之前的一个日期', |
|||
'before_or_equal' => ':attribute 必须是 :date 之前或相同的一个日期', |
|||
'between' => [ |
|||
'numeric' => ':attribute 必须在 :min 到 :max 之间', |
|||
'file' => ':attribute 必须在 :min 到 :max kb 之间', |
|||
'string' => ':attribute 必须在 :min 到 :max 个字符之间', |
|||
'array' => ':attribute 必须在 :min 到 :max 项之间', |
|||
], |
|||
'boolean' => ':attribute 字符必须是 true 或 false, 1 或 0', |
|||
'confirmed' => ':attribute 二次确认不匹配', |
|||
'date' => ':attribute 必须是一个合法的日期', |
|||
'date_format' => ':attribute 与给定的格式 :format 不符合', |
|||
'different' => ':attribute 必须不同于 :other', |
|||
'digits' => ':attribute 必须是 :digits 位', |
|||
'digits_between' => ':attribute 必须在 :min 和 :max 位之间', |
|||
'dimensions' => ':attribute 具有无效的图片尺寸', |
|||
'distinct' => ':attribute 字段具有重复值', |
|||
'email' => ':attribute 必须是一个合法的电子邮件地址', |
|||
'exists' => '选定的 :attribute 是无效的', |
|||
'file' => ':attribute 必须是一个文件', |
|||
'filled' => ':attribute 的字段是必填的', |
|||
'gt' => [ |
|||
'numeric' => ':attribute 必须大于 :value', |
|||
'file' => ':attribute 必须大于 :value kb', |
|||
'string' => ':attribute 必须大于 :value 个字符', |
|||
'array' => ':attribute 必须大于 :value 项', |
|||
], |
|||
'gte' => [ |
|||
'numeric' => ':attribute 必须大于等于 :value', |
|||
'file' => ':attribute 必须大于等于 :value kb', |
|||
'string' => ':attribute 必须大于等于 :value 个字符', |
|||
'array' => ':attribute 必须大于等于 :value 项', |
|||
], |
|||
'image' => ':attribute 必须是 jpg, jpeg, png, bmp 或者 gif 格式的图片', |
|||
'in' => '选定的 :attribute 是无效的', |
|||
'in_array' => ':attribute 字段不存在于 :other', |
|||
'integer' => ':attribute 必须是个整数', |
|||
'ip' => ':attribute 必须是一个合法的 IP 地址', |
|||
'ipv4' => ':attribute 必须是一个合法的 IPv4 地址', |
|||
'ipv6' => ':attribute 必须是一个合法的 IPv6 地址', |
|||
'json' => ':attribute 必须是一个合法的 JSON 字符串', |
|||
'lt' => [ |
|||
'numeric' => ':attribute 必须小于 :value', |
|||
'file' => ':attribute 必须小于 :value kb', |
|||
'string' => ':attribute 必须小于 :value 个字符', |
|||
'array' => ':attribute 必须小于 :value 项', |
|||
], |
|||
'lte' => [ |
|||
'numeric' => ':attribute 必须小于等于 :value', |
|||
'file' => ':attribute 必须小于等于 :value kb', |
|||
'string' => ':attribute 必须小于等于 :value 个字符', |
|||
'array' => ':attribute 必须小于等于 :value 项', |
|||
], |
|||
'max' => [ |
|||
'numeric' => ':attribute 的最大值为 :max', |
|||
'file' => ':attribute 的最大为 :max kb', |
|||
'string' => ':attribute 的最大长度为 :max 字符', |
|||
'array' => ':attribute 至多有 :max 项', |
|||
], |
|||
'mimes' => ':attribute 的文件类型必须是 :values', |
|||
'mimetypes' => ':attribute 的文件MIME必须是 :values', |
|||
'min' => [ |
|||
'numeric' => ':attribute 的最小值为 :min', |
|||
'file' => ':attribute 大小至少为 :min kb', |
|||
'string' => ':attribute 的最小长度为 :min 字符', |
|||
'array' => ':attribute 至少有 :min 项', |
|||
], |
|||
'not_in' => '选定的 :attribute 是无效的', |
|||
'not_regex' => ':attribute 不能匹配给定的正则', |
|||
'numeric' => ':attribute 必须是数字', |
|||
'present' => ':attribute 字段必须存在', |
|||
'regex' => ':attribute 格式是无效的', |
|||
'required' => ':attribute 字段是必须的', |
|||
'required_if' => ':attribute 字段是必须的当 :other 是 :value', |
|||
'required_unless' => ':attribute 字段是必须的，除非 :other 是在 :values 中', |
|||
'required_with' => ':attribute 字段是必须的当 :values 是存在的', |
|||
'required_with_all' => ':attribute 字段是必须的当 :values 是存在的', |
|||
'required_without' => ':attribute 字段是必须的当 :values 是不存在的', |
|||
'required_without_all' => ':attribute 字段是必须的当 没有一个 :values 是存在的', |
|||
'same' => ':attribute 和 :other 必须匹配', |
|||
'size' => [ |
|||
'numeric' => ':attribute 必须是 :size', |
|||
'file' => ':attribute 必须是 :size kb', |
|||
'string' => ':attribute 必须是 :size 个字符', |
|||
'array' => ':attribute 必须包括 :size 项', |
|||
], |
|||
'starts_with' => ':attribute 必须以 :values 为开头', |
|||
'string' => ':attribute 必须是一个字符串', |
|||
'timezone' => ':attribute 必须是个有效的时区', |
|||
'unique' => ':attribute 已存在', |
|||
'uploaded' => ':attribute 上传失败', |
|||
'url' => ':attribute 无效的格式', |
|||
'uuid' => ':attribute 无效的UUID格式', |
|||
'max_if' => [ |
|||
'numeric' => '当 :other 为 :value 时 :attribute 不能大于 :max', |
|||
'file' => '当 :other 为 :value 时 :attribute 不能大于 :max kb', |
|||
'string' => '当 :other 为 :value 时 :attribute 不能大于 :max 个字符', |
|||
'array' => '当 :other 为 :value 时 :attribute 最多只有 :max 个单元', |
|||
], |
|||
'min_if' => [ |
|||
'numeric' => '当 :other 为 :value 时 :attribute 必须大于等于 :min', |
|||
'file' => '当 :other 为 :value 时 :attribute 大小不能小于 :min kb', |
|||
'string' => '当 :other 为 :value 时 :attribute 至少为 :min 个字符', |
|||
'array' => '当 :other 为 :value 时 :attribute 至少有 :min 个单元', |
|||
], |
|||
'between_if' => [ |
|||
'numeric' => '当 :other 为 :value 时 :attribute 必须介于 :min - :max 之间', |
|||
'file' => '当 :other 为 :value 时 :attribute 必须介于 :min - :max kb 之间', |
|||
'string' => '当 :other 为 :value 时 :attribute 必须介于 :min - :max 个字符之间', |
|||
'array' => '当 :other 为 :value 时 :attribute 必须只有 :min - :max 个单元', |
|||
], |
|||
/* |
|||
|-------------------------------------------------------------------------- |
|||
| Custom Validation Language Lines |
|||
|-------------------------------------------------------------------------- |
|||
| |
|||
| Here you may specify custom validation messages for attributes using the |
|||
| convention "attribute.rule" to name the lines. This makes it quick to |
|||
| specify a specific custom language line for a given attribute rule. |
|||
| |
|||
*/ |
|||
|
|||
'custom' => [ |
|||
'attribute-name' => [ |
|||
'rule-name' => 'custom-message', |
|||
], |
|||
], |
|||
|
|||
/* |
|||
|-------------------------------------------------------------------------- |
|||
| Custom Validation Attributes |
|||
|-------------------------------------------------------------------------- |
|||
| |
|||
| The following language lines are used to swap attribute place-holders |
|||
| with something more reader friendly such as E-Mail Address instead |
|||
| of "email". This simply helps us make messages a little cleaner. |
|||
| |
|||
*/ |
|||
|
|||
'attributes' => [], |
|||
'phone_number' => ':attribute 必须为一个有效的电话号码', |
|||
'telephone_number' => ':attribute 必须为一个有效的手机号码', |
|||
|
|||
'chinese_word' => ':attribute 必须包含以下有效字符 (中文/英文，数字, 下划线)', |
|||
'sequential_array' => ':attribute 必须是一个有序数组', |
|||
]; |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue