A client browsing pages on a LabKey web site typically sees URLs that look like this:
https://example.com/labkey/home/study-begin.view
The general form is:
<protocol>://<domain>/<contextpath>/<containerpath>/<controller>-<action>
Details on the meaning of each URL part:
| URL Part | Example | Description |
|---|
| protocol | https:// | Supported protocols are http or https (for secure sockets). |
| domain | www.labkey.org | Your server's host domain name. |
| contextpath | labkey | This is the root of the LabKey web application on the server, and is accessible by developers if they need to build URLs that include it. In the JavaScript API library, see LABKEY.ActionURL.getContextPath(). In Java module code, this is accessible from AppProps.getInstance().getContextPath(). |
| containerpath | home/myproject/myfolder | This may consist of multiple parts if the current container is a sub-folder (e.g., “/project/folder/subfolder/”). This helps the LabKey Server know which container the user is working in. The current container information is also available to developers. In the JavaScript API library, see LABKEY.ActionURL.getContainer(). In Java module code, you can get this information from the Container object returned from the getContainer() method on your action base class. (For details on the container hierarchy reflected in the container path, see Site Structure: Best Practices.) |
| controller | study | The term "controller" comes from the Model-View-Controller (MVC) design pattern, where a controller coordinates user interaction with the model (data) as seen through a particular view of that data. The LabKey Server uses the industry-standard Spring framework for its MVC implementation.
In the LabKey Server, the name of the controller typically matches the name of the module. The system assumes that the controller name is the same as the module name unless the module has explicitly registered other controllers. |
| action | begin.view | Modules/controllers may expose one or more actions, each of which may do several things. Simple actions may return a read-only view, while more complex actions may return an HTML form and handle the posted data, updating the database as necessary. Actions typically have the extension “.view” or “.post”. |
Setting the Default URL Pattern
As of version 16.1, new server installations use the following URL pattern by default:
New URL Pattern<protocol>://<domain>/<contextpath>/<containerpath>/<controller>-<action>
Servers installed before version 16.1 use the following URL pattern by default:
Old URL Pattern<protocol>://<domain>/<contextpath>/<controller>/<containerpath>/<action>
The request parsing system will recognize both the older and new URL patterns, treating them as synonyms. For example, the following URLs are identical requests to the server: each URL will take you to the same page.
You can set the server to use the old URL pattern if you prefer. Go to
Admin > Site > Site Console and click
Site Settings. Locate the property
Use "path first" urls. A checkmark next to this property tells the server to use the new URL pattern. No checkmark tells the server to use the older URL pattern. Note that servers installed before version 16.1 will continue to use the old URL pattern, unless an admin explicitly turns on the 'path first' property.
In some cases, the server will attempt to fix mis-constructed URLs. For example, if the server receives the following URL which mistakening refers to two different controllers:
http://<server>/<controllerA>/PATH/<controllerB>-<action>.view
then the server will redirect to following:
http://<server>/PATH/<controllerB>-<action>.view
Folder/Container-Relative Links
The new URL pattern supports folder-relative links in wikis and static files. For example, a static HTML page in a module can use the following to link to the default page for the current folder/container.
<a href="./project-begin.view">Home Page</a>
Token Replacement and Context Paths
Token replacement/expansion is applied to html files before they are rendered in the browser. Available tokens include:
- contextPath - The token "<%=contextPath%>" will expand to the context root of the labkey server (e.g. "/labkey")
- containerPath - The token "<%=containerPath%>" will expand to the current container (eg. "/MyProject/MyFolder").
- webpartContext - The token <%=webpartContext%> is replaced by a JSON object of the form:
{
wrapperDivId: <String: the unique generated div id for the webpart>,
id: <Number: webpart rowid>,
properties: <JSON: additional properties set on the webpart>
}Web resources such as images, javascript, html files can be placed in the /web directory in the root of the module. To reference an image from one of the views pages, use a url such as:
<img src="<%=contextPath%>/my-image.png" />
Build URLs Using the LabKey API
You can build URLs using the
LABKEY.ActionURL.buildURL() API.
Note that URLs built on this API are not guaranteed to be backward compatible indefinitely.
Show the source for this doc page:
window.location = LABKEY.ActionURL.buildURL("wiki", "source", LABKEY.ActionURL.getContainer(), {name: 'url'});The above builds the URL:
https://www.labkey.org/home/Documentation/wiki-source.view?name=urlExample 2: Navigate the browser to the study controller's begin action in the current container:
window.location = LABKEY.ActionURL.buildURL("study", "begin"); Navigate the browser to the study controller's begin action in the folder '/myproject/mystudyfolder':
window.location = LABKEY.ActionURL.buildURL("study", "begin", "/myproject/mystudyfolder");URL Parameters
LabKey URLs can also include additional parameters that provide additional instructions to an action. For example, some
actions accept a
returnUrl parameter. This parameter allows you to tell the action where to forward the user after it is finished.
Some parameters are listed on the
Web Part Configuration Properties page.
URL parameters can be written explicitly as part of an href link, or provided by LabKey APIs.
HREF Example:Suppose you want to have a user input content to a list, then see a specific page after saving changes to the list.
The following snippet executes an insert action in a specified list ('queryName=lists&schemaName=MyListName'). After clicking the link, the user first sees the appropriate insert page for this list. Once the user has entered changes and pressed "Save," the user is delivered to the returnUrl page ('/MyProject/project-begin.view').
<a href="https://www.labkey.org/MyProject/query-insertQueryRow.view?queryName=lists&
schemaName=MyListName&returnUrl=/project/MyProject/begin.view">
Click here to request specimens</a>
This sample navigates to the list controller's insert action, passing a returnUrl parameter that points back to the current page:
window.location = LABKEY.ActionURL.buildURL(
"query",
"insertQueryRow",
LABKEY.ActionURL.getContainer(),
{schemaName: "lists",
queryName: "MyListName",
returnUrl: window.location}
);
A more complex example of using URL parameters via the LabKey API can be found in the following tutorial:
URL Encoding
Substitution syntax for inserting a field value into a URL is covered in
URL Field Property.
