Exemplo de EmailQueueProcessor

Exemplo de implementação da interface EmailQueueProcessor

Esta implementação de exemplo da interface EmailQueueProcessor usa classes de auxiliar de exemplo.

public without sharing class SampleEmailQueueProcessor implements EmailQueueProcessor {

    private Map<Id, Attachment> bodyAttachments;
    private Map<Id, ContentVersion> bodyContentVersions;
    private final List<SampleEmailMessage> emailMessages = new List<SampleEmailMessage>();

    public void initialize(List<LifeScienceEmail> records) {
        Set<Id> attachmentIds = new Set<Id>();
        
        for(LifeScienceEmail record : records) {
            if (!String.isBlank(String.valueOf(record.BodyAttachmentIdentifier)) && (record.BodyAttachmentIdentifier instanceof Id)) {
                attachmentIds.add((Id)record.BodyAttachmentIdentifier);
            }
        }
    
        bodyAttachments = new Map<Id, Attachment>();
        bodyContentVersions = new Map<Id, ContentVersion>();
    
        if (!attachmentIds.isEmpty()) {
            List<Attachment> attachments = [SELECT Id, Body, ContentType, Name FROM Attachment WHERE Id IN :attachmentIds];
            bodyAttachments = new Map<Id, Attachment>(attachments);

            List<ContentVersion> contentVersions = [SELECT Id, VersionData FROM ContentVersion WHERE Id IN :attachmentIds];
            bodyContentVersions = new Map<Id, ContentVersion>(contentVersions);
        }

    }
    
    public Boolean addMessage(LifeScienceEmail lscEmailRecord) {
        SampleEmailMessage email = new SampleEmailMessage();
        email.setSenderAddress(String.valueOf(lscEmailRecord.SenderEmailAddress));
        email.setSenderName(String.valueOf(lscEmailRecord.SenderUserName));
        email.addRecipient(String.valueOf(lscEmailRecord.SentToEmailAddress));
        email.setCCAddress(String.valueOf(lscEmailRecord.CcEmailAddressList).split(','));
        email.setBCCAddress(String.valueOf(lscEmailRecord.BccEmailAddressList).split(','));
        email.setSubject(String.valueOf(lscEmailRecord.SubjectText));
        
        String body = null;
        
        if (!String.isBlank(String.valueOf(lscEmailRecord.BodyAttachmentIdentifier))) {
                Attachment bodyAsAttachment = bodyAttachments.get(lscEmailRecord.BodyAttachmentIdentifier);
                if (bodyAsAttachment == null) {
                    ContentVersion bodyAsContentVersion = bodyContentVersions.get(lscEmailRecord.BodyAttachmentIdentifier);

                    if(bodyAsContentVersion == null){
                        // Exception - No Body Found
                    } else {
                        body = bodyAsContentVersion.VersionData.toString();
                    }

                } else {
                    body = bodyAsAttachment.Body.toString();
                }

            }
        
        email.setBody(body);
        emailMessages.add(email);
        return true;
    }
        
    public Boolean exceededLimits() {
        Integer remainingEmails = SampleEmailAPI.getRemainingEmails();
        Integer numberEmailsToBeSent = 0;
        for (SampleEmailMessage email : emailMessages) {
            numberEmailsToBeSent += email.getRecipients().size();
            numberEmailsToBeSent += email.getCCs().size();
            numberEmailsToBeSent += email.getBCCs().size();
        }
        return remainingEmails >= numberEmailsToBeSent;
    }
    
    public Boolean canExceedLimits(Integer numEmails) {
        Integer remainingEmails = SampleEmailAPI.getRemainingEmails();
        return remainingEmails >= numEmails;
    }
    
    public List<String> sendEmail() {
        List<String> errorMessages = SampleEmailAPI.sendEmails(emailMessages);
        return errorMessages;
    }
        
    public void cleanUp(List<LifeScienceEmail> records) {
        update records;
    }
    
    public List<LifeScienceEmail> updateAttemptStatus(List<LifeScienceEmail> emailAttemptsToProcess) {
        List<LifeScienceEmail> emailRecordsToUpdate = new List<LifeScienceEmail>();
        for (LifeScienceEmail email : emailAttemptsToProcess) {
            SampleEmailStatus status = SampleEmailAPI.getEmailStatus(email);
            if (status != null) {
                email.IsBounced = status.getIsBounced();
                email.BouncedReason = status.getBouncedReason();
                email.BouncedDate = status.getBouncedDate();
                email.LastOpenedDate = status.getLastOpenedDate();
                email.FirstOpenedDate = status.getFirstOpenedDate();
                email.LastEventDateTime = System.now();
            }
        }
        return emailAttemptsToProcess;
    }

    public void finish() {
        SampleEmailAPI.someMethod();
    }

    public void setParameters(Map<String, Object> params) {
        // Nothing - Not called yet, reserved for future use
    }
}

Exemplo de classes auxiliares

Este exemplo de classe auxiliar armazena um email.

public class SampleEmailMessage {

    private String senderAddress;
    private String senderName;
    private List<String> recipientAddress;
    private List<String> ccAddress;
    private List<String> bccAddress;
    private String subject;
    private String body;

    public String getSenderAddress() {
        return senderAddress;
    }
    public void setSenderAddress(String senderAddress) {
        this.senderAddress = senderAddress;
    }

    public String getSenderName() {
        return senderName;
    }
    public void setSenderName(String senderName) {
        this.senderName = senderName;
    }

    public List<String> getRecipients() {
        return recipientAddress;
    }
    public void setRecipientAddress(List<String> recipientAddress) {
        this.recipientAddress = recipientAddress;
    }
    public void addRecipient(String recipientEmailAddress) {
        this.recipientAddress.add(recipientEmailAddress);
    }
    
    public List<String> getCCs() {
        return ccAddress;
    }
    public void setCCAddress(List<String> ccAddress) {
        this.ccAddress = ccAddress;
    }
    public void addCC(String recipientCC) {
        this.ccAddress.add(recipientCC);
    }
    
    public List<String> getBCCs() {
        return bccAddress;
    }
    public void setBCCAddress(List<String> bccAddress) {
        this.bccAddress = bccAddress;
    }
    public void addBCC(String recipientBCC) {
        this.bccAddress.add(recipientBCC);
    }

    public String getSubject() {
        return subject;
    }
    public void setSubject(String subject) {
        this.subject = subject;
    }

    public String getBody() {
        return body;
    }
    public void setBody(String body) {
        this.body = body;
    }
}

Esta classe auxiliar de exemplo armazena o status de um email.

public class SampleEmailStatus {

    private Datetime SentDateTime;
    private Datetime BouncedDate;
    private String BouncedReason;
    private Boolean IsBounced;
    private Datetime FirstOpenedDate;
    private Datetime LastOpenedDate;

    public Datetime getSentDateTime() {
        return SentDateTime;
    }
    public void setSentDateTime(Datetime SentDateTime) {
        this.SentDateTime = SentDateTime;
    }
    
    public Datetime getBouncedDate() {
        return BouncedDate;
    }
    public void setBouncedDate(Datetime BouncedDate) {
        this.BouncedDate = BouncedDate;
    }

    public String getBouncedReason() {
        return BouncedReason;
    }
    public void setBouncedReason(String BouncedReason) {
        this.BouncedReason = BouncedReason;
    }

    public Boolean getIsBounced() {
        return IsBounced;
    }
    public void setIsBounced(Boolean IsBounced) {
        this.IsBounced = IsBounced;
    }

    public Datetime getFirstOpenedDate() {
        return FirstOpenedDate;
    }
    public void setFirstOpenedDate(Datetime FirstOpenedDate) {
        this.FirstOpenedDate = FirstOpenedDate;
    }

    public Datetime getLastOpenedDate() {
        return LastOpenedDate;
    }
    public void setLastOpenedDate(Datetime LastOpenedDate) {
        this.LastOpenedDate = LastOpenedDate;
    } 
}

Esta é uma classe auxiliar de exemplo para fazer chamadas à API externas para o sistema de email de terceiros. Para fazer chamadas de API válidas, atualize os pontos de extremidade.

public class SampleEmailAPI {

    public static Integer getRemainingEmails() {
        // Replace with valid request
        HttpRequest req = new HttpRequest();
        req.setEndpoint('https://www.examplesite.com/some/api/endpoint');
        req.setHeader('Authorization', 'someauth');
        req.setHeader('Content-Type', 'application/json');
        req.setMethod('GET');
        req.setBody('Request Body');
        
        Http httpReq = new Http();
        HttpResponse response;
        
        try {
            response = httpReq.send(req);
        } catch (Exception ex) {
            // Handle
        }
        
        String body = response.getBody();
        Map<String, Object> results = parseBody(body);

        // Assumes this value will be returned from the API
        return Integer.valueOf(results.get('emails_remaining'));
    }
    
    public static List<String> sendEmails(List<SampleEmailMessage> emails) {
        // Replace with valid request
        List<String> errorMessages = new List<String>();
        for (Integer i = 0; i < emails.size(); i++) {
            try {
                // Send Message - Replace with valid request
                HttpRequest req = new HttpRequest();
                req.setEndpoint('https://www.examplesite.com/some/api/endpoint');
                req.setHeader('Authorization', 'someauth');
                req.setHeader('Content-Type', 'application/json');
                req.setMethod('POST');
                req.setBody('Request Body');
                
                Http httpReq = new Http();
                HttpResponse response;
                
                try {
                    response = httpReq.send(req);
                } catch (Exception ex) {
                    // Handle
                }
                
                String body = response.getBody();
                Map<String, Object> results = parseBody(body);
                
                // Check results if needed
            } catch (Exception x) {
                errorMessages.add(i, x.getMessage());
            }
        }
        return errorMessages;
    }
    
    public static SampleEmailStatus getEmailStatus(LifeScienceEmail email) {
        // Replace with valid request
        HttpRequest req = new HttpRequest();
        req.setEndpoint('https://www.somesite.com/some/api/endpoint');
        req.setHeader('Authorization', 'someauth');
        req.setHeader('Content-Type', 'application/json');
        req.setMethod('GET');
        req.setBody('Request Body');
        
        Http httpReq = new Http();
        HttpResponse response;
        
        try {
            response = httpReq.send(req);
        } catch (Exception ex) {
            // Handle
        }
        
        String body = response.getBody();
        Map<String, Object> results = parseBody(body);
        
        SampleEmailStatus status = new SampleEmailStatus();
        // Assumes these values will be returned from the API
        status.setSentDateTime(Datetime.parse(String.valueOf(results.get('sent_time'))));
        status.setIsBounced(Boolean.valueOf(results.get('is_bounced')));
        status.setBouncedReason(String.valueOf(results.get('bounced_reason')));
        status.setBouncedDate(Datetime.parse(String.valueOf(results.get('bounce_date'))));
        status.setLastOpenedDate(Datetime.parse(String.valueOf(results.get('last_opened'))));
        status.setFirstOpenedDate(Datetime.parse(String.valueOf(results.get('first_opened'))));
        
        return status;
    }
    
    public static void someMethod() {
        // Replace with valid request
        HttpRequest req = new HttpRequest();
        req.setEndpoint('https://www.somesite.com/some/api/endpoint');
        req.setHeader('Authorization', 'someauth');
        req.setHeader('Content-Type', 'application/json');
        req.setMethod('GET');
        req.setBody('Request Body');
        
        Http httpReq = new Http();
        HttpResponse response;
        
        try {
            response = httpReq.send(req);
        } catch (Exception ex) {
            // Handle
        }
        
        String body = response.getBody();
        Map<String, Object> results = parseBody(body);
    }
    
    private static Map<String, Object> parseBody(String body){
        Map<String, Object> m = (Map<String, Object>)JSON.deserializeUntyped(body);
        return m;
    }
}