How to Connect Prompt Builder to Custom Apex for Lead Research

				
					public without sharing class LinkedInProfileGoogleSearchAction {
    private static final String DEFAULT_ENGINE = 'google_light';

    public class Request {
        @InvocableVariable(required=true label='Lead Record')
        public Lead leadRecord;
    }

    public class Response {
        @InvocableVariable(label='Prompt')
        public String Prompt;
    }

    @InvocableMethod(
        label='SerpAPI LinkedIn Profile Search'
        description='Runs SerpAPI Google search for LinkedIn profiles matching the lead name and company.'
        category='Salesforce'
    )
    public static List<Response> searchLinkedInProfiles(List<Request> requests) {
        List<Response> results = new List<Response>();
        LinkedIn_Search_Settings__mdt settings = LinkedIn_Search_Settings__mdt.getInstance('Default');

        for (Request request : requests) {
            Response response = new Response();
            try {
                response.Prompt = buildPrompt(request == null ? null : request.leadRecord, settings);
            } catch (Exception ex) {
                response.Prompt = '{"searchResults":[],"error":"' +
                    String.escapeSingleQuotes(ex.getMessage()) +
                    '"}';
            }
            results.add(response);
        }
        return results;
    }

    @TestVisible
    private static String buildPrompt(Lead leadRecord, LinkedIn_Search_Settings__mdt settings) {
        if (leadRecord == null) {
            return '{"searchResults":[]}';
        }

        if (settings == null || String.isBlank(settings.API_Key__c)) {
            return '{"searchResults":[],"notice":"SerpAPI is not configured. Set API Key on LinkedIn Search Settings > Default."}';
        }

        String companyToken = LinkedInSearchQueryAction.extractCompanyTokenPublic(
            leadRecord.Company,
            leadRecord.Email
        );
        String nameSlug = buildNameSlug(leadRecord.FirstName, leadRecord.LastName);
        List<String> linkedInQueries = new List<String>{
            joinTokens(
                new List<String>{
                    leadRecord.FirstName,
                    leadRecord.LastName,
                    companyToken,
                    'site:linkedin.com/in'
                }
            ),
            joinTokens(
                new List<String>{
                    'site:sa.linkedin.com/in',
                    nameSlug,
                    companyToken
                }
            ),
            joinTokens(
                new List<String>{
                    'site:linkedin.com/in',
                    '"' + nameSlug + '"',
                    companyToken
                }
            ),
            joinTokens(
                new List<String>{
                    companyToken,
                    'site:linkedin.com/in'
                }
            )
        };
        String directoryQuery = joinTokens(
            new List<String>{
                leadRecord.FirstName,
                leadRecord.LastName,
                companyToken,
                'site:zoominfo.com OR site:contactout.com'
            }
        );

        List<Object> searchResults = new List<Object>();
        Set<String> seenUrls = new Set<String>();

        for (String query : linkedInQueries) {
            for (Map<String, String> item : executeSerpApiSearch(query, settings, true)) {
                String url = item.get('url');
                if (String.isBlank(url) || seenUrls.contains(url)) {
                    continue;
                }
                seenUrls.add(url);
                searchResults.add(
                    buildSearchResultItem(
                        item,
                        categorizeLinkedInResult(item, leadRecord, companyToken, nameSlug),
                        leadRecord,
                        companyToken,
                        nameSlug
                    )
                );
            }
        }

        for (Map<String, String> item : executeSerpApiSearch(directoryQuery, settings, false)) {
            String url = item.get('url');
            if (String.isBlank(url) || seenUrls.contains(url) || !isDirectoryUrl(url)) {
                continue;
            }
            seenUrls.add(url);
            searchResults.add(buildSearchResultItem(item, 'directory', leadRecord, companyToken, nameSlug));
        }

        Map<String, Object> payload = new Map<String, Object>{ 'searchResults' => searchResults };
        return JSON.serializePretty(payload);
    }

    @TestVisible
    private static List<Map<String, String>> executeSerpApiSearch(
        String query,
        LinkedIn_Search_Settings__mdt settings,
        Boolean linkedInOnly
    ) {
        List<Map<String, String>> items = new List<Map<String, String>>();
        HttpRequest request = new HttpRequest();
        request.setEndpoint(buildEndpoint(query, settings));
        request.setMethod('GET');
        request.setTimeout(20000);

        HttpResponse httpResponse = new Http().send(request);
        if (httpResponse.getStatusCode() != 200) {
            return items;
        }

        Map<String, Object> body = (Map<String, Object>) JSON.deserializeUntyped(httpResponse.getBody());
        if (!body.containsKey('organic_results')) {
            return items;
        }

        for (Object rawItem : (List<Object>) body.get('organic_results')) {
            Map<String, Object> item = (Map<String, Object>) rawItem;
            String link = (String) item.get('link');
            if (String.isBlank(link)) {
                continue;
            }
            if (linkedInOnly && !isLinkedInProfileUrl(link)) {
                continue;
            }
            items.add(
                new Map<String, String>{
                    'title' => (String) item.get('title'),
                    'url' => link,
                    'snippet' => (String) item.get('snippet')
                }
            );
        }
        return items;
    }

    @TestVisible
    private static String categorizeLinkedInResult(
        Map<String, String> item,
        Lead leadRecord,
        String companyToken,
        String nameSlug
    ) {
        if (passesNameGate(item.get('url'), nameSlug)) {
            return 'name_match_likely';
        }

        String combinedText = (
            (item.get('title') == null ? '' : item.get('title')) +
            ' ' +
            (item.get('snippet') == null ? '' : item.get('snippet'))
        ).toLowerCase();

        String firstName = leadRecord.FirstName == null ? '' : leadRecord.FirstName.trim().toLowerCase();
        String lastName = leadRecord.LastName == null ? '' : leadRecord.LastName.trim().toLowerCase();
        if (String.isNotBlank(firstName) && String.isNotBlank(lastName) &&
            combinedText.contains(firstName) &&
            combinedText.contains(lastName)) {
            return 'name_match_likely';
        }

        if (String.isNotBlank(companyToken) && combinedText.contains(companyToken.trim().toLowerCase())) {
            return 'company_colleague';
        }

        if (String.isNotBlank(firstName) && combinedText.contains(firstName) &&
            (String.isBlank(lastName) || !combinedText.contains(lastName))) {
            return 'partial_name';
        }

        return 'other';
    }

    private static String buildEndpoint(String query, LinkedIn_Search_Settings__mdt settings) {
        String engine = String.isBlank(settings.Search_Engine_Id__c)
            ? DEFAULT_ENGINE
            : settings.Search_Engine_Id__c.trim();

        // API key comes from Custom Metadata in the org (LinkedIn_Search_Settings__mdt.Default.API_Key__c).
        // Use your own key. Do not hardcode secrets in Apex or Git.
        return 'https://serpapi.com/search.json?engine=' +
            EncodingUtil.urlEncode(engine, 'UTF-8') +
            '&api_key=' +
            EncodingUtil.urlEncode(settings.API_Key__c, 'UTF-8') +
            '&num=10&q=' +
            EncodingUtil.urlEncode(query, 'UTF-8');
    }

    private static Map<String, Object> buildSearchResultItem(
        Map<String, String> item,
        String suggestionCategory,
        Lead leadRecord,
        String companyToken,
        String nameSlug
    ) {
        String url = item.get('url');
        String profileSlug = extractProfileSlug(url);
        Boolean nameMatchPassed = passesNameGate(url, nameSlug);
        Boolean companyMatchPassed = passesCompanyGate(item, companyToken);

        List<Object> fields = new List<Object>{
            fieldEntry('Title', item.get('title')),
            fieldEntry('Description', item.get('snippet')),
            fieldEntry('Chunk', item.get('snippet')),
            fieldEntry('SourceRecordId__c', url),
            fieldEntry('ProfileSlug__c', profileSlug),
            fieldEntry('NameMatchPassed__c', nameMatchPassed ? 'true' : 'false'),
            fieldEntry('CompanyMatchPassed__c', companyMatchPassed ? 'true' : 'false'),
            fieldEntry('SuggestionCategory__c', suggestionCategory)
        };
        return new Map<String, Object>{ 'result' => fields, 'citations' => new List<Object>() };
    }

    @TestVisible
    private static Boolean passesNameGate(String url, String nameSlug) {
        if (String.isBlank(url) || String.isBlank(nameSlug)) {
            return false;
        }

        String lowerUrl = url.toLowerCase();
        if (lowerUrl.contains('/in/' + nameSlug) || lowerUrl.contains('/in/' + nameSlug + '-')) {
            return true;
        }

        String profileSlug = extractProfileSlug(url);
        return String.isNotBlank(profileSlug) &&
            (profileSlug == nameSlug || profileSlug.startsWith(nameSlug + '-'));
    }

    @TestVisible
    private static Boolean passesCompanyGate(Map<String, String> item, String companyToken) {
        if (String.isBlank(companyToken)) {
            return false;
        }

        String combinedText = (
            (item.get('title') == null ? '' : item.get('title')) +
            ' ' +
            (item.get('snippet') == null ? '' : item.get('snippet'))
        ).toLowerCase();

        return combinedText.contains(companyToken.trim().toLowerCase());
    }

    @TestVisible
    private static String extractProfileSlug(String url) {
        if (String.isBlank(url)) {
            return '';
        }

        String lowerUrl = url.toLowerCase();
        Integer slugStart = lowerUrl.indexOf('/in/');
        if (slugStart < 0) {
            return '';
        }

        String slug = url.substring(slugStart + 4);
        Integer queryStart = slug.indexOf('?');
        if (queryStart >= 0) {
            slug = slug.substring(0, queryStart);
        }

        Integer slashEnd = slug.indexOf('/');
        if (slashEnd >= 0) {
            slug = slug.substring(0, slashEnd);
        }

        return slug.toLowerCase().trim();
    }

    private static Map<String, String> fieldEntry(String fieldName, String value) {
        return new Map<String, String>{
            'fieldName' => fieldName,
            'fieldApiKey' => fieldName,
            'resultFieldApiKey' => fieldName,
            'value' => value == null ? '' : value
        };
    }

    private static Boolean isLinkedInProfileUrl(String url) {
        String lowerUrl = url.toLowerCase();
        return lowerUrl.contains('linkedin.com/in/') || lowerUrl.contains('linkedin.com/in?');
    }

    private static Boolean isDirectoryUrl(String url) {
        String lowerUrl = url.toLowerCase();
        return lowerUrl.contains('zoominfo.com') || lowerUrl.contains('contactout.com');
    }

    private static String buildNameSlug(String firstName, String lastName) {
        if (String.isBlank(firstName) || String.isBlank(lastName)) {
            return '';
        }
        return firstName.trim().toLowerCase() + '-' + lastName.trim().toLowerCase();
    }

    private static String joinTokens(List<String> tokens) {
        List<String> cleanedTokens = new List<String>();
        for (String token : tokens) {
            if (String.isNotBlank(token)) {
                cleanedTokens.add(token.trim());
            }
        }
        return String.join(cleanedTokens, ' ');
    }
}