MessageServiceImpl.java

/*
    This file is part of Cyclos (www.cyclos.org).
    A project of the Social Trade Organisation (www.socialtrade.org).

    Cyclos is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    Cyclos is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Cyclos; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

 */
package nl.strohalm.cyclos.services.elements;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.EnumSet;
import java.util.List;
import java.util.Set;

import javax.mail.internet.InternetAddress;

import nl.strohalm.cyclos.access.AdminMemberPermission;
import nl.strohalm.cyclos.access.MemberPermission;
import nl.strohalm.cyclos.access.OperatorPermission;
import nl.strohalm.cyclos.dao.members.MessageDAO;
import nl.strohalm.cyclos.entities.Entity;
import nl.strohalm.cyclos.entities.Relationship;
import nl.strohalm.cyclos.entities.accounts.SystemAccountOwner;
import nl.strohalm.cyclos.entities.accounts.transactions.TransferType;
import nl.strohalm.cyclos.entities.customization.fields.MemberCustomField;
import nl.strohalm.cyclos.entities.exceptions.LockingException;
import nl.strohalm.cyclos.entities.exceptions.UnexpectedEntityException;
import nl.strohalm.cyclos.entities.groups.MemberGroup;
import nl.strohalm.cyclos.entities.groups.MemberGroupSettings;
import nl.strohalm.cyclos.entities.members.Element;
import nl.strohalm.cyclos.entities.members.Member;
import nl.strohalm.cyclos.entities.members.messages.Message;
import nl.strohalm.cyclos.entities.members.messages.Message.Direction;
import nl.strohalm.cyclos.entities.members.messages.Message.Type;
import nl.strohalm.cyclos.entities.members.messages.MessageQuery;
import nl.strohalm.cyclos.entities.sms.MemberSmsStatus;
import nl.strohalm.cyclos.entities.sms.SmsLog;
import nl.strohalm.cyclos.entities.sms.SmsLog.ErrorType;
import nl.strohalm.cyclos.services.InitializingService;
import nl.strohalm.cyclos.services.elements.exceptions.MemberWontReceiveNotificationException;
import nl.strohalm.cyclos.services.fetch.FetchServiceLocal;
import nl.strohalm.cyclos.services.permissions.PermissionServiceLocal;
import nl.strohalm.cyclos.services.preferences.MessageChannel;
import nl.strohalm.cyclos.services.preferences.PreferenceServiceLocal;
import nl.strohalm.cyclos.services.settings.SettingsServiceLocal;
import nl.strohalm.cyclos.services.sms.ISmsContext;
import nl.strohalm.cyclos.services.sms.SmsLogServiceLocal;
import nl.strohalm.cyclos.services.transactions.PaymentServiceLocal;
import nl.strohalm.cyclos.services.transactions.TransferDTO;
import nl.strohalm.cyclos.services.transactions.exceptions.MaxAmountPerDayExceededException;
import nl.strohalm.cyclos.services.transactions.exceptions.NotEnoughCreditsException;
import nl.strohalm.cyclos.services.transactions.exceptions.UpperCreditLimitReachedException;
import nl.strohalm.cyclos.utils.DateHelper;
import nl.strohalm.cyclos.utils.LinkGenerator;
import nl.strohalm.cyclos.utils.MailHandler;
import nl.strohalm.cyclos.utils.TimePeriod;
import nl.strohalm.cyclos.utils.TransactionHelper;
import nl.strohalm.cyclos.utils.WorkerThreads;
import nl.strohalm.cyclos.utils.access.LoggedUser;
import nl.strohalm.cyclos.utils.notifications.AdminNotificationHandler;
import nl.strohalm.cyclos.utils.sms.SmsSender;
import nl.strohalm.cyclos.utils.transaction.CurrentTransactionData;
import nl.strohalm.cyclos.utils.transaction.TransactionCommitListener;
import nl.strohalm.cyclos.utils.transaction.TransactionEndListener;
import nl.strohalm.cyclos.utils.validation.InvalidError;
import nl.strohalm.cyclos.utils.validation.PropertyValidation;
import nl.strohalm.cyclos.utils.validation.RequiredValidation;
import nl.strohalm.cyclos.utils.validation.ValidationError;
import nl.strohalm.cyclos.utils.validation.ValidationException;
import nl.strohalm.cyclos.utils.validation.Validator;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.mutable.MutableObject;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;

/**
 * Implementation for message service
 * @author luis
 */
public class MessageServiceImpl implements MessageServiceLocal, DisposableBean, InitializingService {
    public static class RequiredWhenFromAdminValidation implements PropertyValidation {
        private static final long serialVersionUID = -3593591846871843393L;

        @Override
        public ValidationError validate(final Object object, final Object property, final Object value) {
            if (LoggedUser.hasUser() && LoggedUser.isAdministrator()) {
                return RequiredValidation.instance().validate(object, property, value);
            }
            return null;
        }
    }

    /**
     * Ensure the message receiver is not the same logged user
     * @author luis
     */
    public static class SameFromAndToValidation implements PropertyValidation {

        private static final long serialVersionUID = -3649308826565152361L;

        @Override
        public ValidationError validate(final Object object, final Object property, final Object value) {
            final SendMessageToMemberDTO dto = (SendMessageToMemberDTO) object;
            final Member loggedMember = (Member) (LoggedUser.hasUser() && LoggedUser.isMember() ? LoggedUser.element() : null);
            final Member toMember = dto.getToMember();
            if (loggedMember != null && loggedMember.equals(toMember)) {
                return new InvalidError();
            }
            return null;
        }
    }

    private class SmsSenderThreads extends WorkerThreads<SendSmsDTO> {

        public SmsSenderThreads(final String name, final int threadCount) {
            super(name, threadCount);
        }

        @Override
        protected void process(final SendSmsDTO params) {
            sendSms(params);
        }
    }

    private static final Log         LOG = LogFactory.getLog(MessageServiceImpl.class);

    private PermissionServiceLocal   permissionService;

    private MessageDAO               messageDao;
    private FetchServiceLocal        fetchService;
    private MemberServiceLocal       memberService;
    private PaymentServiceLocal      paymentService;
    private PreferenceServiceLocal   preferenceService;
    private SettingsServiceLocal     settingsService;
    private SmsLogServiceLocal       smsLogService;
    private LinkGenerator            linkGenerator;
    private MailHandler              mailHandler;
    private SmsSender                smsSender;
    private TransactionHelper        transactionHelper;
    private int                      maxSmsThreads;
    private SmsSenderThreads         smsSenderThreads;
    private AdminNotificationHandler adminNotificationHandler;

    @Override
    public boolean canManage(Message message) {
        message = checkMessageOwner(message);
        if (message == null) {
            return false;
        }

        return permissionService.permission()
                .admin(AdminMemberPermission.MESSAGES_MANAGE)
                .member(MemberPermission.MESSAGES_MANAGE)
                .operator(OperatorPermission.MESSAGES_MANAGE)
                .hasPermission();
    }

    @Override
    public boolean canSendToAdmin() {
        return permissionService.permission()
                .member(MemberPermission.MESSAGES_SEND_TO_ADMINISTRATION)
                .operator(OperatorPermission.MESSAGES_SEND_TO_ADMINISTRATION)
                .hasPermission();
    }

    @Override
    public boolean canSendToMember(final Member member) {
        return permissionService.permission()
                .admin(AdminMemberPermission.MESSAGES_SEND_TO_MEMBER)
                .member(MemberPermission.MESSAGES_SEND_TO_MEMBER)
                .operator(OperatorPermission.MESSAGES_SEND_TO_MEMBER)
                .hasPermission()
                &&
                permissionService.relatesTo(member);
    }

    @Override
    public Message checkMessageOwner(Message message) {
        if (message == null) {
            return null;
        }
        message = fetchService.fetch(message, Message.Relationships.FROM_MEMBER, Message.Relationships.TO_MEMBER);
        final Member loggedMember = (Member) (LoggedUser.hasUser() && !LoggedUser.isAdministrator() ? LoggedUser.accountOwner() : null);
        final Member owner = message.getOwner();
        if ((loggedMember == null && owner != null) || (loggedMember != null && !loggedMember.equals(owner))) {
            return null;
        }
        return message;
    }

    @Override
    public void destroy() throws Exception {
        if (smsSenderThreads != null) {
            smsSenderThreads.interrupt();
            smsSenderThreads = null;
        }
    }

    @Override
    public void initializeService() {
        purgeExpiredMessagesOnTrash(Calendar.getInstance());
    }

    @Override
    public Message load(final Long id, final Relationship... fetch) {
        return messageDao.load(id, fetch);
    }

    @Override
    public Message nextToSend() {
        return messageDao.nextToSend();
    }

    @Override
    public void performAction(final MessageAction action, final Long... ids) {
        for (final Long id : ids) {
            final Message message = messageDao.load(id);
            if (action == MessageAction.DELETE) {
                messageDao.delete(message.getId());
            } else {
                switch (action) {
                    case MOVE_TO_TRASH:
                        message.setRemovedAt(Calendar.getInstance());
                        break;
                    case RESTORE:
                        message.setRemovedAt(null);
                        break;
                    case MARK_AS_READ:
                        message.setRead(true);
                        break;
                    case MARK_AS_UNREAD:
                        message.setRead(false);
                        break;
                }
                messageDao.update(message);
            }
        }
    }

    @Override
    public void purgeExpiredMessagesOnTrash(final Calendar time) {
        final TimePeriod timePeriod = settingsService.getLocalSettings().getDeleteMessagesOnTrashAfter();
        if (timePeriod == null || timePeriod.getNumber() <= 0) {
            return;
        }
        final Calendar limit = timePeriod.remove(DateHelper.truncate(time));
        messageDao.removeMessagesOnTrashBefore(limit);
    }

    @Override
    public Message read(final Long id, final Relationship... fetch) {
        final Message message = load(id, fetch);
        message.setRead(true);
        return message;
    }

    @Override
    public List<Message> search(final MessageQuery query) {
        return messageDao.search(query);
    }

    @Override
    public Message send(final SendMessageDTO message) {
        if (message instanceof SendMessageToGroupDTO || message instanceof SendMessageFromBrokerToMembersDTO) {
            return doSendBulk(message);
        } else if (message instanceof SendMessageToAdminDTO) {
            Message sentMessage = doSendSingle(message);
            adminNotificationHandler.notifyMessage(sentMessage);
            return sentMessage;
        } else if (message instanceof SendDirectMessageToMemberDTO) {
            return doSendSingle(message);
        }
        return doSendSingle(message);
    }

    @Override
    public void sendEmailIfNeeded(final Message message) {
        Member member = message.getToMember();
        Set<MessageChannel> receivedChannels = preferenceService.receivedChannels(member, message.getType());
        if (receivedChannels.contains(MessageChannel.EMAIL)) {
            InternetAddress replyTo = mailHandler.getInternetAddress(message.getFromMember());
            InternetAddress to = mailHandler.getInternetAddress(member);
            mailHandler.send(message.getSubject(), replyTo, to, message.getBody(), message.isHtml());
        }
    }

    @Override
    public void sendFromSystem(final SendMessageFromSystemDTO message) {
        final Entity entity = message.getEntity();
        String link = "";
        if (entity != null && linkGenerator != null) {
            link = linkGenerator.generateLinkFor(message.getToMember(), entity);
        }
        final String body = StringUtils.replace(message.getBody(), "#link#", link);
        message.setBody(body);
        message.setHtml(true);
        doSendSingle(message);
    }

    /**
     * This methods runs a new transaction for handling the sms status, charging, etc... Then, the log is always persisted in another transaction
     * (with a {@link TransactionEndListener}). So, even if the sending fails, the log is persisted
     */
    @Override
    public SmsLog sendSms(final SendSmsDTO params) {
        final MutableObject result = new MutableObject();
        transactionHelper.runInNewTransaction(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(final TransactionStatus status) {
                // The returned log is transient...
                SmsLog log;
                try {
                    log = doSendSms(params);
                } catch (LockingException e) {
                    throw e;
                } catch (Exception e) {
                    LOG.error("Unknown error sending sms", e);
                    log = newSmsLog(params, ErrorType.SEND_ERROR, false);
                }
                if (log.getErrorType() != null) {
                    status.setRollbackOnly();
                }
                // ... we can only actually persist it after this transaction ends, because we don't know if it will be committed
                final SmsLog toSave = log;
                CurrentTransactionData.addTransactionEndListener(new TransactionEndListener() {
                    @Override
                    protected void onTransactionEnd(final boolean commit) {
                        transactionHelper.runInCurrentThread(new TransactionCallbackWithoutResult() {
                            @Override
                            protected void doInTransactionWithoutResult(final TransactionStatus status) {
                                result.setValue(smsLogService.save(toSave));
                            }
                        });
                    }
                });
            }
        });
        return (SmsLog) result.getValue();
    }

    @Override
    public synchronized void sendSmsAfterTransactionCommit(final SendSmsDTO params) {
        if (smsSenderThreads == null) {
            smsSenderThreads = new SmsSenderThreads("SMS sender for " + settingsService.getLocalSettings().getApplicationName(), maxSmsThreads);
        }
        CurrentTransactionData.addTransactionCommitListener(new TransactionCommitListener() {
            @Override
            public void onTransactionCommit() {
                smsSenderThreads.enqueue(params);
            }
        });
    }

    public void setAdminNotificationHandler(final AdminNotificationHandler adminNotificationHandler) {
        this.adminNotificationHandler = adminNotificationHandler;
    }

    public void setFetchServiceLocal(final FetchServiceLocal fetchService) {
        this.fetchService = fetchService;
    }

    public void setLinkGenerator(final LinkGenerator linkGenerator) {
        this.linkGenerator = linkGenerator;
    }

    public void setMailHandler(final MailHandler mailHandler) {
        this.mailHandler = mailHandler;
    }

    public void setMaxSmsThreads(final int maxSmsThreads) {
        this.maxSmsThreads = maxSmsThreads;
    }

    public void setMemberServiceLocal(final MemberServiceLocal memberService) {
        this.memberService = memberService;
    }

    public void setMessageDao(final MessageDAO messageDao) {
        this.messageDao = messageDao;
    }

    public void setPaymentServiceLocal(final PaymentServiceLocal paymentService) {
        this.paymentService = paymentService;
    }

    public final void setPermissionServiceLocal(final PermissionServiceLocal permissionService) {
        this.permissionService = permissionService;
    }

    public void setPreferenceServiceLocal(final PreferenceServiceLocal preferenceService) {
        this.preferenceService = preferenceService;
    }

    public void setSettingsServiceLocal(final SettingsServiceLocal settingsService) {
        this.settingsService = settingsService;
    }

    public void setSmsLogServiceLocal(final SmsLogServiceLocal smsLogService) {
        this.smsLogService = smsLogService;
    }

    public void setSmsSender(final SmsSender smsSender) {
        this.smsSender = smsSender;
    }

    public void setTransactionHelper(final TransactionHelper transactionHelper) {
        this.transactionHelper = transactionHelper;
    }

    @Override
    public void validate(final SendMessageDTO message) throws ValidationException {
        getValidator(message.getClass()).validate(message);
    }

    private Validator basicToMemberValidator() {
        final Validator validator = basicValidator();
        validator.property("toMember").required();
        return validator;
    }

    private Validator basicValidator() {
        final Validator validator = new Validator("message");
        validator.property("subject").required();
        validator.property("body").required();
        return validator;
    }

    /**
     * Returns a Message instance, filled with data from the given DTO
     */
    private Message buildFromDTO(final SendMessageDTO dto, final Message.Direction direction) {
        return buildFromDTO(dto, dto, direction);
    }

    /**
     * Returns a Message instance, filled with data from the given DTO
     */
    private Message buildFromDTO(final SendMessageDTO original, final SendMessageDTO dto, final Message.Direction direction) {
        final Message message = new Message();
        message.setDate(Calendar.getInstance());
        message.setHtml(dto.isHtml());
        message.setSubject(dto.getSubject());
        message.setBody(dto.getBody());
        if (!(dto instanceof SendMessageFromSystemDTO)) {
            message.setFromMember((Member) (LoggedUser.hasUser() && !LoggedUser.isAdministrator() ? LoggedUser.accountOwner() : null));
        }
        message.setType(dto.getType());
        message.setDirection(direction);
        if (direction == Message.Direction.OUTGOING) {
            message.setRead(true);
            message.setEmailSent(true);
        }
        if (dto instanceof SendMessageToMemberDTO) {
            message.setToMember(((SendMessageToMemberDTO) dto).getToMember());
        } else if (dto instanceof SendMessageToGroupDTO) {
            message.setToGroups(new ArrayList<MemberGroup>(((SendMessageToGroupDTO) dto).getToGroups()));
        }
        if (message.isFromAMember() && message.isToAMember()) {
            message.setCategory(null);
        } else {
            message.setCategory(dto.getCategory());
        }
        return message;
    }

    private TransferDTO buildSmsChargeDto(final Member member, final ISmsContext smsContext) {
        final MemberGroupSettings memberSettings = member.getMemberGroup().getMemberSettings();
        final TransferType smsChargeTransferType = memberSettings.getSmsChargeTransferType();
        final BigDecimal smsChargeAmount = smsContext.getAdditionalChargeAmount(member);

        // There are no charge settings, so don't charge
        if (smsChargeTransferType == null || smsChargeAmount == null) {
            return null;
        }

        // Build charge DTO
        final TransferDTO transferDto = new TransferDTO();
        if (smsChargeTransferType.isFromMember()) {
            transferDto.setFromOwner(member);
        } else {
            transferDto.setFromOwner(SystemAccountOwner.instance());
        }
        transferDto.setToOwner(SystemAccountOwner.instance());
        transferDto.setTransferType(smsChargeTransferType);
        transferDto.setDescription(smsChargeTransferType.getDescription());
        transferDto.setAmount(smsChargeAmount);
        transferDto.setAutomatic(true);
        return transferDto;
    }

    private Message doSendBulk(final SendMessageDTO message) {
        // Validate the message parameters
        validate(message);

        // Insert the sender copy only. The BulkMessageSendingPollingTask will actually deliver each copy
        return insertSenderCopy(message);
    }

    private Message doSendSingle(final SendMessageDTO message) {
        // Validate the message parameters
        validate(message);

        Set<MessageChannel> messageChannels = null;
        if (message instanceof SendMessageToMemberDTO) {
            // If is a message to member, get the received channels
            final SendMessageToMemberDTO toMemberMessage = (SendMessageToMemberDTO) message;
            messageChannels = preferenceService.receivedChannels(toMemberMessage.getToMember(), message.getType());
            if (toMemberMessage.requiresMemberToReceive() && CollectionUtils.isEmpty(messageChannels)) {
                // The message dto requires the member to receive and his preferences say he doesn't - throw an exception
                throw new MemberWontReceiveNotificationException();
            }
        }

        // Then insert the sender copy
        final Message senderCopy = insertSenderCopy(message);
        final Message toSend = buildFromDTO(message, Direction.INCOMING);
        String sms = null;
        String smsTraceData = null;
        if (message instanceof SendMessageFromSystemDTO) {
            SendMessageFromSystemDTO messageFromSystem = (SendMessageFromSystemDTO) message;
            sms = messageFromSystem.getSms();
            smsTraceData = messageFromSystem.getSmsTraceData();
        }
        send(toSend, sms, smsTraceData, messageChannels);
        return senderCopy;
    }

    private SmsLog doSendSms(final SendSmsDTO params) {
        final Member target = params.getTargetMember();
        final MemberCustomField customField = settingsService.getSmsCustomField();
        if (customField == null || !memberService.hasValueForField(target, customField)) {
            // Either no custom field, or the member didn't have value for the mobile phone
            return newSmsLog(params, ErrorType.NO_PHONE, false);
        }
        Member charged = params.getChargedMember();
        final boolean freeMailing = params.getSmsMailing() != null && params.getSmsMailing().isFree();
        ErrorType errorType = null;
        boolean boughtNewMessages = false;
        MemberSmsStatus memberSmsStatus = null;
        int additionalChargedSms = 0;
        boolean statusChanged = false;
        boolean freeBaseUsed = false;
        ISmsContext smsContext = null;
        if (!freeMailing) {
            // Charge the SMS
            if (charged == null) {
                charged = target;
                params.setChargedMember(charged);
            }
            charged = fetchService.reload(charged, Element.Relationships.GROUP);
            smsContext = memberService.getSmsContext(charged);
            memberSmsStatus = memberService.getSmsStatus(charged, true);
            additionalChargedSms = smsContext.getAdditionalChargedSms(charged);
            final int freeSms = smsContext.getFreeSms(charged);
            if (memberSmsStatus.getFreeSmsSent() < freeSms) {
                // There are free messages left
                memberSmsStatus.setFreeSmsSent(memberSmsStatus.getFreeSmsSent() + 1);
                freeBaseUsed = true;
                statusChanged = true;
            } else if (memberSmsStatus.getPaidSmsLeft() > 0) {
                // There are paid messages left
                memberSmsStatus.setPaidSmsLeft(memberSmsStatus.getPaidSmsLeft() - 1);
                statusChanged = true;
            } else {
                // Check if paid messages are enabled
                if (additionalChargedSms > 0) {
                    // Paid messages are enabled
                    if (memberSmsStatus.isAllowChargingSms()) {
                        // The member allows charge
                        final TransferDTO chargeDTO = buildSmsChargeDto(charged, smsContext);
                        try {
                            if (chargeDTO == null) {
                                throw new UnexpectedEntityException();
                            }
                            paymentService.insertWithoutNotification(chargeDTO);
                            // The status will only be updated if the SMS sending is successful, to avoid updating the status and having to undo later
                            boughtNewMessages = true;
                        } catch (final NotEnoughCreditsException e) {
                            errorType = ErrorType.NOT_ENOUGH_FUNDS;
                        } catch (final MaxAmountPerDayExceededException e) {
                            errorType = ErrorType.NOT_ENOUGH_FUNDS;
                        } catch (final UpperCreditLimitReachedException e) {
                            errorType = ErrorType.NOT_ENOUGH_FUNDS;
                        } catch (final UnexpectedEntityException e) {
                            ValidationException exc = new ValidationException("The SMS charging is not well configured. Please, check the charging transfer type.");
                            exc.setShowDetailMessage(true);
                            throw exc;
                        }
                    } else {
                        // The member have disallowed charging
                        errorType = ErrorType.ALLOW_CHARGING_DISABLED;
                    }
                } else {
                    if (freeSms == 0) {
                        ValidationException exc = new ValidationException("SMS cannot be sent becasue both free messages and aditional messages are zero for member: " + charged.getUsername());
                        exc.setShowDetailMessage(true);
                        throw exc;

                    } else {
                        errorType = ErrorType.NO_SMS_LEFT;
                    }
                }
            }
        }
        // Send the message itself if no error so far
        if (errorType == null) {
            try {
                if (!smsSender.send(target, params.getText(), params.getTraceData())) {
                    throw new Exception("Sms sender returns false when sending a sms (trace=" + params.getTraceData() + ")");
                }
                // The message was sent. Update the member sms status
                if (boughtNewMessages) {
                    final int left = additionalChargedSms - 1;
                    Calendar expiration = null;
                    if (left > 0) {
                        TimePeriod additionalChargedPeriod = smsContext.getAdditionalChargedPeriod(charged);
                        if (additionalChargedPeriod == null) {
                            additionalChargedPeriod = TimePeriod.ONE_MONTH;
                        }
                        expiration = additionalChargedPeriod.add(Calendar.getInstance());
                    }
                    memberSmsStatus.setPaidSmsLeft(left);
                    memberSmsStatus.setPaidSmsExpiration(expiration);
                    statusChanged = true;
                }
            } catch (final Exception e) {
                LOG.error("Unknown error sending sms", e);
                errorType = ErrorType.SEND_ERROR;
                // Ensure the status won't be changed on errors
                statusChanged = false;
            }
        }
        // Update the SMS status if it has changed
        if (statusChanged) {
            memberService.updateSmsStatus(memberSmsStatus);
        }
        // Generate the SMS log
        return newSmsLog(params, errorType, freeBaseUsed);
    }

    private Validator getValidator(final Class<? extends SendMessageDTO> type) {
        if (type == SendDirectMessageToMemberDTO.class) {
            final Validator toMember = basicToMemberValidator();
            toMember.property("toMember").add(new SameFromAndToValidation());
            toMember.property("category").add(new RequiredWhenFromAdminValidation());
            return toMember;
        } else if (type == SendMessageToAdminDTO.class) {
            final Validator toAdmin = basicValidator();
            toAdmin.property("category").required();
            return toAdmin;
        } else if (type == SendMessageFromBrokerToMembersDTO.class) {
            final Validator toRegisteredMembers = basicValidator();
            return toRegisteredMembers;
        } else if (type == SendMessageToGroupDTO.class) {
            final Validator toGroup = basicValidator();
            toGroup.property("toGroups").required();
            toGroup.property("category").add(new RequiredWhenFromAdminValidation());
            return toGroup;
        } else if (type == SendMessageFromSystemDTO.class) {
            final Validator fromSystem = basicToMemberValidator();
            fromSystem.property("type").required();
            return fromSystem;
        } else {
            throw new IllegalArgumentException("Unexpected type " + type);
        }
    }

    private Message insertSenderCopy(final SendMessageDTO dto) throws MemberWontReceiveNotificationException {
        // Validate the message being replied
        final Message inReplyTo = checkMessageOwner(dto.getInReplyTo());

        // Update the original message as replied
        if (inReplyTo != null) {
            markAsReplied(inReplyTo);
        }

        if (dto instanceof SendMessageFromSystemDTO) {
            // There is no sender copy for messages from system (a.k.a notifications)
            return null;
        }

        // Insert the sender copy
        Message message = buildFromDTO(dto, Message.Direction.OUTGOING);
        message = messageDao.insert(message);

        // If the message is bulk, assign all members which should receive the messages
        if (dto instanceof SendMessageToGroupDTO) {
            final SendMessageToGroupDTO toGroup = (SendMessageToGroupDTO) dto;
            messageDao.assignPendingToSendByGroups(message, toGroup.getToGroups());
        } else if (dto instanceof SendMessageFromBrokerToMembersDTO) {
            final Member broker = LoggedUser.element();
            messageDao.assignPendingToSendByBroker(message, broker);
        }

        return message;
    }

    /**
     * Marks a given message as replied
     */
    private void markAsReplied(final Message message) {
        if (message != null) {
            message.setReplied(true);
            messageDao.update(message);
        }
    }

    private SmsLog newSmsLog(final SendSmsDTO params, final ErrorType errorType, final boolean freeBaseUsed) {
        final SmsLog newLog = new SmsLog();
        newLog.setDate(Calendar.getInstance());
        newLog.setTargetMember(params.getTargetMember());
        newLog.setChargedMember(params.getChargedMember());
        newLog.setErrorType(errorType);
        newLog.setFreeBaseUsed(freeBaseUsed);
        newLog.setMessageType(params.getMessageType());
        newLog.setSmsMailing(params.getSmsMailing());
        newLog.setSmsType(params.getSmsType());
        newLog.setSmsTypeArgs(params.getSmsTypeArgs());
        return newLog;
    }

    /**
     * Sends the message, returning a set containing the channels actually delivered
     */
    private Set<MessageChannel> send(final Message message, final String smsMessage, final String smsTraceData, Set<MessageChannel> messageChannels) {
        final Member toMember = fetchService.fetch(message.getToMember(), Element.Relationships.GROUP);
        message.setCategory(fetchService.fetch(message.getCategory()));
        final Set<MessageChannel> result = EnumSet.noneOf(MessageChannel.class);

        if (toMember != null) {
            final MemberGroup group = toMember.getMemberGroup();
            final Type type = message.getType();

            // Check which message channels will be used
            if (messageChannels == null) {
                messageChannels = preferenceService.receivedChannels(toMember, type);
            }
            if (CollectionUtils.isEmpty(messageChannels)) {
                // Nothing to send for this member
                return result;
            }

            // Send an e-mail if needed
            final String email = toMember.getEmail();
            if (messageChannels.contains(MessageChannel.EMAIL) && StringUtils.isNotEmpty(email)) {
                InternetAddress replyTo = mailHandler.getInternetAddress(message.getFromMember());
                InternetAddress to = mailHandler.getInternetAddress(toMember);
                mailHandler.sendAfterTransactionCommit(message.getSubject(), replyTo, to, message.getBody(), message.isHtml());
                message.setEmailSent(true);
                result.add(MessageChannel.EMAIL);
            }

            // Check if we need to send a SMS
            if (StringUtils.isNotEmpty(smsMessage) && messageChannels.contains(MessageChannel.SMS) && group.getSmsMessages().contains(type)) {
                // Send the SMS
                final SendSmsDTO sendDTO = new SendSmsDTO();
                sendDTO.setTargetMember(toMember);
                sendDTO.setMessageType(type);
                sendDTO.setText(smsMessage);
                sendDTO.setTraceData(smsTraceData);
                sendSmsAfterTransactionCommit(sendDTO);
                result.add(MessageChannel.SMS);
            }

            // If the user does not want the internal message, return now
            if (!messageChannels.contains(MessageChannel.MESSAGE)) {
                // If not, return now
                return result;
            }
            result.add(MessageChannel.MESSAGE);

        }

        // Insert the internal message
        messageDao.insert(message);

        return result;
    }
}