var assetManager = function(session, type) {
var am;
var user = server.current(ctx.session);
//Create asset manager depend on whether there is a loggedIn user or not.
if (user) {
am = rxt.asset.createUserAssetManager(ctx.session, type);
} else {
var carbon = require('carbon');
var tenantAPI = require('/modules/tenant-api.js').api;
var tenantDetails = tenantAPI.tenantContext(session);
var tenantId = tenantDetails.urlTenantId; //carbon.server.superTenant.tenantId;
am = rxt.asset.createAnonAssetManager(ctx.session, type, tenantId);
}
return am;
};
api.get = function(options, req, res, session) {
var asset = require('rxt').asset;
var assetManager = asset.createUserAssetManager(session, options.type);
try {
var retrievedAsset = assetManager.get(options.id);
if (!retrievedAsset) {
// print(responseProcessor.buildSuccessResponse(200, 'No matching asset found by' + options.id, []));
return null;
} else {
var expansionFields = (request.getParameter('fields') || '');
if (expansionFields) {
options.fields = expansionFields.split(',');
var assets = [];
assets.push(retrievedAsset);
options.assets = assets;
result = fieldExpansion(options, req, res, session);
} else {
result = retrievedAsset;
}
// print(responseProcessor.buildSuccessResponse(200, 'Request Served Sucessfully', result));
}
} catch (e) {
//res.sendError(400, "No matching asset found");
// print(responseProcessor.buildErrorResponse(400, "No matching asset found"));
log.error(e);
result = null;
}
return result;
};
assetCombinedWithRXT: function(page){
if (page.assets && page.assets.type) {
var rxt = require('rxt');
var am = rxt.asset.createUserAssetManager(ctx.session,page.assets.type);
page.assetWithRxt = am.combineWithRxt(page.assets);
}
}
gregAPI.serviceDiscovery.save = function (session, type, serverId, discoveryServicesData, existArtifactStrategy,
orphanArtifactStrategy) {
var HashMap = java.util.HashMap;
var ArrayList = java.util.ArrayList;
var discoveryServiceDataMap = new HashMap();
for (var key in discoveryServicesData) {
var detachedGenericArtifactList = new ArrayList();
for (var key2 in discoveryServicesData[key].data) {
var DetachedGenericArtifact = Packages.org.wso2.carbon.governance.api.generic.dataobjects
.DetachedGenericArtifactImpl;
var Gson = Packages.com.google.gson.Gson;
var gson = new Gson();
var result = gson.fromJson(stringify(discoveryServicesData[key].data[key2]), DetachedGenericArtifact);
detachedGenericArtifactList.add(result);
}
discoveryServiceDataMap.put(discoveryServicesData[key].serviceType, detachedGenericArtifactList);
}
var ServerDiscoveryService = Packages.org.wso2.carbon.governance.registry.extensions.discoveryagents.
ServerDiscoveryService;
var serverDiscoveryService = new ServerDiscoveryService();
var rxt = require('rxt');
var assetManager = rxt.asset.createUserAssetManager(session, type);
var serverArtifact = assetManager.am.manager.getGenericArtifact(serverId);
return serverDiscoveryService.persistArtifacts(discoveryServiceDataMap, serverArtifact, existArtifactStrategy,
orphanArtifactStrategy);
};
api.create = function(options, req, res, session) {
var asset = require('rxt').asset;
var am = asset.createUserAssetManager(session, options.type);
var assetReq = req.getAllParameters('UTF-8');
var asset = am.importAssetFromHttpRequest(assetReq);
putInStorage(options, asset, am, req, session);
try {
am.create(asset);
} catch (e) {
log.error('Asset of type: ' + options.type + ' was not created due to ' + e);
//print(responseProcessor.buildErrorResponse(500, 'Failed to create asset of type: ' + options.type));
return null;
}
var isLcAttached = am.attachLifecycle(asset);
//Check if the lifecycle was attached
if (isLcAttached) {
var synched = am.synchAsset(asset);
if (synched) {
am.invokeDefaultLcAction(asset);
} else {
log.warn('Failed to invoke default action as the asset could not be synched.')
}
}
return asset;
};
api.search = function(options, req, res, session) {
var asset = require('rxt').asset;
var assetManager = asset.createUserAssetManager(session, options.type);
var sort = (request.getParameter("sort") || '');
var sortOrder = DEFAULT_PAGIN.sortOrder;
if (sort) {
var order = sort.charAt(0);
if (order == '+' || order == ' ') {
sortOrder = 'ASC';
sort = sort.slice(1);
} else if (order == '-') {
sortOrder = 'DESC';
sort = sort.slice(1);
} else {
sortOrder = DEFAULT_PAGIN.sortOrder;
}
}
var sortBy = (sort || DEFAULT_PAGIN.sortBy);
var count = (request.getParameter("count") || DEFAULT_PAGIN.count);
var start = (request.getParameter("start") || DEFAULT_PAGIN.start);
var paginationLimit = (request.getParameter("paginationLimit") || DEFAULT_PAGIN.paginationLimit);
var paging = {
'start': start,
'count': count,
'sortOrder': sortOrder,
'sortBy': sortBy,
'paginationLimit': paginationLimit
};
var q = (request.getParameter("q") || '');
try {
if (q) {
var qString = '{' + q + '}';
var query = parse(qString);
var assets = assetManager.search(query, paging); //doesnt work properly
} else {
var assets = assetManager.list(paging);
}
var expansionFields = (request.getParameter('fields') || '');
if (expansionFields) {
options.fields = expansionFields.split(',');
options.assets = assets;
result =fieldExpansion(options, req, res, session);
//return;
} else {
result = assets;
}
//res = responseProcessor.buildSuccessResponse(res,200,result);
} catch (e) {
//res = responseProcessor.buildErrorResponse(400, "Your request is malformed");
//print();
result = null;
log.error(e);
}
return result;
};
api.remove = function(options, req, res, session) {
var asset = require('rxt').asset;
var am = asset.createUserAssetManager(session, options.type);
try {
am.remove(options.id);
result=true;
} catch (e) {
log.error('Asset with id: ' + asset.id + ' was not deleted due to ' + e);
result = false;
}
return result;
};
var resolve = function(path) {
var themeResolver = this.__proto__.resolve;
var asset = require('rxt').asset;
var app = require('rxt').app;
var appPath = app.resolve(request, path, this.name, this, themeResolver, session);
if (!appPath) {
path = asset.resolve(request, path, this.name, this, themeResolver);
} else {
path = appPath;
}
return path;
};
api.get = function(options, req, res, session) {
var asset = require('rxt').asset;
var server = require('store').server;
var userDetails = server.current(session);
var assetManager = null;
var domain = options.domain || "carbon.super";
var tenantId = carbon.server.tenantId({
domain: domain
});
if (!userDetails) {
assetManager = asset.createAnonAssetManager(session, options.type, tenantId);
} else {
assetManager = asset.createUserAssetManager(session, options.type);
}
try {
var retrievedAsset = assetManager.get(options.id);
if (!retrievedAsset) {
// print(responseProcessor.buildSuccessResponse(200, 'No matching asset found by' + options.id, []));
return null;
} else {
var expansionFields = (request.getParameter('fields') || '');
if (expansionFields) {
options.fields = expansionFields.split(',');
var assets = [];
assets.push(retrievedAsset);
options.assets = assets;
result = fieldExpansion(options, req, res, session);
} else {
result = retrievedAsset;
}
// print(responseProcessor.buildSuccessResponse(200, 'Request Served Sucessfully', result));
}
} catch (e) {
//res.sendError(400, "No matching asset found");
// print(responseProcessor.buildErrorResponse(400, "No matching asset found"));
log.error(e);
result = null;
}
return result;
};
publicMethods.getAssetId = function (deviceType) {
var paging = {
'start': 0,
'count': 10,
'sortOrder': 'ASC',
'sortBy': '',
'paginationLimit': 1000
};
var asset = require('rxt').asset;
var assetManager = asset.createUserAssetManager(session, "deviceType");
var assets = assetManager.advanceSearch({"overview_name": deviceType}, paging);
if (assets && assets.length > 0) {
return assets[0].id;
}
return 0;
};
gregAPI.serviceDiscovery.discovery = function (session, type, id) {
var rxt = require('rxt');
var assetManager = rxt.asset.createUserAssetManager(session, type);
var genericArtifact = assetManager.am.manager.getGenericArtifact(id);
var ServerDiscoveryService = Packages.org.wso2.carbon.governance.registry.extensions.discoveryagents.
ServerDiscoveryService;
var serverDiscoveryService = new ServerDiscoveryService();
try {
return serverDiscoveryService.discoverArtifacts(genericArtifact);
} catch (e) {
log.error('Message - ' + e.message);
log.error('File name - ' + e.fileName);
log.error('Line number - ' + e.lineNumber);
throw 'Discovery agent is not configured properly.';
}
};
var resolve = function(path) {
var themeResolver = this.__proto__.resolve;
var asset = require('rxt').asset;
path = asset.resolve(request, path, this.name, this, themeResolver);
/*var p,
publisher = require('/modules/publisher.js'),
asset = publisher.currentAsset();
if (asset) {
p = publisher.ASSETS_EXT_PATH + asset + '/themes/' + this.name + '/' + path;
if (new File(p).isExists()) {
return p;
}
}
var actualPath=this.__proto__.resolve.call(this, path);
log.info('Actual path: '+actualPath);*/
return path;
};
var resolve = function(path) {
/*var themeResolver = this.__proto__.resolve;
var asset = require('rxt').asset;
path = asset.resolve(request, path, this.name, this, themeResolver);
return path;*/
var themeResolver = this.__proto__.resolve;
var asset = require('rxt').asset;
var app = require('rxt').app;
for(var key in this.engine.partials){
}
var appPath = app.resolve(request, path, this.name, this, themeResolver, session);
if (!appPath) {
path = asset.resolve(request, path, this.name, this, themeResolver);
} else {
path = appPath;
}
return path;
};
create: function(options) {
var url = options.overview_url;
var name = options.overview_name;
var version = options.overview_version;
var userRegistry = getRegistry(ctx.session);
var utils = Packages.org.wso2.carbon.registry.resource.services.utils.ImportResourceUtil;
var parentPath = "/_system/governance/trunk/wsdls/".concat(version);
var mediaType = "application/wsdl+xml";
var javaArray = Packages.java.lang.reflect.Array;
var properties = javaArray.newInstance(java.lang.String, 1, 2);
properties[0][0] = 'version';
properties[0][1] = version;
var rxt = require('rxt');
var am = rxt.asset.createUserAssetManager(ctx.session, this.type);
var query = {};
query.overview_name = name;
query._wildcard = false;
var assets = am.search(query);
for (var i = 0; i < assets.length; i++) {
if (assets[i].version == version) {
var msg = "resource already exist with Name \"" + name + "\" and version \"" + version + "\"";
var exceptionUtils = require('utils');
var exceptionModule = exceptionUtils.exception;
var constants = rxt.constants;
throw exceptionModule.buildExceptionObject(msg, constants.STATUS_CODES.BAD_REQUEST);
}
}
log.debug("Grouping attribute " + this.rxtManager.groupingAttributes(this.type));
var path = utils.importResource(parentPath, name, mediaType, '', url, '', userRegistry.registry, properties);
if(!this.rxtManager.isGroupingEnabled(this.type)){
log.debug('Omitted grouping');
return;
} else {
log.debug("Grouping seems to be enabled");
}
addDefaultPropertyIfNotExist(userRegistry.registry, path, name);
addDefaultPropertyIfNotExistToThis(userRegistry.registry, path, name, this);
},
create: function(options) {
var log = new Log();
var name = encodeURIComponent(options.attributes.overview_name);
var version = options.attributes.overview_version;
var rxt = require('rxt');
var am = rxt.asset.createUserAssetManager(ctx.session, this.type);
var query = {};
query.overview_name = name;
query._wildcard = false;
var assets = am.search(query);
for (var i = 0; i < assets.length; i++) {
if (assets[i].version == version) {
var msg = "Resource already exist with same Name \"" + decodeURIComponent(name) + "\" and version \"" + version + "\"";
var exceptionUtils = require('utils');
var exceptionModule = exceptionUtils.exception;
var constants = rxt.constants;
throw exceptionModule.buildExceptionObject(msg, constants.STATUS_CODES.BAD_REQUEST);
}
}
var isDefault = false;
var manager = this.am.manager;
var artifact = createArtifact(manager, options);
if((options.hasOwnProperty('_default')) &&(options._default===true)){
delete options._default;
isDefault = true;
}
manager.addGenericArtifact(artifact);
log.debug('Service successfully created');
options.id = artifact.getId();
var asset = this.get(options.id);
if(!this.rxtManager.isGroupingEnabled(this.type)){
log.debug('Omitted grouping');
return;
}
if ( (isDefault) || (isOnlyAssetVersion(asset,this)) ){
this.setAsDefaultAsset(asset);
}
var wsdlRelativePath = artifact.getPath();
var wsdlPath = "/_system/governance" + wsdlRelativePath;
addDefaultPropertyIfNotExist(getRegistry(ctx.session).registry, wsdlPath, options.attributes.overview_name);
},
api.update = function(options, req, res, session) {
var asset = require('rxt').asset;
var am = asset.createUserAssetManager(session, options.type);
var assetReq = req.getAllParameters('UTF-8');
var asset = am.importAssetFromHttpRequest(assetReq);
asset.id = options.id;
putInStorage(options, asset, am, req, session);
var original = am.get(options.id);
putInOldResources(original, asset, am);
putInUnchangedValues(original, asset, assetReq);
//If the user has not uploaded any new resources then use the old resources
if(!asset.name){
asset.name=am.getName(asset);
}
try {
am.update(asset);
} catch (e) {
log.debug('Failed to update the asset ' + stringify(asset));
log.debug(e);
asset = null;
}
return asset;
};
var getAssetCommentManager = function (ctx) {
var rxt = require('rxt');
var am = rxt.asset.createUserAssetManager(ctx.session, 'comments');
return am;
};
var assetManager = function(session, type) {
var am = rxt.asset.createUserAssetManager(session, type);
return am;
};
var restAssetManager = function(session){
var rxt = require('rxt');
var am = rxt.asset.createUserAssetManager(session, 'restservice');
return am;
};
var assetManager = function(ctx) {
var rxt = require('rxt');
var type = ctx.assetType;
var am = rxt.asset.createUserAssetManager(ctx.session, type);
return am;
};
var getAssetManager = function(session, type) {
var asset = require('rxt').asset;
var am = asset.createUserAssetManager(session, type);
return am;
}
var doTermSearch = function (ctx, facetField, paging, authRequired) {
var terms = [];
var results;
var selectedTag;
var map = new HashMap();
var mediaType;
var app = require('rxt').app;
var asset = require('rxt').asset;
var searchPage = '/pages/top-assets';
var rxtManager = ctx.rxtManager;
if (ctx.assetType) {
mediaType = rxtManager.getMediaType(ctx.assetType);
searchPage = '/assets/'+ctx.assetType+'/list';
} else {
var availableTypes = app.getUIActivatedAssets(ctx.tenantId);
mediaType = '(';
for (var index in availableTypes) {
if (availableTypes.hasOwnProperty(index)) {
if (index == 0) {
mediaType = mediaType + rxtManager.getMediaType(availableTypes[index]);
} else {
mediaType = mediaType + ' OR ' + rxtManager.getMediaType(availableTypes[index]);
}
}
}
mediaType = mediaType + ')';
}
log.debug("term search query criteria:facetField " + facetField + " mediaType " + mediaType);
var q = request.getParameter("q");
if (q) {
var options = parse("{" + q + "}");
/*if (facetField == "tags") {
map = buildQueryMapTags(ctx, options);
} else {
map = buildQueryMap(ctx, options);
}*/
if (options.tags) {
selectedTag = options.tags;
}
}
if (facetField) {
try {
buildPaginationContext(paging);
//results = GovernanceUtils.getTermDataList(map, facetField, mediaType, authRequired);
var am = getAssetManager(ctx);
q = q ? q : (q='');
q = parse('{' + q + '}' );
var query = asset.buildQuery(ctx.assetType, rxtManager, app, q);
results = GovernanceUtils.getTermDataList(query, facetField, mediaType, am.registry.registry);
var iterator = results.iterator();
while (iterator.hasNext()) {
var current = iterator.next();
var term = {};
term.value = current.term;
term.frequency = current.frequency;
term.searchPage = searchPage;
if(selectedTag && selectedTag == current.term){
term.selected=true;
}
else{
term.selected=false;
}
terms.push(term);
}
} finally {
destroyPaginationContext();
}
}
return terms;
};
var assetManager = function(session, type) {
var rxt = require('rxt');
var am = rxt.asset.createUserAssetManager(session, type);
return am;
};
api.advanceSearch = function(options, req, res, session) {
var asset = require('rxt').asset;
var server = require('store').server;
var userDetails = server.current(session);
var assetManager = null;
var domain = options.domain || carbon.server.superTenant.domain;
var tenantId = carbon.server.tenantId({
domain: domain
});
var rxtModule = require('rxt');
var rxtManager = rxtModule.core.rxtManager(tenantId);
var isGroupingEnabled = false; //Assume that grouping is disabled
if (!userDetails) {
assetManager = asset.createAnonAssetManager(session, options.type, tenantId);
} else {
assetManager = asset.createUserAssetManager(session, options.type);
}
var sort = (request.getParameter("sort") || '');
var sortOrder = DEFAULT_PAGIN.sortOrder;
if (sort) {
var order = sort.charAt(0);
if (order == '+' || order == ' ') {
sortOrder = 'ASC';
sort = sort.slice(1);
} else if (order == '-') {
sortOrder = 'DESC';
sort = sort.slice(1);
} else {
sortOrder = DEFAULT_PAGIN.sortOrder;
}
}
var sortBy = (sort || DEFAULT_PAGIN.sortBy);
var count = (request.getParameter("count") || DEFAULT_PAGIN.count);
var start = (request.getParameter("start") || DEFAULT_PAGIN.start);
var paginationLimit = (request.getParameter("paginationLimit") || DEFAULT_PAGIN.paginationLimit);
var paging = {
'start': start,
'count': count,
'sortOrder': sortOrder,
'sortBy': sortBy,
'paginationLimit': paginationLimit
};
var q = (request.getParameter("q") || '');
try {
if (q) {
var qString = '{' + q + '}';
var query = validateQuery(qString);
query = replaceCategoryQuery(query, rxtManager, options.type);
isGroupingEnabled = rxtManager.isGroupingEnabled(options.type);
if(isGroupingEnabled){
query._group = true;
query.default = true;
}
//query = replaceNameQuery(query, rxtManager, options.type);
var assets = assetManager.advanceSearch(query, paging); //doesnt work properly
} else {
var assets = assetManager.list(paging);
}
var expansionFields = (request.getParameter('fields') || '');
if (expansionFields) {
options.fields = expansionFields.split(',');
options.assets = assets;
result = fieldExpansion(options, req, res, session);
//return;
} else {
result = assets;
}
//res = responseProcessor.buildSuccessResponse(res,200,result);
} catch (e) {
//res = responseProcessor.buildErrorResponse(400, "Your request is malformed");
//print();
result = null;
log.error(e);
}
return result;
};
api.genericAdvanceSearch = function(options,req,res,session){
var asset = require('rxt').asset;
var server = require('store').server;
var userDetails = server.current(session);
var assetManager = null;
var domain = options.domain || carbon.server.superTenant.domain;
var ratingApi = require('/modules/rating-api.js').api;
var tenantId = carbon.server.tenantId({
domain: domain
});
var rxtModule = require('rxt');
var rxtManager = rxtModule.core.rxtManager(tenantId);
var sort = (request.getParameter("sort") || '');
var sortOrder = DEFAULT_PAGIN.sortOrder;
if (sort) {
var order = sort.charAt(0);
if (order == '+' || order == ' ') {
sortOrder = 'ASC';
sort = sort.slice(1);
} else if (order == '-') {
sortOrder = 'DESC';
sort = sort.slice(1);
} else {
sortOrder = DEFAULT_PAGIN.sortOrder;
}
}
var sortBy = (sort || DEFAULT_PAGIN.sortBy);
var count = (request.getParameter("count") || DEFAULT_PAGIN.count);
var start = (request.getParameter("start") || DEFAULT_PAGIN.start);
var paginationLimit = (request.getParameter("paginationLimit") || DEFAULT_PAGIN.paginationLimit);
var paging = {
'start': start,
'count': count,
'sortOrder': sortOrder,
'sortBy': sortBy,
'paginationLimit': paginationLimit
};
var q = (request.getParameter("q") || '');
try {
if (q) {
var qString = '{' + q + '}';
var query = validateQuery(qString);
//query = replaceCategoryQuery(query, rxtManager, options.type);
//query = replaceNameQuery(query, rxtManager, options.type);
if (log.isDebugEnabled) {
//Need to log this as we perform some processing on the name and
//category values
log.debug('processed query used for searching: ' + stringify(query));
}
//Note: Advance generic searches will not support grouping as it can
//be enabled/disabled per asset type
var assets = asset.advanceSearch(query,paging,session,tenantId);
} else {
log.error('Unable to perform a bulk asset retrieval without a type been specified');
throw 'Unable to perform a bulk asset retrieval without a type been specified';
}
var expansionFields = (request.getParameter('fields') || '');
if (expansionFields) {
options.fields = expansionFields.split(',');
options.assets = assets;
result = fieldExpansion(options, req, res, session);
//return;
} else {
result = assets;
}
//res = responseProcessor.buildSuccessResponse(res,200,result);
} catch (e) {
//res = responseProcessor.buildErrorResponse(400, "Your request is malformed");
//print();
result = null;
log.error(e);
}
ratingApi.addRatings(result);
return result;
};
var assetManager = function(req, session, options) {
var rxtAPI = require('rxt');
var am = rxtAPI.asset.createUserAssetManager(session, options.type);
return am;
};
pageDecorators.recentAssetsOfActivatedTypes = function(ctx, page) {
var app = require('rxt').app;
var asset = require('rxt').asset;
var permissions = require('rxt').permissions;
var assetAPI = require('/modules/asset-api.js').api;
var assets = {};
var items = [];
var pcItems = [];
var pcTypeDetails = [];
var pcAssets = [];
var assetsByType = [];
var am;
var type;
var rxtDetails;
var assetMap = {};
var bookmarkable;
var tenantAppResources = tenantApi.createTenantAwareAppResources(ctx.session);
var tenantAssetResources;
// Supporting cross tenant views
ctx = tenantAppResources.context;
types = app.getUIActivatedAssets(ctx.tenantId);
var typeDetails;
var ratingApi = require('/modules/rating-api.js').api;
var q = page.assetMeta.q;
var query = buildRecentAssetQuery(q);
var username = ctx.username || null;
var tenantId = ctx.tenantId;
var canBookmark = function(type) {
return permissions.hasAssetPermission(permissions.ASSET_BOOKMARK, type, tenantId, username);
};
var bookmarkPerms = {};
if (query) {
items = asset.advanceSearch(query, null, session, ctx.tenantId)||[];
ratingApi.addRatings(items, am, ctx.tenantId, ctx.username);
assetMap = {};
var template;
//Sort the results by type
items.forEach(function(item){
var type = item.type;
if(!assetMap[type]){
assetMap[type] = [];
}
bookmarkable = bookmarkPerms[type];
if (bookmarkable === undefined) {
bookmarkable = (bookmarkPerms[type] = canBookmark(type));
}
item.bookmarkable = bookmarkable;
assetMap[type].push(item);
});
//Collect the asset result set along with the rxt definition
for(var key in assetMap){
template = ctx.rxtManager.getRxtTypeDetails(key);
assetsByType.push({
assets:assetMap[key],
rxt:template
});
}
} else {
for (var index in types) {
typeDetails = ctx.rxtManager.getRxtTypeDetails(types[index]);
type = typeDetails.shortName;
tenantAssetResources = tenantApi.createTenantAwareAssetResources(ctx.session, {
type: type
});
bookmarkable = bookmarkPerms[type];
if(bookmarkable === undefined) {
bookmarkable = (bookmarkPerms[type] = canBookmark(type));
}
am = tenantAssetResources.am;
if (permissionsAPI.hasAssetPermission(permissionsAPI.ASSET_LIST, type, ctx.tenantId, ctx.username)) {
assets = am.recentAssets();
if (assets.length > 0) {
//Add subscription details if this is not an anon context
if (!ctx.isAnonContext) {
addSubscriptionDetails(assets, am, ctx.session, bookmarkable);
}
ratingApi.addRatings(assets, am, ctx.tenantId, ctx.username);
items = items.concat(assets);
assetsByType.push({
assets: assets,
rxt: typeDetails
});
}
}
}
}
// Display only process type assets for recent assets
for(var i = 0; i <items.length; i++){
if(items[i].type == "process"){
log.debug("Found Process type assets"+ i);
var pcCurrentType =ctx.rxtManager.getRxtTypeDetails(items[i].type);
pcTypeDetails = pcCurrentType ;
pcItems.push(items[i]);
}
}
pcAssets.push({
assets:pcItems,
rxt:pcTypeDetails
});
page.recentAssets = pcItems;
page.recentAssetsByType = pcAssets;
};
var getAssetNoteManager = function (ctx) {
var rxt = require('rxt');
var am = rxt.asset.createUserAssetManager(ctx.session, 'note');
return am;
};