/*
* Copyright (C) 2003-2007 eXo Platform SAS.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Affero General Public License
* as published by the Free Software Foundation; either version 3
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see<http://www.gnu.org/licenses/>.
*/
package org.exoplatform.services.cms.actions.impl;
import org.exoplatform.container.component.ComponentPlugin;
import org.exoplatform.services.cms.CmsService;
import org.exoplatform.services.cms.JcrInputProperty;
import org.exoplatform.services.cms.actions.ActionPlugin;
import org.exoplatform.services.cms.actions.ActionServiceContainer;
import org.exoplatform.services.cms.actions.DMSEvent;
import org.exoplatform.services.cms.impl.Utils;
import org.exoplatform.services.jcr.RepositoryService;
import org.exoplatform.services.jcr.config.RepositoryConfigurationException;
import org.exoplatform.services.jcr.core.ManageableRepository;
import org.exoplatform.services.jcr.core.nodetype.ExtendedNodeTypeManager;
import org.exoplatform.services.jcr.core.nodetype.NodeTypeValue;
import org.exoplatform.services.jcr.core.nodetype.PropertyDefinitionValue;
import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;
import org.picocontainer.Startable;
import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.PathNotFoundException;
import javax.jcr.PropertyType;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.Value;
import javax.jcr.nodetype.NodeType;
import javax.jcr.nodetype.NodeTypeIterator;
import javax.jcr.nodetype.NodeTypeManager;
import javax.jcr.nodetype.PropertyDefinition;
import javax.jcr.query.InvalidQueryException;
import javax.jcr.query.Query;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;
import javax.jcr.version.OnParentVersionAction;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Process with action for node
* @author exo
*
*/
public class ActionServiceContainerImpl implements ActionServiceContainer, Startable {
/**
* Logger.
*/
private static final Log LOG = ExoLogger.getLogger(ActionServiceContainerImpl.class.getName());
/**
* Define nodetype ACTIONABLE
*/
private static final String ACTIONABLE = "exo:actionable";
/**
* Define nodetype ACTION
*/
private static final String ACTION = "exo:action";
/**
* Define nodetype JOB_NAME_PROP
*/
private static final String JOB_NAME_PROP = "exo:jobName";
/**
* Define nodetype JOB_NAME_PROP
*/
private static final String JOB_GROUP_PROP = "exo:jobGroup";
/**
* Define nodetype JOB_CLASS_PROP
*/
private static final String JOB_CLASS_PROP = "exo:jobClass";
/**
* Define nodetype LIFECYCLE_PHASE_PROP
*/
private static final String LIFECYCLE_PHASE_PROP = "exo:lifecyclePhase" ;
/**
* Define query statement
*/
private static final String ACTION_QUERY = "//element(*, exo:action)" ;
/**
* Define sql query statement
*/
private static final String ACTION_SQL_QUERY =
"select * from exo:action" ;
/**
* Define sql append query operator.
*/
private static final String WHERE_OPERATOR = " where" ;
/**
* Define sql path.
*/
private static final String JCR_PATH = " jcr:path" ;
/**
* Define sql like operator.
*/
private static final String LIKE_OPERATOR = " like" ;
/**
* Sql query single quote.
*/
private static final String SINGLE_QUOTE = "'";
/**
* Define nodetype SCHEDULABLE_MIXIN
*/
private static final String SCHEDULABLE_MIXIN = "exo:schedulableInfo";
/**
* Define relative path for action node
*/
private static final String EXO_ACTIONS = "exo:actions";
/**
* Define nodetype ACTION_STORAGE
*/
private static final String ACTION_STORAGE = "exo:actionStorage";
/**
* Define nodetype EXO_HIDDENABLE
*/
private static final String EXO_HIDDENABLE = "exo:hiddenable";
/**
* RepositoryService
*/
private RepositoryService repositoryService_;
/**
* CmsService
*/
private CmsService cmsService_;
/**
* Collection of ComponentPlugin
*/
private Collection<ComponentPlugin> actionPlugins = new ArrayList<ComponentPlugin>();
/**
* Constructor method
* @param repositoryService RepositoryService
* @param cmsService CmsService
* @throws Exception
*/
public ActionServiceContainerImpl(RepositoryService repositoryService, CmsService cmsService
) throws Exception {
repositoryService_ = repositoryService;
cmsService_ = cmsService;
}
/**
* Implement method start service
* Add mixin exo:actionable for node
*/
public void start() {
if (LOG.isInfoEnabled()) {
LOG.info("Start " + this.getClass().getSimpleName()+ "...");
}
try {
for (ComponentPlugin cPlungin : actionPlugins) {
BaseActionPlugin plugin = (BaseActionPlugin) cPlungin;
plugin.importPredefinedActionsInJcr();
}
initiateActionConfiguration();
} catch (Exception e) {
if (LOG.isErrorEnabled()) {
LOG.error("Cannot start ActionServiceContainerImpl", e);
}
}
}
/**
* Implement method stop service
*/
public void stop() {
}
/**
* {@inheritDoc}
*/
public void init() {
try {
for (ComponentPlugin cPlungin : actionPlugins) {
BaseActionPlugin plugin = (BaseActionPlugin) cPlungin;
plugin.reImportPredefinedActionsInJcr();
}
reInitiateActionConfiguration();
} catch (Exception e) {
if (LOG.isErrorEnabled()) {
LOG.error("Cannot initialize the ActionServiceContainerImpl", e);
}
}
}
/**
* {@inheritDoc}
*/
public Collection<String> getActionPluginNames() {
Collection<String> actionPluginNames = new ArrayList<String>(actionPlugins.size());
for (ComponentPlugin plugin : actionPlugins) {
actionPluginNames.add(plugin.getName());
}
return actionPluginNames;
}
/**
* {@inheritDoc}
*/
public ActionPlugin getActionPlugin(String actionsServiceName) {
for (ComponentPlugin plugin : actionPlugins) {
if (plugin.getName().equals(actionsServiceName))
return (ActionPlugin) plugin;
}
return null;
}
/**
* Create NodeTypeValue is in kind of ActionType following action type name
* @param actionTypeName name of action type
* @param parentActionTypeName name of parent action
* @param executable String value of executable
* @param variableNames List name of variable
* @param isMoveType is moved or not
* @throws Exception
*/
@SuppressWarnings("unchecked")
public void createActionType(String actionTypeName, String parentActionTypeName, String executable, String actionLabel,
List<String> variableNames, boolean isMoveType, boolean isUpdate) throws Exception {
NodeTypeValue nodeTypeValue = new NodeTypeValue();
nodeTypeValue.setName(actionTypeName);
List<String> superTypes = new ArrayList<String>();
superTypes.add(parentActionTypeName);
if (isMoveType)
superTypes.add("exo:move");
nodeTypeValue.setDeclaredSupertypeNames(superTypes);
List propDefs = new ArrayList();
PropertyDefinitionValue propDef = null;
for (String variableName : variableNames) {
propDef = createPropertyDef(variableName);
propDefs.add(propDef);
}
propDef = createPropertyDef(getActionPluginForActionType(parentActionTypeName).getExecutableDefinitionName());
List scriptDefaultValues = new ArrayList();
scriptDefaultValues.add(executable);
propDef.setDefaultValueStrings(scriptDefaultValues);
propDef.setMandatory(true);
propDefs.add(propDef);
propDef = createPropertyDef(getActionPluginForActionType(parentActionTypeName).getActionExecutableLabel());
List labelDefaultValues = new ArrayList();
labelDefaultValues.add(actionLabel);
propDef.setDefaultValueStrings(labelDefaultValues);
propDef.setMandatory(true);
propDefs.add(propDef);
nodeTypeValue.setDeclaredPropertyDefinitionValues(propDefs);
nodeTypeValue.setDeclaredChildNodeDefinitionValues(new ArrayList());
ExtendedNodeTypeManager ntmanager = repositoryService_.getCurrentRepository().getNodeTypeManager();
if(isUpdate) ntmanager.registerNodeType(nodeTypeValue, ExtendedNodeTypeManager.REPLACE_IF_EXISTS);
ntmanager.registerNodeType(nodeTypeValue, ExtendedNodeTypeManager.IGNORE_IF_EXISTS);
}
/**
* Definite new property with property name = name
* mandatory = false, multiple = false, readonly = false, autocreate = false, onversion = 1
* type = STRING, default value = new ArrayList(), Value constraints = new ArrayList()
* @param name name of property
* @return PropertyDefinitionValue
*/
@SuppressWarnings("unchecked")
private PropertyDefinitionValue createPropertyDef(String name) {
PropertyDefinitionValue def = new PropertyDefinitionValue();
def.setName(name);
def.setRequiredType(PropertyType.STRING);
def.setMandatory(false);
def.setMultiple(false);
def.setReadOnly(false);
def.setAutoCreate(false);
def.setOnVersion(OnParentVersionAction.COPY);
def.setValueConstraints(new ArrayList());
def.setDefaultValueStrings(new ArrayList());
return def;
}
/**
* Get all created node with nodetype = "exo:action
* @param repository repository name
* @return Collection of NodeType
* @throws Exception
*/
public Collection<NodeType> getCreatedActionTypes(String repository) throws Exception {
Collection<NodeType> createsActions = new ArrayList<NodeType>();
NodeTypeManager ntmanager = repositoryService_.getCurrentRepository().getNodeTypeManager();
for(NodeTypeIterator iter = ntmanager.getAllNodeTypes();iter.hasNext();) {
NodeType nt = (NodeType) iter.next();
String name = nt.getName();
if (nt.isNodeType(ACTION) && !isAbstractType(name) &&
!Utils.getAllEditedConfiguredData("ActionTypeList", "EditedConfiguredActionType", true).contains(name)) {
createsActions.add(nt);
}
}
return createsActions;
}
/**
* Check ComponentPlugin is abstract type or not
* @param name name of ComponentPlugin
* @return true: ComponentPlugin with name is abstract type
* false: ComponentPlugin with name is not abstract type
*/
private boolean isAbstractType(String name) {
for (ComponentPlugin plugin : actionPlugins) {
if (plugin.getName().equals(name))
return true;
}
return false;
}
/**
* Get SystemSession of specific workspace and repository
* @param workspace
* @return
* @throws RepositoryException
* @throws RepositoryConfigurationException
*/
private Session getSystemSession(String workspace) throws RepositoryException,
RepositoryConfigurationException {
ManageableRepository jcrRepository = repositoryService_.getCurrentRepository();
return jcrRepository.getSystemSession(workspace);
}
/**
* {@inheritDoc}
*/
public ActionPlugin getActionPluginForActionType(String actionTypeName) {
for (ComponentPlugin plugin : actionPlugins) {
String actionServiceName = plugin.getName();
ActionPlugin actionService = getActionPlugin(actionServiceName);
if (actionService.isActionTypeSupported(actionTypeName)
|| actionServiceName.equals(actionTypeName))
return actionService;
}
return null;
}
/**
* {@inheritDoc}
*/
public Node getAction(Node node, String actionName) throws Exception {
if (node.hasNode(EXO_ACTIONS + "/"+actionName)) {
return node.getNode(EXO_ACTIONS + "/"+ actionName);
}
return null;
}
/**
* {@inheritDoc}
*/
public boolean hasActions(Node node) throws Exception {
return node.isNodeType(ACTIONABLE);
}
/**
* {@inheritDoc}
*/
public List<Node> getActions(Node node) throws Exception {
return getActions(node, null);
}
/**
* {@inheritDoc}
*/
public List<Node> getCustomActionsNode(Node node, String lifecyclePhase) throws Exception {
try {
return getActions(node, lifecyclePhase) ;
} catch(Exception item) {
return null ;
}
}
/**
* {@inheritDoc}
*/
public List<Node> getActions(Node node, String lifecyclePhase) throws Exception {
List<Node> actions = new ArrayList<Node>();
Node actionStorage = null;
try{
actionStorage = node.getNode(EXO_ACTIONS);
}catch (Exception e) {
return actions;
}
for (NodeIterator iter = actionStorage.getNodes(); iter.hasNext();) {
Node tmpNode = iter.nextNode();
if (tmpNode.isNodeType(ACTION)
&& (lifecyclePhase == null || parseValuesToList(
tmpNode.getProperty(LIFECYCLE_PHASE_PROP).getValues()).contains(lifecyclePhase))) {
actions.add(tmpNode);
}
}
return actions;
}
/**
* {@inheritDoc}
*/
public void removeAction(Node node, String repository) throws Exception {
if(!node.isNodeType(ACTIONABLE)) return ;
List<Node> actions = getActions(node);
for (Node action : actions) {
removeAction(node, action.getName(), repository);
}
}
/**
* {@inheritDoc}
*/
public void removeAction(Node node, String actionName, String repository) throws Exception {
if(!node.isNodeType(ACTIONABLE)) return ;
Node action2Remove = node.getNode(EXO_ACTIONS+ "/" + actionName);
String[] lifecyclePhase = parseValuesToArray(action2Remove.getProperty(LIFECYCLE_PHASE_PROP)
.getValues());
String jobName = null, jobGroup = null, jobClassName = null;
if (action2Remove.isNodeType(SCHEDULABLE_MIXIN)) {
jobName = action2Remove.getProperty(JOB_NAME_PROP).getString();
jobGroup = action2Remove.getProperty(JOB_GROUP_PROP).getString();
jobClassName = action2Remove.getProperty(JOB_CLASS_PROP).getString();
}
String actionTypeName = action2Remove.getPrimaryNodeType().getName();
String actionPath = action2Remove.getPath();
for (ComponentPlugin plugin : actionPlugins) {
String actionServiceName = plugin.getName();
ActionPlugin actionService = getActionPlugin(actionServiceName);
if (actionService.isActionTypeSupported(actionTypeName)) {
if ((DMSEvent.getEventTypes(lifecyclePhase) & DMSEvent.SCHEDULE) > 0) {
actionService.removeActivationJob(jobName, jobGroup, jobClassName);
}
actionService.removeObservation(repository, actionPath);
}
}
action2Remove.remove();
node.save();
}
/**
* {@inheritDoc}}
*/
public void addAction(Node storeActionNode,
String actionType,
boolean isDeep,
String[] uuid,
String[] nodeTypeNames,
Map mappings) throws Exception {
Node actionsNode = null;
try {
actionsNode = storeActionNode.getNode(EXO_ACTIONS);
} catch (PathNotFoundException e) {
actionsNode = storeActionNode.addNode(EXO_ACTIONS,ACTION_STORAGE) ;
actionsNode.addMixin(EXO_HIDDENABLE) ;
storeActionNode.save();
}
if (!storeActionNode.isNodeType(ACTIONABLE)) {
storeActionNode.addMixin(ACTIONABLE);
storeActionNode.save();
}
String newActionPath = cmsService_.storeNode(actionType, actionsNode, mappings,true);
storeActionNode.save();
String srcWorkspace = storeActionNode.getSession().getWorkspace().getName();
String srcPath = storeActionNode.getPath();
ActionPlugin actionService = getActionPluginForActionType(actionType);
if (actionService == null)
throw new ClassNotFoundException("Not found any action's service compatible with action type "+actionType) ;
try {
actionService.addAction(actionType, srcWorkspace, srcPath, isDeep, uuid, nodeTypeNames, mappings);
} catch (Exception e) {
if (LOG.isErrorEnabled()) {
LOG.error(e);
}
Session session = getSystemSession(storeActionNode.getSession().getWorkspace().getName());
Node actionNode = (Node) session.getItem(newActionPath);
actionNode.remove();
session.save();
session.logout();
throw e;
}
}
/**
* {@inheritDoc}
*/
public void addAction(Node storeActionNode, String actionType, Map mappings) throws Exception {
boolean isDeep = true;
String[] nodeTypeName = null;
String[] uuid = null;
if (mappings.containsKey("/node/exo:isDeep")) {
isDeep = Boolean.valueOf(((JcrInputProperty)mappings.get("/node/exo:isDeep")).getValue().toString());
}
if (mappings.containsKey("/node/exo:uuid")) {
uuid = (String[]) ((JcrInputProperty) mappings.get("/node/exo:uuid")).getValue();
if(uuid.length == 0) uuid = null;
}
if (mappings.containsKey("/node/exo:nodeTypeName")) {
nodeTypeName = (String[]) ((JcrInputProperty) mappings.get("/node/exo:nodeTypeName"))
.getValue();
if(nodeTypeName.length == 0) {
nodeTypeName = null;
mappings.remove("/node/exo:nodeTypeName");
}
}
addAction(storeActionNode, actionType, isDeep, uuid, nodeTypeName, mappings);
}
/**
* Call addAction(Node node, String repository, String type, Map mappings) to
* execute action following userId, node, repository, initiated variables
* @param userId user identify
* @param node current node
* @param actionName name of action
* @throws Exception
*/
public void executeAction(String userId, Node node, String actionName) throws Exception {
Map<String, String> variables = new HashMap<String, String>();
variables.put("initiator", userId);
variables.put("actionName", actionName);
variables.put("nodePath", node.getPath());
variables.put("srcWorkspace", node.getSession().getWorkspace().getName());
variables.put("srcPath", node.getPath());
NodeType nodeType = node.getPrimaryNodeType();
String nodeTypeName = nodeType.getName();
variables.put("document-type", nodeTypeName);
Node actionNode = getAction(node, actionName);
NodeType actionNodeType = actionNode.getPrimaryNodeType();
fillVariables(actionNode, actionNodeType, variables);
NodeType[] actionMixinTypes = actionNode.getMixinNodeTypes();
for (int i = 0; i < actionMixinTypes.length; i++) {
NodeType mixinType = actionMixinTypes[i];
fillVariables(actionNode, mixinType, variables);
}
executeAction(userId, node, actionName, variables);
}
/**
* Put to Map with key = property name and value = value of property in actionNode
* @param actionNode get value of property in this node
* @param nodeType get property definition from this object
* @param variables Map to keep (key, value) of all property
* @throws Exception
*/
private void fillVariables(Node actionNode, NodeType nodeType, Map variables) throws Exception {
for(PropertyDefinition def:nodeType.getDeclaredPropertyDefinitions()) {
String propName = def.getName();
if (actionNode.hasProperty(propName)) {
if(actionNode.getProperty(propName).getDefinition().isMultiple()) {
} else {
String propValue = actionNode.getProperty(propName).getString();
variables.put(propName, propValue);
}
}
}
}
/**
* Execute action following userId, node, variables, repository
* @param userId user identify
* @param node current node
* @param actionName name of action
* @param variables Map with variables and value
* @throws Exception
*/
public void executeAction(String userId, Node node, String actionName, Map variables) throws Exception {
if (!node.isNodeType(ACTIONABLE)) return ;
Node actionNode = getAction(node, actionName);
String actionTypeName = actionNode.getPrimaryNodeType().getName();
for (ComponentPlugin plugin : actionPlugins) {
String actionServiceName = plugin.getName();
ActionPlugin actionPlugin = getActionPlugin(actionServiceName);
if (actionPlugin.isActionTypeSupported(actionTypeName)) {
actionPlugin.executeAction(userId, actionNode, variables);
}
}
}
/**
* Add ComponentPlugin
* @param plugin ComponentPlugin
*/
public void addPlugin(ComponentPlugin plugin) { actionPlugins.add(plugin); }
/**
* Need implemented
* @param pluginName
* @return
*/
public ComponentPlugin removePlugin(String pluginName) {
return null;
}
/**
* Get all ComponentPlugin
* @return Collection of ComponentPlugins
*/
public Collection<ComponentPlugin> getPlugins() { return actionPlugins; }
/**
* Get QueryManager, call initAction(QueryManager queryManager, String repository, String workspace)
* to initialize action listener for all available repositories and workspaces
* @throws Exception
*/
private void initiateActionConfiguration() throws Exception {
ManageableRepository jcrRepository = null ;
jcrRepository = repositoryService_.getCurrentRepository();
String[] workspaces = jcrRepository.getWorkspaceNames();
for (String workspace : workspaces) {
Session session = jcrRepository.getSystemSession(workspace);
QueryManager queryManager = null;
try {
queryManager = session.getWorkspace().getQueryManager();
} catch (RepositoryException e) {
if (LOG.isWarnEnabled()) {
LOG.warn("ActionServiceContainer - Query Manager Factory of workspace "
+ workspace + " not found. Check configuration.", e);
}
}
if (queryManager == null) {
session.logout();
continue;
}
initAction(queryManager, workspace) ;
session.logout();
}
}
/**
* Get QueryManager, call initAction(QueryManager queryManager, String repository, String workspace)
* to initialize action listener
* @throws Exception
*/
private void reInitiateActionConfiguration() throws Exception {
ManageableRepository jcrRepository = repositoryService_.getCurrentRepository();
for (String workspace : jcrRepository.getWorkspaceNames()) {
Session session = jcrRepository.getSystemSession(workspace);
QueryManager queryManager = null;
try {
queryManager = session.getWorkspace().getQueryManager();
} catch (RepositoryException e) {
if (LOG.isWarnEnabled()) {
LOG.warn("ActionServiceContainer - Query Manager Factory of workspace "
+ workspace + " not found. Check configuration.", e);
}
}
if (queryManager == null) {
session.logout();
continue;
}
initAction(queryManager, workspace) ;
session.logout();
}
}
/**
* Initialize the action listener for all node in repository
* All node is got by query following ACTION_QUERY
* @param queryManager QueryManager
* @param workspace workspace name
* @throws Exception
*/
private void initAction(QueryManager queryManager, String workspace) throws Exception {
try {
Query query = queryManager.createQuery(ACTION_QUERY, Query.XPATH);
QueryResult queryResult = query.execute();
for (NodeIterator iter = queryResult.getNodes(); iter.hasNext();) {
Node actionNode = iter.nextNode();
String[] lifecyclePhase = parseValuesToArray(actionNode.getProperty(LIFECYCLE_PHASE_PROP)
.getValues());
String actionType = actionNode.getPrimaryNodeType().getName();
for (ComponentPlugin plugin : actionPlugins) {
String actionServiceName = plugin.getName();
ActionPlugin actionService = getActionPlugin(actionServiceName);
if (actionService.isActionTypeSupported(actionType)) {
if (DMSEvent.getEventTypes(lifecyclePhase) == DMSEvent.READ)
continue;
if ((DMSEvent.getEventTypes(lifecyclePhase) & DMSEvent.SCHEDULE) > 0) {
actionService.reScheduleActivations(actionNode);
}
if (DMSEvent.getEventTypes(lifecyclePhase) == DMSEvent.SCHEDULE)
continue;
actionService.initiateActionObservation(actionNode);
}
}
}
} catch (Exception e) {
if (LOG.isErrorEnabled()) {
LOG.error(">>>> Can not launch action listeners for workspace: "
+ workspace + " in current repository", e);
}
}
}
/**
* {@inheritDoc}
*/
public void initiateObservation(Node node) throws Exception {
try {
Session session = node.getSession();
QueryManager queryManager = session.getWorkspace().getQueryManager();
String queryStr;
Query query = null;
try {
if (!"/".equals(node.getPath())) {
queryStr = "/jcr:root" + node.getPath() + ACTION_QUERY;
} else {
queryStr = ACTION_QUERY;
}
query = queryManager.createQuery(queryStr, Query.XPATH);
} catch(InvalidQueryException invalid) {
// With some special character, XPath will be invalid , try SQL
if (!"/".equals(node.getPath())) {
queryStr = ACTION_SQL_QUERY + WHERE_OPERATOR + JCR_PATH + LIKE_OPERATOR
+ SINGLE_QUOTE + node.getPath() + "/" + "%" + SINGLE_QUOTE;
} else {
queryStr = ACTION_SQL_QUERY;
}
query = queryManager.createQuery(queryStr, Query.SQL);
}
QueryResult queryResult = query.execute();
for (NodeIterator iter = queryResult.getNodes(); iter.hasNext();) {
Node actionNode = iter.nextNode();
try {
String actionType = actionNode.getPrimaryNodeType().getName();
for (ComponentPlugin plugin : actionPlugins) {
String actionServiceName = plugin.getName();
ActionPlugin actionService = getActionPlugin(actionServiceName);
if (actionService.isActionTypeSupported(actionType)) {
actionService.initiateActionObservation(actionNode);
}
}
} catch (Exception e) {
if (LOG.isErrorEnabled()) {
LOG.error("Can not launch action listeners named is " + actionNode.getPath(), e);
}
}
}
} catch (Exception ex) {
if (LOG.isErrorEnabled()) {
LOG.error("Can not launch action listeners inside " + node.getPath() + " node.", ex);
}
}
}
/**
* Parase Array Value to Array String
* @param values
* @return Array String
* @throws Exception
*/
private String[] parseValuesToArray(Value[] values) throws Exception {
return parseValuesToList(values).toArray(new String[0]);
}
/**
* Parse Array Value to List String
* @param values
* @return
* @throws Exception
*/
private List<String> parseValuesToList(Value[] values) throws Exception {
List<String> lstValues = new ArrayList<String>();
for(Value value : values) {
lstValues.add(value.getString());
}
return lstValues;
}
}