source: main/trunk/greenstone3/src/java/org/greenstone/gsdl3/action/BrowseAction.java@ 25128

Last change on this file since 25128 was 25128, checked in by sjm84, 12 years ago

Second round of changes adding in the login ability, also interface options are now returned whenever site metadata is returned
  • Property svn:keywords set to Author Date Id Revision
File size: 11.6 KB
Line 
1package org.greenstone.gsdl3.action;
2
3import org.greenstone.gsdl3.core.ModuleInterface;
4import org.greenstone.gsdl3.util.*;
5// XML classes
6import org.w3c.dom.Node;
7import org.w3c.dom.NodeList;
8import org.w3c.dom.Document;
9import org.w3c.dom.Element;
10
11import java.util.HashMap;
12import java.util.HashSet;
13import java.util.Vector;
14import java.io.File;
15
16import org.apache.log4j.*;
17
18//NOTE: this class not used at present!!!!!
19/** action for classifier browsing */
20public class BrowseAction extends Action {
21
22 static Logger logger = Logger.getLogger(org.greenstone.gsdl3.action.BrowseAction.class.getName());
23
24 public static final String CLASSIFIER_ARG = "cl";
25 public static final String SIBLING_ARG = "sib";
26
27 /** process the request */
28 public Node process (Node message_node) {
29
30 Element message = this.converter.nodeToElement(message_node);
31
32 // get the request - assume only one
33 Element request = (Element)GSXML.getChildByTagName(message, GSXML.REQUEST_ELEM);
34
35 // the result
36 Element result = this.doc.createElement(GSXML.MESSAGE_ELEM);
37 Element response = classifierBrowse(request);
38 result.appendChild(response);
39 return result;
40 }
41
42
43 protected Element classifierBrowse(Element request) {
44
45 Element page_response = this.doc.createElement(GSXML.RESPONSE_ELEM);
46
47 // extract the params from the cgi-request, and check that we have a coll specified
48 Element cgi_paramList = (Element)GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
49 HashMap params = GSXML.extractParams(cgi_paramList, false);
50
51 String service_name = (String)params.get(GSParams.SERVICE);
52 String collection = (String)params.get(GSParams.COLLECTION);
53 if (collection == null || collection.equals("")) {
54 logger.error("classifierBrowse, need to specify a collection!");
55 return page_response;
56
57 }
58
59 //whether to retrieve siblings or not
60 boolean get_siblings = false;
61 String sibs = (String) params.get(SIBLING_ARG);
62 if (sibs != null && sibs.equals("1")) {
63 get_siblings = true;
64 }
65
66 UserContext userContext = new UserContext(request);
67 String to = GSPath.appendLink(collection, service_name);
68
69 // the first part of the response is the service description
70 // for now get this again from the service.
71 // this should be cached somehow later on.
72
73 Element info_message = this.doc.createElement(GSXML.MESSAGE_ELEM);
74 Element info_request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_DESCRIBE, to, userContext);
75 info_message.appendChild(info_request);
76
77 // also get the format stuff now if there is some
78 Element format_request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_FORMAT, to, userContext);
79 info_message.appendChild(format_request);
80 // process the requests
81
82 Element info_response = (Element) this.mr.process(info_message);
83
84 // the two responses
85 NodeList responses = info_response.getElementsByTagName(GSXML.RESPONSE_ELEM);
86 Element service_response = (Element)responses.item(0);
87 Element format_response = (Element)responses.item(1);
88
89 Element service_description = (Element)GSXML.getChildByTagName(service_response, GSXML.SERVICE_ELEM);
90 page_response.appendChild(this.doc.importNode(service_description, true));
91
92 //append site metadata
93 addSiteMetadata(page_response, userContext);
94 addInterfaceOptions(page_response);
95
96 // if rt=d, then we are just displaying the service
97 String request_type = (String)params.get(GSParams.REQUEST_TYPE);
98 if (request_type.equals("d")) {
99 //return the page that we have so far
100 return page_response;
101 }
102
103 // get the node that the user has clicked on
104 String classifier_node = (String)params.get(CLASSIFIER_ARG);
105
106 // if the node is not defined, return the page that we have so far
107 if (classifier_node ==null || classifier_node.equals("")) {
108 return page_response;
109 }
110
111 // the id of the classifier is the top id of the selected node
112 String top_id = OID.getTop(classifier_node);
113
114 HashSet metadata_names = new HashSet();
115
116 // add the format info into the response
117 Element format_elem = (Element)GSXML.getChildByTagName(format_response, GSXML.FORMAT_ELEM);
118 if (format_elem != null) {
119 // find the one for the classifier we are in
120 Element this_format = GSXML.getNamedElement(format_elem, GSXML.CLASSIFIER_ELEM, GSXML.NAME_ATT, top_id);
121 if (this_format == null) {
122 this_format = (Element)GSXML.getChildByTagName(format_elem, GSXML.DEFAULT_ELEM);
123 }
124 if (this_format != null) {
125 Element new_format = GSXML.duplicateWithNewName(this.doc, this_format, GSXML.FORMAT_ELEM, false);
126 // set teh format type
127 new_format.setAttribute(GSXML.TYPE_ATT, "browse");
128
129 page_response.appendChild(new_format);
130 getRequiredMetadataNames(new_format, metadata_names);
131 }
132 }
133
134 logger.info("extracted meta names, "+metadata_names.toString());
135 // get the browse structure for the selected node
136 Element classify_message = this.doc.createElement(GSXML.MESSAGE_ELEM);
137 Element classify_request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_PROCESS, to, userContext);
138 classify_message.appendChild(classify_request);
139
140 //Create a parameter list to specify the required structure information
141 // for now, always get ancestors and children
142 Element param_list = this.doc.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
143 classify_request.appendChild(param_list);
144 Element param = this.doc.createElement(GSXML.PARAM_ELEM);
145 param_list.appendChild(param);
146 param.setAttribute(GSXML.NAME_ATT, "structure");
147 param.setAttribute(GSXML.VALUE_ATT, "ancestors");
148 param = this.doc.createElement(GSXML.PARAM_ELEM);
149 param_list.appendChild(param);
150 param.setAttribute(GSXML.NAME_ATT, "structure");
151 param.setAttribute(GSXML.VALUE_ATT, "children");
152 if (get_siblings) {
153 param = this.doc.createElement(GSXML.PARAM_ELEM);
154 param_list.appendChild(param);
155 param.setAttribute(GSXML.NAME_ATT, "structure");
156 param.setAttribute(GSXML.VALUE_ATT, "siblings");
157 }
158
159 // put the classifier node into a classifier node list
160 Element classifier_list = this.doc.createElement(GSXML.CLASS_NODE_ELEM+GSXML.LIST_MODIFIER);
161 Element classifier = this.doc.createElement(GSXML.CLASS_NODE_ELEM);
162 classifier.setAttribute(GSXML.NODE_ID_ATT, classifier_node);
163 classifier_list.appendChild(classifier);
164 classify_request.appendChild(classifier_list);
165
166 // process the request
167 Element classify_response = (Element)this.mr.process(classify_message);
168 // get the structure element
169 String path = GSPath.appendLink(GSXML.RESPONSE_ELEM, GSXML.CLASS_NODE_ELEM+GSXML.LIST_MODIFIER);
170 path = GSPath.appendLink(path, GSXML.CLASS_NODE_ELEM);
171 path = GSPath.appendLink(path, GSXML.NODE_STRUCTURE_ELEM);
172 // assume that we always get back the top level CL1 node - this becomes the page_classifier node
173 path = GSPath.appendLink(path, GSXML.CLASS_NODE_ELEM);
174 Element cl_structure = (Element)GSXML.getNodeByPath(classify_response,
175 path);
176 if (cl_structure ==null) {
177 logger.error("classifier structure request returned no structure");
178 return page_response;
179 }
180
181 // add the classifier node as the page classifier
182 Element page_classifier = GSXML.duplicateWithNewName(this.doc, cl_structure, GSXML.CLASSIFIER_ELEM, true);
183 page_response.appendChild(page_classifier);
184 page_classifier.setAttribute(GSXML.NAME_ATT, top_id);
185
186 // get the metadata for each classifier node,
187 // then for each document node
188
189 Element metadata_message = this.doc.createElement(GSXML.MESSAGE_ELEM);
190
191 boolean did_classifier = false;
192 boolean did_documents = false;
193
194
195 // if there are classifier nodes
196 // create a metadata request for the classifier, and add it to
197 // the the message
198 NodeList cl_nodes = page_classifier.getElementsByTagName(GSXML.CLASS_NODE_ELEM);
199
200 if (cl_nodes.getLength() > 0) {
201 did_classifier = true;
202 Element cl_meta_request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_PROCESS, to+"MetadataRetrieve", userContext);
203 metadata_message.appendChild(cl_meta_request);
204
205 Element new_cl_nodes_list = this.doc.createElement(GSXML.CLASS_NODE_ELEM+GSXML.LIST_MODIFIER);
206 cl_meta_request.appendChild(new_cl_nodes_list);
207
208 for (int c=0; c<cl_nodes.getLength(); c++) {
209
210 Element cl = this.doc.createElement(GSXML.CLASS_NODE_ELEM);
211 cl.setAttribute(GSXML.NODE_ID_ATT, ((Element)cl_nodes.item(c)).getAttribute(GSXML.NODE_ID_ATT));
212 new_cl_nodes_list.appendChild(cl);
213 }
214
215 // create and add in the param list - for now get all the metadata
216 // should be based on info sent in from the recept, and the
217 // format stuff
218 Element cl_param_list = null;
219 if (metadata_names.isEmpty()) {
220 cl_param_list = this.doc.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
221 Element p = this.doc.createElement(GSXML.PARAM_ELEM);
222 cl_param_list.appendChild(p);
223 p.setAttribute(GSXML.NAME_ATT, "metadata");
224 p.setAttribute(GSXML.VALUE_ATT, "Title");
225 } else {
226 cl_param_list = createMetadataParamList(metadata_names);
227 }
228
229 cl_meta_request.appendChild(cl_param_list);
230
231 }
232
233 // if there are document nodes in the classification (happens
234 // sometimes), create a second request for document metadata and
235 // append to the message
236 NodeList doc_nodes = page_classifier.getElementsByTagName(GSXML.DOC_NODE_ELEM);
237 if (doc_nodes.getLength() > 0) {
238 did_documents = true;
239 Element doc_meta_request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_PROCESS, GSPath.appendLink(collection, "DocumentMetadataRetrieve"), userContext);
240 metadata_message.appendChild(doc_meta_request);
241
242 Element doc_list = this.doc.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
243 doc_meta_request.appendChild(doc_list);
244
245 for (int c=0; c<doc_nodes.getLength(); c++) {
246
247 Element d = this.doc.createElement(GSXML.DOC_NODE_ELEM);
248 d.setAttribute(GSXML.NODE_ID_ATT, ((Element)doc_nodes.item(c)).getAttribute(GSXML.NODE_ID_ATT));
249 doc_list.appendChild(d);
250 }
251
252 // create and add in the param list - add all for now
253 Element doc_param_list = this.doc.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
254 Element p = this.doc.createElement(GSXML.PARAM_ELEM);
255 doc_param_list.appendChild(p);
256 p.setAttribute(GSXML.NAME_ATT, "metadata");
257 p.setAttribute(GSXML.VALUE_ATT, "all");
258 doc_meta_request.appendChild(doc_param_list);
259
260 }
261
262 // process the metadata requests
263 Element metadata_response = (Element)this.mr.process(metadata_message);
264 if (did_classifier) {
265 // the classifier one will be the first response
266 // add the metadata lists for each node back into the
267 // page_classifier nodes
268 path = GSPath.appendLink(GSXML.RESPONSE_ELEM,
269 GSXML.CLASS_NODE_ELEM+GSXML.LIST_MODIFIER);
270 NodeList meta_response_cls = GSXML.getNodeByPath(metadata_response, path).getChildNodes();
271 for (int i = 0; i < cl_nodes.getLength(); i++) {
272 GSXML.mergeMetadataLists(cl_nodes.item(i), meta_response_cls.item(i));
273 }
274 }
275 if (did_documents) {
276 NodeList meta_response_docs = null;
277 if (!did_classifier) {
278 // its the first response
279 path = GSPath.appendLink(GSXML.RESPONSE_ELEM,
280 GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
281 meta_response_docs = GSXML.getNodeByPath(metadata_response, path).getChildNodes();
282 } else { // its the second response
283 meta_response_docs = GSXML.getChildByTagName(metadata_response.getElementsByTagName(GSXML.RESPONSE_ELEM).item(1), GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER).getChildNodes();
284 }
285
286 for (int i = 0; i < doc_nodes.getLength(); i++) {
287 GSXML.mergeMetadataLists(doc_nodes.item(i), meta_response_docs.item(i));
288 }
289 }
290
291
292 logger.debug("(BrowseAction) Page:\n" + this.converter.getPrettyString(page_response));
293 return page_response;
294 }
295
296 protected Element unknownBrowse(Element page, Element request, String browse_type) {
297 logger.error("unknown browse subtype: "+browse_type);
298 return null;
299 }
300}
301
302
Note: See TracBrowser for help on using the repository browser.