|
1
21
22 package com.jaspersoft.jasperserver.api.metadata.view.service.impl;
23
24 import java.io.BufferedInputStream  ;
25 import java.io.FileInputStream ;
26 import java.io.FileNotFoundException ;
27 import java.io.IOException ;
28 import java.io.InputStream ;
29 import java.util.HashSet ;
30 import java.util.Iterator ;
31 import java.util.List ;
32 import java.util.Properties ;
33 import java.util.Set ;
34
35 import junit.framework.TestCase;
36
37 import org.springframework.context.support.ClassPathXmlApplicationContext;
38
39 import com.jaspersoft.jasperserver.api.metadata.common.domain.DataType;
40 import com.jaspersoft.jasperserver.api.metadata.common.domain.FileResource;
41 import com.jaspersoft.jasperserver.api.metadata.common.domain.Folder;
42 import com.jaspersoft.jasperserver.api.metadata.common.domain.InputControl;
43 import com.jaspersoft.jasperserver.api.metadata.common.domain.ListOfValues;
44 import com.jaspersoft.jasperserver.api.metadata.common.domain.ListOfValuesItem;
45 import com.jaspersoft.jasperserver.api.metadata.common.domain.Resource;
46 import com.jaspersoft.jasperserver.api.metadata.common.domain.ResourceLookup;
47 import com.jaspersoft.jasperserver.api.metadata.common.domain.ResourceReference;
48 import com.jaspersoft.jasperserver.api.metadata.common.domain.Query;
49 import com.jaspersoft.jasperserver.api.metadata.common.domain.client.DataTypeImpl;
50 import com.jaspersoft.jasperserver.api.metadata.common.domain.client.FolderImpl;
51 import com.jaspersoft.jasperserver.api.metadata.common.domain.client.ListOfValuesItemImpl;
52 import com.jaspersoft.jasperserver.api.metadata.common.service.RepositoryService;
53 import com.jaspersoft.jasperserver.api.metadata.jasperreports.domain.BeanReportDataSource;
54 import com.jaspersoft.jasperserver.api.metadata.jasperreports.domain.JdbcReportDataSource;
55 import com.jaspersoft.jasperserver.api.metadata.jasperreports.domain.JndiJdbcReportDataSource;
56 import com.jaspersoft.jasperserver.api.metadata.jasperreports.domain.ReportDataSource;
57 import com.jaspersoft.jasperserver.api.metadata.jasperreports.domain.ReportUnit;
58 import com.jaspersoft.jasperserver.api.metadata.view.domain.FilterCriteria;
59 import com.jaspersoft.jasperserver.api.metadata.view.domain.FilterElementDisjunction;
60
61
65 public class HibernateRepositoryTest extends TestCase {
66
67 private Properties jdbcProps;
68 private RepositoryService repo;
69
70 public HibernateRepositoryTest(String name) {
71 super(name);
72 }
73
74 protected void setUp() throws Exception {
75 loadJdbcProps();
76 ClassPathXmlApplicationContext appContext = new ClassPathXmlApplicationContext(
77 new String [] {"hibernateConfig.xml", "viewService.xml"});
78
79 repo = (RepositoryService) appContext.getBean("repoService");
80 }
81
82 protected Properties loadJdbcProps() throws IOException , FileNotFoundException {
83 jdbcProps = new Properties ();
84 String jdbcPropFile = System.getProperty("test.hibernate.jdbc.properties");
85 BufferedInputStream is = new BufferedInputStream (new FileInputStream (jdbcPropFile));
86 jdbcProps.load(is);
87 is.close();
88 return jdbcProps;
89 }
90
91 public void disabled_testDeleteFolder() {
93 assertNotNull("Repo not null", repo);
94
95 Folder tmpFolder = new FolderImpl();
96 setCommon(tmpFolder, "tmp_foo");
97 repo.saveFolder(null, tmpFolder);
98
99 Folder subtmpFolder = new FolderImpl();
100 setCommon(subtmpFolder, "sub");
101 subtmpFolder.setParentFolder(tmpFolder);
102 repo.saveFolder(null, subtmpFolder);
103
104 JndiJdbcReportDataSource ds = (JndiJdbcReportDataSource) repo.newResource(null, JndiJdbcReportDataSource.class);
105 setCommon(ds, "dummyDS");
106 ds.setJndiName("foo");
107 ds.setParentFolder(tmpFolder);
108 repo.saveResource(null, ds);
109
110 JndiJdbcReportDataSource subds = (JndiJdbcReportDataSource) repo.newResource(null, JndiJdbcReportDataSource.class);
111 setCommon(subds, "subDS");
112 subds.setJndiName("subfoo");
113 subds.setParentFolder(subtmpFolder);
114 repo.saveResource(null, subds);
115
116 Resource dsResource = repo.getResource(null, "/tmp_foo/dummyDS");
117 assertNotNull(dsResource);
118 assertTrue(dsResource instanceof JndiJdbcReportDataSource);
119 ds = (JndiJdbcReportDataSource) dsResource;
120 assertEquals("foo", ds.getJndiName());
121
122 Resource subdsResource = repo.getResource(null, "/tmp_foo/sub/subDS");
123 assertNotNull(subdsResource);
124 assertTrue(subdsResource instanceof JndiJdbcReportDataSource);
125 subds = (JndiJdbcReportDataSource) subdsResource;
126 assertEquals("subfoo", subds.getJndiName());
127
128 repo.deleteFolder(null, "/tmp_foo");
129
130 List folders = repo.getSubFolders(null, "/");
131 for (Iterator it = folders.iterator(); it.hasNext();) {
132 Folder folder = (Folder) it.next();
133 assertFalse("tmp_foo".equals(folder.getName()));
134 }
135
136 dsResource = repo.getResource(null, "/tmp_foo/dummyDS");
137 assertNull(dsResource);
138
139 subdsResource = repo.getResource(null, "/tmp_foo/dummyDS");
140 assertNull(subdsResource);
141 }
142
143 public void disabled_testDeleteRollback() {
145 assertNotNull("Repo not null", repo);
146
147 Folder tmp1 = new FolderImpl();
148 setCommon(tmp1, "tmp1");
149 repo.saveFolder(null, tmp1);
150
151 Folder tmp2 = new FolderImpl();
152 setCommon(tmp2, "tmp2");
153 repo.saveFolder(null, tmp2);
154
155 tmp1 = repo.getFolder(null, "/tmp1");
156 assertNotNull(tmp1);
157 assertEquals("tmp1", tmp1.getName());
158
159 tmp2 = repo.getFolder(null, "/tmp2");
160 assertNotNull(tmp2);
161 assertEquals("tmp2", tmp2.getName());
162
163 boolean exception = false;
164 try {
165 repo.delete(null, null, new String [] { "/tmp1", "/tmp_zzz" });
166 } catch (Exception e) {
167 exception = true;
168 }
169 assertTrue(exception);
170
171
172 tmp1 = repo.getFolder(null, "/tmp1");
173 assertNotNull(tmp1);
174 assertEquals("tmp1", tmp1.getName());
175
176 repo.delete(null, null, new String [] { "/tmp1", "/tmp2" });
177
178 tmp1 = repo.getFolder(null, "/tmp1");
179 assertNull(tmp1);
180
181 tmp2 = repo.getFolder(null, "/tmp2");
182 assertNull(tmp2);
183 }
184
185 public void testFolderUpdate() {
186 assertNotNull("Repo not null", repo);
187
188 Folder folder = new FolderImpl();
189 setCommon(folder, "test_update");
190 repo.saveFolder(null, folder);
191
192 JndiJdbcReportDataSource ds = (JndiJdbcReportDataSource) repo.newResource(null, JndiJdbcReportDataSource.class);
193 setCommon(ds, "fooDS");
194 ds.setJndiName("foo");
195 ds.setParentFolder(folder);
196 repo.saveResource(null, ds);
197
198 folder = repo.getFolder(null, "/test_update");
199 assertNotNull(folder);
200 assertEquals("test_update", folder.getName());
201 assertEquals("test_update_label", folder.getLabel());
202
203 folder.setLabel("updated");
204 repo.saveFolder(null, folder);
205
206 folder = repo.getFolder(null, "/test_update");
207 assertNotNull(folder);
208 assertEquals("test_update", folder.getName());
209 assertEquals("updated", folder.getLabel());
210
211 Resource resource = repo.getResource(null, "/test_update/fooDS");
212 assertNotNull(resource);
213 assertTrue(resource instanceof JndiJdbcReportDataSource);
214 ds = (JndiJdbcReportDataSource) resource;
215 assertEquals("fooDS", ds.getName());
216 assertEquals("foo", ds.getJndiName());
217
218 repo.deleteFolder(null, "/test_update");
219 folder = repo.getFolder(null, "/test_update");
220 assertNull(folder);
221 }
222
223 public void testRepo() {
224 assertNotNull("Repo not null", repo);
225
226 write();
227
228 read();
229
230 readFolders();
231
232 update();
233
234 optimisticLocking();
235
236 list();
237
238 resources();
239
240 }
243
244 private void deleteRollback() {
245 boolean exception = false;
246 try {
247 repo.delete(null, new String []{"/datasources/JServerJdbcDS"}, null);
248 } catch (Exception e) {
249 exception = true;
250 }
251 assertTrue(exception);
252
253 Resource resource = repo.getResource(null, "/datasources/JServerJdbcDS");
254 assertNotNull(resource);
255 assertTrue(resource instanceof JdbcReportDataSource);
256 }
257
258 private void write() {
259 Folder dsFolder = new FolderImpl();
260 dsFolder.setName("datasources");
261 dsFolder.setLabel("Data Sources");
262 dsFolder.setDescription("Data Sources used by reports");
263 repo.saveFolder(null, dsFolder);
264
265 createJndiDS();
266 createJdbcDS();
267 createBeanDS();
268 createTableModelDS();
269
270 Folder reportsFolder = new FolderImpl();
271 reportsFolder.setName("reports");
272 reportsFolder.setLabel("Reports");
273 reportsFolder.setDescription("Reports");
274 repo.saveFolder(null, reportsFolder);
275
276 Folder samplesFolder = new FolderImpl();
277 samplesFolder.setName("samples");
278 samplesFolder.setLabel("Samples");
279 samplesFolder.setDescription("Samples");
280 samplesFolder.setParentFolder(reportsFolder);
281 repo.saveFolder(null, samplesFolder);
282
283 createAllAccounts(samplesFolder);
284 createSalesByMonth(samplesFolder);
285 createCustomDSReportFileResource(samplesFolder);
286 createCustomDSReport(samplesFolder);
287 createTableModelDSReport(samplesFolder);
288 createEmployeeAccounts(samplesFolder);
289 createEmployees(samplesFolder);
290
291 createImage();
292
293 Folder olapFolder = new FolderImpl();
294 olapFolder.setName("olap");
295 olapFolder.setLabel("OLAP Components");
296 olapFolder.setDescription("OLAP Components");
297 repo.saveFolder(null, olapFolder);
298
299 Folder connectionsFolder = new FolderImpl();
300 connectionsFolder.setName("connections");
301 connectionsFolder.setLabel("OLAP Connections");
302 connectionsFolder.setDescription("Connections used by OLAP");
303 connectionsFolder.setParentFolder(olapFolder);
304 repo.saveFolder(null, connectionsFolder);
305
306 Folder schemasFolder = new FolderImpl();
307 schemasFolder.setName("schemas");
308 schemasFolder.setLabel("OLAP Schemas");
309 schemasFolder.setDescription("Schemas used by OLAP");
310 schemasFolder.setParentFolder(olapFolder);
311 repo.saveFolder(null, schemasFolder);
312
313 Folder olapDsFolder = new FolderImpl();
314 olapDsFolder.setName("datasources");
315 olapDsFolder.setLabel("OLAP Data Sources");
316 olapDsFolder.setDescription("Data sources used by OLAP");
317 olapDsFolder.setParentFolder(olapFolder);
318 repo.saveFolder(null, olapDsFolder);
319
320 Folder olapViewsFolder = new FolderImpl();
321 olapViewsFolder.setName("views");
322 olapViewsFolder.setLabel("OLAP Views");
323 olapViewsFolder.setDescription("OLAP Views");
324 olapViewsFolder.setParentFolder(olapFolder);
325 repo.saveFolder(null, olapViewsFolder);
326 }
327
328 private void createImage() {
329 Folder folder = new FolderImpl();
330 folder.setName("images");
331 folder.setLabel("Images");
332 folder.setDescription("Folder containing reusable images");
333 repo.saveFolder(null, folder);
334
335 FileResource image = (FileResource) repo.newResource(null, FileResource.class);
336 image.setFileType(FileResource.TYPE_IMAGE);
337 image.readData(getClass().getResourceAsStream("/images/jasperreports.gif"));
338 image.setName("JRLogo");
339 image.setLabel("JR logo");
340 image.setDescription("JR logo");
341 image.setParentFolder(folder);
342
343 repo.saveResource(null, image);
344 }
345
346 private void createJndiDS() {
347 JndiJdbcReportDataSource datasource = (JndiJdbcReportDataSource) repo.newResource(null, JndiJdbcReportDataSource.class);
348 datasource.setName("JServerJNDIDS");
349 datasource.setLabel("JServer JNDI data source");
350 datasource.setDescription("JServer JNDI data source");
351 datasource.setJndiName(jdbcProps.getProperty("test.jndi"));
352 datasource.setParentFolder("/datasources");
353
354 repo.saveResource(null, datasource);
355 }
356
357 private void createJdbcDS() {
358 JdbcReportDataSource datasource = (JdbcReportDataSource) repo.newResource(null, JdbcReportDataSource.class);
359 datasource.setName("JServerJdbcDS");
360 datasource.setLabel("JServer Jdbc data source");
361 datasource.setDescription("JServer Jdbc data source");
362 datasource.setParentFolder("/datasources");
363
364 datasource.setDriverClass(jdbcProps.getProperty("test.jdbc.driverClassName"));
365 datasource.setConnectionUrl(jdbcProps.getProperty("test.jdbc.url"));
366 datasource.setUsername(jdbcProps.getProperty("test.jdbc.username"));
367 datasource.setPassword(jdbcProps.getProperty("test.jdbc.password"));
368
369 repo.saveResource(null, datasource);
370 }
371
372 private void createBeanDS() {
373 BeanReportDataSource datasource = (BeanReportDataSource) repo.newResource(null, BeanReportDataSource.class);
374 datasource.setName("CustomDSFromBean");
375 datasource.setLabel("Custom data source from a bean");
376 datasource.setDescription("A custom data source through a bean");
377 datasource.setParentFolder("/datasources");
378
379 datasource.setBeanName("customDataSourceService");
380
381 repo.saveResource(null, datasource);
382 }
383
384 private void createTableModelDS() {
385 BeanReportDataSource datasource = (BeanReportDataSource) repo.newResource(null, BeanReportDataSource.class);
386 datasource.setName("CustomTableModelDS");
387 datasource.setLabel("Custom data source from a table model");
388 datasource.setDescription("A custom data source through a table model");
389 datasource.setParentFolder("/datasources");
390
391 datasource.setBeanName("customDataSourceServiceFactory");
392 datasource.setBeanMethod("tableModelDataSource");
393
394 repo.saveResource(null, datasource);
395 }
396
397 private void createSalesByMonth(Folder folder) {
398 FileResource reportRes = (FileResource) repo.newResource(null, FileResource.class);
399 reportRes.setFileType(FileResource.TYPE_JRXML);
400 reportRes.setName("SalesByMonthReport");
401 reportRes.setLabel("Sales By Month Jasper Report");
402 reportRes.setDescription("Sales By Month Jasper Report");
403
404 InputStream jrxml = getClass().getResourceAsStream("/reports/jasper/SalesByMonth.jrxml");
405 reportRes.readData(jrxml);
406
407 ReportUnit unit = (ReportUnit) repo.newResource(null, ReportUnit.class);
408 unit.setName("SalesByMonth");
409 unit.setLabel("Sales By Month Report");
410 unit.setDescription("Sales By Month Report");
411 unit.setParentFolder(folder);
412
413 unit.setDataSourceReference("/datasources/JServerJdbcDS");
414 unit.setMainReport(reportRes);
415
416 FileResource jar = (FileResource) repo.newResource(null, FileResource.class);
417 jar.setFileType(FileResource.TYPE_JAR);
418 jar.readData(getClass().getResourceAsStream("/jars/scriptlet.jar"));
419 setCommon(jar, "Scriptlet");
420 unit.addResource(jar);
421
422 FileResource img = (FileResource) repo.newResource(null, FileResource.class);
423 img.setFileType(FileResource.TYPE_IMAGE);
424 img.readData(getClass().getResourceAsStream("/images/jasperreports.gif"));
425 setCommon(img, "Logo");
426 unit.addResource(img);
427
428 FileResource subrep = (FileResource) repo.newResource(null, FileResource.class);
429 subrep.setFileType(FileResource.TYPE_JRXML);
430 subrep.readData(getClass().getResourceAsStream("/reports/jasper/SalesByMonthDetail.jrxml"));
431 setCommon(subrep, "SalesByMonthDetail");
432 unit.addResource(subrep);
433
434 FileResource resBdl = (FileResource) repo.newResource(null, FileResource.class);
435 resBdl.setFileType(FileResource.TYPE_RESOURCE_BUNDLE);
436 resBdl.readData(getClass().getResourceAsStream("/resource_bundles/sales.properties"));
437 setCommon(resBdl, "sales.properties");
438 unit.addResource(resBdl);
439
440 FileResource resBdl_ro = (FileResource) repo.newResource(null, FileResource.class);
441 resBdl_ro.setFileType(FileResource.TYPE_RESOURCE_BUNDLE);
442 resBdl_ro.readData(getClass().getResourceAsStream("/resource_bundles/sales_ro.properties"));
443 setCommon(resBdl_ro, "sales_ro.properties");
444 unit.addResource(resBdl_ro);
445
446 InputControl textInputCtrl = (InputControl) repo.newResource(null, InputControl.class);
447 setCommon(textInputCtrl, "TextInputControl");
448 textInputCtrl.setType(InputControl.TYPE_SINGLE_VALUE);
449 textInputCtrl.setMandatory(false);
450 textInputCtrl.setReadOnly(false);
451 textInputCtrl.setLabel("Text Input Control");
453 textInputCtrl.setName("TextInput");
454 DataType dataType = new DataTypeImpl();
455 dataType.setName("test");
456 dataType.setLabel("test");
457 dataType.setType(DataType.TYPE_NUMBER);
458 textInputCtrl.setDataType(dataType);
459 unit.addInputControl(textInputCtrl);
460
461 InputControl checkboxInputControl = (InputControl) repo.newResource(null, InputControl.class);
462 setCommon(checkboxInputControl, "CheckboxInputControl");
463 checkboxInputControl.setType(InputControl.TYPE_BOOLEAN);
464 checkboxInputControl.setMandatory(true);
465 checkboxInputControl.setReadOnly(false);
466 checkboxInputControl.setLabel("Checkbox Input Control");
467 checkboxInputControl.setName("CheckboxInput");
468 unit.addInputControl(checkboxInputControl);
469
470 InputControl listInputControl = (InputControl) repo.newResource(null, InputControl.class);
471 setCommon(listInputControl, "ListInputControl");
472 listInputControl.setType(InputControl.TYPE_SINGLE_SELECT_LIST_OF_VALUES);
473 listInputControl.setMandatory(true);
474 listInputControl.setReadOnly(false);
475 listInputControl.setLabel("List Input Control");
476 listInputControl.setName("ListInput");
477
478 ListOfValues values = (ListOfValues) repo.newResource(null, ListOfValues.class);
479 values.setName("Some list of values");
480 values.setLabel("Some list of values label");
481 values.setDescription("Some list of values description");
482 ListOfValuesItem item = new ListOfValuesItemImpl();
483 item.setLabel("An item");
484 item.setValue("1");
485 values.addValue(item);
486 item = new ListOfValuesItemImpl();
487 item.setLabel("Another item");
488 item.setValue("2");
489 values.addValue(item);
490 item = new ListOfValuesItemImpl();
491 item.setLabel("Yet another item");
492 item.setValue("3");
493 values.addValue(item);
494 listInputControl.setListOfValues(values);
495
496 dataType = new DataTypeImpl();
497 dataType.setName("test");
498 dataType.setLabel("test");
499 dataType.setType(DataType.TYPE_TEXT);
500 listInputControl.setDataType(dataType);
501
502 unit.addInputControl(listInputControl);
503
504 createDateDatatype();
505
506 InputControl dateInputCtrl = (InputControl) repo.newResource(null, InputControl.class);
507 setCommon(dateInputCtrl, "DateInput");
508 dateInputCtrl.setType(InputControl.TYPE_SINGLE_VALUE);
509 dateInputCtrl.setMandatory(false);
510 dateInputCtrl.setReadOnly(false);
511 dateInputCtrl.setDataTypeReference("/datatypes/date");
512 unit.addInputControl(dateInputCtrl);
513
514 InputControl queryInputCtrl = (InputControl) repo.newResource(null, InputControl.class);
515 setCommon(queryInputCtrl, "QueryInput");
516 queryInputCtrl.setType(InputControl.TYPE_SINGLE_SELECT_QUERY);
517 queryInputCtrl.setMandatory(false);
518 queryInputCtrl.setReadOnly(false);
519 queryInputCtrl.setQueryValueColumn("user_name");
520 queryInputCtrl.addQueryVisibleColumn("first_name");
521 queryInputCtrl.addQueryVisibleColumn("last_name");
522 Query query = (Query) repo.newResource(null, Query.class);
523 setCommon(query, "testQuery");
524 query.setLanguage("sql");
525 query.setSql("select user_name, first_name, last_name from users");
526 queryInputCtrl.setQuery(query);
527 unit.addInputControl(queryInputCtrl);
528
529 repo.saveResource(null, unit);
530 }
531
532 private void createEmployees(Folder folder) {
533 FileResource reportRes = (FileResource) repo.newResource(null, FileResource.class);
534 reportRes.setFileType(FileResource.TYPE_JRXML);
535 setCommon(reportRes, "EmployeesJRXML");
536
537 InputStream jrxml = getClass().getResourceAsStream("/reports/jasper/Employees.jrxml");
538 reportRes.readData(jrxml);
539
540 ReportUnit unit = (ReportUnit) repo.newResource(null, ReportUnit.class);
541 unit.setName("Employees");
542 unit.setLabel("Employees");
543 unit.setParentFolder(folder);
544
545 unit.setDataSourceReference("/datasources/JServerJdbcDS");
546 unit.setMainReport(reportRes);
547
548 repo.saveResource(null, unit);
549 }
550
551 private void createEmployeeAccounts(Folder folder) {
552 FileResource reportRes = (FileResource) repo.newResource(null, FileResource.class);
553 reportRes.setFileType(FileResource.TYPE_JRXML);
554 setCommon(reportRes, "EmployeeAccountsJRXML");
555
556 InputStream jrxml = getClass().getResourceAsStream("/reports/jasper/EmployeeAccounts.jrxml");
557 reportRes.readData(jrxml);
558
559 ReportUnit unit = (ReportUnit) repo.newResource(null, ReportUnit.class);
560 unit.setName("EmployeeAccounts");
561 unit.setLabel("Employee Accounts");
562 unit.setParentFolder(folder);
563
564 unit.setDataSourceReference("/datasources/JServerJdbcDS");
565 unit.setMainReport(reportRes);
566
567 InputControl empIC = (InputControl) repo.newResource(null, InputControl.class);
568 setCommon(empIC, "EmployeeID");
569 empIC.setMandatory(true);
570 empIC.setType(InputControl.TYPE_SINGLE_VALUE);
571
572 DataType userDT = (DataType) repo.newResource(null, DataType.class);
573 setCommon(userDT, "UserIDDataType");
574 userDT.setType(DataType.TYPE_TEXT);
575 empIC.setDataType(userDT);
576
577 unit.addInputControl(empIC);
578
579 repo.saveResource(null, unit);
580 }
581
582 protected void createDateDatatype() {
583 Folder folder = new FolderImpl();
584 folder.setName("datatypes");
585 folder.setLabel("Input data types");
586 repo.saveFolder(null, folder);
587
588 DataType dateDataType = new DataTypeImpl();
589 setCommon(dateDataType, "date");
590 dateDataType.setType(DataType.TYPE_DATE);
591 dateDataType.setParentFolder(folder);
592 repo.saveResource(null, dateDataType);
593 }
594
595 private void setCommon(Resource res, String id) {
596 res.setName(id);
597 res.setLabel(id + "_label");
598 res.setDescription(id + " description");
599 }
600
601 private void createAllAccounts(Folder folder) {
602 FileResource reportRes = (FileResource) repo.newResource(null, FileResource.class);
603 reportRes.setFileType(FileResource.TYPE_JRXML);
604 reportRes.setName("AllAccountsReport");
605 reportRes.setLabel("All Accounts Jasper Report");
606 reportRes.setDescription("All Accounts Jasper Report");
607 reportRes.setParentFolder(folder);
608
609 InputStream jrxml = getClass().getResourceAsStream(
610 "/reports/jasper/AllAccounts.jrxml");
611 reportRes.readData(jrxml);
612
613 ReportUnit unit = (ReportUnit) repo.newResource(null, ReportUnit.class);
614 unit.setName("AllAccounts");
615 unit.setLabel("All Accounts Report");
616 unit.setDescription("All Accounts Report");
617 unit.setParentFolder(folder);
618
619 unit.setDataSourceReference("/datasources/JServerJNDIDS");
620 unit.setMainReport(reportRes);
621
622 FileResource res1 = (FileResource) repo.newResource(null, FileResource.class);
623 res1.setFileType(FileResource.TYPE_IMAGE);
624 res1.readData(getClass().getResourceAsStream("/images/jasperreports.gif"));
625 res1.setName("AllAccounts_Res1");
626 res1.setLabel("AllAccounts_Res1");
627 res1.setDescription("AllAccounts_Res1");
628 unit.addResource(res1);
629
630 FileResource res2 = (FileResource) repo.newResource(null, FileResource.class);
631 res2.setFileType(FileResource.TYPE_IMAGE);
632 res2.readData(getClass().getResourceAsStream("/images/logo.jpg"));
633 res2.setName("AllAccounts_Res2");
634 res2.setLabel("AllAccounts_Res2");
635 res2.setDescription("AllAccounts_Res2");
636 unit.addResource(res2);
637
638 repo.saveResource(null, unit);
639 }
640
641
642 private void createCustomDSReportFileResource(Folder folder) {
643 FileResource reportRes = (FileResource) repo.newResource(null, FileResource.class);
644 reportRes.setFileType(FileResource.TYPE_JRXML);
645 reportRes.setName("DataSourceReportTemplate");
646 reportRes.setLabel("Report showing Custom Data Source");
647 reportRes.setDescription("Report showing use of Custom Data Source via a bean");
648 reportRes.setParentFolder(folder);
649
650 InputStream jrxml = getClass().getResourceAsStream(
651 "/reports/jasper/DataSourceReport.jrxml");
652 reportRes.readData(jrxml);
653
654 repo.saveResource(null, reportRes);
655 }
656
657 private void createCustomDSReport(Folder folder) {
658
659 ReportUnit unit = (ReportUnit) repo.newResource(null, ReportUnit.class);
660 unit.setName("DataSourceReport");
661 unit.setLabel("Report showing Custom Data Source");
662 unit.setDescription("Report showing use of Custom Data Source via a bean");
663 unit.setParentFolder(folder);
664
665 unit.setMainReportReference("/reports/samples/DataSourceReportTemplate");
666 unit.setDataSourceReference("/datasources/CustomDSFromBean");
667
668 repo.saveResource(null, unit);
669 }
670
671 private void createTableModelDSReport(Folder folder) {
672
673 ReportUnit unit = (ReportUnit) repo.newResource(null, ReportUnit.class);
674 unit.setName("DataSourceTableModel");
675 unit.setLabel("Table Model Data Source");
676 unit.setDescription("Report showing use of Custom Data Source via table model");
677 unit.setParentFolder(folder);
678
679 unit.setMainReportReference("/reports/samples/DataSourceReportTemplate");
680 unit.setDataSourceReference("/datasources/CustomTableModelDS");
681 unit.setMainReportReference("/reports/samples/DataSourceReportTemplate");
682
683 repo.saveResource(null, unit);
684 }
685
686 private void update() {
687 ReportUnit unit = (ReportUnit) repo.getResource(null, "/reports/samples/AllAccounts");
688 assertEquals("AllAccounts", unit.getName());
689 assertEquals("/reports/samples/AllAccounts", unit.getURIString());
690
691 unit.setLabel("Updated " + unit.getLabel());
692
693 FileResource removed = unit.removeResourceLocal("AllAccounts_Res1");
694 assertNotNull(removed);
695
696 FileResource res3 = (FileResource) repo.newResource(null, FileResource.class);
697 res3.setFileType(FileResource.TYPE_IMAGE);
698 res3.readData(getClass().getResourceAsStream("/images/jasperreports.gif"));
699 res3.setName("AllAccounts_Res3");
700 res3.setLabel("AllAccounts_Res3");
701 res3.setDescription("AllAccounts_Res3");
702 unit.addResource(res3);
703
704 FileResource res4 = (FileResource) repo.newResource(null, FileResource.class);
705 res4.setFileType(FileResource.TYPE_IMAGE);
706 res4.setReferenceURI("/images/JRLogo");
707 setCommon(res4, "LogoLink");
708 unit.addResource(res4);
709
710 repo.saveResource(null, unit);
711
712 unit = (ReportUnit) repo.getResource(null, "/reports/samples/AllAccounts");
713 assertTrue(unit.getLabel().startsWith("Updated "));
714
715 List resources = unit.getResources();
716 assertNotNull(resources);
717 assertEquals(3, resources.size());
718 }
719
720 private void read() {
721 ReportUnit unit = (ReportUnit) repo.getResource(null, "/reports/samples/AllAccounts");
722 assertNotNull(unit);
723 assertEquals(ReportUnit.class.getName(), unit.getResourceType());
724 assertEquals("AllAccounts", unit.getName());
725
726 ResourceReference dsRef = unit.getDataSource();
727 assertNotNull(dsRef);
728 assertFalse(dsRef.isLocal());
729 assertEquals("/datasources/JServerJNDIDS", dsRef.getReferenceURI());
730
731 ResourceReference mainReportRef = unit.getMainReport();
732 assertNotNull(mainReportRef);
733 assertTrue(mainReportRef.isLocal());
734 Resource mainReport = mainReportRef.getLocalResource();
735 assertTrue(mainReport instanceof FileResource);
736 assertEquals("AllAccountsReport", mainReport.getName());
737
738 List resources = unit.getResources();
739 assertNotNull(resources);
740 assertEquals(2, resources.size());
741
742 FileResource img = (FileResource) repo.getResource(null, "/images/JRLogo");
743 assertNotNull(img);
744 assertEquals("JRLogo", img.getName());
745
746 datasources();
747 parentFolder();
748 propertyFilter();
749 disjunctionFilter();
750 }
751
752 private void datasources() {
753 FilterCriteria criteria = FilterCriteria.createFilter(ReportDataSource.class);
754 ResourceLookup[] lookups = repo.findResource(null, criteria);
755 assertNotNull(lookups);
756 assertTrue(2 <= lookups.length);
757 for (int i = 0; i < lookups.length; i++) {
758 Resource res = repo.getResource(null, lookups[i].getURIString());
759 assertTrue(res instanceof ReportDataSource);
760 }
761 }
762
763 private void parentFolder() {
764 FilterCriteria criteria = FilterCriteria.createFilter();
765 criteria.addFilterElement(FilterCriteria.createParentFolderFilter("/datasources"));
766 ResourceLookup[] folderResources = repo.findResource(null, criteria);
767 assertNotNull(folderResources);
768 assertTrue(folderResources.length > 0);
769 for (int i = 0; i < folderResources.length; i++) {
770 ResourceLookup lookup = folderResources[i];
771 assertEquals("/datasources", lookup.getParentFolder());
772 if (lookup.getName().equals("JServerJdbcDS")) {
773 assertEquals(JdbcReportDataSource.class.getName(), lookup.getResourceType());
774 } else if (lookup.getName().equals("JServerJNDIDS")) {
775 assertEquals(JndiJdbcReportDataSource.class.getName(), lookup.getResourceType());
776 }
777 }
778 }
779
780 private void propertyFilter() {
781 FilterCriteria criteria = FilterCriteria.createFilter(FileResource.class);
782 criteria.addFilterElement(FilterCriteria.createPropertyEqualsFilter("fileType", FileResource.TYPE_IMAGE));
783 ResourceLookup[] resources = repo.findResource(null, criteria);
784 assertNotNull(resources);
785 assertTrue(resources.length > 0);
786 for (int i = 0; i < resources.length; i++) {
787 Resource res = repo.getResource(null, resources[i].getURIString());
788 assertTrue(res instanceof FileResource);
789 FileResource fileRes = (FileResource) res;
790 assertEquals(FileResource.class.getName(), fileRes.getResourceType());
791 assertEquals(FileResource.TYPE_IMAGE, fileRes.getFileType());
792 }
793 }
794
795 private void disjunctionFilter() {
796 FilterCriteria criteria = FilterCriteria.createFilter();
797 FilterElementDisjunction disjunction = criteria.addDisjunction();
798 disjunction.addFilterElement(FilterCriteria.createPropertyLikeFilter("name", "%JdbcDS"));
799 disjunction.addNegatedFilterElement(FilterCriteria.createParentFolderFilter("/datasources"));
800
801 ResourceLookup[] resources = repo.findResource(null, criteria);
802 assertNotNull(resources);
803 assertTrue(resources.length > 0);
804 for (int i = 0; i < resources.length; i++) {
805 ResourceLookup lookup = resources[i];
806 assertTrue(lookup.getName().endsWith("JdbcDS") || !lookup.getParentFolder().equals("/datasources"));
807 }
808 }
809
810 private void readFolders() {
811 List folders = repo.getAllFolders(null);
812 assertNotNull(folders);
813 assertTrue(5 <= folders.size());
814
815 Iterator it = folders.iterator();
816 Folder folder = (Folder) it.next();
817 assertEquals("/", folder.getURIString());
818
819 Set folderURIs = new HashSet ();
820 while (it.hasNext()) {
821 folder = (Folder) it.next();
822 folderURIs.add(folder.getURIString());
823 }
824 assertTrue(folderURIs.contains("/datasources"));
825 assertTrue(folderURIs.contains("/images"));
826 assertTrue(folderURIs.contains("/reports"));
827 assertTrue(folderURIs.contains("/reports/samples"));
828
829 List subFolders = repo.getSubFolders(null, "/reports");
830 assertNotNull(subFolders);
831 assertEquals(1, subFolders.size());
832 folder = (Folder) subFolders.get(0);
833 assertEquals("/reports/samples", folder.getURIString());
834 }
835
836 private void list() {
837 ResourceLookup[] units = repo.findResource(null, FilterCriteria.createFilter(ReportUnit.class));
838 assertNotNull(units);
839 assertTrue(units.length >= 2);
840 }
841
842 private void resources() {
843 Resource[] resources = repo.findResource(null, null);
844 assertNotNull(resources);
845 assertTrue(resources.length >= 2);
846 }
847
848 private void optimisticLocking() {
849 JndiJdbcReportDataSource ds1 = (JndiJdbcReportDataSource) repo.getResource(null, "/datasources/JServerJNDIDS");
850 ds1.setLabel(ds1.getLabel() + " Updated 1");
851
852 JndiJdbcReportDataSource ds2 = (JndiJdbcReportDataSource) repo.getResource(null, "/datasources/JServerJNDIDS");
853 ds2.setLabel(ds1.getLabel() + " Updated 2");
854
855 repo.saveResource(null, ds1);
856
857 boolean failed = false;
858 try {
859 repo.saveResource(null, ds2);
860 } catch (Exception e) {
861 failed = true;
862 }
863 assertTrue(failed);
864 }
865
866
867 public void testLocalResourceReplace() {
868 assertNotNull("Repo not null", repo);
869
870 Folder folder = new FolderImpl();
871 setCommon(folder, "testLocalResourceReplace");
872 folder.setParentFolder("/");
873 repo.saveFolder(null, folder);
874
875 ReportUnit unit = (ReportUnit) repo.newResource(null, ReportUnit.class);
876 setCommon(unit, "unit");
877 unit.setParentFolder(folder);
878
879 FileResource rep = (FileResource) repo.newResource(null, FileResource.class);
880 setCommon(rep, "report");
881 rep.readData(getClass().getResourceAsStream("/reports/jasper/SalesByMonth.jrxml"));
882 unit.setMainReport(rep);
883
884 JdbcReportDataSource jdbcDS = (JdbcReportDataSource) repo.newResource(null, JdbcReportDataSource.class);
885 setCommon(jdbcDS, "ds");
886 jdbcDS.setConnectionUrl("jdbc:mysql://localhost:3306/jasperserver");
887 jdbcDS.setDriverClass("com.mysql.jdbc.Driver");
888 jdbcDS.setUsername("user");
889 jdbcDS.setPassword("passwd");
890 unit.setDataSource(jdbcDS);
891
892 repo.saveResource(null, unit);
893
894 Resource res = repo.getResource(null, "/testLocalResourceReplace/unit");
895 assertNotNull(unit);
896 assertTrue(res instanceof ReportUnit);
897 unit = (ReportUnit) res;
898 ResourceReference dsRef = unit.getDataSource();
899 assertNotNull(dsRef);
900 assertTrue(dsRef.isLocal());
901 Resource ds = dsRef.getLocalResource();
902 assertTrue(ds instanceof JdbcReportDataSource);
903 assertEquals("ds", ds.getName());
904
905 JndiJdbcReportDataSource jndiDS = (JndiJdbcReportDataSource) repo.newResource(null, JndiJdbcReportDataSource.class);
906 setCommon(jndiDS, "ds");
907 jndiDS.setJndiName("jdbc/jserver");
908 unit.setDataSource(jndiDS);
909
910 repo.saveResource(null, unit);
911
912 res = repo.getResource(null, "/testLocalResourceReplace/unit");
913 assertNotNull(unit);
914 assertTrue(res instanceof ReportUnit);
915 unit = (ReportUnit) res;
916
917 dsRef = unit.getDataSource();
918 assertNotNull(dsRef);
919 assertTrue(dsRef.isLocal());
920 Resource dsLocal = dsRef.getLocalResource();
921 assertEquals("ds", dsLocal.getName());
922 assertTrue(dsLocal instanceof JndiJdbcReportDataSource);
923 jndiDS = (JndiJdbcReportDataSource) dsLocal;
924 assertEquals("jdbc/jserver", jndiDS.getJndiName());
925
926 repo.deleteFolder(null, "/testLocalResourceReplace");
927 }
928 }
929 |
Popular Tags |
Java API By Example, From Geeks To Geeks.