Default database name to use for AIR applications. Simply set Rx.airDatabaseName anywhere in your code to override. This is usually done at application initialization.

     Rx.airDatabaseName = "myairdb";
     

Any properties that you add to your models can be automatically added to your AIR database. Set this variable to true if you want to enable this functionality.

NOTE: Given limitations in SQLite we can only add columns, existing columns will not be renamed or removed as you add/remove/rename properties in your models. It is your responsibility to migrate data and cleanup client databases if required.

Encryption key to use for connection to AIR SQLite database (if this field is empty connection will be unencrypted = default).

Stores current authenticity token.

exposes the Synchronization capable controller

auxiliary (typically non-CRUD) commands controller

Default database name to use for apps talking to CouchDB directly. Simply set Rx.couchDbdatabaseName anywhere in your code to override. This is usually done at application initialization.

     Rx.couchDbDatabaseName = "foobar";
     

Root URL for CouchDB requests.

Stores any extra HTTP headers that needs to be sent to the backend

Metadata allows us to tag arbitrary data along with any provider requests this is typically useful with HTTP provider (but may be useful with other providers too).

Default metadata specifies metadata that always gets sent along. You can always provide metadata on a per-ModelsController CRUD method basis.
Example
Default metadata is typically an anonymous object

      Rx.defaultMetadata = {foo: 'bar', bar: 'foo'};
     

default service provider to use. XMLHTTPServiceProvider.ID is default.

If set to true, synchronization controller will be initialized

If set to true, undo/redo for create(), update() and destroy() is enabled.

default http controller implementation to use

If http controller handler function is set, it allows you to override behaviour of the send() function in httpController.

      public override function send(url:String, data:Object = null, method:int = AuxHTTPController.GET,
        responder:IResponder = null):void {
              var response:Object = null;
         if (Rx.httpControllerHandler != null) {
           response = Rx.httpControllerHandler(this, url, data, method);
         }  
              responder.result(new ResultEvent(ResultEvent.RESULT, false, false, response));   
      }
     

default root URL for HTTP requests, gets prefixed to CRUD and AUX HTTP operations

Framework logger. In order to see any framework-level logging at all you should call Rx.enableLogging() anywhere in your code. This is typically done at application initialization.

You can control log level by passing appropriate argument to Rx.enableLogging(), such as LogEventLevel.INFO

See also

centralized access to RESTful CRUD operations on models

exposes commonly used serializers (XML and VO)

exposes currently registered service providers

Stores current session id for use by URLRequest. If your application requires authentication, it is recommended that you return a session token from the server as a result of login. This session token will be re-used for subsequent calls until the user logs out. This is particularly important for file uploads.

exposes the undo-redo capable controller

Control the size of the undo-redo stack. the default is 10 (undo redo must be enabled with Rx.enableUndoRedo = true) before this will have any effect

Handy shortcut for non-CRUD AMF operations. Works in much the same way as Rx.http except it expects to receive AMF serializes messages as response

See also

      Rx.amf(function(result:Object):void { trace(result); }).invoke("some/url/here");
     

This will send a GET request with no arguments to "some/url/here" and call anonymous function provided when the result comes back.

Enables tracing for internal restfulx framework classes. This is useful for debugging purposes. The log can be seen in the console of Flex Builder when you are ebugging as opposed to running your project.

Filters a given RxCollection with no side effects, a new restfulx array collection is created that the filter is applied on.

Filters a given RxCollection in place, this version actually modifies the instance passed in as the argument.

Applies a composite filter to a given RxCollection with no side effects, a new restfulx array collection is created that the filters are applied on.

Applies a composite filter to a given RxCollection in place, this version actually modifies the instance passed in as the argument.

Handy shortcut for non-CRUD HTTP operations.

See also

      Rx.http(function(result:Object):void { trace(result); }).invoke("some/url/here");
     

This will send a GET request with no arguments to "some/url/here" and call anonymous function provided when the result comes back.

     Rx.http({
      resultHandler: someFunctionToHandleResult,
      faultHandler: someFunctionToHandleFault,
      contentType: "application/xml"
     }).invoke({data: bla, method: "POST", unmarshall: true});
     

Merges an array into a RxCollection (without side-effects). A new RxCollection is created/returned as a result.

Clears errors, defaultMetadata and the sessionToken (a half-harted attempt at cleaning up framework state, a bullet-proof way, which also clears event listeners you may have is to reload the app on logout.)

Sorts a given RxCollection using SortFields (or anonymous objects) provided without side effects. A new sorted collection is returned.

Sorts a given RxCollection using SortFields (or anonymous objects) provided in place.

default error namespace used by service providers