001 /*
002 *
003 * $Revision: 15202 $ $Date: 2009-05-15 17:00:44 +0200 (Fri, 15 May 2009) $
004 *
005 * This file is part of *** M y C o R e ***
006 * See http://www.mycore.de/ for details.
007 *
008 * This program is free software; you can use it, redistribute it
009 * and / or modify it under the terms of the GNU General Public License
010 * (GPL) as published by the Free Software Foundation; either version 2
011 * of the License or (at your option) any later version.
012 *
013 * This program is distributed in the hope that it will be useful, but
014 * WITHOUT ANY WARRANTY; without even the implied warranty of
015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
016 * GNU General Public License for more details.
017 *
018 * You should have received a copy of the GNU General Public License
019 * along with this program, in a file called gpl.txt or license.txt.
020 * If not, write to the Free Software Foundation Inc.,
021 * 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA
022 */
023
024 package org.mycore.common.events;
025
026 import org.apache.log4j.Logger;
027 import org.mycore.datamodel.classifications2.MCRCategory;
028 import org.mycore.datamodel.ifs.MCRFile;
029 import org.mycore.datamodel.metadata.MCRDerivate;
030 import org.mycore.datamodel.metadata.MCRObject;
031
032 /**
033 * Abstract helper class that can be subclassed to implement event handlers more
034 * easily.
035 *
036 * @author Frank Luetzenkirchen
037 * @author Jens Kupferschmidt
038 */
039 public abstract class MCREventHandlerBase implements MCREventHandler {
040 private static Logger logger = Logger.getLogger(MCREventHandlerBase.class);
041
042 /**
043 * This method handle all calls for EventHandler for the event types
044 * MCRObject, MCRDerivate and MCRFile.
045 *
046 * @param evt
047 * The MCREvent object
048 */
049 public void doHandleEvent(MCREvent evt) {
050
051 if (evt.getObjectType().equals(MCREvent.OBJECT_TYPE)) {
052 MCRObject obj = (MCRObject) (evt.get("object"));
053 if (obj != null) {
054 logger.debug(getClass().getName() + " handling " + obj.getId().getId() + " " + evt.getEventType());
055 if (evt.getEventType().equals(MCREvent.CREATE_EVENT)) {
056 handleObjectCreated(evt, obj);
057 } else if (evt.getEventType().equals(MCREvent.UPDATE_EVENT)) {
058 handleObjectUpdated(evt, obj);
059 } else if (evt.getEventType().equals(MCREvent.DELETE_EVENT)) {
060 handleObjectDeleted(evt, obj);
061 } else if (evt.getEventType().equals(MCREvent.REPAIR_EVENT)) {
062 handleObjectRepaired(evt, obj);
063 } else {
064 logger.warn("Can't find method for an object data handler for event type " + evt.getEventType());
065 }
066 return;
067 }
068 logger.warn("Can't find method for " + MCREvent.OBJECT_TYPE + " for event type " + evt.getEventType());
069 return;
070 }
071
072 if (evt.getObjectType().equals(MCREvent.DERIVATE_TYPE)) {
073 MCRDerivate der = (MCRDerivate) (evt.get("derivate"));
074 if (der != null) {
075 logger.debug(getClass().getName() + " handling " + der.getId().getId() + " " + evt.getEventType());
076 if (evt.getEventType().equals(MCREvent.CREATE_EVENT)) {
077 handleDerivateCreated(evt, der);
078 } else if (evt.getEventType().equals(MCREvent.UPDATE_EVENT)) {
079 handleDerivateUpdated(evt, der);
080 } else if (evt.getEventType().equals(MCREvent.DELETE_EVENT)) {
081 handleDerivateDeleted(evt, der);
082 } else if (evt.getEventType().equals(MCREvent.REPAIR_EVENT)) {
083 handleDerivateRepaired(evt, der);
084 } else {
085 logger.warn("Can't find method for a derivate data handler for event type " + evt.getEventType());
086 }
087 return;
088 }
089 logger.warn("Can't find method for " + MCREvent.DERIVATE_TYPE + " for event type " + evt.getEventType());
090 return;
091 }
092
093 if (evt.getObjectType().equals(MCREvent.FILE_TYPE)) {
094 MCRFile file = (MCRFile) (evt.get("file"));
095 if (file != null) {
096 logger.debug(getClass().getName() + " handling " + file.getOwnerID() + "/" + file.getAbsolutePath() + " " + evt.getEventType());
097 if (evt.getEventType().equals(MCREvent.CREATE_EVENT)) {
098 handleFileCreated(evt, file);
099 } else if (evt.getEventType().equals(MCREvent.UPDATE_EVENT)) {
100 handleFileUpdated(evt, file);
101 } else if (evt.getEventType().equals(MCREvent.DELETE_EVENT)) {
102 handleFileDeleted(evt, file);
103 } else if (evt.getEventType().equals(MCREvent.REPAIR_EVENT)) {
104 handleFileRepaired(evt, file);
105 } else {
106 logger.warn("Can't find method for file data handler for event type " + evt.getEventType());
107 }
108 return;
109 }
110 logger.warn("Can't find method for " + MCREvent.OBJECT_TYPE + " for event type " + evt.getEventType());
111 return;
112 }
113
114 if (evt.getObjectType().equals(MCREvent.CLASS_TYPE)) {
115 MCRCategory cl = (MCRCategory) (evt.get("class"));
116 if (cl != null) {
117 logger.debug(getClass().getName() + " handling " + cl.getId() + " " + evt.getEventType());
118 if (evt.getEventType().equals(MCREvent.CREATE_EVENT)) {
119 handleClassificationCreated(evt, cl);
120 } else if (evt.getEventType().equals(MCREvent.UPDATE_EVENT)) {
121 handleClassificationUpdated(evt, cl);
122 } else if (evt.getEventType().equals(MCREvent.DELETE_EVENT)) {
123 handleClassificationDeleted(evt, cl);
124 } else if (evt.getEventType().equals(MCREvent.REPAIR_EVENT)) {
125 handleClassificationRepaired(evt, cl);
126 } else {
127 logger.warn("Can't find method for a classification data handler for event type " + evt.getEventType());
128 }
129 return;
130 }
131 logger.warn("Can't find method for " + MCREvent.CLASS_TYPE + " for event type " + evt.getEventType());
132 return;
133 }
134
135 }
136
137 /**
138 * This method roll back all calls for EventHandler for the event types
139 * MCRObject, MCRDerivate and MCRFile.
140 *
141 * @param evt
142 * The MCREvent object
143 */
144 public void undoHandleEvent(MCREvent evt) {
145
146 if (evt.getObjectType().equals(MCREvent.OBJECT_TYPE)) {
147 MCRObject obj = (MCRObject) (evt.get("object"));
148 if (obj != null) {
149 logger.debug(getClass().getName() + " handling " + obj.getId().getId() + " " + evt.getEventType());
150 if (evt.getEventType().equals(MCREvent.CREATE_EVENT)) {
151 undoObjectCreated(evt, obj);
152 } else if (evt.getEventType().equals(MCREvent.UPDATE_EVENT)) {
153 undoObjectUpdated(evt, obj);
154 } else if (evt.getEventType().equals(MCREvent.DELETE_EVENT)) {
155 undoObjectDeleted(evt, obj);
156 } else if (evt.getEventType().equals(MCREvent.REPAIR_EVENT)) {
157 undoObjectRepaired(evt, obj);
158 } else {
159 logger.warn("Can't find method for an object data handler for event type " + evt.getEventType());
160 }
161 return;
162 }
163 logger.warn("Can't find method for " + MCREvent.OBJECT_TYPE + " for event type " + evt.getEventType());
164 return;
165 }
166
167 if (evt.getObjectType().equals(MCREvent.DERIVATE_TYPE)) {
168 MCRDerivate der = (MCRDerivate) (evt.get("derivate"));
169 if (der != null) {
170 logger.debug(getClass().getName() + " handling " + der.getId().getId() + evt.getEventType());
171 if (evt.getEventType().equals(MCREvent.CREATE_EVENT)) {
172 undoDerivateCreated(evt, der);
173 } else if (evt.getEventType().equals(MCREvent.UPDATE_EVENT)) {
174 undoDerivateUpdated(evt, der);
175 } else if (evt.getEventType().equals(MCREvent.DELETE_EVENT)) {
176 undoDerivateDeleted(evt, der);
177 } else if (evt.getEventType().equals(MCREvent.REPAIR_EVENT)) {
178 undoDerivateRepaired(evt, der);
179 } else {
180 logger.warn("Can't find method for a derivate data handler for event type " + evt.getEventType());
181 }
182 return;
183 }
184 logger.warn("Can't find method for " + MCREvent.DERIVATE_TYPE + " for event type " + evt.getEventType());
185 return;
186 }
187
188 if (evt.getObjectType().equals(MCREvent.FILE_TYPE)) {
189 MCRFile file = (MCRFile) (evt.get("file"));
190 if (file != null) {
191 logger.debug(getClass().getName() + " handling " + file.getOwnerID() + "/" + file.getAbsolutePath() + " " + evt.getEventType());
192 if (evt.getEventType().equals(MCREvent.CREATE_EVENT)) {
193 undoFileCreated(evt, file);
194 } else if (evt.getEventType().equals(MCREvent.UPDATE_EVENT)) {
195 undoFileUpdated(evt, file);
196 } else if (evt.getEventType().equals(MCREvent.DELETE_EVENT)) {
197 undoFileDeleted(evt, file);
198 } else if (evt.getEventType().equals(MCREvent.REPAIR_EVENT)) {
199 undoFileRepaired(evt, file);
200 } else {
201 logger.warn("Can't find method for file data handler for event type " + evt.getEventType());
202 }
203 return;
204 }
205 logger.warn("Can't find method for " + MCREvent.FILE_TYPE + " for event type " + evt.getEventType());
206 return;
207 }
208
209 if (evt.getObjectType().equals(MCREvent.CLASS_TYPE)) {
210 MCRCategory obj = (MCRCategory) (evt.get("class"));
211 if (obj != null) {
212 logger.debug(getClass().getName() + " handling " + obj.getId() + " " + evt.getEventType());
213 if (evt.getEventType().equals(MCREvent.CREATE_EVENT)) {
214 undoClassificationCreated(evt, obj);
215 } else if (evt.getEventType().equals(MCREvent.UPDATE_EVENT)) {
216 undoClassificationUpdated(evt, obj);
217 } else if (evt.getEventType().equals(MCREvent.DELETE_EVENT)) {
218 undoClassificationDeleted(evt, obj);
219 } else if (evt.getEventType().equals(MCREvent.REPAIR_EVENT)) {
220 undoClassificationRepaired(evt, obj);
221 } else {
222 logger.warn("Can't find method for an classification data handler for event type " + evt.getEventType());
223 }
224 return;
225 }
226 logger.warn("Can't find method for " + MCREvent.CLASS_TYPE + " for event type " + evt.getEventType());
227 return;
228 }
229
230 }
231
232 /** This method does nothing. It is very useful for debugging events. */
233 public void doNothing(MCREvent evt, Object obj) {
234 logger.debug(getClass().getName() + " does nothing on " + evt.getEventType() + " " + evt.getObjectType() + " " + obj.getClass().getName());
235 }
236
237 /**
238 * Handles classification created events. This implementation does nothing and
239 * should be overwritted by subclasses.
240 *
241 * @param evt
242 * the event that occured
243 * @param obj
244 * the MCRClassification that caused the event
245 */
246 protected void handleClassificationCreated(MCREvent evt, MCRCategory obj) {
247 doNothing(evt, obj);
248 }
249
250 /**
251 * Handles classification updated events. This implementation does nothing and
252 * should be overwritted by subclasses.
253 *
254 * @param evt
255 * the event that occured
256 * @param obj
257 * the MCRClassification that caused the event
258 */
259 protected void handleClassificationUpdated(MCREvent evt, MCRCategory obj) {
260 doNothing(evt, obj);
261 }
262
263 /**
264 * Handles classification deleted events. This implementation does nothing and
265 * should be overwritted by subclasses.
266 *
267 * @param evt
268 * the event that occured
269 * @param obj
270 * the MCRClassification that caused the event
271 */
272 protected void handleClassificationDeleted(MCREvent evt, MCRCategory obj) {
273 doNothing(evt, obj);
274 }
275
276 /**
277 * Handles classification repair events. This implementation does nothing and should
278 * be overwritted by subclasses.
279 *
280 * @param evt
281 * the event that occured
282 * @param obj
283 * the MCRClassification that caused the event
284 */
285 protected void handleClassificationRepaired(MCREvent evt, MCRCategory obj) {
286 doNothing(evt, obj);
287 }
288
289 /**
290 * Handles object created events. This implementation does nothing and
291 * should be overwritted by subclasses.
292 *
293 * @param evt
294 * the event that occured
295 * @param obj
296 * the MCRObject that caused the event
297 */
298 protected void handleObjectCreated(MCREvent evt, MCRObject obj) {
299 doNothing(evt, obj);
300 }
301
302 /**
303 * Handles object updated events. This implementation does nothing and
304 * should be overwritted by subclasses.
305 *
306 * @param evt
307 * the event that occured
308 * @param obj
309 * the MCRObject that caused the event
310 */
311 protected void handleObjectUpdated(MCREvent evt, MCRObject obj) {
312 doNothing(evt, obj);
313 }
314
315 /**
316 * Handles object deleted events. This implementation does nothing and
317 * should be overwritted by subclasses.
318 *
319 * @param evt
320 * the event that occured
321 * @param obj
322 * the MCRObject that caused the event
323 */
324 protected void handleObjectDeleted(MCREvent evt, MCRObject obj) {
325 doNothing(evt, obj);
326 }
327
328 /**
329 * Handles object repair events. This implementation does nothing and should
330 * be overwritted by subclasses.
331 *
332 * @param evt
333 * the event that occured
334 * @param obj
335 * the MCRObject that caused the event
336 */
337 protected void handleObjectRepaired(MCREvent evt, MCRObject obj) {
338 doNothing(evt, obj);
339 }
340
341 /**
342 * Handles derivate created events. This implementation does nothing and
343 * should be overwritted by subclasses.
344 *
345 * @param evt
346 * the event that occured
347 * @param der
348 * the MCRDerivate that caused the event
349 */
350 protected void handleDerivateCreated(MCREvent evt, MCRDerivate der) {
351 doNothing(evt, der);
352 }
353
354 /**
355 * Handles derivate updated events. This implementation does nothing and
356 * should be overwritted by subclasses.
357 *
358 * @param evt
359 * the event that occured
360 * @param der
361 * the MCRDerivate that caused the event
362 */
363 protected void handleDerivateUpdated(MCREvent evt, MCRDerivate der) {
364 doNothing(evt, der);
365 }
366
367 /**
368 * Handles derivate deleted events. This implementation does nothing and
369 * should be overwritted by subclasses.
370 *
371 * @param evt
372 * the event that occured
373 * @param der
374 * the MCRDerivate that caused the event
375 */
376 protected void handleDerivateDeleted(MCREvent evt, MCRDerivate der) {
377 doNothing(evt, der);
378 }
379
380 /**
381 * Handles derivate repair events. This implementation does nothing and
382 * should be overwritted by subclasses.
383 *
384 * @param evt
385 * the event that occured
386 * @param der
387 * the MCRDerivate that caused the event
388 */
389 protected void handleDerivateRepaired(MCREvent evt, MCRDerivate der) {
390 doNothing(evt, der);
391 }
392
393 /**
394 * Handles file created events. This implementation does nothing and should
395 * be overwritted by subclasses.
396 *
397 * @param evt
398 * the event that occured
399 * @param file
400 * the MCRFile that caused the event
401 */
402 protected void handleFileCreated(MCREvent evt, MCRFile file) {
403 doNothing(evt, file);
404 }
405
406 /**
407 * Handles file updated events. This implementation does nothing and should
408 * be overwritted by subclasses.
409 *
410 * @param evt
411 * the event that occured
412 * @param file
413 * the MCRFile that caused the event
414 */
415 protected void handleFileUpdated(MCREvent evt, MCRFile file) {
416 doNothing(evt, file);
417 }
418
419 /**
420 * Handles file deleted events. This implementation does nothing and should
421 * be overwritted by subclasses.
422 *
423 * @param evt
424 * the event that occured
425 * @param file
426 * the MCRFile that caused the event
427 */
428 protected void handleFileDeleted(MCREvent evt, MCRFile file) {
429 doNothing(evt, file);
430 }
431
432 /**
433 * Handles file repair events. This implementation does nothing and should
434 * be overwritted by subclasses.
435 *
436 * @param evt
437 * the event that occured
438 * @param file
439 * the MCRFile that caused the event
440 */
441 protected void handleFileRepaired(MCREvent evt, MCRFile file) {
442 doNothing(evt, file);
443 }
444
445 /**
446 * Handles undo of classification created events. This implementation does nothing
447 * and should be overwritted by subclasses.
448 *
449 * @param evt
450 * the event that occured
451 * @param obj
452 * the MCRClassification that caused the event
453 */
454 protected void undoClassificationCreated(MCREvent evt, MCRCategory obj) {
455 doNothing(evt, obj);
456 }
457
458 /**
459 * Handles undo of classification updated events. This implementation does nothing
460 * and should be overwritted by subclasses.
461 *
462 * @param evt
463 * the event that occured
464 * @param obj
465 * the MCRClassification that caused the event
466 */
467 protected void undoClassificationUpdated(MCREvent evt, MCRCategory obj) {
468 doNothing(evt, obj);
469 }
470
471 /**
472 * Handles undo of classification deleted events. This implementation does nothing
473 * and should be overwritted by subclasses.
474 *
475 * @param evt
476 * the event that occured
477 * @param obj
478 * the MCRClassification that caused the event
479 */
480 protected void undoClassificationDeleted(MCREvent evt, MCRCategory obj) {
481 doNothing(evt, obj);
482 }
483
484 /**
485 * Handles undo of classification repaired events. This implementation does nothing
486 * and should be overwritted by subclasses.
487 *
488 * @param evt
489 * the event that occured
490 * @param obj
491 * the MCRClassification that caused the event
492 */
493 protected void undoClassificationRepaired(MCREvent evt, MCRCategory obj) {
494 doNothing(evt, obj);
495 }
496
497 /**
498 * Handles undo of object created events. This implementation does nothing
499 * and should be overwritted by subclasses.
500 *
501 * @param evt
502 * the event that occured
503 * @param obj
504 * the MCRObject that caused the event
505 */
506 protected void undoObjectCreated(MCREvent evt, MCRObject obj) {
507 doNothing(evt, obj);
508 }
509
510 /**
511 * Handles undo of object updated events. This implementation does nothing
512 * and should be overwritted by subclasses.
513 *
514 * @param evt
515 * the event that occured
516 * @param obj
517 * the MCRObject that caused the event
518 */
519 protected void undoObjectUpdated(MCREvent evt, MCRObject obj) {
520 doNothing(evt, obj);
521 }
522
523 /**
524 * Handles undo of object deleted events. This implementation does nothing
525 * and should be overwritted by subclasses.
526 *
527 * @param evt
528 * the event that occured
529 * @param obj
530 * the MCRObject that caused the event
531 */
532 protected void undoObjectDeleted(MCREvent evt, MCRObject obj) {
533 doNothing(evt, obj);
534 }
535
536 /**
537 * Handles undo of object repaired events. This implementation does nothing
538 * and should be overwritted by subclasses.
539 *
540 * @param evt
541 * the event that occured
542 * @param obj
543 * the MCRObject that caused the event
544 */
545 protected void undoObjectRepaired(MCREvent evt, MCRObject obj) {
546 doNothing(evt, obj);
547 }
548
549 /**
550 * Handles undo of derivate created events. This implementation does nothing
551 * and should be overwritted by subclasses.
552 *
553 * @param evt
554 * the event that occured
555 * @param der
556 * the MCRDerivate that caused the event
557 */
558 protected void undoDerivateCreated(MCREvent evt, MCRDerivate der) {
559 doNothing(evt, der);
560 }
561
562 /**
563 * Handles undo of derivate updated events. This implementation does nothing
564 * and should be overwritted by subclasses.
565 *
566 * @param evt
567 * the event that occured
568 * @param der
569 * the MCRDerivate that caused the event
570 */
571 protected void undoDerivateUpdated(MCREvent evt, MCRDerivate der) {
572 doNothing(evt, der);
573 }
574
575 /**
576 * Handles undo of derivate deleted events. This implementation does nothing
577 * and should be overwritted by subclasses.
578 *
579 * @param evt
580 * the event that occured
581 * @param der
582 * the MCRDerivate that caused the event
583 */
584 protected void undoDerivateDeleted(MCREvent evt, MCRDerivate der) {
585 doNothing(evt, der);
586 }
587
588 /**
589 * Handles undo of derivate repaired events. This implementation does
590 * nothing and should be overwritted by subclasses.
591 *
592 * @param evt
593 * the event that occured
594 * @param der
595 * the MCRDerivate that caused the event
596 */
597 protected void undoDerivateRepaired(MCREvent evt, MCRDerivate der) {
598 doNothing(evt, der);
599 }
600
601 /**
602 * Handles undo of file created events. This implementation does nothing and
603 * should be overwritted by subclasses.
604 *
605 * @param evt
606 * the event that occured
607 * @param file
608 * the MCRFile that caused the event
609 */
610 protected void undoFileCreated(MCREvent evt, MCRFile file) {
611 doNothing(evt, file);
612 }
613
614 /**
615 * Handles undo of file updated events. This implementation does nothing and
616 * should be overwritted by subclasses.
617 *
618 * @param evt
619 * the event that occured
620 * @param file
621 * the MCRFile that caused the event
622 */
623 protected void undoFileUpdated(MCREvent evt, MCRFile file) {
624 doNothing(evt, file);
625 }
626
627 /**
628 * Handles undo of file deleted events. This implementation does nothing and
629 * should be overwritted by subclasses.
630 *
631 * @param evt
632 * the event that occured
633 * @param file
634 * the MCRFile that caused the event
635 */
636 protected void undoFileDeleted(MCREvent evt, MCRFile file) {
637 doNothing(evt, file);
638 }
639
640 /**
641 * Handles undo of file repair events. This implementation does nothing and
642 * should be overwritted by subclasses.
643 *
644 * @param evt
645 * the event that occured
646 * @param file
647 * the MCRFile that caused the event
648 */
649 protected void undoFileRepaired(MCREvent evt, MCRFile file) {
650 doNothing(evt, file);
651 }
652 }