/ - Diff - EDIT - EDIT Project Management

         <vaadin.version>7.7.10</vaadin.version>
         <vaadin-spring.version>1.2.0</vaadin-spring.version>
         <vaadin.plugin.version>${vaadin.version}</vaadin.plugin.version>
         <vaadin-spring-addon-eventbus.version>2.0.0.RELEASE</vaadin-spring-addon-eventbus.version>
         <cdmlib.version>4.14.0-SNAPSHOT</cdmlib.version>
         <unitils.version>3.4.2</unitils.version>
         <!--
-...
           <artifactId>vaadin-spring</artifactId>
           <version>${vaadin-spring.version}</version>
         </dependency>
         <dependency>
           <groupId>org.vaadin.spring.addons</groupId>
           <artifactId>vaadin-spring-addon-eventbus</artifactId>
           <version>${vaadin-spring-addon-eventbus.version}</version>
         </dependency>
         <dependency>
           <groupId>com.vaadin</groupId>
           <artifactId>vaadin-server</artifactId>

     import org.springframework.context.annotation.FilterType;
     import org.springframework.core.env.Environment;
     import org.springframework.security.authentication.AuthenticationProvider;
     import org.vaadin.spring.events.annotation.EnableEventBus;
     import com.vaadin.spring.annotation.EnableVaadin;
     import com.vaadin.spring.annotation.SpringUI;
-...
     @EnableVaadin   // this imports VaadinConfiguration
     @EnableVaadinSpringNavigation // activate the NavigationManagerBean
     @EnableAnnotationBasedAccessControl // enable annotation based per view access control
     @EnableEventBus // enable the vaadin spring event bus
     public class CdmVaadinConfiguration implements ApplicationContextAware  {

     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.beans.factory.annotation.Qualifier;
     import org.springframework.context.ApplicationEventPublisher;
     import org.springframework.context.event.EventListener;
     import org.vaadin.spring.events.EventBus;
     import org.vaadin.spring.events.annotation.EventBusListenerMethod;
     import com.vaadin.server.FontAwesome;
     import com.vaadin.server.ThemeResource;
-...
     	 */
     	private static final long serialVersionUID = 5344340511582993289L;
         private EventBus.UIEventBus uiEventBus;
         @Autowired
         protected ApplicationEventPublisher eventBus;
         private final void setViewEventBus(EventBus.UIEventBus viewEventBus){
             this.uiEventBus = viewEventBus;
             viewEventBus.subscribe(AuthenticationSuccessEvent.class);
+        }
         @Autowired
         @Qualifier("cdmRepository")
-...
     		updateAuthenticationButtons();
+        }
         @EventListener
         public void onAuthenticationSuccessEvent(AuthenticationSuccessEvent event){
     	@EventBusListenerMethod
         public void onAuthenticationSuccessEvent(org.vaadin.spring.events.Event<AuthenticationSuccessEvent> event){
             boolean isInitialized = userButton != null;
             // The RegistrationToolbar is being initialize even if not needed only because it is a EventListener
             // which causes Spring to initialize it.
-...
          * @return
          */
         private void performLogin() {
             eventBus.publishEvent(new NavigationEvent("login", navigationManager.getCurrentViewName())); //$NON-NLS-1$
             uiEventBus.publish(this, new NavigationEvent("login", navigationManager.getCurrentViewName())); //$NON-NLS-1$
+        }
-...
     	public Button getDetailButton() {
     		return detailButton;
+    	}
+    }

     import org.joda.time.DateTime;
     import org.joda.time.format.ISODateTimeFormat;
     import org.vaadin.spring.events.EventScope;
     import com.vaadin.server.ExternalResource;
     import com.vaadin.server.FontAwesome;
-...
         private void publishEvent(Object event) {
             parentView.getEventBus().publishEvent(event);
             if(event instanceof NavigationEvent){
                 parentView.getViewEventBus().publish(EventScope.UI, this, event);
             } else {
                 parentView.getViewEventBus().publish(this, event);
+            }
+        }
         /* ====== RegistrationItemDesign Getters ====== */

     import org.apache.log4j.Logger;
     import org.springframework.context.annotation.Profile;
     import org.springframework.context.event.EventListener;
     import org.springframework.stereotype.Component;
     import org.vaadin.spring.events.Event;
     import org.vaadin.spring.events.EventBus;
     import org.vaadin.spring.events.EventBus.ViewEventBus;
     import org.vaadin.spring.events.EventBusListener;
     import com.vaadin.event.ShortcutAction;
     import com.vaadin.event.ShortcutListener;
-...
     import eu.etaxonomy.vaadin.mvp.AbstractPresenter;
     import eu.etaxonomy.vaadin.mvp.AbstractView;
     import eu.etaxonomy.vaadin.ui.view.PopEditorOpenedEvent;
     import eu.etaxonomy.vaadin.ui.view.PopupView;
     /**
      * @author a.kohlbecker
-...
      */
     @Component
     @Profile("debug")
     public class EntityCacheDebugger implements ViewChangeListener {
     public class EntityCacheDebugger implements ViewChangeListener, EventBusListener<PopEditorOpenedEvent> {
         Logger logger = Logger.getLogger(EntityCacheDebugger.class);
         private ViewEventBus viewEventBus;
         // @Autowired // FIXME autowiring fails, need to put in UI Scope?
         protected final void setViewEventBus(EventBus.ViewEventBus viewEventBus){
             this.viewEventBus = viewEventBus;
             viewEventBus.subscribe(this);
+        }
         EntityCacheDebuggerShortcutListener shortcutListener;
-...
+            }
+        }
         @EventListener
         public void onPopEditorOpenedEvent(PopEditorOpenedEvent event){
             if(event.getPopupView() != null && event.getPopupView() instanceof AbstractCdmPopupEditor){
                 findWindow(((AbstractCdmPopupEditor)event.getPopupView())).addShortcutListener(shortcutListener);
         @Override
         public void onEvent(Event<PopEditorOpenedEvent> event){
             PopupView popupView = event.getPayload().getPopupView();
             if(popupView != null && popupView instanceof AbstractCdmPopupEditor){
                 findWindow(((AbstractCdmPopupEditor)popupView)).addShortcutListener(shortcutListener);
+            }
+        }

     /**
     * Copyright (C) 2018 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     package eu.etaxonomy.cdm.vaadin.event;
     import org.vaadin.spring.events.Event;
     import org.vaadin.spring.events.EventBusListenerMethodFilter;
     import eu.etaxonomy.vaadin.event.EditorActionType;
     /**
      * @author a.kohlbecker
      * @since Jan 31, 2018
+     *
      */
     public class EditorActionTypeFilter implements EventBusListenerMethodFilter {
         EditorActionType action;
         private EditorActionTypeFilter(EditorActionType action) {
             this.action = action;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public boolean filter(Event<?> event) {
             if (event.getPayload() instanceof AbstractEditorAction) {
                 AbstractEditorAction editorAction = (AbstractEditorAction) event.getPayload();
                 return this.action.equals(editorAction.type);
+            }
             return false;
+        }
         public static class Add extends EditorActionTypeFilter {
             public Add() {
                 super(EditorActionType.ADD);
+            }
+        }
         public static class Edit extends EditorActionTypeFilter {
             public Edit() {
                 super(EditorActionType.EDIT);
+            }
+        }
         public static class Remove extends EditorActionTypeFilter {
             public Remove() {
                 super(EditorActionType.REMOVE);
+            }
+        }
+    }

     /**
     * Copyright (C) 2018 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     package eu.etaxonomy.cdm.vaadin.event;
     import java.util.Optional;
     import org.vaadin.spring.events.Event;
     import org.vaadin.spring.events.EventBusListenerMethodFilter;
     import eu.etaxonomy.cdm.vaadin.event.EntityChangeEvent.Type;
     /**
      * @author a.kohlbecker
      * @since Jan 31, 2018
+     *
      */
     public class EntityChangeEventFilter implements EventBusListenerMethodFilter {
         private Optional<Class<?>> entityType = null;
         private Optional<Type> eventType = null;
         private EntityChangeEventFilter(Class<?> entityType, Type eventType){
             this.entityType = Optional.of(entityType);
             this.eventType = Optional.of(eventType);
+        }
         private EntityChangeEventFilter(Type eventType){
             this.eventType = Optional.of(eventType);
+        }
         private EntityChangeEventFilter(Class<?> entityType){
             this.entityType = Optional.of(entityType);
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public boolean filter(Event<?> event) {
             if(event.getPayload() instanceof EntityChangeEvent){
                 EntityChangeEvent testEvent = (EntityChangeEvent)event.getPayload();
                 boolean match = true;
                 if(this.entityType != null){
                     match &= this.entityType.get().equals(testEvent.getEntityType());
+                }
                 if(this.eventType != null){
                     match &= this.eventType.get().equals(testEvent.getType());
+                }
                 return match;
+            }
             return false;
+        }
         public static class OccurrenceCollectionFilter extends EntityChangeEventFilter{
             OccurrenceCollectionFilter(){
                 super(eu.etaxonomy.cdm.model.occurrence.Collection.class);
+            }
+        }
         public static class ReferenceFilter extends EntityChangeEventFilter {
             public ReferenceFilter() {
                 super(eu.etaxonomy.cdm.model.reference.Reference.class);
+            }
+        }
+    }

     /**
     * Copyright (C) 2018 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     package eu.etaxonomy.cdm.vaadin.event;
     import org.vaadin.spring.events.Event;
     import org.vaadin.spring.events.EventBusListenerMethodFilter;
     /**
      * @author a.kohlbecker
      * @since Jan 31, 2018
+     *
      */
     public class ShowDetailsEventEntityTypeFilter implements EventBusListenerMethodFilter {
         Class entityType;
         private ShowDetailsEventEntityTypeFilter(Class entityType){
             this.entityType = entityType;
+        }
         /**
          * {@inheritDoc}
          */
         @Override
         public boolean filter(Event<?> event) {
             if(event.getPayload() instanceof ShowDetailsEvent){
                 ShowDetailsEvent detailsEvent = (ShowDetailsEvent)event.getPayload();
                 return this.entityType.equals(detailsEvent.getEntityType());
+            }
             return false;
+        }
         public static class RegistrationWorkingSet extends ShowDetailsEventEntityTypeFilter{
             public RegistrationWorkingSet(){
                 super(RegistrationWorkingSet.class);
+            }
+        }
         public static class RegistrationDTO extends ShowDetailsEventEntityTypeFilter{
             public RegistrationDTO(){
                 super(RegistrationDTO.class);
+            }
+        }
+    }

     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.beans.factory.annotation.Qualifier;
     import org.springframework.context.ApplicationEventPublisher;
     import org.springframework.context.event.EventListener;
     import org.vaadin.spring.events.EventBus;
     import org.vaadin.spring.events.EventBus.UIEventBus;
     import org.vaadin.spring.events.EventBusListener;
     import com.vaadin.server.FontAwesome;
     import com.vaadin.spring.annotation.SpringComponent;
-...
      */
     @SpringComponent("registrationToolbar")
     @UIScope
     public class RegistrationToolbar extends HorizontalLayout implements Toolbar {
     public class RegistrationToolbar extends HorizontalLayout implements Toolbar, EventBusListener<AuthenticationSuccessEvent> {
         private static final long serialVersionUID = 2594781255088231474L;
         @Autowired
         protected ApplicationEventPublisher eventBus;
         @Autowired
         @Qualifier("cdmRepository")
         private CdmRepository repo;
         private UIEventBus uiEventBus;
         @Autowired
         protected final void setUIEventBus(EventBus.UIEventBus uiEventBus){
             this.uiEventBus = uiEventBus;
             uiEventBus.subscribe(this);
+        }
         @Autowired
         protected NavigationManager navigationManager;
-...
+        }
         @EventListener
         public void onAuthenticationSuccessEvent(AuthenticationSuccessEvent event){
             boolean isInitialized = userButton != null;
             // The RegistrationToolbar is being initialize even if not needed only because it is a EventListener
             // which causes Spring to initialize it.
             // TODO After switching to an other event bus this check can be removed
             if(isInitialized){
                 updateAuthenticationButtons();
+            }
         @Override
         public void onEvent(org.vaadin.spring.events.Event<AuthenticationSuccessEvent> event) {
             updateAuthenticationButtons();
+        }
         /**
-...
          * @return
          */
         private void performLogin() {
             eventBus.publishEvent(new NavigationEvent("login", navigationManager.getCurrentViewName()));
             uiEventBus.publish(this, new NavigationEvent("login", navigationManager.getCurrentViewName()));
+        }

     import org.apache.log4j.Logger;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.context.ApplicationEventPublisher;
     import org.vaadin.spring.events.EventBus.UIEventBus;
     import com.vaadin.annotations.Theme;
     import com.vaadin.annotations.Title;
-...
     //    private Toolbar toolbar;
         @Autowired
         ApplicationEventPublisher eventBus;
         UIEventBus uiEventBus;
         public DistributionStatusUI() {
-...
     //            ((ToolbarDisplay)viewDisplay).setToolbar(toolbar);
     //        }
             eventBus.publishEvent(new UIInitializedEvent());
             uiEventBus.publish(this, new UIInitializedEvent());
             navigator.setDefaultViewName(INITIAL_VIEW);

     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.beans.factory.annotation.Qualifier;
     import org.springframework.context.ApplicationEventPublisher;
     import org.vaadin.spring.events.EventBus.UIEventBus;
     import com.flowingcode.vaadin.addons.errorwindow.WindowErrorHandler;
     import com.vaadin.annotations.Theme;
-...
         @Autowired(required = false)
         EntityCacheDebugger entityCacheDebugger = null;
         @Autowired
         UIEventBus uiEventBus;
         /*
              * this HACKY solution forces the bean to be instantiated, TODO do it properly
              */
         //    @Autowired
         //    MenuBeanDiscoveryBean bean;
             @Autowired
             private MainMenu mainMenu;
         /*
                  * this HACKY solution forces the bean to be instantiated, TODO do it properly
                  */
             //    @Autowired
             //    MenuBeanDiscoveryBean bean;
                 @Autowired
                 @Qualifier("registrationToolbar")
                 private Toolbar toolbar;
         //---------------------------------------------
                 public static final String INITIAL_VIEW =  DashBoardView.NAME;
         protected void configureAccessDeniedView() {
             viewProvider.setAccessDeniedViewClass(RedirectToLoginView.class);
+        }
-...
         //---------------------------------------------
         public static final String INITIAL_VIEW =  DashBoardView.NAME;
         /*
-...
     //    @Autowired
     //    MenuBeanDiscoveryBean bean;
         @Autowired
         private MainMenu mainMenu;
         @Autowired
         @Qualifier("registrationToolbar")
         private Toolbar toolbar;
         @Autowired
         ApplicationEventPublisher eventBus;
         public RegistrationUI() {
+        }
-...
+            }
             eventBus.publishEvent(new UIInitializedEvent());
             uiEventBus.publish(this, new UIInitializedEvent());
             String brand = "phycobank";
             //TODO create annotation:

     import org.apache.commons.lang.StringUtils;
     import org.apache.log4j.Logger;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.context.ApplicationEventPublisher;
     import org.springframework.context.event.EventListener;
     import org.springframework.security.authentication.AuthenticationManager;
     import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
     import org.springframework.security.core.Authentication;
     import org.springframework.security.core.AuthenticationException;
     import org.vaadin.spring.events.Event;
     import org.vaadin.spring.events.EventBus;
     import org.vaadin.spring.events.EventBus.ViewEventBus;
     import org.vaadin.spring.events.EventBusListener;
     import com.vaadin.spring.annotation.SpringComponent;
     import com.vaadin.spring.annotation.ViewScope;
-...
      */
     @SpringComponent
     @ViewScope
     public class LoginPresenter extends AbstractPresenter<LoginView> {
     public class LoginPresenter extends AbstractPresenter<LoginView> implements EventBusListener<AuthenticationAttemptEvent> {
         private static final long serialVersionUID = 4020699735656994791L;
-...
         private final static String PROPNAME_PASSWORD = "cdm-vaadin.login.pwd";
         @Autowired
         protected ApplicationEventPublisher eventBus;
         private String redirectToState;
         protected EventBus.UIEventBus uiEventBus;
         /**
          * {@inheritDoc}
          */
         @Override
         protected void eventViewBusSubscription(ViewEventBus viewEventBus) {
             // not listening to view scope events
+        }
         @Autowired
         protected void setUIEventBus(EventBus.UIEventBus uiEventBus){
             this.uiEventBus = uiEventBus;
             uiEventBus.subscribe(this);
+        }
         public boolean authenticate(String userName, String password) {
             getView().clearMessage();
-...
                     log.debug("user '" + userName + "' authenticated");
                     currentSecurityContext().setAuthentication(authentication);
                     if(NavigationManager.class.isAssignableFrom(getNavigationManager().getClass())){
                         eventBus.publishEvent(new AuthenticationSuccessEvent(userName));
                         uiEventBus.publish(this, new AuthenticationSuccessEvent(userName));
                         log.debug("redirecting to " + redirectToState);
                         eventBus.publishEvent(new NavigationEvent(redirectToState));
                         uiEventBus.publish(this, new NavigationEvent(redirectToState));
+                    }
+                }
             } catch (AuthenticationException e){
-...
+            }
+        }
         @EventListener
         protected void onLoginEvent(AuthenticationAttemptEvent e){
             authenticate(e.getUserName(), getView().getLoginDialog().getPassword().getValue());
         @Override
         public void onEvent(Event<AuthenticationAttemptEvent> event) {
             authenticate(event.getPayload().getUserName(), getView().getLoginDialog().getPassword().getValue());
+        }
+    }

     */
     package eu.etaxonomy.cdm.vaadin.view;
     import org.vaadin.spring.events.EventScope;
     import com.vaadin.navigator.View;
     import com.vaadin.navigator.ViewChangeListener.ViewChangeEvent;
     import com.vaadin.spring.annotation.SpringView;
-...
             setCompositionRoot(root);
             loginDialog.getLoginButton().addClickListener(e -> handleLoginClick(e));
             loginDialog.getRegisterButton().addClickListener(e -> eventBus.publishEvent(new RegisterNewUserEvent(e)));
             loginDialog.getSendOnetimeLogin().addClickListener(e -> eventBus.publishEvent(new PasswordRevoveryEvent(e)));
             loginDialog.getRegisterButton().addClickListener(e -> getViewEventBus().publish(EventScope.UI, this, new RegisterNewUserEvent(e)));
             loginDialog.getSendOnetimeLogin().addClickListener(e -> getViewEventBus().publish(EventScope.UI, this, new PasswordRevoveryEvent(e)));
             // NOTE: null viewName will be replaced by the default view name in NavigationManagerBean
             loginDialog.getCancelLoginButton().addClickListener(e -> eventBus.publishEvent(new NavigationEvent(null)));
             loginDialog.getCancelRegistrationButton().addClickListener(e -> eventBus.publishEvent(new NavigationEvent(null)));
             loginDialog.getCancelLoginButton().addClickListener(e -> getViewEventBus().publish(EventScope.UI, this, new NavigationEvent(null)));
             loginDialog.getCancelRegistrationButton().addClickListener(e -> getViewEventBus().publish(EventScope.UI, this, new NavigationEvent(null)));
+        }
         /**
          * @param e
          */
         private void handleLoginClick(ClickEvent e) {
             eventBus.publishEvent(new AuthenticationAttemptEvent(e, loginDialog.getUserName().getValue()));
             getViewEventBus().publish(this, new AuthenticationAttemptEvent(e, loginDialog.getUserName().getValue()));
+        }
         @Override

     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.beans.factory.config.ConfigurableBeanFactory;
     import org.springframework.context.ApplicationEventPublisher;
     import org.springframework.context.annotation.Scope;
     import org.vaadin.spring.events.EventBus;
     import com.vaadin.navigator.Navigator;
     import com.vaadin.navigator.View;
-...
         NavigationManager navigationManager;
         @Autowired
         protected ApplicationEventPublisher eventBus;
         protected EventBus.UIEventBus uiEventBus;
         public RedirectToLoginView() {
-...
             String currentState = ((Navigator)navigationManager).getState();
             // redirect to the login view and pass over the current state
             eventBus.publishEvent(new NavigationEvent(LoginViewBean.NAME, currentState));
             uiEventBus.publish(this, new NavigationEvent(LoginViewBean.NAME, currentState));
+        }
+    }

     import org.vaadin.addons.lazyquerycontainer.LazyQueryContainer;
     import org.vaadin.addons.lazyquerycontainer.QueryDefinition;
     import org.vaadin.addons.lazyquerycontainer.QueryFactory;
     import org.vaadin.spring.events.EventBus.ViewEventBus;
     import com.vaadin.server.VaadinSession;
     import com.vaadin.spring.annotation.SpringComponent;
-...
         @Autowired
         @Qualifier("cdmRepository")
         private CdmRepository repo;
         private CdmRepository repo; // TODO remove, since this is already in the super class
     	public int updateDistributionField(String distributionAreaString, Object comboValue, Taxon taxon) {
     	/**
          * {@inheritDoc}
          */
         @Override
         protected void eventViewBusSubscription(ViewEventBus viewEventBus) {
             // no point subscribing
+        }
         public int updateDistributionField(String distributionAreaString, Object comboValue, Taxon taxon) {
     	    TransactionStatus tx = repo.startTransaction();
     	    taxon = (Taxon)repo.getTaxonService().find(taxon.getUuid());
     	    Set<DefinedTermBase> chosenTerms = getChosenTerms();

     */
     package eu.etaxonomy.cdm.vaadin.view.name;
     import org.springframework.context.annotation.Scope;
     import com.vaadin.spring.annotation.SpringComponent;
     import com.vaadin.ui.Alignment;
     import com.vaadin.ui.CheckBox;
     import com.vaadin.ui.GridLayout;
-...
      * @since Jan 26, 2018
+     *
      */
     @SpringComponent
     @Scope("prototype")
     public class NameTypeDesignationPopupEditor extends AbstractCdmPopupEditor<NameTypeDesignation, NameTypeDesignationPresenter>
         implements NameTypeDesignationEditorView {

     import java.util.List;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.context.annotation.Scope;
     import com.vaadin.spring.annotation.SpringComponent;
     import eu.etaxonomy.cdm.api.service.IService;
     import eu.etaxonomy.cdm.model.name.NameTypeDesignation;
-...
      * @since Jan 26, 2018
+     *
      */
     @SpringComponent
     @Scope("prototype")
     public class NameTypeDesignationPresenter
             extends AbstractCdmEditorPresenter<NameTypeDesignation, NameTypeDesignationEditorView> {

     import java.util.Set;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.context.event.EventListener;
     import org.springframework.context.annotation.Scope;
     import org.vaadin.spring.events.annotation.EventBusListenerMethod;
     import org.vaadin.viritin.fields.AbstractElementCollection;
     import com.vaadin.spring.annotation.SpringComponent;
     import eu.etaxonomy.cdm.api.service.IRegistrationService;
     import eu.etaxonomy.cdm.cache.CdmTransientEntityCacher;
     import eu.etaxonomy.cdm.model.ICdmCacher;
-...
     import eu.etaxonomy.cdm.vaadin.component.CdmBeanItemContainerFactory;
     import eu.etaxonomy.cdm.vaadin.component.CollectionRowItemCollection;
     import eu.etaxonomy.cdm.vaadin.event.EntityChangeEvent;
     import eu.etaxonomy.cdm.vaadin.event.EntityChangeEventFilter;
     import eu.etaxonomy.cdm.vaadin.event.ToOneRelatedEntityButtonUpdater;
     import eu.etaxonomy.cdm.vaadin.event.ToOneRelatedEntityReloader;
     import eu.etaxonomy.cdm.vaadin.model.registration.RegistrationTermLists;
-...
      * @since Jun 13, 2017
+     *
      */
     @SpringComponent
     @Scope("prototype")
     public class SpecimenTypeDesignationWorkingsetEditorPresenter
         extends AbstractEditorPresenter<SpecimenTypeDesignationWorkingSetDTO , SpecimenTypeDesignationWorkingsetPopupEditorView>
         implements CachingPresenter {
-...
             return store;
+        }
         /**
          * Loads an existing working set from the database. This process actually involves
          * loading the Registration specified by the <code>RegistrationAndWorkingsetId.registrationId</code> and in
-...
             collectionPopupEditor.loadInEditor(collectionId);
+        }
         @EventListener(condition = "#event.entityType == T(eu.etaxonomy.cdm.model.occurrence.Collection)")
         @EventBusListenerMethod(filter = EntityChangeEventFilter.OccurrenceCollectionFilter.class)
         public void onCollectionEvent(EntityChangeEvent event){
             Collection newCollection = getRepo().getCollectionService().load(event.getEntityId(), Arrays.asList(new String[]{"$.institute"}));
             Collection newCollection = getRepo().getCollectionService().load(
                     event.getEntityId(), Arrays.asList(new String[]{"$.institute"})
                     );
             cache.load(newCollection);
             for( CollectionRowItemCollection row : collectionPopuEditorSourceRows) {
-...
             referencePopupEditor.loadInEditor(referenceId);
+        }
         @EventListener(condition = "#event.entityType == T(eu.etaxonomy.cdm.model.reference.Reference)")
         @EventBusListenerMethod(filter = EntityChangeEventFilter.ReferenceFilter.class)
         public void onReferenceEvent(EntityChangeEvent event){
             Reference newRef = getRepo().getReferenceService().load(event.getEntityId(), Arrays.asList(new String[]{"$"}));

     import java.util.Collection;
     import java.util.EnumSet;
     import org.springframework.context.annotation.Scope;
     import org.springframework.security.core.GrantedAuthority;
     import org.vaadin.viritin.fields.ElementCollectionField;
     import com.vaadin.data.validator.DoubleRangeValidator;
     import com.vaadin.spring.annotation.SpringComponent;
     import com.vaadin.ui.AbstractSelect.ItemCaptionMode;
     import com.vaadin.ui.Component;
     import com.vaadin.ui.GridLayout;
-...
      * @since May 15, 2017
+     *
      */
     @SpringComponent
     @Scope("prototype")
     public class SpecimenTypeDesignationWorkingsetPopupEditor
         extends AbstractPopupEditor<SpecimenTypeDesignationWorkingSetDTO, SpecimenTypeDesignationWorkingsetEditorPresenter>
         implements SpecimenTypeDesignationWorkingsetPopupEditorView, AccessRestrictedView, PerEntityAuthorityGrantingEditor {

     import org.apache.log4j.Logger;
     import org.hibernate.criterion.Restrictions;
     import org.springframework.context.event.EventListener;
     import org.springframework.context.annotation.Scope;
     import org.vaadin.spring.events.annotation.EventBusListenerMethod;
     import com.vaadin.spring.annotation.SpringComponent;
     import com.vaadin.ui.AbstractField;
     import eu.etaxonomy.cdm.api.service.INameService;
-...
     import eu.etaxonomy.cdm.persistence.hibernate.permission.CRUD;
     import eu.etaxonomy.cdm.service.CdmFilterablePagingProvider;
     import eu.etaxonomy.cdm.vaadin.component.CdmBeanItemContainerFactory;
     import eu.etaxonomy.cdm.vaadin.event.EditorActionTypeFilter;
     import eu.etaxonomy.cdm.vaadin.event.ReferenceEditorAction;
     import eu.etaxonomy.cdm.vaadin.event.TaxonNameEditorAction;
     import eu.etaxonomy.cdm.vaadin.event.ToOneRelatedEntityButtonUpdater;
-...
      * @since May 22, 2017
+     *
      */
     @SpringComponent
     @Scope("prototype")
     public class TaxonNameEditorPresenter extends AbstractCdmEditorPresenter<TaxonName, TaxonNamePopupEditorView> {
         /**
-...
             return getRepo().getNameService();
+        }
         @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).ADD")
         @EventBusListenerMethod(filter = EditorActionTypeFilter.Add.class)
         public void onReferenceEditorActionAdd(ReferenceEditorAction event) {
             if(getView() == null || event.getSourceView() != getView() ){
                 return;
+            }
             referenceEditorPopup = getNavigationManager().showInPopup(ReferencePopupEditor.class);
             referenceEditorPopup.grantToCurrentUser(EnumSet.of(CRUD.UPDATE, CRUD.DELETE));
-...
+            }
+        }
         @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).EDIT")
         @EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)
         public void onReferenceEditorActionEdit(ReferenceEditorAction event) {
             if(getView() == null || event.getSourceView() != getView() ){
                 return;
+            }
-...
+            }
+        }
         @EventListener
         @EventBusListenerMethod
         public void onDoneWithPopupEvent(DoneWithPopupEvent event){
             if(event.getPopup() == referenceEditorPopup){
-...
+            }
+        }
         @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).EDIT")
         @EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)
         public void onTaxonNameEditorActionEdit(TaxonNameEditorAction event) {
             if(getView() == null || event.getSourceView() != getView() ){
                 return;
+            }
             basionymSourceField = (AbstractField<TaxonName>)event.getSourceComponent();
             basionymNamePopup = getNavigationManager().showInPopup(TaxonNamePopupEditor.class);
-...
+        }
         @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).ADD")
         @EventBusListenerMethod(filter = EditorActionTypeFilter.Add.class)
         public void onReferenceEditorActionAdd(TaxonNameEditorAction event) {
             if(getView() == null || event.getSourceView() != getView() ){
                 return;
+            }
             basionymSourceField = (AbstractField<TaxonName>)event.getSourceComponent();
             basionymNamePopup = getNavigationManager().showInPopup(TaxonNamePopupEditor.class);

     import java.util.EnumSet;
     import org.apache.commons.lang3.BooleanUtils;
     import org.springframework.context.annotation.Scope;
     import org.springframework.security.core.GrantedAuthority;
     import com.vaadin.shared.ui.label.ContentMode;
     import com.vaadin.spring.annotation.SpringComponent;
     import com.vaadin.ui.Alignment;
     import com.vaadin.ui.CheckBox;
     import com.vaadin.ui.GridLayout;
-...
      * @since May 22, 2017
+     *
      */
     @SpringComponent
     @Scope("prototype")
     public class TaxonNamePopupEditor extends AbstractCdmPopupEditor<TaxonName, TaxonNameEditorPresenter> implements TaxonNamePopupEditorView, AccessRestrictedView {
         private static final long serialVersionUID = -7037436241474466359L;
-...
             row++;
             nomReferenceCombobox = new ToOneRelatedEntityCombobox<Reference>("Nomenclatural reference", Reference.class);
             nomReferenceCombobox.addClickListenerAddEntity(e -> getEventBus().publishEvent(
             nomReferenceCombobox.addClickListenerAddEntity(e -> getViewEventBus().publish(this,
                     new ReferenceEditorAction(EditorActionType.ADD, null, nomReferenceCombobox, this)
                     ));
             nomReferenceCombobox.addClickListenerEditEntity(e -> {
                 if(nomReferenceCombobox.getValue() != null){
                     getEventBus().publishEvent(
                     getViewEventBus().publish(this,
                         new ReferenceEditorAction(
                                 EditorActionType.EDIT,
                                 nomReferenceCombobox.getValue().getId(),
-...
                     beanId = ((CdmBase)fieldValue).getId();
+                }
                 eventBus.publishEvent(new TaxonNameEditorAction(e.getAction(), beanId, e.getSource(), this));
                 getViewEventBus().publish(this, new TaxonNameEditorAction(e.getAction(), beanId, e.getSource(), this));
             });
             grid.setComponentAlignment(basionymsComboboxSelect, Alignment.TOP_RIGHT);
             row++;

     import java.util.Arrays;
     import java.util.List;
     import org.springframework.context.event.EventListener;
     import org.springframework.context.annotation.Scope;
     import org.vaadin.spring.events.annotation.EventBusListenerMethod;
     import com.vaadin.spring.annotation.SpringComponent;
     import eu.etaxonomy.cdm.api.service.IService;
     import eu.etaxonomy.cdm.model.occurrence.Collection;
     import eu.etaxonomy.cdm.service.CdmFilterablePagingProvider;
     import eu.etaxonomy.cdm.vaadin.event.CollectionEditorAction;
     import eu.etaxonomy.cdm.vaadin.event.EditorActionTypeFilter;
     import eu.etaxonomy.cdm.vaadin.event.ToOneRelatedEntityReloader;
     import eu.etaxonomy.cdm.vaadin.security.UserHelper;
     import eu.etaxonomy.vaadin.mvp.AbstractCdmEditorPresenter;
-...
      * @since Dec 21, 2017
+     *
      */
     @SpringComponent
     @Scope("prototype")
     public class CollectionEditorPresenter extends AbstractCdmEditorPresenter<Collection, CollectionPopupEditorView> {
         private static final long serialVersionUID = -1996365248431425021L;
         private CollectionPopupEditor collectionPopuEditor;
         /**
          * {@inheritDoc}
          */
-...
             getView().getSuperCollectionCombobox().getSelect().addValueChangeListener(new ToOneRelatedEntityReloader<Collection>(getView().getSuperCollectionCombobox(),this));
+        }
         @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).ADD")
         @EventBusListenerMethod(filter = EditorActionTypeFilter.Add.class)
         public void onCollectionEditorActionAdd(CollectionEditorAction event) {
             if(!checkFromOwnView(event)){
-...
             collectionPopuEditor.loadInEditor(null);
+        }
         @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).EDIT")
         @EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)
         public void onCollectionEditorActionEdit(CollectionEditorAction event) {
             if(!checkFromOwnView(event)){
-...
             collectionPopuEditor.loadInEditor(event.getEntityId());
+        }
         @EventBusListenerMethod()
         public void onDoneWithPopupEvent(DoneWithPopupEvent event){
             if(event.getPopup() == collectionPopuEditor){
                 if(event.getReason() == Reason.SAVE){

     */
     package eu.etaxonomy.cdm.vaadin.view.occurrence;
     import org.springframework.context.annotation.Scope;
     import org.springframework.security.core.GrantedAuthority;
     import com.vaadin.spring.annotation.SpringComponent;
     import com.vaadin.ui.GridLayout;
     import com.vaadin.ui.TextField;
-...
      * @since Dec 21, 2017
+     *
      */
     @SpringComponent
     @Scope("prototype")
     public class CollectionPopupEditor extends AbstractCdmPopupEditor<Collection, CollectionEditorPresenter> implements CollectionPopupEditorView, AccessRestrictedView {
         private static final long serialVersionUID = 2019724189877425882L;
-...
             row++;
             superCollectionCombobox = new ToOneRelatedEntityCombobox<Collection>("Super-collection", Collection.class);
             superCollectionCombobox.addClickListenerAddEntity(e -> getEventBus().publishEvent(
             superCollectionCombobox.addClickListenerAddEntity(e -> getViewEventBus().publish(this,
                     new CollectionEditorAction(EditorActionType.ADD, null, superCollectionCombobox, this)
                     ));
             superCollectionCombobox.addClickListenerEditEntity(e -> {
                 if(superCollectionCombobox.getValue() != null){
                     getEventBus().publishEvent(
                     getViewEventBus().publish(this,
                         new CollectionEditorAction(
                                 EditorActionType.EDIT,
                                 superCollectionCombobox.getValue().getId(),
-...
                     new ToOneRelatedEntityButtonUpdater<Collection>(superCollectionCombobox)
                     );
             superCollectionCombobox.addClickListenerAddEntity( e -> getEventBus().publishEvent(
             superCollectionCombobox.addClickListenerAddEntity( e -> getViewEventBus().publish(this,
                     new CollectionEditorAction(
                             EditorActionType.ADD,
                             null,
-...
                     ));
             superCollectionCombobox.addClickListenerEditEntity(e -> {
                     if(superCollectionCombobox.getValue() != null){
                         getEventBus().publishEvent(
                         getViewEventBus().publish(this,
                                 new CollectionEditorAction(
                                     EditorActionType.EDIT,
                                     superCollectionCombobox.getValue().getId(),

     import java.util.List;
     import org.apache.log4j.Logger;
     import org.springframework.context.event.EventListener;
     import org.springframework.context.annotation.Scope;
     import org.vaadin.spring.events.annotation.EventBusListenerMethod;
     import org.vaadin.viritin.fields.CaptionGenerator;
     import com.vaadin.spring.annotation.SpringComponent;
     import eu.etaxonomy.cdm.api.service.IService;
     import eu.etaxonomy.cdm.model.agent.AgentBase;
     import eu.etaxonomy.cdm.model.agent.Person;
-...
      * @since Apr 5, 2017
+     *
      */
     @SpringComponent
     @Scope("prototype")
     public class ReferenceEditorPresenter extends AbstractCdmEditorPresenter<Reference, ReferencePopupEditorView> {
         private static final long serialVersionUID = -7926116447719010837L;
-...
+        }
         /**
          * {@inheritDoc}
          */
-...
         * @param editorAction
          * @throws EditorEntityBeanException
         */
        @EventListener(condition = "#editorAction.sourceComponent != null")
        @EventBusListenerMethod
        public void onReferenceEditorAction(ReferenceEditorAction editorAction) {
            if(!isFromOwnView(editorAction)){
            if(!isFromOwnView(editorAction) || editorAction.getSourceComponent() == null){
                return;
+           }
            if(ToOneRelatedEntityField.class.isAssignableFrom(editorAction.getSourceComponent().getClass())){
                if(editorAction.isAddAction()){
                    inReferencePopup = getNavigationManager().showInPopup(ReferencePopupEditor.class);
-...
+           }
+       }
        @EventListener
        @EventBusListenerMethod
        public void doDoneWithPopupEvent(DoneWithPopupEvent event){
            if(event.getPopup().equals(inReferencePopup)){

     import java.util.Collection;
     import java.util.EnumSet;
     import org.springframework.context.annotation.Scope;
     import org.springframework.security.core.GrantedAuthority;
     import com.vaadin.spring.annotation.SpringComponent;
     import com.vaadin.ui.Alignment;
     import com.vaadin.ui.GridLayout;
     import com.vaadin.ui.ListSelect;
-...
      * @since Apr 4, 2017
+     *
      */
     @SpringComponent
     @Scope("prototype")
     public class ReferencePopupEditor extends AbstractCdmPopupEditor<Reference, ReferenceEditorPresenter> implements ReferencePopupEditorView, AccessRestrictedView {
         private static final long serialVersionUID = -4347633563800758815L;
-...
             inReferenceCombobox = new ToOneRelatedEntityCombobox<Reference>("In-reference", Reference.class);
             inReferenceCombobox.setWidth(100, Unit.PERCENTAGE);
             inReferenceCombobox.addClickListenerAddEntity(e -> getEventBus().publishEvent(
             inReferenceCombobox.addClickListenerAddEntity(e -> getViewEventBus().publish(this,
                     new ReferenceEditorAction(EditorActionType.ADD, null, inReferenceCombobox, this)
                     ));
             inReferenceCombobox.addClickListenerEditEntity(e -> {
                 if(inReferenceCombobox.getValue() != null){
                     getEventBus().publishEvent(
                     getViewEventBus().publish(this,
                         new ReferenceEditorAction(
                                 EditorActionType.EDIT,
                                 inReferenceCombobox.getValue().getId(),

     package eu.etaxonomy.cdm.vaadin.view.registration;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.context.ApplicationEventPublisher;
     import org.vaadin.spring.events.EventBus;
     import com.vaadin.navigator.View;
     import com.vaadin.navigator.ViewChangeListener.ViewChangeEvent;
-...
         private static final long serialVersionUID = -6172448806905158782L;
         @Autowired
         ApplicationEventPublisher eventBus;
         protected EventBus.UIEventBus uiEventBus;
         public DashBoardView() {
             Responsive.makeResponsive(dashboard);
             buttonNew.addClickListener(e -> eventBus.publishEvent(new NavigationEvent(StartRegistrationViewBean.NAME)));
             buttonContinue.addClickListener(e -> eventBus.publishEvent(new NavigationEvent(ListViewBean.NAME + "/" + ListView.Mode.inProgress.name())));
             buttonList.addClickListener(e -> eventBus.publishEvent(new NavigationEvent(ListViewBean.NAME + "/" + ListViewBean.Mode.all.name())));
             buttonNew.addClickListener(e -> uiEventBus.publish(this, new NavigationEvent(StartRegistrationViewBean.NAME)));
             buttonContinue.addClickListener(e -> uiEventBus.publish(this, new NavigationEvent(ListViewBean.NAME + "/" + ListView.Mode.inProgress.name())));
             buttonList.addClickListener(e -> uiEventBus.publish(this, new NavigationEvent(ListViewBean.NAME + "/" + ListViewBean.Mode.all.name())));
+        }
         /**

     import org.apache.commons.lang3.StringUtils;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.context.event.EventListener;
     import org.springframework.security.core.Authentication;
     import org.vaadin.spring.events.annotation.EventBusListenerMethod;
     import com.vaadin.spring.annotation.SpringComponent;
     import com.vaadin.spring.annotation.ViewScope;
-...
             return workingSetService;
+        }
         @Override
         public void handleViewEntered() {
-...
             return dtoPager;
+        }
         @EventListener(classes=ShowDetailsEvent.class, condition = "#event.type == T(eu.etaxonomy.cdm.vaadin.view.registration.RegistrationDTO)")
         public void onShowDetailsEvent(ShowDetailsEvent<?,?> event) { // WARNING don't use more specific generic type arguments
             RegistrationDTO regDto = getWorkingSetService().loadDtoById((Integer)event.getIdentifier());
             if(event.getProperty().equals("messages")){
                 if(getView() != null){
                     getView().openDetailsPopup("Messages", regDto.getMessages());
         @EventBusListenerMethod
         public void onShowDetailsEvent(ShowDetailsEvent<?,?> event) {
             if(event.getEntityType().equals(RegistrationDTO.class)){
                 RegistrationDTO regDto = getWorkingSetService().loadDtoById((Integer)event.getIdentifier());
                 if(event.getProperty().equals("messages")){
                     if(getView() != null){
                         getView().openDetailsPopup("Messages", regDto.getMessages());
+                    }
+                }
+            }
+        }
         @EventListener
         @EventBusListenerMethod
         public void onEntityChangeEvent(EntityChangeEvent event){
             if(event.getEntityType().isAssignableFrom(Reference.class)){
                 // TODO update component showing the according reference, is there a Vaadin event supporting this?
+            }
+        }
         @EventListener
         @EventBusListenerMethod
         public void onUpdateResultsEvent(UpdateResultsEvent event){
             getView().populate(pageRegistrations(event.getField(), event.getNewText()));
+        }

          * @return
          */
         private void updateResults(TextField field, String newText) {
             eventBus.publishEvent(new UpdateResultsEvent(field, newText, this));
             getViewEventBus().publish(this, new UpdateResultsEvent(field, newText, this));
+        }
         @Override

     import java.util.Arrays;
     import java.util.List;
     import org.springframework.context.annotation.Scope;
     import com.vaadin.spring.annotation.SpringComponent;
     import eu.etaxonomy.cdm.api.service.IRegistrationService;
     import eu.etaxonomy.cdm.model.agent.Institution;
     import eu.etaxonomy.cdm.model.common.User;
-...
      * @since May 15, 2017
+     *
      */
     @SpringComponent
     @Scope("prototype")
     public class RegistrationEditorPresenter extends AbstractCdmEditorPresenter<Registration, RegistrationPopEditorView> {
         private static final long serialVersionUID = 6930557602995331944L;

     import java.util.Arrays;
     import java.util.Collection;
     import org.springframework.context.annotation.Scope;
     import org.springframework.security.core.GrantedAuthority;
     import com.vaadin.spring.annotation.SpringComponent;
     import com.vaadin.ui.DateField;
     import com.vaadin.ui.FormLayout;
     import com.vaadin.ui.ListSelect;
-...
      * @since May 15, 2017
+     *
      */
     @SpringComponent
     @Scope("prototype")
     public class RegistrationPopupEditor extends AbstractCdmPopupEditor<Registration, RegistrationEditorPresenter>
         implements RegistrationPopEditorView, AccessRestrictedView {

     import org.hibernate.Session;
     import org.hibernate.Transaction;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.context.event.EventListener;
     import org.springframework.security.core.Authentication;
     import org.springframework.transaction.TransactionStatus;
     import org.vaadin.spring.events.annotation.EventBusListenerMethod;
     import com.vaadin.spring.annotation.SpringComponent;
     import com.vaadin.spring.annotation.ViewScope;
-...
     import eu.etaxonomy.cdm.service.CdmFilterablePagingProvider;
     import eu.etaxonomy.cdm.service.CdmStore;
     import eu.etaxonomy.cdm.service.IRegistrationWorkingSetService;
     import eu.etaxonomy.cdm.vaadin.event.EditorActionTypeFilter;
     import eu.etaxonomy.cdm.vaadin.event.EntityChangeEvent;
     import eu.etaxonomy.cdm.vaadin.event.ReferenceEditorAction;
     import eu.etaxonomy.cdm.vaadin.event.RegistrationEditorAction;
     import eu.etaxonomy.cdm.vaadin.event.ShowDetailsEvent;
     import eu.etaxonomy.cdm.vaadin.event.ShowDetailsEventEntityTypeFilter;
     import eu.etaxonomy.cdm.vaadin.event.TaxonNameEditorAction;
     import eu.etaxonomy.cdm.vaadin.event.TypeDesignationWorkingsetEditorAction;
     import eu.etaxonomy.cdm.vaadin.event.registration.RegistrationWorkingsetAction;
-...
         public RegistrationWorkingsetPresenter() {
+        }
         /**
          * Always create a new Store
+         *
-...
+            }
+        }
         @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).ADD")
         @EventBusListenerMethod(filter = EditorActionTypeFilter.Add.class)
         public void onReferenceEditorActionAdd(ReferenceEditorAction event) {
             if(!checkFromOwnView(event)){
-...
             popup.loadInEditor(null);
+        }
         @EventListener(condition = "#event.type == T(eu.etaxonomy.vaadin.event.EditorActionType).EDIT")
         @EventBusListenerMethod(filter = EditorActionTypeFilter.Edit.class)
         public void onReferenceEditorActionEdit(ReferenceEditorAction event) {
             if(!checkFromOwnView(event)){
-...
             popup.loadInEditor(event.getEntityId());
+        }
         @EventListener
         @EventBusListenerMethod
         public void onDoneWithReferencePopupEditor(DoneWithPopupEvent event) throws RegistrationValidationException{
             if(event.getPopup() instanceof ReferencePopupEditor){
                 if(event.getReason().equals(Reason.SAVE)){
-...
+            }
+        }
         @EventListener
         @EventBusListenerMethod

Project

General

Profile

EDIT

Revision be4a9789

Added by Andreas Kohlbecker about 6 years ago

Project

General

Profile

EDIT

Revision be4a9789

Added by Andreas Kohlbecker about 6 years ago

Related issues