Examples of MessageRecipients


Examples of com.volantis.mps.recipient.MessageRecipients

        // generate message recipient lists for each device
        // then call send with new device specific message
        // recipients list

        // maintain list of all failures for all device names
        MessageRecipients failures = new MessageRecipients();

        // list that is regenerated for each device name
        MessageRecipients deviceSpecificRecips = new MessageRecipients();

        // current device name
        String currentDeviceName = null;

        Iterator recipientsIterator = messageRecipients.getIterator();

        while (recipientsIterator.hasNext()) {

            MessageRecipient recipient =
                    (MessageRecipient) recipientsIterator.next();

            if (recipient.resolveDeviceName(false) != MessageRecipient.OK) {
                logger.warn("device-resolution-failed-for", recipient);
                recipient.setFailureReason(
                        messageLocalizer.format(
                                "device-resolution-failed-for",
                                recipient));
                failures.addRecipient(recipient);
                continue;
            }

            // if recipient is on this channel
            if (recipient.getChannelName().equals(channelName)) {

                // if we are already creating a device specific recipient
                // list
                if (currentDeviceName != null) {

                    // if this recipient is targeted for a different device than
                    // the last recipient
                    if (!currentDeviceName.equals(recipient.getDeviceName())) {

                        // send exisiting message for current device and
                        // then create a new device dependent recipient list
                        boolean failed = false;
                        Exception cause = null;
                        try {
                            // send message via implemented sendImpl and hold
                            // over failures
                            MessageRecipients localFails =
                                    sendImpl(multiChannelMessage,
                                             deviceSpecificRecips,
                                             messageSender);
                            Iterator lfIterator = localFails.getIterator();

                            while (lfIterator.hasNext()) {
                                failures.addRecipient(
                                        (MessageRecipient) lfIterator.next());
                            }
                        } catch (MessageException me) {
                            failed = true;
                            cause = me;
                        } catch (RecipientException re) {
                            failed = true;
                            cause = re;
                        } finally {
                            if (failed) {
                                populateFailures(deviceSpecificRecips,
                                                 failures,
                                                 cause);

                                continue;
                            }
                        }

                        deviceSpecificRecips = new MessageRecipients();
                        currentDeviceName = recipient.getDeviceName();
                        deviceSpecificRecips.addRecipient(recipient);
                    } else {
                        // else add this recipient to the current device specific
                        // recipient list
                        deviceSpecificRecips.addRecipient(recipient);
                    }
                } else {
                    // this must be the first recipient in the list so we
                    // start the processing by creating a new device specific
                    // recipients list and setting the current device name
                    // to the recipients device
                    currentDeviceName = recipient.getDeviceName();
                    deviceSpecificRecips = new MessageRecipients();
                    deviceSpecificRecips.addRecipient(recipient);
                }
            }

            // ignore recipients for other channels
        }

        // send final message
        boolean failed = false;
        Exception cause = null;
        try {
            MessageRecipients localFails = sendImpl(multiChannelMessage,
                                                    deviceSpecificRecips,
                                                    messageSender);
            Iterator lfIterator = localFails.getIterator();
            while (lfIterator.hasNext()) {
                failures.addRecipient((MessageRecipient) lfIterator.next());
            }
        } catch (MessageException me) {
            failed = true;
View Full Code Here

Examples of com.volantis.mps.recipient.MessageRecipients

                                         MessageRecipients messageRecipients,
                                         MessageRecipient messageSender)
            throws RecipientException, MessageException {

        // Maintain a record of recipients for who the message send failed
        MessageRecipients failures = new MessageRecipients();

        Iterator recipientsIterator = messageRecipients.getIterator();

        // pick up device name from first recipient in list
        // and reset iterator
View Full Code Here

Examples of com.volantis.mps.recipient.MessageRecipients

                throws MessageException
   
        MessageRecipientsStatusContainer container =
            new MessageRecipientsStatusContainer();
      
        MessageRecipients failures = new MessageRecipients();
        MessageRecipients successes = new MessageRecipients();

        container.setFailures(failures);
        container.setSuccesses(successes);
       
        MessageRecipient recipient;
        MessageRecipient clone = null;
       
        Iterator recipientsIterator = recipients.getIterator();

        while (recipientsIterator.hasNext()) {
            recipient = (MessageRecipient)recipientsIterator.next();

            try {
                // Clone the recipient as we want to modify it.
                clone = (MessageRecipient)recipient.clone();


                RecipientInternals.setRecipientType(clone, recipientType);
                int channelStatus = clone.resolveChannelName(false);
                int deviceStatus = clone.resolveDeviceName(false);
               
                if (clone.getChannelName() != null &&
                    clone.getDeviceName() != null) {

                    if (clone.getAddress() != null ||
                        clone.getMSISDN() != null) {
                        successes.addRecipient(clone);
                    } else {
                        clone.setFailureReason(
                                messageLocalizer.format(
                                        "address-resolution-failed-for",
                                        clone));
View Full Code Here

Examples of com.volantis.mps.recipient.MessageRecipients

                        localizer.format("recipient-null-invalid"));
            }
   
            MessageRecipientsStatusContainer container;
           
            MessageRecipients recipients = new MessageRecipients();
           
            recipients.addRecipient(recipient);
           
            container = validateRecipients(recipients,
                                           RecipientInternals.TO_RECIPIENT);


            MessageRecipients sendFailures =
                    sendToChannelAdapters(message,
                                          container.getSuccesses(),
                                          null);
            MessageRecipients failures = container.getFailures();

            if (sendFailures != null) {
                RecipientInternals.addRecipients(failures, sendFailures);
            }
View Full Code Here

Examples of com.volantis.mps.recipient.MessageRecipients

     */
    public MessageRecipients send(MultiChannelMessage message,
                                  String toListName,
                                  MessageRecipient replyTo)
            throws MessageException {
        MessageRecipients recipients =
            (MessageRecipients)recipientsMap.get(toListName);
        return send(message, recipients, replyTo);
    }
View Full Code Here

Examples of com.volantis.mps.recipient.MessageRecipients

        MessageRecipientsStatusContainer container;

        container = validateRecipients(recipients,
                                       RecipientInternals.TO_RECIPIENT);

        MessageRecipients sendFailures =
                sendToChannelAdapters(message,
                                      container.getSuccesses(),
                                      replyTo);
        MessageRecipients failures = container.getFailures();
        try {
            if (sendFailures != null) {
                RecipientInternals.addRecipients(failures, sendFailures);
            }
        } catch (RecipientException e) {
View Full Code Here

Examples of com.volantis.mps.recipient.MessageRecipients

                                  String toListName,
                                  String ccListName,
                                  String bccListName,
                                  MessageRecipient replyTo)
        throws MessageException {
        MessageRecipients toList =
                (MessageRecipients)recipientsMap.get(toListName);

        MessageRecipients ccList =
                (MessageRecipients)recipientsMap.get(ccListName);

        MessageRecipients bccList =
                (MessageRecipients)recipientsMap.get(bccListName);
        return send(message, toList, ccList, bccList, replyTo);
    }
View Full Code Here

Examples of com.volantis.mps.recipient.MessageRecipients

                    localizer.format("recipient-lists-null-invalid"));
        }
       
        MessageRecipientsStatusContainer container;
       
        MessageRecipients failures = new MessageRecipients();
        MessageRecipients recipients = new MessageRecipients();
       
        // We need to build one big recipient list with the correct
        // RecipientType
        try {
            if (toList != null) {
                container = validateRecipients(toList,
                        RecipientInternals.TO_RECIPIENT);

                RecipientInternals.addRecipients(recipients,
                        container.getSuccesses());

                RecipientInternals.addRecipients(failures,
                        container.getFailures());
            }

            if (ccList != null) {
                container = validateRecipients(ccList,
                RecipientInternals.CC_RECIPIENT);

                RecipientInternals.addRecipients(recipients,
                        container.getSuccesses());

                RecipientInternals.addRecipients(failures,
                        container.getFailures());
            }

            if (bccList != null) {
                container = validateRecipients(bccList,
                        RecipientInternals.BCC_RECIPIENT);

                RecipientInternals.addRecipients(recipients,
                        container.getSuccesses());

                RecipientInternals.addRecipients(failures,
                        container.getFailures());
            }
        } catch (RecipientException e) {
            throw new MessageException(e);
        }

        MessageRecipients sendFailures =
                sendToChannelAdapters(message, recipients, replyTo);

        try {
            if (sendFailures != null) {
                RecipientInternals.addRecipients(failures, sendFailures);
View Full Code Here

Examples of com.volantis.mps.recipient.MessageRecipients

     */
     private MessageRecipients sendToChannelAdapters(MultiChannelMessage message,
            MessageRecipients recipients, MessageRecipient replyTo)
                    throws MessageException {

        MessageRecipients failures = new MessageRecipients();

        Iterator recipientsIterator = recipients.getIterator();

        String currentChannel = null;

        while (recipientsIterator.hasNext()) {
           
            MessageRecipient recipient =
                    (MessageRecipient)recipientsIterator.next();
            try {
                if (recipient.getChannelName() != null) {

                    if (!recipient.getChannelName().equals(currentChannel)) {
                        currentChannel = recipient.getChannelName();
                        MessageChannel channel =
                                (MessageChannel) CHANNEL_MAP.get(currentChannel);
   
                        if (channel!= null) {
                            try {
                                MessageRecipients sendFailures =
                                        channel.send(message,
                                                     recipients,
                                                     replyTo);
                                if (sendFailures != null) {
                                    RecipientInternals.
                                            addRecipients(failures,
                                                          sendFailures);
                                }
                            } catch (RecipientException e) {
                                throw new MessageException(e);
                            }
                        } else {
                            // log channel configuration error
                            logger.error("unconfigured-message-channel",
                                            currentChannel);

                            // add channel recipients to failure list
                            Iterator cfIterator = recipients.getIterator();
                            MessageRecipients channelFailures =
                                    new MessageRecipients();
                            String failMsg =
                                    messageLocalizer.format(
                                            "unconfigured-message-channel",
                                            currentChannel);
                            while (cfIterator.hasNext()) {
                                MessageRecipient mr =
                                        (MessageRecipient) cfIterator.next();
                                if (mr.getChannelName()
                                      .equals(currentChannel)) {
                                    mr.setFailureReason(failMsg);
                                    channelFailures.addRecipient(mr);
                                }
                            }

                            RecipientInternals.addRecipients(failures,
                                                             channelFailures);
View Full Code Here

Examples of com.volantis.mps.recipient.MessageRecipients

            MessageRecipients messageRecipients,
            MessageRecipient messageSender)
            throws RecipientException, MessageException {

        // Maintain a record of recipients for who the message send failed
        MessageRecipients failures = new MessageRecipients();
        // Maintain references to multiple recipients so a failure can be
        // recorded against multiple recipients where to/cc/bcc are combined
        // and can each contain multiple values.
        List multipleRecipients = new ArrayList();

        MimeMessage message;
 
        try {
            message = new MimeMessage(session);
 
            if (multiChannelMessage.getCharacterEncoding() != null) {
                message.setSubject(
                        multiChannelMessage.getSubject(),
                        multiChannelMessage.getCharacterEncoding());
            } else {
                message.setSubject( multiChannelMessage.getSubject() );
            }

            if (messageSender != null) {
                message.setFrom( messageSender.getAddress() );
            }

        } catch (Exception e) {
            // Failure to create the message hence no failure logged here
            throw new MessageException(e);
        }

        Iterator recipientsIterator = messageRecipients.getIterator();
        MessageRecipient recipient = null;

        while (recipientsIterator.hasNext()) {
            recipient = (MessageRecipient) recipientsIterator.next();
            int recipientType = RecipientInternals.getRecipientType(recipient);
            try {
                switch (recipientType) {
                case RecipientInternals.TO_RECIPIENT:
                    {
                        message.addRecipient(Message.RecipientType.TO,
                                             recipient.getAddress());
                        multipleRecipients.add(recipient);
                        break;
                    }
                case RecipientInternals.CC_RECIPIENT:
                    {
                        message.addRecipient(Message.RecipientType.CC,
                                             recipient.getAddress());
                        multipleRecipients.add(recipient);
                        break;
                    }
                case RecipientInternals.BCC_RECIPIENT:
                    {
                        message.addRecipient(Message.RecipientType.BCC,
                                             recipient.getAddress());
                        multipleRecipients.add(recipient);
                        break;
                    }
                }
            } catch (MessagingException me) {
                // This exception can come from addRecipient so the
                // recipient needs to be added to the failures here
                // and it will not already have been added to the
                // multipleRecipients list so no need to remove it.
                logger.warn("message-recipient-addition-failed-for",
                            recipient.getAddress(), me);
                recipient.setFailureReason(me.getMessage());
                failures.addRecipient(recipient);
            }
        }

        // obtain device name for message header generation
        // from last recipient added
        String currentDeviceName = recipient.getDeviceName();


        // Try and send the messsage
        try {
            message = (MimeMessage) addHeaders(multiChannelMessage,
                                               message,
                                               currentDeviceName);
            MimeMultipart content =
                    multiChannelMessage.generateTargetMessageAsMimeMultipart(
                            currentDeviceName);
            message.setContent(content, content.getContentType());
            Transport.send(message);
        } catch (MessagingException me) {
            for (Iterator i = multipleRecipients.iterator(); i.hasNext();) {
                MessageRecipient failedRecipient = (MessageRecipient) i.next();
                logger.warn("message-send-failed-to",
                            failedRecipient.getAddress());
                logger.error(me);
                failedRecipient.setFailureReason(me.getMessage());
                failures.addRecipient( failedRecipient );
            }
        }

        // Return any failures
        return failures;
View Full Code Here
TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.