EDIT

        "org.springframework.context.event",

        "eu.etaxonomy.cdm.ext.registration.messages.redmine" // FIXME needed???

    public static final String MESSAGES = "messages";

    private Button messageButton;

        messageButton = new Button(FontAwesome.COMMENT);

        CssLayout buttonGroup = new CssLayout(blockedByButton, messageButton, openButton);

        messageButton.setStyleName(ValoTheme.BUTTON_TINY);

        messageButton.setEnabled(false);

        updateUI(workingSet.getCitation(), workingSet.getCreated(), datePublished, workingSet.messagesCount(),

    private void updateUI(String citationString,  DateTime created, TimePeriod datePublished,  int messagesCount,

        if(messagesCount > 0){

            getMessageButton().setEnabled(true);

            getMessageButton().addClickListener(e -> {

            getMessageButton().setCaption("<span class=\"" + RegistrationStyles.BUTTON_BADGE +"\"> " + messagesCount + "</span>");

            getMessageButton().setCaptionAsHtml(true);

    public Button getMessageButton() {

        return messageButton;

    Button messagesButton;

          messagesButton = new Button(FontAwesome.COMMENT);

          messagesButton.setEnabled(false);

          addComponents(blockingRegistrationButton, validationProblemsButton, messagesButton);

    /**

     * @return the messagesButton

     */

    public Button getMessagesButton() {

        return messagesButton;

    }

    Button messageButton;

        messageButton = new Button(FontAwesome.COMMENT);

        messageButton.setEnabled(false);

        buttonGroup.addComponent(messageButton);

            messageButton.setVisible(true);

            messageButton.setVisible(false);

        if(event.getProperty().equals("messages")){

            getView().openDetailsPopup("Messages", regDto.getValidationProblems());

/**

* Copyright (C) 2017 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.view.registration;

import java.text.SimpleDateFormat;

import java.util.Collection;

import java.util.List;

import java.util.UUID;

import org.apache.commons.lang3.StringUtils;

import org.springframework.context.annotation.Scope;

import org.springframework.security.core.GrantedAuthority;

import com.vaadin.server.FontAwesome;

import com.vaadin.shared.ui.label.ContentMode;

import com.vaadin.spring.annotation.SpringComponent;

import com.vaadin.ui.Alignment;

import com.vaadin.ui.Button;

import com.vaadin.ui.HorizontalLayout;

import com.vaadin.ui.Label;

import com.vaadin.ui.Panel;

import com.vaadin.ui.TextArea;

import com.vaadin.ui.VerticalLayout;

import com.vaadin.ui.themes.ValoTheme;

import eu.etaxonomy.cdm.ext.registration.messages.Message;

import eu.etaxonomy.cdm.vaadin.event.error.DelegatingErrorHandler;

import eu.etaxonomy.cdm.vaadin.permission.AccessRestrictedView;

import eu.etaxonomy.cdm.vaadin.theme.EditValoTheme;

import eu.etaxonomy.vaadin.mvp.AbstractPopupView;

@SpringComponent

@Scope("prototype")

public class RegistrationMessagesPopup extends AbstractPopupView<RegistrationMessagesPresenter>

    implements RegistrationMessagesView, AccessRestrictedView {

    private static final long serialVersionUID = 713522519903334889L;

    Panel messagesPanel;

    TextArea newMessageField;

    Button sendMessageButton;

    private VerticalLayout mainLayout;

    private DelegatingErrorHandler errrorHandler = new DelegatingErrorHandler();

    private String accessDeniedMessage;

    public RegistrationMessagesPopup() {

        mainLayout = new VerticalLayout();

        // IMPORTANT: mainLayout must be set to full size otherwise the

        // popup window may have problems with automatic resizing of its

        // content.

        mainLayout.setSizeFull();

        setCompositionRoot(mainLayout);

    }

    @Override

    protected void initContent() {

        messagesPanel = new Panel();

        messagesPanel.setStyleName(EditValoTheme.PANEL_CONTENT_PADDING_LEFT);

        newMessageField = new TextArea();

        newMessageField.setNullRepresentation("");

        newMessageField.addTextChangeListener(e -> {

            sendMessageButton.setEnabled(StringUtils.isNoneBlank(e.getText()));

        });

        newMessageField.setHeight("64px"); // height of the Submit button when ValoTheme.BUTTON_HUGE

        newMessageField.setWidth("100%");

        sendMessageButton = new Button(FontAwesome.SEND);

        sendMessageButton.addClickListener(e -> postNewMessage());

        sendMessageButton.setStyleName(ValoTheme.BUTTON_HUGE + " " +ValoTheme.BUTTON_PRIMARY);

        HorizontalLayout sendMessagebar = new HorizontalLayout(newMessageField, sendMessageButton);

        sendMessagebar.setComponentAlignment(sendMessageButton, Alignment.MIDDLE_RIGHT);

        sendMessagebar.setExpandRatio(newMessageField, 1f);

        sendMessagebar.setWidth("100%");

        mainLayout.addComponents(messagesPanel, sendMessagebar);

        mainLayout.setErrorHandler(errrorHandler);

        mainLayout.setComponentAlignment(sendMessagebar, Alignment.BOTTOM_CENTER);

    }

    @Override

    public int getWindowHeight() {

        // undefined

        return -1;

    }

    @Override

    public boolean isClosable() {

        return true;

    }

    @Override

    public boolean isResizable() {

        return true;

    }

    /**

     * @return

     */

    private void postNewMessage() {

        // quick and dirty implementation, better send an event

        String text = newMessageField.getValue();

        if(StringUtils.isNotBlank(text)){

            getPresenter().postMessage(text);

            newMessageField.setValue(null);

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public String getWindowCaption() {

        return "Messages";

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void focusFirst() {

        // none

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean allowAnonymousAccess() {

        return false;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public Collection<Collection<GrantedAuthority>> allowedGrantedAuthorities() {

        return null;

    }

    @Override

    public String getAccessDeniedMessage() {

        return accessDeniedMessage;

    }

    @Override

    public void setAccessDeniedMessage(String accessDeniedMessage) {

        this.accessDeniedMessage = accessDeniedMessage;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void cancel() {

        // not needed

    }

    /**

     * @param identifier

     */

    public void loadMessagesFor(UUID registrationEntityUuid) {

        getPresenter().loadMessagesFor(registrationEntityUuid);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void showMessages(String registrationLabel, List<Message> messages) {

        VerticalLayout messagesList = new VerticalLayout();

        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm");

        for(Message message : messages){

            Label item = new Label("<span class=\"date-time\">(" +  dateFormat.format(message.getCreatedOn()) + ")</span> <span class=\"user-name\">" + message.getFrom().getUsername() + "</span>: <span class=\"message-text\">"  + message.getText() + "</span>");

            item.setStyleName("message-item");

            item.setContentMode(ContentMode.HTML);

            messagesList.addComponent(item);

        }

        messagesPanel.setCaption(registrationLabel);

        messagesPanel.setContent(messagesList);

    }

    // TODO move into AbstractPopupView?

    @Override

    public DelegatingErrorHandler getErrrorHandler(){

        return errrorHandler;

    }

}

/**

* 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.view.registration;

import java.util.Arrays;

import java.util.List;

import java.util.Stack;

import java.util.UUID;

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.IRegistrationService;

import eu.etaxonomy.cdm.api.utility.RoleProber;

import eu.etaxonomy.cdm.ext.common.ExternalServiceException;

import eu.etaxonomy.cdm.ext.registration.messages.IRegistrationMessageService;

import eu.etaxonomy.cdm.ext.registration.messages.Message;

import eu.etaxonomy.cdm.model.common.User;

import eu.etaxonomy.cdm.model.name.Registration;

import eu.etaxonomy.cdm.service.UserHelperAccess;

import eu.etaxonomy.cdm.vaadin.event.error.ExternalServiceExceptionHandler;

import eu.etaxonomy.cdm.vaadin.permission.RolesAndPermissions;

import eu.etaxonomy.vaadin.mvp.AbstractPresenter;

/**

 * @author a.kohlbecker

 * @since Feb 27, 2018

 *

 */

@SpringComponent

@Scope("prototype")

public class RegistrationMessagesPresenter extends AbstractPresenter<RegistrationMessagesView> {

    private static final long serialVersionUID = -1069755744585623770L;

    @Autowired

    IRegistrationMessageService messageService;

    @Autowired

    IRegistrationService registrationService;

    Registration registration;

    @Override

    public void onPresenterReady() {

        getView().getErrrorHandler().registerHandler(

                new ExternalServiceExceptionHandler("The external messages service reported an error")

                );

    }

    /**

     * @param identifier

     */

    public void loadMessagesFor(UUID uuid) {

        if(registration == null){

            registration = registrationService.load(uuid, Arrays.asList("submitter"));

        }

        try {

            List<Message> messages = messageService.listMessages(registration);

            getView().showMessages("On Registration " + registration.getIdentifier(), messages);

        } catch (ExternalServiceException e) {

            throw new RuntimeException(e);

        }

    }

    /**

     * @param value

     */

    public void postMessage(String message) {

        User user = UserHelperAccess.userHelper().user();

        List<Message> activeMessages;

        try {

            activeMessages = messageService.listActiveMessagesFor(registration, user);

        } catch (ExternalServiceException e) {

            throw new RuntimeException(e);

        }

        User toUser = null;

        if(UserHelperAccess.userHelper().userIs(new RoleProber(RolesAndPermissions.ROLE_CURATION))){

            toUser = registration.getSubmitter();

        } else {

            Stack<Message> stack = new Stack<>();

            stack.addAll(activeMessages);

            while(!stack.empty()){

                toUser = stack.pop().getFrom();

                if(!toUser.equals(user)){

                    break;

                }

            }

            if(toUser == null){

                throw new RuntimeException("Only a curator can initiate a communication");

            }

        }

        try {

            messageService.postMessage(registration, message, user, toUser);

            loadMessagesFor(registration.getUuid());

        } catch (ExternalServiceException e) {

            logger.error(e);

            throw new RuntimeException(e);

        }

    }

}

/**

* 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.view.registration;

import java.util.List;

import eu.etaxonomy.cdm.ext.registration.messages.Message;

import eu.etaxonomy.cdm.vaadin.event.error.DelegatingErrorHandler;

import eu.etaxonomy.vaadin.mvp.ApplicationView;

/**

 * @author a.kohlbecker

 * @since Feb 27, 2018

 *

 */

public interface RegistrationMessagesView extends ApplicationView<RegistrationMessagesPresenter> {

    /**

     * @param messages

     */

    void showMessages(String registrationLabel, List<Message> messages);

    DelegatingErrorHandler getErrrorHandler();

}

import com.vaadin.server.SystemError;

import com.vaadin.ui.Button;

import eu.etaxonomy.cdm.api.utility.RoleProber;

import eu.etaxonomy.cdm.ext.common.ExternalServiceException;

import eu.etaxonomy.cdm.ext.registration.messages.IRegistrationMessageService;

import eu.etaxonomy.cdm.model.common.User;

import eu.etaxonomy.cdm.vaadin.permission.RolesAndPermissions;

import eu.etaxonomy.cdm.vaadin.theme.EditValoTheme;

    @Autowired

    private IRegistrationMessageService messageService;

        // update the messages

        // updateMessages(); // disabled see  #7908

    protected void updateMessages() {

        User user = UserHelperAccess.userHelper().user();

        for (UUID registrationUuid : getView().getRegistrationItemMap().keySet()) {

            Button messageButton = getView().getRegistrationItemMap().get(registrationUuid).regItemButtons.getMessagesButton();

            RegistrationDTO regDto = workingset.getRegistrationDTO(registrationUuid).get();

            try {

                int messageCount = messageService.countActiveMessagesFor(regDto.registration(), user);

                boolean activeMessages = messageCount > 0;

                boolean currentUserIsSubmitter = regDto.getSubmitterUserName() != null && regDto.getSubmitterUserName().equals(UserHelperAccess.userHelper().userName());

                boolean currentUserIsCurator = UserHelperAccess.userHelper().userIs(new RoleProber(RolesAndPermissions.ROLE_CURATION));

                messageButton.setEnabled(false);

                if(currentUserIsCurator){

                    if(currentUserIsSubmitter){

                        messageButton.setDescription("No point sending messages to your self.");

                    } else {

                        messageButton.setEnabled(true);

                        messageButton.setDescription("Open the messages dialog.");

                    }

                } else {

                    messageButton.setDescription("Sorry, only a curator can start a conversation.");

                }

                if(activeMessages){

                    messageButton.setEnabled(true);

                    messageButton.addStyleName(EditValoTheme.BUTTON_HIGHLITE);

                    String who = currentUserIsSubmitter ? "curator" : "submitter";

                    messageButton.setDescription("The " + who + " is looking forward to your reply.");

                }

            } catch (ExternalServiceException e) {

                messageButton.setComponentError(new SystemError(e.getMessage(), e));

            }

        }

    }

        } else if(event.getProperty().equals(RegistrationItem.MESSAGES)){

            RegistrationMessagesPopup popup = openPopupEditor(RegistrationMessagesPopup.class, null);

            popup.loadMessagesFor(regDto.getUuid());

        Button messageButton = regItemButtons.getMessagesButton();

        messageButton.addClickListener(e -> getViewEventBus().publish(this,

                    new ShowDetailsEvent<RegistrationDTO, UUID>(

                        e,

                        RegistrationDTO.class,

                        dto.getUuid(),

                        RegistrationItem.MESSAGES

                        )

                    )

                );

        messageButton.setStyleName(ValoTheme.BUTTON_TINY);