Package com.smartgwt.client.docs

# Interface ReifyOnSite

public interface ReifyOnSite

### Reify OnSite

What is Reify OnSite?

`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
isc_hostedSearches | saved searches | 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:

- Place the number 1 in the "Org Id" field, since Reify OnSite currently only supports a single organization. If in the future, full organization support is added, this field will allow different customizations to be added for each organization.
- In the "Load Style" field, we recommend selecting "externalFile", as then the contents you enter can be the URL of a JavaScript file rather than actual JS. If you want to enter the JS directly in this table, select "inline" instead.
- Enter the "Contents" that will be loaded, as either the URL of a JavaScript file (for "externalFile" mode), or the JS itself (for "inline" mode). When entering a URL, note that both relative (e.g. `/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::

- isc_hostedProjects
- isc_hostedScreens
- isc_hostedDataSources
- isc_hostedSettings
- isc_hostedUsers
- isc_hostedRoles
- isc_hostedSessions
- isc_hostedSearches
- isc_hostedDeployments
- isc_userSkin

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.

Skin Editor Requirements (Ruby and Compass)

Reify OnSite's `Skin Editor` feature, which allows creating and customizing skins/themes, requires Ruby and the Compass gem to be installed on the server. These utilities are used to compile SCSS (Sass) stylesheets into CSS when a custom skin is created or modified.

What breaks without Ruby/Compass: The Skin Editor will fail to compile custom skins. When attempting to save a customized skin, an error will be reported indicating that the `compass` command could not be executed. All other Reify OnSite functionality will work normally; only creating or modifying custom skins requires these utilities.

How these utilities are used: The Smart GWT server invokes the system `compass compile` command via Java's process execution API (`ISCSystem.execute()`) to transform SCSS files into the final CSS used by skins.

Installation: To enable the Skin Editor, install Ruby and the Compass gem. Compass 1.0.3 (the final release) requires Ruby 2.5 to 2.7; it is not compatible with Ruby 3.x:

- On Linux (Debian/Ubuntu):

          sudo apt-get install ruby
            sudo gem install compass

- On Linux (RHEL/CentOS):

          sudo yum install ruby
            sudo gem install compass

- On macOS: Ruby is typically pre-installed; just install Compass:

          sudo gem install compass

- On Windows: Install Ruby from RubyInstaller, then open a command prompt and run:

          gem install compass

Ensure the `compass` command is available in the system PATH for the user account running the servlet engine.