|
1 package org.apache.slide.projector.processor.table;
2
3 import java.io.IOException  ;
4 import java.util.ArrayList ;
5 import java.util.HashMap ;
6 import java.util.Iterator ;
7 import java.util.List ;
8 import java.util.Map ;
9
10 import org.apache.slide.projector.ConfigurationException;
11 import org.apache.slide.projector.Context;
12 import org.apache.slide.projector.ProcessException;
13 import org.apache.slide.projector.Processor;
14 import org.apache.slide.projector.Result;
15 import org.apache.slide.projector.Store;
16 import org.apache.slide.projector.URI;
17 import org.apache.slide.projector.descriptor.AnyValueDescriptor;
18 import org.apache.slide.projector.descriptor.ArrayValueDescriptor;
19 import org.apache.slide.projector.descriptor.BooleanValueDescriptor;
20 import org.apache.slide.projector.descriptor.MapValueDescriptor;
21 import org.apache.slide.projector.descriptor.ParameterDescriptor;
22 import org.apache.slide.projector.descriptor.StringValueDescriptor;
23 import org.apache.slide.projector.descriptor.URIValueDescriptor;
24 import org.apache.slide.projector.engine.ProcessorManager;
25 import org.apache.slide.projector.i18n.ErrorMessage;
26 import org.apache.slide.projector.i18n.ParameterMessage;
27 import org.apache.slide.projector.processor.SimpleProcessor;
28 import org.apache.slide.projector.util.StoreHelper;
29 import org.apache.slide.projector.value.ArrayValue;
30 import org.apache.slide.projector.value.BooleanValue;
31 import org.apache.slide.projector.value.MapValue;
32 import org.apache.slide.projector.value.NullValue;
33 import org.apache.slide.projector.value.PrintableValue;
34 import org.apache.slide.projector.value.StreamableValue;
35 import org.apache.slide.projector.value.StringValue;
36 import org.apache.slide.projector.value.Value;
37
38
41
42 public class TableGenerator extends TableMapRenderer {
43 final static String PARAMETER = "parameter";
44
45 final private static String COLUMN_FRAGMENT = "column";
46 final private static String HEADER_COLUMN_FRAGMENT = "header column";
47 final private static String COLLAPSED_COLUMN_FRAGMENT = "collapsed column";
48 final private static String COLLAPSED_HEADER_COLUMN_FRAGMENT = "collapsed header column";
49 final private static String ASCENDING_HEADER_COLUMN_FRAGMENT = "ascending header column";
50 final private static String DESCENDING_HEADER_COLUMN_FRAGMENT = "descending header column";
51
52 final private static String COLUMNS_PARAMETER = "columns";
53 final private static String RESIZABLE = "resizable";
54 final private static String SORTABLE = "sortable";
55 final private static String HEADER = "header";
56 final private static String KEY = "key";
57 final private static String VALUE = "value";
58 final private static String NAME = "name";
59 final private static String PROCESSOR = "processor";
60 final private static String PARAMETERS = "parameters";
61 final private static String RESULT = "result";
62 final private static String REPLACE_COLUMN = "replaceColumn";
63
64 final private static String HEADERS = "headers";
65 final private static String COLUMNS = "columns";
66
67 final private static String SORTABLE_HANDLER = "sortableHandler";
68 final private static String RESIZABLE_HANDLER = "resizableHandler";
69
70 private Template columnTemplate, collapsedColumnTemplate, headerColumnTemplate, collapsedHeaderColumnTemplate;
71 private Template ascendingHeaderColumnTemplate, descendingHeaderColumnTemplate;
72
73 private ParameterDescriptor []parameterDescriptors;
74
75 public TableGenerator() {
76 setRequiredFragments(new String [] { DEFAULT_FRAGMENT, COLUMN_FRAGMENT, HEADER_COLUMN_FRAGMENT });
77 setOptionalFragments(new String [] { COLLAPSED_HEADER_COLUMN_FRAGMENT, COLLAPSED_COLUMN_FRAGMENT, ASCENDING_HEADER_COLUMN_FRAGMENT, DESCENDING_HEADER_COLUMN_FRAGMENT, EMPTY_FRAGMENT, HEADER_FRAGMENT, FOOTER_FRAGMENT, FIRST_FRAGMENT, LAST_FRAGMENT, EVEN_FRAGMENT });
78 setRepeatedFragments(new String [] { FIRST_FRAGMENT, LAST_FRAGMENT, DEFAULT_FRAGMENT, EVEN_FRAGMENT });
79 ignoreUndefinedFragments(false);
80 }
81
82 public void configure(StreamableValue config) throws ConfigurationException {
83 super.configure(config);
84 ParameterDescriptor []parentParameterDescriptors = super.getParameterDescriptors();
85 List parameterDescriptorList = new ArrayList ();
87 for ( int i = 0; i < parentParameterDescriptors.length; i++ ) {
88 parameterDescriptorList.add(parentParameterDescriptors[i]);
89 }
90 List headerParameterDescriptors = getTemplateParameterDescriptor(new String [] { HEADER_COLUMN_FRAGMENT, COLLAPSED_HEADER_COLUMN_FRAGMENT });
91 headerParameterDescriptors.add(new ParameterDescriptor(HEADER, new ParameterMessage("tableGenerator/parameter/columns/header"), new StringValueDescriptor(), StringValue.EMPTY));
92 headerParameterDescriptors.add(new ParameterDescriptor(VALUE, new ParameterMessage("tableGenerator/parameter/columns/value"), new AnyValueDescriptor(), NullValue.NULL));
93 headerParameterDescriptors.add(new ParameterDescriptor(KEY, new ParameterMessage("tableGenerator/parameter/columns/key"), new StringValueDescriptor()));
94 headerParameterDescriptors.add(new ParameterDescriptor(NAME, new ParameterMessage("tableGenerator/parameter/columns/name"), new StringValueDescriptor(), new StringValue(VALUE)));
95 headerParameterDescriptors.add(new ParameterDescriptor(REPLACE_COLUMN, new ParameterMessage("tableGenerator/parameter/columns/replaceColumn"), new BooleanValueDescriptor(), BooleanValue.FALSE));
96 headerParameterDescriptors.add(new ParameterDescriptor(RESIZABLE, new ParameterMessage("tableGenerator/parameter/columns/resizable"), new BooleanValueDescriptor(), BooleanValue.FALSE));
97 headerParameterDescriptors.add(new ParameterDescriptor(SORTABLE, new ParameterMessage("tableGenerator/parameter/columns/sortable"), new BooleanValueDescriptor(), BooleanValue.FALSE));
98 headerParameterDescriptors.add(new ParameterDescriptor(PROCESSOR, new ParameterMessage("tableGenerator/parameter/columns/processor"), new URIValueDescriptor(), NullValue.NULL));
99 headerParameterDescriptors.add(new ParameterDescriptor(PARAMETERS, new ParameterMessage("tableGenerator/parameter/columns/parameters"), MapValueDescriptor.ANY, NullValue.NULL));
100 headerParameterDescriptors.add(new ParameterDescriptor(RESULT, new ParameterMessage("tableGenerator/parameter/columns/result"), new StringValueDescriptor(), NullValue.NULL));
101 parameterDescriptorList.add(new ParameterDescriptor(COLUMNS_PARAMETER, new ParameterMessage("tableGenerator/parameter/columns"),
102 new ArrayValueDescriptor(new MapValueDescriptor((ParameterDescriptor [])headerParameterDescriptors.toArray(new ParameterDescriptor[headerParameterDescriptors.size()])))));
103 parameterDescriptorList.add(new ParameterDescriptor(PARAMETER, new ParameterMessage("tableGenerator/parameter/parameter"), MapValueDescriptor.ANY, new MapValue(new HashMap ())));
104 parameterDescriptors = (ParameterDescriptor[] )parameterDescriptorList.toArray(new ParameterDescriptor[parameterDescriptorList.size()]);
105 collapsedColumnTemplate = getOptionalFragment(COLLAPSED_COLUMN_FRAGMENT);
106 collapsedHeaderColumnTemplate = getOptionalFragment(COLLAPSED_HEADER_COLUMN_FRAGMENT);
107 ascendingHeaderColumnTemplate = getOptionalFragment(ASCENDING_HEADER_COLUMN_FRAGMENT);
108 descendingHeaderColumnTemplate = getOptionalFragment(DESCENDING_HEADER_COLUMN_FRAGMENT);
109 try {
110 columnTemplate = getRequiredFragment(COLUMN_FRAGMENT);
111 headerColumnTemplate = getRequiredFragment(HEADER_COLUMN_FRAGMENT);
112 } catch ( ProcessException exception ) {
113 throw new ConfigurationException(new ErrorMessage("tableRenderer/fragmentsMissing"), exception);
114 }
115 }
116
117 public Result process(Map parameter, Context context) throws Exception {
118 Map parameters = ((MapValue)parameter.get(PARAMETER)).getMap();
119 String handlerUrl = ProcessorManager.getInstance().process(ProcessorManager.URL, TableHandler.URL, context).toString();
120 String id = parameter.get(TableHandler.ID).toString();
121 String storeName = parameter.get(TableHandler.STORE).toString();
122 Store store = context.getStore(StoreHelper.getStoreByName(storeName));
123 Map tableMap;
124 MapValue idResource = (MapValue)store.get(id);
125 String sortedBy = null, order = null;
126 Map size = null;
127 if ( idResource == null) {
128 tableMap = new HashMap ();
129 MapValue tableState = new MapValue(tableMap);
130 store.put(id, tableState);
131 } else {
132 tableMap = idResource.getMap();
133 Value sortedByValue = (Value)idResource.getMap().get(TableHandler.SORTED_BY);
134 if ( sortedByValue != null && sortedByValue != NullValue.NULL ) sortedBy = sortedByValue.toString();
135 Value orderValue = (Value)idResource.getMap().get(TableHandler.ORDER);
136 if ( orderValue != null && orderValue != NullValue.NULL ) order = orderValue.toString();
137 Value sizeValue = (Value)idResource.getMap().get(TableHandler.SIZE);
138 if ( sizeValue != null && sizeValue != NullValue.NULL ) size = ((MapValue)sizeValue).getMap();
139 }
140 StringBuffer headersBuffer = new StringBuffer (1024);
142 Value []columns = ((ArrayValue)parameter.get(COLUMNS_PARAMETER)).getArray();
143 for ( int i = 0; i < columns.length; i++ ) {
144 Map columnMap = ((MapValue)columns[i]).getMap();
145 boolean sortable = ((BooleanValue)columnMap.get(SORTABLE)).booleanValue();
146 if ( ascendingHeaderColumnTemplate == null || descendingHeaderColumnTemplate == null ) sortable = false;
147 boolean resizable = ((BooleanValue)columnMap.get(RESIZABLE)).booleanValue();
148 Value header = (Value)columnMap.get(HEADER);
149 Map columnHeaderParameters = new HashMap ();
150 columnHeaderParameters.putAll(parameter);
151 columnHeaderParameters.putAll(columnMap);
152 Template template = headerColumnTemplate;
153 String key = columnMap.get(KEY).toString();
154 template = headerColumnTemplate;
155 if ( resizable && collapsedColumnTemplate != null && collapsedHeaderColumnTemplate != null ) {
156 if ( size != null && TableHandler.COLLAPSED.equals(size.get(key))) {
157 createResizableHandler(key, TableHandler.EXPAND, handlerUrl, storeName, id, columnHeaderParameters, parameters);
158 template = collapsedHeaderColumnTemplate;
159 } else {
160 createResizableHandler(key, TableHandler.COLLAPSE, handlerUrl, storeName, id, columnHeaderParameters, parameters);
161 }
162 }
163 if ( sortable && template != collapsedHeaderColumnTemplate ) {
164 String requestedOrder = TableHandler.ASCENDING;
165 if ( sortedBy != null && sortedBy.equals(key) ) {
166 if ( order.equals(TableHandler.ASCENDING) ) {
167 template = ascendingHeaderColumnTemplate;
168 requestedOrder = TableHandler.DESCENDING;
169 } else {
170 template = descendingHeaderColumnTemplate;
171 requestedOrder = TableHandler.ASCENDING;
172 }
173 }
174 createSortableHandler(key, requestedOrder, handlerUrl, storeName, id, columnHeaderParameters, parameters);
175 }
176 template.evaluate(headersBuffer, columnHeaderParameters);
177 }
178 parameter.put(HEADERS, new StringValue(headersBuffer.toString()));
179 Value []input = ((ArrayValue)parameter.get(SimpleProcessor.INPUT)).getArray();
180 for ( int i = 0; i < input.length; i++ ) {
181 StringBuffer columnsBuffer = new StringBuffer (1024);
182 Map inputParameter = ((MapValue)input[i]).getMap();
183 for ( int j = 0; j < columns.length; j++ ) {
184 Map columnMap = ((MapValue)columns[j]).getMap();
185 boolean replaceColumn = ((BooleanValue)columnMap.get(REPLACE_COLUMN)).booleanValue();
186 Value processorUri = (Value)columnMap.get(PROCESSOR);
187 Map columnParameters = new HashMap ();
188 columnParameters.putAll(parameter);
189 String key = columnMap.get(KEY).toString();
190 String name = columnMap.get(NAME).toString();
191 Object value = columnMap.get(VALUE);
192 if ( value == null || value == NullValue.NULL ) {
193 value = inputParameter.get(key);
194 }
195 columnParameters.put(name, value);
196 if ( processorUri != NullValue.NULL ) {
197 Processor processor = ProcessorManager.getInstance().getProcessor((URI)processorUri);
198 Value processorParameters = (Value)columnMap.get(PARAMETERS);
199 if ( processorParameters instanceof MapValue ) {
200 columnParameters.putAll(((MapValue)processorParameters).getMap());
201 }
202 Result processorResult = ProcessorManager.process(processor, columnParameters, context);
203 String resultKey = columnMap.get(RESULT).toString();
204 Value resultEntry = (Value)processorResult.getResultEntries().get(resultKey);
205 if ( resultEntry instanceof PrintableValue ) {
206 if ( replaceColumn ) {
207 ((PrintableValue)resultEntry).print(columnsBuffer);
208 } else {
209 StringBuffer resultBuffer = new StringBuffer ();
210 ((PrintableValue)resultEntry).print(resultBuffer);
211 columnParameters.put(VALUE, new StringValue(resultBuffer.toString()));
212 }
213 }
214 }
215 if ( !replaceColumn ) {
216 Template template = columnTemplate;
217 if ( size != null && TableHandler.COLLAPSED.equals(size.get(key))) {
218 template = collapsedColumnTemplate;
219 }
220 template.evaluate(columnsBuffer, columnParameters);
221 }
222 }
223 inputParameter.put(COLUMNS, new StringValue(columnsBuffer.toString()));
224 }
225 return super.process(parameter, context);
226 }
227
228 public ParameterDescriptor[] getParameterDescriptors() {
229 return parameterDescriptors;
230 }
231
232 protected void createSortableHandler(String column, String requestedOrder, String handlerUrl, String storeName, String id, Map parameters, Map parameter) throws IOException {
233 StringBuffer handlerBuffer = new StringBuffer (128);
234 handlerBuffer.append(handlerUrl).append('?').append(TableHandler.STORE).append('=').append(storeName).append('&').append(TableHandler.ID).append('=').append(id).
235 append('&').append(TableHandler.SORTED_BY).append('=').append(column).append('&').append(TableHandler.ORDER).append('=').append(requestedOrder);
236 for ( Iterator j = parameter.entrySet().iterator(); j.hasNext(); ) {
237 Map.Entry entry = (Map.Entry )j.next();
238 if ( entry.getValue() instanceof PrintableValue ) {
239 handlerBuffer.append('&').append(entry.getKey()).append('=');
240 ((PrintableValue)entry.getValue()).print(handlerBuffer);
241 }
242 }
243 parameters.put(SORTABLE_HANDLER, new StringValue(handlerBuffer.toString()));
244 }
245
246 protected void createResizableHandler(String column, String requestedSize, String handlerUrl, String storeName, String id, Map parameters, Map parameter) throws IOException {
247 StringBuffer handlerBuffer = new StringBuffer (128);
248 handlerBuffer.append(handlerUrl).append('?').append(TableHandler.STORE).append('=').append(storeName).append('&').append(TableHandler.ID).append('=').append(id).
249 append('&').append(requestedSize).append('=').append(column);
250 for ( Iterator j = parameter.entrySet().iterator(); j.hasNext(); ) {
251 Map.Entry entry = (Map.Entry )j.next();
252 if ( entry.getValue() instanceof PrintableValue ) {
253 handlerBuffer.append('&').append(entry.getKey()).append('=');
254 ((PrintableValue)entry.getValue()).print(handlerBuffer);
255 }
256 }
257 parameters.put(RESIZABLE_HANDLER, new StringValue(handlerBuffer.toString()));
258 }
259 } |
Popular Tags |
Java API By Example, From Geeks To Geeks.