public interface ReifyOnSite
 Reify is a cloud-based visual application
 builder in which users
  can build screens via drag-and-drop, create DataSources from sample data or using wizards,
  and visually define standard event handlers and multi-step workflows.
  
  Reify OnSite is a special version of Reify that can be installed on your own network, behind
  your firewall, so that your data and intellectual property never leave your secure site.
  Applications are deployed to your private cloud, also behind your firewall. The tool itself
  can be configured for your specific requirements. DataSources that connect to internal
 enterprise data services are supported, custom
 components can be
  added to the palette library, and the Reify design environment itself can even be customized
  on a per-user basis.
  
Reify OnSite is licensed separately from Reify.com accounts, and separately from Smart GWT developer licenses, generally purchased as a either a fixed number of seats or unlimited within a group, site or company-wide. Contact us here to get started,
Installation
The OnSite package comes with an Embedded Tomcat server and pre-populated HSQL database that's ready to be run with no additional setup required. If desired, it can be deployed to a separate servlet engine or run against a different database engine.
Account Management
 Reify Designer Accounts are managed via a plain SQLDataSource, named "isc_reifyUsers", which
 you
 can edit using the DataSources tab of the Admin
 Console or
 Developer Console.  Within the DataSources tab,
 click on the "isc_reifyUsers"
  DataSource record to open a section for editing user records, and click "add record" to add
  additional users.  User records can be removed by clicking on the delete icon in the
  rightmost column of each record.
  
As shipped, a single user account, "admin" (password "reify"), is provided. To grant superuser privileges to additional accounts, just enter "superuser" for the "roles" field in the record.
How Reify Stores your Designs and Data
 Reify uses FileSource DataSources to store your
 projects
  (isc_hostedProjects DS), screens (isc_hostedScreens DS), and
 DataSources (isc_hostedDataSources DS), rather than writing them to disk as files.
  These DataSources are shared for all users of your organization, so project and screen names
  must be unique.
  
Deployment
  Reify OnSite runs your application in a dedicated sandbox (a separate database in HQL),
 with its own copy of each of your project MockDataSources instantiated
  as real SQL DataSources in the HSQL database.  This process is called deployment.
  DataSources that are not MockDataSources are just deployed "as is" and will behave
  the same in all the different types of deployments.
  
During deployment, a unique database is created on the fly (one per deployment), named:
      sbx_<deploymentType>_deployment_<deploymentId>_org_1
  where the deployment type is one of "test", "staging", or "production".  The following
  DataSources are created in the deployment database during deployment, with records related
  to the project being deployed copied from the common database, in the case of the FileSource
  DataSources:
  
| DataSource Name | Contents | Is FileSource? | 
| isc_hostedProjects | project definitions | Y | 
| isc_hostedScreens | screen definitions | Y | 
| isc_hostedDataSources | MockDataSource definitions | Y | 
| isc_hostedSettings | project-specific settings | Y | 
| isc_hostedUsers | users for deployment | N | 
| isc_hostedRoles | user roles for deployment | N | 
| isc_hostedSessions | tracks deployment sessions | N | 
Your application's deployment URL will target the current host with a path like:
      /<deploymentType>/reify/<deploymentName>/
  where the deployment type is one of "app" (production), "test", or "staging", and the
  deployment name is one you choose during deployment, defaulting to the project name.  For
  example, the complete URL might look like:
  
      https://server1.bigco.com/staging/reify/vendor_evaluation/
  for a staging deployment of BigCo's "vendor evaluation" project to server1.
  Future releases will support deployment to both private and public clouds, and multi-organization, allowing you to customize the middle path segment.
  Note that using the "Export" option under the "Project" button, you can combine any created
  screen with a Smart GWT SDK, and thus deploy to any platform that supports Java servlets
 and a database.  For more details, refer to Reify for Developers.
  
Auditing
  Audit DataSources are automatically created during deployment for each DataSource in your
 deployment.  You can open the Deployment
 Management Console to
  examine any DataSource in the deployment, view or edit users and roles, and analyze what
  sessions have hit the deployment, as well as what changes they've made to your DataSources.
  
Custom Components
  Reify OnSite allows adding custom components to the palette, including components built on
 new classes and component schema.  For an
 overview of the files
  required (e.g. globalDependencies.xml) and where to place them, see
  "Adding Custom Components to Reify".
  
Custom Workflow Tasks
  With Reify OnSite, custom workflow tasks and associated editors can be added to support
 your special project needs. See ReifyAddWorkflowTask for
 details.
  
Advanced Tasks
  Reify has various advanced tasks to be used in workflows, where  Send Email
  and  Send SMS are some of them.
  Take a look at the ReifyMessaging to know more about them.
  
Default Skin for the initial project
Any skin, standard or custom, can be configured as the default skin for Reify and it will be applied to the initial, default project created the first time each user logs in. New projects created thereafter use the currently selected skin.
  Call isc.Reify.setDefaultSkin(skinName [, skinURL]), typically from the
  Runtime Customization detailed below, to set the default skin for this instance of
  Reify. If the default skin is a custom skin it will not show up in the Project->Skin
  menu automatically. See the Custom Skins section below for details on adding that selection.
  
  When using the Runtime Customization to register the default skin, set the
  load timing to afterVBCreate.
  
Custom Skins
  Custom skins that are not hosted by the Skin Editor can be registered with Reify by calling
 Reify.registerSkin(). The skin can then be
 selected from Project->Skin->Custom
  Skins menu. This skin registration is typically done via Runtime Customization detailed
  below. An optional URL can be provided if the skin is not located in the standard location
  (i.e. isomorphic/skins) or is served by a different server. Note that the URL must include
  the skin name as its last component (ex. /mySkins/MyCustomSkin).
  
  When using the Runtime Customization to register the custom skin, set the
  load timing to afterVBCreate.
  
Runtime Customization
 Reify OnSite provides a mechanism, the "isc_reifyCustomizations" DataSource,
  whereby you can customize the project runtime environment with your own JavaScript
  snippets.  Note that direct access to this dataSource
 requies the "superuser"
 role.
 To add customizations, use the DataSources tab
 in the Admin or
  Developer Console. Select "isc_reifyCustomizations" in the DataSource List, and then 
  click "Add Record" at the bottom of the new section that appears to start editing a new 
  record.  The following fields should be populated:
/foo.js) and absolute (e.g.
  http://mysite.com/cool/custom.js) URLs are supported.Resolving Errors
  Errors encountered by Reify OnSite, which may raise a dialog with a countdown timer
  reloading the page, are logged to the "isc_hostedErrorReports" DataSource in the HSQL database
  reifyNoSandbox.  Records here are detailed, containing the click stream of
  events leading up to the crash, as well as the stack trace.  To help resolve any errors,
  VPN-based remote support can be purchased from Isomorphic.
  
Switching Database Engines
  To switch Reify OnSite to use another database engine, such as MySQL, you can use the
 "Database Configuration" tab of the Admin Console
 to change the default
  database, and then the "Import DataSources" tab to populate the required tables.  You'll
  need to import the following DataSource definitions to populate the reify
  database::
Switching Servlet Engines
  To switch to another servlet engine, such as Jetty, you just need to remove the
  bin/ and embeddedTomcat/ subdirectories from the
  WEB-INF/ directory inside the zip, and then repackage it as a war with
  WEB-INF/ underneath the root by running something such as:
  
      cd reifyOnSite && jar -cvf reifyOnSite.war *
  in the directory where you originally expanded the Reify OnSite package.  This will produce
  a standard Java war file that can be deployed to any servlet engine / application server
  that supports at least J2SE.