/** * Attach routes to the application. * @return \Georeferencer\Application\Micro **/ private function bootstrapRouting() { $config = $this->getApplication()->getDI()->get(self::DI_CONFIG); $this->getApplication()->notFound(function () { $controller = new \Georeferencer\Controller\IndexCtrl(); return $controller->notFound(); }); if (isset($config['routesCollection'])) { foreach ($config['routesCollection'] as $routeCollection) { $collection = new \Phalcon\Mvc\Micro\Collection(); $collection->setHandler($routeCollection['setHandler'], true); foreach ($routeCollection['routes'] as $type => $routes) { foreach ($routes as $pattern => $callback) { $collection->{$type}($pattern, $callback); } } $this->getApplication()->mount($collection); } } //Set the correct url for the helper. if (isset($_SERVER['SERVER_NAME'])) { // Detect scheme $scheme = 'http'; if (isset($_SERVER['HTTPS'])) { $scheme = 'https'; } if (isset($_SERVER['HTTP_X_FORWARDED_PROTO'])) { $scheme = $_SERVER['HTTP_X_FORWARDED_PROTO']; } $this->getApplication()->getDI()->get(self::DI_URL_HELPER)->setBaseUri($scheme . '://' . $_SERVER['SERVER_NAME']); } return $this; }
public function resource($route, $controller, $additionals = []) { $collection = new \Phalcon\Mvc\Micro\Collection(); $collection->setPrefix($route); $collection->setHandler(new $controller()); $collection->get('/', 'getAll'); $collection->get('/{id}', 'get'); $collection->post('/', 'create'); $collection->put('/{id}', 'update'); $collection->delete('/{id}', 'delete'); $this->mount($collection); }
public static function resource(&$app, $path, $controller) { $collection = new \Phalcon\Mvc\Micro\Collection(); $collection->setHandler(new $controller()); // index $collection->get($path, 'indexAction'); // show? $collection->get("{$path}/search/{id}", 'searchAction'); // edit? $app->get("{$path}/{id:[0-9]+}", 'editAction'); // store $app->post($path, 'storeAction'); // update $app->put("{$path}/{id:[0-9]+}", 'updateAction'); // delete $app->delete("{$path}/{id:[0-9]+}", 'deleteAction'); $app->mount($collection); }
public function testMicroCollectionsLazy() { $app = new Phalcon\Mvc\Micro(); $collection = new Phalcon\Mvc\Micro\Collection(); $collection->setHandler('PersonasLazyController', true); $collection->map('/', 'index'); $collection->map('/edit/{number}', 'edit'); $app->mount($collection); $app->handle('/'); $this->assertEquals(PersonasLazyController::getEntered(), 1); $app->handle('/edit/100'); $this->assertEquals(PersonasLazyController::getEntered(), 101); }
public static function getAppInstance() { if (!self::$appInstance) { try { /** * Read the configuration */ $config = (include APP_PATH . "/app/config/config.php"); /** * Read auto-loader */ include APP_PATH . "/app/config/loader.php"; /** * Read services */ $di = self::getDiInstance(); include APP_PATH . "/app/config/services.php"; /** * Handle the Route */ self::$appInstance = new \Phalcon\Mvc\Micro($di); $syncRoute = new Phalcon\Mvc\Micro\Collection(); // $syncRoute->setHandler(new SyncController($di)); $syncRoute->setHandler('SyncController', true); $syncRoute->setPrefix('sync/'); $syncRoute->map('get_user/{api}/{guid}', 'indexAction'); $syncRoute->map('add_user/{api}/{guid}', 'addUserAction'); $syncRoute->map('update_user/{api}/{guid}', 'updateUserAction'); $syncRoute->map('insert_user/{api}/{guid}', 'insertUserAction'); $syncRoute->map('plus_user/{api}/{guid}', 'plusUserAction'); self::$appInstance->mount($syncRoute); $asyncRoute = new Phalcon\Mvc\Micro\Collection(); // $asyncRoute->setHandler(new AsyncController($di)); $asyncRoute->setHandler('AsyncController', true); $asyncRoute->setPrefix('async/'); $asyncRoute->map('add_user/{api}/{guid}', 'addUserAction'); $asyncRoute->map('update_user/{api}/{guid}', 'updateUserAction'); $asyncRoute->map('insert_user/{api}/{guid}', 'insertUserAction'); $asyncRoute->map('plus_user/{api}/{guid}', 'plusUserAction'); self::$appInstance->mount($asyncRoute); file_put_contents("/tmp/sw_server_instance.log", "new AppInstance" . date("Y-m-d H:i:s") . "\r\n", FILE_APPEND); } catch (\Exception $e) { echo $e->getMessage() . '<br>'; echo '<pre>' . $e->getTraceAsString() . '</pre>'; } } return self::$appInstance; }
<?php /** * Collections let us define groups of routes that will all use the same controller. * We can also set the handler to be lazy loaded. Collections can share a common prefix. * @var $productsOptionsCollection */ // This is an Immediately Invoked Function in php. The return value of the // anonymous function will be returned to any file that "includes" it. // e.g. $collection = include('products_options.php'); return call_user_func(function () { $productsOptionsCollection = new \Phalcon\Mvc\Micro\Collection(); $productsOptionsCollection->setPrefix('/' . $this->di->getConfig()->application->version . '/products_options')->setHandler('\\App\\Modules\\Backend\\Controllers\\ProductsOptionsController')->setLazy(true); // Set Access-Control-Allow headers. $productsOptionsCollection->options('/', 'optionsBase'); $productsOptionsCollection->options('/{id}', 'optionsOne'); // First paramter is the route, which with the collection prefix here would be GET /products_options/ // Second paramter is the function name of the Controller. $productsOptionsCollection->get('/', 'get'); // This is exactly the same execution as GET, but the Response has no body. $productsOptionsCollection->head('/', 'get'); // $id will be passed as a parameter to the Controller's specified function $productsOptionsCollection->get('/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'getOne'); $productsOptionsCollection->head('/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'getOne'); $productsOptionsCollection->post('/', 'post'); $productsOptionsCollection->post('/search', 'search'); $productsOptionsCollection->post('/search/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'searchOne'); $productsOptionsCollection->delete('/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'delete'); $productsOptionsCollection->put('/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'put'); $productsOptionsCollection->put('/upload/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'upload'); $productsOptionsCollection->put('/import', 'bulkImport');
<?php /** * Collections let us define groups of routes that will all use the same controller. * We can also set the handler to be lazy loaded. Collections can share a common prefix. * @var $autocompleteCollection */ // This is an Immeidately Invoked Function in php. The return value of the // anonymous function will be returned to any file that "includes" it. // e.g. $collection = include('autocomplete.php'); return call_user_func(function () { $userCollection = new \Phalcon\Mvc\Micro\Collection(); $userCollection->setPrefix('/v1/user')->setHandler('\\Api\\Controllers\\UserController')->setLazy(true); // Set Access-Control-Allow headers. $userCollection->options('/', 'optionsBase'); $userCollection->options('/{id,email,images}', 'optionsOne'); // First paramter is the route, which with the collection prefix here would be GET /autocomplete/ // Second paramter is the function name of the Controller. $userCollection->get('/', 'get'); $userCollection->post('/', 'post'); $userCollection->put('/{id:[a-zA-Z0-9_-]+}', 'put'); // This is exactly the same execution as GET, but the Response has no body. $userCollection->head('/', 'get'); return $userCollection; });
<?php /** * Define all routes to be used in module * * @package Reddit_API * @subpackage Index_Routes_Collections * @author Enrique Ojeda <*****@*****.**> */ return call_user_func(function () { /** * Define handler (Controller) */ $handler = '\\Modules\\Index\\Controllers\\IndexController'; /** * Instance collection from Phalcon Mvc */ $collection = new \Phalcon\Mvc\Micro\Collection(); /** * Set prefix, handler and async process as false. */ $collection->setPrefix('')->setHandler($handler)->setLazy(true); /** * Define urls (Routes) and link them with controller */ $collection->get('/', 'index'); $collection->get('/version', 'version'); $collection->post('/version', 'version'); return $collection; });
<?php /** * Collections let us define groups of routes that will all use the same controller. * We can also set the handler to be lazy loaded. Collections can share a common prefix. * @var $exampleCollection */ // This is an Immeidately Invoked Function in php. The return value of the // anonymous function will be returned to any file that "includes" it. // e.g. $collection = include('example.php'); return call_user_func(function () { $collection = new \Phalcon\Mvc\Micro\Collection(); $collection->setPrefix('/api/wordType')->setHandler('\\Base\\Controllers\\Dictionary\\WordTypeController')->setLazy(true); // Set Access-Control-Allow headers. $collection->options('/', 'optionsBase'); $collection->options('/{id}', 'optionsOne'); // First paramter is the route, which with the collection prefix here would be GET /example/ // Second paramter is the function name of the Controller. $collection->get('/', 'get'); // This is exactly the same execution as GET, but the Response has no body. $collection->head('/', 'get'); // $id will be passed as a parameter to the Controller's specified function $collection->get('/{id:[0-9]+}', 'getOne'); $collection->head('/{id:[0-9]+}', 'getOne'); $collection->post('/create', 'create'); $collection->post('/search', 'search'); $collection->post('/update', 'update'); $collection->delete('/{id:[0-9]+}', 'delete'); $collection->put('/{id:[0-9]+}', 'put'); $collection->patch('/{id:[0-9]+}', 'patch'); return $collection;
<?php /** * Collections let us define groups of routes that will all use the same controller. * We can also set the handler to be lazy loaded. Collections can share a common prefix. * @var $channelsCollection */ // This is an Immediately Invoked Function in php. The return value of the // anonymous function will be returned to any file that "includes" it. // e.g. $collection = include('channels.php'); return call_user_func(function () { $channelsCollection = new \Phalcon\Mvc\Micro\Collection(); $channelsCollection->setPrefix('/' . $this->di->getConfig()->application->version . '/channels')->setHandler('\\App\\Modules\\Backend\\Controllers\\ChannelsController')->setLazy(true); // Set Access-Control-Allow headers. $channelsCollection->options('/', 'optionsBase'); $channelsCollection->options('/{id}', 'optionsOne'); // First paramter is the route, which with the collection prefix here would be GET /channels/ // Second paramter is the function name of the Controller. $channelsCollection->get('/', 'get'); // This is exactly the same execution as GET, but the Response has no body. $channelsCollection->head('/', 'get'); $channelsCollection->post('/search', 'search'); $channelsCollection->post('/search/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'searchOne'); // $id will be passed as a parameter to the Controller's specified function $channelsCollection->get('/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'getOne'); $channelsCollection->head('/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'getOne'); $channelsCollection->post('/', 'post'); $channelsCollection->delete('/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'delete'); $channelsCollection->put('/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'put'); return $channelsCollection; });
<?php /** * Collections let us define groups of routes that will all use the same controller. * We can also set the handler to be lazy loaded. Collections can share a common prefix. * @var $autocompleteCollection */ return call_user_func(function () { $collection = new \Phalcon\Mvc\Micro\Collection(); $collection->setPrefix('/v1/skill')->setHandler('\\Api\\Controllers\\SkillController')->setLazy(true); // Set Access-Control-Allow headers. $collection->options('/', 'optionsBase'); // $collection->options('/{access_token}', 'optionsOne'); // First paramter is the route, which with the collection prefix here would be GET /autocomplete/ // Second paramter is the function name of the Controller. $collection->get('/', 'get', 'skill-authbasic'); // $collection->post('/', 'post'); // $collection->put('/', 'put'); // This is exactly the same execution as GET, but the Response has no body. // $collection->head('/', 'get'); return $collection; });
<?php /** * Define all routes to be used in module * * @package Reddit_API * @subpackage User_Routes_Collections * @author Enrique Ojeda <*****@*****.**> */ return call_user_func(function () { /** * Instance collection from Phalcon Mvc */ $collection = new \Phalcon\Mvc\Micro\Collection(); /** * Define handler (Controller) */ $handler = '\\Modules\\User\\Controllers\\UserController'; /** * Set prefix, handler and async process as true. */ $collection->setPrefix('')->setHandler($handler)->setLazy(true); /** * Define routes */ $collection->post('/user', 'register'); $collection->post('/login', 'login'); $collection->post('/login/status', 'loginStatus'); return $collection; });
<?php /** * Collections let us define groups of routes that will all use the same controller. * We can also set the handler to be lazy loaded. Collections can share a common prefix. * @var $autocompleteCollection */ return call_user_func(function () { $collection = new \Phalcon\Mvc\Micro\Collection(); $collection->setPrefix('/v1/linkedinCallback')->setHandler('\\Api\\Controllers\\LinkedinCallbackController')->setLazy(true); // Set Access-Control-Allow headers. // $collection->options('/', 'optionsBase'); // $collection->options('/{access_token}', 'optionsOne'); // First paramter is the route, which with the collection prefix here would be GET /autocomplete/ // Second paramter is the function name of the Controller. $collection->get('/', 'get', 'login-linkedin-allow'); $collection->get('/{aacess}', 'get', 'login-linkedin-authenticating-allow'); // $collection->post('/', 'post'); // This is exactly the same execution as GET, but the Response has no body. // $collection->head('/', 'get'); return $collection; });
<?php /** * Collections let us define groups of routes that will all use the same controller. * We can also set the handler to be lazy loaded. Collections can share a common prefix. * @var $exampleCollection */ // This is an Immeidately Invoked Function in php. The return value of the // anonymous function will be returned to any file that "includes" it. // e.g. $collection = include('example.php'); return call_user_func(function () { $collection = new \Phalcon\Mvc\Micro\Collection(); $collection->setPrefix('/api/resource')->setHandler('\\Base\\Controllers\\Resources\\ResourceController')->setLazy(true); // Set Access-Control-Allow headers. $collection->options('/', 'optionsBase'); $collection->options('/{id}', 'optionsOne'); // First paramter is the route, which with the collection prefix here would be GET /example/ // Second paramter is the function name of the Controller. $collection->get('/', 'get'); // This is exactly the same execution as GET, but the Response has no body. $collection->head('/', 'get'); // $id will be passed as a parameter to the Controller's specified function $collection->get('/{id:[0-9]+}', 'getOne'); $collection->head('/{id:[0-9]+}', 'getOne'); $collection->post('/create', 'create'); $collection->post('/update', 'update'); $collection->delete('/{id:[0-9]+}', 'delete'); $collection->put('/{id:[0-9]+}', 'put'); $collection->patch('/{id:[0-9]+}', 'patch'); return $collection; });
public static function getAppInstance() { if (!self::$appInstance) { try { /** * Read the configuration */ $config = (include APP_PATH . "/app/config/config.php"); /** * Read auto-loader */ include APP_PATH . "/app/config/loader.php"; /** * Read services */ $di = self::getDiInstance(); include APP_PATH . "/app/config/services.php"; self::$appInstance = new \Phalcon\Mvc\Micro($di); /** * Handle the Route, Sync RPC handler */ $syncRoute = new Phalcon\Mvc\Micro\Collection(); $syncRoute->setHandler('IndexController', true); $syncRoute->setPrefix('sync/'); $syncRoute->map('getUserById/{key}', 'getUserByIdAction'); $syncRoute->map('checkUserLoginInfo/{key}', 'checkUserLoginInfoAction'); $syncRoute->map('checkLoginName/{key}', 'checkLoginNameAction'); $syncRoute->map('addUser/{key}', 'addUserAction'); $syncRoute->map('updateUser/{key}', 'updateUserAction'); $syncRoute->map('deleteUser/{key}', 'deleteUserAction'); $syncRoute->map('getUsers/{key}', 'getUsersAction'); self::$appInstance->mount($syncRoute); /** * More, just like Async RPC handler */ } catch (\Exception $e) { echo $e->getMessage() . '<br>'; echo '<pre>' . $e->getTraceAsString() . '</pre>'; } } return self::$appInstance; }
<?php $app = new Phalcon\Mvc\Micro(); $collection = new Phalcon\Mvc\Micro\Collection(); $collection->setHandler(new PostsController()); $collection->get('/posts/edit/{id}', 'edit'); $app->mount($collection);
<?php /** * Collections let us define groups of routes that will all use the same controller. * We can also set the handler to be lazy loaded. Collections can share a common prefix. * @var $exampleCollection */ // This is an Immeidately Invoked Function in php. The return value of the // anonymous function will be returned to any file that "includes" it. // e.g. $collection = include('example.php'); return call_user_func(function () { $exampleCollection = new \Phalcon\Mvc\Micro\Collection(); $exampleCollection->setPrefix('/v1/user')->setHandler('\\PhalconRest\\Controllers\\UsersController')->setLazy(true); // Set Access-Control-Allow headers. $exampleCollection->options('/', 'optionsBase'); $exampleCollection->options('/{id}', 'optionsOne'); // First paramter is the route, which with the collection prefix here would be GET /example/ // Second paramter is the function name of the Controller. $exampleCollection->get('/', 'get'); // This is exactly the same execution as GET, but the Response has no body. $exampleCollection->head('/', 'get'); // $id will be passed as a parameter to the Controller's specified function $exampleCollection->get('/{id:[0-9]+}', 'getOne'); $exampleCollection->head('/{id:[0-9]+}', 'getOne'); $exampleCollection->post('/', 'post'); $exampleCollection->post('/login', 'login'); $exampleCollection->post('/logout', 'logout'); $exampleCollection->get('/profile', 'profile'); $exampleCollection->get('/checkSession', 'checkSession'); $exampleCollection->delete('/{id:[0-9]+}', 'delete'); $exampleCollection->put('/{id:[0-9]+}', 'put');
<?php /** * Created by PhpStorm. * User: Dapo * Date: 08-Dec-14 * Time: 9:48 AM */ return call_user_func(function () { $userCollection = new \Phalcon\Mvc\Micro\Collection(); $userCollection->setPrefix('/v1/users')->setHandler('\\PhalconRest\\Controllers\\UserController')->setLazy(true); $userCollection->get('/', 'index'); $userCollection->post('/login', 'login'); $userCollection->post('/login_jwt', 'login_jwt'); $userCollection->options('/login_jwt', 'info'); $userCollection->post('/register', 'register'); return $userCollection; });
<?php /** * Collections let us define groups of routes that will all use the same controller. * We can also set the handler to be lazy loaded. Collections can share a common prefix. * @var $exampleCollection */ // This is an Immeidately Invoked Function in php. The return value of the // anonymous function will be returned to any file that "includes" it. // e.g. $collection = include('example.php'); return call_user_func(function () { $exampleCollection = new \Phalcon\Mvc\Micro\Collection(); $exampleCollection->setPrefix('/v1/example')->setHandler('\\Phalcon2Rest\\Modules\\V1\\Controllers\\ExampleController')->setLazy(true); // Set Access-Control-Allow headers. $exampleCollection->options('/', 'optionsBase'); $exampleCollection->options('/{id}', 'optionsOne'); // First parameter is the route, which with the collection prefix here would be GET /example/ // Second parameter is the function name of the Controller. $exampleCollection->get('/', 'get'); // This is exactly the same execution as GET, but the Response has no body. $exampleCollection->head('/', 'get'); // $id will be passed as a parameter to the Controller's specified function $exampleCollection->get('/{id:[0-9]+}', 'getOne'); $exampleCollection->head('/{id:[0-9]+}', 'getOne'); $exampleCollection->post('/', 'post'); $exampleCollection->delete('/{id:[0-9]+}', 'delete'); $exampleCollection->put('/{id:[0-9]+}', 'put'); $exampleCollection->patch('/{id:[0-9]+}', 'patch'); return $exampleCollection; });
<?php /** * Created by PhpStorm. * User: Dapo * Date: 09-Dec-14 * Time: 1:43 PM */ return call_user_func(function () { $api = new \Phalcon\Mvc\Micro\Collection(); $api->setPrefix('/v1/grouper')->setHandler('\\PhalconRest\\Controllers\\GrouperController')->setLazy(true); // Issues Handlers $api->get('/issues', 'issues'); $api->options('/issues', 'info'); $api->get('/issues/principles', 'issuePrinciples'); $api->options('/issues/principles', 'info'); $api->get('/issues/stats', 'issueStats'); $api->options('/issues/stats', 'info'); $api->put('/principles/{id:[0-9]+}', 'updatePrinciple'); $api->options('/principles/{id:[0-9]+}', 'info'); $api->get('/reviews', 'reviews'); $api->options('/reviews', 'info'); $api->post('/reviews', 'newReview'); $api->put('/reviews/{id:[0-9]+}', 'updateReview'); return $api; });
<?php /** * Collections let us define groups of routes that will all use the same controller. * We can also set the handler to be lazy loaded. Collections can share a common prefix. * * @link http://docs.phalconphp.com/en/latest/api/Phalcon_Mvc_Micro_Collection.html */ return call_user_func(function () { $testCollection = new \Phalcon\Mvc\Micro\Collection(); $testCollection->setPrefix('/' . VERSION . '/posts')->setHandler('Phanbook\\Controllers\\PostsController')->setLazy(true); // First paramter is the route, which with the collection prefix here would be GET /example/ // Second paramter is the function name of the Controller. $testCollection->get('/', 'index'); // This is exactly the same execution as GET, but the Response has no body. $testCollection->head('/', 'index'); // $id will be passed as a parameter to the Controller's specified function $testCollection->get('/{id:[0-9]+}', 'getOne'); $testCollection->head('/{id:[0-9]+}', 'getOne'); $testCollection->post('/', 'post'); $testCollection->delete('/{id:[0-9]+}', 'delete'); $testCollection->put('/{id:[0-9]+}', 'put'); $testCollection->patch('/{id:[0-9]+}', 'patch'); return $testCollection; });
<?php /** * Created by PhpStorm. * User: Dapo * Date: 09-Dec-14 * Time: 1:43 PM */ return call_user_func(function () { $api = new \Phalcon\Mvc\Micro\Collection(); $api->setPrefix('/v1/reports')->setHandler('\\PhalconRest\\Controllers\\ReportsController')->setLazy(true); $api->get('/summary', 'summary'); $api->get('/staff', 'staff'); $api->get('/details', 'details'); return $api; });
<?php // This is an Immeidately Invoked Function in php. The return value of the // anonymous function will be returned to any file that "includes" it. // e.g. $collection = include('example.php'); return call_user_func(function () { $userCollection = new \Phalcon\Mvc\Micro\Collection(); $userCollection->setPrefix('/v1/users')->setHandler('\\PhalconRest\\Controllers\\UsersController')->setLazy(true); // Set Access-Control-Allow headers. //$userCollection->options('/', 'optionsBase'); $userCollection->options('/{id}', 'optionsOne'); // First parameter is the route, which with the collection prefix here would be GET /user/ // Second parameter is the function name of the Controller. $userCollection->get('/', 'get'); // This is exactly the same execution as GET, but the Response has no body. $userCollection->head('/', 'get'); // $id will be passed as a parameter to the Controller's specified function $userCollection->get('/{id:[0-9]+}', 'getOne'); $userCollection->head('/{id:[0-9]+}', 'getOne'); $userCollection->post('/', 'post'); $userCollection->delete('/{id:[0-9]+}', 'delete'); $userCollection->put('/{id:[0-9]+}', 'put'); $userCollection->patch('/{id:[0-9]+}', 'patch'); return $userCollection; });
<?php /** * Collections let us define groups of routes that will all use the same controller. * We can also set the handler to be lazy loaded. Collections can share a common prefix. * @var $adminUsersCollection */ // This is an Immediately Invoked Function in php. The return value of the // anonymous function will be returned to any file that "includes" it. // e.g. $collection = include('admin_users.php'); return call_user_func(function () { $adminUsersCollection = new \Phalcon\Mvc\Micro\Collection(); $adminUsersCollection->setPrefix('/' . $this->di->getConfig()->application->version . '/admin/users')->setHandler('\\App\\Modules\\Admin\\Controllers\\UsersController')->setLazy(true); // Set Access-Control-Allow headers. $adminUsersCollection->options('/', 'optionsBase'); $adminUsersCollection->options('/{id}', 'optionsOne'); // First paramter is the route, which with the collection prefix here would be GET /users/ // Second paramter is the function name of the Controller. $adminUsersCollection->get('/', 'get'); // This is exactly the same execution as GET, but the Response has no body. $adminUsersCollection->head('/', 'get'); $adminUsersCollection->post('/search', 'search'); $adminUsersCollection->post('/search/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'searchOne'); $adminUsersCollection->post('/login', 'login'); // $id will be passed as a parameter to the Controller's specified function $adminUsersCollection->get('/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'getOne'); $adminUsersCollection->head('/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'getOne'); $adminUsersCollection->post('/', 'post'); $adminUsersCollection->delete('/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'delete'); $adminUsersCollection->put('/{id:' . $this->di->getConfig()->application->idRegExp . '+}', 'put'); return $adminUsersCollection;
<?php /** * Standard routes for resource * Refer to routes/collections/example.php for further details */ return call_user_func(function () { $routes = new \Phalcon\Mvc\Micro\Collection(); // VERSION NUMBER SHOULD BE FIRST URL PARAMETER, ALWAYS // setHandler MUST be a string in order to support lazy loading $routes->setPrefix('/v1/events')->setHandler('\\PhalconRest\\Controllers\\EventController')->setLazy(true); $routes->options('/', 'optionsBase'); $routes->options('/{id}', 'optionsOne'); $routes->get('/', 'get'); $routes->head('/', 'get'); $routes->post('/', 'post'); $routes->get('/{id:[0-9]+}', 'getOne'); $routes->head('/{id:[0-9]+}', 'getOne'); $routes->delete('/{id:[0-9]+}', 'delete'); $routes->put('/{id:[0-9]+}', 'put'); $routes->patch('/{id:[0-9]+}', 'patch'); return $routes; });
<?php /** * Define all routes to be used in module * * @package Reddit_API * @subpackage Post_Routes_Collections * @author Enrique Ojeda <*****@*****.**> */ return call_user_func(function () { /** * Instance collection from Phalcon Mvc */ $collection = new \Phalcon\Mvc\Micro\Collection(); /** * Define handler (Controller) */ $handler = '\\Modules\\Post\\Controllers\\PostController'; /** * Set prefix, handler and async process as true. */ $collection->setPrefix('')->setHandler($handler)->setLazy(true); /** * Define urls (Routes) and link them with controller */ $collection->post('/post/submit', 'submit'); $collection->get('/posts/{page:[0-9]+}', 'fetch'); $collection->get('/posts', 'fetch'); $collection->post('/post/vote', 'vote'); return $collection; });
<?php /** * Collections let us define groups of routes that will all use the same controller. * We can also set the handler to be lazy loaded. Collections can share a common prefix. */ return call_user_func(function () { $exampleCollection = new \Phalcon\Mvc\Micro\Collection(); $exampleCollection->setPrefix('/v1/access_token')->setHandler('\\Phalcon2Rest\\Modules\\V1\\Controllers\\AccessTokenController')->setLazy(true); // Set Access-Control-Allow headers. $exampleCollection->options('/', 'optionsBase'); $exampleCollection->post('/', 'post'); return $exampleCollection; });
<?php /** * Collections let us define groups of routes that will all use the same controller. * We can also set the handler to be lazy loaded. Collections can share a common prefix. * @var $autocompleteCollection */ return call_user_func(function () { $collection = new \Phalcon\Mvc\Micro\Collection(); $collection->setPrefix('/v1/registerPersonal')->setHandler('\\Api\\Controllers\\RegisterPersonalController')->setLazy(true); // Set Access-Control-Allow headers. $collection->options('/', 'optionsBase'); // $collection->options('/{access_token}', 'optionsOne'); // First paramter is the route, which with the collection prefix here would be GET /autocomplete/ // Second paramter is the function name of the Controller. $collection->get('/', 'get', 'registerPersonal-authbasic'); // $collection->get('/{aacess}', 'get', 'registerPersonal-authbasic'); $collection->post('/', 'post'); $collection->put('/', 'put'); // This is exactly the same execution as GET, but the Response has no body. $collection->head('/', 'get'); return $collection; });
<?php /** * Created by PhpStorm. * User: Dapo * Date: 09-Dec-14 * Time: 1:43 PM */ return call_user_func(function () { $api = new \Phalcon\Mvc\Micro\Collection(); $api->setPrefix('/v1')->setHandler('\\PhalconRest\\Controllers\\AppController')->setLazy(true); $api->get('/legalHeads', 'getLegalHeads'); $api->post('/setStandard', 'setAsStandard'); $api->post('/updateSubjectMatter', 'updateSubjectMatter'); $api->post('/changeLegalHead', 'changeLegalHead'); $api->post('/changeSubjectMatter', 'changeSubjectMatter'); $api->post('/updateIssue', 'updateIssue'); $api->post('/mergeSubjectMatters', 'mergeSubjectMatters'); $api->post('/mergeIssues', 'mergeIssues'); $api->post('/detachRatio', 'detachRatio'); $api->post('/markDone', 'markDone'); $api->post('/removeStandard', 'removeStandard'); $api->post('/newBookCase/{id:[0-9]+}', 'newBookCase'); $api->get('/bookCases/{id:[0-9]+}', 'getCases'); $api->get('/alternateCitations/{id:[0-9]+}', 'getCaseAlternateCitations'); $api->get('/fullCases', 'fullCases'); $api->get('/fullCases/{id:[0-9]+}/{term}', 'fullCases'); $api->get('/fullCases/{id:[0-9]+}/{term}/{type}', 'fullCases'); $api->get('/caseList/{term}', 'caseList'); $api->delete('/deleteCase/{id:[0-9]+}', 'deleteCase'); return $api;
<?php /** * collection of routes to support for user controller */ return call_user_func(function () { $routes = new \Phalcon\Mvc\Micro\Collection(); // VERSION NUMBER SHOULD BE FIRST URL PARAMETER, ALWAYS // setHandler MUST be a string in order to support lazy loading $routes->setPrefix('/v1/auth')->setHandler('\\PhalconRest\\Controllers\\AuthController')->setLazy(true); // Set Access-Control-Allow headers. $routes->options('/', 'optionsBase'); $routes->options('/{id}', 'optionsOne'); // First paramter is the route, which with the collection prefix here would be GET /user/ // Second paramter is the function name of the Controller. // custom routes $routes->get('/session_check', 'session_check'); $routes->get('/logout', 'logout'); $routes->get('/scratch1', 'scratch1'); $routes->post('/login', 'login'); $routes->post('/create', 'create'); $routes->post('/reminder', 'reminder'); $routes->post('/activate', 'activate'); $routes->post('/reset', 'reset'); // copies used mostly for testing $routes->get('/login', 'login'); // $routes->get('/activate', 'activate'); // $routes->get('/reminder', 'reminder'); // $routes->get('/reset', 'reset'); return $routes; });