eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/CdmStore.java

   1 /**
   2  * Copyright (C) 2007 EDIT
   3  * European Distributed Institute of Taxonomy
   4  * http://www.e-taxonomy.eu
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version 1.1
   7  * See LICENSE.TXT at the top of this package for the full license terms.
   8  */
   9
  10 package eu.etaxonomy.taxeditor.store;
  11
  12 import java.util.EnumSet;
  13
  14 import org.eclipse.core.runtime.IProgressMonitor;
  15 import org.eclipse.core.runtime.jobs.Job;
  16 import org.eclipse.swt.widgets.Display;
  17 import org.springframework.core.io.ClassPathResource;
  18 import org.springframework.core.io.Resource;
  19 import org.springframework.security.access.PermissionEvaluator;
  20 import org.springframework.security.authentication.AuthenticationManager;
  21 import org.springframework.security.core.Authentication;
  22 import org.springframework.security.core.GrantedAuthority;
  23 import org.springframework.security.core.context.SecurityContext;
  24 import org.springframework.security.core.context.SecurityContextHolder;
  25
  26 import eu.etaxonomy.cdm.api.application.CdmApplicationException;
  27 import eu.etaxonomy.cdm.api.application.CdmApplicationRemoteController;
  28 import eu.etaxonomy.cdm.api.application.CdmApplicationState;
  29 import eu.etaxonomy.cdm.api.application.ICdmRepository;
  30 import eu.etaxonomy.cdm.api.cache.CdmServiceCacher;
  31 import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
  32 import eu.etaxonomy.cdm.api.service.IAgentService;
  33 import eu.etaxonomy.cdm.api.service.IAnnotationService;
  34 import eu.etaxonomy.cdm.api.service.IClassificationService;
  35 import eu.etaxonomy.cdm.api.service.ICollectionService;
  36 import eu.etaxonomy.cdm.api.service.ICommonService;
  37 import eu.etaxonomy.cdm.api.service.IDescriptionService;
  38 import eu.etaxonomy.cdm.api.service.IEntityConstraintViolationService;
  39 import eu.etaxonomy.cdm.api.service.IEntityValidationService;
  40 import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
  41 import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
  42 import eu.etaxonomy.cdm.api.service.IGrantedAuthorityService;
  43 import eu.etaxonomy.cdm.api.service.IGroupService;
  44 import eu.etaxonomy.cdm.api.service.IMarkerService;
  45 import eu.etaxonomy.cdm.api.service.IMediaService;
  46 import eu.etaxonomy.cdm.api.service.INameService;
  47 import eu.etaxonomy.cdm.api.service.IOccurrenceService;
  48 import eu.etaxonomy.cdm.api.service.IPolytomousKeyNodeService;
  49 import eu.etaxonomy.cdm.api.service.IPolytomousKeyService;
  50 import eu.etaxonomy.cdm.api.service.IReferenceService;
  51 import eu.etaxonomy.cdm.api.service.IRegistrationService;
  52 import eu.etaxonomy.cdm.api.service.IRightsService;
  53 import eu.etaxonomy.cdm.api.service.IService;
  54 import eu.etaxonomy.cdm.api.service.ITaxonService;
  55 import eu.etaxonomy.cdm.api.service.ITermService;
  56 import eu.etaxonomy.cdm.api.service.IUserService;
  57 import eu.etaxonomy.cdm.api.service.IVocabularyService;
  58 import eu.etaxonomy.cdm.api.service.IWorkingSetService;
  59 import eu.etaxonomy.cdm.api.service.molecular.IAmplificationService;
  60 import eu.etaxonomy.cdm.api.service.molecular.IPrimerService;
  61 import eu.etaxonomy.cdm.api.service.statistics.Statistics;
  62 import eu.etaxonomy.cdm.config.ICdmSource;
  63 import eu.etaxonomy.cdm.database.DbSchemaValidation;
  64 import eu.etaxonomy.cdm.model.agent.AgentBase;
  65 import eu.etaxonomy.cdm.model.common.Annotation;
  66 import eu.etaxonomy.cdm.model.common.CdmBase;
  67 import eu.etaxonomy.cdm.model.common.DefinedTerm;
  68 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  69 import eu.etaxonomy.cdm.model.common.Group;
  70 import eu.etaxonomy.cdm.model.common.Language;
  71 import eu.etaxonomy.cdm.model.common.Marker;
  72 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  73 import eu.etaxonomy.cdm.model.common.User;
  74 import eu.etaxonomy.cdm.model.description.DescriptionBase;
  75 import eu.etaxonomy.cdm.model.description.FeatureNode;
  76 import eu.etaxonomy.cdm.model.description.FeatureTree;
  77 import eu.etaxonomy.cdm.model.description.PolytomousKey;
  78 import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;
  79 import eu.etaxonomy.cdm.model.description.WorkingSet;
  80 import eu.etaxonomy.cdm.model.media.Media;
  81 import eu.etaxonomy.cdm.model.media.Rights;
  82 import eu.etaxonomy.cdm.model.molecular.Amplification;
  83 import eu.etaxonomy.cdm.model.molecular.Primer;
  84 import eu.etaxonomy.cdm.model.name.Registration;
  85 import eu.etaxonomy.cdm.model.name.TaxonName;
  86 import eu.etaxonomy.cdm.model.occurrence.Collection;
  87 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  88 import eu.etaxonomy.cdm.model.reference.Reference;
  89 import eu.etaxonomy.cdm.model.taxon.Classification;
  90 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  91 import eu.etaxonomy.cdm.model.validation.EntityConstraintViolation;
  92 import eu.etaxonomy.cdm.model.validation.EntityValidation;
  93 import eu.etaxonomy.cdm.model.view.AuditEvent;
  94 import eu.etaxonomy.cdm.persistence.hibernate.permission.CRUD;
  95 import eu.etaxonomy.cdm.persistence.hibernate.permission.ICdmPermissionEvaluator;
  96 import eu.etaxonomy.cdm.persistence.hibernate.permission.Role;
  97 import eu.etaxonomy.taxeditor.datasource.CdmDataSourceRepository;
  98 import eu.etaxonomy.taxeditor.io.ExportManager;
  99 import eu.etaxonomy.taxeditor.io.ImportManager;
 100 import eu.etaxonomy.taxeditor.model.MessagingUtils;
 101 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
 102 import eu.etaxonomy.taxeditor.remoting.cache.CdmRemoteCacheManager;
 103 import eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager;
 104 import eu.etaxonomy.taxeditor.session.mock.MockCdmEntitySessionManager;
 105 import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;
 106 import eu.etaxonomy.taxeditor.ui.dialog.RemotingLoginDialog;
 107 import eu.etaxonomy.taxeditor.util.ProgressMonitorClientManager;
 108 import eu.etaxonomy.taxeditor.webapp.CDMServer;
 109
 110 /**
 111  * This implementation of ICdmDataRepository depends on hibernate sessions to
 112  * store the data correctly for the current session. No state is held in this
 113  * class.
 114  *
 115  * Only methods that either get or manipulate data are exposed here. So this
 116  * class acts as a facade for the methods in cdmlib-service.
 117  *
 118  * @author n.hoffmann
 119  * @created 17.03.2009
 120  * @version 1.0
 121  */
 122 public class CdmStore {
 123
 124     private static final Resource DEFAULT_APPLICATION_CONTEXT = new ClassPathResource(
 125             "/eu/etaxonomy/cdm/editorApplicationContext.xml",
 126             TaxeditorStorePlugin.class);
 127     private static final DbSchemaValidation DEFAULT_DB_SCHEMA_VALIDATION = DbSchemaValidation.VALIDATE;
 128
 129     private static CdmStore instance;
 130
 131     //private final ICdmRepository applicationConfiguration;
 132
 133     private static ContextManager contextManager = new ContextManager();
 134
 135     private static LoginManager loginManager = new LoginManager();
 136
 137     private static TermManager termManager = new TermManager();
 138
 139     private static SearchManager searchManager = new SearchManager();
 140
 141     private static EditorManager editorManager = new EditorManager();
 142
 143     private static UseObjectStore useObjectInitializer = new UseObjectStore();
 144
 145     private static ProgressMonitorClientManager progressMonitorClientManager = new ProgressMonitorClientManager();
 146
 147     private static CdmStoreConnector job;
 148
 149     private static CDMServer managedServer;
 150
 151     private Language language;
 152
 153     private ICdmSource cdmSource;
 154
 155     private boolean isConnected;
 156
 157
 158
 159     /**
 160      * <p>
 161      * getDefault
 162      * </p>
 163      *
 164      * @return a {@link eu.etaxonomy.taxeditor.store.CdmStore} object.
 165      */
 166     protected static CdmStore getDefault(boolean connecting){
 167         if (instance != null && instance.isConnected) {
 168             return instance;
 169         } else{// if (instance == null || !instance.isConnected) {
 170             if (connecting){
 171                 MessagingUtils.dataSourceNotAvailableWarningDialog(instance);
 172             }else{
 173                 MessagingUtils.noDataSourceWarningDialog(instance);
 174             }
 175
 176
 177             return null;
 178         }
 179     }
 180     /**
 181      * <p>
 182      * getDefault
 183      * </p>
 184      *
 185      * @return a {@link eu.etaxonomy.taxeditor.store.CdmStore} object.
 186      */
 187     protected static CdmStore getDefault(){
 188        return getDefault(false);
 189     }
 190
 191     /**
 192      * Initialize the with the last edited datasource
 193      */
 194     public static void connect() {
 195
 196         ICdmSource cdmSource;
 197         try {
 198
 199             cdmSource = CdmDataSourceRepository.getCurrentCdmSource();
 200             connect(cdmSource);
 201         } catch (Exception e) {
 202             MessagingUtils.messageDialog("Connection to CDM Source Failed", CdmStore.class, "Could not connect to target CDM Source", e);
 203         }
 204
 205
 206     }
 207
 208     /**
 209      * Initialize with a specific datasource
 210      *
 211      * @param datasource
 212      *            a {@link eu.etaxonomy.cdm.database.ICdmDataSource} object.
 213      */
 214     public static void connect(ICdmSource cdmSource) {
 215         connect(cdmSource, DEFAULT_DB_SCHEMA_VALIDATION,
 216                 DEFAULT_APPLICATION_CONTEXT);
 217     }
 218
 219     public static void connect(ICdmSource cdmSource, RemotingLoginDialog loginDialog) {
 220         connect(cdmSource,
 221                 DEFAULT_DB_SCHEMA_VALIDATION,
 222                 DEFAULT_APPLICATION_CONTEXT,
 223                 loginDialog);
 224     }
 225
 226     /**
 227      * Initialize and provide
 228      *
 229      * @param datasource
 230      * @param dbSchemaValidation
 231      * @param applicationContextBean
 232      */
 233     private static void connect(final ICdmSource cdmSource,
 234             final DbSchemaValidation dbSchemaValidation,
 235             final Resource applicationContextBean) {
 236
 237         MessagingUtils.info("Connecting to datasource: " + cdmSource);
 238
 239         job = new CdmStoreConnector(Display.getDefault(), cdmSource,
 240                 dbSchemaValidation, applicationContextBean);
 241         job.setUser(true);
 242         job.setPriority(Job.BUILD);
 243         job.schedule();
 244
 245     }
 246
 247     private static void connect(final ICdmSource cdmSource,
 248             final DbSchemaValidation dbSchemaValidation,
 249             final Resource applicationContextBean,
 250             RemotingLoginDialog remotingLoginDialog) {
 251         RemotingLoginDialog loginDialog = remotingLoginDialog;
 252         if(isActive()) {
 253             // before we connect we clear the entity caches and the sessions
 254             CdmRemoteCacheManager.removeEntityCaches();
 255             if(getCurrentSessionManager(true) != null) {
 256                 getCurrentSessionManager(true).disposeAll();
 257             }
 258         }
 259         MessagingUtils.info("Connecting to datasource: " + cdmSource);
 260
 261         job = new CdmStoreConnector(Display.getDefault(),
 262                 cdmSource,
 263                 dbSchemaValidation,
 264                 applicationContextBean);
 265         job.start(loginDialog);
 266
 267     }
 268
 269     public static boolean isConnecting() {
 270         return job != null && job.getState() == Job.RUNNING;
 271     }
 272
 273     /**
 274      * Closes the current application context
 275      *
 276      * @param monitor
 277      *            a {@link org.eclipse.core.runtime.IProgressMonitor} object.
 278      */
 279     public static void close(final IProgressMonitor monitor) {
 280         Display.getDefault().asyncExec(new Runnable() {
 281
 282             @Override
 283             public void run() {
 284                 getContextManager().notifyContextAboutToStop(monitor);
 285                 if ((monitor == null || (!monitor.isCanceled()) && isActive())) {
 286                     getContextManager().notifyContextStop(monitor);
 287                     instance.close();
 288                 }
 289             }
 290         });
 291     }
 292
 293     public static void close(IProgressMonitor monitor, boolean async) {
 294         if(async) {
 295             close(monitor);
 296         } else {
 297             getContextManager().notifyContextAboutToStop(monitor);
 298             if ((monitor == null || (!monitor.isCanceled()) && isActive())) {
 299                 getContextManager().notifyContextStop(monitor);
 300                 instance.close();
 301             }
 302         }
 303
 304     }
 305     private void close() {
 306         isConnected = false;
 307         cdmSource = null;
 308         CdmApplicationState.dispose();
 309     }
 310
 311     static void setInstance(ICdmRepository applicationController,
 312             ICdmSource cdmSource) {
 313         instance = new CdmStore(applicationController, cdmSource);
 314         CdmApplicationState.setCdmServiceCacher(new CdmServiceCacher());
 315
 316     }
 317
 318     private CdmStore(ICdmRepository repository,
 319             ICdmSource cdmSource) {
 320         CdmApplicationState.setCurrentAppConfig(repository);
 321         CdmApplicationState.setCurrentDataChangeService(new CdmUIDataChangeService());
 322         this.cdmSource = cdmSource;
 323         isConnected = true;
 324     }
 325
 326     /**
 327      * All calls to the datastore require
 328      *
 329      * @return
 330      */
 331     private ICdmRepository getApplicationConfiguration() {
 332         try {
 333             return CdmApplicationState.getCurrentAppConfig();
 334         } catch (Exception e) {
 335             MessagingUtils.error(CdmStore.class, e);
 336         }
 337         return null;
 338     }
 339
 340     /**
 341      * <p>
 342      * getCurrentApplicationController
 343      * </p>
 344      *
 345      * @return a
 346      *         {@link eu.etaxonomy.cdm.remote.api.application.CdmApplicationController}
 347      *         object.
 348      */
 349     public static ICdmRepository getCurrentApplicationConfiguration() {
 350         if (getDefault() != null) {
 351             return getDefault().getApplicationConfiguration();
 352         }
 353         return null;
 354     }
 355
 356     /*
 357      * CONVERSATIONS
 358      */
 359
 360     /**
 361      * Creates a new conversation, binds resources to the conversation and start
 362      * a transaction for this conversation.
 363      *
 364      * @return a {@link eu.etaxonomy.cdm.api.conversation.ConversationHolder}
 365      *         object.
 366      */
 367     public static ConversationHolder createConversation() {
 368         ConversationHolder conversation = getCurrentApplicationConfiguration()
 369                 .NewConversation();
 370         try {
 371             conversation.startTransaction();
 372         }catch(Exception e){
 373             MessagingUtils.messageDialog("No database connection", CdmStore.class, "No database connection available", e);
 374         }
 375         return conversation;
 376     }
 377
 378     //FIXME:Remoting should be removed after moving completely to remoting
 379     private MockCdmEntitySessionManager mockCdmEntitySessionManager;
 380
 381     private ICdmEntitySessionManager getSessionManager() {
 382         //FIXME:Remoting we should only have CdmApplicationRemoteConfiguration after move to remoting
 383         //               bad hack which should be finally removed
 384         if(getCurrentApplicationConfiguration() instanceof CdmApplicationRemoteController) {
 385             return ((CdmApplicationRemoteController)getCurrentApplicationConfiguration()).getCdmEntitySessionManager();
 386         } else {
 387             if(mockCdmEntitySessionManager == null) {
 388                 mockCdmEntitySessionManager = new MockCdmEntitySessionManager();
 389             }
 390             return mockCdmEntitySessionManager;
 391         }
 392     }
 393     public static  ICdmEntitySessionManager getCurrentSessionManager() {
 394         return getCurrentSessionManager(false);
 395     }
 396
 397
 398     public static  ICdmEntitySessionManager getCurrentSessionManager(boolean connecting) {
 399         if (getDefault(connecting) != null) {
 400             return getDefault(connecting).getSessionManager();
 401         }
 402         return null;
 403
 404     }
 405
 406     /**
 407      * Generic method that will scan the getters of {@link ICdmRepository} for the given service
 408      * interface. If a matching getter is found the according service implementation is returned by
 409      * invoking the getter otherwise the method returns <code>null</code>.
 410      *
 411      * @param <T>
 412      * @param serviceClass
 413      * @return the configured implementation of <code>serviceClass</code> or <code>null</code>
 414      */
 415     public static <T extends IService> T getService(Class<T> serviceClass) {
 416         T service = null;
 417         try {
 418             service = CdmApplicationState.getService(serviceClass);
 419         } catch (CdmApplicationException cae) {
 420             MessagingUtils.error(CdmStore.class, cae);
 421         }
 422
 423         return service;
 424     }
 425
 426     /**
 427      * @see #getService(Class)
 428      * As ICommonService is not extending IService we need a specific request here
 429      */
 430     public static ICommonService getCommonService() {
 431         return CdmApplicationState.getCommonService();
 432
 433     }
 434
 435     /**
 436      * <p>
 437      * getAuthenticationManager
 438      * </p>
 439      *
 440      * @return a
 441      *         {@link org.springframework.security.authentication.ProviderManager}
 442      *         object.
 443      */
 444     public static AuthenticationManager getAuthenticationManager() {
 445         return getCurrentApplicationConfiguration().getAuthenticationManager();
 446     }
 447
 448     /**
 449      * <p>
 450      * getAuthenticationManager
 451      * </p>
 452      *
 453      * @return a
 454      *         {@link ICdmPermissionEvaluator} object.
 455      */
 456     public static ICdmPermissionEvaluator getPermissionEvaluator() {
 457         return getCurrentApplicationConfiguration().getPermissionEvaluator();
 458     }
 459
 460
 461     /*
 462      * SECURITY RELATED CONVENIENCE METHODS
 463      */
 464
 465     /**
 466      * @see org.springframework.security.access.PermissionEvaluator#hasPermission(org.springframework.security.core.Authentication, java.lang.Object, java.lang.Object)
 467      *
 468      * @param targetDomainObject
 469      * @param permission
 470      * @return
 471      */
 472     public static boolean currentAuthentiationHasPermission(CdmBase targetDomainObject, EnumSet<CRUD> permission){
 473         //TODO use getCurrentApplicationConfiguration().currentAuthentiationHasPermission(CdmBase targetDomainObject, Operation permission) instead
 474         SecurityContext context = SecurityContextHolder.getContext();
 475         PermissionEvaluator pe = getPermissionEvaluator();
 476         boolean hasPermission = false;
 477         try {
 478             hasPermission = getPermissionEvaluator().hasPermission(context.getAuthentication(), targetDomainObject,
 479                     permission);
 480         } catch (org.springframework.security.access.AccessDeniedException e) {
 481             /* IGNORE */
 482         }
 483         return hasPermission;
 484     }
 485
 486     /**
 487      * @see org.springframework.security.access.PermissionEvaluator#hasPermission(org.springframework.security.core.Authentication, java.lang.Object, java.lang.Object)
 488      *
 489      * @param targetDomainObject
 490      * @param permission
 491      * @return
 492      */
 493     public static boolean currentAuthentiationHasPermission(Class<? extends CdmBase> targetType, EnumSet<CRUD> permission){
 494         boolean hasPermission = false;
 495         try {
 496             hasPermission = getPermissionEvaluator().hasPermission(getCurrentAuthentiation(), null, targetType.getName(), permission);
 497         } catch (org.springframework.security.access.AccessDeniedException e) {
 498             /* IGNORE */
 499         }
 500         return hasPermission;
 501     }
 502
 503     public static boolean currentAuthentiationHasOneOfRoles(Role ... roles){
 504         boolean hasPermission = false;
 505         try {
 506             hasPermission =  getPermissionEvaluator().hasOneOfRoles(getCurrentAuthentiation(), roles);
 507         } catch (org.springframework.security.access.AccessDeniedException e) {
 508             /* IGNORE */
 509         }
 510         return hasPermission;
 511     }
 512
 513     public static Authentication getCurrentAuthentiation() {
 514         SecurityContext context = SecurityContextHolder.getContext();
 515         return context.getAuthentication();
 516     }
 517
 518     /*
 519      * LANGUAGE
 520      */
 521
 522     /**
 523      * Provides access to the global default language set in the application preferences.
 524      *
 525      * @return a {@link eu.etaxonomy.cdm.model.common.Language} object.
 526      */
 527     public static Language getDefaultLanguage() {
 528         if (getDefault().getLanguage() == null) {
 529             getDefault().setLanguage(PreferencesUtil.getGlobalLanguage());
 530         }
 531         return getDefault().getLanguage();
 532     }
 533
 534     /**
 535      * <p>
 536      * setDefaultLanguage
 537      * </p>
 538      *
 539      * @param language
 540      *            a {@link eu.etaxonomy.cdm.model.common.Language} object.
 541      */
 542     public static void setDefaultLanguage(Language language) {
 543         getDefault().setLanguage(language);
 544     }
 545
 546     /**
 547      * @return the language
 548      */
 549     private Language getLanguage() {
 550         return language;
 551     }
 552
 553     /**
 554      * @param language
 555      *            the language to set
 556      */
 557     private void setLanguage(Language language) {
 558         this.language = language;
 559     }
 560
 561     /*
 562      * LOGIN
 563      */
 564
 565     /**
 566      * <p>
 567      * Getter for the field <code>loginManager</code>.
 568      * </p>
 569      *
 570      * @return a {@link eu.etaxonomy.taxeditor.store.LoginManager} object.
 571      */
 572     public static LoginManager getLoginManager() {
 573         return loginManager;
 574     }
 575
 576     /**
 577      * <p>
 578      * Getter for the field <code>contextManager</code>.
 579      * </p>
 580      *
 581      * @return a {@link eu.etaxonomy.taxeditor.store.ContextManager} object.
 582      */
 583     public static ContextManager getContextManager() {
 584         return contextManager;
 585     }
 586
 587     public static TermManager getTermManager() {
 588         return termManager;
 589     }
 590
 591     public static SearchManager getSearchManager() {
 592         return searchManager;
 593     }
 594
 595     public static EditorManager getEditorManager() {
 596         return editorManager;
 597     }
 598
 599     public static ProgressMonitorClientManager getProgressMonitorClientManager() {
 600         return progressMonitorClientManager;
 601     }
 602
 603     /*
 604      * IMPORT/EXPORT FACTORIES
 605      */
 606
 607     /**
 608      * <p>
 609      * Getter for the field <code>importHandler</code>.
 610      * </p>
 611      *
 612      * @return a {@link eu.etaxonomy.taxeditor.io.ImportManager} object.
 613      */
 614     public static ImportManager getImportManager() {
 615         return ImportManager.NewInstance(getCurrentApplicationConfiguration());
 616     }
 617
 618     /**
 619      * <p>
 620      * Getter for the field <code>exportHandler</code>.
 621      * </p>
 622      *
 623      * @return a {@link eu.etaxonomy.taxeditor.io.ExportManager} object.
 624      */
 625     public static ExportManager getExportManager() {
 626         return ExportManager.NewInstance(getCurrentApplicationConfiguration());
 627     }
 628
 629     /**
 630      * Whether this CdmStore is currently connected to a datasource
 631      *
 632      * @return a boolean.
 633      */
 634     public static boolean isActive() {
 635         return instance != null && instance.isConnected;
 636     }
 637
 638     public static ICdmSource getActiveCdmSource() {
 639         if (isActive()) {
 640             return instance.getCdmSource();
 641         }
 642         return null;
 643     }
 644
 645     /**
 646      * <p>
 647      * getDataSource
 648      * </p>
 649      *
 650      * @return a {@link eu.etaxonomy.cdm.database.ICdmDataSource} object.
 651      * @deprecated currently retained for backward compatibility - use {@link getActiveCdmSource()} instead
 652      */
 653     //  public static ICdmDataSource getDataSource() {
 654     //          if (isActive()) {
 655     //                  return (ICdmDataSource)instance.getCdmSource();
 656     //          }
 657     //          return null;
 658     //  }
 659
 660     /**
 661      * @return
 662      */
 663     private ICdmSource getCdmSource() {
 664         return cdmSource;
 665     }
 666
 667
 668     public static <T extends CdmBase> IService<T> getService(T cdmBase){
 669         IService<T> service = null;
 670         if(cdmBase!=null){
 671             //get corresponding service
 672             if(cdmBase.isInstanceOf(Reference.class)){
 673                 service = (IService<T>) getService(IReferenceService.class);
 674             }
 675             else if (cdmBase.isInstanceOf(AgentBase.class)){
 676                 service = (IService<T>) getService(IAgentService.class);
 677             }
 678             else if (cdmBase instanceof TaxonName) {
 679                 service = (IService<T>) getService(INameService.class);
 680             }
 681             else if (cdmBase instanceof TaxonBase) {
 682                 service = (IService<T>) getService(ITaxonService.class);
 683             }
 684             else if (cdmBase instanceof SpecimenOrObservationBase) {
 685                 service = (IService<T>) getService(IOccurrenceService.class);
 686             }
 687             else if (cdmBase instanceof Media) {
 688                 service = (IService<T>) getService(IMediaService.class);
 689             }
 690             else if (cdmBase instanceof Collection) {
 691                 service = (IService<T>) getService(ICollectionService.class);
 692             }
 693             else if (cdmBase instanceof User) {
 694                 service = (IService<T>) getService(IUserService.class);
 695             }
 696             else if (cdmBase instanceof Group) {
 697                 service = (IService<T>) getService(IGroupService.class);
 698             }
 699             else if (cdmBase instanceof WorkingSet) {
 700                 service = (IService<T>) getService(IWorkingSetService.class);
 701             }
 702             else if (cdmBase instanceof TermVocabulary<?>) {
 703                 service = (IService<T>) getService(IVocabularyService.class);
 704             }
 705             else if (cdmBase instanceof DefinedTermBase<?>) {
 706                 service = (IService<T>) getService(ITermService.class);
 707             }
 708             else if (cdmBase instanceof Primer) {
 709                 service = (IService<T>) getService(IPrimerService.class);
 710             }
 711             else if (cdmBase instanceof Amplification) {
 712                 service = (IService<T>) getService(IAmplificationService.class);
 713             }
 714             else if (cdmBase instanceof PolytomousKey) {
 715                 service = (IService<T>) getService(IPolytomousKeyService.class);
 716             }
 717             else if (cdmBase instanceof PolytomousKeyNode) {
 718                 service = (IService<T>) getService(IPolytomousKeyNodeService.class);
 719             }
 720             else if (cdmBase instanceof Annotation) {
 721                 service = (IService<T>) getService(IAnnotationService.class);
 722             }
 723 //            else if (cdmBase instanceof AuditEvent) {
 724 //                service = (IService<T>) getService(IAuditEventService.class);
 725 //            }
 726             else if (cdmBase instanceof Classification) {
 727                 service = (IService<T>) getService(IClassificationService.class);
 728             }
 729             else if (cdmBase instanceof DescriptionBase<?>) {
 730                 service = (IService<T>) getService(IDescriptionService.class);
 731             }
 732             else if (cdmBase instanceof EntityConstraintViolation) {
 733                 service = (IService<T>) getService(IEntityConstraintViolationService.class);
 734             }
 735             else if (cdmBase instanceof EntityValidation) {
 736                 service = (IService<T>) getService(IEntityValidationService.class);
 737             }
 738             else if (cdmBase instanceof FeatureNode) {
 739                 service = (IService<T>) getService(IFeatureNodeService.class);
 740             }
 741             else if (cdmBase instanceof FeatureTree) {
 742                 service = (IService<T>) getService(IFeatureTreeService.class);
 743             }
 744             else if (cdmBase instanceof GrantedAuthority) {
 745                 service = (IService<T>) getService(IGrantedAuthorityService.class);
 746             }
 747             else if (cdmBase instanceof Marker) {
 748                 service = (IService<T>) getService(IMarkerService.class);
 749             }
 750             else if (cdmBase instanceof Registration) {
 751                 service = (IService<T>) getService(IRegistrationService.class);
 752             }
 753             else if (cdmBase instanceof Rights) {
 754                 service = (IService<T>) getService(IRightsService.class);
 755             }
 756             else{
 757                 String message = "Service for entity of class %s not yet implemented in TaxEditor";
 758                 message = String.format(message, cdmBase.getClass().getSimpleName());
 759                 throw new RuntimeException(message);
 760             }
 761         }
 762         return service;
 763     }
 764
 765     public static void setManagedServer(CDMServer server) {
 766         managedServer = server;
 767     }
 768
 769     public static CDMServer getManagedServer() {
 770         return managedServer;
 771     }
 772
 773 }