sendEmailGlobally.cls

public class SendEmailGlobally {
    @InvocableMethod(label = 'Send Email Globally Multiple')
    public static void sendEmailGlobally(List<FlowInput> flowInputs) {
        Set<String> emailTemplateNames = new Set<String>();
        Set<String> fromEmailAddresses = new Set<String>();
        
        // Collect email template names and sender email addresses
        for (FlowInput fInput : flowInputs) {
            emailTemplateNames.add(fInput.templatename);
            fromEmailAddresses.add(fInput.fromEmailAddress);
        }

        // Map email templates by developer name
        Map<String, Id> emailTemplateMap = new Map<String, Id>();
        for (EmailTemplate et : [
            SELECT Id, DeveloperName 
            FROM EmailTemplate 
            WHERE DeveloperName IN :emailTemplateNames
        ]) {
            emailTemplateMap.put(et.DeveloperName.toLowerCase(), et.Id);
        }

        // Map Org-Wide Email Addresses
        Map<String, Id> orgWideAddMap = new Map<String, Id>();
        for (OrgWideEmailAddress org : [
            SELECT Id, Address 
            FROM OrgWideEmailAddress 
            WHERE Address IN :fromEmailAddresses AND IsVerified = true
        ]) {
            orgWideAddMap.put(org.Address.toLowerCase(), org.Id);
        }

        // Prepare email messages
        List<Messaging.SingleEmailMessage> allEmails = new List<Messaging.SingleEmailMessage>();
        for (FlowInput fInput : flowInputs) {
            String templateName = fInput.templatename;
            String sendEmailIds = fInput.sendEmailIds;
            String recordId = fInput.recordId;
            String fromEmailAddress = fInput.fromEmailAddress;
            Boolean individualEmail = fInput.individualEmail;
            Boolean showEmailActivity = fInput.showEmailActivity == true;

            if (String.isNotBlank(sendEmailIds)) {
                List<List<String>> toAddressesList = new List<List<String>>();
                
                // Split email addresses into individual lists
                if (individualEmail == true) {
                    for (String sendEmailId : sendEmailIds.split(';')) {
                        toAddressesList.add(new List<String>{sendEmailId});
                    }
                } else {
                    toAddressesList.add(sendEmailIds.split(';'));
                }

                for (List<String> toAddressList : toAddressesList) {
                    String etId = emailTemplateMap.get(templateName.toLowerCase());
                    if (etId == null) {
                        throw new IllegalArgumentException('Email template not found: ' + templateName);
                    }

                    Messaging.SingleEmailMessage email = Messaging.renderStoredEmailTemplate(
                        etId, 
                        null, 
                        Id.valueOf(recordId)
                    );

                    if (fromEmailAddress != null && orgWideAddMap.containsKey(fromEmailAddress.toLowerCase())) {
                        email.setOrgWideEmailAddressId(orgWideAddMap.get(fromEmailAddress.toLowerCase()));        
                    }

                    email.setToAddresses(toAddressList);
                    email.setSaveAsActivity(showEmailActivity);
                    allEmails.add(email);
                }
            }
        }

        // Send all emails
        if (!allEmails.isEmpty()) {
            Messaging.sendEmail(allEmails, true);
        }
    }

    public class FlowInput {
        @InvocableVariable
        public String recordId;

        @InvocableVariable
        public String sendEmailIds;

        @InvocableVariable
        public String templatename;

        @InvocableVariable
        public String fromEmailAddress;

        @InvocableVariable
        public Boolean individualEmail;

        @InvocableVariable
        public Boolean showEmailActivity;
    }
}

Description:

Invocable Method:
- The sendEmailGlobally method is annotated with @InvocableMethod, enabling its invocation from Flow processes. It accepts a list of FlowInput objects as input parameters.
Input Parameters:
- InputThe FlowInput inner class defines the input variables:
  - recordId: ID of the associated record.
  - sendEmailIds: Semicolon-separated recipient email addresses.
  - templateName: DeveloperName of the email template.
  - fromEmailAddress: Sender's email address.
  - individualEmail: Boolean flag indicating individual or bulk email sending.
Email Sending Logic:
- Fetches the specified email template based on its DeveloperName and renders it with the associated record ID.
- Sets the sender's email address if provided and verified as an Org-Wide Email Address in Salesforce.
- Constructs a list of recipient email addresses either individually or in bulk based on the individualEmail flag.
- Creates Messaging.SingleEmailMessage objects for each recipient and adds them to a list.
- Sends the emails using Messaging.sendEmail method and handles success or failure accordingly.
Return Values:
- Returns a list containing a single string indicating the outcome: 'Success' or 'Failure'.

Benefits:

Customizability: Users can specify various parameters, tailoring email sending according to specific needs.
Efficiency: Automation through Flow processes streamlines email communication tasks, saving time and effort.
Scalability: Supports simultaneous sending to multiple recipients, ensuring scalability.
Integration: Seamlessly integrates with existing Salesforce functionalities like email templates and Org-Wide Email Addresses.

By mastering the SendEmailGloballyController functionality, individuals can enhance productivity by automating email communication processes, thereby increasing efficiency and productivity. Acquiring knowledge about FlowActions and Apex classes broadens one's skill set within the Salesforce ecosystem, opening up new opportunities for career growth and advancement. Moreover, understanding how to leverage custom Apex logic for email automation enables users to innovate and tailor solutions to meet unique business requirements, ultimately driving organizational success.
Happy Coding!