|
1 package org.jahia.webapps.fichotheque;
2
3 import java.util.*;
4 import java.sql.*;
5
6 import org.jahia.tools.*;
7 import org.jahia.tools.db.*;
8
9 import org.apache.ojb.broker.PersistenceBroker;
11
12 import org.apache.ojb.broker.*;
13 import org.apache.ojb.broker.query.*;
14 import org.apache.ojb.broker.accesslayer.*;
15
16
22 public class AccessDB {
23 private static org.apache.log4j.Logger logger =
24 org.apache.log4j.Logger.getLogger(AccessDB.class);
25
26
27 private static DBServices m_DBServices;
28
29
30 private static PersistenceBroker broker = null;
31
32
37 public static void init (PersistenceBroker broker_) {
38 logger.debug("AccessDB: getting broker instance");
39 broker = broker_;
40 }
41
42
50 public static ResultSet execSql (String  sql)
51 throws SQLException {
52
53 ResultSet rs = null;
54
55 try {
56 Connection conn = broker.serviceConnectionManager().getConnection();
57 Statement stmt = conn.createStatement();
58 rs = stmt.executeQuery(sql);
59 } catch (LookupException e) {
60 logger.error("DBServices#executeQuery", e);
61 }
62 return rs;
63 }
64
65
72 public static int getNextId (String column, String table) {
73 int new_id = 1;
74 ResultSet rs;
75
76 try {
77 rs = execSql("select max(" + column + ") from " + table);
78 if (rs.next()) {
79 new_id = rs.getInt(1) + 1;
80 } else {
81 logger.debug("DBServices - getNextId: problem reaching DB " +
82 table);
83 }
84 } catch (SQLException e) {
85 logger.error("DBServices - getNextId", e);
86 }
87 return new_id;
88 }
89
90 public static boolean insertCard (Card crd) {
91 boolean ret = true;
92
93 try {
94 broker.beginTransaction();
95 broker.store(crd);
96 broker.commitTransaction();
97 } catch (PersistenceBrokerException e) {
98 logger.error("AccessDB - inserCard", e);
99 broker.abortTransaction();
100 ret = false;
101 }
102 return ret;
103 }
104
105 public static boolean deleteCard (int id) {
106 boolean test = true;
107 try {
108
109 Criteria crit = new Criteria();
110 crit.addEqualTo("card_id", new Integer (id));
111 broker.clearCache();
112 broker.beginTransaction();
113 QueryByCriteria q = QueryFactory.newQuery(Card.class, crit);
114 broker.deleteByQuery(q);
115 broker.commitTransaction();
116 } catch (PersistenceBrokerException e) {
117 logger.error("DBServices - removeExpense", e);
118 broker.abortTransaction();
119 test = false;
120 }
121 return test;
122 }
123
124 public static Card updateCard (Card card, Vector fields, Vector fieldsName) {
125
126 Card crd = null;
127 try {
128 Criteria crit1 = new Criteria();
129 crit1.addEqualTo("card_id", new Integer (card.getId()));
130 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
131 broker.clearCache();
132 Collection userColl = broker.getCollectionByQuery(q);
133
134 if (!userColl.isEmpty()) {
135 java.util.Iterator iter = userColl.iterator();
136 crd = (Card) iter.next();
137 crd.setLastName( (String ) fields.get(1));
138 crd.setFirstName( (String ) fields.get(2));
139 crd.setAbsenceType( (String ) fields.get(3));
140 crd.setFirstAbsenceDay( (String ) fields.get(4));
141 crd.setLastAbsenceDay( (String ) fields.get(5));
142 crd.setUser( (String ) fields.get(6));
143 crd.setContextId( (String ) fields.get(7));
144 crd.setStatus( (String ) fields.get(8));
145
146 broker.beginTransaction();
147 broker.store(crd);
148 broker.commitTransaction();
149 }
150 } catch (PersistenceBrokerException e) {
151 logger.error("DBServices - renameCategory", e);
152 broker.abortTransaction();
153
154 }
155 return crd;
156 }
157
158
164 public static int updateDB (String sql)
165 throws SQLException {
166 Connection dbConn = null;
167
168 try {
170 dbConn = m_DBServices.getInstance().getConnection();
171 Statement stmt = dbConn.createStatement();
172 int count = stmt.executeUpdate(sql);
173 return count;
174 } finally {
175 if (dbConn != null) {
176 m_DBServices.getInstance().freeConnection(dbConn);
177 logger.debug("AccessDB: execSql: freeConnection executed.");
178 }
179 }
180 }
181
182 public static Vector getSearchAll (String paraName1, String param1,
183 String paraName2, String param2,
184 String user) {
185 Vector contacts = new Vector();
186
187 try {
188
189 Criteria crit1 = new Criteria();
190 if (param2.equals("")) {
191 Criteria crit2 = new Criteria();
192 Criteria crit3 = new Criteria();
193 Criteria crit4 = new Criteria();
194 Criteria crit5 = new Criteria();
195 Criteria crit6 = new Criteria();
196
197 crit1.addEqualTo("name", param1);
198 crit1.addEqualTo("user", user);
199 crit2.addEqualTo("firstname", param1);
200 crit2.addEqualTo("user", user);
201 crit3.addEqualTo("absencetype", param1);
202 crit3.addEqualTo("user", user);
203 crit4.addEqualTo("firstabsenceday", param1);
204 crit4.addEqualTo("user", user);
205 crit5.addEqualTo("lastabsenceday", param1);
206 crit5.addEqualTo("user", user);
207 crit6.addEqualTo("status", param1);
208 crit6.addEqualTo("user", user);
209 crit1.addOrCriteria(crit2);
210 crit1.addOrCriteria(crit3);
211 crit1.addOrCriteria(crit4);
212 crit1.addOrCriteria(crit5);
213 crit1.addOrCriteria(crit6);
214 } else {
215 Criteria crit2 = new Criteria();
216 Criteria crit3 = new Criteria();
217 Criteria crit4 = new Criteria();
218 Criteria crit5 = new Criteria();
219 Criteria crit6 = new Criteria();
220 Criteria crit7 = new Criteria();
221 Criteria crit8 = new Criteria();
222 Criteria crit9 = new Criteria();
223 Criteria crit10 = new Criteria();
224 Criteria crit11 = new Criteria();
225 Criteria crit12 = new Criteria();
226
227 crit1.addEqualTo("name", param1);
228 crit1.addEqualTo("user", user);
229 crit2.addEqualTo("firstname", param1);
230 crit2.addEqualTo("user", user);
231 crit3.addEqualTo("absencetype", param1);
232 crit3.addEqualTo("user", user);
233 crit4.addEqualTo("firstabsenceday", param1);
234 crit4.addEqualTo("user", user);
235 crit5.addEqualTo("lastabsenceday", param1);
236 crit5.addEqualTo("user", user);
237 crit6.addEqualTo("status", param1);
238 crit6.addEqualTo("user", user);
239 crit7.addEqualTo("name", param2);
240 crit7.addEqualTo("user", user);
241 crit8.addEqualTo("firstname", param2);
242 crit8.addEqualTo("user", user);
243 crit9.addEqualTo("absencetype", param2);
244 crit9.addEqualTo("user", user);
245 crit10.addEqualTo("firstabsenceday", param2);
246 crit10.addEqualTo("user", user);
247 crit11.addEqualTo("lastabsenceday", param2);
248 crit11.addEqualTo("user", user);
249 crit12.addEqualTo("status", param2);
250 crit12.addEqualTo("user", user);
251
252 crit1.addOrCriteria(crit2);
253 crit1.addOrCriteria(crit3);
254 crit1.addOrCriteria(crit4);
255 crit1.addOrCriteria(crit5);
256 crit1.addOrCriteria(crit6);
257 crit1.addOrCriteria(crit7);
258 crit1.addOrCriteria(crit8);
259 crit1.addOrCriteria(crit9);
260 crit1.addOrCriteria(crit10);
261 crit1.addOrCriteria(crit11);
262 crit1.addOrCriteria(crit12);
263
264 }
265
266 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
267 broker.clearCache();
268 Collection userColl = broker.getCollectionByQuery(q);
269 if (!userColl.isEmpty()) {
270
271 java.util.Iterator iter = userColl.iterator();
272 while (iter.hasNext()) {
273 contacts.add(iter.next());
274 }
275 }
276 for (int i = 0; i < contacts.size(); i++) {
277 Card c = (Card) contacts.get(i);
278
279 }
280
281 } catch (Exception e) {
282 logger.error("DBServices - getDbUserDesc", e);
283 }
284
285 return contacts;
286 }
287
288 public static Vector getSearchNameFirst (String paraName1, String param1,
289 String paraName2, String param2,
290 String user) {
291 Vector contacts = new Vector();
292
293 try {
294
295 Criteria crit1 = new Criteria();
296 if (param2.equals("")) {
297
298 crit1.addEqualTo("name", param1);
299 crit1.addEqualTo("user", user);
300
301 } else {
302 Criteria crit2 = new Criteria();
303 crit1.addEqualTo("name", param1);
304 crit1.addEqualTo("user", user);
305 crit2.addEqualTo("firstname", param2);
306 crit2.addEqualTo("user", user);
307 crit1.addOrCriteria(crit2);
308 }
309
310 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
311 broker.clearCache();
312 Collection userColl = broker.getCollectionByQuery(q);
313 if (!userColl.isEmpty()) {
314
315 java.util.Iterator iter = userColl.iterator();
316 while (iter.hasNext()) {
317 contacts.add(iter.next());
318 }
319 }
320 for (int i = 0; i < contacts.size(); i++) {
321 Card c = (Card) contacts.get(i);
322
323 }
324
325 } catch (Exception e) {
326 logger.error("DBServices - getDbUserDesc", e);
327 }
328
329 return contacts;
330 }
331
332 public static Vector getSearchNameName (String paraName1, String param1,
333 String paraName2, String param2,
334 String user) {
335 Vector contacts = new Vector();
336
337 try {
338 Criteria crit1 = new Criteria();
339 if (param2.equals("")) {
340
341 crit1.addEqualTo("name", param1);
342 crit1.addEqualTo("user", user);
343
344 } else {
345 Criteria crit2 = new Criteria();
346 crit1.addEqualTo("name", param1);
347 crit1.addEqualTo("user", user);
348 crit2.addEqualTo("name", param2);
349 crit2.addEqualTo("user", user);
350 crit1.addOrCriteria(crit2);
351 }
352
353 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
354 broker.clearCache();
355 Collection userColl = broker.getCollectionByQuery(q);
356 if (!userColl.isEmpty()) {
357
358 java.util.Iterator iter = userColl.iterator();
359 while (iter.hasNext()) {
360 contacts.add(iter.next());
361 }
362 }
363 for (int i = 0; i < contacts.size(); i++) {
364 Card c = (Card) contacts.get(i);
365 }
366
367 } catch (Exception e) {
368 logger.error("DBServices - getDbUserDesc", e);
369 }
370
371 return contacts;
372 }
373
374 public static Vector getSearchFirstName (String paraName1, String param1,
375 String paraName2, String param2,
376 String user) {
377 Vector contacts = new Vector();
378
379 try {
380
381 Criteria crit1 = new Criteria();
382 if (param2.equals("")) {
383
384 crit1.addEqualTo("firstname", param1);
385 crit1.addEqualTo("user", user);
386
387 } else {
388 Criteria crit2 = new Criteria();
389 crit1.addEqualTo("firstname", param1);
390 crit1.addEqualTo("user", user);
391 crit2.addEqualTo("name", param2);
392 crit2.addEqualTo("user", user);
393 crit1.addOrCriteria(crit2);
394 }
395
396 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
397 broker.clearCache();
398 Collection userColl = broker.getCollectionByQuery(q);
399 if (!userColl.isEmpty()) {
400
401 java.util.Iterator iter = userColl.iterator();
402 while (iter.hasNext()) {
403 contacts.add(iter.next());
404 }
405 }
406 for (int i = 0; i < contacts.size(); i++) {
407 Card c = (Card) contacts.get(i);
408
409 }
410
411 } catch (Exception e) {
412 logger.error("DBServices - getDbUserDesc", e);
413 }
414
415 return contacts;
416 }
417
418 public static Vector getSearchNameAbs (String paraName1, String param1,
419 String paraName2, String param2,
420 String user) {
421 Vector contacts = new Vector();
422
423 try {
424
425 Criteria crit1 = new Criteria();
426 if (param2.equals("")) {
427
428 crit1.addEqualTo("name", param1);
429 crit1.addEqualTo("user", user);
430
431 } else {
432 Criteria crit2 = new Criteria();
433 crit1.addEqualTo("name", param1);
434 crit1.addEqualTo("user", user);
435 crit2.addEqualTo("absencetype", param2);
436 crit2.addEqualTo("user", user);
437 crit1.addOrCriteria(crit2);
438 }
439
440 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
441 broker.clearCache();
442 Collection userColl = broker.getCollectionByQuery(q);
443 if (!userColl.isEmpty()) {
444
445 java.util.Iterator iter = userColl.iterator();
446 while (iter.hasNext()) {
447 contacts.add(iter.next());
448 }
449 }
450 for (int i = 0; i < contacts.size(); i++) {
451 Card c = (Card) contacts.get(i);
452
453 }
454
455 } catch (Exception e) {
456 logger.error("DBServices - getDbUserDesc", e);
457 }
458
459 return contacts;
460 }
461
462 public static Vector getSearchAbsName (String paraName1, String param1,
463 String paraName2, String param2,
464 String user) {
465 Vector contacts = new Vector();
466
467 try {
468
469 Criteria crit1 = new Criteria();
470 if (param2.equals("")) {
471
472 crit1.addEqualTo("absencetype", param1);
473 crit1.addEqualTo("user", user);
474
475 } else {
476 Criteria crit2 = new Criteria();
477 crit1.addEqualTo("absencetype", param1);
478 crit1.addEqualTo("user", user);
479 crit2.addEqualTo("name", param2);
480 crit2.addEqualTo("user", user);
481 crit1.addOrCriteria(crit2);
482 }
483
484 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
485 broker.clearCache();
486 Collection userColl = broker.getCollectionByQuery(q);
487 if (!userColl.isEmpty()) {
488
489 java.util.Iterator iter = userColl.iterator();
490 while (iter.hasNext()) {
491 contacts.add(iter.next());
492 }
493 }
494 for (int i = 0; i < contacts.size(); i++) {
495 Card c = (Card) contacts.get(i);
496
497 }
498
499 } catch (Exception e) {
500 logger.error("DBServices - getDbUserDesc", e);
501 }
502
503 return contacts;
504 }
505
506 public static Vector getSearchAllParam (String paraName1, String param1,
507 String paraName2, String param2,
508 String user) {
509 Vector contacts = new Vector();
510
511 try {
512
513 Criteria crit1 = new Criteria();
514 if (param2.equals("")) {
515 if (paraName1.equals("NAME")) {
516
517 crit1.addEqualTo("name", param1);
518 crit1.addEqualTo("user", user);
519 }
520 if (paraName1.equals("FIRSTNAME")) {
521 crit1.addEqualTo("firstname", param1);
522 crit1.addEqualTo("user", user);
523
524 }
525 if (paraName1.equals("FIRSTABSENCEDAY")) {
526 crit1.addEqualTo("firstabsenceday", param1);
527 crit1.addEqualTo("user", user);
528
529 }
530 if (paraName1.equals("LASTABSENCEDAY")) {
531 crit1.addEqualTo("lastabsenceday", param1);
532 crit1.addEqualTo("user", user);
533
534 }
535 if (paraName1.equals("ABSENCETYPE")) {
536 crit1.addEqualTo("absencetype", param1);
537 crit1.addEqualTo("user", user);
538
539 }
540 if (paraName1.equals("STATUS")) {
541 crit1.addEqualTo("status", param1);
542 crit1.addEqualTo("user", user);
543
544 }
545
546 } else {
547
548 Criteria crit2 = new Criteria();
549 Criteria crit3 = new Criteria();
550 Criteria crit4 = new Criteria();
551 Criteria crit5 = new Criteria();
552 Criteria crit6 = new Criteria();
553 Criteria crit7 = new Criteria();
554
555 if (paraName1.equals("NAME")) {
556
557 crit1.addEqualTo("name", param1);
558 crit1.addEqualTo("user", user);
559 }
560 if (paraName1.equals("FIRSTNAME")) {
561 crit1.addEqualTo("firstname", param1);
562 crit1.addEqualTo("user", user);
563
564 }
565 if (paraName1.equals("FIRSTABSENCEDAY")) {
566 crit1.addEqualTo("firstabsenceday", param1);
567 crit1.addEqualTo("user", user);
568
569 }
570 if (paraName1.equals("LASTABSENCEDAY")) {
571 crit1.addEqualTo("lastabsenceday", param1);
572 crit1.addEqualTo("user", user);
573
574 }
575 if (paraName1.equals("ABSENCETYPE")) {
576 crit1.addEqualTo("absencetype", param1);
577 crit1.addEqualTo("user", user);
578
579 }
580 if (paraName1.equals("STATUS")) {
581 crit1.addEqualTo("status", param1);
582 crit1.addEqualTo("user", user);
583
584 }
585
586 crit2.addEqualTo("name", param2);
587 crit2.addEqualTo("user", user);
588 crit3.addEqualTo("firstname", param2);
589 crit3.addEqualTo("user", user);
590 crit4.addEqualTo("absencetype", param2);
591 crit4.addEqualTo("user", user);
592 crit5.addEqualTo("firstabsenceday", param2);
593 crit5.addEqualTo("user", user);
594 crit6.addEqualTo("lastabsenceday", param2);
595 crit6.addEqualTo("user", user);
596 crit7.addEqualTo("status", param2);
597 crit7.addEqualTo("user", user);
598
599 crit1.addOrCriteria(crit2);
600 crit1.addOrCriteria(crit3);
601 crit1.addOrCriteria(crit4);
602 crit1.addOrCriteria(crit5);
603 crit1.addOrCriteria(crit6);
604 crit1.addOrCriteria(crit7);
605
606 }
607
608 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
609 broker.clearCache();
610 Collection userColl = broker.getCollectionByQuery(q);
611 if (!userColl.isEmpty()) {
612
613 java.util.Iterator iter = userColl.iterator();
614 while (iter.hasNext()) {
615 contacts.add(iter.next());
616 }
617 }
618 for (int i = 0; i < contacts.size(); i++) {
619 Card c = (Card) contacts.get(i);
620
621 }
622
623 } catch (Exception e) {
624 logger.error("DBServices - getDbUserDesc", e);
625 }
626
627 return contacts;
628 }
629
630 public static Vector getSearchParamAll (String paraName1, String param1,
631 String paraName2, String param2,
632 String user) {
633 Vector contacts = new Vector();
634
635 try {
636
637 Criteria crit1 = new Criteria();
638 if (param1.equals("")) {
639 if (paraName2.equals("NAME")) {
640 crit1.addEqualTo("name", param2);
641 crit1.addEqualTo("user", user);
642 }
643 if (paraName2.equals("FIRSTNAME")) {
644
645 crit1.addEqualTo("firstname", param2);
646 crit1.addEqualTo("user", user);
647
648 }
649 if (paraName2.equals("FIRSTABSENCEDAY")) {
650 crit1.addEqualTo("firstabsenceday", param2);
651 crit1.addEqualTo("user", user);
652
653 }
654 if (paraName2.equals("LASTABSENCEDAY")) {
655 crit1.addEqualTo("lastabsenceday", param2);
656 crit1.addEqualTo("user", user);
657
658 }
659 if (paraName2.equals("ABSENCETYPE")) {
660 crit1.addEqualTo("absencetype", param2);
661 crit1.addEqualTo("user", user);
662
663 }
664 if (paraName2.equals("STATUS")) {
665 crit1.addEqualTo("status", param2);
666 crit1.addEqualTo("user", user);
667
668 }
669
670 } else {
671
672 Criteria crit2 = new Criteria();
673 Criteria crit3 = new Criteria();
674 Criteria crit4 = new Criteria();
675 Criteria crit5 = new Criteria();
676 Criteria crit6 = new Criteria();
677 Criteria crit7 = new Criteria();
678
679 if (paraName2.equals("NAME")) {
680
681 crit1.addEqualTo("name", param2);
682 crit1.addEqualTo("user", user);
683 }
684 if (paraName2.equals("FIRSTNAME")) {
685
686 crit1.addEqualTo("firstname", param2);
687 crit1.addEqualTo("user", user);
688
689 }
690 if (paraName2.equals("FIRSTABSENCEDAY")) {
691 crit1.addEqualTo("firstabsenceday", param2);
692 crit1.addEqualTo("user", user);
693
694 }
695 if (paraName2.equals("LASTABSENCEDAY")) {
696 crit1.addEqualTo("lastabsenceday", param2);
697 crit1.addEqualTo("user", user);
698
699 }
700 if (paraName2.equals("ABSENCETYPE")) {
701 crit1.addEqualTo("absencetype", param2);
702 crit1.addEqualTo("user", user);
703
704 }
705 if (paraName2.equals("STATUS")) {
706 crit1.addEqualTo("status", param2);
707 crit1.addEqualTo("user", user);
708
709 }
710
711 crit2.addEqualTo("name", param1);
712 crit2.addEqualTo("user", user);
713 crit3.addEqualTo("firstname", param1);
714 crit3.addEqualTo("user", user);
715 crit4.addEqualTo("absencetype", param1);
716 crit4.addEqualTo("user", user);
717 crit5.addEqualTo("firstabsenceday", param1);
718 crit5.addEqualTo("user", user);
719 crit6.addEqualTo("lastabsenceday", param1);
720 crit6.addEqualTo("user", user);
721 crit7.addEqualTo("status", param1);
722 crit7.addEqualTo("user", user);
723
724 crit1.addOrCriteria(crit2);
725 crit1.addOrCriteria(crit3);
726 crit1.addOrCriteria(crit4);
727 crit1.addOrCriteria(crit5);
728 crit1.addOrCriteria(crit6);
729 crit1.addOrCriteria(crit7);
730
731 }
732
733 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
734 broker.clearCache();
735 Collection userColl = broker.getCollectionByQuery(q);
736 if (!userColl.isEmpty()) {
737
738 java.util.Iterator iter = userColl.iterator();
739 while (iter.hasNext()) {
740 contacts.add(iter.next());
741 }
742 }
743 for (int i = 0; i < contacts.size(); i++) {
744 Card c = (Card) contacts.get(i);
745
746 }
747
748 } catch (Exception e) {
749 logger.error("DBServices - getDbUserDesc", e);
750 }
751
752 return contacts;
753 }
754
755 public static Vector getSearchNameFirstAbs (String paraName1, String param1,
756 String paraName2, String param2,
757 String user) {
758 Vector contacts = new Vector();
759
760 try {
761
762 Criteria crit1 = new Criteria();
763 if (param2.equals("")) {
764
765 crit1.addEqualTo("name", param1);
766 crit1.addEqualTo("user", user);
767
768 } else {
769 Criteria crit2 = new Criteria();
770 crit1.addEqualTo("name", param1);
771 crit1.addEqualTo("user", user);
772 crit2.addEqualTo("firstabsenceday", param2);
773 crit2.addEqualTo("user", user);
774 crit1.addOrCriteria(crit2);
775 }
776
777 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
778 broker.clearCache();
779 Collection userColl = broker.getCollectionByQuery(q);
780 if (!userColl.isEmpty()) {
781
782 java.util.Iterator iter = userColl.iterator();
783 while (iter.hasNext()) {
784 contacts.add(iter.next());
785 }
786 }
787 for (int i = 0; i < contacts.size(); i++) {
788 Card c = (Card) contacts.get(i);
789
790 }
791
792 } catch (Exception e) {
793 logger.error("DBServices - getDbUserDesc", e);
794 }
795
796 return contacts;
797 }
798
799 public static Vector getSearchFirstAbsName (String paraName1, String param1,
800 String paraName2, String param2,
801 String user) {
802 Vector contacts = new Vector();
803
804 try {
805
806 Criteria crit1 = new Criteria();
807 if (param2.equals("")) {
808
809 crit1.addEqualTo("firstabsenceday", param1);
810 crit1.addEqualTo("user", user);
811
812 } else {
813 Criteria crit2 = new Criteria();
814 crit1.addEqualTo("firstabsenceday", param1);
815 crit1.addEqualTo("user", user);
816 crit2.addEqualTo("name", param2);
817 crit2.addEqualTo("user", user);
818 crit1.addOrCriteria(crit2);
819 }
820
821 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
822 broker.clearCache();
823 Collection userColl = broker.getCollectionByQuery(q);
824 if (!userColl.isEmpty()) {
825
826 java.util.Iterator iter = userColl.iterator();
827 while (iter.hasNext()) {
828 contacts.add(iter.next());
829 }
830 }
831 for (int i = 0; i < contacts.size(); i++) {
832 Card c = (Card) contacts.get(i);
833
834 }
835
836 } catch (Exception e) {
837 logger.error("DBServices - getDbUserDesc", e);
838 }
839
840 return contacts;
841 }
842
843 public static Vector getSearchNameLastAbs (String paraName1, String param1,
844 String paraName2, String param2,
845 String user) {
846 Vector contacts = new Vector();
847
848 try {
849
850 Criteria crit1 = new Criteria();
851 if (param2.equals("")) {
852
853 crit1.addEqualTo("name", param1);
854 crit1.addEqualTo("user", user);
855
856 } else {
857 Criteria crit2 = new Criteria();
858 crit1.addEqualTo("name", param1);
859 crit1.addEqualTo("user", user);
860 crit2.addEqualTo("lastabsenceday", param2);
861 crit2.addEqualTo("user", user);
862 crit1.addOrCriteria(crit2);
863 }
864
865 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
866 broker.clearCache();
867 Collection userColl = broker.getCollectionByQuery(q);
868 if (!userColl.isEmpty()) {
869
870 java.util.Iterator iter = userColl.iterator();
871 while (iter.hasNext()) {
872 contacts.add(iter.next());
873 }
874 }
875 for (int i = 0; i < contacts.size(); i++) {
876 Card c = (Card) contacts.get(i);
877
878 }
879
880 } catch (Exception e) {
881 logger.error("DBServices - getDbUserDesc", e);
882 }
883
884 return contacts;
885 }
886
887 public static Vector getSearchNameAbsLast (String paraName1, String param1,
888 String paraName2, String param2,
889 String user) {
890 Vector contacts = new Vector();
891
892 try {
893
894 Criteria crit1 = new Criteria();
895 if (param2.equals("")) {
896
897 crit1.addEqualTo("lastabsenceday", param1);
898 crit1.addEqualTo("user", user);
899
900 } else {
901 Criteria crit2 = new Criteria();
902 crit1.addEqualTo("lastabsenceday", param1);
903 crit1.addEqualTo("user", user);
904 crit2.addEqualTo("name", param2);
905 crit2.addEqualTo("user", user);
906 crit1.addOrCriteria(crit2);
907 }
908
909 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
910 broker.clearCache();
911 Collection userColl = broker.getCollectionByQuery(q);
912 if (!userColl.isEmpty()) {
913
914 java.util.Iterator iter = userColl.iterator();
915 while (iter.hasNext()) {
916 contacts.add(iter.next());
917 }
918 }
919 for (int i = 0; i < contacts.size(); i++) {
920 Card c = (Card) contacts.get(i);
921
922 }
923
924 } catch (Exception e) {
925 logger.error("DBServices - getDbUserDesc", e);
926 }
927
928 return contacts;
929 }
930
931 public static Vector getSearchNameStat (String paraName1, String param1,
932 String paraName2, String param2,
933 String user) {
934 Vector contacts = new Vector();
935
936 try {
937
938 Criteria crit1 = new Criteria();
939 if (param2.equals("")) {
940
941 crit1.addEqualTo("name", param1);
942 crit1.addEqualTo("user", user);
943
944 } else {
945 Criteria crit2 = new Criteria();
946 crit1.addEqualTo("name", param1);
947 crit1.addEqualTo("user", user);
948 crit2.addEqualTo("status", param2);
949 crit2.addEqualTo("user", user);
950 crit1.addOrCriteria(crit2);
951 }
952
953 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
954 broker.clearCache();
955 Collection userColl = broker.getCollectionByQuery(q);
956 if (!userColl.isEmpty()) {
957
958 java.util.Iterator iter = userColl.iterator();
959 while (iter.hasNext()) {
960 contacts.add(iter.next());
961 }
962 }
963 for (int i = 0; i < contacts.size(); i++) {
964 Card c = (Card) contacts.get(i);
965
966 }
967
968 } catch (Exception e) {
969 logger.error("DBServices - getDbUserDesc", e);
970 }
971
972 return contacts;
973 }
974
975 public static Vector getSearchStatName (String paraName1, String param1,
976 String paraName2, String param2,
977 String user) {
978 Vector contacts = new Vector();
979
980 try {
981
982 Criteria crit1 = new Criteria();
983 if (param2.equals("")) {
984
985 crit1.addEqualTo("status", param1);
986 crit1.addEqualTo("user", user);
987
988 } else {
989 Criteria crit2 = new Criteria();
990 crit1.addEqualTo("status", param1);
991 crit1.addEqualTo("user", user);
992 crit2.addEqualTo("name", param2);
993 crit2.addEqualTo("user", user);
994 crit1.addOrCriteria(crit2);
995 }
996
997 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
998 broker.clearCache();
999 Collection userColl = broker.getCollectionByQuery(q);
1000 if (!userColl.isEmpty()) {
1001
1002 java.util.Iterator iter = userColl.iterator();
1003 while (iter.hasNext()) {
1004 contacts.add(iter.next());
1005 }
1006 }
1007 for (int i = 0; i < contacts.size(); i++) {
1008 Card c = (Card) contacts.get(i);
1009
1010 }
1011
1012 } catch (Exception e) {
1013 logger.error("DBServices - getDbUserDesc", e);
1014 }
1015
1016 return contacts;
1017 }
1018
1019 public static Vector getSearchFirstAbs (String paraName1, String param1,
1020 String paraName2, String param2,
1021 String user) {
1022 Vector contacts = new Vector();
1023
1024 try {
1025
1026 Criteria crit1 = new Criteria();
1027 if (param2.equals("")) {
1028
1029 crit1.addEqualTo("firstname", param1);
1030 crit1.addEqualTo("user", user);
1031
1032 } else {
1033 Criteria crit2 = new Criteria();
1034 crit1.addEqualTo("firstname", param1);
1035 crit1.addEqualTo("user", user);
1036 crit2.addEqualTo("absencetype", param2);
1037 crit2.addEqualTo("user", user);
1038 crit1.addOrCriteria(crit2);
1039 }
1040
1041 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1042 broker.clearCache();
1043 Collection userColl = broker.getCollectionByQuery(q);
1044 if (!userColl.isEmpty()) {
1045
1046 java.util.Iterator iter = userColl.iterator();
1047 while (iter.hasNext()) {
1048 contacts.add(iter.next());
1049 }
1050 }
1051 for (int i = 0; i < contacts.size(); i++) {
1052 Card c = (Card) contacts.get(i);
1053
1054 }
1055
1056 } catch (Exception e) {
1057 logger.error("DBServices - getDbUserDesc", e);
1058 }
1059
1060 return contacts;
1061 }
1062
1063 public static Vector getSearchAbsFirs (String paraName1, String param1,
1064 String paraName2, String param2,
1065 String user) {
1066 Vector contacts = new Vector();
1067
1068 try {
1069
1070 Criteria crit1 = new Criteria();
1071 if (param2.equals("")) {
1072
1073 crit1.addEqualTo("absencetype", param1);
1074 crit1.addEqualTo("user", user);
1075
1076 } else {
1077 Criteria crit2 = new Criteria();
1078 crit1.addEqualTo("absencetype", param1);
1079 crit1.addEqualTo("user", user);
1080 crit2.addEqualTo("firstname", param2);
1081 crit2.addEqualTo("user", user);
1082 crit1.addOrCriteria(crit2);
1083 }
1084
1085 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1086 broker.clearCache();
1087 Collection userColl = broker.getCollectionByQuery(q);
1088 if (!userColl.isEmpty()) {
1089
1090 java.util.Iterator iter = userColl.iterator();
1091 while (iter.hasNext()) {
1092 contacts.add(iter.next());
1093 }
1094 }
1095 for (int i = 0; i < contacts.size(); i++) {
1096 Card c = (Card) contacts.get(i);
1097
1098 }
1099
1100 } catch (Exception e) {
1101 logger.error("DBServices - getDbUserDesc", e);
1102 }
1103
1104 return contacts;
1105 }
1106
1107 public static Vector getSearchAbsAbs (String paraName1, String param1,
1108 String paraName2, String param2,
1109 String user) {
1110 Vector contacts = new Vector();
1111
1112 try {
1113
1114 Criteria crit1 = new Criteria();
1115 if (param2.equals("")) {
1116
1117 crit1.addEqualTo("absencetype", param1);
1118 crit1.addEqualTo("user", user);
1119
1120 } else {
1121 Criteria crit2 = new Criteria();
1122 crit1.addEqualTo("absencetype", param1);
1123 crit1.addEqualTo("user", user);
1124 crit2.addEqualTo("absencetype", param2);
1125 crit2.addEqualTo("user", user);
1126 crit1.addOrCriteria(crit2);
1127 }
1128
1129 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1130 broker.clearCache();
1131 Collection userColl = broker.getCollectionByQuery(q);
1132 if (!userColl.isEmpty()) {
1133
1134 java.util.Iterator iter = userColl.iterator();
1135 while (iter.hasNext()) {
1136 contacts.add(iter.next());
1137 }
1138 }
1139 for (int i = 0; i < contacts.size(); i++) {
1140 Card c = (Card) contacts.get(i);
1141
1142 }
1143
1144 } catch (Exception e) {
1145 logger.error("DBServices - getDbUserDesc", e);
1146 }
1147
1148 return contacts;
1149 }
1150
1151 public static Vector getSearchFirstFirst (String paraName1, String param1,
1152 String paraName2, String param2,
1153 String user) {
1154 Vector contacts = new Vector();
1155
1156 try {
1157
1158 Criteria crit1 = new Criteria();
1159 if (param2.equals("")) {
1160
1161 crit1.addEqualTo("firstname", param1);
1162 crit1.addEqualTo("user", user);
1163
1164 } else {
1165 Criteria crit2 = new Criteria();
1166 crit1.addEqualTo("firstname", param1);
1167 crit1.addEqualTo("user", user);
1168 crit2.addEqualTo("firstabsenceday", param2);
1169 crit2.addEqualTo("user", user);
1170 crit1.addOrCriteria(crit2);
1171 }
1172
1173 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1174 broker.clearCache();
1175 Collection userColl = broker.getCollectionByQuery(q);
1176 if (!userColl.isEmpty()) {
1177
1178 java.util.Iterator iter = userColl.iterator();
1179 while (iter.hasNext()) {
1180 contacts.add(iter.next());
1181 }
1182 }
1183 for (int i = 0; i < contacts.size(); i++) {
1184 Card c = (Card) contacts.get(i);
1185
1186 }
1187
1188 } catch (Exception e) {
1189 logger.error("DBServices - getDbUserDesc", e);
1190 }
1191
1192 return contacts;
1193 }
1194
1195 public static Vector getSearchFirstFirstName (String paraName1,
1196 String param1,
1197 String paraName2,
1198 String param2,
1199 String user) {
1200 Vector contacts = new Vector();
1201
1202 try {
1203
1204 Criteria crit1 = new Criteria();
1205 if (param2.equals("")) {
1206
1207 crit1.addEqualTo("firstname", param1);
1208 crit1.addEqualTo("user", user);
1209
1210 } else {
1211 Criteria crit2 = new Criteria();
1212 crit1.addEqualTo("firstname", param1);
1213 crit1.addEqualTo("user", user);
1214 crit2.addEqualTo("firstname", param2);
1215 crit2.addEqualTo("user", user);
1216 crit1.addOrCriteria(crit2);
1217 }
1218
1219 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1220 broker.clearCache();
1221 Collection userColl = broker.getCollectionByQuery(q);
1222 if (!userColl.isEmpty()) {
1223
1224 java.util.Iterator iter = userColl.iterator();
1225 while (iter.hasNext()) {
1226 contacts.add(iter.next());
1227 }
1228 }
1229 for (int i = 0; i < contacts.size(); i++) {
1230 Card c = (Card) contacts.get(i);
1231
1232 }
1233
1234 } catch (Exception e) {
1235 logger.error("DBServices - getDbUserDesc", e);
1236 }
1237
1238 return contacts;
1239 }
1240
1241 public static Vector getSearchFirstFirst2 (String paraName1, String param1,
1242 String paraName2, String param2,
1243 String user) {
1244 Vector contacts = new Vector();
1245
1246 try {
1247
1248 Criteria crit1 = new Criteria();
1249 if (param2.equals("")) {
1250
1251 crit1.addEqualTo("firstabsenceday", param1);
1252 crit1.addEqualTo("user", user);
1253
1254 } else {
1255 Criteria crit2 = new Criteria();
1256 crit1.addEqualTo("firstabsenceday", param1);
1257 crit1.addEqualTo("user", user);
1258 crit2.addEqualTo("firstname", param2);
1259 crit2.addEqualTo("user", user);
1260 crit1.addOrCriteria(crit2);
1261 }
1262
1263 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1264 broker.clearCache();
1265 Collection userColl = broker.getCollectionByQuery(q);
1266 if (!userColl.isEmpty()) {
1267
1268 java.util.Iterator iter = userColl.iterator();
1269 while (iter.hasNext()) {
1270 contacts.add(iter.next());
1271 }
1272 }
1273 for (int i = 0; i < contacts.size(); i++) {
1274 Card c = (Card) contacts.get(i);
1275
1276 }
1277
1278 } catch (Exception e) {
1279 logger.error("DBServices - getDbUserDesc", e);
1280 }
1281
1282 return contacts;
1283 }
1284
1285 public static Vector getSearchFirstLast (String paraName1, String param1,
1286 String paraName2, String param2,
1287 String user) {
1288 Vector contacts = new Vector();
1289
1290 try {
1291
1292 Criteria crit1 = new Criteria();
1293 if (param2.equals("")) {
1294
1295 crit1.addEqualTo("firstname", param1);
1296 crit1.addEqualTo("user", user);
1297
1298 } else {
1299 Criteria crit2 = new Criteria();
1300 crit1.addEqualTo("firstname", param1);
1301 crit1.addEqualTo("user", user);
1302 crit2.addEqualTo("lastabsenceday", param2);
1303 crit2.addEqualTo("user", user);
1304 crit1.addOrCriteria(crit2);
1305 }
1306
1307 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1308 broker.clearCache();
1309 Collection userColl = broker.getCollectionByQuery(q);
1310 if (!userColl.isEmpty()) {
1311
1312 java.util.Iterator iter = userColl.iterator();
1313 while (iter.hasNext()) {
1314 contacts.add(iter.next());
1315 }
1316 }
1317 for (int i = 0; i < contacts.size(); i++) {
1318 Card c = (Card) contacts.get(i);
1319
1320 }
1321
1322 } catch (Exception e) {
1323 logger.error("DBServices - getDbUserDesc", e);
1324 }
1325
1326 return contacts;
1327 }
1328
1329 public static Vector getSearchLastFirst (String paraName1, String param1,
1330 String paraName2, String param2,
1331 String user) {
1332 Vector contacts = new Vector();
1333
1334 try {
1335
1336 Criteria crit1 = new Criteria();
1337 if (param2.equals("")) {
1338
1339 crit1.addEqualTo("lastabsenceday", param1);
1340 crit1.addEqualTo("user", user);
1341
1342 } else {
1343 Criteria crit2 = new Criteria();
1344 crit1.addEqualTo("lastabsenceday", param1);
1345 crit1.addEqualTo("user", user);
1346 crit2.addEqualTo("firstname", param2);
1347 crit2.addEqualTo("user", user);
1348 crit1.addOrCriteria(crit2);
1349 }
1350
1351 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1352 broker.clearCache();
1353 Collection userColl = broker.getCollectionByQuery(q);
1354 if (!userColl.isEmpty()) {
1355
1356 java.util.Iterator iter = userColl.iterator();
1357 while (iter.hasNext()) {
1358 contacts.add(iter.next());
1359 }
1360 }
1361 for (int i = 0; i < contacts.size(); i++) {
1362 Card c = (Card) contacts.get(i);
1363
1364 }
1365
1366 } catch (Exception e) {
1367 logger.error("DBServices - getDbUserDesc", e);
1368 }
1369
1370 return contacts;
1371 }
1372
1373 public static Vector getSearchFirstStat (String paraName1, String param1,
1374 String paraName2, String param2,
1375 String user) {
1376 Vector contacts = new Vector();
1377
1378 try {
1379
1380 Criteria crit1 = new Criteria();
1381 if (param2.equals("")) {
1382
1383 crit1.addEqualTo("firstname", param1);
1384 crit1.addEqualTo("user", user);
1385
1386 } else {
1387 Criteria crit2 = new Criteria();
1388 crit1.addEqualTo("firstname", param1);
1389 crit1.addEqualTo("user", user);
1390 crit2.addEqualTo("status", param2);
1391 crit2.addEqualTo("user", user);
1392 crit1.addOrCriteria(crit2);
1393 }
1394
1395 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1396 broker.clearCache();
1397 Collection userColl = broker.getCollectionByQuery(q);
1398 if (!userColl.isEmpty()) {
1399
1400 java.util.Iterator iter = userColl.iterator();
1401 while (iter.hasNext()) {
1402 contacts.add(iter.next());
1403 }
1404 }
1405 for (int i = 0; i < contacts.size(); i++) {
1406 Card c = (Card) contacts.get(i);
1407
1408 }
1409
1410 } catch (Exception e) {
1411 logger.error("DBServices - getDbUserDesc", e);
1412 }
1413
1414 return contacts;
1415 }
1416
1417 public static Vector getSearchStatFirst (String paraName1, String param1,
1418 String paraName2, String param2,
1419 String user) {
1420 Vector contacts = new Vector();
1421
1422 try {
1423
1424 Criteria crit1 = new Criteria();
1425 if (param2.equals("")) {
1426
1427 crit1.addEqualTo("status", param1);
1428 crit1.addEqualTo("user", user);
1429
1430 } else {
1431 Criteria crit2 = new Criteria();
1432 crit1.addEqualTo("status", param1);
1433 crit1.addEqualTo("user", user);
1434 crit2.addEqualTo("firstname", param2);
1435 crit2.addEqualTo("user", user);
1436 crit1.addOrCriteria(crit2);
1437 }
1438
1439 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1440 broker.clearCache();
1441 Collection userColl = broker.getCollectionByQuery(q);
1442 if (!userColl.isEmpty()) {
1443
1444 java.util.Iterator iter = userColl.iterator();
1445 while (iter.hasNext()) {
1446 contacts.add(iter.next());
1447 }
1448 }
1449 for (int i = 0; i < contacts.size(); i++) {
1450 Card c = (Card) contacts.get(i);
1451
1452 }
1453
1454 } catch (Exception e) {
1455 logger.error("DBServices - getDbUserDesc", e);
1456 }
1457
1458 return contacts;
1459 }
1460
1461 public static Vector getSearchAbsFirst (String paraName1, String param1,
1462 String paraName2, String param2,
1463 String user) {
1464 Vector contacts = new Vector();
1465
1466 try {
1467
1468 Criteria crit1 = new Criteria();
1469 if (param2.equals("")) {
1470
1471 crit1.addEqualTo("absencetype", param1);
1472 crit1.addEqualTo("user", user);
1473
1474 } else {
1475 Criteria crit2 = new Criteria();
1476 crit1.addEqualTo("absencetype", param1);
1477 crit1.addEqualTo("user", user);
1478 crit2.addEqualTo("firstabsenceday", param2);
1479 crit2.addEqualTo("user", user);
1480 crit1.addOrCriteria(crit2);
1481 }
1482
1483 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1484 broker.clearCache();
1485 Collection userColl = broker.getCollectionByQuery(q);
1486 if (!userColl.isEmpty()) {
1487
1488 java.util.Iterator iter = userColl.iterator();
1489 while (iter.hasNext()) {
1490 contacts.add(iter.next());
1491 }
1492 }
1493 for (int i = 0; i < contacts.size(); i++) {
1494 Card c = (Card) contacts.get(i);
1495
1496 }
1497
1498 } catch (Exception e) {
1499 logger.error("DBServices - getDbUserDesc", e);
1500 }
1501
1502 return contacts;
1503 }
1504
1505 public static Vector getSearchFirsAbs (String paraName1, String param1,
1506 String paraName2, String param2,
1507 String user) {
1508 Vector contacts = new Vector();
1509
1510 try {
1511
1512 Criteria crit1 = new Criteria();
1513 if (param2.equals("")) {
1514
1515 crit1.addEqualTo("firstabsenceday", param1);
1516 crit1.addEqualTo("user", user);
1517
1518 } else {
1519 Criteria crit2 = new Criteria();
1520 crit1.addEqualTo("firstabsenceday", param1);
1521 crit1.addEqualTo("user", user);
1522 crit2.addEqualTo("absencetype", param2);
1523 crit2.addEqualTo("user", user);
1524 crit1.addOrCriteria(crit2);
1525 }
1526
1527 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1528 broker.clearCache();
1529 Collection userColl = broker.getCollectionByQuery(q);
1530 if (!userColl.isEmpty()) {
1531
1532 java.util.Iterator iter = userColl.iterator();
1533 while (iter.hasNext()) {
1534 contacts.add(iter.next());
1535 }
1536 }
1537 for (int i = 0; i < contacts.size(); i++) {
1538 Card c = (Card) contacts.get(i);
1539
1540 }
1541
1542 } catch (Exception e) {
1543 logger.error("DBServices - getDbUserDesc", e);
1544 }
1545
1546 return contacts;
1547 }
1548
1549 public static Vector getSearchAbsLast (String paraName1, String param1,
1550 String paraName2, String param2,
1551 String user) {
1552 Vector contacts = new Vector();
1553
1554 try {
1555
1556 Criteria crit1 = new Criteria();
1557 if (param2.equals("")) {
1558
1559 crit1.addEqualTo("absencetype", param1);
1560 crit1.addEqualTo("user", user);
1561
1562 } else {
1563 Criteria crit2 = new Criteria();
1564 crit1.addEqualTo("absencetype", param1);
1565 crit1.addEqualTo("user", user);
1566 crit2.addEqualTo("lastabsenceday", param2);
1567 crit2.addEqualTo("user", user);
1568 crit1.addOrCriteria(crit2);
1569 }
1570
1571 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1572 broker.clearCache();
1573 Collection userColl = broker.getCollectionByQuery(q);
1574 if (!userColl.isEmpty()) {
1575
1576 java.util.Iterator iter = userColl.iterator();
1577 while (iter.hasNext()) {
1578 contacts.add(iter.next());
1579 }
1580 }
1581 for (int i = 0; i < contacts.size(); i++) {
1582 Card c = (Card) contacts.get(i);
1583
1584 }
1585
1586 } catch (Exception e) {
1587 logger.error("DBServices - getDbUserDesc", e);
1588 }
1589
1590 return contacts;
1591 }
1592
1593 public static Vector getSearchLastAbs (String paraName1, String param1,
1594 String paraName2, String param2,
1595 String user) {
1596 Vector contacts = new Vector();
1597
1598 try {
1599
1600 Criteria crit1 = new Criteria();
1601 if (param2.equals("")) {
1602
1603 crit1.addEqualTo("lastabsenceday", param1);
1604 crit1.addEqualTo("user", user);
1605
1606 } else {
1607 Criteria crit2 = new Criteria();
1608 crit1.addEqualTo("lastabsenceday", param1);
1609 crit1.addEqualTo("user", user);
1610 crit2.addEqualTo("absencetype", param2);
1611 crit2.addEqualTo("user", user);
1612 crit1.addOrCriteria(crit2);
1613 }
1614
1615 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1616 broker.clearCache();
1617 Collection userColl = broker.getCollectionByQuery(q);
1618 if (!userColl.isEmpty()) {
1619
1620 java.util.Iterator iter = userColl.iterator();
1621 while (iter.hasNext()) {
1622 contacts.add(iter.next());
1623 }
1624 }
1625 for (int i = 0; i < contacts.size(); i++) {
1626 Card c = (Card) contacts.get(i);
1627
1628 }
1629
1630 } catch (Exception e) {
1631 logger.error("DBServices - getDbUserDesc", e);
1632 }
1633
1634 return contacts;
1635 }
1636
1637 public static Vector getSearchAbsStat (String paraName1, String param1,
1638 String paraName2, String param2,
1639 String user) {
1640 Vector contacts = new Vector();
1641
1642 try {
1643
1644 Criteria crit1 = new Criteria();
1645 if (param2.equals("")) {
1646
1647 crit1.addEqualTo("absencetype", param1);
1648 crit1.addEqualTo("user", user);
1649
1650 } else {
1651 Criteria crit2 = new Criteria();
1652 crit1.addEqualTo("absencetype", param1);
1653 crit1.addEqualTo("user", user);
1654 crit2.addEqualTo("status", param2);
1655 crit2.addEqualTo("user", user);
1656 crit1.addOrCriteria(crit2);
1657 }
1658
1659 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1660 broker.clearCache();
1661 Collection userColl = broker.getCollectionByQuery(q);
1662 if (!userColl.isEmpty()) {
1663
1664 java.util.Iterator iter = userColl.iterator();
1665 while (iter.hasNext()) {
1666 contacts.add(iter.next());
1667 }
1668 }
1669 for (int i = 0; i < contacts.size(); i++) {
1670 Card c = (Card) contacts.get(i);
1671
1672 }
1673
1674 } catch (Exception e) {
1675 logger.error("DBServices - getDbUserDesc", e);
1676 }
1677
1678 return contacts;
1679 }
1680
1681 public static Vector getSearchStatAbs (String paraName1, String param1,
1682 String paraName2, String param2,
1683 String user) {
1684 Vector contacts = new Vector();
1685
1686 try {
1687
1688 Criteria crit1 = new Criteria();
1689 if (param2.equals("")) {
1690
1691 crit1.addEqualTo("status", param1);
1692 crit1.addEqualTo("user", user);
1693
1694 } else {
1695 Criteria crit2 = new Criteria();
1696 crit1.addEqualTo("status", param1);
1697 crit1.addEqualTo("user", user);
1698 crit2.addEqualTo("absencetype", param2);
1699 crit2.addEqualTo("user", user);
1700 crit1.addOrCriteria(crit2);
1701 }
1702
1703 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1704 broker.clearCache();
1705 Collection userColl = broker.getCollectionByQuery(q);
1706 if (!userColl.isEmpty()) {
1707
1708 java.util.Iterator iter = userColl.iterator();
1709 while (iter.hasNext()) {
1710 contacts.add(iter.next());
1711 }
1712 }
1713 for (int i = 0; i < contacts.size(); i++) {
1714 Card c = (Card) contacts.get(i);
1715
1716 }
1717
1718 } catch (Exception e) {
1719 logger.error("DBServices - getDbUserDesc", e);
1720 }
1721
1722 return contacts;
1723 }
1724
1725 public static Vector getSearchFirstLastAbs (String paraName1, String param1,
1726 String paraName2, String param2,
1727 String user) {
1728 Vector contacts = new Vector();
1729
1730 try {
1731
1732 Criteria crit1 = new Criteria();
1733 if (param2.equals("")) {
1734
1735 crit1.addEqualTo("firstabsenceday", param1);
1736 crit1.addEqualTo("user", user);
1737
1738 } else {
1739 Criteria crit2 = new Criteria();
1740 crit1.addEqualTo("firstabsenceday", param1);
1741 crit1.addEqualTo("user", user);
1742 crit2.addEqualTo("lastabsenceday", param2);
1743 crit2.addEqualTo("user", user);
1744 crit1.addOrCriteria(crit2);
1745 }
1746
1747 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1748 broker.clearCache();
1749 Collection userColl = broker.getCollectionByQuery(q);
1750 if (!userColl.isEmpty()) {
1751
1752 java.util.Iterator iter = userColl.iterator();
1753 while (iter.hasNext()) {
1754 contacts.add(iter.next());
1755 }
1756 }
1757 for (int i = 0; i < contacts.size(); i++) {
1758 Card c = (Card) contacts.get(i);
1759
1760 }
1761
1762 } catch (Exception e) {
1763 logger.error("DBServices - getDbUserDesc", e);
1764 }
1765
1766 return contacts;
1767 }
1768
1769 public static Vector getSearchFirstFirstAbs (String paraName1,
1770 String param1,
1771 String paraName2,
1772 String param2,
1773 String user) {
1774 Vector contacts = new Vector();
1775
1776 try {
1777
1778 Criteria crit1 = new Criteria();
1779 if (param2.equals("")) {
1780
1781 crit1.addEqualTo("firstabsenceday", param1);
1782 crit1.addEqualTo("user", user);
1783
1784 } else {
1785 Criteria crit2 = new Criteria();
1786 crit1.addEqualTo("firstabsenceday", param1);
1787 crit1.addEqualTo("user", user);
1788 crit2.addEqualTo("firstabsenceday", param2);
1789 crit2.addEqualTo("user", user);
1790 crit1.addOrCriteria(crit2);
1791 }
1792
1793 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1794 broker.clearCache();
1795 Collection userColl = broker.getCollectionByQuery(q);
1796 if (!userColl.isEmpty()) {
1797
1798 java.util.Iterator iter = userColl.iterator();
1799 while (iter.hasNext()) {
1800 contacts.add(iter.next());
1801 }
1802 }
1803 for (int i = 0; i < contacts.size(); i++) {
1804 Card c = (Card) contacts.get(i);
1805 }
1806
1807 } catch (Exception e) {
1808 logger.error("DBServices - getDbUserDesc", e);
1809 }
1810
1811 return contacts;
1812 }
1813
1814 public static Vector getSearchLastAbsFirst (String paraName1, String param1,
1815 String paraName2, String param2,
1816 String user) {
1817 Vector contacts = new Vector();
1818
1819 try {
1820
1821 Criteria crit1 = new Criteria();
1822 if (param2.equals("")) {
1823
1824 crit1.addEqualTo("lastabsenceday", param1);
1825 crit1.addEqualTo("user", user);
1826
1827 } else {
1828 Criteria crit2 = new Criteria();
1829 crit1.addEqualTo("lastabsenceday", param1);
1830 crit1.addEqualTo("user", user);
1831 crit2.addEqualTo("firstabsenceday", param2);
1832 crit2.addEqualTo("user", user);
1833 crit1.addOrCriteria(crit2);
1834 }
1835
1836 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1837 broker.clearCache();
1838 Collection userColl = broker.getCollectionByQuery(q);
1839 if (!userColl.isEmpty()) {
1840
1841 java.util.Iterator iter = userColl.iterator();
1842 while (iter.hasNext()) {
1843 contacts.add(iter.next());
1844 }
1845 }
1846 for (int i = 0; i < contacts.size(); i++) {
1847 Card c = (Card) contacts.get(i);
1848
1849 }
1850
1851 } catch (Exception e) {
1852 logger.error("DBServices - getDbUserDesc", e);
1853 }
1854
1855 return contacts;
1856 }
1857
1858 public static Vector getSearchFirstAbsStat (String paraName1, String param1,
1859 String paraName2, String param2,
1860 String user) {
1861 Vector contacts = new Vector();
1862
1863 try {
1864
1865 Criteria crit1 = new Criteria();
1866 if (param2.equals("")) {
1867
1868 crit1.addEqualTo("firstabsenceday", param1);
1869 crit1.addEqualTo("user", user);
1870
1871 } else {
1872 Criteria crit2 = new Criteria();
1873 crit1.addEqualTo("firstabsenceday", param1);
1874 crit1.addEqualTo("user", user);
1875 crit2.addEqualTo("status", param2);
1876 crit2.addEqualTo("user", user);
1877 crit1.addOrCriteria(crit2);
1878 }
1879
1880 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1881 broker.clearCache();
1882 Collection userColl = broker.getCollectionByQuery(q);
1883 if (!userColl.isEmpty()) {
1884
1885 java.util.Iterator iter = userColl.iterator();
1886 while (iter.hasNext()) {
1887 contacts.add(iter.next());
1888 }
1889 }
1890 for (int i = 0; i < contacts.size(); i++) {
1891 Card c = (Card) contacts.get(i);
1892
1893 }
1894
1895 } catch (Exception e) {
1896 logger.error("DBServices - getDbUserDesc", e);
1897 }
1898
1899 return contacts;
1900 }
1901
1902 public static Vector getSearchStatFirstAbs (String paraName1, String param1,
1903 String paraName2, String param2,
1904 String user) {
1905 Vector contacts = new Vector();
1906
1907 try {
1908
1909 Criteria crit1 = new Criteria();
1910 if (param2.equals("")) {
1911
1912 crit1.addEqualTo("status", param1);
1913 crit1.addEqualTo("user", user);
1914
1915 } else {
1916 Criteria crit2 = new Criteria();
1917 crit1.addEqualTo("status", param1);
1918 crit1.addEqualTo("user", user);
1919 crit2.addEqualTo("firstabsenceday", param2);
1920 crit2.addEqualTo("user", user);
1921 crit1.addOrCriteria(crit2);
1922 }
1923
1924 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1925 broker.clearCache();
1926 Collection userColl = broker.getCollectionByQuery(q);
1927 if (!userColl.isEmpty()) {
1928
1929 java.util.Iterator iter = userColl.iterator();
1930 while (iter.hasNext()) {
1931 contacts.add(iter.next());
1932 }
1933 }
1934 for (int i = 0; i < contacts.size(); i++) {
1935 Card c = (Card) contacts.get(i);
1936
1937 }
1938
1939 } catch (Exception e) {
1940 logger.error("DBServices - getDbUserDesc", e);
1941 }
1942
1943 return contacts;
1944 }
1945
1946 public static Vector getSearchLastAbsStat (String paraName1, String param1,
1947 String paraName2, String param2,
1948 String user) {
1949 Vector contacts = new Vector();
1950
1951 try {
1952
1953 Criteria crit1 = new Criteria();
1954 if (param2.equals("")) {
1955
1956 crit1.addEqualTo("lastabsenceday", param1);
1957 crit1.addEqualTo("user", user);
1958
1959 } else {
1960 Criteria crit2 = new Criteria();
1961 crit1.addEqualTo("lastabsenceday", param1);
1962 crit1.addEqualTo("user", user);
1963 crit2.addEqualTo("status", param2);
1964 crit2.addEqualTo("user", user);
1965 crit1.addOrCriteria(crit2);
1966 }
1967
1968 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
1969 broker.clearCache();
1970 Collection userColl = broker.getCollectionByQuery(q);
1971 if (!userColl.isEmpty()) {
1972
1973 java.util.Iterator iter = userColl.iterator();
1974 while (iter.hasNext()) {
1975 contacts.add(iter.next());
1976 }
1977 }
1978 for (int i = 0; i < contacts.size(); i++) {
1979 Card c = (Card) contacts.get(i);
1980
1981 }
1982
1983 } catch (Exception e) {
1984 logger.error("DBServices - getDbUserDesc", e);
1985 }
1986
1987 return contacts;
1988 }
1989
1990 public static Vector getSearchLastLastAbs (String paraName1, String param1,
1991 String paraName2, String param2,
1992 String user) {
1993 Vector contacts = new Vector();
1994
1995 try {
1996
1997 Criteria crit1 = new Criteria();
1998 if (param2.equals("")) {
1999
2000 crit1.addEqualTo("lastabsenceday", param1);
2001 crit1.addEqualTo("user", user);
2002
2003 } else {
2004 Criteria crit2 = new Criteria();
2005 crit1.addEqualTo("lastabsenceday", param1);
2006 crit1.addEqualTo("user", user);
2007 crit2.addEqualTo("lastabsenceday", param2);
2008 crit2.addEqualTo("user", user);
2009 crit1.addOrCriteria(crit2);
2010 }
2011
2012 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
2013 broker.clearCache();
2014 Collection userColl = broker.getCollectionByQuery(q);
2015 if (!userColl.isEmpty()) {
2016
2017 java.util.Iterator iter = userColl.iterator();
2018 while (iter.hasNext()) {
2019 contacts.add(iter.next());
2020 }
2021 }
2022 for (int i = 0; i < contacts.size(); i++) {
2023 Card c = (Card) contacts.get(i);
2024
2025 }
2026
2027 } catch (Exception e) {
2028 logger.error("DBServices - getDbUserDesc", e);
2029 }
2030
2031 return contacts;
2032 }
2033
2034 public static Vector getSearchStatLastAbs (String paraName1, String param1,
2035 String paraName2, String param2,
2036 String user) {
2037 Vector contacts = new Vector();
2038
2039 try {
2040
2041 Criteria crit1 = new Criteria();
2042 if (param2.equals("")) {
2043
2044 crit1.addEqualTo("status", param1);
2045 crit1.addEqualTo("user", user);
2046
2047 } else {
2048 Criteria crit2 = new Criteria();
2049 crit1.addEqualTo("status", param1);
2050 crit1.addEqualTo("user", user);
2051 crit2.addEqualTo("lastabsenceday", param2);
2052 crit2.addEqualTo("user", user);
2053 crit1.addOrCriteria(crit2);
2054 }
2055
2056 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
2057 broker.clearCache();
2058 Collection userColl = broker.getCollectionByQuery(q);
2059 if (!userColl.isEmpty()) {
2060
2061 java.util.Iterator iter = userColl.iterator();
2062 while (iter.hasNext()) {
2063 contacts.add(iter.next());
2064 }
2065 }
2066 for (int i = 0; i < contacts.size(); i++) {
2067 Card c = (Card) contacts.get(i);
2068
2069 }
2070
2071 } catch (Exception e) {
2072 logger.error("DBServices - getDbUserDesc", e);
2073 }
2074
2075 return contacts;
2076 }
2077
2078 public static Vector getSearchStatStat (String paraName1, String param1,
2079 String paraName2, String param2,
2080 String user) {
2081 Vector contacts = new Vector();
2082
2083 try {
2084
2085 Criteria crit1 = new Criteria();
2086 if (param2.equals("")) {
2087
2088 crit1.addEqualTo("status", param1);
2089 crit1.addEqualTo("user", user);
2090
2091 } else {
2092 Criteria crit2 = new Criteria();
2093 crit1.addEqualTo("status", param1);
2094 crit1.addEqualTo("user", user);
2095 crit2.addEqualTo("status", param2);
2096 crit2.addEqualTo("user", user);
2097 crit1.addOrCriteria(crit2);
2098 }
2099
2100 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
2101 broker.clearCache();
2102 Collection userColl = broker.getCollectionByQuery(q);
2103 if (!userColl.isEmpty()) {
2104
2105 java.util.Iterator iter = userColl.iterator();
2106 while (iter.hasNext()) {
2107 contacts.add(iter.next());
2108 }
2109 }
2110 for (int i = 0; i < contacts.size(); i++) {
2111 Card c = (Card) contacts.get(i);
2112
2113 }
2114
2115 } catch (Exception e) {
2116 logger.error("DBServices - getDbUserDesc", e);
2117 }
2118
2119 return contacts;
2120 }
2121
2122
2127 public static Vector loadList (String user, String status, String sortFlag,
2128 String sortedBy) {
2129 Vector cards = new Vector();
2130
2131 try {
2132
2133 Criteria crit1 = new Criteria();
2134 crit1.addEqualTo("user", user);
2135 crit1.addEqualTo("status", status);
2136 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
2137 broker.clearCache();
2138 Collection userColl = broker.getCollectionByQuery(q);
2139 if (!userColl.isEmpty()) {
2140 java.util.Iterator iter = userColl.iterator();
2141 while (iter.hasNext()) {
2142 cards.add(iter.next());
2143 }
2144 }
2145 for (int i = 0; i < cards.size(); i++) {
2146 Card c = (Card) cards.get(i);
2147
2148 }
2149 } catch (PersistenceBrokerException e) {
2150 logger.error("DBServices - findBook", e);
2151 broker.abortTransaction();
2152
2153 }
2154
2155 return cards;
2156 }
2157
2158
2163 public static Vector loadListSinUser (String status, String sortFlag,
2164 String sortedBy) {
2165 Vector cards = new Vector();
2166
2167 try {
2168 logger.debug("load status " + status);
2169 Criteria crit1 = new Criteria();
2170 crit1.addEqualTo("status", status);
2171 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
2172 broker.clearCache();
2173 Collection userColl = broker.getCollectionByQuery(q);
2174 if (!userColl.isEmpty()) {
2175 java.util.Iterator iter = userColl.iterator();
2176 while (iter.hasNext()) {
2177 cards.add(iter.next());
2178 }
2179 for (int i = 0; i < cards.size(); i++) {
2180 Card c = (Card) cards.get(i);
2181 }
2182 }
2183 } catch (PersistenceBrokerException e) {
2184 logger.error("DBServices - findBook", e);
2185 broker.abortTransaction();
2186
2187 }
2188
2189 return cards;
2190 }
2191
2192
2197 public static Vector loadListCard (String user, String sortFlag,
2198 String sortedBy) {
2199 Vector cards = new Vector();
2200
2201 try {
2202
2203 Criteria crit1 = new Criteria();
2204 crit1.addEqualTo("user", user);
2205 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
2206 if (sortFlag.equals("DES")) {
2207 q.addOrderByDescending(sortedBy.toLowerCase());
2208 } else {
2209 q.addOrderByAscending(sortedBy.toLowerCase());
2210 }
2211 broker.clearCache();
2212 Collection userColl = broker.getCollectionByQuery(q);
2213 if (!userColl.isEmpty()) {
2214 java.util.Iterator iter = userColl.iterator();
2215 while (iter.hasNext()) {
2216 cards.add(iter.next());
2217 }
2218 for (int i = 0; i < cards.size(); i++) {
2219 Card c = (Card) cards.get(i);
2220
2221 }
2222 }
2223 } catch (PersistenceBrokerException e) {
2224 logger.error("DBServices - findBook", e);
2225 broker.abortTransaction();
2226
2227 }
2228
2229 return cards;
2230 }
2231
2232
2237 public static Vector loadListCardSinUser (String sortFlag, String sortedBy) {
2238 Vector cards = new Vector();
2239
2240 try {
2241
2242 Criteria crit1 = new Criteria();
2243 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
2244 broker.clearCache();
2245 Collection userColl = broker.getCollectionByQuery(q);
2246 if (!userColl.isEmpty()) {
2247 java.util.Iterator iter = userColl.iterator();
2248 while (iter.hasNext()) {
2249 cards.add(iter.next());
2250 }
2251 for (int i = 0; i < cards.size(); i++) {
2252 Card c = (Card) cards.get(i);
2253 }
2254 }
2255 } catch (PersistenceBrokerException e) {
2256 logger.error("DBServices - findBook", e);
2257 broker.abortTransaction();
2258
2259 }
2260
2261 return cards;
2262 }
2263
2264
2269 public static Vector loadList (String user, String contextId, String status,
2270 String sortFlag, String sortedBy) {
2271 Vector cards = new Vector();
2272
2273 try {
2274
2275 Criteria crit1 = new Criteria();
2276 crit1.addEqualTo("user", user);
2277 crit1.addEqualTo("status", status);
2278 crit1.addEqualTo("contextid", contextId);
2279 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
2280 broker.clearCache();
2281 Collection userColl = broker.getCollectionByQuery(q);
2282 if (!userColl.isEmpty()) {
2283 java.util.Iterator iter = userColl.iterator();
2284 while (iter.hasNext()) {
2285 cards.add(iter.next());
2286 }
2287 for (int i = 0; i < cards.size(); i++) {
2288 Card c = (Card) cards.get(i);
2289 }
2290 }
2291 } catch (PersistenceBrokerException e) {
2292 logger.error("DBServices - findBook", e);
2293 broker.abortTransaction();
2294
2295 }
2296
2297 return cards;
2298 }
2299
2300
2305 public static Vector loadListSinUser (String contextId, String status,
2306 String sortFlag, String sortedBy) {
2307 Vector cards = new Vector();
2308
2309 try {
2310
2311 Criteria crit1 = new Criteria();
2312 crit1.addEqualTo("status", status);
2313 crit1.addEqualTo("contextid", contextId);
2314 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
2315 broker.clearCache();
2316 Collection userColl = broker.getCollectionByQuery(q);
2317 if (!userColl.isEmpty()) {
2318 java.util.Iterator iter = userColl.iterator();
2319 while (iter.hasNext()) {
2320 cards.add(iter.next());
2321 }
2322 for (int i = 0; i < cards.size(); i++) {
2323 Card c = (Card) cards.get(i);
2324 }
2325 }
2326 } catch (PersistenceBrokerException e) {
2327 logger.error("DBServices - findBook", e);
2328 broker.abortTransaction();
2329
2330 }
2331
2332 return cards;
2333 }
2334
2335
2340 public static Vector loadListCard (String user, String contextId,
2341 String sortFlag, String sortedBy) {
2342 Vector cards = new Vector();
2343
2344 try {
2345
2346 Criteria crit1 = new Criteria();
2347 crit1.addEqualTo("user", user);
2348 crit1.addEqualTo("contextid", contextId);
2349 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
2350 if (sortFlag.equals("ASC")) {
2351 q.addOrderByAscending(sortedBy);
2352 } else {
2353 q.addOrderByDescending(sortedBy);
2354 }
2355 broker.clearCache();
2356 Collection userColl = broker.getCollectionByQuery(q);
2357 if (!userColl.isEmpty()) {
2358 java.util.Iterator iter = userColl.iterator();
2359 while (iter.hasNext()) {
2360 cards.add(iter.next());
2361 }
2362 for (int i = 0; i < cards.size(); i++) {
2363 Card c = (Card) cards.get(i);
2364
2365 }
2366 }
2367 } catch (PersistenceBrokerException e) {
2368 logger.error("DBServices - findBook", e);
2369 broker.abortTransaction();
2370
2371 }
2372
2373 return cards;
2374 }
2375
2376
2381 public static Vector loadListCardSinUser (String contextId, String sortFlag,
2382 String sortedBy) {
2383 Vector cards = new Vector();
2384
2385 try {
2386
2387 Criteria crit1 = new Criteria();
2388 crit1.addEqualTo("contextid", contextId);
2389 QueryByCriteria q = new QueryByCriteria(Card.class, crit1);
2390 broker.clearCache();
2391 Collection userColl = broker.getCollectionByQuery(q);
2392 if (!userColl.isEmpty()) {
2393 java.util.Iterator iter = userColl.iterator();
2394 while (iter.hasNext()) {
2395 cards.add(iter.next());
2396 }
2397 for (int i = 0; i < cards.size(); i++) {
2398 Card c = (Card) cards.get(i);
2399 }
2400 }
2401 } catch (PersistenceBrokerException e) {
2402 logger.error("DBServices - findBook", e);
2403 broker.abortTransaction();
2404
2405 }
2406
2407 return cards;
2408 }
2409
2410
2415
2416 public static Card findCard (int id) {
2417
2418 Card card = null;
2420
2421 try {
2422 Criteria crit = new Criteria();
2423 crit.addEqualTo("card_id", new Integer (id));
2424 QueryByCriteria q = QueryFactory.newQuery(Card.class, crit);
2425
2426 broker.clearCache();
2428 Collection allPeriods = broker.getCollectionByQuery(q);
2429 if (!allPeriods.isEmpty()) {
2430 Iterator iter = allPeriods.iterator();
2432 card = (Card) iter.next();
2433 } else {
2434 card = null;
2437 }
2438 } catch (PersistenceBrokerException e) {
2439 logger.error("DBServices - findCard", e);
2440 }
2441
2442 return card;
2443 }
2444
2445 public static Vector findNextCards (int id) {
2446
2447 Vector cards = new Vector();
2449 Card card = null;
2450
2451 try {
2452 Criteria crit = new Criteria();
2453 crit.addGreaterThan("card_id", new Integer (id));
2454 QueryByCriteria q = QueryFactory.newQuery(Card.class, crit);
2455 q.addOrderByAscending("card_id");
2456 broker.clearCache();
2458 Collection allPeriods = broker.getCollectionByQuery(q);
2459 if (!allPeriods.isEmpty()) {
2460 Iterator iter = allPeriods.iterator();
2462 card = (Card) iter.next();
2463 cards.add(card);
2464 } else {
2465
2468 }
2469
2470 } catch (PersistenceBrokerException e) {
2471 logger.error("DBServices - findCard", e);
2472 }
2473
2474 return cards;
2475 }
2476
2477
2482
2483 public static User findUser (String login, String passwd) {
2484
2485 User user = null;
2487
2488 try {
2489 Criteria crit = new Criteria();
2490 crit.addEqualTo("user_login", login);
2491 crit.addEqualTo("user_passwd", passwd);
2492 QueryByCriteria q = QueryFactory.newQuery(User.class, crit);
2493
2494 broker.clearCache();
2496 Collection allUsers = broker.getCollectionByQuery(q);
2497 if (!allUsers.isEmpty()) {
2498 Iterator iter = allUsers.iterator();
2500 user = (User) iter.next();
2501 } else {
2502 user = null;
2505 }
2506
2507 } catch (PersistenceBrokerException e) {
2508 logger.error("DBServices - findCard", e);
2509 }
2510
2511 return user;
2512 }
2513
2514 public static AccessRight checkRight (User user, String cardLib) {
2515
2516 AccessRight right = null; ;
2518
2519 try {
2520 Criteria crit = new Criteria();
2521 crit.addEqualTo("user_id", new Integer (user.getUserId()));
2522 crit.addEqualTo("cardlibraryname", cardLib);
2523 QueryByCriteria q = QueryFactory.newQuery(AccessRight.class, crit);
2524
2525 broker.clearCache();
2527 Collection allRights = broker.getCollectionByQuery(q);
2528 if (!allRights.isEmpty()) {
2529 Iterator iter = allRights.iterator();
2531 right = (AccessRight) iter.next();
2532 } else {
2533 right = null;
2536 }
2537
2538 } catch (PersistenceBrokerException e) {
2539 logger.error("DBServices - findCard", e);
2540 }
2541
2542 return right;
2543 }
2544
2545
2551 public static int insertDB (String sql)
2552 throws SQLException {
2553 Connection dbConn = null;
2554
2555 int id = 0;
2556
2557 try {
2559 dbConn = m_DBServices.getInstance().getConnection();
2560 Statement stmt = dbConn.createStatement();
2561 int count = stmt.executeUpdate(sql);
2562
2563 if (count != 1) {
2564 throw new SQLException("Couldn't insert: " + sql);
2565 }
2566 Statement idStmt = dbConn.createStatement();
2567
2568 ResultSet rs = idStmt.executeQuery("Call IDENTITY()");
2570
2571 if (rs.next()) {
2572 id = rs.getInt(1);
2573 logger.debug("insertDB" + Integer.toString(id));
2574 } else {
2576 throw new SQLException("Couldn't get IDENTITY: " + sql);
2577 }
2578 return id;
2579 } finally {
2580 if (dbConn != null) {
2581 logger.debug("AccessDB: execSql: freeConnection executed.");
2583 }
2584 }
2585 }
2586
2587
2592 public static void closeAllConnection(){
2593 m_DBServices.closeAllConnection();
2594 }
2595
2596}
2597 |
Popular Tags |
Java API By Example, From Geeks To Geeks.