Toplan\PhpSms\Sms

Complexity

Total Complexity

131

Size/Duplication

Total Lines	821
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	4

Test Coverage

Coverage

82.64%

Importance

Changes	37
Bugs	8	Features	8

41 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
B	make()	0	15	6
A	voice()	0	7	1
B	queue()	0	16	5
A	to()	0	6	1
A	content()	0	6	1
B	template()	0	15	7
A	data()	0	6	1
A	agent()	0	6	1
B	send()	0	32	4
A	push()	0	15	3
A	getData()	0	4	1
A	bootstrap()	0	11	3
A	generatorTask()	0	8	2
A	configuration()	0	7	1
A	generatorAgentsName()	0	8	4
B	generatorAgentsConfig()	0	13	6
A	configValidator()	0	6	2
C	createDrivers()	0	34	7
A	parseAgentArrayOptions()	0	10	1
B	pullAgentOptionByName()	0	10	5
A	getAgentConfigData()	0	5	2
B	getSmsAgent()	0	21	8
A	validator()	0	8	2
B	enable()	0	14	12
B	agents()	0	13	6
A	getEnableAgents()	0	4	1
A	getAgentsConfig()	0	4	1
A	cleanEnableAgents()	0	4	1
A	cleanAgentsConfig()	0	4	1
B	__callStatic()	0	19	8
A	__call()	0	8	2
A	__sleep()	0	8	1
A	__wakeup()	0	8	1
A	getSerializer()	0	8	2
A	serializeEnableAgents()	0	12	3
A	unserializeEnableAgents()	0	11	3
A	serializeClosureAndReplace()	0	7	3
A	unserializeToClosureAndReplace()	0	7	2
A	serializeHandlers()	0	17	4
A	reinstallHandlers()	0	13	4

<?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;

It seems like $handler of type callable is incompatible with the declared type object<Closure> of property $howToUseQueue.

        }

        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()
    {
        $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()
    {
        $status = $this->_status_before_enqueue_;
        self::$agentsName = self::unserializeEnableAgents($status['enableAgents']);
        self::$agentsConfig = $status['agentsConfig'];
        self::bootstrap(true);
        self::reinstallHandlers($status['handlers']);
    }

    /**
     * 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);
            }
        }
    }
}