Domain

Configuration

As with all data stores, this data store maintain a configuration document that contains system and custom properties. You can write your own properties onto this configuration document if you wish. You might use those properties to query and retrieve the directory at a later time.

Some system properties are read-only and others are writable. You can adjust the writable properties to modify the behavior and characteristics of the directory.

The following table presents you the system properties.

Data Store Properties

{{#if containerTypeId}} {{/if}}

Data Store Type	{{#dataTypeArticle datastoreTypeId}}{{datastoreTypeId}}{{/dataTypeArticle}}
Container	{{#dataTypeArticle containerTypeId}}{{containerTypeId}}{{/dataTypeArticle}}
Supports	{{#article "security/teams"}}teams{{/article}}, {{#article "security/authorities"}}authorities{{/article}}, {{#article "security/permissions"}}permissions{{/article}}, {{#article "binaries"}}binaries{{/article}}, {{#article "transfer"}}transfer{{/article}}

Any system properties that are shown to be Read-Only are not modifiable on calls to create() or update(). Anything else is fair game.

Property	Type	Default	Read-Only	Description
title	text			The title of the data store.
description	text			A description for the data store.
enableAuthorities	boolean	true		If true, the data store will check whether the current principal has rights to perform an operation against content upon interaction. If turned off, you'll see some performance benefits. This should only ever be switched off for "published" or general availability content and never for authoring-side content.
enableAuditing	boolean	false		If true, then the data store will collect audit records for all service-level operations (such as CRUD operations). This incurs a slight performance penalty but guarantees you a record of all interactions with data for changesets, branches and nodes in the data store.
locked	boolean	false	Read-only	Whether the data store is presently locked. If the data store is locked, then write operations against it will block.
lockedBy	text		Read-only	The principal that holds the lock (if the data store is locked).
size	number	0	Read-only	The last-recorded allocation size (on disk) of the data store in bytes. This value is updated periodically and may not be precise at the moment it is read.
maxsize	number	-1		The maximum allowed allocation size (on disk) of the data store in bytes. If this size of the data store exceeds this value, write operations will fail. A value of -1 indicates that there is no upper limit.
objectcount	number	0	Read-only	The number of objects stored within the data store. This includes system-maintained objects. This value is updated periodically and may not be precise at the moment it is read.
statisticsDate	timestamp		Read-only	Records the time when statistics were last run against the data store. Statistics are run periodically to calculate the data store size and object allocations.
statisticsDirty	boolean	false	Read-only	Whether writes have occurred against this data store since the last time statistics were run. This signals to the system that statistics need to be collected at the next available opportunity.

Create a Domain

You can create an empty domain like this:

platform.createDomain();

Or you can pass in configuration which will be applied to the domain. You can pass in any properties you'd like. These properties will become part of the domain configuration and you can utilize that however you'd like.

platform.createDomain({
    "title": "My first domain",
    "description": "Oh who are the people in my neighborhood"
});

Here is an example where we create a domain and then immediately display a property and then update it.

platform.createDomain({
    "title": "My first domain",
    "country": "USA"
}).then(function() {
        console.log("Country: " + this.get("country"));
    })

Update a Domain

To update a domain, you just adjust its properties and then tell the server to update.

domain.set("country", "Canada");
domain.update();

Here is an example that creates a domain and then immediately updates it.

platform.createDomain({
    "title": "The Rise and Fall of Ziggy Stardust and the Spiders from Mars",
    "country": "USA"
}).then(function() {

    // yay, my domain was successfully created!

    // display the country
    console.log("Country: " + this.get("country"));

    // update the directory
    this.set("country", "Canada");
    this.update();
});

Delete a Domain

Once you delete a domain, it's gone for good. If you're not sure whether you'll need it again in the future, you might want to archive it first.

Here is an example of a simple delete.

domain.del();

And here is an example where we create, update and then delete.

platform.createDomain().update().del();

Read a Domain

Reading a domain is really quite simple provided that you know what you're looking for. You retrieve domains by their ID - the _doc field.

// suppose we know the domain id ahead of time
var domainId = "4b5b685c980c10f98beb";

// read the domain
platform.readDomain(domainId);

Granted, in many cases you won't know the domain ID off-hand. You'll likely need to look up the domain ID ahead of time by some other means. Read further on this page for examples of how you can do this.

List Domains

You can retrieve a list of domains for your platform quite easily. The following code hands back the full list.

platform.listDomains();

You can then iterate over the list to pick at what you'd like.

platform.listDomains().each(function() {
    console.log("Domain title: " + this.get("title"));
});

Retrieving the full list is potentially an expensive operation, depending how many domains you have. The more your retrieve, the more data goes over the wire and so forth. Thus, you might wish to paginate your call and retrieve a subset of the total list at a time.

Here is an example that retrieves in pages of size 10. It starts on the second page (by skipping to starting index 20). It also sorts by the title field in a descending sequence.

platform.listDomains({
    "limit": 10,
    "skip": 20,
    "sort": { "title": -1 }
}).each(function() {
    console.log("Domain title: " + this.get("title"));
});

You don't have to have all of the pagination parameters (limit, skip and sort). You might only want to include one or two. It's up to you.

Query Domains

You can run custom queries against your domains to find exactly what you're looking for. Here is a query that looks for domains whose field country is "USA".

platform.queryDomains({
    "country": "USA"
});

Here is that same query followed by an iteration over the result map.

platform.queryDomains({
    "country": "USA"
}).each(function(id) {
    console.log("Found a domain: " + id + " with title: " + this.get("title"));
});

Cloud CMS utilizes the MongoDB query syntax under the hood. As such, you can really go to town. You're able to express queries with some pretty rich complexity.

Here is a query that finds all domains created after July 4, 2012.

var milliseconds = new Date(2012, 7, 4, 0, 0, 0, 0).getTime();
platform.queryDomains({
    "_system.createdon.ms": { "$gt": milliseconds }
}).each(function(id) {
    console.log("Found a domain: " + id + " with title: " + this.get("title"));
});

Finally, you can mix queries with pagination to reduce data over the wire and speed up performance. Here is that same query with some pagination thrown in. We limit to pages of size 10 and sort by title.

// the milliseconds for July 4, 2012
var milliseconds = new Date(2012, 7, 4, 0, 0, 0, 0).getTime();

// our query
var query = {
    "_system.createdon.ms": { "$gt": milliseconds }
};

// pagination parameters
var pagination = {
    "limit": 10,
    "skip": 20,
    "sort": {
        "title": -1
    }
};

// run the query and iterate over the result set
platform.queryDomains(query, pagination).each(function(id) {
    console.log("Found a domain: " + id + " with title: " + this.get("title"));
});