Sms::__callStatic() - Code Metrics - Inspection of "Merge pull request #47 from toplan/dev" - toplan/phpsms - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c73d62...76a557 )

by lan tian

created 2016-04-15 09:48 UTC

Sms::__callStatic() B

↳ Parent: Sms

Complexity

Conditions	8
Paths	80

Size

Total Lines	19
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	14
CRAP Score	8.125

Importance

Changes	7
Bugs	2	Features	1

Metric	Value
c	7
b	2
f	1
dl	0
loc	19
ccs	14
cts	16
cp	0.875
rs	7.7777
cc	8
eloc	15
nc	80
nop	2
crap	8.125

<?php

namespace Toplan\PhpSms;

use SuperClosure\Serializer;
use Toplan\TaskBalance\Balancer;

/**
 * Class Sms
 */
class Sms
{
    /**
     * sms send task name
     */
    const TASK = 'PhpSms';

    /**
     * agents instance
     */
    protected static $agents = [];

    /**
     * agents`s name
     *
     * @var
     */
    protected static $agentsName = [];

    /**
     * agents`s config
     *
     * @var
     */
    protected static $agentsConfig = [];

    /**
     * whether to enable queue
     *
     * @var bool
     */
    protected static $enableQueue = false;

    /**
     * queue work
     *
     * @var \Closure
     */
    protected static $howToUseQueue = null;

    /**
     * sms already pushed to queue
     *
     * @var bool
     */
    protected $pushedToQueue = false;

    /**
     * hook handlers
     *
     * @var array
     */
    protected static $enableHooks = [
        'beforeRun',
        'beforeDriverRun',
        'afterDriverRun',
        'afterRun',
    ];

    /**
     * sms data
     *
     * @var array
     */
    protected $smsData = [
        'to'           => null,
        'templates'    => [],
        'content'      => '',
        'templateData' => [],
        'voiceCode'    => null,
    ];

    /**
     * first agent for send sms/voice verify
     *
     * @var string
     */
    protected $firstAgent = null;

    /**
     * a instance of class 'SuperClosure\Serializer'
     *
     * @var Serializer
     */
    protected static $serializer = null;

    /**
     * store the static properties of Sms class when serialize a instance
     *
     * @var array
     */
    protected $_status_before_enqueue_ = [];

    /**
     * construct
     *
     * @param bool $autoBoot
     */
    public function __construct($autoBoot = true)
    {
        if ($autoBoot) {
            self::bootstrap();
        }
    }

    /**
     * create sms instance and set templates
     *
     * @param mixed $agentName
     * @param mixed $tempId
     *
     * @return Sms
     */
    public static function make($agentName = null, $tempId = null)
    {
        $sms = new self();
        if (is_array($agentName)) {
            $sms->template($agentName);
        } elseif ($agentName && is_string($agentName)) {
            if ($tempId === null) {
                $sms->content($agentName);
            } elseif (is_string("$tempId")) {
                $sms->template($agentName, $tempId);
            }
        }

        return $sms;
    }

    /**
     * send voice verify
     *
     * @param $code
     *
     * @return Sms
     */
    public static function voice($code)
    {
        $sms = new self();
        $sms->smsData['voiceCode'] = $code;

        return $sms;
    }

    /**
     * set how to use queue.
     *
     * @param $enable
     * @param $handler
     *
     * @return bool
     */
    public static function queue($enable = null, $handler = null)
    {
        if ($enable === null && $handler === null) {
            return self::$enableQueue;
        }
        if (is_callable($enable)) {
            $handler = $enable;
            $enable = true;
        }
        self::$enableQueue = (bool) $enable;
        if (is_callable($handler)) {
            self::$howToUseQueue = $handler;

        }

        return self::$enableQueue;
    }

    /**
     * set the mobile number
     *
     * @param $mobile
     *
     * @return $this
     */
    public function to($mobile)
    {
        $this->smsData['to'] = $mobile;

        return $this;
    }

    /**
     * set content for content sms
     *
     * @param $content
     *
     * @return $this
     */
    public function content($content)
    {
        $this->smsData['content'] = trim((string) $content);

        return $this;
    }

    /**
     * set template id for template sms
     *
     * @param $agentName
     * @param $tempId
     *
     * @return $this
     */
    public function template($agentName, $tempId = null)
    {
        if (is_array($agentName)) {
            foreach ($agentName as $k => $v) {
                $this->template($k, $v);
            }
        } elseif ($agentName && $tempId) {
            if (!isset($this->smsData['templates']) || !is_array($this->smsData['templates'])) {
                $this->smsData['templates'] = [];
            }
            $this->smsData['templates']["$agentName"] = $tempId;
        }

        return $this;
    }

    /**
     * set data for template sms
     *
     * @param array $data
     *
     * @return $this
     */
    public function data(array $data)
    {
        $this->smsData['templateData'] = $data;

        return $this;
    }

    /**
     * set the first agent
     *
     * @param $name
     *
     * @return $this
     */
    public function agent($name)
    {
        $this->firstAgent = (string) $name;

        return $this;
    }

    /**
     * start send
     *
     * @param bool $immediately
     *
     * @return mixed
     */
    public function send($immediately = false)
    {
        $this->validator();

        // if disable push to queue,
        // send the sms immediately.
        if (!self::$enableQueue) {
            $immediately = true;
        }

        // whatever 'PhpSms' whether to enable or disable push to queue,
        // if you are already pushed sms instance to queue,
        // you can recall the method `send()` in queue job without `true` parameter.
        //
        // So this mechanism in order to make you convenient use the method `send()` in queue system.
        if ($this->pushedToQueue) {
            $immediately = true;
        }

        // whether to send sms immediately,
        // or push it to queue.
        if ($immediately) {
            $result = Balancer::run(self::TASK, [
                'data'   => $this->getData(),
                'driver' => $this->firstAgent,
            ]);
        } else {
            $result = $this->push();
        }

        return $result;
    }

    /**
     * push sms send task to queue
     *
     * @throws \Exception | PhpSmsException
     *
     * @return mixed
     */
    protected function push()
    {
        if (is_callable(self::$howToUseQueue)) {
            try {
                $this->pushedToQueue = true;

                return call_user_func_array(self::$howToUseQueue, [$this, $this->smsData]);
            } catch (\Exception $e) {
                $this->pushedToQueue = false;
                throw $e;
            }
        } else {
            throw new PhpSmsException('Please define how to use queue by method `queue($enable, $handler)`');
        }
    }

    /**
     * get sms data
     *
     * @return array
     */
    public function getData()
    {
        return $this->smsData;
    }

    /**
     * bootstrap
     *
     * @param bool $force
     */
    public static function bootstrap($force = false)
    {
        if ((bool) $force) {
            Balancer::destroy(self::TASK);
        }
        $task = self::generatorTask();
        if (!count($task->drivers)) {
            self::configuration();
            self::createDrivers($task);
        }
    }

    /**
     * generator a sms send task
     *
     * @return object
     */
    public static function generatorTask()
    {
        if (!Balancer::hasTask(self::TASK)) {
            Balancer::task(self::TASK);
        }

        return Balancer::getTask(self::TASK);
    }

    /**
     * configuration
     */
    protected static function configuration()
    {
        $config = [];
        self::generatorAgentsName($config);
        self::generatorAgentsConfig($config);
        self::configValidator();
    }

    /**
     * generate enabled agents name
     *
     * @param array $config
     */
    protected static function generatorAgentsName(&$config)
    {
        if (empty(self::$agentsName)) {
            $config = $config ?: include __DIR__ . '/../config/phpsms.php';
            $enableAgents = isset($config['enable']) ? $config['enable'] : null;
            self::enable($enableAgents);
        }
    }

    /**
     * generator agents config
     *
     * @param array $config
     */
    protected static function generatorAgentsConfig(&$config)
    {
        $diff = array_diff_key(self::$agentsName, self::$agentsConfig);
        $diff = array_keys($diff);
        if (count($diff)) {
            $config = $config ?: include __DIR__ . '/../config/phpsms.php';
            $agentsConfig = isset($config['agents']) ? $config['agents'] : [];
            foreach ($diff as $name) {
                $agentConfig = isset($agentsConfig[$name]) ? $agentsConfig[$name] : [];
                self::agents($name, $agentConfig);
            }
        }
    }

    /**
     * config value validator
     *
     * @throws PhpSmsException
     */
    protected static function configValidator()
    {
        if (!count(self::$agentsName)) {
            throw new PhpSmsException('Please set at least one enable agent in config file(config/phpsms.php) or use method enable()');
        }
    }

    /**
     * create drivers for sms send task
     *
     * @param $task
     */
    protected static function createDrivers($task)
    {
        foreach (self::$agentsName as $name => $options) {
            //获取代理器配置
            $configData = self::getAgentConfigData($name);
            //解析代理器数组模式的调度配置
            if (is_array($options)) {
                $data = self::parseAgentArrayOptions($options);
                $configData = array_merge($configData, $data);
                $options = $data['driverOpts'];
            }
            //创建任务驱动器
            $task->driver("$name $options")->data($configData)
                 ->work(function ($driver) {
                     $configData = $driver->getDriverData();
                     $agent = self::getSmsAgent($driver->name, $configData);
                     $smsData = $driver->getTaskData();
                     extract($smsData);
                     if (isset($smsData['voiceCode']) && $smsData['voiceCode']) {
                         $agent->voiceVerify($to, $voiceCode);
                     } else {
                         $template = isset($templates[$driver->name]) ? $templates[$driver->name] : 0;
                         $agent->sendSms($template, $to, $templateData, $content);
                     }
                     $result = $agent->result();
                     if ($result['success']) {
                         $driver->success();
                     }
                     unset($result['success']);

                     return $result;
                 });
        }
    }

    /**
     * 解析可用代理器的数组模式的调度配置
     *
     * @param array $options
     *
     * @return array
     */
    protected static function parseAgentArrayOptions(array $options)
    {
        $agentClass = self::pullAgentOptionByName($options, 'agentClass');
        $sendSms = self::pullAgentOptionByName($options, 'sendSms');
        $voiceVerify = self::pullAgentOptionByName($options, 'voiceVerify');
        $backup = self::pullAgentOptionByName($options, 'backup');
        $driverOpts = implode(' ', array_values($options)) . " $backup";

        return compact('agentClass', 'sendSms', 'voiceVerify', 'driverOpts');
    }

    /**
     * 从调度配置中拉取指定数据
     *
     * @param array  $options
     * @param string $name
     *
     * @return null|string
     */
    protected static function pullAgentOptionByName(array &$options, $name)
    {
        $value = isset($options[$name]) ? $options[$name] : null;
        if ($name === 'backup') {
            $value = isset($options[$name]) ? ($options[$name] ? 'backup' : '') : '';
        }
        unset($options[$name]);

        return $value;
    }

    /**
     * get agent config data by name
     *
     * @param $name
     *
     * @return array
     */
    protected static function getAgentConfigData($name)
    {
        return isset(self::$agentsConfig[$name]) ?
               (array) self::$agentsConfig[$name] : [];
    }

    /**
     * get a sms agent instance,
     * if null, will create a new agent instance
     *
     * @param       $name
     * @param array $configData
     *
     * @throws PhpSmsException
     *
     * @return mixed
     */
    public static function getSmsAgent($name, array $configData)
    {
        if (!isset(self::$agents[$name])) {
            $configData['name'] = $name;
            $className = isset($configData['agentClass']) ? $configData['agentClass'] : ('Toplan\\PhpSms\\' . $name . 'Agent');
            if ((isset($configData['sendSms']) && is_callable($configData['sendSms'])) ||
                (isset($configData['voiceVerify']) && is_callable($configData['voiceVerify']))) {
                //创建寄生代理器
                $configData['agentClass'] = '';
                self::$agents[$name] = new ParasiticAgent($configData);
            } elseif (class_exists($className)) {
                //创建新代理器
                self::$agents[$name] = new $className($configData);
            } else {
                //无代理器可用
                throw new PhpSmsException("Do not support [$name] agent.");
            }
        }

        return self::$agents[$name];
    }

    /**
     * validate
     *
     * @throws PhpSmsException
     */
    protected function validator()
    {
        if (!$this->smsData['to']) {
            throw new PhpSmsException('Please set send sms(or voice verify) to who use `to()` method.');
        }

        return true;
    }

    /**
     * set enable agents
     *
     * @param      $agentName
     * @param null $options
     */
    public static function enable($agentName, $options = null)
    {
        if (is_array($agentName)) {
            foreach ($agentName as $name => $opt) {
                self::enable($name, $opt);
            }
        } elseif ($agentName && is_string($agentName) && $options !== null) {
            self::$agentsName["$agentName"] = is_array($options) ? $options : "$options";
        } elseif (is_int($agentName) && !is_array($options) && "$options") {
            self::$agentsName["$options"] = '1';
        } elseif ($agentName && $options === null) {
            self::$agentsName["$agentName"] = '1';
        }
    }

    /**
     * set config for available agents
     *
     * @param       $agentName
     * @param array $config
     *
     * @throws PhpSmsException
     */
    public static function agents($agentName, array $config = [])
    {
        if (is_array($agentName)) {
            foreach ($agentName as $name => $conf) {
                self::agents($name, $conf);
            }
        } elseif ($agentName && is_array($config)) {
            if (preg_match('/^[0-9]+$/', $agentName)) {
                throw new PhpSmsException("Agent name [$agentName] must be string, could not be a pure digital");
            }
            self::$agentsConfig["$agentName"] = $config;
        }
    }

    /**
     * get enable agents
     *
     * @return array
     */
    public static function getEnableAgents()
    {
        return self::$agentsName;
    }

    /**
     * get agents config info
     *
     * @return array
     */
    public static function getAgentsConfig()
    {
        return self::$agentsConfig;
    }

    /**
     * tear down enable agents
     */
    public static function cleanEnableAgents()
    {
        self::$agentsName = [];
    }

    /**
     * tear down agents config
     */
    public static function cleanAgentsConfig()
    {
        self::$agentsConfig = [];
    }

    /**
     * overload static method
     *
     * @param $name
     * @param $args
     *
     * @throws PhpSmsException
     */
    public static function __callStatic($name, $args)
    {
        $name = $name === 'beforeSend' ? 'beforeRun' : $name;
        $name = $name === 'afterSend' ? 'afterRun' : $name;
        $name = $name === 'beforeAgentSend' ? 'beforeDriverRun' : $name;
        $name = $name === 'afterAgentSend' ? 'afterDriverRun' : $name;
        if (in_array($name, self::$enableHooks)) {
            $handler = $args[0];
            $override = isset($args[1]) ? (bool) $args[1] : false;
            if (is_callable($handler)) {
                $task = self::generatorTask();
                $task->hook($name, $handler, $override);
            } else {
                throw new PhpSmsException("Please give method static $name() a callable parameter");
            }
        } else {
            throw new PhpSmsException("Do not find static method $name()");
        }
    }

    /**
     * overload method
     *
     * @param $name
     * @param $args
     *
     * @throws PhpSmsException
     * @throws \Exception
     */
    public function __call($name, $args)
    {
        try {
            $this->__callStatic($name, $args);
        } catch (\Exception $e) {
            throw $e;
        }
    }

    /**
     * serialize magic method
     * store current sms instance status
     *
     * @return array
     */
    public function __sleep()
    {
        if (self::needSerializeStatusWhenSleep()) {
            $this->_status_before_enqueue_['enableAgents'] = self::serializeEnableAgents();
            $this->_status_before_enqueue_['agentsConfig'] = self::getAgentsConfig();
            $this->_status_before_enqueue_['handlers'] = self::serializeHandlers();
        }

        return ['pushedToQueue', 'smsData', 'firstAgent', '_status_before_enqueue_'];
    }

    /**
     * unserialize magic method
     * note: the force bootstrap must before reinstall handlers!
     */
    public function __wakeup()
    {
        if (!self::needSerializeStatusWhenSleep()) {
            return;
        }
        $status = $this->_status_before_enqueue_;
        self::$agentsName = self::unserializeEnableAgents($status['enableAgents']);
        self::$agentsConfig = $status['agentsConfig'];
        self::bootstrap(true);
        self::reinstallHandlers($status['handlers']);
    }

    /**
     * whether to need to serialize status when call sleep
     *
     * @return bool
     */
    public static function needSerializeStatusWhenSleep()
    {
        if (CheckFramework::is('laravel')) {
            return config('queue.default') !== 'sync';
        }

        return true;
    }

    /**
     * get a serializer
     *
     * @return Serializer
     */
    public static function getSerializer()
    {
        if (!self::$serializer) {
            self::$serializer = new Serializer();
        }

        return self::$serializer;
    }

    /**
     * serialize enable agents
     *
     * @return array
     */
    protected static function serializeEnableAgents()
    {
        $enableAgents = self::getEnableAgents();
        foreach ($enableAgents as $name => &$options) {
            if (is_array($options)) {
                self::serializeClosureAndReplace($options, 'sendSms');
                self::serializeClosureAndReplace($options, 'voiceVerify');
            }
        }

        return $enableAgents;
    }

    /**
     * unserialize enable agents
     *
     * @param array $serialized
     *
     * @return mixed
     */
    protected static function unserializeEnableAgents(array $serialized)
    {
        foreach ($serialized as $name => &$options) {
            if (is_array($options)) {
                self::unserializeToClosureAndReplace($options, 'sendSms');
                self::unserializeToClosureAndReplace($options, 'voiceVerify');
            }
        }

        return $serialized;
    }

    /**
     * serialize character closure value of a array and replace origin value
     *
     * @param array $options
     * @param       $key
     */
    protected static function serializeClosureAndReplace(array &$options, $key)
    {
        if (isset($options["$key"]) && is_callable($options["$key"])) {
            $serializer = self::getSerializer();
            $options["$key"] = (string) $serializer->serialize($options["$key"]);
        }
    }

    /**
     * unserialize character string of a array to closure and replace origin value
     *
     * @param array $options
     * @param       $key
     */
    protected static function unserializeToClosureAndReplace(array &$options, $key)
    {
        if (isset($options["$key"])) {
            $serializer = self::getSerializer();
            $options["$key"] = $serializer->unserialize($options["$key"]);
        }
    }

    /**
     * serialize these hooks` handlers:
     * 'beforeRun','beforeDriverRun','afterDriverRun','afterRun'
     *
     * @return array
     */
    protected static function serializeHandlers()
    {
        $hooks = [];
        $serializer = self::getSerializer();
        $task = self::generatorTask();
        foreach ($task->handlers as $hookName => $handlers) {
            foreach ($handlers as $handler) {
                $serialized = $serializer->serialize($handler);
                if (!isset($hooks[$hookName])) {
                    $hooks[$hookName] = [];
                }
                array_push($hooks[$hookName], $serialized);
            }
        }

        return $hooks;
    }

    /**
     * reinstall hooks` handlers by serialized handlers
     *
     * @param array $handlers
     */
    protected static function reinstallHandlers(array $handlers)
    {
        $serializer = self::getSerializer();
        foreach ($handlers as $hookName => $serializedHandlers) {
            foreach ($serializedHandlers as $index => $handler) {
                if (is_string($handler)) {
                    $handler = $serializer->unserialize($handler);
                }
                $override = $index === 0;
                self::$hookName($handler, $override);
            }
        }
    }
}


1		<?php
2
3		namespace Toplan\PhpSms;
4
5		use SuperClosure\Serializer;
6		use Toplan\TaskBalance\Balancer;
7
8		/**
9		* Class Sms
10		*/
11		class Sms
12		{
13		/**
14		* sms send task name
15		*/
16		const TASK = 'PhpSms';
17
18		/**
19		* agents instance
20		*/
21		protected static $agents = [];
22
23		/**
24		* agents`s name
25		*
26		* @var
27		*/
28		protected static $agentsName = [];
29
30		/**
31		* agents`s config
32		*
33		* @var
34		*/
35		protected static $agentsConfig = [];
36
37		/**
38		* whether to enable queue
39		*
40		* @var bool
41		*/
42		protected static $enableQueue = false;
43
44		/**
45		* queue work
46		*
47		* @var \Closure
48		*/
49		protected static $howToUseQueue = null;
50
51		/**
52		* sms already pushed to queue
53		*
54		* @var bool
55		*/
56		protected $pushedToQueue = false;
57
58		/**
59		* hook handlers
60		*
61		* @var array
62		*/
63		protected static $enableHooks = [
64		'beforeRun',
65		'beforeDriverRun',
66		'afterDriverRun',
67		'afterRun',
68		];
69
70		/**
71		* sms data
72		*
73		* @var array
74		*/
75		protected $smsData = [
76		'to' => null,
77		'templates' => [],
78		'content' => '',
79		'templateData' => [],
80		'voiceCode' => null,
81		];
82
83		/**
84		* first agent for send sms/voice verify
85		*
86		* @var string
87		*/
88		protected $firstAgent = null;
89
90		/**
91		* a instance of class 'SuperClosure\Serializer'
92		*
93		* @var Serializer
94		*/
95		protected static $serializer = null;
96
97		/**
98		* store the static properties of Sms class when serialize a instance
99		*
100		* @var array
101		*/
102		protected $_status_before_enqueue_ = [];
103
104		/**
105		* construct
106		*
107		* @param bool $autoBoot
108		*/
109	9	public function __construct($autoBoot = true)
110		{
111	9	if ($autoBoot) {
112	9	self::bootstrap();
113	9	}
114	9	}
115
116		/**
117		* create sms instance and set templates
118		*
119		* @param mixed $agentName
120		* @param mixed $tempId
121		*
122		* @return Sms
123		*/
124	3	public static function make($agentName = null, $tempId = null)
125		{
126	3	$sms = new self();
127	3	if (is_array($agentName)) {
128		$sms->template($agentName);
129	3	} elseif ($agentName && is_string($agentName)) {
130		if ($tempId === null) {
131		$sms->content($agentName);
132		} elseif (is_string("$tempId")) {
133		$sms->template($agentName, $tempId);
134		}
135		}
136
137	3	return $sms;
138		}
139
140		/**
141		* send voice verify
142		*
143		* @param $code
144		*
145		* @return Sms
146		*/
147	3	public static function voice($code)
148		{
149	3	$sms = new self();
150	3	$sms->smsData['voiceCode'] = $code;
151
152	3	return $sms;
153		}
154
155		/**
156		* set how to use queue.
157		*
158		* @param $enable
159		* @param $handler
160		*
161		* @return bool
162		*/
163	3	public static function queue($enable = null, $handler = null)
164		{
165	3	if ($enable === null && $handler === null) {
166	3	return self::$enableQueue;
167		}
168	3	if (is_callable($enable)) {
169	3	$handler = $enable;
170	3	$enable = true;
171	3	}
172	3	self::$enableQueue = (bool) $enable;
173	3	if (is_callable($handler)) {
174	3	self::$howToUseQueue = $handler;
		0 ignored issues – show Documentation Bug introduced 2015-12-30 10:17 UTC by Report Bug Copy Issue Report It seems like `$handler` of type `callable` is incompatible with the declared type `object<Closure>` of property `$howToUseQueue`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
175	3	}
176
177	3	return self::$enableQueue;
178		}
179
180		/**
181		* set the mobile number
182		*
183		* @param $mobile
184		*
185		* @return $this
186		*/
187	6	public function to($mobile)
188		{
189	6	$this->smsData['to'] = $mobile;
190
191	6	return $this;
192		}
193
194		/**
195		* set content for content sms
196		*
197		* @param $content
198		*
199		* @return $this
200		*/
201	3	public function content($content)
202		{
203	3	$this->smsData['content'] = trim((string) $content);
204
205	3	return $this;
206		}
207
208		/**
209		* set template id for template sms
210		*
211		* @param $agentName
212		* @param $tempId
213		*
214		* @return $this
215		*/
216	3	public function template($agentName, $tempId = null)
217		{
218	3	if (is_array($agentName)) {
219	3	foreach ($agentName as $k => $v) {
220	3	$this->template($k, $v);
221	3	}
222	3	} elseif ($agentName && $tempId) {
223	3	if (!isset($this->smsData['templates']) \|\| !is_array($this->smsData['templates'])) {
224		$this->smsData['templates'] = [];
225		}
226	3	$this->smsData['templates']["$agentName"] = $tempId;
227	3	}
228
229	3	return $this;
230		}
231
232		/**
233		* set data for template sms
234		*
235		* @param array $data
236		*
237		* @return $this
238		*/
239	3	public function data(array $data)
240		{
241	3	$this->smsData['templateData'] = $data;
242
243	3	return $this;
244		}
245
246		/**
247		* set the first agent
248		*
249		* @param $name
250		*
251		* @return $this
252		*/
253	3	public function agent($name)
254		{
255	3	$this->firstAgent = (string) $name;
256
257	3	return $this;
258		}
259
260		/**
261		* start send
262		*
263		* @param bool $immediately
264		*
265		* @return mixed
266		*/
267	18	public function send($immediately = false)
268		{
269	18	$this->validator();
270
271		// if disable push to queue,
272		// send the sms immediately.
273	18	if (!self::$enableQueue) {
274	15	$immediately = true;
275	15	}
276
277		// whatever 'PhpSms' whether to enable or disable push to queue,
278		// if you are already pushed sms instance to queue,
279		// you can recall the method `send()` in queue job without `true` parameter.
280		//
281		// So this mechanism in order to make you convenient use the method `send()` in queue system.
282	18	if ($this->pushedToQueue) {
283	3	$immediately = true;
284	3	}
285
286		// whether to send sms immediately,
287		// or push it to queue.
288	18	if ($immediately) {
289	18	$result = Balancer::run(self::TASK, [
290	18	'data' => $this->getData(),
291	18	'driver' => $this->firstAgent,
292	18	]);
293	18	} else {
294	3	$result = $this->push();
295		}
296
297	18	return $result;
298		}
299
300		/**
301		* push sms send task to queue
302		*
303		* @throws \Exception \| PhpSmsException
304		*
305		* @return mixed
306		*/
307	3	protected function push()
308		{
309	3	if (is_callable(self::$howToUseQueue)) {
310		try {
311	3	$this->pushedToQueue = true;
312
313	3	return call_user_func_array(self::$howToUseQueue, [$this, $this->smsData]);
314		} catch (\Exception $e) {
315		$this->pushedToQueue = false;
316		throw $e;
317		}
318		} else {
319		throw new PhpSmsException('Please define how to use queue by method `queue($enable, $handler)`');
320		}
321		}
322
323		/**
324		* get sms data
325		*
326		* @return array
327		*/
328	36	public function getData()
329		{
330	36	return $this->smsData;
331		}
332
333		/**
334		* bootstrap
335		*
336		* @param bool $force
337		*/
338	12	public static function bootstrap($force = false)
339		{
340	12	if ((bool) $force) {
341	3	Balancer::destroy(self::TASK);
342	3	}
343	12	$task = self::generatorTask();
344	12	if (!count($task->drivers)) {
345	6	self::configuration();
346	6	self::createDrivers($task);
347	6	}
348	12	}
349
350		/**
351		* generator a sms send task
352		*
353		* @return object
354		*/
355	21	public static function generatorTask()
356		{
357	21	if (!Balancer::hasTask(self::TASK)) {
358	6	Balancer::task(self::TASK);
359	6	}
360
361	21	return Balancer::getTask(self::TASK);
362		}
363
364		/**
365		* configuration
366		*/
367	6	protected static function configuration()
368		{
369	6	$config = [];
370	6	self::generatorAgentsName($config);
371	6	self::generatorAgentsConfig($config);
372	6	self::configValidator();
373	6	}
374
375		/**
376		* generate enabled agents name
377		*
378		* @param array $config
379		*/
380	6	protected static function generatorAgentsName(&$config)
381		{
382	6	if (empty(self::$agentsName)) {
383	3	$config = $config ?: include __DIR__ . '/../config/phpsms.php';
384	3	$enableAgents = isset($config['enable']) ? $config['enable'] : null;
385	3	self::enable($enableAgents);
386	3	}
387	6	}
388
389		/**
390		* generator agents config
391		*
392		* @param array $config
393		*/
394	6	protected static function generatorAgentsConfig(&$config)
395		{
396	6	$diff = array_diff_key(self::$agentsName, self::$agentsConfig);
397	6	$diff = array_keys($diff);
398	6	if (count($diff)) {
399	6	$config = $config ?: include __DIR__ . '/../config/phpsms.php';
400	6	$agentsConfig = isset($config['agents']) ? $config['agents'] : [];
401	6	foreach ($diff as $name) {
402	6	$agentConfig = isset($agentsConfig[$name]) ? $agentsConfig[$name] : [];
403	6	self::agents($name, $agentConfig);
404	6	}
405	6	}
406	6	}
407
408		/**
409		* config value validator
410		*
411		* @throws PhpSmsException
412		*/
413	6	protected static function configValidator()
414		{
415	6	if (!count(self::$agentsName)) {
416		throw new PhpSmsException('Please set at least one enable agent in config file(config/phpsms.php) or use method enable()');
417		}
418	6	}
419
420		/**
421		* create drivers for sms send task
422		*
423		* @param $task
424		*/
425	18	protected static function createDrivers($task)
426		{
427	6	foreach (self::$agentsName as $name => $options) {
428		//获取代理器配置
429	6	$configData = self::getAgentConfigData($name);
430		//解析代理器数组模式的调度配置
431	6	if (is_array($options)) {
432	3	$data = self::parseAgentArrayOptions($options);
433	3	$configData = array_merge($configData, $data);
434	3	$options = $data['driverOpts'];
435	3	}
436		//创建任务驱动器
437	6	$task->driver("$name $options")->data($configData)
438	18	->work(function ($driver) {
439	18	$configData = $driver->getDriverData();
440	18	$agent = self::getSmsAgent($driver->name, $configData);
441	18	$smsData = $driver->getTaskData();
442	18	extract($smsData);
443	18	if (isset($smsData['voiceCode']) && $smsData['voiceCode']) {
444		$agent->voiceVerify($to, $voiceCode);
445		} else {
446	18	$template = isset($templates[$driver->name]) ? $templates[$driver->name] : 0;
447	18	$agent->sendSms($template, $to, $templateData, $content);
448		}
449	18	$result = $agent->result();
450	18	if ($result['success']) {
451	18	$driver->success();
452	18	}
453	18	unset($result['success']);
454
455	18	return $result;
456	6	});
457	6	}
458	6	}
459
460		/**
461		* 解析可用代理器的数组模式的调度配置
462		*
463		* @param array $options
464		*
465		* @return array
466		*/
467	3	protected static function parseAgentArrayOptions(array $options)
468		{
469	3	$agentClass = self::pullAgentOptionByName($options, 'agentClass');
470	3	$sendSms = self::pullAgentOptionByName($options, 'sendSms');
471	3	$voiceVerify = self::pullAgentOptionByName($options, 'voiceVerify');
472	3	$backup = self::pullAgentOptionByName($options, 'backup');
473	3	$driverOpts = implode(' ', array_values($options)) . " $backup";
474
475	3	return compact('agentClass', 'sendSms', 'voiceVerify', 'driverOpts');
476		}
477
478		/**
479		* 从调度配置中拉取指定数据
480		*
481		* @param array $options
482		* @param string $name
483		*
484		* @return null\|string
485		*/
486	3	protected static function pullAgentOptionByName(array &$options, $name)
487		{
488	3	$value = isset($options[$name]) ? $options[$name] : null;
489	3	if ($name === 'backup') {
490	3	$value = isset($options[$name]) ? ($options[$name] ? 'backup' : '') : '';
491	3	}
492	3	unset($options[$name]);
493
494	3	return $value;
495		}
496
497		/**
498		* get agent config data by name
499		*
500		* @param $name
501		*
502		* @return array
503		*/
504	6	protected static function getAgentConfigData($name)
505		{
506	6	return isset(self::$agentsConfig[$name]) ?
507	6	(array) self::$agentsConfig[$name] : [];
508		}
509
510		/**
511		* get a sms agent instance,
512		* if null, will create a new agent instance
513		*
514		* @param $name
515		* @param array $configData
516		*
517		* @throws PhpSmsException
518		*
519		* @return mixed
520		*/
521	21	public static function getSmsAgent($name, array $configData)
522		{
523	21	if (!isset(self::$agents[$name])) {
524	6	$configData['name'] = $name;
525	6	$className = isset($configData['agentClass']) ? $configData['agentClass'] : ('Toplan\\PhpSms\\' . $name . 'Agent');
526	6	if ((isset($configData['sendSms']) && is_callable($configData['sendSms'])) \|\|
527	6	(isset($configData['voiceVerify']) && is_callable($configData['voiceVerify']))) {
528		//创建寄生代理器
529	3	$configData['agentClass'] = '';
530	3	self::$agents[$name] = new ParasiticAgent($configData);
531	6	} elseif (class_exists($className)) {
532		//创建新代理器
533	3	self::$agents[$name] = new $className($configData);
534	3	} else {
535		//无代理器可用
536		throw new PhpSmsException("Do not support [$name] agent.");
537		}
538	6	}
539
540	21	return self::$agents[$name];
541		}
542
543		/**
544		* validate
545		*
546		* @throws PhpSmsException
547		*/
548	21	protected function validator()
549		{
550	21	if (!$this->smsData['to']) {
551		throw new PhpSmsException('Please set send sms(or voice verify) to who use `to()` method.');
552		}
553
554	21	return true;
555		}
556
557		/**
558		* set enable agents
559		*
560		* @param $agentName
561		* @param null $options
562		*/
563	6	public static function enable($agentName, $options = null)
564		{
565	6	if (is_array($agentName)) {
566	6	foreach ($agentName as $name => $opt) {
567	6	self::enable($name, $opt);
568	6	}
569	6	} elseif ($agentName && is_string($agentName) && $options !== null) {
570	3	self::$agentsName["$agentName"] = is_array($options) ? $options : "$options";
571	6	} elseif (is_int($agentName) && !is_array($options) && "$options") {
572	3	self::$agentsName["$options"] = '1';
573	6	} elseif ($agentName && $options === null) {
574	3	self::$agentsName["$agentName"] = '1';
575	3	}
576	6	}
577
578		/**
579		* set config for available agents
580		*
581		* @param $agentName
582		* @param array $config
583		*
584		* @throws PhpSmsException
585		*/
586	9	public static function agents($agentName, array $config = [])
587		{
588	9	if (is_array($agentName)) {
589	3	foreach ($agentName as $name => $conf) {
590	3	self::agents($name, $conf);
591	3	}
592	9	} elseif ($agentName && is_array($config)) {
593	9	if (preg_match('/^[0-9]+$/', $agentName)) {
594		throw new PhpSmsException("Agent name [$agentName] must be string, could not be a pure digital");
595		}
596	9	self::$agentsConfig["$agentName"] = $config;
597	9	}
598	9	}
599
600		/**
601		* get enable agents
602		*
603		* @return array
604		*/
605	12	public static function getEnableAgents()
606		{
607	12	return self::$agentsName;
608		}
609
610		/**
611		* get agents config info
612		*
613		* @return array
614		*/
615	12	public static function getAgentsConfig()
616		{
617	12	return self::$agentsConfig;
618		}
619
620		/**
621		* tear down enable agents
622		*/
623	6	public static function cleanEnableAgents()
624		{
625	6	self::$agentsName = [];
626	6	}
627
628		/**
629		* tear down agents config
630		*/
631	3	public static function cleanAgentsConfig()
632		{
633	3	self::$agentsConfig = [];
634	3	}
635
636		/**
637		* overload static method
638		*
639		* @param $name
640		* @param $args
641		*
642		* @throws PhpSmsException
643		*/
644	9	public static function __callStatic($name, $args)
645		{
646	9	$name = $name === 'beforeSend' ? 'beforeRun' : $name;
647	9	$name = $name === 'afterSend' ? 'afterRun' : $name;
648	9	$name = $name === 'beforeAgentSend' ? 'beforeDriverRun' : $name;
649	9	$name = $name === 'afterAgentSend' ? 'afterDriverRun' : $name;
650	9	if (in_array($name, self::$enableHooks)) {
651	9	$handler = $args[0];
652	9	$override = isset($args[1]) ? (bool) $args[1] : false;
653	9	if (is_callable($handler)) {
654	9	$task = self::generatorTask();
655	9	$task->hook($name, $handler, $override);
656	9	} else {
657		throw new PhpSmsException("Please give method static $name() a callable parameter");
658		}
659	9	} else {
660		throw new PhpSmsException("Do not find static method $name()");
661		}
662	9	}
663
664		/**
665		* overload method
666		*
667		* @param $name
668		* @param $args
669		*
670		* @throws PhpSmsException
671		* @throws \Exception
672		*/
673	3	public function __call($name, $args)
674		{
675		try {
676	3	$this->__callStatic($name, $args);
677	3	} catch (\Exception $e) {
678		throw $e;
679		}
680	3	}
681
682		/**
683		* serialize magic method
684		* store current sms instance status
685		*
686		* @return array
687		*/
688	3	public function __sleep()
689		{
690	3	if (self::needSerializeStatusWhenSleep()) {
691	3	$this->_status_before_enqueue_['enableAgents'] = self::serializeEnableAgents();
692	3	$this->_status_before_enqueue_['agentsConfig'] = self::getAgentsConfig();
693	3	$this->_status_before_enqueue_['handlers'] = self::serializeHandlers();
694	3	}
695
696	3	return ['pushedToQueue', 'smsData', 'firstAgent', '_status_before_enqueue_'];
697		}
698
699		/**
700		* unserialize magic method
701		* note: the force bootstrap must before reinstall handlers!
702		*/
703	3	public function __wakeup()
704		{
705	3	if (!self::needSerializeStatusWhenSleep()) {
706		return;
707		}
708	3	$status = $this->_status_before_enqueue_;
709	3	self::$agentsName = self::unserializeEnableAgents($status['enableAgents']);
710	3	self::$agentsConfig = $status['agentsConfig'];
711	3	self::bootstrap(true);
712	3	self::reinstallHandlers($status['handlers']);
713	3	}
714
715		/**
716		* whether to need to serialize status when call sleep
717		*
718		* @return bool
719		*/
720	3	public static function needSerializeStatusWhenSleep()
721		{
722	3	if (CheckFramework::is('laravel')) {
723		return config('queue.default') !== 'sync';
724		}
725
726	3	return true;
727		}
728
729		/**
730		* get a serializer
731		*
732		* @return Serializer
733		*/
734	3	public static function getSerializer()
735		{
736	3	if (!self::$serializer) {
737	3	self::$serializer = new Serializer();
738	3	}
739
740	3	return self::$serializer;
741		}
742
743		/**
744		* serialize enable agents
745		*
746		* @return array
747		*/
748	3	protected static function serializeEnableAgents()
749		{
750	3	$enableAgents = self::getEnableAgents();
751	3	foreach ($enableAgents as $name => &$options) {
752	3	if (is_array($options)) {
753	3	self::serializeClosureAndReplace($options, 'sendSms');
754	3	self::serializeClosureAndReplace($options, 'voiceVerify');
755	3	}
756	3	}
757
758	3	return $enableAgents;
759		}
760
761		/**
762		* unserialize enable agents
763		*
764		* @param array $serialized
765		*
766		* @return mixed
767		*/
768	3	protected static function unserializeEnableAgents(array $serialized)
769		{
770	3	foreach ($serialized as $name => &$options) {
771	3	if (is_array($options)) {
772	3	self::unserializeToClosureAndReplace($options, 'sendSms');
773	3	self::unserializeToClosureAndReplace($options, 'voiceVerify');
774	3	}
775	3	}
776
777	3	return $serialized;
778		}
779
780		/**
781		* serialize character closure value of a array and replace origin value
782		*
783		* @param array $options
784		* @param $key
785		*/
786	3	protected static function serializeClosureAndReplace(array &$options, $key)
787		{
788	3	if (isset($options["$key"]) && is_callable($options["$key"])) {
789	3	$serializer = self::getSerializer();
790	3	$options["$key"] = (string) $serializer->serialize($options["$key"]);
791	3	}
792	3	}
793
794		/**
795		* unserialize character string of a array to closure and replace origin value
796		*
797		* @param array $options
798		* @param $key
799		*/
800	3	protected static function unserializeToClosureAndReplace(array &$options, $key)
801		{
802	3	if (isset($options["$key"])) {
803	3	$serializer = self::getSerializer();
804	3	$options["$key"] = $serializer->unserialize($options["$key"]);
805	3	}
806	3	}
807
808		/**
809		* serialize these hooks` handlers:
810		* 'beforeRun','beforeDriverRun','afterDriverRun','afterRun'
811		*
812		* @return array
813		*/
814	3	protected static function serializeHandlers()
815		{
816	3	$hooks = [];
817	3	$serializer = self::getSerializer();
818	3	$task = self::generatorTask();
819	3	foreach ($task->handlers as $hookName => $handlers) {
820	3	foreach ($handlers as $handler) {
821	3	$serialized = $serializer->serialize($handler);
822	3	if (!isset($hooks[$hookName])) {
823	3	$hooks[$hookName] = [];
824	3	}
825	3	array_push($hooks[$hookName], $serialized);
826	3	}
827	3	}
828
829	3	return $hooks;
830		}
831
832		/**
833		* reinstall hooks` handlers by serialized handlers
834		*
835		* @param array $handlers
836		*/
837	3	protected static function reinstallHandlers(array $handlers)
838		{
839	3	$serializer = self::getSerializer();
840	3	foreach ($handlers as $hookName => $serializedHandlers) {
841	3	foreach ($serializedHandlers as $index => $handler) {
842	3	if (is_string($handler)) {
843	3	$handler = $serializer->unserialize($handler);
844	3	}
845	3	$override = $index === 0;
846	3	self::$hookName($handler, $override);
847	3	}
848	3	}
849	3	}
850		}
851

toplan / phpsms

Push — master ( c73d62...76a557 )

Sms::__callStatic() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like