'aliases' => array(
        .. .
        'RestfullYii' =>realpath(__DIR__ . '/../extensions/starship/RestfullYii'),
        .. .
    ),

    'components' => array(
        'urlManager' => array(
            'urlFormat' => 'path',
            'rules' => require(
                dirname(__FILE__).'/../extensions/starship/restfullyii/config/routes.php'
            ),
        ),
    )

    'aliases' => array(
        .. .
        //Path to your Composer vendor dir plus starship/restfullyii path
        'RestfullYii' =>realpath(__DIR__ . '/../../../vendor/starship/restfullyii/starship/RestfullYii'),
        .. .
    ),

    'components' => array(
        'urlManager' => array(
            'urlFormat' => 'path',
            'rules' => require(
                dirname(__FILE__).'/../../../vendor/starship/restfullyii/starship/RestfullYii/config/routes.php
            ),
        ),
    )

$config = array(
    ..,
    'params'=>[
        'RestfullYii' => [
            'req.auth.user'=>function($application_id, $username, $password) {
                return false;
            },
        ]
    ]
);

class WorkController extends Controller
{
    .. .

    public function restEvents()
    {
        $this->onRest('post.filter.req.auth.ajax.user', function($validation) {
            if(!$validation) {
                return false;
            }
            switch ($this->getAction()->getId()) {
                case 'REST.POST':
                    return Yii::app()->user->checkAccess('REST-CREATE');
                    break;
                case 'REST.POST':
                    return Yii::app()->user->checkAccess('REST-UPDATE');
                    break;
                case 'REST.DELETE':
                    return Yii::app()->user->checkAccess('REST-DELETE');
                    break;
                default:
                    return false;
                    break;
            }
        });
    }

    .. .
}

class CategoryController extends Controller
{
    .. .

    public function restEvents()
    {
        $this->onRest('post.filter.req.auth.ajax.user', function($validation) {
            if(!$validation) {
                return false;
            }
            return ($this->getAction()->getId() == 'REST.GET');
        });
    }

    .. .
}

class CategoryController extends Controller
{
    .. .
    public function restEvents()
    {
        $this->onRest('req.get.active.render', function() {
            //Custom logic for this route.
            //Should output results.
            $this->emitRest('req.render.json', [
                [
                    'type'=>'raw',
                    'data'=>['active'=>true]
                ]
            ])
        });
    }
}

class WorkController extends Controller
{
    .. .

    public function restEvents()
    {
        $this->onRest('req.get.special.render', function($param1) {
            echo CJSON::encode(['param1'=>$param1]);
        });

        $this->onRest('req.put.special.render', function($data, $param1, $param2) {
            //$data is the data sent in the PUT
            echo CJSON::encode(['data'=>$data, $param1, $param2]);
        });

        $this->onRest('req.post.special.render', function($data, $param1) {
            //$data is the data sent in the POST
            echo CJSON::encode(['data'=>$data, 'param1'=>$param1, 'param2'=>$param2]);
        });

        $this->onRest('req.delete.special.render', function($param1, $param2) {
            echo CJSON::encode(['param1'=>$param1, 'param2'=>$param2]);
        });
    }

class ArtistController extends Controller
{
    [...]

    public function restEvents()
    {
        $this->onRest('req.cors.access.control.allow.origin', function() {
            return ['http://my-js-client-app.front']; //List of sites allowed to make CORS requests 
        });
    }
}

class ArtistController extends Controller
{
    [...]

    public function restEvents()
    {
        $this->onRest('req.cors.access.control.allow.origin', function() {
            return ['http://my-js-client-app.front']; //List of sites allowed to make CORS requests 
        });

        $this->onRest('req.cors.access.control.allow.methods', function() {
            return ['GET', 'POST', 'PUT', 'DELETE']; //List of allowed http methods (verbs) 
        });
    }
}

/**
 * config.application.id
 *
 * returns the app id that is applied to header vars (username, password)
 *
 * @return (String) default is 'REST'
 */
$this->onRest('config.application.id', function() {
    return 'REST';
});

$this->onRest('pre.filter.config.application.id', function() {
    //no return
});

$this->onRest('post.filter.config.application.id', function($app_id) {
    return $app_id; //String
});

/**
 * config.dev.flag
 *
 * return true to set develop mode; false to turn of develop mode
 *
 * @return (bool) true by default
 */
$this->onRest('config.dev.flag', function() {
    return true;
});

$this->onRest('pre.filter.config.dev.flag', function() {
    //no return
});

$this->onRest('post.filter.config.dev.flag', function($flag) {
    return $flag; //Bool
});

/**
* req.event.logger
*
* @param (String) (event) the event to log
* @param (String) (category) the log category
* @param (Array) (ignore) Events to ignore logging
*
* @return (Array) the params sent into the event
*/
$this->onRest('req.event.logger', function($event, $category='application',$ignore=[]) {
    if(!isset($ignore[$event])) {
        Yii::trace($event, $category);
    }
    return [$event, $category, $ignore];
});

/**
 * req.disable.cweblogroute
 *
 * this is only relevant if you have enabled CWebLogRoute in your main config
 *
 * @return (Bool) true (default) to disable CWebLogRoute, false to allow
 */ 
$this->onRest('req.auth.username', function(){
    return true;
});

$this->onRest('pre.filter.req.disable.cweblogroute', function() {
    //no return
});

$this->onRest('post.filter.req.disable.cweblogroute', function($disable) {
    return $disable; //Bool
});

/**
 * req.auth.https.only
 *
 * return true to restrict to https;
 * false to allow http or https
 *
 * @return (bool) default is false
 */ 
$this->onRest('req.auth.https.only', function() {
    return false;
});

$this->onRest('pre.filter.req.auth.https.only', function() {
    //no return
});

$this->onRest('post.filter.req.auth.https.only', function($https_only) {
    return $https_only; //Bool
});

/**
 * req.auth.username
 *
 * This is the username used to grant access to non-ajax users
 * At a minimum you should change this value
 *
 * @return (String) the username
 */ 
$this->onRest('req.auth.username', function(){
    return 'admin@restuser';
});

$this->onRest('pre.filter.req.auth.username', function() {
    //no return
});

$this->onRest('post.filter.req.auth.username', function($username) {
    return $username; //String
});

/**
 * req.auth.password
 *
 * This is the password use to grant access to non-ajax users
 * At a minimum you should change this value
 *
 * @return (String) the password
 */ 
$this->onRest('req.auth.password', function(){
    return 'admin@Access';
});

$this->onRest('pre.filter.req.auth.password', function() {
    //no return
});

$this->onRest('post.filter.req.auth.password', function($password) {
    return $password; //String
});

/**
 * req.auth.user
 *
 * Used to validate a non-ajax user
 *
 * @param (String) (application_id) the application_id defined in config.application.id
 * @param (String) (username) the username defined in req.auth.username
 * @param (String) (password) the password defined in req.auth.password
 *
 * @return (Bool) true to grant access; false to deny access
 */ 
$this->onRest('req.auth.user', function($application_id, $username, $password) {
    if(!isset($_SERVER['HTTP_X_'.$application_id.'_USERNAME']) || !isset($_SERVER['HTTP_X_'.$application_id.'_PASSWORD'])) {
                return false;
            }
    if( $username != $_SERVER['HTTP_X_'.$application_id.'_USERNAME'] ) {
        return false;
    }
    if( $password != $_SERVER['HTTP_X_'.$application_id.'_PASSWORD'] ) {
        return false;
    }
    return true;
});

$this->onRest('pre.filter.req.auth.user', function($application_id, $username, $password) {
    return [$application_id, $username, $password]; //Array [String, String, String]
});

$this->onRest('post.filter.req.auth.user', function($validation) {
    return $validation; //Bool
});

/**
 * req.auth.ajax.user
 *
 * Used to validate an ajax user
 * That is requests originating from JavaScript
 * By default all logged-in users will be granted access
 * everyone else will be denied
 * You should most likely over ride this
 *
 * @return (Bool) return true to grant access; false to deny access
 */ 
$this->onRest('req.auth.ajax.user', function() {
    if(Yii::app()->user->isGuest) {
        return false;
    }
    return true;
});

$this->onRest('pre.filter.req.auth.ajax.user', function() {
    //no return
});

$this->onRest('post.filter.req.auth.ajax.user', function($validation) {
    return $validation; //Bool
});

/**
 * req.auth.type
 *
 * @return (Int) The request authentication type which may be 'USERPASS' (2), 'AJAX' (3) or 'CORS' (1)
 */
$this->onRest('req.auth.type', function($application_id) {
    if(isset($_SERVER['HTTP_X_'.$application_id.'_CORS']) || (isset($_SERVER['REQUEST_METHOD']) && $_SERVER['REQUEST_METHOD'] == 'OPTIONS')) {
        return ERestEventListenerRegistry::REQ_TYPE_CORS;
    } else if(isset($_SERVER['HTTP_X_'.$application_id.'_USERNAME']) && isset($_SERVER['HTTP_X_'.$application_id.'_PASSWORD'])) {
        return ERestEventListenerRegistry::REQ_TYPE_USERPASS;
    } else {
        return ERestEventListenerRegistry::REQ_TYPE_AJAX;
    }
});

$this->onRest('pre.filter.req.auth.type', function($application_id) {
    return $application_id; //String
});

$this->onRest('post.filter.config.application.id', function($auth_type) {
    return $auth_type; //Int
});

/**
 * req.cors.access.control.allow.origin
 *
 * Used to validate a CORS request
 *
 * @return (Array) return a list of domains (origin) allowed access
 */
$this->onRest('req.cors.access.control.allow.origin', function() {
    return []; //Array
});

$this->onRest('pre.filter.req.cors.access.control.allow.origin', function() {
    //No Return
});

$this->onRest('post.filter.req.cors.access.control.allow.origin', function($allowed_origins) {
    return $allowed_origins; //Array
});

/**
 * req.cors.access.control.allow.methods
 *
 * Used by CORS request to indicate the http methods (verbs) 
 * that can be used in the actual request
 *
 * @return (Array) List of http methods allowed via CORS
 */
$this->onRest('req.cors.access.control.allow.methods', function() {
    return ['GET', 'POST'];
});

$this->onRest('pre.filter.req.cors.access.control.allow.methods', function() {
    //No Return
});

$this->onRest('post.filter.req.cors.access.control.allow.methods', function($allowed_methods) {
    return $allowed_methods; //Array
});

/**
 * req.cors.access.control.allow.headers
 *
 * Used by CORS request to indicate which custom headers are allowed in a request
 *
 * @return (Array) List of allowed headers
 */ 
$this->onRest('req.cors.access.control.allow.headers', function($application_id) {
    return ["X_{$application_id}_CORS"];
});

$this->onRest('pre.filter.req.cors.access.control.allow.headers', function() {
    //No Return
});

$this->onRest('post.filter.req.cors.access.control.allow.headers', function($allowed_headers) {
    return $allowed_headers; //Array
});

/**
 * req.cors.access.control.max.age
 *
 * Used in a CORS request to indicate how long the response can be cached, 
 * so that for subsequent requests, within the specified time, no preflight request has to be made
 *
 * @return (Int) time in seconds
 */
$this->onRest('req.cors.access.control.max.age', function() {
    return 3628800; //Int
});

$this->onRest('pre.filter.req.cors.access.control.max.age', function() {
    //No Return
});

$this->onRest('post.filter.req.cors.access.control.max.age', function($max_age_in_seconds) {
    return $max_age_in_seconds; //int
});

/**
 * req.auth.cors
 *
 * Used to authorize a given CORS request
 *
 * @param (Array) (allowed_origins) list of allowed remote origins
 *
 * @return (Bool) true to allow access and false to deny access
 */
$this->onRest('req.auth.cors', function ($allowed_origins) {
    if((isset($_SERVER['HTTP_ORIGIN'])) && (( array_search($_SERVER['HTTP_ORIGIN'], $allowed_origins)) !== false )) {
        return true;
    }
    return false;   
});

$this->onRest('pre.filter.req.auth.cors', function($allowed_origins) {
    return $allowed_origins; //Array
});

$this->onRest('post.filter.config.application.id', function($auth_cors) {
    return $auth_cors; //Bool
});

/**
 * req.auth.uri
 *
 * return true to allow access to a given uri / http verb;
 * false to deny access to a given uri / http verb;
 *
 * @return (bool) default is true
 */ 
$this->onRest(req.auth.uri, function($uri, $verb) {
    return true;
});

$this->onRest('pre.filter.req.auth.uri', function($uri, $verb) {
    return [$uri, $verb]; //array[string, string]
});

$this->onRest('post.filter.req.auth.uri, function($validation) {
    return $validation; //bool
});

/**
 * req.after.action
 *
 * Called after the request has been fulfilled
 * By default it has no behavior
 */ 
$this->onRest('req.after.action', function($filterChain) {
    //Logic being applied after the action is executed
});

$this->onRest('pre.filter.req.after.action', function($filterChain) {
    return $filterChain; //Object
});

$this->onRest('post.filter.after.action', function($result=null) {
    return $result; //Mixed
});

/**
 * req.param.is.pk
 *
 * Called when attempting to validate a resources primary key
 * The default is an integer
 *
 * @return (bool) true to confirm primary key; false to deny
 */
$this->onRest('req.param.is.pk', function($pk) {
    return $pk === '0' || preg_match('/^-?[1-9][0-9]*$/', $pk) === 1;
});

$this->onRest('pre.filter.req.param.is.pk', function($pk) {
    return $pk; //Mixed
});

$this->onRest('post.filter.req.param.is.pk', function($isPk) {
    return $isPk; //Bool
});

/**
 * req.data.read
 *
 * Called when reading data on POST & PUT requests
 *
 * @param (String) this can be either a stream wrapper of a file path
 *
 * @return (Array) the JSON decoded array of data
 */ 
$this->onRest('req.data.read', function($stream='php://input') {
    $reader = new ERestRequestReader($stream);
    return CJSON::decode($reader->getContents());
});

$this->onRest('pre.filter.req.data.read, function($stream='php://input') {
    return $stream; //Mixed
});

$this->onRest('post.filter.req.data.read', function($data) {
    return [$data]; //Array [Array]
});

/**
 * req.get.resource.render
 *
 * Called when a GET request for a single resource is to be rendered
 * @param (Object) (data) this is the resources model
 * @param (String) (model_name) the name of the resources model
 * @param (Array) (relations) the list of relations to include with the data
 * @param (Int) (count) the count of records to return (will be either 1 or 0)
 */
$this->onRest('req.get.resource.render', function($data, $model_name, $relations, $count) {
    //Handler for GET (single resource) request
    $this->setHttpStatus((($count > 0)? 200: 204));
    $this->renderJSON([
        'type'              => 'rest',
        'success'           => (($count > 0)? true: false),
        'message'           => (($count > 0)? "Record Found": "No Record Found"),
        'totalCount'        => $count,
        'modelName'         => $model_name,
        'relations'         => $relations,
        'data'              => $data,
    ]);
});

$this->onRest('pre.filter.req.get.resource.render, function($data, $model_name, $relations, $count) {
    return [$data, $model_name, $relations, $count]; //Array [Object, String, Array, Int]
});

/**
 * req.get.resources.render
 *
 * Called when a GET request for when a list resources is to be rendered
 *
 * @param (Array) (data) this is an array of models representing the resources
 * @param (String) (model_name) the name of the resources model
 * @param (Array) (relations) the list of relations to include with the data
 * @param (Int) (count) the count of records to return
 */
$this->onRest('req.get.resources.render', function($data, $model_name, $relations, $count) {
    //Handler for GET (list resources) request
    $this->setHttpStatus((($count > 0)? 200: 204));
    $this->renderJSON([
        'type'              => 'rest',
        'success'           => (($count > 0)? true: false),
        'message'           => (($count > 0)? "Record(s) Found": "No Record(s) Found"),
        'totalCount'        => $count,
        'modelName'         => $model_name,
        'relations'         => $relations,
        'data'              => $data,
    ]);
});

$this->onRest('pre.filter.req.get.resources.render, function($data, $model_name, $relations, $count) {
    return [$data, $model_name, $relations, $count]; //Array [Array [Object], String, Array, Int]
});

/**
 * req.put.resource.render
 * 
 * Called when a PUT request (update) is to be rendered
 *
 * @param (Object) (model) the updated model
 * @param (Array) (relations) list of relations to render with model
 */
$this->onRest('req.put.resource.render' function($model, $relations) {
    $this->renderJSON([
        'type'              => 'rest',
        'success'           => 'true',
        'message'           => "Record Updated",
        'totalCount'    => "1",
        'modelName'     => get_class($model),
        'relations'     => $relations,
        'data'              => $model,
    ]);
});

$this->onRest('pre.filter.req.req.put.resource.render, function($model, $relations) {
    return [$model, relations]; //Array [Object, Array]
});

/**
 * req.post.resource.render
 * 
 * Called when a POST request (create) is to be rendered
 *
 * @param (Object) (model) the newly created model
 * @param (Array) (relations) list of relations to render with model
 */
$this->onRest('req.post.resource.render', function($model, $relations=[]) {
    $this->renderJSON([
        'type'              => 'rest',
        'success'           => 'true',
        'message'           => "Record Created",
        'totalCount'    => "1",
        'modelName'     => get_class($model),
        'relations'     => $relations,
        'data'              => $model,
    ]);
});

$this->onRest('pre.filter.req.post.resource.render', function($model, $relations) {
    return [$model, relations]; //Array [Object, Array]
});

/**
 * req.delete.resource.render
 *
 * Called when DELETE request is to be rendered
 *
 * @param (Object) (model) this is the deleted model object for the resource
 */
$this->onRest('req.delete.resource.render', function($model) {
    $this->renderJSON([
        'type'              => 'rest',
        'success'           => 'true',
        'message'           => "Record Deleted",
        'totalCount'        => "1",
        'modelName'         => get_class($model),
        'relations'         => [],
        'data'              => $model,
    ]);
});

$this->onRest('pre.filter.req.delete.resource.render', function($model) {
    return $model; //Object
});

/**
 * req.get.subresource.render
 *
 * Called when a GET request for a sub-resource is to be rendered
 *
 * @param (Object) (model) the model representing the sub-resource
 * @param (String) (subresource_name) the name of the sub-resource to render
 * @param (Int) (count) the count of sub-resources to render (will be either 1 or 0)
 */
$this->onRest('req.get.subresource.render', function($model, $subresource_name, $count) {
    $this->setHttpStatus((($count > 0)? 200: 204));

    $this->renderJSON([
        'type'              => 'rest',
        'success'           => true,
        'message'           => (($count > 0)? "Record(s) Found": "No Record(s) Found"),
        'totalCount'        => $count,
        'modelName'         => $subresource_name,
        'data'              => $model,
    ]);
});

$this->onRest('pre.filter.req.get.subresource.render', function($model, $subresource_name, $count) {
    return [$model, $subresource_name, $count]; //Array [Object, String, Int]
});

/**
 * req.get.subresources.render
 *
 * Called when a GET request for a list of sub-resources is to be rendered
 *
 * @param (Array) (models) list of sub-resource models
 * @param (String) (subresource_name) the name of the sub-resources to render
 * @param (Int) (count) the count of sub-resources to render
 */
$this->onRest('req.get.subresources.render', function($models, $subresource_name, $count) {
    $this->setHttpStatus((($count > 0)? 200: 204));

    $this->renderJSON([
        'type'              => 'rest',
        'success'           => (($count > 0)? true: false),
        'message'           => (($count > 0)? "Record(s) Found": "No Record(s) Found"),
        'totalCount'        => $count,
        'modelName'         => $subresource_name,
        'data'              => $models,
    ]);
});

$this->onRest('pre.filter.req.get.subresources.render', function($models, $subresource_name, $count) {
    return [$models, $subresource_name, $count]; //Array [Array[Object], String, Int]
});

/**
 * req.put.subresource.render
 *
 * Called when a PUT request to a sub-resource (add a sub-resource) is rendered
 *
 * @param (Object) (model) the model of the resource that owns the subresource
 * @param (String) (subresource_name) the name of the sub-resource
 * @param (Mixed/Int) (subresource_id) the primary key of the sub-resource
 */
$this->onRest('req.put.subresource.render', function($model, $subresource_name, $subresource_id) {
    $this->renderJSON([
        'type'              => 'rest',
        'success'           => 'true',
        'message'           => "Subresource Added",
        'totalCount'        => "1",
        'modelName'         => get_class($model),
        'relations'         => [$subresource_name],
        'data'              => $model,
    ]);
});

$this->onRest('pre.filter.req.put.subresource.render', function($model, $subresource_name, $subresource_id) {
    return [$model, $subresource_name, $subresource_id]; //Array [Object, String, Int]
});

/**
 * req.delete.subresource.render
 *
 * Called when DELETE request on a sub-resource is to be made
 *
 * @param (Object) (model) this is the model object that owns the deleted sub-resource
 * @param (String) (subresource_name) the name of the deleted sub-resource
 * @param (Mixed/Int) (subresource_id) the primary key of the deleted sub-resource
 */
$this->onRest('req.delete.subresource.render', function($model, $subresource_name, $subresource_id) {
    $this->renderJSON([
        'type'              => 'rest',
        'success'           => 'true',
        'message'           => "Sub-Resource Deleted",
        'totalCount'        => "1",
        'modelName'         => get_class($model),
        'relations'         => [$subresource_name],
        'data'              => $model,
    ]);
});

$this->onRest('pre.filter.req.delete.subresource.render', function($model, $subresource_name, $subresource_id) {
    return [$model, $subresource_name, $subresource_id]; //Array [Object, String, Int]
});

/**
 * req.render.json
 * NOT CALLED internally
 * The handler exists to allow users the ability to easily render arbitrary JSON
 * To do so you must 'emitRest' this event
 *
 * @param (Array) (data) data to be rendered
 */
$this->onRest('req.render.json', function($data) {
    $this->renderJSON([
        'type' => 'raw',
        'data' => $data,
    ]);
});

$this->onRest('pre.filter.req.render.json', function($data) {
    return [$data]; //Array[Array]
});

/**
 * req.exception
 *
 * Error handler called when an Exception is thrown
 * Used to render response to the client
 *
 * @param (Int) (errorCode) the http status code
 * @param (String) the error message
 */
$this->onRest('req.exception', function($errorCode, $message=null) {
    $this->renderJSON([
        'type'          => 'error',
        'success'       => false,
        'message'       => (is_null($message)? $this->getHttpStatus()->message: $message),
        'errorCode' => $errorCode,
    ]);
});

$this->onRest('pre.filter.req.exception', function($errorCode, $message=null) {
    return [$errorCode, $message=null]; //Array [Int, String]
});

/**
 * model.instance
 *
 * Called when an instance of the model representing the resource(s) is requested
 * By default this is your controller class name minus the 'Controller'
 *
 * @return (Object) an empty instance of a resources Active Record model
 */
$this->onRest('model.instance', function() {
    $modelName = str_replace('Controller', '', get_class($this));
    return new $modelName();
});

$this->onRest('pre.filter.model.instance', function() {
    //No return
});

$this->onRest('post.filter.model.instance', function($result)) {
    return $result; //
});

/**
 * model.attach.behaviors
 *
 * Called on all requests (Other then custom) to add some magic to your models
 * Attach helper behaviors to model
 *
 * @param (Object) (model) an instance of an AR Model
 *
 * @return (Object) an instance of an Active Record model
 */
$this->onRest('model.attach.behaviors', function($model) {
    //Attach this behavior to help saving nested models
    if(!array_key_exists('ERestActiveRecordRelationBehavior', $model->behaviors())) {
        $model->attachBehavior('ERestActiveRecordRelationBehavior', new ERestActiveRecordRelationBehavior());
    }

    if(!array_key_exists('ERestHelperScopes', $model->behaviors())) {
        $model->attachBehavior('ERestHelperScopes', new ERestHelperScopes());
    }
    return $model;
});

$this->onRest('pre.filter.model.attach.behaviors', function($model) {
    return $model //Object
});

$this->onRest('post.filter.model.attach.behaviors', function($model)) {
    return $model; //Object
});

/**
 * model.with.relations
 *
 * Called when trying to determine which relations to include in a requests render
 * The default is all relations not starting with an underscore
 * You should most likely customize this per resource
 * as some resources may have relations that return large number of records
 *
 * @return (Array) list of relations (Strings) to attach to resources output
 */
$this->onRest('model.with.relations', function($model) {
    $nestedRelations = [];
    foreach($model->metadata->relations as $rel=>$val)
    {
        $className = $val->className;
        $rel_model = call_user_func([$className, 'model']);
        if(!is_array($rel_model->tableSchema->primaryKey) && substr($rel, 0, 1) != '_') {
            $nestedRelations[] = $rel;
        }
    }
    return $nestedRelations;
});

$this->onRest('pre.filter.model.with.relations', function($model) {
    return $model; //Object
});

$this->onRest('post.filter.model.with.relations', function($result)) {
    return $result; //Array[String]
});

/**
 * model.lazy.load.relations
 *
 * Called when determining if relations should be lazy or eager loaded
 * The default is to lazy load. In most cases this is sufficient
 * Under certain conditions eager loading my be more appropriate
 *
 * @return (Bool) true to lazy load relations; false to eager load
 */
$this->onRest('model.lazy.load.relations', function() {
    return true;
});

$this->onRest('pre.filter.model.lazy.load.relations', function() {
    //No return
});

$this->onRest('post.filter.model.lazy.load.relations', function($result)) {
    return $result; //Bool
});

/**
 * model.limit
 *
 * Called when applying a limit to the resources returned in a GET request
 * The default is 100 or the value of the _GET param 'limit'
 *
 * @return (Int) the number of results to return
 */
$this->onRest('model.limit', function() {
    return isset($_GET['limit'])? $_GET['limit']: 100;
});

$this->onRest('pre.filter.model.limit', function() {
    //No return
});

$this->onRest('post.filter.model.limit', function($result)) {
    return $result; //Int
});

/**
 * model.offset
 *
 * Called when applying an offset to the records returned in a GET request
 * The default is 0 or the value of the _GET param 'offset'
 *
 * @return (Int) the offset of results to return
 */
$this->onRest('model.offset', function() {
    return isset($_GET['offset'])? $_GET['offset']: 0;
});

$this->onRest('pre.filter.model.offset', function() {
    //No return
});

$this->onRest('post.filter.model.offset', function($result)) {
    return $result; //Int
});

/**
 * model.scenario
 *
 * Called before a resource is found
 * This is the scenario to apply to a resource pre-find
 * The default is 'restfullyii' or the value of the _GET param 'scenario'
 *
 * @return (String) the scenario name
 */
$this->onRest('model.scenario', function() {
    return isset($_GET['scenario'])? $_GET['scenario']: 'restfullyii';
});

$this->onRest('pre.filter.model.scenario', function() {
    //No return
});

$this->onRest('post.filter.model.scenario', function($result)) {
    return $result; //String
});

/**
 * model.filter
 *
 * Called when attempting to apply a filter to apply to the records in a GET request
 * The default is 'NULL' or the value of the _GET param 'filter'
 * The format is JSON: 
 * '[{"property":"SOME_PROPERTY", "value":"SOME_VALUE"}]'
 * See documentation for additional options
 *
 * @return (JSON) the filter to apply
 */
$this->onRest('model.filter', function() {
    return isset($_GET['filter'])? $_GET['filter']: null;
});

$this->onRest('pre.filter.model.filter', function() {
    //No return
});

$this->onRest('post.filter.model.filter', function($result)) {
    return $result; //Array[Object]
});

/**
 * model.sort
 *
 * Called when attempting to sort records returned in a GET request
 * The default is 'NULL' or the value of the _GET param 'sort'
 * The format is JSON:
 * [{"property":"SOME_PROPERTY", "direction":"DESC"}]
 *
 * @return (JSON) the sort to apply
 */ 
$this->onRest('model.sort', function() {
    return isset($_GET['sort'])? $_GET['sort']: null;
});

$this->onRest('pre.filter.model.sort', function() {
    //No return
});

$this->onRest('post.filter.model.sort', function($result)) {
    return $result; //Array[Object]
});

/**
 * model.find
 *
 * Called when attempting to find a single model
 *
 * @param (Object) (model) an instance of the resources model
 * @param (Mixed/Int) (id) the resources primary key
 *
 * @return (Object) the found model
 */
$this->onRest('model.find', function($model, $id) {
    return $model->findByPk($id);
});

$this->onRest('pre.filter.model.find', function($model, $id) {
    return [$model, $id]; //Array [Object, Int]
});

$this->onRest('post.filter.model.find', function($result)) {
    return $result; //Object
});

/**
 * model.find.all
 *
 * Called when attempting to find a list of models
 *
 * @param (Object) (model) an instance of the resources model
 *
 * @return (Array) list of found models
 */
$this->onRest('model.find.all', function($model) {
    return $model->findAll();
});

$this->onRest('pre.filter.model.find.all', function($model) {
    return $model; //Object
});

$this->onRest('post.filter.model.find.all', function($result)) {
    return $result; //Array[Object]
});

/**
 * model.count
 *
 * Called when the count of model(s) is needed
 *
 * @param (Object) (model) the model to apply the count to
 *
 * @return (Int) the count of models
 */
$this->onRest('model.count', function($model) {
    return $model->count();
});

$this->onRest('pre.filter.model.count', function($model) {
    return $model; //Object
});

$this->onRest('post.filter.model.count', function($result)) {
    return $result; //Int
});

/**
 * model.subresource.find
 *
 * Called when attempting to find a subresource
 *
 * @param (Object) (model) the model that represents the owner of the sub-resource
 * @param (String) (subresource_name) the name of the sub-resource
 * @param (Mixed/Int) (subresource_id) the primary key of the sub-resource
 *
 * @return (Object) the sub-resource model
 */
$this->onRest('model.subresource.find', function($model, $subresource_name, $subresource_id) {
    $subresource = @$this->getSubresourceHelper()->getSubresource($model, $subresource_name, $subresource_id);
    if(count($subresource) > 0) {
        return $subresource[0];
    }
    return $subresource; //Object
});

$this->onRest('pre.filter.model.subresource.find', function($model, $subresource_name, $subresource_id) {
    return [$model, $subresource_name, $subresource_id]; //Array [Object, String, Int]
});

$this->onRest('post.filter.model.subresource.find', function($result)) {
    return $result; //Object
});

/**
 * model.subresource.find.all
 *
 * Called when attempting to find all subresources of a resource
 *
 * @param (Object) (model) the model that represents the owner of the sub-resources
 * @param (String) (subresource_name) the name of the sub-resource
 *
 * @return (Array) list of sub-resource models
 */
$this->onRest(ERestEvent::MODEL_SUBRESOURCES_FIND_ALL, function($model, $subresource_name) {
    return $this->getSubresourceHelper()->getSubresource($model, $subresource_name);
});

$this->onRest('pre.filter.model.subresource.find.all', function($model, $subresource_name) {
    return [$model, $subresource_name]; //Array [Object, String]
});

$this->onRest('post.filter.model.subresource.find.all', function($result)) {
    return $result; //Array[Object]
});

/**
 * model.subresource.count
 *
 * Called when the count of sub-resources is needed
 *
 * @param (Object) (model) the model that represents the owner of the sub-resource
 * @param (String) (subresource_name) the name of the sub-resource
 * @param (Mixed/Int) (subresource_id) the primary key of the sub-resource
 *
 * @return (Int) count of the subresources
 */
$this->onRest('model.subresource.count', function($model, $subresource_name, $subresource_id=null) {
    return $this->getSubresourceHelper()->getSubresourceCount($model, $subresource_name, $subresource_id);
});

$this->onRest('pre.filter.model.subresource.count', function($model, $subresource_name, $subresource_id=null) {
    return [$model, $subresource_name, $subresource_id=null]; //Array [Object, String, Int]
});

$this->onRest('post.filter.model.subresource.count', function($result)) {
    return $result; //Int
});

/**
 * model.apply.post.data
 *
 * Called on POST requests when attempting to apply posted data
 *
 * @param (Object) (model) the resource model to save data to
 * @param (Array) (data) the data to save to the model
 * @param (Array) (restricted_properties) list of restricted properties
 *
 * @return (Object) the model with posted data applied
 */
$this->onRest('model.apply.post.data', function($model, $data, $restricted_properties) {
    return $this->getResourceHelper()->setModelAttributes($model, $data, $restricted_properties);
});

$this->onRest('pre.filter.model.apply.post.data', function($model, $data, $restricted_properties) {
    return [$model, $data, $restricted_properties]; //Array []
});

$this->onRest('post.filter.model.apply.post.data', function($result)) {
    return $result; //
});

/**
 * model.apply.put.data
 *
 * Called on PUT requests when attempting to apply PUT data
 *
 * @param (Object) (model) the resource model to save data to
 * @param (Array) (data) the data to save to the model
 * @param (Array) (restricted_properties) list of restricted properties
 *
 * @return (Object) the model with PUT data applied
 */
$this->onRest('model.apply.put.data', function($model, $data, $restricted_properties) {
    return $this->getResourceHelper()->setModelAttributes($model, $data, $restricted_properties);
});

$this->onRest('pre.filter.model.apply.put.data', function($model, $data, $restricted_properties) {
    return [$model, $data, $restricted_properties]; //Array [Object, Array, Array]
});

$this->onRest('post.filter.model.apply.put.data', function($result)) {
    return $result; //Object
});

/**
 * model.save
 *
 * Called whenever a model resource is saved
 *
 * @param (Object) the resource model to save
 *
 * @return (Object) the saved resource
 */
$this->onRest('model.save', function($model) {
    if(!$model->save()) {
        throw new CHttpException('400', CJSON::encode($model->errors));
    }
    $model->refresh();
    return $model;
});

$this->onRest('pre.filter.model.save', function($model) {
    return $model; //Object
});

$this->onRest('post.filter.model.save', function($result)) {
    return $result; //Object
});

/**
 * model.subresources.save
 *
 * Called whenever a sub-resource is saved
 *
 * @param (Object) (model) the owner of the sub-resource
 * @param (String) (subresource_name) the name of the subresource
 * @param (Mixed/Int) (subresource_id) the primary key of the subresource
 *
 * @return (Object) the updated model representing the owner of the sub-resource
 */
$this->onRest(ERestEvent::MODEL_SUBRESOURCE_SAVE, function($model, $subresource_name, $subresource_id) {
    if(!$this->getSubresourceHelper()->putSubresourceHelper($model, $subresource_name, $subresource_id)) {
        throw new CHttpException('500', 'Could not save Sub-Resource');
    }
    $model->refresh();
    return true;
});

$this->onRest('pre.filter.model.subresources.save', function($model, $subresource_name, $subresource_id) {
    return [$model, $subresource_name, $subresource_id]; //Array [Object, String, Int]
});

$this->onRest('post.filter.model.subresources.save', function($result)) {
    return $result; //Object
});

/**
 * model.delete
 *
 * Called whenever a model resource needs deleting
 *
 * @param (Object) (model) the model resource to be deleted
 */
$this->onRest('model.delete', function($model) {
    if(!$model->delete()) {
        throw new CHttpException(500, 'Could not delete model');
    }
    return $model;
});

$this->onRest('pre.filter.model.delete', function($model) {
    return $model; //Object
});

$this->onRest('post.filter.model.delete', function($result)) {
    return $result; //Object
});

/**
 * model.subresource.delete
 *
 * Called whenever a subresource needs deleting
 *
 * @param (Object) (model) the owner of the sub-resource
 * @param (String) (subresource_name) the name of the subresource
 * @param (Mixed/Int) (subresource_id) the primary key of the subresource
 *
 * @return (Object) the updated model representing the owner of the sub-resource
 */
$this->onRest('model.subresource.delete', function($model, $subresource_name, $subresource_id) {
    if(!$this->getSubresourceHelper()->deleteSubResource($model, $subresource_name, $subresource_id)) {
        throw new CHttpException(500, 'Could not delete Sub-Resource');
    }
    $model->refresh();
    return $model;
});

$this->onRest('pre.filter.model.subresource.delete', function($model, $subresource_name, $subresource_id) {
    return [$model, $subresource_name, $subresource_id]; //Array [Object, String, Int]
});

$this->onRest('post.filter.model.subresource.delete', function($result)) {
    return $result; //Object
});

/**
 * model.restricted.properties
 *
 * Called when determining which properties if any should be considered restricted
 * The default is [] (no restricted properties)
 *
 * @return (Array) list of restricted properties
 */
$this->onRest('model.restricted.properties', function() {
    return [];
});

$this->onRest('pre.filter.model.restricted.properties', function() {
    //No return
});

$this->onRest('post.filter.model.restricted.properties', function($result)) {
    return $result; //Array
});

/**
 * model.visible.properties
 *
 * Called when determining which properties if any should be considered visible
 * The default is [] (no hidden properties)
 *
 * @return (Array) list of visible properties
 */
$this->onRest('model.visible.properties', function() {
    return [];
});

$this->onRest('pre.filter.model.visible.properties', function() {
    //No return
});

$this->onRest('post.filter.model.visible.properties', function($result)) {
    return $result; //Array
});

/**
 * model.hidden.properties
 *
 * Called when determining which properties if any should be considered hidden
 * The default is [] (no hidden properties)
 *
 * @return (Array) list of hidden properties
 */
$this->onRest('model.hidden.properties', function() {
    return [];
});

$this->onRest('pre.filter.model.hidden.properties', function() {
    //No return
});

$this->onRest('post.filter.model.hidden.properties', function($result)) {
    return $result; //Array
});