public function work(GearmanJob $job)
 {
     $workload = $job->workload();
     $json = json_decode($workload, true);
     if (!json_last_error()) {
         $workload = $json;
     }
     $eventManager = new CakeEventManager();
     $eventManager->dispatch(new CakeEvent('Gearman.beforeWork', $this, $workload));
     $data = call_user_func($this->_workers[$job->functionName()], $job, $workload);
     $eventManager->dispatch(new CakeEvent('Gearman.afterWork', $this, $workload));
     return $data;
 }
 /**
  * testProcessVersion
  *
  * @return void
  */
 public function testProcessVersion()
 {
     $this->Image->create();
     $result = $this->Image->save(array('foreign_key' => 'test-1', 'model' => 'Test', 'file' => array('name' => 'titus.jpg', 'size' => 332643, 'tmp_name' => CakePlugin::path('FileStorage') . DS . 'Test' . DS . 'Fixture' . DS . 'File' . DS . 'titus.jpg', 'error' => 0)));
     $result = $this->Image->find('first', array('conditions' => array('id' => $this->Image->getLastInsertId())));
     $this->assertTrue(!empty($result) && is_array($result));
     $this->assertTrue(file_exists($this->testPath . $result['ImageStorage']['path']));
     $path = $this->testPath . $result['ImageStorage']['path'];
     $Folder = new Folder($path);
     $folderResult = $Folder->read();
     $this->assertEqual(count($folderResult[1]), 3);
     Configure::write('Media.imageSizes.Test', array('t200' => array('thumbnail' => array('mode' => 'outbound', 'width' => 200, 'height' => 200))));
     ClassRegistry::init('FileStorage.ImageStorage')->generateHashes();
     $Event = new CakeEvent('ImageVersion.createVersion', $this->Image, array('record' => $result, 'storage' => StorageManager::adapter('Local'), 'operations' => array('t200' => array('thumbnail' => array('mode' => 'outbound', 'width' => 200, 'height' => 200)))));
     CakeEventManager::instance()->dispatch($Event);
     $path = $this->testPath . $result['ImageStorage']['path'];
     $Folder = new Folder($path);
     $folderResult = $Folder->read();
     $this->assertEqual(count($folderResult[1]), 4);
     $Event = new CakeEvent('ImageVersion.removeVersion', $this->Image, array('record' => $result, 'storage' => StorageManager::adapter('Local'), 'operations' => array('t200' => array('thumbnail' => array('mode' => 'outbound', 'width' => 200, 'height' => 200)))));
     CakeEventManager::instance()->dispatch($Event);
     $path = $this->testPath . $result['ImageStorage']['path'];
     $Folder = new Folder($path);
     $folderResult = $Folder->read();
     $this->assertEqual(count($folderResult[1]), 3);
 }
 public function changeStatus(Model $Model, $status, $id = null, $force = false)
 {
     if ($id === null) {
         $id = $Model->getID();
     }
     if ($id === false) {
         return false;
     }
     $force = true;
     $Model->id = $id;
     if (!$Model->exists()) {
         throw new NotFoundException();
     }
     if ($force !== true) {
         $modelData = $Model->read();
         if ($modelData[$Model->alias]['status'] === $status) {
             CakeLog::write(LOG_WARNING, __d('webshop', 'The status of %1$s with id %2$d is already set to %3$s. Not making a change', strtolower(Inflector::humanize(Inflector::underscore($Model->name))), $id, $status), array('webshop'));
             return false;
         }
     } else {
         CakeLog::write(LOG_WARNING, __d('webshop', 'Status change of %1$s with id %2$d is being forced to %3$s', strtolower(Inflector::humanize(Inflector::underscore($Model->name))), $id, $status), array('webshop'));
     }
     $Model->saveField('status', $status);
     CakeLog::write(LOG_INFO, __d('webshop', 'Changed status of %1$s with id %2$d to %3$s', strtolower(Inflector::humanize(Inflector::underscore($Model->name))), $id, $status), array('webshop'));
     $eventData = array();
     $eventData[Inflector::underscore($Model->name)]['id'] = $id;
     $eventData[Inflector::underscore($Model->name)]['status'] = $status;
     $overallEvent = new CakeEvent($Model->name . '.statusChanged', $this, $eventData);
     $specificEvent = new CakeEvent($Model->name . '.statusChangedTo' . Inflector::camelize($status), $this, $eventData);
     CakeEventManager::instance()->dispatch($overallEvent);
     CakeEventManager::instance()->dispatch($specificEvent);
     return true;
 }
 /**
  * Import exchange rate for the euro.
  */
 public function import()
 {
     $exchangeRateImporter = new EcbExchangeRateImporter();
     $exchangeRateImporter->import();
     $event = new CakeEvent('ExchangeRateImport.completed', $this);
     CakeEventManager::instance()->dispatch($event);
 }
 public function onProductBought($event)
 {
     $this->Product->id = $event->data['product']['id'];
     $this->Product->recursive = 2;
     $product = $this->Product->read();
     if ($product[$this->Product->WebhostingProduct->alias]['id'] === null) {
         return;
     }
     $this->Product->WebhostingProduct->HostGroup->id = $product['HostGroup']['id'];
     $this->Product->WebhostingProduct->HostGroup->recursive = 2;
     $hostGroup = $this->Product->WebhostingProduct->HostGroup->read();
     $WebhostingProvider = BasicWebhostingProvider::get($hostGroup['Host'][0]['Provider']['class']);
     $webhostingPackage = $this->WebhostingPackage->createFromWebhostingProduct($product['WebhostingProduct'], $event->data['customer']['id'], $hostGroup['Host'][0]['id']);
     $webhostingDetails = $WebhostingProvider->createPackage($webhostingPackage['WebhostingPackage']['id']);
     if ($webhostingDetails === false) {
         CakeLog::write(LOG_ERROR, __d('pltfrm', 'Webhosting provider %1$s could not create webhosting package with id %2$d owned by %3$s', $hostGroup['Host'][0]['Provider']['class'], $webhostingPackage['WebhostingPackage']['id'], $webhostingPackage['Customer']['name']), array('webhosting', 'pltfrm'));
         return false;
     }
     $eventData = array();
     $eventData['webhosting']['id'] = $webhostingPackage['WebhostingPackage']['id'];
     $eventData['details'] = $webhostingDetails;
     $eventData['metadata'] = array();
     $webhostingCreatedEvent = new CakeEvent('Webhosting.created', $this, $eventData);
     CakeEventManager::instance()->dispatch($webhostingCreatedEvent);
     CakeLog::write(LOG_INFO, __d('pltfrm', 'Webhosting provider %1$s created webhosting package with id %2$d', $hostGroup['Host'][0]['Provider']['class'], $webhostingPackage['WebhostingPackage']['id']), array('webhosting', 'pltfrm'));
     if (isset($event->data['order'])) {
         $this->OrderProduct->changeStatus('delivered', $event->data['order']['product_id']);
     }
     return true;
 }
Esempio n. 6
0
 /**
  * Syntactic sugar improving the readability for on* methods
  *
  * @param string $eventName
  * @param CakeWampAppServer $scope
  * @param array $params
  */
 public function dispatchEvent($eventName, $scope, $params)
 {
     $event = new CakeEvent($eventName, $scope, $params);
     $this->outVerbose('Event begin: ' . $eventName);
     $this->_eventManager->dispatch($event);
     $this->outVerbose('Event end: ' . $eventName);
     return $event;
 }
Esempio n. 7
0
 /**
  * Dispatch event
  *
  * @param string $name    Name of the event
  * @param object $subject the object that this event applies to (usually the object that is generating the event)
  * @param mixed  $data    any value you wish to be transported with this event to it can be read by listeners
  */
 public static function dispatchEvent($name, $subject = null, $data = [])
 {
     $event = new CakeEvent($name, $subject, $data);
     if (!$subject) {
         CakeEventManager::instance()->dispatch($event);
     } else {
         $subject->getEventManager()->dispatch($event);
     }
 }
Esempio n. 8
0
 /**
  * Constructor
  * Overridden to provide Twig loading
  *
  * @param Controller $Controller Controller
  */
 public function __construct(Controller $Controller = null)
 {
     $this->Twig = new Twig_Environment(new Twig_Loader_Cakephp(array()), array('cache' => Configure::read('TwigView.Cache'), 'charset' => strtolower(Configure::read('App.encoding')), 'auto_reload' => Configure::read('debug') > 0, 'autoescape' => false, 'debug' => Configure::read('debug') > 0));
     CakeEventManager::instance()->dispatch(new CakeEvent('Twig.TwigView.construct', $this, array('TwigEnvironment' => $this->Twig)));
     parent::__construct($Controller);
     if (isset($Controller->theme)) {
         $this->theme = $Controller->theme;
     }
     $this->ext = self::EXT;
 }
 /**
  * Default settings
  *
  * @var array
  */
 public function initialize(Controller $Controller)
 {
     $this->settings = array_merge($this->_defaultSettings, $this->settings);
     $this->Controller = $Controller;
     $this->_EventManager = CakeEventManager::instance();
     if (empty($this->settings['model'])) {
         $this->settings['model'] = $this->Controller->modelClass;
     }
     $this->sessionKey = $this->settings['sessionKey'];
 }
Esempio n. 10
0
 /**
  * Returns the globally available instance of a CakeEventManager
  * this is used for dispatching events attached from outside the scope
  * other managers were created. Usually for creating hook systems or inter-class
  * communication
  *
  * If called with a first params, it will be set as the globally available instance
  *
  * @param CakeEventManager $manager 
  * @return CakeEventManager the global event manager
  */
 public static function instance($manager = null)
 {
     if ($manager instanceof CakeEventManager) {
         self::$_generalManager = $manager;
     }
     if (empty(self::$_generalManager)) {
         self::$_generalManager = new CakeEventManager();
     }
     self::$_generalManager->_isGlobal = true;
     return self::$_generalManager;
 }
Esempio n. 11
0
 /**
  * Starts the websocket server
  *
  * @return void
  */
 public function start()
 {
     $this->__loop = LoopFactory::create();
     if ($this->__loop instanceof \React\EventLoop\StreamSelectLoop) {
         $this->out('<warning>Your configuration doesn\'t seem to support \'ext-libevent\'. It is highly reccomended that you install and configure it as it provides significant performance gains over stream select!</warning>');
     }
     $socket = new Reactor($this->__loop);
     $socket->listen(Configure::read('Ratchet.Connection.websocket.port'), Configure::read('Ratchet.Connection.websocket.address'));
     $this->__ioServer = new IoServer(new HttpServer(new WsServer(new SessionProvider(new WampServer(new CakeWampAppServer($this, $this->__loop, CakeEventManager::instance(), $this->params['verbose'])), new CakeWampSessionHandler(), [], new PhpSerializeHandler()))), $socket, $this->__loop);
     $this->__loop->run();
 }
Esempio n. 12
0
 /**
  * Detaches all listeners from the Cart events to avoid application level events changing the tests
  *
  * @return void
  */
 protected function _detachAllListeners()
 {
     $EventManager = CakeEventManager::instance();
     $events = array('Cart.beforeCalculateCart', 'Cart.applyTaxRules', 'Cart.applyDiscounts', 'Cart.afterCalculateCart');
     foreach ($events as $event) {
         $listeners = $EventManager->listeners($event);
         foreach ($listeners as $listener) {
             foreach ($listener['callable'] as $callable) {
                 $EventManager->detach($callable);
             }
         }
     }
 }
Esempio n. 13
0
 public function testConstruct()
 {
     $this->_hibernateListeners('Twig.TwigView.construct');
     $callbackFired = false;
     $that = $this;
     $eventCallback = function ($event) use($that, &$callbackFired) {
         $that->assertInstanceof('Twig_Environment', $event->data['TwigEnvironment']);
         $callbackFired = true;
     };
     CakeEventManager::instance()->attach($eventCallback, 'Twig.TwigView.construct');
     $TwigView = new TwigView();
     CakeEventManager::instance()->detach($eventCallback, 'Twig.TwigView.construct');
     $this->_wakeupListeners('Twig.TwigView.construct');
     $this->assertTrue($callbackFired);
 }
 /**
  * Triggers a Crud event by creating a new subject and filling it with $data
  * if $data is an instance of CrudSubject it will be reused as the subject
  * object for this event.
  *
  * If Event listeners return a CakeResponse object, the this method will throw an
  * exception and fill a 'response' property on it with a reference to the response
  * object.
  *
  * @param string $eventName
  * @param array $data
  * @throws Exception if any event listener return a CakeResponse object
  * @return CrudSubject
  */
 public function trigger($eventName, $data = array())
 {
     $subject = $data instanceof CrudSubject ? $data : $this->_getSubject($data);
     $event = new CakeEvent($this->config('eventPrefix') . '.' . $eventName, $subject);
     $this->_eventManager->dispatch($event);
     if ($event->result instanceof CakeResponse) {
         $exception = new Exception();
         $exception->response = $event->result;
         throw $exception;
     }
     $subject->stopped = false;
     if ($event->isStopped()) {
         $subject->stopped = true;
     }
     return $subject;
 }
 /**
  * URL
  *
  * @param array $image FileStorage array record or whatever else table that matches this helpers needs without the model, we just want the record fields
  * @param string $version Image version string
  * @param array $options HtmlHelper::image(), 2nd arg options array
  * @throws InvalidArgumentException
  * @return string
  */
 public function imageUrl($image, $version = null, $options = array())
 {
     if (empty($image) || empty($image['id'])) {
         return false;
     }
     if (!empty($version)) {
         $hash = Configure::read('Media.imageHashes.' . $image['model'] . '.' . $version);
         if (empty($hash)) {
             throw new \InvalidArgumentException(__d('file_storage', 'No valid version key (%s %s) passed!', @$image['model'], $version));
         }
     } else {
         $hash = null;
     }
     $Event = new CakeEvent('FileStorage.ImageHelper.imagePath', $this, array('hash' => $hash, 'image' => $image, 'version' => $version, 'options' => $options));
     CakeEventManager::instance()->dispatch($Event);
     if ($Event->isStopped()) {
         return $this->normalizePath($Event->data['path']);
     } else {
         return false;
     }
 }
 protected function _expectedEventCalls(&$asserts, $events)
 {
     $cbi = [];
     foreach ($events as $eventName => $event) {
         $this->__preservedEventListeners[$eventName] = CakeEventManager::instance()->listeners($eventName);
         foreach ($this->__preservedEventListeners[$eventName] as $eventListener) {
             $this->eventManager->detach($eventListener['callable'], $eventName);
         }
         $count = count($events[$eventName]['callback']);
         for ($i = 0; $i < $count; $i++) {
             $asserts[$eventName . '_' . $i] = false;
         }
         $cbi[$eventName] = 0;
         $this->eventManager->attach(function ($event) use(&$events, $eventName, &$asserts, &$cbi) {
             $asserts[$eventName . '_' . $cbi[$eventName]] = true;
             call_user_func($events[$eventName]['callback'][$cbi[$eventName]], $event);
             $cbi[$eventName]++;
         }, $eventName);
     }
     return $asserts;
 }
 /**
  * Default callback entry point for API callbacks for payment processors
  *
  * @param null $token
  * @throws NotFoundException
  * @internal param string $processor
  * @return void
  */
 public function callback($token = null)
 {
     $order = $this->Order->find('first', array('contain' => array(), 'conditions' => array('Order.token' => $token)));
     if (empty($order)) {
         throw new NotFoundException(__d('cart', 'Invalid payment token %s!', $token));
     }
     try {
         $Processor = $this->_loadPaymentProcessor($order['Order']['processor']);
         $status = $Processor->notificationCallback($order);
         $transactionId = $Processor->getTransactionId();
         if (empty($order['Order']['payment_reference']) && !empty($transactionId)) {
             $order['Order']['payment_reference'] = $transactionId;
         }
         $result = $this->Order->save(array('Order' => array('id' => $order['Order']['id'], 'payment_status' => $status, 'payment_reference' => $order['Order']['payment_reference'])), array('validate' => false, 'callbacks' => false));
     } catch (Exception $e) {
         $this->log($e->getMessage(), 'payment-error');
         $this->log($this->request, 'payment-error');
     }
     $Event = new CakeEvent('Payment.callback', $this->request);
     CakeEventManager::dispatch($Event, $this, array($result));
     $this->_stop();
 }
 /**
  * {@inheritdoc}
  *
  * @return void
  */
 public function execute()
 {
     $tasks = array();
     $this->TaskServer->killZombies();
     while ($this->TaskServer->freeSlots() > 0 && ($task = $this->TaskServer->getPending())) {
         $tasks[] = $task;
     }
     if (empty($tasks)) {
         return;
     }
     $events = (array) Configure::read('Task.processEvents');
     $models = array();
     foreach ($events as $event) {
         $models[$event['model']] = ClassRegistry::init($event['model']);
         CakeEventManager::instance()->attach($models[$event['model']], $event['key'], $event['options']);
     }
     foreach ($tasks as $task) {
         $this->_run($task);
     }
     foreach ($events as $event) {
         CakeEventManager::instance()->detach($models[$event['model']], $event['key'], $event['options']);
     }
 }
Esempio n. 19
0
 /**
  * Load a CrudAction instance.
  *
  * @param string $name The controller action name.
  * @return CrudAction
  * @throws CakeException If action is not mapped.
  */
 protected function _loadAction($name)
 {
     if (!isset($this->_actionInstances[$name])) {
         $config = $this->config('actions.' . $name);
         if (empty($config)) {
             throw new CakeException(sprintf('Action "%s" has not been mapped', $name));
         }
         list($plugin, $class) = pluginSplit($config['className'], true);
         $class = ucfirst($class);
         if (in_array($class, array('Index', 'View', 'Add', 'Edit', 'Delete'))) {
             if (!empty($plugin) && $plugin !== 'Crud.') {
                 throw new CakeException('The build-in CrudActions (Index, View, Add, Edit and Delete) must be loaded from the Crud plugin');
             }
             $plugin = 'Crud.';
         }
         $class .= 'CrudAction';
         App::uses($class, $plugin . 'Controller/Crud/Action');
         $subject = $this->getSubject(array('action' => $name));
         $this->_actionInstances[$name] = new $class($subject, $config);
         $this->_eventManager->attach($this->_actionInstances[$name]);
     }
     return $this->_actionInstances[$name];
 }
Esempio n. 20
0
 /**
  * dispatch
  * 
  * 命名規則に従ったイベント名で、イベントをディスパッチする
  * 
  * @param string $name
  * @param Object $subject
  * @param array $params
  * @param array $options
  * @return boolean|\CakeEvent
  */
 public static function dispatch($name, $subject, $params = array(), $options = array())
 {
     $options = array_merge(array('modParams' => 0, 'layer' => '', 'plugin' => $subject->plugin, 'class' => $subject->name), $options);
     extract($options);
     if ($layer && !preg_match('/^' . $layer . './', $name)) {
         $evnetName = $layer;
         if ($plugin) {
             $evnetName .= '.' . $plugin;
         }
         if ($class) {
             $evnetName .= '.' . $class;
         }
         $evnetName .= '.' . $name;
     }
     $EventManager = CakeEventManager::instance();
     if (!$EventManager->listeners($evnetName)) {
         return false;
     }
     $event = new CakeEvent($evnetName, $subject, $params);
     $event->modParams = $modParams;
     $EventManager->dispatch($event);
     return $event;
 }
Esempio n. 21
0
 /**
  * Removes a listener from the active listeners.
  * @see CakeEventManager::detach()
  * @return void
  */
 public function detach($callable, $eventKey = null)
 {
     if (is_object($callable)) {
         $key = get_class($callable);
         unset($this->_listenersMap[$key]);
     }
     parent::detach($callable, $eventKey);
 }
Esempio n. 22
0
 /**
  * Returns the CakeEventManager manager instance that is handling any callbacks.
  * You can use this instance to register any new listeners or callbacks to the
  * controller events, or create your own events and trigger them at will.
  *
  * @return CakeEventManager
  */
 public function getEventManager()
 {
     if (empty($this->_eventManager)) {
         $this->_eventManager = new CakeEventManager();
         $this->_eventManager->attach($this->Components);
         $this->_eventManager->attach($this);
     }
     return $this->_eventManager;
 }
Esempio n. 23
0
 */
if (BC_INSTALLED && !$isUpdater && !$isMaintenance) {
    App::build(array('Plugin' => array_merge(array(BASER_THEMES . $bcSite['theme'] . DS . 'Plugin' . DS), App::path('Plugin'))));
    $plugins = getEnablePlugins();
    foreach ($plugins as $plugin) {
        loadPlugin($plugin['Plugin']['name'], $plugin['Plugin']['priority']);
    }
    $plugins = Hash::extract($plugins, '{n}.Plugin.name');
    Configure::write('BcStatus.enablePlugins', $plugins);
    /**
     * イベント登録
     */
    App::uses('BcControllerEventDispatcher', 'Event');
    App::uses('BcModelEventDispatcher', 'Event');
    App::uses('BcViewEventDispatcher', 'Event');
    $CakeEvent = CakeEventManager::instance();
    $CakeEvent->attach(new BcControllerEventDispatcher());
    $CakeEvent->attach(new BcModelEventDispatcher());
    $CakeEvent->attach(new BcViewEventDispatcher());
    /**
     * テーマの bootstrap を実行する
     */
    $themePath = WWW_ROOT . 'theme' . DS . Configure::read('BcSite.theme') . DS;
    $themeBootstrap = $themePath . 'Config' . DS . 'bootstrap.php';
    if (file_exists($themeBootstrap)) {
        include $themeBootstrap;
    }
}
/**
 * 文字コードの検出順を指定
 */
 /**
  * Attaches all event listeners for this dispatcher instance. Loads the
  * dispatcher filters from the configured locations.
  *
  * @param CakeEventManager $manager
  * @return void
  * @throws MissingDispatcherFilterException
  */
 protected function _attachFilters($manager)
 {
     $filters = Configure::read('Dispatcher.filters');
     if (empty($filters)) {
         return;
     }
     foreach ($filters as $filter) {
         if (is_string($filter)) {
             $filter = array('callable' => $filter);
         }
         if (is_string($filter['callable'])) {
             list($plugin, $callable) = pluginSplit($filter['callable'], true);
             App::uses($callable, $plugin . 'Routing/Filter');
             if (!class_exists($callable)) {
                 throw new MissingDispatcherFilterException($callable);
             }
             $manager->attach(new $callable());
         } else {
             $on = strtolower($filter['on']);
             $options = array();
             if (isset($filter['priority'])) {
                 $options = array('priority' => $filter['priority']);
             }
             $manager->attach($filter['callable'], 'Dispatcher.' . $on . 'Dispatch', $options);
         }
     }
 }
Esempio n. 25
0
<?php

App::uses('FileStorageUtils', 'FileStorage.Lib/Utility');
App::uses('StorageManager', 'FileStorage.Lib');
App::uses('LocalImageProcessingListener', 'FileStorage.Event');
//App::uses('LocalFileStorageListener', 'FileStorage.Event');
App::uses('CakeEventManager', 'Event');
spl_autoload_register(__NAMESPACE__ . '\\FileStorageUtils::gaufretteLoader');
$listener = new LocalImageProcessingListener();
CakeEventManager::instance()->attach($listener);
Esempio n. 26
0
 /**
  * Returns the CakeEventManager manager instance that is handling any callbacks.
  * You can use this instance to register any new listeners or callbacks to the
  * controller events, or create your own events and trigger them at will.
  *
  * @return CakeEventManager
  */
 public function getEventManager()
 {
     if (empty($this->_eventManager)) {
         $this->_eventManager = new CakeEventManager();
     }
     if (!$this->_eventManagerConfigured) {
         $this->_eventManager->attach($this->Helpers);
         $this->_eventManagerConfigured = true;
     }
     return $this->_eventManager;
 }
Esempio n. 27
0
 *
 */
/**
 * Plugins need to be loaded manually, you can either load them one by one or all of them in a single call
 * Uncomment one of the lines below, as you need. make sure you read the documentation on CakePlugin to use more
 * advanced ways of loading plugins
 *
 * CakePlugin::loadAll(); // Loads all plugins at once
 * CakePlugin::load('DebugKit'); //Loads a single plugin named DebugKit
 *
 */
//CakePlugin::load('Crud');
if (php_sapi_name() !== 'cli' && Configure::read('debug') && in_array('DebugKit', App::objects('plugin'))) {
    CakePlugin::load('DebugKit');
    App::uses('CakeEventManager', 'Event');
    CakeEventManager::instance()->attach(function ($event) {
        $controller = $event->subject();
        if (!isset($controller->Crud)) {
            return;
        }
        $controller->Toolbar = $controller->Components->load('DebugKit.Toolbar', ['panels' => ['Crud.Crud']]);
        $controller->Crud->addListener('DebugKit', 'Crud.DebugKit');
    }, 'Controller.initialize');
}
/**
 * You can attach event listeners to the request lifecycle as Dispatcher Filter . By Default CakePHP bundles two filters:
 *
 * - AssetDispatcher filter will serve your asset files (css, images, js, etc) from your themes and plugins
 * - CacheDispatcher filter will read the Cache.check configure variable and try to serve cached content generated from controllers
 *
 * Feel free to remove or add filters as you see fit for your application. A few examples:
Esempio n. 28
0
 /**
  * Tests that stopping an event will not notify the rest of the listeners
  *
  * @return void
  */
 public function testStopPropagation()
 {
     $manager = new CakeEventManager();
     $listener = new CakeEventTestListener();
     $manager->attach(array($listener, 'listenerFunction'), 'fake.event');
     $manager->attach(array($listener, 'stopListener'), 'fake.event', array('priority' => 8));
     $manager->attach(array($listener, 'secondListenerFunction'), 'fake.event', array('priority' => 5));
     $event = new CakeEvent('fake.event');
     $manager->dispatch($event);
     $expected = array('secondListenerFunction');
     $this->assertEquals($expected, $listener->callStack);
 }
 /**
  * Test that events are dispatched properly when there are global and local
  * listeners at the same priority.
  *
  * @return void
  */
 public function testDispatchWithGlobalAndLocalEvents()
 {
     $listener = new CustomTestEventListener();
     CakeEventManager::instance()->attach($listener);
     $listener2 = new CakeEventTestListener();
     $manager = new CakeEventManager();
     $manager->attach(array($listener2, 'listenerFunction'), 'fake.event');
     $manager->dispatch(new CakeEvent('fake.event', $this));
     $this->assertEquals(array('listenerFunction'), $listener->callStack);
     $this->assertEquals(array('listenerFunction'), $listener2->callStack);
 }
 /**
  * Tets helper. Makes task runner mock
  * 
  * @param array $processEvents
  * @return object
  */
 protected function _makeRunner(array $processEvents)
 {
     return function () use($processEvents) {
         $Runner = $this->getMockBuilder('TaskRunner')->setMethods(array('start'))->disableOriginalConstructor()->getMock();
         $Runner->expects($this->once())->method('start')->willReturnCallback(function () use($processEvents) {
             foreach ($processEvents as $processEvent) {
                 CakeEventManager::instance()->dispatch(new CakeEvent($processEvent['key'], $this, array()));
             }
         });
         return $Runner;
     };
 }