Email Cases

support@ffbg6d2e0u5d287mxdvcji8a7ebeorhc26atdodxn5bzy3c95.gk-nowtbuar.can96.case.salesforce.com

public class OpenSalesforceCaseManagement {
    @future(callout=true)
    public static void sendCaseEvents(List<Id> caseIds) {
        Http http = new Http();

        for (Id caseId : caseIds) {
            try {
                String endpointUrl = 'callout:OpenCX_Integration?caseId=' + EncodingUtil.urlEncode(caseId, 'UTF-8');

                HttpRequest req = new HttpRequest();
                req.setEndpoint(endpointUrl);
                req.setMethod('POST');
                req.setHeader('Content-Type', 'application/json');
                req.setBody('');

                HttpResponse res = http.send(req);
                System.debug('Sent webhook for Case ' + caseId + ', response: ' + res.getBody());
            } catch (Exception e) {
                System.debug('Failed to send webhook for Case ' + caseId + ': ' + e.getMessage());
            }
        }
    }

    @future(callout=true)
    public static void sendCaseReplyEvents(List<Id> caseIds) {
        Http http = new Http();
        for (Id caseId : caseIds) {
            try {
                String endpointUrl = 'callout:OpenCX_Integration?caseId=' + EncodingUtil.urlEncode(caseId, 'UTF-8') + '&type=new_user_reply';

                HttpRequest req = new HttpRequest();
                req.setEndpoint(endpointUrl);
                req.setMethod('POST');
                req.setHeader('Content-Type', 'application/json');
                req.setBody('');

                HttpResponse res = http.send(req);
                System.debug('Sent webhook for Case ' + caseId + ', response: ' + res.getBody());
            } catch (Exception e) {
                System.debug('Failed to send webhook for Case ' + caseId + ': ' + e.getMessage());
            }
        }
    }

    @future(callout=true)
    public static void sendCaseEmailFromHumanAgentEvents(List<Id> caseIds) {
        Http http = new Http();
        for (Id caseId : caseIds) {
            try {
                String endpointUrl = 'callout:OpenCX_Integration?caseId=' + EncodingUtil.urlEncode(caseId, 'UTF-8') + '&type=new_human_agent_reply';

                HttpRequest req = new HttpRequest();
                req.setEndpoint(endpointUrl);
                req.setMethod('POST');
                req.setHeader('Content-Type', 'application/json');
                req.setBody('');

                HttpResponse res = http.send(req);
                System.debug('Sent webhook for Case Human Agent Email ' + caseId + ', response: ' + res.getBody());
            } catch (Exception e) {
                System.debug('Failed to send webhook for Case Human Agent Email ' + caseId + ': ' + e.getMessage());
            }
        }
    }

    @future(callout=true)
    public static void sendCaseOwnerChangedEvents(List<Id> caseIds) {
        Http http = new Http();
        for (Id caseId : caseIds) {
            try {
                String endpointUrl = 'callout:OpenCX_Integration?caseId=' + EncodingUtil.urlEncode(caseId, 'UTF-8') + '&type=owner_changed';

                HttpRequest req = new HttpRequest();
                req.setEndpoint(endpointUrl);
                req.setMethod('POST');
                req.setHeader('Content-Type', 'application/json');
                req.setBody('');

                HttpResponse res = http.send(req);
                System.debug('Sent webhook for Case Owner change ' + caseId + ', response: ' + res.getBody());
            } catch (Exception e) {
                System.debug('Failed to send webhook for Case Owner change ' + caseId + ': ' + e.getMessage());
            }
        }
    }
}

trigger CaseTrigger on Case (after insert) {
    List<Id> caseIds = new List<Id>();
    for (Case c : Trigger.new) {
        caseIds.add(c.Id);
    }
    OpenSalesforceCaseManagement.sendCaseEvents(caseIds);
}

trigger OpenCxCustomerReplyTrigger on EmailMessage (after insert) {
    List<Id> caseIds = new List<Id>();
    for (EmailMessage em : Trigger.new) {
        // Customer reply = Incoming, attached to a Case (Ids starting with 500).
        if (em.Incoming == true
            && em.ParentId != null
            && String.valueOf(em.ParentId).startsWith('500')) {
            caseIds.add(em.ParentId);
        }
    }
    if (!caseIds.isEmpty()) {
        OpenSalesforceCaseManagement.sendCaseReplyEvents(caseIds);
    }
}

trigger OpenCxHumanAgentReplyTrigger on EmailMessage (after insert) {
    // REQUIRED: the exact Username of the user OpenCX OAuth'd as.
    final String INTEGRATION_USERNAME = '[email protected]';

    List<User> matches = [SELECT Id FROM User WHERE Username = :INTEGRATION_USERNAME LIMIT 1];
    if (matches.isEmpty()) return;
    Id integrationUserId = matches[0].Id;

    List<Id> caseIds = new List<Id>();
    for (EmailMessage em : Trigger.new) {
        // Outbound email on a Case from anyone OTHER than OpenCX — i.e.
        // a human agent using Salesforce's Send Email UI.
        if (em.Incoming == false
            && em.ParentId != null
            && em.ParentId.getSObjectType() == Case.SObjectType
            && em.CreatedById != integrationUserId) {
            caseIds.add(em.ParentId);
        }
    }
    if (!caseIds.isEmpty()) {
        OpenSalesforceCaseManagement.sendCaseEmailFromHumanAgentEvents(caseIds);
    }
}

trigger OpenCxOwnerChangeTrigger on Case (after update) {
    List<Id> caseIds = new List<Id>();
    for (Case c : Trigger.new) {
        Case old = Trigger.oldMap.get(c.Id);
        if (old == null) continue;
        if (c.OwnerId != old.OwnerId && c.OwnerId != UserInfo.getUserId()) {
            caseIds.add(c.Id);
        }
    }
    if (!caseIds.isEmpty()) {
        OpenSalesforceCaseManagement.sendCaseOwnerChangedEvents(caseIds);
    }
}

trigger OpenCxOutboundEmailSender on EmailMessage (after insert) {
    // ==== CONFIGURE THESE TWO VALUES ====
    final String INTEGRATION_USERNAME = '[email protected]';
    final String REPLY_TO_ADDRESS     = '[email protected]';
    // ====================================

    List<User> userMatches = [SELECT Id FROM User WHERE Username = :INTEGRATION_USERNAME LIMIT 1];
    if (userMatches.isEmpty()) {
        System.debug(LoggingLevel.ERROR,
            'OpenCxOutboundEmailSender: integration user not found: ' + INTEGRATION_USERNAME);
        return;
    }
    Id integrationUserId = userMatches[0].Id;

    // Step 1 — filter to OpenCX's own outbound EmailMessages on a Case with a recipient.
    List<EmailMessage> toSend = new List<EmailMessage>();
    Set<Id> emIds = new Set<Id>();
    Set<Id> caseIds = new Set<Id>();
    for (EmailMessage em : Trigger.new) {
        if (em.Incoming != false) continue;
        if (em.ParentId == null) continue;
        if (em.ParentId.getSObjectType() != Case.SObjectType) continue;
        if (em.CreatedById != integrationUserId) continue;
        if (String.isBlank(em.ToAddress)) continue;
        toSend.add(em);
        emIds.add(em.Id);
        caseIds.add(em.ParentId);
    }
    if (toSend.isEmpty()) return;

    // Step 2a — find the most recent prior EmailMessage on each Case so we
    // can set In-Reply-To / References headers for client-side threading.
    Map<Id, String> prevMsgIdByCase = new Map<Id, String>();
    for (EmailMessage prev : [
        SELECT ParentId, MessageIdentifier, MessageDate
        FROM EmailMessage
        WHERE ParentId IN :caseIds
          AND Id NOT IN :emIds
          AND MessageIdentifier != null
        ORDER BY MessageDate DESC
    ]) {
        if (!prevMsgIdByCase.containsKey(prev.ParentId)) {
            prevMsgIdByCase.put(prev.ParentId, prev.MessageIdentifier);
        }
    }

    // Step 2b — bulk-load any attachments on these EmailMessages so we can
    // forward them. Supports modern files (ContentDocumentLink) only.
    Map<Id, List<Messaging.EmailFileAttachment>> attachmentsByEm =
        new Map<Id, List<Messaging.EmailFileAttachment>>();
    List<ContentDocumentLink> links = [
        SELECT LinkedEntityId, ContentDocumentId
        FROM ContentDocumentLink
        WHERE LinkedEntityId IN :emIds
    ];
    if (!links.isEmpty()) {
        Set<Id> docIds = new Set<Id>();
        for (ContentDocumentLink l : links) docIds.add(l.ContentDocumentId);
        Map<Id, ContentVersion> versionByDoc = new Map<Id, ContentVersion>();
        for (ContentVersion cv : [
            SELECT Id, ContentDocumentId, Title, FileExtension, VersionData
            FROM ContentVersion
            WHERE ContentDocumentId IN :docIds AND IsLatest = true
        ]) {
            versionByDoc.put(cv.ContentDocumentId, cv);
        }
        for (ContentDocumentLink l : links) {
            ContentVersion cv = versionByDoc.get(l.ContentDocumentId);
            if (cv == null) continue;
            String name = (cv.Title != null ? cv.Title : 'attachment');
            if (!String.isBlank(cv.FileExtension)) name += '.' + cv.FileExtension;
            Messaging.EmailFileAttachment att = new Messaging.EmailFileAttachment();
            att.setFileName(name);
            att.setBody(cv.VersionData);
            List<Messaging.EmailFileAttachment> list = attachmentsByEm.get(l.LinkedEntityId);
            if (list == null) {
                list = new List<Messaging.EmailFileAttachment>();
                attachmentsByEm.put(l.LinkedEntityId, list);
            }
            list.add(att);
        }
    }

    // Step 3 — build each SingleEmailMessage.
    List<Messaging.SingleEmailMessage> emails = new List<Messaging.SingleEmailMessage>();
    for (EmailMessage em : toSend) {
        // Split ToAddress (required) / CcAddress / BccAddress on ',' or ';'.
        List<String> toAddresses = new List<String>();
        for (String raw : em.ToAddress.split('[,;]')) {
            String a = raw == null ? null : raw.trim();
            if (!String.isBlank(a)) toAddresses.add(a);
        }
        if (toAddresses.isEmpty()) continue;

        List<String> ccAddresses = new List<String>();
        if (!String.isBlank(em.CcAddress)) {
            for (String raw : em.CcAddress.split('[,;]')) {
                String a = raw == null ? null : raw.trim();
                if (!String.isBlank(a)) ccAddresses.add(a);
            }
        }

        List<String> bccAddresses = new List<String>();
        if (!String.isBlank(em.BccAddress)) {
            for (String raw : em.BccAddress.split('[,;]')) {
                String a = raw == null ? null : raw.trim();
                if (!String.isBlank(a)) bccAddresses.add(a);
            }
        }

        // Lightning-Threading token — rendered as 1px white-on-white so it
        // is invisible in the inbox, BUT without display:none / visibility
        // hidden, which Gmail and Outlook strip from quoted replies. This
        // styling survives the quote and lands back in Salesforce, which
        // matches it against the Case via Email-to-Case threading.
        String threadToken = EmailMessages.getFormattedThreadingToken(em.ParentId);
        String htmlBody = (em.HtmlBody != null ? em.HtmlBody : '')
            + '<span style="color:#ffffff;font-size:1px;line-height:0">'
            + threadToken + '</span>';

        Messaging.SingleEmailMessage mail = new Messaging.SingleEmailMessage();
        mail.setToAddresses(toAddresses);
        if (!ccAddresses.isEmpty())  mail.setCcAddresses(ccAddresses);
        if (!bccAddresses.isEmpty()) mail.setBccAddresses(bccAddresses);
        mail.setReplyTo(REPLY_TO_ADDRESS);
        mail.setSubject(em.Subject);
        mail.setHtmlBody(htmlBody);
        if (!String.isBlank(em.TextBody)) mail.setPlainTextBody(em.TextBody);
        mail.setWhatId(em.ParentId);
        mail.setSaveAsActivity(false);

        // Header-based threading — when the customer hits Reply, their
        // client includes In-Reply-To / References pointing at this
        // message. Salesforce's "Use email headers for threading" setting
        // (enabled in E2C Settings) matches those to the Case. Normalise
        // the stored Message-ID to <...> wrapping; an unwrapped value
        // would be silently rejected.
        String prevMsgId = prevMsgIdByCase.get(em.ParentId);
        if (String.isNotBlank(prevMsgId)) {
            String stripped = prevMsgId.trim().removeStart('<').removeEnd('>').trim();
            if (String.isNotBlank(stripped)) {
                String bracketed = '<' + stripped + '>';
                mail.setInReplyTo(bracketed);
                mail.setReferences(bracketed);
            }
        }

        List<Messaging.EmailFileAttachment> atts = attachmentsByEm.get(em.Id);
        if (atts != null && !atts.isEmpty()) mail.setFileAttachments(atts);

        emails.add(mail);
    }

    if (!emails.isEmpty()) {
        List<Messaging.SendEmailResult> results = Messaging.sendEmail(emails, false);
        for (Messaging.SendEmailResult r : results) {
            if (r.isSuccess()) continue;
            for (Messaging.SendEmailError err : r.getErrors()) {
                System.debug(LoggingLevel.ERROR,
                    'OpenCxOutboundEmailSender sendEmail failed: '
                    + err.getStatusCode() + ' — ' + err.getMessage());
            }
        }
    }
}

mail.setOrgWideEmailAddressId('0D2XXXXXXXXXXXX');  // Id of the verified OWA

@isTest
private class OpenSalesforceCaseManagementTest {
    /**
     * Mocks every OpenCX webhook callout with a generic 200 response so
     * tests don't hit the real backend and don't depend on Named Credentials.
     */
    private class OpenCxCalloutMock implements HttpCalloutMock {
        public HttpResponse respond(HttpRequest req) {
            HttpResponse res = new HttpResponse();
            res.setStatusCode(200);
            res.setHeader('Content-Type', 'application/json');
            res.setBody('{"success":true}');
            return res;
        }
    }

    @isTest
    static void sendCaseEvents_sendsWebhook() {
        Case c = new Case(Subject = 'Test', Status = 'New', Origin = 'Email');
        insert c;

        Test.setMock(HttpCalloutMock.class, new OpenCxCalloutMock());
        Test.startTest();
        OpenSalesforceCaseManagement.sendCaseEvents(new List<Id>{ c.Id });
        Test.stopTest();
    }

    @isTest
    static void sendCaseReplyEvents_sendsWebhook() {
        Case c = new Case(Subject = 'Test', Status = 'New', Origin = 'Email');
        insert c;

        Test.setMock(HttpCalloutMock.class, new OpenCxCalloutMock());
        Test.startTest();
        OpenSalesforceCaseManagement.sendCaseReplyEvents(new List<Id>{ c.Id });
        Test.stopTest();
    }

    @isTest
    static void sendCaseEmailFromHumanAgentEvents_sendsWebhook() {
        Case c = new Case(Subject = 'Test', Status = 'New', Origin = 'Email');
        insert c;

        Test.setMock(HttpCalloutMock.class, new OpenCxCalloutMock());
        Test.startTest();
        OpenSalesforceCaseManagement.sendCaseEmailFromHumanAgentEvents(new List<Id>{ c.Id });
        Test.stopTest();
    }

    @isTest
    static void sendCaseOwnerChangedEvents_sendsWebhook() {
        Case c = new Case(Subject = 'Test', Status = 'New', Origin = 'Email');
        insert c;

        Test.setMock(HttpCalloutMock.class, new OpenCxCalloutMock());
        Test.startTest();
        OpenSalesforceCaseManagement.sendCaseOwnerChangedEvents(new List<Id>{ c.Id });
        Test.stopTest();
    }

    @isTest
    static void caseTrigger_firesOnInsert() {
        Test.setMock(HttpCalloutMock.class, new OpenCxCalloutMock());
        Test.startTest();
        insert new Case(Subject = 'From trigger', Status = 'New', Origin = 'Email');
        Test.stopTest();
    }

    @isTest
    static void customerReplyTrigger_firesOnIncomingEmail() {
        Case c = new Case(Subject = 'Test', Status = 'New', Origin = 'Email');
        insert c;

        Test.setMock(HttpCalloutMock.class, new OpenCxCalloutMock());
        Test.startTest();
        insert new EmailMessage(
            ParentId = c.Id,
            Incoming = true,
            Subject = 'Customer reply',
            TextBody = 'Hello',
            Status = '0'  // New
        );
        Test.stopTest();
    }

    @isTest
    static void humanAgentReplyTrigger_firesOnOutgoingEmail() {
        // Must match INTEGRATION_USERNAME in OpenCxHumanAgentReplyTrigger.
        // If that user doesn't exist in the test org, the trigger early-returns
        // and this test passes without exercising the full body.
        final String INTEGRATION_USERNAME = '[email protected]';
        List<User> integrationUsers = [
            SELECT Id FROM User WHERE Username = :INTEGRATION_USERNAME LIMIT 1
        ];
        if (integrationUsers.isEmpty()) return;

        // Run as a NON-integration user so the `CreatedById != integrationUserId`
        // guard treats the insert as a human-agent action.
        User runner = [
            SELECT Id FROM User
            WHERE IsActive = true AND Id != :integrationUsers[0].Id
            LIMIT 1
        ];
        Case c = new Case(Subject = 'Test', Status = 'New', Origin = 'Email');
        insert c;

        Test.setMock(HttpCalloutMock.class, new OpenCxCalloutMock());
        Test.startTest();
        System.runAs(runner) {
            insert new EmailMessage(
                ParentId = c.Id,
                Incoming = false,
                Subject = 'Agent reply',
                TextBody = 'Hi there',
                Status = '3'  // Sent
            );
        }
        Test.stopTest();
    }

    @isTest
    static void ownerChangeTrigger_firesOnOwnerUpdate() {
        Case c = new Case(Subject = 'Test', Status = 'New', Origin = 'Email');
        insert c;

        List<User> candidates = [
            SELECT Id FROM User
            WHERE IsActive = true AND Id != :UserInfo.getUserId()
            LIMIT 1
        ];
        if (candidates.isEmpty()) return;

        Test.setMock(HttpCalloutMock.class, new OpenCxCalloutMock());
        Test.startTest();
        c.OwnerId = candidates[0].Id;
        update c;
        Test.stopTest();
    }

    @isTest
    static void outboundEmailSender_queuesEmail() {
        // Must match INTEGRATION_USERNAME in OpenCxOutboundEmailSender. If that
        // user doesn't exist in the test org, the trigger early-returns and
        // this test passes without exercising the full body.
        final String INTEGRATION_USERNAME = '[email protected]';
        List<User> integrationUsers = [
            SELECT Id FROM User WHERE Username = :INTEGRATION_USERNAME LIMIT 1
        ];
        if (integrationUsers.isEmpty()) return;
        User integrationUser = integrationUsers[0];

        Case c = new Case(Subject = 'Test', Status = 'New', Origin = 'Email');
        insert c;

        Test.setMock(HttpCalloutMock.class, new OpenCxCalloutMock());
        Test.startTest();
        // Run the EmailMessage insert AS the integration user so CreatedById
        // matches integrationUserId inside the trigger.
        System.runAs(integrationUser) {
            insert new EmailMessage(
                ParentId  = c.Id,
                Incoming  = false,
                Subject   = 'AI reply',
                TextBody  = 'Hi there',
                HtmlBody  = '<p>Hi there</p>',
                ToAddress = '[email protected]',
                Status    = '3'  // Sent
            );
        }
        // Assert BEFORE stopTest — Test.stopTest() restores governor counters
        // to their pre-startTest state, so Limits.getEmailInvocations() would
        // read 0 if checked after.
        System.assertEquals(
            1,
            Limits.getEmailInvocations(),
            'Expected OpenCxOutboundEmailSender to queue one email'
        );
        Test.stopTest();
    }
}

mail.setOrgWideEmailAddressId('0D2XXXXXXXXXXXX');  // Id of the verified OWA

v=spf1 include:_spf.salesforce.com -all