PHP CM_Params::decode方法代码示例

 /**
  * @param array[] $paramsList
  * @return mixed[]
  * @throws CM_Exception
  */
 public function runMultiple(array $paramsList)
 {
     $this->_verifyParams($paramsList);
     if (!$this->_getGearmanEnabled()) {
         return $this->_runMultipleWithoutGearman($paramsList);
     }
     $resultList = array();
     $gearmanClient = $this->_getGearmanClient();
     $gearmanClient->setCompleteCallback(function (GearmanTask $task) use(&$resultList) {
         $resultList[] = CM_Params::decode($task->data(), true);
     });
     $failureList = array();
     $gearmanClient->setFailCallback(function (GearmanTask $task) use(&$failureList) {
         $failureList[] = $task;
     });
     foreach ($paramsList as $params) {
         $workload = CM_Params::encode($params, true);
         $task = $gearmanClient->addTask($this->_getJobName(), $workload);
         if (false === $task) {
             throw new CM_Exception('Cannot add task `' . $this->_getJobName() . '`.');
         }
     }
     $gearmanClient->runTasks();
     if (count($resultList) != count($paramsList)) {
         throw new CM_Exception('Job `' . $this->_getJobName() . '` failed (' . count($resultList) . '/' . count($paramsList) . ' results).');
     }
     return $resultList;
 }

 public function queueOutstanding()
 {
     $executeAtMax = time();
     $result = CM_Db_Db::select('cm_jobdistribution_delayedqueue', '*', '`executeAt` <= ' . $executeAtMax, '`executeAt` ASC');
     while ($row = $result->fetch()) {
         $job = $this->_instantiateJob($row['className']);
         if ($job) {
             $job->queue(CM_Params::decode($row['params'], true));
         }
     }
     CM_Db_Db::delete('cm_jobdistribution_delayedqueue', '`executeAt` <= ' . $executeAtMax);
 }

 public function synchronize()
 {
     $startStampLimit = time() - 3;
     $status = array();
     foreach (CM_Stream_Video::getInstance()->getServers() as $serverId => $wowzaServer) {
         $singleStatus = CM_Params::decode($this->_fetchStatus($wowzaServer['privateIp']), true);
         foreach ($singleStatus as $streamName => $publish) {
             $publish['serverId'] = $serverId;
             $publish['serverHost'] = $wowzaServer['privateIp'];
             $status[$streamName] = $publish;
         }
     }
     $streamChannels = $this->_getStreamChannels();
     foreach ($status as $streamName => $publish) {
         /** @var CM_Model_StreamChannel_Abstract $streamChannel */
         $streamChannel = CM_Model_StreamChannel_Abstract::findByKeyAndAdapter($streamName, $this->getType());
         if (!$streamChannel || !$streamChannel->getStreamPublishs()->findKey($publish['clientId'])) {
             $this->_stopClient($publish['clientId'], $publish['serverHost']);
         }
         foreach ($publish['subscribers'] as $clientId => $subscribe) {
             if (!$streamChannel || !$streamChannel->getStreamSubscribes()->findKey($clientId)) {
                 $this->_stopClient($clientId, $publish['serverHost']);
             }
         }
     }
     /** @var CM_Model_StreamChannel_Abstract $streamChannel */
     foreach ($streamChannels as $streamChannel) {
         if (!$streamChannel->hasStreams()) {
             $streamChannel->delete();
             continue;
         }
         /** @var CM_Model_Stream_Publish $streamPublish */
         $streamPublish = $streamChannel->getStreamPublishs()->getItem(0);
         if ($streamPublish) {
             if ($streamPublish->getStart() > $startStampLimit) {
                 continue;
             }
             if (!isset($status[$streamChannel->getKey()])) {
                 $this->unpublish($streamChannel->getKey());
             }
         }
         /** @var CM_Model_Stream_Subscribe $streamSubscribe */
         foreach ($streamChannel->getStreamSubscribes() as $streamSubscribe) {
             if ($streamSubscribe->getStart() > $startStampLimit) {
                 continue;
             }
             if (!isset($status[$streamChannel->getKey()]['subscribers'][$streamSubscribe->getKey()])) {
                 $this->unsubscribe($streamChannel->getKey(), $streamSubscribe->getKey());
             }
         }
     }
 }

 public function testPublish()
 {
     $adapter = $this->mockObject('CM_MessageStream_Adapter_Abstract');
     $publishMethod = $adapter->mockMethod('publish')->set(function ($channel, $event, $data) {
         $this->assertSame('channel', $channel);
         $this->assertSame('event', $event);
         $this->assertSame(['foo' => 'bar'], CM_Params::decode($data));
     });
     /** @var CM_MessageStream_Service|\Mocka\AbstractClassTrait $stream */
     $stream = $this->mockObject('CM_MessageStream_Service', [$adapter]);
     $stream->publish('channel', 'event', ['foo' => 'bar']);
     $this->assertSame(1, $publishMethod->getCallCount());
     $stream->mockMethod('getEnabled')->set(false);
     $stream->publish('channel', 'event', ['foo' => 'bar']);
     $this->assertSame(1, $publishMethod->getCallCount());
 }

 public function testDecodeRecursive()
 {
     $object = $this->mockClass(null, ['CM_ArrayConvertible', 'JsonSerializable']);
     $nestedArrayConvertible = $this->mockClass(null, ['CM_ArrayConvertible']);
     $nestedJsonSerializable = $this->mockClass(null, ['JsonSerializable']);
     $encodedArrayConvertible = ['_class' => $nestedArrayConvertible->getClassName(), 'foo' => 2];
     $encodedJsonSerializable = ['_class' => $nestedJsonSerializable->getClassName(), 'bar' => 2];
     $encodedObject = ['_class' => $object->getClassName(), 'foo' => 1, 'nested1' => $encodedArrayConvertible, 'bar' => 1, 'nested2' => $encodedJsonSerializable];
     $fromArrayMethodObject = $object->mockStaticMethod('fromArray')->set(function ($encoded) use($encodedJsonSerializable) {
         $this->assertSame(['foo' => 1, 'nested1' => 2, 'bar' => 1, 'nested2' => $encodedJsonSerializable], $encoded);
         return [$encoded['foo'], $encoded['nested1']];
     });
     $fromArrayMethodNestedObject = $nestedArrayConvertible->mockStaticMethod('fromArray')->set(function ($encoded) {
         $this->assertSame(['foo' => 2], $encoded);
         return $encoded['foo'];
     });
     $this->assertEquals([1, 2], CM_Params::decode($encodedObject));
     $this->assertSame(1, $fromArrayMethodNestedObject->getCallCount());
     $this->assertSame(1, $fromArrayMethodObject->getCallCount());
 }

 /**
  * @param string                        $url
  * @param array|null                    $query
  * @param array|null                    $headers
  * @param CM_Frontend_ViewResponse|null $scopeView
  * @param CM_Frontend_ViewResponse|null $scopeComponent
  * @return CM_Http_Request_Post|\Mocka\AbstractClassTrait
  * @throws Mocka\Exception
  */
 public function createRequest($url, array $query = null, array $headers = null, CM_Frontend_ViewResponse $scopeView = null, CM_Frontend_ViewResponse $scopeComponent = null)
 {
     $url = (string) $url;
     $query = (array) $query;
     if (!$headers) {
         $site = CM_Site_Abstract::factory();
         $headers = array('host' => $site->getHost());
     }
     $getViewInfo = function (CM_Frontend_ViewResponse $viewResponse) {
         /**
          * Simulate sending view-params to client and back (remove any objects)
          */
         $viewParams = $viewResponse->getView()->getParams()->getParamsDecoded();
         $viewParams = CM_Params::decode(CM_Params::encode($viewParams, true), true);
         return array('id' => $viewResponse->getAutoId(), 'className' => get_class($viewResponse->getView()), 'params' => $viewParams);
     };
     $viewInfoList = array_map($getViewInfo, array_filter(['CM_View_Abstract' => $scopeView, 'CM_Component_Abstract' => $scopeComponent]));
     if ($viewInfoList) {
         $query['viewInfoList'] = $viewInfoList;
     }
     $mockClass = $this->mockClass('CM_Http_Request_Post');
     $mockClass->mockMethod('getQuery')->set(function () use($query) {
         return $query;
     });
     $mockClass->mockMethod('getIp')->set(function () {
         return '16909060';
     });
     return $mockClass->newInstance([$url, $headers]);
 }

 /**
  * @param string         $key
  * @param CM_Params|null $default
  * @return CM_Params
  * @throws CM_Exception_Invalid
  */
 public function getParams($key, CM_Params $default = null)
 {
     $param = $this->getObject($key, 'CM_Params', $default, function ($className, $param) {
         if (is_string($param)) {
             $json = (string) $param;
             try {
                 $array = CM_Params::decode($json, true);
             } catch (CM_Exception_Invalid $e) {
                 throw new CM_Exception_InvalidParam('Cannot decode input', null, ['message' => $e->getMessage()]);
             }
         } elseif (is_array($param)) {
             $array = $param;
         } else {
             throw new CM_Exception_InvalidParam('Unexpected type of arguments', null, ['type' => gettype($param)]);
         }
         return CM_Params::factory($array, false);
     });
     if (!$param instanceof CM_Params) {
         throw new CM_Exception_Invalid('Not a CM_Params');
     }
     return $param;
 }

 public function testLoadComponent()
 {
     $response = $this->getResponseAjax(new CM_Component_Graph(), 'loadComponent', ['className' => 'CM_Component_Graph', 'series' => []]);
     $this->assertViewResponseSuccess($response);
     $successContent = CM_Params::decode($response->getContent(), true)['success'];
     $autoId = $successContent['data']['autoId'];
     $this->assertNotEmpty($autoId);
     $html = new CM_Dom_NodeList($successContent['data']['html']);
     $this->assertSame($autoId, $html->getAttribute('id'));
     $this->assertArrayNotHasKey('exec', $successContent);
     $this->assertContains('new CM_Component_Graph', $successContent['data']['js']);
 }

 public function testDecodeArrayConvertible()
 {
     $arrayConvertibleClass = $this->mockInterface('CM_ArrayConvertible');
     $fromArrayMethod = $arrayConvertibleClass->mockStaticMethod('fromArray')->set(function ($encoded) {
         $this->assertSame(['foo' => 1], $encoded);
         return $encoded['foo'];
     });
     $encodedArrayConvertible = ['foo' => 1, '_class' => get_class($arrayConvertibleClass->newInstance())];
     $this->assertEquals(1, CM_Params::decode($encodedArrayConvertible));
     $this->assertSame(1, $fromArrayMethod->getCallCount());
 }