KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > openi > web > controller > admin > DatasourceFormController


1 /*********************************************************************************
2  * The contents of this file are subject to the OpenI Public License Version 1.0
3  * ("License"); You may not use this file except in compliance with the
4  * License. You may obtain a copy of the License at
5  * http://www.openi.org/docs/LICENSE.txt
6  *
7  * Software distributed under the License is distributed on an "AS IS" basis,
8  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
9  * the specific language governing rights and limitations under the License.
10  *
11  * The Original Code is: OpenI Open Source
12  *
13  * The Initial Developer of the Original Code is Loyalty Matrix, Inc.
14  * Portions created by Loyalty Matrix, Inc. are
15  * Copyright (C) 2005 Loyalty Matrix, Inc.; All Rights Reserved.
16  *
17  * Contributor(s): ______________________________________.
18  *
19  ********************************************************************************/

20 package org.openi.web.controller.admin;
21
22 import com.tonbeller.jpivot.olap.model.*;
23 import com.tonbeller.jpivot.xmla.*;
24 import org.apache.log4j.Logger;
25 import org.openi.analysis.Datasource;
26 import org.openi.application.Application;
27 import org.openi.project.JdbcDatasource;
28 import org.openi.project.Project;
29 import org.openi.project.ProjectContext;
30 import org.openi.util.*;
31 import org.springframework.validation.BindException;
32 import org.springframework.web.servlet.ModelAndView;
33 import org.springframework.web.servlet.mvc.SimpleFormController;
34 import org.springframework.web.servlet.mvc.multiaction.MultiActionController;
35 import java.net.URLEncoder JavaDoc;
36 import java.util.*;
37 import java.util.Map JavaDoc;
38 import javax.servlet.ServletException JavaDoc;
39 import javax.servlet.http.HttpServletRequest JavaDoc;
40 import javax.servlet.http.HttpServletResponse JavaDoc;
41 import javax.servlet.http.HttpSession JavaDoc;
42 import java.sql.SQLException JavaDoc;
43 import java.sql.Connection JavaDoc;
44 import java.sql.DriverManager JavaDoc;
45
46
47 /**
48  * @author Dipendra Pokhrel <br>
49  * @version $Revision: 1.19 $ $Date: 2006/04/12 00:39:12 $ <br>
50  *
51  * Controller for handling <strong>manage datasource</strong> request.
52  * This class is responsible for:
53  * <ul>
54  * <li> adding new datasource
55  * <li> editing exsting datasource
56  * <li> deleting existing datasource
57  * </ul>
58  *
59  */

60 public class DatasourceFormController extends SimpleFormController {
61     private static Logger logger = Logger.getLogger(DatasourceFormController.class);
62
63     private static final String JavaDoc MAIN_VIEW = "mainDatasourceView";
64     private static final String JavaDoc EDIT_VIEW = "editDatasourceView";
65     private static final String JavaDoc JASPER_VIEW = "manageJasperDatasourceView";
66     private static final String JavaDoc TYPE_SELECT_VIEW = "selectDatasourceTypeView";
67
68     private String JavaDoc mainView = MAIN_VIEW;
69     private String JavaDoc editView = EDIT_VIEW;
70     private String JavaDoc jasperView = JASPER_VIEW;
71     private String JavaDoc typeSelectView = TYPE_SELECT_VIEW;
72
73     private ProjectContext projectContext = null;
74
75     /**
76      * Retrieve a backing object for the current form from the given request
77      * @param request HttpServletRequest
78      * @return Object as application config object
79      * @throws Exception
80      */

81     protected Object JavaDoc formBackingObject(HttpServletRequest JavaDoc request)
82         throws Exception JavaDoc {
83         logger.debug("formBackingObject");
84
85         //get project context from session
86
projectContext = (ProjectContext) request.getSession()
87                                                  .getAttribute("projectContext");
88         Map JavaDoc map = new HashMap();
89         initModel(map);
90         return map;
91     }
92
93     private void initModel(Map JavaDoc map) {
94         Project project = projectContext.getProject();
95         Iterator iterator = project.getDataSourceMap().keySet().iterator();
96         List items = new ArrayList();
97
98         while (iterator.hasNext()) {
99             String JavaDoc ds = (String JavaDoc) iterator.next();
100             NameValue item = new NameValue(ds,
101                                            projectContext.getDatasourceObject(ds));
102             items.add(item);
103         }
104
105         map.put("datasourceList", items);
106         map.put("projectContext", projectContext);
107         map.put("datasourceMap", project.getDataSourceMap());
108     }
109
110     protected boolean validateParam(HttpServletRequest JavaDoc request, Map JavaDoc map)
111         throws Exception JavaDoc {
112         if ("Save".equalsIgnoreCase(request.getParameter("action"))) {
113             String JavaDoc dataSource;
114             dataSource = request.getParameter("dataSource");
115
116             //dataSource.trim();
117
if ((dataSource == null) || dataSource.equalsIgnoreCase("")) {
118                 map.put("errorMessage", "dataSource.message");
119
120                 return false;
121             }
122
123             String JavaDoc server = request.getParameter("server");
124
125             //server.trim();
126
if ((server == null) || server.equalsIgnoreCase("")) {
127                 map.put("errorMessage", "server.message");
128
129                 return false;
130             }
131
132             String JavaDoc catalog = request.getParameter("catalog");
133
134             //catalog.trim();
135
if ((catalog == null) || catalog.equalsIgnoreCase("")) {
136                 map.put("errorMessage", "catalog.message");
137
138                 return false;
139             }
140         }
141
142         return true;
143     }
144
145     protected boolean validateJdbcParam(HttpServletRequest JavaDoc request, Map JavaDoc map)
146         throws Exception JavaDoc {
147         if ("Save".equalsIgnoreCase(request.getParameter("action"))) {
148             String JavaDoc dataSource;
149             dataSource = request.getParameter("dataSource");
150
151             //dataSource.trim();
152
if ((dataSource == null) || dataSource.equalsIgnoreCase("")) {
153                 map.put("errorMessage", "dataSource.message");
154                 return false;
155             }
156
157             String JavaDoc driver = request.getParameter("driver");
158
159             //server.trim();
160
if ((driver == null) || driver.equalsIgnoreCase("")) {
161                 map.put("errorMessage", "driver.message");
162                 return false;
163             }
164
165             String JavaDoc url = request.getParameter("url");
166
167             //catalog.trim();
168
if ((url == null) || url.equalsIgnoreCase("")) {
169                 map.put("errorMessage", "jdbcurl.message");
170                 return false;
171             }
172
173             String JavaDoc user = request.getParameter("username");
174             String JavaDoc password = request.getParameter("password");
175
176             try {
177                 Class.forName(driver);
178                 Connection JavaDoc con = DriverManager.getConnection(url, user, password);
179                 try {
180                     con.close();
181                 } catch (SQLException JavaDoc ex) {}
182                 con = null;
183             } catch(ClassNotFoundException JavaDoc ex) {
184                 map.put("errorMessage", "driver.notfoundmessage");
185             } catch(SQLException JavaDoc ex) {
186                 map.put("errorMessage", "connection.errormessage");
187             }
188         }
189
190         return true;
191     }
192
193     /**
194      * Submit callback with all parameters. Called in case of submit without
195      * errors reported by the registered validator, or on every submit if no validator.
196      * @param request HttpServletRequest
197      * @param response HttpServletResponse
198      * @param command Object
199      * @param errors BindException
200      * @return ModelAndView
201      * @throws Exception
202      */

203     protected ModelAndView onSubmit(HttpServletRequest JavaDoc request,
204                                     HttpServletResponse JavaDoc response,
205                                     Object JavaDoc command, BindException errors) throws
206             Exception JavaDoc {
207         String JavaDoc action = request.getParameter("action");
208         logger.debug("onSubmit action=" + action);
209
210
211         if ("New".equals(action)) {
212             return handleNew(request, response, command, errors);
213         } else if("Select".equals(action)) {
214            return handleTypeSelect(request, response, command, errors);
215         } else if ("Edit".equals(action)) {
216             return handleEdit(request, response, command, errors);
217         } else if ("Delete".equals(action)) {
218             return handleDelete(request, response, command, errors);
219         } else if ("Save".equals(action)) {
220             if ("jdbc".equals(request.getParameter("selectedType"))) {
221                 return handleJdbcSave(request, response, command, errors);
222             } else {
223                 return handleSave(request, response, command, errors);
224             }
225         } else if ("Cancel".equals(action)) {
226             return handleCancel(request, response, command, errors);
227         } else if ("Get Catalog".equals(action)) {
228             return handleCatalog(request, response, command, errors);
229         } else if("Configure RDBMS Mapping".equals(action)) {
230             return handleJasper(request, response, command, errors);
231         } else if("Save All".equals(action)) {
232             return handleJasperSave(request, response, command, errors);
233         } else if (request.getParameter("dataSource") != null) {
234             return handleSelection(request, response, command, errors);
235         } else {
236             return super.onSubmit(request, response, command, errors);
237         }
238     }
239
240     private ModelAndView handleNew(HttpServletRequest JavaDoc request,
241                                    HttpServletResponse JavaDoc response, Object JavaDoc command,
242                                    BindException errors) throws Exception JavaDoc {
243         return new ModelAndView(typeSelectView, "model", command);
244     }
245
246     private ModelAndView handleTypeSelect(HttpServletRequest JavaDoc request,
247                                           HttpServletResponse JavaDoc response,
248                                           Object JavaDoc command, BindException errors) throws
249             Exception JavaDoc {
250         String JavaDoc type = request.getParameter("datasourceType");
251
252         if ("xmla".equals(type)) {
253             return handleAdd(request, response, command, errors);
254         } else if ("jdbc".equals(type)) {
255             return handleJdbcAdd(request, response, command, errors);
256         } else {
257             return handleNew(request, response, command, errors);
258         }
259     }
260
261     private ModelAndView handleSelection(HttpServletRequest JavaDoc request,
262         HttpServletResponse JavaDoc response, Object JavaDoc command, BindException errors)
263         throws Exception JavaDoc {
264         Map JavaDoc map = (Map JavaDoc) command;
265
266         if (request.getParameter("dataSource") != null) {
267             Object JavaDoc obj = projectContext.getDatasourceObject(request.getParameter(
268                         "dataSource"));
269
270             if (obj instanceof Datasource) {
271                 map.put("selectedType", "xmla");
272             } else {
273                 map.put("selectedType", "jdbc");
274             }
275
276             map.put("selectedDatasource", request.getParameter("dataSource"));
277             map.put("selectedDatasourceInstance", obj);
278         }
279
280         return new ModelAndView(mainView, "model", map);
281     }
282
283     private ModelAndView handleEdit(HttpServletRequest JavaDoc request,
284         HttpServletResponse JavaDoc response, Object JavaDoc command, BindException errors)
285         throws Exception JavaDoc {
286         ModelAndView modelview;
287
288         String JavaDoc datasource = request.getParameter("dataSource");
289
290         Map JavaDoc map = (Map JavaDoc) command;
291         map.put("dataSource", datasource);
292
293         if (datasource != null) {
294             Object JavaDoc obj = projectContext.getDatasourceObject(datasource);
295             map.put("selectedDatasourceInstance", obj);
296
297             if (obj instanceof Datasource) {
298                 map.put("selectedType", "xmla");
299
300                 String JavaDoc server = projectContext.getDatasource(datasource)
301                                               .getServer();
302                 String JavaDoc catelog = projectContext.getDatasource(datasource)
303                                                .getCatalog();
304
305                 List catalogList = null;
306
307                 try {
308                     catalogList = getCatalogList(server, getUser(request),
309                             getPassword(request));
310                 } catch (Exception JavaDoc e) {
311                     logger.error("Exception:", e);
312                     map.put("olapError", e.getMessage());
313                 }
314
315                 map.put("server", server);
316                 map.put("catalog", catelog);
317                 map.put("catalogList", catalogList);
318             } else {
319                 JdbcDatasource jdbc = (JdbcDatasource) obj;
320                 map.put("selectedType", "jdbc");
321                 map.put("driver", jdbc.getDriverClassName());
322                 map.put("url", jdbc.getUrl());
323                 map.put("username", jdbc.getUsername());
324                 map.put("password", jdbc.getPassword());
325             }
326
327             map.put("formType", "Edit");
328             modelview = new ModelAndView(editView, "model", map);
329         } else {
330             modelview = super.onSubmit(request, response, command, errors);
331         }
332
333         return modelview;
334     }
335
336     private ModelAndView handleAdd(HttpServletRequest JavaDoc request,
337         HttpServletResponse JavaDoc response, Object JavaDoc command, BindException errors)
338         throws Exception JavaDoc {
339         Map JavaDoc map = (Map JavaDoc) command;
340         map.put("formType", "Add");
341         map.put("selectedType", "xmla");
342
343         return new ModelAndView(editView, "model", command);
344     }
345
346     private ModelAndView handleJdbcAdd(HttpServletRequest JavaDoc request,
347         HttpServletResponse JavaDoc response, Object JavaDoc command, BindException errors)
348         throws Exception JavaDoc {
349         Map JavaDoc map = (Map JavaDoc) command;
350         map.put("formType", "Add");
351         map.put("selectedType", "jdbc");
352         map.put("driver", "net.sourceforge.jtds.jdbc.Driver");
353         map.put("url", "jdbc:jtds:sqlserver://yourhostname;DATABASENAME=yourdatabase");
354         return new ModelAndView(editView, "model", command);
355     }
356
357     private ModelAndView handleCatalog(HttpServletRequest JavaDoc request,
358         HttpServletResponse JavaDoc response, Object JavaDoc command, BindException errors) {
359         String JavaDoc server = request.getParameter("server");
360         Map JavaDoc map = (Map JavaDoc) command;
361         map.put("dataSource", request.getParameter("dataSource"));
362
363         if (server != null) {
364             List catalogList = null;
365
366             try {
367                 catalogList = getCatalogList(server, getUser(request),
368                         getPassword(request));
369             } catch (Exception JavaDoc e) {
370                 logger.error("Exception:", e);
371                 map.put("olapError", e.getMessage());
372             }
373
374             map.put("catalogList", catalogList);
375             map.put("server", server);
376             map.put("selectedType", request.getParameter("selectedType"));
377             map.put("formType", request.getParameter("formType"));
378         }
379
380         return new ModelAndView(editView, "model", command);
381     }
382
383     private ModelAndView handleDelete(HttpServletRequest JavaDoc request,
384         HttpServletResponse JavaDoc response, Object JavaDoc command, BindException errors)
385         throws Exception JavaDoc {
386         String JavaDoc datasource = request.getParameter("dataSource");
387
388         if (datasource != null) {
389             Map JavaDoc map = (Map JavaDoc) command;
390             ((Map JavaDoc) map.get("datasourceMap")).remove(datasource);
391             projectContext.saveProject();
392             initModel(map); //command = formBackingObject(request);
393
}
394         return new ModelAndView(mainView, "model", command);
395     }
396
397     private ModelAndView handleCancel(HttpServletRequest JavaDoc request,
398         HttpServletResponse JavaDoc response, Object JavaDoc command, BindException errors)
399         throws Exception JavaDoc {
400         if("Edit".equals(request.getParameter("formType"))) {
401             return handleSelection(request, response, command, errors);
402         } else {
403             return super.onSubmit(request, response, command, errors);
404         }
405     }
406
407     private ModelAndView handleSave(HttpServletRequest JavaDoc request,
408         HttpServletResponse JavaDoc response, Object JavaDoc command, BindException errors)
409         throws Exception JavaDoc {
410         String JavaDoc formtype = request.getParameter("formType");
411
412         if (formtype != null) {
413             String JavaDoc datasource = request.getParameter("dataSource");
414             String JavaDoc server = request.getParameter("server");
415             String JavaDoc catalog = request.getParameter("catalog");
416             Map JavaDoc map = (Map JavaDoc) command;
417             map.put("server", server);
418             map.put("dataSource", datasource);
419             map.put("catalog", catalog);
420             map.put("formType", request.getParameter("formType"));
421             map.put("selectedType", request.getParameter("selectedType"));
422
423             if (formtype.equalsIgnoreCase("Edit")) {
424                 if (validateParam(request, (Map JavaDoc) command)) {
425                     Datasource ds = projectContext.getDatasource(datasource);
426
427                     if (ds != null) {
428                         ds.setServer(server);
429                         ds.setCatalog(catalog);
430                         projectContext.saveProject();
431                         initModel(map);//command = formBackingObject(request);
432

433                         return handleSelection(request, response, command, errors);
434                         //return new ModelAndView(mainView, "model", command);
435
}
436                 } else {
437                     return new ModelAndView(editView, "model", command);
438                 }
439             } else if (formtype.equalsIgnoreCase("Add")) {
440                 if (validateParam(request, (Map JavaDoc) command)) {
441                     Datasource ds = projectContext.getDatasource(datasource);
442
443                     if (ds == null) {
444                         ds = new Datasource(server, catalog);
445
446                         projectContext.setDatasource(datasource, ds);
447                         projectContext.saveProject();
448
449                         initModel(map);//command = formBackingObject(request);
450

451                         return handleSelection(request, response, command, errors);
452                         //return new ModelAndView(mainView, "model", command);
453
}
454                 }
455             } else {
456                 return new ModelAndView(editView, "model", command);
457             }
458         }
459
460         return new ModelAndView(editView, "model", command);
461     }
462
463     private ModelAndView handleJdbcSave(HttpServletRequest JavaDoc request,
464                                         HttpServletResponse JavaDoc response,
465                                         Object JavaDoc command, BindException errors) throws
466             Exception JavaDoc {
467
468         String JavaDoc formtype = request.getParameter("formType");
469
470         if (formtype != null) {
471             String JavaDoc datasource = request.getParameter("dataSource");
472             String JavaDoc driver = request.getParameter("driver");
473             String JavaDoc url = request.getParameter("url");
474             String JavaDoc user = request.getParameter("username");
475             String JavaDoc password = request.getParameter("password");
476             Map JavaDoc map = (Map JavaDoc) command;
477             map.put("dataSource", datasource);
478             map.put("driver", driver);
479             map.put("url", url);
480             map.put("username", user);
481             map.put("password", password);
482             map.put("formType", request.getParameter("formType"));
483             map.put("selectedType", request.getParameter("selectedType"));
484
485             if (formtype.equalsIgnoreCase("Edit")) {
486                 if (validateJdbcParam(request, (Map JavaDoc) command)) {
487                     JdbcDatasource ds = (JdbcDatasource) projectContext
488                                         .getDatasourceObject(datasource);
489                     if (ds != null) {
490                         ds.setDriverClassName(driver);
491                         ds.setUrl(url);
492                         ds.setUsername(user);
493                         ds.setPassword(password);
494                         projectContext.saveProject();
495                         //command = formBackingObject(request);
496
return handleSelection(request, response, command,
497                                                errors);
498                         //return new ModelAndView(mainView, "model", command);
499
}
500                 } else {
501                     return new ModelAndView(editView, "model", command);
502                 }
503             } else if (formtype.equalsIgnoreCase("Add")) {
504                 if (validateJdbcParam(request, (Map JavaDoc) command)) {
505                     JdbcDatasource ds = (JdbcDatasource) projectContext
506                                         .getDatasourceObject(datasource);
507                     if (ds == null) {
508                         ds = new JdbcDatasource();
509                         ds.setDriverClassName(driver);
510                         ds.setUrl(url);
511                         ds.setUsername(user);
512                         ds.setPassword(password);
513                         projectContext.setDatasource(datasource, ds);
514                         projectContext.saveProject();
515                         initModel(map);//command = formBackingObject(request);
516
return handleSelection(request, response, command,
517                                                errors);
518                         //return new ModelAndView(mainView, "model",
519
// command);
520
}
521                 }
522             } else {
523                 return new ModelAndView(editView, "model", command);
524             }
525         }
526
527         return new ModelAndView(editView, "model", command);
528     }
529
530     private ModelAndView handleJasper(HttpServletRequest JavaDoc request,
531                                         HttpServletResponse JavaDoc response,
532                                         Object JavaDoc command, BindException errors) throws
533             Exception JavaDoc {
534         Map JavaDoc map = (Map JavaDoc) command;
535         Map JavaDoc files = buildJasperFileList();
536         if(files.size() == 0) {
537             map.put("errorMessage", "nojaspertemplates.errormessage");
538             return handleSelection(request, response, command, errors);
539         }
540         map.put("jdbcMap", files);
541         map.put("jdbcDatasource", projectContext.getJdbcDatasourceMap());
542         return new ModelAndView(jasperView, "model", command);
543     }
544
545     private ModelAndView handleJasperSave(HttpServletRequest JavaDoc request,
546                      HttpServletResponse JavaDoc response,
547                      Object JavaDoc command, BindException errors) throws
548             Exception JavaDoc {
549         String JavaDoc[] files = request.getParameterValues("templatePath");
550         String JavaDoc[] datasource = request.getParameterValues("datasource");
551         for (int i = 0; i < files.length; i++) {
552             if (files[i] != null && !"".equals(files[i]) && datasource[i] != null &&
553                 !"".equals(datasource[i])) {
554                 Map JavaDoc jdbcMap = projectContext.getProject().getJdbcMap();
555                 if (jdbcMap == null) {
556                     jdbcMap = new HashMap();
557                     projectContext.getProject().setJdbcMap(jdbcMap);
558                 }
559                 jdbcMap.put(files[i], datasource[i]);
560                 ((Map JavaDoc) command).put("jdbcMap", buildJasperFileList());
561             }
562         }
563         projectContext.saveProject();
564
565         return super.onSubmit(request, response, command, errors);
566     }
567
568     private Map JavaDoc buildJasperFileList() {
569         List files = projectContext.getFilesByExtension(".jrxml");
570         Iterator iter = files.iterator();
571         Map JavaDoc fileMap = new HashMap();
572         Map JavaDoc dsMap = projectContext.getJdbcDatasourceMap();
573         while (iter.hasNext()) {
574             String JavaDoc path = (String JavaDoc) iter.next();
575             String JavaDoc datasource = "";
576             if (projectContext.getProject().getJdbcMap() != null
577                 && projectContext.getProject().getJdbcMap().containsKey(path)) {
578                 if (dsMap != null) {
579                     datasource = (String JavaDoc) projectContext.getProject().
580                                  getJdbcMap().get(path);
581                 }
582             }
583             fileMap.put(path, datasource);
584         }
585         return fileMap;
586     }
587
588
589     private List getCatalogList(String JavaDoc server, String JavaDoc user, String JavaDoc pwd) throws
590             OlapException {
591         XMLA_SOAP olap = null;
592
593         if (Application.getInstance().isBasicAuthentication()) {
594             olap = new XMLA_SOAP(server, user, pwd);
595         } else {
596             // user password should not be null
597
olap = new XMLA_SOAP(server, "", "");
598         }
599
600         if (olap == null) {
601             return null;
602         }
603
604         List catalogList = new ArrayList();
605
606         Iterator iterator = olap.discoverCat().iterator();
607
608         while (iterator.hasNext()) {
609             OlapItem item = (OlapItem) iterator.next();
610             catalogList.add(item.getName());
611         }
612
613         return catalogList;
614     }
615
616     /**
617      * It will be better to place encoded user and password in current project so that it can
618      * be accessable easily without any helper method.**
619      * User or password passed to XMLA_SOAP c'tor or XMLAQueryTag as 'null' creates an exception.
620      * User can not be null in our case (beacuse we are using form based authentication
621      * however password can be if user does not use login valve.
622      * TODO: needs to add user/password accessor in project class and refactor this class
623      */

624     private String JavaDoc getUser(HttpServletRequest JavaDoc request) throws Exception JavaDoc {
625         return URLEncoder.encode(request.getUserPrincipal().getName(),
626                                  "UTF-8");
627     }
628
629     private String JavaDoc getPassword(HttpServletRequest JavaDoc request) throws Exception JavaDoc {
630         String JavaDoc pwd = (String JavaDoc) request.getSession()
631                      .getAttribute("user.credentials");
632
633         if (pwd != null) {
634             pwd = URLEncoder.encode(pwd, "UTF-8");
635         } else {
636             pwd = "";
637         }
638
639         return pwd;
640     }
641 }
642
Popular Tags