src/main/java/eu/etaxonomy/cdm/vaadin/view/registration/RegistrationWorksetViewBean.java

   1 /**
   2 * Copyright (C) 2017 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 package eu.etaxonomy.cdm.vaadin.view.registration;
  10
  11 import static eu.etaxonomy.cdm.vaadin.component.registration.RegistrationStyles.LABEL_NOWRAP;
  12
  13 import java.util.ArrayList;
  14 import java.util.Collection;
  15 import java.util.Collections;
  16 import java.util.EnumSet;
  17 import java.util.HashMap;
  18 import java.util.Iterator;
  19 import java.util.List;
  20 import java.util.Map;
  21 import java.util.Set;
  22 import java.util.Stack;
  23 import java.util.UUID;
  24
  25 import org.springframework.security.core.GrantedAuthority;
  26 import org.vaadin.viritin.fields.LazyComboBox;
  27
  28 import com.vaadin.navigator.View;
  29 import com.vaadin.navigator.ViewChangeListener.ViewChangeEvent;
  30 import com.vaadin.server.FontAwesome;
  31 import com.vaadin.server.Page;
  32 import com.vaadin.shared.ui.label.ContentMode;
  33 import com.vaadin.spring.annotation.SpringView;
  34 import com.vaadin.ui.Alignment;
  35 import com.vaadin.ui.Button;
  36 import com.vaadin.ui.Component;
  37 import com.vaadin.ui.CssLayout;
  38 import com.vaadin.ui.GridLayout;
  39 import com.vaadin.ui.HorizontalLayout;
  40 import com.vaadin.ui.Label;
  41 import com.vaadin.ui.Notification;
  42 import com.vaadin.ui.Panel;
  43 import com.vaadin.ui.UI;
  44 import com.vaadin.ui.VerticalLayout;
  45 import com.vaadin.ui.Window;
  46 import com.vaadin.ui.themes.ValoTheme;
  47
  48 import eu.etaxonomy.cdm.api.service.dto.RegistrationDTO;
  49 import eu.etaxonomy.cdm.api.service.dto.RegistrationWorkingSet;
  50 import eu.etaxonomy.cdm.api.service.name.TypeDesignationSet.TypeDesignationSetType;
  51 import eu.etaxonomy.cdm.api.util.RoleProberImpl;
  52 import eu.etaxonomy.cdm.model.common.VersionableEntity;
  53 import eu.etaxonomy.cdm.model.name.Registration;
  54 import eu.etaxonomy.cdm.model.name.RegistrationStatus;
  55 import eu.etaxonomy.cdm.model.name.TaxonName;
  56 import eu.etaxonomy.cdm.model.permission.CRUD;
  57 import eu.etaxonomy.cdm.ref.EntityReference;
  58 import eu.etaxonomy.cdm.ref.TypedEntityReference;
  59 import eu.etaxonomy.cdm.service.UserHelperAccess;
  60 import eu.etaxonomy.cdm.vaadin.component.BadgeButton;
  61 import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItem;
  62 import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItemButtons;
  63 import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItemNameAndTypeButtons;
  64 import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItemNameAndTypeButtons.TypeDesignationSetButton;
  65 import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationItemsPanel;
  66 import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationStatusFieldInstantiator;
  67 import eu.etaxonomy.cdm.vaadin.component.registration.RegistrationStatusLabel;
  68 import eu.etaxonomy.cdm.vaadin.event.EditorActionContext;
  69 import eu.etaxonomy.cdm.vaadin.event.RegistrationEditorAction;
  70 import eu.etaxonomy.cdm.vaadin.event.ShowDetailsEvent;
  71 import eu.etaxonomy.cdm.vaadin.event.TaxonNameEditorAction;
  72 import eu.etaxonomy.cdm.vaadin.event.TypeDesignationSetEditorAction;
  73 import eu.etaxonomy.cdm.vaadin.event.registration.RegistrationWorkingsetAction;
  74 import eu.etaxonomy.cdm.vaadin.permission.AccessRestrictedView;
  75 import eu.etaxonomy.cdm.vaadin.permission.PermissionDebugUtils;
  76 import eu.etaxonomy.cdm.vaadin.permission.RolesAndPermissions;
  77 import eu.etaxonomy.cdm.vaadin.theme.EditValoTheme;
  78 import eu.etaxonomy.cdm.vaadin.view.AbstractPageView;
  79 import eu.etaxonomy.vaadin.event.EditorActionType;
  80
  81 /**
  82  * @author a.kohlbecker
  83  * @since Mar 2, 2017
  84  */
  85 @SpringView(name=RegistrationWorksetViewBean.NAME)
  86 public class RegistrationWorksetViewBean
  87         extends AbstractPageView<RegistrationWorkingsetPresenter>
  88         implements RegistrationWorkingsetView, View, AccessRestrictedView {
  89
  90     private static final long serialVersionUID = -213040114015958970L;
  91
  92     private static final int COL_INDEX_STATE_LABEL = 0;
  93
  94     private static final int COL_INDEX_REG_ITEM = 1;
  95
  96     private static final int COL_INDEX_BUTTON_GROUP = 2;
  97
  98     public static final String DOM_ID_WORKINGSET = "workingset";
  99
 100     public static final String TEXT_NAME_TYPIFICATION = "covering the name and typifications";
 101     public static final String TEXT_TYPIFICATION_ONLY = "covering typifications only";
 102
 103     public static final String NAME = "workingset";
 104
 105     private List<CssLayout> registrations = new ArrayList<>();
 106
 107     private String headerText = "Registration Workingset Editor";
 108     private String subheaderText = "";
 109
 110     private UUID citationUuid;
 111
 112     private GridLayout registrationsGrid;
 113
 114     private RegistrationItem workingsetHeader;
 115
 116     private Panel registrationListPanel;
 117
 118     private Button addNewNameRegistrationButton;
 119
 120     private Button addExistingNameButton;
 121
 122     private LazyComboBox<TaxonName> existingNameCombobox;
 123
 124     private Label existingNameRegistrationTypeLabel;
 125
 126     /**
 127      * uses the registrationId as key
 128      */
 129     private Map<UUID, RegistrationDetailsItem> registrationItemMap = new HashMap<>();
 130
 131     /**
 132      * uses the registrationId as key
 133      */
 134     private Map<UUID, EntityReference> typifiedNamesMap = new HashMap<>();
 135
 136     private RegistrationStatusFieldInstantiator statusFieldInstantiator;
 137
 138     private String accessDeniedMessage;
 139
 140     private Object existingNameEditor;
 141
 142     public RegistrationWorksetViewBean() {
 143         super();
 144     }
 145
 146     @Override
 147     protected void initContent() {
 148         getLayout().setId(NAME);
 149         updateHeader();
 150         // all content is added in createRegistrationsList()
 151     }
 152
 153     @Override
 154     public void enter(ViewChangeEvent event) {
 155         if(event.getParameters() != null){
 156             this.citationUuid = UUID.fromString(event.getParameters());
 157
 158             getPresenter().handleViewEntered();
 159         }
 160     }
 161
 162     @Override
 163     public void setWorkingset(RegistrationWorkingSet workingset) {
 164
 165         if(workingsetHeader != null){
 166             getLayout().removeComponent(workingsetHeader);
 167             getLayout().removeComponent(registrationListPanel);
 168         }
 169         workingsetHeader = new RegistrationItem(workingset, this, getPresenter().getCache());
 170         addContentComponent(workingsetHeader, null);
 171
 172         registrationListPanel = createRegistrationsList(workingset);
 173         registrationListPanel.setHeight("100%");
 174         registrationListPanel.setStyleName("registration-list");
 175         registrationListPanel.setCaption("Registrations");
 176         addContentComponent(registrationListPanel, 1.0f);
 177     }
 178
 179     @Override
 180     public void setBlockingRegistrations(UUID registrationUuid, Set<RegistrationDTO> blockingRegDTOs) {
 181
 182         RegistrationDetailsItem regItem = registrationItemMap.get(registrationUuid);
 183
 184         boolean blockingRegAdded = false;
 185         for(Iterator it = regItem.itemFooter.iterator(); it.hasNext(); ){
 186             if(it.next() instanceof RegistrationItemsPanel){
 187                 blockingRegAdded = true;
 188                 break;
 189             }
 190         }
 191         if(!blockingRegAdded){
 192             regItem.itemFooter.addComponent(new RegistrationItemsPanel(this, "Blocked by", blockingRegDTOs, getPresenter().getCache()));
 193         }
 194     }
 195
 196     @Override
 197     @Deprecated // no longer needed
 198     public void addBlockingRegistration(RegistrationDTO blocking) {
 199         if(registrations == null) {
 200             throw new RuntimeException("A Workingset must be present prior adding blocking registrations.");
 201         }
 202         // add the blocking registration
 203
 204     }
 205
 206     public Panel createRegistrationsList(RegistrationWorkingSet workingset) {
 207
 208         registrationsGrid = new GridLayout(3, 1);
 209         registrationsGrid.setWidth("100%");
 210         // allow vertical scrolling:
 211         registrationsGrid.setHeightUndefined();
 212
 213         //registrationsGrid.setColumnExpandRatio(0, 0.1f);
 214         registrationsGrid.setColumnExpandRatio(1, 1f);
 215
 216         registrationItemMap.clear();
 217         registrationsGrid.setRows(workingset.getRegistrationDTOs().size() * 2  + 3);
 218         int row = 0;
 219         for(RegistrationDTO dto : workingset.getRegistrationDTOs()) {
 220             row = putRegistrationListComponent(row, dto);
 221         }
 222
 223         // --- Footer with UI to create new registrations ----
 224         Label addRegistrationLabel_1 = new Label("Add a new registration for a");
 225         Label addRegistrationLabel_2 = new Label("or an");
 226
 227         addNewNameRegistrationButton = new Button("new name");
 228         addNewNameRegistrationButton.setDescription("A name which is newly published in this publication.");
 229         Stack<EditorActionContext> context = new Stack<EditorActionContext>();
 230         context.push(new EditorActionContext(
 231                     new TypedEntityReference<>(Registration.class, null),
 232                     this)
 233                     );
 234         addNewNameRegistrationButton.addClickListener(
 235                 e -> {
 236                     getViewEventBus().publish(this, new TaxonNameEditorAction(EditorActionType.ADD, null, addNewNameRegistrationButton, null, this, context));
 237                 }
 238         );
 239
 240         existingNameRegistrationTypeLabel = new Label();
 241         addExistingNameButton = new Button("existing name:");
 242         addExistingNameButton.setEnabled(false);
 243         addExistingNameButton.addClickListener(e -> reviewExistingName());
 244
 245         existingNameCombobox = new LazyComboBox<TaxonName>(TaxonName.class);
 246         existingNameCombobox.addValueChangeListener(
 247                 e -> {
 248                     boolean selectionNotEmpty = e.getProperty().getValue() != null;
 249                     addExistingNameButton.setEnabled(false);
 250                     existingNameRegistrationTypeLabel.setValue(null);
 251                     if(selectionNotEmpty){
 252                         TaxonName name = (TaxonName)e.getProperty().getValue();
 253                         if(getPresenter().canCreateNameRegistrationFor(name)){
 254                             existingNameRegistrationTypeLabel.setValue(TEXT_NAME_TYPIFICATION);
 255                             addExistingNameButton.setEnabled(true);
 256                         } else {
 257                             if(!getPresenter().checkWokingsetContainsProtologe(name)){
 258                                 existingNameRegistrationTypeLabel.setValue(TEXT_TYPIFICATION_ONLY);
 259                                 addExistingNameButton.setEnabled(true);
 260                             }
 261                         }
 262                     } else {
 263                         existingNameRegistrationTypeLabel.setValue(null);
 264                     }
 265                 }
 266                 );
 267
 268         HorizontalLayout buttonContainer = new HorizontalLayout(
 269                 addRegistrationLabel_1,
 270                 addNewNameRegistrationButton,
 271                 addRegistrationLabel_2,
 272                 addExistingNameButton,
 273                 existingNameCombobox,
 274                 existingNameRegistrationTypeLabel
 275                 );
 276         buttonContainer.setSpacing(true);
 277 //        buttonContainer.setWidth(100, Unit.PERCENTAGE);
 278         buttonContainer.setComponentAlignment(addRegistrationLabel_1, Alignment.MIDDLE_LEFT);
 279         buttonContainer.setComponentAlignment(addRegistrationLabel_2, Alignment.MIDDLE_LEFT);
 280
 281         row++;
 282         registrationsGrid.addComponent(buttonContainer, 0, row, COL_INDEX_BUTTON_GROUP, row);
 283         registrationsGrid.setComponentAlignment(buttonContainer, Alignment.MIDDLE_RIGHT);
 284
 285         row++;
 286         Label hint = new Label(
 287                 "For most names that already exist in the system, it is only possible to create a registration covering type designations. "
 288                 + "In all other cases please choose <a href=\"registration#!regStart\">\"New\"</a> from the main menu and start a registration for the nomenclatural reference of the name to be registered.",
 289                 ContentMode.HTML);
 290         registrationsGrid.addComponent(hint, 0, row, COL_INDEX_BUTTON_GROUP, row);
 291         registrationsGrid.setComponentAlignment(hint, Alignment.MIDDLE_RIGHT);
 292
 293         Panel namesTypesPanel = new Panel(registrationsGrid);
 294         namesTypesPanel.setStyleName(EditValoTheme.PANEL_CONTENT_PADDING_LEFT);
 295         return namesTypesPanel;
 296     }
 297
 298     private void reviewExistingName() {
 299         // call commit to make the selection available
 300         existingNameCombobox.commit();
 301         TaxonName taxonName = existingNameCombobox.getValue();
 302         Stack<EditorActionContext> context = new Stack<>();
 303         context.push(new EditorActionContext(
 304                     TypedEntityReference.fromEntity(taxonName),
 305                     this)
 306                     );
 307         getViewEventBus().publish(
 308                 this,
 309                 new TaxonNameEditorAction(
 310                         EditorActionType.EDIT,
 311                         taxonName.getUuid(),
 312                         addExistingNameButton,
 313                         existingNameCombobox,
 314                         this,
 315                         context)
 316         );
 317
 318     }
 319
 320     /**
 321      * publishes an event to the {@link RegistrationWorkingsetPresenter}
 322      * @deprecated no longer used but kept for reference
 323      * TODO remove for version 5.8 when not used again.
 324      */
 325     @Deprecated
 326     private void triggerRegistrationForExistingName() {
 327         getViewEventBus().publish(this, new RegistrationWorkingsetAction(
 328                 citationUuid,
 329                 RegistrationWorkingsetAction.Action.start
 330                 )
 331         );
 332     }
 333
 334     protected int putRegistrationListComponent(int row, RegistrationDTO dto) {
 335
 336         EntityReference typifiedNameReference = dto.getTypifiedNameRef();
 337         if(typifiedNameReference == null){
 338             typifiedNameReference = dto.getNameRef();
 339         }
 340         typifiedNamesMap.put(dto.getUuid(), typifiedNameReference);
 341
 342         RegistrationItemNameAndTypeButtons regItemButtonGroup = new RegistrationItemNameAndTypeButtons(dto, getPresenter().getCache());
 343         UUID registrationEntityUuid = dto.getUuid();
 344
 345         RegistrationItemButtons regItemButtons = new RegistrationItemButtons();
 346
 347         CssLayout footer = new CssLayout();
 348         footer.setWidth(100, Unit.PERCENTAGE);
 349         footer.setStyleName("item-footer");
 350
 351         RegistrationDetailsItem regDetailsItem = new RegistrationDetailsItem(regItemButtonGroup, regItemButtons, footer);
 352         registrationItemMap.put(registrationEntityUuid, regDetailsItem);
 353
 354         Stack<EditorActionContext> context = new Stack<EditorActionContext>();
 355         context.push(new EditorActionContext(
 356                     new TypedEntityReference<>(Registration.class, registrationEntityUuid),
 357                     this)
 358                     );
 359
 360         if(regItemButtonGroup.getNameButton() != null){
 361             regItemButtonGroup.getNameButton().getButton().addClickListener(e -> {
 362                 UUID nameuUuid = regItemButtonGroup.getNameButton().getUuid();
 363                 getViewEventBus().publish(this, new TaxonNameEditorAction(
 364                     EditorActionType.EDIT,
 365                     nameuUuid,
 366                     e.getButton(),
 367                     null,
 368                     this,
 369                     context
 370                     )
 371                 );
 372             });
 373         }
 374
 375         for(TypeDesignationSetButton workingsetButton : regItemButtonGroup.getTypeDesignationButtons()){
 376             workingsetButton.getButton().addClickListener(e -> {
 377                 VersionableEntity baseEntity = workingsetButton.getBaseEntity();
 378                 EntityReference typifiedNameRef = typifiedNamesMap.get(registrationEntityUuid);
 379                 TypeDesignationSetType workingsetType = workingsetButton.getType();
 380                 getViewEventBus().publish(this, new TypeDesignationSetEditorAction(
 381                         baseEntity,
 382                         workingsetType,
 383                         registrationEntityUuid,
 384                         typifiedNameRef.getUuid(),
 385                         e.getButton(),
 386                         null,
 387                         this,
 388                         context
 389                         )
 390                     );
 391             });
 392         }
 393
 394         regItemButtonGroup.getAddTypeDesignationButton().addClickListener(
 395                 e -> chooseNewTypeRegistrationWorkingset(dto.getUuid())
 396                 );
 397
 398         Button blockingRegistrationButton = regItemButtons.getBlockingRegistrationButton();
 399         blockingRegistrationButton.setStyleName(ValoTheme.BUTTON_TINY);
 400         blockingRegistrationButton.setDescription("No blocking registrations");
 401         if(dto.isBlocked()){
 402             blockingRegistrationButton.setEnabled(true);
 403             blockingRegistrationButton.setDescription("This registration is currently blocked by other registrations");
 404             blockingRegistrationButton.addStyleName(EditValoTheme.BUTTON_HIGHLITE);
 405             blockingRegistrationButton.addClickListener(e -> getViewEventBus().publish(
 406                     this,
 407                     new ShowDetailsEvent<RegistrationDTO, UUID>(
 408                             e,
 409                             RegistrationDTO.class,
 410                             dto.getUuid(),
 411                             RegistrationItem.BLOCKED_BY
 412                             )
 413                     ));
 414         }
 415
 416         BadgeButton validationProblemsButton = regItemButtons.getValidationProblemsButton();
 417         validationProblemsButton.setStyleName(ValoTheme.BUTTON_TINY); //  + " " + RegistrationStyles.STYLE_FRIENDLY_FOREGROUND);
 418
 419         if(!dto.getValidationProblems().isEmpty()){
 420             validationProblemsButton.setEnabled(true);
 421             validationProblemsButton.addClickListener(e -> getViewEventBus().publish(this,
 422                     new ShowDetailsEvent<RegistrationDTO, UUID>(
 423                         e,
 424                         RegistrationDTO.class,
 425                         dto.getUuid(),
 426                         RegistrationItem.VALIDATION_PROBLEMS
 427                         )
 428                     )
 429                 );
 430         }
 431         int problemCount = dto.getValidationProblems().size();
 432         validationProblemsButton.setCaption(problemCount > 0 ? Integer.toString(problemCount) : null);
 433
 434         Component statusComponent;
 435         if(statusFieldInstantiator != null){
 436             statusComponent = statusFieldInstantiator.create(dto);
 437         } else {
 438             statusComponent = new RegistrationStatusLabel().update(dto.getStatus());
 439         }
 440         Label submitterLabel = new Label(dto.getSubmitterUserName());
 441         submitterLabel.setStyleName(LABEL_NOWRAP + " submitter");
 442         submitterLabel.setIcon(FontAwesome.USER);
 443         submitterLabel.setContentMode(ContentMode.HTML);
 444         CssLayout stateAndSubmitter = new CssLayout(statusComponent, submitterLabel);
 445
 446
 447         if(UserHelperAccess.userHelper().userIs(new RoleProberImpl(RolesAndPermissions.ROLE_CURATION)) || UserHelperAccess.userHelper().userIsAdmin()) {
 448
 449             Button editRegistrationButton = new Button(FontAwesome.COG);
 450             editRegistrationButton.setStyleName(ValoTheme.BUTTON_TINY);
 451             editRegistrationButton.setDescription("Edit registration");
 452             editRegistrationButton.addClickListener(e -> getViewEventBus().publish(this, new RegistrationEditorAction(
 453                 EditorActionType.EDIT,
 454                 dto.getUuid(),
 455                 e.getButton(),
 456                 null,
 457                 this
 458                 )));
 459
 460             Button unlockButton = new Button(FontAwesome.LOCK);
 461             unlockButton.setStyleName(ValoTheme.BUTTON_TINY);
 462             unlockButton.setDescription("Unlock");
 463             unlockButton.addClickListener(e -> {
 464                 regItemButtonGroup.setLockOverride(!regItemButtonGroup.isLockOverride());
 465                 if(regItemButtonGroup.isRegistrationLocked()){
 466                     unlockButton.setIcon(regItemButtonGroup.isLockOverride() ? FontAwesome.UNLOCK_ALT : FontAwesome.LOCK);
 467                     unlockButton.setDescription(regItemButtonGroup.isLockOverride() ? "Click to unlock editing" : "Click to lock editing");
 468                 }
 469             });
 470             unlockButton.setEnabled(regItemButtonGroup.isRegistrationLocked());
 471             regItemButtons.addComponents(unlockButton, editRegistrationButton);
 472         }
 473
 474         PermissionDebugUtils.addGainPerEntityPermissionButton(regItemButtons, Registration.class, dto.getUuid(),
 475                 EnumSet.of(CRUD.UPDATE), RegistrationStatus.PREPARATION.name());
 476
 477         row++;
 478         registrationsGrid.addComponent(stateAndSubmitter, COL_INDEX_STATE_LABEL, row);
 479         // registrationsGrid.setComponentAlignment(stateLabel, Alignment.TOP_LEFT);
 480         registrationsGrid.addComponent(regItemButtonGroup, COL_INDEX_REG_ITEM, row);
 481         registrationsGrid.addComponent(regItemButtons, COL_INDEX_BUTTON_GROUP, row);
 482         registrationsGrid.setComponentAlignment(regItemButtons, Alignment.TOP_LEFT);
 483
 484         row++;
 485         registrationsGrid.addComponent(footer, 0, row, COL_INDEX_BUTTON_GROUP, row);
 486
 487         return row;
 488     }
 489
 490     @Override
 491     public void chooseNewTypeRegistrationWorkingset(UUID registrationEntityUuid){
 492         Window typeDesignationTypeCooser = new Window();
 493         typeDesignationTypeCooser.setModal(true);
 494         typeDesignationTypeCooser.setResizable(false);
 495         typeDesignationTypeCooser.setCaption("Add new type designation");
 496         Label label = new Label("Please select kind of type designation to be created.");
 497         Button newSpecimenTypeDesignationButton = new Button("Specimen type designation",
 498                 e -> addNewTypeDesignationSet(TypeDesignationSetType.SPECIMEN_TYPE_DESIGNATION_SET, registrationEntityUuid, typeDesignationTypeCooser, e.getButton()));
 499         Button newNameTypeDesignationButton = new Button("Name type designation",
 500                 e -> addNewTypeDesignationSet(TypeDesignationSetType.NAME_TYPE_DESIGNATION_SET, registrationEntityUuid, typeDesignationTypeCooser, e.getButton()));
 501
 502         VerticalLayout layout = new VerticalLayout(label, newSpecimenTypeDesignationButton, newNameTypeDesignationButton);
 503         layout.setMargin(true);
 504         layout.setSpacing(true);
 505         layout.setComponentAlignment(newSpecimenTypeDesignationButton, Alignment.MIDDLE_CENTER);
 506         layout.setComponentAlignment(newNameTypeDesignationButton, Alignment.MIDDLE_CENTER);
 507         typeDesignationTypeCooser.setContent(layout);
 508         UI.getCurrent().addWindow(typeDesignationTypeCooser);
 509     }
 510
 511     protected void addNewTypeDesignationSet(TypeDesignationSetType newWorkingsetType, UUID registrationEntityUuid, Window typeDesignationTypeCooser, Button sourceButton) {
 512         UI.getCurrent().removeWindow(typeDesignationTypeCooser);
 513         EntityReference typifiedNameRef = typifiedNamesMap.get(registrationEntityUuid);
 514         getViewEventBus().publish(this, new TypeDesignationSetEditorAction(
 515                 newWorkingsetType,
 516                 registrationEntityUuid,
 517                 typifiedNameRef.getUuid(),
 518                 sourceButton,
 519                 null,
 520                 this
 521                 ));
 522     }
 523
 524     @Override
 525     public void openReferenceEditor(UUID referenceUuid) {
 526         // TODO Auto-generated method stub
 527     }
 528
 529     @Override
 530     public void openNameEditor(UUID nameUuid) {
 531         // TODO Auto-generated method stub
 532     }
 533
 534     @Override
 535     protected String getHeaderText() {
 536         return headerText;
 537     }
 538
 539     @Override
 540     public void setHeaderText(String text) {
 541         this.headerText = text;
 542         updateHeader();
 543     }
 544
 545     public String getSubheaderText() {
 546         return subheaderText;
 547     }
 548
 549     @Override
 550     public void setSubheaderText(String text) {
 551         subheaderText = text;
 552         updateHeader();
 553     }
 554
 555     @Override
 556     protected String getSubHeaderText() {
 557         return subheaderText;
 558     }
 559
 560     @Override
 561     public void openDetailsPopup(String caption, List<String> messages) {
 562         StringBuffer sb = new StringBuffer();
 563         sb.append("<div class=\"details-popup-content\">");
 564         messages.forEach(s -> sb.append(s).append("</br>"));
 565         sb.append("</div>");
 566         new Notification(caption, sb.toString(), Notification.Type.HUMANIZED_MESSAGE, true).show(Page.getCurrent());
 567     }
 568
 569     @Override
 570     public boolean allowAnonymousAccess() {
 571         return false;
 572     }
 573
 574     @Override
 575     public Collection<Collection<GrantedAuthority>> allowedGrantedAuthorities() {
 576         return null;
 577     }
 578
 579     @Override
 580     public String getAccessDeniedMessage() {
 581         return accessDeniedMessage;
 582     }
 583
 584     @Override
 585     public void setAccessDeniedMessage(String accessDeniedMessage) {
 586         this.accessDeniedMessage = accessDeniedMessage;
 587     }
 588
 589     /**
 590      * @return the addNewNameRegistrationButton
 591      */
 592     @Override
 593     public Button getAddNewNameRegistrationButton() {
 594         return addNewNameRegistrationButton;
 595     }
 596
 597     @Override
 598     public Button getAddExistingNameRegistrationButton() {
 599         return addExistingNameButton;
 600     }
 601
 602     @Override
 603     public LazyComboBox<TaxonName> getExistingNameCombobox() {
 604         return existingNameCombobox;
 605     }
 606
 607     @Override
 608     public UUID getCitationUuid() {
 609         return citationUuid;
 610     }
 611
 612     @Override
 613     public Map<UUID, RegistrationDetailsItem> getRegistrationItemMap(){
 614         return Collections.unmodifiableMap(registrationItemMap);
 615     }
 616
 617     /**
 618      * @param statusFieldInstantiator the statusFieldInstantiator to set
 619      */
 620     @Override
 621     public void setStatusComponentInstantiator(RegistrationStatusFieldInstantiator statusComponentInstantiator) {
 622         this.statusFieldInstantiator = statusComponentInstantiator;
 623     }
 624 }