1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34 package info.magnolia.commands;
35
36
37 import info.magnolia.jcr.node2bean.Node2BeanException;
38 import info.magnolia.jcr.node2bean.PropertyTypeDescriptor;
39 import info.magnolia.jcr.node2bean.TransformationState;
40 import info.magnolia.jcr.node2bean.TypeDescriptor;
41 import info.magnolia.jcr.node2bean.TypeMapping;
42 import info.magnolia.jcr.node2bean.impl.Node2BeanTransformerImpl;
43 import info.magnolia.objectfactory.Classes;
44 import info.magnolia.objectfactory.ComponentProvider;
45
46 import java.util.Iterator;
47 import java.util.Map;
48
49 import javax.jcr.Node;
50 import javax.jcr.RepositoryException;
51
52 import org.apache.commons.chain.Catalog;
53 import org.apache.commons.chain.Chain;
54 import org.apache.commons.chain.Command;
55 import org.apache.commons.chain.impl.ChainBase;
56 import org.apache.commons.lang.StringUtils;
57
58
59
60
61
62
63 public class CommandTransformer extends Node2BeanTransformerImpl {
64 private final static org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(CommandTransformer.class);
65
66 private static final String DEPRECATED_CATALOG_NAME_NODE_DATA = "catalogName";
67
68 private static final String DEPRECATED_IMPL_NODE_DATA = "impl";
69
70 @Override
71 protected TypeDescriptor onResolveType(TypeMapping typeMapping, TransformationState state, TypeDescriptor resolvedType, ComponentProvider componentProvider) {
72 if(resolvedType != null){
73 return resolvedType;
74 }
75 Class klass = null;
76
77 if(state.getLevel() == 1){
78 klass = MgnlCatalog.class;
79 }
80 else{
81 Node node = state.getCurrentNode();
82 try {
83 if(node.hasProperty(DEPRECATED_IMPL_NODE_DATA)){
84 log.warn("Rename '" + DEPRECATED_IMPL_NODE_DATA + "' to 'class' [" + node + "]!");
85 try {
86 final String className = node.getProperty(DEPRECATED_IMPL_NODE_DATA).getString();
87 klass = Classes.getClassFactory().forName(className);
88 }
89 catch (ClassNotFoundException e) {
90 klass = DelegateCommand.class;
91 }
92 }
93 else{
94
95
96 boolean buildingCommand = false;
97 for (int i = 0; i < state.getLevel() -1; i++) {
98 TypeDescriptor td = state.peekType(i);
99 if(isCommandClass(td.getType()) && !isChainClass(td.getType())){
100 buildingCommand = true;
101 }
102 }
103 if(!buildingCommand){
104 klass = ChainBase.class;
105 }
106 }
107 }
108 catch (RepositoryException e) {
109 log.error("Can't check " + DEPRECATED_IMPL_NODE_DATA + " nodedata [" + node + "]", e);
110 }
111 }
112 if(klass != null){
113 return typeMapping.getTypeDescriptor(klass);
114 }
115 return resolvedType;
116 }
117
118 @Override
119 public void initBean(TransformationState state, Map values) throws Node2BeanException {
120
121 if(state.getCurrentBean() instanceof Catalog){
122 Catalog catalog = (Catalog) state.getCurrentBean();
123 for (Iterator iter = values.keySet().iterator(); iter.hasNext();) {
124 String name = (String) iter.next();
125 if(values.get(name) instanceof Command){
126 Command command = (Command) values.get(name);
127 if(!(command instanceof MgnlCommand) || ((MgnlCommand)command).isEnabled()){
128 catalog.addCommand(name, command);
129 }
130 }
131 }
132 }
133
134
135 if(state.getCurrentBean() instanceof Chain){
136 Chain chain = (Chain) state.getCurrentBean();
137 for (Iterator iter = values.values().iterator(); iter.hasNext();) {
138 Object value = iter.next();
139 if (value instanceof Command) {
140 Command command = (Command) value;
141 if(!(command instanceof MgnlCommand) || ((MgnlCommand)command).isEnabled()){
142 chain.addCommand(command);
143 }
144 }
145 }
146 }
147
148
149 if(state.getCurrentBean() instanceof DelegateCommand){
150 DelegateCommand delegateCommand = (DelegateCommand) state.getCurrentBean();
151 if(StringUtils.isEmpty(delegateCommand.getCommandName())){
152 log.warn("You should define the commandName property on [{}]", state.getCurrentNode());
153 delegateCommand.setCommandName((String) values.get(DEPRECATED_IMPL_NODE_DATA));
154 }
155 }
156 super.initBean(state, values);
157 }
158
159 @Override
160 public void setProperty(TypeMapping typeMapping, TransformationState state, PropertyTypeDescriptor descriptor, Map values) throws RepositoryException {
161 Object bean = state.getCurrentBean();
162 if(bean instanceof MgnlCatalog){
163 MgnlCatalog catalog = (MgnlCatalog) bean;
164 if(values.containsKey(DEPRECATED_CATALOG_NAME_NODE_DATA)){
165 log.warn("Rename the 'catalogName' nodedata to 'name' [" + state.getCurrentNode() + "]");
166 catalog.setName((String)values.get(DEPRECATED_CATALOG_NAME_NODE_DATA));
167 }
168
169 if (!values.containsKey("name") && state.getCurrentNode().getName().equals("commands")) {
170 try {
171 catalog.setName(state.getCurrentNode().getParent().getName());
172 }
173 catch (RepositoryException e) {
174 log.error("Can't resolve catalog name by using parent node [" + state.getCurrentNode() + "]", e);
175 }
176 }
177 }
178
179 super.setProperty(typeMapping, state, descriptor, values);
180 }
181
182 protected boolean isCommandClass(Class<?> type) {
183 return Command.class.isAssignableFrom(type);
184 }
185
186 protected boolean isChainClass(Class<?> type) {
187 return Chain.class.isAssignableFrom(type);
188 }
189 }