Configuration

{
  ...
  // properties section (optional)
  "properties" : {
    "title" : "${apptitle}"
  },
  ...
}

{
  ...
  "properties" : {
    // app id
    id: "sample",
    // title
    title: "Sample",
    // description of the app
    description: "Sample application",
    // editor state
    editorState: "PUBLISHED",
    // user who created the application
    createdBy: "admin",
    // timestamp when the application was created
    createdAt: 1354314261408,
    // user who last modified the application
    modifiedBy: "admin",
    // timestamp when the application was last modified
    modifiedAt: 1354314268706,
    // the uploaded filename of the application template
    templateFile: "poicache.zip",
    // id of the application template
    templateId: "13B536ACA54D56",
    // preview image url
    thumbnailFile: null
  },
  ...
}

<div ... >
  <div ...>${appProps.title}</div>
</div>

{
  ...
  "load": {
    "allowedBundles": ["splashscreen","map", "windowmanager","system","templatelayout","templates","themes","reporttool@>=3.1.1"],
    "require": ["${app}/app"],
    "i18n": ["bundle"],
    "styles": ["${app}:app.css"]
  }
}

// assume that following package is registered at the AMD loader
require({
    packages : [{
        name : "myprefix",
        location : "http://localhost:8080/mybundles"
    }]
});


{
    "load": {
        // define http://localhost:8080/mybundles/bundles.json as source for bundle meta information
        "bundleLocations":["myprefix"]
    }
}


{
    "load": {
        // define http://localhost:8080/mybundles/test/bundles.json as source for bundle meta information
        "bundleLocations":["myprefix/test"]
    }
}


{
    "load": {
        // define http://localhost:8080/mybundles/mybundles.json as source for bundle meta information
        "bundleLocations":["myprefix/mybundles.json"]
    }
}

{
    "load": {
        // define http://localhost:8080/mybundles/bundles.json as source for bundle meta information
        "bundleLocations":["http://localhost:8080/mybundles"]
    }
}

{
    "load": {
        // define exactly that http://localhost:8080/mybundles/mybundles.json as source for bundle meta information
        "bundleLocations":["http://localhost:8080/mybundles/mybundles.json"]
    }
}

{
    "load": {
        // define an HTML page relative location as bundle location
        "bundleLocations":["./mybundles/mybundles.json"]
    }
}

// app.json

{
    "load": {
        "bundleLocations":[{
            // lookup myprefix and load mybundles.json
            "name" : "myprefix/mybundles.json"
        }]
    }
}

{
    "load": {
        "bundleLocations":[{
            // define a name and an explicit location
            "name" : "mybundles",
            "location" : "http://localhost:8080/mybundles"
        }]
    }
}

// The main reason to use the object syntax is to define additional properties which control the loading process from the registry
{
    "load" : {
        "bundleLocations":[{
            // define the location
            "name" : "mybundles",

            // list of bundle names which should not loaded from this registry.
            "excludes" : ["bundlename"],

            // jsonp not allowed for this registry
            "useJSONP" : false,

            // relative or absolute URL which should be requested to prefetch the JavaScript files from this registry
            "prefetch" : "./bundles.js",

            // disable the prefetching of JavaScript files for this registry
            "noprefetch" : true
        }]
    }
}

{
  ...,

  "bundles" : {
    "map" : {                          // name of the bundle
      "MapState" : {                   // name of the component
        "initialExtent":{              // name of the property (if property has complex value, it must fully be redeclared)
          "xmin" : 267804.1562000003,
          "ymin" : 5565553.608100001,
          "xmax" : 544362.0157999999,
          "ymax" : 5832335.593900001,
          "spatialReference": {
            "wkid": 25832
          }
        }
      }
    },
    "agssearch": {
      "AGSStore": [         // sample of factory component, here an array style must be used
      {
        "id": "Helipads",
        "url": "http://...",
        ...
      },
      {
        "id": "LargeAirportPoints",
        "url": "http://...",
        ...
      }
      ]
    }

  ...
  }
}

module.exports = {
  root : {
    "mykey" : "Test",
    "map" : {
      "bundleName" : "New Map Bundle Name"
    }
  },
  de: true
}

{
  ...,

  "bundles" : {
    "mybundle": {
      "MyComponent":{
        "windowTitle": "${mykey}"
      }
    }
  }
}

module.exports = {
  root : {
    "<bundlename>" : {
      "<original i18nKey in bundle>" : "<new value>"
    },
    ...
  },
  de: true
}

{
  ...,

  "bundles" : {
    "mybundle": {
      "MyComponent":{
      // pattern is: "${app}:<path>/<file>"
      "url": "${app}:images/test.png"
    }
  }
}

{
  ...,
  "bundles" : {
    "mybundle": {
      "MyComponent":{
        "url": "resource('${app}:images/test.png')"
      }
    }
  }
}

// get injected configuration admin service (ct.framework.api.ConfigurationAdmin)
let configAdminService = this.configAdminService;

// need to know a concrete pid
let pid = "map-MapWidgetFactory";

// need to know a concrete bundle identifier (symbolic name)
let bundleIdentifier = "map";

// read configuration entry
let config = configAdminService.getConfiguration(pid, bundleIdentifier);

// properties are a plain object
let configProperties = config.get("properties");

...
// change the configuration
configProperties.newProperty = "test";


// use the update method of the configuration entry to update the configuration data
// note: this triggers a runtime component update
config.update(configProperties);

// deletes the configuration entry
config.remove();

modifyConfiguration(targetInfo, configProperties){
    // targetInfo can be used to get information about the target component, which properties are given in "configProperties".
    let managedServiceProperties = targetInfo.managedServiceProperties;
    // the persistent identifier
    let targetPid = targetInfo.pid;
    // the factory persistent identifier
    let targetPid = targetInfo.factoryPid;

    // to change the or extent the configuration, simple change the configProperties
    configProperties.changedProperty = "test";

    // optional, allowed to return fully different properties
    return configProperties;
}

{
    "name" : "MyConfigPlugin",
    "provides" : ["ct.framework.api.ConfigurationPlugin"],
    "properties" : {

        // array of pids or factory pids, for which this plugin should be called
        // if the property is not specified or a empty array, the plugin is called for each target service
        "CM-Target-Pids" : ["themes-ThemeModel"],

        // if more than one plugin is configured, the ranking can control the order.
        // lower rankings are called before higher rankings
        // a plugin with high ranking can overwrite the changes of plugin with a lower ranking
        // default value is 0
        "CM-Ranking" : 0
    }]
}

// A ConfigurationInterceptor must implement the method "intercept"

intercept(configStore){

        // read old config
        let oldConfig = configStore.getConfig("oldbundle-ComponentName");

        // delete old config
        configStore.removeConfig("oldbundle-ComponentName");

        // check if a config exists
        if (configStore.getConfig("newbundle-ComponentName")){
                // do nothing if config is present
            return;
        }

        // write new configuration
        configStore.setConfig("newbundle-ComponentName",{
                bundleIdentifier: "newbundle",
                properties: {
                        ...
                }
        });
}

{
    "name" : "MyConfigInterceptor",
    "provides" : ["system.config.ConfigurationInterceptor"]
}

// get injected configuration admin service (ct.framework.api.ConfigurationAdmin)
let configAdminService = this.configAdminService;

// to trigger the storage of any changed configurations call "save" on the configuration admin serivce
// note this works only if a persistence layer exists
configAdminService.save();