define([
|
'dojo/_base/declare',
|
'dojo/_base/lang',
|
'dojo/_base/array',
|
'dojo/_base/html',
|
'dojo/_base/config',
|
'dojo/cookie',
|
'dojo/Deferred',
|
'dojo/promise/all',
|
'dojo/request/xhr',
|
'./utils',
|
'./WidgetManager',
|
'./shared/utils'
|
],
|
function (declare, lang, array, html, dojoConfig, cookie,
|
Deferred, all, xhr, jimuUtils, WidgetManager, sharedUtils) {
|
var instance = null, clazz;
|
|
clazz = declare(null, {
|
urlParams: null,
|
appConfig: null,
|
rawAppConfig: null,
|
configFile: null,
|
_configLoaded: false,
|
portalSelf: null,
|
|
constructor: function (urlParams, options) {
|
this._removeHash(urlParams);
|
this.urlParams = urlParams || {};
|
this.widgetManager = WidgetManager.getInstance();
|
lang.mixin(this, options);
|
},
|
|
/****************************************************
|
* The app accept the following URL parameters:
|
* ?config=<abc-config.json>, this is a config file url
|
* ?id=<123>, the id is WAB app id, which is created from portal.
|
URL has this parameter means open WAB app from portal.
|
* ?appid=<123>, the appid is portal/AGOL app id, which is created from portal/AGOL template.
|
The template is created from WAB's app.
|
When URL has this parameter, we'll check whether the app is launched
|
in portal/AGOL, or not in portal/AGOL.
|
> IF in portal, we'll use the appid to get portal/AGOL template id and app data,
|
then get WAB app id, then get WAB app config, then merge config;
|
> IF NOT in portal, we'll use the appid to get app data, then merge the data
|
to WAB app config.
|
How to check whether the app is in portal?
|
When try to load config file, if URL has no config or id parameter, we'll load
|
<app>/config.json file. If the app is in XT, the portalUrl in config.json is not empty.
|
If the app is in portal/AGOL, the app is stemapp indeed, which portalUrl is empty.
|
So, if portal url is empty, we consider the app is in portal. However, the exception is
|
launch stemapp directly. The solution is the XT builder will write "wab_portalurl" cookie
|
for stemapp. So, if we find this cookie, we know the app is not in portal.
|
* ?itemid=<itemid>, this webmap item will override the itemid in app config
|
* ?mode=<config|preview>, this is for internal using purpose
|
* ?URL parameters that affect map extent
|
********************************************************/
|
loadConfig: function () {
|
console.time('Load Config');
|
return this._tryLoadConfig().then(lang.hitch(this, function(appConfig) {
|
var err = this.checkConfig(appConfig);
|
if (err) {
|
throw err;
|
}
|
this.rawAppConfig = lang.clone(appConfig);
|
appConfig = this._upgradeAppConfig(appConfig);
|
this._processAfterTryLoad(appConfig);
|
this.appConfig = appConfig;
|
|
return this.loadWidgetsManifest(appConfig).then(lang.hitch(this, function() {
|
return this.loadAndUpgradeAllWidgetsConfig(appConfig);
|
})).then(lang.hitch(this, function() {
|
this._configLoaded = true;
|
if(appConfig.title){
|
document.title = appConfig.title;
|
}
|
return this.getAppConfig();
|
}));
|
}), lang.hitch(this, function(err){
|
this.showError(err);
|
}));
|
},
|
|
getAppConfig: function(){
|
var c = lang.clone(this.appConfig);
|
c.getConfigElementById = function(id){
|
return jimuUtils.getConfigElementById(this, id);
|
};
|
|
c.getConfigElementsByName = function(name){
|
return jimuUtils.getConfigElementsByName(this, name);
|
};
|
|
c.visitElement = function(cb){
|
jimuUtils.visitElement(this, cb);
|
};
|
|
|
return c;
|
},
|
|
checkConfig: function(){
|
return false;
|
},
|
|
addNeedValues: function(appConfig){
|
this._processNoUriWidgets(appConfig);
|
this._processEmptyGroups(appConfig);
|
this._addElementId(appConfig);
|
|
//do't know why repreated id is generated sometimes, so fix here.
|
this._fixRepeatedId(appConfig);
|
},
|
|
showError: function(err){
|
if(err && err.message){
|
html.create('div', {
|
'class': 'app-error',
|
innerHTML: jimuUtils.sanitizeHTML(err.message)
|
}, document.body);
|
}
|
},
|
|
_tryLoadConfig: function() {
|
if(this.urlParams.id === 'stemapp'){
|
this.urlParams.config = window.appInfo.appPath + 'config.json';
|
delete this.urlParams.id;
|
}
|
if(this.urlParams.config) {
|
this.configFile = this.urlParams.config;
|
return xhr(this.configFile, {
|
handleAs: 'json',
|
headers: {
|
"X-Requested-With": null
|
}
|
}).then(lang.hitch(this, function(appConfig){
|
return appConfig;
|
}));
|
}else if(this.urlParams.id){
|
|
} else{
|
this.configFile = "config.json";
|
return xhr(this.configFile, {handleAs: 'json'}).then(lang.hitch(this, function(appConfig){
|
|
return appConfig;
|
}));
|
}
|
},
|
|
_upgradeAppConfig: function(appConfig){
|
var appVersion = window.wabVersion;
|
var configVersion = appConfig.wabVersion;
|
var newConfig;
|
|
//save wabVersion in app config json here
|
appConfig.configWabVersion = appConfig.wabVersion;
|
|
if(appVersion === configVersion){
|
return appConfig;
|
}
|
var configVersionIndex = this.versionManager.getVersionIndex(configVersion);
|
var appVersionIndex = this.versionManager.getVersionIndex(appVersion);
|
if(configVersionIndex > appVersionIndex){
|
throw Error('Bad version number, ' + configVersion);
|
}else{
|
newConfig = this.versionManager.upgrade(appConfig, configVersion, appVersion);
|
newConfig.wabVersion = appVersion;
|
return newConfig;
|
}
|
},
|
|
loadAndUpgradeAllWidgetsConfig: function(appConfig){
|
var def = new Deferred(), defs = [];
|
|
sharedUtils.visitElement(appConfig, lang.hitch(this, function(e){
|
if(!e.uri){
|
return;
|
}
|
var upgradeDef = this.widgetManager.tryLoadWidgetConfig(e);
|
defs.push(upgradeDef);
|
}));
|
all(defs).then(lang.hitch(this, function(){
|
def.resolve(appConfig);
|
}), function(err){
|
def.reject(err);
|
});
|
return def;
|
},
|
|
_processAfterTryLoad: function(appConfig){
|
this._processUrlParams(appConfig);
|
|
this.addNeedValues(appConfig);
|
|
return appConfig;
|
},
|
|
_processNoUriWidgets: function(appConfig){
|
var i = 0;
|
sharedUtils.visitElement(appConfig, function(e, info){
|
if(info.isWidget && !e.uri){
|
i ++;
|
e.placeholderIndex = i;
|
}
|
});
|
},
|
|
_processEmptyGroups: function(appConfig){
|
var i = 0;
|
if(!appConfig.widgetOnScreen.groups){
|
return;
|
}
|
array.forEach(appConfig.widgetOnScreen.groups, function(g){
|
if(!g.widgets || g.widgets && g.widgets.length === 0){
|
i ++;
|
g.placeholderIndex = i;
|
}
|
});
|
},
|
|
_addElementId: function (appConfig){
|
var maxId = 0, i;
|
|
sharedUtils.visitElement(appConfig, function(e){
|
if(!e.id){
|
return;
|
}
|
//fix element id
|
e.id = e.id.replace(/\//g, '_');
|
|
var li = e.id.lastIndexOf('_');
|
if(li > -1){
|
i = e.id.substr(li + 1);
|
maxId = Math.max(maxId, i);
|
}
|
});
|
|
sharedUtils.visitElement(appConfig, function(e){
|
if(!e.id){
|
maxId ++;
|
if(e.itemId){
|
e.id = e.itemId + '_' + maxId;
|
}else if(e.uri){
|
e.id = e.uri.replace(/\//g, '_') + '_' + maxId;
|
}else{
|
e.id = '' + '_' + maxId;
|
}
|
}
|
});
|
},
|
|
|
_removeHash: function(urlParams){
|
for(var p in urlParams){
|
if(urlParams[p]){
|
urlParams[p] = urlParams[p].replace('#', '');
|
}
|
}
|
},
|
|
loadWidgetsManifest: function(config){
|
var defs = [], def = new Deferred();
|
if(this.urlParams.manifest && config._buildInfo && config._buildInfo.widgetManifestsMerged){
|
delete config._buildInfo.widgetManifestsMerged;
|
}
|
if(config._buildInfo && config._buildInfo.widgetManifestsMerged){
|
this._loadMergedWidgetManifests().then(lang.hitch(this, function(manifests){
|
sharedUtils.visitElement(config, lang.hitch(this, function(e){
|
if(!e.widgets && (e.uri || e.itemId)){
|
if(e.uri && manifests[e.uri]){
|
this._addNeedValuesForManifest(manifests[e.uri], e.uri);
|
jimuUtils.widgetJson.addManifest2WidgetJson(e, manifests[e.uri]);
|
}else{
|
defs.push(loadWidgetManifest(this.widgetManager, e, config.portalUrl));
|
}
|
}
|
}));
|
all(defs).then(function(){
|
def.resolve(config);
|
});
|
}));
|
}else{
|
sharedUtils.visitElement(config, lang.hitch(this, function(e){
|
if(!e.widgets && (e.uri || e.itemId)){
|
defs.push(loadWidgetManifest(this.widgetManager, e, config.portalUrl));
|
}
|
}));
|
all(defs).then(function(){
|
def.resolve(config);
|
});
|
}
|
|
function loadWidgetManifest(widgetManager, e, portalUrl){
|
function _doLoadWidgetManifest(e){
|
return widgetManager.loadWidgetManifest(e).then(function(manifest){
|
return manifest;
|
}, function(err){
|
console.log('Widget failed to load, it is removed.', e.name);
|
|
if(err.stack){
|
console.error(err.stack);
|
}else{
|
//TODO err.code === 400, err.code === 403
|
console.log(err);
|
}
|
deleteUnloadedWidgets(config, e);
|
});
|
}
|
|
if(e.itemId){
|
|
}else{
|
return _doLoadWidgetManifest(e);
|
}
|
}
|
|
function isWidgetUsable(/*widgetUrl*/){
|
return true;
|
}
|
|
function deleteUnloadedWidgets(config, e){
|
//if has e, delete a specific widget
|
//if has no e, delete all unloaded widget
|
deleteInSection('widgetOnScreen');
|
deleteInSection('widgetPool');
|
|
function deleteInSection(section){
|
if(config[section] && config[section].widgets){
|
config[section].widgets = config[section].widgets.filter(function(w){
|
if(e){
|
return w.id !== e.id;
|
}else{
|
if(w.uri && !w.manifest){
|
console.error('Widget is removed because it is not loaded successfully.', w.uri);
|
}
|
return w.manifest;
|
}
|
});
|
}
|
if(config[section] && config[section].groups){
|
config[section].groups.forEach(function(g){
|
if(g.widgets){
|
g.widgets = g.widgets.filter(function(w){
|
if(e){
|
return w.id !== e.id;
|
}else{
|
if(w.uri && !w.manifest){
|
console.error('Widget is removed because it is not loaded successfully.', w.uri);
|
}
|
return w.manifest;
|
}
|
});
|
}
|
});
|
}
|
}
|
}
|
|
setTimeout(function(){
|
//delete problem widgets to avoid one widget crash app
|
if(!def.isResolved()){
|
deleteUnloadedWidgets(config);
|
def.resolve(config);
|
}
|
}, 60 * 1000);
|
return def;
|
},
|
|
_addNeedValuesForManifest: function(manifest, uri){
|
lang.mixin(manifest, jimuUtils.getUriInfo(uri));
|
|
jimuUtils.manifest.addManifestProperies(manifest);
|
jimuUtils.manifest.processManifestLabel(manifest, dojoConfig.locale);
|
},
|
|
_loadMergedWidgetManifests: function(){
|
var file = window.appInfo.appPath + 'widgets/widgets-manifest.json';
|
return xhr(file, {
|
handleAs: 'json'
|
});
|
},
|
|
_fixRepeatedId: function(appConfig){
|
var id = [];
|
sharedUtils.visitElement(appConfig, function(e){
|
if(id.indexOf(e.id) >= 0){
|
e.id += '_';
|
}
|
id.push(e.id);
|
});
|
},
|
|
//we use URL parameters for the first loading.
|
//After loaded, if user changes app config through builder,
|
//we'll use the configuration in builder.
|
_processUrlParams: function(appConfig){
|
var urlWebmap = this.urlParams.itemid || this.urlParams.webmap;
|
if(urlWebmap && appConfig.map.itemId !== urlWebmap){
|
if(appConfig.map.mapOptions){
|
jimuUtils.deleteMapOptions(appConfig.map.mapOptions);
|
}
|
appConfig.map.itemId = urlWebmap;
|
}
|
if(this.urlParams.mode){
|
appConfig.mode = this.urlParams.mode;
|
}
|
if(!appConfig.map.mapOptions){
|
appConfig.map.mapOptions = {};
|
}
|
|
if(this.urlParams.scale){
|
appConfig.map.mapOptions.scale = this.urlParams.scale;
|
}
|
if(this.urlParams.level || this.urlParams.zoom){
|
appConfig.map.mapOptions.zoom = this.urlParams.level || this.urlParams.zoom;
|
}
|
}
|
});
|
|
clazz.getInstance = function (urlParams, options) {
|
if(instance === null) {
|
instance = new clazz(urlParams, options);
|
}else{
|
instance.urlParams = urlParams || {};
|
instance.options = options;
|
}
|
return instance;
|
};
|
|
return clazz;
|
});
|
